com.datastax.data.dataset.DataSet Maven / Gradle / Ivy

Go to download


package com.datastax.data.dataset;

import com.datastax.data.dataset.event.TableChangeEvent;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.*;
import java.math.BigDecimal;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;


public class DataSet {
    
    
    public enum OutputControl { ALL_ROWS, MODIFIED_ONLY };
    
    
    private static final Logger LOG = Logger.getLogger(DataSet.class.getName());
    
    
    
    protected static final String DEFAULT_NAME_PREFIX = "DataSource";
    
    
    private static final NameGenerator NAMEGEN = new NameGenerator(DEFAULT_NAME_PREFIX);
    
    
    
    private PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    
    private String name;
    
    
    private Map tables = new HashMap();
    
    
    private Map relations = new HashMap();

    
    private Map values = new HashMap();
    
    
    private Parser parser;
    
    
    private NameChangeListener nameChangeListener = new NameChangeListener();
    
    
    public DataSet() {
        setName(NAMEGEN.generateName(this));
    }
    
    
    public DataSet(String name) {
        setName(name);
    }

    
    public void setName(String name) {
        if (this.name != name) {
            assert DataSetUtils.isValidName(name);
            String oldName = this.name;
            this.name = name;
            pcs.firePropertyChange("name", oldName, name);
        }
    }
    
    
    
    public String getName() {
        return name;
    }
    
    
    public DataTable createTable() {
        return createTable(null);
    }

    
    
    public DataTable createTable(String name) {
        DataTable table = new DataTable(this, name);
        table.addPropertyChangeListener("name",  nameChangeListener);
        tables.put(table.getName(), table);
        return table;
    }
    
    
    public DataRelationTable createRelationTable() {
        return createRelationTable(null);
    }
    
    
    
    public DataRelationTable createRelationTable(String name) {
        DataRelationTable table = new DataRelationTable(this, name);
        table.addPropertyChangeListener("name",  nameChangeListener);
        tables.put(table.getName(), table);
        return table;
    }
    
    
    public DataRelation createRelation() {
        return createRelation(null);
    }
    
    
    
    public DataRelation createRelation(String name) {
        DataRelation relation = new DataRelation(this, name);
        relation.addPropertyChangeListener("name",  nameChangeListener);
        relations.put(relation.getName(), relation);
        return relation;
    }
    
    
    public DataValue createValue() {
        return createValue(null);
    }
        
    
    
    public DataValue createValue(String name) {
        DataValue value = new DataValue(this, name);
        value.addPropertyChangeListener("name", nameChangeListener);
        values.put(value.getName(), value);
        return value;
    }

    
    public void dropTable(DataTable table) {
        dropTable(table.getName());
    }
    
    
    public void dropTable(String tableName) {
        
        
        DataTable table = tables.remove(tableName);
        if (table != null) {
            table.removeFromDataSet();
            table.removePropertyChangeListener("name",  nameChangeListener);
            for (DataRelation r : relations.values()) {
                DataColumn col = r.getChildColumn();
                if (col != null && col.getTable() == table) {
                    r.setChildColumn(null);
                }
                col = r.getParentColumn();
                if (col != null && col.getTable() == table) {
                    r.setParentColumn(null);
                }
            }

            for (DataTable t : tables.values()) {
                if (t instanceof DataRelationTable) {
                    DataRelationTable drt = (DataRelationTable)t;
                    if (drt.getParentTable() == table) {
                        drt.setParentTable(null);
                    }
                    if (drt.getParentSelector() != null && drt.getParentSelector().getTable() == table) {
                        drt.setParentSelector(null);
                    }
                }
            }
        }
    }
    
    
    public void dropRelationTable(DataRelationTable table) {
        dropTable(table.getName());
    }
    
    
    public void dropRelationTable(String tableName) {
        dropTable(tableName);
    }
    
    
    public void dropRelation(DataRelation relation) {
        dropRelation(relation.getName());
    }
    
    
    public void dropRelation(String relationName) {
        DataRelation relation = relations.remove(relationName);
        if (relation != null) {
            relation.removeFromDataSet();
            relation.removePropertyChangeListener("name",  nameChangeListener);
            for (DataTable t : tables.values()) {
                if (t instanceof DataRelationTable) {
                    DataRelationTable drt = (DataRelationTable)t;
                    if (drt.getRelation() == relation) {
                        drt.setRelation(null);
                    }
                }
            }
        }
    }
    
    
    public void dropValue(DataValue value) {
        dropValue(value.getName());
    }
    
    
    public void dropValue(String valueName) {
        DataValue value = values.remove(valueName);
        if (value != null) {
            value.removeFromDataSet();
            value.removePropertyChangeListener("name",  nameChangeListener);
        }
    }
    
    
    protected boolean hasElement(String name) {
        boolean b = relations.containsKey(name);
        if (!b) {
            b = tables.containsKey(name);
        }
        if (!b) {
            b = values.containsKey(name);
        }
        return b;
    }
    
    
    
