Application: gvSIG desktop

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

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

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.evaluator.Evaluator;

        if (this.query != null && (query.hasGroupByColumns() || query.hasAggregateFunctions())) {

            subselect.column().value(subsqlbuilder.count().all());

            for (FeatureAttributeDescriptor attr : this.featureType) {

                if (attr.isComputed()) {

                    if (extraColumnNames != null && !extraColumnNames.contains(attr.getName())) {

                        extraColumnNames.add(attr.getName());

                    }

                    if (attr.getRelationType() == DynField.RELATION_TYPE_NONE) {

                        FeatureAttributeEmulator attrEmulator = attr.getFeatureAttributeEmulator();

                        if (attrEmulator instanceof FeatureAttributeEmulatorExpression) {

                            FeatureAttributeEmulatorExpression x = (FeatureAttributeEmulatorExpression) attrEmulator;

                            Expression exp = x.getExpression();

//                            if (query != null && (query.hasGroupByColumns() || query.hasAggregateFunctions())) {

                                String aggregate = query.getAggregate(this.table.getTable(), attr.getName());

                                if (this.query.isAGroupByColumn(attr.getName())) {

                                    if (!subselect.has_column(attr.getName())) {

                                        subselect.column().value(exp.getCode().toValue()).as(attr.getName());

                                    }

                                } else if (aggregate == null) {

                                    subselect.column().value(expbuilder.constant(null)).as(attr.getName());

                                } else {

                                    String fn = this.query.getAggregateFunctions().get(attr.getName());

                                    ExpressionBuilder.Function aggregateExp = expbuilder.function(fn, exp.getCode().toValue());

                                    if (!subselect.has_column(attr.getName())) {

                                        subselect.column().value(aggregateExp).as(attr.getName());

                                    }

                                }

//                            } else {

//                                if (exp != null && !exp.isEmpty() && this.helper.supportExpression(this.featureType, exp.getPhrase())) {

//                                    Code code = exp.getCode();

//                                    subselect.column()

//                                            .value(code.toValue(expbuilder))

//                                            .as(attr.getName());

//                                

//                                }

//

//                            }

                        }

                    }

                }

            if (this.query != null) {

                FeatureExtraColumns extraColumns = this.query.getExtraColumn();

                if (extraColumns != null && !extraColumns.isEmpty()) {

                    for (EditableFeatureAttributeDescriptor attr : extraColumns.getColumns()) {

                        if (!attr.isComputed()) {

                            continue;

                        }

                        if (extraColumnNames != null && !extraColumnNames.contains(attr.getName())) {

                            extraColumnNames.add(attr.getName());

                        }

                    }

                }

            }

            if (this.query.hasGroupByColumns() || query.hasAggregateFunctions()) {

                subselect.from().table()

                        .database(this.table.getDatabase())

                        .schema(this.table.getSchema())

                        .name(this.table.getTable());

                subselect.from().subquery(this.table.getSubquery());

                Evaluator filter = query == null ? null : query.getFilter();

                if (filter != null) {

                    String sqlfilter = filter.getSQL();

                    if (!StringUtils.isEmpty(sqlfilter)) {

                        if (this.helper.supportFilter(this.featureType, filter)) {

                            subselect.where().set(expbuilder.toValue(sqlfilter));

                        }

                    }

                }

                if (!StringUtils.isEmpty(baseFilter)) {

                    subselect.where().and(expbuilder.toValue(baseFilter));

                }

                List<String> groupbyColumns = query == null ? null : query.getGroupByColumns();

                if (groupbyColumns != null && !groupbyColumns.isEmpty()) {

                    for (String columnName : groupbyColumns) {

                        if (this.featureType.getAttributeDescriptor(columnName) != null) {

                            subselect.group_by(expbuilder.column(columnName));

                        } else if(this.featureType.getExtraColumns().get(columnName)!=null) {

                            ExpressionBuilder.Variable col = expbuilder.column(columnName);

                            subselect.group_by(col);

                            EditableFeatureAttributeDescriptor attr = this.featureType.getExtraColumns().get(columnName); // TODO no deberia?

                            Expression exp = ((FeatureAttributeEmulatorExpression) attr.getFeatureAttributeEmulator()).getExpression();

                            subselect.column().value(exp.getCode().toValue()).as(columnName);

                        } else {

                            try {

                                try {

                                    Code groupByColumnCode = ExpressionUtils.compile(columnName);

    //                                if (groupByColumnCode.code() == Code.CALLABLE) {

    //                                    Code.Callable callable = (Code.Callable) groupByColumnCode;

    //                                    if (callable.name().equalsIgnoreCase(FUNCTION_LET)) {

    //                                        Code exp = callable.parameters().get(1);

    //                                        Code name = callable.parameters().get(0);

    //                                        subselect.column().value(exp.toValue())

    //                                                .as((String) ((Code.Constant) name).value());

    //                                        // nombre que se pone en la parte del groupby debe de ser el nombre de la var del set

    //                                        groupByColumnCode = exp; 

    //                                    }

    //                                }

                                    subselect.group_by(groupByColumnCode.toValue());

                                } catch (Exception ex) {

                                    throw new RuntimeException("Not able to create column by expression in groupby query", ex);

                                }

                            } catch (Exception ex) {

                                throw new RuntimeException("Not able to create column by expression in groupby query", ex);

                            }

                        }

                    }

                }

                subsqlbuilder.setProperties(

                        ExpressionBuilder.Variable.class,

                        PROP_FEATURE_TYPE, this.featureType,

                        PROP_TABLE, table,

                        PROP_SYMBOLTABLE, this.query == null ? null : this.query.getSymbolTable(),

                        PROP_JDBCHELPER, this.helper,

                        PROP_QUERY, this.query

                );

                for (ExpressionBuilder.Value value : valuesToRemoveFeatureType) {

                    value.setProperty(PROP_FEATURE_TYPE, null);

                }

                this.helper.expandCalculedColumns(subsqlbuilder);

                this.helper.processSpecialFunctions(subsqlbuilder, featureType, extraColumnNames);

                String subsql = subselect.toString();

                select.from().table()

                        .database(this.table.getDatabase())

                        .schema(this.table.getSchema())

                        .name(this.table.getTable());

                select.from().subquery(subsql);

        } else {

            select.column().value(sqlbuilder.count().all());

            select.from().subquery(this.table.getSubquery());

            if (this.query != null) {

                if (this.query.getFilter() != null && !StringUtils.isBlank(this.query.getFilter().getSQL())) {

                    // El and() hace un set() si no hay un filtro previo

                    select.where().and(expbuilder.toValue(this.query.getFilter().getSQL()));

                }

            }

//        sqlbuilder.setProperties(

//                ExpressionBuilder.Variable.class,

//                PROP_TABLE, table

//        );