/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.sis.internal.sql.feature;

import java.util.Map;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Optional;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import java.sql.DatabaseMetaData;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.opengis.util.GenericName;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.apache.sis.feature.builder.AttributeRole;
import org.apache.sis.feature.builder.AttributeTypeBuilder;
import org.apache.sis.feature.builder.AssociationRoleBuilder;
import org.apache.sis.feature.builder.FeatureTypeBuilder;
import org.apache.sis.internal.feature.Geometries;
import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.DataStoreContentException;
import org.apache.sis.storage.InternalDataStoreException;
import org.apache.sis.internal.metadata.sql.Reflection;
import org.apache.sis.internal.metadata.sql.SQLUtilities;
import org.apache.sis.internal.storage.AbstractFeatureSet;
import org.apache.sis.internal.util.CollectionsExt;
import org.apache.sis.util.collection.WeakValueHashMap;
import org.apache.sis.util.collection.TreeTable;
import org.apache.sis.util.CharSequences;
import org.apache.sis.util.Exceptions;
import org.apache.sis.util.Classes;
import org.apache.sis.util.Numbers;
import org.apache.sis.util.Debug;

// Branch-dependent imports
import org.apache.sis.feature.AbstractFeature;
import org.apache.sis.feature.DefaultFeatureType;
import org.apache.sis.feature.DefaultAssociationRole;


/**
 * Description of a table in the database, including columns, primary keys and foreigner keys.
 * This class contains a {@code FeatureType} inferred from the table structure. The {@code FeatureType}
 * contains an {@code AttributeType} for each table column, except foreigner keys which are represented
 * by {@link DefaultAssociationRole}s.
 *
 * @author  Johann Sorel (Geomatys)
 * @author  Martin Desruisseaux (Geomatys)
 * @version 1.0
 * @since   1.0
 * @module
 */
final class Table extends AbstractFeatureSet {
    /**
     * Provider of (pooled) connections to the database.
     */
    private final DataSource source;

    /**
     * The structure of this table represented as a feature. Each feature attribute is a table column,
     * except synthetic attributes like "sis:identifier". The feature may also contain associations
     * inferred from foreigner keys that are not immediately apparent in the table.
     */
    final DefaultFeatureType featureType;

    /**
     * The name in the database of this {@code Table} object, together with its schema and catalog.
     */
    final TableReference name;

    /**
     * Name of attributes in feature instances, excluding operations and associations to other tables.
     * Those names are in the order of columns declared in the {@code SELECT <columns} statement.
     * This array shall not be modified after construction.
     */
    private final String[] attributeNames;

    /**
     * Name of columns corresponding to each {@link #attributeNames}. This is often a reference to the
     * same array than {@link #attributeNames}, but may be different if some attributes have been renamed
     * for avoiding name collisions.
     */
    private final String[] attributeColumns;

    /**
     * The columns that constitute the primary key, or {@code null} if there is no primary key.
     */
    private final String[] primaryKeys;

    /**
     * The primary keys of other tables that are referenced by this table foreign key columns.
     * They are 0:1 relations. May be {@code null} if there is no imported keys.
     */
    private final Relation[] importedKeys;

    /**
     * The foreign keys of other tables that reference this table primary key columns.
     * They are 0:N relations. May be {@code null} if there is no exported keys.
     */
    private final Relation[] exportedKeys;

    /**
     * The class of primary key values, or {@code null} if there is no primary keys.
     * If the primary keys use more than one column, then this field is the class of
     * an array; it may be an array of primitive type.
     */
    final Class<?> primaryKeyClass;

    /**
     * Feature instances already created for given primary keys. This map is used only when requesting feature
     * instances by identifiers (not for iterating over all features) and those identifiers are primary keys.
     * We create this map only for tables referenced by foreigner keys of other tables as enumerated by the
     * {@link Relation.Direction#IMPORT} and {@link Relation.Direction#EXPORT} cases; not for arbitrary
     * cross-reference cases. Values are usually {@code Feature} instances, but may also be {@code Collection<Feature>}.
     *
     * @see #instanceForPrimaryKeys()
     */
    private WeakValueHashMap<?,Object> instanceForPrimaryKeys;

