Application: gvSIG desktop

                    attrnames.add(attrdesc.getName().toLowerCase());

            } else { 

                // Ojo, este bucle falla cuando hay un campo calculado que depende

                // de otro campo calculado.

                    if (emulator != null && attrnames.contains(attrdesc.getName().toLowerCase())) {

                        String theNames[] = emulator.getRequiredFieldNames();

                        if (names != null) {

                            for (String name : theNames) {

                                name = name.toLowerCase();

                                attrnames.add(name);

                                requiredAttrnames.add(name);

                            }

                        String name = attrdesc.getName().toLowerCase();

                        attrnames.add(name);

                        requiredAttrnames.add(name);

            // Set the constants attributes.

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

            DataManagerProviderServices dataManager = (DataManagerProviderServices) DALLocator.getDataManager();

            FeatureStore myStore = this.descriptor.getStore();

            if( myStore!=null ) {

                this.availableValues = dataManager.getAvailableValues(myStore, this.descriptor);

    @Override

    public Object getExtraValue(String name) {

        return this.data.getExtraValue(name);

    }

    @Override

    public Object getExtraValue(int index) {

        return this.data.getExtraValue(index);

    }

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.dynobject.DynObjectAdapter;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

//    public static final String FUNCTION_FEATURES = "FEATURES";

//

//    public class FeaturesFunction extends AbstractFunction {

//

//        public FeaturesFunction() {

//            super(

//                    "Data access",

//                    FUNCTION_FEATURES,

//                    Range.between(1, 3),

//                    "Return a list of the features selecteds with filter in the store.",

//                    FUNCTION_FEATURES + "({{store_name}}, filter, order)",

//                    new String[]{

//                        "store - data store name to be used",

//                        "where - Optional. String value with a filter expression",

//                        "order - Optional. String value with the order. must be a string with the names of separate fields with commas"

//                    },

//                    "LIST"

//            );

//        }

//

//        @Override

//        public Object call(Interpreter interpreter, Object[] args) throws Exception {

//            String storeName = getStr(args, 0);

//            String where = null;

//            String order = null;

//            switch (args.length) {

//                case 2:

//                    where = getStr(args, 1);

//                    break;

//                case 3:

//                    where = getStr(args, 1);

//                    order = getStr(args, 2);

//                    break;

//            }

//            try {

//                DataStore store = getStore(storeName);

//                if (store == null || !(store instanceof FeatureStore)) {

//                    throw new ExpressionRuntimeException("Cant locate the store '" + storeName + "' in function '" + FUNCTION_FEATURES + "'.");

//                }

//                if (!(store instanceof FeatureStore)) {

//                    throw new ExpressionRuntimeException("The store'" + storeName + "' is not valid for function '" + FUNCTION_FEATURES + "', a FeatureStore is required.");

//                }

//                FeatureStore featureStore = (FeatureStore) store;

//                List<Feature> features;

//                if (where == null && order == null) {

//                    features = featureStore.getFeatures();

//                } else {

//                    FeatureQuery query = featureStore.createFeatureQuery();

//                    if (where != null) {

//                        query.addFilter(where);

//                    }

//                    if (order != null) {

//                        query.getOrder().add(order);

//                    }

//                    query.retrievesAllAttributes();

//                    features = featureStore.getFeatures(query);

//                }

//                return features;

//            } catch (ExpressionRuntimeException ex) {

//                throw ex;

//            } catch (Exception ex) {

//                throw new ExpressionRuntimeException("Problems calling '" + FUNCTION_FEATURES + "' function", ex);

//            }

//        }

//

//        protected DataStore getStore(String storeName) {

//            DataStore store = feature.getStore();

////            DataManager dataManager = DALLocator.getDataManager();

////            DataStore store = dataManager.getStoresRepository().getStore(storeName);

//            return store;

//        }

//    }

                    "Problems calling '" + FUNCTION_FOREING_VALUE + 

                value = feature.getExtraValue(StringUtils.join(fieldNames, "."));

                if( value != null ) {

                    return value;

                }

                throw new ExpressionRuntimeException("Problems calling '" + FUNCTION_FOREING_VALUE + "' function", ex);

                store = store.getStoresRepository().getStore(storeName);

    private String storeName;

//        this.addFunction(new FeaturesFunction());

        if( StringUtils.equalsIgnoreCase(name, this.storeName) ) {

            return new DynObjectAdapter() {

                @Override

                public Object getDynValue(String string) throws DynFieldNotFoundException {

                    return feature.get(string);

                }

            };

        }

        if( this.type == null ) {

            this.type = feature.getType();

            FeatureStore store = feature.getStore();

            if( store!=null ) {

                this.storeName = store.getName();

            }

        }

import java.util.Objects;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.ForeingKey;

import static org.gvsig.fmap.dal.feature.ForeingKey.MAX_AVAILABLE_VALUES;

import org.gvsig.tools.dynobject.DynObjectValueItem;

    private Map<String,DynObjectValueItem[]> availableValues = null;

    @Override

    public DynObjectValueItem[] getAvailableValues(FeatureStore myStore, FeatureAttributeDescriptor descriptor) {

        String keyName = myStore.getFullName() + ":columnName=" + descriptor.getName();

        if( this.availableValues==null ) {

            this.availableValues = new HashMap<>();

        }

        DynObjectValueItem[] values = this.availableValues.get(keyName);

        if( values != null ) {

            return values;

        }

        if( !descriptor.isForeingKey() ) {

            return null;

        }

        ForeingKey foreingKey = descriptor.getForeingKey();

        try {

            StoresRepository theStoresRepository;

            FeatureStore store = descriptor.getStore();

            if (store == null) {

                theStoresRepository = DALLocator.getDataManager().getStoresRepository();

            } else {

                theStoresRepository = store.getStoresRepository();

            }

            FeatureStore foreingStore = (FeatureStore) theStoresRepository.getStore(

                foreingKey.getTableName()

            );

            Expression labelExpression = foreingKey.getLabelExpression(null);

            String codeName = foreingKey.getCodeName();

            FeatureSymbolTable featureSymbolTable = this.createFeatureSymbolTable();

            MutableSymbolTable symbolTable = featureSymbolTable.createParent();

            int count = (int) foreingStore.getFeatureCount();

            values = new DynObjectValueItem[Math.min(count, MAX_AVAILABLE_VALUES)];

            int n = 0;

            for (Feature feature : foreingStore.getFeatureSet()) {

                Object code = feature.get(codeName);

                Object value;

                if (labelExpression == null) {

                    value = code;

                } else {

                    featureSymbolTable.setFeature(feature);

                    value = labelExpression.execute(symbolTable);

                }

                values[n++] = new DynObjectValueItem(code, Objects.toString(value, Objects.toString(code, "##ERROR##")));

                if( n>=MAX_AVAILABLE_VALUES ) {

                    break;

                }

            }

            this.availableValues.put(keyName, values);

            return values;

        } catch (Exception ex) {

            LOGGER.warn("Can't get available values for field '"+myStore.getName()+"."+descriptor.getName()+"' from table '" + foreingKey.getTableName() + "'.", ex);

        }

        return null;

    }

    <dependency>

      <artifactId>junit</artifactId>

      <groupId>junit</groupId>

      <version>4.11</version>

    </dependency>

<!--

    -->

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-surefire-plugin</artifactId>

        <version>2.15</version>

      </plugin>

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.EditableForeingKey;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCHelperBase;

                "SELECT ST_AsBinary(ST_ExtentAggregate(\"the_geom\")) AS \"envelope\" FROM \"master\".\"dbo\".\"test1\" WHERE (ST_Intersects((ST_Envelope(\"the_geom\")), (ST_GeomFromWKB((DECODE('000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000','hex')), (4326)))) AND x = 27)",

//        # Test:: testPerformDeletes

//        # SQL:: DELETE FROM "master"."dbo"."test1" WHERE (( ("id1") = (?) ) AND ( ("id2") = (?) ))

//        # Variables:: [id1, id2]

//        # Parametros:: ["id1", "id2"]

                "DELETE FROM \"master\".\"dbo\".\"test1\" WHERE (( (\"id1\") = (?) ) AND ( (\"id2\") = (?) ))",

    public void testForeingValue() throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

        JDBCHelperBase helper = new JDBCHelperBase(null);

        SQLBuilder sqlbuilder = createSQLBuilder();

        ExpressionBuilder expbuilder = sqlbuilder.expression();

        EditableFeatureAttributeDescriptor attr;

        EditableForeingKey foreingKey;

        EditableFeatureType ft = dataManager.createFeatureType();

        ft.add("ID", DataTypes.INT);

        ft.add("NAME", DataTypes.STRING, 80);

        attr = ft.add("TYPE", DataTypes.INT);

        foreingKey = attr.getForeingKey();

        foreingKey.setForeingKey(true);

        foreingKey.setClosedList(true);

        foreingKey.setCodeName("ID");

        foreingKey.setTableName("TYPES");

        attr = ft.add("PHONE_TYPE", DataTypes.INT);

        foreingKey = attr.getForeingKey();

        foreingKey.setForeingKey(true);

        foreingKey.setClosedList(true);

        foreingKey.setCodeName("ID");

        foreingKey.setTableName("PHONE_TYPES");

        sqlbuilder.select().column().name("ID");

        sqlbuilder.select().column().name("NAME");

        sqlbuilder.select().column().name("DESCRIPTION");

        sqlbuilder.select().column().name("TYPE");

        sqlbuilder.select().from().table().schema("dbo").name("test1");

        sqlbuilder.select().where().set( 

            expbuilder.and(

                expbuilder.like(

                    expbuilder.function(

                        "FOREING_VALUE",

                        expbuilder.constant("TYPE.DESCRIPTION")

                    ),

                    expbuilder.constant("A%")

                ),

                expbuilder.eq(

                    expbuilder.function(

                        "FOREING_VALUE",

                        expbuilder.constant("PHONE_TYPE.DESCRIPTION")

                    ),

                    expbuilder.constant("mobile")

                )

            )

        );

        System.out.println("# Test:: testForeingValue");

        System.out.println("# SQL1:: " + sqlbuilder.toString());        

        String[] attrNames = helper.replaceForeingValueFunction(sqlbuilder, ft);

        System.out.println("# SQL2:: " + sqlbuilder.toString());

        System.out.println("# Variables:: " + ArrayUtils.toString(sqlbuilder.variables_names()));

        System.out.println("# Parametros:: " + ArrayUtils.toString(sqlbuilder.parameters_names()));

        System.out.println("# attrNames:: " + ArrayUtils.toString(attrNames));

        //# Test:: testForeingValue

        //# SQL1:: SELECT "ID", "NAME", "DESCRIPTION", "TYPE" FROM "dbo"."test1" WHERE (( (FOREING_VALUE('TYPE.DESCRIPTION')) LIKE ('A%') ) AND ( (FOREING_VALUE('PHONE_TYPE.DESCRIPTION')) = ('mobile') ))

        //# SQL2:: SELECT "ID", "NAME", "dbo"."test1"."DESCRIPTION", "TYPE", "dbo"."TYPES"."DESCRIPTION", "dbo"."PHONE_TYPES"."DESCRIPTION" FROM "dbo"."test1" LEFT JOIN "dbo"."TYPES" ON ( ("dbo"."test1"."TYPE") = ("dbo"."TYPES"."ID") ) LEFT JOIN "dbo"."PHONE_TYPES" ON ( ("dbo"."test1"."PHONE_TYPE") = ("dbo"."PHONE_TYPES"."ID") ) WHERE (( ("dbo"."TYPES"."DESCRIPTION") LIKE ('A%') ) AND ( ("dbo"."PHONE_TYPES"."DESCRIPTION") = ('mobile') ))

        //# Variables:: [DESCRIPTION, DESCRIPTION, DESCRIPTION, ID, NAME, TYPE]

        //# Parametros:: []

        //# attrNames:: [TYPE.DESCRIPTION, PHONE_TYPE.DESCRIPTION]

        assertEquals(

                "SELECT \"ID\", \"NAME\", \"dbo\".\"test1\".\"DESCRIPTION\", \"TYPE\", \"dbo\".\"TYPES\".\"DESCRIPTION\", \"dbo\".\"PHONE_TYPES\".\"DESCRIPTION\" FROM \"dbo\".\"test1\" LEFT JOIN \"dbo\".\"TYPES\" ON ( (\"dbo\".\"test1\".\"TYPE\") = (\"dbo\".\"TYPES\".\"ID\") ) LEFT JOIN \"dbo\".\"PHONE_TYPES\" ON ( (\"dbo\".\"test1\".\"PHONE_TYPE\") = (\"dbo\".\"PHONE_TYPES\".\"ID\") ) WHERE (( (\"dbo\".\"TYPES\".\"DESCRIPTION\") LIKE ('A%') ) AND ( (\"dbo\".\"PHONE_TYPES\".\"DESCRIPTION\") = ('mobile') ))",

                sqlbuilder.toString()

        );

        assertEquals(

                "[DESCRIPTION, DESCRIPTION, DESCRIPTION, ID, NAME, TYPE]",

                ArrayUtils.toString(sqlbuilder.variables_names())

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(sqlbuilder.parameters_names())

        );

        assertEquals(

                "{TYPE.DESCRIPTION,PHONE_TYPE.DESCRIPTION}",

                ArrayUtils.toString(attrNames)

        );

    }

            FeatureType featureType,

            FeatureType featureType,

            FeatureType featureType,

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.feature.ForeingKey;

import org.gvsig.fmap.dal.feature.spi.SQLBuilderBase;

    protected boolean supportCaller(Code.Caller caller) {

        if( StringUtils.equalsIgnoreCase(caller.name(), "FOREING_VALUE") ) {

            return true;

        }

        Function function = caller.function();

        if( function==null ) {

            return false;

        }

        if( !function.isSQLCompatible() ) {

            return false;

        }

        if( !this.hasSpatialFunctions() ) {

            if( StringUtils.equalsIgnoreCase(function.group(),Function.GROUP_OGC) ) {

                return false;

            }

        }

        return true;

    }

                            if( !supportCaller(caller) ) {

        fetchFeature(feature, rs.get(), rs.getColumns(), rs.getExtraValueNames());

    public void fetchFeature(FeatureProvider feature, ResultSet rs, FeatureAttributeDescriptor[] columns, String[] extraValueNames) throws DataException {

            int rsIndex = 1;

            for (FeatureAttributeDescriptor column : columns) {

                        value = this.getGeometryFromColumn(rs, rsIndex++);

                        value = rs.getObject(rsIndex++);

            if( ArrayUtils.isNotEmpty(extraValueNames) ) {

                feature.setExtraValueNames(extraValueNames);

                for (int index = 0; index < extraValueNames.length; index++) {

                    value = rs.getObject(rsIndex++);

                    if( value instanceof Blob ) {

                        Blob blob = (Blob)value;

                        value = blob.getBytes(0, (int) blob.length());

                        blob.free();

                    }

                    feature.setExtraValue(index, value);

                }

            }

    @Override

    public String[] replaceForeingValueFunction(SQLBuilder sqlbuilder, FeatureType type) {

        // See test SQLBuilderTest->testForeingValue()

        final ExpressionBuilder where = sqlbuilder.select().where();

        if( where == null || where.isEmpty() ) {

            return null;

        }

        final SQLBuilder.TableNameBuilder table = sqlbuilder.select().from().table();

        final ExpressionBuilder expbuilder = sqlbuilder.expression();

        final List<String> foreing_value_args = new ArrayList<>();

        final List<ExpressionBuilder.Value[]> value_replacements = new ArrayList<>();

        // Buscamos las llamadas a la funcion "foreing_value" y nos quedamos

        // el argumento de esta asi como por que tendriamos que sustituirla 

        // una vez hechos los left joins que toquen.

        where.accept(new ExpressionBuilder.Visitor() {

            @Override

            public void visit(ExpressionBuilder.Visitable value) {

                // Requiere que sea la funcion "FOREING_VALUE con un solo 

                // argumento que sea una constante de tipo string.

                if( !(value instanceof ExpressionBuilder.Function) ) {

                    return;

                }

                ExpressionBuilder.Function function = (ExpressionBuilder.Function) value;

                if( !StringUtils.equalsIgnoreCase(function.name(), "FOREING_VALUE") ) {

                    return;

                }

                if( function.parameters().size()!=1 ) {

                    return;

                } 

                ExpressionBuilder.Value arg = function.parameters().get(0);

                if( !(arg instanceof ExpressionBuilder.Constant) ) {

                    return;

                }

                Object arg_value = ((ExpressionBuilder.Constant) arg).value();

                if( !(arg_value instanceof CharSequence) ) {

                    return;

                }

                String foreing_value_arg = arg_value.toString();

                String[] foreingNameParts = StringUtils.split(foreing_value_arg, "[.]");

                if( foreingNameParts.length!=2 ) {

                    // De momento solo tratamos joins entre dos tablas.

                    return;

                }

                String columnNameLocal = foreingNameParts[0];

                String columnNameForeing = foreingNameParts[1];

                FeatureAttributeDescriptor attr = type.getAttributeDescriptor(columnNameLocal);

                if( !attr.isForeingKey() ) {

                    // Uhm... si el argumento no referencia a un campo que es

                    // clave ajena no lo procesamos. 

                    // ? Deberiamos lanzar un error ?

                    return;

                }

                // Nos guardaremos por que hay que reemplazar la funcion 

                // FOREING_VALUE, y su argumento para mas tarde.

                ForeingKey foreingKey = attr.getForeingKey();

                SQLBuilder.TableNameBuilder foreingTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .schema(table.getSchema()) 

                        .name(foreingKey.getTableName());

                // Reemplzaremos la funcion FOREING_VALUE, por el acceso al campo

                // que toca de la tabla a la que referencia la clave ajena.

                ExpressionBuilder.Variable function_replacement = sqlbuilder.column(foreingTable, columnNameForeing);

                value_replacements.add(

                    new ExpressionBuilder.Value[] {

                        function,

                        function_replacement

                    }

                );

                foreing_value_args.add(foreing_value_arg);

            }

        }, null);

        // Si no habia ningun llamada a la funcion FOREING_VALUE, no hay que

        // hacer nada.

        if( foreing_value_args.isEmpty() ) {

            return null;

        }

        // Calculamos que referencias de columnas hemos de cambiar para 

        // que no aparezcan ambiguedades al hacer el join (nombres de

        // columna de una y otra tabla que coincidan).

        // Para las columnas que puedan dar conflicto se prepara un reemplazo 

        // de estas que tenga el nombre de tabla.

        for (ExpressionBuilder.Variable variable : sqlbuilder.variables()) {

            if( variable instanceof SQLBuilderBase.ColumnBase ) {

                continue;

            }

            for (String foreingName : foreing_value_args) {

                String[] foreingNameParts = foreingName.split("[.]");

                if( foreingNameParts.length != 2) {

                    continue;

                }

                String columnNameLocal = foreingNameParts[0];

                String columnNameForeing = foreingNameParts[1];

                if( !StringUtils.equalsIgnoreCase(variable.name(), columnNameForeing) ) {

                    continue;

                }

                ExpressionBuilder.Variable variable_replacement = sqlbuilder.column(

                    table, 

                    variable.name()

                );

                value_replacements.add(

                    new ExpressionBuilder.Value[] {

                        variable,

                        variable_replacement

                    }

                );

            }

        }

        // Realizamos los reemplazos calculados previamente (value_replacements).

        for (ExpressionBuilder.Value[] replaceValue : value_replacements) {

            ExpressionBuilder.Value target = replaceValue[0];

            ExpressionBuilder.Value replacement = replaceValue[1];

            sqlbuilder.select().replace(target, replacement);    

        }

        // A?adimos a la SQL los "LEFT JOIN" que toca para poder acceder

        // a los valores referenciados por la funcion FOREING_VALUE.

        // Ademas a?adimos los valores referenciados por la funcion FOREING_VALUE

        // como columnas de la SQL para poder acceder a ellos si fuese necesario.

        for (String foreingName : foreing_value_args) {

            String[] foreingNameParts = foreingName.split("[.]");

            if( foreingNameParts.length != 2) {

                continue;

            }

            String columnNameLocal = foreingNameParts[0];

            String columnNameForeing = foreingNameParts[1];

            FeatureAttributeDescriptor attr = type.getAttributeDescriptor(columnNameLocal);

            if( attr.isForeingKey() ) {

                ForeingKey foreingKey = attr.getForeingKey();

                SQLBuilder.TableNameBuilder foreingTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .schema(table.getSchema()) 

                        .name(foreingKey.getTableName());

                SQLBuilder.TableNameBuilder mainTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .schema(table.getSchema()) 

                        .name(table.getName());

                sqlbuilder.select().from()

                    .left_join(

                        foreingTable,

                        expbuilder.eq(

                                sqlbuilder.column(mainTable, columnNameLocal),

                                sqlbuilder.column(foreingTable,foreingKey.getCodeName()) 

                        )

                    );

                sqlbuilder.select().column().name(foreingTable,columnNameForeing);

            }

        }

        return foreing_value_args.toArray(new String[foreing_value_args.size()]);

    }

            FeatureType featureType,

                featureType, table, columnName, baseFilter, workingArea, crs);

            FeatureType featureType,

        return new CountOperation(helper, featureType, table, baseFilter, filter);

            FeatureType featureType,

        return new TableIsEmptyOperation(helper, featureType, table, baseFilter, filter);

        }        

        String[] extraColumnNames = this.helper.replaceForeingValueFunction(sqlbuilder, storeType);

                sql, fetchSize, 

                columns.toArray(new FeatureAttributeDescriptor[columns.size()]),

                extraColumnNames

import org.gvsig.fmap.dal.feature.FeatureType;

    private final FeatureType featureType;

        this(helper, null, null, null, null);

            FeatureType featureType,

        this.featureType = featureType;

        return this.count(conn, featureType, table, baseFilter, filter);

            FeatureType featureType,

        this.helper.replaceForeingValueFunction(sqlbuilder, featureType);

            this.helper.fetchFeature(data, rs, columns.toArray(new FeatureAttributeDescriptor[columns.size()]), null); 

import org.gvsig.fmap.dal.feature.FeatureType;

    private final FeatureType featureType;

            FeatureType featureType,

        this.featureType = featureType;

            featureType,

            FeatureType featureType,

        this.helper.replaceForeingValueFunction(sqlbuilder, featureType);

import org.gvsig.fmap.dal.feature.FeatureType;

    private final FeatureType featureType;

        this(helper, null, null, null, null);

            FeatureType featureType,

        this.featureType = featureType;

        return this.tableIsEmpty(conn, featureType, table, baseFilter, filter);

            FeatureType featureType,

        this.helper.replaceForeingValueFunction(sqlbuilder, featureType);

    protected final TableReference table;

            try {

                JDBCStoreParameters params = getParameters();

                CountOperation count = getOperations().createCount(

                        getFeatureStore().getDefaultFeatureType(),

                        getOperations().createTableReference(params),

                        params.getBaseFilter(),

                        null

                );            

                this.value = (Long) count.perform();

            } catch (DataException ex) {

                throw new RuntimeException("Can't calculate count",ex);

            }

                        getFeatureStore().getDefaultFeatureType(),

        public String[] getExtraValueNames();

    public ResultSetEntry create(String sql, int fetchSize, FeatureAttributeDescriptor[] columns, String[] extraValueNames ) throws DataException;

    public ResultSetEntry create(String sql, List<Object> values, int fetchSize, FeatureAttributeDescriptor[] columns, String[] extraValueNames) throws DataException;

                    this.getFeatureType(),

                        this.getFeatureType(),

        private final String[] extraValueNames;

        public ResultSetEntryBase(ResultSet resulSet, String sql, FeatureAttributeDescriptor[] columns, String[] extraValueNames) {

            this.extraValueNames = extraValueNames;

        public String[] getExtraValueNames() {

            return this.extraValueNames;

        }

        @Override

            FeatureAttributeDescriptor[] columns,

            String[] extraValueNames) throws DataException {

        return create(sql, null, fetchSize, columns, extraValueNames);

            String sql, 

            List<Object> values, 

            int fetchSize, 

            FeatureAttributeDescriptor[] columns, 

            String[] extraValueNames) throws DataException {

            ResultSetEntryBase rsentry = new ResultSetEntryBase(rs, sql, columns,  extraValueNames);

import java.util.List;

import org.gvsig.fmap.dal.SQLBuilder;

            FeatureAttributeDescriptor[] columns,

            String[] extraValueNames

    public String[] replaceForeingValueFunction(SQLBuilder sqlbuilder, FeatureType type);

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

    private GeometryColumnInfo getGeometryColumnInfo(String name) {

        if( geometry_column==null ) {

            geometry_column = new HashMap<>();

            try {

                //

                // https://github.com/orbisgis/h2gis/wiki/1.-Spatial-data#geometry-columns-view

                //

                StringBuilder where = null;

                if( table.hasDatabase() ) {

                    if( where == null ) {

                        where = new StringBuilder();

                    } else {

                        where.append(" AND ");

                    }

                    where.append("UPPER(F_TABLE_CATALOG) = '");

                    where.append(table.getDatabase().toUpperCase());

                    where.append("'");

                if( table.hasSchema()) {

                    if( where == null ) {

                        where = new StringBuilder();

                    } else {

                        where.append(" AND ");

                    }

                    where.append("UPPER(F_TABLE_SCHEMA) = '");

                    where.append(table.getSchema().toUpperCase());

                    where.append("'");

                if( table.hasTable()) {