Tabnine Logo
CalciteConnectionConfig.caseSensitive
Code IndexAdd Tabnine to your IDE (free)

How to use
caseSensitive
method
in
org.apache.calcite.config.CalciteConnectionConfig

Best Java code snippets using org.apache.calcite.config.CalciteConnectionConfig.caseSensitive (Showing top 15 results out of 315)

origin: apache/kylin

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

public CalciteCatalogReader(CalciteSchema rootSchema,
  List<String> defaultSchema, RelDataTypeFactory typeFactory, CalciteConnectionConfig config) {
 this(rootSchema, SqlNameMatchers.withCaseSensitive(config != null && config.caseSensitive()),
   ImmutableList.of(Objects.requireNonNull(defaultSchema),
     ImmutableList.of()),
   typeFactory, config);
}
origin: org.apache.calcite/calcite-core

public CalciteCatalogReader(CalciteSchema rootSchema,
  List<String> defaultSchema, RelDataTypeFactory typeFactory, CalciteConnectionConfig config) {
 this(rootSchema, SqlNameMatchers.withCaseSensitive(config != null && config.caseSensitive()),
   ImmutableList.of(Objects.requireNonNull(defaultSchema),
     ImmutableList.of()),
   typeFactory, config);
}
origin: com.alibaba.blink/flink-table

public FlinkCalciteCatalogReader(
  CalciteSchema rootSchema,
  List<List<String>> defaultSchemas,
  RelDataTypeFactory typeFactory,
  CalciteConnectionConfig config) {
  this(
    rootSchema,
    SqlNameMatchers.withCaseSensitive(config != null && config.caseSensitive()),
    getDefaultSchemas(defaultSchemas),
    typeFactory,
    config);
}
origin: qubole/quark

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());
}
origin: org.apache.kylin/atopcalcite

new CalciteCatalogReader(
  context.getRootSchema(),
  context.config().caseSensitive(),
  context.getDefaultSchemaPath(),
  typeFactory);
origin: Qihoo360/Quicksql

    : 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());
origin: org.apache.calcite/calcite-core

    : 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());
origin: org.apache.kylin/atopcalcite

protected void populateMaterializations(Context context,
                    RelOptPlanner planner, Prepare.Materialization materialization) {
 // REVIEW: initialize queryRel and tableRel inside MaterializationService,
 // not here?
 try {
  final CalciteSchema schema = materialization.materializedTable.schema;
  CalciteCatalogReader catalogReader =
    new CalciteCatalogReader(
      schema.root(),
      context.config().caseSensitive(),
      materialization.viewSchemaPath,
      context.getTypeFactory());
  final CalciteMaterializer materializer =
    new CalciteMaterializer(this, context, catalogReader, schema, planner,
      createConvertletTable());
  materializer.populate(materialization);
 } catch (Exception e) {
  throw new RuntimeException("While populating materialization "
    + materialization.materializedTable.path(), e);
 }
}
origin: org.apache.calcite/calcite-core

private SqlAdvisor getSqlAdvisor() {
 final CalciteConnectionImpl con = (CalciteConnectionImpl) queryProvider;
 final String schemaName;
 try {
  schemaName = con.getSchema();
 } catch (SQLException e) {
  throw new RuntimeException(e);
 }
 final List<String> schemaPath =
   schemaName == null
     ? ImmutableList.of()
     : ImmutableList.of(schemaName);
 final SqlValidatorWithHints validator =
   new SqlAdvisorValidator(SqlStdOperatorTable.instance(),
   new CalciteCatalogReader(rootSchema,
     schemaPath, typeFactory, con.config()),
   typeFactory, SqlConformanceEnum.DEFAULT);
 final CalciteConnectionConfig config = con.config();
 // This duplicates org.apache.calcite.prepare.CalcitePrepareImpl.prepare2_
 final SqlParser.Config parserConfig = SqlParser.configBuilder()
   .setQuotedCasing(config.quotedCasing())
   .setUnquotedCasing(config.unquotedCasing())
   .setQuoting(config.quoting())
   .setConformance(config.conformance())
   .setCaseSensitive(config.caseSensitive())
   .build();
 return new SqlAdvisor(validator, parserConfig);
}
origin: Qihoo360/Quicksql

