first round of refactoring
authorJörg Unbehauen <joerg@unbehauen.net>
Thu, 27 Jul 2017 11:01:26 +0000 (13:01 +0200)
committerJörg Unbehauen <joerg@unbehauen.net>
Thu, 27 Jul 2017 11:01:26 +0000 (13:01 +0200)
75 files changed:
core/pom.xml
core/src/main/java/org/apache/metamodel/AbstractDataContext.java
core/src/main/java/org/apache/metamodel/AbstractUpdateCallback.java
core/src/main/java/org/apache/metamodel/CompositeDataContext.java
core/src/main/java/org/apache/metamodel/CompositeQueryDelegate.java
core/src/main/java/org/apache/metamodel/DataContext.java
core/src/main/java/org/apache/metamodel/DeleteAndInsertBuilder.java
core/src/main/java/org/apache/metamodel/MetaModelHelper.java
core/src/main/java/org/apache/metamodel/QueryPostprocessDataContext.java
core/src/main/java/org/apache/metamodel/convert/ConvertedDataSetInterceptor.java
core/src/main/java/org/apache/metamodel/convert/Converters.java
core/src/main/java/org/apache/metamodel/create/AbstractTableCreationBuilder.java
core/src/main/java/org/apache/metamodel/data/AbstractDataSet.java
core/src/main/java/org/apache/metamodel/data/AbstractRow.java
core/src/main/java/org/apache/metamodel/data/AbstractRowBuilder.java
core/src/main/java/org/apache/metamodel/data/CachingDataSetHeader.java
core/src/main/java/org/apache/metamodel/data/DataSet.java
core/src/main/java/org/apache/metamodel/data/DataSetHeader.java
core/src/main/java/org/apache/metamodel/data/DataSetTableModel.java
core/src/main/java/org/apache/metamodel/data/EmptyDataSet.java
core/src/main/java/org/apache/metamodel/data/InMemoryDataSet.java
core/src/main/java/org/apache/metamodel/data/Row.java
core/src/main/java/org/apache/metamodel/data/ScalarFunctionDataSet.java
core/src/main/java/org/apache/metamodel/data/SimpleDataSetHeader.java
core/src/main/java/org/apache/metamodel/data/UnionDataSet.java
core/src/main/java/org/apache/metamodel/insert/AbstractRowInsertionBuilder.java
core/src/main/java/org/apache/metamodel/intercept/InterceptableDataContext.java
core/src/main/java/org/apache/metamodel/query/FromItem.java
core/src/main/java/org/apache/metamodel/query/Query.java
core/src/main/java/org/apache/metamodel/query/builder/GroupedQueryBuilderImpl.java
core/src/main/java/org/apache/metamodel/query/builder/InitFromBuilderImpl.java
core/src/main/java/org/apache/metamodel/query/builder/SatisfiedFromBuilder.java
core/src/main/java/org/apache/metamodel/query/builder/SatisfiedFromBuilderCallback.java
core/src/main/java/org/apache/metamodel/schema/AbstractRelationship.java
core/src/main/java/org/apache/metamodel/schema/AbstractSchema.java
core/src/main/java/org/apache/metamodel/schema/AbstractTable.java
core/src/main/java/org/apache/metamodel/schema/CompositeSchema.java
core/src/main/java/org/apache/metamodel/schema/ImmutableRelationship.java
core/src/main/java/org/apache/metamodel/schema/ImmutableSchema.java
core/src/main/java/org/apache/metamodel/schema/ImmutableTable.java
core/src/main/java/org/apache/metamodel/schema/MutableRelationship.java
core/src/main/java/org/apache/metamodel/schema/MutableSchema.java
core/src/main/java/org/apache/metamodel/schema/MutableTable.java
core/src/main/java/org/apache/metamodel/schema/Relationship.java
core/src/main/java/org/apache/metamodel/schema/Schema.java
core/src/main/java/org/apache/metamodel/schema/Table.java
core/src/test/java/org/apache/metamodel/AbstractDataContextTest.java
core/src/test/java/org/apache/metamodel/CompositeDataContextTest.java
core/src/test/java/org/apache/metamodel/MetaModelHelperTest.java
core/src/test/java/org/apache/metamodel/MetaModelTestCase.java
core/src/test/java/org/apache/metamodel/MockDataContext.java
core/src/test/java/org/apache/metamodel/MockUpdateableDataContext.java
core/src/test/java/org/apache/metamodel/QueryPostprocessDataContextTest.java
core/src/test/java/org/apache/metamodel/convert/ConvertersTest.java
core/src/test/java/org/apache/metamodel/create/AbstractCreateTableBuilderTest.java
core/src/test/java/org/apache/metamodel/data/DataSetTableModelTest.java
core/src/test/java/org/apache/metamodel/data/DefaultRowTest.java
core/src/test/java/org/apache/metamodel/data/RowTest.java
core/src/test/java/org/apache/metamodel/data/UnionDataSetTest.java
core/src/test/java/org/apache/metamodel/delete/AbstractRowDeletionCallbackTest.java
core/src/test/java/org/apache/metamodel/intercept/InterceptableDataContextTest.java
core/src/test/java/org/apache/metamodel/query/FilterItemTest.java
core/src/test/java/org/apache/metamodel/query/FromItemTest.java
core/src/test/java/org/apache/metamodel/query/QueryTest.java
core/src/test/java/org/apache/metamodel/query/SelectItemTest.java
core/src/test/java/org/apache/metamodel/query/builder/GroupedQueryBuilderImplTest.java
core/src/test/java/org/apache/metamodel/query/builder/SyntaxExamplesTest.java
core/src/test/java/org/apache/metamodel/schema/MutableTableTest.java
core/src/test/java/org/apache/metamodel/schema/SchemaModelTest.java
core/src/test/java/org/apache/metamodel/util/LegacyDeserializationObjectInputStreamTest.java
sugarcrm/src/main/java/org/apache/metamodel/sugarcrm/SugarCrmDataContext.java
xml/src/main/java/org/apache/metamodel/xml/XmlDomDataContext.java
xml/src/main/java/org/apache/metamodel/xml/XmlSaxDataContext.java
xml/src/test/java/org/apache/metamodel/xml/XmlDomDataContextTest.java
xml/src/test/java/org/apache/metamodel/xml/XmlSaxDataContextTest.java

index 3af58c9..4add6ad 100644 (file)
@@ -28,6 +28,10 @@ under the License.
        <name>MetaModel core API</name>
        <dependencies>
                <dependency>
