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

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.Range;

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

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

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

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

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

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

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

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

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

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class UpdateFunction

        extends AbstractFunction

        implements Optimizer.FunctionOptimizer {

    public UpdateFunction() {

        super(DALFunctions.GROUP_DATA_ACCESS,

                FUNCTION_UPDATE,

                Range.is(6),

                "bla bla bla",

                "UPDATE {{tablename}} SET column1 = exp1, column2 = exp2, ... WHERE expression;"

        );

    }

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

    }

    private static final int TABLE = 0;

    private static final int WHERE = 1;

    @Override

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

        // UPDATE( store, where, column1, column2, column3, exp1, exp2, exp3)

        // indices 0      1      2        3        4        5     6     7

        // num_columns = (args.size()-2)/2 --> (8-2)/2 --> 3

        // first_column = 2

        // first_exp = num_columns +2 --> 5

        SymbolTable symbolTable = interpreter.getSymbolTable();

        int num_columns = (args.size() - 2) / 2;

        int first_column = 2;

        int first_exp = num_columns + 2;

        Code.Identifier storeName = (Code.Identifier) args.get(TABLE);

        Code where = args.get(WHERE);

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

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

                where = null;

            }

        }

        Map<String, Code> values = new HashMap<>();

        for (int i = 0; i < num_columns; i++) {

            Code.Identifier column = (Code.Identifier) args.get(first_column + i);

            Code exp = args.get(first_exp + i);

            values.put(column.name(), exp);

        }

        try {

            DataStore store = this.getStore(storeName.name());

            if (store == null) {

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

            }

            if (!(store instanceof FeatureStore)) {

                throw new ExpressionRuntimeException("The store'" + storeName + "' is not valid for function '" + FUNCTION_SELECT + "', a FeatureStore is required.");

            }

            FeatureStore featureStore = (FeatureStore) store;

            FeatureSet features;

            if (where == null) {

                features = featureStore.getFeatureSet();

            } else {

                where = this.replaceLocalReferences(symbolTable, where);

                FeatureQuery query = featureStore.createFeatureQuery(where.toString(), (String)null, true);

                query.retrievesAllAttributes();

                features = featureStore.getFeatureSet(query);

            }

            if (features == null) {

                return 0;

            }

            long count = 0;

            featureStore.edit();

            for (Feature feature : features) {

                EditableFeature ef = feature.getEditable();

                for (String column : values.keySet()) {

                    Code exp = values.get(column);

                    exp = this.replaceLocalReferences(symbolTable, exp);

                    Object value = interpreter.run(exp);

                    ef.set(column, value);

                    // TODO: Tener en cuenta aqui llamar a algo que no dispare el concurrent modificacion exception.

                    featureStore.update(ef);

                }

                count++;

            }

            featureStore.finishEditing();

            return count;

        } catch (ExpressionRuntimeException ex) {

            throw ex;

        } catch (Exception ex) {

            throw new ExpressionRuntimeException("Problems calling '" + FUNCTION_SELECT + "' function", ex);

        }

    }

    protected DataStore getStore(String storeName) {

        DataManager dataManager = DALLocator.getDataManager();

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

        return store;

    }

    @Override

    public Code optimize(Optimizer optimizer, Callable caller) {

        return caller; // Don't optimize SELECT

    }

    private Code replaceLocalReferences(SymbolTable symbolTable, Code where) {

        try {

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

            CodeBuilder codeBuilder = ExpressionUtils.createCodeBuilder();

            Code where2 = where.clone();

            where2.accept((Object o) -> {

                if (o == null) {

                    return;

                }

                Code code = (Code) o;

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

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

                    if( id.startsWith("@") ) {

                        replaces.add(new ImmutablePair(

                                code,

                                codeBuilder.constant(symbolTable.value(id.substring(1)))

                        ));

                    }

                }

            });

            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 resolve local variables.", ex);

        }

    }

}