feat(isthmus): make unquoted identifier casing configurable in ConverterProvider

nielspardon · nielspardon · commit 2467c50b9a9d · 2026-07-02T20:31:46.000+02:00
Add `withUnquotedCasing(Casing)` and `getUnquotedCasing()` to
`ConverterProvider` so callers can control how unquoted SQL identifiers
are cased. The default remains `Casing.TO_UPPER`.

The setting is now propagated consistently through the full pipeline:
- `getSqlParserConfig()` uses the stored casing value
- `SubstraitSqlToCalcite.convertQueries` gains a `ConverterProvider`
  overload so query parsing respects the provider config
- `SubstraitCreateStatementParser.processCreateStatements/ToCatalog`
  gain `ConverterProvider` overloads so CREATE TABLE parsing uses the
  same casing, keeping catalog names and plan names in sync
- `SqlExpressionToSubstrait` and `IsthmusEntryPoint` updated to pass
  the provider rather than extracting `SqlParser.Config` themselves;
  the CLI anonymous subclass workaround is removed

Closes #&lt;issue&gt;
diff --git a/isthmus-cli/src/main/java/io/substrait/isthmus/cli/IsthmusEntryPoint.java b/isthmus-cli/src/main/java/io/substrait/isthmus/cli/IsthmusEntryPoint.java
@@ -15,7 +15,6 @@
 import java.util.concurrent.Callable;
 import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.prepare.Prepare;
-import org.apache.calcite.sql.parser.SqlParser;
 import picocli.CommandLine;
 import picocli.CommandLine.Command;
 import picocli.CommandLine.Option;
