Revert "Continue work on #2054: complete SortClause decoding for Lexical Sort support for Tables (but not actual Sort execution) (#2130)"

This reverts commit a69a5d8.

Author: Hazel-Datastax

src/main/java/io/stargate/sgv2/jsonapi/api/model/command/builders/CollectionSortClauseBuilder.java

@@ -102,39 +102,6 @@ public SortClause buildClauseFromDefinition(ObjectNode sortNode) {
     return new SortClause(sortExpressions);
   }
 
-  /**
-   * Helper method to build a "non-special" sort expression for given definition; validates
-   * expression value and builds the {@link SortExpression} object.
-   *
-   * @param path Path to the field to sort by, already validated
-   * @param innerValue JSON value of the sort expression to use
-   * @return {@link SortExpression} for the regular sort
-   */
-  private SortExpression buildRegularSortExpression(String path, JsonNode innerValue) {
-    if (!innerValue.isInt()) {
-      // Special checking for String and ArrayNode to give less confusing error messages
-      if (innerValue.isArray()) {
-        throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
-            "Sort ordering value can be Array only for Vector search");
-      }
-      if (innerValue.isTextual()) {
-        throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
-            "Sort ordering value can be String only for Lexical or Vectorize search");
-      }
-      throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
-          "Sort ordering value should be integer `1` or `-1`; or Array (Vector); or String (Lexical or Vectorize), was: %s",
-          JsonUtil.nodeTypeAsString(innerValue));
-    }
-    if (!(innerValue.intValue() == 1 || innerValue.intValue() == -1)) {
-      throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
-          "Sort ordering value can only be `1` for ascending or `-1` for descending (not `%s`)",
-          innerValue);
-    }
-
-    boolean ascending = innerValue.intValue() == 1;
-    return SortExpression.sort(path, ascending);
-  }
-
   private void validateSortExpressionPaths(ObjectNode sortNode) {
     Iterator<String> it = sortNode.fieldNames();
     while (it.hasNext()) {

src/main/java/io/stargate/sgv2/jsonapi/api/model/command/builders/SortClauseBuilder.java

@@ -5,10 +5,12 @@
 import io.stargate.sgv2.jsonapi.api.model.command.clause.filter.EJSONWrapper;
 import io.stargate.sgv2.jsonapi.api.model.command.clause.filter.SortDefinition;
 import io.stargate.sgv2.jsonapi.api.model.command.clause.sort.SortClause;
+import io.stargate.sgv2.jsonapi.api.model.command.clause.sort.SortExpression;
 import io.stargate.sgv2.jsonapi.exception.ErrorCodeV1;
 import io.stargate.sgv2.jsonapi.service.cqldriver.executor.SchemaObject;
 import io.stargate.sgv2.jsonapi.service.cqldriver.executor.TableSchemaObject;
 import io.stargate.sgv2.jsonapi.service.schema.collections.CollectionSchemaObject;
+import io.stargate.sgv2.jsonapi.util.JsonUtil;
 import java.util.Objects;
 
 /**
@@ -57,6 +59,39 @@ public SortClause build(JsonNode node) {
    */
   protected abstract SortClause buildClauseFromDefinition(ObjectNode sortNode);
 
+  /**
+   * Helper method to build a sort expression for given definition. Base implementation is for
+   * regular sorts (not vector, vectorize or lexical).
+   *
+   * @param path Path to the field to sort by, already validated
+   * @param innerValue JSON value of the sort expression to use
+   * @return {@link SortExpression} for the regular sort
+   */
+  protected SortExpression buildRegularSortExpression(String path, JsonNode innerValue) {
+    if (!innerValue.isInt()) {
+      // Special checking for String and ArrayNode to give less confusing error messages
+      if (innerValue.isArray()) {
+        throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
+            "Sort ordering value can be Array only for Vector search");
+      }
+      if (innerValue.isTextual()) {
+        throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
+            "Sort ordering value can be String only for Lexical or Vectorize search");
+      }
+      throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
+          "Sort ordering value should be integer `1` or `-1`; or Array (Vector); or String (Lexical or Vectorize), was: %s",
+          JsonUtil.nodeTypeAsString(innerValue));
+    }
+    if (!(innerValue.intValue() == 1 || innerValue.intValue() == -1)) {
+      throw ErrorCodeV1.INVALID_SORT_CLAUSE_VALUE.toApiException(
+          "Sort ordering value can only be `1` for ascending or `-1` for descending (not `%s`)",
+          innerValue);
+    }
+
+    boolean ascending = innerValue.intValue() == 1;
+    return SortExpression.sort(path, ascending);
+  }
+
   protected float[] tryDecodeBinaryVector(String path, JsonNode innerValue) {
     if (innerValue instanceof ObjectNode innerObject) {
       var ejsonWrapped = EJSONWrapper.maybeFrom(innerObject);

src/main/java/io/stargate/sgv2/jsonapi/api/model/command/builders/TableSortClauseBuilder.java

@@ -2,7 +2,6 @@
 
 import static io.stargate.sgv2.jsonapi.exception.ErrorFormatters.errFmtApiColumnDef;
 import static io.stargate.sgv2.jsonapi.exception.ErrorFormatters.errFmtCqlIdentifier;
-import static io.stargate.sgv2.jsonapi.exception.ErrorFormatters.errFmtJoin;
 import static io.stargate.sgv2.jsonapi.exception.ErrorFormatters.errVars;
 import static io.stargate.sgv2.jsonapi.util.JsonUtil.arrayNodeToVector;
 
@@ -17,7 +16,6 @@
 import io.stargate.sgv2.jsonapi.service.schema.tables.ApiColumnDef;
 import io.stargate.sgv2.jsonapi.service.schema.tables.ApiColumnDefContainer;
 import io.stargate.sgv2.jsonapi.util.CqlIdentifierUtil;
-import io.stargate.sgv2.jsonapi.util.JsonUtil;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -33,53 +31,10 @@ public TableSortClauseBuilder(TableSchemaObject table) {
   @Override
   protected SortClause buildClauseFromDefinition(ObjectNode sortNode) {
     // First, resolve the paths to column definitions
-    var sortExprDefs = resolveColumns(sortNode);
-
-    // Then split into "special" (vector/vectorize, lexical) and regular expressions
-    var lexicalExprs = new ArrayList<SortExpressionDefinition>();
-    var vectorExprs = new ArrayList<SortExpressionDefinition>();
-    var regularExprs = new ArrayList<SortExpressionDefinition>();
-
-    for (SortExpressionDefinition sortExprDef : sortExprDefs) {
-      var column = sortExprDef.column;
-      switch (column.type().typeName()) {
-        case VECTOR -> vectorExprs.add(sortExprDef);
-        case ASCII, TEXT -> {
-          if (sortExprDef.sortValue.isTextual()) {
-            lexicalExprs.add(sortExprDef);
-          } else {
-            regularExprs.add(sortExprDef);
-          }
-        }
-        default -> regularExprs.add(sortExprDef);
-      }
-    }
-
-    // Lexical(s)? Must have but one expression, cannot be combined with other sorts
-    // Ditto for vector/vectorize
-    if (!lexicalExprs.isEmpty() || !vectorExprs.isEmpty()) {
-      if (sortExprDefs.size() > 1) {
-        throw SortException.Code.CANNOT_SORT_ON_SPECIAL_WITH_OTHERS.get(
-            errVars(
-                schema,
-                map -> {
-                  map.put("lexicalSorts", columnsDesc(lexicalExprs));
-                  map.put("regularSorts", columnsDesc(regularExprs));
-                  map.put("vectorSorts", columnsDesc(vectorExprs));
-                }));
-      }
-
-      if (!lexicalExprs.isEmpty()) {
-        return new SortClause(List.of(buildLexicalSortExpression(lexicalExprs.getFirst())));
-      }
-
-      return new SortClause(List.of(buildVectorOrVectorizeSortExpression(vectorExprs.getFirst())));
-    }
-
-    // Otherwise, we can build regular sort expression(s)
+    List<SortExpressionDefinition> sortExprDefs = resolveColumns(sortNode);
     final List<SortExpression> sortExpressions = new ArrayList<>();
-    for (SortExpressionDefinition exprDef : regularExprs) {
-      sortExpressions.add(buildRegularSortExpression(exprDef));
+    for (SortExpressionDefinition sortExprDef : sortExprDefs) {
+      sortExpressions.add(buildSortExpression(sortExprDef));
     }
     return new SortClause(sortExpressions);
   }
@@ -115,98 +70,32 @@ private List<SortExpressionDefinition> resolveColumns(ObjectNode sortNode) {
     return sortExprDefs;
   }
 
-  protected SortExpression buildLexicalSortExpression(SortExpressionDefinition lexicalExpr) {
-    // caller validated JsonNode is textual; for now nothing more to validate
-    return SortExpression.tableLexicalSort(lexicalExpr.path(), lexicalExpr.sortValue.textValue());
-  }
+  protected SortExpression buildSortExpression(SortExpressionDefinition exprDef) {
+    final String path = exprDef.path();
+    final JsonNode innerValue = exprDef.sortValue();
 
-  protected SortExpression buildVectorOrVectorizeSortExpression(
-      SortExpressionDefinition vectorExpr) {
-    final String path = vectorExpr.path();
-    final JsonNode exprValue = vectorExpr.sortValue();
+    float[] vectorFloats = tryDecodeBinaryVector(path, innerValue);
 
-    // So we know we have a Vector column; now can check if value is a binary vector or an array
-    // of floats, or a string to vectorize.
-    // For Vectorize, further checks are done in the TableSortClauseResolver.
-
-    // First: vector data either as EJSON binary or as JSON Array (of floats)
-    float[] vectorFloats = tryDecodeBinaryVector(path, exprValue);
+    // handle table vector sort
     if (vectorFloats != null) {
       return SortExpression.tableVectorSort(path, vectorFloats);
     }
-    if (exprValue instanceof ArrayNode innerArray) {
+    if (innerValue instanceof ArrayNode innerArray) {
+      // TODO: HACK: quick support for tables, if the value is an array we will assume the
+      // column is a vector then need to check on table pathway that the sort is correct.
+      // NOTE: does not check if there are more than one sort expression, the
+      // TableSortClauseResolver will take care of that so we can get proper ApiExceptions
       return SortExpression.tableVectorSort(path, arrayNodeToVector(innerArray));
     }
-
-    // Otherwise, check if it is a String to vectorize
-    if (exprValue.isTextual()) {
-      return SortExpression.tableVectorizeSort(path, exprValue.textValue());
+    if (innerValue.isTextual()) {
+      // TODO: HACK: quick support for tables, if the value is an text  we will assume the column
+      // is a vector and the user wants to do vectorize then need to check on table pathway that
+      // the sort is correct.
+      // NOTE: does not check if there are more than one sort expression, the
+      // TableSortClauseResolver will take care of that so we can get proper ApiExceptions
+      // this is also why we do not break the look here
+      return SortExpression.tableVectorizeSort(path, innerValue.textValue());
     }
-
-    // Otherwise, invalid (cannot be a regular sort as it is a Vector column)
-    throw SortException.Code.INVALID_VECTOR_SORT_EXPRESSION.get(
-        errVars(
-            schema,
-            map -> {
-              map.put("jsonType", JsonUtil.nodeTypeAsString(exprValue));
-            }));
-  }
-
-  /**
-   * Helper method to build a "non-special" sort expression for given definition; validates
-   * expression value and builds the {@link SortExpression} object.
-   */
-  private SortExpression buildRegularSortExpression(SortExpressionDefinition exprDef) {
-    JsonNode sortValue = exprDef.sortValue();
-
-    // First: valid cases
-    if (sortValue.isInt()) {
-      // Yes, we have an integer value. But is it valid?
-      if (sortValue.intValue() == 1) {
-        return SortExpression.sort(exprDef.path(), true);
-      }
-      if (sortValue.intValue() == -1) {
-        return SortExpression.sort(exprDef.path(), false);
-      }
-    } else if (sortValue.isArray()) {
-      // Special checking for ArrayNode and String to give less confusing error messages
-
-      throw SortException.Code.CANNOT_VECTOR_SORT_NON_VECTOR_COLUMNS.get(
-          errVars(
-              schema,
-              map -> {
-                map.put(
-                    "vectorColumns",
-                    errFmtApiColumnDef(
-                        schema.apiTableDef().allColumns().filterVectorColumnsToList()));
-                map.put("sortColumns", exprDef.path());
-              }));
-    } else if (sortValue.isTextual()) {
-      // We only end up here for non-TEXT/ASCII/VECTOR columns (other cases are handled
-      // by caller and further validated later on)
-      throw SortException.Code.CANNOT_VECTORIZE_SORT_NON_VECTOR_COLUMN.get(
-          errVars(
-              schema,
-              map -> {
-                map.put(
-                    "vectorColumns",
-                    errFmtApiColumnDef(
-                        schema.apiTableDef().allColumns().filterVectorColumnsToList()));
-                map.put("sortColumns", exprDef.path());
-              }));
-    }
-
-    // Otherwise general failure message wrt use of 1 or -1 for Regular sort expression
-    throw SortException.Code.INVALID_REGULAR_SORT_EXPRESSION.get(
-        errVars(
-            schema,
-            map -> {
-              map.put("jsonExpr", sortValue.toString());
-              map.put("jsonType", JsonUtil.nodeTypeAsString(sortValue));
-            }));
-  }
-
-  private String columnsDesc(List<SortExpressionDefinition> sortExprDefs) {
-    return errFmtJoin(sortExprDefs.stream().map(SortExpressionDefinition::path).toList());
+    return super.buildRegularSortExpression(path, innerValue);
   }
 }

src/main/java/io/stargate/sgv2/jsonapi/exception/SortException.java

@@ -16,7 +16,6 @@ public SortException(ErrorInstance errorInstance) {
   public enum Code implements ErrorCode<SortException> {
     CANNOT_SORT_ON_MULTIPLE_VECTORIZE,
     CANNOT_SORT_ON_MULTIPLE_VECTORS,
-    CANNOT_SORT_ON_SPECIAL_WITH_OTHERS,
     CANNOT_SORT_UNKNOWN_COLUMNS,
     CANNOT_SORT_VECTOR_AND_NON_VECTOR_COLUMNS,
     CANNOT_VECTORIZE_SORT_NON_VECTOR_COLUMN,
@@ -25,8 +24,6 @@ public enum Code implements ErrorCode<SortException> {
     CANNOT_VECTOR_SORT_NON_VECTOR_COLUMNS,
     CANNOT_VECTOR_SORT_WITH_LIMIT_EXCEEDS_MAX,
     CANNOT_VECTOR_SORT_WITH_SKIP_OPTION,
-    INVALID_REGULAR_SORT_EXPRESSION,
-    INVALID_VECTOR_SORT_EXPRESSION,
     OVERLOADED_SORT_ROW_LIMIT,
     UNSUPPORTED_PAGINATION_WITH_IN_MEMORY_SORTING,
     UNSUPPORTED_VECTOR_SORT_FOR_COLLECTION,

src/main/resources/errors.yaml

@@ -76,17 +76,11 @@ snippets:
     body: |-
       Resend the command using only defined columns.
 
-  - name: REGULAR_SORT_EXPLANATION
-    body: |-
-      A regular sort expression in the sort clause identifies the column by name and then provides either:  
-      - `1` for ascending
-      - `-1` for descending
-
   - name: VECTOR_SORT_EXPLANATION
     body: |-
       A vector sort in the sort clause identifies the vector column by name and then provides either:  
       - The vector as an array of decimal numbers.
-      - The vector as a base64-encoded `{"$binary": "base64-encoded-vector"}` object.
+      - The vector as a base64 encoded `{"$binary": "base64-encoded-vector"}` object.
       - A string to be vectorized if enabled for the column.
 
   - name: CURRENTLY_UNSUPPORTED
@@ -1353,19 +1347,6 @@ request-errors:
       
       Resend the command with only one vectorize sort.
 
-  - scope: SORT
-    code: CANNOT_SORT_ON_SPECIAL_WITH_OTHERS
-    title: Special sort combined with other sort expressions
-    body: |-
-      The command used a sort clause with a special (lexical/vector/vectorize) sort combined with one or more other sort expressions:
-      Special sorts can only be used on their own, and cannot be combined with other sort expressions.
-      
-      The command attempted to use lexical sort on columns: ${lexicalSorts}.
-      The command attempted to use vector/vectorize sort on columns: ${vectorSorts}.
-      The command attempted to use regular sort on columns: ${regularSorts}.
-      
-      Resend the command with only one special sort expression.
-
   - scope: SORT
     code: CANNOT_SORT_UNKNOWN_COLUMNS
     title: Sorted columns are not defined in the table schema
@@ -1391,12 +1372,12 @@ request-errors:
     code: CANNOT_VECTOR_SORT_NON_VECTOR_COLUMNS
     title: Vector sort columns are not `vector` type
     body: |-
-      The command attempted to vector sort on a column that is not of `vector` type.
+      The command attempted to vectorize sort on a column that is not of `vector` type.
       
       ${SNIPPET.VECTOR_SORT_EXPLANATION}
       
-      The table ${keyspace}.${table} defines vector columns: ${vectorColumns}.
-      The command attempted to sort the non-vector columns: ${sortColumns}.
+      The table ${keyspace}.${table} defines the columns: ${vectorColumns}.
+      The command attempted to sort the non vector columns: ${sortColumns}.  
       
       Resend the command using only `vector` columns.
 
@@ -1479,26 +1460,6 @@ request-errors:
       
       Resend the command using either vector or non-vector sorting.
 
-  - scope: SORT
-    code: INVALID_REGULAR_SORT_EXPRESSION
-    title: Sort expression is not valid for regular sort
-    body: |-
-      The command attempted to use unsupported JSON expression `${jsonExpr}` (type ${jsonType}) for sort clause.
-      
-      ${SNIPPET.REGULAR_SORT_EXPLANATION}
-      
-      Resend the command with only valid sort expressions.
-
-  - scope: SORT
-    code: INVALID_VECTOR_SORT_EXPRESSION
-    title: Sort expression is not valid for vector/vectorize sort
-    body: |-
-      The command attempted to use unsupported JSON type (${jsonType}) for vector or vectorize sort.
-      
-      ${SNIPPET.VECTOR_SORT_EXPLANATION}
-      
-      Resend the command with valid vector/vectorize sort expression.
-
   - scope: SORT
     code: UNSUPPORTED_SORT_FOR_TABLE_DELETE_COMMAND
     title: Sorting not supported by delete command on Tables