Java IndexOperator.EQ属性代码示例

/**
 * Returns IndexOperator from string representation
 * @param operator - string representing IndexOperator (=, >=, >, <, <=)
 * @return IndexOperator - enum value of IndexOperator or null if not found
 */
public static IndexOperator getIndexOperator(String operator)
{
    if (operator.equals("="))
    {
        return IndexOperator.EQ;
    }
    else if (operator.equals(">="))
    {
        return IndexOperator.GTE;
    }
    else if (operator.equals(">"))
    {
        return IndexOperator.GT;
    }
    else if (operator.equals("<"))
    {
        return IndexOperator.LT;
    }
    else if (operator.equals("<="))
    {
        return IndexOperator.LTE;
    }

    return null;
}
 

@Test
public void testSatisfiedByWithMultipleTerms()
{
    final ByteBuffer comment = UTF8Type.instance.decompose("comment");
    final ColumnFamilyStore store = Keyspace.open("sasecondaryindex").getColumnFamilyStore("saindexed1");
    final IPartitioner<?> partitioner = StorageService.getPartitioner();

    ColumnFamily cf = ArrayBackedSortedColumns.factory.create(store.metadata);
    cf.addColumn(new Column(comment, UTF8Type.instance.decompose("software engineer is working on a project"), System.currentTimeMillis()));

    Operation.Builder builder = new Operation.Builder(OperationType.AND, UTF8Type.instance, controller,
                                        new IndexExpression(comment, IndexOperator.EQ, UTF8Type.instance.decompose("eng is a work")));
    Operation op = builder.complete();

    Assert.assertTrue(op.satisfiedBy(new Row(partitioner.decorateKey(UTF8Type.instance.decompose("key1")), cf), null, false));

    builder = new Operation.Builder(OperationType.AND, UTF8Type.instance, controller,
                                        new IndexExpression(comment, IndexOperator.EQ, UTF8Type.instance.decompose("soft works fine")));
    op = builder.complete();

    Assert.assertTrue(op.satisfiedBy(new Row(partitioner.decorateKey(UTF8Type.instance.decompose("key1")), cf), null, false));
}
 

@VisibleForTesting
protected static ListMultimap<ByteBuffer, Expression> analyzeGroup(QueryController controller,
                                                                   final AbstractType<?> comparator,
                                                                   OperationType op,
                                                                   List<IndexExpression> expressions)
{
    ListMultimap<ByteBuffer, Expression> analyzed = ArrayListMultimap.create();

    // sort all of the expressions in the operation by name and priority of the logical operator
    // this gives us an efficient way to handle inequality and combining into ranges without extra processing
    // and converting expressions from one type to another.
    Collections.sort(expressions, new Comparator<IndexExpression>()
    {
        @Override
        public int compare(IndexExpression a, IndexExpression b)
        {
            int cmp = comparator.compare(ByteBuffer.wrap(a.getColumn_name()), ByteBuffer.wrap(b.getColumn_name()));
            return cmp == 0 ? -Integer.compare(getPriority(a.getOp()), getPriority(b.getOp())) : cmp;
        }
    });

    for (final IndexExpression e : expressions)
    {
        if (e.isSetLogicalOp())
            continue;

        ByteBuffer name = ByteBuffer.wrap(e.getColumn_name());
        ColumnIndex columnIndex = controller.getIndex(name);

        List<Expression> perColumn = analyzed.get(name);

        if (columnIndex == null)
        {
            ColumnDefinition nonIndexedColumn = controller.getColumn(name);
            columnIndex = new ColumnIndex(controller.getKeyValidator(),
                                          nonIndexedColumn,
                                          controller.getComparator(nonIndexedColumn));
        }

        AbstractAnalyzer analyzer = columnIndex.getAnalyzer();
        analyzer.reset(ByteBuffer.wrap(e.getValue()));

        // EQ/NOT_EQ can have multiple expressions e.g. text = "Hello World",
        // becomes text = "Hello" OR text = "World" because "space" is always interpreted as a split point (by analyzer),
        // NOT_EQ is made an independent expression only in case of pre-existing multiple EQ expressions, or
        // if there is no EQ operations and NOT_EQ is met or a single NOT_EQ expression present,
        // in such case we know exactly that there would be no more EQ/RANGE expressions for given column
        // since NOT_EQ has the lowest priority.
        if (e.getOp() == IndexOperator.EQ
                || (e.getOp() == IndexOperator.NOT_EQ
                   && (perColumn.size() == 0 || perColumn.size() > 1
                       || (perColumn.size() == 1 && perColumn.get(0).getOp() == Op.NOT_EQ))))
        {
            while (analyzer.hasNext())
            {
                final ByteBuffer token = analyzer.next();
                perColumn.add(new Expression(controller, columnIndex)
                {{
                        add(e.op, token);
                }});
            }
        }
        else
        // "range" or not-equals operator, combines both bounds together into the single expression,
        // iff operation of the group is AND, otherwise we are forced to create separate expressions,
        // not-equals is combined with the range iff operator is AND.
        {
            Expression range;
            if (perColumn.size() == 0 || op != OperationType.AND)
                perColumn.add((range = new Expression(controller, columnIndex)));
            else
                range = Iterables.getLast(perColumn);

            while (analyzer.hasNext())
                range.add(e.op, analyzer.next());
        }
    }

    return analyzed;
}