How to use

SqlTypeFactoryImpl

in

org.apache.calcite.sql.type

@Test
public void testCreateSqlType() {
  RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  DataType kylinDataType = DataType.getType("array<string>");

public RelDataType createSqlType(SqlTypeName typeName) {
 if (typeName.allowsPrec()) {
  return createSqlType(typeName, typeSystem.getDefaultPrecision(typeName));
 }
 assertBasic(typeName);
 RelDataType newType = new BasicSqlType(typeSystem, typeName);
 return canonize(newType);
}

@Override public RelDataType createTypeWithNullability(
  final RelDataType type,
  final boolean nullable) {
 final RelDataType newType;
 if (type instanceof BasicSqlType) {
  newType = ((BasicSqlType) type).createWithNullability(nullable);
 } else if (type instanceof MapSqlType) {
  newType = copyMapType(type, nullable);
 } else if (type instanceof ArraySqlType) {
  newType = copyArrayType(type, nullable);
 } else if (type instanceof MultisetSqlType) {
  newType = copyMultisetType(type, nullable);
 } else if (type instanceof IntervalSqlType) {
  newType = copyIntervalType(type, nullable);
 } else if (type instanceof ObjectSqlType) {
  newType = copyObjectType(type, nullable);
 } else {
  return super.createTypeWithNullability(type, nullable);
 }
 return canonize(newType);
}

  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));
  is(false));
final RelDataType bigintNullableArray =
  typeFactory.createArrayType(bigintNullable, -1);
final RelDataType bigintArrayNullable =
  typeFactory.createTypeWithNullability(bigintNullableArray, true);
final RelDataType bigintNotNullArray =
  new ArraySqlType(bigintNotNull, false);

if (isJavaType(type)) {
 ++javaCount;
return createTypeWithNullability(createSqlType(SqlTypeName.ANY),
  nullCount > 0 || nullableCount > 0);
if (isJavaType(type) && javaCount + nullCount < types.size()) {
 final RelDataType originalType = type;
 type = typeName.allowsPrecScale(true, true)
   ? createSqlType(typeName, type.getPrecision(), type.getScale())
   : typeName.allowsPrecScale(true, false)
   ? createSqlType(typeName, type.getPrecision())
   : createSqlType(typeName);
 type = createTypeWithNullability(type, originalType.isNullable());
 resultType = type;
 if (resultType.getSqlTypeName() == SqlTypeName.ROW) {
  return leastRestrictiveStructuredType(types);
  resultType = createSqlType(resultType.getSqlTypeName());
 } else if (SqlTypeUtil.isLob(type)) {
  resultType = createSqlType(type.getSqlTypeName());
 } else if (SqlTypeUtil.isBoundedVariableWidth(resultType)) {
  resultType =
    createSqlType(
      resultType.getSqlTypeName(),
      precision);
    createSqlType(

    .apply(new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT) {
      @Override
      public RelDataType copyType(RelDataType type) {
RelDataTypeFactory.FieldInfoBuilder fieldInfo = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT).builder();

 @Override
 public RelDataType createSqlType(SqlTypeName typeName, int precision) {
  switch (typeName) {
  case TIME:
  case TIMESTAMP:
   return super.createSqlType(typeName, RelDataTypeSystemImpl.SUPPORTED_DATETIME_PRECISION);
  default:
   return super.createSqlType(typeName, precision);
  }
 }
}

private RelDataType leastRestrictiveByCast(List<RelDataType> types) {
 RelDataType resultType = types.get(0);
 boolean anyNullable = resultType.isNullable();
 for (int i = 1; i < types.size(); i++) {
  RelDataType type = types.get(i);
  if (type.getSqlTypeName() == SqlTypeName.NULL) {
   anyNullable = true;
   continue;
  }
  if (type.isNullable()) {
   anyNullable = true;
  }
  if (SqlTypeUtil.canCastFrom(type, resultType, false)) {
   resultType = type;
  } else {
   if (!SqlTypeUtil.canCastFrom(resultType, type, false)) {
    return null;
   }
  }
 }
 if (anyNullable) {
  return createTypeWithNullability(resultType, true);
 } else {
  return resultType;
 }
}

public RelDataType createArrayType(
  RelDataType elementType,
  long maxCardinality) {
 assert maxCardinality == -1;
 ArraySqlType newType = new ArraySqlType(elementType, false);
 return canonize(newType);
}

public RelDataType createSqlType(
  SqlTypeName typeName,
  int precision,
  int scale) {
 assertBasic(typeName);
 assert (precision >= 0)
   || (precision == RelDataType.PRECISION_NOT_SPECIFIED);
 final int maxPrecision = typeSystem.getMaxPrecision(typeName);
 if (maxPrecision >= 0 && precision > maxPrecision) {
  precision = maxPrecision;
 }
 RelDataType newType =
   new BasicSqlType(typeSystem, typeName, precision, scale);
 newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
 return canonize(newType);
}

 private RelDataType struct(RelDataType...relDataTypes) {
  final RelDataTypeFactory.Builder builder = f.typeFactory.builder();
  for (int i = 0; i < relDataTypes.length; i++) {
   builder.add("field" + i, relDataTypes[i]);
  }
  return builder.build();
 }
}

  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));
  is(false));