private SqlAdvisor getSqlAdvisor() {
 final CalciteConnectionImpl con = (CalciteConnectionImpl) queryProvider;
 final String schemaName;
 try {
  schemaName = con.getSchema();
 } catch (SQLException e) {
  throw new RuntimeException(e);
 }
 final List<String> schemaPath =
   schemaName == null
     ? ImmutableList.of()
     : ImmutableList.of(schemaName);
 final SqlValidatorWithHints validator =
   new SqlAdvisorValidator(SqlStdOperatorTable.instance(),
   new CalciteCatalogReader(rootSchema,
     schemaPath, typeFactory, con.config()),
   typeFactory, SqlConformanceEnum.DEFAULT);
 final CalciteConnectionConfig config = con.config();
 // This duplicates org.apache.calcite.prepare.CalcitePrepareImpl.prepare2_
 final SqlParser.Config parserConfig = SqlParser.configBuilder()
   .setQuotedCasing(config.quotedCasing())
   .setUnquotedCasing(config.unquotedCasing())
   .setQuoting(config.quoting())
   .setConformance(config.conformance())
   .setCaseSensitive(config.caseSensitive())
   .build();
 return new SqlAdvisor(validator, parserConfig);
}
origin: org.apache.kylin/atopcalcite

/** Shared implementation for {@link #parse}, {@link #convert} and
 * {@link #analyzeView}. */
private ParseResult parse_(Context context, String sql, boolean convert,
              boolean analyze, boolean fail) {
 final JavaTypeFactory typeFactory = context.getTypeFactory();
 CalciteCatalogReader catalogReader =
   new CalciteCatalogReader(
     context.getRootSchema(),
     context.config().caseSensitive(),
     context.getDefaultSchemaPath(),
     typeFactory);
 SqlParser parser = createParser(sql);
 SqlNode sqlNode;
 try {
  sqlNode = parser.parseStmt();
 } catch (SqlParseException e) {
  throw new RuntimeException("parse failed", e);
 }
 final SqlValidator validator = createSqlValidator(context, catalogReader);
 SqlNode sqlNode1 = validator.validate(sqlNode);
 if (convert) {
  return convert_(
    context, sql, analyze, fail, catalogReader, validator, sqlNode1);
 }
 return new ParseResult(this, validator, sql, sqlNode1,
   validator.getValidatedNodeType(sqlNode1));
}
origin: Qihoo360/Quicksql

  .setQuoting(config.quoting())
  .setConformance(config.conformance())
  .setCaseSensitive(config.caseSensitive());
final SqlParserImplFactory parserFactory =
  config.parserFactory(SqlParserImplFactory.class, null);
origin: org.apache.calcite/calcite-core

  .setQuoting(config.quoting())
  .setConformance(config.conformance())
  .setCaseSensitive(config.caseSensitive());
final SqlParserImplFactory parserFactory =
  config.parserFactory(SqlParserImplFactory.class, null);
origin: org.apache.kylin/atopcalcite

/** Executes a prepare action. */
public <R> R perform(CalciteServerStatement statement,
  Frameworks.PrepareAction<R> action) {
 final CalcitePrepare.Context prepareContext =
   statement.createPrepareContext();
 final JavaTypeFactory typeFactory = prepareContext.getTypeFactory();
 final CalciteSchema schema =
   action.getConfig().getDefaultSchema() != null
     ? CalciteSchema.from(action.getConfig().getDefaultSchema())
     : prepareContext.getRootSchema();
 CalciteCatalogReader catalogReader =
   new CalciteCatalogReader(schema.root(),
     prepareContext.config().caseSensitive(),
     schema.path(null),
     typeFactory);
 final RexBuilder rexBuilder = new RexBuilder(typeFactory);
 final RelOptPlanner planner =
   createPlanner(prepareContext,
     action.getConfig().getContext(),
     action.getConfig().getCostFactory());
 final RelOptCluster cluster = createCluster(planner, rexBuilder);
 return action.apply(cluster, catalogReader,
   prepareContext.getRootSchema().plus(), statement);
}
org.apache.calcite.configCalciteConnectionConfigcaseSensitive

Popular methods of CalciteConnectionConfig

  • defaultNullCollation
  • quotedCasing
  • quoting
  • timeZone
  • unquotedCasing
  • typeSystem
  • autoTemp
  • conformance
  • forceDecorrelate
  • fun
  • materializationsEnabled
  • parserFactory
  • materializationsEnabled,
  • parserFactory,
  • approximateDecimal,
  • approximateDistinctCount,
  • approximateTopN,
  • createMaterializations,
  • model,
  • schema,
  • schemaFactory

Popular in Java

  • Making http requests using okhttp
  • getExternalFilesDir (Context)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • getSystemService (Context)
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • LinkedList (java.util)
    Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
  • Set (java.util)
    A Set is a data structure which does not allow duplicate elements.
  • Vector (java.util)
    Vector is an implementation of List, backed by an array and synchronized. All optional operations in
  • AtomicInteger (java.util.concurrent.atomic)
    An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
  • IOUtils (org.apache.commons.io)
    General IO stream manipulation utilities. This class provides static utility methods for input/outpu
  • Best IntelliJ plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now