    public Object getElement(String path) {
        if (path == null) {
            return null;
        }
        if (path.contains(".")) {
            
            String[] steps = path.split("\\.");
            assert steps.length == 2;
            DataTable table = tables.get(steps[0]);
            DataColumn col = table.getColumn(steps[1]);
            if (col != null) {
                return col;
            } else {
                return table.getSelector(steps[1]);
            }
        } else {
            if (relations.containsKey(path)) {
                return relations.get(path);
            } else if (tables.containsKey(path)) {
                return tables.get(path);
            } else if (values.containsKey(path)) {
                return values.get(path);
            }
        }
        return null;
    }
    
    
    
    public List getRows(String path) {
        if (path == null || path.trim().equals("")) {
            return Collections.EMPTY_LIST;
        }
        
        path = path.trim();
        
        
        String[] steps = path.split("\\.");
        
        
        
        
        
        List workingSet = null;
        
        for (String step : steps) {
            String name = null;
            String selectorName = null;
            if (step.contains("[")) {
                name = step.substring(0, step.indexOf('['));
                selectorName = step.substring(step.indexOf('[')+1,  step.indexOf(']'));
            }
            
            if (workingSet == null) {
                
                
                DataTable table = tables.get(name);
                if (table == null) {
                    assert false;
                }
                workingSet = table.getRows();
                if (selectorName != null) {
                    

                }
            } else {
                
                DataRelation relation = relations.get(name);
                if (relation == null) {
                    assert false;
                }
                workingSet = relation.getRows((DataRow[])workingSet.toArray(new DataRow[workingSet.size()]));
                if (selectorName != null) {
                    

                }
            }
        }
        return Collections.unmodifiableList(workingSet);
    }
    
    
    
