From b33a47a83efb24402e09c8b4408cfc736b7b0473 Mon Sep 17 00:00:00 2001 From: Stefan Miklosovic Date: Fri, 21 Mar 2025 19:18:33 +0100 Subject: [PATCH 1/4] wip --- src/antlr/Parser.g | 33 +++++++- .../AbstractFunctionConstraint.java | 4 +- .../cql3/constraints/ColumnConstraint.java | 4 +- .../cql3/constraints/ColumnConstraints.java | 29 +++++-- .../cql3/constraints/ConstraintFunction.java | 59 +++++++++++++- .../cql3/constraints/Enumeration.java | 80 +++++++++++++++++++ .../constraints/FunctionColumnConstraint.java | 69 +++++++++------- .../cql3/constraints/JsonConstraint.java | 5 +- .../cql3/constraints/LengthConstraint.java | 5 +- .../cql3/constraints/NotNullConstraint.java | 12 ++- .../constraints/OctetLengthConstraint.java | 5 +- .../cql3/constraints/RegexpConstraint.java | 6 +- .../constraints/ScalarColumnConstraint.java | 14 ++-- .../constraints/UnaryConstraintFunction.java | 5 +- .../UnaryFunctionColumnConstraint.java | 79 +++++++++++------- .../schema/AlterTableStatement.java | 4 + .../schema/CreateTableStatement.java | 6 +- .../cassandra/schema/ColumnMetadata.java | 1 + .../ConstraintsSatisfiabilityTest.java | 11 ++- .../constraints/JsonConstraintTest.java | 2 +- .../constraints/NotNullConstraintTest.java | 4 +- .../constraints/RegexpConstraintTest.java | 8 +- 22 files changed, 340 insertions(+), 105 deletions(-) create mode 100644 src/java/org/apache/cassandra/cql3/constraints/Enumeration.java diff --git a/src/antlr/Parser.g b/src/antlr/Parser.g index b3fb490dcaf0..37a217b95ab9 100644 --- a/src/antlr/Parser.g +++ b/src/antlr/Parser.g @@ -982,9 +982,30 @@ columnConstraints returns [ColumnConstraints.Raw constraints] ; columnConstraint returns [ColumnConstraint columnConstraint] - : funcName=ident '(' k=ident ')' op=relationType t=value { $columnConstraint = new FunctionColumnConstraint.Raw(funcName, k, op, t.getText()).prepare(); } - | funcName=ident '(' k=ident ')' { $columnConstraint = new UnaryFunctionColumnConstraint.Raw(funcName, k).prepare(); } - | k=ident op=relationType t=value { $columnConstraint = new ScalarColumnConstraint.Raw(k, op, t.getText()).prepare(); } + @init { List arguments = new ArrayList<>(); } + : K_NOT K_NULL + { + $columnConstraint = new UnaryFunctionColumnConstraint.Raw("NOT_NULL").prepare(); + } + | funcName=ident columnConstraintsArguments[arguments] (op=relationType t=value)? + { + if (op != null && t != null) + { + $columnConstraint = new FunctionColumnConstraint.Raw(funcName, arguments, op, t.getText()).prepare(); + } + else + { + $columnConstraint = new UnaryFunctionColumnConstraint.Raw(funcName, arguments).prepare(); + } + } + | k=ident op=relationType t=value + { + $columnConstraint = new ScalarColumnConstraint.Raw(k, op, t.getText()).prepare(); + } + | funcName=ident + { + $columnConstraint = new UnaryFunctionColumnConstraint.Raw(funcName).prepare(); + } ; columnMask returns [ColumnMask.Raw mask] @@ -997,6 +1018,12 @@ columnMaskArguments[List arguments] : '(' ')' | '(' c=term { arguments.add(c); } (',' cn=term { arguments.add(cn); })* ')' ; +columnConstraintsArguments[List arguments] + : '(' ')' + | '(' c=term { try { arguments.add(c.toString()); } catch (Throwable t) { throw new SyntaxException("Constraint function parameters need to be strings."); }; } (',' cn=term { try { arguments.add(cn.toString()); } catch (Throwable t) { throw new SyntaxException("Constraint function parameters need to be strings."); }; })* ')' + | '(' ci=ident { throw new SyntaxException("Constraint function parameters need to be strings."); } (',' cni=ident)* ')' + ; + tablePartitionKey[CreateTableStatement.Raw stmt] @init {List l = new ArrayList();} @after{ $stmt.setPartitionKeyColumns(l); } diff --git a/src/java/org/apache/cassandra/cql3/constraints/AbstractFunctionConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/AbstractFunctionConstraint.java index 6204b96a212c..2f6805bdef10 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/AbstractFunctionConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/AbstractFunctionConstraint.java @@ -20,7 +20,6 @@ import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.CqlBuilder; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.utils.LocalizeString; @@ -30,9 +29,8 @@ public abstract class AbstractFunctionConstraint extends ColumnConstraint protected final Operator relationType; protected final String term; - public AbstractFunctionConstraint(ColumnIdentifier columnName, Operator relationType, String term) + public AbstractFunctionConstraint(Operator relationType, String term) { - super(columnName); this.relationType = relationType; this.term = term; } diff --git a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraint.java index eecc0b8ecce1..bddea571aa4c 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraint.java @@ -40,9 +40,9 @@ */ public abstract class ColumnConstraint { - protected final ColumnIdentifier columnName; + protected ColumnIdentifier columnName; - public ColumnConstraint(ColumnIdentifier columnName) + public void setColumnName(ColumnIdentifier columnName) { this.columnName = columnName; } diff --git a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java index 21b119522866..9f0c44a29aff 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java @@ -49,10 +49,17 @@ public class ColumnConstraints extends ColumnConstraint public ColumnConstraints(List> constraints) { - super(null); this.constraints = constraints; } + @Override + public void setColumnName(ColumnIdentifier columnName) + { + this.columnName = columnName; + for (ColumnConstraint constraint : constraints) + constraint.setColumnName(columnName); + } + @Override public String name() { @@ -218,18 +225,24 @@ public ColumnConstraints prepare(ColumnIdentifier column) for (ColumnConstraint constraint : constraints) { - if (constraint.columnName != null && !column.equals(constraint.columnName)) - throw new InvalidConstraintDefinitionException(format("Constraint %s was not specified on a column it operates on: %s but on: %s", - constraint, column.toCQLString(), constraint.columnName)); + if (constraint.getConstraintType() == ConstraintType.SCALAR) + { + if (!column.equals(constraint.columnName)) + { + throw new InvalidConstraintDefinitionException(format("Constraint %s was not specified on a column it operates on: %s but on: %s", + constraint, column.toCQLString(), constraint.columnName)); + } + } } - return new ColumnConstraints(constraints); + ColumnConstraints columnConstraints = new ColumnConstraints(constraints); + columnConstraints.setColumnName(column); + return columnConstraints; } } public static class Serializer implements MetadataSerializer { - @Override public void serialize(ColumnConstraints columnConstraint, DataOutputPlus out, Version version) throws IOException { @@ -255,6 +268,10 @@ public ColumnConstraints deserialize(DataInputPlus in, Version version) throws I .deserialize(in, version); columnConstraints.add(constraint); } + + // we are not setting column name here on purpose + // that is deffered in ColumnMetadata's constructor, + // we do not have the access to a column name here anyway return new ColumnConstraints(columnConstraints); } diff --git a/src/java/org/apache/cassandra/cql3/constraints/ConstraintFunction.java b/src/java/org/apache/cassandra/cql3/constraints/ConstraintFunction.java index ad8424c3f563..e7837c74f76a 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ConstraintFunction.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ConstraintFunction.java @@ -19,14 +19,17 @@ package org.apache.cassandra.cql3.constraints; import java.nio.ByteBuffer; +import java.util.ArrayList; import java.util.List; import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; +import org.apache.cassandra.cql3.functions.types.ParseUtils; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.utils.ByteBufferUtil; +import static java.lang.String.format; import static org.apache.cassandra.cql3.Operator.EQ; import static org.apache.cassandra.cql3.Operator.GT; import static org.apache.cassandra.cql3.Operator.GTE; @@ -41,13 +44,22 @@ public abstract class ConstraintFunction { public static final List DEFAULT_FUNCTION_OPERATORS = List.of(EQ, NEQ, GTE, GT, LTE, LT); - protected final ColumnIdentifier columnName; + protected ColumnIdentifier columnName; protected final String name; + protected final List args; + // args as propagated from cql + protected final List rawArgs; - public ConstraintFunction(ColumnIdentifier columnName, String name) + public ConstraintFunction(String name, List args) { - this.columnName = columnName; this.name = name; + this.rawArgs = args; + this.args = unquote(args); + } + + public List arguments() + { + return args; } /** @@ -84,6 +96,7 @@ public void evaluate(AbstractType valueType, ByteBuffer columnValue) throws C */ public void validate(ColumnMetadata columnMetadata, String term) throws InvalidConstraintDefinitionException { + maybeThrowOnNonEmptyArguments(name); } /** @@ -100,4 +113,44 @@ public void validate(ColumnMetadata columnMetadata, String term) throws InvalidC * @return supported types for given constraint */ public abstract List> getSupportedTypes(); + + /** + * Tells whether implementation supports specifying arguments on its function. + *
+ * In this case, this function will return "true" + * 
+     *     val int check length() < 1024
+     *
+ * + * In this case, this function will return "false" + * 
+     *     val int check someconstraint('abc', 'def')
+     *
+ * @return true if this constraint does not accept any parameters, false otherwise. + */ + public boolean isParameterless() { return true; } + + @Override + public String toString() + { + return name; + } + + protected void maybeThrowOnNonEmptyArguments(String constraintName) + { + if (!isParameterless()) + return; + + if (args != null && !args.isEmpty()) + throw new InvalidConstraintDefinitionException(format("Constraint %s does not accept any arguments.", constraintName)); + } + + private List unquote(List quotedArgs) + { + List unquotedArgs = new ArrayList<>(); + for (String quotedArg : quotedArgs) + unquotedArgs.add(ParseUtils.unquote(quotedArg)); + + return unquotedArgs; + } } diff --git a/src/java/org/apache/cassandra/cql3/constraints/Enumeration.java b/src/java/org/apache/cassandra/cql3/constraints/Enumeration.java new file mode 100644 index 000000000000..8ec21a9676b5 --- /dev/null +++ b/src/java/org/apache/cassandra/cql3/constraints/Enumeration.java @@ -0,0 +1,80 @@ +/* + * 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.constraints; + +import java.nio.ByteBuffer; +import java.util.List; + +import org.apache.cassandra.cql3.Operator; +import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.AsciiType; +import org.apache.cassandra.db.marshal.UTF8Type; + +import static java.lang.String.format; + +// TODO DO NOT COMMIT +public class Enumeration extends UnaryConstraintFunction +{ + private static final List> SUPPORTED_TYPES = List.of(UTF8Type.instance, AsciiType.instance); + + public static final String FUNCTION_NAME = "ENUM"; + + public Enumeration(List args) + { + super(FUNCTION_NAME, args); + } + + @Override + public void internalEvaluate(AbstractType valueType, Operator relationType, String term, ByteBuffer columnValue) + { + if (!args.contains(valueType.getString(columnValue))) + { + throw new ConstraintViolationException(format("Value for column '%s' violated %s constraint as its value is not one of %s.", + columnName.toCQLString(), + name, + args)); + } + } + + @Override + public List> getSupportedTypes() + { + return SUPPORTED_TYPES; + } + + @Override + public boolean isParameterless() + { + return false; + } + + @Override + public boolean equals(Object o) + { + if (this == o) + return true; + + if (!(o instanceof Enumeration)) + return false; + + Enumeration other = (Enumeration) o; + + return columnName.equals(other.columnName) && name.equals(other.name); + } +} diff --git a/src/java/org/apache/cassandra/cql3/constraints/FunctionColumnConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/FunctionColumnConstraint.java index a94b4bd0bdcb..a25553bd7bbc 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/FunctionColumnConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/FunctionColumnConstraint.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.nio.ByteBuffer; +import java.util.ArrayList; import java.util.List; import java.util.function.Function; @@ -45,21 +46,21 @@ public class FunctionColumnConstraint extends AbstractFunctionConstraint arguments, Operator relationType, String term) { this.relationType = relationType; - this.columnName = columnName; this.term = term; - function = createConstraintFunction(functionName.toCQLString(), columnName); + if (arguments == null) + arguments = new ArrayList<>(); + function = createConstraintFunction(functionName.toCQLString(), arguments); } public FunctionColumnConstraint prepare() { - return new FunctionColumnConstraint(function, columnName, relationType, term); + return new FunctionColumnConstraint(function, relationType, term); } } @@ -81,23 +82,31 @@ public enum Functions OCTET_LENGTH(OctetLengthConstraint::new), REGEXP(RegexpConstraint::new); - private final Function functionCreator; + private final Function, ConstraintFunction> functionCreator; - Functions(Function functionCreator) + Functions(Function, ConstraintFunction> functionCreator) { this.functionCreator = functionCreator; } } - private static ConstraintFunction createConstraintFunction(String functionName, ColumnIdentifier columnName) + private static ConstraintFunction createConstraintFunction(String functionName, List args) { - return getEnum(Functions.class, functionName).functionCreator.apply(columnName); + return getEnum(Functions.class, functionName).functionCreator.apply(args); } - private FunctionColumnConstraint(ConstraintFunction function, ColumnIdentifier columnName, Operator relationType, String term) + private FunctionColumnConstraint(ConstraintFunction function, Operator relationType, String term) { - super(columnName, relationType, term); + super(relationType, term); this.function = function; + this.columnName = function.columnName; + } + + @Override + public void setColumnName(ColumnIdentifier columnName) + { + this.columnName = columnName; + this.function.columnName = columnName; } public ConstraintFunction function() @@ -156,7 +165,6 @@ protected void internalEvaluate(AbstractType valueType, ByteBuffer columnValu @Override public void validate(ColumnMetadata columnMetadata) { - validateArgs(columnMetadata); validateTypes(columnMetadata); function.validate(columnMetadata, term); } @@ -167,18 +175,11 @@ public ConstraintType getConstraintType() return ConstraintType.FUNCTION; } - void validateArgs(ColumnMetadata columnMetadata) - { - if (!columnMetadata.name.equals(columnName)) - throw new InvalidConstraintDefinitionException(String.format("Parameter of %s constraint should be the column name (%s)", - name(), - columnMetadata.name)); - } - @Override public String toString() { - return function.name + "(" + columnName + ") " + relationType + " " + term; + String arguments = String.join(",", function.rawArgs); + return function.name + '(' + arguments + ") " + relationType + ' ' + term; } public static class Serializer implements MetadataSerializer @@ -187,7 +188,12 @@ public static class Serializer implements MetadataSerializer args = new ArrayList<>(); + int argsSize = in.readInt(); + for (int i = 0; i < argsSize; i++) + args.add(in.readUTF()); + ConstraintFunction function; - String columnNameString = in.readUTF(); - ColumnIdentifier columnName = new ColumnIdentifier(columnNameString, true); try { - function = createConstraintFunction(functionName, columnName); + function = createConstraintFunction(functionName, args); } catch (Exception e) { @@ -209,14 +219,19 @@ public FunctionColumnConstraint deserialize(DataInputPlus in, Version version) t } Operator relationType = Operator.readFrom(in); final String term = in.readUTF(); - return new FunctionColumnConstraint(function, columnName, relationType, term); + return new FunctionColumnConstraint(function, relationType, term); } @Override public long serializedSize(FunctionColumnConstraint columnConstraint, Version version) { + int argsSizes = 0; + for (String arg : columnConstraint.function.args) + argsSizes += TypeSizes.sizeof(arg); + return TypeSizes.sizeof(columnConstraint.function.getClass().getName()) - + TypeSizes.sizeof(columnConstraint.columnName.toCQLString()) + + TypeSizes.sizeof(columnConstraint.function.args.size()) + + argsSizes + TypeSizes.sizeof(columnConstraint.term) + Operator.serializedSize(); } diff --git a/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java index 95fbac5b3c0a..510d4d1555ce 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java @@ -21,7 +21,6 @@ import java.nio.ByteBuffer; import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.db.marshal.AsciiType; @@ -37,9 +36,9 @@ public class JsonConstraint extends UnaryConstraintFunction public static final String FUNCTION_NAME = "JSON"; - public JsonConstraint(ColumnIdentifier columnName) + public JsonConstraint(List args) { - super(columnName, FUNCTION_NAME); + super(FUNCTION_NAME, args); } @Override diff --git a/src/java/org/apache/cassandra/cql3/constraints/LengthConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/LengthConstraint.java index 49954c28fb93..59d78afcaa39 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/LengthConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/LengthConstraint.java @@ -21,7 +21,6 @@ import java.nio.ByteBuffer; import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.db.marshal.AsciiType; @@ -35,9 +34,9 @@ public class LengthConstraint extends ConstraintFunction private static final String NAME = "LENGTH"; private static final List> SUPPORTED_TYPES = List.of(BytesType.instance, UTF8Type.instance, AsciiType.instance); - public LengthConstraint(ColumnIdentifier columnName) + public LengthConstraint(List args) { - super(columnName, NAME); + super(NAME, args); } @Override diff --git a/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java index af79086701f0..a28e8c21a8ec 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java @@ -21,7 +21,6 @@ import java.nio.ByteBuffer; import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.schema.ColumnMetadata; @@ -32,9 +31,9 @@ public class NotNullConstraint extends UnaryConstraintFunction { public static final String FUNCTION_NAME = "NOT_NULL"; - public NotNullConstraint(ColumnIdentifier columnName) + public NotNullConstraint(List args) { - super(columnName, FUNCTION_NAME); + super(FUNCTION_NAME, args); } @Override @@ -46,6 +45,7 @@ public void internalEvaluate(AbstractType valueType, Operator relationType, S @Override public void validate(ColumnMetadata columnMetadata, String term) throws InvalidConstraintDefinitionException { + super.validate(columnMetadata, term); if (columnMetadata.isPrimaryKeyColumn()) throw new InvalidConstraintDefinitionException(format("%s constraint can not be specified on a %s key column '%s'", name, @@ -59,6 +59,12 @@ public List> getSupportedTypes() return null; } + @Override + public String toString() + { + return "NOT NULL"; + } + @Override public boolean equals(Object o) { diff --git a/src/java/org/apache/cassandra/cql3/constraints/OctetLengthConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/OctetLengthConstraint.java index 8147d37d62d2..b55b489465c9 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/OctetLengthConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/OctetLengthConstraint.java @@ -21,7 +21,6 @@ import java.nio.ByteBuffer; import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.db.marshal.AsciiType; @@ -34,9 +33,9 @@ public class OctetLengthConstraint extends ConstraintFunction { private static final List> SUPPORTED_TYPES = List.of(BytesType.instance, UTF8Type.instance, AsciiType.instance); - public OctetLengthConstraint(ColumnIdentifier columnName) + public OctetLengthConstraint(List args) { - super(columnName, "OCTET_LENGTH"); + super("OCTET_LENGTH", args); } @Override diff --git a/src/java/org/apache/cassandra/cql3/constraints/RegexpConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/RegexpConstraint.java index a2e439585f05..062a5a1c6a97 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/RegexpConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/RegexpConstraint.java @@ -23,7 +23,6 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; import org.apache.cassandra.cql3.functions.types.ParseUtils; import org.apache.cassandra.db.marshal.AbstractType; @@ -43,9 +42,9 @@ public class RegexpConstraint extends ConstraintFunction private Pattern pattern; - public RegexpConstraint(ColumnIdentifier columnName) + public RegexpConstraint(List args) { - super(columnName, FUNCTION_NAME); + super(FUNCTION_NAME, args); } @Override @@ -84,6 +83,7 @@ public List getSupportedOperators() @Override public void validate(ColumnMetadata columnMetadata, String regexp) throws InvalidConstraintDefinitionException { + super.validate(columnMetadata, regexp); try { // compilation of a regexp every single time upon evaluation is not performance friendly diff --git a/src/java/org/apache/cassandra/cql3/constraints/ScalarColumnConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/ScalarColumnConstraint.java index 80671a6bf39f..f230c6b2d61e 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ScalarColumnConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ScalarColumnConstraint.java @@ -96,10 +96,12 @@ public void checkSatisfiability(List> constraints, ColumnMet } private ByteBuffer value; + private AbstractType returnType; - private ScalarColumnConstraint(ColumnIdentifier param, Operator relationType, String term) + private ScalarColumnConstraint(ColumnIdentifier columnName, Operator relationType, String term) { - super(param, relationType, term); + super(relationType, term); + setColumnName(columnName); } @Override @@ -125,11 +127,13 @@ protected void internalEvaluate(AbstractType valueType, ByteBuffer columnValu @Override public void validate(ColumnMetadata columnMetadata) throws InvalidConstraintDefinitionException { + returnType = columnMetadata.type; + validateTypes(columnMetadata); try { - value = columnMetadata.type.fromString(ParseUtils.unquote(term)); + value = returnType.fromString(ParseUtils.unquote(term)); } catch (Throwable t) { @@ -180,9 +184,9 @@ public void serialize(ScalarColumnConstraint columnConstraint, DataOutputPlus ou @Override public ScalarColumnConstraint deserialize(DataInputPlus in, Version version) throws IOException { - ColumnIdentifier param = new ColumnIdentifier(in.readUTF(), true); + ColumnIdentifier columnName = new ColumnIdentifier(in.readUTF(), true); Operator relationType = Operator.readFrom(in); - return new ScalarColumnConstraint(param, relationType, in.readUTF()); + return new ScalarColumnConstraint(columnName, relationType, in.readUTF()); } @Override diff --git a/src/java/org/apache/cassandra/cql3/constraints/UnaryConstraintFunction.java b/src/java/org/apache/cassandra/cql3/constraints/UnaryConstraintFunction.java index 8696e81a65a7..0e4b0ddd2de9 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/UnaryConstraintFunction.java +++ b/src/java/org/apache/cassandra/cql3/constraints/UnaryConstraintFunction.java @@ -20,14 +20,13 @@ import java.util.List; -import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.Operator; public abstract class UnaryConstraintFunction extends ConstraintFunction { - public UnaryConstraintFunction(ColumnIdentifier columnName, String name) + public UnaryConstraintFunction(String name, List args) { - super(columnName, name); + super(name, args); } public List getSupportedOperators() diff --git a/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java index 80fd443e0e4d..7cfe162dc555 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.nio.ByteBuffer; +import java.util.ArrayList; import java.util.List; import java.util.function.Function; @@ -45,42 +46,59 @@ public class UnaryFunctionColumnConstraint extends AbstractFunctionConstraint arguments) + { + function = createConstraintFunction(functionName.toString(), arguments); + } + + public Raw(ColumnIdentifier functionName) + { + function = createConstraintFunction(functionName.toString(), List.of()); } public UnaryFunctionColumnConstraint prepare() { - return new UnaryFunctionColumnConstraint(function, columnName); + return new UnaryFunctionColumnConstraint(function); } } public enum Functions implements UnaryFunctionSatisfiabilityChecker { NOT_NULL(NotNullConstraint::new), - JSON(JsonConstraint::new); + JSON(JsonConstraint::new), + ENUM(Enumeration::new); // TODO DO NOT COMMIT - private final Function functionCreator; + private final Function, ConstraintFunction> functionCreator; - Functions(Function functionCreator) + Functions(Function, ConstraintFunction> functionCreator) { this.functionCreator = functionCreator; } } - private static ConstraintFunction createConstraintFunction(String functionName, ColumnIdentifier columnName) + private static ConstraintFunction createConstraintFunction(String functionName, List arguments) { - return getEnum(Functions.class, functionName).functionCreator.apply(columnName); + return getEnum(Functions.class, functionName).functionCreator.apply(arguments); } - private UnaryFunctionColumnConstraint(ConstraintFunction function, ColumnIdentifier columnName) + private UnaryFunctionColumnConstraint(ConstraintFunction function) { - super(columnName, null, null); + super(null, null); this.function = function; + this.columnName = function.columnName; + } + + @Override + public void setColumnName(ColumnIdentifier columnName) + { + this.columnName = columnName; + this.function.columnName = columnName; } @Override @@ -122,7 +140,6 @@ public void internalEvaluate(AbstractType valueType, ByteBuffer columnValue) @Override public void validate(ColumnMetadata columnMetadata) throws InvalidConstraintDefinitionException { - validateArgs(columnMetadata); validateTypes(columnMetadata); function.validate(columnMetadata, term); } @@ -133,18 +150,18 @@ public ConstraintType getConstraintType() return UNARY_FUNCTION; } - void validateArgs(ColumnMetadata columnMetadata) - { - if (!columnMetadata.name.equals(columnName)) - throw new InvalidConstraintDefinitionException(String.format("Parameter of %s constraint should be the column name (%s)", - name(), - columnMetadata.name)); - } - @Override public String toString() { - return function.name + "(" + columnName + ")"; + if (function.isParameterless()) + { + return function.toString(); + } + else + { + String arguments = String.join(",", function.rawArgs); + return function.toString() + '(' + arguments + ')'; + } } public static class Serializer implements MetadataSerializer @@ -153,26 +170,34 @@ public static class Serializer implements MetadataSerializer args = new ArrayList<>(); + int argsSize = in.readInt(); + for (int i = 0; i < argsSize; i++) + args.add(in.readUTF()); + ConstraintFunction function; - String columnNameString = in.readUTF(); - ColumnIdentifier columnName = new ColumnIdentifier(columnNameString, true); try { - function = createConstraintFunction(functionName, columnName); + function = createConstraintFunction(functionName, args); } catch (Exception e) { throw new IOException(e); } - return new UnaryFunctionColumnConstraint(function, columnName); + return new UnaryFunctionColumnConstraint(function); } @Override diff --git a/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java b/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java index 0da92dc9df95..c7a57139d129 100644 --- a/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/schema/AlterTableStatement.java @@ -278,6 +278,8 @@ private static class Column this.type = type; this.isStatic = isStatic; this.mask = mask; + if (constraints != null) + constraints.prepare(name); this.constraints = constraints; } } @@ -931,6 +933,8 @@ public void constraint(ColumnIdentifier name, ColumnConstraints.Raw rawConstrain { kind = Kind.ALTER_CONSTRAINTS; this.constraintName = name; + if (rawConstraints != null) + rawConstraints.prepare(constraintName); this.constraints = rawConstraints; } diff --git a/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java b/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java index 2e25291ed873..0a2589b78a04 100644 --- a/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java @@ -613,10 +613,8 @@ public void addColumn(ColumnIdentifier column, CQL3Type.Raw type, boolean isStat if (isStatic) staticColumns.add(column); - if (null == constraints) - columnConstraints.put(column, ColumnConstraints.NO_OP); - else - columnConstraints.put(column, constraints.prepare(column)); + + columnConstraints.put(column, constraints == null ? ColumnConstraints.NO_OP : constraints.prepare(column)); } public void setCompactStorage() diff --git a/src/java/org/apache/cassandra/schema/ColumnMetadata.java b/src/java/org/apache/cassandra/schema/ColumnMetadata.java index fc8cd984c9af..d5e7b23e4060 100644 --- a/src/java/org/apache/cassandra/schema/ColumnMetadata.java +++ b/src/java/org/apache/cassandra/schema/ColumnMetadata.java @@ -269,6 +269,7 @@ public ColumnMetadata(String ksName, this.comparisonOrder = comparisonOrder(kind, isComplex(), Math.max(0, position), name); this.mask = mask; this.columnConstraints = columnConstraints; + this.columnConstraints.setColumnName(name); } private static Comparator makeCellPathComparator(Kind kind, AbstractType type) diff --git a/test/unit/org/apache/cassandra/constraints/ConstraintsSatisfiabilityTest.java b/test/unit/org/apache/cassandra/constraints/ConstraintsSatisfiabilityTest.java index 6f767ca0a45a..c22bb7ea533d 100644 --- a/test/unit/org/apache/cassandra/constraints/ConstraintsSatisfiabilityTest.java +++ b/test/unit/org/apache/cassandra/constraints/ConstraintsSatisfiabilityTest.java @@ -18,6 +18,8 @@ package org.apache.cassandra.constraints; +import java.util.List; + import org.junit.Test; import org.apache.cassandra.cql3.ColumnIdentifier; @@ -101,6 +103,13 @@ else if ((op1 == GT && op2 == LTE) || { check(op1, 50, op2, 100, quadFunction, null, columnMetadata); } + else if ((op1 == GT && op2 == LTE) || + (op1 == GT && op2 == LT) || + (op1 == GTE && op2 == LTE) || + (op1 == GTE && op2 == LT)) + { + check(op1, 0, op2, 100, quadFunction, null, columnMetadata); + } else if (!(op1 == NEQ || op2 == NEQ)) { check(op1, 50, op2, 100, quadFunction, null, columnMetadata); @@ -174,7 +183,7 @@ private ScalarColumnConstraint scalar(Operator operator, Integer term) private FunctionColumnConstraint length(Operator operator, Integer term) { return new FunctionColumnConstraint.Raw(lengthFunctionIdentifier, - columnIdentifier, + List.of(), operator, term.toString()).prepare(); } diff --git a/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java b/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java index 1646d5ed0a15..0fbf4602294d 100644 --- a/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java +++ b/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java @@ -42,7 +42,7 @@ public class JsonConstraintTest private static final ColumnMetadata regularStringColumn = getColumnOfType(UTF8Type.instance); private static final ColumnMetadata regularAsciiColumn = getColumnOfType(AsciiType.instance); - private static final ColumnConstraints json = new ColumnConstraints(of(new Raw(jsonFunctionIdentifier, columnIdentifier).prepare())); + private static final ColumnConstraints json = new ColumnConstraints(of(new Raw(jsonFunctionIdentifier).prepare())); @Test public void testJsonConstraint() throws Throwable diff --git a/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java b/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java index d09d8f83b6fe..2230d1aae0b1 100644 --- a/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java +++ b/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java @@ -54,9 +54,9 @@ public class NotNullConstraintTest { private static final ColumnIdentifier columnIdentifier = new ColumnIdentifier("a_column", false); - private static final ColumnConstraints unaryConstraint = new ColumnConstraints(of(new UnaryFunctionColumnConstraint.Raw(new ColumnIdentifier(NotNullConstraint.FUNCTION_NAME, false), columnIdentifier).prepare())); + private static final ColumnConstraints unaryConstraint = new ColumnConstraints(of(new UnaryFunctionColumnConstraint.Raw(new ColumnIdentifier(NotNullConstraint.FUNCTION_NAME, false), List.of()).prepare())); private static final ColumnConstraints scalarConstraint = new ColumnConstraints(of(new ScalarColumnConstraint.Raw(columnIdentifier, GT, "5").prepare())); - private static final ColumnConstraints functionConstraint = new ColumnConstraints(of(new FunctionColumnConstraint.Raw(new ColumnIdentifier("LENGTH", false), columnIdentifier, GT, "5").prepare())); + private static final ColumnConstraints functionConstraint = new ColumnConstraints(of(new FunctionColumnConstraint.Raw(new ColumnIdentifier("LENGTH", false), List.of(), GT, "5").prepare())); @Test public void testNotNullConstraintValidation() diff --git a/test/unit/org/apache/cassandra/constraints/RegexpConstraintTest.java b/test/unit/org/apache/cassandra/constraints/RegexpConstraintTest.java index 1b93c30baaba..ddbff0c45d1f 100644 --- a/test/unit/org/apache/cassandra/constraints/RegexpConstraintTest.java +++ b/test/unit/org/apache/cassandra/constraints/RegexpConstraintTest.java @@ -18,6 +18,8 @@ package org.apache.cassandra.constraints; +import java.util.List; + import org.junit.Test; import org.apache.cassandra.cql3.ColumnIdentifier; @@ -44,8 +46,8 @@ public class RegexpConstraintTest private static final ColumnMetadata regularStringColumn = getColumnOfType(UTF8Type.instance); private static final ColumnMetadata regularAsciiColumn = getColumnOfType(AsciiType.instance); - private static final ColumnConstraints regexp = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, columnIdentifier, Operator.EQ, "'a..b'").prepare())); - private static final ColumnConstraints negatedRegexp = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, columnIdentifier, Operator.NEQ, "'a..b'").prepare())); + private static final ColumnConstraints regexp = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, List.of(), Operator.EQ, "'a..b'").prepare())); + private static final ColumnConstraints negatedRegexp = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, List.of(), Operator.NEQ, "'a..b'").prepare())); @Test public void testRegexpConstraint() throws Throwable @@ -59,7 +61,7 @@ public void testRegexpConstraint() throws Throwable @Test public void testInvalidPattern() { - ColumnConstraints invalid = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, columnIdentifier, Operator.EQ, "'*abc'").prepare())); + ColumnConstraints invalid = new ColumnConstraints(of(new Raw(regexpFunctionIdentifier, List.of(), Operator.EQ, "'*abc'").prepare())); assertThatThrownBy(() -> invalid.validate(regularStringColumn)) .hasMessage("String '*abc' is not a valid regular expression") .isInstanceOf(InvalidConstraintDefinitionException.class); From 4012d26ec60b3ce95b386b75ca91f1a76f0a3246 Mon Sep 17 00:00:00 2001 From: Stefan Miklosovic Date: Fri, 25 Apr 2025 13:11:00 +0200 Subject: [PATCH 2/4] implement simple not null --- src/antlr/Parser.g | 4 +-- .../cql3/constraints/ColumnConstraints.java | 11 ++++++++ .../cql3/constraints/NotNullConstraint.java | 13 ++++++++-- .../UnaryFunctionColumnConstraint.java | 2 +- .../schema/CreateTableStatement.java | 25 +++++++++++++++++-- 5 files changed, 48 insertions(+), 7 deletions(-) diff --git a/src/antlr/Parser.g b/src/antlr/Parser.g index 37a217b95ab9..649dd7708668 100644 --- a/src/antlr/Parser.g +++ b/src/antlr/Parser.g @@ -967,8 +967,8 @@ tableDefinition[CreateTableStatement.Raw stmt] ; tableColumns[CreateTableStatement.Raw stmt] - @init { boolean isStatic = false; } - : k=ident v=comparatorType (K_STATIC { isStatic = true; })? (mask=columnMask)? (constraints=columnConstraints)? { $stmt.addColumn(k, v, isStatic, mask, constraints); } + @init { boolean isStatic = false; boolean isNotNull = false; } + : k=ident v=comparatorType (K_STATIC { isStatic = true; })? (K_NOT K_NULL { isNotNull = true; })? (mask=columnMask)? (constraints=columnConstraints)? { $stmt.addColumn(k, v, isStatic, isNotNull, mask, constraints); } (K_PRIMARY K_KEY { $stmt.setPartitionKeyColumn(k); })? | K_PRIMARY K_KEY '(' tablePartitionKey[stmt] (',' c=ident { $stmt.markClusteringColumn(c); } )* ')' ; diff --git a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java index 9f0c44a29aff..c4c06af5bc80 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java @@ -124,6 +124,17 @@ public boolean hasRelevantConstraints() return false; } + public boolean containsNotNullConstraint() + { + for (ColumnConstraint c : constraints) + { + if (c.toString().equals(NotNullConstraint.CQL_FUNCTION_NAME)) + return true; + } + + return false; + } + @Override public void validate(ColumnMetadata columnMetadata) throws InvalidConstraintDefinitionException { diff --git a/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java index a28e8c21a8ec..d0d050db4544 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/NotNullConstraint.java @@ -19,6 +19,7 @@ package org.apache.cassandra.cql3.constraints; import java.nio.ByteBuffer; +import java.util.Collections; import java.util.List; import org.apache.cassandra.cql3.Operator; @@ -29,7 +30,15 @@ public class NotNullConstraint extends UnaryConstraintFunction { - public static final String FUNCTION_NAME = "NOT_NULL"; + public static final String FUNCTION_NAME = "NOT_NULL"; // as enum item + public static final String CQL_FUNCTION_NAME = "NOT NULL"; + + private static final List emptyArguments = Collections.emptyList(); + + public NotNullConstraint() + { + super(FUNCTION_NAME, emptyArguments); + } public NotNullConstraint(List args) { @@ -62,7 +71,7 @@ public List> getSupportedTypes() @Override public String toString() { - return "NOT NULL"; + return CQL_FUNCTION_NAME; } @Override diff --git a/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java index 7cfe162dc555..ada833440ecf 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/UnaryFunctionColumnConstraint.java @@ -87,7 +87,7 @@ private static ConstraintFunction createConstraintFunction(String functionName, return getEnum(Functions.class, functionName).functionCreator.apply(arguments); } - private UnaryFunctionColumnConstraint(ConstraintFunction function) + public UnaryFunctionColumnConstraint(ConstraintFunction function) { super(null, null); this.function = function; diff --git a/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java b/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java index 0a2589b78a04..1f12366677ac 100644 --- a/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/schema/CreateTableStatement.java @@ -39,6 +39,7 @@ import org.apache.cassandra.auth.IResource; import org.apache.cassandra.auth.Permission; import org.apache.cassandra.config.DatabaseDescriptor; +import org.apache.cassandra.cql3.constraints.ColumnConstraint; import org.apache.cassandra.cql3.constraints.ColumnConstraints; import org.apache.cassandra.cql3.CQL3Type; import org.apache.cassandra.cql3.CQLFragmentParser; @@ -46,6 +47,8 @@ import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.cql3.CqlParser; import org.apache.cassandra.cql3.QualifiedName; +import org.apache.cassandra.cql3.constraints.NotNullConstraint; +import org.apache.cassandra.cql3.constraints.UnaryFunctionColumnConstraint; import org.apache.cassandra.cql3.functions.masking.ColumnMask; import org.apache.cassandra.db.guardrails.Guardrails; import org.apache.cassandra.db.marshal.AbstractType; @@ -606,7 +609,7 @@ public String table() return name.getName(); } - public void addColumn(ColumnIdentifier column, CQL3Type.Raw type, boolean isStatic, ColumnMask.Raw mask, ColumnConstraints.Raw constraints) + public void addColumn(ColumnIdentifier column, CQL3Type.Raw type, boolean isStatic, boolean isNotNull, ColumnMask.Raw mask, ColumnConstraints.Raw constraints) { if (null != rawColumns.put(column, new ColumnProperties.Raw(type, mask))) throw ire("Duplicate column '%s' declaration for table '%s'", column, name); @@ -614,7 +617,25 @@ public void addColumn(ColumnIdentifier column, CQL3Type.Raw type, boolean isStat if (isStatic) staticColumns.add(column); - columnConstraints.put(column, constraints == null ? ColumnConstraints.NO_OP : constraints.prepare(column)); + ColumnConstraints preparedConstraints = constraints == null ? ColumnConstraints.NO_OP : constraints.prepare(column); + + if (isNotNull) + { + if (preparedConstraints.containsNotNullConstraint()) + throw ire("Duplicate definition of NOT NULL constraint"); + + List> checkConstraints = new ArrayList<>(preparedConstraints.getConstraints()); + checkConstraints.add(new UnaryFunctionColumnConstraint(new NotNullConstraint())); + preparedConstraints = new ColumnConstraints(checkConstraints); + preparedConstraints.setColumnName(column); + } + + columnConstraints.put(column, preparedConstraints); + } + + public void addColumn(ColumnIdentifier column, CQL3Type.Raw type, boolean isStatic, ColumnMask.Raw mask, ColumnConstraints.Raw constraints) + { + addColumn(column, type, isStatic, false, mask, constraints); } public void setCompactStorage() From d9153969e0058d521cf7933279a3378c452b7d52 Mon Sep 17 00:00:00 2001 From: Bernardo Botella Corbi Date: Fri, 2 May 2025 08:30:59 -0700 Subject: [PATCH 3/4] Align tests --- .../cql3/constraints/ColumnConstraints.java | 2 + .../cql3/constraints/JsonConstraint.java | 2 +- .../test/ColumnConstraintsTest.java | 6 +- ...ableWithTableConstraintValidationTest.java | 26 ++---- ...WithColumnCqlConstraintValidationTest.java | 84 +++++++++---------- ...ithColumnNotNullConstraintInvalidTest.java | 6 +- ...eWithColumnNotNullConstraintValidTest.java | 2 +- ...mnOctetLengthConstraintValidationTest.java | 68 +++++++-------- .../constraints/JsonConstraintTest.java | 4 +- .../constraints/NotNullConstraintTest.java | 6 ++ 10 files changed, 97 insertions(+), 109 deletions(-) diff --git a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java index c4c06af5bc80..60c79533c42f 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java +++ b/src/java/org/apache/cassandra/cql3/constraints/ColumnConstraints.java @@ -236,6 +236,8 @@ public ColumnConstraints prepare(ColumnIdentifier column) for (ColumnConstraint constraint : constraints) { + // We only check scalar constraints column name, as the rest of the constraints + // imply the name from the column they are defined at if (constraint.getConstraintType() == ConstraintType.SCALAR) { if (!column.equals(constraint.columnName)) diff --git a/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java b/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java index 510d4d1555ce..15a19d7954fc 100644 --- a/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java +++ b/src/java/org/apache/cassandra/cql3/constraints/JsonConstraint.java @@ -51,7 +51,7 @@ public void internalEvaluate(AbstractType valueType, Operator relationType, S catch (MarshalException ex) { throw new ConstraintViolationException(format("Value for column '%s' violated %s constraint as it is not a valid JSON.", - columnName.toCQLString(), + columnName, name)); } } diff --git a/test/distributed/org/apache/cassandra/distributed/test/ColumnConstraintsTest.java b/test/distributed/org/apache/cassandra/distributed/test/ColumnConstraintsTest.java index 77b72ccca1d2..4abdd780aa0b 100644 --- a/test/distributed/org/apache/cassandra/distributed/test/ColumnConstraintsTest.java +++ b/test/distributed/org/apache/cassandra/distributed/test/ColumnConstraintsTest.java @@ -58,7 +58,7 @@ public void testInvalidConstraintsExceptions() throws IOException "org.apache.cassandra.db.marshal.IntegerType, org.apache.cassandra.db.marshal.LongType, " + "org.apache.cassandra.db.marshal.ShortType] but it was class org.apache.cassandra.db.marshal.UTF8Type"); - assertThrowsInvalidConstraintException(cluster, String.format("CREATE TABLE %s (pk int, ck1 int CHECK LENGTH(ck1) < 100, ck2 int, v int, " + + assertThrowsInvalidConstraintException(cluster, String.format("CREATE TABLE %s (pk int, ck1 int CHECK LENGTH() < 100, ck2 int, v int, " + "PRIMARY KEY ((pk), ck1, ck2));", tableName), "Column should be of type class org.apache.cassandra.db.marshal.UTF8Type or " + "class org.apache.cassandra.db.marshal.AsciiType but got class org.apache.cassandra.db.marshal.Int32Type"); @@ -213,7 +213,7 @@ public void testLengthTableLevelConstraint() throws IOException for (Map.Entry relation : RELATIONS_MAP.entrySet()) { String tableName = String.format(KEYSPACE + ".%s_tbl1_%s", type, relation.getKey()); - String createTableStatementSmallerThan = "CREATE TABLE " + tableName + " (pk " + type + " CHECK LENGTH(pk) " + relation.getValue() + " 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2));"; + String createTableStatementSmallerThan = "CREATE TABLE " + tableName + " (pk " + type + " CHECK LENGTH() " + relation.getValue() + " 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2));"; cluster.schemaChange(createTableStatementSmallerThan); } } @@ -299,7 +299,7 @@ public void testNotNullTableLevelConstraint() throws IOException try (Cluster cluster = init(Cluster.build(1).start())) { String tableName = String.format(KEYSPACE + ".%s_tbl1_%s", type, "st"); - String createTableNotNullValue = "CREATE TABLE " + tableName + " (pk int, value int CHECK NOT_NULL(value), PRIMARY KEY (pk));"; + String createTableNotNullValue = "CREATE TABLE " + tableName + " (pk int, value int CHECK NOT NULL, PRIMARY KEY (pk));"; cluster.schemaChange(createTableNotNullValue); Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(String.format("INSERT INTO " + tableName + " (pk, value) VALUES (1, null)"), ConsistencyLevel.ALL)) diff --git a/test/unit/org/apache/cassandra/constraints/AlterTableWithTableConstraintValidationTest.java b/test/unit/org/apache/cassandra/constraints/AlterTableWithTableConstraintValidationTest.java index 91f21f8b0922..9c4987b932e8 100644 --- a/test/unit/org/apache/cassandra/constraints/AlterTableWithTableConstraintValidationTest.java +++ b/test/unit/org/apache/cassandra/constraints/AlterTableWithTableConstraintValidationTest.java @@ -116,12 +116,12 @@ public void testCreateTableAddMultipleMixedConstraints() throws Throwable table, tableCreateStatement)); - execute("ALTER TABLE %s ALTER ck2 CHECK LENGTH(ck2) = 4"); + execute("ALTER TABLE %s ALTER ck2 CHECK LENGTH() = 4"); tableCreateStatement = "CREATE TABLE " + KEYSPACE + "." + table + " (\n" + " pk int,\n" + " ck1 int CHECK ck1 < 100,\n" + - " ck2 text CHECK LENGTH(ck2) = 4,\n" + + " ck2 text CHECK LENGTH() = 4,\n" + " v int,\n" + " PRIMARY KEY (pk, ck1, ck2)\n" + ") WITH CLUSTERING ORDER BY (ck1 ASC, ck2 ASC)\n" + @@ -133,13 +133,13 @@ public void testCreateTableAddMultipleMixedConstraints() throws Throwable table, tableCreateStatement)); - execute("ALTER TABLE %s ALTER v CHECK NOT_NULL(v)"); + execute("ALTER TABLE %s ALTER v CHECK NOT NULL"); tableCreateStatement = "CREATE TABLE " + KEYSPACE + "." + table + " (\n" + " pk int,\n" + " ck1 int CHECK ck1 < 100,\n" + - " ck2 text CHECK LENGTH(ck2) = 4,\n" + - " v int CHECK NOT_NULL(v),\n" + + " ck2 text CHECK LENGTH() = 4,\n" + + " v int CHECK NOT NULL,\n" + " PRIMARY KEY (pk, ck1, ck2)\n" + ") WITH CLUSTERING ORDER BY (ck1 ASC, ck2 ASC)\n" + " AND " + tableParametersCql(); @@ -202,7 +202,7 @@ public void testAlterWithConstraintsAndCdcEnabled() throws Throwable @Test public void testAlterWithCdcAndPKConstraintsEnabled() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK length(pk) = 100, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2));"); + createTable("CREATE TABLE %s (pk text CHECK length() = 100, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2));"); // It works execute("ALTER TABLE %s WITH cdc = true"); } @@ -245,12 +245,6 @@ public void testAlterTableAlterExistingColumnWithCheckOnNonExistingColumn() thro assertInvalidThrowMessage("Constraint ck3 < 100 was not specified on a column it operates on: ck1 but on: ck3", InvalidRequestException.class, "ALTER TABLE %s ALTER ck1 CHECK ck3 < 100"); - assertInvalidThrowMessage("Constraint NOT_NULL(ck3) was not specified on a column it operates on: ck1 but on: ck3", - InvalidRequestException.class, - "ALTER TABLE %s ALTER ck1 CHECK NOT_NULL(ck3)"); - assertInvalidThrowMessage("Constraint LENGTH(ck3) > 10 was not specified on a column it operates on: ck1 but on: ck3", - InvalidRequestException.class, - "ALTER TABLE %s ALTER ck1 CHECK LENGTH(ck3) > 10"); } @Test @@ -261,14 +255,6 @@ public void testAlterTableAddNewColumnWithCheckOnNonExistingColumn() throws Thro assertInvalidThrowMessage("Constraint v3 < 100 was not specified on a column it operates on: v2 but on: v3", InvalidRequestException.class, "ALTER TABLE %s ADD v2 int CHECK v3 < 100"); - - assertInvalidThrowMessage("Constraint NOT_NULL(v3) was not specified on a column it operates on: v2 but on: v3", - InvalidRequestException.class, - "ALTER TABLE %s ADD v2 int CHECK NOT_NULL(v3)"); - - assertInvalidThrowMessage("Constraint LENGTH(v3) > 10 was not specified on a column it operates on: v2 but on: v3", - InvalidRequestException.class, - "ALTER TABLE %s ADD v2 int CHECK LENGTH(v3) > 10"); } @Test diff --git a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnCqlConstraintValidationTest.java b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnCqlConstraintValidationTest.java index 857ec85f408b..f68ee1ab6920 100644 --- a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnCqlConstraintValidationTest.java +++ b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnCqlConstraintValidationTest.java @@ -98,11 +98,11 @@ public void testCreateTableWithColumnMultipleConstraintsDescribeTableNonFunction @Test public void testCreateTableWithColumnNotNamedConstraintDescribeTableFunction() throws Throwable { - String table = createTable(KEYSPACE_PER_TEST, "CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + String table = createTable(KEYSPACE_PER_TEST, "CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); String tableCreateStatement = "CREATE TABLE " + KEYSPACE_PER_TEST + "." + table + " (\n" + " pk int,\n" + - " ck1 text CHECK LENGTH(ck1) = 4,\n" + + " ck1 text CHECK LENGTH() = 4,\n" + " ck2 int,\n" + " v int,\n" + " PRIMARY KEY (pk, ck1, ck2)\n" + @@ -119,13 +119,13 @@ public void testCreateTableWithColumnNotNamedConstraintDescribeTableFunction() t @Test public void testCreateTableWithColumnNotNullConstraintDescribe() throws Throwable { - String table = createTable(KEYSPACE_PER_TEST, "CREATE TABLE %s (pk int, ck1 int, ck2 int, v int CHECK NOT_NULL(v), PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + String table = createTable(KEYSPACE_PER_TEST, "CREATE TABLE %s (pk int, ck1 int, ck2 int, v int CHECK NOT NULL, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); String tableCreateStatement = "CREATE TABLE " + KEYSPACE_PER_TEST + "." + table + " (\n" + " pk int,\n" + " ck1 int,\n" + " ck2 int,\n" + - " v int CHECK NOT_NULL(v),\n" + + " v int CHECK NOT NULL,\n" + " PRIMARY KEY (pk, ck1, ck2)\n" + ") WITH CLUSTERING ORDER BY (ck1 ASC, ck2 ASC)\n" + " AND " + tableParametersCql(); @@ -932,7 +932,7 @@ public void testCreateTableWithColumnWithNotNullCheckScalarFloatConstraints() th @Test public void testCreateTableWithColumnWithClusteringColumnLengthEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fooo', 2, 3)"); @@ -946,7 +946,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthEqualToConstraint @Test public void testCreateTableWithColumnWithClusteringColumnLengthDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'ck1'. It has a length of"; // Valid @@ -960,7 +960,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthDifferentThanCons @Test public void testCreateTableWithColumnWithClusteringColumnLengthBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'foooo', 2, 3)"); @@ -974,7 +974,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthBiggerThanConstra @Test public void testCreateTableWithColumnWithClusteringColumnLengthBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'foooo', 2, 3)"); @@ -988,7 +988,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthBiggerOrEqualThan @Test public void testCreateTableWithColumnWithClusteringColumnLengthSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'foo', 2, 3)"); @@ -1002,7 +1002,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthSmallerThanConstr @Test public void testCreateTableWithColumnWithClusteringColumnLengthSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck1) <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH() <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'foo', 2, 3)"); @@ -1016,7 +1016,7 @@ public void testCreateTableWithColumnWithClusteringColumnLengthSmallerOrEqualTha @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fooo'), 2, 3)"); @@ -1030,7 +1030,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthEqualToConstr @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('foo'), 2, 3)"); @@ -1044,7 +1044,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthDifferentThan @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('foooo'), 2, 3)"); @@ -1058,7 +1058,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthBiggerThanCon @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('foooo'), 2, 3)"); @@ -1072,7 +1072,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthBiggerOrEqual @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('foo'), 2, 3)"); @@ -1086,7 +1086,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthSmallerThanCo @Test public void testCreateTableWithColumnWithClusteringBlobColumnLengthSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH(ck1) <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK LENGTH() <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 ASC);"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('foo'), 2, 3)"); @@ -1101,7 +1101,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnLengthSmallerOrEqua @Test public void testCreateTableWithColumnWithPkColumnLengthEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) = 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() = 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fooo', 1, 2, 3)"); @@ -1115,7 +1115,7 @@ public void testCreateTableWithColumnWithPkColumnLengthEqualToConstraint() throw @Test public void testCreateTableWithColumnWithPkColumnLengthDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) != 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() != 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('foo', 1, 2, 3)"); @@ -1129,7 +1129,7 @@ public void testCreateTableWithColumnWithPkColumnLengthDifferentThanConstraint() @Test public void testCreateTableWithColumnWithPkColumnLengthBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) > 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() > 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('foooo', 1, 2, 3)"); @@ -1143,7 +1143,7 @@ public void testCreateTableWithColumnWithPkColumnLengthBiggerThanConstraint() th @Test public void testCreateTableWithColumnWithPkColumnLengthBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) >= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() >= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('foooo', 1, 2, 3)"); @@ -1157,7 +1157,7 @@ public void testCreateTableWithColumnWithPkColumnLengthBiggerOrEqualThanConstrai @Test public void testCreateTableWithColumnWithPkColumnLengthSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) < 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() < 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('foo', 1, 2, 3)"); @@ -1171,7 +1171,7 @@ public void testCreateTableWithColumnWithPkColumnLengthSmallerThanConstraint() t @Test public void testCreateTableWithColumnWithPkColumnLengthSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) <= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() <= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('foo', 1, 2, 3)"); @@ -1186,7 +1186,7 @@ public void testCreateTableWithColumnWithPkColumnLengthSmallerOrEqualThanConstra @Test public void testCreateTableWithColumnWithRegularColumnLengthEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fooo')"); @@ -1200,7 +1200,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthEqualToConstraint() @Test public void testCreateTableWithColumnWithRegularColumnLengthDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) != 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() != 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'foo')"); @@ -1214,7 +1214,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthDifferentThanConstra @Test public void testCreateTableWithColumnWithRegularColumnLengthBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) > 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() > 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'foooo')"); @@ -1228,7 +1228,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthBiggerThanConstraint @Test public void testCreateTableWithColumnWithRegularColumnLengthBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) >= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() >= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'foooo')"); @@ -1242,7 +1242,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthBiggerOrEqualThanCon @Test public void testCreateTableWithColumnWithRegularColumnLengthSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) < 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() < 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'foo')"); @@ -1256,7 +1256,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthSmallerThanConstrain @Test public void testCreateTableWithColumnWithRegularColumnLengthSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'foo')"); @@ -1270,7 +1270,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthSmallerOrEqualThanCo @Test public void testCreateTableWithColumnWithRegularColumnLengthCheckNullTextConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -1278,7 +1278,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthCheckNullTextConstra @Test public void testCreateTableWithColumnWithRegularColumnLengthCheckNullVarcharConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v varchar CHECK LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v varchar CHECK LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -1286,7 +1286,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthCheckNullVarcharCons @Test public void testCreateTableWithColumnWithRegularColumnLengthCheckNullAsciiConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v ascii CHECK LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v ascii CHECK LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -1294,7 +1294,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthCheckNullAsciiConstr @Test public void testCreateTableWithColumnWithRegularColumnLengthCheckNullBlobConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v blob CHECK LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v blob CHECK LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -1302,7 +1302,7 @@ public void testCreateTableWithColumnWithRegularColumnLengthCheckNullBlobConstra @Test public void testCreateTableWithColumnMixedColumnsLengthConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK LENGTH(pk) = 4, ck1 int, ck2 int, v text CHECK LENGTH(v) = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK LENGTH() = 4, ck1 int, ck2 int, v text CHECK LENGTH() = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fooo', 2, 3, 'fooo')"); @@ -1323,7 +1323,7 @@ public void testCreateTableWithWrongColumnConstraint() throws Throwable { try { - createTable("CREATE TABLE %s (pk text, ck1 int CHECK LENGTH(pk) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text, ck1 int CHECK LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -1338,7 +1338,7 @@ public void testCreateTableWithWrongColumnMultipleConstraint() throws Throwable { try { - createTable("CREATE TABLE %s (pk text, ck1 int CHECK LENGTH(pk) = 4 AND ck1 < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text, ck1 int CHECK LENGTH() = 4 AND ck1 < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -1353,7 +1353,7 @@ public void testCreateTableWithColumnWithClusteringColumnInvalidTypeConstraint() { try { - createTable("CREATE TABLE %s (pk int, ck1 int CHECK LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int CHECK LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -1384,7 +1384,7 @@ public void testCreateTableInvalidFunction() throws Throwable { try { - createTable("CREATE TABLE %s (pk text CHECK not_a_function(pk) = 4, ck1 int, ck2 int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK not_a_function() = 4, ck1 int, ck2 int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -1398,7 +1398,7 @@ public void testCreateTableInvalidFunction() throws Throwable public void testCreateTableWithPKConstraintsAndCDCEnabled() throws Throwable { // It works - createTable("CREATE TABLE %s (pk text CHECK length(pk) = 4, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2)) WITH cdc = true;"); + createTable("CREATE TABLE %s (pk text CHECK length() = 4, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2)) WITH cdc = true;"); } @Test @@ -1444,16 +1444,8 @@ public void testCreateTableWithColumnWithClusteringColumnLessThanScalarConstrain @Test public void testCreateTableAddConstraintWithCheckOnNonExistingColumn() throws Throwable { - assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk int, ck1 text CHECK NOT_NULL(ck3), ck2 text, v int, PRIMARY KEY ((pk),ck1, ck2));")) - .hasRootCauseMessage("Constraint NOT_NULL(ck3) was not specified on a column it operates on: ck1 but on: ck3") - .rootCause().isInstanceOf(InvalidConstraintDefinitionException.class); - assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk int, ck1 int CHECK ck3 > 5, ck2 text, v int, PRIMARY KEY ((pk),ck1, ck2));")) .hasRootCauseMessage("Constraint ck3 > 5 was not specified on a column it operates on: ck1 but on: ck3") .rootCause().isInstanceOf(InvalidConstraintDefinitionException.class); - - assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk int, ck1 text CHECK LENGTH(ck3) > 10, ck2 text, v int, PRIMARY KEY ((pk),ck1, ck2));")) - .hasRootCauseMessage("Constraint LENGTH(ck3) > 10 was not specified on a column it operates on: ck1 but on: ck3") - .rootCause().isInstanceOf(InvalidConstraintDefinitionException.class); } } diff --git a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintInvalidTest.java b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintInvalidTest.java index dcb172163807..0fab10870ae5 100644 --- a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintInvalidTest.java +++ b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintInvalidTest.java @@ -59,7 +59,7 @@ public static Collection data() @Test public void testCreateTableWithColumnNotNullCheckNonExisting() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 " + typeString + " CHECK NOT_NULL(ck1), ck2 int, v int, PRIMARY KEY (pk));"); + createTable("CREATE TABLE %s (pk int, ck1 " + typeString + " CHECK NOT NULL, ck2 int, v int, PRIMARY KEY (pk));"); // Invalid assertInvalidThrowMessage("Column 'ck1' has to be specified as part of this query.", InvalidRequestException.class, "INSERT INTO %s (pk, ck2, v) VALUES (1, 2, 3)"); @@ -71,12 +71,12 @@ public void testCreateTableWithColumnNotNullCheckNonExisting() throws Throwable @Test public void testInvalidSpecificationOfNotNullConstraintOnPrimaryKeys() throws Throwable { - assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk " + typeString + " CHECK NOT_NULL(pk) PRIMARY KEY)")) + assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk " + typeString + " CHECK NOT NULL PRIMARY KEY)")) .isInstanceOf(InvalidRequestException.class) .hasRootCauseInstanceOf(InvalidConstraintDefinitionException.class) .hasRootCauseMessage("NOT_NULL constraint can not be specified on a partition key column 'pk'"); - assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk int, cl " + typeString + " CHECK NOT_NULL(cl), PRIMARY KEY (pk, cl))")) + assertThatThrownBy(() -> createTable("CREATE TABLE %s (pk int, cl " + typeString + " CHECK NOT NULL, PRIMARY KEY (pk, cl))")) .isInstanceOf(InvalidRequestException.class) .hasRootCauseInstanceOf(InvalidConstraintDefinitionException.class) .hasRootCauseMessage("NOT_NULL constraint can not be specified on a clustering key column 'cl'"); diff --git a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintValidTest.java b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintValidTest.java index b1ad79a43f1a..bf91fdbd6bdb 100644 --- a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintValidTest.java +++ b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnNotNullConstraintValidTest.java @@ -55,7 +55,7 @@ public static Collection data() @Test public void testCreateTableWithColumnNotNullCheckValid() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 " + typeString + " CHECK NOT_NULL(ck1), ck2 int, v int, PRIMARY KEY (pk));"); + createTable("CREATE TABLE %s (pk int, ck1 " + typeString + " CHECK NOT NULL, ck2 int, v int, PRIMARY KEY (pk));"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, " + value + ", 2, 3)"); diff --git a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnOctetLengthConstraintValidationTest.java b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnOctetLengthConstraintValidationTest.java index 6f9260f022ec..092f21f77063 100644 --- a/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnOctetLengthConstraintValidationTest.java +++ b/test/unit/org/apache/cassandra/constraints/CreateTableWithColumnOctetLengthConstraintValidationTest.java @@ -53,7 +53,7 @@ public static Collection generateData() @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk), ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fooo', 2, 3)"); @@ -69,7 +69,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeEqualToCo @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'ck1'. It has a length of"; // Valid @@ -83,7 +83,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeDifferent @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fñoo', 2, 3)"); @@ -97,7 +97,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeBiggerTha @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fñoo', 2, 3)"); @@ -111,7 +111,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeBiggerOrE @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fñ', 2, 3)"); @@ -125,7 +125,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeSmallerTh @Test public void testCreateTableWithColumnWithClusteringColumnSerializedSizeSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH(ck1) <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 text CHECK OCTET_LENGTH() <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 'fñ', 2, 3)"); @@ -139,7 +139,7 @@ public void testCreateTableWithColumnWithClusteringColumnSerializedSizeSmallerOr @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fño'), 2, 3)"); @@ -153,7 +153,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeEqual @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() != 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fñ'), 2, 3)"); @@ -167,7 +167,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeDiffe @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() > 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fñoo'), 2, 3)"); @@ -181,7 +181,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeBigge @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() >= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fñoo'), 2, 3)"); @@ -195,7 +195,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeBigge @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fñ'), 2, 3)"); @@ -209,7 +209,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeSmall @Test public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH(ck1) <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 blob CHECK OCTET_LENGTH() <= 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, textAsBlob('fñ'), 2, 3)"); @@ -224,7 +224,7 @@ public void testCreateTableWithColumnWithClusteringBlobColumnSerializedSizeSmall @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) = 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() = 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fño', 1, 2, 3)"); @@ -238,7 +238,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeEqualToConstraint @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) != 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() != 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fñ', 1, 2, 3)"); @@ -252,7 +252,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeDifferentThanCons @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) > 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() > 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fñoo', 1, 2, 3)"); @@ -266,7 +266,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeBiggerThanConstra @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) >= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() >= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fñoo', 1, 2, 3)"); @@ -280,7 +280,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeBiggerOrEqualThan @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) < 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() < 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fñ', 1, 2, 3)"); @@ -294,7 +294,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeSmallerThanConstr @Test public void testCreateTableWithColumnWithPkColumnSerializedSizeSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) <= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() <= 4, ck1 int, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fñ', 1, 2, 3)"); @@ -309,7 +309,7 @@ public void testCreateTableWithColumnWithPkColumnSerializedSizeSmallerOrEqualTha @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeEqualToConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fño')"); @@ -323,7 +323,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeEqualToConst @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeDifferentThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) != 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() != 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fñ')"); @@ -337,7 +337,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeDifferentTha @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeBiggerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) > 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() > 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fñoo')"); @@ -351,7 +351,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeBiggerThanCo @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeBiggerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) >= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() >= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fñoo')"); @@ -365,7 +365,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeBiggerOrEqua @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeSmallerThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) < 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() < 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fñ')"); @@ -379,7 +379,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeSmallerThanC @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeSmallerOrEqualThanConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, 'fñ')"); @@ -393,7 +393,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeSmallerOrEqu @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullTextConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -401,7 +401,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullTex @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullVarcharConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v varchar CHECK OCTET_LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v varchar CHECK OCTET_LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -409,7 +409,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullVar @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullAsciiConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v ascii CHECK OCTET_LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v ascii CHECK OCTET_LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -417,7 +417,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullAsc @Test public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullBlobConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v blob CHECK OCTET_LENGTH(v) <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int, ck2 int, v blob CHECK OCTET_LENGTH() <= 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); final String expectedErrorMessage = "Column value does not satisfy value constraint for column 'v' as it is null."; assertInvalidThrowMessage(expectedErrorMessage, InvalidRequestException.class, "INSERT INTO %s (pk, ck1, ck2, v) VALUES (1, 2, 3, null)"); } @@ -425,7 +425,7 @@ public void testCreateTableWithColumnWithRegularColumnSerializedSizeCheckNullBlo @Test public void testCreateTableWithColumnMixedColumnsSerializedSizeConstraint() throws Throwable { - createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH(pk) = 4, ck1 int, ck2 int, v text CHECK OCTET_LENGTH(v) = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK OCTET_LENGTH() = 4, ck1 int, ck2 int, v text CHECK OCTET_LENGTH() = 4, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); // Valid execute("INSERT INTO %s (pk, ck1, ck2, v) VALUES ('fño', 2, 3, 'fño')"); @@ -446,7 +446,7 @@ public void testCreateTableWithWrongColumnConstraint() throws Throwable { try { - createTable("CREATE TABLE %s (pk text, ck1 int CHECK OCTET_LENGTH(pk) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text, ck1 int CHECK OCTET_LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -461,7 +461,7 @@ public void testCreateTableWithWrongColumnMultipleConstraint() throws Throwable { try { - createTable("CREATE TABLE %s (pk text, ck1 int CHECK OCTET_LENGTH(pk) = 4 AND ck1 < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text, ck1 int CHECK OCTET_LENGTH() = 4 AND ck1 < 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -476,7 +476,7 @@ public void testCreateTableWithColumnWithClusteringColumnInvalidTypeConstraint() { try { - createTable("CREATE TABLE %s (pk int, ck1 int CHECK OCTET_LENGTH(ck1) = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk int, ck1 int CHECK OCTET_LENGTH() = 4, ck2 int, v int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -507,7 +507,7 @@ public void testCreateTableInvalidFunction() throws Throwable { try { - createTable("CREATE TABLE %s (pk text CHECK not_a_function(pk) = 4, ck1 int, ck2 int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); + createTable("CREATE TABLE %s (pk text CHECK not_a_function() = 4, ck1 int, ck2 int, PRIMARY KEY ((pk),ck1, ck2)) WITH CLUSTERING ORDER BY (ck1 " + order + ");"); fail(); } catch (InvalidRequestException e) @@ -521,7 +521,7 @@ public void testCreateTableInvalidFunction() throws Throwable public void testCreateTableWithPKConstraintsAndCDCEnabled() throws Throwable { // It works - createTable("CREATE TABLE %s (pk text CHECK length(pk) = 4, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2)) WITH cdc = true;"); + createTable("CREATE TABLE %s (pk text CHECK length() = 4, ck1 int, ck2 int, PRIMARY KEY ((pk), ck1, ck2)) WITH cdc = true;"); } @Test diff --git a/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java b/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java index 0fbf4602294d..9dc964dd60a1 100644 --- a/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java +++ b/test/unit/org/apache/cassandra/constraints/JsonConstraintTest.java @@ -42,17 +42,19 @@ public class JsonConstraintTest private static final ColumnMetadata regularStringColumn = getColumnOfType(UTF8Type.instance); private static final ColumnMetadata regularAsciiColumn = getColumnOfType(AsciiType.instance); - private static final ColumnConstraints json = new ColumnConstraints(of(new Raw(jsonFunctionIdentifier).prepare())); + private final ColumnConstraints json = new ColumnConstraints(of(new Raw(jsonFunctionIdentifier).prepare())); @Test public void testJsonConstraint() throws Throwable { + json.setColumnName(columnIdentifier); run("{}"); run("{\"a\": 5, \"b\": \"1\", \"c\": [1,2,3]}"); run("nonsense", "Value for column 'a_column' violated JSON constraint as it is not a valid JSON."); run("", "Value for column 'a_column' violated JSON constraint as it is not a valid JSON."); } + @Test public void testInvalidTypes() { diff --git a/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java b/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java index 2230d1aae0b1..e033c62c5909 100644 --- a/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java +++ b/test/unit/org/apache/cassandra/constraints/NotNullConstraintTest.java @@ -61,6 +61,9 @@ public class NotNullConstraintTest @Test public void testNotNullConstraintValidation() { + unaryConstraint.setColumnName(columnIdentifier); + scalarConstraint.setColumnName(columnIdentifier); + functionConstraint.setColumnName(columnIdentifier); // unary unaryConstraint.validate(getColumnOfType(UTF8Type.instance)); assertThatThrownBy(() -> unaryConstraint.evaluate(UTF8Type.instance, EMPTY_BYTE_BUFFER)) @@ -95,6 +98,9 @@ public void testNotNullConstraintValidation() @Test public void testCollections() { + unaryConstraint.setColumnName(columnIdentifier); + scalarConstraint.setColumnName(columnIdentifier); + functionConstraint.setColumnName(columnIdentifier); checkList(false); checkSet(false); checkMap(false); From 6bf6553737b14103b2dc9466093306da979cfd45 Mon Sep 17 00:00:00 2001 From: Bernardo Botella Corbi Date: Fri, 2 May 2025 08:40:39 -0700 Subject: [PATCH 4/4] Update docs --- .../pages/developing/cql/constraints.adoc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/modules/cassandra/pages/developing/cql/constraints.adoc b/doc/modules/cassandra/pages/developing/cql/constraints.adoc index 390d6c27a979..87b45ee03042 100644 --- a/doc/modules/cassandra/pages/developing/cql/constraints.adoc +++ b/doc/modules/cassandra/pages/developing/cql/constraints.adoc @@ -105,7 +105,7 @@ For example, we can create a constraint that checks that name can't be longer th ---- CREATE TABLE ks.tb ( - name text CHECK LENGTH(name) < 256 + name text CHECK LENGTH() < 256 ..., ); ---- @@ -113,7 +113,7 @@ CREATE TABLE ks.tb ( Altering that constraint can be done with: ---- -ALTER TABLE ks.tb ALTER name LENGTH(name) < 512; +ALTER TABLE ks.tb ALTER name LENGTH() < 512; ---- Finally, the constraint can be removed: @@ -130,7 +130,7 @@ For example, we can create a constraint that checks that name can't be bigger th ---- CREATE TABLE ks.tb ( - name text CHECK OCTET_LENGTH(name) < 2 + name text CHECK OCTET_LENGTH() < 2 ..., ); ---- @@ -158,8 +158,8 @@ For example, let's have this table: CREATE TABLE ks.tb ( id int, cl int, - col1 int CHECK NOT_NULL(col1), - col2 int CHECK NOT_NULL(col2), + col1 int CHECK NOT NULL, + col2 int CHECK NOT NULL, PRIMARY KEY (id, cl) ); ---- @@ -205,7 +205,7 @@ Defines a constraint which checks if a column contains a string which is a valid ---- CREATE TABLE ks.tb ( id int primary key, - val text CHECK JSON(val) + val text CHECK JSON() ); -- valid JSON string @@ -230,7 +230,7 @@ Defines a constraint which checks text-like values againt a regular expression. ---- CREATE TABLE ks.tb ( id int primary key, - value CHECK REGEXP(value) = 'a.*b' + value CHECK REGEXP() = 'a.*b' ) ---- @@ -243,7 +243,7 @@ cassandra@cqlsh> INSERT INTO ks.tb (id , value ) VALUES ( 1, 'aaaaa'); Negation can be also used: ---- -ALTER TABLE ks.tb ALTER value CHECK REGEXP(value) != 'a.*b'; +ALTER TABLE ks.tb ALTER value CHECK REGEXP() != 'a.*b'; ---- which would logically invert the condition: