Java Casing类代码示例

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public Parser getParser(String sql, Properties info)
    throws SQLException {
  SqlParser parser = SqlParser.create(sql,
      SqlParser.configBuilder()
          .setQuotedCasing(Casing.UNCHANGED)
          .setUnquotedCasing(Casing.UNCHANGED)
          .setQuoting(Quoting.DOUBLE_QUOTE)
          .setParserFactory(QuarkParserImpl.FACTORY)
          .build());
  SqlNode sqlNode;
  try {
    sqlNode = parser.parseStmt();
  } catch (SqlParseException e) {
    throw new RuntimeException(
        "parse failed: " + e.getMessage(), e);
  }
  if (sqlNode.getKind().equals(SqlKind.OTHER_DDL)) {
    return new DDLParser();
  } else  {
    return getSqlQueryParser(info);
  }
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
private Planner buildPlanner(QueryContext context) {
  final List<RelTraitDef> traitDefs = new ArrayList<RelTraitDef>();
  traitDefs.add(ConventionTraitDef.INSTANCE);
  traitDefs.add(RelCollationTraitDef.INSTANCE);
  final ChainedSqlOperatorTable opTab =
      new ChainedSqlOperatorTable(
          ImmutableList.of(SqlStdOperatorTable.instance(),
              HiveSqlOperatorTable.instance(), catalogReader));
  FrameworkConfig config = Frameworks.newConfigBuilder() //
      .parserConfig(SqlParser.configBuilder()
          .setQuotedCasing(Casing.UNCHANGED)
          .setUnquotedCasing(Casing.TO_UPPER)
          .setQuoting(Quoting.DOUBLE_QUOTE)
          .build()) //
      .defaultSchema(context.getDefaultSchema()) //
      .operatorTable(opTab) //
      .traitDefs(traitDefs) //
      .convertletTable(StandardConvertletTable.INSTANCE)//
      .programs(getPrograms()) //
      .typeSystem(RelDataTypeSystem.DEFAULT) //
      .build();
  return Frameworks.getPlanner(config);
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
/**
 * Unquotes a quoted string, using different quotes for beginning and end.
 */
public static String strip(String s, String startQuote, String endQuote,
    String escape, Casing casing) {
  if (startQuote != null) {
    assert endQuote != null;
    assert startQuote.length() == 1;
    assert endQuote.length() == 1;
    assert escape != null;
    assert s.startsWith(startQuote) && s.endsWith(endQuote) : s;
    s = s.substring(1, s.length() - 1).replace(escape, endQuote);
  }
  switch (casing) {
  case TO_UPPER:
    return s.toUpperCase(Locale.ROOT);
  case TO_LOWER:
    return s.toLowerCase(Locale.ROOT);
  default:
    return s;
  }
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1305">[CALCITE-1305]
 * Case-insensitive table aliases and GROUP BY</a>. */
@Test public void testCaseInsensitiveTableAliasInGroupBy() {
  final SqlTester tester1 = tester
      .withCaseSensitive(false)
      .withUnquotedCasing(Casing.UNCHANGED);
  tester1.checkQuery("select deptno, count(*) from EMP AS emp\n"
      + "group by eMp.deptno");
  tester1.checkQuery("select deptno, count(*) from EMP AS EMP\n"
      + "group by eMp.deptno");
  tester1.checkQuery("select deptno, count(*) from EMP\n"
      + "group by eMp.deptno");
  tester1.checkQuery("select * from EMP where exists (\n"
      + "  select 1 from dept\n"
      + "  group by eMp.deptno)");
  tester1.checkQuery("select deptno, count(*) from EMP group by DEPTNO");
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public static IdentifierCasing getIdentifierCasing(Casing casing, boolean caseSensitive) {
  switch(casing) {
  case TO_LOWER:
    return IdentifierCasing.IC_STORES_LOWER;

  case TO_UPPER:
    return IdentifierCasing.IC_STORES_UPPER;

  case UNCHANGED:
    return caseSensitive ? IdentifierCasing.IC_SUPPORTS_MIXED : IdentifierCasing.IC_STORES_MIXED;

  default:
    throw new AssertionError("Unknown casing:" + casing);
  }
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private T parseSql(String sql) throws SQLException {
    logger.debug("[parseSql]");
    try {
        SqlParser sqlParser = SqlParser.create(sql, SqlParser.configBuilder()
                .setParserFactory(SqlParserImpl.FACTORY)
                .setUnquotedCasing(Casing.TO_LOWER)
                .setQuoting(Quoting.DOUBLE_QUOTE)
                .build());
        return (T) sqlParser.parseStmt();
    } catch (SqlParseException exc) {
        throw new SQLException("Could not parse sql: " + sql, exc);
    }
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
/**
 * Converts the contents of an sql quoted string literal into the
 * corresponding Java string representation (removing leading and trailing
 * quotes and unescaping internal doubled quotes).
 */
public static String parseString(String s) {
  int i = s.indexOf("'"); // start of body
  if (i > 0) {
    s = s.substring(i);
  }
  return strip(s, "'", "'", "''", Casing.UNCHANGED);
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
private ConfigImpl(int identifierMaxLength, Casing quotedCasing,
    Casing unquotedCasing, Quoting quoting, boolean caseSensitive,
    SqlConformance conformance, SqlParserImplFactory parserFactory) {
  this.identifierMaxLength = identifierMaxLength;
  this.caseSensitive = caseSensitive;
  this.conformance = Preconditions.checkNotNull(conformance);
  this.quotedCasing = Preconditions.checkNotNull(quotedCasing);
  this.unquotedCasing = Preconditions.checkNotNull(unquotedCasing);
  this.quoting = Preconditions.checkNotNull(quoting);
  this.parserFactory = Preconditions.checkNotNull(parserFactory);
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public SqlParser createParser(SqlTestFactory factory, String sql) {
  return SqlParser.create(sql,
      SqlParser.configBuilder()
          .setQuoting((Quoting) factory.get("quoting"))
          .setUnquotedCasing((Casing) factory.get("unquotedCasing"))
          .setQuotedCasing((Casing) factory.get("quotedCasing"))
          .setConformance((SqlConformance) factory.get("conformance"))
          .build());
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
private Casing unquotedCasing() {
  return UNQUOTED_CASING.getEnum(getProperties(), Casing.class);
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
private Casing quotedCasing() {
  return QUOTED_CASING.getEnum(getProperties(), Casing.class);
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public boolean storesMixedCaseIdentifiers() throws SQLException {
  return !caseSensitive() && unquotedCasing() == Casing.UNCHANGED;
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public boolean supportsMixedCaseIdentifiers() throws SQLException {
  return caseSensitive() && unquotedCasing() == Casing.UNCHANGED;
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public boolean storesUpperCaseIdentifiers() throws SQLException {
  return unquotedCasing() == Casing.TO_UPPER;
}
 

import org.apache.calcite.avatica.util.Casing; //导入依赖的package包/类
public boolean storesLowerCaseIdentifiers() throws SQLException {
  return unquotedCasing() == Casing.TO_LOWER;
}