cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tylerho...@apache.org
Subject [3/3] cassandra git commit: Merge branch 'cassandra-2.1' into trunk
Date Wed, 19 Nov 2014 17:12:39 GMT
Merge branch 'cassandra-2.1' into trunk


Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/b8cf1728
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/b8cf1728
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/b8cf1728

Branch: refs/heads/trunk
Commit: b8cf17284e55eb98fea61be672a0bcadb3613754
Parents: 3cc9a0c 289314a
Author: Tyler Hobbs <tyler@datastax.com>
Authored: Wed Nov 19 11:11:37 2014 -0600
Committer: Tyler Hobbs <tyler@datastax.com>
Committed: Wed Nov 19 11:11:37 2014 -0600

----------------------------------------------------------------------
 CHANGES.txt                                     |   1 +
 .../apache/cassandra/cql3/ColumnIdentifier.java |   5 +
 .../cassandra/cql3/selection/RawSelector.java   |   5 +
 .../cassandra/cql3/selection/Selectable.java    |  20 ++
 .../cassandra/cql3/selection/Selection.java     |  24 +-
 .../cql3/selection/SelectorFactories.java       |  10 +
 .../cql3/statements/ModificationStatement.java  |   2 +-
 .../org/apache/cassandra/cql3/CQLTester.java    |   7 +
 .../cassandra/cql3/SelectionOrderingTest.java   | 233 +++++++++++++++++++
 9 files changed, 298 insertions(+), 9 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/CHANGES.txt
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/ColumnIdentifier.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/selection/RawSelector.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/selection/RawSelector.java
index c7e2658,0000000..7d5543f
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/cql3/selection/RawSelector.java
+++ b/src/java/org/apache/cassandra/cql3/selection/RawSelector.java
@@@ -1,56 -1,0 +1,61 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one
 + * or more contributor license agreements.  See the NOTICE file
 + * distributed with this work for additional information
 + * regarding copyright ownership.  The ASF licenses this file
 + * to you under the Apache License, Version 2.0 (the
 + * "License"); you may not use this file except in compliance
 + * with the License.  You may obtain a copy of the License at
 + *
 + *   http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing,
 + * software distributed under the License is distributed on an
 + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 + * KIND, either express or implied.  See the License for the
 + * specific language governing permissions and limitations
 + * under the License.
 + */
 +package org.apache.cassandra.cql3.selection;
 +
 +import java.util.List;
 +
 +import org.apache.cassandra.config.CFMetaData;
 +import org.apache.cassandra.cql3.ColumnIdentifier;
 +
 +import com.google.common.base.Function;
 +import com.google.common.collect.Lists;
 +
 +public class RawSelector
 +{
 +    public final Selectable.Raw selectable;
 +    public final ColumnIdentifier alias;
 +
 +    public RawSelector(Selectable.Raw selectable, ColumnIdentifier alias)
 +    {
 +        this.selectable = selectable;
 +        this.alias = alias;
 +    }
 +
 +    /**
 +     * Converts the specified list of <code>RawSelector</code>s into a list
of <code>Selectable</code>s.
 +     *
 +     * @param raws the <code>RawSelector</code>s to converts.
 +     * @return a list of <code>Selectable</code>s
 +     */
 +    public static List<Selectable> toSelectables(List<RawSelector> raws, final
CFMetaData cfm)
 +    {
 +        return Lists.transform(raws, new Function<RawSelector, Selectable>()
 +        {
 +            public Selectable apply(RawSelector raw)
 +            {
 +                return raw.selectable.prepare(cfm);
 +            }
 +        });
 +    }
++
++    public boolean processesSelection()
++    {
++        return selectable.processesSelection();
++    }
 +}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/selection/Selectable.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/selection/Selectable.java