    /**
     * {@code true} if this table contains at least one geometry column.
     */
    final boolean hasGeometry;

    /**
     * Creates a description of the table of the given name.
     * The table is identified by {@code id}, which contains a (catalog, schema, name) tuple.
     * The catalog and schema parts are optional and can be null, but the table is mandatory.
     *
     * @param  analyzer    helper functions, e.g. for converting SQL types to Java types.
     * @param  id          the catalog, schema and table name of the table to analyze.
     * @param  importedBy  if this table is imported by the foreigner keys of another table,
     *                     the parent table. Otherwise {@code null}.
     */
    Table(final Analyzer analyzer, final TableReference id, final TableReference importedBy)
            throws SQLException, DataStoreException
    {
        super(analyzer.listeners);
        this.source = analyzer.source;
        this.name   = id;
        final String tableEsc  = analyzer.escape(id.table);
        final String schemaEsc = analyzer.escape(id.schema);
        /*
         * Get a list of primary keys. We need to know them before to create the attributes,
         * in order to detect which attributes are used as components of Feature identifiers.
         * In the 'primaryKeys' map, the boolean tells whether the column uses auto-increment,
         * with null value meaning that we don't know.
         *
         * Note: when a table contains no primary keys, we could still look for index columns
         * with unique constraint using metadata.getIndexInfo(catalog, schema, table, true).
         * We don't do that for now because of uncertainties (which index to use if there is
         * many? If they are suitable as identifiers why they are not primary keys?).
         */
        final Map<String,Boolean> primaryKeys = new LinkedHashMap<>();
        try (ResultSet reflect = analyzer.metadata.getPrimaryKeys(id.catalog, id.schema, id.table)) {
            while (reflect.next()) {
                primaryKeys.put(analyzer.getUniqueString(reflect, Reflection.COLUMN_NAME), null);
                // The actual Boolean value will be fetched in the loop on columns later.
            }
        }
        this.primaryKeys = primaryKeys.isEmpty() ? null : primaryKeys.keySet().toArray(new String[primaryKeys.size()]);
        /*
         * Creates a list of associations between the table read by this method and other tables.
         * The associations are defined by the foreigner keys referencing primary keys. Note that
         * the table relations can be defined in both ways:  the foreigner keys of this table may
         * be referencing the primary keys of other tables (Direction.IMPORT) or the primary keys
         * of this table may be referenced by the foreigner keys of other tables (Direction.EXPORT).
         * However in both case, we will translate that into associations from this table to the
         * other tables. We can not rely on IMPORT versus EXPORT for determining the association
         * navigability because the database designer's choice may be driven by the need to support
         * multi-occurrences.
         */
        final List<Relation> importedKeys = new ArrayList<>();
        final Map<String, List<Relation>> foreignerKeys = new HashMap<>();
        try (ResultSet reflect = analyzer.metadata.getImportedKeys(id.catalog, id.schema, id.table)) {
            if (reflect.next()) do {
                Relation relation = new Relation(analyzer, Relation.Direction.IMPORT, reflect);
                importedKeys.add(relation);
                for (final String column : relation.getForeignerKeys()) {
                    CollectionsExt.addToMultiValuesMap(foreignerKeys, column, relation);
                    relation = null;     // Only the first column will be associated.
                }
            } while (!reflect.isClosed());
        }
        final List<Relation> exportedKeys = new ArrayList<>();
        try (ResultSet reflect = analyzer.metadata.getExportedKeys(id.catalog, id.schema, id.table)) {
            if (reflect.next()) do {
                final Relation export = new Relation(analyzer, Relation.Direction.EXPORT, reflect);
                if (!export.equals(importedBy)) {
                    exportedKeys.add(export);
                }
            } while (!reflect.isClosed());
        }
        /*
         * For each column in the table that is not a foreigner key, create an AttributeType of the same name.
         * The Java type is inferred from the SQL type, and the attribute multiplicity in inferred from the SQL
         * nullability. Attribute names are added in the 'attributeNames' and 'attributeColumns' list. Those
         * names are usually the same, except when a column is used both as a primary key and as foreigner key.
         */
        Class<?> primaryKeyClass   = null;
        boolean  primaryKeyNonNull = true;
        boolean  hasGeometry       = false;
        int startWithLowerCase     = 0;
        final List<String> attributeNames = new ArrayList<>();
        final List<String> attributeColumns = new ArrayList<>();
        final FeatureTypeBuilder feature = new FeatureTypeBuilder(analyzer.nameFactory, analyzer.functions.library, analyzer.locale);
        try (ResultSet reflect = analyzer.metadata.getColumns(id.catalog, schemaEsc, tableEsc, null)) {
            while (reflect.next()) {
                final String         column       = analyzer.getUniqueString(reflect, Reflection.COLUMN_NAME);
                final boolean        mandatory    = Boolean.FALSE.equals(SQLUtilities.parseBoolean(reflect.getString(Reflection.IS_NULLABLE)));
                final boolean        isPrimaryKey = primaryKeys.containsKey(column);
                final List<Relation> dependencies = foreignerKeys.get(column);
                /*
                 * Heuristic rule for determining if the column names starts with lower case or upper case.
                 * Words that are all upper-case are ignored on the assumption that they are acronyms.
                 */
                if (!column.isEmpty()) {
                    final int firstLetter = column.codePointAt(0);
                    if (Character.isLowerCase(firstLetter)) {
                        startWithLowerCase++;
                    } else if (Character.isUpperCase(firstLetter) && !CharSequences.isUpperCase(column)) {
                        startWithLowerCase--;
                    }
                }
                /*
                 * Add the column as an attribute. Foreign keys are excluded (they will be replaced by associations),
                 * except if the column is also a primary key. In the later case we need to keep that column because
                 * it is needed for building the feature identifier.
                 */
                AttributeTypeBuilder<?> attribute = null;
                if (isPrimaryKey || dependencies == null) {
                    attributeNames.add(column);
                    attributeColumns.add(column);
                    final String typeName = reflect.getString(Reflection.TYPE_NAME);
                    Class<?> type = analyzer.functions.toJavaType(reflect.getInt(Reflection.DATA_TYPE), typeName);
                    if (type == null) {
                        analyzer.warning(Resources.Keys.UnknownType_1, typeName);
                        type = Object.class;
                    }
                    attribute = feature.addAttribute(type).setName(column);
                    if (CharSequence.class.isAssignableFrom(type)) {
                        final int size = reflect.getInt(Reflection.COLUMN_SIZE);
                        if (!reflect.wasNull()) {
                            attribute.setMaximalLength(size);
                        }
                    }
                    if (!mandatory) {
                        attribute.setMinimumOccurs(0);
                    }
                    /*
                     * Some columns have special purposes: components of primary keys will be used for creating
                     * identifiers, some columns may contain a geometric object. Adding a role on those columns
                     * may create synthetic columns, for example "sis:identifier".
                     */
                    if (isPrimaryKey) {
                        attribute.addRole(AttributeRole.IDENTIFIER_COMPONENT);
                        primaryKeyNonNull &= mandatory;
                        primaryKeyClass = Classes.findCommonClass(primaryKeyClass, type);
                        if (primaryKeys.put(column, SQLUtilities.parseBoolean(reflect.getString(Reflection.IS_AUTOINCREMENT))) != null) {
                            throw new DataStoreContentException(Resources.forLocale(analyzer.locale)
                                    .getString(Resources.Keys.DuplicatedColumn_1, column));
                        }
                    }
                    if (Geometries.isKnownType(type)) {
                        final CoordinateReferenceSystem crs = analyzer.functions.createGeometryCRS(reflect);
                        if (crs != null) {
                            attribute.setCRS(crs);
                        }
                        if (!hasGeometry) {
                            hasGeometry = true;
                            attribute.addRole(AttributeRole.DEFAULT_GEOMETRY);
                        }
                    }
                }
                /*
                 * If the column is a foreigner key, insert an association to another feature instead.
                 * If the foreigner key uses more than one column, only one of those columns will become
                 * an association and other columns will be omitted from the FeatureType (but there will
                 * still be used in SQL queries). Note that columns may be used by more than one relation.
                 */
                if (dependencies != null) {
                    int count = 0;
                    for (final Relation dependency : dependencies) {
                        if (dependency != null) {
                            final GenericName typeName = dependency.getName(analyzer);
                            final Table table = analyzer.table(dependency, typeName, id);
                            /*
                             * Use the column name as the association name, provided that the foreigner key
                             * use only that column. If the foreigner key use more than one column, then we
                             * do not know which column describes better the association (often there is none).
                             * In such case we use the foreigner key name as a fallback.
                             */
                            dependency.setPropertyName(column, count++);
                            final AssociationRoleBuilder association;
                            if (table != null) {
                                dependency.setSearchTable(analyzer, table, table.primaryKeys, Relation.Direction.IMPORT);
                                association = feature.addAssociation(table.featureType);
                            } else {
                                association = feature.addAssociation(typeName);     // May happen in case of cyclic dependency.
                            }
                            association.setName(dependency.propertyName);
                            if (!mandatory) {
                                association.setMinimumOccurs(0);
                            }
                            /*
                             * If the column is also used in the primary key, then we have a name clash.
                             * Rename the primary key column with the addition of a "pk:" scope. We rename
                             * the primary key column instead than this association because the primary key
                             * column should rarely be used directly.
                             */
                            if (attribute != null) {
                                attribute.setName(analyzer.nameFactory.createGenericName(null, "pk", column));
                                attributeNames.set(attributeNames.size() - 1, attribute.getName().toString());
                                attribute = null;
                            }
                        }
                    }
                }
            }
        }
        /*
         * Add the associations created by other tables having foreigner keys to this table.
         * We infer the column name from the target type. We may have a name clash with other
         * columns, in which case an arbitrary name change is applied.
         */
        int count = 0;
        for (final Relation dependency : exportedKeys) {
            if (dependency != null) {
                final GenericName typeName = dependency.getName(analyzer);
                String propertyName = typeName.tip().toString();
                if (startWithLowerCase > 0) {
                    final CharSequence words = CharSequences.camelCaseToWords(propertyName, true);
                    final int first = Character.codePointAt(words, 0);
                    propertyName = new StringBuilder(words.length())
                            .appendCodePoint(Character.toLowerCase(first))
                            .append(words, Character.charCount(first), words.length())
                            .toString();
                }
                final String base = propertyName;
                while (feature.isNameUsed(propertyName)) {
                    propertyName = base + '-' + ++count;
                }
                dependency.propertyName = propertyName;
                final Table table = analyzer.table(dependency, typeName, null);   // 'null' because exported, not imported.
                final AssociationRoleBuilder association;
                if (table != null) {
                    dependency.setSearchTable(analyzer, table, this.primaryKeys, Relation.Direction.EXPORT);
                    association = feature.addAssociation(table.featureType);
                } else {
                    association = feature.addAssociation(typeName);     // May happen in case of cyclic dependency.
                }
                association.setName(propertyName)
                           .setMinimumOccurs(0)
                           .setMaximumOccurs(Integer.MAX_VALUE);
            }
        }
        /*
         * If the primary keys uses more than one column, we will need an array to store it.
         * If all columns are non-null numbers, use primitive arrays instead than array of wrappers.
         */
        if (primaryKeys.size() > 1) {
            if (primaryKeyNonNull) {
                primaryKeyClass = Numbers.wrapperToPrimitive(primaryKeyClass);
            }
            primaryKeyClass = Classes.changeArrayDimension(primaryKeyClass, 1);
        }
        /*
         * Global information on the feature type (name, remarks).
         * The remarks are opportunistically stored in id.freeText if known by the caller.
         */
        feature.setName(id.getName(analyzer));
        String remarks = id.freeText;
        if (id instanceof Relation) {
            try (ResultSet reflect = analyzer.metadata.getTables(id.catalog, schemaEsc, tableEsc, null)) {
                while (reflect.next()) {
                    remarks = analyzer.getUniqueString(reflect, Reflection.REMARKS);
                    if (remarks != null) {
                        remarks = remarks.trim();
                        if (remarks.isEmpty()) {
                            remarks = null;
                        } else break;
                    }
                }
            }
        }
        if (remarks != null) {
            feature.setDefinition(remarks);
        }
        this.featureType      = feature.build();
        this.importedKeys     = toArray(importedKeys);
        this.exportedKeys     = toArray(exportedKeys);
        this.primaryKeyClass  = primaryKeyClass;
        this.hasGeometry      = hasGeometry;
        this.attributeNames   = attributeNames.toArray(new String[attributeNames.size()]);
        this.attributeColumns = attributeColumns.equals(attributeNames) ? this.attributeNames
                              : attributeColumns.toArray(new String[attributeColumns.size()]);
    }

