Application: gvSIG desktop

package com.hardcode.gdbms.engine.strategies;

import java.io.IOException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.data.indexes.IndexFactory;

import com.hardcode.gdbms.engine.data.indexes.VariableIndexSet;

import com.hardcode.gdbms.engine.data.persistence.Memento;

import com.hardcode.gdbms.engine.data.persistence.MementoException;

import com.hardcode.gdbms.engine.data.persistence.OperationLayerMemento;

import com.hardcode.gdbms.engine.instruction.EvaluationException;

import com.hardcode.gdbms.engine.instruction.Expression;

import com.hardcode.gdbms.engine.instruction.IncompatibleTypesException;

import com.hardcode.gdbms.engine.instruction.SemanticException;

import com.hardcode.gdbms.engine.values.BooleanValue;

import com.hardcode.gdbms.engine.values.Value;

/**

 * Representa una fuente de datos que contiene una cl?usula where mediante la

 * cual se filtran los campos

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class FilteredDataSource extends OperationDataSource {

        private DataSource source;

        private Expression whereExpression;

        private VariableIndexSet indexes;

        /**

         * Creates a new FilteredDataSource object.

         *

         * @param source DataSource que se va a filtrar

         * @param whereExpression Expresi?n de la cl?usula where

         */

        public FilteredDataSource(DataSource source, Expression whereExpression) {

                this.source = source;

                this.whereExpression = whereExpression;

        }

    public Value[] aggregatedFilter(Expression[] fields) throws IncompatibleTypesException, DriverException, EvaluationException, IOException {

        Value[] aggregatedValues = new Value[fields.length];

                indexes = IndexFactory.createVariableIndex();

                indexes.open();

                for (long i = 0; i < source.getRowCount(); i++) {

                        try {

                                if (((BooleanValue) whereExpression.evaluateExpression(i)).getValue()) {

                                        indexes.addIndex(i);

                                        for (int j = 0; j < aggregatedValues.length; j++) {

                        aggregatedValues[j] = fields[j].evaluate(i);

                    }

                                }

                        } catch (ClassCastException e) {

                                throw new IncompatibleTypesException("where expression is not boolean",

                                        e);

                        }

                }

                indexes.indexSetComplete();

                return aggregatedValues;

    }

    /**

         * M?todo que construye el array de ?ndices de las posiciones que las filas

         * filtradas ocupan en el DataSource origen

         *

         * @throws DriverException Si se produce un fallo en el driver al acceder a

         *                    los datos

         * @throws IOException Si se produce un error usando las estructuras de

         *                    datos internas

         * @throws SemanticException Si se produce alg?n error sem?ntico al evaluar

         *                    la expresi?n

         * @throws IncompatibleTypesException Si la expresi?n where no evalua a

         *                    booleano

         * @throws EvaluationException If the expression evaluation fails

         */

        public void filtrar()

                throws DriverException, IOException, SemanticException, EvaluationException {

                indexes = IndexFactory.createVariableIndex();

                indexes.open();

                for (long i = 0; i < source.getRowCount(); i++) {

                        try {

                                if (((BooleanValue) whereExpression.evaluateExpression(i)).getValue()) {

                                        indexes.addIndex(i);

                                }

                        } catch (ClassCastException e) {

                                throw new IncompatibleTypesException("where expression is not boolean",

                                        e);

                        }

                }

                indexes.indexSetComplete();

        }

        /**

         * @see com.hardcode.gdbms.engine.data.DataSource#open()

         */

        public void start() throws DriverException {

                source.start();

        }

        /**

         * @see com.hardcode.gdbms.engine.data.DataSource#close()

         */

        public void stop() throws DriverException {

                source.stop();

                try {

                        indexes.close();

                } catch (IOException e) {

                        throw new DriverException(e);

                }

        }

        /**

         * @see com.hardcode.gdbms.engine.data.FieldNameAccess#getFieldIndexByName(java.lang.String)

         */

        public int getFieldIndexByName(String fieldName) throws DriverException {

                return source.getFieldIndexByName(fieldName);

        }

        /**

         * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldValue(long,

         *                 int)

         */

        public Value getFieldValue(long rowIndex, int fieldId)

                throws DriverException {

                try {

                        return source.getFieldValue(indexes.getIndex(rowIndex), fieldId);

                } catch (IOException e) {

                        throw new DriverException(e);

                }

        }

        /**

         * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldCount()

         */

        public int getFieldCount() throws DriverException {

                return source.getFieldCount();

        }

        /**

         * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldName(int)

         */

        public String getFieldName(int fieldId) throws DriverException {

                return source.getFieldName(fieldId);

        }

        /**

         * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getRowCount()

         */

        public long getRowCount() throws DriverException {

                return indexes.getIndexCount();

        }

        /**

         * DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         *

         * @throws IOException

         *

         * @see com.hardcode.gdbms.engine.data.DataSource#getWhereFilter()

         */

        public long[] getWhereFilter() throws IOException {

                return indexes.getIndexes();

        }

        /**

         * @see com.hardcode.gdbms.engine.data.driver.ObjectDriver#getFieldType(int)

         */

        public int getFieldType(int i) throws DriverException {

                return source.getFieldType(i);

        }

        /**

         * @see com.hardcode.gdbms.engine.data.DataSource#getMemento()

         */

        public Memento getMemento() throws MementoException {

                return new OperationLayerMemento(getName(),

                        new Memento[] { source.getMemento() }, getSQL());

        }

        public int getFieldWidth(int i) throws DriverException {        

                return source.getFieldWidth(i);

        }

}