Changeset 888


Ignore:
Timestamp:
02/04/10 21:57:54 (2 years ago)
Author:
kasper
Message:
 
Location:
MetadataBeans/trunk/src
Files:
34 edited
4 moved

Legend:

Unmodified
Added
Removed

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

    r887 r888  
    4040                                        _database = Database.open(_file, true); 
    4141                                } catch (IOException e) { 
    42                                         throw new MetaModelException(e); 
     42                                        throw new MetadataBeansException(e); 
    4343                                } 
    4444                        } 
    … …  
    4848 
    4949        @Override 
    50         protected MutableSchema getMainSchema() throws MetaModelException { 
     50        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    5151                MutableSchema schema = new MutableSchema(_file.getName()); 
    5252                Database db = getDatabase(); 
    … …  
    7171                                schema.addTable(table); 
    7272                        } catch (Exception e) { 
    73                                 throw new MetaModelException(e); 
     73                                throw new MetadataBeansException(e); 
    7474                        } 
    7575                } 
    … …  
    7878 
    7979        @Override 
    80         protected String getMainSchemaName() throws MetaModelException { 
     80        protected String getMainSchemaName() throws MetadataBeansException { 
    8181                return _file.getName(); 
    8282        } 
    … …  
    108108                        return new DataSet(selectItems, data); 
    109109                } catch (Exception e) { 
    110                         throw new MetaModelException(e); 
     110                        throw new MetadataBeansException(e); 
    111111                } 
    112112        } 

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

    r887 r888  
    4141        } 
    4242 
    43         public DataSet executeQuery(Query query) throws MetaModelException { 
     43        public DataSet executeQuery(Query query) throws MetadataBeansException { 
    4444                Set<DataContext> dataContexts = new HashSet<DataContext>(); 
    4545                List<FromItem> items = query.getFromClause().getItems(); 
    4646                for (FromItem item : items) { 
    47                         List<FromItem> tableFromItems = MetaModelHelper 
     47                        List<FromItem> tableFromItems = MetadataBeansHelper 
    4848                                        .getTableFromItems(item); 
    4949                        for (FromItem fromItem : tableFromItems) { 
    … …  
    5656 
    5757                if (dataContexts.isEmpty()) { 
    58                         throw new MetaModelException( 
     58                        throw new MetadataBeansException( 
    5959                                        "No suiting delegate DataContext to execute query: " 
    6060                                                        + query); 
    … …  
    7676 
    7777                                @Override 
    78                                 protected String getMainSchemaName() throws MetaModelException { 
     78                                protected String getMainSchemaName() throws MetadataBeansException { 
    7979                                        throw new UnsupportedOperationException( 
    8080                                                        "Use CompositeDataContextStrategy for exploring the schema"); 
    … …  
    8383                                @Override 
    8484                                protected MutableSchema getMainSchema() 
    85                                                 throws MetaModelException { 
     85                                                throws MetadataBeansException { 
    8686                                        throw new UnsupportedOperationException( 
    8787                                                        "Use CompositeDataContextStrategy for exploring the schema"); 
    … …  
    112112        } 
    113113 
    114         public String getDefaultSchemaName() throws MetaModelException { 
     114        public String getDefaultSchemaName() throws MetadataBeansException { 
    115115                for (DataContext dc : _delegates) { 
    116116                        Schema schema = dc.getDefaultSchema(); 
    … …  
    122122        } 
    123123 
    124         public Schema getSchemaByName(String name) throws MetaModelException { 
     124        public Schema getSchemaByName(String name) throws MetadataBeansException { 
    125125                CompositeSchema compositeSchema = _compositeSchemas.get(name); 
    126126                if (compositeSchema != null) { 
    … …  
    149149        } 
    150150 
    151         public String[] getSchemaNames() throws MetaModelException { 
     151        public String[] getSchemaNames() throws MetadataBeansException { 
    152152                Set<String> set = new HashSet<String>(); 
    153153                for (DataContext dc : _delegates) { 

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

    r887 r888  
    157157 
    158158        @Override 
    159         protected MutableSchema getMainSchema() throws MetaModelException { 
     159        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    160160                CSVReader reader = null; 
    161161                try { 

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

    r886 r888  
    3939        } 
    4040 
    41         public Row getRow() throws MetaModelException { 
     41        public Row getRow() throws MetadataBeansException { 
    4242                return _row; 
    4343        } 

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

    r886 r888  
    6565         *         many situations so if you want to update the schemas, use the 
    6666         *         refreshSchemas() method. 
    67          * @throws MetaModelException 
     67         * @throws MetadataBeansException 
    6868         *             if an error occurs retrieving the schema model 
    6969         */ 
    70         public Schema[] getSchemas() throws MetaModelException { 
     70        public Schema[] getSchemas() throws MetadataBeansException { 
    7171                String[] schemaNames = getSchemaNames(); 
    7272                for (int i = 0; i < schemaNames.length; i++) { 
    … …  
    8383        /** 
    8484         * @return an array of valid schema names 
    85          * @throws MetaModelException 
     85         * @throws MetadataBeansException 
    8686         *             if an error occurs retrieving the schema model 
    8787         */ 
    88         public String[] getSchemaNames() throws MetaModelException { 
     88        public String[] getSchemaNames() throws MetadataBeansException { 
    8989                if (_schemaNames == null) { 
    9090                        _schemaNames = _strategy.getSchemaNames(); 
    … …  
    9999         *         single available schema and in that case this will of course be 
    100100         *         the schema returned. 
    101          * @throws MetaModelException 
     101         * @throws MetadataBeansException 
    102102         *             if an error occurs retrieving the schema model 
    103103         */ 
    104         public Schema getDefaultSchema() throws MetaModelException { 
     104        public Schema getDefaultSchema() throws MetadataBeansException { 
    105105                Schema result = null; 
    106106                String defaultSchemaName = _strategy.getDefaultSchemaName(); 
    … …  
    133133         * @return the Schema with the specified name or null if no such schema 
    134134         *         exists 
    135          * @throws MetaModelException 
     135         * @throws MetadataBeansException 
    136136         *             if an error occurs retrieving the schema model 
    137137         */ 
    138         public Schema getSchemaByName(String name) throws MetaModelException { 
     138        public Schema getSchemaByName(String name) throws MetadataBeansException { 
    139139                Schema schema = _schemas.get(name); 
    140140                if (schema != null) { 
    … …  
    158158         *            the query object to execute 
    159159         * @return the dataset produced from executing the query 
    160          * @throws MetaModelException 
     160         * @throws MetadataBeansException 
    161161         *             if the specified query does not make sense or cannot be 
    162162         *             executed because of restraints on the type of datastore. 
    163163         */ 
    164         public DataSet executeQuery(Query query) throws MetaModelException { 
     164        public DataSet executeQuery(Query query) throws MetadataBeansException { 
    165165                DataSet dataSet = _strategy.executeQuery(query); 
    166166                return dataSet; 

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

    r887 r888  
    120120 
    121121        @Override 
    122         protected String getMainSchemaName() throws MetaModelException { 
     122        protected String getMainSchemaName() throws MetadataBeansException { 
    123123                return _file.getName(); 
    124124        } 
    125125 
    126         protected MutableSchema getMainSchema() throws MetaModelException { 
     126        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    127127                InputStream in = null; 
    128128                MutableSchema schema = null; 

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

    r886 r888  
    3030         *         if none is present or possible to deterministically tell. 
    3131         */ 
    32         public String getDefaultSchemaName() throws MetaModelException; 
     32        public String getDefaultSchemaName() throws MetadataBeansException; 
    3333 
    3434        /** 
    … …  
    3838         * @return a dataset representing the result of the query. 
    3939         */ 
    40         public DataSet executeQuery(Query query) throws MetaModelException; 
     40        public DataSet executeQuery(Query query) throws MetadataBeansException; 
    4141 
    4242        /** 
    4343         * @return an array of schema names within this datastore. 
    4444         */ 
    45         public String[] getSchemaNames() throws MetaModelException; 
     45        public String[] getSchemaNames() throws MetadataBeansException; 
    4646 
    4747        /** 
    … …  
    5050         *         not available 
    5151         */ 
    52         public Schema getSchemaByName(String name) throws MetaModelException; 
     52        public Schema getSchemaByName(String name) throws MetadataBeansException; 
    5353 
    5454} 

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

    r887 r888  
    430430        } 
    431431 
    432         public DataSet executeQuery(Query query) throws MetaModelException { 
     432        public DataSet executeQuery(Query query) throws MetadataBeansException { 
    433433                Statement statement = null; 
    434434                ResultSet resultSet = null; 
    … …  
    484484                                return failoverStrategy.executeQuery(query); 
    485485                        } else { 
    486                                 throw new MetaModelException("Could not execute query", e); 
     486                                throw new MetadataBeansException("Could not execute query", e); 
    487487                        } 
    488488                } 
    … …  
    551551                                } catch (SQLException e) { 
    552552                                        close(resultSet, statement); 
    553                                         throw new MetaModelException(e); 
     553                                        throw new MetadataBeansException(e); 
    554554                                } 
    555555                        } 
    556556 
    557557                        @Override 
    558                         protected MutableSchema getMainSchema() throws MetaModelException { 
     558                        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    559559                                return JdbcDataContextStrategy.this 
    560560                                                .getSchemaByName(getMainSchemaName()); 
    … …  
    562562 
    563563                        @Override 
    564                         protected String getMainSchemaName() throws MetaModelException { 
     564                        protected String getMainSchemaName() throws MetadataBeansException { 
    565565                                return JdbcDataContextStrategy.this.getDefaultSchemaName(); 
    566566                        } 
    … …  
    606606                } catch (SQLException e) { 
    607607                        _log.error("Error retrieving metadata", e); 
    608                         throw new MetaModelException(e); 
     608                        throw new MetadataBeansException(e); 
    609609                } 
    610610 
    … …  
    639639                        return _dataSource.getConnection(); 
    640640                } catch (SQLException e) { 
    641                         throw new MetaModelException("Could not establish connection", e); 
     641                        throw new MetadataBeansException("Could not establish connection", e); 
    642642                } 
    643643        } 
    … …  
    735735        } 
    736736 
    737         public MutableSchema getSchemaByName(String name) throws MetaModelException { 
     737        public MutableSchema getSchemaByName(String name) throws MetadataBeansException { 
    738738                DatabaseMetaData metaData; 
    739739                try { 
    740740                        metaData = getConnection().getMetaData(); 
    741741                } catch (SQLException e) { 
    742                         throw new MetaModelException(e); 
     742                        throw new MetadataBeansException(e); 
    743743                } 
    744744                JdbcSchema schema = new JdbcSchema(name, this); 
    … …  
    751751        } 
    752752 
    753         public String[] getSchemaNames() throws MetaModelException { 
     753        public String[] getSchemaNames() throws MetadataBeansException { 
    754754                try { 
    755755                        DatabaseMetaData metaData = getConnection().getMetaData(); 
    … …  
    786786                        return result.toArray(new String[result.size()]); 
    787787                } catch (SQLException e) { 
    788                         throw new MetaModelException(e); 
     788                        throw new MetadataBeansException(e); 
    789789                } 
    790790        } 

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

    r886 r888  
    2424 * schema. 
    2525 */ 
    26 public class MetaModelException extends RuntimeException { 
     26public class MetadataBeansException extends RuntimeException { 
    2727 
    2828        private static final long serialVersionUID = 5455738384633428319L; 
    2929 
    30         public MetaModelException(String message, Exception cause) { 
     30        public MetadataBeansException(String message, Exception cause) { 
    3131                super(message, cause); 
    3232        } 
    3333 
    34         public MetaModelException(String message) { 
     34        public MetadataBeansException(String message) { 
    3535                super(message); 
    3636        } 
    3737 
    38         public MetaModelException(Exception cause) { 
     38        public MetadataBeansException(Exception cause) { 
    3939                super(cause); 
    4040        } 

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

    r887 r888  
    5454 * </ul> 
    5555 */ 
    56 public class MetaModelHelper { 
    57  
    58         private static final Log _log = LogFactory.getLog(MetaModelHelper.class); 
     56public class MetadataBeansHelper { 
     57 
     58        private static final Log _log = LogFactory.getLog(MetadataBeansHelper.class); 
    5959 
    6060        // Prevent instantiation 
    61         private MetaModelHelper() { 
     61        private MetadataBeansHelper() { 
    6262        } 
    6363 
    … …  
    566566         *            the query to execute 
    567567         * @return a row object representing the single row returned from the query 
    568          * @throws MetaModelException 
     568         * @throws MetadataBeansException 
    569569         *             if less or more than one Row is returned from the query 
    570570         */ 
    571571        public static Row executeSingleRowQuery(DataContext dataContext, Query query) 
    572                         throws MetaModelException { 
     572                        throws MetadataBeansException { 
    573573                DataSet dataSet = dataContext.executeQuery(query); 
    574574                boolean next = dataSet.next(); 
    575575                if (!next) { 
    576                         throw new MetaModelException("No rows returned from query: " 
     576                        throw new MetadataBeansException("No rows returned from query: " 
    577577                                        + query); 
    578578                } 
    … …  
    580580                next = dataSet.next(); 
    581581                if (next) { 
    582                         throw new MetaModelException( 
     582                        throw new MetadataBeansException( 
    583583                                        "More than one row returned from query: " + query); 
    584584                } 

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

    r886 r888  
    4343        private Connection _connection; 
    4444 
    45         public OpenOfficeDataContextStrategy(File dbFile) throws MetaModelException { 
     45        public OpenOfficeDataContextStrategy(File dbFile) throws MetadataBeansException { 
    4646                try { 
    4747                        String databaseName = dbFile.getName(); 
    … …  
    9090                                        JdbcDataContextFactory.DEFAULT_TABLE_TYPES, null); 
    9191                } catch (Exception e) { 
    92                         throw new MetaModelException(e); 
     92                        throw new MetadataBeansException(e); 
    9393                } 
    9494        } 
    9595 
    96         public DataSet executeQuery(Query query) throws MetaModelException { 
     96        public DataSet executeQuery(Query query) throws MetadataBeansException { 
    9797                return _strategy.executeQuery(query); 
    9898        } 
    9999 
    100         public String getDefaultSchemaName() throws MetaModelException { 
     100        public String getDefaultSchemaName() throws MetadataBeansException { 
    101101                return _strategy.getDefaultSchemaName(); 
    102102        } 
    103103 
    104         public Schema getSchemaByName(String name) throws MetaModelException { 
     104        public Schema getSchemaByName(String name) throws MetadataBeansException { 
    105105                return _strategy.getSchemaByName(name); 
    106106        } 
    107107 
    108         public String[] getSchemaNames() throws MetaModelException { 
     108        public String[] getSchemaNames() throws MetadataBeansException { 
    109109                return _strategy.getSchemaNames(); 
    110110        } 

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

    r887 r888  
    110110                                DataSet dataSet = materializeTable(table, columns, query 
    111111                                                .getMaxRows()); 
    112                                 dataSet = MetaModelHelper.getSelection(selectItems, dataSet); 
     112                                dataSet = MetadataBeansHelper.getSelection(selectItems, dataSet); 
    113113                                return dataSet; 
    114114                        } 
    … …  
    128128 
    129129                // Execute the query using the raw data 
    130                 DataSet dataSet = MetaModelHelper.getCarthesianProduct(fromDataSets, 
     130                DataSet dataSet = MetadataBeansHelper.getCarthesianProduct(fromDataSets, 
    131131                                whereItems); 
    132132                if (groupByItems.size() > 0) { 
    133                         dataSet = MetaModelHelper.getGrouped(workSelectItems, dataSet, 
     133                        dataSet = MetadataBeansHelper.getGrouped(workSelectItems, dataSet, 
    134134                                        groupByItems); 
    135135                } else { 
    136                         dataSet = MetaModelHelper.getAggregated(workSelectItems, dataSet); 
    137                 } 
    138                 dataSet = MetaModelHelper.getFiltered(dataSet, havingItems); 
     136                        dataSet = MetadataBeansHelper.getAggregated(workSelectItems, dataSet); 
     137                } 
     138                dataSet = MetadataBeansHelper.getFiltered(dataSet, havingItems); 
    139139 
    140140                if (query.getSelectClause().isDistinct()) { 
    141                         dataSet = MetaModelHelper.getSelection(selectItems, dataSet); 
    142                         dataSet = MetaModelHelper.getDistinct(dataSet); 
    143                         dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems); 
     141                        dataSet = MetadataBeansHelper.getSelection(selectItems, dataSet); 
     142                        dataSet = MetadataBeansHelper.getDistinct(dataSet); 
     143                        dataSet = MetadataBeansHelper.getOrdered(dataSet, orderByItems); 
    144144                } else { 
    145                         dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems); 
    146                         dataSet = MetaModelHelper.getSelection(selectItems, dataSet); 
     145                        dataSet = MetadataBeansHelper.getOrdered(dataSet, orderByItems); 
     146                        dataSet = MetadataBeansHelper.getSelection(selectItems, dataSet); 
    147147                } 
    148148 
    … …  
    160160        public QueryPostprocessDataContextStrategy transformColumnTypes( 
    161161                        Column... columns) { 
    162                 Table[] tables = MetaModelHelper.getTables(columns); 
     162                Table[] tables = MetadataBeansHelper.getTables(columns); 
    163163                for (Table table : tables) { 
    164                         Column[] columnsToQuery = MetaModelHelper.getTableColumns(table, 
     164                        Column[] columnsToQuery = MetadataBeansHelper.getTableColumns(table, 
    165165                                        columns); 
    166                         columnsToQuery = MetaModelHelper.getColumnsByType(columnsToQuery, 
     166                        columnsToQuery = MetadataBeansHelper.getColumnsByType(columnsToQuery, 
    167167                                        ColumnType.VARCHAR); 
    168168                        DataSet dataSet = executeQuery(new Query().select(columnsToQuery) 
    … …  
    264264                        } 
    265265                        if (joinType == JoinType.INNER) { 
    266                                 dataSet = MetaModelHelper.getCarthesianProduct( 
     266                                dataSet = MetadataBeansHelper.getCarthesianProduct( 
    267267                                                fromItemDataSets, onConditions); 
    268268                        } else if (joinType == JoinType.LEFT) { 
    269                                 dataSet = MetaModelHelper.getLeftJoin(fromItemDataSets[0], 
     269                                dataSet = MetadataBeansHelper.getLeftJoin(fromItemDataSets[0], 
    270270                                                fromItemDataSets[1], onConditions); 
    271271                        } else if (joinType == JoinType.RIGHT) { 
    272                                 dataSet = MetaModelHelper.getRightJoin(fromItemDataSets[0], 
     272                                dataSet = MetadataBeansHelper.getRightJoin(fromItemDataSets[0], 
    273273                                                fromItemDataSets[1], onConditions); 
    274274                        } else { 
    … …  
    332332        } 
    333333 
    334         public String[] getSchemaNames() throws MetaModelException { 
     334        public String[] getSchemaNames() throws MetadataBeansException { 
    335335                if (_schemaNames == null) { 
    336336                        _schemaNames = new String[2]; 
    … …  
    341341        } 
    342342 
    343         public String getDefaultSchemaName() throws MetaModelException { 
     343        public String getDefaultSchemaName() throws MetadataBeansException { 
    344344                return getSchemaNames()[1]; 
    345345        } 
    346346 
    347         public Schema getSchemaByName(String name) throws MetaModelException { 
     347        public Schema getSchemaByName(String name) throws MetadataBeansException { 
    348348                if (name != null) { 
    349349                        if (name.equals(getSchemaNames()[1])) { 
    … …  
    438438                        } 
    439439 
    440                         dataSet = new DataSet(MetaModelHelper.createSelectItems(table 
     440                        dataSet = new DataSet(MetadataBeansHelper.createSelectItems(table 
    441441                                        .getColumns()), data); 
    442442                } else if ("columns".equals(tableName)) { 
    … …  
    456456                                } 
    457457                        } 
    458                         dataSet = new DataSet(MetaModelHelper.createSelectItems(table 
     458                        dataSet = new DataSet(MetadataBeansHelper.createSelectItems(table 
    459459                                        .getColumns()), data); 
    460460                } else if ("relationships".equals(tableName)) { 
    … …  
    475475                                } 
    476476                        } 
    477                         dataSet = new DataSet(MetaModelHelper.createSelectItems(table 
     477                        dataSet = new DataSet(MetadataBeansHelper.createSelectItems(table 
    478478                                        .getColumns()), data); 
    479479                } else { 
    … …  
    483483 
    484484                // Handle column subset 
    485                 dataSet = MetaModelHelper.getSelection(MetaModelHelper 
     485                dataSet = MetadataBeansHelper.getSelection(MetadataBeansHelper 
    486486                                .createSelectItems(columns), dataSet); 
    487487 
    … …  
    504504         * @return the main schema that subclasses of this class produce 
    505505         */ 
    506         protected abstract Schema getMainSchema() throws MetaModelException; 
     506        protected abstract Schema getMainSchema() throws MetadataBeansException; 
    507507 
    508508        /** 
    509509         * @return the name of the main schema that subclasses of this class produce 
    510510         */ 
    511         protected abstract String getMainSchemaName() throws MetaModelException; 
     511        protected abstract String getMainSchemaName() throws MetadataBeansException; 
    512512 
    513513        /** 

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

    r887 r888  
    141141                SelectItem minItem = new SelectItem(FunctionType.MIN, column); 
    142142                Query q = new Query().from(column.getTable()).select(maxItem, minItem); 
    143                 Row row = MetaModelHelper.executeSingleRowQuery(_dataContext, q); 
     143                Row row = MetadataBeansHelper.executeSingleRowQuery(_dataContext, q); 
    144144                long max = ceil((Number) row.getValue(maxItem)); 
    145145                long min = floor((Number) row.getValue(minItem)); 
    … …  
    322322                        q.select(countAllItem); 
    323323                } 
    324                 Row row = MetaModelHelper.executeSingleRowQuery(_dataContext, q); 
     324                Row row = MetadataBeansHelper.executeSingleRowQuery(_dataContext, q); 
    325325                Number count = (Number) row.getValue(countAllItem); 
    326326                return count.longValue(); 

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

    r887 r888  
    192192 
    193193        @Override 
    194         protected String getMainSchemaName() throws MetaModelException { 
     194        protected String getMainSchemaName() throws MetadataBeansException { 
    195195                return _schemaName; 
    196196        } 
    197197 
    198198        @Override 
    199         protected MutableSchema getMainSchema() throws MetaModelException { 
     199        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    200200                loadSchema(); 
    201201                return _schema; 
    … …  
    225225                                loadSchema(document); 
    226226                        } catch (Exception e) { 
    227                                 throw new MetaModelException("Error parsing XML file: " 
     227                                throw new MetadataBeansException("Error parsing XML file: " 
    228228                                                + e.getMessage(), e); 
    229229                        } 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/data/JdbcDataSetStrategy.java

    r886 r888  
    2424import org.apache.commons.logging.Log; 
    2525import org.apache.commons.logging.LogFactory; 
    26 import org.eobjects.metamodel.MetaModelException; 
     26import org.eobjects.metamodel.MetadataBeansException; 
    2727import org.eobjects.metamodel.query.Query; 
    2828import org.eobjects.metamodel.query.SelectItem; 
    … …  
    6363        } 
    6464 
    65         public boolean next() throws MetaModelException { 
     65        public boolean next() throws MetadataBeansException { 
    6666                try { 
    6767                        boolean result = _resultSet.next(); 

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/data/SplitQueriesDataSetStrategy.java

    r886 r888  
    2323import org.apache.commons.logging.LogFactory; 
    2424import org.eobjects.metamodel.DataContext; 
    25 import org.eobjects.metamodel.MetaModelException; 
     25import org.eobjects.metamodel.MetadataBeansException; 
    2626import org.eobjects.metamodel.query.Query; 
    2727import org.eobjects.metamodel.query.SelectItem; 
    … …  
    7070        } 
    7171 
    72         public Row getRow() throws MetaModelException { 
     72        public Row getRow() throws MetadataBeansException { 
    7373                if (_currentDataSet != null) { 
    7474                        return _currentDataSet.getRow(); 

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

    r887 r888  
    2121import java.util.List; 
    2222 
    23 import org.eobjects.metamodel.MetaModelException; 
     23import org.eobjects.metamodel.MetadataBeansException; 
    2424import org.eobjects.metamodel.QueryPostprocessDataContextStrategy; 
    2525import org.eobjects.metamodel.data.DataSet; 
    … …  
    6565                                                dbf = new DBF(filename); 
    6666                                        } catch (Exception e) { 
    67                                                 throw new MetaModelException("Could not open DBF file"); 
     67                                                throw new MetadataBeansException("Could not open DBF file"); 
    6868                                        } 
    6969                                } 
    … …  
    7474 
    7575        @Override 
    76         protected Schema getMainSchema() throws MetaModelException { 
     76        protected Schema getMainSchema() throws MetadataBeansException { 
    7777                DBF dbf = getDbf(); 
    7878 
    … …  
    122122 
    123123                        } catch (Exception e) { 
    124                                 throw new MetaModelException("Could not retrieve DBF field", e); 
     124                                throw new MetadataBeansException("Could not retrieve DBF field", e); 
    125125                        } 
    126126                } 
    … …  
    130130 
    131131        @Override 
    132         protected String getMainSchemaName() throws MetaModelException { 
     132        protected String getMainSchemaName() throws MetadataBeansException { 
    133133                return getMainSchema().getName(); 
    134134        } 
    … …  
    143143                                dbf.gotoRecord(1); 
    144144                        } catch (Exception e) { 
    145                                 throw new MetaModelException(e); 
     145                                throw new MetadataBeansException(e); 
    146146                        } 
    147147 
    … …  
    158158                                        rowValues.add(values); 
    159159                                } catch (Exception e) { 
    160                                         throw new MetaModelException(e); 
     160                                        throw new MetadataBeansException(e); 
    161161                                } 
    162162 
    … …  
    168168                                                break; 
    169169                                        } 
    170                                         throw new MetaModelException(e); 
     170                                        throw new MetadataBeansException(e); 
    171171                                } 
    172172                        } 

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

    r887 r888  
    2929import org.apache.commons.lang.builder.ToStringBuilder; 
    3030import org.apache.commons.lang.builder.ToStringStyle; 
    31 import org.eobjects.metamodel.MetaModelHelper; 
     31import org.eobjects.metamodel.MetadataBeansHelper; 
    3232 
    3333public class MutableTable implements Serializable, Comparable<Table>, Table { 
    … …  
    445445        public Column[] getColumnsOfType(ColumnType columnType) { 
    446446                Column[] columns = getColumns(); 
    447                 return MetaModelHelper.getColumnsByType(columns, columnType); 
     447                return MetadataBeansHelper.getColumnsByType(columns, columnType); 
    448448        } 
    449449} 

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

    r887 r888  
    1414 
    1515 
    16 public class CompositeDataContextStrategyTest extends MetaModelTestCase { 
     16public class CompositeDataContextStrategyTest extends MetadataBeansTestCase { 
    1717 
    1818        /** 

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

    r887 r888  
    3636import org.eobjects.metamodel.schema.Table; 
    3737 
    38 public class CsvDataContextStrategyTest extends MetaModelTestCase { 
     38public class CsvDataContextStrategyTest extends MetadataBeansTestCase { 
    3939 
    4040        /** 

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

    r887 r888  
    128128                assertEquals(2996, tableModel.getRowCount()); 
    129129 
    130                 assertEquals(110, MetaModelHelper.executeSingleRowQuery(dc, 
     130                assertEquals(110, MetadataBeansHelper.executeSingleRowQuery(dc, 
    131131                                new Query().selectCount().from(productsTable)).getValue(0)); 
    132132        } 

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

    r887 r888  
    4444 
    4545 
    46 public class JdbcDataContextStrategyTest extends MetaModelTestCase { 
     46public class JdbcDataContextStrategyTest extends MetadataBeansTestCase { 
    4747 
    4848        public void testGetDefaultSchema() throws Exception { 
    … …  
    358358 
    359359                                        @Override 
    360                                         protected MutableSchema getMainSchema() throws MetaModelException { 
     360                                        protected MutableSchema getMainSchema() throws MetadataBeansException { 
    361361                                                return schema; 
    362362                                        } 
    … …  
    364364                                        @Override 
    365365                                        protected String getMainSchemaName() 
    366                                                         throws MetaModelException { 
     366                                                        throws MetadataBeansException { 
    367367                                                return "PUBLIC"; 
    368368                                        } 

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

    r887 r888  
    3737 
    3838 
    39 public class MetaModelHelperTest extends MetaModelTestCase { 
     39public class MetadataBeansHelperTest extends MetadataBeansTestCase { 
    4040 
    4141        public void testLeftJoin() throws Exception { 
    … …  
    7272                onConditions[0] = new FilterItem(si4, OperatorType.EQUALS_TO, si5); 
    7373 
    74                 DataSet result = MetaModelHelper.getLeftJoin(ds1, ds2, onConditions); 
     74                DataSet result = MetadataBeansHelper.getLeftJoin(ds1, ds2, onConditions); 
    7575                List<Object[]> objectArrays = result.toObjectArrays(); 
    7676                assertEquals("{1,peter,18,1,1,class president,clpr}", ArrayUtils 
    … …  
    119119                onConditions[0] = new FilterItem(si4, OperatorType.EQUALS_TO, si5); 
    120120 
    121                 DataSet result = MetaModelHelper.getRightJoin(ds1, ds2, onConditions); 
     121                DataSet result = MetadataBeansHelper.getRightJoin(ds1, ds2, onConditions); 
    122122                List<Object[]> objectArrays = result.toObjectArrays(); 
    123123                assertEquals("{1,peter,18,1,1,class president,clpr}", ArrayUtils 
    … …  
    131131 
    132132        public void testSimpleCarthesianProduct() throws Exception { 
    133                 DataSet dataSet = MetaModelHelper.getCarthesianProduct( 
     133                DataSet dataSet = MetadataBeansHelper.getCarthesianProduct( 
    134134                                createDataSet1(), createDataSet2()); 
    135135 
    … …  
    151151 
    152152        public void testTripleCarthesianProduct() throws Exception { 
    153                 DataSet dataSet = MetaModelHelper.getCarthesianProduct( 
     153                DataSet dataSet = MetadataBeansHelper.getCarthesianProduct( 
    154154                                createDataSet1(), createDataSet2(), createDataSet3()); 
    155155                assertEquals(4, dataSet.getSelectItems().length); 
    … …  
    166166                FilterItem w1 = new FilterItem(ds1.getSelectItems()[0], 
    167167                                OperatorType.EQUALS_TO, "f"); 
    168                 DataSet dataSet = MetaModelHelper.getCarthesianProduct(dataSets, w1); 
     168                DataSet dataSet = MetadataBeansHelper.getCarthesianProduct(dataSets, w1); 
    169169                assertEquals(2, dataSet.getSelectItems().length); 
    170170                for (int i = 0; i < 1 * 3; i++) { 
    … …  
    176176 
    177177        public void testGetCarthesianProductNoRows() throws Exception { 
    178                 DataSet dataSet = MetaModelHelper.getCarthesianProduct( 
     178                DataSet dataSet = MetadataBeansHelper.getCarthesianProduct( 
    179179                                createDataSet4(), createDataSet2(), createDataSet3()); 
    180180                assertEquals(4, dataSet.getSelectItems().length); 
    181181                assertFalse(dataSet.next()); 
    182182 
    183                 dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), 
     183                dataSet = MetadataBeansHelper.getCarthesianProduct(createDataSet1(), 
    184184                                createDataSet4(), createDataSet3()); 
    185185                assertEquals(4, dataSet.getSelectItems().length); 
    186186                assertFalse(dataSet.next()); 
    187187 
    188                 dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), 
     188                dataSet = MetadataBeansHelper.getCarthesianProduct(createDataSet1(), 
    189189                                createDataSet2(), createDataSet4()); 
    190190                assertEquals(3, dataSet.getSelectItems().length); 
    … …  
    197197                orderByItems.add(new OrderByItem(dataSet.getSelectItems()[0])); 
    198198 
    199                 dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems); 
     199                dataSet = MetadataBeansHelper.getOrdered(dataSet, orderByItems); 
    200200                assertTrue(dataSet.next()); 
    201201                assertEquals("Row[values={w00p,true}]", dataSet.getRow().toString()); 
    … …  
    261261                columnList.add(t2column1); 
    262262 
    263                 Table[] tables = MetaModelHelper.getTables(tableList, columnList); 
     263                Table[] tables = MetadataBeansHelper.getTables(tableList, columnList); 
    264264                assertEquals(2, tables.length); 
    265265                assertTrue(ArrayUtils.indexOf(tables, table1) != -1); 
    … …  
    281281                ArrayList<Column> columnList = new ArrayList<Column>(); 
    282282 
    283                 Column[] columns = MetaModelHelper.getTableColumns(table1, columnList); 
     283                Column[] columns = MetadataBeansHelper.getTableColumns(table1, columnList); 
    284284                assertEquals(0, columns.length); 
    285285 
    … …  
    287287                columnList.add(column3); 
    288288 
    289                 columns = MetaModelHelper.getTableColumns(table1, columnList); 
     289                columns = MetadataBeansHelper.getTableColumns(table1, columnList); 
    290290                assertEquals(2, columns.length); 
    291291                assertSame(column1, columns[0]); 
    … …  
    307307                Query q = new Query().from(fromItem); 
    308308 
    309                 FromItem[] fromItems = MetaModelHelper.getTableFromItems(q); 
     309                FromItem[] fromItems = MetadataBeansHelper.getTableFromItems(q); 
    310310                assertEquals(3, fromItems.length); 
    311311                assertEquals( 

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

    r887 r888  
    4141 * Convenient super-class to use for unittesting 
    4242 */ 
    43 public abstract class MetaModelTestCase extends TestCase { 
     43public abstract class MetadataBeansTestCase extends TestCase { 
    4444 
    4545        public static final String COLUMN_CONTRIBUTOR_COUNTRY = "country"; 

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

    r887 r888  
    3939import org.eobjects.metamodel.schema.Table; 
    4040 
    41 public class QueryPostprocessDataContextStrategyTest extends MetaModelTestCase { 
     41public class QueryPostprocessDataContextStrategyTest extends MetadataBeansTestCase { 
    4242 
    4343        private final Schema schema = getExampleSchema(); 
    … …  
    9999 
    100100                        @Override 
    101                         protected String getMainSchemaName() throws MetaModelException { 
     101                        protected String getMainSchemaName() throws MetadataBeansException { 
    102102                                return schema.getName(); 
    103103                        } 
    104104 
    105105                        @Override 
    106                         protected Schema getMainSchema() throws MetaModelException { 
     106                        protected Schema getMainSchema() throws MetadataBeansException { 
    107107                                return schema; 
    108108                        } 

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

    r887 r888  
    3232 
    3333 
    34 public class QuerySplitterTest extends MetaModelTestCase { 
     34public class QuerySplitterTest extends MetadataBeansTestCase { 
    3535 
    3636        public void testSimpleQuerySplit() throws Exception { 

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

    r887 r888  
    3737import org.w3c.dom.Element; 
    3838 
    39 public class XmlDataContextStrategyTest extends MetaModelTestCase { 
     39public class XmlDataContextStrategyTest extends MetadataBeansTestCase { 
    4040 
    4141        public void testGetFromUrl() throws Exception { 

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

    r887 r888  
    2121import org.eobjects.metamodel.DataContext; 
    2222import org.eobjects.metamodel.JdbcDataContextFactory; 
    23 import org.eobjects.metamodel.MetaModelTestCase; 
     23import org.eobjects.metamodel.MetadataBeansTestCase; 
    2424import org.eobjects.metamodel.query.Query; 
    2525import org.eobjects.metamodel.schema.Table; 
    2626 
    2727 
    28 public class RowFilterDataSetStrategyTest extends MetaModelTestCase { 
     28public class RowFilterDataSetStrategyTest extends MetadataBeansTestCase { 
    2929 
    3030        public void testStrategy() throws Exception { 

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

    r886 r888  
    1717package org.eobjects.metamodel.data; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.data.Row; 
    2121import org.eobjects.metamodel.query.SelectItem; 
    … …  
    2424 
    2525 
    26 public class RowTest extends MetaModelTestCase { 
     26public class RowTest extends MetadataBeansTestCase { 
    2727 
    2828        public void testRow() throws Exception { 

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

    r887 r888  
    77import org.apache.commons.lang.ArrayUtils; 
    88import org.eobjects.metamodel.DataContext; 
    9 import org.eobjects.metamodel.MetaModelException; 
     9import org.eobjects.metamodel.MetadataBeansException; 
    1010import org.eobjects.metamodel.data.DataSet; 
    1111import org.eobjects.metamodel.data.Row; 
    … …  
    9090                                        System.out.println("other type: " + columnValue); 
    9191                                } else { 
    92                                         throw new MetaModelException( 
     92                                        throw new MetadataBeansException( 
    9393                                                        "Value type not expected for Dbase data: " + column); 
    9494                                } 

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

    r887 r888  
    1717package org.eobjects.metamodel.dialects; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.dialects.MysqlQueryRewriter; 
    2121import org.eobjects.metamodel.query.Query; 
    … …  
    2424 
    2525 
    26 public class MysqlQueryRewriterTest extends MetaModelTestCase { 
     26public class MysqlQueryRewriterTest extends MetadataBeansTestCase { 
    2727 
    2828        public void testRewriteLimit() throws Exception { 

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

    r887 r888  
    1717package org.eobjects.metamodel.dialects; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.dialects.PostgresqlQueryRewriter; 
    2121import org.eobjects.metamodel.query.Query; 
    … …  
    2525 
    2626 
    27 public class PostgresqlQueryRewriterTest extends MetaModelTestCase { 
     27public class PostgresqlQueryRewriterTest extends MetadataBeansTestCase { 
    2828 
    2929        public void testRewriteLimit() throws Exception { 

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

    r887 r888  
    1717package org.eobjects.metamodel.query; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.query.Query; 
    2121import org.eobjects.metamodel.schema.Table; 
    … …  
    2323 
    2424 
    25 public class FromClauseTest extends MetaModelTestCase { 
     25public class FromClauseTest extends MetadataBeansTestCase { 
    2626 
    2727        public void testGetItemByReference() throws Exception { 

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

    r887 r888  
    1717package org.eobjects.metamodel.query; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.schema.Column; 
    2121import org.eobjects.metamodel.schema.Relationship; 
    … …  
    2424 
    2525 
    26 public class FromItemTest extends MetaModelTestCase { 
     26public class FromItemTest extends MetadataBeansTestCase { 
    2727 
    2828        private Schema _schema = getExampleSchema(); 

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

    r887 r888  
    1717package org.eobjects.metamodel.query; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.query.OrderByItem.Direction; 
    2121import org.eobjects.metamodel.schema.Column; 
    … …  
    2424 
    2525 
    26 public class QueryTest extends MetaModelTestCase { 
     26public class QueryTest extends MetadataBeansTestCase { 
    2727 
    2828        private Schema _schema = getExampleSchema(); 

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

    r887 r888  
    1717package org.eobjects.metamodel.query; 
    1818 
    19 import org.eobjects.metamodel.MetaModelTestCase; 
     19import org.eobjects.metamodel.MetadataBeansTestCase; 
    2020import org.eobjects.metamodel.query.FromItem; 
    2121import org.eobjects.metamodel.query.FunctionType; 
    … …  
    2727import org.eobjects.metamodel.schema.Schema; 
    2828 
    29 public class SelectItemTest extends MetaModelTestCase { 
     29public class SelectItemTest extends MetadataBeansTestCase { 
    3030 
    3131        private Schema _schema = getExampleSchema(); 

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

    r887 r888  
    2727import org.eobjects.metamodel.DataContext; 
    2828import org.eobjects.metamodel.JdbcDataContextFactory; 
    29 import org.eobjects.metamodel.MetaModelTestCase; 
     29import org.eobjects.metamodel.MetadataBeansTestCase; 
    3030import org.eobjects.metamodel.schema.JdbcSchema; 
    3131 
    3232 
    33 public class JdbcSchemaTest extends MetaModelTestCase { 
     33public class JdbcSchemaTest extends MetadataBeansTestCase { 
    3434 
    3535        /** 

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

    r887 r888  
    1818 
    1919import org.apache.commons.lang.ArrayUtils; 
    20 import org.eobjects.metamodel.MetaModelTestCase; 
     20import org.eobjects.metamodel.MetadataBeansTestCase; 
    2121import org.eobjects.metamodel.schema.ImmutableRelationship; 
    2222import org.eobjects.metamodel.schema.TableType; 
    2323 
    24 public class SchemaModelTest extends MetaModelTestCase { 
     24public class SchemaModelTest extends MetadataBeansTestCase { 
    2525 
    2626        public void testGetExampleSchema() throws Exception { 
Note: See TracChangeset for help on using the changeset viewer.