    /**
     * Returns the given relations as an array, or {@code null} if none.
     */
    private static Relation[] toArray(final Collection<Relation> relations) {
        final int size = relations.size();
        return (size != 0) ? relations.toArray(new Relation[size]) : null;
    }

    /**
     * Sets the search tables on all {@link Relation} instances for which this operation has been deferred.
     * This happen when a table could not be obtained because of circular dependency. This method is invoked
     * after all tables have been created in order to fill such holes.
     *
     * @param  tables  all tables created.
     */
    final void setDeferredSearchTables(final Analyzer analyzer, final Map<GenericName,Table> tables) throws DataStoreException {
        for (final Relation.Direction direction : Relation.Direction.values()) {
            final Relation[] relations;
            switch (direction) {
                case IMPORT: relations = importedKeys; break;
                case EXPORT: relations = exportedKeys; break;
                default: continue;
            }
            if (relations != null) {
                for (final Relation relation : relations) {
                    if (!relation.isSearchTableDefined()) {
                        // A ClassCastException below would be a bug since 'relation.propertyName' shall be for an association.
                        DefaultAssociationRole association = (DefaultAssociationRole) featureType.getProperty(relation.propertyName);
                        final Table table = tables.get(association.getValueType().getName());
                        if (table == null) {
                            throw new InternalDataStoreException(association.toString());
                        }
                        final String[] referenced;
                        switch (direction) {
                            case IMPORT: referenced = table.primaryKeys; break;
                            case EXPORT: referenced =  this.primaryKeys; break;
                            default: throw new AssertionError(direction);
                        }
                        relation.setSearchTable(analyzer, table, referenced, direction);
                    }
                }
            }
        }
    }


