/*
* 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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import com.google.common.base.Joiner;
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.TokenRestriction;
import org.apache.cassandra.cql3.statements.Bound;
import org.apache.cassandra.exceptions.InvalidRequestException;
import static org.apache.cassandra.cql3.statements.RequestValidations.checkContainsNoDuplicates;
import static org.apache.cassandra.cql3.statements.RequestValidations.checkContainsOnly;
import static org.apache.cassandra.cql3.statements.RequestValidations.checkTrue;
import static org.apache.cassandra.cql3.statements.RequestValidations.invalidRequest;
/**
* A relation using the token function.
* Examples:
* <ul>
* <li>SELECT ... WHERE token(a) > token(1)</li>
* <li>SELECT ... WHERE token(a, b) > token(1, 3)</li>
* </ul>
*/
public final class TokenRelation extends Relation
{
private final List<ColumnIdentifier.Raw> entities;
private final Term.Raw value;
public TokenRelation(List<ColumnIdentifier.Raw> entities, Operator type, Term.Raw value)
{
this.entities = entities;
this.relationType = type;
this.value = value;
}
@Override
public boolean onToken()
{
return true;
}
public Term.Raw getValue()
{
return value;
}
public List<? extends Term.Raw> getInValues()
{
return null;
}
@Override
protected Restriction newEQRestriction(CFMetaData cfm, VariableSpecifications boundNames) throws InvalidRequestException
{
List<ColumnDefinition> columnDefs = getColumnDefinitions(cfm);
Term term = toTerm(toReceivers(cfm, columnDefs), value, cfm.ksName, boundNames);
return new TokenRestriction.EQRestriction(cfm, columnDefs, term);
}
@Override
protected Restriction newINRestriction(CFMetaData cfm, VariableSpecifications boundNames) throws InvalidRequestException
{
throw invalidRequest("%s cannot be used with the token function", operator());
}
@Override
protected Restriction newSliceRestriction(CFMetaData cfm,
VariableSpecifications boundNames,
Bound bound,
boolean inclusive) throws InvalidRequestException
{
List<ColumnDefinition> columnDefs = getColumnDefinitions(cfm);
Term term = toTerm(toReceivers(cfm, columnDefs), value, cfm.ksName, boundNames);
return new TokenRestriction.SliceRestriction(cfm, columnDefs, bound, inclusive, term);
}
@Override
protected Restriction newContainsRestriction(CFMetaData cfm, VariableSpecifications boundNames, boolean isKey) throws InvalidRequestException
{
throw invalidRequest("%s cannot be used with the token function", operator());
}
@Override
protected Restriction newIsNotRestriction(CFMetaData cfm, VariableSpecifications boundNames) throws InvalidRequestException
{
throw invalidRequest("%s cannot be used with the token function", operator());
}
@Override
protected Term toTerm(List<? extends ColumnSpecification> receivers,
Raw raw,
String keyspace,
VariableSpecifications boundNames) throws InvalidRequestException
{
Term term = raw.prepare(keyspace, receivers.get(0));
term.collectMarkerSpecification(boundNames);
return term;
}
public Relation renameIdentifier(ColumnIdentifier.Raw from, ColumnIdentifier.Raw to)
{
if (!entities.contains(from))
return this;
List<ColumnIdentifier.Raw> newEntities = entities.stream().map(e -> e.equals(from) ? to : e).collect(Collectors.toList());
return new TokenRelation(newEntities, operator(), value);
}
@Override
public String toString()
{
return String.format("token%s %s %s", Tuples.tupleToString(entities), relationType, value);
}
/**
* Returns the definition of the columns to which apply the token restriction.
*
* @param cfm the column family metadata
* @return the definition of the columns to which apply the token restriction.
* @throws InvalidRequestException if the entity cannot be resolved
*/
private List<ColumnDefinition> getColumnDefinitions(CFMetaData cfm) throws InvalidRequestException
{
List<ColumnDefinition> columnDefs = new ArrayList<>();
for ( ColumnIdentifier.Raw raw : entities)
{
columnDefs.add(toColumnDefinition(cfm, raw));
}
return columnDefs;
}
/**
* Returns the receivers for this relation.
*
* @param cfm the Column Family meta data
* @param columnDefs the column definitions
* @return the receivers for the specified relation.
* @throws InvalidRequestException if the relation is invalid
*/
private static List<? extends ColumnSpecification> toReceivers(CFMetaData cfm,
List<ColumnDefinition> columnDefs)
throws InvalidRequestException
{
if (!columnDefs.equals(cfm.partitionKeyColumns()))
{
checkTrue(columnDefs.containsAll(cfm.partitionKeyColumns()),
"The token() function must be applied to all partition key components or none of them");
checkContainsNoDuplicates(columnDefs, "The token() function contains duplicate partition key components");
checkContainsOnly(columnDefs, cfm.partitionKeyColumns(), "The token() function must contains only partition key components");
throw invalidRequest("The token function arguments must be in the partition key order: %s",
Joiner.on(", ").join(ColumnDefinition.toIdentifiers(cfm.partitionKeyColumns())));
}
ColumnDefinition firstColumn = columnDefs.get(0);
return Collections.singletonList(new ColumnSpecification(firstColumn.ksName,
firstColumn.cfName,
new ColumnIdentifier("partition key token", true),
cfm.partitioner.getTokenValidator()));
}
}