Refine search
public static List<ColumnMetaData> createColumnMetaData(final RelDataType rowType) List<RelDataTypeField> fieldList = rowType.getFieldList(); final ColumnMetaData.Rep rep = QueryMaker.rep(field.getType().getSqlTypeName()); final ColumnMetaData.ScalarType columnType = ColumnMetaData.scalar( field.getType().getSqlTypeName().getJdbcOrdinal(), field.getType().getSqlTypeName().getName(), rep );
final public SqlIdentifier CollectionsTypeName() throws ParseException { jj_consume_token(MULTISET); {if (true) return new SqlIdentifier( SqlTypeName.MULTISET.name(), getPos());} throw new Error("Missing return statement in function"); }
SqlAggFunction createCustomAggFunction(String funcName, RelDataType returnType, Class<?> customAggFuncClz) { RelDataTypeFactory typeFactory = getCluster().getTypeFactory(); SqlIdentifier sqlIdentifier = new SqlIdentifier(funcName, new SqlParserPos(1, 1)); AggregateFunction aggFunction = AggregateFunctionImpl.create(customAggFuncClz); List<RelDataType> argTypes = new ArrayList<RelDataType>(); List<SqlTypeFamily> typeFamilies = new ArrayList<SqlTypeFamily>(); for (FunctionParameter o : aggFunction.getParameters()) { final RelDataType type = o.getType(typeFactory); argTypes.add(type); typeFamilies.add(Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY)); } return new SqlUserDefinedAggFunction(sqlIdentifier, ReturnTypes.explicit(returnType), InferTypes.explicit(argTypes), OperandTypes.family(typeFamilies), aggFunction, false, false, typeFactory); }
@Override public Object[] apply(final RelDataTypeField field) { final RelDataType type = field.getType(); boolean isNumeric = SqlTypeName.NUMERIC_TYPES.contains(type.getSqlTypeName()); boolean isCharacter = SqlTypeName.CHAR_TYPES.contains(type.getSqlTypeName()); boolean isDateTime = SqlTypeName.DATETIME_TYPES.contains(type.getSqlTypeName()); return new Object[]{ CATALOG_NAME, // TABLE_CATALOG schemaName, // TABLE_SCHEMA tableName, // TABLE_NAME field.getName(), // COLUMN_NAME String.valueOf(field.getIndex()), // ORDINAL_POSITION "", // COLUMN_DEFAULT type.isNullable() ? "YES" : "NO", // IS_NULLABLE type.getSqlTypeName().toString(), // DATA_TYPE null, // CHARACTER_MAXIMUM_LENGTH null, // CHARACTER_OCTET_LENGTH isNumeric ? String.valueOf(type.getPrecision()) : null, // NUMERIC_PRECISION isNumeric ? "10" : null, // NUMERIC_PRECISION_RADIX isNumeric ? String.valueOf(type.getScale()) : null, // NUMERIC_SCALE isDateTime ? String.valueOf(type.getPrecision()) : null, // DATETIME_PRECISION isCharacter ? type.getCharset().name() : null, // CHARACTER_SET_NAME isCharacter ? type.getCollation().getCollationName() : null, // COLLATION_NAME Long.valueOf(type.getSqlTypeName().getJdbcOrdinal()) // JDBC_TYPE (Druid extension) }; } }
CalcitePrepare.Context context = abortException.getContext(); CalcitePrepare.ParseResult preparedResult = abortException.getPreparedResult(); List<RelDataTypeField> fieldList = preparedResult.rowType.getFieldList(); columnName, null, null, null, basicSqlType.getPrecision(), basicSqlType.getScale() < 0 ? 0 : basicSqlType.getScale(), basicSqlType.getSqlTypeName().getJdbcOrdinal(), basicSqlType.getSqlTypeName().getName(), true, false, false));
int nameIndex = sqlIdentifier.names.size(); RexFieldAccess access; while ((access = accesses.pollLast()) != null) { sqlIdentifier = sqlIdentifier.add(nameIndex++, access.getField().getName(), POS); SqlNode refNode = field(ref.getIndex()); final SqlIdentifier id = (SqlIdentifier) refNode; if (id.names.size() > 1) { return id.setName(0, pv); } else { return new SqlIdentifier(ImmutableList.of(pv, id.names.get(0)), POS); return SqlLiteral.createSymbol(symbol, POS); switch (literal.getTypeName().getFamily()) { case CHARACTER: return SqlLiteral.createCharString((String) literal.getValue2(), POS); return SqlLiteral.createInterval(negative ? -1 : 1, literal.getValueAs(String.class), literal.getType().getIntervalQualifier(), POS); case DATE: return SqlLiteral.createDate(literal.getValueAs(DateString.class),
MajorType castType = null; final SqlTypeName argType = call.getOperands().get(0).getType().getSqlTypeName(); switch(call.getType().getSqlTypeName()) { case VARCHAR: case CHAR: break; case ANY: return arg; // Type will be same as argument. default: castType = Types.required(MinorType.valueOf(call.getType().getSqlTypeName().getName())); switch (sourceExpression.getType().getSqlTypeName().getFamily()) { case INTERVAL_DAY_TIME: case INTERVAL_YEAR_MONTH: sourceExpression.getType().getSqlTypeName().getEndUnit().multiplier.intValue()); if (call.getType().getSqlTypeName() == SqlTypeName.INTEGER) { final List<LogicalExpression> args = ImmutableList.of(castExpr, divider); final LogicalExpression divisionOp = FunctionCallFactory.createExpression("divide", args); return FunctionCallFactory.createCast(Types.required(MinorType.INT), divisionOp); final List<LogicalExpression> args = ImmutableList.of(castExpr, divider); return FunctionCallFactory.createExpression("divide", args);
private ImmutableList<MetaTypeInfo> getAllDefaultType() { final ImmutableList.Builder<MetaTypeInfo> allTypeList = ImmutableList.builder(); final CalciteConnectionImpl conn = (CalciteConnectionImpl) connection; final RelDataTypeSystem typeSystem = conn.typeFactory.getTypeSystem(); for (SqlTypeName sqlTypeName : SqlTypeName.values()) { allTypeList.add( new MetaTypeInfo(sqlTypeName.getName(), sqlTypeName.getJdbcOrdinal(), typeSystem.getMaxPrecision(sqlTypeName), typeSystem.getLiteral(sqlTypeName, true), typeSystem.getLiteral(sqlTypeName, false), // All types are nullable (short) DatabaseMetaData.typeNullable, typeSystem.isCaseSensitive(sqlTypeName), // Making all type searchable; we may want to // be specific and declare under SqlTypeName (short) DatabaseMetaData.typeSearchable, false, false, typeSystem.isAutoincrement(sqlTypeName), (short) sqlTypeName.getMinScale(), (short) typeSystem.getMaxScale(sqlTypeName), typeSystem.getNumTypeRadix(sqlTypeName))); } return allTypeList.build(); }
int iFormalOperand, boolean throwOnFailure) { SqlTypeFamily family = families.get(iFormalOperand); if (family == SqlTypeFamily.ANY) { callBinding.getScope(), node); SqlTypeName typeName = type.getSqlTypeName(); if (typeName.getFamily() == SqlTypeFamily.ANY) { return true;
private Object toJson(RelDataType node) { if (node.isStruct()) { final List<Object> list = jsonBuilder.list(); for (RelDataTypeField field : node.getFieldList()) { list.add(toJson(field)); } return list; } else { final Map<String, Object> map = jsonBuilder.map(); map.put("type", node.getSqlTypeName().name()); map.put("nullable", node.isNullable()); if (node.getSqlTypeName().allowsPrec()) { map.put("precision", node.getPrecision()); } if (node.getSqlTypeName().allowsScale()) { map.put("scale", node.getScale()); } return map; } }
final RelDataType rowType = table.calciteTable.getRowType(getConnection().typeFactory); return Linq4j.asEnumerable(rowType.getFieldList()) .select(field -> { final int precision = field.getType().getSqlTypeName().allowsPrec() && !(field.getType() instanceof RelDataTypeFactoryImpl.JavaType) ? field.getType().getPrecision() : -1; return new MetaColumn( table.tableName, field.getName(), field.getType().getSqlTypeName().getJdbcOrdinal(), field.getType().getFullTypeString(), precision, field.getType().getSqlTypeName().allowsScale() ? field.getType().getScale() : null,
SqlTypeName typeName = type.getSqlTypeName(); new SqlIdentifier( typeName.name(), SqlParserPos.ZERO); charSetName = type.getCharset().name(); if (typeName.allowsScale()) { return new SqlDataTypeSpec( typeIdentifier, type.getPrecision(), type.getScale(), charSetName, null, SqlParserPos.ZERO); } else if (typeName.allowsPrec()) { return new SqlDataTypeSpec( typeIdentifier,
final SqlTypeName sqlTypeName = relDataType.getSqlTypeName(); this.DATA_TYPE = sqlTypeName.name(); break; logger.warn( "Type not handled explicitly (code needs review): " + sqlTypeName ); this.DATA_TYPE = sqlTypeName.toString(); break; case CHAR: case VARCHAR: this.CHARACTER_MAXIMUM_LENGTH = relDataType.getPrecision(); if ( this.CHARACTER_MAXIMUM_LENGTH < Integer.MAX_VALUE / MAX_UTF8_BYTES_PER_CHARACTER ) { this.CHARACTER_MAXIMUM_LENGTH = relDataType.getPrecision(); this.CHARACTER_OCTET_LENGTH = this.CHARACTER_MAXIMUM_LENGTH;
private SqlNode literal(RelDataType type, Object value) { if (value == null) { int precision = type.getPrecision(); int scale = type.getScale(); if (!type.getSqlTypeName().allowsPrec()) { precision = -1; if (!type.getSqlTypeName().allowsScale()) { scale = -1; SqlLiteral.createNull(SqlParserPos.ZERO), new SqlDataTypeSpec( new SqlIdentifier(type.getSqlTypeName().getName(), SqlParserPos.ZERO), precision, scale, null, null, SqlParserPos.ZERO));
/*********************** Convert Calcite Types To Hive Types ***********************/ public static HiveToken hiveToken(RelDataType calciteType) { HiveToken ht = null; switch (calciteType.getSqlTypeName()) { case CHAR: { ht = new HiveToken(HiveParser.TOK_CHAR, "TOK_CHAR", String.valueOf(calciteType.getPrecision())); } break; case VARCHAR: { if (calciteType.getPrecision() == Integer.MAX_VALUE) ht = new HiveToken(HiveParser.TOK_STRING, "TOK_STRING", String.valueOf(calciteType .getPrecision())); else ht = new HiveToken(HiveParser.TOK_VARCHAR, "TOK_VARCHAR", String.valueOf(calciteType .getPrecision())); } break; case DECIMAL: { ht = new HiveToken(HiveParser.TOK_DECIMAL, "TOK_DECIMAL", String.valueOf(calciteType .getPrecision()), String.valueOf(calciteType.getScale())); } break; default: ht = calciteToHiveTypeNameMap.get(calciteType.getSqlTypeName().getName()); } return ht; } }
private List<Pair<ColumnMetaData.Rep, Integer>> fieldClasses( final JavaTypeFactory typeFactory) { final RelDataType rowType = protoRowType.apply(typeFactory); return Lists.transform(rowType.getFieldList(), f -> { final RelDataType type = f.getType(); final Class clazz = (Class) typeFactory.getJavaClass(type); final ColumnMetaData.Rep rep = Util.first(ColumnMetaData.Rep.of(clazz), ColumnMetaData.Rep.OBJECT); return Pair.of(rep, type.getSqlTypeName().getJdbcOrdinal()); }); }
if (rowType2.getFieldCount() != rowType1.getFieldCount()) { return false; final List<RelDataTypeField> f1 = rowType1.getFieldList(); final List<RelDataTypeField> f2 = rowType2.getFieldList(); for (Pair<RelDataTypeField, RelDataTypeField> pair : Pair.zip(f1, f2)) { if (!type1.getSqlTypeName().equals(type2.getSqlTypeName())) { return false;
private static CalciteUDFInfo getUDFInfo(String hiveUdfName, ImmutableList<RelDataType> calciteArgTypes, RelDataType calciteRetType) { CalciteUDFInfo udfInfo = new CalciteUDFInfo(); udfInfo.udfName = hiveUdfName; udfInfo.returnTypeInference = ReturnTypes.explicit(calciteRetType); udfInfo.operandTypeInference = InferTypes.explicit(calciteArgTypes); ImmutableList.Builder<SqlTypeFamily> typeFamilyBuilder = new ImmutableList.Builder<SqlTypeFamily>(); for (RelDataType at : calciteArgTypes) { typeFamilyBuilder.add(Util.first(at.getSqlTypeName().getFamily(), SqlTypeFamily.ANY)); } udfInfo.operandTypeChecker = OperandTypes.family(typeFamilyBuilder.build()); return udfInfo; }
protected static RelDataTypeFamily family(RelDataType type) { // REVIEW jvs 2-June-2005: This is needed to keep // the Saffron type system happy. RelDataTypeFamily family = null; if (type.getSqlTypeName() != null) { family = type.getSqlTypeName().getFamily(); } if (family == null) { family = type.getFamily(); } return family; }
private boolean areTypesCompatible(RelDataType type1, RelDataType type2) { if (type1.equals(type2)) { return true; } SqlTypeName sqlType1 = type1.getSqlTypeName(); if (sqlType1 != null) { return sqlType1.equals(type2.getSqlTypeName()); } return false; } }