org.apache.cassandra.cql3.SingleColumnRelation Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-unit-shaded Show documentation
Show all versions of cassandra-unit-shaded Show documentation
Shaded version of cassandra-unit
/*
* 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;
import java.util.Collections;
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.Term.Raw;
import org.apache.cassandra.cql3.restrictions.Restriction;
import org.apache.cassandra.cql3.restrictions.SingleColumnRestriction;
import org.apache.cassandra.cql3.statements.Bound;
import org.apache.cassandra.db.marshal.CollectionType;
import org.apache.cassandra.db.marshal.ListType;
import org.apache.cassandra.db.marshal.MapType;
import org.apache.cassandra.exceptions.InvalidRequestException;
import static org.apache.cassandra.cql3.statements.RequestValidations.checkFalse;
import static org.apache.cassandra.cql3.statements.RequestValidations.checkTrue;
import static org.apache.cassandra.cql3.statements.RequestValidations.invalidRequest;
/**
* Relations encapsulate the relationship between an entity of some kind, and
* a value (term). For example, {@code > "start" or "colname1" = "somevalue"}.
*
*/
public class SingleColumnRelation extends Relation
{
private final ColumnDefinition.Raw entity;
private final Term.Raw mapKey;
private final Term.Raw value;
private final List inValues;
private SingleColumnRelation(ColumnDefinition.Raw entity, Term.Raw mapKey, Operator type, Term.Raw value, List inValues)
{
this.entity = entity;
this.mapKey = mapKey;
this.relationType = type;
this.value = value;
this.inValues = inValues;
if (type == Operator.IS_NOT)
assert value == Constants.NULL_LITERAL;
}
/**
* Creates a new relation.
*
* @param entity the kind of relation this is; what the term is being compared to.
* @param mapKey the key into the entity identifying the value the term is being compared to.
* @param type the type that describes how this entity relates to the value.
* @param value the value being compared.
*/
public SingleColumnRelation(ColumnDefinition.Raw entity, Term.Raw mapKey, Operator type, Term.Raw value)
{
this(entity, mapKey, type, value, null);
}
/**
* Creates a new relation.
*
* @param entity the kind of relation this is; what the term is being compared to.
* @param type the type that describes how this entity relates to the value.
* @param value the value being compared.
*/
public SingleColumnRelation(ColumnDefinition.Raw entity, Operator type, Term.Raw value)
{
this(entity, null, type, value);
}
public Term.Raw getValue()
{
return value;
}
public List getInValues()
{
return inValues;
}
public static SingleColumnRelation createInRelation(ColumnDefinition.Raw entity, List inValues)
{
return new SingleColumnRelation(entity, null, Operator.IN, null, inValues);
}
public ColumnDefinition.Raw getEntity()
{
return entity;
}
public Term.Raw getMapKey()
{
return mapKey;
}
@Override
protected Term toTerm(List receivers,
Raw raw,
String keyspace,
VariableSpecifications boundNames)
throws InvalidRequestException
{
assert receivers.size() == 1;
Term term = raw.prepare(keyspace, receivers.get(0));
term.collectMarkerSpecification(boundNames);
return term;
}
public SingleColumnRelation withNonStrictOperator()
{
switch (relationType)
{
case GT: return new SingleColumnRelation(entity, Operator.GTE, value);
case LT: return new SingleColumnRelation(entity, Operator.LTE, value);
default: return this;
}
}
public Relation renameIdentifier(ColumnDefinition.Raw from, ColumnDefinition.Raw to)
{
return entity.equals(from)
? new SingleColumnRelation(to, mapKey, operator(), value, inValues)
: this;
}
@Override
public String toString()
{
String entityAsString = entity.toString();
if (mapKey != null)
entityAsString = String.format("%s[%s]", entityAsString, mapKey);
if (isIN())
return String.format("%s IN %s", entityAsString, inValues);
return String.format("%s %s %s", entityAsString, relationType, value);
}
@Override
protected Restriction newEQRestriction(CFMetaData cfm,
VariableSpecifications boundNames) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
if (mapKey == null)
{
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.EQRestriction(columnDef, term);
}
List receivers = toReceivers(columnDef);
Term entryKey = toTerm(Collections.singletonList(receivers.get(0)), mapKey, cfm.ksName, boundNames);
Term entryValue = toTerm(Collections.singletonList(receivers.get(1)), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.ContainsRestriction(columnDef, entryKey, entryValue);
}
@Override
protected Restriction newINRestriction(CFMetaData cfm,
VariableSpecifications boundNames) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
List receivers = toReceivers(columnDef);
List terms = toTerms(receivers, inValues, cfm.ksName, boundNames);
if (terms == null)
{
Term term = toTerm(receivers, value, cfm.ksName, boundNames);
return new SingleColumnRestriction.InRestrictionWithMarker(columnDef, (Lists.Marker) term);
}
// An IN restrictions with only one element is the same than an EQ restriction
if (terms.size() == 1)
return new SingleColumnRestriction.EQRestriction(columnDef, terms.get(0));
return new SingleColumnRestriction.InRestrictionWithValues(columnDef, terms);
}
@Override
protected Restriction newSliceRestriction(CFMetaData cfm,
VariableSpecifications boundNames,
Bound bound,
boolean inclusive) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
if (columnDef.type.referencesDuration())
{
checkFalse(columnDef.type.isCollection(), "Slice restrictions are not supported on collections containing durations");
checkFalse(columnDef.type.isTuple(), "Slice restrictions are not supported on tuples containing durations");
checkFalse(columnDef.type.isUDT(), "Slice restrictions are not supported on UDTs containing durations");
throw invalidRequest("Slice restrictions are not supported on duration columns");
}
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.SliceRestriction(columnDef, bound, inclusive, term);
}
@Override
protected Restriction newContainsRestriction(CFMetaData cfm,
VariableSpecifications boundNames,
boolean isKey) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.ContainsRestriction(columnDef, term, isKey);
}
@Override
protected Restriction newIsNotRestriction(CFMetaData cfm,
VariableSpecifications boundNames) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
// currently enforced by the grammar
assert value == Constants.NULL_LITERAL : "Expected null literal for IS NOT relation: " + this.toString();
return new SingleColumnRestriction.IsNotNullRestriction(columnDef);
}
@Override
protected Restriction newLikeRestriction(CFMetaData cfm, VariableSpecifications boundNames, Operator operator) throws InvalidRequestException
{
if (mapKey != null)
throw invalidRequest("%s can't be used with collections.", operator());
ColumnDefinition columnDef = entity.prepare(cfm);
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.LikeRestriction(columnDef, operator, term);
}
/**
* Returns the receivers for this relation.
* @param columnDef the column definition
* @return the receivers for the specified relation.
* @throws InvalidRequestException if the relation is invalid
*/
private List toReceivers(ColumnDefinition columnDef) throws InvalidRequestException
{
ColumnSpecification receiver = columnDef;
if (isIN())
{
// We only allow IN on the row key and the clustering key so far, never on non-PK columns, and this even if
// there's an index
// Note: for backward compatibility reason, we conside a IN of 1 value the same as a EQ, so we let that
// slide.
checkFalse(!columnDef.isPrimaryKeyColumn() && !canHaveOnlyOneValue(),
"IN predicates on non-primary-key columns (%s) is not yet supported", columnDef.name);
}
checkFalse(isContainsKey() && !(receiver.type instanceof MapType), "Cannot use CONTAINS KEY on non-map column %s", receiver.name);
checkFalse(isContains() && !(receiver.type.isCollection()), "Cannot use CONTAINS on non-collection column %s", receiver.name);
if (mapKey != null)
{
checkFalse(receiver.type instanceof ListType, "Indexes on list entries (%s[index] = value) are not currently supported.", receiver.name);
checkTrue(receiver.type instanceof MapType, "Column %s cannot be used as a map", receiver.name);
checkTrue(receiver.type.isMultiCell(), "Map-entry equality predicates on frozen map column %s are not supported", receiver.name);
checkTrue(isEQ(), "Only EQ relations are supported on map entries");
}
// Non-frozen UDTs don't support any operator
checkFalse(receiver.type.isUDT() && receiver.type.isMultiCell(),
"Non-frozen UDT column '%s' (%s) cannot be restricted by any relation",
receiver.name,
receiver.type.asCQL3Type());
if (receiver.type.isCollection())
{
// We don't support relations against entire collections (unless they're frozen), like "numbers = {1, 2, 3}"
checkFalse(receiver.type.isMultiCell() && !isLegalRelationForNonFrozenCollection(),
"Collection column '%s' (%s) cannot be restricted by a '%s' relation",
receiver.name,
receiver.type.asCQL3Type(),
operator());
if (isContainsKey() || isContains())
{
receiver = makeCollectionReceiver(receiver, isContainsKey());
}
else if (receiver.type.isMultiCell() && mapKey != null && isEQ())
{
List receivers = new ArrayList<>(2);
receivers.add(makeCollectionReceiver(receiver, true));
receivers.add(makeCollectionReceiver(receiver, false));
return receivers;
}
}
return Collections.singletonList(receiver);
}
private static ColumnSpecification makeCollectionReceiver(ColumnSpecification receiver, boolean forKey)
{
return ((CollectionType) receiver.type).makeCollectionReceiver(receiver, forKey);
}
private boolean isLegalRelationForNonFrozenCollection()
{
return isContainsKey() || isContains() || isMapEntryEquality();
}
private boolean isMapEntryEquality()
{
return mapKey != null && isEQ();
}
private boolean canHaveOnlyOneValue()
{
return isEQ() || isLIKE() || (isIN() && inValues != null && inValues.size() == 1);
}
@Override
public Relation toSuperColumnAdapter()
{
return new SuperColumnSingleColumnRelation(entity, mapKey, relationType, value);
}
/**
* Required for SuperColumn compatibility, in order to map the SuperColumn key restrictions from the regular
* column to the collection key one.
*/
private class SuperColumnSingleColumnRelation extends SingleColumnRelation
{
SuperColumnSingleColumnRelation(ColumnDefinition.Raw entity, Raw mapKey, Operator type, Raw value)
{
super(entity, mapKey, type, value, inValues);
}
@Override
public Restriction newSliceRestriction(CFMetaData cfm,
VariableSpecifications boundNames,
Bound bound,
boolean inclusive) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
if (cfm.isSuperColumnKeyColumn(columnDef))
{
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.SuperColumnKeySliceRestriction(cfm.superColumnKeyColumn(), bound, inclusive, term);
}
else
{
return super.newSliceRestriction(cfm, boundNames, bound, inclusive);
}
}
@Override
protected Restriction newEQRestriction(CFMetaData cfm,
VariableSpecifications boundNames) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
if (cfm.isSuperColumnKeyColumn(columnDef))
{
Term term = toTerm(toReceivers(columnDef), value, cfm.ksName, boundNames);
return new SingleColumnRestriction.SuperColumnKeyEQRestriction(cfm.superColumnKeyColumn(), term);
}
else
{
return super.newEQRestriction(cfm, boundNames);
}
}
@Override
protected Restriction newINRestriction(CFMetaData cfm,
VariableSpecifications boundNames) throws InvalidRequestException
{
ColumnDefinition columnDef = entity.prepare(cfm);
if (cfm.isSuperColumnKeyColumn(columnDef))
{
List receivers = Collections.singletonList(cfm.superColumnKeyColumn());
List terms = toTerms(receivers, inValues, cfm.ksName, boundNames);
if (terms == null)
{
Term term = toTerm(receivers, value, cfm.ksName, boundNames);
return new SingleColumnRestriction.SuperColumnKeyINRestrictionWithMarkers(cfm.superColumnKeyColumn(), (Lists.Marker) term);
}
return new SingleColumnRestriction.SuperColumnKeyINRestrictionWithValues(cfm.superColumnKeyColumn(), terms);
}
else
{
return super.newINRestriction(cfm, boundNames);
}
}
}
}