How to use

CalciteConnectionConfig

in

org.apache.calcite.config

columnMetas.add(new SelectedColumnMeta(false, config.caseSensitive(), false, false,
    basicSqlType.isNullable() ? 1 : 0, true, basicSqlType.getPrecision(), columnName,
    columnName, null, null, null, basicSqlType.getPrecision(),

/**
 * utility function to extract timezone id from Druid query
 * @param query Druid Rel
 * @return time zone
 */
private static TimeZone timezoneId(final DruidQuery query, final RexNode arg) {
 return arg.getType().getSqlTypeName() == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE
   ? TimeZone.getTimeZone(
   query.getTopNode().getCluster().getPlanner().getContext().unwrap(CalciteConnectionConfig.class).timeZone()) :
   TimeZone.getTimeZone("UTC");
}

protected QuarkConnectionImpl(QuarkDriver driver, AvaticaFactory factory, String url,
               Properties info, CalciteRootSchema rootSchema,
               JavaTypeFactory typeFactory) throws SQLException {
 super(driver, factory, url, info);
 CalciteConnectionConfig cfg = new CalciteConnectionConfigImpl(info);
 if (typeFactory != null) {
  this.typeFactory = typeFactory;
 } else {
  final RelDataTypeSystem typeSystem =
    cfg.typeSystem(RelDataTypeSystem.class, RelDataTypeSystem.DEFAULT);
  this.typeFactory = new JavaTypeFactoryImpl(typeSystem);
 }
 this.properties.put(InternalProperty.CASE_SENSITIVE, cfg.caseSensitive());
 this.properties.put(InternalProperty.UNQUOTED_CASING, cfg.unquotedCasing());
 this.properties.put(InternalProperty.QUOTED_CASING, cfg.quotedCasing());
 this.properties.put(InternalProperty.QUOTING, cfg.quoting());
}

final CalciteConnectionConfig config = context.config();
final SqlParser.ConfigBuilder parserConfig = createParserConfig()
  .setQuotedCasing(config.quotedCasing())
  .setUnquotedCasing(config.unquotedCasing())
  .setQuoting(config.quoting())
  .setConformance(config.conformance())
  .setCaseSensitive(config.caseSensitive());
final SqlParserImplFactory parserFactory =
  config.parserFactory(SqlParserImplFactory.class, null);
if (parserFactory != null) {
 parserConfig.setParserFactory(parserFactory);
  createSqlValidator(context, catalogReader);
validator.setIdentifierExpansion(true);
validator.setDefaultNullCollation(config.defaultNullCollation());

public SqlParser getSqlParser(String sql) {
 try {
  final CalciteConnectionConfig config = context.getCfg();
  return SqlParser.create(sql,
    SqlParser.configBuilder()
      .setQuotedCasing(config.quotedCasing())
      .setUnquotedCasing(config.unquotedCasing())
      .setQuoting(config.quoting())
      .build());
 } catch (Exception e) {
  return SqlParser.create(sql);
 }
}

private SqlValidator createSqlValidator(Context context,
                    CalciteCatalogReader catalogReader) {
 final SqlOperatorTable opTab0 =
   context.config().fun(SqlOperatorTable.class,
     SqlStdOperatorTable.instance());
 final SqlOperatorTable opTab =
   ChainedSqlOperatorTable.of(opTab0, catalogReader);
 final JavaTypeFactory typeFactory = context.getTypeFactory();
 final SqlConformance conformance = context.config().conformance();
 return new CalciteSqlValidator(opTab, catalogReader, typeFactory,
   conformance);
}

final CalciteConnectionConfig config = getConnectionConfig();
QueryType queryType = QueryType.SCAN;
final Translator translator = new Translator(druidTable, rowType, config.timeZone());
List<String> fieldNames = rowType.getFieldNames();
Set<String> usedFieldNames = Sets.newHashSet(fieldNames);
            usedFieldNames, SqlValidatorUtil.EXPR_SUGGESTER);
          timeExtractionDimensionSpec = TimeExtractionDimensionSpec.makeFullTimeExtract(
            extractColumnName, config.timeZone());
          dimensions.add(timeExtractionDimensionSpec);
          builder.add(extractColumnName);
          DruidDateTimeUtils.extractGranularity(call, config.timeZone());
        if (funcGranularity != null) {
          final String extractColumnName;
                  SqlValidatorUtil.EXPR_SUGGESTER);
              timeExtractionDimensionSpec = TimeExtractionDimensionSpec.makeTimeExtract(
                funcGranularity, extractColumnName, config.timeZone());
              dimensions.add(timeExtractionDimensionSpec);
              builder.add(extractColumnName);
                dimensions.add(
                  TimeExtractionDimensionSpec.makeTimeFloor(funcGranularity,
                    extractColumnName, config.timeZone()));
                finalGranularity = Granularities.all();
                builder.add(extractColumnName);
          usedFieldNames, SqlValidatorUtil.EXPR_SUGGESTER);

final String timeZoneConf = druidQuery.getConnectionConfig().timeZone();
final TimeZone timeZone = TimeZone.getTimeZone(timeZoneConf == null ? "UTC" : timeZoneConf);
final boolean nullEqualToEmpty = druidQuery.getConnectionConfig().nullEqualToEmpty();
    Period.days(1).toString(),
    "",
    TimeZone.getTimeZone(druidQuery.getConnectionConfig().timeZone()));
 } else {
  return typeCastExpression;

final CalciteConnectionConfig calciteConfig = context.unwrap(CalciteConnectionConfig.class);
if (calciteConfig != null) {
 validator.setDefaultNullCollation(calciteConfig.defaultNullCollation());

 public RelNode run(RelOptPlanner planner, RelNode rel,
           RelTraitSet requiredOutputTraits,
           List<RelOptMaterialization> materializations,
           List<RelOptLattice> lattices) {
  final CalciteConnectionConfig config =
    planner.getContext().unwrap(CalciteConnectionConfig.class);
  if (config != null && config.forceDecorrelate()) {
   return RelDecorrelator.decorrelateQuery(rel);
  }
  return rel;
 }
}

private SqlConformance conformance() {
 final Context context = config.getContext();
 if (context != null) {
  final CalciteConnectionConfig connectionConfig =
    context.unwrap(CalciteConnectionConfig.class);
  if (connectionConfig != null) {
   return connectionConfig.conformance();
  }
 }
 return SqlConformanceEnum.DEFAULT;
}

@Override protected CalciteResultSet execute() throws SQLException {
 // Call driver's callback. It is permitted to throw a RuntimeException.
 CalciteConnectionImpl connection = getCalciteConnection();
 final boolean autoTemp = connection.config().autoTemp();
 Handler.ResultSink resultSink = null;
 if (autoTemp) {
  resultSink = () -> {
  };
 }
 connection.getDriver().handler.onStatementExecute(statement, resultSink);
 super.execute();
 return this;
}

  cfg.typeSystem(RelDataTypeSystem.class, RelDataTypeSystem.DEFAULT);
this.typeFactory = new JavaTypeFactoryImpl(typeSystem);
this.unitTestMode = Boolean.parseBoolean(info.getProperty("unitTestMode", "false"));

} else {
 RelDataTypeSystem typeSystem =
   cfg.typeSystem(RelDataTypeSystem.class, RelDataTypeSystem.DEFAULT);
 if (cfg.conformance().shouldConvertRaggedUnionTypesToVarying()) {
  typeSystem =
    new DelegatingTypeSystem(typeSystem) {
    : CalciteSchema.createRootSchema(true));
Preconditions.checkArgument(this.rootSchema.isRoot(), "must be root schema");
this.properties.put(InternalProperty.CASE_SENSITIVE, cfg.caseSensitive());
this.properties.put(InternalProperty.UNQUOTED_CASING, cfg.unquotedCasing());
this.properties.put(InternalProperty.QUOTED_CASING, cfg.quotedCasing());
this.properties.put(InternalProperty.QUOTING, cfg.quoting());

final CalciteConnectionConfig config = context.config();
final SqlParser.ConfigBuilder parserConfig = createParserConfig()
  .setQuotedCasing(config.quotedCasing())
  .setUnquotedCasing(config.unquotedCasing())
  .setQuoting(config.quoting())
  .setConformance(config.conformance())
  .setCaseSensitive(config.caseSensitive());
final SqlParserImplFactory parserFactory =
  config.parserFactory(SqlParserImplFactory.class, null);
if (parserFactory != null) {
 parserConfig.setParserFactory(parserFactory);
  createSqlValidator(context, catalogReader);
validator.setIdentifierExpansion(true);
validator.setDefaultNullCollation(config.defaultNullCollation());

private SqlValidator createSqlValidator(Context context,
  CalciteCatalogReader catalogReader) {
 final SqlOperatorTable opTab0 =
   context.config().fun(SqlOperatorTable.class,
     SqlStdOperatorTable.instance());
 final SqlOperatorTable opTab =
   ChainedSqlOperatorTable.of(opTab0, catalogReader);
 final JavaTypeFactory typeFactory = context.getTypeFactory();
 final SqlConformance conformance = context.config().conformance();
 return new CalciteSqlValidator(opTab, catalogReader, typeFactory,
   conformance);
}

final CalciteConnectionConfig calciteConfig = context.unwrap(CalciteConnectionConfig.class);
if (calciteConfig != null) {
 validator.setDefaultNullCollation(calciteConfig.defaultNullCollation());

 public RelNode run(RelOptPlanner planner, RelNode rel,
   RelTraitSet requiredOutputTraits,
   List<RelOptMaterialization> materializations,
   List<RelOptLattice> lattices) {
  final CalciteConnectionConfig config =
    planner.getContext().unwrap(CalciteConnectionConfig.class);
  if (config != null && config.forceDecorrelate()) {
   final RelBuilder relBuilder =
     RelFactories.LOGICAL_BUILDER.create(rel.getCluster(), null);
   return RelDecorrelator.decorrelateQuery(rel, relBuilder);
  }
  return rel;
 }
}

private SqlConformance conformance() {
 final Context context = config.getContext();
 if (context != null) {
  final CalciteConnectionConfig connectionConfig =
    context.unwrap(CalciteConnectionConfig.class);
  if (connectionConfig != null) {
   return connectionConfig.conformance();
  }
 }
 return config.getParserConfig().conformance();
}

@Override protected CalciteResultSet execute() throws SQLException {
 // Call driver's callback. It is permitted to throw a RuntimeException.
 CalciteConnectionImpl connection = getCalciteConnection();
 final boolean autoTemp = connection.config().autoTemp();
 Handler.ResultSink resultSink = null;
 if (autoTemp) {
  resultSink = () -> {
  };
 }
 connection.getDriver().handler.onStatementExecute(statement, resultSink);
 super.execute();
 return this;
}