+                       <groupId>com.google.guava</groupId>
+                       <artifactId>guava</artifactId>
+               </dependency>
+               <dependency>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                </dependency>
index a42d7f6..4fd00a6 100644 (file)
@@ -45,7 +45,7 @@ public abstract class AbstractDataContext implements DataContext {
     private static final String NULL_SCHEMA_NAME_TOKEN = "<metamodel.schema.name.null>";
     private final ConcurrentMap<String, Schema> _schemaCache = new ConcurrentHashMap<String, Schema>();
     private final Comparator<? super String> _schemaNameComparator = SchemaNameComparator.getInstance();
-    private String[] _schemaNameCache;
+    private List<String> _schemaNameCache;
 
     /**
      * {@inheritDoc}
@@ -70,11 +70,10 @@ public abstract class AbstractDataContext implements DataContext {
      * {@inheritDoc}
      */
     @Override
-    public final Schema[] getSchemas() throws MetaModelException {
-        String[] schemaNames = getSchemaNames();
-        Schema[] schemas = new Schema[schemaNames.length];
-        for (int i = 0; i < schemaNames.length; i++) {
-            final String name = schemaNames[i];
+    public final List<Schema> getSchemas() throws MetaModelException {
+        List<String> schemaNames = getSchemaNames();
+        List<Schema> schemas = new ArrayList<>();
+        for (final String name: schemaNames) {
             final Schema schema = _schemaCache.get(getSchemaCacheKey(name));
             if (schema == null) {
                 final Schema newSchema = getSchemaByName(name);
@@ -83,12 +82,12 @@ public abstract class AbstractDataContext implements DataContext {
                 }
                 final Schema existingSchema = _schemaCache.putIfAbsent(getSchemaCacheKey(name), newSchema);
                 if (existingSchema == null) {
-                    schemas[i] = newSchema;
+                    schemas.add(newSchema);
                 } else {
-                    schemas[i] = existingSchema;
+                    schemas.add(existingSchema);
                 }
             } else {
-                schemas[i] = schema;
+                schemas.add(schema);
             }
         }
         return schemas;
@@ -105,12 +104,12 @@ public abstract class AbstractDataContext implements DataContext {
      * m {@inheritDoc}
      */
     @Override
-    public final String[] getSchemaNames() throws MetaModelException {
+    public final List<String> getSchemaNames() throws MetaModelException {
         if (_schemaNameCache == null) {
             _schemaNameCache = getSchemaNamesInternal();
         }
-        String[] schemaNames = Arrays.copyOf(_schemaNameCache, _schemaNameCache.length);
-        Arrays.sort(schemaNames, _schemaNameComparator);
+        List<String> schemaNames = new ArrayList<>(_schemaNameCache);
+        schemaNames.sort(_schemaNameComparator);
         return schemaNames;
     }
 
@@ -125,13 +124,12 @@ public abstract class AbstractDataContext implements DataContext {
             result = getSchemaByName(defaultSchemaName);
         }
         if (result == null) {
-            final Schema[] schemas = getSchemas();
-            if (schemas.length == 1) {
-                result = schemas[0];
+            final List<Schema> schemas = getSchemas();
+            if (schemas.size() == 1) {
+                result = schemas.get(0);
             } else {
                 int highestTableCount = -1;
-                for (int i = 0; i < schemas.length; i++) {
-                    final Schema schema = schemas[i];
+                for (Schema schema: schemas) {
                     String name = schema.getName();
                     if (schema != null) {
                         name = name.toLowerCase();
@@ -200,7 +198,7 @@ public abstract class AbstractDataContext implements DataContext {
             if (name == null) {
                 schema = getSchemaByNameInternal(null);
             } else {
-                String[] schemaNames = getSchemaNames();
+                List<String> schemaNames = getSchemaNames();
                 for (String schemaName : schemaNames) {
                     if (name.equalsIgnoreCase(schemaName)) {
                         schema = getSchemaByNameInternal(name);
@@ -255,7 +253,7 @@ public abstract class AbstractDataContext implements DataContext {
         }
 
         Schema schema = null;
-        final String[] schemaNames = getSchemaNames();
+        final List<String> schemaNames = getSchemaNames();
         for (final String schemaName : schemaNames) {
             if (schemaName == null) {
                 // search without schema name (some databases have only a single
@@ -333,7 +331,7 @@ public abstract class AbstractDataContext implements DataContext {
     private final Column getColumn(final Schema schema, final String tableAndColumnPath) {
         Table table = null;
         String columnPath = tableAndColumnPath;
-        final String[] tableNames = schema.getTableNames();
+        final List<String> tableNames = schema.getTableNames();
         for (final String tableName : tableNames) {
             if (tableName != null) {
                 // search case-sensitive
@@ -368,8 +366,8 @@ public abstract class AbstractDataContext implements DataContext {
             }
         }
 
-        if (table == null && tableNames.length == 1) {
-            table = schema.getTables()[0];
+        if (table == null && tableNames.size() == 1) {
+            table = schema.getTables().get(0);
         }
 
         if (table != null) {
@@ -403,7 +401,7 @@ public abstract class AbstractDataContext implements DataContext {
         }
 
         Schema schema = null;
-        String[] schemaNames = getSchemaNames();
+        List<String> schemaNames = getSchemaNames();
         for (String schemaName : schemaNames) {
             if (schemaName == null) {
                 // there's an unnamed schema present.
@@ -452,7 +450,7 @@ public abstract class AbstractDataContext implements DataContext {
     /**
      * Tokenizes a path for a table or a column.
      * 
-     * @param tableName
+     * @param path
      * @param expectedParts
      * @return
      */
@@ -545,7 +543,7 @@ public abstract class AbstractDataContext implements DataContext {
      * 
      * @return an array of schema names.
      */
-    protected abstract String[] getSchemaNamesInternal();
+    protected abstract List<String> getSchemaNamesInternal();
 
     /**
      * Gets the name of the default schema.
index a1c2f1a..4ff7279 100644 (file)
@@ -60,7 +60,7 @@ public abstract class AbstractUpdateCallback implements UpdateCallback {
         final Table table = schema.getTableByName(tableName);
         if (table == null) {
             throw new IllegalArgumentException("Nu such table '" + tableName + "' found in schema: " + schema
-                    + ". Available tables are: " + Arrays.toString(schema.getTableNames()));
+                    + ". Available tables are: " + Arrays.toString(schema.getTableNames().toArray()));
         }
         return dropTable(table);
     }
@@ -82,7 +82,7 @@ public abstract class AbstractUpdateCallback implements UpdateCallback {
         final Table table = schema.getTableByName(tableName);
         if (table == null) {
             throw new IllegalArgumentException("Nu such table '" + tableName + "' found in schema: " + schema
-                    + ". Available tables are: " + Arrays.toString(schema.getTableNames()));
+                    + ". Available tables are: " + Arrays.toString(schema.getTableNames().toArray()));
         }
         return table;
     }
index 8612a51..0ddc78c 100644 (file)
  */
 package org.apache.metamodel;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.data.DataSet;
 import org.apache.metamodel.query.FromItem;
@@ -178,10 +171,10 @@ public class CompositeDataContext extends AbstractDataContext {
     }
 
     @Override
-    public String[] getSchemaNamesInternal() throws MetaModelException {
-        Set<String> set = new HashSet<String>();
+    public List<String> getSchemaNamesInternal() throws MetaModelException {
+        Set<String> set = new TreeSet<>();
         for (DataContext dc : _delegates) {
-            String[] schemaNames = dc.getSchemaNames();
+            List<String> schemaNames = dc.getSchemaNames();
             for (String name : schemaNames) {
                 if (!MetaModelHelper.isInformationSchema(name)) {
                     // we skip information schemas, since they're anyways going
@@ -190,9 +183,7 @@ public class CompositeDataContext extends AbstractDataContext {
                 }
             }
         }
-        String[] result = set.toArray(new String[set.size()]);
-        Arrays.sort(result);
-        return result;
+        return new ArrayList<>(set);
     }
 
 }
\ No newline at end of file
index d3e1a04..8402695 100644 (file)
@@ -18,6 +18,7 @@
  */
 package org.apache.metamodel;
 
+import java.util.List;
 import java.util.function.Function;
 
 import org.apache.metamodel.data.DataSet;
@@ -35,7 +36,7 @@ final class CompositeQueryDelegate extends QueryPostprocessDelegate {
        }
 
        @Override
-       protected DataSet materializeMainSchemaTable(Table table, Column[] columns,
+       protected DataSet materializeMainSchemaTable(Table table, List<Column> columns,
                        int maxRows) {
                // find the appropriate datacontext to execute a simple
                // table materialization query
index 132ecfb..ee56f1e 100644 (file)
@@ -27,6 +27,9 @@ import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.Schema;
 import org.apache.metamodel.schema.Table;
 
+import java.util.Collection;
+import java.util.List;
+
 /**
  * A DataContext represents the central entry point for interactions with
  * datastores. The DataContext contains of the structure of data (in the form of
@@ -51,7 +54,7 @@ public interface DataContext {
      * @throws MetaModelException
      *             if an error occurs retrieving the schema model
      */
-    public Schema[] getSchemas() throws MetaModelException;
+    public List<Schema> getSchemas() throws MetaModelException;
 
     /**
      * Gets the names of all schemas within this DataContext.
@@ -60,7 +63,7 @@ public interface DataContext {
      * @throws MetaModelException
      *             if an error occurs retrieving the schema model
      */
-    public String[] getSchemaNames() throws MetaModelException;
+    public List<String> getSchemaNames() throws MetaModelException;
 
     /**
      * Gets the default schema of this DataContext.
index 1b4670b..2227256 100644 (file)
@@ -82,11 +82,11 @@ public class DeleteAndInsertBuilder extends AbstractRowUpdationBuilder {
      * @return
      */
     private Row update(final Row original) {
-        SelectItem[] items = original.getSelectItems();
-        Object[] values = new Object[items.length];
-        for (int i = 0; i < items.length; i++) {
+        List<SelectItem> items = original.getSelectItems();
+        Object[] values = new Object[items.size()];
+        for (int i = 0; i < items.size(); i++) {
             final Object value;
-            Column column = items[i].getColumn();
+            Column column = items.get(i).getColumn();
             if (isSet(column)) {
                 // use update statement's value
                 value = getValues()[i];
@@ -103,7 +103,10 @@ public class DeleteAndInsertBuilder extends AbstractRowUpdationBuilder {
         final DataContext dc = _updateCallback.getDataContext();
         final Table table = getTable();
         final List<FilterItem> whereItems = getWhereItems();
-        final DataSet dataSet = dc.query().from(table).select(table.getColumns()).where(whereItems).execute();
+        final DataSet dataSet = dc.query()
+                .from(table)
+                .select(table.getColumns().toArray(new Column[table.getColumns().size()]))
+                .where(whereItems).execute();
         final List<Row> rows = dataSet.toRows();
         return rows;
     }
index 09d47bc..ae87083 100644 (file)
@@ -28,7 +28,10 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import com.google.common.collect.Lists;
 import org.apache.metamodel.data.CachingDataSetHeader;
 import org.apache.metamodel.data.DataSet;
 import org.apache.metamodel.data.DataSetHeader;
@@ -185,8 +188,8 @@ public final class MetaModelHelper {
 
         List<SelectItem> selectItems = new ArrayList<SelectItem>();
         for (DataSet dataSet : fromDataSets) {
-            for (int i = 0; i < dataSet.getSelectItems().length; i++) {
-                SelectItem item = dataSet.getSelectItems()[i];
+            for (int i = 0; i < dataSet.getSelectItems().size(); i++) {
+                SelectItem item = dataSet.getSelectItems().get(i);
                 selectItems.add(item);
             }
         }
@@ -195,7 +198,7 @@ public final class MetaModelHelper {
         List<Object[]> data = new ArrayList<Object[]>();
         for (int fromDataSetIndex = 0; fromDataSetIndex < fromDataSets.length; fromDataSetIndex++) {
             DataSet fromDataSet = fromDataSets[fromDataSetIndex];
-            SelectItem[] fromSelectItems = fromDataSet.getSelectItems();
+            List<SelectItem> fromSelectItems = fromDataSet.getSelectItems();
             if (fromDataSetIndex == 0) {
                 while (fromDataSet.next()) {
                     Object[] values = fromDataSet.getRow().getValues();
@@ -220,7 +223,7 @@ public final class MetaModelHelper {
                     }
                 }
             }
-            selectItemOffset += fromSelectItems.length;
+            selectItemOffset += fromSelectItems.size();
         }
 
         if (data.isEmpty()) {
@@ -261,7 +264,7 @@ public final class MetaModelHelper {
     }
 
     public static DataSet getSelection(final List<SelectItem> selectItems, final DataSet dataSet) {
-        final List<SelectItem> dataSetSelectItems = Arrays.asList(dataSet.getSelectItems());
+        final List<SelectItem> dataSetSelectItems = dataSet.getSelectItems();
 
         // check if the selection is already the same
         if (selectItems.equals(dataSetSelectItems)) {
@@ -295,18 +298,17 @@ public final class MetaModelHelper {
 
     public static DataSet getGrouped(List<SelectItem> selectItems, DataSet dataSet,
             Collection<GroupByItem> groupByItems) {
-        return getGrouped(selectItems, dataSet, groupByItems.toArray(new GroupByItem[groupByItems.size()]));
+        return getGrouped(selectItems, dataSet, groupByItems);
     }
 
-    public static DataSet getGrouped(List<SelectItem> selectItems, DataSet dataSet, GroupByItem[] groupByItems) {
+    public static DataSet getGrouped(List<SelectItem> selectItems, DataSet dataSet, List<GroupByItem> groupByItems) {
         DataSet result = dataSet;
-        if (groupByItems != null && groupByItems.length > 0) {
+        if (groupByItems != null && groupByItems.size() > 0) {
             Map<Row, Map<SelectItem, List<Object>>> uniqueRows = new HashMap<Row, Map<SelectItem, List<Object>>>();
 
-            final SelectItem[] groupBySelects = new SelectItem[groupByItems.length];
-            for (int i = 0; i < groupBySelects.length; i++) {
-                groupBySelects[i] = groupByItems[i].getSelectItem();
-            }
+            final List<SelectItem> groupBySelects = groupByItems.stream()
+                    .map(gbi -> gbi.getSelectItem())
+                    .collect(Collectors.toList());
             final DataSetHeader groupByHeader = new CachingDataSetHeader(groupBySelects);
 
             // Creates a list of SelectItems that have aggregate functions
@@ -663,12 +665,9 @@ public final class MetaModelHelper {
         if (ds2 == null) {
             throw new IllegalArgumentException("Right DataSet cannot be null");
         }
-        SelectItem[] si1 = ds1.getSelectItems();
-        SelectItem[] si2 = ds2.getSelectItems();
-        SelectItem[] selectItems = new SelectItem[si1.length + si2.length];
-        System.arraycopy(si1, 0, selectItems, 0, si1.length);
-        System.arraycopy(si2, 0, selectItems, si1.length, si2.length);
-
+        List<SelectItem> si1 = ds1.getSelectItems();
+        List<SelectItem> si2 = ds2.getSelectItems();
+        List<SelectItem> selectItems = Stream.concat(si1.stream(),si2.stream()).collect(Collectors.toList());
         List<Row> resultRows = new ArrayList<Row>();
         List<Row> ds2data = readDataSetFull(ds2);
         if (ds2data.isEmpty()) {
@@ -695,7 +694,7 @@ public final class MetaModelHelper {
                 resultRows.addAll(carthesianRows);
             } else {
                 Object[] values = ds1row.getValues();
-                Object[] row = new Object[selectItems.length];
+                Object[] row = new Object[selectItems.size()];
                 System.arraycopy(values, 0, row, 0, values.length);
                 resultRows.add(new DefaultRow(header, row));
             }
@@ -721,11 +720,11 @@ public final class MetaModelHelper {
      * @return the right joined result dataset
      */
     public static DataSet getRightJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) {
-        SelectItem[] ds1selects = ds1.getSelectItems();
-        SelectItem[] ds2selects = ds2.getSelectItems();
-        SelectItem[] leftOrderedSelects = new SelectItem[ds1selects.length + ds2selects.length];
-        System.arraycopy(ds1selects, 0, leftOrderedSelects, 0, ds1selects.length);
-        System.arraycopy(ds2selects, 0, leftOrderedSelects, ds1selects.length, ds2selects.length);
+        List<SelectItem> ds1selects = ds1.getSelectItems();
+        List<SelectItem> ds2selects = ds2.getSelectItems();
+        List<SelectItem> leftOrderedSelects = new ArrayList<>();
+        leftOrderedSelects.addAll(ds1selects);
+        leftOrderedSelects.addAll(ds2selects);
 
         // We will reuse the left join algorithm (but switch the datasets
         // around)
@@ -744,12 +743,12 @@ public final class MetaModelHelper {
     }
 
     public static DataSet getDistinct(DataSet dataSet) {
-        SelectItem[] selectItems = dataSet.getSelectItems();
-        GroupByItem[] groupByItems = new GroupByItem[selectItems.length];
-        for (int i = 0; i < groupByItems.length; i++) {
-            groupByItems[i] = new GroupByItem(selectItems[i]);
-        }
-        return getGrouped(Arrays.asList(selectItems), dataSet, groupByItems);
+        List<SelectItem> selectItems = dataSet.getSelectItems();
+        List<GroupByItem> groupByItems = selectItems.stream()
+                .map(GroupByItem::new)
+                .collect(Collectors.toList());
+
+        return getGrouped(selectItems, dataSet, groupByItems);
     }
 
     public static Table[] getTables(Column[] columns) {
index fac70d0..cbd97d3 100644 (file)
@@ -24,6 +24,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.convert.ConvertedDataSetInterceptor;
 import org.apache.metamodel.convert.Converters;
@@ -366,11 +367,11 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
         if (selectItems == null || selectItems.isEmpty()) {
             // add any column (typically this occurs because of COUNT(*)
             // queries)
-            Column[] columns = table.getColumns();
-            if (columns.length == 0) {
+            List<Column> columns = table.getColumns();
+            if (columns.size() == 0) {
                 logger.warn("Queried table has no columns: {}", table);
             } else {
-                selectItems.add(new SelectItem(columns[0]));
+                selectItems.add(new SelectItem(columns.get(0)));
             }
         }
 
@@ -442,10 +443,10 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
     }
 
     @Override
-    protected final String[] getSchemaNamesInternal() throws MetaModelException {
-        final String[] schemaNames = new String[2];
-        schemaNames[0] = INFORMATION_SCHEMA_NAME;
-        schemaNames[1] = getMainSchemaName();
+    protected final List<String> getSchemaNamesInternal() throws MetaModelException {
+        final List<String> schemaNames = new ArrayList<>();
+        schemaNames.add(INFORMATION_SCHEMA_NAME);
+        schemaNames.add(getMainSchemaName());
         return schemaNames;
     }
 
@@ -527,9 +528,11 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
 
     private DataSet materializeInformationSchemaTable(final Table table, final List<SelectItem> selectItems) {
         final String tableName = table.getName();
-        final SelectItem[] columnSelectItems = MetaModelHelper.createSelectItems(table.getColumns());
+        final List<SelectItem> columnSelectItems = table.getColumns().stream()
+                .map(SelectItem::new)
+                .collect(Collectors.toList());
         final SimpleDataSetHeader header = new SimpleDataSetHeader(columnSelectItems);
-        final Table[] tables = getDefaultSchema().getTables();
+        final List<Table> tables = getDefaultSchema().getTables();
         final List<Row> data = new ArrayList<Row>();
         if ("tables".equals(tableName)) {
             // "tables" columns: name, type, num_columns, remarks
@@ -558,13 +561,13 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
             // "relationships" columns: primary_table, primary_column,
             // foreign_table, foreign_column
             for (Relationship r : getDefaultSchema().getRelationships()) {
-                Column[] primaryColumns = r.getPrimaryColumns();
-                Column[] foreignColumns = r.getForeignColumns();
+                List<Column> primaryColumns = r.getPrimaryColumns();
+                List<Column> foreignColumns = r.getForeignColumns();
                 Table pTable = r.getPrimaryTable();
                 Table fTable = r.getForeignTable();
-                for (int i = 0; i < primaryColumns.length; i++) {
-                    Column pColumn = primaryColumns[i];
-                    Column fColumn = foreignColumns[i];
+                for (int i = 0; i < primaryColumns.size(); i++) {
+                    Column pColumn = primaryColumns.get(i);
+                    Column fColumn = foreignColumns.get(i);
                     data.add(new DefaultRow(header,
                             new Object[] { pTable.getName(), pColumn.getName(), fTable.getName(), fColumn.getName() }));
                 }
@@ -628,11 +631,11 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
         DataSet dataSet;
         if (whereItems.isEmpty()) {
             // paging is pushed down to materializeMainSchemaTable
-            dataSet = materializeMainSchemaTable(table, workingSelectItems, firstRow, maxRows);
+            dataSet = materializeMainSchemaTableSelect(table, workingSelectItems, firstRow, maxRows);
             dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
         } else {
             // do not push down paging, first we have to apply filtering
-            dataSet = materializeMainSchemaTable(table, workingSelectItems, 1, -1);
+            dataSet = materializeMainSchemaTableSelect(table, workingSelectItems, 1, -1);
             dataSet = MetaModelHelper.getFiltered(dataSet, whereItems);
             dataSet = MetaModelHelper.getPaged(dataSet, firstRow, maxRows);
             dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
@@ -643,19 +646,19 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
     /**
      * Executes a simple one-table query against a table in the main schema of
      * the subclasses of this class. This default implementation will delegate
-     * to {@link #materializeMainSchemaTable(Table, Column[], int, int)}.
-     * 
+     * to {@link #materializeMainSchemaTable(Table, List, int, int)}.
+     *
      * @param table
      * @param selectItems
      * @param firstRow
      * @param maxRows
      * @return
      */
-    protected DataSet materializeMainSchemaTable(Table table, List<SelectItem> selectItems, int firstRow, int maxRows) {
-        Column[] columns = new Column[selectItems.size()];
-        for (int i = 0; i < columns.length; i++) {
-            columns[i] = selectItems.get(i).getColumn();
-        }
+    protected DataSet materializeMainSchemaTableSelect(Table table, List<SelectItem> selectItems, int firstRow, int maxRows) {
+        List<Column> columns = selectItems.stream()
+                .map(si -> si.getColumn())
+                .collect(Collectors.toList());
+
         DataSet dataSet = materializeMainSchemaTable(table, columns, firstRow, maxRows);
 
         dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
@@ -666,7 +669,7 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
     /**
      * Executes a simple one-table query against a table in the main schema of
      * the subclasses of this class. This default implementation will delegate
-     * to {@link #materializeMainSchemaTable(Table, Column[], int)} and apply a
+     * to {@link #materializeMainSchemaTable(Table, List, int)} and apply a
      * {@link FirstRowDataSet} if necessary.
      * 
      * @param table
@@ -675,7 +678,7 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
      * @param maxRows
      * @return
      */
-    protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int firstRow, int maxRows) {
+    protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int firstRow, int maxRows) {
         final int rowsToMaterialize;
         if (firstRow == 1) {
             rowsToMaterialize = maxRows;
@@ -702,5 +705,5 @@ public abstract class QueryPostprocessDataContext extends AbstractDataContext im
      *            wanted.
      * @return a dataset with the raw table/column content.
      */
-    protected abstract DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows);
+    protected abstract DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows);
 }
\ No newline at end of file
index 082d121..4ff00e8 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.convert;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.apache.metamodel.data.DataSet;
@@ -67,10 +68,10 @@ public class ConvertedDataSetInterceptor implements DataSetInterceptor, HasReadT
                }
 
                boolean hasConverter = false;
-               SelectItem[] selectItems = dataSet.getSelectItems();
-               TypeConverter<?, ?>[] converterArray = new TypeConverter[selectItems.length];
-               for (int i = 0; i < selectItems.length; i++) {
-                       SelectItem selectItem = selectItems[i];
+               List<SelectItem> selectItems = dataSet.getSelectItems();
+               TypeConverter<?, ?>[] converterArray = new TypeConverter[selectItems.size()];
+               for (int i = 0; i < selectItems.size(); i++) {
+                       SelectItem selectItem = selectItems.get(i);
                        Column column = selectItem.getColumn();
                        if (column != null && selectItem.getAggregateFunction() == null) {
                                TypeConverter<?, ?> converter = converters.get(column);
index 1be0e13..142987e 100644 (file)
  */
 package org.apache.metamodel.convert;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.DataContext;
 import org.apache.metamodel.MetaModelHelper;
@@ -136,15 +135,19 @@ public final class Converters {
      *         used (eg. with the {@link #addTypeConverters(DataContext, Map)}
      *         method) to decorate the DataContext with type converters.
      */
-    public static Map<Column, TypeConverter<?, ?>> autoDetectConverters(DataContext dataContext, Column[] columns,
+    public static Map<Column, TypeConverter<?, ?>> autoDetectConverters(DataContext dataContext, final List<Column> columns,
             int sampleSize) {
-        columns = MetaModelHelper.getColumnsBySuperType(columns, SuperColumnType.LITERAL_TYPE);
         final Map<Column, TypeConverter<?, ?>> result = new HashMap<Column, TypeConverter<?, ?>>();
-        Table[] tables = MetaModelHelper.getTables(columns);
-        for (Table table : tables) {
-            Column[] tableColumns = MetaModelHelper.getTableColumns(table, columns);
-            autoDetectConvertersInternally(dataContext, table, tableColumns, sampleSize, result);
-        }
+        columns.stream()
+                .filter(col -> col.getType() != null)
+                .filter(col -> col.getType().getSuperType().equals(SuperColumnType.LITERAL_TYPE))
+                // group by table
+                .collect(Collectors.toMap(Column::getTable,Arrays::asList))
+                //and detect it
+                .forEach((tab, cols) ->{
+                    autoDetectConvertersInternally(dataContext,tab,cols,sampleSize,result);
+        });
+
         return result;
     }
 
@@ -172,14 +175,14 @@ public final class Converters {
     public static Map<Column, TypeConverter<?, ?>> autoDetectConverters(DataContext dataContext, Table table,
             int sampleSize) {
         final Map<Column, TypeConverter<?, ?>> result = new HashMap<Column, TypeConverter<?, ?>>();
-        Column[] columns = table.getColumnsOfSuperType(SuperColumnType.LITERAL_TYPE);
+        List<Column> columns = table.getColumnsOfSuperType(SuperColumnType.LITERAL_TYPE);
         autoDetectConvertersInternally(dataContext, table, columns, sampleSize, result);
         return result;
     }
 
-    private static void autoDetectConvertersInternally(DataContext dataContext, Table table, Column[] columns,
+    private static void autoDetectConvertersInternally(DataContext dataContext, Table table, List<Column> columns,
             int sampleSize, Map<Column, TypeConverter<?, ?>> result) {
-        if (columns == null || columns.length == 0) {
+        if (columns == null || columns.size() == 0) {
             return;
         }
 
@@ -188,7 +191,7 @@ public final class Converters {
             detectors.put(column, new ColumnTypeDetector());
         }
 
-        Query query = dataContext.query().from(table).select(columns).toQuery();
+        Query query = dataContext.query().from(table).select(columns.toArray(new Column[columns.size()])).toQuery();
         if (sampleSize > 0 && sampleSize != Integer.MAX_VALUE) {
             query.setMaxRows(sampleSize);
         }
@@ -306,7 +309,7 @@ public final class Converters {
      */
     protected static <RB extends RowBuilder<?>> RB convertRow(RB rowBuilder, Map<Column, TypeConverter<?, ?>> converters) {
         Table table = rowBuilder.getTable();
-        Column[] columns = table.getColumns();
+        List<Column> columns = table.getColumns();
         Row row = rowBuilder.toRow();
         for (Column column : columns) {
             @SuppressWarnings("unchecked")
index 401be9f..1833120 100644 (file)
@@ -29,6 +29,8 @@ import org.apache.metamodel.schema.TableType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.List;
+
 /**
  * Abstract {@link TableCreationBuilder} implementation, provided as convenience
  * for {@link TableCreatable} implementations. Handles all the building
@@ -72,7 +74,7 @@ public abstract class AbstractTableCreationBuilder<U extends UpdateCallback> imp
     @Override
     public TableCreationBuilder like(Table table) {
         logger.debug("like({})", table);
-        Column[] columns = table.getColumns();
+        List<Column> columns = table.getColumns();
         for (Column column : columns) {
             withColumn(column.getName()).like(column);
         }
@@ -101,12 +103,12 @@ public abstract class AbstractTableCreationBuilder<U extends UpdateCallback> imp
         sb.append("CREATE TABLE ");
         sb.append(_table.getQualifiedLabel());
         sb.append(" (");
-        Column[] columns = _table.getColumns();
-        for (int i = 0; i < columns.length; i++) {
+        List<Column> columns = _table.getColumns();
+        for (int i = 0; i < columns.size(); i++) {
             if (i != 0) {
                 sb.append(',');
             }
-            Column column = columns[i];
+            Column column = columns.get(i);
             sb.append(column.getName());
             ColumnType type = column.getType();
             if (type != null) {
@@ -125,15 +127,15 @@ public abstract class AbstractTableCreationBuilder<U extends UpdateCallback> imp
             }
         }
         boolean primaryKeyExists = false;
-        for(int i = 0 ; i < columns.length ; i++) {
-            if(columns[i].isPrimaryKey()) {
+        for(int i = 0 ; i < columns.size() ; i++) {
+            if(columns.get(i).isPrimaryKey()) {
                 if(!primaryKeyExists) {
                     sb.append(", PRIMARY KEY(");
-                    sb.append(columns[i].getName());
+                    sb.append(columns.get(i).getName());
                     primaryKeyExists = true;
                 } else {
                     sb.append(",");
-                    sb.append(columns[i].getName());
+                    sb.append(columns.get(i).getName());
                 }
             }    
         }
index f616ddc..6e64446 100644 (file)
@@ -56,7 +56,7 @@ public abstract class AbstractDataSet extends BaseObject implements DataSet {
         if (dataSet instanceof AbstractDataSet) {
             _header = ((AbstractDataSet) dataSet).getHeader();
         } else {
-            _header = new CachingDataSetHeader(Arrays.asList(dataSet.getSelectItems()));
+            _header = new CachingDataSetHeader(dataSet.getSelectItems());
         }
     }
 
@@ -72,7 +72,7 @@ public abstract class AbstractDataSet extends BaseObject implements DataSet {
      * {@inheritDoc}
      */
     @Override
-    public SelectItem[] getSelectItems() {
+    public List<SelectItem> getSelectItems() {
         return getHeader().getSelectItems();
     }
 
@@ -118,7 +118,7 @@ public abstract class AbstractDataSet extends BaseObject implements DataSet {
      */
     @Override
     public String toString() {
-        return "DataSet[selectItems=" + Arrays.toString(getSelectItems()) + "]";
+        return "DataSet[selectItems=" + Arrays.toString(getSelectItems().toArray()) + "]";
     }
 
     @Override
index 9c931f1..f438a64 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.data;
 
 import java.util.Arrays;
+import java.util.List;
 
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
@@ -122,7 +123,7 @@ public abstract class AbstractRow implements Cloneable, Row {
     }
 
     @Override
-    public final SelectItem[] getSelectItems() {
+    public final List<SelectItem> getSelectItems() {
         return getHeader().getSelectItems();
     }
 
index fef04c9..144017c 100644 (file)
 package org.apache.metamodel.data;
 
 import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 
+import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.Table;
 
@@ -37,8 +40,8 @@ public abstract class AbstractRowBuilder<RB extends RowBuilder<?>> implements Ro
         this(table.getColumns());
     }
 
-    public AbstractRowBuilder(Column[] columns) {
-        _columns = columns;
+    public AbstractRowBuilder(List<Column> columns) {
+        _columns = columns.toArray(new Column[columns.size()]);
         _explicitNulls = new boolean[_columns.length];
         _values = new Object[_columns.length];
         _styles = new Style[_columns.length];
@@ -68,7 +71,7 @@ public abstract class AbstractRowBuilder<RB extends RowBuilder<?>> implements Ro
 
     @Override
     public final Row toRow() {
-        return new DefaultRow(new SimpleDataSetHeader(_columns), _values);
+        return new DefaultRow(new SimpleDataSetHeader(Arrays.stream(_columns).map(SelectItem::new).collect(Collectors.toList())), _values);
     }
 
     @Override
index 2c4b0c9..76ce891 100644 (file)
@@ -46,9 +46,6 @@ public final class CachingDataSetHeader extends SimpleDataSetHeader implements D
         super(items);
     }
 
-    public CachingDataSetHeader(SelectItem[] items) {
-        this(Arrays.asList(items));
-    }
 
     @Override
     public int indexOf(Column column) {
index 993d408..fc277d0 100644 (file)
@@ -35,7 +35,7 @@ public interface DataSet extends Closeable, Iterable<Row> {
     /**
      * @return the SelectItems that represent the columns of this DataSet
      */
-    public SelectItem[] getSelectItems();
+    public List<SelectItem> getSelectItems();
 
     /**
      * Finds the index of a given SelectItem
index 79e8c6c..6113497 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.data;
 
 import java.io.Serializable;
+import java.util.List;
 
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
@@ -29,7 +30,7 @@ import org.apache.metamodel.schema.Column;
  */
 public interface DataSetHeader extends Serializable {
 
-    public SelectItem[] getSelectItems();
+    public List<SelectItem> getSelectItems();
 
     public int size();
 
index 7316c00..c67ff05 100644 (file)
@@ -39,7 +39,7 @@ public class DataSetTableModel extends AbstractTableModel {
        private boolean _materialized;
        private final List<Row> _materializedRows = new ArrayList<Row>();
        private final DataSet _dataSet;
-       private final SelectItem[] _selectItems;
+       private final List<SelectItem> _selectItems;
 
        public DataSetTableModel(DataSet dataSet) {
                _dataSet = dataSet;
@@ -49,7 +49,7 @@ public class DataSetTableModel extends AbstractTableModel {
 
        @Override
        public int hashCode() {
-               return Arrays.hashCode(_selectItems) + _materializedRows.hashCode();
+               return _selectItems.hashCode() + _materializedRows.hashCode();
        }
 
        @Override
@@ -71,7 +71,7 @@ public class DataSetTableModel extends AbstractTableModel {
        }
 
        public int getColumnCount() {
-               return _selectItems.length;
+               return _selectItems.size();
        }
 
        public int getRowCount() {
@@ -99,7 +99,7 @@ public class DataSetTableModel extends AbstractTableModel {
 
        @Override
        public String getColumnName(int column) {
-               return _selectItems[column].getSuperQueryAlias(false);
+               return _selectItems.get(column).getSuperQueryAlias(false);
        }
 
        @Override
index 0849255..fd71be3 100644 (file)
@@ -32,14 +32,6 @@ public final class EmptyDataSet extends AbstractDataSet {
         super(header);
     }
 
-    public EmptyDataSet(SelectItem[] selectItems) {
-        super(new SimpleDataSetHeader(selectItems));
-    }
-
-    public EmptyDataSet(Column[] columns) {
-        super(new SimpleDataSetHeader(columns));
-    }
-
     public EmptyDataSet(List<SelectItem> selectItems) {
        this(new SimpleDataSetHeader(selectItems));
     }
index a6b2d7e..88bf5ad 100644 (file)
@@ -55,7 +55,7 @@ public final class InMemoryDataSet extends AbstractDataSet {
                     + " for this");
         }
 
-        final SelectItem[] selectItems = rows.get(0).getSelectItems();
+        final List<SelectItem> selectItems = rows.get(0).getSelectItems();
 
         if (rows.size() > 3) {
             // not that many records - caching will not have body to scale
index 65fc273..9f6f634 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.data;
 
 import java.io.Serializable;
+import java.util.List;
 
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
@@ -96,7 +97,7 @@ public interface Row extends Serializable {
      * 
      * @return
      */
-    public SelectItem[] getSelectItems();
+    public List<SelectItem> getSelectItems();
 
     /**
      * Gets the values of the row, represented as an object array
index 64a7866..9d45946 100644 (file)
@@ -36,7 +36,7 @@ public class ScalarFunctionDataSet extends AbstractDataSet implements WrappingDa
 
     public ScalarFunctionDataSet(List<SelectItem> scalarFunctionSelectItemsToEvaluate, DataSet dataSet) {
         super(CollectionUtils.concat(false, scalarFunctionSelectItemsToEvaluate,
-                Arrays.<SelectItem> asList(dataSet.getSelectItems())));
+                dataSet.getSelectItems()));
         _scalarFunctionSelectItemsToEvaluate = scalarFunctionSelectItemsToEvaluate;
         _dataSet = dataSet;
     }
index 8f8a8a8..afc6226 100644 (file)
@@ -19,7 +19,9 @@
 package org.apache.metamodel.data;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.MetaModelHelper;
 import org.apache.metamodel.query.SelectItem;
@@ -46,13 +48,10 @@ public class SimpleDataSetHeader implements DataSetHeader {
         this(Arrays.asList(selectItems));
     }
 
-    public SimpleDataSetHeader(Column[] columns) {
-        this(MetaModelHelper.createSelectItems(columns));
-    }
 
     @Override
-    public final SelectItem[] getSelectItems() {
-        return _items.toArray(new SelectItem[_items.size()]);
+    public final List<SelectItem> getSelectItems() {
+        return Collections.unmodifiableList(_items);
     }
 
     @Override
index 7962f56..f13124c 100644 (file)
@@ -67,7 +67,7 @@ public class UnionDataSet extends AbstractDataSet implements WrappingDataSet {
                 return false;
             }
             _currentDataSet = _iterator.next().get();
-            assert getHeader().size() == _currentDataSet.getSelectItems().length;
+            assert getHeader().size() == _currentDataSet.getSelectItems().size();
         }
         return true;
     }
index bc09f98..58c0da8 100644 (file)
@@ -25,6 +25,8 @@ import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.Table;
 
+import java.util.List;
+
 /**
  * Abstract implementation of the {@link RowInsertionBuilder} interface,
  * provided as a convenience to {@link RowInsertable} implementations. Handles
@@ -53,9 +55,9 @@ public abstract class AbstractRowInsertionBuilder<U extends UpdateCallback> exte
 
     @Override
     public RowInsertionBuilder like(Row row) {
-        SelectItem[] selectItems = row.getSelectItems();
-        for (int i = 0; i < selectItems.length; i++) {
-            SelectItem selectItem = selectItems[i];
+        List<SelectItem> selectItems = row.getSelectItems();
+        for (int i = 0; i < selectItems.size(); i++) {
+            SelectItem selectItem = selectItems.get(i);
             Column column = selectItem.getColumn();
             if (column != null) {
                 if (_table == column.getTable()) {
index f8c74cb..1811e78 100644 (file)
@@ -38,6 +38,10 @@ import org.apache.metamodel.schema.Table;
 import org.apache.metamodel.update.RowUpdationBuilder;
 import org.apache.metamodel.util.HasNameMapper;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class InterceptableDataContext implements UpdateableDataContext {
 
     private final DataContext _delegate;
@@ -189,27 +193,29 @@ public class InterceptableDataContext implements UpdateableDataContext {
     }
 
     @Override
-    public Schema[] getSchemas() throws MetaModelException {
-        Schema[] schemas = _delegate.getSchemas();
+    public List<Schema> getSchemas() throws MetaModelException {
+        List<Schema> schemas = _delegate.getSchemas();
+        List<Schema> result = new ArrayList<>(schemas.size());
         if (!_schemaInterceptors.isEmpty()) {
-            for (int i = 0; i < schemas.length; i++) {
-                schemas[i] = _schemaInterceptors.interceptAll(schemas[i]);
+            for (int i = 0; i < schemas.size(); i++) {
+                schemas.set(i, _schemaInterceptors.interceptAll(schemas.get(i)));
             }
+        }else {
+            result = schemas;
         }
-        return schemas;
+        return result;
+
     }
 
     @Override
-    public String[] getSchemaNames() throws MetaModelException {
+    public List<String> getSchemaNames() throws MetaModelException {
         if (_schemaInterceptors.isEmpty()) {
             return _delegate.getSchemaNames();
         }
-        Schema[] schemas = getSchemas();
-        String[] schemaNames = new String[schemas.length];
-        for (int i = 0; i < schemaNames.length; i++) {
-            schemaNames[i] = new HasNameMapper().apply(schemas[i]);
-        }
-        return schemaNames;
+
+        return getSchemas().stream()
+                .map(schema -> schema.getName())
+                .collect(Collectors.toList());
     }
 
     @Override
index 392c0bf..63eac69 100644 (file)
@@ -88,16 +88,16 @@ public class FromItem extends BaseObject implements QueryItem, Cloneable {
     public FromItem(JoinType join, Relationship relationship) {
         _join = join;
         _leftSide = new FromItem(relationship.getPrimaryTable());
-        Column[] columns = relationship.getPrimaryColumns();
-        _leftOn = new SelectItem[columns.length];
-        for (int i = 0; i < columns.length; i++) {
-            _leftOn[i] = new SelectItem(columns[i]);
+        List<Column> columns = relationship.getPrimaryColumns();
+        _leftOn = new SelectItem[columns.size()];
+        for (int i = 0; i < columns.size(); i++) {
+            _leftOn[i] = new SelectItem(columns.get(i));
         }
         _rightSide = new FromItem(relationship.getForeignTable());
         columns = relationship.getForeignColumns();
-        _rightOn = new SelectItem[columns.length];
-        for (int i = 0; i < columns.length; i++) {
-            _rightOn[i] = new SelectItem(columns[i]);
+        _rightOn = new SelectItem[columns.size()];
+        for (int i = 0; i < columns.size(); i++) {
+            _rightOn[i] = new SelectItem(columns.get(i));
         }
     }
 
index 7dc9278..e29b7dd 100644 (file)
@@ -92,6 +92,10 @@ public final class Query extends BaseObject implements Cloneable, Serializable {
         return select(selectItem);
     }
 
+    public Query select(List<Column> columns){
+        return select(columns.toArray(new Column[columns.size()]));
+    }
+
     public Query select(Column... columns) {
         for (Column column : columns) {
             SelectItem selectItem = new SelectItem(column);
@@ -164,7 +168,7 @@ public final class Query extends BaseObject implements Cloneable, Serializable {
 
     public Query selectAll(final FromItem fromItem) {
         if (fromItem.getTable() != null) {
-            final Column[] columns = fromItem.getTable().getColumns();
+            final List<Column> columns = fromItem.getTable().getColumns();
             for (final Column column : columns) {
                 select(column, fromItem);
             }
@@ -242,6 +246,14 @@ public final class Query extends BaseObject implements Cloneable, Serializable {
         return this;
     }
 
+    public Query groupBy(List<Column> columns) {
+        for (Column column : columns) {
+            SelectItem selectItem = new SelectItem(column).setQuery(this);
+            _groupByClause.addItem(new GroupByItem(selectItem));
+        }
+        return this;
+    }
+
     public Query orderBy(OrderByItem... items) {
         _orderByClause.addItems(items);
         return this;
index d73ae8f..904b657 100644 (file)
@@ -198,7 +198,7 @@ final class GroupedQueryBuilderImpl extends BaseObject implements GroupedQueryBu
                 final Table table = fromItem.getTable();
                 if (table != null) {
                     logger.debug("Table available in FROM item: {}. Column names: {}", table, Arrays.toString(table
-                            .getColumnNames()));
+                            .getColumnNames().toArray()));
                 }
             }
         }
index 2585bea..9248db6 100644 (file)
@@ -65,7 +65,7 @@ public final class InitFromBuilderImpl extends BaseObject implements InitFromBui
         Table table = schema.getTableByName(tableName);
         if (table == null) {
             throw new IllegalArgumentException("Nu such table '" + tableName + "' found in schema: " + schema
-                    + ". Available tables are: " + Arrays.toString(schema.getTableNames()));
+                    + ". Available tables are: " + Arrays.toString(schema.getTableNames().toArray()));
         }
         return from(table);
     }
index f1a706c..8984dca 100644 (file)
@@ -22,6 +22,8 @@ import org.apache.metamodel.query.FunctionType;
 import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.Table;
 
+import java.util.List;
+
 /**
  * Represents a builder where the FROM part is satisfied, ie. a SELECT clause is
  * now buildable.
@@ -47,7 +49,9 @@ public interface SatisfiedFromBuilder {
     public CountSelectBuilder<?> selectCount();
 
     public SatisfiedSelectBuilder<?> select(Column... columns);
-    
+
+    public SatisfiedSelectBuilder<?> select(List<Column> columns);
+
     public SatisfiedSelectBuilder<?> selectAll();
 
     public SatisfiedSelectBuilder<?> select(String selectExpression);
index 74831e9..4fb54ef 100644 (file)
@@ -150,6 +150,11 @@ abstract class SatisfiedFromBuilderCallback extends BaseObject implements Satisf
     }
 
     @Override
+    public SatisfiedSelectBuilder<?> select(List<Column> columns) {
+        return select(columns.toArray(new Column[columns.size()]));
+    }
+
+    @Override
     public SatisfiedSelectBuilder<?> select(String... columnNames) {
         if (columnNames == null) {
             throw new IllegalArgumentException("columnNames cannot be null");
index 88dd54e..cafa1c1 100644 (file)
@@ -27,16 +27,16 @@ public abstract class AbstractRelationship extends BaseObject implements
     
     private static final long serialVersionUID = 1L;
 
-       protected static Table checkSameTable(Column[] columns) {
-               if (columns == null || columns.length == 0) {
+       protected static Table checkSameTable(List<Column> columns) {
+               if (columns == null || columns.size() == 0) {
                        throw new IllegalArgumentException(
                                        "At least one key-column must exist on both "
                                                        + "primary and foreign side for "
                                                        + "a relation to exist.");
                }
                Table table = null;
-               for (int i = 0; i < columns.length; i++) {
-                       Column column = columns[i];
+               for (int i = 0; i < columns.size(); i++) {
+                       Column column = columns.get(i);
                        if (i == 0) {
                                table = column.getTable();
                        } else {
@@ -51,12 +51,12 @@ public abstract class AbstractRelationship extends BaseObject implements
 
        @Override
        public Table getForeignTable() {
-               return getForeignColumns()[0].getTable();
+               return getForeignColumns().get(0).getTable();
        }
 
        @Override
        public Table getPrimaryTable() {
-               return getPrimaryColumns()[0].getTable();
+               return getPrimaryColumns().get(0).getTable();
        }
 
        @Override
@@ -64,23 +64,23 @@ public abstract class AbstractRelationship extends BaseObject implements
                StringBuilder sb = new StringBuilder();
                sb.append("Relationship[");
                sb.append("primaryTable=" + getPrimaryTable().getName());
-               Column[] columns = getPrimaryColumns();
+               List<Column> columns = getPrimaryColumns();
                sb.append(",primaryColumns=[");
-               for (int i = 0; i < columns.length; i++) {
+               for (int i = 0; i < columns.size(); i++) {
                        if (i != 0) {
                                sb.append(", ");
                        }
-                       sb.append(columns[i].getName());
+                       sb.append(columns.get(i).getName());
                }
                sb.append("]");
                sb.append(",foreignTable=" + getForeignTable().getName());
                columns = getForeignColumns();
                sb.append(",foreignColumns=[");
-               for (int i = 0; i < columns.length; i++) {
+               for (int i = 0; i < columns.size(); i++) {
                        if (i != 0) {
                                sb.append(", ");
                        }
-                       sb.append(columns[i].getName());
+                       sb.append(columns.get(i).getName());
                }
                sb.append("]");
                sb.append("]");
@@ -105,11 +105,11 @@ public abstract class AbstractRelationship extends BaseObject implements
        @Override
        public boolean containsColumnPair(Column pkColumn, Column fkColumn) {
                if (pkColumn != null && fkColumn != null) {
-                       Column[] primaryColumns = getPrimaryColumns();
-                       Column[] foreignColumns = getForeignColumns();
-                       for (int i = 0; i < primaryColumns.length; i++) {
-                               if (pkColumn.equals(primaryColumns[i])
-                                               && fkColumn.equals(foreignColumns[i])) {
+                       List<Column> primaryColumns = getPrimaryColumns();
+                       List<Column> foreignColumns = getForeignColumns();
+                       for (int i = 0; i < primaryColumns.size(); i++) {
+                               if (pkColumn.equals(primaryColumns.get(i))
+                                               && fkColumn.equals(foreignColumns.get(i))) {
                                        return true;
                                }
                        }
index e44737a..df4a033 100644 (file)
  */
 package org.apache.metamodel.schema;
 
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.util.CollectionUtils;
 import org.apache.metamodel.util.EqualsBuilder;
@@ -49,22 +47,15 @@ public abstract class AbstractSchema implements Schema {
     }
 
     @Override
-    public Relationship[] getRelationships() {
-        final Set<Relationship> result = new LinkedHashSet<Relationship>();
-        CollectionUtils.forEach(getTables(), table -> {
-            final Relationship[] relations = table.getRelationships();
-            for (int i = 0; i < relations.length; i++) {
-                final Relationship relation = relations[i];
-                result.add(relation);
-            }
-        });
-        return result.toArray(new Relationship[result.size()]);
+    public Collection<Relationship> getRelationships() {
+        return getTables().stream()
+                .flatMap(tab -> tab.getRelationships().stream())
+                .collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     @Override
     public Table getTable(int index) throws IndexOutOfBoundsException {
-        Table[] tables = getTables();
-        return tables[index];
+        return getTables().get(index);
     }
 
     @Override
@@ -74,24 +65,24 @@ public abstract class AbstractSchema implements Schema {
 
     @Override
     public final int getTableCount(TableType type) {
-        return getTables(type).length;
+        return getTables(type).size();
     }
 
     @Override
     public final int getRelationshipCount() {
-        return getRelationships().length;
+        return getRelationships().size();
     }
 
     @Override
     public final int getTableCount() {
-        return getTables().length;
+        return getTables().size();
     }
 
     @Override
-    public final Table[] getTables(final TableType type) {
-        return CollectionUtils.filter(getTables(), table -> {
-            return table.getType() == type;
-        }).toArray(new Table[0]);
+    public final List<Table> getTables(final TableType type) {
+        return  getTables().stream()
+                .filter(table -> table.getType().equals(type))
+                .collect(Collectors.toList());
     }
 
     @Override
@@ -131,9 +122,10 @@ public abstract class AbstractSchema implements Schema {
     }
 
     @Override
-    public final String[] getTableNames() {
-        Table[] tables = getTables();
-        return CollectionUtils.map(tables, new HasNameMapper()).toArray(new String[tables.length]);
+    public final List<String> getTableNames() {
+        return getTables().stream()
+                .map(table -> table.getName())
+                .collect(Collectors.toList());
     }
 
     @Override
index 4f5ad7f..6e5b55f 100644 (file)
  */
 package org.apache.metamodel.schema;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.MetaModelHelper;
 import org.apache.metamodel.util.CollectionUtils;
-import org.apache.metamodel.util.HasNameMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -42,13 +38,12 @@ public abstract class AbstractTable implements Table {
 
     @Override
     public final int getColumnCount() {
-        return getColumns().length;
+        return getColumns().size();
     }
 
     @Override
     public Column getColumn(int index) throws IndexOutOfBoundsException {
-        Column[] columns = getColumns();
-        return columns[index];
+        return getColumns().get(index);
     }
 
     @Override
@@ -93,112 +88,102 @@ public abstract class AbstractTable implements Table {
 
     @Override
     public final int getRelationshipCount() {
-        return getRelationships().length;
+        return getRelationships().size();
     }
 
     @Override
-    public final Column[] getNumberColumns() {
-        return CollectionUtils.filter(getColumns(), new Predicate<Column>() {
-            @Override
-            public boolean test(Column col) {
-                ColumnType type = col.getType();
-                return type != null && type.isNumber();
-            }
-        }).toArray(new Column[0]);
+    public final List<Column> getNumberColumns() {
+        return getColumnsOfSuperType(SuperColumnType.NUMBER_TYPE);
     }
 
     @Override
-    public final Column[] getLiteralColumns() {
-        return CollectionUtils.filter(getColumns(), new Predicate<Column>() {
-            @Override
-            public boolean test(Column col) {
-                ColumnType type = col.getType();
-                return type != null && type.isLiteral();
-            }
-        }).toArray(new Column[0]);
+    public final List<Column> getLiteralColumns() {
+        return getColumnsOfSuperType(SuperColumnType.LITERAL_TYPE);
     }
 
     @Override
-    public final Column[] getTimeBasedColumns() {
-        return CollectionUtils.filter(getColumns(), col -> {
-            final ColumnType type = col.getType();
-            return type != null && type.isTimeBased();
-        }).toArray(new Column[0]);
+    public final List<Column> getTimeBasedColumns() {
+        return getColumnsOfSuperType(SuperColumnType.TIME_TYPE);
     }
 
     @Override
-    public final Column[] getBooleanColumns() {
-        return CollectionUtils.filter(getColumns(), col -> {
-            final ColumnType type = col.getType();
-            return type != null && type.isBoolean();
-        }).toArray(new Column[0]);
+    public final List<Column> getBooleanColumns() {
+        return getColumnsOfSuperType(SuperColumnType.BOOLEAN_TYPE);
     }
 
     @Override
-    public final Column[] getIndexedColumns() {
-        return CollectionUtils.filter(getColumns(), Column::isIndexed).toArray(new Column[0]);
+    public final List<Column> getIndexedColumns() {
+        return getColumns().stream()
+                .filter(Column::isIndexed)
+                .collect(Collectors.toList());
     }
 
     @Override
-    public final Relationship[] getForeignKeyRelationships() {
+    public final Collection<Relationship> getForeignKeyRelationships() {
         return CollectionUtils.filter(getRelationships(), rel -> {
             return AbstractTable.this.equals(rel.getForeignTable());
-        }).toArray(new Relationship[0]);
+        });
     }
 
     @Override
-    public final Relationship[] getPrimaryKeyRelationships() {
+    public final List<Relationship> getPrimaryKeyRelationships() {
         return CollectionUtils.filter(getRelationships(), rel -> {
             return AbstractTable.this.equals(rel.getPrimaryTable());
-        }).toArray(new Relationship[0]);
+        });
     }
 
     @Override
-    public final Column[] getForeignKeys() {
-        final Set<Column> columns = new HashSet<Column>();
-        final Relationship[] relationships = getForeignKeyRelationships();
+    public final List<Column> getForeignKeys() {
+        final Set<Column> columns = new LinkedHashSet<>();
+        final Collection<Relationship> relationships = getForeignKeyRelationships();
         CollectionUtils.forEach(relationships, rel -> {
-            Column[] foreignColumns = rel.getForeignColumns();
+            List<Column> foreignColumns = rel.getForeignColumns();
             for (Column column : foreignColumns) {
                 columns.add(column);
             }
         });
-        return columns.toArray(new Column[columns.size()]);
+        return new ArrayList<>(columns);
     }
 
     @Override
-    public final Column[] getPrimaryKeys() {
+    public final List<Column> getPrimaryKeys() {
         final List<Column> primaryKeyColumns = new ArrayList<Column>();
-        final Column[] columnsInTable = getColumns();
+        final List<Column> columnsInTable = getColumns();
         for (Column column : columnsInTable) {
             if (column.isPrimaryKey()) {
                 primaryKeyColumns.add(column);
             }
         }
-        return primaryKeyColumns.toArray(new Column[primaryKeyColumns.size()]);
+        return primaryKeyColumns;
     }
 
     @Override
-    public final String[] getColumnNames() {
-        Column[] columns = getColumns();
-        return CollectionUtils.map(columns, new HasNameMapper()).toArray(new String[columns.length]);
+    public final List<String> getColumnNames() {
+        return getColumns().stream()
+                .map(col -> col.getName())
+                .collect(Collectors.toList());
     }
 
     @Override
-    public final Column[] getColumnsOfType(ColumnType columnType) {
-        Column[] columns = getColumns();
-        return MetaModelHelper.getColumnsByType(columns, columnType);
+    public final List<Column> getColumnsOfType(ColumnType columnType) {
+        return getColumns().stream()
+                .filter(col -> col.getType()!=null)
+                .filter((col -> col.getType().equals(columnType)))
+                .collect(Collectors.toList());
     }
 
+
+
     @Override
-    public final Column[] getColumnsOfSuperType(final SuperColumnType superColumnType) {
-        Column[] columns = getColumns();
-        return MetaModelHelper.getColumnsBySuperType(columns, superColumnType);
+    public final List<Column> getColumnsOfSuperType(final SuperColumnType superColumnType) {
+        return getColumns().stream() .filter(col -> col.getType()!=null)
+                .filter((col -> col.getType().getSuperType().equals(superColumnType)))
+                .collect(Collectors.toList());
     }
 
     @Override
-    public final Relationship[] getRelationships(final Table otherTable) {
-        Relationship[] relationships = getRelationships();
+    public final Collection<Relationship> getRelationships(final Table otherTable) {
+        Collection<Relationship> relationships = getRelationships();
 
         return CollectionUtils.filter(relationships, relation -> {
             if (relation.getForeignTable() == otherTable && relation.getPrimaryTable() == AbstractTable.this) {
@@ -207,7 +192,7 @@ public abstract class AbstractTable implements Table {
                 return true;
             }
             return false;
-        }).toArray(new Relationship[0]);
+        });
     }
 
     @Override
@@ -270,12 +255,12 @@ public abstract class AbstractTable implements Table {
             }
 
             try {
-                final String[] columnNames1 = getColumnNames();
-                final String[] columnNames2 = other.getColumnNames();
+                final List<String> columnNames1 = getColumnNames();
+                final List<String> columnNames2 = other.getColumnNames();
 
-                if (columnNames1 != null && columnNames1.length != 0) {
-                    if (columnNames2 != null && columnNames2.length != 0) {
-                        if (!Arrays.equals(columnNames1, columnNames2)) {
+                if (columnNames1 != null && columnNames1.size() != 0) {
+                    if (columnNames2 != null && columnNames2.size() != 0) {
+                        if (!columnNames1.equals(columnNames2)) {
                             return false;
                         }
                     }
index 68cfecf..4e5a569 100644 (file)
@@ -20,7 +20,9 @@ package org.apache.metamodel.schema;
 
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.DataContext;
 import org.apache.metamodel.util.CollectionUtils;
@@ -60,21 +62,17 @@ public class CompositeSchema extends AbstractSchema {
     }
 
     @Override
-    public Relationship[] getRelationships() {
-        Relationship[] result = new Relationship[0];
-        for (Schema delegate : delegates) {
-            result = CollectionUtils.array(result, delegate.getRelationships());
-        }
-        return result;
+    public List<Relationship> getRelationships() {
+        return delegates.stream()
+                .flatMap(delegate -> delegate.getRelationships().stream())
+                .collect(Collectors.toList());
     }
 
     @Override
-    public Table[] getTables() {
-        Table[] result = new Table[0];
-        for (Schema delegate : delegates) {
-            result = CollectionUtils.array(result, delegate.getTables());
-        }
-        return result;
+    public List<Table> getTables() {
+        return delegates.stream()
+                .flatMap(delegate -> delegate.getTables().stream())
+                .collect(Collectors.toList());
     }
 
     @Override
index 2bcf95b..b930359 100644 (file)
 package org.apache.metamodel.schema;
 
 import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
 
 public final class ImmutableRelationship extends AbstractRelationship implements Serializable {
 
        private static final long serialVersionUID = 1L;
 
-       private final Column[] primaryColumns;
-       private final Column[] foreignColumns;
+       private final List<Column> primaryColumns;
+       private final List<Column> foreignColumns;
 
        public static void create(Relationship origRelationship,
                        ImmutableSchema schema) {
                ImmutableTable primaryTable = getSimilarTable(
                                origRelationship.getPrimaryTable(), schema);
                assert primaryTable != null;
-               Column[] primaryColumns = getSimilarColumns(
+               List<Column> primaryColumns = getSimilarColumns(
                                origRelationship.getPrimaryColumns(), primaryTable);
                checkSameTable(primaryColumns);
 
                ImmutableTable foreignTable = getSimilarTable(
                                origRelationship.getForeignTable(), schema);
                assert foreignTable != null;
-               Column[] foreignColumns = getSimilarColumns(
+               List<Column> foreignColumns = getSimilarColumns(
                                origRelationship.getForeignColumns(), foreignTable);
                checkSameTable(foreignColumns);
 
@@ -49,13 +52,11 @@ public final class ImmutableRelationship extends AbstractRelationship implements
                foreignTable.addRelationship(relationship);
        }
 
-       private static Column[] getSimilarColumns(Column[] columns, Table table) {
-               Column[] result = new Column[columns.length];
-               for (int i = 0; i < columns.length; i++) {
-                       String name = columns[i].getName();
-                       result[i] = table.getColumnByName(name);
-               }
-               return result;
+       private static List<Column> getSimilarColumns(List<Column> columns, Table table) {
+               return columns.stream()
+                               .map( col -> table.getColumnByName(col.getName()))
+                               .collect(Collectors.toList());
+
        }
 
        private static ImmutableTable getSimilarTable(Table table,
@@ -64,19 +65,19 @@ public final class ImmutableRelationship extends AbstractRelationship implements
                return (ImmutableTable) schema.getTableByName(name);
        }
 
-       private ImmutableRelationship(Column[] primaryColumns,
-                       Column[] foreignColumns) {
+       private ImmutableRelationship(List<Column> primaryColumns,
+                       List<Column> foreignColumns) {
                this.primaryColumns = primaryColumns;
                this.foreignColumns = foreignColumns;
        }
 
        @Override
-       public Column[] getPrimaryColumns() {
+       public List<Column> getPrimaryColumns() {
                return primaryColumns;
        }
 
        @Override
-       public Column[] getForeignColumns() {
+       public List<Column> getForeignColumns() {
                return foreignColumns;
        }
 }
index ddceb12..8da76eb 100644 (file)
@@ -20,6 +20,8 @@ package org.apache.metamodel.schema;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -42,20 +44,20 @@ public final class ImmutableSchema extends AbstractSchema implements
 
        public ImmutableSchema(Schema schema) {
                this(schema.getName(), schema.getQuote());
-               Table[] origTables = schema.getTables();
+               List<Table> origTables = schema.getTables();
                for (Table table : origTables) {
                        tables.add(new ImmutableTable(table, this));
                }
 
-               Relationship[] origRelationships = schema.getRelationships();
+               Collection<Relationship> origRelationships = schema.getRelationships();
                for (Relationship relationship : origRelationships) {
                        ImmutableRelationship.create(relationship, this);
                }
        }
 
        @Override
-       public Table[] getTables() {
-               return tables.toArray(new Table[tables.size()]);
+       public List<Table> getTables() {
+               return Collections.unmodifiableList(tables);
        }
 
        @Override
index d807290..150384c 100644 (file)
@@ -20,6 +20,8 @@ package org.apache.metamodel.schema;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -54,7 +56,7 @@ final class ImmutableTable extends AbstractTable implements Serializable {
        protected ImmutableTable(Table table, ImmutableSchema schema) {
                this(table.getName(), table.getType(), schema, table.getRemarks(),
                                table.getQuote());
-               Column[] origColumns = table.getColumns();
+               List<Column> origColumns = table.getColumns();
                for (Column column : origColumns) {
                        columns.add(new ImmutableColumn(column, this));
                }
@@ -67,8 +69,8 @@ final class ImmutableTable extends AbstractTable implements Serializable {
        }
 
        @Override
-       public Column[] getColumns() {
-               return columns.toArray(new Column[columns.size()]);
+       public List<Column> getColumns() {
+               return Collections.unmodifiableList(columns);
        }
 
        @Override
@@ -82,8 +84,8 @@ final class ImmutableTable extends AbstractTable implements Serializable {
        }
 
        @Override
-       public Relationship[] getRelationships() {
-               return relationships.toArray(new Relationship[relationships.size()]);
+       public Collection<Relationship> getRelationships() {
+               return Collections.unmodifiableCollection(relationships);
        }
 
        @Override
index e96c86c..466244c 100644 (file)
@@ -19,6 +19,8 @@
 package org.apache.metamodel.schema;
 
 import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -36,8 +38,8 @@ public class MutableRelationship extends AbstractRelationship implements
        private static final Logger logger = LoggerFactory
                        .getLogger(MutableRelationship.class);
 
-       private final Column[] _primaryColumns;
-       private final Column[] _foreignColumns;
+       private final List<Column> _primaryColumns;
+       private final List<Column> _foreignColumns;
 
        /**
         * Factory method to create relations between two tables by specifying which
@@ -49,8 +51,8 @@ public class MutableRelationship extends AbstractRelationship implements
         *            the columns from the foreign key table
         * @return the relation created
         */
-       public static Relationship createRelationship(Column[] primaryColumns,
-                       Column[] foreignColumns) {
+       public static Relationship createRelationship(List<Column> primaryColumns,
+                       List<Column> foreignColumns) {
                Table primaryTable = checkSameTable(primaryColumns);
                Table foreignTable = checkSameTable(foreignColumns);
                MutableRelationship relation = new MutableRelationship(primaryColumns,
@@ -105,25 +107,30 @@ public class MutableRelationship extends AbstractRelationship implements
 
        public static Relationship createRelationship(Column primaryColumn,
                        Column foreignColumn) {
-               return createRelationship(new Column[] { primaryColumn },
-                               new Column[] { foreignColumn });
+               List<Column> pcols = new ArrayList<>();
+               pcols.add(primaryColumn);
+               List<Column> fcols = new ArrayList<>();
+               pcols.add(foreignColumn);
+
+
+               return createRelationship(pcols, fcols);
        }
 
        /**
         * Prevent external instantiation
         */
-       private MutableRelationship(Column[] primaryColumns, Column[] foreignColumns) {
+       private MutableRelationship(List<Column> primaryColumns, List<Column> foreignColumns) {
                _primaryColumns = primaryColumns;
                _foreignColumns = foreignColumns;
        }
 
        @Override
-       public Column[] getPrimaryColumns() {
+       public List<Column> getPrimaryColumns() {
                return _primaryColumns;
        }
 
        @Override
-       public Column[] getForeignColumns() {
+       public List<Column> getForeignColumns() {
                return _foreignColumns;
        }
 
index c4cfe2e..29d361b 100644 (file)
@@ -21,6 +21,7 @@ package org.apache.metamodel.schema;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -63,9 +64,8 @@ public class MutableSchema extends AbstractSchema implements Serializable,
        }
 
        @Override
-       public MutableTable[] getTables() {
-               MutableTable[] array = new MutableTable[_tables.size()];
-               return _tables.toArray(array);
+       public List<Table> getTables() {
+               return Collections.unmodifiableList(_tables);
        }
 
        public MutableSchema setTables(Collection<? extends MutableTable> tables) {
index 904fc81..0b3475c 100644 (file)
@@ -21,6 +21,7 @@ package org.apache.metamodel.schema;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -100,9 +101,8 @@ public class MutableTable extends AbstractTable implements Serializable {
     }
 
     @Override
-    public Column[] getColumns() {
-        List<Column> columns = getColumnsInternal();
-        return columns.toArray(new Column[columns.size()]);
+    public List<Column> getColumns() {
+        return Collections.unmodifiableList(_columns);
     }
 
     public MutableTable setColumns(Column... columns) {
@@ -157,9 +157,8 @@ public class MutableTable extends AbstractTable implements Serializable {
     }
 
     @Override
-    public Relationship[] getRelationships() {
-        List<Relationship> relationships = getRelationshipsInternal();
-        return relationships.toArray(new Relationship[relationships.size()]);
+    public List<Relationship> getRelationships() {
+      return Collections.unmodifiableList(_relationships);
     }
 
     /**
index 1ae3132..12a5c8c 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.schema;
 
 import java.io.Serializable;
+import java.util.List;
 
 /**
  * Represents a relationship between two tables where one set of columns is the
@@ -41,7 +42,7 @@ public interface Relationship extends Serializable, Comparable<Relationship> {
         * 
         * @return an array of primary key columns.
         */
-       public Column[] getPrimaryColumns();
+       public List<Column> getPrimaryColumns();
 
        /**
         * Gets the table of the foreign key column(s).
@@ -55,7 +56,7 @@ public interface Relationship extends Serializable, Comparable<Relationship> {
         * 
         * @return an array of foreign key columns.
         */
-       public Column[] getForeignColumns();
+       public List<Column> getForeignColumns();
 
        /**
         * Determines whether this relationship contains a specific pair of columns
index 1184954..082acb1 100644 (file)
@@ -19,6 +19,8 @@
 package org.apache.metamodel.schema;
 
 import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
 
 import org.apache.metamodel.DataContext;
 
@@ -61,14 +63,14 @@ public interface Schema extends Comparable<Schema>, Serializable, NamedStructure
         * 
         * @return an array of table names.
         */
-       public String[] getTableNames();
+       public List<String> getTableNames();
 
        /**
         * Gets all tables in this Schema.
         * 
         * @return the tables that reside in the schema
         */
-       public Table[] getTables();
+       public List<Table> getTables();
 
        /**
         * Gets all tables in this Schema of a particular type.
@@ -78,7 +80,7 @@ public interface Schema extends Comparable<Schema>, Serializable, NamedStructure
         * @return an array of tables in this schema that matches the specified
         *         type.
         */
-       public Table[] getTables(TableType type);
+       public List<Table> getTables(TableType type);
 
        /**
         * Gets a table by index. Use {@link #getTableCount()} to get the (0-based)
@@ -108,7 +110,7 @@ public interface Schema extends Comparable<Schema>, Serializable, NamedStructure
         * 
         * @return an array of relationships.
         */
-       public Relationship[] getRelationships();
+       public Collection<Relationship> getRelationships();
 
        /**
         * Gets the number of relationships to and from this Schema.
index f5c6680..d549dba 100644 (file)
@@ -19,6 +19,8 @@
 package org.apache.metamodel.schema;
 
 import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
 
 /**
  * Represents a table and it's metadata description. Tables reside within a
@@ -49,7 +51,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * 
      * @return the columns of this table.
      */
-    public Column[] getColumns();
+    public List<Column> getColumns();
 
     /**
      * Convenience method for retrieving a column by it's name.
@@ -93,7 +95,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * @return all relationsips for this table. To add relations use
      *         TableRelation.createRelation();
      */
-    public Relationship[] getRelationships();
+    public Collection<Relationship> getRelationships();
 
     /**
      * Gets relationships between this table and another table.
@@ -102,7 +104,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      *            another table for which to find relationships to and from.
      * @return an array of relationsips between this and the other table.
      */
-    public Relationship[] getRelationships(Table otherTable);
+    public Collection<Relationship> getRelationships(Table otherTable);
 
     /**
      * Gets a count of relationships to and from this table.
@@ -124,7 +126,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * @return an array of columns.
      * @see ColumnType
      */
-    public Column[] getNumberColumns();
+    public List<Column> getNumberColumns();
 
     /**
      * Gets all of this table's columns that are of literal (String/text) type.
@@ -132,7 +134,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * @return an array of columns.
      * @see ColumnType
      */
-    public Column[] getLiteralColumns();
+    public List<Column> getLiteralColumns();
 
     /**
      * Gets all of this table's columns that are time and/or date based.
@@ -140,7 +142,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * @return an array of columns.
      * @see ColumnType
      */
-    public Column[] getTimeBasedColumns();
+    public List<Column> getTimeBasedColumns();
 
     /**
      * Gets all of this table's columns that are of boolean type.
@@ -148,24 +150,24 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * @return an array of columns.
      * @see ColumnType
      */
-    public Column[] getBooleanColumns();
+    public List<Column> getBooleanColumns();
 
     /**
      * Gets all of this table's columns that are indexed.
      * 
      * @return an array of columns.
      */
-    public Column[] getIndexedColumns();
+    public List<Column> getIndexedColumns();
 
     /**
      * @return the relationships where this table is the foreign table
      */
-    public Relationship[] getForeignKeyRelationships();
+    public Collection<Relationship> getForeignKeyRelationships();
 
     /**
      * @return the relationships where this table is the primary table
      */
-    public Relationship[] getPrimaryKeyRelationships();
+    public Collection<Relationship> getPrimaryKeyRelationships();
 
     /**
      * Gets the columns of this table that are known to be foreign keys (ie.
@@ -173,7 +175,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * 
      * @return an array of columns that are known to be foreign keys.
      */
-    public Column[] getForeignKeys();
+    public List<Column> getForeignKeys();
 
     /**
      * Gets the columns of this table that are known to be primary keys. See
@@ -181,14 +183,14 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      * 
      * @return an array of columns that are known to be primary keys.
      */
-    public Column[] getPrimaryKeys();
+    public List<Column> getPrimaryKeys();
 
     /**
      * Gets the names of this table's columns.
      * 
      * @return an array of column names.
      */
-    public String[] getColumnNames();
+    public List<String> getColumnNames();
 
     /**
      * Gets the columns of this table that conforms to a specified
@@ -198,7 +200,7 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      *            the column type to search for.
      * @return an array of columns that match the specified ColumnType.
      */
-    public Column[] getColumnsOfType(ColumnType columnType);
+    public List<Column> getColumnsOfType(ColumnType columnType);
 
     /**
      * Gets the columns of this table that conforms to a specified
@@ -208,6 +210,6 @@ public interface Table extends Comparable<Table>, Serializable, NamedStructure {
      *            the super type of the column
      * @return an array of columns that match the specified SuperColumnType.
      */
-    public Column[] getColumnsOfSuperType(SuperColumnType superColumnType);
+    public List<Column> getColumnsOfSuperType(SuperColumnType superColumnType);
 
 }
\ No newline at end of file
index ea8a9de..c526df5 100644 (file)
  */
 package org.apache.metamodel;
 
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.Map;
+import java.util.*;
 
+import com.google.common.collect.Lists;
+import javafx.scene.Scene;
 import junit.framework.TestCase;
 import org.apache.metamodel.data.DataSet;
 import org.apache.metamodel.query.Query;
@@ -57,8 +57,8 @@ public class AbstractDataContextTest extends TestCase {
         }
 
         @Override
-        protected String[] getSchemaNamesInternal() {
-            return _schemas.keySet().toArray(new String[0]);
+        protected List<String> getSchemaNamesInternal() {
+            return new ArrayList<>(_schemas.keySet());
         }
 
         @Override
@@ -154,8 +154,8 @@ public class AbstractDataContextTest extends TestCase {
             }
 
             @Override
-            protected String[] getSchemaNamesInternal() {
-                return new String[] { "test" };
+            protected List<String> getSchemaNamesInternal() {
+                return Lists.newArrayList("test");
             }
 
             @Override
@@ -209,12 +209,12 @@ public class AbstractDataContextTest extends TestCase {
 
     public void testGetSchemas() throws Exception {
         MyDataContext dc = new MyDataContext();
-        Schema[] schemas = dc.getSchemas();
-        assertEquals("[Schema[name=barfoo], Schema[name=foo.bar], Schema[name=foobar]]", Arrays.toString(schemas));
+        List<Schema> schemas = dc.getSchemas();
+        assertEquals("[Schema[name=barfoo], Schema[name=foo.bar], Schema[name=foobar]]", Arrays.toString(schemas.toArray()));
 
         dc.refreshSchemas();
         schemas = dc.getSchemas();
-        assertEquals("[Schema[name=barfoo], Schema[name=foo.bar], Schema[name=foobar]]", Arrays.toString(schemas));
+        assertEquals("[Schema[name=barfoo], Schema[name=foo.bar], Schema[name=foobar]]", Arrays.toString(schemas.toArray()));
     }
 
     public void testGetColumnByQualifiedLabelWithNameOverlaps() throws Exception {
@@ -226,8 +226,8 @@ public class AbstractDataContextTest extends TestCase {
             }
 
             @Override
-            protected String[] getSchemaNamesInternal() {
-                return new String[] { "sch" };
+            protected List<String> getSchemaNamesInternal() {
+                return Lists.newArrayList( "sch" );
             }
 
             @Override
index 61e0dcc..f2ae8e0 100644 (file)
@@ -42,11 +42,11 @@ public class CompositeDataContextTest extends TestCase {
                DataContext composite = new CompositeDataContext(dc1, dc2);
 
                assertEquals("[schema1, schema2]",
-                               Arrays.toString(composite.getSchemaNames()));
+                               Arrays.toString(composite.getSchemaNames().toArray()));
                assertSame(dc1.getDefaultSchema(), composite.getDefaultSchema());
 
                DataSet ds = composite.query()
-                               .from(dc1.getDefaultSchema().getTables()[0]).select("foo")
+                               .from(dc1.getDefaultSchema().getTables().get(0)).select("foo")
                                .execute();
                List<Object[]> objectArrays = ds.toObjectArrays();
                assertEquals("1", objectArrays.get(0)[0]);
@@ -61,12 +61,12 @@ public class CompositeDataContextTest extends TestCase {
                DataContext composite = new CompositeDataContext(dc1, dc2);
 
                assertEquals("[schema]",
-                               Arrays.toString(composite.getSchemaNames()));
+                               Arrays.toString(composite.getSchemaNames().toArray()));
 
                Schema schema = composite.getDefaultSchema();
                assertEquals(4, schema.getTableCount());
                assertEquals("[table1, an_empty_table, table2, an_empty_table]",
-                               Arrays.toString(schema.getTableNames()));
+                               Arrays.toString(schema.getTableNames().toArray()));
                assertTrue(schema instanceof CompositeSchema);
        }
 
@@ -77,15 +77,14 @@ public class CompositeDataContextTest extends TestCase {
                DataContext composite = new CompositeDataContext(dc1, dc2);
 
                assertEquals("[schema]",
-                               Arrays.toString(composite.getSchemaNames()));
+                               Arrays.toString(composite.getSchemaNames().toArray()));
 
                Schema schema = composite.getDefaultSchema();
                assertEquals(4, schema.getTableCount());
-               assertEquals("[table, an_empty_table, table, an_empty_table]", Arrays.toString(schema.getTableNames()));
+               assertEquals("[table, an_empty_table, table, an_empty_table]", Arrays.toString(schema.getTableNames().toArray()));
                assertTrue(schema instanceof CompositeSchema);
-               Table[] tables = schema.getTables();
-        Table table1 = tables[0];
-        Table table2 = tables[2];
+        Table table1 = schema.getTable(0);
+        Table table2 = schema.getTable(2);
         assertNotSame(table1, table2);
 
                Query q = composite
index 540aa95..84a09b2 100644 (file)
@@ -22,6 +22,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import com.google.common.collect.Lists;
 import org.apache.metamodel.data.DataSet;
 import org.apache.metamodel.data.DataSetHeader;
 import org.apache.metamodel.data.DefaultRow;
@@ -66,8 +67,8 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         data2.add(new Object[] { 2, "bad boy", "bb" });
         data2.add(new Object[] { 4, "trying harder", "try" });
 
-        DataSet ds1 = createDataSet(new SelectItem[] { si1, si2, si3, si4 }, data1);
-        DataSet ds2 = createDataSet(new SelectItem[] { si5, si6, si7 }, data2);
+        DataSet ds1 = createDataSet(Lists.newArrayList(si1, si2, si3, si4 ), data1);
+        DataSet ds2 = createDataSet(Lists.newArrayList(si5, si6, si7 ), data2);
         FilterItem[] onConditions = new FilterItem[1];
         onConditions[0] = new FilterItem(si4, OperatorType.EQUALS_TO, si5);
 
@@ -100,8 +101,8 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         data2.add(new Object[] { 2, "bad boy", "bb" });
         data2.add(new Object[] { 4, "trying harder", "try" });
 
-        DataSet ds1 = createDataSet(new SelectItem[] { si1, si2, si3, si4 }, data1);
-        DataSet ds2 = createDataSet(new SelectItem[] { si5, si6, si7 }, data2);
+        DataSet ds1 = createDataSet(Lists.newArrayList(si1, si2, si3, si4 ), data1);
+        DataSet ds2 = createDataSet(Lists.newArrayList( si5, si6, si7 ), data2);
         FilterItem[] onConditions = new FilterItem[1];
         onConditions[0] = new FilterItem(si4, OperatorType.EQUALS_TO, si5);
 
@@ -116,7 +117,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
     public void testSimpleCarthesianProduct() throws Exception {
         DataSet dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), createDataSet2());
 
-        assertEquals(2, dataSet.getSelectItems().length);
+        assertEquals(2, dataSet.getSelectItems().size());
         assertTrue(dataSet.next());
         assertEquals("Row[values=[f, b]]", dataSet.getRow().toString());
         assertTrue(dataSet.next());
@@ -134,7 +135,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
 
     public void testTripleCarthesianProduct() throws Exception {
         DataSet dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), createDataSet2(), createDataSet3());
-        assertEquals(4, dataSet.getSelectItems().length);
+        assertEquals(4, dataSet.getSelectItems().size());
         for (int i = 0; i < 3 * 3 * 2; i++) {
             assertTrue("Assertion failed at i=" + i, dataSet.next());
         }
@@ -145,9 +146,9 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         DataSet ds1 = createDataSet1();
         DataSet ds2 = createDataSet2();
         DataSet[] dataSets = new DataSet[] { ds1, ds2, };
-        FilterItem w1 = new FilterItem(ds1.getSelectItems()[0], OperatorType.EQUALS_TO, "f");
+        FilterItem w1 = new FilterItem(ds1.getSelectItems().get(0), OperatorType.EQUALS_TO, "f");
         DataSet dataSet = MetaModelHelper.getCarthesianProduct(dataSets, w1);
-        assertEquals(2, dataSet.getSelectItems().length);
+        assertEquals(2, dataSet.getSelectItems().size());
         for (int i = 0; i < 1 * 3; i++) {
             assertTrue("Assertion failed at i=" + i, dataSet.next());
             assertEquals("f", dataSet.getRow().getValue(0));
@@ -157,22 +158,22 @@ public class MetaModelHelperTest extends MetaModelTestCase {
 
     public void testGetCarthesianProductNoRows() throws Exception {
         DataSet dataSet = MetaModelHelper.getCarthesianProduct(createDataSet4(), createDataSet2(), createDataSet3());
-        assertEquals(4, dataSet.getSelectItems().length);
+        assertEquals(4, dataSet.getSelectItems().size());
         assertFalse(dataSet.next());
 
         dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), createDataSet4(), createDataSet3());
-        assertEquals(4, dataSet.getSelectItems().length);
+        assertEquals(4, dataSet.getSelectItems().size());
         assertFalse(dataSet.next());
 
         dataSet = MetaModelHelper.getCarthesianProduct(createDataSet1(), createDataSet2(), createDataSet4());
-        assertEquals(3, dataSet.getSelectItems().length);
+        assertEquals(3, dataSet.getSelectItems().size());
         assertFalse(dataSet.next());
     }
 
     public void testGetOrdered() throws Exception {
         DataSet dataSet = createDataSet3();
         List<OrderByItem> orderByItems = new ArrayList<OrderByItem>();
-        orderByItems.add(new OrderByItem(dataSet.getSelectItems()[0]));
+        orderByItems.add(new OrderByItem(dataSet.getSelectItems().get(0)));
 
         dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems);
         assertTrue(dataSet.next());
@@ -188,7 +189,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         data1.add(new Object[] { "o" });
         data1.add(new Object[] { "o" });
         DataSet dataSet1 = createDataSet(
-                new SelectItem[] { new SelectItem(new MutableColumn("foo", ColumnType.VARCHAR)) }, data1);
+                Lists.newArrayList( new SelectItem(new MutableColumn("foo", ColumnType.VARCHAR)) ), data1);
         return dataSet1;
     }
 
@@ -197,7 +198,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         data2.add(new Object[] { "b" });
         data2.add(new Object[] { "a" });
         data2.add(new Object[] { "r" });
-        DataSet dataSet2 = createDataSet(new SelectItem[] { new SelectItem("bar", "bar") }, data2);
+        DataSet dataSet2 = createDataSet(Lists.newArrayList(new SelectItem("bar", "bar") ), data2);
         return dataSet2;
     }
 
@@ -205,14 +206,14 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         List<Object[]> data3 = new ArrayList<Object[]>();
         data3.add(new Object[] { "w00p", true });
         data3.add(new Object[] { "yippie", false });
-        DataSet dataSet3 = createDataSet(new SelectItem[] { new SelectItem("expression", "e"),
-                new SelectItem("webish?", "w") }, data3);
+        DataSet dataSet3 = createDataSet(Lists.newArrayList(new SelectItem("expression", "e"),
+                new SelectItem("webish?", "w") ), data3);
         return dataSet3;
     }
 
     private DataSet createDataSet4() {
         List<Object[]> data4 = new ArrayList<Object[]>();
-        DataSet dataSet4 = createDataSet(new SelectItem[] { new SelectItem("abc", "abc") }, data4);
+        DataSet dataSet4 = createDataSet(Lists.newArrayList(new SelectItem("abc", "abc") ), data4);
         return dataSet4;
     }
 
@@ -294,7 +295,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
         DataSet ds = MetaModelHelper.getSelection(selectItems2, new EmptyDataSet(selectItems1));
         assertEquals(SubSelectionDataSet.class, ds.getClass());
 
-        assertEquals("[bar AS b, foo AS f]", Arrays.toString(ds.getSelectItems()));
+        assertEquals("[bar AS b, foo AS f]", Arrays.toString(ds.getSelectItems().toArray()));
     }
 
     public void testLeftJoinNoRowsOrSingleRow() throws Exception {
@@ -311,7 +312,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
                 OperatorType.EQUALS_TO, item3) });
 
         assertEquals(SubSelectionDataSet.class, joinedDs.getClass());
-        assertEquals("[foo AS f, bar AS b, baz AS z]", Arrays.toString(joinedDs.getSelectItems()));
+        assertEquals("[foo AS f, bar AS b, baz AS z]", Arrays.toString(joinedDs.getSelectItems().toArray()));
 
         DataSetHeader header1 = new SimpleDataSetHeader(selectItems1);
         Row row = new DefaultRow(header1, new Object[] { 1, 2 }, null);
@@ -319,7 +320,7 @@ public class MetaModelHelperTest extends MetaModelTestCase {
 
         joinedDs = MetaModelHelper.getLeftJoin(ds1, ds2, new FilterItem[] { new FilterItem(item2,
                 OperatorType.EQUALS_TO, item3) });
-        assertEquals("[foo AS f, bar AS b, baz AS z]", Arrays.toString(joinedDs.getSelectItems()));
+        assertEquals("[foo AS f, bar AS b, baz AS z]", Arrays.toString(joinedDs.getSelectItems().toArray()));
         assertTrue(joinedDs.next());
         assertEquals("Row[values=[1, 2, null]]", joinedDs.getRow().toString());
         assertFalse(joinedDs.next());
index 3e1e5a9..56d57c8 100644 (file)
@@ -124,25 +124,25 @@ public abstract class MetaModelTestCase extends TestCase {
         table4.setColumns(columnList);
 
         // one-Contributor-to-many-Role's
-        MutableRelationship.createRelationship(new Column[] { column1 }, new Column[] { column8 });
+        MutableRelationship.createRelationship( column1 , column8 );
 
         // one-Project-to-many-Role's
-        MutableRelationship.createRelationship(new Column[] { column4 }, new Column[] { column9 });
+        MutableRelationship.createRelationship(column4 , column9 );
 
         // view relation [contributor -> contributor_name]
-        MutableRelationship.createRelationship(new Column[] { column2 }, new Column[] { column11 });
+        MutableRelationship.createRelationship(column2 , column11 );
 
         // view relation [project -> project_name]
-        MutableRelationship.createRelationship(new Column[] { column5 }, new Column[] { column12 });
+        MutableRelationship.createRelationship(column5 , column12 );
 
         // view relation [role -> role_name]
-        MutableRelationship.createRelationship(new Column[] { column10 }, new Column[] { column13 });
+        MutableRelationship.createRelationship( column10 ,  column13 );
 
         schema.setTables(table1, table2, table3, table4);
         return schema;
     }
 
-    protected static DataSet createDataSet(SelectItem[] selectItems, List<Object[]> data) {
+    protected static DataSet createDataSet(List<SelectItem> selectItems, List<Object[]> data) {
         if (data.isEmpty()) {
             return new EmptyDataSet(selectItems);
         }
@@ -179,7 +179,7 @@ public abstract class MetaModelTestCase extends TestCase {
     }
 
     public void assertEquals(DataSet ds1, DataSet ds2) {
-        assertEquals(Arrays.toString(ds1.getSelectItems()), Arrays.toString(ds2.getSelectItems()));
+        assertEquals(Arrays.toString(ds1.getSelectItems().toArray()), Arrays.toString(ds2.getSelectItems().toArray()));
         boolean ds1next = true;
         while (ds1next) {
             ds1next = ds1.next();
index 74d2464..0c217f2 100644 (file)
@@ -20,6 +20,7 @@ package org.apache.metamodel;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.data.CachingDataSetHeader;
 import org.apache.metamodel.data.DataSet;
@@ -79,9 +80,9 @@ public class MockDataContext extends QueryPostprocessDataContext {
     }
 
     @Override
-    protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+    protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
         if (_tableName.equals(table.getName())) {
-            final SelectItem[] allSelectItems = MetaModelHelper.createSelectItems(table.getColumns());
+            final List<SelectItem> allSelectItems = table.getColumns().stream().map(SelectItem::new).collect(Collectors.toList());
             final DataSetHeader header = new CachingDataSetHeader(allSelectItems);
             final List<Row> data = new ArrayList<Row>();
             data.add(new DefaultRow(header, new Object[] { "1", "hello", "world" }, null));
@@ -91,11 +92,11 @@ public class MockDataContext extends QueryPostprocessDataContext {
 
             final DataSet sourceDataSet = new InMemoryDataSet(header, data);
 
-            final SelectItem[] columnSelectItems = MetaModelHelper.createSelectItems(columns);
+            final List<SelectItem> columnSelectItems = columns.stream().map(SelectItem::new).collect(Collectors.toList());
             final DataSet selectionDataSet = MetaModelHelper.getSelection(columnSelectItems, sourceDataSet);
             return selectionDataSet;
         } else if ("an_empty_table".equals(table.getName())) {
-            return new EmptyDataSet(columns);
+            return new EmptyDataSet(columns.stream().map(SelectItem::new).collect(Collectors.toList()));
         }
         throw new UnsupportedOperationException();
     }
index 8d6d48e..4e6563a 100644 (file)
@@ -21,6 +21,7 @@ package org.apache.metamodel;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.apache.metamodel.create.TableCreationBuilder;
 import org.apache.metamodel.data.CachingDataSetHeader;
@@ -68,16 +69,16 @@ public class MockUpdateableDataContext extends QueryPostprocessDataContext imple
     }
 
     @Override
-    protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+    protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
 
         List<Row> rows = new ArrayList<Row>();
-        SelectItem[] items = MetaModelHelper.createSelectItems(columns);
+        List<SelectItem> items = columns.stream().map(SelectItem::new).collect(Collectors.toList());
         CachingDataSetHeader header = new CachingDataSetHeader(items);
 
         for (final Object[] values : _values) {
-            Object[] rowValues = new Object[columns.length];
-            for (int i = 0; i < columns.length; i++) {
-                int columnNumber = columns[i].getColumnNumber();
+            Object[] rowValues = new Object[columns.size()];
+            for (int i = 0; i < columns.size(); i++) {
+                int columnNumber = columns.get(i).getColumnNumber();
                 rowValues[i] = values[columnNumber];
             }
             rows.add(new DefaultRow(header, rowValues));
@@ -161,7 +162,7 @@ public class MockUpdateableDataContext extends QueryPostprocessDataContext imple
     }
 
     private void delete(List<FilterItem> whereItems) {
-        final SelectItem[] selectItems = MetaModelHelper.createSelectItems(_table.getColumns());
+        final List<SelectItem> selectItems = _table.getColumns().stream().map(SelectItem::new).collect(Collectors.toList());
         final CachingDataSetHeader header = new CachingDataSetHeader(selectItems);
         for (Iterator<Object[]> it = _values.iterator(); it.hasNext();) {
             Object[] values = (Object[]) it.next();
index d6955a9..f6352d4 100644 (file)
@@ -22,6 +22,7 @@ import java.nio.channels.UnsupportedAddressTypeException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import javax.swing.table.TableModel;
 
@@ -61,7 +62,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testQueryMaxRows0() throws Exception {
         final MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        final Table table = dc.getDefaultSchema().getTables()[0];
+        final Table table = dc.getDefaultSchema().getTable(0);
         final DataSet dataSet = dc.query().from(table).selectAll().limit(0).execute();
         assertTrue(dataSet instanceof EmptyDataSet);
         assertFalse(dataSet.next());
@@ -77,12 +78,12 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
         final QueryPostprocessDataContext dc = new QueryPostprocessDataContext() {
             @Override
-            protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
-                Object[] values = new Object[columns.length];
-                for (int i = 0; i < columns.length; i++) {
-                    values[i] = columns[i].getColumnNumber();
+            protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
+                Object[] values = new Object[columns.size()];
+                for (int i = 0; i < columns.size(); i++) {
+                    values[i] = columns.get(i).getColumnNumber();
                 }
-                DataSetHeader header = new SimpleDataSetHeader(columns);
+                DataSetHeader header = new SimpleDataSetHeader(columns.stream().map(SelectItem::new).collect(Collectors.toList()));
                 DefaultRow row = new DefaultRow(header, values);
                 return new InMemoryDataSet(row);
             }
@@ -110,13 +111,13 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testAggregateQueryNoWhereClause() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
         assertSingleRowResult("Row[values=[4]]", dc.query().from(table).selectCount().execute());
     }
 
     public void testAggregateQueryRegularWhereClause() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
         assertSingleRowResult("Row[values=[3]]", dc.query().from(table).selectCount().where("baz").eq("world")
                 .execute());
     }
@@ -124,14 +125,10 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
     public void testApplyFunctionToNullValues() throws Exception {
         QueryPostprocessDataContext dataContext = new QueryPostprocessDataContext() {
             @Override
-            public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            public DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 if (table == table1) {
-                    Column[] columns1 = table1.getColumns();
-                    SelectItem[] selectItems = new SelectItem[columns1.length];
-                    for (int i = 0; i < selectItems.length; i++) {
-                        SelectItem selectItem = new SelectItem(columns1[i]);
-                        selectItems[i] = selectItem;
-                    }
+                    List<Column> columns1 = table1.getColumns();
+                    List<SelectItem> selectItems = columns1.stream().map(SelectItem::new).collect(Collectors.toList());
                     List<Object[]> data = new ArrayList<Object[]>();
                     data.add(new Object[] { 1, "no nulls", 1 });
                     data.add(new Object[] { 2, "onlynull", null });
@@ -175,7 +172,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testGroupByNulls() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", null);
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
         DataSet dataSet = dc.query().from(table).select(FunctionType.SUM, "foo").select("baz").groupBy("baz").execute();
         assertTrue(dataSet.next());
         assertEquals("Row[values=[7.0, world]]", dataSet.getRow().toString());
@@ -187,7 +184,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testNewAggregateFunctions() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", null);
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
         DataSet dataSet = dc.query().from(table).select(FunctionType.FIRST, "foo").select(FunctionType.LAST, "foo")
                 .select(FunctionType.RANDOM, "foo").execute();
         assertTrue(dataSet.next());
@@ -226,10 +223,10 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testMixedAggregateAndRawQuery() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        Table table = dc.getDefaultSchema().getTables()[0];
-        Column[] columns = table.getColumns();
+        Table table = dc.getDefaultSchema().getTable(0);
+        List<Column> columns = table.getColumns();
 
-        Query query = dc.query().from(table).select(FunctionType.MAX, columns[0]).and(columns[1]).toQuery();
+        Query query = dc.query().from(table).select(FunctionType.MAX, columns.get(0)).and(columns.get(1)).toQuery();
         assertEquals("SELECT MAX(tab.foo), tab.bar FROM sch.tab", query.toSql());
 
         DataSet ds = dc.executeQuery(query);
@@ -246,7 +243,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testScalarFunctionSelect() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
 
         Query query = dc.query().from(table).select("foo").select(FunctionType.TO_NUMBER, "foo").select("bar")
                 .select(FunctionType.TO_STRING, "bar").select(FunctionType.TO_NUMBER, "bar").toQuery();
@@ -278,7 +275,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testScalarFunctionWhere() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
 
         Query query = dc.query().from(table).select("foo").where(FunctionType.TO_NUMBER, "bar").eq(1).toQuery();
         assertEquals("SELECT tab.foo FROM sch.tab WHERE TO_NUMBER(tab.bar) = 1", query.toSql());
@@ -297,7 +294,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
     public void testSelectItemReferencesToFromItems() throws Exception {
         MockDataContext dc = new MockDataContext("sch", "tab", "1");
 
-        Table table = dc.getDefaultSchema().getTables()[0];
+        Table table = dc.getDefaultSchema().getTable(0);
 
         Query q = new Query();
         FromItem fromItem1 = q.from(table, "t1").getFromClause().getItem(0);
@@ -308,10 +305,10 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
         assertEquals("SELECT t1.foo, t2.foo FROM sch.tab t1, sch.tab t2 WHERE t1.foo = '2'", q.toSql());
 
         DataSet ds = dc.executeQuery(q);
-        SelectItem[] selectItems = ds.getSelectItems();
-        assertEquals(2, selectItems.length);
-        assertEquals("t1.foo", selectItems[0].toSql());
-        assertEquals("t2.foo", selectItems[1].toSql());
+        List<SelectItem> selectItems = ds.getSelectItems();
+        assertEquals(2, selectItems.size());
+        assertEquals("t1.foo", selectItems.get(0).toSql());
+        assertEquals("t2.foo", selectItems.get(1).toSql());
         assertTrue(ds.next());
         assertEquals("Row[values=[2, 1]]", ds.getRow().toString());
         assertTrue(ds.next());
@@ -328,14 +325,10 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
         QueryPostprocessDataContext dataContext = new QueryPostprocessDataContext() {
 
             @Override
-            public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            public DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 if (table == table1) {
-                    Column[] columns1 = table1.getColumns();
-                    SelectItem[] selectItems = new SelectItem[columns1.length];
-                    for (int i = 0; i < selectItems.length; i++) {
-                        SelectItem selectItem = new SelectItem(columns1[i]);
-                        selectItems[i] = selectItem;
-                    }
+                    List<Column> columns1 = table1.getColumns();
+                    List<SelectItem> selectItems = columns1.stream().map(SelectItem::new).collect(Collectors.toList());
                     List<Object[]> data = new ArrayList<Object[]>();
                     data.add(new Object[] { 1, "kasper", "denmark" });
                     data.add(new Object[] { 2, "asbjorn", "denmark" });
@@ -350,12 +343,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
                     }
                     return createDataSet(selectItems, data);
                 } else if (table == table2) {
-                    Column[] columns2 = table2.getColumns();
-                    SelectItem[] selectItems = new SelectItem[columns2.length];
-                    for (int i = 0; i < selectItems.length; i++) {
-                        SelectItem selectItem = new SelectItem(columns2[i]);
-                        selectItems[i] = selectItem;
-                    }
+                    List<SelectItem> selectItems = table2.getColumns().stream().map(SelectItem::new).collect(Collectors.toList());
                     List<Object[]> data = new ArrayList<Object[]>();
                     data.add(new Object[] { 1, 1, "founder" });
                     data.add(new Object[] { 1, 1, "developer" });
@@ -408,25 +396,25 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
     public void testInformationSchema() throws Exception {
         DataContext dc = getDataContext();
-        assertEquals("[information_schema, MetaModelSchema]", Arrays.toString(dc.getSchemaNames()));
+        assertEquals("[information_schema, MetaModelSchema]", Arrays.toString(dc.getSchemaNames().toArray()));
         Schema informationSchema = dc.getSchemaByName("information_schema");
         assertEquals(
                 "[Table[name=tables,type=TABLE,remarks=null], Table[name=columns,type=TABLE,remarks=null], Table[name=relationships,type=TABLE,remarks=null]]",
-                Arrays.toString(informationSchema.getTables()));
+                Arrays.toString(informationSchema.getTables().toArray()));
         assertEquals(
                 "[Relationship[primaryTable=tables,primaryColumns=[name],foreignTable=columns,foreignColumns=[table]], "
                         + "Relationship[primaryTable=tables,primaryColumns=[name],foreignTable=relationships,foreignColumns=[primary_table]], "
                         + "Relationship[primaryTable=tables,primaryColumns=[name],foreignTable=relationships,foreignColumns=[foreign_table]], "
                         + "Relationship[primaryTable=columns,primaryColumns=[name],foreignTable=relationships,foreignColumns=[primary_column]], "
                         + "Relationship[primaryTable=columns,primaryColumns=[name],foreignTable=relationships,foreignColumns=[foreign_column]]]",
-                Arrays.toString(informationSchema.getRelationships()));
+                Arrays.toString(informationSchema.getRelationships().toArray()));
         Table tablesTable = informationSchema.getTableByName("tables");
         assertEquals(
                 "[Column[name=name,columnNumber=0,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=type,columnNumber=1,type=VARCHAR,nullable=true,nativeType=null,columnSize=null], "
                         + "Column[name=num_columns,columnNumber=2,type=INTEGER,nullable=true,nativeType=null,columnSize=null], "
                         + "Column[name=remarks,columnNumber=3,type=VARCHAR,nullable=true,nativeType=null,columnSize=null]]",
-                Arrays.toString(tablesTable.getColumns()));
+                Arrays.toString(tablesTable.getColumns().toArray()));
         Table columnsTable = informationSchema.getTableByName("columns");
         assertEquals(
                 "[Column[name=name,columnNumber=0,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
@@ -437,14 +425,14 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
                         + "Column[name=indexed,columnNumber=5,type=BOOLEAN,nullable=true,nativeType=null,columnSize=null], "
                         + "Column[name=table,columnNumber=6,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=remarks,columnNumber=7,type=VARCHAR,nullable=true,nativeType=null,columnSize=null]]",
-                Arrays.toString(columnsTable.getColumns()));
+                Arrays.toString(columnsTable.getColumns().toArray()));
         Table relationshipsTable = informationSchema.getTableByName("relationships");
         assertEquals(
                 "[Column[name=primary_table,columnNumber=0,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=primary_column,columnNumber=1,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=foreign_table,columnNumber=2,type=VARCHAR,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=foreign_column,columnNumber=3,type=VARCHAR,nullable=false,nativeType=null,columnSize=null]]",
-                Arrays.toString(relationshipsTable.getColumns()));
+                Arrays.toString(relationshipsTable.getColumns().toArray()));
 
         DataSet dataSet = dc.query().from(tablesTable).select(tablesTable.getColumns()).execute();
         assertTrue(dataSet.next());
@@ -458,7 +446,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
         assertFalse(dataSet.next());
         dataSet.close();
 
-        Relationship relationship = tablesTable.getRelationships(columnsTable)[0];
+        Relationship relationship = tablesTable.getRelationships(columnsTable).iterator().next();
         FromItem joinFromItem = new FromItem(JoinType.INNER, relationship);
         Query q = new Query().select(tablesTable.getColumnByName("name")).select(columnsTable.getColumnByName("name"))
                 .select(columnsTable.getBooleanColumns()).from(joinFromItem);
@@ -492,7 +480,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
         DataContext dc = getDataContext();
         DataSet data = dc.executeQuery(q);
-        assertEquals(1, data.getSelectItems().length);
+        assertEquals(1, data.getSelectItems().size());
 
         TableModel tableModel = new DataSetTableModel(data);
 
@@ -533,8 +521,8 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
         DataContext dc = getDataContext();
 
         DataSet data = dc.executeQuery(q);
-        assertEquals(1, data.getSelectItems().length);
-        assertEquals("SUM(r.project_id)", data.getSelectItems()[0].toString());
+        assertEquals(1, data.getSelectItems().size());
+        assertEquals("SUM(r.project_id)", data.getSelectItems().get(0).toString());
 
         TableModel tableModel = new DataSetTableModel(data);
         assertEquals(3, tableModel.getRowCount());
@@ -564,31 +552,31 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
         DataContext dc = getDataContext();
         DataSet data = dc.executeQuery(q);
-        assertEquals(1, data.getSelectItems().length);
-        assertEquals("r.name", data.getSelectItems()[0].toString());
+        assertEquals(1, data.getSelectItems().size());
+        assertEquals("r.name", data.getSelectItems().get(0).toString());
         TableModel tableModel = new DataSetTableModel(data);
         assertEquals(3, tableModel.getRowCount());
 
         q.select(new SelectItem(FunctionType.COUNT, "*", "c"));
         q.where(new FilterItem(new SelectItem(roleColumn), OperatorType.EQUALS_TO, "founder"));
         data = dc.executeQuery(q);
-        assertEquals(2, data.getSelectItems().length);
-        assertEquals("r.name", data.getSelectItems()[0].toString());
-        assertEquals("COUNT(*) AS c", data.getSelectItems()[1].toString());
+        assertEquals(2, data.getSelectItems().size());
+        assertEquals("r.name", data.getSelectItems().get(0).toString());
+        assertEquals("COUNT(*) AS c", data.getSelectItems().get(1).toString());
         tableModel = new DataSetTableModel(data);
         assertEquals(1, tableModel.getRowCount());
         assertEquals("founder", tableModel.getValueAt(0, 0));
         assertEquals(2l, tableModel.getValueAt(0, 1));
 
-        q.select(new SelectItem(FunctionType.SUM, table2.getColumns()[0]));
+        q.select(new SelectItem(FunctionType.SUM, table2.getColumn(0)));
         assertEquals(
                 "SELECT r.name, COUNT(*) AS c, SUM(r.contributor_id) FROM MetaModelSchema.role r WHERE r.name = 'founder' GROUP BY r.name",
                 q.toString());
         data = dc.executeQuery(q);
-        assertEquals(3, data.getSelectItems().length);
-        assertEquals("r.name", data.getSelectItems()[0].toString());
-        assertEquals("COUNT(*) AS c", data.getSelectItems()[1].toString());
-        assertEquals("SUM(r.contributor_id)", data.getSelectItems()[2].toString());
+        assertEquals(3, data.getSelectItems().size());
+        assertEquals("r.name", data.getSelectItems().get(0).toString());
+        assertEquals("COUNT(*) AS c", data.getSelectItems().get(1).toString());
+        assertEquals("SUM(r.contributor_id)", data.getSelectItems().get(2).toString());
         tableModel = new DataSetTableModel(data);
         assertEquals(1, tableModel.getRowCount());
         assertEquals("founder", tableModel.getValueAt(0, 0));
@@ -744,7 +732,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
         q.select(table1.getColumns());
         q.select(table2.getColumns());
         DataSet data = dc.executeQuery(q);
-        assertEquals(table1.getColumnCount() + table2.getColumnCount(), data.getSelectItems().length);
+        assertEquals(table1.getColumnCount() + table2.getColumnCount(), data.getSelectItems().size());
         for (int i = 0; i < 6 * 8; i++) {
             assertTrue(data.next());
             if (i == 0) {
@@ -843,7 +831,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
                 q.toString());
 
         DataSet data = dc.executeQuery(q);
-        assertEquals(2, data.getSelectItems().length);
+        assertEquals(2, data.getSelectItems().size());
         assertTrue(data.next());
         assertEquals("Row[values=[kasper, founder]]", data.getRow().toString());
         assertTrue(data.next());
@@ -888,7 +876,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
         SelectItem s1 = new SelectItem(table1.getColumnByName(COLUMN_CONTRIBUTOR_NAME));
         SelectItem s2 = new SelectItem(table2.getColumnByName(COLUMN_ROLE_ROLE_NAME));
-        FromItem fromItem = new FromItem(JoinType.INNER, table1.getRelationships(table2)[0]);
+        FromItem fromItem = new FromItem(JoinType.INNER, table1.getRelationships(table2).iterator().next());
 
         Query q = new Query();
         q.select(s1);
@@ -899,7 +887,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
                 q.toString());
 
         DataSet data = dc.executeQuery(q);
-        assertEquals(2, data.getSelectItems().length);
+        assertEquals(2, data.getSelectItems().size());
         assertTrue(data.next());
         assertEquals("Row[values=[kasper, founder]]", data.getRow().toString());
         assertTrue(data.next());
@@ -941,7 +929,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
 
         DataContext dc = getDataContext();
         DataSet data = dc.executeQuery(q2);
-        assertEquals(1, data.getSelectItems().length);
+        assertEquals(1, data.getSelectItems().size());
         assertTrue(data.next());
         assertEquals("Row[values=[kasper]]", data.getRow().toString());
         assertTrue(data.next());
@@ -968,7 +956,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
                 "SELECT d.e AS f FROM (SELECT c.name AS e FROM (SELECT contributor.contributor_id, contributor.name, contributor.country FROM MetaModelSchema.contributor) c) d",
                 q3.toString());
         data = dc.executeQuery(q3);
-        assertEquals(1, data.getSelectItems().length);
+        assertEquals(1, data.getSelectItems().size());
         assertTrue(data.next());
         assertEquals("Row[values=[kasper]]", data.getRow().toString());
         assertTrue(data.next());
@@ -1015,7 +1003,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
     public void testExecuteCount() throws Exception {
         QueryPostprocessDataContext dc = new QueryPostprocessDataContext() {
             @Override
-            protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 throw new UnsupportedOperationException();
             }
 
@@ -1047,7 +1035,7 @@ public class QueryPostprocessDataContextTest extends MetaModelTestCase {
     public void testExecutePrimaryKeyLookupQuery() throws Exception {
         QueryPostprocessDataContext dc = new QueryPostprocessDataContext() {
             @Override
-            protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 throw new UnsupportedAddressTypeException();
             }
 
index c68dfd2..f23cf1a 100644 (file)
@@ -37,7 +37,7 @@ public class ConvertersTest extends TestCase {
 
     public void testAutoDetectConverters() throws Exception {
         final MockUpdateableDataContext decoratedDataContext = new MockUpdateableDataContext();
-        final Table table = decoratedDataContext.getDefaultSchema().getTables()[0];
+        final Table table = decoratedDataContext.getDefaultSchema().getTables().get(0);
         Map<Column, TypeConverter<?, ?>> converters = Converters.autoDetectConverters(decoratedDataContext, table, 2);
         assertEquals(1, converters.size());
         assertEquals(
@@ -92,7 +92,7 @@ public class ConvertersTest extends TestCase {
             assertEquals("foo is expected to be string", String.class, physicalValues[0].getClass());
         }
 
-        final Table table = dc.getDefaultSchema().getTables()[0];
+        final Table table = dc.getDefaultSchema().getTables().get(0);
         Map<Column, TypeConverter<?, ?>> converters = Converters.autoDetectConverters(dc, table, 1000);
         assertEquals(1, converters.size());
         dc = Converters.addTypeConverters(dc, converters);
index c4d320c..f5e7356 100644 (file)
@@ -57,11 +57,11 @@ public class AbstractCreateTableBuilderTest extends TestCase {
         assertEquals("tablename", table.getName());
         assertEquals(3, table.getColumnCount());
         assertEquals("Column[name=foo,columnNumber=0,type=VARCHAR,nullable=true,nativeType=vch,columnSize=1234]",
-                table.getColumns()[0].toString());
+                table.getColumn(0).toString());
         assertEquals("Column[name=bar,columnNumber=1,type=null,nullable=null,nativeType=null,columnSize=null]",
-                table.getColumns()[1].toString());
+                table.getColumn(1).toString());
         assertEquals("Column[name=baz,columnNumber=2,type=null,nullable=false,nativeType=null,columnSize=null]",
-                table.getColumns()[2].toString());
+                table.getColumn(2).toString());
 
         System.out.println(builder.toSql());
         assertEquals("CREATE TABLE schema.tablename (foo VARCHAR(1234),bar,baz NOT NULL, PRIMARY KEY(foo))", builder.toSql());
@@ -96,12 +96,12 @@ public class AbstractCreateTableBuilderTest extends TestCase {
         assertEquals("tablename", table.getName());
         assertEquals(3, table.getColumnCount());
         assertEquals("Column[name=foo,columnNumber=0,type=VARCHAR,nullable=true,nativeType=vch,columnSize=1234]",
-                table.getColumns()[0].toString());
-        assertTrue(table.getColumns()[0].isPrimaryKey());
+                table.getColumn(0).toString());
+        assertTrue(table.getColumn(0).isPrimaryKey());
 
         assertEquals("Column[name=bar,columnNumber=1,type=null,nullable=null,nativeType=null,columnSize=null]",
-                table.getColumns()[1].toString());
+                table.getColumn(1).toString());
         assertEquals("Column[name=baz,columnNumber=2,type=null,nullable=null,nativeType=null,columnSize=null]",
-                table.getColumns()[2].toString());
+                table.getColumn(1).toString());
     }
 }
index b70bc8c..6736c5f 100644 (file)
@@ -23,6 +23,7 @@ import java.util.List;
 
 import javax.swing.table.TableModel;
 
+import com.google.common.collect.Lists;
 import org.apache.metamodel.MetaModelHelper;
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.MutableColumn;
@@ -34,7 +35,7 @@ public class DataSetTableModelTest extends TestCase {
     public void testToTableModel() throws Exception {
         SelectItem[] selectItems = MetaModelHelper.createSelectItems(new MutableColumn("CUSTOMERNUMBER"),
                 new MutableColumn("CUSTOMERNAME"), new MutableColumn("CONTACTLASTNAME"));
-        CachingDataSetHeader header = new CachingDataSetHeader(selectItems);
+        CachingDataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(selectItems));
         List<Row> rows = new ArrayList<Row>();
         rows.add(new DefaultRow(header, new Object[] { 1, "John", "Doe" }));
         rows.add(new DefaultRow(header, new Object[] { 2, "John", "Taylor" }));
index 40f0551..1f485ea 100644 (file)
@@ -24,6 +24,7 @@ import java.io.FileInputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.lang.reflect.Field;
+import java.util.List;
 
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
@@ -71,9 +72,9 @@ public class DefaultRowTest extends TestCase {
 
         Row row = (Row) obj;
         assertEquals(2, row.size());
-        SelectItem[] selectItems = row.getSelectItems();
-        assertEquals("foo", selectItems[0].toString());
-        assertEquals("bar", selectItems[1].toString());
+        List<SelectItem> selectItems = row.getSelectItems();
+        assertEquals("foo", selectItems.get(0).toString());
+        assertEquals("bar", selectItems.get(1).toString());
 
         assertEquals("foo", row.getValue(0));
         assertEquals("bar", row.getValue(1));
@@ -81,7 +82,7 @@ public class DefaultRowTest extends TestCase {
         assertEquals(Style.NO_STYLE, row.getStyle(0));
         assertEquals(Style.NO_STYLE, row.getStyle(1));
 
-        Column column = selectItems[0].getColumn();
+        Column column = selectItems.get(0).getColumn();
         assertNotNull(column);
         
         // the columns used to create the object did not have column types assigned.
index daa846a..685a1d3 100644 (file)
@@ -18,6 +18,7 @@
  */
 package org.apache.metamodel.data;
 
+import com.google.common.collect.Lists;
 import org.apache.metamodel.MetaModelTestCase;
 import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Schema;
@@ -28,29 +29,27 @@ public class RowTest extends MetaModelTestCase {
     public void testRow() throws Exception {
         Schema schema = getExampleSchema();
         Table projectTable = schema.getTableByName(TABLE_PROJECT);
-        SelectItem item = new SelectItem(projectTable.getColumns()[0]);
-        SelectItem[] items = { item };
-        DataSetHeader header = new CachingDataSetHeader(items);
+        SelectItem item = new SelectItem(projectTable.getColumn(0));
+        DataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(item));
         Object[] values = { "foobar" };
         Row row = new DefaultRow(header, values);
         assertEquals("Row[values=[foobar]]", row.toString());
         assertEquals("foobar", row.getValue(0));
         assertEquals("foobar", row.getValues()[0]);
         assertEquals("foobar", row.getValue(item));
-        assertEquals(item, row.getSelectItems()[0]);
+        assertEquals(item, row.getSelectItems().get(0));
     }
 
     public void testGetSubSelection() throws Exception {
         Schema schema = getExampleSchema();
         Table projectTable = schema.getTableByName(TABLE_PROJECT);
-        SelectItem item1 = new SelectItem(projectTable.getColumns()[0]);
-        SelectItem item2 = new SelectItem(projectTable.getColumns()[0]);
-        SelectItem[] items = { item1, item2 };
-        DataSetHeader header = new CachingDataSetHeader(items);
+        SelectItem item1 = new SelectItem(projectTable.getColumn(0));
+        SelectItem item2 = new SelectItem(projectTable.getColumn(0));
+        DataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(item1,item2));
         Object[] values = { "foo", "bar" };
         Row row = new DefaultRow(header, values);
         row = row.getSubSelection(new SimpleDataSetHeader(new SelectItem[] { item1 }));
-        assertEquals(1, row.getSelectItems().length);
+        assertEquals(1, row.getSelectItems().size());
         assertEquals(1, row.getValues().length);
         assertEquals("foo", row.getValue(0));
     }
index 44178b2..cce8b18 100644 (file)
@@ -23,7 +23,10 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
+import java.util.stream.Collectors;
 
+import com.google.common.collect.Lists;
+import org.apache.metamodel.query.SelectItem;
 import org.apache.metamodel.schema.Column;
 import org.apache.metamodel.schema.MutableColumn;
 import org.junit.Test;
@@ -34,25 +37,33 @@ public class UnionDataSetTest {
     public void testVanillaUnion() {
         // data set 1
         final DataSetHeader header1 =
-                new SimpleDataSetHeader(new Column[] { new MutableColumn("foo1"), new MutableColumn("bar1") });
+                new SimpleDataSetHeader(
+                        Lists.newArrayList(new MutableColumn("foo1"), new MutableColumn("bar1")).stream()
+                                .map(SelectItem::new).collect(Collectors.toList()));
         final Row row1 = new DefaultRow(header1, new Object[] { "1", "2" });
         final Row row2 = new DefaultRow(header1, new Object[] { "3", "4" });
         final DataSet ds1 = new InMemoryDataSet(header1, row1, row2);
 
         // data set 2
         final DataSetHeader header2 =
-                new SimpleDataSetHeader(new Column[] { new MutableColumn("foo2"), new MutableColumn("bar2") });
+                new SimpleDataSetHeader(
+                        Lists.newArrayList( new MutableColumn("foo2"), new MutableColumn("bar2") ).stream()
+                                .map(SelectItem::new).collect(Collectors.toList()));
         final Row row3 = new DefaultRow(header2, new Object[] { "5", "6" });
         final DataSet ds2 = new InMemoryDataSet(header2, row3);
 
         // data set 3
         final DataSetHeader header3 =
-                new SimpleDataSetHeader(new Column[] { new MutableColumn("foo3"), new MutableColumn("bar3") });
+                new SimpleDataSetHeader(
+                        Lists.newArrayList( new MutableColumn("foo3"), new MutableColumn("bar3") ).stream()
+                                .map(SelectItem::new).collect(Collectors.toList()));
         final Row row4 = new DefaultRow(header2, new Object[] { "7", "8" });
         final DataSet ds3 = new InMemoryDataSet(header3, row4);
 
         final DataSetHeader unionHeader =
-                new SimpleDataSetHeader(new Column[] { new MutableColumn("fooUnion"), new MutableColumn("barUnion") });
+                new SimpleDataSetHeader(
+                        Lists.newArrayList( new MutableColumn("fooUnion"), new MutableColumn("barUnion") ).stream()
+                            .map(SelectItem::new).collect(Collectors.toList()));
         final DataSet unionDataSet = UnionDataSet.ofDataSets(unionHeader, Arrays.asList(ds1, ds2, ds3));
         assertTrue(unionDataSet.next());
         assertEquals("Row[values=[1, 2]]", unionDataSet.getRow().toString());
index f0774f0..0c0b98f 100644 (file)
@@ -30,7 +30,7 @@ public class AbstractRowDeletionCallbackTest extends TestCase {
 
     public void testDelete() throws Exception {
         final MockUpdateableDataContext dc = new MockUpdateableDataContext();
-        final Table table = dc.getDefaultSchema().getTables()[0];
+        final Table table = dc.getDefaultSchema().getTables().get(0);
         DataSet ds = dc.query().from(table).selectCount().execute();
         assertTrue(ds.next());
         assertEquals("3", ds.getRow().getValue(0).toString());
index e5ee2f1..647ace4 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.intercept;
 
 import java.util.Arrays;
+import java.util.List;
 
 import junit.framework.TestCase;
 
@@ -35,7 +36,7 @@ public class InterceptableDataContextTest extends TestCase {
 
        private final MockUpdateableDataContext delegateDataContext = new MockUpdateableDataContext();
        private final Table table = delegateDataContext.getDefaultSchema()
-                       .getTables()[0];
+                       .getTables().get(0);
 
        public void testInterceptSchema() throws Exception {
                // without an interceptor
@@ -43,15 +44,15 @@ public class InterceptableDataContextTest extends TestCase {
                        DataContext dc = new InterceptableDataContext(delegateDataContext);
 
                        Schema schema = dc.getDefaultSchema();
-                       Schema[] schemas = dc.getSchemas();
+                       List<Schema> schemas = dc.getSchemas();
 
                        assertEquals("schema", schema.getName());
                        assertEquals(MutableSchema.class, schema.getClass());
                        assertEquals("[information_schema, schema]",
-                                       Arrays.toString(dc.getSchemaNames()));
-                       assertEquals(2, schemas.length);
-                       assertEquals("information_schema", schemas[0].getName());
-                       assertEquals("schema", schemas[1].getName());
+                                       Arrays.toString(dc.getSchemaNames().toArray()));
+                       assertEquals(2, schemas.size());
+                       assertEquals("information_schema", schemas.get(0).getName());
+                       assertEquals("schema", schemas.get(1).getName());
                }
 
                // with an interceptor
@@ -65,15 +66,15 @@ public class InterceptableDataContextTest extends TestCase {
                                        });
 
                        Schema schema = dc.getDefaultSchema();
-                       Schema[] schemas = dc.getSchemas();
+                       List<Schema> schemas = dc.getSchemas();
 
                        assertEquals("schema foo!", schema.getName());
                        assertEquals(MutableSchema.class, schema.getClass());
                        assertEquals("[information_schema foo!, schema foo!]",
-                                       Arrays.toString(dc.getSchemaNames()));
-                       assertEquals(2, schemas.length);
-                       assertEquals("information_schema foo!", schemas[0].getName());
-                       assertEquals("schema foo!", schemas[1].getName());
+                                       Arrays.toString(dc.getSchemaNames().toArray()));
+                       assertEquals(2, schemas.size());
+                       assertEquals("information_schema foo!", schemas.get(0).getName());
+                       assertEquals("schema foo!", schemas.get(1).getName());
                }
        }
 
@@ -108,6 +109,6 @@ public class InterceptableDataContextTest extends TestCase {
                                });
 
                DataSet ds = dc.executeQuery(new Query().from(table));
-               assertEquals("[table.foo, table.bar]", Arrays.toString(ds.getSelectItems()));
+               assertEquals("[table.foo, table.bar]", Arrays.toString(ds.getSelectItems().toArray()));
        }
 }
index 3b89d9d..9053625 100644 (file)
@@ -18,6 +18,7 @@
  */
 package org.apache.metamodel.query;
 
+import com.google.common.collect.Lists;
 import junit.framework.TestCase;
 
 import org.apache.metamodel.DataContext;
@@ -43,6 +44,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class FilterItemTest extends TestCase {
 
@@ -168,7 +170,7 @@ public class FilterItemTest extends TestCase {
         Column col2 = new MutableColumn("Col2", ColumnType.DECIMAL);
         SelectItem s1 = new SelectItem(col1);
         SelectItem s2 = new SelectItem(col2);
-        SelectItem[] selectItems = new SelectItem[] { s1, s2 };
+        List<SelectItem> selectItems = Lists.newArrayList( s1, s2 );
         CachingDataSetHeader header = new CachingDataSetHeader(selectItems);
 
         FilterItem c = new FilterItem(s1, OperatorType.EQUALS_TO, null);
@@ -235,8 +237,7 @@ public class FilterItemTest extends TestCase {
     public void testEvaluateDates() throws Exception {
         Column col1 = new MutableColumn("Col1", ColumnType.DATE);
         SelectItem s1 = new SelectItem(col1);
-        SelectItem[] selectItems = new SelectItem[] { s1 };
-        CachingDataSetHeader header = new CachingDataSetHeader(selectItems);
+        CachingDataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(s1));
 
         long currentTimeMillis = System.currentTimeMillis();
         FilterItem c = new FilterItem(s1, OperatorType.LESS_THAN, new java.sql.Date(currentTimeMillis));
@@ -331,8 +332,7 @@ public class FilterItemTest extends TestCase {
         FilterItem filter = new FilterItem(LogicalOperator.AND, c1, c2, c3);
         assertEquals("(Col1 LIKE 'foo%' AND Col1 LIKE '%bar' AND Col1 <> 'foobar')", filter.toString());
 
-        SelectItem[] items = new SelectItem[] { s1 };
-        CachingDataSetHeader header = new CachingDataSetHeader(items);
+        CachingDataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(s1));
         assertTrue(filter.evaluate(new DefaultRow(header, new Object[] { "foo bar" })));
         assertTrue(filter.evaluate(new DefaultRow(header, new Object[] { "foosenbar" })));
         assertFalse(filter.evaluate(new DefaultRow(header, new Object[] { "foo" })));
@@ -373,15 +373,16 @@ public class FilterItemTest extends TestCase {
         DataContext dc = new QueryPostprocessDataContext() {
 
             @Override
-            public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            public DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 // we expect 3 columns to be materialized because the query has column references in both SELECT and WHERE clause
-                assertEquals(3, columns.length);
-                assertEquals("column_number", columns[0].getName());
-                assertEquals("name", columns[1].getName());
-                assertEquals("role", columns[2].getName());
-                SelectItem[] selectItems = new SelectItem[] { new SelectItem(col1), new SelectItem(col2),
-                        new SelectItem(col3) };
-                DataSetHeader header = new CachingDataSetHeader(selectItems);
+                assertEquals(3, columns.size());
+                assertEquals("column_number", columns.get(0).getName());
+                assertEquals("name", columns.get(1).getName());
+                assertEquals("role", columns.get(2).getName());
+
+                DataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(col1, col2, col3).stream()
+                        .map(SelectItem::new)
+                        .collect(Collectors.toList()));
                 List<Row> rows = new LinkedList<Row>();
                 rows.add(new DefaultRow(header, new Object[] { "foo", "bar", 1 }));
                 rows.add(new DefaultRow(header, new Object[] { "kasper", "developer", 2 }));
@@ -462,8 +463,7 @@ public class FilterItemTest extends TestCase {
         Object operand = new String[] { "foo", "bar" };
 
         FilterItem filterItem = new FilterItem(selectItem, OperatorType.IN, operand);
-        SelectItem[] selectItems = new SelectItem[] { selectItem };
-        DataSetHeader header = new CachingDataSetHeader(selectItems);
+        DataSetHeader header = new CachingDataSetHeader(Lists.newArrayList(selectItem));
 
         assertTrue(filterItem.evaluate(new DefaultRow(header, new Object[] { "foo" })));
         assertTrue(filterItem.evaluate(new DefaultRow(header, new Object[] { "bar" })));
index b026f8d..adca140 100644 (file)
@@ -27,6 +27,9 @@ import org.apache.metamodel.schema.Relationship;
 import org.apache.metamodel.schema.Schema;
 import org.apache.metamodel.schema.Table;
 
+import java.util.Collection;
+import java.util.List;
+
 public class FromItemTest extends MetaModelTestCase {
 
        private Schema _schema = getExampleSchema();
@@ -44,9 +47,9 @@ public class FromItemTest extends MetaModelTestCase {
        public void testRelationJoinToString() throws Exception {
                Table contributorTable = _schema.getTableByName(TABLE_CONTRIBUTOR);
                Table roleTable = _schema.getTableByName(TABLE_ROLE);
-               Relationship[] relationships = roleTable
+               Collection<Relationship> relationships = roleTable
                                .getRelationships(contributorTable);
-               FromItem from = new FromItem(JoinType.INNER, relationships[0]);
+               FromItem from = new FromItem(JoinType.INNER, relationships.iterator().next());
                assertEquals(
                                "MetaModelSchema.contributor INNER JOIN MetaModelSchema.role ON contributor.contributor_id = role.contributor_id",
                                from.toString());
@@ -73,7 +76,7 @@ public class FromItemTest extends MetaModelTestCase {
                leftSide.setAlias("a");
                SelectItem[] leftOn = new SelectItem[] { new SelectItem(projectIdColumn) };
 
-               Column[] columns = roleTable.getColumns();
+               List<Column> columns = roleTable.getColumns();
 
                Query subQuery = new Query();
                FromItem subQueryFrom = new FromItem(roleTable);
@@ -107,7 +110,7 @@ public class FromItemTest extends MetaModelTestCase {
    
         final QueryPostprocessDataContext dc = new QueryPostprocessDataContext() {
             @Override
-            protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+            protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
                 throw new UnsupportedOperationException("This method is not used");
             }
 
index 823c4d9..8e518c9 100644 (file)
@@ -106,7 +106,7 @@ public class QueryTest extends MetaModelTestCase {
         Query q1 = new Query();
         Table contributorTable = _schema.getTableByName(TABLE_CONTRIBUTOR);
         Table roleTable = _schema.getTableByName(TABLE_ROLE);
-        FromItem fromItem = new FromItem(JoinType.INNER, contributorTable.getRelationships(roleTable)[0]);
+        FromItem fromItem = new FromItem(JoinType.INNER, contributorTable.getRelationships(roleTable).iterator().next());
         q1.from(fromItem);
 
         Column nameColumn = contributorTable.getColumnByName(COLUMN_CONTRIBUTOR_NAME);
index e6bbdca..7f412c0 100644 (file)
@@ -24,14 +24,16 @@ import org.apache.metamodel.schema.MutableColumn;
 import org.apache.metamodel.schema.Schema;
 import org.apache.metamodel.schema.Table;
 
+import java.util.List;
+
 public class SelectItemTest extends MetaModelTestCase {
 
     private Schema _schema = getExampleSchema();
 
     public void testSelectColumnInFromItem() throws Exception {
         final Table projectTable = _schema.getTableByName(TABLE_PROJECT);
-        final Column column1 = projectTable.getColumns()[0];
-        final Column column2 = projectTable.getColumns()[1];
+        final Column column1 = projectTable.getColumns().get(0);
+        final Column column2 = projectTable.getColumns().get(1);
 
         Query q = new Query().from(projectTable, "a").from(projectTable, "b");
         q.select(column1, q.getFromClause().getItem(1));
@@ -41,12 +43,12 @@ public class SelectItemTest extends MetaModelTestCase {
     }
     
     public void testToSql() throws Exception {
-        SelectItem selectItem = new SelectItem(_schema.getTableByName(TABLE_PROJECT).getColumns()[0]);
+        SelectItem selectItem = new SelectItem(_schema.getTableByName(TABLE_PROJECT).getColumns().get(0));
         assertEquals("project.project_id", selectItem.toSql());
     }
     
     public void testToSqlFuntionApproximation() throws Exception {
-        SelectItem selectItem = new SelectItem(FunctionType.MAX, _schema.getTableByName(TABLE_PROJECT).getColumns()[0]);
+        SelectItem selectItem = new SelectItem(FunctionType.MAX, _schema.getTableByName(TABLE_PROJECT).getColumns().get(0));
         selectItem.setFunctionApproximationAllowed(true);
         assertEquals("APPROXIMATE MAX(project.project_id)", selectItem.toSql());
     }
@@ -65,10 +67,10 @@ public class SelectItemTest extends MetaModelTestCase {
         FromItem subQueryFrom = new FromItem(roleTable);
         subQueryFrom.setAlias("c");
         subQuery.from(subQueryFrom);
-        Column[] columns = roleTable.getColumns();
+        List<Column> columns = roleTable.getColumns();
         subQuery.select(columns);
 
-        SelectItem subQuerySelectItem = subQuery.getSelectClause().getSelectItem(columns[1]);
+        SelectItem subQuerySelectItem = subQuery.getSelectClause().getSelectItem(columns.get(1));
         FromItem rightSide = new FromItem(subQuery);
         rightSide.setAlias("b");
         SelectItem[] rightOn = new SelectItem[] { subQuerySelectItem };
index 238889f..b4baf34 100644 (file)
@@ -32,6 +32,8 @@ import org.apache.metamodel.schema.MutableTable;
 import org.apache.metamodel.schema.Schema;
 import org.apache.metamodel.schema.Table;
 
+import java.util.List;
+
 public class GroupedQueryBuilderImplTest extends TestCase {
 
        public void testFindColumnWithAlias() throws Exception {
@@ -76,7 +78,7 @@ public class GroupedQueryBuilderImplTest extends TestCase {
                        }
 
                        @Override
-                       protected String[] getSchemaNamesInternal() {
+                       protected List<String> getSchemaNamesInternal() {
                                throw new UnsupportedOperationException();
                        }
 
index af81801..d83e82a 100644 (file)
@@ -42,11 +42,11 @@ public class SyntaxExamplesTest extends TestCase {
         super.setUp();
         dc = new MockDataContext("sch", "tab1", "foo");
         MutableSchema schema = (MutableSchema) dc.getDefaultSchema();
-        table1 = schema.getTables()[0];
+        table1 = schema.getTables().get(0);
         schema.addTable(new MutableTable("tab2").setSchema(schema));
         table2 = schema.getTableByName("tab2");
-        col1 = table1.getColumns()[0];
-        col2 = table1.getColumns()[1];
+        col1 = table1.getColumns().get(0);
+        col2 = table1.getColumns().get(1);
     }
 
     public void testSchema() throws Exception {
index c738a2b..1e1351b 100644 (file)
@@ -19,6 +19,7 @@
 package org.apache.metamodel.schema;
 
 import java.util.Arrays;
+import java.util.List;
 
 import junit.framework.TestCase;
 
@@ -53,17 +54,17 @@ public class MutableTableTest extends TestCase {
         t.addColumn(new MutableColumn("a").setType(ColumnType.VARCHAR));
         t.addColumn(new MutableColumn("r").setType(ColumnType.INTEGER));
 
-        Column[] cols = t.getColumnsOfType(ColumnType.VARCHAR);
-        assertEquals(2, cols.length);
-        assertEquals("b", cols[0].getName());
-        assertEquals("a", cols[1].getName());
+        List<Column> cols = t.getColumnsOfType(ColumnType.VARCHAR);
+        assertEquals(2, cols.size());
+        assertEquals("b", cols.get(0).getName());
+        assertEquals("a", cols.get(1).getName());
 
         cols = t.getColumnsOfType(ColumnType.INTEGER);
-        assertEquals(1, cols.length);
-        assertEquals("r", cols[0].getName());
+        assertEquals(1, cols.size());
+        assertEquals("r", cols.get(0).getName());
 
         cols = t.getColumnsOfType(ColumnType.FLOAT);
-        assertEquals(0, cols.length);
+        assertEquals(0, cols.size());
     }
 
     public void testGetIndexedColumns() throws Exception {
@@ -71,10 +72,10 @@ public class MutableTableTest extends TestCase {
         t.addColumn(new MutableColumn("b").setIndexed(true));
         t.addColumn(new MutableColumn("a").setIndexed(false));
         t.addColumn(new MutableColumn("r").setIndexed(true));
-        Column[] indexedColumns = t.getIndexedColumns();
+        List<Column> indexedColumns = t.getIndexedColumns();
         assertEquals(
                 "[Column[name=b,columnNumber=0,type=null,nullable=null,nativeType=null,columnSize=null], Column[name=r,columnNumber=0,type=null,nullable=null,nativeType=null,columnSize=null]]",
-                Arrays.toString(indexedColumns));
+                Arrays.toString(indexedColumns.toArray()));
         for (Column column : indexedColumns) {
             assertTrue(column.isIndexed());
         }
index 956f7e8..0c00277 100644 (file)
@@ -19,6 +19,8 @@
 package org.apache.metamodel.schema;
 
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
 
 import org.apache.metamodel.MetaModelTestCase;
 
@@ -28,7 +30,7 @@ public class SchemaModelTest extends MetaModelTestCase {
         Schema schema = getExampleSchema();
         assertEquals("MetaModelSchema", schema.getName());
         assertEquals("Schema[name=MetaModelSchema]", schema.toString());
-        assertEquals(5, schema.getRelationships().length);
+        assertEquals(5, schema.getRelationships().size());
 
         assertEquals(4, schema.getTableCount());
         assertEquals(3, schema.getTableCount(TableType.TABLE));
@@ -47,18 +49,18 @@ public class SchemaModelTest extends MetaModelTestCase {
         assertNotNull(projectTable.getColumnByName("project_id"));
 
         assertEquals("[project_id, name, lines_of_code, parent_project_id]",
-                Arrays.toString(projectTable.getColumnNames()));
+                Arrays.toString(projectTable.getColumnNames().toArray()));
 
         assertEquals(
                 "[Column[name=project_id,columnNumber=0,type=INTEGER,nullable=false,nativeType=null,columnSize=null], "
                         + "Column[name=lines_of_code,columnNumber=2,type=BIGINT,nullable=true,nativeType=null,columnSize=null], "
                         + "Column[name=parent_project_id,columnNumber=3,type=INTEGER,nullable=true,nativeType=null,columnSize=null]]",
-                Arrays.toString(projectTable.getNumberColumns()));
+                Arrays.toString(projectTable.getNumberColumns().toArray()));
 
         assertEquals("[Column[name=name,columnNumber=1,type=VARCHAR,nullable=false,nativeType=null,columnSize=null]]",
-                Arrays.toString(projectTable.getLiteralColumns()));
+                Arrays.toString(projectTable.getLiteralColumns().toArray()));
 
-        assertEquals("[]", Arrays.toString(projectTable.getTimeBasedColumns()));
+        assertEquals("[]", Arrays.toString(projectTable.getTimeBasedColumns().toArray()));
 
         assertNull(projectTable.getColumnByName("foobar"));
         assertNull(projectTable.getColumnByName(null));
@@ -71,34 +73,34 @@ public class SchemaModelTest extends MetaModelTestCase {
         assertEquals(3, projectContributorView.getColumnCount());
         assertEquals(3, projectContributorView.getRelationshipCount());
 
-        Relationship[] projectContributorToContributorRelations = projectContributorView
+        Collection<Relationship> projectContributorToContributorRelations = projectContributorView
                 .getRelationships(contributorTable);
-        assertEquals(1, projectContributorToContributorRelations.length);
-        Relationship[] contributorToProjectContributorRelations = contributorTable
+        assertEquals(1, projectContributorToContributorRelations.size());
+        Collection<Relationship> contributorToProjectContributorRelations = contributorTable
                 .getRelationships(projectContributorView);
-        assertEquals(1, contributorToProjectContributorRelations.length);
-        assertTrue(Arrays.equals(projectContributorToContributorRelations, contributorToProjectContributorRelations));
+        assertEquals(1, contributorToProjectContributorRelations.size());
+        assertTrue(projectContributorToContributorRelations.equals(contributorToProjectContributorRelations));
 
         assertEquals(
                 "Relationship[primaryTable=contributor,primaryColumns=[name],foreignTable=project_contributor,foreignColumns=[contributor]]",
-                projectContributorToContributorRelations[0].toString());
+                projectContributorToContributorRelations.iterator().next().toString());
 
-        ((MutableRelationship) projectContributorToContributorRelations[0]).remove();
+        ((MutableRelationship) projectContributorToContributorRelations.iterator().next()).remove();
         projectContributorToContributorRelations = projectContributorView.getRelationships(contributorTable);
-        assertEquals(0, projectContributorToContributorRelations.length);
+        assertEquals(0, projectContributorToContributorRelations.size());
         contributorToProjectContributorRelations = contributorTable.getRelationships(projectContributorView);
-        assertEquals(0, contributorToProjectContributorRelations.length);
+        assertEquals(0, contributorToProjectContributorRelations.size());
 
         // Get primary keys / Get foreign keys test
         assertEquals(
                 "[Column[name=contributor_id,columnNumber=0,type=INTEGER,nullable=false,nativeType=null,columnSize=null]]",
-                Arrays.toString(contributorTable.getPrimaryKeys()));
-        assertEquals("[]", Arrays.toString(contributorTable.getForeignKeys()));
+                Arrays.toString(contributorTable.getPrimaryKeys().toArray()));
+        assertEquals("[]", Arrays.toString(contributorTable.getForeignKeys().toArray()));
 
         assertEquals(
                 "[Column[name=contributor_id,columnNumber=0,type=INTEGER,nullable=false,nativeType=null,columnSize=null], Column[name=project_id,columnNumber=1,type=INTEGER,nullable=false,nativeType=null,columnSize=null]]",
-                Arrays.toString(roleTable.getPrimaryKeys()));
-        Column[] foreignKeys = roleTable.getForeignKeys();
-        assertEquals(2, foreignKeys.length);
+                Arrays.toString(roleTable.getPrimaryKeys().toArray()));
+        List<Column> foreignKeys = roleTable.getForeignKeys();
+        assertEquals(2, foreignKeys.size());
     }
 }
\ No newline at end of file
index fffb679..7753539 100644 (file)
@@ -75,13 +75,12 @@ public class LegacyDeserializationObjectInputStreamTest extends TestCase {
 
         final Query q = (Query) obj;
         final Table table = q.getFromClause().getItem(0).getTable();
-        final Column[] columns = table.getColumns();
 
         assertEquals("Table[name=mytable,type=TABLE,remarks=null]", table.toString());
         assertEquals("Column[name=mycol1,columnNumber=0,type=INTEGER,nullable=false,nativeType=int,columnSize=16]",
-                columns[0].toString());
+                table.getColumn(0).toString());
         assertEquals("Column[name=mycol1,columnNumber=1,type=VARCHAR,nullable=true,nativeType=text,columnSize=255]",
-                columns[1].toString());
+                table.getColumn(1).toString());
 
         assertEquals("SELECT mytable.\"mycol1\" FROM myschema.mytable WHERE mytable.mycol1 = 'foo'", q.toSql());
     }
index 22446fc..e3908c0 100644 (file)
@@ -38,7 +38,7 @@ import org.apache.metamodel.util.LazyRef;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.sugarcrm.ws.soap.EntryValue;
+import com.sugarcrm.ws.soapyxyx.EntryValue;
 import com.sugarcrm.ws.soap.GetEntriesCountResult;
 import com.sugarcrm.ws.soap.GetEntryListResultVersion2;
 import com.sugarcrm.ws.soap.LinkNamesToFieldsArray;
index b9936af..0d0bebb 100644 (file)
@@ -21,13 +21,10 @@ package org.apache.metamodel.xml;
 import java.io.File;
 import java.io.InputStream;
 import java.net.URL;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
@@ -178,7 +175,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
     }
 
     @Override
-    public DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+    public DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
         loadSchema();
         List<Object[]> tableData = _tableData.get(table.getName());
         if (tableData == null) {
@@ -186,7 +183,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
                     + _tableData.keySet());
         }
 
-        final SelectItem[] selectItems = MetaModelHelper.createSelectItems(columns);
+        final List<SelectItem> selectItems = columns.stream().map(SelectItem::new).collect(Collectors.toList());
         final DataSetHeader header = new CachingDataSetHeader(selectItems);
 
         final List<Row> resultData = new ArrayList<Row>();
@@ -195,9 +192,9 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
                 break;
             }
             maxRows--;
-            Object[] dataValues = new Object[columns.length];
-            for (int i = 0; i < columns.length; i++) {
-                Column column = columns[i];
+            Object[] dataValues = new Object[columns.size()];
+            for (int i = 0; i < columns.size(); i++) {
+                Column column = columns.get(i);
                 int columnNumber = column.getColumnNumber();
                 // Some rows may not contain values for all columns
                 // (attributes)
@@ -259,7 +256,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
 
         // Remove tables from schema that has no data (typically root
         // node or pure XML structure)
-        Table[] tables = _schema.getTables();
+        List<Table> tables = _schema.getTables();
         for (Table table : tables) {
             String tableName = table.getName();
             List<Object[]> tableRows = _tableData.get(tableName);
@@ -330,8 +327,8 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
                     foreignKeyColumn.setNativeType(NATIVE_TYPE_FOREIGN_KEY);
                     table.addColumn(foreignKeyColumn);
 
-                    MutableRelationship.createRelationship(new Column[] { parentKeyColumn }, new Column[] {
-                            foreignKeyColumn });
+                    MutableRelationship.createRelationship(parentKeyColumn ,
+                            foreignKeyColumn );
 
                 } else {
                     foreignKeyColumn = null;
@@ -339,9 +336,9 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
             } else {
                 idColumn = getIdColumn(table);
                 tableRows = _tableData.get(tableName);
-                Column[] foreignKeys = table.getForeignKeys();
-                if (foreignKeys.length == 1) {
-                    foreignKeyColumn = (MutableColumn) foreignKeys[0];
+                List<Column> foreignKeys = table.getForeignKeys();
+                if (foreignKeys.size() == 1) {
+                    foreignKeyColumn = (MutableColumn) foreignKeys.get(0);
                 } else {
                     foreignKeyColumn = null;
                 }
@@ -401,7 +398,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
     }
 
     private Column getTextContentColumn(MutableTable table, String preferredColumnName) {
-        Column[] columns = table.getColumns();
+        List<Column> columns = table.getColumns();
         MutableColumn column = null;
         for (Column col : columns) {
             if (NATIVE_TYPE_TEXT.equals(col.getNativeType())) {
@@ -420,7 +417,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
     }
 
     private MutableColumn getIdColumn(MutableTable table) {
-        Column[] columns = table.getColumns();
+        List<Column> columns = table.getColumns();
         MutableColumn column = null;
         for (Column col : columns) {
             if (NATIVE_TYPE_PRIMARY_KEY.equals(col.getNativeType())) {
@@ -507,18 +504,15 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
         // Check that foreignTable is not primary table in other relationships
         // (if so we can't flatten as that would require id-rewriting of those
         // foreign tables as well)
-        if (foreignTable.getPrimaryKeyRelationships().length != 0) {
-            Relationship[] foreignPrimaryRelationships = foreignTable.getPrimaryKeyRelationships();
-            String[] foreignPrimaryNames = new String[foreignPrimaryRelationships.length];
-            for (int i = 0; i < foreignPrimaryRelationships.length; i++) {
-                foreignPrimaryNames[i] = foreignPrimaryRelationships[i].getForeignTable().getName();
-            }
+        if (!foreignTable.getPrimaryKeyRelationships().isEmpty()) {
+            Collection<Relationship> foreignPrimaryRelationships = foreignTable.getPrimaryKeyRelationships();
             throw new UnsupportedOperationException("Cannot flatten foreign table '" + foreignTable.getName()
-                    + "' as it acts as primary table for tables: " + Arrays.toString(foreignPrimaryNames));
+                    + "' as it acts as primary table for tables: " + foreignPrimaryRelationships.stream()
+                    .map(ftRel -> ftRel.getForeignTable().getName()).collect(Collectors.joining(", ")));
         }
 
-        List<Column> primaryColumns = new ArrayList<Column>(Arrays.asList(primaryTable.getColumns()));
-        List<Column> foreignColumns = new ArrayList<Column>(Arrays.asList(foreignTable.getColumns()));
+        List<Column> primaryColumns = primaryTable.getColumns();
+        List<Column> foreignColumns = foreignTable.getColumns();
 
         // Remove the surrogate id
         String primaryTableName = primaryTable.getName();
@@ -527,8 +521,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
         foreignColumns.remove(idColumn);
 
         // Remove the foreign keys
-        Column[] foreignKeys = foreignTable.getForeignKeys();
-        for (Column foreignKey : foreignKeys) {
+        for (Column foreignKey : foreignTable.getForeignKeys()) {
             foreignColumns.remove(foreignKey);
         }
 
@@ -560,7 +553,7 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
             logger.info("Tables '" + primaryTableName + "' and '" + foreignTableName + "' flattened to: "
                     + primaryTableName);
             if (logger.isDebugEnabled()) {
-                logger.debug(primaryTableName + " columns: " + Arrays.toString(primaryTable.getColumns()));
+                logger.debug(primaryTableName + " columns: " + Arrays.toString(primaryTable.getColumns().toArray()));
             }
         }
 
@@ -574,22 +567,20 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
      * mapped tables).
      */
     public XmlDomDataContext autoFlattenTables() {
-        Table[] tables = _schema.getTables();
-        for (Table table : tables) {
+        for (Table table : _schema.getTables()) {
             // First check to see that this table still exist (ie. has not been
             // flattened in a previous loop)
             if (_tableData.containsKey(table.getName())) {
                 // Find all tables that represent inner tags
-                Relationship[] foreignKeyRelationships = table.getForeignKeyRelationships();
-                if (foreignKeyRelationships.length == 1 && table.getPrimaryKeyRelationships().length == 0) {
-                    Relationship foreignKeyRelationship = foreignKeyRelationships[0];
+                Collection<Relationship> foreignKeyRelationships = table.getForeignKeyRelationships();
+                if (foreignKeyRelationships.size() == 1 && table.getPrimaryKeyRelationships().size() == 0) {
+                    Relationship foreignKeyRelationship = foreignKeyRelationships.iterator().next();
 
                     // If there is exactly one inner tag then we can probably
                     // flatten the tables, but it's only relevant if the inner
                     // tag only carry a single data column
                     int nonDataColumns = 0;
-                    Column[] columns = table.getColumns();
-                    for (Column column : columns) {
+                    for (Column column : table.getColumns()) {
                         String nativeType = column.getNativeType();
                         // Use the native column type constants to determine if
                         // the column is an artificial column
@@ -598,14 +589,14 @@ public class XmlDomDataContext extends QueryPostprocessDataContext {
                         }
                     }
 
-                    if (columns.length == nonDataColumns + 1) {
+                    if (table.getColumns().size() == nonDataColumns + 1) {
                         // If the foreign key is unique for all rows, we will
                         // flatten it (otherwise it means that multiple inner
                         // tags occur, which requires two tables to deal with
                         // multiplicity)
                         boolean uniqueForeignKeys = true;
 
-                        Column[] foreignColumns = foreignKeyRelationship.getForeignColumns();
+                        List<Column> foreignColumns = foreignKeyRelationship.getForeignColumns();
 
                         SelectItem countAllItem = SelectItem.getCountAllItem();
                         Query q = new Query().select(foreignColumns).select(countAllItem).from(table).groupBy(
index f1c2d6c..217503c 100644 (file)
@@ -22,6 +22,7 @@ import java.io.File;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
 
@@ -205,13 +206,13 @@ public class XmlSaxDataContext extends QueryPostprocessDataContext {
     }
 
     @Override
-    protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
+    protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) {
         final XmlSaxTableDef tableDef = getTableDef(table);
 
-        final String[] valueXpaths = new String[columns.length];
-        final SelectItem[] selectItems = new SelectItem[columns.length];
-        for (int i = 0; i < columns.length; i++) {
-            final Column column = columns[i];
+        final String[] valueXpaths = new String[columns.size()];
+        final SelectItem[] selectItems = new SelectItem[columns.size()];
+        for (int i = 0; i < columns.size(); i++) {
+            final Column column = columns.get(i);
             selectItems[i] = new SelectItem(column);
             valueXpaths[i] = getXpath(tableDef, column);
         }
index 6985852..b5a7a02 100644 (file)
@@ -51,7 +51,7 @@ public class XmlDomDataContextTest extends TestCase {
         try {
             XmlDomDataContext dataContext = new XmlDomDataContext(url, false);
             assertEquals("xml_input_eobjects.xml", dataContext.getDefaultSchema().getName());
-            assertEquals(2, dataContext.getSchemaNames().length);
+            assertEquals(2, dataContext.getSchemaNames().size());
             Schema schema = dataContext.getSchemaByName("xml_input_eobjects.xml");
             assertEquals("Schema[name=xml_input_eobjects.xml]", schema.toString());
             assertEquals(5, schema.getTableCount());
@@ -68,31 +68,30 @@ public class XmlDomDataContextTest extends TestCase {
         XmlDomDataContext dataContext = new XmlDomDataContext(file, false);
 
         assertEquals("xml_input_eobjects.xml", dataContext.getDefaultSchema().getName());
-        assertEquals(2, dataContext.getSchemaNames().length);
+        assertEquals(2, dataContext.getSchemaNames().size());
 
         Schema schema = dataContext.getSchemaByName("xml_input_eobjects.xml");
         assertEquals("Schema[name=xml_input_eobjects.xml]", schema.toString());
 
-        Table[] tables = schema.getTables();
         assertEquals(5, schema.getTableCount());
         assertEquals("[Table[name=eobjects.dk,type=TABLE,remarks=null], "
                 + "Table[name=contributors_person,type=TABLE,remarks=null], "
                 + "Table[name=contributors_person_name,type=TABLE,remarks=null], "
                 + "Table[name=contributors_person_address,type=TABLE,remarks=null], "
-                + "Table[name=projects_project,type=TABLE,remarks=null]]", Arrays.toString(tables));
+                + "Table[name=projects_project,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables().toArray()));
 
         Table table = schema.getTableByName("eobjects.dk");
         assertEquals(2, table.getColumnCount());
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=website,columnNumber=2,type=STRING,nullable=true,nativeType=XML Attribute,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
 
         table = schema.getTableByName("contributors_person");
         assertEquals(1, table.getColumnCount());
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
 
         table = schema.getTableByName("contributors_person_name");
         assertEquals(3, table.getColumnCount());
@@ -100,10 +99,10 @@ public class XmlDomDataContextTest extends TestCase {
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,nativeType=Auto-generated foreign key,columnSize=null], "
                         + "Column[name=name,columnNumber=2,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
         assertEquals("[Relationship[primaryTable=contributors_person,primaryColumns=[id],"
                 + "foreignTable=contributors_person_name,foreignColumns=[contributors_person_id]]]",
-                Arrays.toString(table.getRelationships()));
+                Arrays.toString(table.getRelationships().toArray()));
 
         table = schema.getTableByName("contributors_person_address");
         assertEquals(3, table.getColumnCount());
@@ -111,10 +110,10 @@ public class XmlDomDataContextTest extends TestCase {
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=contributors_person_id,columnNumber=1,type=INTEGER,nullable=false,nativeType=Auto-generated foreign key,columnSize=null], "
                         + "Column[name=address,columnNumber=2,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
         assertEquals("[Relationship[primaryTable=contributors_person,primaryColumns=[id],"
                 + "foreignTable=contributors_person_address,foreignColumns=[contributors_person_id]]]",
-                Arrays.toString(table.getRelationships()));
+                Arrays.toString(table.getRelationships().toArray()));
 
         table = schema.getTableByName("projects_project");
         assertEquals(3, table.getColumnCount());
@@ -122,7 +121,7 @@ public class XmlDomDataContextTest extends TestCase {
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=project,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=name,columnNumber=2,type=STRING,nullable=true,nativeType=XML Attribute,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
 
         dataContext.autoFlattenTables();
         table = schema.getTableByName("contributors_person");
@@ -130,7 +129,7 @@ public class XmlDomDataContextTest extends TestCase {
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=name,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
     }
 
     public void testExecuteQuery() throws Exception {
@@ -159,7 +158,7 @@ public class XmlDomDataContextTest extends TestCase {
 
         // Make a new query that joins the normalized tables together
         table = schema.getTableByName("contributors_person_address");
-        Relationship relationShip = table.getRelationships()[0];
+        Relationship relationShip = table.getRelationships().iterator().next();
         q = new Query().select(relationShip.getPrimaryTable().getColumns())
                 .select(relationShip.getForeignTable().getColumns()).from(new FromItem(JoinType.INNER, relationShip));
 
@@ -211,12 +210,12 @@ public class XmlDomDataContextTest extends TestCase {
         XmlDomDataContext strategy = new XmlDomDataContext("foobarSchema", document, true);
         Schema schema = strategy.getSchemaByName("foobarSchema");
         assertEquals("Schema[name=foobarSchema]", schema.toString());
-        assertEquals("[Table[name=child,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables()));
-        Table table = schema.getTables()[0];
+        assertEquals("[Table[name=child,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables().toArray()));
+        Table table = schema.getTable(0);
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=child,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
     }
 
     public void testFlattenTables() throws Exception {
@@ -227,18 +226,18 @@ public class XmlDomDataContextTest extends TestCase {
                 + "Table[name=dependency_groupId,type=TABLE,remarks=null], "
                 + "Table[name=dependency_artifactId,type=TABLE,remarks=null], "
                 + "Table[name=dependency_version,type=TABLE,remarks=null], "
-                + "Table[name=dependency_scope,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables()));
+                + "Table[name=dependency_scope,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables().toArray()));
         Table dependencyTable = schema.getTableByName("dependency");
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null]]",
-                Arrays.toString(dependencyTable.getColumns()));
+                Arrays.toString(dependencyTable.getColumns().toArray()));
         List<Object[]> dependencyData = dc
                 .materializeMainSchemaTable(dependencyTable, dependencyTable.getColumns(), -1).toObjectArrays();
         assertEquals(11, dependencyData.size());
         assertEquals("[1]", Arrays.toString(dependencyData.get(0)));
         assertEquals("[11]", Arrays.toString(dependencyData.get(10)));
 
-        Relationship relationship = schema.getTableByName("dependency_groupId").getRelationships()[0];
+        Relationship relationship = schema.getTableByName("dependency_groupId").getRelationships().iterator().next();
         assertEquals(
                 "Relationship[primaryTable=dependency,primaryColumns=[id],foreignTable=dependency_groupId,foreignColumns=[dependency_id]]",
                 relationship.toString());
@@ -248,12 +247,12 @@ public class XmlDomDataContextTest extends TestCase {
         assertEquals("[Table[name=dependency,type=TABLE,remarks=null], "
                 + "Table[name=dependency_artifactId,type=TABLE,remarks=null], "
                 + "Table[name=dependency_version,type=TABLE,remarks=null], "
-                + "Table[name=dependency_scope,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables()));
+                + "Table[name=dependency_scope,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables().toArray()));
 
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=groupId,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(dependencyTable.getColumns()));
+                Arrays.toString(dependencyTable.getColumns().toArray()));
 
         dependencyData = dc.materializeMainSchemaTable(dependencyTable, dependencyTable.getColumns(), -1)
                 .toObjectArrays();
@@ -263,14 +262,14 @@ public class XmlDomDataContextTest extends TestCase {
 
         dc.autoFlattenTables();
 
-        assertEquals("[Table[name=dependency,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables()));
+        assertEquals("[Table[name=dependency,type=TABLE,remarks=null]]", Arrays.toString(schema.getTables().toArray()));
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=groupId,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=artifactId,columnNumber=2,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=version,columnNumber=3,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=scope,columnNumber=4,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(dependencyTable.getColumns()));
+                Arrays.toString(dependencyTable.getColumns().toArray()));
 
         dependencyData = dc.materializeMainSchemaTable(dependencyTable, dependencyTable.getColumns(), -1)
                 .toObjectArrays();
@@ -290,13 +289,13 @@ public class XmlDomDataContextTest extends TestCase {
                         + "Column[name=artifactId,columnNumber=2,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=version,columnNumber=3,type=STRING,nullable=true,nativeType=XML Text,columnSize=null], "
                         + "Column[name=scope,columnNumber=4,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
 
         table = schema.getTableByName("inceptionYear");
         assertEquals(
                 "[Column[name=id,columnNumber=0,type=INTEGER,nullable=false,nativeType=Auto-generated primary key,columnSize=null], "
                         + "Column[name=inceptionYear,columnNumber=1,type=STRING,nullable=true,nativeType=XML Text,columnSize=null]]",
-                Arrays.toString(table.getColumns()));
+                Arrays.toString(table.getColumns().toArray()));
 
         // first read
         DataSet data = dc.executeQuery(new Query().select(table.getColumnByName("inceptionYear")).from(table)
@@ -323,10 +322,10 @@ public class XmlDomDataContextTest extends TestCase {
                 + "Machine_Hardware_Network_Adapter, Machine_Hardware_UART_Port, Machine_Hardware_LPT_Port, "
                 + "Machine_Hardware_AudioAdapter, Machine_Hardware_SharedFolders_SharedFolder, "
                 + "Machine_Hardware_Guest, Machine_HardDiskAttachments_HardDiskAttachment]",
-                Arrays.toString(schema.getTableNames()));
+                Arrays.toString(schema.getTableNames().toArray()));
         assertEquals(
                 "[id, OSType, lastStateChange, name, uuid, enabled, enabled, RAMSize, enabled, enabled, mode, value, "
                         + "enabled, type, enabled, mode]",
-                Arrays.toString(schema.getTableByName("Machine").getColumnNames()));
+                Arrays.toString(schema.getTableByName("Machine").getColumnNames().toArray()));
     }
 }
\ No newline at end of file
index d150aac..4ee8dba 100644 (file)
@@ -44,11 +44,11 @@ public class XmlSaxDataContextTest extends TestCase {
 
                final Schema schema = dc.getDefaultSchema();
                assertEquals("Schema[name=/dependencies]", schema.toString());
-               assertEquals("[/dependency]", Arrays.toString(schema.getTableNames()));
+               assertEquals("[/dependency]", Arrays.toString(schema.getTableNames().toArray()));
 
                final Table table = schema.getTableByName("/dependency");
                assertEquals("[row_id, /artifactId, /groupId, /version, /scope]",
-                               Arrays.toString(table.getColumnNames()));
+                               Arrays.toString(table.getColumnNames().toArray()));
 
                // perform a regular query
                DataSet ds = dc.query().from(table).select(table.getColumns())
@@ -112,13 +112,13 @@ public class XmlSaxDataContextTest extends TestCase {
                final Schema schema = dc.getDefaultSchema();
                assertEquals("Schema[name=/root]", schema.toString());
                assertEquals("[/employee, /organization]",
-                               Arrays.toString(schema.getTableNames()));
+                               Arrays.toString(schema.getTableNames().toArray()));
 
                // organization assertions
                final Table organizationTable = schema.getTableByName("/organization");
                {
                        assertEquals("[row_id, /name, @type]",
-                                       Arrays.toString(organizationTable.getColumnNames()));
+                                       Arrays.toString(organizationTable.getColumnNames().toArray()));
 
                        DataSet ds = dc.query().from(organizationTable)
                                        .select(organizationTable.getColumns()).execute();
@@ -140,7 +140,7 @@ public class XmlSaxDataContextTest extends TestCase {
                {
                        assertEquals(
                                        "[row_id, /name, /gender, index(/root/organization/employees), index(/root/organization)]",
-                                       Arrays.toString(employeeTable.getColumnNames()));
+                                       Arrays.toString(employeeTable.getColumnNames().toArray()));
 
                        DataSet ds = dc.query().from(employeeTable)
                                        .select(employeeTable.getColumns()).execute();