Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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.fmap.dal.feature.impl;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.json.JsonObject;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.builder.ToStringBuilder;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableCodes;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

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.FeatureExtraColumns;

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.impl.expressionevaluator.DefaultFeatureExpressionEvaluator;

import org.gvsig.json.Json;

import org.gvsig.json.JsonArrayBuilder;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.json.SupportJson;

import org.gvsig.json.SupportToJson;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.AndEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.packageutils.Version;

import org.gvsig.tools.packageutils.impl.DefaultVersion;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Defines the properties of a collection of Features, as a result of a query

 * through a FeatureStore.

 *

 * A FeatureQuery is always defined by a FeatureType, or by the list of

 * attribute names of the FeatureStore to return.

 *

 * The filter allows to select Features whose properties have values with the

 * characteristics defined by the filter.

 *

 * The order is used to set the order of the result FeatureCollection, based on

 * the values of the properties of the Features.

 *

 * The scale parameter can be used by the FeatureStore as a hint about the

 * quality or resolution of the data needed to view or operate with the data

 * returned. As an example, the FeatureStore may use the scale to return only a

 * representative subset of the data, or maybe to return Features with less

 * detail, like a point or a line instead of a polygon.

 *

 * If an implementation of FeatureStore is able to get other parameters to

 * customize the behavior of the getDataCollection methods, there is an option

 * to set more parameters through the setAttribute method.

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureQuery implements FeatureQuery {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultFeatureQuery.class);

    public static final String SCALE_PARAM_NAME = "Scale";

    private static final Version VERSION_2_6_0 = ToolsLocator.getPackageManager().createVersion("2.6.0");

    private static final Version VERSION_2_6_0_1 = ToolsLocator.getPackageManager().createVersion("2.6.0-1");

    private Map<String,Object> queryParameters = new HashMap();

    private String featureTypeId = null;

    private List<String> attributeNames = new ArrayList();

    private List<String> constantsAttributeNames = new ArrayList();

    private Evaluator filter;

    private FeatureQueryOrder order = new DefaultFeatureQueryOrder();

    private long limit;

    private long pageSize;

    private List<String> groupByColumns;

    private Map<String,String> aggregateFunctions;

    private FeatureExtraColumns extraColumns = new DefaultFeatureExtraColumns();

    private MutableSymbolTable symbolTable;

    private String storeName;

    private boolean useSubquery;

    /**

     * Creates a FeatureQuery which will load all available Features of a type.

     *

     */

    public DefaultFeatureQuery() {

        super();

        this.useSubquery = true; // true for backwards compatibility.

        this.limit = NO_LIMIT;

        this.pageSize = 0;

    }

    public DefaultFeatureQuery(String storeName) {

        this();

        this.storeName = storeName;

    }

    /**

     * Creates a FeatureQuery which will load all available Features of a type.

     *

     * @param featureType

     *            the type of Features of the query

     */

    public DefaultFeatureQuery(FeatureType featureType) {

        this();

        this.setFeatureType(featureType);

    }

    /**

     * Creates a FeatureQuery with the type of features, a filter and the order

     * for the FeatureCollection.

     *

     * @param featureType

     *            the type of Features of the query

     * @param filter

     *            based on the properties of the Features

     */

    public DefaultFeatureQuery(FeatureType featureType, Evaluator filter) {

        this();

        this.setFeatureType(featureType);

        this.filter = filter;

    }

    /**

     * Creates a FeatureQuery with the type of features, a filter, the order for

     * the FeatureCollection and the view scale.

     *

     * @param featureType

     *            the type of Features of the query

     * @param filter

     *            based on the properties of the Features

     * @param scale

     *            to view the Features.

     */

    public DefaultFeatureQuery(FeatureType featureType, Evaluator filter,

        double scale) {

        this();

        this.setFeatureType(featureType);

        this.filter = filter;

        this.setScale(scale);

    }

    /**

     * Creates a FeatureQuery which will load a list of attribute names of all

     * available Features.

     *

     * @param attributeNames

     *            the list of attribute names to load

     */

    public DefaultFeatureQuery(String[] attributeNames) {

        this();

        setAttributeNames(attributeNames);

    }

    /**

     * Creates a FeatureQuery with the list of attribute names of feature, a

     * filter and the order for the FeatureCollection.

     *

     * @param attributeNames

     *            the list of attribute names to load

     * @param filter

     *            based on the properties of the Features

     */

    public DefaultFeatureQuery(String[] attributeNames, Evaluator filter) {

        this();

        setAttributeNames(attributeNames);

        this.filter = filter;

    }

    /**

     * Creates a FeatureQuery with the list of attribute names of feature, a

     * filter, the order for the FeatureCollection and the view scale.

     *

     * @param attributeNames

     *            the list of attribute names to load

     * @param filter

     *            based on the properties of the Features

     * @param scale

     *            to view the Features.

     */

    public DefaultFeatureQuery(String[] attributeNames, Evaluator filter,

        double scale) {

        this();

        setAttributeNames(attributeNames);

        this.filter = filter;

        this.setScale(scale);

    }

    @Override

    public double getScale() {

        Double scale = (Double) this.getQueryParameter(SCALE_PARAM_NAME);

        if (scale == null) {

            return 0;

        }

        return scale;

    }

    @Override

    public final void setScale(double scale) {

        this.setQueryParameter(SCALE_PARAM_NAME, scale);

    }

    @Override

    public Object getQueryParameter(String name) {

        return queryParameters.get(name);

    }

    @Override

    public void setQueryParameter(String name, Object value) {

        queryParameters.put(name, value);

    }

    @Override

    public final void setFeatureType(FeatureType featureType) {

        this.featureTypeId = featureType.getId();

    }

    @Override

    public String[] getAttributeNames() {

        if (this.hasExtraColumnDeclaredAsGroupByField()) {

            this.retrievesAllAttributes();

        }

        if(this.extraColumns == null || this.extraColumns.isEmpty()){

            return (String[])attributeNames.toArray(new String[attributeNames.size()]);

        }

        for (EditableFeatureAttributeDescriptor extraColumn : this.extraColumns) {

            for (String attributeName : attributeNames) {

                if(StringUtils.equalsIgnoreCase(attributeName, extraColumn.getName())){

                    attributeNames.remove(attributeName);

                    break;

                }

            }

        }

        return (String[])attributeNames.toArray(new String[attributeNames.size()]);

    }

    private boolean hasExtraColumnDeclaredAsGroupByField() {

        // indica si un campo de agrupaciones es una columna calculada

        if (this.hasGroupByColumns()) {

            for (String groupByColumn : groupByColumns) {

                if (this.extraColumns.get(groupByColumn)!=null) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public final void setAttributeNames(String[] attributeNames) {

        this.attributeNames.clear();

        if (attributeNames != null){

            this.attributeNames.addAll(Arrays.asList(attributeNames));

        }

    }

    @Override

    public void retrievesAllAttributes() {

        this.attributeNames.clear();

    }

    @Override

    public void addAttributeName(String attributeName){

        //If the attribute exists finish the method

        for (int i=0 ; i<attributeNames.size() ; i++){

            if (attributeNames.get(i).equals(attributeName)){

                return;

            }

        }

        this.attributeNames.add(attributeName);

    }

    @Override

    public void addEssentialAttributeNames(FeatureStore store) {

        FeatureType storeType;

        try {

            storeType = store.getDefaultFeatureType();

        } catch (DataException ex) {

            throw new RuntimeException("Can't access to the default feature type of tghe store", ex);

        }

        FeatureAttributeDescriptor[] pks = storeType.getPrimaryKey();

        if( storeType.hasOID() || ArrayUtils.isEmpty(pks) ) {

            FeatureAttributeDescriptor attrInt = null;

            FeatureAttributeDescriptor attrStr = null;

            FeatureAttributeDescriptor attrNotGeom = null;

            for (FeatureAttributeDescriptor attr : storeType) {

                if( attrInt == null && (attr.getType()==DataTypes.INT || attr.getType()==DataTypes.LONG) ) {

                    attrInt = attr;

                } else if( attrStr == null && attr.getType()==DataTypes.STRING ) {

                    attrStr = attr;

                } else if( attrNotGeom == null && attr.getType()!=DataTypes.GEOMETRY ) {

                    attrNotGeom = attr;

                }

            }

            if( attrInt != null ) {

                this.addAttributeName(attrInt.getName());

            } else if( attrStr != null ) {

                this.addAttributeName(attrStr.getName());

            } else if( attrNotGeom != null ) {

                this.addAttributeName(attrNotGeom.getName());

            } else {

                this.addAttributeName(storeType.getAttributeDescriptor(0).getName());

            }

        } else {

            for(FeatureAttributeDescriptor attr : pks ) {

                this.addAttributeName(attr.getName());

            }

        }

    }

    @Override

    public void addPrimaryKeyAttributeNames(FeatureStore store) {

        FeatureType storeType;

        try {

            storeType = store.getDefaultFeatureType();

        } catch (DataException ex) {

            throw new RuntimeException("Can't access to the default feature type of tghe store", ex);

        }

        for(FeatureAttributeDescriptor attr : storeType.getPrimaryKey() ) {

            this.addAttributeName(attr.getName());

        }

    }

    @Override

    public boolean hasAttributeNames() {

        if (hasExtraColumnDeclaredAsGroupByField()) {

            return true;

        }

        if(this.extraColumns == null || this.extraColumns.isEmpty()){

            return !this.attributeNames.isEmpty();

        }

        for (EditableFeatureAttributeDescriptor extraColumn : this.extraColumns) {

            for (String attributeName : attributeNames) {

                if(StringUtils.equalsIgnoreCase(attributeName, extraColumn.getName())){

                    attributeNames.remove(attributeName);

                    break;

                }

            }

        }

        return !this.attributeNames.isEmpty();

    }

    @Override

    public void clearAttributeNames() {

        this.attributeNames = new ArrayList();

    }

    @Override

    public Evaluator getFilter() {

      if( this.filter instanceof ExpressionEvaluator ) {

        ExpressionEvaluator eefilter = (ExpressionEvaluator) this.filter;

        if( symbolTable != null ) {

            eefilter.addSymbolTable(symbolTable);

        }

      }

      return filter;

    }

    @Override

    public Expression getExpressionFilter() {

      if( this.filter instanceof ExpressionEvaluator ) {

        ExpressionEvaluator eefilter = (ExpressionEvaluator) this.filter;

        if( symbolTable != null ) {

            eefilter.addSymbolTable(symbolTable);

        }

        return eefilter.toExpression();

      }

      return null;

    }

    @Override

    public void setFilter(Expression filter) {

        if( filter == null ) {

            this.clearFilter();

            return;

        }

        Evaluator x = new DefaultFeatureExpressionEvaluator(storeName, filter);

        this.setFilter(x);

    }

   @Override

    public void setFilter(String filter) {

        if( StringUtils.isEmpty(filter) ) {

            this.clearFilter();

            return;

        }

        try {

            this.setFilter(ExpressionUtils.createExpression(filter));

        } catch (Exception ex) {

            throw new RuntimeException("Can't create filter from '"+filter+"'",ex);

        }

    }

    @Override

    public void setFilter(Evaluator filter) {

        if( filter == null ) {

            this.clearFilter();

            return;

        }

        this.filter = filter;

        addFilterAttributes(filter);

    }

    @Override

    public void addFilter(String filter) {

        if( StringUtils.isEmpty(filter) ) {

            return;

        }

        this.addFilter(ExpressionUtils.createExpression(filter));

    }

    @Override

    public void addFilter(Expression filter) {

        Evaluator x = new DefaultFeatureExpressionEvaluator(filter);

        this.addFilter(x);

    }

    @Override

    public void addFilter(Evaluator evaluator) {

        if (evaluator == null) {

            return;

        }

        if (this.filter == null) {

            this.filter = evaluator;

        } else {

            if (this.filter instanceof AndEvaluator) {

                ((AndEvaluator) this.filter).addEvaluator(evaluator);

            } else {

                this.filter = new AndEvaluator(this.filter);

                ((AndEvaluator) this.filter).addEvaluator(evaluator);

            }

        }

        addFilterAttributes(evaluator);

    }

    @Override

    public void clearFilter() {

      this.filter = null;

    }

    private void addFilterAttributes(Evaluator evaluator){

        if (evaluator != null){

            EvaluatorFieldsInfo fieldsInfo = evaluator.getFieldsInfo();

            if (fieldsInfo == null){

                // FieldsInfo is not available in this evaluator

                return;

            }

            String[] fieldNames = fieldsInfo.getFieldNames();

            if (fieldNames== null){

                // fieldNames is not available in this evaluator

                return;

            }

            for (String fieldName : fieldNames) {

                addAttributeName(fieldName);

            }

        }

    }

    @Override

    public FeatureQueryOrder getOrder() {

        return order;

    }

    @Override

    public void setOrder(FeatureQueryOrder order) {

        if(order == null){

            this.order = new DefaultFeatureQueryOrder();

        } else {

            this.order = order;

        }

    }

    @Override

    public boolean hasFilter() {

        return this.filter != null;

    }

    @Override

    public boolean hasLimit() {

        return this.limit != NO_LIMIT;

    }

    @Override

    public boolean hasOrder() {

        return this.order != null && this.order.size() > 0;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultFeatureQuery clone = (DefaultFeatureQuery) super.clone();

        // Clone attribute names array

        if (attributeNames != null) {

            clone.attributeNames = new ArrayList();

            for (int i=0 ; i<attributeNames.size() ; i++){

                clone.attributeNames.add(attributeNames.get(i));

            }

        }

        // Clone order

        if (order != null) {

            clone.order = (FeatureQueryOrder) order.clone();

        }

        clone.extraColumns = extraColumns.getCopy();

        if( this.filter instanceof ExpressionEvaluator ) {

            Expression exp = ((ExpressionEvaluator)this.filter).toExpression();

            clone.filter =  new DefaultFeatureExpressionEvaluator(exp);

        }

        if (groupByColumns!=null) {

            clone.groupByColumns = new ArrayList<>();

            for (String value : groupByColumns) {

                clone.groupByColumns.add(value);

            }

        } else {

            clone.groupByColumns = null;

        }

        if (aggregateFunctions!=null) {

            clone.aggregateFunctions = new HashMap<>();

            for (String key : aggregateFunctions.keySet()) {

                clone.aggregateFunctions.put(key, aggregateFunctions.get(key));

            }

        } else {

            clone.aggregateFunctions = null;

        }

        if( this.symbolTable!=null ) {

            clone.symbolTable = this.symbolTable.clone();

        }

        return clone;

    }

    @Override

    public FeatureQuery getCopy() {

        try {

            return (FeatureQuery) clone();

        } catch (CloneNotSupportedException e) {

            LOGGER.debug("Can't clone feature query",e);

            return null;

        }

        // DefaultFeatureQuery aCopy = new DefaultFeatureQuery();

        //

        // aCopy.featureTypeId = this.featureTypeId;

        //

        // if (this.attributeNames != null) {

        // aCopy.attributeNames = (String[]) Arrays

        // .asList(this.attributeNames).toArray(new String[0]);

        // }

        //

        // aCopy.filter = this.filter;

        //

        // if (this.order != null) {

        // aCopy.order = this.order.getCopy();

        // }

        //

        // return aCopy;

    }

    @Override

    public String getFeatureTypeId() {

        return featureTypeId;

    }

    @Override

    public void setFeatureTypeId(String featureTypeId) {

        this.featureTypeId = featureTypeId;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // FIXME: falta por terminar de implementar

        state.set("version", VERSION_2_6_0_1);

        state.set("queryParameters", this.queryParameters);

        state.set("featureTypeId", this.featureTypeId);

        state.set("attributeNames", this.attributeNames);

        ArrayList<Expression> filterList = new ArrayList<>();

        if (this.filter instanceof DefaultFeatureExpressionEvaluator) {

            DefaultFeatureExpressionEvaluator filterExpression = (DefaultFeatureExpressionEvaluator) this.filter;

           filterList.add(filterExpression.toExpression());

        } else if (this.filter instanceof AndEvaluator) {

            AndEvaluator filterAnd = (AndEvaluator) this.filter;

            List<Evaluator> evaluators = filterAnd.getEvaluators();

            for (Evaluator evaluator : evaluators) {

                if (evaluator instanceof DefaultFeatureExpressionEvaluator) {

                    DefaultFeatureExpressionEvaluator expressionEvaluator = (DefaultFeatureExpressionEvaluator) evaluator;

                    filterList.add(expressionEvaluator.toExpression());

                } else {

                    filterList.clear();

                    LOGGER.warn(StringUtils.join("Filters in this FeatureQuery will not persist:", this.toString()));

                    break;

                }

            }

        } else {

            filterList.clear();

            if( this.filter!=null ) {

                LOGGER.warn(StringUtils.join("Filters in this FeatureQuery will not persist:", this.toString()));

            }

        }

        state.set("filter", filterList);

        state.set("limit", this.limit);

        state.set("pageSize", this.pageSize);

        state.set("useSubquery", this.useSubquery);

        state.set("order", this.order);

        state.set("groupByColumns", this.groupByColumns);

        state.set("aggregateFunctions", this.aggregateFunctions);

        state.set("extraColumn", this.extraColumns);

        state.set("storeName", this.storeName);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // FIXME: falta por terminar de implementar

        Version version = (Version) state.get("version");

        this.queryParameters = (Map) state.get("queryParameters");

        this.featureTypeId = state.getString("featureTypeId");

        this.attributeNames = state.getList("attributeNames");

        List<Expression> filterList = state.getList("filter");

        DataManager dataManager = DALLocator.getDataManager();

        if (filterList.isEmpty()) {

            this.filter = null;

        } else if (filterList.size() == 1) {

            Expression expression = filterList.get(0);

            Evaluator evaluator;

            try {

                evaluator = dataManager.createFilter(expression);

            } catch (InitializeException ex) {

                LOGGER.warn("Can't create evaluator", ex);

                evaluator = null;

            }

            this.filter = evaluator;

        } else {

            AndEvaluator andEvaluator = null;

            for (Expression expression : filterList) {

                Evaluator evaluator;

                try {

                    evaluator = dataManager.createFilter(expression);

                    if (andEvaluator == null) {

                        andEvaluator = new AndEvaluator(evaluator);

                    } else {

                        andEvaluator.addEvaluator(evaluator);

                    }

                } catch (InitializeException ex) {

                    LOGGER.warn("Can't create AndEvaluator", ex);//TODO evaluator a null

                    break;

                }

                this.filter = evaluator;

            }

        }

        this.limit = state.getLong("limit");

        this.pageSize = state.getLong("pageSize");

        this.useSubquery = state.getBoolean("useSubquery",true);

        this.storeName = state.getString("storeName");

        this.order = (FeatureQueryOrder) state.get("order");

        List asListGroupByColumns = (List) state.getList("groupByColumns");

        if (asListGroupByColumns!=null) {

            this.groupByColumns = new ArrayList<>(asListGroupByColumns);

        } else {

            this.groupByColumns = null;

        }

        Map asMapAggregateFunctions = (Map) state.getMap("aggregateFunctions");

        if (asMapAggregateFunctions!=null) {

            this.aggregateFunctions = new HashMap<>(asMapAggregateFunctions);

        } else {

            this.aggregateFunctions = null;

        }

        this.extraColumns = (FeatureExtraColumns) state.get("extraColumn");

        //

        // -------------------------------------------------------------

        // Correcciones por perdida de compatibilidad entre versiones

        //

        // Ver TC13-AC Listado peatones USUARIOS 2021.....

        if(version == null || version.compareTo(VERSION_2_6_0)<0){

            if(this.limit == 0) {

                this.clearLimit();

            }

            Expression exp = this.getExpressionFilter();

            fixOldExistsSelect(exp);

            for (EditableFeatureAttributeDescriptor extraColumn : this.extraColumns) {

                if(extraColumn.getFeatureAttributeEmulator() instanceof FeatureAttributeEmulatorExpression) {

                    exp = ((FeatureAttributeEmulatorExpression)extraColumn.getFeatureAttributeEmulator()).getExpression();

                    fixOldExistsSelect(exp);

                }

            }

        }

    }

    public static void selfRegister() {

        registerPersistent();

        Json.registerSerializer(DefaultFeatureQuery.class);

    }

    /**

     * Register the class on PersistenceManager

     *

     */

    private static void registerPersistent() {

        DynStruct definition =

            ToolsLocator.getPersistenceManager()

            .addDefinition(DefaultFeatureQuery.class,

                "DefaultFeatureQuery",

                "DefaultFeatureQuery Persistent definition",

                null,

                null);

        definition.addDynFieldObject("version")

                .setClassOfValue(DefaultVersion.class)

                .setMandatory(false);

        definition.addDynFieldMap("queryParameters")

                .setClassOfItems(Object.class)

                .setMandatory(true);

        definition.addDynFieldString("featureTypeId").setMandatory(false);

        definition.addDynFieldList("attributeNames")

                .setClassOfItems(String.class)

                .setMandatory(false);

        definition.addDynFieldList("filter")

                .setClassOfItems(Expression.class)

                .setMandatory(false);

        definition.addDynFieldObject("order")

                .setClassOfValue(FeatureQueryOrder.class)

                .setMandatory(false);

        definition.addDynFieldLong("limit").setMandatory(false);

        definition.addDynFieldLong("pageSize").setMandatory(false);

        definition.addDynFieldBoolean("useSubquery").setMandatory(false);

        definition.addDynFieldList("groupByColumns")

                .setClassOfItems(String.class);

        definition.addDynFieldMap("aggregateFunctions")

                .setClassOfItems(String.class)

                .setClassOfValue(String.class);

        definition.addDynFieldObject("extraColumn")

                .setClassOfValue(DefaultFeatureExtraColumns.class);

                definition.addDynFieldString("storeName").setMandatory(false);

    }

    @Override

    public long getLimit() {

        return limit;

    }

    @Override

    public long getPageSize() {

        return pageSize;

    }

    @Override

    public void setLimit(long limit) {

        this.limit = limit;

    }

    @Override

    public void clearLimit() {

        this.limit = NO_LIMIT;

    }

    @Override

    public void setPageSize(long pageSize) {

        this.pageSize = pageSize;

    }

    @Override

    public String[] getConstantsAttributeNames() {

        return (String[])constantsAttributeNames.toArray(new String[constantsAttributeNames.size()]);

    }

    @Override

    public void setConstantsAttributeNames(String[] constantsAttributeNames) {

        this.constantsAttributeNames.clear();

        if (constantsAttributeNames != null){

            this.constantsAttributeNames.addAll(Arrays.asList(constantsAttributeNames));

        }

    }

    @Override

    public void addConstantAttributeName(String attributeName) {

        //If the attribute exists finish the method

        for (int i=0 ; i<constantsAttributeNames.size() ; i++){

            if (constantsAttributeNames.get(i).equals(attributeName)){

                return;

            }

        }

        this.constantsAttributeNames.add(attributeName);

    }

    @Override

    public boolean hasConstantsAttributeNames() {

        return !this.constantsAttributeNames.isEmpty();

    }

    @Override

    public void clearConstantsAttributeNames() {

        this.constantsAttributeNames = new ArrayList();

    }

  @Override

  public boolean isAGroupByColumn(String name) {

    if( groupByColumns==null ) {

        return false;

    }

    for (String columnName : groupByColumns) {

      if( StringUtils.equalsIgnoreCase(name, columnName) ) {

        return true;

      }

    }

    return false;

  }

  @Override

  public List<String> getGroupByColumns() {

    if( this.groupByColumns == null ) {

      this.groupByColumns = new ArrayList<>();

    }

    return this.groupByColumns;

  }

  @Override

  public void removeGroupByColumn(String colname) {

    if( this.groupByColumns == null ) {

      return;

    }

    this.groupByColumns.remove(colname);

  }

  @Override

  public void addAggregate(String funcName, String columnName) {

        Map<String, String> aggregateds = this.getAggregateFunctions();