Application: gvSIG desktop

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

    }