@@ -61,12 +60,7 @@ enum OutputFormat {
   private Casing unquotedCasing = Casing.TO_UPPER;
 
   private ConverterProvider converterProvider() {
-    return new ConverterProvider() {
-      @Override
-      public SqlParser.Config getSqlParserConfig() {
-        return super.getSqlParserConfig().withUnquotedCasing(unquotedCasing);
-      }
-    };
+    return new ConverterProvider().withUnquotedCasing(unquotedCasing);
   }
 
   /**
@@ -102,10 +96,11 @@ public Integer call() throws Exception {
       ExtendedExpression extendedExpression = converter.convert(sqlExpressions, createStatements);
       printMessage(extendedExpression);
     } else { // by default Isthmus image are parsing SQL Query
-      SqlToSubstrait converter = new SqlToSubstrait(converterProvider());
+      ConverterProvider provider = converterProvider();
+      SqlToSubstrait converter = new SqlToSubstrait(provider);
       Prepare.CatalogReader catalog =
           SubstraitCreateStatementParser.processCreateStatementsToCatalog(
-              createStatements.toArray(String[]::new));
+              provider, createStatements);
       Plan plan = new PlanProtoConverter().toProto(converter.convert(sql, catalog));
       printMessage(plan);
     }
diff --git a/isthmus/src/main/java/io/substrait/isthmus/ConverterProvider.java b/isthmus/src/main/java/io/substrait/isthmus/ConverterProvider.java
@@ -55,6 +55,12 @@ public class ConverterProvider {
   /** The collection of Substrait extensions (functions and types) available for conversion. */
   protected final SimpleExtension.ExtensionCollection extensions;
 
+  /**
+   * The casing applied to unquoted SQL identifiers during parsing. Defaults to {@link
+   * Casing#TO_UPPER}.
+   */
+  protected Casing unquotedCasing = Casing.TO_UPPER;
+
   /** Converter for Substrait scalar functions. */
   protected ScalarFunctionConverter scalarFunctionConverter;
 
@@ -165,6 +171,30 @@ private static Plan.ExecutionBehavior createDefaultExecutionBehavior() {
 
   // SQL to Calcite Processing
 
+  /**
+   * Returns the casing applied to unquoted SQL identifiers during parsing.
+   *
+   * @return the unquoted identifier casing
+   */
+  public Casing getUnquotedCasing() {
+    return unquotedCasing;
+  }
+
+  /**
+   * Sets the casing applied to unquoted SQL identifiers during parsing and returns this instance
+   * for method chaining.
+   *
+   * <p>The default is {@link Casing#TO_UPPER}. Use {@link Casing#UNCHANGED} to preserve the
+   * original casing of unquoted identifiers in SQL statements.
+   *
+   * @param unquotedCasing the casing to apply to unquoted identifiers
+   * @return this {@code ConverterProvider} instance
+   */
+  public ConverterProvider withUnquotedCasing(Casing unquotedCasing) {
+    this.unquotedCasing = unquotedCasing;
+    return this;
+  }
+
   /**
    * {@link SqlParser.Config} is a Calcite class which controls SQL parsing behaviour like
    * identifier casing.
@@ -173,7 +203,7 @@ private static Plan.ExecutionBehavior createDefaultExecutionBehavior() {
    */
   public SqlParser.Config getSqlParserConfig() {
     return SqlParser.Config.DEFAULT
-        .withUnquotedCasing(Casing.TO_UPPER)
+        .withUnquotedCasing(unquotedCasing)
         .withParserFactory(SqlDdlParserImpl.FACTORY)
         .withConformance(SqlConformanceEnum.LENIENT);
   }
diff --git a/isthmus/src/main/java/io/substrait/isthmus/SqlExpressionToSubstrait.java b/isthmus/src/main/java/io/substrait/isthmus/SqlExpressionToSubstrait.java
@@ -202,7 +202,7 @@ private Result registerCreateTablesForExtendedExpression(List<String> tables)
     if (tables != null) {
       for (String tableDef : tables) {
         List<SubstraitTable> tList =
-            SubstraitCreateStatementParser.processCreateStatements(tableDef);
+            SubstraitCreateStatementParser.processCreateStatements(converterProvider, tableDef);
         for (SubstraitTable t : tList) {
           rootSchema.add(t.getName(), t);
           for (RelDataTypeField field : t.getRowType(factory).getFieldList()) {
diff --git a/isthmus/src/main/java/io/substrait/isthmus/SqlToSubstrait.java b/isthmus/src/main/java/io/substrait/isthmus/SqlToSubstrait.java
@@ -50,7 +50,9 @@ public Plan convert(final String sqlStatements, final Prepare.CatalogReader cata
     builder.executionBehavior(converterProvider.getExecutionBehavior());
 
     // TODO: consider case in which one sql passes conversion while others don't
-    SubstraitSqlToCalcite.convertQueries(sqlStatements, catalogReader, operatorTable).stream()
+    SubstraitSqlToCalcite.convertQueries(
+            sqlStatements, catalogReader, converterProvider, operatorTable)
+        .stream()
         .map(root -> SubstraitRelVisitor.convert(root, converterProvider))
         .forEach(root -> builder.addRoots(root));
 
diff --git a/isthmus/src/main/java/io/substrait/isthmus/sql/SubstraitCreateStatementParser.java b/isthmus/src/main/java/io/substrait/isthmus/sql/SubstraitCreateStatementParser.java
@@ -1,5 +1,6 @@
 package io.substrait.isthmus.sql;
 
+import io.substrait.isthmus.ConverterProvider;
 import io.substrait.isthmus.SqlConverterBase;
 import io.substrait.isthmus.SubstraitTypeSystem;
 import io.substrait.isthmus.Utils;
@@ -16,6 +17,7 @@
 import org.apache.calcite.sql.ddl.SqlCreateTable;
 import org.apache.calcite.sql.ddl.SqlKeyConstraint;
 import org.apache.calcite.sql.parser.SqlParseException;
+import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.jspecify.annotations.NonNull;
@@ -50,28 +52,26 @@ public class SubstraitCreateStatementParser {
    */
   public static List<SubstraitTable> processCreateStatements(@NonNull final String createStatements)
       throws SqlParseException {
-    final List<SubstraitTable> tableList = new ArrayList<>();
-
-    final List<SqlNode> sqlNode = SubstraitSqlStatementParser.parseStatements(createStatements);
-    for (final SqlNode parsed : sqlNode) {
-      if (!(parsed instanceof SqlCreateTable)) {
-        throw fail("Not a valid CREATE TABLE statement.");
-      }
-
-      final SqlCreateTable create = (SqlCreateTable) parsed;
-
-      if (create.name.names.size() > 1) {
-        throw fail("Only simple table names are allowed.", create.name.getParserPosition());
-      }
-
-      if (create.query != null) {
-        throw fail("CTAS not supported.", create.name.getParserPosition());
-      }
-
-      tableList.add(createSubstraitTable(create.name.names.get(0), create.columnList));
-    }
+    return processCreateStatements((SqlParser.Config) null, createStatements);
+  }
 
-    return tableList;
+  /**
+   * Parses a SQL string containing only CREATE statements into a list of {@link SubstraitTable}s,
+   * using the parser settings from the given {@link ConverterProvider}.
+   *
+   * <p>This method only supports simple table names without any additional qualifiers. Only used
+   * with {@link io.substrait.isthmus.SqlExpressionToSubstrait}.
+   *
+   * @param converterProvider the converter provider whose parser config controls identifier casing
+   *     and other parser settings
+   * @param createStatements a SQL string containing only CREATE statements; must not be null
+   * @return list of {@link SubstraitTable}s generated from the CREATE statements
+   * @throws SqlParseException if parsing fails or statements are invalid
+   */
+  public static List<SubstraitTable> processCreateStatements(
+      @NonNull final ConverterProvider converterProvider, @NonNull final String createStatements)
+      throws SqlParseException {
+    return processCreateStatements(converterProvider.getSqlParserConfig(), createStatements);
   }
 
   /**
@@ -89,6 +89,26 @@ public static CalciteCatalogReader processCreateStatementsToCatalog(
     return processCreateStatementsToCatalog(createStatements.toArray(new String[0]));
   }
 
+  /**
+   * Parses one or more SQL strings containing only CREATE statements into a {@link
+   * CalciteCatalogReader}, using the parser settings from the given {@link ConverterProvider}.
+   *
+   * <p>This method expects the use of fully qualified table names in the CREATE statements.
+   *
+   * @param converterProvider the converter provider whose parser config controls identifier casing
+   *     and other parser settings
+   * @param createStatements List of SQL strings containing only CREATE statements, must not be null
+   * @return a {@link CalciteCatalogReader} generated from the CREATE statements
+   * @throws SqlParseException if there is an error parsing the SQL statements
+   */
+  public static CalciteCatalogReader processCreateStatementsToCatalog(
+      @NonNull final ConverterProvider converterProvider,
+      @NonNull final List<String> createStatements)
+      throws SqlParseException {
+    return processCreateStatementsToCatalog(
+        converterProvider, createStatements.toArray(new String[0]));
+  }
+
   /**
    * Parses one or more SQL strings containing only CREATE statements into a {@link
    * CalciteCatalogReader}
@@ -101,7 +121,32 @@ public static CalciteCatalogReader processCreateStatementsToCatalog(
    */
   public static CalciteCatalogReader processCreateStatementsToCatalog(
       @NonNull final String... createStatements) throws SqlParseException {
-    final CalciteSchema rootSchema = processCreateStatementsToSchema(createStatements);
+    final CalciteSchema rootSchema = processCreateStatementsToSchema(null, createStatements);
+    final List<String> defaultSchema = Collections.emptyList();
+    return new CalciteCatalogReader(
+        rootSchema,
+        defaultSchema,
+        SubstraitTypeSystem.TYPE_FACTORY,
+        SqlConverterBase.CONNECTION_CONFIG);
+  }
+
+  /**
+   * Parses one or more SQL strings containing only CREATE statements into a {@link
+   * CalciteCatalogReader}, using the parser settings from the given {@link ConverterProvider}.
+   *
+   * <p>This method expects the use of fully qualified table names in the CREATE statements.
+   *
+   * @param converterProvider the converter provider whose parser config controls identifier casing
+   *     and other parser settings
+   * @param createStatements a SQL string containing only CREATE statements, must not be null
+   * @return a {@link CalciteCatalogReader} generated from the CREATE statements
+   * @throws SqlParseException if parsing fails or statements are invalid
+   */
+  public static CalciteCatalogReader processCreateStatementsToCatalog(
+      @NonNull final ConverterProvider converterProvider, @NonNull final String... createStatements)
+      throws SqlParseException {
+    final CalciteSchema rootSchema =
+        processCreateStatementsToSchema(converterProvider.getSqlParserConfig(), createStatements);
     final List<String> defaultSchema = Collections.emptyList();
     return new CalciteCatalogReader(
         rootSchema,
@@ -133,19 +178,53 @@ private static SqlParseException fail(@Nullable final String message) {
   }
 
   /**
-   * Parses one or more SQL strings containing only CREATE statements into a {@link CalciteSchema}.
-   *
-   * @param createStatements one or more SQL strings containing only CREATE statements; must not be
-   *     null
-   * @return a {@link CalciteSchema} generated from the CREATE statements
-   * @throws SqlParseException if parsing fails or statements are invalid
+   * Parses a SQL string containing only CREATE statements into a list of {@link SubstraitTable}s
+   * using the given parser config (may be {@code null} for the default).
+   */
+  private static List<SubstraitTable> processCreateStatements(
+      SqlParser.Config parserConfig, @NonNull final String createStatements)
+      throws SqlParseException {
+    final List<SubstraitTable> tableList = new ArrayList<>();
+
+    final List<SqlNode> sqlNode =
+        parserConfig == null
+            ? SubstraitSqlStatementParser.parseStatements(createStatements)
+            : SubstraitSqlStatementParser.parseStatements(createStatements, parserConfig);
+    for (final SqlNode parsed : sqlNode) {
+      if (!(parsed instanceof SqlCreateTable)) {
+        throw fail("Not a valid CREATE TABLE statement.");
+      }
+
+      final SqlCreateTable create = (SqlCreateTable) parsed;
+
+      if (create.name.names.size() > 1) {
+        throw fail("Only simple table names are allowed.", create.name.getParserPosition());
+      }
+
+      if (create.query != null) {
+        throw fail("CTAS not supported.", create.name.getParserPosition());
+      }
+
+      tableList.add(createSubstraitTable(create.name.names.get(0), create.columnList));
+    }
+
+    return tableList;
+  }
+
+  /**
+   * Parses one or more SQL strings containing only CREATE statements into a {@link CalciteSchema}
+   * using the given parser config (may be {@code null} for the default).
    */
   private static CalciteSchema processCreateStatementsToSchema(
-      @NonNull final String... createStatements) throws SqlParseException {
+      SqlParser.Config parserConfig, @NonNull final String... createStatements)
+      throws SqlParseException {
     final CalciteSchema rootSchema = CalciteSchema.createRootSchema(false);
 
     for (final String statement : createStatements) {
-      final List<SqlNode> sqlNode = SubstraitSqlStatementParser.parseStatements(statement);
+      final List<SqlNode> sqlNode =
+          parserConfig == null
+              ? SubstraitSqlStatementParser.parseStatements(statement)
+              : SubstraitSqlStatementParser.parseStatements(statement, parserConfig);
       for (final SqlNode parsed : sqlNode) {
         if (!(parsed instanceof SqlCreateTable)) {
           throw fail("Not a valid CREATE TABLE statement.");
diff --git a/isthmus/src/main/java/io/substrait/isthmus/sql/SubstraitSqlToCalcite.java b/isthmus/src/main/java/io/substrait/isthmus/sql/SubstraitSqlToCalcite.java
@@ -1,5 +1,6 @@
 package io.substrait.isthmus.sql;
 
+import io.substrait.isthmus.ConverterProvider;
 import io.substrait.isthmus.SubstraitTypeSystem;
 import io.substrait.isthmus.calcite.rel.DdlSqlToRelConverter;
 import java.util.List;
@@ -109,6 +110,34 @@ public static List<RelRoot> convertQueries(
     return convertQueries(sqlStatements, catalogReader, validator, createDefaultRelOptCluster());
   }
 
+  /**
+   * Converts one or more SQL statements to a List of {@link RelRoot}, with one {@link RelRoot} per
+   * statement, using the parser configuration from the given {@link ConverterProvider}.
+   *
+   * @param sqlStatements a string containing one or more SQL statements
+   * @param catalogReader the {@link Prepare.CatalogReader} for finding tables/views referenced in
+   *     the SQL statements
+   * @param converterProvider the converter provider whose parser config controls identifier casing
+   *     and other parser settings
+   * @param operatorTable the {@link SqlOperatorTable} for controlling valid operators
+   * @return a list of {@link RelRoot}s corresponding to the given SQL statements
+   * @throws SqlParseException if there is an error while parsing the SQL statements
+   */
+  public static List<RelRoot> convertQueries(
+      String sqlStatements,
+      Prepare.CatalogReader catalogReader,
+      ConverterProvider converterProvider,
+      SqlOperatorTable operatorTable)
+      throws SqlParseException {
+    SqlValidator validator = new SubstraitSqlValidator(catalogReader, operatorTable);
+    return convertQueries(
+        sqlStatements,
+        catalogReader,
+        validator,
+        createDefaultRelOptCluster(),
+        converterProvider.getSqlParserConfig());
+  }
+
   /**
    * Converts one or more SQL statements to a List of {@link RelRoot}, with one {@link RelRoot} per
    * statement.
diff --git a/isthmus/src/test/java/io/substrait/isthmus/UnquotedCasingTest.java b/isthmus/src/test/java/io/substrait/isthmus/UnquotedCasingTest.java
