public String name() { return get(0).toString(); }
private void genParamPath(SqlNode sqlNode, List<Integer> path) { if (sqlNode instanceof SqlIdentifier) { int paramIdx = ParamNodeParser.parseParamIdx(sqlNode.toString()); if (paramIdx >= 0 && path.size() > 0) { paramPath.put(paramIdx, path); } } else if (sqlNode instanceof SqlCall) { List<SqlNode> operands = ((SqlCall) sqlNode).getOperandList(); for (int i = 0; i < operands.size(); i++) { List<Integer> copiedPath = Lists.newArrayList(path); copiedPath.add(i); genParamPath(operands.get(i), copiedPath); } } }
if (queryNode != null && exprNode != null) { if (exprNode instanceof SqlIdentifier) { int parsedIdx = ParamNodeParser.parseParamIdx(exprNode.toString()); if (parsedIdx >= 0) { SqlNode matchedBefore = matchedNodesMap.get(parsedIdx);
if (parsed instanceof SqlCall || parsed instanceof SqlIdentifier) { String name = parsed instanceof SqlCall ? ((SqlCall) parsed).getOperator().getName() : parsed.toString(); List<String> defIds = functionNameDefMap.get(name); if (defIds == null) {
@Test public void testParamFinder() throws SqlParseException { SqlParser sqlParser1 = SqlParser.create("POWER($0, $1) + AVG(LN($3)) + EXP($5)"); SqlNode sqlPattern = sqlParser1.parseExpression(); SqlParser sqlParser2 = SqlParser.create("POWER(3, POWER(2, POWER(2, 3))) + AVG(LN(EXP(4))) + EXP(CAST('2018-03-22' AS DATE))"); SqlNode sqlCall = sqlParser2.parseExpression(); SqlParamsFinder sqlParamsFinder = new SqlParamsFinder((SqlCall)sqlPattern, (SqlCall)sqlCall); Map<Integer, SqlNode> paramNodes = sqlParamsFinder.getParamNodes(); Assert.assertEquals("3", paramNodes.get(0).toString()); Assert.assertEquals("POWER(2, POWER(2, 3))", paramNodes.get(1).toString()); Assert.assertEquals("EXP(4)", paramNodes.get(3).toString()); Assert.assertEquals("CAST('2018-03-22' AS DATE)", paramNodes.get(5).toString()); }
@Test public void testWindowCallParams() throws SqlParseException { SqlParser sqlParser1 = SqlParser.create("STDDEV_POP($0) OVER($1)"); SqlNode sqlPattern = sqlParser1.parseExpression(); SqlParser sqlParser2 = SqlParser.create("STDDEV_POP(C1) OVER (ORDER BY C1)"); SqlNode sqlCall = sqlParser2.parseExpression(); SqlParamsFinder sqlParamsFinder = SqlParamsFinder.newInstance((SqlCall)sqlPattern, (SqlCall)sqlCall, true); Map<Integer, SqlNode> paramNodes = sqlParamsFinder.getParamNodes(); Assert.assertEquals("C1", paramNodes.get(0).toString()); Assert.assertEquals("(ORDER BY `C1`)", paramNodes.get(1).toString()); Assert.assertTrue(paramNodes.get(1) instanceof SqlWindow); } }
Pair<SqlNode, SqlNode> matchSqlFunc(SqlNode sourceFunc) { if (sourceFunc == null || sourceDS == null || targetDS == null) return null; if (sourceFunc instanceof SqlCall || sourceFunc instanceof SqlIdentifier) { String funcName = sourceFunc instanceof SqlCall ? ((SqlCall) sourceFunc).getOperator().getName() : sourceFunc.toString(); List<String> validDefIds = sourceDS.getFuncDefsByName(funcName); if (validDefIds != null) { for (String defId : validDefIds) { SqlNode sourceCandidate = sourceDS.getFuncDefSqlNode(defId); if (ExpressionComparator.isNodeEqual(sourceFunc, sourceCandidate, new ParamSqlNodeComparator())) { SqlNode targetTmpl = targetDS.getFuncDefSqlNode(defId); if (targetTmpl != null) return new Pair<>(sourceCandidate, targetDS.getFuncDefSqlNode(defId)); } } } } return null; }
/** * Unwrap a constant in the AST as a Java Object. * * <p>The Calcite validator has folded all the constants by this point. * Thus the function expects either a SqlLiteral or a SqlIdentifier but not a SqlCall.</p> */ private static String unwrapConstant(SqlNode value) { if (value == null) { return null; } else if (value instanceof SqlLiteral) { return ((SqlLiteral) value).toValue(); } else if (value instanceof SqlIdentifier) { return value.toString(); } else { throw new IllegalArgumentException("Invalid constant " + value); } } }
call = (SqlCall) node; if (alias == null) { alias = call.operand(1).toString();
public List<String> getFieldNames() { List<String> fieldNames = Lists.newArrayList(); for (SqlNode node : fieldList.getList()) { fieldNames.add(node.toString()); } return fieldNames; }
public List<String> getDistributionColumns() { List<String> columnNames = Lists.newArrayList(); for(SqlNode node : distributionColumns.getList()) { columnNames.add(node.toString()); } return columnNames; }
public List<String> getSortColumns() { List<String> columnNames = Lists.newArrayList(); for(SqlNode node : sortColumns.getList()) { columnNames.add(node.toString()); } return columnNames; }
@Override public SqlCall createCall(SqlLiteral functionQualifier, SqlParserPos pos, SqlNode... operands) { final SqlNode scopeNode = operands[0]; return new SqlSetOption(pos, scopeNode == null ? null : scopeNode.toString(), (SqlIdentifier) operands[1], operands[2]); } };
private List<String> toStrings(SqlNodeList list){ if(list == null){ return ImmutableList.of(); } List<String> columnNames = Lists.newArrayList(); for(SqlNode node : list.getList()) { columnNames.add(node.toString()); } return columnNames; }
public List<String> getPartitionColumns() { List<String> columnNames = Lists.newArrayList(); for(SqlNode node : partitionColumns.getList()) { columnNames.add(node.toString()); } return columnNames; }
public List<String> getFieldNames() { List<String> fieldNames = Lists.newArrayList(); for (SqlNode node : fieldList.getList()) { fieldNames.add(node.toString()); } return fieldNames; }
public List<String> getPartitionColumns() { List<String> columnNames = Lists.newArrayList(); for(SqlNode node : partitionColumns.getList()) { columnNames.add(node.toString()); } return columnNames; }
public boolean equalsDeep(SqlNode node, Litmus litmus) { final String thisString = this.toString(); final String thatString = node.toString(); if (!thisString.equals(thatString)) { return litmus.fail("{} != {}", this, node); } return litmus.succeed(); }
public boolean equalsDeep(SqlNode node, Litmus litmus) { final String thisString = this.toString(); final String thatString = node.toString(); if (!thisString.equals(thatString)) { return litmus.fail("{} != {}", this, node); } return litmus.succeed(); }
private void checkParseAndConvert(String query, String queryFromParseTree, String expectedRelExpr) throws Exception { Planner planner = getPlanner(null); SqlNode parse = planner.parse(query); assertThat(Util.toLinux(parse.toString()), equalTo(queryFromParseTree)); SqlNode validate = planner.validate(parse); RelNode rel = planner.rel(validate).project(); assertThat(toString(rel), equalTo(expectedRelExpr)); }