Changeset 887


Ignore:
Timestamp:
02/04/10 21:56:24 (2 years ago)
Author:
kasper
Message:
 
Location:
MetadataBeans/trunk
Files:
59 edited
4 copied

Legend:

Unmodified
Added
Removed

  • MetadataBeans/trunk/.classpath

    r877 r887  
    11<?xml version="1.0" encoding="UTF-8"?> 
    22<classpath> 
    3         <classpathentry kind="src" path="src/main/java"/> 
    4         <classpathentry kind="src" path="src/main/resources"/> 
    5         <classpathentry kind="src" path="src/test/java"/> 
    6         <classpathentry kind="src" path="src/test/resources"/> 
    7         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> 
     3        <classpathentry kind="src" output="target/classes" path="src/main/java"/> 
     4        <classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/> 
     5        <classpathentry kind="src" output="target/test-classes" path="src/test/java"/> 
     6        <classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources"/> 
     7        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/> 
    88        <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/> 
    99        <classpathentry kind="output" path="target/classes"/> 

  • MetadataBeans/trunk/.settings/org.eclipse.jdt.core.prefs

    r624 r887  
    1 #Sun Oct 05 18:07:39 CEST 2008 
     1#Thu Feb 04 21:14:57 CET 2010 
    22eclipse.preferences.version=1 
    3 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 
    4 org.eclipse.jdt.core.compiler.compliance=1.5 
    5 org.eclipse.jdt.core.compiler.source=1.5 
     3org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled 
     4org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 
     5org.eclipse.jdt.core.compiler.compliance=1.6 
     6org.eclipse.jdt.core.compiler.problem.assertIdentifier=error 
     7org.eclipse.jdt.core.compiler.problem.enumIdentifier=error 
     8org.eclipse.jdt.core.compiler.source=1.6 

  • MetadataBeans/trunk/pom.xml

    r878 r887  
    6262        <build> 
    6363                <plugins> 
    64                         <!-- Ensures java 5 compatibility --> 
     64                        <!-- Ensures java 6 compatibility --> 
    6565                        <plugin> 
    6666                                <artifactId>maven-compiler-plugin</artifactId> 
    6767                                <configuration> 
    68                                         <source>1.5</source> 
    69                                         <target>1.5</target> 
     68                                        <source>1.6</source> 
     69                                        <target>1.6</target> 
    7070                                        <encoding>utf-8</encoding> 
    7171                                </configuration> 
    … …  
    170170                        <groupId>junit</groupId> 
    171171                        <artifactId>junit</artifactId> 
    172                         <version>3.8.2</version> 
     172                        <version>4.7</version> 
    173173                        <scope>test</scope> 
    174174                </dependency> 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/AccessDataContextStrategy.java

    r886 r887  
    1212import org.eobjects.metamodel.schema.Column; 
    1313import org.eobjects.metamodel.schema.ColumnType; 
    14 import org.eobjects.metamodel.schema.Schema; 
     14import org.eobjects.metamodel.schema.MutableColumn; 
     15import org.eobjects.metamodel.schema.MutableSchema; 
     16import org.eobjects.metamodel.schema.MutableTable; 
    1517import org.eobjects.metamodel.schema.Table; 
    1618import org.eobjects.metamodel.schema.TableType; 
    1719 
    1820import com.healthmarketscience.jackcess.Database; 
    19  
    2021 
    2122public class AccessDataContextStrategy extends 
    … …  
    4748 
    4849        @Override 
    49         protected Schema getMainSchema() throws MetaModelException { 
    50                 Schema schema = new Schema(_file.getName()); 
     50        protected MutableSchema getMainSchema() throws MetaModelException { 
     51                MutableSchema schema = new MutableSchema(_file.getName()); 
    5152                Database db = getDatabase(); 
    5253                for (com.healthmarketscience.jackcess.Table mdbTable : db) { 
    53                         Table table = new Table(mdbTable.getName(), TableType.TABLE, schema); 
     54                        MutableTable table = new MutableTable(mdbTable.getName(), 
     55                                        TableType.TABLE, schema); 
    5456 
    5557                        try { 
    … …  
    5961                                        ColumnType columnType = ColumnType 
    6062                                                        .convertColumnType(mdbColumn.getSQLType()); 
    61                                         Column column = new Column(mdbColumn.getName(), columnType, 
    62                                                         table, i, null); 
     63                                        MutableColumn column = new MutableColumn(mdbColumn 
     64                                                        .getName(), columnType, table, i, null); 
    6365                                        column.setColumnSize((int) mdbColumn.getLength()); 
    6466                                        column.setNativeType(mdbColumn.getType().name()); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/CompositeDataContextStrategy.java

    r886 r887  
    1717import org.eobjects.metamodel.schema.Column; 
    1818import org.eobjects.metamodel.schema.CompositeSchema; 
     19import org.eobjects.metamodel.schema.MutableSchema; 
    1920import org.eobjects.metamodel.schema.Schema; 
    2021import org.eobjects.metamodel.schema.Table; 
    21  
    2222 
    2323public class CompositeDataContextStrategy implements IDataContextStrategy { 
    … …  
    8282 
    8383                                @Override 
    84                                 protected Schema getMainSchema() throws MetaModelException { 
     84                                protected MutableSchema getMainSchema() 
     85                                                throws MetaModelException { 
    8586                                        throw new UnsupportedOperationException( 
    8687                                                        "Use CompositeDataContextStrategy for exploring the schema"); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/CsvDataContextStrategy.java

    r886 r887  
    2828import org.eobjects.metamodel.schema.Column; 
    2929import org.eobjects.metamodel.schema.ColumnType; 
    30 import org.eobjects.metamodel.schema.Schema; 
     30import org.eobjects.metamodel.schema.MutableColumn; 
     31import org.eobjects.metamodel.schema.MutableSchema; 
     32import org.eobjects.metamodel.schema.MutableTable; 
    3133import org.eobjects.metamodel.schema.Table; 
    3234import org.eobjects.metamodel.schema.TableType; 
    … …  
    4648 
    4749        public CsvDataContextStrategy(File file) { 
    48                 this(file, CSVReader.DEFAULT_SEPARATOR, CSVReader.DEFAULT_QUOTE_CHARACTER); 
     50                this(file, CSVReader.DEFAULT_SEPARATOR, 
     51                                CSVReader.DEFAULT_QUOTE_CHARACTER); 
    4952        } 
    5053 
    … …  
    6770         *            the character to use for enclosing/quoting values 
    6871         */ 
    69         public CsvDataContextStrategy(File file, char separatorChar, char quoteChar, String fileEncoding) { 
     72        public CsvDataContextStrategy(File file, char separatorChar, 
     73                        char quoteChar, String fileEncoding) { 
    7074                if (file == null) { 
    7175                        throw new IllegalArgumentException("File cannot be null"); 
    … …  
    8488        } 
    8589 
    86         public CsvDataContextStrategy(URL url, char separatorChar, char quoteChar, String encoding) { 
     90        public CsvDataContextStrategy(URL url, char separatorChar, char quoteChar, 
     91                        String encoding) { 
    8792                _encoding = encoding; 
    8893                _separatorChar = separatorChar; 
    … …  
    95100        } 
    96101 
    97         public CsvDataContextStrategy(InputStream inputStream, char separatorChar, char quoteChar) { 
     102        public CsvDataContextStrategy(InputStream inputStream, char separatorChar, 
     103                        char quoteChar) { 
    98104                this(inputStream, separatorChar, quoteChar, FileHelper.DEFAULT_ENCODING); 
    99105        } 
    100106 
    101         public CsvDataContextStrategy(InputStream inputStream, char separatorChar, char quoteChar, String encoding) { 
     107        public CsvDataContextStrategy(InputStream inputStream, char separatorChar, 
     108                        char quoteChar, String encoding) { 
    102109                _encoding = encoding; 
    103110                _separatorChar = separatorChar; 
    … …  
    110117        } 
    111118 
    112         private void createFileFromInputStream(InputStream inputStream) throws IOException { 
     119        private void createFileFromInputStream(InputStream inputStream) 
     120                        throws IOException { 
    113121                File tempDir = FileHelper.getTempDir(); 
    114122                boolean usableName = false; 
    … …  
    121129                _file.deleteOnExit(); 
    122130                BufferedWriter writer = FileHelper.getBufferedWriter(_file, _encoding); 
    123                 BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); 
    124                 for (String line = reader.readLine(); line != null; line = reader.readLine()) { 
     131                BufferedReader reader = new BufferedReader(new InputStreamReader( 
     132                                inputStream)); 
     133                for (String line = reader.readLine(); line != null; line = reader 
     134                                .readLine()) { 
    125135                        writer.write(line); 
    126136                        writer.write('\n'); 
    … …  
    131141 
    132142        @Override 
    133         public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) { 
     143        public DataSet materializeMainSchemaTable(Table table, Column[] columns, 
     144                        int maxRows) { 
    134145                if (columns == null || columns.length == 0) { 
    135146                        columns = table.getColumns(); 
    136147                } 
    137                 CSVReader reader = new CSVReader(FileHelper.getReader(_file, _encoding), _separatorChar, _quoteChar, 1); 
     148                CSVReader reader = new CSVReader( 
     149                                FileHelper.getReader(_file, _encoding), _separatorChar, 
     150                                _quoteChar, 1); 
    138151                if (maxRows < 0) { 
    139152                        return new DataSet(new CsvDataSetStrategy(reader, columns, null)); 
    … …  
    144157 
    145158        @Override 
    146         protected Schema getMainSchema() throws MetaModelException { 
     159        protected MutableSchema getMainSchema() throws MetaModelException { 
    147160                CSVReader reader = null; 
    148161                try { 
    149162                        String schemaName = getDefaultSchemaName(); 
    150                         Schema schema = new Schema(schemaName); 
    151                         Table table = new Table(schemaName.substring(0, schemaName.length() - 4), TableType.TABLE, schema); 
     163                        MutableSchema schema = new MutableSchema(schemaName); 
     164                        MutableTable table = new MutableTable(schemaName.substring(0, 
     165                                        schemaName.length() - 4), TableType.TABLE, schema); 
    152166                        schema.addTable(table); 
    153167 
    154                         reader = new CSVReader(FileHelper.getReader(_file, _encoding), _separatorChar, _quoteChar); 
     168                        reader = new CSVReader(FileHelper.getReader(_file, _encoding), 
     169                                        _separatorChar, _quoteChar); 
    155170                        String[] columnHeaders = reader.readNext(); 
    156171                        reader.close(); 
    157172                        for (int i = 0; i < columnHeaders.length; i++) { 
    158                                 Column column = new Column(columnHeaders[i], ColumnType.VARCHAR, table, i, true); 
     173                                MutableColumn column = new MutableColumn(columnHeaders[i], 
     174                                                ColumnType.VARCHAR, table, i, true); 
    159175                                table.addColumn(column); 
    160176                        } 
    … …  
    162178                        return schema; 
    163179                } catch (Exception e) { 
    164                         throw new IllegalStateException("Exception reading from file: " + _file, e); 
     180                        throw new IllegalStateException("Exception reading from file: " 
     181                                        + _file, e); 
    165182                } finally { 
    166183                        if (reader != null) { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/ExcelDataContextStrategy.java

    r886 r887  
    3535import org.eobjects.metamodel.schema.Column; 
    3636import org.eobjects.metamodel.schema.ColumnType; 
    37 import org.eobjects.metamodel.schema.Schema; 
     37import org.eobjects.metamodel.schema.MutableColumn; 
     38import org.eobjects.metamodel.schema.MutableSchema; 
     39import org.eobjects.metamodel.schema.MutableTable; 
    3840import org.eobjects.metamodel.schema.Table; 
    3941import org.eobjects.metamodel.util.FormatHelper; 
    40  
    4142 
    4243/** 
    4344 * DataContextStrategy to use for Excel files 
    4445 */ 
    45 public class ExcelDataContextStrategy extends QueryPostprocessDataContextStrategy { 
     46public class ExcelDataContextStrategy extends 
     47                QueryPostprocessDataContextStrategy { 
    4648 
    47         private static final NumberFormat _numberFormat = FormatHelper.getUiNumberFormat(); 
     49        private static final NumberFormat _numberFormat = FormatHelper 
     50                        .getUiNumberFormat(); 
    4851        private File _file; 
    4952 
    … …  
    5962 
    6063        @Override 
    61         public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) { 
     64        public DataSet materializeMainSchemaTable(Table table, Column[] columns, 
     65                        int maxRows) { 
    6266                if (columns == null || columns.length == 0) 
    6367                        columns = table.getColumns(); 
    … …  
    8589                                        String[] dataValues = new String[columns.length]; 
    8690                                        for (int j = 0; j < columns.length; j++) { 
    87                                                 HSSFCell cell = row.getCell(columns[j].getColumnNumber()); 
     91                                                HSSFCell cell = row.getCell(columns[j] 
     92                                                                .getColumnNumber()); 
    8893                                                dataValues[j] = getCellValue(cell); 
    8994                                        } 
    … …  
    101106 
    102107                } catch (Exception e) { 
    103                         throw new IllegalStateException("Exception reading from file: " + _file, e); 
     108                        throw new IllegalStateException("Exception reading from file: " 
     109                                        + _file, e); 
    104110                } finally { 
    105111                        if (in != null) { 
    … …  
    118124        } 
    119125 
    120         protected Schema getMainSchema() throws MetaModelException { 
     126        protected MutableSchema getMainSchema() throws MetaModelException { 
    121127                InputStream in = null; 
    122                 Schema schema = null; 
     128                MutableSchema schema = null; 
    123129                try { 
    124130 
    125                         schema = new Schema(getDefaultSchemaName()); 
     131                        schema = new MutableSchema(getDefaultSchemaName()); 
    126132                        in = new FileInputStream(_file); 
    127133                        HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(in)); 
    … …  
    133139                                        Iterator<HSSFRow> rowIterator = currentSheet.rowIterator(); 
    134140                                        if (rowIterator.hasNext()) { 
    135                                                 Table table = new Table(wb.getSheetName(i)); 
     141                                                MutableTable table = new MutableTable(wb 
     142                                                                .getSheetName(i)); 
    136143                                                HSSFRow row = rowIterator.next(); 
    137144                                                short rowLength = row.getLastCellNum(); 
    … …  
    142149                                                                columnName = "[Column " + (j + 1) + "]"; 
    143150                                                        } 
    144                                                         Column column = new Column(columnName, ColumnType.VARCHAR, table, j, true); 
     151                                                        MutableColumn column = new MutableColumn( 
     152                                                                        columnName, ColumnType.VARCHAR, table, j, 
     153                                                                        true); 
    145154                                                        table.addColumn(column); 
    146155                                                } 
    … …  
    152161 
    153162                } catch (Exception e) { 
    154                         throw new IllegalStateException("Exception reading from file: " + _file, e); 
     163                        throw new IllegalStateException("Exception reading from file: " 
     164                                        + _file, e); 
    155165                } finally { 
    156166                        if (in != null) { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/JdbcDataContextStrategy.java

    r886 r887  
    4848import org.eobjects.metamodel.schema.JdbcSchema; 
    4949import org.eobjects.metamodel.schema.JdbcTable; 
     50import org.eobjects.metamodel.schema.MutableColumn; 
     51import org.eobjects.metamodel.schema.ImmutableRelationship; 
     52import org.eobjects.metamodel.schema.MutableSchema; 
    5053import org.eobjects.metamodel.schema.Relationship; 
    5154import org.eobjects.metamodel.schema.Schema; 
    5255import org.eobjects.metamodel.schema.Table; 
    5356import org.eobjects.metamodel.schema.TableType; 
    54  
    5557 
    5658/** 
    … …  
    252254                                if (columnName != null) { 
    253255                                        Column column = table.getColumnByName(columnName); 
    254                                         if (column != null) { 
    255                                                 column.setIndexed(true); 
     256                                        if (column != null && column instanceof MutableColumn) { 
     257                                                ((MutableColumn) column).setIndexed(true); 
    256258                                        } else { 
    257259                                                _log.error("Indexed column \"" + columnName 
    … …  
    328330                                String remarks = rs.getString(12); 
    329331 
    330                                 Column column = new JdbcColumn(columnName, columnType, table, 
    331                                                 columnNumber, nullable); 
     332                                MutableColumn column = new JdbcColumn(columnName, columnType, 
     333                                                table, columnNumber, nullable); 
    332334                                column.setRemarks(remarks); 
    333335                                column.setNativeType(nativeType); 
    … …  
    420422                                } 
    421423                                if (!exists) { 
    422                                         Relationship.createRelationship(new Column[] { pkColumn }, 
     424                                        ImmutableRelationship.createRelationship( 
     425                                                        new Column[] { pkColumn }, 
    423426                                                        new Column[] { fkColumn }); 
    424427                                } 
    … …  
    553556 
    554557                        @Override 
    555                         protected Schema getMainSchema() throws MetaModelException { 
     558                        protected MutableSchema getMainSchema() throws MetaModelException { 
    556559                                return JdbcDataContextStrategy.this 
    557560                                                .getSchemaByName(getMainSchemaName()); 
    … …  
    732735        } 
    733736 
    734         public Schema getSchemaByName(String name) throws MetaModelException { 
     737        public MutableSchema getSchemaByName(String name) throws MetaModelException { 
    735738                DatabaseMetaData metaData; 
    736739                try { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/MetaModelHelper.java

    r886 r887  
    4444import org.eobjects.metamodel.util.ObjectComparator; 
    4545 
    46  
    4746/** 
    4847 * This class contains various helper functionality to common tasks involving 
    … …  
    6766         * list of tables and columns are included 
    6867         */ 
    69         public static Table[] getTables(List<Table> tableList, List<Column> columnList) { 
     68        public static Table[] getTables(List<? extends Table> tableList, 
     69                        List<? extends Column> columnList) { 
    7070                HashSet<Table> set = new HashSet<Table>(); 
    7171                set.addAll(tableList); 
    … …  
    103103         */ 
    104104        public static Column[] getTableColumns(Table table, List<Column> columns) { 
    105                 return getTableColumns(table, columns.toArray(new Column[columns.size()])); 
     105                return getTableColumns(table, columns 
     106                                .toArray(new Column[columns.size()])); 
    106107        } 
    107108 
    … …  
    129130        } 
    130131 
    131         public static DataSet getCarthesianProduct(DataSet[] fromDataSets, List<FilterItem> whereItems) { 
    132                 return getCarthesianProduct(fromDataSets, whereItems.toArray(new FilterItem[whereItems.size()])); 
    133         } 
    134  
    135         public static DataSet getCarthesianProduct(DataSet[] fromDataSets, FilterItem... filterItems) { 
     132        public static DataSet getCarthesianProduct(DataSet[] fromDataSets, 
     133                        List<FilterItem> whereItems) { 
     134                return getCarthesianProduct(fromDataSets, whereItems 
     135                                .toArray(new FilterItem[whereItems.size()])); 
     136        } 
     137 
     138        public static DataSet getCarthesianProduct(DataSet[] fromDataSets, 
     139                        FilterItem... filterItems) { 
    136140                // First check if carthesian product is even nescesary 
    137141                if (fromDataSets.length == 1) { 
    … …  
    156160                                        Object[] values = fromDataSet.getRow().getValues(); 
    157161                                        Object[] row = new Object[selectItems.size()]; 
    158                                         System.arraycopy(values, 0, row, selectItemOffset, values.length); 
     162                                        System.arraycopy(values, 0, row, selectItemOffset, 
     163                                                        values.length); 
    159164                                        data.add(row); 
    160165                                } 
    … …  
    171176                                        for (int j = 0; j < fromDataRows.size(); j++) { 
    172177                                                Object[] newRow = fromDataRows.get(j); 
    173                                                 System.arraycopy(newRow, 0, originalRow, selectItemOffset, newRow.length); 
     178                                                System.arraycopy(newRow, 0, originalRow, 
     179                                                                selectItemOffset, newRow.length); 
    174180                                                data.add(i + j, originalRow.clone()); 
    175181                                        } 
    … …  
    179185                } 
    180186 
    181                 SelectItem[] finalSelectItems = selectItems.toArray(new SelectItem[selectItems.size()]); 
     187                SelectItem[] finalSelectItems = selectItems 
     188                                .toArray(new SelectItem[selectItems.size()]); 
    182189                for (Iterator<Object[]> it = data.iterator(); it.hasNext();) { 
    183190                        Object[] objects = it.next(); 
    … …  
    193200        } 
    194201 
    195         public static DataSet getFiltered(DataSet dataSet, List<FilterItem> filterItems) { 
    196                 return getFiltered(dataSet, filterItems.toArray(new FilterItem[filterItems.size()])); 
    197         } 
    198  
    199         public static DataSet getFiltered(DataSet dataSet, FilterItem... filterItems) { 
     202        public static DataSet getFiltered(DataSet dataSet, 
     203                        List<FilterItem> filterItems) { 
     204                return getFiltered(dataSet, filterItems 
     205                                .toArray(new FilterItem[filterItems.size()])); 
     206        } 
     207 
     208        public static DataSet getFiltered(DataSet dataSet, 
     209                        FilterItem... filterItems) { 
    200210                if (filterItems.length == 0) { 
    201211                        return dataSet; 
    … …  
    219229        } 
    220230 
    221         public static DataSet getSelection(List<SelectItem> selectItems, DataSet dataSet) { 
    222                 return getSelection(selectItems.toArray(new SelectItem[selectItems.size()]), dataSet); 
     231        public static DataSet getSelection(List<SelectItem> selectItems, 
     232                        DataSet dataSet) { 
     233                return getSelection(selectItems.toArray(new SelectItem[selectItems 
     234                                .size()]), dataSet); 
    223235        } 
    224236 
    … …  
    233245                                        SelectItem selectItem = selectItems[i]; 
    234246                                        if (selectItem.getSubQuerySelectItem() != null) { 
    235                                                 resultRow[i] = row.getValue(selectItem.getSubQuerySelectItem()); 
     247                                                resultRow[i] = row.getValue(selectItem 
     248                                                                .getSubQuerySelectItem()); 
    236249                                        } else { 
    237250                                                resultRow[i] = row.getValue(selectItem); 
    … …  
    246259        } 
    247260 
    248         public static DataSet getGrouped(List<SelectItem> selectItems, DataSet dataSet, List<GroupByItem> groupByItems) { 
    249                 return getGrouped(selectItems.toArray(new SelectItem[selectItems.size()]), dataSet, groupByItems 
    250                                 .toArray(new GroupByItem[groupByItems.size()])); 
    251         } 
    252  
    253         public static DataSet getGrouped(SelectItem[] selectItems, DataSet dataSet, GroupByItem[] groupByItems) { 
     261        public static DataSet getGrouped(List<SelectItem> selectItems, 
     262                        DataSet dataSet, List<GroupByItem> groupByItems) { 
     263                return getGrouped(selectItems 
     264                                .toArray(new SelectItem[selectItems.size()]), dataSet, 
     265                                groupByItems.toArray(new GroupByItem[groupByItems.size()])); 
     266        } 
     267 
     268        public static DataSet getGrouped(SelectItem[] selectItems, DataSet dataSet, 
     269                        GroupByItem[] groupByItems) { 
    254270                DataSet result = dataSet; 
    255271                if (groupByItems != null && groupByItems.length > 0) { 
    … …  
    262278 
    263279                        // Creates a list of SelectItems that have functions 
    264                         List<SelectItem> functionItems = getFunctionSelectItems(Arrays.asList(selectItems)); 
     280                        List<SelectItem> functionItems = getFunctionSelectItems(Arrays 
     281                                        .asList(selectItems)); 
    265282 
    266283                        // Loop through the dataset and identify groups 
    … …  
    300317                                                objects.add(""); 
    301318                                        } else { 
    302                                                 throw new IllegalArgumentException("Expression function not supported: " + item); 
     319                                                throw new IllegalArgumentException( 
     320                                                                "Expression function not supported: " + item); 
    303321                                        } 
    304322                                } 
    … …  
    309327 
    310328                        // Loop through the groups to generate aggregates 
    311                         for (Entry<Row, Map<SelectItem, List<Object>>> entry : uniqueRows.entrySet()) { 
     329                        for (Entry<Row, Map<SelectItem, List<Object>>> entry : uniqueRows 
     330                                        .entrySet()) { 
    312331                                Row row = entry.getKey(); 
    313332                                Map<SelectItem, List<Object>> functionInput = entry.getValue(); 
    … …  
    326345                                                List<Object> objects = functionInput.get(item); 
    327346                                                if (objects != null) { 
    328                                                         Object functionResult = item.getFunction().evaluate(objects.toArray()); 
     347                                                        Object functionResult = item.getFunction() 
     348                                                                        .evaluate(objects.toArray()); 
    329349                                                        resultRow[i] = functionResult; 
    330350                                                } else { 
    331351                                                        if (item.getFunction() != null) { 
    332                                                                 _log.error("No function input found for SelectItem: " + item); 
     352                                                                _log 
     353                                                                                .error("No function input found for SelectItem: " 
     354                                                                                                + item); 
    333355                                                        } 
    334356                                                } 
    … …  
    343365        } 
    344366 
    345         public static DataSet getAggregated(List<SelectItem> resultSelectItems, DataSet dataSet) { 
     367        public static DataSet getAggregated(List<SelectItem> resultSelectItems, 
     368                        DataSet dataSet) { 
    346369                List<SelectItem> functionItems = getFunctionSelectItems(resultSelectItems); 
    347370                if (functionItems.isEmpty()) { 
    348371                        return dataSet; 
    349372                } else { 
    350                         SelectItem[] resultSelectItemsArray = resultSelectItems.toArray(new SelectItem[resultSelectItems.size()]); 
     373                        SelectItem[] resultSelectItemsArray = resultSelectItems 
     374                                        .toArray(new SelectItem[resultSelectItems.size()]); 
    351375                        Map<SelectItem, List<Object>> functionInput = new HashMap<SelectItem, List<Object>>(); 
    352376                        for (SelectItem item : functionItems) { 
    … …  
    366390                                        Column column = item.getColumn(); 
    367391                                        if (column != null) { 
    368                                                 Object value = inputRow.getValue(new SelectItem(column)); 
     392                                                Object value = inputRow 
     393                                                                .getValue(new SelectItem(column)); 
    369394                                                objects.add(value); 
    370395                                        } else if (SelectItem.isCountAllItem(item)) { 
    … …  
    373398                                                objects.add(""); 
    374399                                        } else { 
    375                                                 throw new IllegalArgumentException("Expression function not supported: " + item); 
     400                                                throw new IllegalArgumentException( 
     401                                                                "Expression function not supported: " + item); 
    376402                                        } 
    377403                                } 
    … …  
    382408                                        Object[] values = new Object[resultSelectItemsArray.length]; 
    383409                                        for (int i = 0; i < resultSelectItemsArray.length; i++) { 
    384                                                 Object value = inputRow.getValue(resultSelectItemsArray[i]); 
     410                                                Object value = inputRow 
     411                                                                .getValue(resultSelectItemsArray[i]); 
    385412                                                if (value != null) { 
    386413                                                        values[i] = value; 
    … …  
    414441                                        Row row = resultRows.get(i); 
    415442                                        Object[] values = row.getValues(); 
    416                                         for (Entry<SelectItem, Object> entry : functionResult.entrySet()) { 
     443                                        for (Entry<SelectItem, Object> entry : functionResult 
     444                                                        .entrySet()) { 
    417445                                                SelectItem item = entry.getKey(); 
    418446                                                int itemIndex = row.indexOf(item); 
    … …  
    429457        } 
    430458 
    431         public static List<SelectItem> getFunctionSelectItems(List<SelectItem> selectItems) { 
     459        public static List<SelectItem> getFunctionSelectItems( 
     460                        List<SelectItem> selectItems) { 
    432461                List<SelectItem> result = new ArrayList<SelectItem>(); 
    433462                for (SelectItem selectItem : selectItems) { 
    … …  
    442471        } 
    443472 
    444         public static DataSet getOrdered(DataSet dataSet, List<OrderByItem> orderByItems) { 
    445                 return getOrdered(dataSet, orderByItems.toArray(new OrderByItem[orderByItems.size()])); 
    446         } 
    447  
    448         public static DataSet getOrdered(DataSet dataSet, final OrderByItem... orderByItems) { 
     473        public static DataSet getOrdered(DataSet dataSet, 
     474                        List<OrderByItem> orderByItems) { 
     475                return getOrdered(dataSet, orderByItems 
     476                                .toArray(new OrderByItem[orderByItems.size()])); 
     477        } 
     478 
     479        public static DataSet getOrdered(DataSet dataSet, 
     480                        final OrderByItem... orderByItems) { 
    449481                if (orderByItems != null && orderByItems.length != 0) { 
    450482                        final int[] sortIndexes = new int[orderByItems.length]; 
    … …  
    456488                        List<Object[]> data = dataSet.toObjectArrays(); 
    457489 
    458                         final Comparator<Object> valueComparator = ObjectComparator.getComparator(); 
     490                        final Comparator<Object> valueComparator = ObjectComparator 
     491                                        .getComparator(); 
    459492 
    460493                        Collections.sort(data, new Comparator<Object[]>() { 
    … …  
    463496                                                Object sortObj1 = o1[sortIndexes[i]]; 
    464497                                                Object sortObj2 = o2[sortIndexes[i]]; 
    465                                                 int compare = valueComparator.compare(sortObj1, sortObj2); 
     498                                                int compare = valueComparator.compare(sortObj1, 
     499                                                                sortObj2); 
    466500                                                if (compare != 0) { 
    467501                                                        OrderByItem orderByItem = orderByItems[i]; 
    … …  
    516550                        result.addAll(getTableFromItems(rightSide)); 
    517551                } else { 
    518                         throw new IllegalStateException("FromItem was neither of Table type, SubQuery type or Join type: " + item); 
     552                        throw new IllegalStateException( 
     553                                        "FromItem was neither of Table type, SubQuery type or Join type: " 
     554                                                        + item); 
    519555                } 
    520556                return result; 
    … …  
    533569         *             if less or more than one Row is returned from the query 
    534570         */ 
    535         public static Row executeSingleRowQuery(DataContext dataContext, Query query) throws MetaModelException { 
     571        public static Row executeSingleRowQuery(DataContext dataContext, Query query) 
     572                        throws MetaModelException { 
    536573                DataSet dataSet = dataContext.executeQuery(query); 
    537574                boolean next = dataSet.next(); 
    538575                if (!next) { 
    539                         throw new MetaModelException("No rows returned from query: " + query); 
     576                        throw new MetaModelException("No rows returned from query: " 
     577                                        + query); 
    540578                } 
    541579                Row row = dataSet.getRow(); 
    542580                next = dataSet.next(); 
    543581                if (next) { 
    544                         throw new MetaModelException("More than one row returned from query: " + query); 
     582                        throw new MetaModelException( 
     583                                        "More than one row returned from query: " + query); 
    545584                } 
    546585                dataSet.close(); 
    … …  
    559598         * @return the left joined result dataset 
    560599         */ 
    561         public static DataSet getLeftJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) { 
     600        public static DataSet getLeftJoin(DataSet ds1, DataSet ds2, 
     601                        FilterItem[] onConditions) { 
    562602                if (ds1 == null) { 
    563603                        throw new IllegalArgumentException("Left DataSet cannot be null"); 
    … …  
    583623 
    584624                        List<Object[]> carthesianRows = getCarthesianProduct( 
    585                                         new DataSet[] { new DataSet(ds1rows), new DataSet(si2, ds2data) }, onConditions).toObjectArrays(); 
     625                                        new DataSet[] { new DataSet(ds1rows), 
     626                                                        new DataSet(si2, ds2data) }, onConditions) 
     627                                        .toObjectArrays(); 
    586628                        if (carthesianRows.size() > 0) { 
    587629                                resultRows.addAll(carthesianRows); 
    … …  
    609651         * @return the right joined result dataset 
    610652         */ 
    611         public static DataSet getRightJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) { 
     653        public static DataSet getRightJoin(DataSet ds1, DataSet ds2, 
     654                        FilterItem[] onConditions) { 
    612655                SelectItem[] ds1selects = ds1.getSelectItems(); 
    613656                SelectItem[] ds2selects = ds2.getSelectItems(); 
    614                 SelectItem[] leftOrderedSelects = new SelectItem[ds1selects.length + ds2selects.length]; 
    615                 System.arraycopy(ds1selects, 0, leftOrderedSelects, 0, ds1selects.length); 
    616                 System.arraycopy(ds2selects, 0, leftOrderedSelects, ds1selects.length, ds2selects.length); 
     657                SelectItem[] leftOrderedSelects = new SelectItem[ds1selects.length 
     658                                + ds2selects.length]; 
     659                System.arraycopy(ds1selects, 0, leftOrderedSelects, 0, 
     660                                ds1selects.length); 
     661                System.arraycopy(ds2selects, 0, leftOrderedSelects, ds1selects.length, 
     662                                ds2selects.length); 
    617663 
    618664                // We will reuse the left join algorithm (but switch the datasets 
    … …  
    645691        } 
    646692 
    647         public static Column[] getColumnsByType(Column[] columns, ColumnType columnType) { 
     693        public static Column[] getColumnsByType(Column[] columns, 
     694                        ColumnType columnType) { 
    648695                ArrayList<Column> result = new ArrayList<Column>(); 
    649696                for (Column column : columns) { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/QueryPostprocessDataContextStrategy.java

    r886 r887  
    4141import org.eobjects.metamodel.schema.Column; 
    4242import org.eobjects.metamodel.schema.ColumnType; 
     43import org.eobjects.metamodel.schema.MutableColumn; 
     44import org.eobjects.metamodel.schema.ImmutableRelationship; 
     45import org.eobjects.metamodel.schema.MutableSchema; 
     46import org.eobjects.metamodel.schema.MutableTable; 
    4347import org.eobjects.metamodel.schema.Relationship; 
    4448import org.eobjects.metamodel.schema.Schema; 
    … …  
    354358        private Schema getInformationSchema() { 
    355359                // Create schema 
    356                 Schema informationSchema = new Schema(INFORMATION_SCHEMA_NAME); 
    357                 Table tablesTable = new Table("tables", TableType.TABLE, 
     360                MutableSchema informationSchema = new MutableSchema(INFORMATION_SCHEMA_NAME); 
     361                MutableTable tablesTable = new MutableTable("tables", TableType.TABLE, 
    358362                                informationSchema); 
    359                 Table columnsTable = new Table("columns", TableType.TABLE, 
     363                MutableTable columnsTable = new MutableTable("columns", TableType.TABLE, 
    360364                                informationSchema); 
    361                 Table relationshipsTable = new Table("relationships", TableType.TABLE, 
     365                MutableTable relationshipsTable = new MutableTable("relationships", TableType.TABLE, 
    362366                                informationSchema); 
    363367                informationSchema.addTable(tablesTable).addTable(columnsTable) 
    … …  
    365369 
    366370                // Create "tables" table: name, type, num_columns, remarks 
    367                 tablesTable.addColumn(new Column("name", ColumnType.VARCHAR, 
     371                tablesTable.addColumn(new MutableColumn("name", ColumnType.VARCHAR, 
    368372                                tablesTable, 0, false)); 
    369                 tablesTable.addColumn(new Column("type", ColumnType.VARCHAR, 
     373                tablesTable.addColumn(new MutableColumn("type", ColumnType.VARCHAR, 
    370374                                tablesTable, 1, true)); 
    371                 tablesTable.addColumn(new Column("num_columns", ColumnType.INTEGER, 
     375                tablesTable.addColumn(new MutableColumn("num_columns", ColumnType.INTEGER, 
    372376                                tablesTable, 2, true)); 
    373                 tablesTable.addColumn(new Column("remarks", ColumnType.VARCHAR, 
     377                tablesTable.addColumn(new MutableColumn("remarks", ColumnType.VARCHAR, 
    374378                                tablesTable, 3, true)); 
    375379 
    376380                // Create "columns" table: name, type, native_type, size, nullable, 
    377381                // indexed, table, remarks 
    378                 columnsTable.addColumn(new Column("name", ColumnType.VARCHAR, 
     382                columnsTable.addColumn(new MutableColumn("name", ColumnType.VARCHAR, 
    379383                                columnsTable, 0, false)); 
    380                 columnsTable.addColumn(new Column("type", ColumnType.VARCHAR, 
     384                columnsTable.addColumn(new MutableColumn("type", ColumnType.VARCHAR, 
    381385                                columnsTable, 1, true)); 
    382                 columnsTable.addColumn(new Column("native_type", ColumnType.VARCHAR, 
     386                columnsTable.addColumn(new MutableColumn("native_type", ColumnType.VARCHAR, 
    383387                                columnsTable, 2, true)); 
    384                 columnsTable.addColumn(new Column("size", ColumnType.INTEGER, 
     388                columnsTable.addColumn(new MutableColumn("size", ColumnType.INTEGER, 
    385389                                columnsTable, 3, true)); 
    386                 columnsTable.addColumn(new Column("nullable", ColumnType.BOOLEAN, 
     390                columnsTable.addColumn(new MutableColumn("nullable", ColumnType.BOOLEAN, 
    387391                                columnsTable, 4, true)); 
    388                 columnsTable.addColumn(new Column("indexed", ColumnType.BOOLEAN, 
     392                columnsTable.addColumn(new MutableColumn("indexed", ColumnType.BOOLEAN, 
    389393                                columnsTable, 5, true)); 
    390                 columnsTable.addColumn(new Column("table", ColumnType.VARCHAR, 
     394                columnsTable.addColumn(new MutableColumn("table", ColumnType.VARCHAR, 
    391395                                columnsTable, 6, false)); 
    392                 columnsTable.addColumn(new Column("remarks", ColumnType.VARCHAR, 
     396                columnsTable.addColumn(new MutableColumn("remarks", ColumnType.VARCHAR, 
    393397                                columnsTable, 7, true)); 
    394398 
    395399                // Create "relationships" table: primary_table, primary_column, 
    396400                // foreign_table, foreign_column 
    397                 relationshipsTable.addColumn(new Column("primary_table", 
     401                relationshipsTable.addColumn(new MutableColumn("primary_table", 
    398402                                ColumnType.VARCHAR, relationshipsTable, 0, false)); 
    399                 relationshipsTable.addColumn(new Column("primary_column", 
     403                relationshipsTable.addColumn(new MutableColumn("primary_column", 
    400404                                ColumnType.VARCHAR, relationshipsTable, 1, false)); 
    401                 relationshipsTable.addColumn(new Column("foreign_table", 
     405                relationshipsTable.addColumn(new MutableColumn("foreign_table", 
    402406                                ColumnType.VARCHAR, relationshipsTable, 2, false)); 
    403                 relationshipsTable.addColumn(new Column("foreign_column", 
     407                relationshipsTable.addColumn(new MutableColumn("foreign_column", 
    404408                                ColumnType.VARCHAR, relationshipsTable, 3, false)); 
    405409 
    406                 Relationship.createRelationship(tablesTable.getColumnByName("name"), 
     410                ImmutableRelationship.createRelationship(tablesTable.getColumnByName("name"), 
    407411                                columnsTable.getColumnByName("table")); 
    408                 Relationship.createRelationship(tablesTable.getColumnByName("name"), 
     412                ImmutableRelationship.createRelationship(tablesTable.getColumnByName("name"), 
    409413                                relationshipsTable.getColumnByName("primary_table")); 
    410                 Relationship.createRelationship(tablesTable.getColumnByName("name"), 
     414                ImmutableRelationship.createRelationship(tablesTable.getColumnByName("name"), 
    411415                                relationshipsTable.getColumnByName("foreign_table")); 
    412                 Relationship.createRelationship(columnsTable.getColumnByName("name"), 
     416                ImmutableRelationship.createRelationship(columnsTable.getColumnByName("name"), 
    413417                                relationshipsTable.getColumnByName("primary_column")); 
    414                 Relationship.createRelationship(columnsTable.getColumnByName("name"), 
     418                ImmutableRelationship.createRelationship(columnsTable.getColumnByName("name"), 
    415419                                relationshipsTable.getColumnByName("foreign_column")); 
    416420 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/QuerySplitter.java

    r886 r887  
    3636import org.eobjects.metamodel.schema.Table; 
    3737 
    38  
    3938/** 
    4039 * The QuerySplitter class makes it possible to split up queries that are 
    … …  
    5251 */ 
    5352public class QuerySplitter { 
    54          
     53 
    5554        public final static long DEFAULT_MAX_ROWS = 300000; 
    5655        private static final int MINIMUM_MAX_ROWS = 100; 
    … …  
    110109        } 
    111110 
    112         private List<Query> splitQueryBasedOnColumns(List<Column> splitColumns) { 
     111        private List<Query> splitQueryBasedOnColumns( 
     112                        List<Column> splitColumns) { 
    113113                List<Query> result = new ArrayList<Query>(); 
    114114                if (splitColumns.isEmpty() || getRowCount() <= _maxRows) { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/XmlDataContextStrategy.java

    r886 r887  
    3737import org.eobjects.metamodel.query.SelectItem; 
    3838import org.eobjects.metamodel.schema.Column; 
     39import org.eobjects.metamodel.schema.MutableColumn; 
    3940import org.eobjects.metamodel.schema.ColumnType; 
     41import org.eobjects.metamodel.schema.ImmutableRelationship; 
     42import org.eobjects.metamodel.schema.MutableSchema; 
     43import org.eobjects.metamodel.schema.MutableTable; 
    4044import org.eobjects.metamodel.schema.Relationship; 
    41 import org.eobjects.metamodel.schema.Schema; 
    4245import org.eobjects.metamodel.schema.Table; 
    4346import org.eobjects.metamodel.schema.TableType; 
    … …  
    5356import org.xml.sax.InputSource; 
    5457 
    55  
    5658/** 
    5759 * A DataContext strategy that reads XML content and maps it to a table-based 
    … …  
    6971        public static final String NATIVE_TYPE_TEXT = "XML Text"; 
    7072        private static final String TEXT_CONTENT_TEMP_SUFFIX = "_metamodel_text_content"; 
    71         private Schema _schema; 
     73        private MutableSchema _schema; 
    7274        private Map<String, List<Object[]>> _tableData = new HashMap<String, List<Object[]>>();; 
    7375        private boolean _autoFlattenTables; 
    … …  
    8688                _autoFlattenTables = autoFlattenTables; 
    8789                _schemaName = schemaName; 
    88                 _schema = new Schema(_schemaName); 
     90                _schema = new MutableSchema(_schemaName); 
    8991                loadSchema(document); 
    9092        } 
    … …  
    195197 
    196198        @Override 
    197         protected Schema getMainSchema() throws MetaModelException { 
     199        protected MutableSchema getMainSchema() throws MetaModelException { 
    198200                loadSchema(); 
    199201                return _schema; 
    … …  
    214216        public XmlDataContextStrategy loadSchema() { 
    215217                if (_schema == null) { 
    216                         _schema = new Schema(_schemaName); 
     218                        _schema = new MutableSchema(_schemaName); 
    217219                        try { 
    218220                                DocumentBuilderFactory dbf = DocumentBuilderFactory 
    … …  
    237239                // node or pure XML structure) 
    238240                Table[] tables = _schema.getTables(); 
    239                 for (Table table : tables) { 
     241                for (Table t : tables) { 
     242                        MutableTable table = (MutableTable) t; 
    240243                        String tableName = table.getName(); 
    241244                        List<Object[]> tableRows = _tableData.get(tableName); 
    … …  
    248251                                Column idColumn = getIdColumn(table); 
    249252                                Column column = table.getColumnByName("id"); 
    250                                 if (column == null) { 
    251                                         idColumn.setName("id"); 
     253                                if (column == null && column instanceof MutableColumn) { 
     254                                        ((MutableColumn) idColumn).setName("id"); 
    252255                                } 
    253256 
    … …  
    264267                                } 
    265268                                if (!found) { 
    266                                         table.removeColumn(textContentColumn); 
     269                                        ((MutableTable) table).removeColumn(textContentColumn); 
    267270                                } else { 
    268271                                        // Rename all text content columns to reasonable 
    … …  
    274277                                        column = table.getColumnByName(preferredName); 
    275278                                        if (column == null) { 
    276                                                 textContentColumn.setName(preferredName); 
     279                                                ((MutableColumn) textContentColumn) 
     280                                                                .setName(preferredName); 
    277281                                        } 
    278282                                } 
    … …  
    285289 
    286290        private void loadTables(Element element, String tablePrefix, 
    287                         Column parentKeyColumn, int parentKey) { 
     291                        MutableColumn parentKeyColumn, int parentKey) { 
    288292                Attr[] attributes = getAttributes(element); 
    289293                String textContent = getTextContent(element); 
    … …  
    292296                                || hasSiblings(element)) { 
    293297                        // We need to represent this type of node with a table 
    294                         Table table = _schema.getTableByName(tableName); 
     298                        MutableTable table = (MutableTable) _schema 
     299                                        .getTableByName(tableName); 
    295300                        Column idColumn; 
    296                         Column foreignKeyColumn; 
     301                        MutableColumn foreignKeyColumn; 
    297302                        List<Object[]> tableRows; 
    298303                        if (table == null) { 
    299304                                _log.info("Creating table: " + tableName); 
    300                                 table = new Table(tableName, TableType.TABLE, _schema); 
     305                                table = new MutableTable(tableName, TableType.TABLE, _schema); 
    301306                                _schema.addTable(table); 
    302307                                idColumn = getIdColumn(table); 
    … …  
    306311                                if (parentKeyColumn != null) { 
    307312                                        Table parentTable = parentKeyColumn.getTable(); 
    308                                         foreignKeyColumn = new Column( 
    309                                                         parentTable.getName() + "_id", parentKeyColumn 
    310                                                                         .getType(), table, table.getColumnCount(), 
    311                                                         false); 
     313                                        foreignKeyColumn = new MutableColumn(parentTable.getName() 
     314                                                        + "_id", parentKeyColumn.getType(), table, table 
     315                                                        .getColumnCount(), false); 
    312316                                        foreignKeyColumn.setNativeType(NATIVE_TYPE_FOREIGN_KEY); 
    313                                         table.addColumn(foreignKeyColumn); 
    314  
    315                                         Relationship.createRelationship( 
    316                                                         new Column[] { parentKeyColumn }, 
    317                                                         new Column[] { foreignKeyColumn }); 
     317                                        ((MutableTable) table).addColumn(foreignKeyColumn); 
     318 
     319                                        ImmutableRelationship.createRelationship( 
     320                                                        new MutableColumn[] { parentKeyColumn }, 
     321                                                        new MutableColumn[] { foreignKeyColumn }); 
    318322 
    319323                                } else { 
    … …  
    325329                                Column[] foreignKeys = table.getForeignKeys(); 
    326330                                if (foreignKeys.length == 1) { 
    327                                         foreignKeyColumn = foreignKeys[0]; 
     331                                        foreignKeyColumn = (MutableColumn) foreignKeys[0]; 
    328332                                } else { 
    329333                                        foreignKeyColumn = null; 
    … …  
    333337                        Column textContentColumn = getTextContentColumn(table, element 
    334338                                        .getNodeName()); 
    335                         Map<Column, String> columnValues = new HashMap<Column, String>(); 
     339                        Map<MutableColumn, String> columnValues = new HashMap<MutableColumn, String>(); 
    336340                        for (Attr attr : attributes) { 
    337341                                String name = attr.getName(); 
    338                                 Column column = table.getColumnByName(name); 
     342                                MutableColumn column = (MutableColumn) table 
     343                                                .getColumnByName(name); 
    339344                                if (column == null) { 
    340345                                        _log.info("Creating column: " + tableName + "." + name); 
    341                                         column = new Column(name, ColumnType.VARCHAR, table, table 
    342                                                         .getColumnCount(), true); 
     346                                        column = new MutableColumn(name, ColumnType.VARCHAR, table, 
     347                                                        table.getColumnCount(), true); 
    343348                                        column.setNativeType(NATIVE_TYPE_ATTRIBUTE); 
    344                                         table.addColumn(column); 
     349                                        ((MutableTable) table).addColumn(column); 
    345350                                } 
    346351                                columnValues.put(column, attr.getValue()); 
    … …  
    360365                        } 
    361366                        // Add values for attributes 
    362                         for (Entry<Column, String> entry : columnValues.entrySet()) { 
     367                        for (Entry<MutableColumn, String> entry : columnValues.entrySet()) { 
    363368                                rowData[entry.getKey().getColumnNumber()] = entry.getValue(); 
    364369                        } 
    … …  
    373378                                // child tables can create relationship to it 
    374379                                parentKey = id; 
    375                                 parentKeyColumn = idColumn; 
     380                                parentKeyColumn = (MutableColumn) idColumn; 
    376381                        } 
    377382                        tableRows.add(rowData); 
    … …  
    400405                        _log.info("Creating text content column for table: " 
    401406                                        + table.getName()); 
    402                         column = new Column(preferredColumnName + TEXT_CONTENT_TEMP_SUFFIX, 
    403                                         ColumnType.VARCHAR, table, table.getColumnCount(), true); 
    404                         column.setNativeType(NATIVE_TYPE_TEXT); 
    405                         table.addColumn(column); 
     407                        MutableColumn c = new MutableColumn(preferredColumnName 
     408                                        + TEXT_CONTENT_TEMP_SUFFIX, ColumnType.VARCHAR, table, 
     409                                        table.getColumnCount(), true); 
     410                        c.setNativeType(NATIVE_TYPE_TEXT); 
     411                        ((MutableTable) table).addColumn(c); 
     412                        column = c; 
     413 
    406414                } 
    407415                return column; 
    408416        } 
    409417 
    410         private Column getIdColumn(Table table) { 
     418        private Column getIdColumn(MutableTable table) { 
    411419                Column[] columns = table.getColumns(); 
    412420                Column column = null; 
    413421                for (Column col : columns) { 
    414422                        if (NATIVE_TYPE_PRIMARY_KEY.equals(col.getNativeType())) { 
    415                                 column = col; 
     423                                column = (MutableColumn) col; 
    416424                                break; 
    417425                        } 
    … …  
    420428                        String tableName = table.getName(); 
    421429                        _log.info("Creating id column for table: " + tableName); 
    422                         column = new Column(tableName + "_metamodel_surrogate_id", 
    423                                         ColumnType.INTEGER, table, table.getColumnCount(), false); 
    424                         column.setNativeType(NATIVE_TYPE_PRIMARY_KEY); 
    425                         column.setIndexed(true); 
    426                         table.addColumn(column); 
     430                        MutableColumn c = new MutableColumn(tableName 
     431                                        + "_mdbeans_surrogate_id", ColumnType.INTEGER, table, table 
     432                                        .getColumnCount(), false); 
     433                        c.setNativeType(NATIVE_TYPE_PRIMARY_KEY); 
     434                        c.setIndexed(true); 
     435                        table.addColumn(c); 
     436                        column = c; 
    427437                } 
    428438                return column; 
    … …  
    492502 
    493503        public XmlDataContextStrategy flattenTables(Relationship relationship) { 
    494                 Table primaryTable = relationship.getPrimaryTable(); 
    495                 Table foreignTable = relationship.getForeignTable(); 
     504                MutableTable primaryTable = (MutableTable) relationship 
     505                                .getPrimaryTable(); 
     506                MutableTable foreignTable = (MutableTable) relationship 
     507                                .getForeignTable(); 
    496508 
    497509                // Check that foreignTable is not primary table in other relationships 
    … …  
    530542 
    531543                Query q = new Query(); 
    532                 q.select(primaryColumns.toArray(new Column[primaryColumns.size()])); 
    533                 q.select(foreignColumns.toArray(new Column[foreignColumns.size()])); 
     544                q.select(primaryColumns 
     545                                .toArray(new MutableColumn[primaryColumns.size()])); 
     546                q.select(foreignColumns 
     547                                .toArray(new MutableColumn[foreignColumns.size()])); 
    534548                q.from(new FromItem(JoinType.LEFT, relationship)); 
    535549                if (_log.isDebugEnabled()) { 
    … …  
    540554 
    541555                for (Column foreignColumn : foreignColumns) { 
    542                         Column newPrimaryColumn = new Column(foreignColumn.getName(), 
    543                                         foreignColumn.getType(), primaryTable, primaryTable 
    544                                                         .getColumnCount(), foreignColumn.isNullable()); 
     556                        MutableColumn newPrimaryColumn = new MutableColumn(foreignColumn 
     557                                        .getName(), foreignColumn.getType(), primaryTable, 
     558                                        primaryTable.getColumnCount(), foreignColumn.isNullable()); 
    545559                        newPrimaryColumn.setIndexed(foreignColumn.isIndexed()); 
    546560                        newPrimaryColumn.setNativeType(foreignColumn.getNativeType()); 
    547                         primaryTable.addColumn(newPrimaryColumn); 
     561                        ((MutableTable) primaryTable).addColumn(newPrimaryColumn); 
    548562                } 
    549563                _tableData.put(primaryTableName, tableRows); 
    550                 foreignTable.getSchema().removeTable(foreignTable); 
     564                ((MutableSchema) foreignTable.getSchema()).removeTable(foreignTable); 
    551565                _tableData.remove(foreignTableName); 
    552                 relationship.remove(); 
     566                ImmutableRelationship.remove(relationship); 
    553567 
    554568                if (_log.isInfoEnabled()) { 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/dbase/DbaseDataContextStrategy.java

    r886 r887  
    2828import org.eobjects.metamodel.schema.Column; 
    2929import org.eobjects.metamodel.schema.ColumnType; 
     30import org.eobjects.metamodel.schema.MutableColumn; 
     31import org.eobjects.metamodel.schema.MutableSchema; 
     32import org.eobjects.metamodel.schema.MutableTable; 
    3033import org.eobjects.metamodel.schema.Schema; 
    3134import org.eobjects.metamodel.schema.Table; 
    … …  
    4043import org.xBaseJ.fields.NumField; 
    4144import org.xBaseJ.fields.PictureField; 
    42  
    4345 
    4446public class DbaseDataContextStrategy extends 
    … …  
    8183                } 
    8284 
    83                 Schema schema = new Schema(schemaName); 
    84                 Table table = new Table(schemaName 
    85                                 .substring(0, schemaName.length() - 4), TableType.TABLE, schema); 
     85                MutableSchema schema = new MutableSchema(schemaName); 
     86                MutableTable table = new MutableTable(schemaName.substring(0, 
     87                                schemaName.length() - 4), TableType.TABLE, schema); 
    8688                schema.addTable(table); 
    8789 
    … …  
    9092                                Field field = dbf.getField(i + 1); 
    9193 
    92                                 Column column = new Column(field.getName()); 
     94                                MutableColumn column = new MutableColumn(field.getName()); 
    9395                                ColumnType columnType = ColumnType.VARCHAR; 
    9496 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/detect/ColumnTypeTransformer.java

    r886 r887  
    2323import org.apache.commons.logging.LogFactory; 
    2424import org.eobjects.metamodel.schema.Column; 
     25import org.eobjects.metamodel.schema.MutableColumn; 
    2526import org.eobjects.metamodel.schema.ColumnType; 
    2627import org.eobjects.metamodel.util.BooleanComparator; 
    … …  
    2829import org.joda.time.LocalDate; 
    2930import org.joda.time.LocalTime; 
    30  
    3131 
    3232/** 
    … …  
    6464        private boolean _timePossible = true; 
    6565        private boolean _nullPossible = false; 
    66         private Column _column; 
     66        private MutableColumn _column; 
    6767 
    6868        public ColumnTypeTransformer(Column column) { 
    … …  
    7070                        throw new IllegalArgumentException("Column cannot be null"); 
    7171                } 
    72                 _column = column; 
     72                if (!(column instanceof MutableColumn)) { 
     73                        throw new IllegalArgumentException( 
     74                                        "Can only transform type of MutableColumns"); 
     75                } 
     76                _column = (MutableColumn) column; 
    7377        } 
    7478 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/query/FromItem.java

    r886 r887  
    2222import org.eobjects.metamodel.schema.Table; 
    2323 
    24  
    2524/** 
    2625 * Represents a FROM item. FROM items can take different forms: 
    … …  
    120119                _rightOn = rightOn; 
    121120        } 
    122          
    123         /** 
    124          * Creates a single unvalidated from item based on a expression. 
    125          * Expression based from items are typically NOT datastore-neutral but are 
    126          * available for special "hacking" needs. 
    127          *  
    128          * Expression based from items can only be used for JDBC based datastores since 
    129          * they are translated directly into SQL. 
     121 
     122        /** 
     123         * Creates a single unvalidated from item based on a expression. Expression 
     124         * based from items are typically NOT datastore-neutral but are available 
     125         * for special "hacking" needs. 
     126         *  
     127         * Expression based from items can only be used for JDBC based datastores 
     128         * since they are translated directly into SQL. 
    130129         *  
    131130         * @param expression 
    132          *            An expression to use for the from item, for example 
    133          *            "MYTABLE". 
     131         *            An expression to use for the from item, for example "MYTABLE". 
    134132         */ 
    135133        public FromItem(String expression) { 
    … …  
    186184                return _rightOn; 
    187185        } 
    188          
     186 
    189187        public String getExpression() { 
    190188                return _expression; 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/query/Query.java

    r886 r887  
    2424import org.eobjects.metamodel.schema.Column; 
    2525import org.eobjects.metamodel.schema.Table; 
    26  
    2726 
    2827/** 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/query/SelectItem.java

    r886 r887  
    2424import org.eobjects.metamodel.schema.Table; 
    2525 
    26  
    2726/** 
    2827 * Represents a SELECT item. SelectItems can take different forms: 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/Column.java

    r886 r887  
    1 /** 
    2  *  This file is part of MetaModel. 
    3  * 
    4  *  MetaModel is free software: you can redistribute it and/or modify 
    5  *  it under the terms of the GNU General Public License as published by 
    6  *  the Free Software Foundation, either version 3 of the License, or 
    7  *  (at your option) any later version. 
    8  * 
    9  *  MetaModel is distributed in the hope that it will be useful, 
    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    12  *  GNU General Public License for more details. 
    13  * 
    14  *  You should have received a copy of the GNU General Public License 
    15  *  along with MetaModel.  If not, see <http://www.gnu.org/licenses/>. 
    16  */ 
    171package org.eobjects.metamodel.schema; 
    18  
    19 import java.io.Serializable; 
    20  
    21 import org.apache.commons.lang.builder.CompareToBuilder; 
    22 import org.apache.commons.lang.builder.EqualsBuilder; 
    23 import org.apache.commons.lang.builder.HashCodeBuilder; 
    24 import org.apache.commons.lang.builder.ToStringBuilder; 
    25 import org.apache.commons.lang.builder.ToStringStyle; 
    262 
    273/** 
    … …  
    328 * @see Relationship 
    339 */ 
    34 public class Column implements Serializable, Comparable<Column> { 
    35  
    36         private static final long serialVersionUID = -353183696233890927L; 
    37         private transient String _qualifiedLabel; 
    38         private int _columnNumber; 
    39         private String _name; 
    40         private ColumnType _type; 
    41         private Table _table; 
    42         private Boolean _nullable = null; 
    43         private String _remarks; 
    44         private boolean _indexed = false; 
    45         private Integer _columnSize = null; 
    46         private String _nativeType = null; 
    47         private String _quoteString = null; 
    48  
    49         public Column() { 
    50         } 
    51  
    52         public Column(String name) { 
    53                 this(); 
    54                 setName(name); 
    55         } 
    56  
    57         public Column(String name, ColumnType type) { 
    58                 this(name); 
    59                 setType(type); 
    60         } 
    61  
    62         public Column(String name, ColumnType type, Table table, int columnNumber, 
    63                         Boolean nullable) { 
    64                 this(name, type); 
    65                 setColumnNumber(columnNumber); 
    66                 setTable(table); 
    67                 setNullable(nullable); 
    68         } 
     10public interface Column extends Comparable<Column> { 
    6911 
    7012        /** 
    … …  
    7214         * whereas the JDBC is 1-based. 
    7315         */ 
    74         public int getColumnNumber() { 
    75                 return _columnNumber; 
    76         } 
    77  
    78         public Column setColumnNumber(int columnNumber) { 
    79                 _columnNumber = columnNumber; 
    80                 return this; 
    81         } 
     16        public int getColumnNumber(); 
    8217 
    8318        /** 
    8419         * Returns the Column Name 
    8520         */ 
    86         public String getName() { 
    87                 return _name; 
    88         } 
     21        public String getName(); 
    8922 
    9023        /** 
    … …  
    9629         * @return a qualified label 
    9730         */ 
    98         public String getQualifiedLabel() { 
    99                 if (_qualifiedLabel == null) { 
    100                         StringBuilder sb = new StringBuilder(); 
    101                         if (_table != null) { 
    102                                 sb.append(_table.getQualifiedLabel()); 
    103                                 sb.append('.'); 
    104                         } 
    105                         sb.append(getName()); 
    106                         _qualifiedLabel = sb.toString(); 
    107                 } 
    108                 return _qualifiedLabel; 
    109         } 
    110  
    111         public Column setName(String name) { 
    112                 _name = name; 
    113                 _qualifiedLabel = null; 
    114                 return this; 
    115         } 
     31        public String getQualifiedLabel(); 
    11632 
    11733        /** 
    11834         * Gets the type of the column 
    11935         */ 
    120         public ColumnType getType() { 
    121                 return _type; 
    122         } 
    123  
    124         public Column setType(ColumnType type) { 
    125                 _type = type; 
    126                 return this; 
    127         } 
     36        public ColumnType getType(); 
    12837 
    12938        /** 
    13039         * Gets the table for which this column belong 
    13140         */ 
    132         public Table getTable() { 
    133                 return _table; 
    134         } 
     41        public Table getTable(); 
    13542 
    136         public Column setTable(Table table) { 
    137                 _table = table; 
    138                 _qualifiedLabel = null; 
    139                 return this; 
    140         } 
     43        public Boolean isNullable(); 
    14144 
    142         public Boolean isNullable() { 
    143                 return _nullable; 
    144         } 
     45        public String getRemarks(); 
    14546 
    146         public Column setNullable(Boolean nullable) { 
    147                 _nullable = nullable; 
    148                 return this; 
    149         } 
     47        public Integer getColumnSize(); 
    15048 
    151         public String getRemarks() { 
    152                 return _remarks; 
    153         } 
     49        public String getNativeType(); 
    15450 
    155         public void setRemarks(String remarks) { 
    156                 _remarks = remarks; 
    157         } 
     51        public boolean isIndexed(); 
    15852 
    159         public Integer getColumnSize() { 
    160                 return _columnSize; 
    161         } 
     53        public String getQuote(); 
    16254 
    163         public Column setColumnSize(Integer columnSize) { 
    164                 _columnSize = columnSize; 
    165                 return this; 
    166         } 
     55        public String getQuotedName(); 
    16756 
    168         public String getNativeType() { 
    169                 return _nativeType; 
    170         } 
     57        public int compareTo(Column that); 
    17158 
    172         public Column setNativeType(String nativeType) { 
    173                 _nativeType = nativeType; 
    174                 return this; 
    175         } 
    176  
    177         public boolean isIndexed() { 
    178                 return _indexed; 
    179         } 
    180  
    181         public Column setIndexed(boolean indexed) { 
    182                 _indexed = indexed; 
    183                 return this; 
    184         } 
    185  
    186         public String getQuote() { 
    187                 return _quoteString; 
    188         } 
    189  
    190         public Column setQuote(String quoteString) { 
    191                 _quoteString = quoteString; 
    192                 return this; 
    193         } 
    194  
    195         public String getQuotedName() { 
    196                 if (_quoteString != null) { 
    197                         return _quoteString + getName() + _quoteString; 
    198                 } 
    199                 return getName(); 
    200         } 
    201  
    202         @Override 
    203         public String toString() { 
    204                 return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE) 
    205                                 .append("name", _name).append("columnNumber", _columnNumber) 
    206                                 .append("type", _type).append("nullable", _nullable).append( 
    207                                                 "indexed", isIndexed()).append("nativeType", 
    208                                                 _nativeType).append("columnSize", _columnSize) 
    209                                 .toString(); 
    210         } 
    211  
    212         @Override 
    213         public int hashCode() { 
    214                 HashCodeBuilder hcb = new HashCodeBuilder(); 
    215                 hcb.append(_columnNumber).append(_name).append(_table); 
    216                 return hcb.toHashCode(); 
    217         } 
    218  
    219         @Override 
    220         public boolean equals(Object obj) { 
    221                 if (obj == this) { 
    222                         return true; 
    223                 } 
    224                 if (obj instanceof Column) { 
    225                         Column that = (Column) obj; 
    226                         EqualsBuilder eb = new EqualsBuilder().append(this.getName(), 
    227                                         that.getName()).append(this.getColumnNumber(), 
    228                                         that.getColumnNumber()).append(this.getType(), 
    229                                         that.getType()).append(this.isIndexed(), that.isIndexed()) 
    230                                         .append(this.getNativeType(), that.getNativeType()).append( 
    231                                                         this.getColumnSize(), that.getColumnSize()); 
    232                         if (this.getTable() != null && that.getTable() != null) { 
    233                                 eb.append(this.getTable().getName(), that.getTable().getName()); 
    234                         } 
    235                         return eb.isEquals(); 
    236                 } 
    237                 return false; 
    238         } 
    239  
    240         public int compareTo(Column that) { 
    241                 CompareToBuilder ctb = new CompareToBuilder(); 
    242                 ctb.append(this.getColumnNumber(), that.getColumnNumber()); 
    243                 ctb.append(this.getTable(), that.getTable()); 
    244                 return ctb.toComparison(); 
    245         } 
    246  
    247         /** 
    248          * Tells the column object that the table it belongs to have changed. This 
    249          * is typically done if the table is being renamed or similar. 
    250          */ 
    251         protected void fireTableChanged() { 
    252                 _qualifiedLabel = null; 
    253         } 
    25459} 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/CompositeSchema.java

    r886 r887  
    88import org.apache.commons.logging.LogFactory; 
    99 
    10 public class CompositeSchema extends Schema { 
     10public class CompositeSchema extends MutableSchema { 
    1111 
    1212        private static final long serialVersionUID = -4018186004438335133L; 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/ImmutableRelationship.java

    r886 r887  
    2222import org.apache.commons.lang.builder.EqualsBuilder; 
    2323import org.apache.commons.lang.builder.HashCodeBuilder; 
    24  
    25 /** 
    26  * Represents a relationship between two tables where one set of columns is the 
    27  * primary key, and another set is the foreign key. Relationship is unlike most 
    28  * of the MetaModel an immutable type. The immutability help ensure integrity of 
    29  * object-relationships. To create relationsips use the 
    30  * <code>createRelationship</code> method and to remove them use the 
    31  * <code>remove</remove> method. 
    32  *  
    33  * @see Table 
    34  * @see Column 
    35  */ 
    36 public class Relationship implements Serializable, Comparable<Relationship> { 
     24import org.apache.commons.lang.builder.ToStringBuilder; 
     25import org.apache.commons.lang.builder.ToStringStyle; 
     26 
     27public class ImmutableRelationship implements Serializable, Relationship { 
    3728 
    3829        private static final long serialVersionUID = 238786848828528822L; 
    39         private Table _primaryTable; 
     30        private MutableTable _primaryTable; 
    4031        private Column[] _primaryColumns; 
    41         private Table _foreignTable; 
     32        private MutableTable _foreignTable; 
    4233        private Column[] _foreignColumns; 
    4334 
    … …  
    5445        public static Relationship createRelationship(Column[] primaryColumns, 
    5546                        Column[] foreignColumns) { 
    56                 Table primaryTable = checkSameTable(primaryColumns); 
    57                 Table foreignTable = checkSameTable(foreignColumns); 
    58                 Relationship relation = new Relationship(primaryTable, primaryColumns, 
    59                                 foreignTable, foreignColumns); 
     47                MutableTable primaryTable = checkSameTable(primaryColumns); 
     48                MutableTable foreignTable = checkSameTable(foreignColumns); 
     49                ImmutableRelationship relation = new ImmutableRelationship(primaryTable, 
     50                                primaryColumns, foreignTable, foreignColumns); 
    6051                primaryTable.addRelationship(relation); 
    6152 
    … …  
    7465        } 
    7566 
    76         private static Table checkSameTable(Column[] columns) { 
     67        private static MutableTable checkSameTable(Column[] columns) { 
    7768                if (columns == null || columns.length == 0) { 
    7869                        throw new IllegalArgumentException( 
    … …  
    9384                        } 
    9485                } 
    95                 return table; 
    96         } 
    97  
    98         public void remove() { 
     86                if (table instanceof MutableTable) { 
     87                        return (MutableTable) table; 
     88                } 
     89                throw new IllegalStateException( 
     90                                "Can only create MutableRelationship for MutableTables"); 
     91        } 
     92 
     93        private void remove() { 
    9994                _primaryTable.removeRelationship(this); 
    10095                _foreignTable.removeRelationship(this); 
    … …  
    108103         * Prevent external instantiation 
    109104         */ 
    110         private Relationship(Table primaryTable, Column[] primaryColumns, 
    111                         Table foreignTable, Column[] foreignColumns) { 
     105        private ImmutableRelationship(MutableTable primaryTable, 
     106                        Column[] primaryColumns, MutableTable foreignTable, 
     107                        Column[] foreignColumns) { 
    112108                _primaryTable = primaryTable; 
    113109                _primaryColumns = primaryColumns; 
    … …  
    116112        } 
    117113 
     114        @Override 
    118115        public Table getPrimaryTable() { 
    119116                return _primaryTable; 
    120117        } 
    121118 
     119        @Override 
    122120        public Column[] getPrimaryColumns() { 
    123121                return _primaryColumns; 
    124122        } 
    125123 
     124        @Override 
    126125        public Table getForeignTable() { 
    127126                return _foreignTable; 
    128127        } 
    129128 
     129        @Override 
    130130        public Column[] getForeignColumns() { 
    131131                return _foreignColumns; 
    … …  
    134134        @Override 
    135135        public String toString() { 
    136                 StringBuilder sb = new StringBuilder(); 
    137                 sb.append("Relationship["); 
    138                 sb.append("primaryTable=" + _primaryTable.getName()); 
     136                StringBuilder sb = new StringBuilder("{"); 
    139137                Column[] columns = getPrimaryColumns(); 
    140                 sb.append(",primaryColumns={"); 
    141138                for (int i = 0; i < columns.length; i++) { 
    142139                        if (i != 0) { 
    … …  
    146143                } 
    147144                sb.append("}"); 
    148                 sb.append(",foreignTable=" + _foreignTable.getName()); 
     145                String primaryColumns = sb.toString(); 
     146 
     147                sb = new StringBuilder("{"); 
    149148                columns = getForeignColumns(); 
    150                 sb.append(",foreignColumns={"); 
    151149                for (int i = 0; i < columns.length; i++) { 
    152150                        if (i != 0) { 
    … …  
    156154                } 
    157155                sb.append("}"); 
    158                 sb.append("]"); 
    159                 return sb.toString(); 
    160         } 
    161  
     156                String foreignColumns = sb.toString(); 
     157                 
     158                return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE) 
     159                                .append("primaryTable", _primaryTable.getName()).append( 
     160                                                "primaryColumns", primaryColumns).append( 
     161                                                "foreignTable", _foreignTable.getName()).append("foreignColumns", foreignColumns).toString(); 
     162        } 
     163 
     164        @Override 
    162165        public int compareTo(Relationship that) { 
    163166                CompareToBuilder ctb = new CompareToBuilder(); 
    … …  
    198201         *         columns as a part of the relation 
    199202         */ 
     203        @Override 
    200204        public boolean containsColumnPair(Column pkColumn, Column fkColumn) { 
    201205                if (pkColumn != null && fkColumn != null) { 
    … …  
    209213                return false; 
    210214        } 
     215 
     216        public static void remove(Relationship relationship) { 
     217                ((ImmutableRelationship) relationship).remove(); 
     218        } 
    211219} 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/JdbcColumn.java

    r886 r887  
    2121import java.io.ObjectOutputStream; 
    2222 
    23 public class JdbcColumn extends Column { 
     23public class JdbcColumn extends MutableColumn { 
    2424 
    2525        private static final long serialVersionUID = 389872697452157919L; 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/JdbcSchema.java

    r886 r887  
    2424 
    2525 
    26 public class JdbcSchema extends Schema { 
     26public class JdbcSchema extends MutableSchema { 
    2727 
    2828        private static final long serialVersionUID = 7543633400859277467L; 
    … …  
    4747                // Trigger the lazy-loading of the full schema, including relationships, 
    4848                // indexes and all columns 
    49                 Schema schema = new Schema(_name); 
     49                MutableSchema schema = new MutableSchema(_name); 
    5050                Table[] tables = getTables(); 
    5151                for (int i = 0; i < tables.length; i++) { 
    5252                        Table origTable = tables[i]; 
    53                         Table newTable = new Table(origTable.getName(), 
     53                        MutableTable newTable = new MutableTable(origTable.getName(), 
    5454                                        origTable.getType(), schema); 
    5555                        newTable.setQuote(origTable.getQuote()); 
    … …  
    5858                        for (int j = 0; j < columns.length; j++) { 
    5959                                Column origColumn = columns[j]; 
    60                                 Column newColumn = new Column(origColumn.getName(), origColumn 
     60                                MutableColumn newColumn = new MutableColumn(origColumn.getName(), origColumn 
    6161                                                .getType(), newTable, origColumn.getColumnNumber(), 
    6262                                                origColumn.isNullable()); 
    … …  
    9292                        } 
    9393 
    94                         Relationship.createRelationship(newPrimaryColumns, 
     94                        ImmutableRelationship.createRelationship(newPrimaryColumns, 
    9595                                        newForeignColumns); 
    9696                } 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/JdbcTable.java

    r886 r887  
    2424import org.eobjects.metamodel.JdbcDataContextStrategy; 
    2525 
    26  
    27 public class JdbcTable extends Table { 
     26public class JdbcTable extends MutableTable { 
    2827 
    2928        private static final long serialVersionUID = 5952310469458880330L; 
    … …  
    8483        private void readObject(ObjectInputStream stream) throws IOException, 
    8584                        ClassNotFoundException { 
    86                 Schema schema = (Schema) stream.readObject(); 
     85                MutableSchema schema = (MutableSchema) stream.readObject(); 
    8786                String tableName = (String) stream.readObject(); 
    8887                Table table = schema.getTableByName(tableName); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/MutableColumn.java

    r886 r887  
    2525import org.apache.commons.lang.builder.ToStringStyle; 
    2626 
    27 /** 
    28  * Represents a column and it's metadata description. Columns reside within a 
    29  * Table and can be used as keys for relationships between tables. 
    30  *  
    31  * @see Table 
    32  * @see Relationship 
    33  */ 
    34 public class Column implements Serializable, Comparable<Column> { 
     27public class MutableColumn implements Serializable, Column { 
    3528 
    3629        private static final long serialVersionUID = -353183696233890927L; 
    … …  
    4740        private String _quoteString = null; 
    4841 
    49         public Column() { 
    50         } 
    51  
    52         public Column(String name) { 
     42        public MutableColumn() { 
     43        } 
     44 
     45        public MutableColumn(String name) { 
    5346                this(); 
    5447                setName(name); 
    5548        } 
    5649 
    57         public Column(String name, ColumnType type) { 
     50        public MutableColumn(String name, ColumnType type) { 
    5851                this(name); 
    5952                setType(type); 
    6053        } 
    6154 
    62         public Column(String name, ColumnType type, Table table, int columnNumber, 
    63                         Boolean nullable) { 
     55        public MutableColumn(String name, ColumnType type, Table table, 
     56                        int columnNumber, Boolean nullable) { 
    6457                this(name, type); 
    6558                setColumnNumber(columnNumber); 
    … …  
    7265         * whereas the JDBC is 1-based. 
    7366         */ 
     67        @Override 
    7468        public int getColumnNumber() { 
    7569                return _columnNumber; 
    … …  
    8478         * Returns the Column Name 
    8579         */ 
     80        @Override 
    8681        public String getName() { 
    8782                return _name; 
    … …  
    9691         * @return a qualified label 
    9792         */ 
     93        @Override 
    9894        public String getQualifiedLabel() { 
    9995                if (_qualifiedLabel == null) { 
    … …  
    118114         * Gets the type of the column 
    119115         */ 
     116        @Override 
    120117        public ColumnType getType() { 
    121118                return _type; 
    … …  
    130127         * Gets the table for which this column belong 
    131128         */ 
     129        @Override 
    132130        public Table getTable() { 
    133131                return _table; 
    … …  
    140138        } 
    141139 
     140        @Override 
    142141        public Boolean isNullable() { 
    143142                return _nullable; 
    … …  
    149148        } 
    150149 
     150        @Override 
    151151        public String getRemarks() { 
    152152                return _remarks; 
    … …  
    157157        } 
    158158 
     159        @Override 
    159160        public Integer getColumnSize() { 
    160161                return _columnSize; 
    … …  
    166167        } 
    167168 
     169        @Override 
    168170        public String getNativeType() { 
    169171                return _nativeType; 
    … …  
    175177        } 
    176178 
     179        @Override 
    177180        public boolean isIndexed() { 
    178181                return _indexed; 
    179182        } 
    180183 
    181         public Column setIndexed(boolean indexed) { 
     184        public MutableColumn setIndexed(boolean indexed) { 
    182185                _indexed = indexed; 
    183186                return this; 
    184187        } 
    185188 
     189        @Override 
    186190        public String getQuote() { 
    187191                return _quoteString; 
    … …  
    193197        } 
    194198 
     199        @Override 
    195200        public String getQuotedName() { 
    196201                if (_quoteString != null) { 
    … …  
    222227                        return true; 
    223228                } 
    224                 if (obj instanceof Column) { 
     229                if (obj instanceof MutableColumn) { 
    225230                        Column that = (Column) obj; 
    226231                        EqualsBuilder eb = new EqualsBuilder().append(this.getName(), 
    … …  
    238243        } 
    239244 
     245        @Override 
    240246        public int compareTo(Column that) { 
    241247                CompareToBuilder ctb = new CompareToBuilder(); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/MutableSchema.java

    r886 r887  
    2828import org.apache.commons.lang.builder.ToStringStyle; 
    2929 
    30 /** 
    31  * Represents a schema and it's metadata. Schemas represent a collection of 
    32  * tables. 
    33  *  
    34  * @see Table 
    35  */ 
    36 public class Schema implements Serializable, Comparable<Schema> { 
     30public class MutableSchema implements Serializable, Schema { 
    3731 
    3832        private static final long serialVersionUID = 4465197783868238863L; 
    … …  
    4135        protected List<Table> _tables = new ArrayList<Table>(); 
    4236 
    43         public Schema() { 
    44         } 
    45  
    46         public Schema(String name) { 
     37        public MutableSchema() { 
     38        } 
     39 
     40        public MutableSchema(String name) { 
    4741                this(); 
    4842                _name = name; 
    4943        } 
    5044 
    51         public Schema(String name, Table... tables) { 
     45        public MutableSchema(String name, Table... tables) { 
    5246                this(name); 
    5347                setTables(tables); 
    … …  
    5751         * @return the name of the schema 
    5852         */ 
     53        @Override 
    5954        public String getName() { 
    6055                return _name; 
    … …  
    6459                _name = name; 
    6560                for (Table table : _tables) { 
    66                         table.fireSchemaChanged(); 
     61                        if (table instanceof MutableTable) { 
     62                                ((MutableTable) table).fireSchemaChanged(); 
     63                        } 
    6764                } 
    6865                return this; 
    … …  
    7269         * @return the number of tables that reside in the schema 
    7370         */ 
     71        @Override 
    7472        public int getTableCount() { 
    7573                return _tables.size(); 
    7674        } 
    7775 
     76        @Override 
    7877        public int getTableCount(TableType type) { 
    7978                return getTables(type).length; 
    … …  
    8382         * @return the tables that reside in the schema 
    8483         */ 
     84        @Override 
    8585        public Table[] getTables() { 
    8686                return _tables.toArray(new Table[_tables.size()]); 
    8787        } 
    8888 
     89        @Override 
    8990        public Table[] getTables(TableType type) { 
    9091                List<Table> result = new ArrayList<Table>(); 
    … …  
    113114        } 
    114115 
    115         public Schema addTable(Table table) { 
     116        public MutableSchema addTable(Table table) { 
    116117                _tables.add(table); 
    117118                return this; 
    … …  
    131132         *         found. 
    132133         */ 
     134        @Override 
    133135        public Table getTableByName(String tableName) { 
    134136                if (tableName != null) { 
    … …  
    157159        } 
    158160 
     161        @Override 
    159162        public Relationship[] getRelationships() { 
    160163                List<Relationship> result = new ArrayList<Relationship>(); 
    161164                for (Table table : _tables) { 
    162165                        Relationship[] relations = table.getRelationships(); 
    163                         for (int i = 0; i < relations.length; i++) { 
    164                                 Relationship relation = relations[i]; 
     166                        for (Relationship relation : relations) { 
    165167                                boolean found = false; 
    166168                                for (Relationship existingRelation : result) { 
    … …  
    179181        } 
    180182 
     183        @Override 
    181184        public int getRelationshipCount() { 
    182185                return getRelationships().length; 
    … …  
    202205                        return true; 
    203206                } 
    204                 if (obj instanceof Schema) { 
     207                if (obj instanceof MutableSchema) { 
    205208                        Schema that = (Schema) obj; 
    206209                        return new EqualsBuilder().append(this.getName(), that.getName()) 
    … …  
    210213        } 
    211214 
     215        @Override 
    212216        public int compareTo(Schema that) { 
    213217                CompareToBuilder ctb = new CompareToBuilder(); 
    … …  
    217221        } 
    218222 
     223        @Override 
    219224        public String[] getTableNames() { 
    220225                ArrayList<String> result = new ArrayList<String>(); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/MutableTable.java

    r886 r887  
    3131import org.eobjects.metamodel.MetaModelHelper; 
    3232 
    33  
    34 /** 
    35  * Represents the metadata about a table. Tables reside within a schema and 
    36  * contains columns and relationships to other tables. 
    37  *  
    38  * @see Schema 
    39  * @see Column 
    40  * @see Relationship 
    41  */ 
    42 public class Table implements Serializable, Comparable<Table> { 
     33public class MutableTable implements Serializable, Comparable<Table>, Table { 
    4334 
    4435        private static final long serialVersionUID = -5094888465714027354L; 
    … …  
    4637        protected TableType _type; 
    4738        protected String _remarks; 
    48         protected Schema _schema; 
     39        protected MutableSchema _schema; 
    4940        protected List<Column> _columns = new ArrayList<Column>(); 
    5041        protected List<Relationship> _relationships = new ArrayList<Relationship>(); 
    … …  
    5243        private transient String _qualifiedLabel; 
    5344 
    54         public Table() { 
    55         } 
    56  
    57         public Table(String name) { 
     45        public MutableTable() { 
     46        } 
     47 
     48        public MutableTable(String name) { 
    5849                this(); 
    5950                setName(name); 
    6051        } 
    6152 
    62         public Table(String name, TableType type) { 
     53        public MutableTable(String name, TableType type) { 
    6354                this(name); 
    6455                _type = type; 
    6556        } 
    6657 
    67         public Table(String name, TableType type, Schema schema) { 
     58        public MutableTable(String name, TableType type, MutableSchema schema) { 
    6859                this(name, type); 
    6960                _schema = schema; 
    7061        } 
    7162 
    72         public Table(String name, TableType type, Schema schema, Column... columns) { 
     63        public MutableTable(String name, TableType type, MutableSchema schema, 
     64                        Column... columns) { 
    7365                this(name, type, schema); 
    7466                setColumns(columns); 
    7567        } 
    7668 
    77         /** 
    78          * @return the name of the table 
    79          */ 
     69        @Override 
    8070        public String getName() { 
    8171                return _name; 
    … …  
    10494        } 
    10595 
    106         /** 
    107          * @return the number of columns in this table 
    108          */ 
     96        @Override 
    10997        public int getColumnCount() { 
    11098                return getColumnsInternal().size(); 
    11199        } 
    112100 
    113         /** 
    114          * @return the columns of the table 
    115          */ 
     101        @Override 
    116102        public Column[] getColumns() { 
    117103                List<Column> columns = getColumnsInternal(); 
    … …  
    128114        } 
    129115 
    130         public Table setColumns(Collection<Column> columns) { 
     116        public Table setColumns(Collection<? extends Column> columns) { 
    131117                List<Column> existingColumns = getColumnsInternal(); 
    132118                existingColumns.clear(); 
    … …  
    147133        } 
    148134 
    149         /** 
    150          * Convenience method for retrieving a column by it's name 
    151          *  
    152          * @param columnName 
    153          *            the name of the column to retrieve 
    154          * @return the column with the given name. Returns null if no such column is 
    155          *         found. 
    156          */ 
     135        @Override 
    157136        public Column getColumnByName(String columnName) { 
    158137                if (columnName != null) { 
    … …  
    181160        } 
    182161 
    183         /** 
    184          * @return the schema that the table belong to 
    185          */ 
    186         public Schema getSchema() { 
     162        @Override 
     163        public MutableSchema getSchema() { 
    187164                return _schema; 
    188165        } 
    189166 
    190         public Table setSchema(Schema schema) { 
     167        public Table setSchema(MutableSchema schema) { 
    191168                _schema = schema; 
    192169                fireSchemaChanged(); 
    … …  
    201178                _qualifiedLabel = null; 
    202179                for (Column column : _columns) { 
    203                         column.fireTableChanged(); 
    204                 } 
    205         } 
    206          
    207         /** 
    208          * @return the type of table 
    209          */ 
     180                        if (column instanceof MutableColumn) { 
     181                                ((MutableColumn) column).fireTableChanged(); 
     182                        } 
     183                } 
     184        } 
     185 
     186        @Override 
    210187        public TableType getType() { 
    211188                return _type; 
    … …  
    217194        } 
    218195 
    219         /** 
    220          * @return all relations for this table. To add relations use 
    221          *         TableRelation.createRelation(); 
    222          */ 
     196        @Override 
    223197        public Relationship[] getRelationships() { 
    224198                List<Relationship> relationships = getRelationshipsInternal(); 
    … …  
    226200        } 
    227201 
    228         /** 
    229          * @param otherTable 
    230          * @return this tables relationsips to another table 
    231          */ 
     202        @Override 
    232203        public Relationship[] getRelationships(Table otherTable) { 
    233204                List<Relationship> result = new ArrayList<Relationship>(); 
    … …  
    263234        } 
    264235 
     236        @Override 
    265237        public int getRelationshipCount() { 
    266238                return getRelationshipsInternal().size(); 
    267239        } 
    268240 
     241        @Override 
    269242        public String getRemarks() { 
    270243                return _remarks; 
    … …  
    275248        } 
    276249 
     250        @Override 
    277251        public String getQuote() { 
    278252                return _quoteString; 
    … …  
    284258        } 
    285259 
     260        @Override 
    286261        public String getQuotedName() { 
    287262                if (_quoteString != null) { 
    … …  
    291266        } 
    292267 
    293         /** 
    294          * Gets a label with a simple dot-separated qualified name such as 
    295          * "MY_SCHEMA.MY_TABLE". The qualified label can be used as a unique 
    296          * identifier for the table but is not necessarily directly transferable to 
    297          * SQL syntax. 
    298          *  
    299          * @return a qualified label 
    300          */ 
     268        @Override 
    301269        public String getQualifiedLabel() { 
    302270                if (_qualifiedLabel == null) { 
    … …  
    312280        } 
    313281 
     282        @Override 
    314283        public Column[] getNumberColumns() { 
    315284                List<Column> result = new ArrayList<Column>(); 
    … …  
    323292        } 
    324293 
     294        @Override 
    325295        public Column[] getLiteralColumns() { 
    326296                List<Column> result = new ArrayList<Column>(); 
    … …  
    335305        } 
    336306 
     307        @Override 
    337308        public Column[] getTimeBasedColumns() { 
    338309                List<Column> result = new ArrayList<Column>(); 
    … …  
    347318        } 
    348319 
     320        @Override 
    349321        public Column[] getBooleanColumns() { 
    350322                List<Column> result = new ArrayList<Column>(); 
    … …  
    359331        } 
    360332 
     333        @Override 
    361334        public Column[] getIndexedColumns() { 
    362335                List<Column> result = new ArrayList<Column>(); 
    … …  
    389362                        return true; 
    390363                } 
    391                 if (obj instanceof Table) { 
     364                if (obj instanceof MutableTable) { 
    392365                        Table that = (Table) obj; 
    393366                        return new EqualsBuilder().append(this.getName(), that.getName()) 
    … …  
    401374        } 
    402375 
     376        @Override 
    403377        public int compareTo(Table that) { 
    404378                CompareToBuilder ctb = new CompareToBuilder(); 
    … …  
    408382        } 
    409383 
    410         /** 
    411          * @return the relationships where this table is the foreign table 
    412          */ 
     384        @Override 
    413385        public Relationship[] getForeignKeyRelationships() { 
    414386                List<Relationship> result = new ArrayList<Relationship>(); 
    … …  
    422394        } 
    423395 
    424         /** 
    425          * @return the relationships where this table is the primary table 
    426          */ 
     396        @Override 
    427397        public Relationship[] getPrimaryKeyRelationships() { 
    428398                List<Relationship> result = new ArrayList<Relationship>(); 
    … …  
    436406        } 
    437407 
     408        @Override 
    438409        public Column[] getForeignKeys() { 
    439410                Set<Column> columns = new HashSet<Column>(); 
    … …  
    448419        } 
    449420 
     421        @Override 
    450422        public Column[] getPrimaryKeys() { 
    451423                Set<Column> columns = new HashSet<Column>(); 
    … …  
    460432        } 
    461433 
     434        @Override 
    462435        public String[] getColumnNames() { 
    463436                ArrayList<String> result = new ArrayList<String>(); 
    … …  
    469442        } 
    470443 
     444        @Override 
    471445        public Column[] getColumnsOfType(ColumnType columnType) { 
    472446                Column[] columns = getColumns(); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/Relationship.java

    r886 r887  
    1 /** 
    2  *  This file is part of MetaModel. 
    3  * 
    4  *  MetaModel is free software: you can redistribute it and/or modify 
    5  *  it under the terms of the GNU General Public License as published by 
    6  *  the Free Software Foundation, either version 3 of the License, or 
    7  *  (at your option) any later version. 
    8  * 
    9  *  MetaModel is distributed in the hope that it will be useful, 
    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    12  *  GNU General Public License for more details. 
    13  * 
    14  *  You should have received a copy of the GNU General Public License 
    15  *  along with MetaModel.  If not, see <http://www.gnu.org/licenses/>. 
    16  */ 
    171package org.eobjects.metamodel.schema; 
    18  
    19 import java.io.Serializable; 
    20  
    21 import org.apache.commons.lang.builder.CompareToBuilder; 
    22 import org.apache.commons.lang.builder.EqualsBuilder; 
    23 import org.apache.commons.lang.builder.HashCodeBuilder; 
    242 
    253/** 
    264 * Represents a relationship between two tables where one set of columns is the 
    275 * primary key, and another set is the foreign key. Relationship is unlike most 
    28  * of the MetaModel an immutable type. The immutability help ensure integrity of 
     6 * of the MetaModel an im type. The immutability help ensure integrity of 
    297 * object-relationships. To create relationsips use the 
    308 * <code>createRelationship</code> method and to remove them use the 
    … …  
    3412 * @see Column 
    3513 */ 
    36 public class Relationship implements Serializable, Comparable<Relationship> { 
     14public interface Relationship extends Comparable<Relationship> { 
    3715 
    38         private static final long serialVersionUID = 238786848828528822L; 
    39         private Table _primaryTable; 
    40         private Column[] _primaryColumns; 
    41         private Table _foreignTable; 
    42         private Column[] _foreignColumns; 
     16        public Table getPrimaryTable(); 
    4317 
    44         /** 
    45          * Factory method to create relations between two tables by specifying which 
    46          * columns from the tables that enforce the relationship. 
    47          *  
    48          * @param primaryColumns 
    49          *            the columns from the primary key table 
    50          * @param foreignColumns 
    51          *            the columns from the foreign key table 
    52          * @return the relation created 
    53          */ 
    54         public static Relationship createRelationship(Column[] primaryColumns, 
    55                         Column[] foreignColumns) { 
    56                 Table primaryTable = checkSameTable(primaryColumns); 
    57                 Table foreignTable = checkSameTable(foreignColumns); 
    58                 Relationship relation = new Relationship(primaryTable, primaryColumns, 
    59                                 foreignTable, foreignColumns); 
    60                 primaryTable.addRelationship(relation); 
     18        public Column[] getPrimaryColumns(); 
    6119 
    62                 // Ticket #144: Some tables have relations with them selves and then the 
    63                 // relationship should only be added once. 
    64                 if (foreignTable != primaryTable) { 
    65                         foreignTable.addRelationship(relation); 
    66                 } 
    67                 return relation; 
    68         } 
     20        public Table getForeignTable(); 
    6921 
    70         public static Relationship createRelationship(Column primaryColumn, 
    71                         Column foreignColumn) { 
    72                 return createRelationship(new Column[] { primaryColumn }, 
    73                                 new Column[] { foreignColumn }); 
    74         } 
     22        public Column[] getForeignColumns(); 
    7523 
    76         private static Table checkSameTable(Column[] columns) { 
    77                 if (columns == null || columns.length == 0) { 
    78                         throw new IllegalArgumentException( 
    79                                         "At least one key-column must exist on both " 
    80                                                         + "primary and foreign side for " 
    81                                                         + "a relation to exist."); 
    82                 } 
    83                 Table table = null; 
    84                 for (int i = 0; i < columns.length; i++) { 
    85                         Column column = columns[i]; 
    86                         if (i == 0) { 
    87                                 table = column.getTable(); 
    88                         } else { 
    89                                 if (table != column.getTable()) { 
    90                                         throw new IllegalArgumentException( 
    91                                                         "Key-columns did not have same table"); 
    92                                 } 
    93                         } 
    94                 } 
    95                 return table; 
    96         } 
    97  
    98         public void remove() { 
    99                 _primaryTable.removeRelationship(this); 
    100                 _foreignTable.removeRelationship(this); 
    101                 _primaryColumns = null; 
    102                 _primaryTable = null; 
    103                 _foreignColumns = null; 
    104                 _foreignTable = null; 
    105         } 
    106  
    107         /** 
    108          * Prevent external instantiation 
    109          */ 
    110         private Relationship(Table primaryTable, Column[] primaryColumns, 
    111                         Table foreignTable, Column[] foreignColumns) { 
    112                 _primaryTable = primaryTable; 
    113                 _primaryColumns = primaryColumns; 
    114                 _foreignTable = foreignTable; 
    115                 _foreignColumns = foreignColumns; 
    116         } 
    117  
    118         public Table getPrimaryTable() { 
    119                 return _primaryTable; 
    120         } 
    121  
    122         public Column[] getPrimaryColumns() { 
    123                 return _primaryColumns; 
    124         } 
    125  
    126         public Table getForeignTable() { 
    127                 return _foreignTable; 
    128         } 
    129  
    130         public Column[] getForeignColumns() { 
    131                 return _foreignColumns; 
    132         } 
    133  
    134         @Override 
    135         public String toString() { 
    136                 StringBuilder sb = new StringBuilder(); 
    137                 sb.append("Relationship["); 
    138                 sb.append("primaryTable=" + _primaryTable.getName()); 
    139                 Column[] columns = getPrimaryColumns(); 
    140                 sb.append(",primaryColumns={"); 
    141                 for (int i = 0; i < columns.length; i++) { 
    142                         if (i != 0) { 
    143                                 sb.append(","); 
    144                         } 
    145                         sb.append(columns[i].getName()); 
    146                 } 
    147                 sb.append("}"); 
    148                 sb.append(",foreignTable=" + _foreignTable.getName()); 
    149                 columns = getForeignColumns(); 
    150                 sb.append(",foreignColumns={"); 
    151                 for (int i = 0; i < columns.length; i++) { 
    152                         if (i != 0) { 
    153                                 sb.append(","); 
    154                         } 
    155                         sb.append(columns[i].getName()); 
    156                 } 
    157                 sb.append("}"); 
    158                 sb.append("]"); 
    159                 return sb.toString(); 
    160         } 
    161  
    162         public int compareTo(Relationship that) { 
    163                 CompareToBuilder ctb = new CompareToBuilder(); 
    164                 ctb.append(this.getPrimaryTable(), that.getPrimaryTable()); 
    165                 ctb.append(this.getForeignTable(), that.getForeignTable()); 
    166                 ctb.append(this.getPrimaryColumns(), that.getPrimaryColumns()); 
    167                 ctb.append(this.getForeignColumns(), that.getForeignColumns()); 
    168                 return ctb.toComparison(); 
    169         } 
    170  
    171         @Override 
    172         public boolean equals(Object obj) { 
    173                 if (obj == this) { 
    174                         return true; 
    175                 } 
    176                 if (obj instanceof Relationship) { 
    177                         Relationship that = (Relationship) obj; 
    178                         EqualsBuilder eb = new EqualsBuilder(); 
    179                         eb.append(this.getPrimaryColumns(), that.getPrimaryColumns()); 
    180                         eb.append(this.getForeignColumns(), that.getForeignColumns()); 
    181                         return eb.isEquals(); 
    182                 } 
    183                 return false; 
    184         } 
    185  
    186         @Override 
    187         public int hashCode() { 
    188                 return new HashCodeBuilder().append(_foreignColumns).append( 
    189                                 _primaryColumns).toHashCode(); 
    190         } 
     24        public int compareTo(Relationship that); 
    19125 
    19226        /** 
    … …  
    19832         *         columns as a part of the relation 
    19933         */ 
    200         public boolean containsColumnPair(Column pkColumn, Column fkColumn) { 
    201                 if (pkColumn != null && fkColumn != null) { 
    202                         for (int i = 0; i < _primaryColumns.length; i++) { 
    203                                 if (pkColumn.equals(_primaryColumns[i]) 
    204                                                 && fkColumn.equals(_foreignColumns[i])) { 
    205                                         return true; 
    206                                 } 
    207                         } 
    208                 } 
    209                 return false; 
    210         } 
     34        public boolean containsColumnPair(Column pkColumn, 
     35                        Column fkColumn); 
     36 
    21137} 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/Schema.java

    r886 r887  
    1 /** 
    2  *  This file is part of MetaModel. 
    3  * 
    4  *  MetaModel is free software: you can redistribute it and/or modify 
    5  *  it under the terms of the GNU General Public License as published by 
    6  *  the Free Software Foundation, either version 3 of the License, or 
    7  *  (at your option) any later version. 
    8  * 
    9  *  MetaModel is distributed in the hope that it will be useful, 
    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    12  *  GNU General Public License for more details. 
    13  * 
    14  *  You should have received a copy of the GNU General Public License 
    15  *  along with MetaModel.  If not, see <http://www.gnu.org/licenses/>. 
    16  */ 
    171package org.eobjects.metamodel.schema; 
    18  
    19 import java.io.Serializable; 
    20 import java.util.ArrayList; 
    21 import java.util.Collection; 
    22 import java.util.List; 
    23  
    24 import org.apache.commons.lang.builder.CompareToBuilder; 
    25 import org.apache.commons.lang.builder.EqualsBuilder; 
    26 import org.apache.commons.lang.builder.HashCodeBuilder; 
    27 import org.apache.commons.lang.builder.ToStringBuilder; 
    28 import org.apache.commons.lang.builder.ToStringStyle; 
    292 
    303/** 
    … …  
    347 * @see Table 
    358 */ 
    36 public class Schema implements Serializable, Comparable<Schema> { 
    37  
    38         private static final long serialVersionUID = 4465197783868238863L; 
    39  
    40         protected String _name; 
    41         protected List<Table> _tables = new ArrayList<Table>(); 
    42  
    43         public Schema() { 
    44         } 
    45  
    46         public Schema(String name) { 
    47                 this(); 
    48                 _name = name; 
    49         } 
    50  
    51         public Schema(String name, Table... tables) { 
    52                 this(name); 
    53                 setTables(tables); 
    54         } 
     9public interface Schema extends Comparable<Schema> { 
    5510 
    5611        /** 
    5712         * @return the name of the schema 
    5813         */ 
    59         public String getName() { 
    60                 return _name; 
    61         } 
    62  
    63         public Schema setName(String name) { 
    64                 _name = name; 
    65                 for (Table table : _tables) { 
    66                         table.fireSchemaChanged(); 
    67                 } 
    68                 return this; 
    69         } 
     14        public String getName(); 
    7015 
    7116        /** 
    7217         * @return the number of tables that reside in the schema 
    7318         */ 
    74         public int getTableCount() { 
    75                 return _tables.size(); 
    76         } 
     19        public int getTableCount(); 
    7720 
    78         public int getTableCount(TableType type) { 
    79                 return getTables(type).length; 
    80         } 
     21        public int getTableCount(TableType type); 
    8122 
    8223        /** 
    8324         * @return the tables that reside in the schema 
    8425         */ 
    85         public Table[] getTables() { 
    86                 return _tables.toArray(new Table[_tables.size()]); 
    87         } 
     26        public Table[] getTables(); 
    8827 
    89         public Table[] getTables(TableType type) { 
    90                 List<Table> result = new ArrayList<Table>(); 
    91                 for (Table table : _tables) { 
    92                         if (table.getType() == type) { 
    93                                 result.add(table); 
    94                         } 
    95                 } 
    96                 return result.toArray(new Table[result.size()]); 
    97         } 
    98  
    99         public Schema setTables(Collection<Table> tables) { 
    100                 _tables.clear(); 
    101                 for (Table table : tables) { 
    102                         _tables.add(table); 
    103                 } 
    104                 return this; 
    105         } 
    106  
    107         public Schema setTables(Table... tables) { 
    108                 _tables.clear(); 
    109                 for (Table table : tables) { 
    110                         _tables.add(table); 
    111                 } 
    112                 return this; 
    113         } 
    114  
    115         public Schema addTable(Table table) { 
    116                 _tables.add(table); 
    117                 return this; 
    118         } 
    119  
    120         public Schema removeTable(Table table) { 
    121                 _tables.remove(table); 
    122                 return this; 
    123         } 
     28        public Table[] getTables(TableType type); 
    12429 
    12530        /** 
    … …  
    13136         *         found. 
    13237         */ 
    133         public Table getTableByName(String tableName) { 
    134                 if (tableName != null) { 
    135                         List<Table> foundTables = new ArrayList<Table>(); 
    136                         // Search for table matches, case insensitive. 
    137                         for (Table table : _tables) { 
    138                                 if (tableName.equalsIgnoreCase(table.getName())) { 
    139                                         foundTables.add(table); 
    140                                 } 
    141                         } 
    142                         int numTables = foundTables.size(); 
    143                         if (numTables == 0) { 
    144                                 return null; 
    145                         } else if (numTables == 1) { 
    146                                 return foundTables.get(0); 
    147                         } else { 
    148                                 // If more matches are found, search case sensitive 
    149                                 for (Table table : foundTables) { 
    150                                         if (tableName.equals(table.getName())) { 
    151                                                 return table; 
    152                                         } 
    153                                 } 
    154                         } 
    155                 } 
    156                 return null; 
    157         } 
     38        public Table getTableByName(String tableName); 
    15839 
    159         public Relationship[] getRelationships() { 
    160                 List<Relationship> result = new ArrayList<Relationship>(); 
    161                 for (Table table : _tables) { 
    162                         Relationship[] relations = table.getRelationships(); 
    163                         for (int i = 0; i < relations.length; i++) { 
    164                                 Relationship relation = relations[i]; 
    165                                 boolean found = false; 
    166                                 for (Relationship existingRelation : result) { 
    167                                         if (relation == existingRelation) { 
    168                                                 found = true; 
    169                                                 break; 
    170                                         } 
    171                                 } 
     40        public Relationship[] getRelationships(); 
    17241 
    173                                 if (!found) { 
    174                                         result.add(relation); 
    175                                 } 
    176                         } 
    177                 } 
    178                 return result.toArray(new Relationship[result.size()]); 
    179         } 
     42        public int getRelationshipCount(); 
    18043 
    181         public int getRelationshipCount() { 
    182                 return getRelationships().length; 
    183         } 
     44        public int compareTo(Schema that); 
    18445 
    185         @Override 
    186         public String toString() { 
    187                 return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE) 
    188                                 .append("name", _name).toString(); 
    189         } 
     46        public String[] getTableNames(); 
    19047 
    191         @Override 
    192         public int hashCode() { 
    193                 HashCodeBuilder hcb = new HashCodeBuilder(); 
    194                 hcb.append(_name); 
    195                 hcb.append(_tables.size()); 
    196                 return hcb.toHashCode(); 
    197         } 
    198  
    199         @Override 
    200         public boolean equals(Object obj) { 
    201                 if (obj == this) { 
    202                         return true; 
    203                 } 
    204                 if (obj instanceof Schema) { 
    205                         Schema that = (Schema) obj; 
    206                         return new EqualsBuilder().append(this.getName(), that.getName()) 
    207                                         .append(this.getTables(), that.getTables()).isEquals(); 
    208                 } 
    209                 return false; 
    210         } 
    211  
    212         public int compareTo(Schema that) { 
    213                 CompareToBuilder ctb = new CompareToBuilder(); 
    214                 ctb.append(this.getName(), that.getName()); 
    215                 ctb.append(this.getTableCount(), that.getTableCount()); 
    216                 return ctb.toComparison(); 
    217         } 
    218  
    219         public String[] getTableNames() { 
    220                 ArrayList<String> result = new ArrayList<String>(); 
    221                 Table[] tables = getTables(); 
    222                 for (Table table : tables) { 
    223                         result.add(table.getName()); 
    224                 } 
    225                 return result.toArray(new String[result.size()]); 
    226         } 
    22748} 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/schema/Table.java

    r886 r887  
    1 /** 
    2  *  This file is part of MetaModel. 
    3  * 
    4  *  MetaModel is free software: you can redistribute it and/or modify 
    5  *  it under the terms of the GNU General Public License as published by 
    6  *  the Free Software Foundation, either version 3 of the License, or 
    7  *  (at your option) any later version. 
    8  * 
    9  *  MetaModel is distributed in the hope that it will be useful, 
    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    12  *  GNU General Public License for more details. 
    13  * 
    14  *  You should have received a copy of the GNU General Public License 
    15  *  along with MetaModel.  If not, see <http://www.gnu.org/licenses/>. 
    16  */ 
    171package org.eobjects.metamodel.schema; 
    18  
    19 import java.io.Serializable; 
    20 import java.util.ArrayList; 
    21 import java.util.Collection; 
    22 import java.util.HashSet; 
    23 import java.util.List; 
    24 import java.util.Set; 
    25  
    26 import org.apache.commons.lang.builder.CompareToBuilder; 
    27 import org.apache.commons.lang.builder.EqualsBuilder; 
    28 import org.apache.commons.lang.builder.HashCodeBuilder; 
    29 import org.apache.commons.lang.builder.ToStringBuilder; 
    30 import org.apache.commons.lang.builder.ToStringStyle; 
    31 import org.eobjects.metamodel.MetaModelHelper; 
    32  
    332 
    343/** 
    … …  
    409 * @see Relationship 
    4110 */ 
    42 public class Table implements Serializable, Comparable<Table> { 
    43  
    44         private static final long serialVersionUID = -5094888465714027354L; 
    45         protected String _name; 
    46         protected TableType _type; 
    47         protected String _remarks; 
    48         protected Schema _schema; 
    49         protected List<Column> _columns = new ArrayList<Column>(); 
    50         protected List<Relationship> _relationships = new ArrayList<Relationship>(); 
    51         protected String _quoteString = null; 
    52         private transient String _qualifiedLabel; 
    53  
    54         public Table() { 
    55         } 
    56  
    57         public Table(String name) { 
    58                 this(); 
    59                 setName(name); 
    60         } 
    61  
    62         public Table(String name, TableType type) { 
    63                 this(name); 
    64                 _type = type; 
    65         } 
    66  
    67         public Table(String name, TableType type, Schema schema) { 
    68                 this(name, type); 
    69                 _schema = schema; 
    70         } 
    71  
    72         public Table(String name, TableType type, Schema schema, Column... columns) { 
    73                 this(name, type, schema); 
    74                 setColumns(columns); 
    75         } 
     11public interface Table extends Comparable<Table> { 
    7612 
    7713        /** 
    7814         * @return the name of the table 
    7915         */ 
    80         public String getName() { 
    81                 return _name; 
    82         } 
    83  
    84         public Table setName(String name) { 
    85                 _name = name; 
    86                 fireSchemaChanged(); 
    87                 return this; 
    88         } 
    89  
    90         /** 
    91          * Internal getter for the columns of the table. Overwrite this method to 
    92          * implement column lookup, column lazy-loading or similar. 
    93          */ 
    94         protected List<Column> getColumnsInternal() { 
    95                 return _columns; 
    96         } 
    97  
    98         /** 
    99          * Internal getter for the relationships of the table. Overwrite this method 
    100          * to implement relationship lookup, relationship lazy-loading or similar. 
    101          */ 
    102         protected List<Relationship> getRelationshipsInternal() { 
    103                 return _relationships; 
    104         } 
     16        public String getName(); 
    10517 
    10618        /** 
    10719         * @return the number of columns in this table 
    10820         */ 
    109         public int getColumnCount() { 
    110                 return getColumnsInternal().size(); 
    111         } 
     21        public int getColumnCount(); 
    11222 
    11323        /** 
    11424         * @return the columns of the table 
    11525         */ 
    116         public Column[] getColumns() { 
    117                 List<Column> columns = getColumnsInternal(); 
    118                 return columns.toArray(new Column[columns.size()]); 
    119         } 
    120  
    121         public Table setColumns(Column... columns) { 
    122                 List<Column> existingColumns = getColumnsInternal(); 
    123                 existingColumns.clear(); 
    124                 for (Column column : columns) { 
    125                         existingColumns.add(column); 
    126                 } 
    127                 return this; 
    128         } 
    129  
    130         public Table setColumns(Collection<Column> columns) { 
    131                 List<Column> existingColumns = getColumnsInternal(); 
    132                 existingColumns.clear(); 
    133                 for (Column column : columns) { 
    134                         existingColumns.add(column); 
    135                 } 
    136                 return this; 
    137         } 
    138  
    139         public Table addColumn(Column column) { 
    140                 getColumnsInternal().add(column); 
    141                 return this; 
    142         } 
    143  
    144         public Table removeColumn(Column column) { 
    145                 getColumnsInternal().remove(column); 
    146                 return this; 
    147         } 
     26        public Column[] getColumns(); 
    14827 
    14928        /** 
    … …  
    15534         *         found. 
    15635         */ 
    157         public Column getColumnByName(String columnName) { 
    158                 if (columnName != null) { 
    159                         List<Column> foundColumn = new ArrayList<Column>(); 
    160                         // Search for column matches, case insensitive. 
    161                         for (Column column : getColumnsInternal()) { 
    162                                 if (columnName.equalsIgnoreCase(column.getName())) { 
    163                                         foundColumn.add(column); 
    164                                 } 
    165                         } 
    166                         int numColumns = foundColumn.size(); 
    167                         if (numColumns == 0) { 
    168                                 return null; 
    169                         } else if (numColumns == 1) { 
    170                                 return foundColumn.get(0); 
    171                         } else { 
    172                                 // If more matches are found, search case sensitive 
    173                                 for (Column column : foundColumn) { 
    174                                         if (columnName.equals(column.getName())) { 
    175                                                 return column; 
    176                                         } 
    177                                 } 
    178                         } 
    179                 } 
    180                 return null; 
    181         } 
     36        public Column getColumnByName(String columnName); 
    18237 
    18338        /** 
    18439         * @return the schema that the table belong to 
    18540         */ 
    186         public Schema getSchema() { 
    187                 return _schema; 
    188         } 
     41        public Schema getSchema(); 
    18942 
    190         public Table setSchema(Schema schema) { 
    191                 _schema = schema; 
    192                 fireSchemaChanged(); 
    193                 return this; 
    194         } 
    195  
    196         /** 
    197          * Tells the table object that the schema it belongs to have changed. This 
    198          * is typically done if the schema is being renamed or similar. 
    199          */ 
    200         protected void fireSchemaChanged() { 
    201                 _qualifiedLabel = null; 
    202                 for (Column column : _columns) { 
    203                         column.fireTableChanged(); 
    204                 } 
    205         } 
    206          
    20743        /** 
    20844         * @return the type of table 
    20945         */ 
    210         public TableType getType() { 
    211                 return _type; 
    212         } 
     46        public TableType getType(); 
    21347 
    214         public Table setType(TableType type) { 
    215                 _type = type; 
    216                 return this; 
    217         } 
     48        public Table setType(TableType type); 
    21849 
    21950        /** 
    … …  
    22152         *         TableRelation.createRelation(); 
    22253         */ 
    223         public Relationship[] getRelationships() { 
    224                 List<Relationship> relationships = getRelationshipsInternal(); 
    225                 return relationships.toArray(new Relationship[relationships.size()]); 
    226         } 
     54        public Relationship[] getRelationships(); 
    22755 
    22856        /** 
    … …  
    23058         * @return this tables relationsips to another table 
    23159         */ 
    232         public Relationship[] getRelationships(Table otherTable) { 
    233                 List<Relationship> result = new ArrayList<Relationship>(); 
    234                 List<Relationship> relationships = getRelationshipsInternal(); 
    235                 for (Relationship relation : relationships) { 
    236                         if (relation.getForeignTable() == otherTable 
    237                                         && relation.getPrimaryTable() == this) { 
    238                                 result.add(relation); 
    239                         } else if (relation.getForeignTable() == this 
    240                                         && relation.getPrimaryTable() == otherTable) { 
    241                                 result.add(relation); 
    242                         } 
    243                 } 
    244                 return result.toArray(new Relationship[result.size()]); 
    245         } 
     60        public Relationship[] getRelationships(Table otherTable); 
    24661 
    247         /** 
    248          * Protected method for adding a relationship to this table. Should not be 
    249          * used. Use Relationship.createRelationship(Column[], Column[]) instead. 
    250          */ 
    251         protected Table addRelationship(Relationship relation) { 
    252                 getRelationshipsInternal().add(relation); 
    253                 return this; 
    254         } 
     62        public int getRelationshipCount(); 
    25563 
    256         /** 
    257          * Protected method for removing a relationship from this table. Should not 
    258          * be used. Use Relationship.remove() instead. 
    259          */ 
    260         protected Table removeRelationship(Relationship relation) { 
    261                 getRelationshipsInternal().remove(relation); 
    262                 return this; 
    263         } 
     64        public String getRemarks(); 
    26465 
    265         public int getRelationshipCount() { 
    266                 return getRelationshipsInternal().size(); 
    267         } 
     66        public String getQuote(); 
    26867 
    269         public String getRemarks() { 
    270                 return _remarks; 
    271         } 
    272  
    273         public void setRemarks(String remarks) { 
    274                 _remarks = remarks; 
    275         } 
    276  
    277         public String getQuote() { 
    278                 return _quoteString; 
    279         } 
    280  
    281         public Table setQuote(String quoteString) { 
    282                 _quoteString = quoteString; 
    283                 return this; 
    284         } 
    285  
    286         public String getQuotedName() { 
    287                 if (_quoteString != null) { 
    288                         return _quoteString + getName() + _quoteString; 
    289                 } 
    290                 return getName(); 
    291         } 
     68        public String getQuotedName(); 
    29269 
    29370        /** 
    … …  
    29976         * @return a qualified label 
    30077         */ 
    301         public String getQualifiedLabel() { 
    302                 if (_qualifiedLabel == null) { 
    303                         StringBuilder sb = new StringBuilder(); 
    304                         if (_schema != null && _schema.getName() != null) { 
    305                                 sb.append(_schema.getName()); 
    306                                 sb.append('.'); 
    307                         } 
    308                         sb.append(getName()); 
    309                         _qualifiedLabel = sb.toString(); 
    310                 } 
    311                 return _qualifiedLabel; 
    312         } 
     78        public String getQualifiedLabel(); 
    31379 
    314         public Column[] getNumberColumns() { 
    315                 List<Column> result = new ArrayList<Column>(); 
    316                 Column[] columns = getColumns(); 
    317                 for (int i = 0; i < columns.length; i++) { 
    318                         if (columns[i].getType() != null && columns[i].getType().isNumber()) { 
    319                                 result.add(columns[i]); 
    320                         } 
    321                 } 
    322                 return result.toArray(new Column[result.size()]); 
    323         } 
     80        public Column[] getNumberColumns(); 
    32481 
    325         public Column[] getLiteralColumns() { 
    326                 List<Column> result = new ArrayList<Column>(); 
    327                 Column[] columns = getColumns(); 
    328                 for (int i = 0; i < columns.length; i++) { 
    329                         if (columns[i].getType() != null 
    330                                         && columns[i].getType().isLiteral()) { 
    331                                 result.add(columns[i]); 
    332                         } 
    333                 } 
    334                 return result.toArray(new Column[result.size()]); 
    335         } 
     82        public Column[] getLiteralColumns(); 
    33683 
    337         public Column[] getTimeBasedColumns() { 
    338                 List<Column> result = new ArrayList<Column>(); 
    339                 Column[] columns = getColumns(); 
    340                 for (int i = 0; i < columns.length; i++) { 
    341                         if (columns[i].getType() != null 
    342                                         && columns[i].getType().isTimeBased()) { 
    343                                 result.add(columns[i]); 
    344                         } 
    345                 } 
    346                 return result.toArray(new Column[result.size()]); 
    347         } 
     84        public Column[] getTimeBasedColumns(); 
    34885 
    349         public Column[] getBooleanColumns() { 
    350                 List<Column> result = new ArrayList<Column>(); 
    351                 Column[] columns = getColumns(); 
    352                 for (int i = 0; i < columns.length; i++) { 
    353                         if (columns[i].getType() != null 
    354                                         && columns[i].getType().isBoolean()) { 
    355                                 result.add(columns[i]); 
    356                         } 
    357                 } 
    358                 return result.toArray(new Column[result.size()]); 
    359         } 
     86        public Column[] getBooleanColumns(); 
    36087 
    361         public Column[] getIndexedColumns() { 
    362                 List<Column> result = new ArrayList<Column>(); 
    363                 Column[] columns = getColumns(); 
    364                 for (int i = 0; i < columns.length; i++) { 
    365                         if (columns[i].isIndexed()) { 
    366                                 result.add(columns[i]); 
    367                         } 
    368                 } 
    369                 return result.toArray(new Column[result.size()]); 
    370         } 
    371  
    372         @Override 
    373         public String toString() { 
    374                 return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE) 
    375                                 .append("name", _name).append("type", _type).append("remarks", 
    376                                                 _remarks).toString(); 
    377         } 
    378  
    379         @Override 
    380         public int hashCode() { 
    381                 HashCodeBuilder hcb = new HashCodeBuilder(); 
    382                 hcb.append(_name).append(_type).append(_schema).append(_columns.size()); 
    383                 return hcb.toHashCode(); 
    384         } 
    385  
    386         @Override 
    387         public boolean equals(Object obj) { 
    388                 if (obj == this) { 
    389                         return true; 
    390                 } 
    391                 if (obj instanceof Table) { 
    392                         Table that = (Table) obj; 
    393                         return new EqualsBuilder().append(this.getName(), that.getName()) 
    394                                         .append(this.getType(), that.getType()).append( 
    395                                                         this.getRemarks(), that.getRemarks()).append( 
    396                                                         this.getColumns(), that.getColumns()).append( 
    397                                                         this.getRelationships(), that.getRelationships()) 
    398                                         .isEquals(); 
    399                 } 
    400                 return false; 
    401         } 
    402  
    403         public int compareTo(Table that) { 
    404                 CompareToBuilder ctb = new CompareToBuilder(); 
    405                 ctb.append(this.getName(), that.getName()); 
    406                 ctb.append(this.getSchema(), that.getSchema()); 
    407                 return ctb.toComparison(); 
    408         } 
     88        public Column[] getIndexedColumns(); 
    40989 
    41090        /** 
    41191         * @return the relationships where this table is the foreign table 
    41292         */ 
    413         public Relationship[] getForeignKeyRelationships() { 
    414                 List<Relationship> result = new ArrayList<Relationship>(); 
    415                 Relationship[] relationships = getRelationships(); 
    416                 for (Relationship relationship : relationships) { 
    417                         if (equals(relationship.getForeignTable())) { 
    418                                 result.add(relationship); 
    419                         } 
    420                 } 
    421                 return result.toArray(new Relationship[result.size()]); 
    422         } 
     93        public Relationship[] getForeignKeyRelationships(); 
    42394 
    42495        /** 
    42596         * @return the relationships where this table is the primary table 
    42697         */ 
    427         public Relationship[] getPrimaryKeyRelationships() { 
    428                 List<Relationship> result = new ArrayList<Relationship>(); 
    429                 Relationship[] relationships = getRelationships(); 
    430                 for (Relationship relationship : relationships) { 
    431                         if (equals(relationship.getPrimaryTable())) { 
    432                                 result.add(relationship); 
    433                         } 
    434                 } 
    435                 return result.toArray(new Relationship[result.size()]); 
    436         } 
     98        public Relationship[] getPrimaryKeyRelationships(); 
    43799 
    438         public Column[] getForeignKeys() { 
    439                 Set<Column> columns = new HashSet<Column>(); 
    440                 Relationship[] relationships = getForeignKeyRelationships(); 
    441                 for (Relationship relationship : relationships) { 
    442                         Column[] foreignColumns = relationship.getForeignColumns(); 
    443                         for (Column column : foreignColumns) { 
    444                                 columns.add(column); 
    445                         } 
    446                 } 
    447                 return columns.toArray(new Column[columns.size()]); 
    448         } 
     100        public Column[] getForeignKeys(); 
    449101 
    450         public Column[] getPrimaryKeys() { 
    451                 Set<Column> columns = new HashSet<Column>(); 
    452                 Relationship[] relationships = getPrimaryKeyRelationships(); 
    453                 for (Relationship relationship : relationships) { 
    454                         Column[] foreignColumns = relationship.getPrimaryColumns(); 
    455                         for (Column column : foreignColumns) { 
    456                                 columns.add(column); 
    457                         } 
    458                 } 
    459                 return columns.toArray(new Column[columns.size()]); 
    460         } 
     102        public Column[] getPrimaryKeys(); 
    461103 
    462         public String[] getColumnNames() { 
    463                 ArrayList<String> result = new ArrayList<String>(); 
    464                 Column[] columns = getColumns(); 
    465                 for (Column column : columns) { 
    466                         result.add(column.getName()); 
    467                 } 
    468                 return result.toArray(new String[result.size()]); 
    469         } 
     104        public String[] getColumnNames(); 
    470105 
    471         public Column[] getColumnsOfType(ColumnType columnType) { 
    472                 Column[] columns = getColumns(); 
    473                 return MetaModelHelper.getColumnsByType(columns, columnType); 
    474         } 
     106        public Column[] getColumnsOfType(ColumnType columnType); 
     107 
    475108} 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/AccessDataContextStrategyTest.java

    r886 r887  
    33import java.util.Date; 
    44 
     5import junit.framework.TestCase; 
     6 
    57import org.apache.commons.lang.ArrayUtils; 
    6 import org.eobjects.metamodel.AccessDataContextStrategy; 
    7 import org.eobjects.metamodel.DataContext; 
    88import org.eobjects.metamodel.data.DataSet; 
    99import org.eobjects.metamodel.data.Row; 
    … …  
    1212import org.eobjects.metamodel.schema.Schema; 
    1313import org.eobjects.metamodel.schema.Table; 
    14  
    15 import junit.framework.TestCase; 
    1614 
    1715public class AccessDataContextStrategyTest extends TestCase { 
    … …  
    3331                Column nameCol = table.getColumnByName("name"); 
    3432                assertEquals( 
    35                                 "Column[name=name,columnNumber=1,type=VARCHAR,nullable=<null>,indexed=false,nativeType=TEXT,columnSize=100]", 
     33                                "MutableColumn[name=name,columnNumber=1,type=VARCHAR,nullable=<null>,indexed=false,nativeType=TEXT,columnSize=100]", 
    3634                                nameCol.toString()); 
    3735 
    3836                Column maleCol = table.getColumnByName("male"); 
    3937                assertEquals( 
    40                                 "Column[name=male,columnNumber=3,type=BOOLEAN,nullable=<null>,indexed=false,nativeType=BOOLEAN,columnSize=1]", 
     38                                "MutableColumn[name=male,columnNumber=3,type=BOOLEAN,nullable=<null>,indexed=false,nativeType=BOOLEAN,columnSize=1]", 
    4139                                maleCol.toString()); 
    4240 
    4341                Column developerSinceCol = table.getColumnByName("developer_since"); 
    4442                assertEquals( 
    45                                 "Column[name=developer_since,columnNumber=4,type=TIMESTAMP,nullable=<null>,indexed=false,nativeType=SHORT_DATE_TIME,columnSize=8]", 
     43                                "MutableColumn[name=developer_since,columnNumber=4,type=TIMESTAMP,nullable=<null>,indexed=false,nativeType=SHORT_DATE_TIME,columnSize=8]", 
    4644                                developerSinceCol.toString()); 
    4745 
    … …  
    7068                Column idCol = table.getColumnByName("id"); 
    7169                assertEquals( 
    72                                 "Column[name=id,columnNumber=0,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
     70                                "MutableColumn[name=id,columnNumber=0,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
    7371                                idCol.toString()); 
    7472 
    7573                Column nameCol = table.getColumnByName("name"); 
    7674                assertEquals( 
    77                                 "Column[name=name,columnNumber=1,type=VARCHAR,nullable=<null>,indexed=false,nativeType=TEXT,columnSize=100]", 
     75                                "MutableColumn[name=name,columnNumber=1,type=VARCHAR,nullable=<null>,indexed=false,nativeType=TEXT,columnSize=100]", 
    7876                                nameCol.toString()); 
    7977 
    8078                Column versionCol = table.getColumnByName("version"); 
    8179                assertEquals( 
    82                                 "Column[name=version,columnNumber=2,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
     80                                "MutableColumn[name=version,columnNumber=2,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
    8381                                versionCol.toString()); 
    8482 
    8583                Column founderCol = table.getColumnByName("founder_developer"); 
    8684                assertEquals( 
    87                                 "Column[name=founder_developer,columnNumber=3,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
     85                                "MutableColumn[name=founder_developer,columnNumber=3,type=INTEGER,nullable=<null>,indexed=false,nativeType=LONG,columnSize=4]", 
    8886                                founderCol.toString()); 
    8987 
    … …  
    9189                                founderCol).from(table)); 
    9290                assertTrue(ds.next()); 
    93                 assertEquals("Anthons Algorithms", ds.getRow().getValue(nameCol).toString()); 
     91                assertEquals("Anthons Algorithms", ds.getRow().getValue(nameCol) 
     92                                .toString()); 
    9493                assertEquals(11, ds.getRow().getValue(versionCol)); 
    9594                assertEquals(1, ds.getRow().getValue(founderCol)); 
    9695                assertTrue(ds.next()); 
    97                 assertEquals("Barbaras Basic Bundle", ds.getRow().getValue(nameCol).toString()); 
     96                assertEquals("Barbaras Basic Bundle", ds.getRow().getValue(nameCol) 
     97                                .toString()); 
    9898                assertEquals(2, ds.getRow().getValue(versionCol)); 
    9999                assertEquals(2, ds.getRow().getValue(founderCol)); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/CompositeDataContextStrategyTest.java

    r886 r887  
    55 
    66import org.apache.commons.lang.ArrayUtils; 
    7 import org.eobjects.metamodel.DataContext; 
    8 import org.eobjects.metamodel.DataContextFactory; 
    97import org.eobjects.metamodel.data.DataSet; 
    108import org.eobjects.metamodel.query.JoinType; 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/CsvDataContextStrategyTest.java

    r886 r887  
    2424 
    2525import org.apache.commons.lang.ArrayUtils; 
    26 import org.eobjects.metamodel.CsvDataContextStrategy; 
    27 import org.eobjects.metamodel.DataContext; 
    28 import org.eobjects.metamodel.QueryPostprocessDataContextStrategy; 
    2926import org.eobjects.metamodel.data.DataSet; 
    3027import org.eobjects.metamodel.query.FilterItem; 
    … …  
    3532import org.eobjects.metamodel.schema.Column; 
    3633import org.eobjects.metamodel.schema.ColumnType; 
     34import org.eobjects.metamodel.schema.MutableColumn; 
    3735import org.eobjects.metamodel.schema.Schema; 
    3836import org.eobjects.metamodel.schema.Table; 
    39  
    4037 
    4138public class CsvDataContextStrategyTest extends MetaModelTestCase { 
    … …  
    5148                File file = new File("target/huge_csv.csv"); 
    5249                ExampleDataCreator.createFile(file); 
    53                  
     50 
    5451                long timeAtStart = System.currentTimeMillis(); 
    5552                System.out.println("time at start: " + timeAtStart); 
    5653 
    57                 DataContext dc = new DataContext(new CsvDataContextStrategy(file, ',', '"')); 
     54                DataContext dc = new DataContext(new CsvDataContextStrategy(file, ',', 
     55                                '"')); 
    5856                Table t = dc.getDefaultSchema().getTables()[0]; 
    5957 
    … …  
    6866 
    6967                while (ds.next()) { 
    70                         assertEquals(ExampleDataCreator.NUM_COLS, ds.getRow().getValues().length); 
     68                        assertEquals(ExampleDataCreator.NUM_COLS, 
     69                                        ds.getRow().getValues().length); 
    7170                } 
    7271                ds.close(); 
    … …  
    7473                long timeAfterDataSet = System.currentTimeMillis(); 
    7574                System.out.println("time after dataSet: " + timeAfterDataSet); 
    76                  
     75 
    7776                if (!file.delete()) { 
    7877                        file.deleteOnExit(); 
    … …  
    8382                File file = new File("src/test/resources/tickets.csv"); 
    8483                FileInputStream inputStream = new FileInputStream(file); 
    85                 DataContext dc = new DataContext(new CsvDataContextStrategy(inputStream, ',', '"')); 
     84                DataContext dc = new DataContext(new CsvDataContextStrategy( 
     85                                inputStream, ',', '"')); 
    8686                Schema schema = dc.getDefaultSchema(); 
    8787                String name = schema.getName(); 
    … …  
    9191                Table table = schema.getTables()[0]; 
    9292                Column column = table.getColumns()[0]; 
    93                 TableModel tableModel = dc.executeQuery(new Query().select(column).from(table)).toTableModel(); 
     93                TableModel tableModel = dc.executeQuery( 
     94                                new Query().select(column).from(table)).toTableModel(); 
    9495                assertEquals(1, tableModel.getColumnCount()); 
    9596                assertEquals(36, tableModel.getRowCount()); 
    … …  
    9899                // Test two seperate reads to ensure that the temp file is working 
    99100                // properly and persistent. 
    100                 tableModel = dc.executeQuery(new Query().select(column).from(table)).toTableModel(); 
     101                tableModel = dc.executeQuery(new Query().select(column).from(table)) 
     102                                .toTableModel(); 
    101103                assertEquals(1, tableModel.getColumnCount()); 
    102104                assertEquals(36, tableModel.getRowCount()); 
    … …  
    132134        public void testGetSchemas() throws Exception { 
    133135                File file = new File("src/test/resources/csv_people.csv"); 
    134                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     136                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     137                                file); 
    135138                Schema[] schemas = new DataContext(strategy).getSchemas(); 
    136139                assertEquals(2, schemas.length); 
    … …  
    153156        public void testWhereItemNotInSelectClause() throws Exception { 
    154157                File file = new File("src/test/resources/csv_people.csv"); 
    155                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
    156                 Table table = new DataContext(strategy).getSchemas()[0].getTableByName("csv_people"); 
     158                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     159                                file); 
     160                Table table = new DataContext(strategy).getSchemas()[0] 
     161                                .getTableByName("csv_people"); 
    157162 
    158163                Query q = new Query(); 
    159164                q.from(table); 
    160                 q.where(new FilterItem(new SelectItem(table.getColumnByName("id")), OperatorType.EQUALS_TO, 1)); 
     165                q.where(new FilterItem(new SelectItem(table.getColumnByName("id")), 
     166                                OperatorType.EQUALS_TO, 1)); 
    161167                q.select(table.getColumnByName("name")); 
    162168                DataSet data = strategy.executeQuery(q); 
    … …  
    167173 
    168174        public void testGroupByQuery() throws Exception { 
    169                 DataContext dc = new DataContext(new CsvDataContextStrategy(new File("src/test/resources/csv_people.csv"))); 
     175                DataContext dc = new DataContext(new CsvDataContextStrategy(new File( 
     176                                "src/test/resources/csv_people.csv"))); 
    170177                Table table = dc.getSchemas()[0].getTableByName("csv_people"); 
    171178 
    … …  
    173180                q.from(table); 
    174181                q.groupBy(table.getColumnByName("gender")); 
    175                 q.select(new SelectItem(table.getColumnByName("gender")), new SelectItem(FunctionType.MAX, table 
    176                                 .getColumnByName("age")), new SelectItem(FunctionType.MIN, table.getColumnByName("age")), 
    177                                 new SelectItem(FunctionType.COUNT, "*", "total"), new SelectItem(FunctionType.MIN, table 
    178                                                 .getColumnByName("id")).setAlias("firstId")); 
     182                q.select(new SelectItem(table.getColumnByName("gender")), 
     183                                new SelectItem(FunctionType.MAX, table.getColumnByName("age")), 
     184                                new SelectItem(FunctionType.MIN, table.getColumnByName("age")), 
     185                                new SelectItem(FunctionType.COUNT, "*", "total"), 
     186                                new SelectItem(FunctionType.MIN, table.getColumnByName("id")) 
     187                                                .setAlias("firstId")); 
    179188                DataSet data = dc.executeQuery(q); 
    180189                assertEquals( 
    … …  
    182191                                ArrayUtils.toString(data.getSelectItems())); 
    183192 
    184                 String[] expectations = new String[] { "Row[values={female,20,17,5,5}]", "Row[values={male,19,17,4,1}]" }; 
     193                String[] expectations = new String[] { 
     194                                "Row[values={female,20,17,5,5}]", 
     195                                "Row[values={male,19,17,4,1}]" }; 
    185196 
    186197                assertTrue(data.next()); 
    … …  
    193204        public void testMaterializeTable() throws Exception { 
    194205                File file = new File("src/test/resources/csv_people.csv"); 
    195                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     206                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     207                                file); 
    196208                Table table = new DataContext(strategy).getSchemas()[0].getTables()[0]; 
    197                 DataSet dataSet = strategy.materializeMainSchemaTable(table, table.getColumns(), -1); 
     209                DataSet dataSet = strategy.materializeMainSchemaTable(table, table 
     210                                .getColumns(), -1); 
    198211                assertNull(dataSet.getRow()); 
    199212                assertTrue(dataSet.next()); 
    200                 assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow().toString()); 
    201                 assertTrue(dataSet.next()); 
    202                 assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow().toString()); 
    203                 assertTrue(dataSet.next()); 
    204                 assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow().toString()); 
    205                 assertTrue(dataSet.next()); 
    206                 assertTrue(dataSet.next()); 
    207                 assertEquals("Row[values={5,barbara, barb,female,18}]", dataSet.getRow().toString()); 
    208                 assertTrue(dataSet.next()); 
    209                 assertTrue(dataSet.next()); 
    210                 assertTrue(dataSet.next()); 
    211                 assertTrue(dataSet.next()); 
    212                 assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow().toString()); 
     213                assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow() 
     214                                .toString()); 
     215                assertTrue(dataSet.next()); 
     216                assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow() 
     217                                .toString()); 
     218                assertTrue(dataSet.next()); 
     219                assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow() 
     220                                .toString()); 
     221                assertTrue(dataSet.next()); 
     222                assertTrue(dataSet.next()); 
     223                assertEquals("Row[values={5,barbara, barb,female,18}]", dataSet 
     224                                .getRow().toString()); 
     225                assertTrue(dataSet.next()); 
     226                assertTrue(dataSet.next()); 
     227                assertTrue(dataSet.next()); 
     228                assertTrue(dataSet.next()); 
     229                assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow() 
     230                                .toString()); 
    213231                assertFalse(dataSet.next()); 
    214232 
    215                 dataSet = strategy.materializeMainSchemaTable(table, table.getColumns(), 1); 
    216                 assertTrue(dataSet.next()); 
    217                 assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow().toString()); 
     233                dataSet = strategy.materializeMainSchemaTable(table, 
     234                                table.getColumns(), 1); 
     235                assertTrue(dataSet.next()); 
     236                assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow() 
     237                                .toString()); 
    218238                assertFalse(dataSet.next()); 
    219239        } 
    … …  
    221241        public void testAlternativeDelimitors() throws Exception { 
    222242                File file = new File("src/test/resources/csv_semicolon_singlequote.csv"); 
    223                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file, ';', '\''); 
     243                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     244                                file, ';', '\''); 
    224245                Table table = new DataContext(strategy).getSchemas()[0].getTables()[0]; 
    225                 DataSet dataSet = strategy.materializeMainSchemaTable(table, table.getColumns(), -1); 
    226                 assertTrue(dataSet.next()); 
    227                 assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow().toString()); 
    228                 assertTrue(dataSet.next()); 
    229                 assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow().toString()); 
    230                 assertTrue(dataSet.next()); 
    231                 assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow().toString()); 
    232                 assertTrue(dataSet.next()); 
    233                 assertTrue(dataSet.next()); 
    234                 assertEquals("Row[values={5,barbara; barb,female,18}]", dataSet.getRow().toString()); 
    235                 assertTrue(dataSet.next()); 
    236                 assertTrue(dataSet.next()); 
    237                 assertTrue(dataSet.next()); 
    238                 assertTrue(dataSet.next()); 
    239                 assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow().toString()); 
     246                DataSet dataSet = strategy.materializeMainSchemaTable(table, table 
     247                                .getColumns(), -1); 
     248                assertTrue(dataSet.next()); 
     249                assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow() 
     250                                .toString()); 
     251                assertTrue(dataSet.next()); 
     252                assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow() 
     253                                .toString()); 
     254                assertTrue(dataSet.next()); 
     255                assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow() 
     256                                .toString()); 
     257                assertTrue(dataSet.next()); 
     258                assertTrue(dataSet.next()); 
     259                assertEquals("Row[values={5,barbara; barb,female,18}]", dataSet 
     260                                .getRow().toString()); 
     261                assertTrue(dataSet.next()); 
     262                assertTrue(dataSet.next()); 
     263                assertTrue(dataSet.next()); 
     264                assertTrue(dataSet.next()); 
     265                assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow() 
     266                                .toString()); 
    240267                assertFalse(dataSet.next()); 
    241268                assertNull(dataSet.getRow()); 
    … …  
    244271        public void testMaxRows() throws Exception { 
    245272                File file = new File("src/test/resources/csv_semicolon_singlequote.csv"); 
    246                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file, ';', '\''); 
     273                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     274                                file, ';', '\''); 
    247275                Table table = new DataContext(strategy).getSchemas()[0].getTables()[0]; 
    248                 Query query = new Query().from(table).select(table.getColumns()).setMaxRows(5); 
     276                Query query = new Query().from(table).select(table.getColumns()) 
     277                                .setMaxRows(5); 
    249278                DataSet dataSet = strategy.executeQuery(query); 
    250279                TableModel tableModel = dataSet.toTableModel(); 
    … …  
    254283        public void testQueryOnlyAggregate() throws Exception { 
    255284                File file = new File("src/test/resources/csv_people.csv"); 
    256                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     285                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     286                                file); 
    257287                DataContext dc = new DataContext(strategy); 
    258288                Table table = dc.getDefaultSchema().getTables()[0]; 
    259289 
    260290                Query q = new Query().selectCount().from(table); 
    261                 assertEquals("SELECT COUNT(*) FROM csv_people.csv.csv_people", q.toString()); 
     291                assertEquals("SELECT COUNT(*) FROM csv_people.csv.csv_people", q 
     292                                .toString()); 
    262293 
    263294                List<Object[]> data = dc.executeQuery(q).toObjectArrays(); 
    … …  
    268299 
    269300                q.select(table.getColumns()[0]); 
    270                 assertEquals("SELECT COUNT(*), csv_people.id FROM csv_people.csv.csv_people", q.toString()); 
     301                assertEquals( 
     302                                "SELECT COUNT(*), csv_people.id FROM csv_people.csv.csv_people", 
     303                                q.toString()); 
    271304                data = dc.executeQuery(q).toObjectArrays(); 
    272305                assertEquals(9, data.size()); 
    … …  
    290323        public void testUsingColumnTypeTransformers() throws Exception { 
    291324                File file = new File("src/test/resources/csv_people.csv"); 
    292                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     325                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     326                                file); 
    293327                DataContext dc = new DataContext(strategy); 
    294328                Table table = dc.getDefaultSchema().getTables()[0]; 
    … …  
    299333                strategy.transformColumnTypes(idColumn, ageColumn); 
    300334 
    301                 idColumn.setType(ColumnType.INTEGER); 
    302                 ageColumn.setType(ColumnType.DOUBLE); 
    303  
    304                 DataSet dataSet = dc.executeQuery(new Query().select(idColumn, ageColumn).from(table)); 
    305                 assertTrue(dataSet.next()); 
    306                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn).getClass().getName()); 
     335                ((MutableColumn) idColumn).setType(ColumnType.INTEGER); 
     336                ((MutableColumn) ageColumn).setType(ColumnType.DOUBLE); 
     337 
     338                DataSet dataSet = dc.executeQuery(new Query().select(idColumn, 
     339                                ageColumn).from(table)); 
     340                assertTrue(dataSet.next()); 
     341                assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn) 
     342                                .getClass().getName()); 
    307343                assertEquals(1, dataSet.getRow().getValue(idColumn)); 
    308                 assertEquals("java.lang.Double", dataSet.getRow().getValue(ageColumn).getClass().getName()); 
     344                assertEquals("java.lang.Double", dataSet.getRow().getValue(ageColumn) 
     345                                .getClass().getName()); 
    309346                assertEquals(18.0, dataSet.getRow().getValue(ageColumn)); 
    310347 
    311348                assertTrue(dataSet.next()); 
    312                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn).getClass().getName()); 
     349                assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn) 
     350                                .getClass().getName()); 
    313351                assertEquals(2, dataSet.getRow().getValue(idColumn)); 
    314                 assertEquals("java.lang.Double", dataSet.getRow().getValue(ageColumn).getClass().getName()); 
     352                assertEquals("java.lang.Double", dataSet.getRow().getValue(ageColumn) 
     353                                .getClass().getName()); 
    315354                assertEquals(19.0, dataSet.getRow().getValue(ageColumn)); 
    316355 
    … …  
    320359        public void testAutoTransformColumnTypes() throws Exception { 
    321360                File file = new File("src/test/resources/csv_people.csv"); 
    322                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     361                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     362                                file); 
    323363                strategy.autoTransformColumnTypes(); 
    324364 
    … …  
    331371                assertEquals(ColumnType.INTEGER, ageColumn.getType()); 
    332372 
    333                 DataSet dataSet = dc.executeQuery(new Query().select(idColumn, ageColumn).from(table)); 
    334                 assertTrue(dataSet.next()); 
    335                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn).getClass().getName()); 
     373                DataSet dataSet = dc.executeQuery(new Query().select(idColumn, 
     374                                ageColumn).from(table)); 
     375                assertTrue(dataSet.next()); 
     376                assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn) 
     377                                .getClass().getName()); 
    336378                assertEquals(1, dataSet.getRow().getValue(idColumn)); 
    337                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(ageColumn).getClass().getName()); 
     379                assertEquals("java.lang.Integer", dataSet.getRow().getValue(ageColumn) 
     380                                .getClass().getName()); 
    338381                assertEquals(18, dataSet.getRow().getValue(ageColumn)); 
    339382 
    340383                assertTrue(dataSet.next()); 
    341                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn).getClass().getName()); 
     384                assertEquals("java.lang.Integer", dataSet.getRow().getValue(idColumn) 
     385                                .getClass().getName()); 
    342386                assertEquals(2, dataSet.getRow().getValue(idColumn)); 
    343                 assertEquals("java.lang.Integer", dataSet.getRow().getValue(ageColumn).getClass().getName()); 
     387                assertEquals("java.lang.Integer", dataSet.getRow().getValue(ageColumn) 
     388                                .getClass().getName()); 
    344389                assertEquals(19, dataSet.getRow().getValue(ageColumn)); 
    345390 
    … …  
    349394        public void testAllTypes() throws Exception { 
    350395                File file = new File("src/test/resources/csv_various_types.csv"); 
    351                 QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy(file); 
     396                QueryPostprocessDataContextStrategy strategy = new CsvDataContextStrategy( 
     397                                file); 
    352398                strategy.autoTransformColumnTypes(); 
    353399 
    354400                DataContext dc = new DataContext(strategy); 
    355401                Table table = dc.getDefaultSchema().getTables()[0]; 
    356                 assertEquals("{date,time,description,rating,holiday}", ArrayUtils.toString(table.getColumnNames())); 
    357  
    358                 assertEquals( 
    359                                 "Column[name=date,columnNumber=0,type=DATE,nullable=false,indexed=false,nativeType=Text transformed to date,columnSize=<null>]", 
     402                assertEquals("{date,time,description,rating,holiday}", ArrayUtils 
     403                                .toString(table.getColumnNames())); 
     404 
     405                assertEquals( 
     406                                "MutableColumn[name=date,columnNumber=0,type=DATE,nullable=false,indexed=false,nativeType=Text transformed to date,columnSize=<null>]", 
    360407                                table.getColumnByName("date").toString()); 
    361408                assertEquals( 
    362                                 "Column[name=time,columnNumber=1,type=TIME,nullable=false,indexed=false,nativeType=Text transformed to time,columnSize=<null>]", 
     409                                "MutableColumn[name=time,columnNumber=1,type=TIME,nullable=false,indexed=false,nativeType=Text transformed to time,columnSize=<null>]", 
    363410                                table.getColumnByName("time").toString()); 
    364411                assertEquals( 
    365                                 "Column[name=description,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]", 
     412                                "MutableColumn[name=description,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]", 
    366413                                table.getColumnByName("description").toString()); 
    367414                assertEquals( 
    368                                 "Column[name=rating,columnNumber=3,type=DOUBLE,nullable=false,indexed=false,nativeType=Text transformed to double,columnSize=<null>]", 
     415                                "MutableColumn[name=rating,columnNumber=3,type=DOUBLE,nullable=false,indexed=false,nativeType=Text transformed to double,columnSize=<null>]", 
    369416                                table.getColumnByName("rating").toString()); 
    370417                assertEquals( 
    371                                 "Column[name=holiday,columnNumber=4,type=BOOLEAN,nullable=true,indexed=false,nativeType=Text transformed to boolean,columnSize=<null>]", 
     418                                "MutableColumn[name=holiday,columnNumber=4,type=BOOLEAN,nullable=true,indexed=false,nativeType=Text transformed to boolean,columnSize=<null>]", 
    372419                                table.getColumnByName("holiday").toString()); 
    373420 
    374                 DataSet dataSet = dc.executeQuery(new Query().from(table).select(table.getColumns())); 
    375                 assertTrue(dataSet.next()); 
    376                 assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass().getName()); 
    377                 assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass().getName()); 
    378                 assertEquals("java.lang.String", dataSet.getRow().getValue(2).getClass().getName()); 
    379                 assertEquals("java.lang.Double", dataSet.getRow().getValue(3).getClass().getName()); 
    380                 assertEquals("java.lang.Boolean", dataSet.getRow().getValue(4).getClass().getName()); 
    381                 assertEquals("{2008-11-04,12:00:00,election day,8.8,false}", ArrayUtils.toString(dataSet.getRow().getValues())); 
    382                 assertTrue(dataSet.next()); 
    383                 assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass().getName()); 
    384                 assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass().getName()); 
    385                 assertEquals("java.lang.String", dataSet.getRow().getValue(2).getClass().getName()); 
    386                 assertEquals("java.lang.Double", dataSet.getRow().getValue(3).getClass().getName()); 
    387                 assertEquals("java.lang.Boolean", dataSet.getRow().getValue(4).getClass().getName()); 
    388                 assertEquals("{2008-12-24,00:00:00,christmas day,9.0,true}", ArrayUtils.toString(dataSet.getRow().getValues())); 
    389                 assertTrue(dataSet.next()); 
    390                 assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass().getName()); 
    391                 assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass().getName()); 
    392                 assertEquals("java.lang.String", dataSet.getRow().getValue(2).getClass().getName()); 
    393                 assertEquals("java.lang.Double", dataSet.getRow().getValue(3).getClass().getName()); 
     421                DataSet dataSet = dc.executeQuery(new Query().from(table).select( 
     422                                table.getColumns())); 
     423                assertTrue(dataSet.next()); 
     424                assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass() 
     425                                .getName()); 
     426                assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass() 
     427                                .getName()); 
     428                assertEquals("java.lang.String", dataSet.getRow().getValue(2) 
     429                                .getClass().getName()); 
     430                assertEquals("java.lang.Double", dataSet.getRow().getValue(3) 
     431                                .getClass().getName()); 
     432                assertEquals("java.lang.Boolean", dataSet.getRow().getValue(4) 
     433                                .getClass().getName()); 
     434                assertEquals("{2008-11-04,12:00:00,election day,8.8,false}", ArrayUtils 
     435                                .toString(dataSet.getRow().getValues())); 
     436                assertTrue(dataSet.next()); 
     437                assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass() 
     438                                .getName()); 
     439                assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass() 
     440                                .getName()); 
     441                assertEquals("java.lang.String", dataSet.getRow().getValue(2) 
     442                                .getClass().getName()); 
     443                assertEquals("java.lang.Double", dataSet.getRow().getValue(3) 
     444                                .getClass().getName()); 
     445                assertEquals("java.lang.Boolean", dataSet.getRow().getValue(4) 
     446                                .getClass().getName()); 
     447                assertEquals("{2008-12-24,00:00:00,christmas day,9.0,true}", ArrayUtils 
     448                                .toString(dataSet.getRow().getValues())); 
     449                assertTrue(dataSet.next()); 
     450                assertEquals("java.sql.Date", dataSet.getRow().getValue(0).getClass() 
     451                                .getName()); 
     452                assertEquals("java.sql.Time", dataSet.getRow().getValue(1).getClass() 
     453                                .getName()); 
     454                assertEquals("java.lang.String", dataSet.getRow().getValue(2) 
     455                                .getClass().getName()); 
     456                assertEquals("java.lang.Double", dataSet.getRow().getValue(3) 
     457                                .getClass().getName()); 
    394458                assertNull(dataSet.getRow().getValue(4)); 
    395                 assertEquals("{2007-12-31,23:59:00,new years eve,6.4,<null>}", ArrayUtils 
    396                                 .toString(dataSet.getRow().getValues())); 
     459                assertEquals("{2007-12-31,23:59:00,new years eve,6.4,<null>}", 
     460                                ArrayUtils.toString(dataSet.getRow().getValues())); 
    397461                assertFalse(dataSet.next()); 
    398462        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/DerbyTest.java

    r886 r887  
    3131import org.eobjects.metamodel.query.Query; 
    3232import org.eobjects.metamodel.query.SelectItem; 
     33import org.eobjects.metamodel.schema.Table; 
    3334import org.eobjects.metamodel.schema.Schema; 
    34 import org.eobjects.metamodel.schema.Table; 
    3535import org.eobjects.metamodel.schema.TableType; 
    3636 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/ExcelDataContextStrategyTest.java

    r886 r887  
    2222 
    2323import org.apache.commons.lang.ArrayUtils; 
    24 import org.eobjects.metamodel.DataContext; 
    25 import org.eobjects.metamodel.ExcelDataContextStrategy; 
    26 import org.eobjects.metamodel.QueryPostprocessDataContextStrategy; 
    2724import org.eobjects.metamodel.data.DataSet; 
    2825import org.eobjects.metamodel.query.Query; 
    … …  
    3128import org.eobjects.metamodel.schema.Table; 
    3229 
    33  
    3430public class ExcelDataContextStrategyTest extends TestCase { 
    3531 
    3632        public void testGetSchemas() throws Exception { 
    3733                File file = new File("src/test/resources/xls_people.xls"); 
    38                 QueryPostprocessDataContextStrategy strategy = new ExcelDataContextStrategy(file); 
     34                QueryPostprocessDataContextStrategy strategy = new ExcelDataContextStrategy( 
     35                                file); 
    3936                Schema[] schemas = new DataContext(strategy).getSchemas(); 
    4037                assertEquals(2, schemas.length); 
    … …  
    5754        public void testMaterializeTable() throws Exception { 
    5855                File file = new File("src/test/resources/xls_people.xls"); 
    59                 QueryPostprocessDataContextStrategy strategy = new ExcelDataContextStrategy(file); 
     56                QueryPostprocessDataContextStrategy strategy = new ExcelDataContextStrategy( 
     57                                file); 
    6058                Table table = new DataContext(strategy).getDefaultSchema().getTables()[0]; 
    61                 DataSet dataSet = strategy.materializeMainSchemaTable(table, table.getColumns(), -1); 
     59                DataSet dataSet = strategy.materializeMainSchemaTable(table, table 
     60                                .getColumns(), -1); 
    6261                assertTrue(dataSet.next()); 
    63                 assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow().toString()); 
     62                assertEquals("Row[values={1,mike,male,18}]", dataSet.getRow() 
     63                                .toString()); 
    6464                assertTrue(dataSet.next()); 
    65                 assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow().toString()); 
     65                assertEquals("Row[values={2,michael,male,19}]", dataSet.getRow() 
     66                                .toString()); 
    6667                assertTrue(dataSet.next()); 
    67                 assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow().toString()); 
     68                assertEquals("Row[values={3,peter,male,18}]", dataSet.getRow() 
     69                                .toString()); 
    6870                assertTrue(dataSet.next()); 
    6971                assertTrue(dataSet.next()); 
    … …  
    7274                assertTrue(dataSet.next()); 
    7375                assertTrue(dataSet.next()); 
    74                 assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow().toString()); 
     76                assertEquals("Row[values={9,carrie,female,17}]", dataSet.getRow() 
     77                                .toString()); 
    7578                assertFalse(dataSet.next()); 
    7679                assertNull(dataSet.getRow()); 
    … …  
    8588                Table table = schema.getTables()[0]; 
    8689                assertEquals( 
    87                                 "{Column[name=a,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    88                                                 + "Column[name=b,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    89                                                 + "Column[name=c,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    90                                                 + "Column[name=d,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     90                                "{MutableColumn[name=a,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     91                                                + "MutableColumn[name=b,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     92                                                + "MutableColumn[name=c,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     93                                                + "MutableColumn[name=d,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    9194                                ArrayUtils.toString(table.getColumns())); 
    9295 
    … …  
    9497                DataSet ds = dc.executeQuery(q); 
    9598                assertTrue(ds.next()); 
    96                 assertEquals("{1,2,3,<null>}", ArrayUtils.toString(ds.getRow().getValues())); 
     99                assertEquals("{1,2,3,<null>}", ArrayUtils.toString(ds.getRow() 
     100                                .getValues())); 
    97101                assertTrue(ds.next()); 
    98                 assertEquals("{5,<null>,7,8}", ArrayUtils.toString(ds.getRow().getValues())); 
     102                assertEquals("{5,<null>,7,8}", ArrayUtils.toString(ds.getRow() 
     103                                .getValues())); 
    99104                assertTrue(ds.next()); 
    100                 assertEquals("{9,10,11,12}", ArrayUtils.toString(ds.getRow().getValues())); 
     105                assertEquals("{9,10,11,12}", ArrayUtils.toString(ds.getRow() 
     106                                .getValues())); 
    101107                assertFalse(ds.next()); 
    102108        } 
    … …  
    110116                Table table = schema.getTables()[0]; 
    111117                assertEquals( 
    112                                 "{Column[name=a,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    113                                                 + "Column[name=b,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    114                                                 + "Column[name=[Column 3],columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    115                                                 + "Column[name=d,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     118                                "{MutableColumn[name=a,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     119                                                + "MutableColumn[name=b,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     120                                                + "MutableColumn[name=[Column 3],columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     121                                                + "MutableColumn[name=d,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    116122                                ArrayUtils.toString(table.getColumns())); 
    117123 
    … …  
    123129                assertEquals("{5,6,7,8}", ArrayUtils.toString(ds.getRow().getValues())); 
    124130                assertTrue(ds.next()); 
    125                 assertEquals("{9,10,11,12}", ArrayUtils.toString(ds.getRow().getValues())); 
     131                assertEquals("{9,10,11,12}", ArrayUtils.toString(ds.getRow() 
     132                                .getValues())); 
    126133                assertFalse(ds.next()); 
    127134        } 
    … …  
    131138                DataContext dc = new DataContext(new ExcelDataContextStrategy(file)); 
    132139                Schema schema = dc.getDefaultSchema(); 
    133                 assertEquals("{Table[name=Sheet1,type=<null>,remarks=<null>]}", ArrayUtils.toString(schema.getTables())); 
     140                assertEquals("{MutableTable[name=Sheet1,type=<null>,remarks=<null>]}", 
     141                                ArrayUtils.toString(schema.getTables())); 
    134142                Table table = schema.getTableByName("Sheet1"); 
    135143                assertEquals( 
    136                                 "{Column[name=Pkg No.,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    137                                                 + "Column[name=Description,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    138                                                 + "Column[name=Room,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    139                                                 + "Column[name=Level,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    140                                                 + "Column[name=[Column 5],columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    141                                                 + "Column[name=[Column 6],columnNumber=5,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    142                                                 + "Column[name=[Column 7],columnNumber=6,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    143                                                 + "Column[name=[Column 8],columnNumber=7,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    144                                                 + "Column[name=[Column 9],columnNumber=8,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    145                                                 + "Column[name=[Column 10],columnNumber=9,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    146                                                 + "Column[name=[Column 11],columnNumber=10,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>],Column[name=[Column 12],columnNumber=11,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     144                                "{MutableColumn[name=Pkg No.,columnNumber=0,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     145                                                + "MutableColumn[name=Description,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     146                                                + "MutableColumn[name=Room,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     147                                                + "MutableColumn[name=Level,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     148                                                + "MutableColumn[name=[Column 5],columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     149                                                + "MutableColumn[name=[Column 6],columnNumber=5,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     150                                                + "MutableColumn[name=[Column 7],columnNumber=6,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     151                                                + "MutableColumn[name=[Column 8],columnNumber=7,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     152                                                + "MutableColumn[name=[Column 9],columnNumber=8,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     153                                                + "MutableColumn[name=[Column 10],columnNumber=9,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     154                                                + "MutableColumn[name=[Column 11],columnNumber=10,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     155                                                + "MutableColumn[name=[Column 12],columnNumber=11,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    147156                                ArrayUtils.toString(table.getColumns())); 
    148157        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/HsqldbTest.java

    r886 r887  
    2525 
    2626import org.apache.commons.lang.ArrayUtils; 
    27 import org.eobjects.metamodel.DataContext; 
    28 import org.eobjects.metamodel.JdbcDataContextFactory; 
    29 import org.eobjects.metamodel.JdbcDataContextStrategy; 
    30 import org.eobjects.metamodel.MetaModelHelper; 
    3127import org.eobjects.metamodel.data.DataSet; 
    3228import org.eobjects.metamodel.dialects.DefaultQueryRewriter; 
    … …  
    3935import org.eobjects.metamodel.schema.Schema; 
    4036import org.eobjects.metamodel.schema.Table; 
    41  
    4237 
    4338/** 
    … …  
    110105                // Only a single relationship registered in the database 
    111106                assertEquals( 
    112                                 "{Relationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
     107                                "{ImmutableRelationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
    113108                                ArrayUtils.toString(publicSchema.getRelationships())); 
    114109        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/JdbcDataContextStrategyTest.java

    r886 r887  
    2727import org.apache.commons.lang.ArrayUtils; 
    2828import org.easymock.EasyMock; 
    29 import org.eobjects.metamodel.DataContext; 
    30 import org.eobjects.metamodel.JdbcDataContextFactory; 
    31 import org.eobjects.metamodel.JdbcDataContextStrategy; 
    32 import org.eobjects.metamodel.MetaModelException; 
    33 import org.eobjects.metamodel.QueryPostprocessDataContextStrategy; 
    3429import org.eobjects.metamodel.data.DataSet; 
    3530import org.eobjects.metamodel.dialects.AbstractQueryRewriter; 
    … …  
    4237import org.eobjects.metamodel.query.SelectItem; 
    4338import org.eobjects.metamodel.schema.Column; 
     39import org.eobjects.metamodel.schema.MutableSchema; 
    4440import org.eobjects.metamodel.schema.Relationship; 
    4541import org.eobjects.metamodel.schema.Schema; 
    … …  
    179175                 */ 
    180176                assertEquals( 
    181                                 "{Relationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
     177                                "{ImmutableRelationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
    182178                                ArrayUtils.toString(relations)); 
    183179 
    … …  
    345341         */ 
    346342        public void testCsvQueryResultComparison() throws Exception { 
    347                 final Schema schema = getExampleSchema(); 
     343                final MutableSchema schema = getExampleSchema(); 
    348344 
    349345                Connection connection = getTestDbConnection(); 
    … …  
    362358 
    363359                                        @Override 
    364                                         protected Schema getMainSchema() throws MetaModelException { 
     360                                        protected MutableSchema getMainSchema() throws MetaModelException { 
    365361                                                return schema; 
    366362                                        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/MetaModelHelperTest.java

    r886 r887  
    2121 
    2222import org.apache.commons.lang.ArrayUtils; 
    23 import org.eobjects.metamodel.MetaModelHelper; 
    2423import org.eobjects.metamodel.data.DataSet; 
    2524import org.eobjects.metamodel.query.FilterItem; 
    … …  
    3231import org.eobjects.metamodel.schema.Column; 
    3332import org.eobjects.metamodel.schema.ColumnType; 
     33import org.eobjects.metamodel.schema.MutableColumn; 
     34import org.eobjects.metamodel.schema.MutableTable; 
    3435import org.eobjects.metamodel.schema.Schema; 
    3536import org.eobjects.metamodel.schema.Table; 
    … …  
    3940 
    4041        public void testLeftJoin() throws Exception { 
    41                 SelectItem si1 = new SelectItem(new Column("person_id", 
    42                                 ColumnType.INTEGER)); 
    43                 SelectItem si2 = new SelectItem(new Column("person_name", 
    44                                 ColumnType.VARCHAR)); 
    45                 SelectItem si3 = new SelectItem(new Column("person_age", 
    46                                 ColumnType.INTEGER)); 
    47                 SelectItem si4 = new SelectItem(new Column("person_role_id", 
    48                                 ColumnType.INTEGER)); 
    49                 SelectItem si5 = new SelectItem(new Column("role_id", 
    50                                 ColumnType.INTEGER)); 
    51                 SelectItem si6 = new SelectItem(new Column("role_name", 
    52                                 ColumnType.VARCHAR)); 
    53                 SelectItem si7 = new SelectItem(new Column("role_code", 
     42                SelectItem si1 = new SelectItem(new MutableColumn("person_id", 
     43                                ColumnType.INTEGER)); 
     44                SelectItem si2 = new SelectItem(new MutableColumn("person_name", 
     45                                ColumnType.VARCHAR)); 
     46                SelectItem si3 = new SelectItem(new MutableColumn("person_age", 
     47                                ColumnType.INTEGER)); 
     48                SelectItem si4 = new SelectItem(new MutableColumn("person_role_id", 
     49                                ColumnType.INTEGER)); 
     50                SelectItem si5 = new SelectItem(new MutableColumn("role_id", 
     51                                ColumnType.INTEGER)); 
     52                SelectItem si6 = new SelectItem(new MutableColumn("role_name", 
     53                                ColumnType.VARCHAR)); 
     54                SelectItem si7 = new SelectItem(new MutableColumn("role_code", 
    5455                                ColumnType.VARCHAR)); 
    5556                List<Object[]> data1 = new ArrayList<Object[]>(); 
    … …  
    8788 
    8889        public void testRightJoin() throws Exception { 
    89                 SelectItem si1 = new SelectItem(new Column("person_id", 
    90                                 ColumnType.INTEGER)); 
    91                 SelectItem si2 = new SelectItem(new Column("person_name", 
    92                                 ColumnType.VARCHAR)); 
    93                 SelectItem si3 = new SelectItem(new Column("person_age", 
    94                                 ColumnType.INTEGER)); 
    95                 SelectItem si4 = new SelectItem(new Column("person_role_id", 
    96                                 ColumnType.INTEGER)); 
    97                 SelectItem si5 = new SelectItem(new Column("role_id", 
    98                                 ColumnType.INTEGER)); 
    99                 SelectItem si6 = new SelectItem(new Column("role_name", 
    100                                 ColumnType.VARCHAR)); 
    101                 SelectItem si7 = new SelectItem(new Column("role_code", 
     90                SelectItem si1 = new SelectItem(new MutableColumn("person_id", 
     91                                ColumnType.INTEGER)); 
     92                SelectItem si2 = new SelectItem(new MutableColumn("person_name", 
     93                                ColumnType.VARCHAR)); 
     94                SelectItem si3 = new SelectItem(new MutableColumn("person_age", 
     95                                ColumnType.INTEGER)); 
     96                SelectItem si4 = new SelectItem(new MutableColumn("person_role_id", 
     97                                ColumnType.INTEGER)); 
     98                SelectItem si5 = new SelectItem(new MutableColumn("role_id", 
     99                                ColumnType.INTEGER)); 
     100                SelectItem si6 = new SelectItem(new MutableColumn("role_name", 
     101                                ColumnType.VARCHAR)); 
     102                SelectItem si7 = new SelectItem(new MutableColumn("role_code", 
    102103                                ColumnType.VARCHAR)); 
    103104                List<Object[]> data1 = new ArrayList<Object[]>(); 
    … …  
    210211                data1.add(new Object[] { "o" }); 
    211212                DataSet dataSet1 = new DataSet(new SelectItem[] { new SelectItem( 
    212                                 new Column("foo", ColumnType.VARCHAR)) }, data1); 
     213                                new MutableColumn("foo", ColumnType.VARCHAR)) }, data1); 
    213214                return dataSet1; 
    214215        } 
    … …  
    242243 
    243244        public void testGetTables() throws Exception { 
    244                 Table table1 = new Table("table1"); 
    245                 Table table2 = new Table("table2"); 
    246                 Column t1column1 = new Column("t1c1", ColumnType.BIGINT); 
    247                 Column t2column1 = new Column("t2c1", ColumnType.BIGINT); 
    248                 Column t2column2 = new Column("t2c2", ColumnType.BIGINT); 
     245                MutableTable table1 = new MutableTable("table1"); 
     246                MutableTable table2 = new MutableTable("table2"); 
     247                MutableColumn t1column1 = new MutableColumn("t1c1", ColumnType.BIGINT); 
     248                MutableColumn t2column1 = new MutableColumn("t2c1", ColumnType.BIGINT); 
     249                MutableColumn t2column2 = new MutableColumn("t2c2", ColumnType.BIGINT); 
    249250                table1.addColumn(t1column1); 
    250251                t1column1.setTable(table1); 
    … …  
    267268 
    268269        public void testGetTableColumns() throws Exception { 
    269                 Table table1 = new Table("table1"); 
    270                 Column column1 = new Column("c1", ColumnType.BIGINT); 
    271                 Column column2 = new Column("c2", ColumnType.BIGINT); 
    272                 Column column3 = new Column("c3", ColumnType.BIGINT); 
     270                MutableTable table1 = new MutableTable("table1"); 
     271                MutableColumn column1 = new MutableColumn("c1", ColumnType.BIGINT); 
     272                MutableColumn column2 = new MutableColumn("c2", ColumnType.BIGINT); 
     273                MutableColumn column3 = new MutableColumn("c3", ColumnType.BIGINT); 
    273274                table1.addColumn(column1); 
    274275                column1.setTable(table1); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/MetaModelTestCase.java

    r886 r887  
    3030import org.eobjects.metamodel.data.Row; 
    3131import org.eobjects.metamodel.schema.Column; 
     32import org.eobjects.metamodel.schema.MutableColumn; 
    3233import org.eobjects.metamodel.schema.ColumnType; 
    33 import org.eobjects.metamodel.schema.Relationship; 
    34 import org.eobjects.metamodel.schema.Schema; 
    35 import org.eobjects.metamodel.schema.Table; 
     34import org.eobjects.metamodel.schema.ImmutableRelationship; 
     35import org.eobjects.metamodel.schema.MutableSchema; 
     36import org.eobjects.metamodel.schema.MutableTable; 
    3637import org.eobjects.metamodel.schema.TableType; 
    3738 
    … …  
    8182         * </ul> 
    8283         */ 
    83         protected Schema getExampleSchema() { 
    84                 Schema schema = new Schema("MetaModelSchema"); 
    85  
    86                 Table table1 = new Table(TABLE_CONTRIBUTOR, TableType.TABLE, schema); 
    87                 Column column1 = new Column(COLUMN_CONTRIBUTOR_CONTRIBUTOR_ID, 
     84        protected MutableSchema getExampleSchema() { 
     85                MutableSchema schema = new MutableSchema("MetaModelSchema"); 
     86 
     87                MutableTable table1 = new MutableTable(TABLE_CONTRIBUTOR, TableType.TABLE, schema); 
     88                MutableColumn column1 = new MutableColumn(COLUMN_CONTRIBUTOR_CONTRIBUTOR_ID, 
    8889                                ColumnType.INTEGER, table1, 0, false).setIndexed(true); 
    89                 Column column2 = new Column(COLUMN_CONTRIBUTOR_NAME, 
     90                MutableColumn column2 = new MutableColumn(COLUMN_CONTRIBUTOR_NAME, 
    9091                                ColumnType.VARCHAR, table1, 1, false); 
    91                 Column column3 = new Column(COLUMN_CONTRIBUTOR_COUNTRY, 
     92                Column column3 = new MutableColumn(COLUMN_CONTRIBUTOR_COUNTRY, 
    9293                                ColumnType.VARCHAR, table1, 2, true); 
    9394                table1.setColumns(column1, column2, column3); 
    9495 
    95                 Table table2 = new Table(TABLE_PROJECT, TableType.TABLE, schema); 
    96                 Column column4 = new Column(COLUMN_PROJECT_PROJECT_ID, 
     96                MutableTable table2 = new MutableTable(TABLE_PROJECT, TableType.TABLE, schema); 
     97                MutableColumn column4 = new MutableColumn(COLUMN_PROJECT_PROJECT_ID, 
    9798                                ColumnType.INTEGER, table2, 0, false); 
    98                 Column column5 = new Column(COLUMN_PROJECT_NAME, ColumnType.VARCHAR, 
     99                MutableColumn column5 = new MutableColumn(COLUMN_PROJECT_NAME, ColumnType.VARCHAR, 
    99100                                table2, 1, false); 
    100                 Column column6 = new Column(COLUMN_PROJECT_LINES_OF_CODE, 
     101                Column column6 = new MutableColumn(COLUMN_PROJECT_LINES_OF_CODE, 
    101102                                ColumnType.BIGINT, table2, 2, true); 
    102                 Column column7 = new Column(COLUMN_PROJECT_PARENT_PROJECT_ID, 
     103                Column column7 = new MutableColumn(COLUMN_PROJECT_PARENT_PROJECT_ID, 
    103104                                ColumnType.INTEGER, table2, 3, true); 
    104105                table2.setColumns(column4, column5, column6, column7); 
    105106 
    106                 Table table3 = new Table(TABLE_ROLE, TableType.TABLE, schema); 
    107                 Column column8 = new Column(COLUMN_ROLE_CONTRIBUTOR_ID, 
     107                MutableTable table3 = new MutableTable(TABLE_ROLE, TableType.TABLE, schema); 
     108                MutableColumn column8 = new MutableColumn(COLUMN_ROLE_CONTRIBUTOR_ID, 
    108109                                ColumnType.INTEGER, table3, 0, false); 
    109                 Column column9 = new Column(COLUMN_ROLE_PROJECT_ID, ColumnType.INTEGER, 
     110                MutableColumn column9 = new MutableColumn(COLUMN_ROLE_PROJECT_ID, ColumnType.INTEGER, 
    110111                                table3, 1, false); 
    111                 Column column10 = new Column(COLUMN_ROLE_ROLE_NAME, ColumnType.VARCHAR, 
     112                MutableColumn column10 = new MutableColumn(COLUMN_ROLE_ROLE_NAME, ColumnType.VARCHAR, 
    112113                                table3, 2, false); 
    113114                table3.setColumns(column8, column9, column10); 
    114115 
    115                 Table table4 = new Table(TABLE_PROJECT_CONTRIBUTOR, TableType.VIEW, 
     116                MutableTable table4 = new MutableTable(TABLE_PROJECT_CONTRIBUTOR, TableType.VIEW, 
    116117                                schema); 
    117                 Column column11 = new Column(COLUMN_PROJECT_CONTRIBUTOR_CONTRIBUTOR, 
     118                MutableColumn column11 = new MutableColumn(COLUMN_PROJECT_CONTRIBUTOR_CONTRIBUTOR, 
    118119                                ColumnType.VARCHAR, table4, 0, false); 
    119                 Column column12 = new Column(COLUMN_PROJECT_CONTRIBUTOR_PROJECT, 
     120                MutableColumn column12 = new MutableColumn(COLUMN_PROJECT_CONTRIBUTOR_PROJECT, 
    120121                                ColumnType.VARCHAR, table4, 1, false); 
    121                 Column column13 = new Column(COLUMN_PROJECT_CONTRIBUTOR_ROLE, 
     122                MutableColumn column13 = new MutableColumn(COLUMN_PROJECT_CONTRIBUTOR_ROLE, 
    122123                                ColumnType.VARCHAR, table4, 2, false); 
    123                 ArrayList<Column> columnList = new ArrayList<Column>(); 
     124                ArrayList<MutableColumn> columnList = new ArrayList<MutableColumn>(); 
    124125                columnList.add(column11); 
    125126                columnList.add(column12); 
    … …  
    128129 
    129130                // one-Contributor-to-many-Role's 
    130                 Relationship.createRelationship(new Column[] { column1 }, 
    131                                 new Column[] { column8 }); 
     131                ImmutableRelationship.createRelationship(new MutableColumn[] { column1 }, 
     132                                new MutableColumn[] { column8 }); 
    132133 
    133134                // one-Project-to-many-Role's 
    134                 Relationship.createRelationship(new Column[] { column4 }, 
    135                                 new Column[] { column9 }); 
     135                ImmutableRelationship.createRelationship(new MutableColumn[] { column4 }, 
     136                                new MutableColumn[] { column9 }); 
    136137 
    137138                // view relation [contributor -> contributor_name] 
    138                 Relationship.createRelationship(new Column[] { column2 }, 
    139                                 new Column[] { column11 }); 
     139                ImmutableRelationship.createRelationship(new MutableColumn[] { column2 }, 
     140                                new MutableColumn[] { column11 }); 
    140141 
    141142                // view relation [project -> project_name] 
    142                 Relationship.createRelationship(new Column[] { column5 }, 
    143                                 new Column[] { column12 }); 
     143                ImmutableRelationship.createRelationship(new MutableColumn[] { column5 }, 
     144                                new MutableColumn[] { column12 }); 
    144145 
    145146                // view relation [role -> role_name] 
    146                 Relationship.createRelationship(new Column[] { column10 }, 
    147                                 new Column[] { column13 }); 
     147                ImmutableRelationship.createRelationship(new MutableColumn[] { column10 }, 
     148                                new MutableColumn[] { column13 }); 
    148149 
    149150                schema.setTables(table1, table2, table3, table4); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/OpenOfficeDataContextStrategyTest.java

    r886 r887  
    2727import org.eobjects.metamodel.data.DataSet; 
    2828import org.eobjects.metamodel.query.Query; 
     29import org.eobjects.metamodel.schema.Table; 
    2930import org.eobjects.metamodel.schema.Schema; 
    30 import org.eobjects.metamodel.schema.Table; 
    3131 
    3232 
    … …  
    7373                                ArrayUtils.toString(schema.getTables())); 
    7474                assertEquals( 
    75                                 "{Relationship[primaryTable=CONTRIBUTORS,primaryColumns={ID},foreignTable=projects,foreignColumns={admin}]}", 
     75                                "{ImmutableRelationship[primaryTable=CONTRIBUTORS,primaryColumns={ID},foreignTable=projects,foreignColumns={admin}]}", 
    7676                                ArrayUtils.toString(schema.getRelationships())); 
    7777        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/QueryPostprocessDataContextStrategyTest.java

    r886 r887  
    2323 
    2424import org.apache.commons.lang.ArrayUtils; 
    25 import org.eobjects.metamodel.IDataContextStrategy; 
    26 import org.eobjects.metamodel.MetaModelException; 
    27 import org.eobjects.metamodel.QueryPostprocessDataContextStrategy; 
    2825import org.eobjects.metamodel.data.DataSet; 
    2926import org.eobjects.metamodel.data.Row; 
    … …  
    4138import org.eobjects.metamodel.schema.Schema; 
    4239import org.eobjects.metamodel.schema.Table; 
    43  
    4440 
    4541public class QueryPostprocessDataContextStrategyTest extends MetaModelTestCase { 
    … …  
    141137                                .getSchemaByName("information_schema"); 
    142138                assertEquals( 
    143                                 "{Table[name=tables,type=TABLE,remarks=<null>],Table[name=columns,type=TABLE,remarks=<null>],Table[name=relationships,type=TABLE,remarks=<null>]}", 
     139                                "{MutableTable[name=tables,type=TABLE,remarks=<null>],MutableTable[name=columns,type=TABLE,remarks=<null>],MutableTable[name=relationships,type=TABLE,remarks=<null>]}", 
    144140                                ArrayUtils.toString(informationSchema.getTables())); 
    145141                assertEquals( 
    146                                 "{Relationship[primaryTable=tables,primaryColumns={name},foreignTable=columns,foreignColumns={table}]," 
    147                                                 + "Relationship[primaryTable=tables,primaryColumns={name},foreignTable=relationships,foreignColumns={primary_table}]," 
    148                                                 + "Relationship[primaryTable=tables,primaryColumns={name},foreignTable=relationships,foreignColumns={foreign_table}]," 
    149                                                 + "Relationship[primaryTable=columns,primaryColumns={name},foreignTable=relationships,foreignColumns={primary_column}]," 
    150                                                 + "Relationship[primaryTable=columns,primaryColumns={name},foreignTable=relationships,foreignColumns={foreign_column}]}", 
     142                                "{ImmutableRelationship[primaryTable=tables,primaryColumns={name},foreignTable=columns,foreignColumns={table}]," 
     143                                                + "ImmutableRelationship[primaryTable=tables,primaryColumns={name},foreignTable=relationships,foreignColumns={primary_table}]," 
     144                                                + "ImmutableRelationship[primaryTable=tables,primaryColumns={name},foreignTable=relationships,foreignColumns={foreign_table}]," 
     145                                                + "ImmutableRelationship[primaryTable=columns,primaryColumns={name},foreignTable=relationships,foreignColumns={primary_column}]," 
     146                                                + "ImmutableRelationship[primaryTable=columns,primaryColumns={name},foreignTable=relationships,foreignColumns={foreign_column}]}", 
    151147                                ArrayUtils.toString(informationSchema.getRelationships())); 
    152148                Table tablesTable = informationSchema.getTableByName("tables"); 
    153149                assertEquals( 
    154                                 "{Column[name=name,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    155                                                 + "Column[name=type,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    156                                                 + "Column[name=num_columns,columnNumber=2,type=INTEGER,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    157                                                 + "Column[name=remarks,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     150                                "{MutableColumn[name=name,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     151                                                + "MutableColumn[name=type,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     152                                                + "MutableColumn[name=num_columns,columnNumber=2,type=INTEGER,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     153                                                + "MutableColumn[name=remarks,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    158154                                ArrayUtils.toString(tablesTable.getColumns())); 
    159155                Table columnsTable = informationSchema.getTableByName("columns"); 
    160156                assertEquals( 
    161                                 "{Column[name=name,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    162                                                 + "Column[name=type,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    163                                                 + "Column[name=native_type,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    164                                                 + "Column[name=size,columnNumber=3,type=INTEGER,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    165                                                 + "Column[name=nullable,columnNumber=4,type=BOOLEAN,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    166                                                 + "Column[name=indexed,columnNumber=5,type=BOOLEAN,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
    167                                                 + "Column[name=table,columnNumber=6,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    168                                                 + "Column[name=remarks,columnNumber=7,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     157                                "{MutableColumn[name=name,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     158                                                + "MutableColumn[name=type,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     159                                                + "MutableColumn[name=native_type,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     160                                                + "MutableColumn[name=size,columnNumber=3,type=INTEGER,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     161                                                + "MutableColumn[name=nullable,columnNumber=4,type=BOOLEAN,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     162                                                + "MutableColumn[name=indexed,columnNumber=5,type=BOOLEAN,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]," 
     163                                                + "MutableColumn[name=table,columnNumber=6,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     164                                                + "MutableColumn[name=remarks,columnNumber=7,type=VARCHAR,nullable=true,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    169165                                ArrayUtils.toString(columnsTable.getColumns())); 
    170166                Table relationshipsTable = informationSchema 
    171167                                .getTableByName("relationships"); 
    172168                assertEquals( 
    173                                 "{Column[name=primary_table,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    174                                                 + "Column[name=primary_column,columnNumber=1,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    175                                                 + "Column[name=foreign_table,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
    176                                                 + "Column[name=foreign_column,columnNumber=3,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     169                                "{MutableColumn[name=primary_table,columnNumber=0,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     170                                                + "MutableColumn[name=primary_column,columnNumber=1,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     171                                                + "MutableColumn[name=foreign_table,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]," 
     172                                                + "MutableColumn[name=foreign_column,columnNumber=3,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    177173                                ArrayUtils.toString(relationshipsTable.getColumns())); 
    178174 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/QuerySplitterTest.java

    r886 r887  
    2121 
    2222import org.apache.commons.lang.ArrayUtils; 
    23 import org.eobjects.metamodel.DataContext; 
    24 import org.eobjects.metamodel.JdbcDataContextFactory; 
    25 import org.eobjects.metamodel.QuerySplitter; 
    2623import org.eobjects.metamodel.data.DataSet; 
    2724import org.eobjects.metamodel.query.FromItem; 
    … …  
    128125                Relationship relationship = relationships[0]; 
    129126                assertEquals( 
    130                                 "Relationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]", 
     127                                "ImmutableRelationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]", 
    131128                                relationship.toString()); 
    132129 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/SqliteTest.java

    r886 r887  
    2121import java.util.List; 
    2222 
     23import junit.framework.TestCase; 
     24 
    2325import org.apache.commons.lang.ArrayUtils; 
    24 import org.eobjects.metamodel.DataContext; 
    25 import org.eobjects.metamodel.JdbcDataContextFactory; 
    2626import org.eobjects.metamodel.query.OperatorType; 
    2727import org.eobjects.metamodel.query.Query; 
    … …  
    2929import org.eobjects.metamodel.schema.Schema; 
    3030import org.eobjects.metamodel.schema.Table; 
    31  
    32  
    33 import junit.framework.TestCase; 
    3431 
    3532/** 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/XmlDataContextStrategyTest.java

    r886 r887  
    2727 
    2828import org.apache.commons.lang.ArrayUtils; 
    29 import org.eobjects.metamodel.DataContext; 
    30 import org.eobjects.metamodel.IDataContextStrategy; 
    31 import org.eobjects.metamodel.XmlDataContextStrategy; 
    3229import org.eobjects.metamodel.data.DataSet; 
    3330import org.eobjects.metamodel.query.FromItem; 
    … …  
    4037import org.w3c.dom.Element; 
    4138 
    42  
    4339public class XmlDataContextStrategyTest extends MetaModelTestCase { 
    4440 
    … …  
    4642                // Retrieve the eobjects.org news rss 
    4743                URL url = new URL("http://eobjects.org/trac/blog?format=rss"); 
    48                  
     44 
    4945                try { 
    50                         XmlDataContextStrategy strategy = new XmlDataContextStrategy(url, true); 
     46                        XmlDataContextStrategy strategy = new XmlDataContextStrategy(url, 
     47                                        true); 
    5148                        DataContext dataContext = new DataContext(strategy); 
    52                          
     49 
    5350                        Schema schema = dataContext.getDefaultSchema(); 
    5451                        assertEquals("/blog?format=rss", schema.getName()); 
    55                          
     52 
    5653                        assertEquals( 
    5754                                        "{rss,channel_title,channel_link,channel_description,channel_language," 
    58                                         + "channel_generator,channel_image_title,channel_image_url," 
    59                                         + "channel_image_link,channel_item,channel_item_guid,channel_item_category}", 
     55                                                        + "channel_generator,channel_image_title,channel_image_url," 
     56                                                        + "channel_image_link,channel_item,channel_item_guid,channel_item_category}", 
    6057                                        ArrayUtils.toString(schema.getTableNames())); 
    6158                } catch (IllegalArgumentException e) { 
    … …  
    7673 
    7774                Schema schema = strategy.getSchemaByName("xml_input_eobjects.xml"); 
    78                 assertEquals("Schema[name=xml_input_eobjects.xml]", schema.toString()); 
     75                assertEquals("MutableSchema[name=xml_input_eobjects.xml]", schema 
     76                                .toString()); 
    7977 
    8078                Table[] tables = schema.getTables(); 
    8179                assertEquals(5, schema.getTableCount()); 
    8280                assertEquals( 
    83                                 "{Table[name=eobjects.dk,type=TABLE,remarks=<null>]," 
    84                                                 + "Table[name=contributors_person,type=TABLE,remarks=<null>]," 
    85                                                 + "Table[name=contributors_person_name,type=TABLE,remarks=<null>]," 
    86                                                 + "Table[name=contributors_person_address,type=TABLE,remarks=<null>]," 
    87                                                 + "Table[name=projects_project,type=TABLE,remarks=<null>]}", 
     81                                "{MutableTable[name=eobjects.org,type=TABLE,remarks=<null>]," 
     82                                                + "MutableTable[name=contributors_person,type=TABLE,remarks=<null>]," 
     83                                                + "MutableTable[name=contributors_person_name,type=TABLE,remarks=<null>]," 
     84                                                + "MutableTable[name=contributors_person_address,type=TABLE,remarks=<null>]," 
     85                                                + "MutableTable[name=projects_project,type=TABLE,remarks=<null>]}", 
    8886                                ArrayUtils.toString(tables)); 
    8987 
    90                 Table table = schema.getTableByName("eobjects.dk"); 
     88                Table table = schema.getTableByName("eobjects.org"); 
    9189                assertEquals(2, table.getColumnCount()); 
    9290                assertEquals( 
    93                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    94                                                 + "Column[name=website,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Attribute,columnSize=<null>]}", 
     91                                "{MutableColumn[name=eobjects.org_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     92                                                + "MutableColumn[name=website,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Attribute,columnSize=<null>]}", 
    9593                                ArrayUtils.toString(table.getColumns())); 
    9694 
    … …  
    9896                assertEquals(1, table.getColumnCount()); 
    9997                assertEquals( 
    100                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]}", 
     98                                "{MutableColumn[name=contributors_person_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]}", 
    10199                                ArrayUtils.toString(table.getColumns())); 
    102100 
    … …  
    104102                assertEquals(3, table.getColumnCount()); 
    105103                assertEquals( 
    106                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    107                                                 + "Column[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Auto-generated foreign key,columnSize=<null>]," 
    108                                                 + "Column[name=name,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    109                                 ArrayUtils.toString(table.getColumns())); 
    110                 assertEquals( 
    111                                 "{Relationship[primaryTable=contributors_person,primaryColumns={id}," 
    112                                                 + "foreignTable=contributors_person_name,foreignColumns={contributors_person_id}]}", 
     104                                "{MutableColumn[name=contributors_person_name_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     105                                                + "MutableColumn[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Auto-generated foreign key,columnSize=<null>]," 
     106                                                + "MutableColumn[name=name,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     107                                ArrayUtils.toString(table.getColumns())); 
     108                assertEquals( 
     109                                "{ImmutableRelationship[primaryTable=contributors_person,primaryColumns={contributors_person_mdbeans_surrogate_id},foreignTable=contributors_person_name,foreignColumns={contributors_person_id}]}", 
    113110                                ArrayUtils.toString(table.getRelationships())); 
    114111 
    … …  
    116113                assertEquals(3, table.getColumnCount()); 
    117114                assertEquals( 
    118                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    119                                                 + "Column[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Auto-generated foreign key,columnSize=<null>]," 
    120                                                 + "Column[name=address,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    121                                 ArrayUtils.toString(table.getColumns())); 
    122                 assertEquals( 
    123                                 "{Relationship[primaryTable=contributors_person,primaryColumns={id}," 
     115                                "{MutableColumn[name=contributors_person_address_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     116                                                + "MutableColumn[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Auto-generated foreign key,columnSize=<null>]," 
     117                                                + "MutableColumn[name=address,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     118                                ArrayUtils.toString(table.getColumns())); 
     119                assertEquals( 
     120                                "{ImmutableRelationship[primaryTable=contributors_person,primaryColumns={contributors_person_mdbeans_surrogate_id}," 
    124121                                                + "foreignTable=contributors_person_address,foreignColumns={contributors_person_id}]}", 
    125122                                ArrayUtils.toString(table.getRelationships())); 
    … …  
    128125                assertEquals(3, table.getColumnCount()); 
    129126                assertEquals( 
    130                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    131                                                 + "Column[name=project,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    132                                                 + "Column[name=name,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Attribute,columnSize=<null>]}", 
     127                                "{MutableColumn[name=projects_project_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     128                                                + "MutableColumn[name=project,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     129                                                + "MutableColumn[name=name,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Attribute,columnSize=<null>]}", 
    133130                                ArrayUtils.toString(table.getColumns())); 
    134131 
    … …  
    137134                assertEquals(2, table.getColumnCount()); 
    138135                assertEquals( 
    139                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    140                                                 + "Column[name=name,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     136                                "{MutableColumn[name=contributors_person_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     137                                                + "MutableColumn[name=name,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    141138                                ArrayUtils.toString(table.getColumns())); 
    142139        } 
    … …  
    150147                Query q = new Query().select(table.getColumns()).from(table, "p"); 
    151148                assertEquals( 
    152                                 "SELECT p.id, p.project, p.name FROM xml_input_eobjects.xml.projects_project p", 
     149                                "SELECT p.projects_project_mdbeans_surrogate_id, p.project, p.name FROM xml_input_eobjects.xml.projects_project p", 
    153150                                q.toString()); 
    154151                DataSet data = dc.executeQuery(q); 
    … …  
    177174 
    178175                assertEquals( 
    179                                 "SELECT contributors_person.id, contributors_person_address.id, " 
     176                                "SELECT contributors_person.contributors_person_mdbeans_surrogate_id, contributors_person_address.contributors_person_address_mdbeans_surrogate_id, " 
    180177                                                + "contributors_person_address.contributors_person_id, contributors_person_address.address " 
    181178                                                + "FROM xml_input_eobjects.xml.contributors_person INNER JOIN xml_input_eobjects.xml.contributors_person_address " 
    182                                                 + "ON contributors_person.id = contributors_person_address.contributors_person_id", 
     179                                                + "ON contributors_person.contributors_person_mdbeans_surrogate_id = contributors_person_address.contributors_person_id", 
    183180                                q.toString()); 
    184181 
    … …  
    227224                                "foobarSchema", document, true); 
    228225                Schema schema = strategy.getSchemaByName("foobarSchema"); 
    229                 assertEquals("Schema[name=foobarSchema]", schema.toString()); 
    230                 assertEquals("{Table[name=child,type=TABLE,remarks=<null>]}", 
     226                assertEquals("MutableSchema[name=foobarSchema]", schema.toString()); 
     227                assertEquals("{MutableTable[name=child,type=TABLE,remarks=<null>]}", 
    231228                                ArrayUtils.toString(schema.getTables())); 
    232229                Table table = schema.getTables()[0]; 
    233230                assertEquals( 
    234                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    235                                                 + "Column[name=child,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     231                                "{MutableColumn[name=child_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     232                                                + "MutableColumn[name=child,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    236233                                ArrayUtils.toString(table.getColumns())); 
    237234        } 
    … …  
    244241                Schema schema = dc.getDefaultSchema(); 
    245242                assertEquals( 
    246                                 "{Table[name=dependency,type=TABLE,remarks=<null>]," 
    247                                                 + "Table[name=dependency_groupId,type=TABLE,remarks=<null>]," 
    248                                                 + "Table[name=dependency_artifactId,type=TABLE,remarks=<null>]," 
    249                                                 + "Table[name=dependency_version,type=TABLE,remarks=<null>]," 
    250                                                 + "Table[name=dependency_scope,type=TABLE,remarks=<null>]}", 
     243                                "{MutableTable[name=dependency,type=TABLE,remarks=<null>]," 
     244                                                + "MutableTable[name=dependency_groupId,type=TABLE,remarks=<null>]," 
     245                                                + "MutableTable[name=dependency_artifactId,type=TABLE,remarks=<null>]," 
     246                                                + "MutableTable[name=dependency_version,type=TABLE,remarks=<null>]," 
     247                                                + "MutableTable[name=dependency_scope,type=TABLE,remarks=<null>]}", 
    251248                                ArrayUtils.toString(schema.getTables())); 
    252249                Table dependencyTable = schema.getTableByName("dependency"); 
    253250                assertEquals( 
    254                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]}", 
     251                                "{MutableColumn[name=dependency_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]}", 
    255252                                ArrayUtils.toString(dependencyTable.getColumns())); 
    256253                List<Object[]> dependencyData = strategy.materializeMainSchemaTable( 
    … …  
    264261                                .getRelationships()[0]; 
    265262                assertEquals( 
    266                                 "Relationship[primaryTable=dependency,primaryColumns={id},foreignTable=dependency_groupId,foreignColumns={dependency_id}]", 
     263                                "ImmutableRelationship[primaryTable=dependency,primaryColumns={dependency_mdbeans_surrogate_id},foreignTable=dependency_groupId,foreignColumns={dependency_id}]", 
    267264                                relationship.toString()); 
    268265 
    … …  
    270267 
    271268                assertEquals( 
    272                                 "{Table[name=dependency,type=TABLE,remarks=<null>]," 
    273                                                 + "Table[name=dependency_artifactId,type=TABLE,remarks=<null>]," 
    274                                                 + "Table[name=dependency_version,type=TABLE,remarks=<null>]," 
    275                                                 + "Table[name=dependency_scope,type=TABLE,remarks=<null>]}", 
     269                                "{MutableTable[name=dependency,type=TABLE,remarks=<null>]," 
     270                                                + "MutableTable[name=dependency_artifactId,type=TABLE,remarks=<null>]," 
     271                                                + "MutableTable[name=dependency_version,type=TABLE,remarks=<null>]," 
     272                                                + "MutableTable[name=dependency_scope,type=TABLE,remarks=<null>]}", 
    276273                                ArrayUtils.toString(schema.getTables())); 
    277274 
    278275                assertEquals( 
    279                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    280                                                 + "Column[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     276                                "{MutableColumn[name=dependency_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     277                                                + "MutableColumn[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    281278                                ArrayUtils.toString(dependencyTable.getColumns())); 
    282279 
    … …  
    290287                strategy.autoFlattenTables(); 
    291288 
    292                 assertEquals("{Table[name=dependency,type=TABLE,remarks=<null>]}", 
     289                assertEquals( 
     290                                "{MutableTable[name=dependency,type=TABLE,remarks=<null>]}", 
    293291                                ArrayUtils.toString(schema.getTables())); 
    294292                assertEquals( 
    295                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    296                                                 + "Column[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    297                                                 + "Column[name=artifactId,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    298                                                 + "Column[name=version,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    299                                                 + "Column[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     293                                "{MutableColumn[name=dependency_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     294                                                + "MutableColumn[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     295                                                + "MutableColumn[name=artifactId,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     296                                                + "MutableColumn[name=version,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     297                                                + "MutableColumn[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    300298                                ArrayUtils.toString(dependencyTable.getColumns())); 
    301299 
    … …  
    317315                Table table = schema.getTableByName("dependencies_dependency"); 
    318316                assertEquals( 
    319                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    320                                                 + "Column[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    321                                                 + "Column[name=artifactId,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    322                                                 + "Column[name=version,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
    323                                                 + "Column[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
     317                                "{MutableColumn[name=dependencies_dependency_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     318                                                + "MutableColumn[name=groupId,columnNumber=1,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     319                                                + "MutableColumn[name=artifactId,columnNumber=2,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     320                                                + "MutableColumn[name=version,columnNumber=3,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]," 
     321                                                + "MutableColumn[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=XML Text,columnSize=<null>]}", 
    324322                                ArrayUtils.toString(table.getColumns())); 
    325323 
    … …  
    327325 
    328326                assertEquals( 
    329                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    330                                                 + "Column[name=groupId,columnNumber=1,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
    331                                                 + "Column[name=artifactId,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
    332                                                 + "Column[name=version,columnNumber=3,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
    333                                                 + "Column[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=Text,columnSize=<null>]}", 
     327                                "{MutableColumn[name=dependencies_dependency_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     328                                                + "MutableColumn[name=groupId,columnNumber=1,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
     329                                                + "MutableColumn[name=artifactId,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
     330                                                + "MutableColumn[name=version,columnNumber=3,type=VARCHAR,nullable=false,indexed=false,nativeType=Text,columnSize=<null>]," 
     331                                                + "MutableColumn[name=scope,columnNumber=4,type=VARCHAR,nullable=true,indexed=false,nativeType=Text,columnSize=<null>]}", 
    334332                                ArrayUtils.toString(table.getColumns())); 
    335333 
    336334                table = schema.getTableByName("inceptionYear"); 
    337335                assertEquals( 
    338                                 "{Column[name=id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
    339                                                 + "Column[name=inceptionYear,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Text transformed to integer,columnSize=<null>]}", 
     336                                "{MutableColumn[name=inceptionYear_mdbeans_surrogate_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=Auto-generated primary key,columnSize=<null>]," 
     337                                                + "MutableColumn[name=inceptionYear,columnNumber=1,type=INTEGER,nullable=false,indexed=false,nativeType=Text transformed to integer,columnSize=<null>]}", 
    340338                                ArrayUtils.toString(table.getColumns())); 
    341339 
    … …  
    362360                                ArrayUtils.toString(schema.getTableNames())); 
    363361                assertEquals( 
    364                                 "{id,OSType,lastStateChange,name,uuid,enabled,enabled,RAMSize,enabled,enabled,mode,value," 
     362                                "{Machine_mdbeans_surrogate_id,OSType,lastStateChange,name,uuid,enabled,enabled,RAMSize,enabled,enabled,mode,value," 
    365363                                                + "enabled,type,enabled,mode}", ArrayUtils 
    366364                                                .toString(schema.getTableByName("Machine") 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/data/RowFilterDataSetStrategyTest.java

    r886 r887  
    2222import org.eobjects.metamodel.JdbcDataContextFactory; 
    2323import org.eobjects.metamodel.MetaModelTestCase; 
    24 import org.eobjects.metamodel.data.DataSet; 
    25 import org.eobjects.metamodel.data.IRowFilter; 
    26 import org.eobjects.metamodel.data.Row; 
    27 import org.eobjects.metamodel.data.RowFilterDataSetStrategyWrapper; 
    2824import org.eobjects.metamodel.query.Query; 
    2925import org.eobjects.metamodel.schema.Table; 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dbase/DbaseDataContextStrategyMeterTest.java

    r886 r887  
    22 
    33import java.util.Date; 
     4 
     5import junit.framework.TestCase; 
    46 
    57import org.apache.commons.lang.ArrayUtils; 
    … …  
    810import org.eobjects.metamodel.data.DataSet; 
    911import org.eobjects.metamodel.data.Row; 
    10 import org.eobjects.metamodel.dbase.DbaseDataContextStrategy; 
    1112import org.eobjects.metamodel.query.Query; 
    1213import org.eobjects.metamodel.query.SelectItem; 
    … …  
    1516import org.eobjects.metamodel.schema.Schema; 
    1617import org.eobjects.metamodel.schema.Table; 
    17  
    18 import junit.framework.TestCase; 
    1918 
    2019public class DbaseDataContextStrategyMeterTest extends TestCase { 
    … …  
    2827 
    2928                Schema schema = dc.getSchemaByName("METER.DBF"); 
    30                 assertEquals("{Table[name=METER,type=TABLE,remarks=<null>]}", 
     29                assertEquals("{MutableTable[name=METER,type=TABLE,remarks=<null>]}", 
    3130                                ArrayUtils.toString(schema.getTables())); 
    3231 
    … …  
    3837                Column column = table.getColumnByName("F_TYPE"); 
    3938                assertEquals( 
    40                                 "Column[name=F_TYPE,columnNumber=11,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=1]", 
     39                                "MutableColumn[name=F_TYPE,columnNumber=11,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=1]", 
    4140                                column.toString()); 
    4241 
    4342                column = table.getColumnByName("V1"); 
    4443                assertEquals( 
    45                                 "Column[name=V1,columnNumber=26,type=DOUBLE,nullable=<null>,indexed=false,nativeType=N,columnSize=12]", 
     44                                "MutableColumn[name=V1,columnNumber=26,type=DOUBLE,nullable=<null>,indexed=false,nativeType=N,columnSize=12]", 
    4645                                column.toString()); 
    4746 
    4847                column = table.getColumnByName("V12"); 
    4948                assertEquals( 
    50                                 "Column[name=V12,columnNumber=37,type=DOUBLE,nullable=<null>,indexed=false,nativeType=N,columnSize=12]", 
     49                                "MutableColumn[name=V12,columnNumber=37,type=DOUBLE,nullable=<null>,indexed=false,nativeType=N,columnSize=12]", 
    5150                                column.toString()); 
    5251 
    5352                column = table.getColumnByName("A_NAME"); 
    5453                assertEquals( 
    55                                 "Column[name=A_NAME,columnNumber=25,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22]", 
     54                                "MutableColumn[name=A_NAME,columnNumber=25,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22]", 
    5655                                column.toString()); 
    5756        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dbase/DbaseDataContextStrategyReportTest.java

    r886 r887  
    77import org.eobjects.metamodel.data.DataSet; 
    88import org.eobjects.metamodel.data.Row; 
    9 import org.eobjects.metamodel.dbase.DbaseDataContextStrategy; 
    109import org.eobjects.metamodel.query.Query; 
    1110import org.eobjects.metamodel.query.SelectItem; 
    … …  
    1413import org.eobjects.metamodel.schema.Schema; 
    1514import org.eobjects.metamodel.schema.Table; 
    16  
    1715 
    1816public class DbaseDataContextStrategyReportTest extends TestCase { 
    … …  
    2624 
    2725                Schema schema = dc.getSchemaByName("report.dbf"); 
    28                 assertEquals("{Table[name=report,type=TABLE,remarks=<null>]}", 
     26                assertEquals("{MutableTable[name=report,type=TABLE,remarks=<null>]}", 
    2927                                ArrayUtils.toString(schema.getTables())); 
    3028 
    … …  
    3937                columns = table.getColumnsOfType(ColumnType.CHAR); 
    4038                assertEquals( 
    41                                 "{Column[name=R_INST,columnNumber=0,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=4],Column[name=R_NAME,columnNumber=1,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=R_TITLE,columnNumber=2,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=255],Column[name=R_SUBTIT,columnNumber=3,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=64],Column[name=CUS_CORP,columnNumber=4,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=CUS_NAME,columnNumber=5,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=CUS_TITL,columnNumber=6,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=CUS_SALU,columnNumber=7,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=CUS_AD1,columnNumber=8,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=CUS_AD2,columnNumber=9,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=CUS_AD3,columnNumber=10,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=CUS_CTY,columnNumber=11,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=CUS_ST,columnNumber=12,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=CUS_COU,columnNumber=13,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=CUS_ZIP,columnNumber=14,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=10],Column[name=CUS_PHON,columnNumber=15,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=CUS_FAX,columnNumber=16,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=CUS_OPHN,columnNumber=17,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=CUS_EMAI,columnNumber=18,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=AUT_CORP,columnNumber=19,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=AUT_NAME,columnNumber=20,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=AUT_TITL,columnNumber=21,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=AUT_SALU,columnNumber=22,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],Column[name=AUT_AD1,columnNumber=23,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=AUT_AD2,columnNumber=24,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=AUT_AD3,columnNumber=25,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],Column[name=AUT_CTY,columnNumber=26,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=AUT_ST,columnNumber=27,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=AUT_COU,columnNumber=28,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],Column[name=AUT_ZIP,columnNumber=29,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=10],Column[name=AUT_PHON,columnNumber=30,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=AUT_FAX,columnNumber=31,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=AUT_OPHN,columnNumber=32,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],Column[name=AUT_EMAI,columnNumber=33,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55]}", 
     39                                "{MutableColumn[name=R_INST,columnNumber=0,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=4],MutableColumn[name=R_NAME,columnNumber=1,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=R_TITLE,columnNumber=2,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=255],MutableColumn[name=R_SUBTIT,columnNumber=3,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=64],MutableColumn[name=CUS_CORP,columnNumber=4,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=CUS_NAME,columnNumber=5,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=CUS_TITL,columnNumber=6,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=CUS_SALU,columnNumber=7,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=CUS_AD1,columnNumber=8,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=CUS_AD2,columnNumber=9,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=CUS_AD3,columnNumber=10,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=CUS_CTY,columnNumber=11,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=CUS_ST,columnNumber=12,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=CUS_COU,columnNumber=13,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=CUS_ZIP,columnNumber=14,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=10],MutableColumn[name=CUS_PHON,columnNumber=15,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=CUS_FAX,columnNumber=16,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=CUS_OPHN,columnNumber=17,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=CUS_EMAI,columnNumber=18,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=AUT_CORP,columnNumber=19,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=AUT_NAME,columnNumber=20,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=AUT_TITL,columnNumber=21,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=AUT_SALU,columnNumber=22,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55],MutableColumn[name=AUT_AD1,columnNumber=23,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=AUT_AD2,columnNumber=24,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=AUT_AD3,columnNumber=25,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=33],MutableColumn[name=AUT_CTY,columnNumber=26,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=AUT_ST,columnNumber=27,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=AUT_COU,columnNumber=28,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=22],MutableColumn[name=AUT_ZIP,columnNumber=29,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=10],MutableColumn[name=AUT_PHON,columnNumber=30,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=AUT_FAX,columnNumber=31,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=AUT_OPHN,columnNumber=32,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=14],MutableColumn[name=AUT_EMAI,columnNumber=33,type=CHAR,nullable=<null>,indexed=false,nativeType=C,columnSize=55]}", 
    4240                                ArrayUtils.toString(columns)); 
    4341                assertEquals(columns.length, table.getColumnCount()); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/detect/ColumnTypeTransformerTest.java

    r886 r887  
    1818 
    1919import org.eobjects.metamodel.detect.ColumnTypeTransformer; 
    20 import org.eobjects.metamodel.schema.Column; 
     20import org.eobjects.metamodel.schema.MutableColumn; 
    2121import org.eobjects.metamodel.schema.ColumnType; 
    2222 
    … …  
    2626 
    2727        public void testIntegerAndDouble() throws Exception { 
    28                 Column column = new Column("foobar", ColumnType.VARCHAR); 
     28                MutableColumn column = new MutableColumn("foobar", ColumnType.VARCHAR); 
    2929                ColumnTypeTransformer transformer = new ColumnTypeTransformer(column); 
    3030                transformer.registerValue("20"); 
    … …  
    5353 
    5454        public void testBoolean() throws Exception { 
    55                 Column column = new Column("foobar", ColumnType.VARCHAR); 
     55                MutableColumn column = new MutableColumn("foobar", ColumnType.VARCHAR); 
    5656                ColumnTypeTransformer transformer = new ColumnTypeTransformer(column); 
    5757                transformer.registerValue("1"); 
    … …  
    7777 
    7878        public void testDate() throws Exception { 
    79                 Column column = new Column("foobar", ColumnType.VARCHAR); 
     79                MutableColumn column = new MutableColumn("foobar", ColumnType.VARCHAR); 
    8080                ColumnTypeTransformer transformer = new ColumnTypeTransformer(column); 
    8181                transformer.registerValue("2008-11-04"); 
    … …  
    8888 
    8989        public void testTime() throws Exception { 
    90                 Column column = new Column("foobar", ColumnType.VARCHAR); 
     90                MutableColumn column = new MutableColumn("foobar", ColumnType.VARCHAR); 
    9191                ColumnTypeTransformer transformer = new ColumnTypeTransformer(column); 
    9292                transformer.registerValue("02:20"); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dialects/AbstractQueryRewriterTest.java

    r886 r887  
    2424import org.eobjects.metamodel.query.Query; 
    2525import org.eobjects.metamodel.query.SelectItem; 
    26 import org.eobjects.metamodel.schema.Column; 
    27 import org.eobjects.metamodel.schema.Table; 
     26import org.eobjects.metamodel.schema.MutableColumn; 
     27import org.eobjects.metamodel.schema.MutableTable; 
    2828 
    2929import junit.framework.TestCase; 
    … …  
    3232 
    3333        public void testRewriteQuery() throws Exception { 
    34                 Query q = new Query().selectCount().from(new Table("foobar")).where( 
    35                                 new Column("foob"), OperatorType.EQUALS_TO, null).groupBy( 
    36                                 new Column("col1")).having( 
    37                                 new FilterItem(new SelectItem(new Column("col2")), 
     34                Query q = new Query().selectCount().from(new MutableTable("foobar")).where( 
     35                                new MutableColumn("foob"), OperatorType.EQUALS_TO, null).groupBy( 
     36                                new MutableColumn("col1")).having( 
     37                                new FilterItem(new SelectItem(new MutableColumn("col2")), 
    3838                                                OperatorType.HIGHER_THAN, 40)).orderBy( 
    39                                 new Column("bla")); 
     39                                new MutableColumn("bla")); 
    4040                assertEquals( 
    4141                                "SELECT COUNT(*) FROM foobar WHERE foob IS NULL GROUP BY col1 HAVING col2 > 40 ORDER BY bla ASC", 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dialects/MysqlQueryRewriterTest.java

    r886 r887  
    2020import org.eobjects.metamodel.dialects.MysqlQueryRewriter; 
    2121import org.eobjects.metamodel.query.Query; 
    22 import org.eobjects.metamodel.schema.Column; 
    23 import org.eobjects.metamodel.schema.Table; 
     22import org.eobjects.metamodel.schema.MutableColumn; 
     23import org.eobjects.metamodel.schema.MutableTable; 
    2424 
    2525 
    … …  
    2727 
    2828        public void testRewriteLimit() throws Exception { 
    29                 Query q = new Query().from(new Table("foo")).select(new Column("bar")) 
     29                Query q = new Query().from(new MutableTable("foo")).select(new MutableColumn("bar")) 
    3030                                .setMaxRows(25); 
    3131                String queryString = new MysqlQueryRewriter().rewriteQuery(null, q); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dialects/PostgresqlQueryRewriterTest.java

    r886 r887  
    2020import org.eobjects.metamodel.dialects.PostgresqlQueryRewriter; 
    2121import org.eobjects.metamodel.query.Query; 
    22 import org.eobjects.metamodel.schema.Column; 
    23 import org.eobjects.metamodel.schema.Schema; 
    24 import org.eobjects.metamodel.schema.Table; 
     22import org.eobjects.metamodel.schema.MutableColumn; 
     23import org.eobjects.metamodel.schema.MutableSchema; 
     24import org.eobjects.metamodel.schema.MutableTable; 
    2525 
    2626 
    … …  
    2828 
    2929        public void testRewriteLimit() throws Exception { 
    30                 Table table = new Table("foo"); 
    31                 table.setSchema(new Schema("MY_SCHEMA")); 
     30                MutableTable table = new MutableTable("foo"); 
     31                table.setSchema(new MutableSchema("MY_SCHEMA")); 
    3232                table.setQuote("\""); 
    33                 Column column = new Column("bar"); 
     33                MutableColumn column = new MutableColumn("bar"); 
    3434                column.setQuote("\""); 
    3535                column.setTable(table); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/dialects/SQLServerQueryRewriterTest.java

    r886 r887  
    44import org.eobjects.metamodel.dialects.SQLServerQueryRewriter; 
    55import org.eobjects.metamodel.query.Query; 
    6 import org.eobjects.metamodel.schema.Column; 
    7 import org.eobjects.metamodel.schema.Schema; 
    8 import org.eobjects.metamodel.schema.Table; 
     6import org.eobjects.metamodel.schema.MutableColumn; 
     7import org.eobjects.metamodel.schema.MutableSchema; 
     8import org.eobjects.metamodel.schema.MutableTable; 
    99 
    1010import junit.framework.TestCase; 
    … …  
    1313 
    1414        public void testAliasing() throws Exception { 
    15                 Table table = new Table("foo"); 
    16                 table.setSchema(new Schema("MY_SCHEMA")); 
     15                MutableTable table = new MutableTable("foo"); 
     16                table.setSchema(new MutableSchema("MY_SCHEMA")); 
    1717                table.setQuote("\""); 
    18                 Column column = new Column("bar"); 
     18                MutableColumn column = new MutableColumn("bar"); 
    1919                column.setQuote("\""); 
    2020                column.setTable(table); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/query/FilterItemTest.java

    r886 r887  
    2424import org.eobjects.metamodel.query.Query; 
    2525import org.eobjects.metamodel.query.SelectItem; 
    26 import org.eobjects.metamodel.schema.Column; 
     26import org.eobjects.metamodel.schema.MutableColumn; 
    2727import org.eobjects.metamodel.schema.ColumnType; 
    2828import org.joda.time.DateTime; 
    … …  
    4646                } 
    4747 
    48                 Column col1 = new Column("Col1", ColumnType.VARCHAR); 
     48                MutableColumn col1 = new MutableColumn("Col1", ColumnType.VARCHAR); 
    4949                assertEquals("SELECT Col1 WHERE foobar", new Query().select(col1) 
    5050                                .where(filterItem).toString()); 
    … …  
    5555 
    5656        public void testToSqlWhereItem() throws Exception { 
    57                 Column col1 = new Column("Col1", ColumnType.VARCHAR); 
     57                MutableColumn col1 = new MutableColumn("Col1", ColumnType.VARCHAR); 
    5858                SelectItem selectItem = new SelectItem(col1); 
    5959                FilterItem c = new FilterItem(selectItem, OperatorType.DIFFERENT_FROM, 
    … …  
    101101                assertEquals("Col1 = 1", c.toString()); 
    102102 
    103                 Column timeColumn = new Column("TimeCol", ColumnType.TIME); 
     103                MutableColumn timeColumn = new MutableColumn("TimeCol", ColumnType.TIME); 
    104104                selectItem = new SelectItem(timeColumn); 
    105105                c = new FilterItem(selectItem, OperatorType.HIGHER_THAN, new LocalTime( 
    … …  
    107107                assertEquals("TimeCol > TIME '02:30:05.000000'", c.toString()); 
    108108 
    109                 Column dateColumn = new Column("DateCol", ColumnType.DATE); 
     109                MutableColumn dateColumn = new MutableColumn("DateCol", ColumnType.DATE); 
    110110                c = new FilterItem(new SelectItem(dateColumn), 
    111111                                OperatorType.HIGHER_THAN, new LocalDate(2000, 12, 31)); 
    112112                assertEquals("DateCol > DATE '2000-12-31'", c.toString()); 
    113113 
    114                 Column timestampColumn = new Column("TimestampCol", 
     114                MutableColumn timestampColumn = new MutableColumn("TimestampCol", 
    115115                                ColumnType.TIMESTAMP); 
    116116                c = new FilterItem(new SelectItem(timestampColumn), 
    … …  
    126126 
    127127        public void testEvaluateStrings() throws Exception { 
    128                 Column col1 = new Column("Col1", ColumnType.VARCHAR); 
    129                 Column col2 = new Column("Col2", ColumnType.VARCHAR); 
     128                MutableColumn col1 = new MutableColumn("Col1", ColumnType.VARCHAR); 
     129                MutableColumn col2 = new MutableColumn("Col2", ColumnType.VARCHAR); 
    130130                SelectItem s1 = new SelectItem(col1); 
    131131                SelectItem s2 = new SelectItem(col2); 
    … …  
    158158 
    159159        public void testEvaluateNull() throws Exception { 
    160                 Column col1 = new Column("Col1", ColumnType.INTEGER); 
    161                 Column col2 = new Column("Col2", ColumnType.DECIMAL); 
     160                MutableColumn col1 = new MutableColumn("Col1", ColumnType.INTEGER); 
     161                MutableColumn col2 = new MutableColumn("Col2", ColumnType.DECIMAL); 
    162162                SelectItem s1 = new SelectItem(col1); 
    163163                SelectItem s2 = new SelectItem(col2); 
    … …  
    202202 
    203203        public void testEvaluateDates() throws Exception { 
    204                 Column col1 = new Column("Col1", ColumnType.DATE); 
     204                MutableColumn col1 = new MutableColumn("Col1", ColumnType.DATE); 
    205205                SelectItem s1 = new SelectItem(col1); 
    206206                SelectItem[] selectItems = new SelectItem[] { s1 }; 
    … …  
    222222 
    223223        public void testEvaluateBooleans() throws Exception { 
    224                 Column col1 = new Column("Col1", ColumnType.BIT); 
     224                MutableColumn col1 = new MutableColumn("Col1", ColumnType.BIT); 
    225225                SelectItem s1 = new SelectItem(col1); 
    226226                SelectItem[] selectItems = new SelectItem[] { s1 }; 
    … …  
    254254         */ 
    255255        public void testEqualsAndHashCode() throws Exception { 
    256                 Column col1 = new Column("Col1", ColumnType.BIT); 
     256                MutableColumn col1 = new MutableColumn("Col1", ColumnType.BIT); 
    257257 
    258258                FilterItem c1 = new FilterItem(new SelectItem(col1), 
    … …  
    268268                assertFalse(c1.hashCode() == c2.hashCode()); 
    269269 
    270                 Column col2 = new Column("Col2", ColumnType.VARBINARY); 
     270                MutableColumn col2 = new MutableColumn("Col2", ColumnType.VARBINARY); 
    271271                c2 = new FilterItem(new SelectItem(col2), OperatorType.EQUALS_TO, true); 
    272272                assertFalse(c1.equals(c2)); 
    … …  
    275275 
    276276        public void testOrFilterItem() throws Exception { 
    277                 Column col1 = new Column("Col1", ColumnType.VARCHAR); 
     277                MutableColumn col1 = new MutableColumn("Col1", ColumnType.VARCHAR); 
    278278 
    279279                SelectItem s1 = new SelectItem(col1); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/query/FromClauseTest.java

    r886 r887  
    1919import org.eobjects.metamodel.MetaModelTestCase; 
    2020import org.eobjects.metamodel.query.Query; 
     21import org.eobjects.metamodel.schema.Table; 
    2122import org.eobjects.metamodel.schema.Schema; 
    22 import org.eobjects.metamodel.schema.Table; 
    2323 
    2424 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/query/FromItemTest.java

    r886 r887  
    1818 
    1919import org.eobjects.metamodel.MetaModelTestCase; 
    20 import org.eobjects.metamodel.query.FromItem; 
    21 import org.eobjects.metamodel.query.JoinType; 
    22 import org.eobjects.metamodel.query.Query; 
    23 import org.eobjects.metamodel.query.SelectItem; 
    2420import org.eobjects.metamodel.schema.Column; 
    2521import org.eobjects.metamodel.schema.Relationship; 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/query/QueryTest.java

    r886 r887  
    1818 
    1919import org.eobjects.metamodel.MetaModelTestCase; 
    20 import org.eobjects.metamodel.query.FilterItem; 
    21 import org.eobjects.metamodel.query.FromItem; 
    22 import org.eobjects.metamodel.query.FunctionType; 
    23 import org.eobjects.metamodel.query.GroupByItem; 
    24 import org.eobjects.metamodel.query.JoinType; 
    25 import org.eobjects.metamodel.query.OperatorType; 
    26 import org.eobjects.metamodel.query.OrderByItem; 
    27 import org.eobjects.metamodel.query.Query; 
    28 import org.eobjects.metamodel.query.SelectClause; 
    29 import org.eobjects.metamodel.query.SelectItem; 
    3020import org.eobjects.metamodel.query.OrderByItem.Direction; 
    3121import org.eobjects.metamodel.schema.Column; 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/query/SelectItemTest.java

    r886 r887  
    2424import org.eobjects.metamodel.query.SelectItem; 
    2525import org.eobjects.metamodel.schema.Column; 
     26import org.eobjects.metamodel.schema.Table; 
    2627import org.eobjects.metamodel.schema.Schema; 
    27 import org.eobjects.metamodel.schema.Table; 
    28  
    2928 
    3029public class SelectItemTest extends MetaModelTestCase { 
    … …  
    3332 
    3433        public void testSubQuerySelectItem() throws Exception { 
    35                 Table projectTable = _schema.getTableByName(TABLE_PROJECT); 
     34                Table table = _schema.getTableByName(TABLE_PROJECT); 
    3635                Table roleTable = _schema.getTableByName(TABLE_ROLE); 
    3736 
    38                 Column projectIdColumn = projectTable 
     37                Column projectIdColumn = table 
    3938                                .getColumnByName(COLUMN_PROJECT_PROJECT_ID); 
    4039 
    41                 FromItem leftSide = new FromItem(projectTable); 
     40                FromItem leftSide = new FromItem(table); 
    4241                leftSide.setAlias("a"); 
    4342                SelectItem[] leftOn = new SelectItem[] { new SelectItem(projectIdColumn) }; 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/schema/ColumnTest.java

    r886 r887  
    1717package org.eobjects.metamodel.schema; 
    1818 
    19 import org.eobjects.metamodel.schema.Column; 
     19import org.eobjects.metamodel.schema.MutableColumn; 
    2020import org.eobjects.metamodel.schema.ColumnType; 
    21 import org.eobjects.metamodel.schema.Schema; 
    22 import org.eobjects.metamodel.schema.Table; 
     21import org.eobjects.metamodel.schema.MutableSchema; 
     22import org.eobjects.metamodel.schema.MutableTable; 
    2323 
    2424import junit.framework.TestCase; 
    … …  
    3434         */ 
    3535        public void testEqualsAndHashCode() throws Exception { 
    36                 Column column1 = new Column("foo"); 
    37                 Column column2 = new Column("foo"); 
     36                MutableColumn column1 = new MutableColumn("foo"); 
     37                MutableColumn column2 = new MutableColumn("foo"); 
    3838 
    3939                assertEquals(column1.hashCode(), column2.hashCode()); 
    4040                assertEquals(column1, column2); 
    4141 
    42                 column2 = new Column("bar"); 
     42                column2 = new MutableColumn("bar"); 
    4343                assertFalse(column1.equals(column2)); 
    4444 
    45                 column2 = new Column("foo", ColumnType.VARBINARY); 
     45                column2 = new MutableColumn("foo", ColumnType.VARBINARY); 
    4646                assertFalse(column1.equals(column2)); 
    4747 
    48                 column1 = new Column("foo", ColumnType.VARBINARY); 
     48                column1 = new MutableColumn("foo", ColumnType.VARBINARY); 
    4949                assertTrue(column1.equals(column2)); 
    5050        } 
    5151 
    5252        public void testQualifiedLabel() throws Exception { 
    53                 Schema s = new Schema("FOO_SCHEMA"); 
    54                 Table t = new Table("FOO_TABLE"); 
    55                 Column c = new Column("FOO_COLUMN"); 
     53                MutableSchema s = new MutableSchema("FOO_SCHEMA"); 
     54                MutableTable t = new MutableTable("FOO_TABLE"); 
     55                MutableColumn c = new MutableColumn("FOO_COLUMN"); 
    5656 
    5757                assertEquals("FOO_COLUMN", c.getQualifiedLabel()); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/schema/JdbcSchemaTest.java

    r886 r887  
    2929import org.eobjects.metamodel.MetaModelTestCase; 
    3030import org.eobjects.metamodel.schema.JdbcSchema; 
    31 import org.eobjects.metamodel.schema.Schema; 
    32 import org.eobjects.metamodel.schema.Table; 
    3331 
    3432 
    … …  
    8987 
    9088                assertEquals( 
    91                                 "{Relationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
     89                                "{ImmutableRelationship[primaryTable=PRODUCTS,primaryColumns={PRODUCTCODE},foreignTable=ORDERFACT,foreignColumns={PRODUCTCODE}]}", 
    9290                                ArrayUtils.toString(schema.getRelationships())); 
    9391        } 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/schema/SchemaModelTest.java

    r886 r887  
    1919import org.apache.commons.lang.ArrayUtils; 
    2020import org.eobjects.metamodel.MetaModelTestCase; 
    21 import org.eobjects.metamodel.schema.Column; 
    22 import org.eobjects.metamodel.schema.Relationship; 
    23 import org.eobjects.metamodel.schema.Schema; 
    24 import org.eobjects.metamodel.schema.Table; 
     21import org.eobjects.metamodel.schema.ImmutableRelationship; 
    2522import org.eobjects.metamodel.schema.TableType; 
    26  
    2723 
    2824public class SchemaModelTest extends MetaModelTestCase { 
    … …  
    3127                Schema schema = getExampleSchema(); 
    3228                assertEquals("MetaModelSchema", schema.getName()); 
    33                 assertEquals("Schema[name=MetaModelSchema]", schema.toString()); 
     29                assertEquals("MutableSchema[name=MetaModelSchema]", schema.toString()); 
    3430                assertEquals(5, schema.getRelationships().length); 
    3531 
    … …  
    7369 
    7470                assertEquals( 
    75                                 "Relationship[primaryTable=contributor,primaryColumns={name},foreignTable=project_contributor,foreignColumns={contributor}]", 
     71                                "ImmutableRelationship[primaryTable=contributor,primaryColumns={name},foreignTable=project_contributor,foreignColumns={contributor}]", 
    7672                                projectContributorToContributorRelations[0].toString()); 
    7773 
    78                 projectContributorToContributorRelations[0].remove(); 
     74                ImmutableRelationship.remove(projectContributorToContributorRelations[0]); 
    7975                projectContributorToContributorRelations = projectContributorView 
    8076                                .getRelationships(contributorTable); 
    … …  
    8682                // Get primary keys / Get foreign keys test 
    8783                assertEquals( 
    88                                 "{Column[name=contributor_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=<null>,columnSize=<null>]}", 
     84                                "{MutableColumn[name=contributor_id,columnNumber=0,type=INTEGER,nullable=false,indexed=true,nativeType=<null>,columnSize=<null>]}", 
    8985                                ArrayUtils.toString(contributorTable.getPrimaryKeys())); 
    9086                assertEquals("{}", ArrayUtils.toString(contributorTable 
    … …  
    9288 
    9389                assertEquals( 
    94                                 "{Column[name=name,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]}", 
     90                                "{MutableColumn[name=name,columnNumber=2,type=VARCHAR,nullable=false,indexed=false,nativeType=<null>,columnSize=<null>]}", 
    9591                                ArrayUtils.toString(roleTable.getPrimaryKeys())); 
    9692                Column[] foreignKeys = roleTable.getForeignKeys(); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/schema/SchemaTest.java

    r886 r887  
    1717package org.eobjects.metamodel.schema; 
    1818 
    19 import org.eobjects.metamodel.schema.Schema; 
    20 import org.eobjects.metamodel.schema.Table; 
     19import org.eobjects.metamodel.schema.MutableSchema; 
     20import org.eobjects.metamodel.schema.MutableTable; 
    2121 
    2222import junit.framework.TestCase; 
    … …  
    3232         */ 
    3333        public void testEqualsAndHashCode() throws Exception { 
    34                 Schema schema1 = new Schema("foo"); 
    35                 Schema schema2 = new Schema("foo"); 
     34                Schema schema1 = new MutableSchema("foo"); 
     35                MutableSchema schema2 = new MutableSchema("foo"); 
    3636 
    3737                assertTrue(schema1.equals(schema2)); 
    3838                assertTrue(schema1.hashCode() == schema2.hashCode()); 
    3939 
    40                 schema2.addTable(new Table("foo")); 
     40                schema2.addTable(new MutableTable("foo")); 
    4141                assertFalse(schema1.equals(schema2)); 
    4242                assertFalse(schema1.hashCode() == schema2.hashCode()); 
    4343 
    44                 schema2 = new Schema("foo"); 
     44                schema2 = new MutableSchema("foo"); 
    4545                assertTrue(schema1.equals(schema2)); 
    4646                assertTrue(schema1.hashCode() == schema2.hashCode()); 
    … …  
    4848 
    4949        public void testGetTableByName() throws Exception { 
    50                 Schema s = new Schema("foobar"); 
    51                 s.addTable(new Table("Foo")); 
    52                 s.addTable(new Table("FOO")); 
    53                 s.addTable(new Table("bar")); 
     50                MutableSchema s = new MutableSchema("foobar"); 
     51                s.addTable(new MutableTable("Foo")); 
     52                s.addTable(new MutableTable("FOO")); 
     53                s.addTable(new MutableTable("bar")); 
    5454 
    5555                assertEquals("Foo", s.getTableByName("Foo").getName()); 

  • MetadataBeans/trunk/src/test/java/org/eobjects/metamodel/schema/TableTest.java

    r886 r887  
    1818 
    1919import org.apache.commons.lang.ArrayUtils; 
    20 import org.eobjects.metamodel.schema.Column; 
    21 import org.eobjects.metamodel.schema.Table; 
     20import org.eobjects.metamodel.schema.MutableColumn; 
     21import org.eobjects.metamodel.schema.MutableTable; 
    2222 
    2323 
    … …  
    3434         */ 
    3535        public void testEqualsAndHashCode() throws Exception { 
    36                 Table table1 = new Table("Foo"); 
    37                 Table table2 = new Table("Foo"); 
     36                MutableTable table1 = new MutableTable("Foo"); 
     37                MutableTable table2 = new MutableTable("Foo"); 
    3838 
    3939                assertFalse(table2.equals(null)); 
    … …  
    4141                assertEquals(table1, table2); 
    4242 
    43                 table2.addColumn(new Column("bar")); 
     43                table2.addColumn(new MutableColumn("bar")); 
    4444                assertFalse(table1.equals(table2)); 
    4545                assertTrue(table1.hashCode() != table2.hashCode()); 
    … …  
    4747 
    4848        public void testGetIndexedColumns() throws Exception { 
    49                 Table t = new Table("foo"); 
    50                 t.addColumn(new Column("b").setIndexed(true)); 
    51                 t.addColumn(new Column("a").setIndexed(false)); 
    52                 t.addColumn(new Column("r").setIndexed(true)); 
     49                MutableTable t = new MutableTable("foo"); 
     50                t.addColumn(new MutableColumn("b").setIndexed(true)); 
     51                t.addColumn(new MutableColumn("a").setIndexed(false)); 
     52                t.addColumn(new MutableColumn("r").setIndexed(true)); 
    5353                Column[] indexedColumns = t.getIndexedColumns(); 
    5454                assertEquals( 
    55                                 "{Column[name=b,columnNumber=0,type=<null>,nullable=<null>,indexed=true,nativeType=<null>,columnSize=<null>],Column[name=r,columnNumber=0,type=<null>,nullable=<null>,indexed=true,nativeType=<null>,columnSize=<null>]}", 
     55                                "{MutableColumn[name=b,columnNumber=0,type=<null>,nullable=<null>,indexed=true,nativeType=<null>,columnSize=<null>]," + 
     56                                "MutableColumn[name=r,columnNumber=0,type=<null>,nullable=<null>,indexed=true,nativeType=<null>,columnSize=<null>]}", 
    5657                                ArrayUtils.toString(indexedColumns)); 
    5758        } 
    5859 
    5960        public void testGetColumnByName() throws Exception { 
    60                 Table t = new Table("foobar"); 
    61                 t.addColumn(new Column("Foo")); 
    62                 t.addColumn(new Column("FOO")); 
    63                 t.addColumn(new Column("bar")); 
     61                MutableTable t = new MutableTable("foobar"); 
     62                t.addColumn(new MutableColumn("Foo")); 
     63                t.addColumn(new MutableColumn("FOO")); 
     64                t.addColumn(new MutableColumn("bar")); 
    6465 
    6566                assertEquals("Foo", t.getColumnByName("Foo").getName()); 

  • MetadataBeans/trunk/src/test/resources/xml_input_eobjects.xml

    r882 r887  
    11<?xml version="1.0" encoding="UTF-8"?> 
    2 <eobjects.dk website="http://www.eobjects.dk"> 
     2<eobjects.org website="http://eobjects.org"> 
    33        <contributors> 
    44                <person> 
    … …  
    1717                <project name="MetaModel" /> 
    1818        </projects> 
    19 </eobjects.dk> 
     19</eobjects.org> 
Note: See TracChangeset for help on using the changeset viewer.