/** * Returns the type inferred for a dynamic parameter. * * @param index 0-based index of dynamic parameter * @return inferred type, never null */ public RelDataType getDynamicParamType(int index) { SqlNode sqlNode = dynamicParamSqlNodes.get(index); if (sqlNode == null) { throw Util.needToImplement("dynamic param type inference"); } return validator.getValidatedNodeType(sqlNode); }
protected boolean checkConvertedRowType( SqlNode query, RelDataType convertedRowType) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); return RelOptUtil.equal( "validated row type", validatedRowType, "converted row type", convertedRowType, false); }
SqlTypeUtil.promoteToRowType( typeFactory, validator.getValidatedNodeType(rowList), null);
null); RelDataType multisetType = validator.getValidatedNodeType(call); validator.setValidatedNodeType( list,
rexAgg = rexBuilder.ensureType( validator.getValidatedNodeType(call), rexAgg, false);
validator.getValidatedNodeType(call); assert targetRowType != null; RelNode sourceRel =
private void checkConvertedType(SqlNode query, RelNode result) { if (!query.isA(SqlKind.DML)) { // Verify that conversion from SQL to relational algebra did // not perturb any type information. (We can't do this if the // SQL statement is something like an INSERT which has no // validator type information associated with its result, // hence the namespace check above.) RelDataType convertedRowType = result.getRowType(); if (!checkConvertedRowType(query, convertedRowType)) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); throw Util.newInternal( "Conversion to relational algebra failed to preserve " + "datatypes:\n" + "validated type:\n" + validatedRowType.getFullTypeString() + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n" + RelOptUtil.toString(result)); } } }
&& !validator.getValidatedNodeType(node).isNullable()) { logic = RelOptUtil.Logic.UNKNOWN_AS_FALSE;
rexCall, elementType, validator.getValidatedNodeType(call), columnMappings); bb.setRoot(callRel, true);
/** * Returns the type inferred for a dynamic parameter. * * @param index 0-based index of dynamic parameter * @return inferred type, never null */ public RelDataType getDynamicParamType(int index) { SqlNode sqlNode = dynamicParamSqlNodes.get(index); if (sqlNode == null) { throw Util.needToImplement("dynamic param type inference"); } return validator.getValidatedNodeType(sqlNode); }
/** * Returns the type inferred for a dynamic parameter. * * @param index 0-based index of dynamic parameter * * @return inferred type, never null */ public RelDataType getDynamicParamType(int index) { SqlNode sqlNode = dynamicParamSqlNodes.get(index); if (sqlNode == null) { throw Util.needToImplement("dynamic param type inference"); } return validator.getValidatedNodeType(sqlNode); }
protected boolean checkConvertedRowType( SqlNode query, RelDataType convertedRowType) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); return RelOptUtil.equal( "validated row type", validatedRowType, "converted row type", convertedRowType, false); }
protected boolean checkConvertedRowType( SqlNode query, RelDataType convertedRowType) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); return RelOptUtil.equal( "validated row type", validatedRowType, "converted row type", convertedRowType, false); }
/** * Casts a RexNode value to the validated type of a SqlCall. If the value * was already of the validated type, then the value is returned without an * additional cast. */ public RexNode castToValidatedType( SqlRexContext cx, SqlCall call, RexNode value) { final RelDataType resType = cx.getValidator().getValidatedNodeType(call); if (value.getType() == resType) { return value; } return cx.getRexBuilder().makeCast(resType, value); }
/** * Casts a RexNode value to the validated type of a SqlCall. If the value * was already of the validated type, then the value is returned without an * additional cast. */ public RexNode castToValidatedType( SqlRexContext cx, SqlCall call, RexNode value) { final RelDataType resType = cx.getValidator().getValidatedNodeType(call); if (value.getType() == resType) { return value; } return cx.getRexBuilder().makeCast(resType, value); }
public RelDataType getResultType(String sql) { SqlValidator validator = getValidator(); SqlNode n = parseAndValidate(validator, sql); return validator.getValidatedNodeType(n); }
public RelDataType getResultType(String sql) { SqlValidator validator = getValidator(); SqlNode n = parseAndValidate(validator, sql); RelDataType rowType = validator.getValidatedNodeType(n); return rowType; }
/** * Converts a ROW. * * <p>Called automatically via reflection. */ public RexNode convertRow( SqlRexContext cx, SqlRowOperator op, SqlCall call) { if (cx.getValidator().getValidatedNodeType(call).getSqlTypeName() != SqlTypeName.COLUMN_LIST) { return convertCall(cx, call); } final RexBuilder rexBuilder = cx.getRexBuilder(); final List<RexNode> columns = new ArrayList<RexNode>(); for (SqlNode operand : call.getOperandList()) { columns.add( rexBuilder.makeLiteral( ((SqlIdentifier) operand).getSimple())); } final RelDataType type = rexBuilder.deriveReturnType(SqlStdOperatorTable.COLUMN_LIST, columns); return rexBuilder.makeCall(type, SqlStdOperatorTable.COLUMN_LIST, columns); }
private void checkConvertedType(SqlNode query, RelNode result) { if (!query.isA(SqlKind.DML)) { // Verify that conversion from SQL to relational algebra did // not perturb any type information. (We can't do this if the // SQL statement is something like an INSERT which has no // validator type information associated with its result, // hence the namespace check above.) RelDataType convertedRowType = result.getRowType(); if (!checkConvertedRowType(query, convertedRowType)) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); throw Util.newInternal( "Conversion to relational algebra failed to preserve " + "datatypes:\n" + "validated type:\n" + validatedRowType.getFullTypeString() + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n" + RelOptUtil.toString(result)); } } }
public ParseResult parse( Context context, String sql) { final JavaTypeFactory typeFactory = context.getTypeFactory(); OptiqCatalogReader catalogReader = new OptiqCatalogReader( context.getRootSchema(), context.config().caseSensitive(), context.getDefaultSchemaPath(), typeFactory); SqlParser parser = SqlParser.create(sql); SqlNode sqlNode; try { sqlNode = parser.parseStmt(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } final SqlValidator validator = new OptiqSqlValidator( SqlStdOperatorTable.instance(), catalogReader, typeFactory); SqlNode sqlNode1 = validator.validate(sqlNode); return new ParseResult(this, validator, sql, sqlNode1, validator.getValidatedNodeType(sqlNode1)); }