    // ────────────────────────────────────────────────────────────────────────────────────────
    //     End of table construction. Next methods are for visualizing the table structure.
    // ────────────────────────────────────────────────────────────────────────────────────────


    /**
     * Appends all children to the given parent. The children are added under the given node.
     * If the children array is null, then this method does nothing.
     *
     * @param  parent    the node where to add children.
     * @param  children  the children to add, or {@code null} if none.
     * @param  arrow     the symbol to use for relating the columns of two tables in a foreigner key.
     */
    @Debug
    private static void appendAll(final TreeTable.Node parent, final Relation[] children, final String arrow) {
        if (children != null) {
            for (final Relation child : children) {
                child.appendTo(parent, arrow);
            }
        }
    }

    /**
     * Creates a tree representation of this table for debugging purpose.
     *
     * @param  parent  the parent node where to add the tree representation.
     */
    @Debug
    final void appendTo(TreeTable.Node parent) {
        parent = Relation.newChild(parent, featureType.getName().toString());
        for (final String attribute : attributeNames) {
            TableReference.newChild(parent, attribute);
        }
        appendAll(parent, importedKeys, " → ");
        appendAll(parent, exportedKeys, " ← ");
    }

    /**
     * Formats a graphical representation of this table for debugging purpose. This representation
     * can be printed to the {@linkplain System#out standard output stream} (for example) if the
     * output device uses a monospaced font and supports Unicode.
     */
    @Override
    public String toString() {
        return TableReference.toString(this, (n) -> appendTo(n));
    }


