Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

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

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

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import static org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable.SYMBOL_CURRENT_TABLE;

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

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

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractSelectFunction extends AbstractFunction {

    protected AbstractSelectFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType, boolean sqlCompatible) {

        super(group, name, argc, description, template, descriptionArgs, returnType, sqlCompatible);

    }

    protected AbstractSelectFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType) {

        super(group, name, argc, description, template, descriptionArgs, returnType);

    }

    protected String getIdentifier(Codes args, int argn) {

        Code storeName_code = (Code) args.get(argn);

        if (storeName_code instanceof Code.Identifier) {

            return ((Code.Identifier) storeName_code).name();

        } else if (storeName_code instanceof Code.Constant) {

            Code.Constant storeName_const = (Code.Constant) storeName_code;

            if (storeName_const.value() instanceof CharSequence) {

                return storeName_const.value().toString();

            }

        }

        throw new ExpressionRuntimeException("Invalid table name (" + Objects.toString(storeName_code) + ") in function '" + this.name() + "'.");

    }

    protected Code getWhereCode(Codes args, int argn) {

        Code where = args.get(argn);

        if (where.code() == Code.CONSTANT) {

            if (((Code.Constant) where).value() == null) {

                where = null;

            }

        }

        return where;

    }

    protected Callable getTupleOrNull(Codes args, int argn) {

        Code code = args.get(argn);

        if (code.code() == Code.CONSTANT) {

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

                throw new ExpressionRuntimeException("Tupple or null expected in argument " + argn + " of function '" + this.name() + "'.");

            }

            return null;

        }

        if (code.code() != Code.CALLABLE) {

            throw new ExpressionRuntimeException("Tupple or null expected in argument " + argn + " of function '" + this.name() + "'.");

        }

        Callable caller = (Callable) code;

        if (!StringUtils.equalsIgnoreCase(FUNCTION_TUPLE, caller.name())) {

            throw new ExpressionRuntimeException("Tupple or null expected in argument " + argn + " of function '" + this.name() + "'.");

        }

        return caller;

    }

    protected Code removeOuterTablesReferences(Interpreter interpreter, Code where) {

        try {

            SymbolTable symbolTable = interpreter.getSymbolTable();

            TableAttributeHandler table = (TableAttributeHandler) symbolTable.value(SYMBOL_CURRENT_TABLE);

            List<Pair<Code, Code>> replaces = new ArrayList<>();

            CodeBuilder codeBuilder = ExpressionUtils.createCodeBuilder();

            final Set<Code> replacesToASkip = new HashSet<>();

            Code where2 = where.clone();

            where2.accept((Object o) -> {

                if (o == null) {

                    return;

                }

                Code code = (Code) o;

                switch (code.code()) {

                    case Code.CALLABLE:

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

                        if (StringUtils.equalsIgnoreCase(caller.name(), FUNCTION_GETATTR)) {

                            Codes args = caller.parameters();

                            Code arg0 = args.get(0);

                            Code arg1 = args.get(1);

                            replacesToASkip.add(arg1);

                            if (arg0 instanceof Code.Identifier && arg1 instanceof Code.Constant) {

                                Object tt = symbolTable.value(((Code.Identifier) arg0).name());

                                if (tt instanceof TableAttributeHandler

                                        && StringUtils.equalsIgnoreCase(((TableAttributeHandler) tt).getName(), table.getName())) {

                                    String columnName = Objects.toString(((Code.Constant) arg1).value(), null);

                                    if (columnName != null) {

                                        Object value = table.get(columnName);

                                        replaces.add(

                                                new ImmutablePair<>(

                                                        caller,

                                                        codeBuilder.constant(value)

                                                )

                                        );

                                    }

                                }

                            }

                        }

                        break;

                }

            });

            where2.accept((Object o) -> {

                if (o == null) {

                    return;

                }

                Code code = (Code) o;

                if (replacesToASkip.contains(code)) {

                    return;

                }

                switch (code.code()) {

                    case Code.IDENTIFIER:

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

                        if (symbolTable.exists(id.name())) {

                            Object value = symbolTable.value(id.name());

                            replaces.add(

                                    new ImmutablePair<>(

                                            id,

                                            codeBuilder.constant(value)

                                    )

                            );

                        }

                        break;

                }

            });

            if (replaces.isEmpty()) {

                return where;

            }

            for (Pair<Code, Code> replace : replaces) {

                if (replace != null) {

                    where2.replace(replace.getLeft(), replace.getRight());

                }

            }

            return where2;

        } catch (Exception ex) {

            throw new ExpressionRuntimeException("Can't remove references to outer tables.", ex);

        }

    }

    protected DataStore getStore(String storeName) {

        DataManager dataManager = DALLocator.getDataManager();

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

        return store;

    }

    protected FeatureStore getFeatureStore(String storeName) {

        DataManager dataManager = DALLocator.getDataManager();

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

        if (store instanceof FeatureStore) {

            return (FeatureStore) store;

        }

        return null;

    }

}