Java SqlTypeFactoryImpl类代码示例

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
public List<String> getColumnList(final String username, DatasetPath path) {
  final SchemaConfig schemaConfig = SchemaConfig.newBuilder(username)
      .setProvider(new SchemaInfoProvider() {
        private final ViewExpansionContext viewExpansionContext = new ViewExpansionContext(this, schemaProvider, username);

        @Override
        public ViewExpansionContext getViewExpansionContext() {
          return viewExpansionContext;
        }

        @Override
        public OptionValue getOption(String optionKey) {
          throw new UnsupportedOperationException();
        }
      })
      .build();
  final SchemaPlus schema = schemaProvider.getRootSchema(schemaConfig);
  final Table table = path.getTable(schema);
  return table.getRowType(new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT)).getFieldNames();
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
public OctopusTable(MetaTable metaTable, OctopusSchema schema) {
    super(Object[].class);
    name = metaTable.getName();

    try {
        //tableType = Schema.TableType.valueOf(table.getType().name());
        tableType = Schema.TableType.TABLE; // FIXME
    } catch (IllegalArgumentException e) {
        tableType = Schema.TableType.TABLE;
    }

    RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
    RelDataTypeFactory.FieldInfoBuilder fieldInfo = typeFactory.builder();
    for (MetaColumn metaColumn : metaTable.getColumns()) {
        String columnName = metaColumn.getName();
        //int jdbcType = metaColumn.getType().getJdbcType();
        int jdbcType = metaColumn.getType(); //FIXME
        SqlTypeName typeName = SqlTypeName.getNameForJdbcType(jdbcType);
        RelDataType sqlType = typeFactory.createSqlType(typeName);

        fieldInfo.add(columnName, sqlType);
    }
    protoRowType = RelDataTypeImpl.proto(fieldInfo.build());

    this.schema = schema;
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/** Creates an operator table that contains functions in the given class.
 *
 * @see ModelHandler#addFunctions */
public static SqlOperatorTable operatorTable(String className) {
  // Dummy schema to collect the functions
  final CalciteSchema schema =
      CalciteSchema.createRootSchema(false, false);
  ModelHandler.addFunctions(schema.plus(), null, ImmutableList.<String>of(),
      className, "*", true);

  // The following is technical debt; see [CALCITE-2082] Remove
  // RelDataTypeFactory argument from SqlUserDefinedAggFunction constructor
  final SqlTypeFactoryImpl typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);

  final ListSqlOperatorTable table = new ListSqlOperatorTable();
  for (String name : schema.getFunctionNames()) {
    for (Function function : schema.getFunctions(name, true)) {
      final SqlIdentifier id = new SqlIdentifier(name, SqlParserPos.ZERO);
      table.add(
          toOp(typeFactory, id, function));
    }
  }
  return table;
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/** Tests {@link RexBuilder#makeDateLiteral(DateString)}. */
@Test public void testDateLiteral() {
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RelDataType dateType = typeFactory.createSqlType(SqlTypeName.DATE);
  final RexBuilder builder = new RexBuilder(typeFactory);

  // Old way: provide a Calendar
  final Calendar calendar = Util.calendar();
  calendar.set(1969, Calendar.JULY, 21); // one small step
  calendar.set(Calendar.MILLISECOND, 0);
  checkDate(builder.makeLiteral(calendar, dateType, false));

  // Old way #2: Provide in Integer
  checkDate(builder.makeLiteral(MOON_DAY, dateType, false));

  // The new way
  final DateString d = new DateString(1969, 7, 21);
  checkDate(builder.makeLiteral(d, dateType, false));
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
@Override
RelProtoDataType getRelDataType(
		DatabaseMetaData metaData,
		String catalogName,
		String schemaName,
		String tableName
) throws SQLException {
	if (journalledTableKeys.containsKey(tableName)) {
		// 1: Find columns for journal table
		RelDataType relDataType = super
				.getRelDataType(metaData, catalogName, schemaName, journalNameFor(tableName))
				.apply(new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT) {
					@Override
					public RelDataType copyType(RelDataType type) {
						return type;
					}
				});

		RelDataTypeFactory.FieldInfoBuilder fieldInfo = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT).builder();

		// 2: Filter out journal-implementation columns
		for (RelDataTypeField field : relDataType.getFieldList()) {
			String fieldName = field.getName();
			if (fieldName.equals(versionField) || fieldName.equals(subsequentVersionField)) {
				continue;
			}
			fieldInfo.add(field);
		}

		return RelDataTypeImpl.proto(fieldInfo.build());
	} else {
		return super.getRelDataType(metaData, catalogName, schemaName, tableName);
	}
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
@Before
public void setup() {
  MockitoAnnotations.initMocks(this);

  final VolcanoPlanner planner = new VolcanoPlanner();
  typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RelOptCluster cluster = RelOptCluster.create(planner, new RexBuilder(typeFactory));
  builder = DremioRelFactories.LOGICAL_BUILDER.create(cluster, schema);
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/** Creates a CassandraEnumerator.
 *
 * @param results Cassandra result set ({@link com.datastax.driver.core.ResultSet})
 * @param protoRowType The type of resulting rows
 */
CassandraEnumerator(ResultSet results, RelProtoDataType protoRowType) {
  this.iterator = results.iterator();
  this.current = null;

  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  this.fieldTypes = protoRowType.apply(typeFactory).getFieldList();
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
RelProtoDataType getRelDataType(DatabaseMetaData metaData, String catalogName,
    String schemaName, String tableName) throws SQLException {
  final ResultSet resultSet =
      metaData.getColumns(catalogName, schemaName, tableName, null);

  // Temporary type factory, just for the duration of this method. Allowable
  // because we're creating a proto-type, not a type; before being used, the
  // proto-type will be copied into a real type factory.
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  final RelDataTypeFactory.Builder fieldInfo = typeFactory.builder();
  while (resultSet.next()) {
    final String columnName = resultSet.getString(4);
    final int dataType = resultSet.getInt(5);
    final String typeString = resultSet.getString(6);
    final int precision;
    final int scale;
    switch (SqlType.valueOf(dataType)) {
    case TIMESTAMP:
    case TIME:
      precision = resultSet.getInt(9); // SCALE
      scale = 0;
      break;
    default:
      precision = resultSet.getInt(7); // SIZE
      scale = resultSet.getInt(9); // SCALE
      break;
    }
    RelDataType sqlType =
        sqlType(typeFactory, dataType, precision, scale, typeString);
    boolean nullable = resultSet.getInt(11) != DatabaseMetaData.columnNoNulls;
    fieldInfo.add(columnName, sqlType).nullable(nullable);
  }
  resultSet.close();
  return RelDataTypeImpl.proto(fieldInfo.build());
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
@Override public SqlValidator getValidator(SqlTestFactory factory) {
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  final SqlConformance conformance = (SqlConformance) get("conformance");
  final boolean caseSensitive = (Boolean) factory.get("caseSensitive");
  return new SqlAdvisorValidator(
      SqlStdOperatorTable.instance(),
      new MockCatalogReader(typeFactory, caseSensitive).init(),
      typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
@Override public SqlValidator getValidator(SqlTestFactory factory) {
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  SqlConformance conformance = (SqlConformance) get("conformance");
  final boolean caseSensitive = (Boolean) get("caseSensitive");
  return new FeatureValidator(
      factory.createOperatorTable(factory),
      new MockCatalogReader(typeFactory, caseSensitive).init(),
      typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1804">[CALCITE-1804]
 * Cannot assign NOT NULL array to nullable array</a>. */
@Test public void testArrayAssignment() {
  final SqlTypeFactoryImpl typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  final RelDataType bigint = typeFactory.createSqlType(SqlTypeName.BIGINT);
  final RelDataType bigintNullable =
      typeFactory.createTypeWithNullability(bigint, true);
  final RelDataType bigintNotNull =
      typeFactory.createTypeWithNullability(bigint, false);
  final RelDataType date = typeFactory.createSqlType(SqlTypeName.DATE);
  final RelDataType dateNotNull =
      typeFactory.createTypeWithNullability(date, false);
  assertThat(SqlTypeUtil.canAssignFrom(bigintNullable, bigintNotNull),
      is(true));
  assertThat(SqlTypeUtil.canAssignFrom(bigintNullable, dateNotNull),
      is(false));
  final RelDataType bigintNullableArray =
      typeFactory.createArrayType(bigintNullable, -1);
  final RelDataType bigintArrayNullable =
      typeFactory.createTypeWithNullability(bigintNullableArray, true);
  final RelDataType bigintNotNullArray =
      new ArraySqlType(bigintNotNull, false);
  assertThat(SqlTypeUtil.canAssignFrom(bigintArrayNullable, bigintNotNullArray),
      is(true));
  final RelDataType dateNotNullArray =
      new ArraySqlType(dateNotNull, false);
  assertThat(SqlTypeUtil.canAssignFrom(bigintArrayNullable, dateNotNullArray),
      is(false));
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
@Test public void testTypeDump() {
  RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RelDataType t1 =
      typeFactory.builder()
          .add("f0", SqlTypeName.DECIMAL, 5, 2)
          .add("f1", SqlTypeName.VARCHAR, 10)
          .build();
  TestUtil.assertEqualsVerbose(
      TestUtil.fold(
          "f0 DECIMAL(5, 2) NOT NULL,",
          "f1 VARCHAR(10) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\" NOT NULL"),
      Util.toLinux(RelOptUtil.dumpType(t1) + "\n"));

  RelDataType t2 =
      typeFactory.builder()
          .add("f0", t1)
          .add("f1", typeFactory.createMultisetType(t1, -1))
          .build();
  TestUtil.assertEqualsVerbose(
      TestUtil.fold(
          "f0 RECORD (",
          "  f0 DECIMAL(5, 2) NOT NULL,",
          "  f1 VARCHAR(10) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\" NOT NULL) NOT NULL,",
          "f1 RECORD (",
          "  f0 DECIMAL(5, 2) NOT NULL,",
          "  f1 VARCHAR(10) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\" NOT NULL) NOT NULL MULTISET NOT NULL"),
      Util.toLinux(RelOptUtil.dumpType(t2) + "\n"));
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/**
 * Test RexBuilder.ensureType()
 */
@Test
public void testEnsureTypeWithAny() {
  final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RexBuilder builder = new RexBuilder(typeFactory);

  RexNode node =  new RexLiteral(
          Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
  RexNode ensuredNode = builder.ensureType(
          typeFactory.createSqlType(SqlTypeName.ANY), node, true);

  assertEquals(node, ensuredNode);
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/**
 * Test RexBuilder.ensureType()
 */
@Test
public void testEnsureTypeWithItself() {
  final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RexBuilder builder = new RexBuilder(typeFactory);

  RexNode node =  new RexLiteral(
          Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
  RexNode ensuredNode = builder.ensureType(
          typeFactory.createSqlType(SqlTypeName.BOOLEAN), node, true);

  assertEquals(node, ensuredNode);
}
 

import org.apache.calcite.sql.type.SqlTypeFactoryImpl; //导入依赖的package包/类
/**
 * Test RexBuilder.ensureType()
 */
@Test
public void testEnsureTypeWithDifference() {
  final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  RexBuilder builder = new RexBuilder(typeFactory);

  RexNode node =  new RexLiteral(
          Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
  RexNode ensuredNode = builder.ensureType(
          typeFactory.createSqlType(SqlTypeName.INTEGER), node, true);

  assertNotEquals(node, ensuredNode);
  assertEquals(ensuredNode.getType(), typeFactory.createSqlType(SqlTypeName.INTEGER));
}