Application: gvSIG desktop

    private JDBCConnectionParameters connectionParameters;

    protected OperationsFactory operationsFactory = null;

    protected SRSSolver srssolver;

    public JDBCHelperBase(JDBCConnectionParameters connectionParameters) {

        this.connectionParameters = connectionParameters;

        // If a particular treatment is required to convert SRS to the 

        // BBDD format, overwrite JDBCSRSsBase and use it instead of JDBCSRSsDumb.

        this.srssolver = new SRSSolverDumb(this);

            ResourceConsumer helperClient,

            JDBCConnectionParameters connectionParameters,

            JDBCStoreProvider store

        this.store = store;

        this.helperClient = helperClient;

        this.connectionParameters = connectionParameters;

    }

    protected String getResourceType() {

        return JDBCResource.NAME;

    }

    public String getProviderName() {

        return JDBCLibrary.NAME;

    }

    @Override

    public GeometrySupportType getGeometrySupportType() {

        // El proveedor generico de JDBC guadara las geoemtrias como WKT

    public boolean allowNestedOperations() {

        return false;

    }

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype) {

        // Como va a guardar las geometrias en WKT, puede escribirlas todas.

        // Asumimos que la BBDD soporta OFFSET

        return true;

    }

    @Override

    public String getQuoteForStrings() {

        return QUOTE_FOR_USE_IN_STRINGS;

    }

    protected boolean supportCaller(Code.Caller caller) {

            return true;

        }

        Function function = caller.function();

            return false;

        }

            return false;

        }

                return false;

            }

        }

        return true;

    }

    @Override

    public boolean supportFilter(final FeatureType type, Evaluator filter) {

        // No podemos filtrar cuando:

        // Un proveedor especifico podria sobreescribir el metodo,

        // para hilar mas fino al comprobar si soporta el filtro o no.

        //

        if (this.useSubquery()) {

            // Se esta usando una subquery en los parametros de acceso a la

            // BBDD, asi que no podemos filtrar.

                @Override

                public void visit(Object code_obj) throws VisitCanceledException, BaseException {

                    Code code = (Code) code_obj;

                        case Code.CALLER:

                            Code.Caller caller = (Code.Caller) code;

                                isCompatible.setValue(false);

                                throw new VisitCanceledException();

                            }

                            break;

                        case Code.IDENTIFIER:

                            Code.Identifier identifier = (Code.Identifier) code;

                                FeatureAttributeDescriptor attrdesc = type.getAttributeDescriptor(identifier.name());

                                        isCompatible.setValue(false);

                                        throw new VisitCanceledException();

                                    }

        } catch (Exception ex) {

            LOGGER.warn("Can't calculate if is SQL compatible.", ex);

        }

        return isCompatible.booleanValue();

    }

    @Override

    public boolean supportOrder(FeatureType type, FeatureQueryOrder order) {

        if (this.useSubquery()) {

        if (order == null) {

            return true;

        }

            if (member.hasEvaluator()) {

                    return false;

                }

        }

        return true;

    }

    @Override

    public OperationsFactory getOperations() {

            this.operationsFactory = new OperationsFactoryBase(this);

        }

        return operationsFactory;

    }

    protected void initializeResource(JDBCConnectionParameters params) {

//        Object[] resourceParams = new Object[]{

//            params.getUrl(),

    public String getSourceId() {

        return this.store.getSourceId();

    }

    @Override

    public JDBCResource getResource() {

        return null;

    @Override

    public void closeConnection(Connection connection) {

            try {

                connection.close();

                LOGGER.warn("Can't close connection.", ex);

            }

    }

    @Override

    public void closeConnectionQuietly(Connection connection) {

            try {

                connection.close();

                LOGGER.warn("Can't close connection.", ex);

            }

    }

    @Override

    protected void doDispose() throws BaseException {

        JDBCUtils.closeQuietly(this);

                        break;

                    default:

                        value = rs.getObject(rsIndex++);

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

                            blob.free();

                        }

                }

                feature.set(column.getIndex(), value);

            }

                feature.setExtraValueNames(extraValueNames);

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

                    value = rs.getObject(rsIndex++);

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

                        blob.free();

                    }

    public FeatureProvider createFeature(FeatureType featureType) throws DataException {

        return this.store.getStoreServices().createDefaultFeatureProvider(featureType);

    }

    @Override

    public boolean useSubquery() {

            return false;

        }

        return !StringUtils.isEmpty(this.store.getParameters().getSQL());

    @Override

    public SRSSolver getSRSSolver() {

        return this.srssolver;

    }

    @Override

    public JDBCStoreProvider createProvider(

            DataStoreProviderServices providerServices

        JDBCStoreProviderBase theStore = new JDBCStoreProviderBase(

                DBHelper.newMetadataContainer(JDBCLibrary.NAME),

                this

        );

    @Override

    public JDBCServerExplorer createServerExplorer(

            DataServerExplorerProviderServices providerServices

        JDBCServerExplorer explorer = new JDBCServerExplorerBase(

                this

        );

        this.initialize(explorer, parameters, null);

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

    }

    @Override

    public boolean isThreadSafe() {

        return true;

    }

    @Override

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

        // See test SQLBuilderTest->testForeingValue()

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

            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<>();

            public void visit(ExpressionBuilder.Visitable value) {

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

                // argumento que sea una constante de tipo string.

                    return;

                }

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

                    return;

                }

                    return;

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

                    return;

                }

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

                    return;

                }

                String foreing_value_arg = arg_value.toString();

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

                    // De momento solo tratamos joins entre dos tablas.

                    return;

                }

                String columnNameLocal = foreingNameParts[0];

                String columnNameForeing = foreingNameParts[1];

                FeatureAttributeDescriptor attr = type.getAttributeDescriptor(columnNameLocal);

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

                    // clave ajena no lo procesamos. 

                    // ? Deberiamos lanzar un error ?

                ForeingKey foreingKey = attr.getForeingKey();

                SQLBuilder.TableNameBuilder foreingTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .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(

                );

                foreing_value_args.add(foreing_value_arg);

            }

        }, null);

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

        // hacer nada.

            return null;

        }

        // 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()) {

                continue;

            }

            for (String foreingName : foreing_value_args) {

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

                    continue;

                }

                String columnNameLocal = foreingNameParts[0];

                String columnNameForeing = foreingNameParts[1];

                }

            }

        }

        // Realizamos los reemplazos calculados previamente (value_replacements).

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

            ExpressionBuilder.Value target = replaceValue[0];

            ExpressionBuilder.Value replacement = replaceValue[1];

        }

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

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

        for (String foreingName : foreing_value_args) {

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

                continue;

            }

            String columnNameLocal = foreingNameParts[0];

            String columnNameForeing = foreingNameParts[1];

            FeatureAttributeDescriptor attr = type.getAttributeDescriptor(columnNameLocal);

                ForeingKey foreingKey = attr.getForeingKey();

                SQLBuilder.TableNameBuilder foreingTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .name(foreingKey.getTableName());

                SQLBuilder.TableNameBuilder mainTable = sqlbuilder.createTableNameBuilder()

                        .database(table.getDatabase())

                        .name(table.getName());

                sqlbuilder.select().from()

            }

        }