final RelDataType bigintNullableArray =
  typeFactory.createArrayType(bigintNullable, -1);
final RelDataType bigintArrayNullable =
  typeFactory.createTypeWithNullability(bigintNullableArray, true);
final RelDataType bigintNotNullArray =
  new ArraySqlType(bigintNotNull, false);

if (isJavaType(type)) {
 ++javaCount;
return createTypeWithNullability(createSqlType(SqlTypeName.ANY),
  nullCount > 0 || nullableCount > 0);
if (isJavaType(type) && javaCount + nullCount < types.size()) {
 final RelDataType originalType = type;
 type = typeName.allowsPrecScale(true, true)
   ? createSqlType(typeName, type.getPrecision(), type.getScale())
   : typeName.allowsPrecScale(true, false)
   ? createSqlType(typeName, type.getPrecision())
   : createSqlType(typeName);
 type = createTypeWithNullability(type, originalType.isNullable());
 resultType = type;
 if (resultType.getSqlTypeName() == SqlTypeName.ROW) {
  return leastRestrictiveStructuredType(types);
  resultType = createSqlType(resultType.getSqlTypeName());
 } else if (SqlTypeUtil.isLob(type)) {
  resultType = createSqlType(type.getSqlTypeName());
 } else if (SqlTypeUtil.isBoundedVariableWidth(resultType)) {
  resultType =
    createSqlType(
      resultType.getSqlTypeName(),
      precision);
    createSqlType(

private RelDataType createDoublePrecisionType() {
 return createSqlType(SqlTypeName.DOUBLE);
}

private RelDataType leastRestrictiveByCast(List<RelDataType> types) {
 RelDataType resultType = types.get(0);
 boolean anyNullable = resultType.isNullable();
 for (int i = 1; i < types.size(); i++) {
  RelDataType type = types.get(i);
  if (type.getSqlTypeName() == SqlTypeName.NULL) {
   anyNullable = true;
   continue;
  }
  if (type.isNullable()) {
   anyNullable = true;
  }
  if (SqlTypeUtil.canCastFrom(type, resultType, false)) {
   resultType = type;
  } else {
   if (!SqlTypeUtil.canCastFrom(resultType, type, false)) {
    return null;
   }
  }
 }
 if (anyNullable) {
  return createTypeWithNullability(resultType, true);
 } else {
  return resultType;
 }
}

public RelDataType createSqlIntervalType(
  SqlIntervalQualifier intervalQualifier) {
 RelDataType newType =
   new IntervalSqlType(typeSystem, intervalQualifier, false);
 return canonize(newType);
}

public RelDataType createSqlType(
  SqlTypeName typeName,
  int precision,
  int scale) {
 assertBasic(typeName);
 assert (precision >= 0)
   || (precision == RelDataType.PRECISION_NOT_SPECIFIED);
 final int maxPrecision = typeSystem.getMaxPrecision(typeName);
 if (maxPrecision >= 0 && precision > maxPrecision) {
  precision = maxPrecision;
 }
 RelDataType newType =
   new BasicSqlType(typeSystem, typeName, precision, scale);
 newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
 return canonize(newType);
}

 private RelDataType struct(RelDataType...relDataTypes) {
  final RelDataTypeFactory.Builder builder = f.typeFactory.builder();
  for (int i = 0; i < relDataTypes.length; i++) {
   builder.add("field" + i, relDataTypes[i]);
  }
  return builder.build();
 }
}

@Test
public void testLegalDecimalType() {
  RelDataTypeSystem typeSystem = new KylinRelDataTypeSystem();
  RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(typeSystem);
  
  DataType dataType = DataType.getType("decimal(30, 10)");
  RelDataType relDataType = OLAPTable.createSqlType(typeFactory, dataType, true);
  
  Assert.assertTrue(relDataType instanceof BasicSqlType);
  Assert.assertEquals(relDataType.getSqlTypeName(), SqlTypeName.DECIMAL);
  Assert.assertEquals(relDataType.getPrecision(), 30);
  Assert.assertTrue(relDataType.getPrecision() <= typeSystem.getMaxNumericPrecision());
  Assert.assertEquals(relDataType.getScale(), 10);
  Assert.assertTrue(relDataType.getScale() <= typeSystem.getMaxNumericScale());
}

public RelDataType createSqlType(SqlTypeName typeName) {
 if (typeName.allowsPrec()) {
  return createSqlType(typeName, typeSystem.getDefaultPrecision(typeName));
 }
 assertBasic(typeName);
 RelDataType newType = new BasicSqlType(typeSystem, typeName);
 return canonize(newType);
}