public void validate(ClientState state) throws RequestValidationException {
ThriftValidation.validateColumnFamily(keyspace(), columnFamily());
try {
TriggerExecutor.instance.loadTriggerInstance(triggerClass);
} catch (Exception e) {
throw new ConfigurationException(
String.format("Trigger class '%s' doesn't exist", triggerClass));
}
}
public static void validateColumnOrSuperColumn(
String keyspace, String cfName, ColumnOrSuperColumn cosc) throws InvalidRequestException {
if (cosc.column != null) {
validateTtl(cosc.column);
ThriftValidation.validateColumnPath(
keyspace,
new ColumnPath(cfName).setSuper_column((ByteBuffer) null).setColumn(cosc.column.name));
}
if (cosc.super_column != null) {
for (Column c : cosc.super_column.columns) {
validateTtl(c);
ThriftValidation.validateColumnPath(
keyspace,
new ColumnPath(cfName).setSuper_column(cosc.super_column.name).setColumn(c.name));
}
}
if (cosc.column == null && cosc.super_column == null)
throw new InvalidRequestException(
"ColumnOrSuperColumn must have one or both of Column or SuperColumn");
}
public ParsedStatement.Prepared prepare(ColumnSpecification[] boundNames)
throws InvalidRequestException {
CFMetaData metadata = ThriftValidation.validateColumnFamily(keyspace(), columnFamily());
type = metadata.getDefaultValidator().isCommutative() ? Type.COUNTER : Type.LOGGED;
cfDef = metadata.getCfDef();
UpdateStatement.processKeys(cfDef, whereClause, processedKeys, boundNames);
for (Selector column : columns) {
CFDefinition.Name name = cfDef.get(column.id());
if (name == null)
throw new InvalidRequestException(String.format("Unknown identifier %s", column));
// For compact, we only have one value except the key, so the only form of DELETE that make
// sense is without a column
// list. However, we support having the value name for coherence with the static/sparse case
if (name.kind != CFDefinition.Name.Kind.COLUMN_METADATA
&& name.kind != CFDefinition.Name.Kind.VALUE_ALIAS)
throw new InvalidRequestException(
String.format(
"Invalid identifier %s for deletion (should not be a PRIMARY KEY part)", column));
if (column.key() != null) {
if (name.type instanceof ListType) {
if (column.key().isBindMarker())
boundNames[column.key().bindIndex] = ListOperation.indexSpecOf(name);
} else if (name.type instanceof MapType) {
if (column.key().isBindMarker())
boundNames[column.key().bindIndex] = MapOperation.keySpecOf(name, (MapType) name.type);
} else {
throw new InvalidRequestException(
String.format(
"Invalid selection %s since %s is neither a list or a map", column, column.id()));
}
}
toRemove.add(Pair.create(name, column.key()));
}
return new ParsedStatement.Prepared(this, Arrays.<ColumnSpecification>asList(boundNames));
}
public void validate(ClientState state) throws InvalidRequestException {
ThriftValidation.validateColumnFamily(keyspace(), columnFamily());
}
public void validate(ClientState state) throws RequestValidationException {
CFMetaData cfm = ThriftValidation.validateColumnFamily(keyspace(), columnFamily());
if (cfm.isCounter())
throw new InvalidRequestException("Secondary indexes are not supported on counter tables");
IndexTarget target = rawTarget.prepare(cfm);
ColumnDefinition cd = cfm.getColumnDefinition(target.column);
if (cd == null)
throw new InvalidRequestException("No column definition found for column " + target.column);
boolean isMap = cd.type instanceof MapType;
boolean isFrozenCollection = cd.type.isCollection() && !cd.type.isMultiCell();
if (target.isCollectionKeys) {
if (!isMap)
throw new InvalidRequestException(
"Cannot create index on keys of column " + target + " with non-map type");
if (!cd.type.isMultiCell())
throw new InvalidRequestException(
"Cannot create index on keys of frozen<map> column " + target);
} else if (target.isFullCollection) {
if (!isFrozenCollection)
throw new InvalidRequestException(
"full() indexes can only be created on frozen collections");
} else if (isFrozenCollection) {
throw new InvalidRequestException(
"Frozen collections currently only support full-collection indexes. "
+ "For example, 'CREATE INDEX ON <table>(full(<columnName>))'.");
}
if (cd.getIndexType() != null) {
boolean previousIsKeys = cd.hasIndexOption(SecondaryIndex.INDEX_KEYS_OPTION_NAME);
if (isMap && target.isCollectionKeys != previousIsKeys) {
String msg =
"Cannot create index on %s %s, an index on %s %s already exists and indexing "
+ "a map on both keys and values at the same time is not currently supported";
throw new InvalidRequestException(
String.format(
msg,
target.column,
target.isCollectionKeys ? "keys" : "values",
target.column,
previousIsKeys ? "keys" : "values"));
}
if (ifNotExists) return;
else throw new InvalidRequestException("Index already exists");
}
properties.validate();
// TODO: we could lift that limitation
if ((cfm.comparator.isDense() || !cfm.comparator.isCompound())
&& cd.kind != ColumnDefinition.Kind.REGULAR)
throw new InvalidRequestException(
"Secondary indexes are not supported on PRIMARY KEY columns in COMPACT STORAGE tables");
// It would be possible to support 2ndary index on static columns (but not without modifications
// of at least ExtendedFilter and
// CompositesIndex) and maybe we should, but that means a query like:
// SELECT * FROM foo WHERE static_column = 'bar'
// would pull the full partition every time the static column of partition is 'bar', which
// sounds like offering a
// fair potential for foot-shooting, so I prefer leaving that to a follow up ticket once we have
// identified cases where
// such indexing is actually useful.
if (cd.isStatic())
throw new InvalidRequestException("Secondary indexes are not allowed on static columns");
if (cd.kind == ColumnDefinition.Kind.PARTITION_KEY && cd.isOnAllComponents())
throw new InvalidRequestException(
String.format("Cannot create secondary index on partition key column %s", target.column));
}