    // ────────────────────────────────────────────────────────────────────────────────────────
    //     End of table structure visualization. Next methods are for fetching features.
    // ────────────────────────────────────────────────────────────────────────────────────────


    /**
     * Returns the table identifier composed of catalog, schema and table name.
     */
    @Override
    public final Optional<GenericName> getIdentifier() {
        return Optional.of(featureType.getName().toFullyQualifiedName());
    }

    /**
     * Returns the feature type inferred from the database structure analysis.
     */
    @Override
    public final DefaultFeatureType getType() {
        return featureType;
    }

    /**
     * If this table imports the inverse of the given relation, returns the imported relation.
     * Otherwise returns {@code null}. This method is used for preventing infinite recursivity.
     *
     * @param  exported       the relation exported by another table.
     * @param  exportedOwner  {@code exported.owner.name}: table that contains the {@code exported} relation.
     * @return the inverse of the given relation, or {@code null} if none.
     */
    final Relation getInverseOf(final Relation exported, final TableReference exportedOwner) {
        if (importedKeys != null && name.equals(exported)) {
            for (final Relation relation : importedKeys) {
                if (relation.equals(exportedOwner) && relation.isInverseOf(exported)) {
                    return relation;
                }
            }
        }
        return null;
    }

    /**
     * Returns a cache for fetching feature instances by identifier. The map is created when this method is
     * first invoked. Keys are primary key values, typically as {@code String} or {@code Integer} instances
     * or arrays of those if the keys use more than one column. Values are usually {@code Feature} instances,
     * but may also be {@code Collection<Feature>}.
     */
    @SuppressWarnings("ReturnOfCollectionOrArrayField")
    final synchronized WeakValueHashMap<?,Object> instanceForPrimaryKeys() {
        if (instanceForPrimaryKeys == null) {
            instanceForPrimaryKeys = new WeakValueHashMap<>(primaryKeyClass);
        }
        return instanceForPrimaryKeys;
    }