    public List filterRows(List rows, DataSelector ds) {
        List indices = ds.getRowIndices();
        List results = new ArrayList(indices.size());
        for (int index : indices) {
            results.add(rows.get(index));
        }
        return results;
    }
    
    
    public List getColumns(String path) {
        
        
        String[] parts = path.split("\\.");
        assert parts.length == 1 || parts.length == 2;
        
        DataTable table = tables.get(parts[0]);
        if (table == null) {
            DataRelation relation = relations.get(parts[0]);
            if (relation == null) {
                return new ArrayList();
            } else {
                table = relation.getChildColumn().getTable();
            }
        }
        
        if (parts.length == 1) {
            return table.getColumns();
        } else {
            List results = new ArrayList();
            results.add(table.getColumn(parts[1]));
            return Collections.unmodifiableList(results);
        }
    }
    
    
    public DataTable getTable(String tableName) {
        return tables.get(tableName);
    }
    
    
    public List getTables() {
        List tableList = new ArrayList();
        for(DataTable table : tables.values()) {
            tableList.add(table);
        }
        return tableList;
    }
    
    
    public DataRelationTable getRelationTable(String name) {
        return (DataRelationTable)tables.get(name);
    }
    
    
    public DataValue getValue(String valueName) {
        return values.get(valueName);
    }
    
    
    public List getValues() {
        List values = new ArrayList();
        for (DataValue v : this.values.values()) {
            values.add(v);
        }
        return values;
    }
    
    
    public DataRelation getRelation(String relationName) {
        return relations.get(relationName);
    }
    
    
    public List getRelations() {
        List relations = new ArrayList();
        for (DataRelation r : this.relations.values()) {
            relations.add(r);
        }
        return relations;
    }
    
    
    public void load() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.load();
            }
        }
    }
    
    
    public void loadAndWait() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.loadAndWait();
            }
        }
    }
    
    
    public void refresh() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.refresh();
            }
        }
    }
    
    
    public void refreshAndWait() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.refreshAndWait();
            }
        }
    }
    
    
    public void clear() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.clear();
            }
        }
    }
    
    
    public void save() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.save();
            }
        }
    }
    
    
    public void saveAndWait() {
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                table.saveAndWait();
            }
        }
    }

    
    Parser getParser() {
        if (parser == null || parser.isInUse()) {
            parser = new Parser(this);
        }
            
        return parser;
    }


    
    public static DataSet createFromSchema(String schema) {
        return DataSetUtils.createFromXmlSchema(schema);
    }
    
    
     
    public String getSchema() {
        return DataSetUtils.getXmlSchema(this);
    }
    
    
    public static DataSet createFromSchema(File f) throws FileNotFoundException {
        return DataSetUtils.createFromXmlSchema(f);
    }
    
    
    public static DataSet createFromSchema(InputStream is) {
        return DataSetUtils.createFromXmlSchema(is);
    }
    
    
     
    public void readXml(File f) {
        String xml = "";
        try {
            FileInputStream fis = new FileInputStream(f);
            readXml(fis);
            fis.close();
        } catch (Exception e) {
	    LOG.log(Level.SEVERE, "Failed to read xml from file {0}. {1}", new Object[]{f, e.getStackTrace()});
        }
    }
    
    
     
    public void readXml(InputStream is) {
        String xml = "";
        try {
            StringBuilder builder = new StringBuilder();
            byte[] bytes = new byte[4096];
            int length = -1;
            while ((length = is.read(bytes)) != -1) {
                builder.append(new String(bytes, 0, length));
            }
            xml = builder.toString();
            readXml(xml);
        } catch (Exception e) {
	    LOG.log(Level.SEVERE, "Failed to read xml from input stream.", e);
        }
    }
    
    
     
    public void readXml(String xml) {
        
        
        try { 
            DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            Document dom = db.parse(new ByteArrayInputStream(xml.getBytes()));

            
            XPath xpath = XPathFactory.newInstance().newXPath();
            
            String path = null;
            
            
            for (DataTable table : tables.values()) {
                if (!(table instanceof DataRelationTable)) {
                    table.fireDataTableChanged(TableChangeEvent.newLoadStartEvent(table));
                    
                    table.clear();
                    
                    if ( !table.isAppendRowSupported()) {
                        LOG.fine("Table '" + table.getName() + "' does " +
                                "not support append row; skipping (regardless of " +
                                "input).");
                        continue;
                    }
                    
                    LOG.finer("loading table " + table.getName());
                    
                    
                    path = "/" + name + "/" + table.getName();
                    NodeList nodes = (NodeList)xpath.evaluate(path, dom, XPathConstants.NODESET);
                    
                    LOG.finer("  found " + nodes.getLength() + " rows for path " + path);
                    
                    
                    for (int i=0; i\n");
        builder.append("<");
        builder.append(name);
        builder.append(">\n");
        for (DataTable table : tables.values()) {
            if (!(table instanceof DataRelationTable)) {
                for (DataRow row : table.rows) {
                    if ( flags == OutputControl.MODIFIED_ONLY && row.getStatus() == DataRow.DataRowStatus.UNCHANGED ) {
                        continue;                        
                    }
                        
                    builder.append("\t<");
                    builder.append(table.getName());
                    builder.append(">\n");

                    for (DataColumn col : table.columns.values()) {
                        builder.append("\t\t<");
                        builder.append(col.getName());
                        builder.append(">");
                        String val = row.getValue(col) == null ? "" : row.getValue(col).toString();
                        
                        val = val.replaceAll("&", "&");
                        val = val.replaceAll("<", "<");
                        val = val.replaceAll(">", ">");
                        val = val.replaceAll("'", "'");
                        val = val.replaceAll("\"", """);
                        builder.append(val);
                        builder.append("\n");
                    }

                    builder.append("\t\n");
                }
            }
        }
        builder.append("");
        
        return builder.toString();
    }
    
    public String toString() {
        StringBuilder buffer = new StringBuilder();
        buffer.append("DataSource: ").append(name).append("\n");
        for (DataTable table : tables.values()) {
            if (table instanceof DataRelationTable) {
                buffer.append("\tDataRelationTable: ").append(table.getName()).append("\n");
            } else {
                buffer.append("\tDataTable: ").append(table.getName()).append("\n");
            }
            for (DataColumn col : table.getColumns()) {
                buffer.append("\t\tDataColumn: ").append(col.getName()).append("\n");
            }
        }
        for (DataRelation relation : relations.values()) {
            buffer.append("\tRelation: ").append(relation.getName()).append("\n");
            DataColumn parentColumn = relation.getParentColumn();
            buffer.append("\t\tParentColumn: ").append(parentColumn == null ? "" : parentColumn.getTable().getName()).append(".").append(parentColumn == null ? "" : parentColumn.getName()).append("\n");
            DataColumn childColumn = relation.getChildColumn();
            buffer.append("\t\tChildColumn: ").append(childColumn == null ? "" : childColumn.getTable().getName()).append(".").append(childColumn == null ? "" : childColumn.getName()).append("\n");
        }
        buffer.append(getSchema());
        return buffer.toString();
    }
    
    
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        try {
            DataSet ds = DataSetUtils.createFromXmlSchema(new File("/usr/local/src/databinding/src/test/org/data/dataset/contact.ds"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        long stopTime = System.currentTimeMillis();

        System.out.println((stopTime - startTime));
        










        
        
















    }

    
    private final class NameChangeListener implements PropertyChangeListener {
        public void propertyChange(PropertyChangeEvent evt) {
            Object source = evt.getSource();
            if (source instanceof DataTable) {
                DataTable table = (DataTable)source;
                tables.remove(evt.getOldValue());
                tables.put((String)evt.getNewValue(), table);
            } else if (source instanceof DataRelation) {
                DataRelation relation = (DataRelation)source;
                relations.remove(evt.getOldValue());
                relations.put((String)evt.getNewValue(), relation);
            } else if (source instanceof DataValue) {
                DataValue value = (DataValue)source;
                values.remove(evt.getOldValue());
                values.put((String)evt.getNewValue(), value);
            }
        }
    }
}