Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.expressionevaluator.impl.function.dataaccess;

import java.util.Iterator;

import java.util.List;

import java.util.function.Function;

import java.util.function.Predicate;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_LET;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.impl.DALFunctions;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_SELECT;

import org.gvsig.fmap.dal.SQLBuilder;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_FEATURE_TYPE;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_SQLBUILDER;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_TABLE;

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureQueryOrder;

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

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureExpressionEvaluator;

import org.gvsig.timesupport.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.util.FilteredIterator;

import org.gvsig.tools.util.LimitIterator;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SelectFunction

        extends AbstractSelectFunction

        implements Optimizer.FunctionOptimizer {

    public static final int MODE_FROM_STORE = 0;

    public static final int MODE_FROM_SELECTION = 1;

    public static final int MODE_FROM_SELECTION_IF_NOT_EMPTY = 2;

    public static final String PROP_FEATURETYPESUPPLIER = "FEATURETYPESUPPLIER";

    private static final int COLUMNS = 0;

    private static final int TABLE = 1;

    private static final int WHERE = 2;

    private static final int ORDER = 3;

    private static final int ORDER_MODE = 4;

    private static final int LIMIT = 5;

    private static final int INTOVAR = 6;

    private static final int MODE_FROM = 7;

    public SelectFunction() {

        super(DALFunctions.GROUP_DATA_ACCESS,

                FUNCTION_SELECT,

                Range.between(6,8),

                "Returns a list of features of the table by applying the filter, order and limit indicated.\n"

                + "The syntax is:\n\n"

                + "SELECT * FROM table WHERE boolean_expression ORDER BY order_column LIMIT limit;\n\n"

                + "Indicate a filter expression with WHERE, an order or LIMIT is optional.\n"

                + "You can use an asterisk or enter the column names you want to retrieve separated by commas.\n"

                + "The SELECT statement must always end with a semicolon.",

                "SELECT * FROM table WHERE boolean_expression ORDER BY order_column LIMIT limit;",

                new String[]{

                    "column_names/asterisk - Names of the columns table to retrieve.",

                    "table_name - Name of the table",

                    "filter - boolean expression to apply as filter",

                    "order_column - the order used to retrieve the features. It is a list of column names separated by a comma. The column name can optionally be followed by ASC or DESC to indicate whether the order should be ascending or descending.",

                    "limit - Maximum number of features to return"

                },

                "List",

                true

        );

    }

    @Override

    public boolean isHidden() {

        return false;

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    @Override

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

        throw new UnsupportedOperationException();

    }

    protected Callable getColumnsCode(Codes args) {

        Code code = args.get(COLUMNS);

        if( code == null ) {

            return null;

        }

        CodeBuilder builder;

        Callable callable;

        switch (code.code()) {

            case Code.CONSTANT:

                if (((Code.Constant) code).value() != null) {

                    throw new ExpressionRuntimeException("Null expected in argument COLUMNS of function '" + this.name() + "'.");

                }

                return null;

            case Code.IDENTIFIER:

                builder = ExpressionUtils.createCodeBuilder();

                return builder.block(code);

            case Code.CALLABLE:

                callable = (Callable) code;

                if( callable.parameters().isEmpty() ) {

                    return null;

                }

                if (StringUtils.equalsIgnoreCase(callable.name(), "BLOCK")) {

                    return callable;

                }

                if (StringUtils.equalsIgnoreCase(callable.name(), "TUPLE")) {

                    return callable;

                }

                if (StringUtils.equalsIgnoreCase(callable.name(), "GETATTR")) {

                    builder = ExpressionUtils.createCodeBuilder();

                    return builder.block(code);

                }

                throw new ExpressionRuntimeException("BLOCK, TUPLE expected in argument COLUMNS of function '" + this.name() + "'.");

            default:

                throw new ExpressionRuntimeException("BLOCK or NULL expected in argument COLUMNS of function '" + this.name() + "'.");

        }

    }

    @Override

    public Object call(Interpreter interpreter, Codes args) throws Exception {

        String storeName = this.getIdentifier(args, TABLE);

        Callable columns = getColumnsCode(args);

        Code where = this.getWhereCode(args, WHERE);

        Number limit = (Number) getObject(interpreter, args, LIMIT);

        int mode_from = MODE_FROM_STORE;

        if( args.size() > MODE_FROM ) {

            mode_from = this.getInt(interpreter, args, MODE_FROM);

        }

        Callable order = getTupleOrNull(args, ORDER);

        Callable order_mode = getTupleOrNull(args, ORDER_MODE);

        FeatureQueryOrder queryOrder = null;

        FeatureStore featureStore;

        try {

            featureStore = this.getFeatureStore(storeName);

            if (featureStore == null) {

                throw new ExpressionRuntimeException("Cant locate the feature store '" + storeName + "' in function '" + this.name() + "'.");

            }

            if (order != null || order_mode != null) {

                for (int n = 0; n < order.parameters().size(); n++) {

                    if (queryOrder == null) {

                        queryOrder = new DefaultFeatureQueryOrder();

                    }

                    Boolean mode = (Boolean) ((Code.Constant)order_mode.parameters().get(n)).value();

                    Code memberCode = order.parameters().get(n);

                    if(memberCode.code() == Code.IDENTIFIER) {

                        queryOrder.add(((Code.Identifier)memberCode).name(), mode);

                    } else {

                        Code memberCode2 = replaceLocalVariables(interpreter, memberCode, featureStore.getDefaultFeatureTypeQuietly());

                        Expression exp = ExpressionUtils.createExpression(memberCode2.toString());

                        queryOrder.add(exp, mode);

                    }

                }

            }

            String intovar = null;

            if( args.size()>INTOVAR ) {

                intovar = this.getIdentifier(args, INTOVAR);

            }

            FeatureQuery query = featureStore.createFeatureQuery();

            if (where != null) {

                Code where2 = removeOuterTablesReferences(interpreter, where, featureStore.getDefaultFeatureTypeQuietly());

                ExpressionEvaluator filter = new DefaultFeatureExpressionEvaluator(where2.toString());

                filter.toSymbolTable().addSymbolTable(interpreter.getSymbolTable());

                query.addFilter(filter);

            }

            if (queryOrder != null) {

                query.getOrder().copyFrom(queryOrder);

            }

            if (limit != null) {

                query.setLimit(limit.longValue());

            }

            if( columns!=null ) {

                for (Code column : columns.parameters()) {

                    if( column instanceof Code.Identifier ) {

                        query.addAttributeName( ((Code.Identifier)column).name());

                    } else {

                        // TODO: Aqui habria que a?adir una columna calculada.

                        String name = "nose";

                        Code exp;

                        if( column instanceof Code.Callable && 

                                StringUtils.equals(((Code.Callable)column).name(),FUNCTION_LET) ) {

                            name = ((Code.Identifier)((Code.Callable)column).parameters().get(0)).name();

                            exp = ((Code.Callable)column).parameters().get(1);

                        } else {

                            exp = column;

                        }

                        EditableFeatureAttributeDescriptor fad = query.getExtraColumns().add(name, DataTypes.STRING);

                        fad.setFeatureAttributeEmulator(ExpressionUtils.createExpression(exp.toString()));

                    }

                }

            }

            switch(mode_from) {

                case MODE_FROM_SELECTION:

                    return select_from_selection(interpreter, featureStore, query, intovar);

                case MODE_FROM_SELECTION_IF_NOT_EMPTY:

                    return select_from_selection_if_not_empty(interpreter, featureStore, query, intovar);

                case MODE_FROM_STORE:

                default:

                    return select_from_store(interpreter, featureStore, query, intovar);

            }

        } catch (ExpressionRuntimeException ex) {

            throw ex;

        } catch (Exception ex) {

            throw new ExpressionRuntimeException("Problems calling '" + this.name() + "' function", ex);

        }

    }

    private Object select_from_selection(Interpreter interpreter, FeatureStore store, FeatureQuery query, String intovar) {

        try {

            if( store.isFeatureSelectionEmpty() ) {

                return null;

            }

            Iterable features = store.getFeatureSelection();

            if ( query.hasFilter() ) {

                final Iterable baseSelection = features;

                final ExpressionEvaluator evaluator = new DefaultFeatureExpressionEvaluator(

                        query.getExpressionFilter().toString()

                );

                evaluator.toSymbolTable().addSymbolTable(interpreter.getSymbolTable());

                final Predicate filter = (Predicate) (Object t) -> {

                    try {

                        return (boolean) evaluator.evaluate((EvaluatorData) t);

                    } catch (EvaluatorException ex1) {

                        throw new ExpressionRuntimeException("Can't evaluate expression for row.", ex1);

                    }

                };

                features = (Iterable) () -> new FilteredIterator(baseSelection.iterator(), filter);

            }

            if( query.hasLimit() ) {

                final Iterable baseSelection = features;

                features = (Iterable) () -> new LimitIterator(baseSelection.iterator(), query.getLimit());

            }

            if( intovar!=null ) {

                Feature f = null;

                Iterator<Feature> it = features.iterator();

                if( it.hasNext() ) {

                    f = it.next();

                }

                DisposeUtils.dispose(it);

                DisposeUtils.dispose(features);

                ((MutableSymbolTable)(interpreter.getSymbolTable())).setVar(intovar, f);

                return f;

            }

            return features;

        } catch (ExpressionRuntimeException ex) {

            throw ex;

        } catch (Exception ex) {

            throw new ExpressionRuntimeException("Problems calling '" + this.name() + "' function", ex);

        }

    }

    private Object select_from_store(Interpreter interpreter, FeatureStore store, FeatureQuery query, String intovar) throws Exception {

        // FIXME: add columns to query.addAttributeName() 

        query.retrievesAllAttributes();

        if( intovar!=null ) {

            Feature f = store.findFirst(query);

            ((MutableSymbolTable)(interpreter.getSymbolTable())).setVar(intovar, f);

            return f;

        }

        List<Feature> features = store.getFeatures(query);

        return features;

    }

    private Object select_from_selection_if_not_empty(Interpreter interpreter, FeatureStore store, FeatureQuery query, String intovar) throws Exception {

        if( store.isFeatureSelectionEmpty() ) {

          return select_from_store(interpreter, store, query, intovar);

        } 

        return select_from_selection(interpreter, store, query, intovar);

    }

    @Override

    public Code optimize(Optimizer optimizer, Callable caller) {

        return caller; // Don't optimize SELECT

    }

    public ExpressionBuilder.Value toValue(ExpressionBuilder builder, Codes args) {

        try {

            SQLBuilder sqlBuilder = (SQLBuilder) builder.getProperty(PROP_SQLBUILDER);

            if (sqlBuilder == null) {

                return super.toValue(builder, args);

            }

            Function<String, FeatureType> featureTypeSupplier = (Function<String, FeatureType>) builder.getProperty(PROP_FEATURETYPESUPPLIER);

            if (featureTypeSupplier == null) {

                featureTypeSupplier = (String tableName) -> {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureType featureType = dataManager.getStoresRepository().getFeatureType(tableName);

                    return featureType;

                };

            }

            FeatureType featureType = null;

            SQLBuilder.SelectBuilder select = sqlBuilder.createSelectBuilder();

            String builderTableName = (String) builder.getProperty(SQLBuilder.PROP_TABLENAME);

            Code tableCode = args.get(TABLE);

            Callable columns = getColumnsCode(args);

            Code where = this.getWhereCode(args, WHERE);

            Callable order = getTupleOrNull(args, ORDER);

            Callable order_mode = getTupleOrNull(args, ORDER_MODE);

            Code limit = args.get(LIMIT);

            int mode_from = MODE_FROM_STORE;

            if( args.size() > MODE_FROM ) {

                Code codeModeFrom = args.get(MODE_FROM);

                mode_from = (Integer)((Code.Constant)codeModeFrom).value();

            }

            String intovar = null;

            if( args.size()>INTOVAR && args.get(INTOVAR)!=null ) {

                intovar = this.getIdentifier(args, INTOVAR);

            }

            if (tableCode != null) {

                String tableName = null;

                String tableNameHE = null;

                if( isHostExpression(tableCode) ) {

                    tableNameHE = tableCode.toString();

                } else {

                    tableName = this.getIdentifier(args, TABLE);

                }

                switch (mode_from) {

                    case MODE_FROM_SELECTION: {

                            SQLBuilder.FromBuilder from = select.from();

                            if( tableNameHE == null ) {

                                select.from().custom("SELECTION OF " + from.table().name(tableName).toString());    

                            } else {

                                select.from().custom("SELECTION OF " + tableNameHE);    

                            }

                        }

                        break;

                    case MODE_FROM_SELECTION_IF_NOT_EMPTY: {

                            SQLBuilder.FromBuilder from = select.from();

                            if( tableNameHE == null ) {

                                select.from().custom("SELECTION IF NOT EMPTY OF " + from.table().name(tableName).toString());    

                            } else {

                                select.from().custom("SELECTION IF NOT EMPTY OF " + tableNameHE);    

                            }

                        }

                        break;

                    case MODE_FROM_STORE:

                        if( tableNameHE == null ) {

                            select.from().table().name(tableName);

                        } else {

                            select.from().custom(tableNameHE);    

                        }

                        break;

                }

            }

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

            String tableName = table.getName();

            if (columns == null || columns.parameters().isEmpty()){

                if( intovar==null ) {

                    select.column().all();

                } else {

                    select.column().value(builder.custom("* INTO "+intovar));

                }

            } else {

                for (Code column : columns.parameters()) {

                    if( column == null ) {

                        select.column().value(builder.constant(null));

                    } else if (column instanceof Code.Identifier) {

                        String columnName = ((Code.Identifier) column).name();

                        if(featureType == null) {

                            if(StringUtils.equalsIgnoreCase(builderTableName, tableName)){

                                featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);

                            } else {

                                featureType = featureTypeSupplier.apply(tableName);

                            }

                        }

                        if(featureType == null){

                            select.column().name(select.from().table(),columnName);

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

                            select.column().name(select.from().table(),columnName);

                        } else {

                            select.column().name(columnName).table(null);

                        }

                    } else {

                        select.column().value(column.toValue(builder));

                    }

                }

            }

            if (where != null) {

                ExpressionBuilder.Value value = where.toValue(builder);

                select.where().value(value);

                sqlBuilder.setProperties(value, null, SQLBuilder.PROP_ADD_TABLE_NAME_TO_COLUMNS, true);

            }

            if (limit != null) {

                Object value = ((Code.Constant) limit).value();

                if(value != null){

                    select.limit(((Number) value).longValue());

                }

            }

            if (order != null || order_mode != null) {

                for (int n = 0; n < order.parameters().size(); n++) {

                    Code member = order.parameters().get(n);

                    Code.Constant mode = (Code.Constant) order_mode.parameters().get(n);

                    select.order_by().value(member.toValue(builder)).ascending((boolean) mode.value());

                }

            }

            if (featureType == null) {

                if (StringUtils.equalsIgnoreCase(builderTableName, tableName)) {

                    featureType = (FeatureType) builder.getProperty(SQLBuilder.PROP_FEATURE_TYPE);

                } else {

                    featureType = featureTypeSupplier.apply(tableName);

                }

            }

            sqlBuilder.setProperties(

                    select,

                    null,

                    PROP_FEATURE_TYPE, featureType,

                    PROP_TABLE, table

            );

            return builder.group(select);

        } catch (Exception ex) {

            return super.toValue(builder, args);

        }

    }

    @Override

    public String toString(Codes args, Formatter<Code> formatter) {

        SQLBuilderBase sqlbuilder = new SQLBuilderBase();

        ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        ExpressionBuilder expressionBuilder = expressionManager.createExpressionBuilder();

        expressionBuilder.setProperty(PROP_SQLBUILDER, sqlbuilder);

        expressionBuilder.setProperty(PROP_FEATURETYPESUPPLIER, new Function<String, FeatureType>() {

            @Override

            public FeatureType apply(String t) {

                return null;

            }

        });

        ExpressionBuilder.Value values = this.toValue(expressionBuilder, args);

        return values.toString();

    }

}