index 48ce11a,0000000..c5ef857
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/cql3/selection/Selectable.java
+++ b/src/java/org/apache/cassandra/cql3/selection/Selectable.java
@@@ -1,226 -1,0 +1,246 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one
 + * or more contributor license agreements.  See the NOTICE file
 + * distributed with this work for additional information
 + * regarding copyright ownership.  The ASF licenses this file
 + * to you under the Apache License, Version 2.0 (the
 + * "License"); you may not use this file except in compliance
 + * with the License.  You may obtain a copy of the License at
 + *
 + *   http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing,
 + * software distributed under the License is distributed on an
 + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 + * KIND, either express or implied.  See the License for the
 + * specific language governing permissions and limitations
 + * under the License.
 + */
 +package org.apache.cassandra.cql3.selection;
 +
 +import java.util.ArrayList;
 +import java.util.List;
 +
 +import org.apache.cassandra.config.CFMetaData;
 +import org.apache.cassandra.config.ColumnDefinition;
 +import org.apache.cassandra.cql3.ColumnIdentifier;
 +import org.apache.cassandra.cql3.functions.Function;
 +import org.apache.cassandra.cql3.functions.FunctionName;
 +import org.apache.cassandra.cql3.functions.Functions;
 +import org.apache.cassandra.db.marshal.AbstractType;
 +import org.apache.cassandra.db.marshal.UserType;
 +import org.apache.cassandra.exceptions.InvalidRequestException;
 +import org.apache.commons.lang3.text.StrBuilder;
 +
 +public abstract class Selectable
 +{
 +    public abstract Selector.Factory newSelectorFactory(CFMetaData cfm, List<ColumnDefinition>
defs)
 +            throws InvalidRequestException;
 +
 +    protected static int addAndGetIndex(ColumnDefinition def, List<ColumnDefinition>
l)
 +    {
 +        int idx = l.indexOf(def);
 +        if (idx < 0)
 +        {
 +            idx = l.size();
 +            l.add(def);
 +        }
 +        return idx;
 +    }
 +
 +    public static interface Raw
 +    {
 +        public Selectable prepare(CFMetaData cfm);
++
++        /**
++         * Returns true if any processing is performed on the selected column.
++         **/
++        public boolean processesSelection();
 +    }
 +
 +    public static class WritetimeOrTTL extends Selectable
 +    {
 +        public final ColumnIdentifier id;
 +        public final boolean isWritetime;
 +
 +        public WritetimeOrTTL(ColumnIdentifier id, boolean isWritetime)
 +        {
 +            this.id = id;
 +            this.isWritetime = isWritetime;
 +        }
 +
 +        @Override
 +        public String toString()
 +        {
 +            return (isWritetime ? "writetime" : "ttl") + "(" + id + ")";
 +        }
 +
 +        public Selector.Factory newSelectorFactory(CFMetaData cfm,
 +                                                   List<ColumnDefinition> defs) throws
InvalidRequestException
 +        {
 +            ColumnDefinition def = cfm.getColumnDefinition(id);
 +            if (def == null)
 +                throw new InvalidRequestException(String.format("Undefined name %s in selection
clause", id));
 +            if (def.isPrimaryKeyColumn())
 +                throw new InvalidRequestException(
 +                        String.format("Cannot use selection function %s on PRIMARY KEY part
%s",
 +                                      isWritetime ? "writeTime" : "ttl",
 +                                      def.name));
 +            if (def.type.isCollection())
 +                throw new InvalidRequestException(String.format("Cannot use selection function
%s on collections",
 +                                                                isWritetime ? "writeTime"
: "ttl"));
 +
 +            return WritetimeOrTTLSelector.newFactory(def.name.toString(), addAndGetIndex(def,
defs), isWritetime);
 +        }
 +
 +        public static class Raw implements Selectable.Raw
 +        {
 +            private final ColumnIdentifier.Raw id;
 +            private final boolean isWritetime;
 +
 +            public Raw(ColumnIdentifier.Raw id, boolean isWritetime)
 +            {
 +                this.id = id;
 +                this.isWritetime = isWritetime;
 +            }
 +
 +            public WritetimeOrTTL prepare(CFMetaData cfm)
 +            {
 +                return new WritetimeOrTTL(id.prepare(cfm), isWritetime);
 +            }
++
++            public boolean processesSelection()
++            {
++                return true;
++            }
 +        }
 +    }
 +
 +    public static class WithFunction extends Selectable
 +    {
 +        public final FunctionName functionName;
 +        public final List<Selectable> args;
 +
 +        public WithFunction(FunctionName functionName, List<Selectable> args)
 +        {
 +            this.functionName = functionName;
 +            this.args = args;
 +        }
 +
 +        @Override
 +        public String toString()
 +        {
 +            return new StrBuilder().append(functionName)
 +                                   .append("(")
 +                                   .appendWithSeparators(args, ", ")
 +                                   .append(")")
 +                                   .toString();
 +        }
 +
 +        public Selector.Factory newSelectorFactory(CFMetaData cfm,
 +                                                   List<ColumnDefinition> defs) throws
InvalidRequestException
 +        {
 +            SelectorFactories factories  =
 +                    SelectorFactories.createFactoriesAndCollectColumnDefinitions(args, cfm,
defs);
 +
 +            // resolve built-in functions before user defined functions
 +            Function fun = Functions.get(cfm.ksName, functionName, factories.newInstances(),
cfm.ksName, cfm.cfName);
 +            if (fun == null)
 +                throw new InvalidRequestException(String.format("Unknown function '%s'",
functionName));
 +            if (fun.returnType() == null)
 +                throw new InvalidRequestException(String.format("Unknown function %s called
in selection clause",
 +                                                                functionName));
 +
 +            return AbstractFunctionSelector.newFactory(fun, factories);
 +        }
 +
 +        public static class Raw implements Selectable.Raw
 +        {
 +            private final FunctionName functionName;
 +            private final List<Selectable.Raw> args;
 +
 +            public Raw(FunctionName functionName, List<Selectable.Raw> args)
 +            {
 +                this.functionName = functionName;
 +                this.args = args;
 +            }
 +
 +            public WithFunction prepare(CFMetaData cfm)
 +            {
 +                List<Selectable> preparedArgs = new ArrayList<>(args.size());
 +                for (Selectable.Raw arg : args)
 +                    preparedArgs.add(arg.prepare(cfm));
 +                return new WithFunction(functionName, preparedArgs);
 +            }
++
++            public boolean processesSelection()
++            {
++                return true;
++            }
 +        }
 +    }
 +
 +    public static class WithFieldSelection extends Selectable
 +    {
 +        public final Selectable selected;
 +        public final ColumnIdentifier field;
 +
 +        public WithFieldSelection(Selectable selected, ColumnIdentifier field)
 +        {
 +            this.selected = selected;
 +            this.field = field;
 +        }
 +
 +        @Override
 +        public String toString()
 +        {
 +            return String.format("%s.%s", selected, field);
 +        }
 +
 +        public Selector.Factory newSelectorFactory(CFMetaData cfm,
 +                                                   List<ColumnDefinition> defs) throws
InvalidRequestException
 +        {
 +            Selector.Factory factory = selected.newSelectorFactory(cfm, defs);
 +            AbstractType<?> type = factory.newInstance().getType();
 +            if (!(type instanceof UserType))
 +                throw new InvalidRequestException(
 +                        String.format("Invalid field selection: %s of type %s is not a user
type",
 +                                      selected,
 +                                      type.asCQL3Type()));
 +
 +            UserType ut = (UserType) type;
 +            for (int i = 0; i < ut.size(); i++)
 +            {
 +                if (!ut.fieldName(i).equals(field.bytes))
 +                    continue;
 +                return FieldSelector.newFactory(ut, i, factory);
 +            }
 +            throw new InvalidRequestException(String.format("%s of type %s has no field
%s",
 +                                                            selected,
 +                                                            type.asCQL3Type(),
 +                                                            field));
 +        }
 +
 +        public static class Raw implements Selectable.Raw
 +        {
 +            private final Selectable.Raw selected;
 +            private final ColumnIdentifier.Raw field;
 +
 +            public Raw(Selectable.Raw selected, ColumnIdentifier.Raw field)
 +            {
 +                this.selected = selected;
 +                this.field = field;
 +            }
 +
 +            public WithFieldSelection prepare(CFMetaData cfm)
 +            {
 +                return new WithFieldSelection(selected.prepare(cfm), field.prepare(cfm));
 +            }
++
++            public boolean processesSelection()
++            {
++                return true;
++            }
 +        }
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/selection/Selection.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/selection/Selection.java
index 7c7dab7,0000000..888d96d
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/cql3/selection/Selection.java
+++ b/src/java/org/apache/cassandra/cql3/selection/Selection.java
@@@ -1,405 -1,0 +1,413 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one
 + * or more contributor license agreements.  See the NOTICE file
 + * distributed with this work for additional information
 + * regarding copyright ownership.  The ASF licenses this file
 + * to you under the Apache License, Version 2.0 (the
 + * "License"); you may not use this file except in compliance
 + * with the License.  You may obtain a copy of the License at
 + *
 + *     http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package org.apache.cassandra.cql3.selection;
 +
 +import java.nio.ByteBuffer;
 +import java.util.ArrayList;
 +import java.util.Collection;
 +import java.util.Iterator;
 +import java.util.List;
 +
 +import org.apache.cassandra.config.CFMetaData;
 +import org.apache.cassandra.config.ColumnDefinition;
 +import org.apache.cassandra.cql3.ColumnIdentifier;
 +import org.apache.cassandra.cql3.ColumnSpecification;
 +import org.apache.cassandra.cql3.ResultSet;
 +import org.apache.cassandra.db.Cell;
 +import org.apache.cassandra.db.CounterCell;
 +import org.apache.cassandra.db.ExpiringCell;
 +import org.apache.cassandra.db.context.CounterContext;
 +import org.apache.cassandra.exceptions.InvalidRequestException;
 +import org.apache.cassandra.utils.ByteBufferUtil;
 +
 +import com.google.common.collect.Iterators;
 +
 +public abstract class Selection
 +{
 +    private final Collection<ColumnDefinition> columns;
 +    private final ResultSet.Metadata metadata;
 +    private final boolean collectTimestamps;
 +    private final boolean collectTTLs;
 +
 +    protected Selection(Collection<ColumnDefinition> columns, List<ColumnSpecification>
metadata, boolean collectTimestamps, boolean collectTTLs)
 +    {
 +        this.columns = columns;
 +        this.metadata = new ResultSet.Metadata(metadata);
 +        this.collectTimestamps = collectTimestamps;
 +        this.collectTTLs = collectTTLs;
 +    }
 +
 +    // Overriden by SimpleSelection when appropriate.
 +    public boolean isWildcard()
 +    {
 +        return false;
 +    }
 +
 +    public ResultSet.Metadata getResultMetadata()
 +    {
 +        return metadata;
 +    }
 +
 +    public static Selection wildcard(CFMetaData cfm)
 +    {
 +        List<ColumnDefinition> all = new ArrayList<ColumnDefinition>(cfm.allColumns().size());
 +        Iterators.addAll(all, cfm.allColumnsInSelectOrder());
 +        return new SimpleSelection(all, true);
 +    }
 +
 +    public static Selection forColumns(Collection<ColumnDefinition> columns)
 +    {
 +        return new SimpleSelection(columns, false);
 +    }
 +
 +    public int addColumnForOrdering(ColumnDefinition c)
 +    {
 +        columns.add(c);
 +        metadata.addNonSerializedColumn(c);
 +        return columns.size() - 1;
 +    }
 +
 +    public boolean usesFunction(String ksName, String functionName)
 +    {
 +        return false;
 +    }
 +
-     private static boolean isUsingFunction(List<RawSelector> rawSelectors)
++    private static boolean processesSelection(List<RawSelector> rawSelectors)
 +    {
 +        for (RawSelector rawSelector : rawSelectors)
 +        {
-             if (!(rawSelector.selectable instanceof ColumnIdentifier))
++            if (rawSelector.processesSelection())
 +                return true;
 +        }
 +        return false;
 +    }
 +
 +    public static Selection fromSelectors(CFMetaData cfm, List<RawSelector> rawSelectors)
throws InvalidRequestException
 +    {
 +        List<ColumnDefinition> defs = new ArrayList<ColumnDefinition>();
 +
 +        SelectorFactories factories =
 +                SelectorFactories.createFactoriesAndCollectColumnDefinitions(RawSelector.toSelectables(rawSelectors,
cfm), cfm, defs);
 +        List<ColumnSpecification> metadata = collectMetadata(cfm, rawSelectors, factories);
 +
-         return isUsingFunction(rawSelectors) ? new SelectionWithFunctions(defs, metadata,
factories)
-                                              : new SimpleSelection(defs, metadata, false);
++        return processesSelection(rawSelectors) ? new SelectionWithProcessing(defs, metadata,
factories)
++                                                : new SimpleSelection(defs, metadata, false);
 +    }
 +
 +    private static List<ColumnSpecification> collectMetadata(CFMetaData cfm,
 +                                                             List<RawSelector> rawSelectors,
 +                                                             SelectorFactories factories)
 +    {
 +        List<ColumnSpecification> metadata = new ArrayList<ColumnSpecification>(rawSelectors.size());
 +        Iterator<RawSelector> iter = rawSelectors.iterator();
 +        for (Selector.Factory factory : factories)
 +        {
 +            ColumnSpecification colSpec = factory.getColumnSpecification(cfm);
 +            ColumnIdentifier alias = iter.next().alias;
 +            metadata.add(alias == null ? colSpec : colSpec.withAlias(alias));
 +        }
 +        return metadata;
 +    }
 +
 +    protected abstract Selectors newSelectors();
 +
 +    /**
 +     * @return the list of CQL3 columns value this SelectionClause needs.
 +     */
 +    public Collection<ColumnDefinition> getColumns()
 +    {
 +        return columns;
 +    }
 +
 +    public ResultSetBuilder resultSetBuilder(long now)
 +    {
 +        return new ResultSetBuilder(now);
 +    }
 +
 +    public abstract boolean isAggregate();
 +
 +    /**
 +     * Checks that selectors are either all aggregates or that none of them is.
 +     *
 +     * @param selectors the selectors to test.
 +     * @param messageTemplate the error message template
 +     * @param messageArgs the error message arguments
 +     * @throws InvalidRequestException if some of the selectors are aggregate but not all
of them
 +     */
 +    static void validateSelectors(List<Selector> selectors, String messageTemplate,
Object... messageArgs)
 +            throws InvalidRequestException
 +    {
 +        int aggregates = 0;
 +        for (Selector s : selectors)
 +            if (s.isAggregate())
 +                ++aggregates;
 +
 +        if (aggregates != 0 && aggregates != selectors.size())
 +            throw new InvalidRequestException(String.format(messageTemplate, messageArgs));
 +    }
 +
 +    public class ResultSetBuilder
 +    {
 +        private final ResultSet resultSet;
 +
 +        /**
 +         * As multiple thread can access a <code>Selection</code> instance each
<code>ResultSetBuilder</code> will use
 +         * its own <code>Selectors</code> instance.
 +         */
 +        private final Selectors selectors;
 +
 +        /*
 +         * We'll build CQL3 row one by one.
 +         * The currentRow is the values for the (CQL3) columns we've fetched.
 +         * We also collect timestamps and ttls for the case where the writetime and
 +         * ttl functions are used. Note that we might collect timestamp and/or ttls
 +         * we don't care about, but since the array below are allocated just once,
 +         * it doesn't matter performance wise.
 +         */
 +        List<ByteBuffer> current;
 +        final long[] timestamps;
 +        final int[] ttls;
 +        final long now;
 +
 +        private ResultSetBuilder(long now)
 +        {
 +            this.resultSet = new ResultSet(getResultMetadata().copy(), new ArrayList<List<ByteBuffer>>());
 +            this.selectors = newSelectors();
 +            this.timestamps = collectTimestamps ? new long[columns.size()] : null;
 +            this.ttls = collectTTLs ? new int[columns.size()] : null;
 +            this.now = now;
 +        }
 +
 +        public void add(ByteBuffer v)
 +        {
 +            current.add(v);
 +        }
 +
 +        public void add(Cell c)
 +        {
 +            current.add(isDead(c) ? null : value(c));
 +            if (timestamps != null)
 +            {
 +                timestamps[current.size() - 1] = isDead(c) ? Long.MIN_VALUE : c.timestamp();
 +            }
 +            if (ttls != null)
 +            {
 +                int ttl = -1;
 +                if (!isDead(c) && c instanceof ExpiringCell)
 +                    ttl = c.getLocalDeletionTime() - (int) (now / 1000);
 +                ttls[current.size() - 1] = ttl;
 +            }
 +        }
 +
 +        private boolean isDead(Cell c)
 +        {
 +            return c == null || !c.isLive(now);
 +        }
 +
 +        public void newRow() throws InvalidRequestException
 +        {
 +            if (current != null)
 +            {
 +                selectors.addInputRow(this);
 +                if (!selectors.isAggregate())
 +                {
 +                    resultSet.addRow(selectors.getOutputRow());
 +                    selectors.reset();
 +                }
 +            }
 +            current = new ArrayList<ByteBuffer>(columns.size());
 +        }
 +
 +        public ResultSet build() throws InvalidRequestException
 +        {
 +            if (current != null)
 +            {
 +                selectors.addInputRow(this);
 +                resultSet.addRow(selectors.getOutputRow());
 +                selectors.reset();
 +                current = null;
 +            }
 +
 +            if (resultSet.isEmpty() && selectors.isAggregate())
 +            {
 +                resultSet.addRow(selectors.getOutputRow());
 +            }
 +            return resultSet;
 +        }
 +
 +        private ByteBuffer value(Cell c)
 +        {
 +            return (c instanceof CounterCell)
 +                ? ByteBufferUtil.bytes(CounterContext.instance().total(c.value()))
 +                : c.value();
 +        }
 +    }
 +
 +    private static interface Selectors
 +    {
 +        public boolean isAggregate();
 +
 +        /**
 +         * Adds the current row of the specified <code>ResultSetBuilder</code>.
 +         *
 +         * @param rs the <code>ResultSetBuilder</code>
 +         * @throws InvalidRequestException
 +         */
 +        public void addInputRow(ResultSetBuilder rs) throws InvalidRequestException;
 +
 +        public List<ByteBuffer> getOutputRow() throws InvalidRequestException;
 +
 +        public void reset();
 +    }
 +
 +    // Special cased selection for when no function is used (this save some allocations).
 +    private static class SimpleSelection extends Selection
 +    {
 +        private final boolean isWildcard;
 +
 +        public SimpleSelection(Collection<ColumnDefinition> columns, boolean isWildcard)
 +        {
 +            this(columns, new ArrayList<ColumnSpecification>(columns), isWildcard);
 +        }
 +
 +        public SimpleSelection(Collection<ColumnDefinition> columns, List<ColumnSpecification>
metadata, boolean isWildcard)
 +        {
 +            /*
 +             * In theory, even a simple selection could have multiple time the same column,
so we
 +             * could filter those duplicate out of columns. But since we're very unlikely
to
 +             * get much duplicate in practice, it's more efficient not to bother.
 +             */
 +            super(columns, metadata, false, false);
 +            this.isWildcard = isWildcard;
 +        }
 +
 +        @Override
 +        public boolean isWildcard()
 +        {
 +            return isWildcard;
 +        }
 +
 +        public boolean isAggregate()
 +        {
 +            return false;
 +        }
 +
 +        protected Selectors newSelectors()
 +        {
 +            return new Selectors()
 +            {
 +                private List<ByteBuffer> current;
 +
 +                public void reset()
 +                {
 +                    current = null;
 +                }
 +
 +                public List<ByteBuffer> getOutputRow()
 +                {
 +                    return current;
 +                }
 +
 +                public void addInputRow(ResultSetBuilder rs) throws InvalidRequestException
 +                {
 +                    current = rs.current;
 +                }
 +
 +                public boolean isAggregate()
 +                {
 +                    return false;
 +                }
 +            };
 +        }
 +    }
 +
-     private static class SelectionWithFunctions extends Selection
++    private static class SelectionWithProcessing extends Selection
 +    {
 +        private final SelectorFactories factories;
 +
-         public SelectionWithFunctions(Collection<ColumnDefinition> columns,
-                                       List<ColumnSpecification> metadata,
-                                       SelectorFactories factories) throws InvalidRequestException
++        public SelectionWithProcessing(Collection<ColumnDefinition> columns,
++                                       List<ColumnSpecification> metadata,
++                                       SelectorFactories factories) throws InvalidRequestException
 +        {
 +            super(columns, metadata, factories.containsWritetimeSelectorFactory(), factories.containsTTLSelectorFactory());
 +            this.factories = factories;
 +
 +            if (factories.doesAggregation() && !factories.containsOnlyAggregateFunctions())
 +                throw new InvalidRequestException("the select clause must either contains
only aggregates or none");
 +        }
 +
 +        public boolean usesFunction(String ksName, String functionName)
 +        {
 +            return factories.usesFunction(ksName, functionName);
 +        }
 +
++        @Override
++        public int addColumnForOrdering(ColumnDefinition c)
++        {
++            int index = super.addColumnForOrdering(c);
++            factories.addSelectorForOrdering(c, index);
++            return index;
++        }
++
 +        public boolean isAggregate()
 +        {
 +            return factories.containsOnlyAggregateFunctions();
 +        }
 +
 +        protected Selectors newSelectors()
 +        {
 +            return new Selectors()
 +            {
 +                private final List<Selector> selectors = factories.newInstances();
 +
 +                public void reset()
 +                {
 +                    for (int i = 0, m = selectors.size(); i < m; i++)
 +                    {
 +                        selectors.get(i).reset();
 +                    }
 +                }
 +
 +                public boolean isAggregate()
 +                {
 +                    return factories.containsOnlyAggregateFunctions();
 +                }
 +
 +                public List<ByteBuffer> getOutputRow() throws InvalidRequestException
 +                {
 +                    List<ByteBuffer> outputRow = new ArrayList<>(selectors.size());
 +
 +                    for (int i = 0, m = selectors.size(); i < m; i++)
 +                    {
 +                        outputRow.add(selectors.get(i).getOutput());
 +                    }
 +                    return outputRow;
 +                }
 +
 +                public void addInputRow(ResultSetBuilder rs) throws InvalidRequestException
 +                {
 +                    for (int i = 0, m = selectors.size(); i < m; i++)
 +                    {
 +                        selectors.get(i).addInput(rs);
 +                    }
 +                }
 +            };
 +        }
 +
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/selection/SelectorFactories.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/selection/SelectorFactories.java
index 4d3e974,0000000..9f6025c
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/cql3/selection/SelectorFactories.java
+++ b/src/java/org/apache/cassandra/cql3/selection/SelectorFactories.java
@@@ -1,179 -1,0 +1,189 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one
 + * or more contributor license agreements.  See the NOTICE file
 + * distributed with this work for additional information
 + * regarding copyright ownership.  The ASF licenses this file
 + * to you under the Apache License, Version 2.0 (the
 + * "License"); you may not use this file except in compliance
 + * with the License.  You may obtain a copy of the License at
 + *
 + *     http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package org.apache.cassandra.cql3.selection;
 +
 +import java.util.ArrayList;
 +import java.util.Iterator;
 +import java.util.List;
 +
 +import com.google.common.base.Function;
 +import com.google.common.collect.Lists;
 +
 +import org.apache.cassandra.config.CFMetaData;
 +import org.apache.cassandra.config.ColumnDefinition;
 +import org.apache.cassandra.cql3.selection.Selector.Factory;
 +import org.apache.cassandra.exceptions.InvalidRequestException;
 +
 +/**
 + * A set of <code>Selector</code> factories.
 + */
 +final class SelectorFactories implements Iterable<Selector.Factory>
 +{
 +    /**
 +     * The <code>Selector</code> factories.
 +     */
 +    private final List<Selector.Factory> factories;
 +
 +    /**
 +     * <code>true</code> if one of the factory creates writetime selectors.
 +     */
 +    private boolean containsWritetimeFactory;
 +
 +    /**
 +     * <code>true</code> if one of the factory creates TTL selectors.
 +     */
 +    private boolean containsTTLFactory;
 +
 +    /**
 +     * The number of factories creating aggregates.
 +     */
 +    private int numberOfAggregateFactories;
 +
 +    /**
 +     * Creates a new <code>SelectorFactories</code> instance and collect the
column definitions.
 +     *
 +     * @param selectables the <code>Selectable</code>s for which the factories
must be created
 +     * @param cfm the Column Family Definition
 +     * @param defs the collector parameter for the column definitions
 +     * @return a new <code>SelectorFactories</code> instance
 +     * @throws InvalidRequestException if a problem occurs while creating the factories
 +     */
 +    public static SelectorFactories createFactoriesAndCollectColumnDefinitions(List<Selectable>
selectables,
 +                                                                               CFMetaData
cfm,
 +                                                                               List<ColumnDefinition>
defs)
 +                                                                               throws InvalidRequestException
 +    {
 +        return new SelectorFactories(selectables, cfm, defs);
 +    }
 +
 +    private SelectorFactories(List<Selectable> selectables,
 +                              CFMetaData cfm,
 +                              List<ColumnDefinition> defs)
 +                              throws InvalidRequestException
 +    {
 +        factories = new ArrayList<>(selectables.size());
 +
 +        for (Selectable selectable : selectables)
 +        {
 +            Factory factory = selectable.newSelectorFactory(cfm, defs);
 +            containsWritetimeFactory |= factory.isWritetimeSelectorFactory();
 +            containsTTLFactory |= factory.isTTLSelectorFactory();
 +            if (factory.isAggregateSelectorFactory())
 +                ++numberOfAggregateFactories;
 +            factories.add(factory);
 +        }
 +    }
 +
 +    public boolean usesFunction(String ksName, String functionName)
 +    {
 +        for (Factory factory : factories)
 +            if (factory != null && factory.usesFunction(ksName, functionName))
 +                return true;
 +        return false;
 +    }
 +
 +    /**
++     * Adds a new <code>Selector.Factory</code> for a column that is needed
only for ORDER BY purposes.
++     * @param def the column that is needed for ordering
++     * @param index the index of the column definition in the Selection's list of columns
++     */
++    public void addSelectorForOrdering(ColumnDefinition def, int index)
++    {
++        factories.add(SimpleSelector.newFactory(def.name.toString(), index, def.type));
++    }
++
++    /**
 +     * Checks if this <code>SelectorFactories</code> contains only factories
for aggregates.
 +     *
 +     * @return <code>true</code> if this <code>SelectorFactories</code>
contains only factories for aggregates,
 +     * <code>false</code> otherwise.
 +     */
 +    public boolean containsOnlyAggregateFunctions()
 +    {
 +        int size = factories.size();
 +        return  size != 0 && numberOfAggregateFactories == size;
 +    }
 +
 +    /**
 +     * Whether the selector built by this factory does aggregation or not (either directly
or in a sub-selector).
 +     *
 +     * @return <code>true</code> if the selector built by this factor does aggregation,
<code>false</code> otherwise.
 +     */
 +    public boolean doesAggregation()
 +    {
 +        return numberOfAggregateFactories > 0;
 +    }
 +
 +    /**
 +     * Checks if this <code>SelectorFactories</code> contains at least one factory
for writetime selectors.
 +     *
 +     * @return <code>true</code> if this <code>SelectorFactories</code>
contains at least one factory for writetime
 +     * selectors, <code>false</code> otherwise.
 +     */
 +    public boolean containsWritetimeSelectorFactory()
 +    {
 +        return containsWritetimeFactory;
 +    }
 +
 +    /**
 +     * Checks if this <code>SelectorFactories</code> contains at least one factory
for TTL selectors.
 +     *
 +     * @return <code>true</code> if this <code>SelectorFactories</code>
contains at least one factory for TTL
 +     * selectors, <code>false</code> otherwise.
 +     */
 +    public boolean containsTTLSelectorFactory()
 +    {
 +        return containsTTLFactory;
 +    }
 +
 +    /**
 +     * Creates a list of new <code>Selector</code> instances.
 +     * @return a list of new <code>Selector</code> instances.
 +     */
 +    public List<Selector> newInstances()
 +    {
 +        List<Selector> selectors = new ArrayList<>(factories.size());
 +        for (Selector.Factory factory : factories)
 +        {
 +            selectors.add(factory.newInstance());
 +        }
 +        return selectors;
 +    }
 +
 +    public Iterator<Factory> iterator()
 +    {
 +        return factories.iterator();
 +    }
 +
 +    /**
 +     * Returns the names of the columns corresponding to the output values of the selector
instances created by
 +     * these factories.
 +     *
 +     * @return a list of column names
 +     */
 +    public List<String> getColumnNames()
 +    {
 +        return Lists.transform(factories, new Function<Selector.Factory, String>()
 +        {
 +            public String apply(Selector.Factory factory)
 +            {
 +                return factory.getColumnName();
 +            }
 +        });
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/b8cf1728/test/unit/org/apache/cassandra/cql3/CQLTester.java
----------------------------------------------------------------------


Mime
View raw message