    /**
     * Returns the number of rows, or -1 if unknown. Note that some database drivers returns 0,
     * so it is better to consider 0 as "unknown" too. We do not cache this count because it may
     * change at any time.
     *
     * @param  metadata     information about the database.
     * @param  approximate  whether approximate or outdated values are acceptable.
     * @return number of rows (may be approximate), or -1 if unknown.
     */
    final long countRows(final DatabaseMetaData metadata, final boolean approximate) throws SQLException {
        long count = -1;
        final String[] names = TableReference.splitName(featureType.getName());
        try (ResultSet reflect = metadata.getIndexInfo(names[2], names[1], names[0], false, approximate)) {
            while (reflect.next()) {
                final long n = reflect.getLong(Reflection.CARDINALITY);
                if (!reflect.wasNull()) {
                    if (reflect.getShort(Reflection.TYPE) == DatabaseMetaData.tableIndexStatistic) {
                        return n;       // "Index statistic" type provides the number of rows in the table.
                    }
                    if (n > count) {    // Other index types may be inaccurate.
                        count = n;
                    }
                }
            }
        }
        return count;
    }

    /**
     * Returns a stream of all features contained in this dataset.
     *
     * @param  parallel  {@code true} for a parallel stream (if supported), or {@code false} for a sequential stream.
     * @return all features contained in this dataset.
     * @throws DataStoreException if an error occurred while creating the stream.
     */
    @Override
    public Stream<AbstractFeature> features(final boolean parallel) throws DataStoreException {
        DataStoreException ex;
        Connection connection = null;
        try {
            connection = source.getConnection();
            final Features iter = features(connection, new ArrayList<>(), null);
            return StreamSupport.stream(iter, parallel).onClose(iter);
        } catch (SQLException cause) {
            ex = new DataStoreException(Exceptions.unwrap(cause));
        }
        if (connection != null) try {
            connection.close();
        } catch (SQLException e) {
            ex.addSuppressed(e);
        }
        throw ex;
    }

    /**
     * Returns an iterator over the features.
     *
     * @param connection  connection to the database.
     * @param following   the relations that we are following. Used for avoiding never ending loop.
     * @param noFollow    relation to not follow, or {@code null} if none.
     */
    final Features features(final Connection connection, final List<Relation> following, final Relation noFollow)
            throws SQLException, InternalDataStoreException
    {
        return new Features(this, connection, attributeNames, attributeColumns, importedKeys, exportedKeys, following, noFollow);
    }
}