public String convertColumn(String column, String originQuote) { String converted = column.replace(originQuote, ""); try { SqlNode sqlNode = SqlParser.create(converted).parseExpression(); sqlNode = sqlNode.accept(sqlNodeConverter); converted = sqlWriter.format(sqlNode); } catch (Throwable e) { logger.error("Failed to default convert Column, will use the input: {}", column, e); } finally { sqlWriter.reset(); } return converted; }
/** * Check if the SELECT query has join operation */ public static boolean hasJoinOperation(String selectQuery) { if (selectQuery == null || selectQuery.length() == 0) { return false; } SqlParser sqlParser = SqlParser.create(selectQuery); try { SqlNode all = sqlParser.parseQuery(); SqlSelect query; if (all instanceof SqlSelect) { query = (SqlSelect) all; } else if (all instanceof SqlOrderBy) { query = (SqlSelect) ((SqlOrderBy) all).query; } else { throw new UnsupportedOperationException("The select query is type of " + all.getClass() + " which is not supported here"); } return query.getFrom().getKind() == SqlKind.JOIN; } catch (SqlParseException e) { return false; } }
public static SqlNode parse(String sql) throws SqlParseException { SqlParser.ConfigBuilder parserBuilder = SqlParser.configBuilder(); SqlParser sqlParser = SqlParser.create(sql, parserBuilder.build()); return sqlParser.parseQuery(); }
public String convertSql(String orig) { // for jdbc source, convert quote from backtick to double quote String converted = orig.replaceAll("`", "\""); if (!configurer.skipHandleDefault()) { String escapedDefault = SqlDialect.CALCITE .quoteIdentifier(configurer.useUppercaseDefault() ? "DEFAULT" : "default"); converted = converted.replaceAll("(?i)default\\.", escapedDefault + "."); // use Calcite dialect to cater to SqlParser converted = converted.replaceAll("\"(?i)default\"\\.", escapedDefault + "."); } if (!configurer.skipDefaultConvert()) { try { SqlNode sqlNode = SqlParser.create(converted).parseQuery(); sqlNode = sqlNode.accept(sqlNodeConverter); converted = sqlWriter.format(sqlNode); } catch (Throwable e) { logger.error("Failed to default convert sql, will use the input: {}", orig, e); } finally { sqlWriter.reset(); } } converted = configurer.fixAfterDefaultConvert(converted); return converted; }
function.init(); try { SqlParser sqlParser = SqlParser.create(function.getExpression()); SqlNode parsed = sqlParser.parseExpression(); if (parsed instanceof SqlCall || parsed instanceof SqlIdentifier) {
@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); } }
@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()); }
.build(); final SqlParser parser = SqlParser.create(substituted, config); try { parser.parseStmt();
/** * Returns the underlying Parser metadata. * * <p>To use a different parser (recognizing a different dialect of SQL), * derived class should override. * * @return metadata */ protected SqlAbstractParserImpl.Metadata getParserMetadata() { SqlParser parser = SqlParser.create("", parserConfig); return parser.getMetadata(); }
/** * Returns the underlying Parser metadata. * * <p>To use a different parser (recognizing a different dialect of SQL), * derived class should override. * * @return metadata */ protected SqlAbstractParserImpl.Metadata getParserMetadata() { SqlParser parser = SqlParser.create("", parserConfig); return parser.getMetadata(); }
/** Factory method for SQL parser with a given configuration. */ protected SqlParser createParser(String sql, SqlParser.ConfigBuilder parserConfig) { return SqlParser.create(sql, parserConfig.build()); }
public List<Object> getPlan(String joinSql, SqlParser.Config sqlParserConfig) throws SqlParseException { SqlParser sqlParser = SqlParser.create(joinSql, sqlParserConfig); SqlNode sqlNode = sqlParser.parseStmt(); SqlNode rootNode = sqlParse(sqlNode); plan.add(rootNode); return plan; }
public static SqlNode parse(String sql) throws SqlParseException { SqlParser.ConfigBuilder parserBuilder = SqlParser.configBuilder(); SqlParser sqlParser = SqlParser.create(sql, parserBuilder.build()); return sqlParser.parseQuery(); }
public SqlNode parse(final String sql) throws SqlParseException { switch (state) { case STATE_0_CLOSED: case STATE_1_RESET: ready(); } ensure(State.STATE_2_READY); SqlParser parser = SqlParser.create(sql, parserConfig); SqlNode sqlNode = parser.parseStmt(); state = State.STATE_3_PARSED; return sqlNode; }
/** * Get table names from sql. * * @param sql SQL line * @return List of TableName */ public List<String> parseTableName(String sql) throws SqlParseException { SqlParser parser = SqlParser.create(sql, config); SqlNode sqlNode = parser.parseQuery(sql); return validateTableName(sqlNode.accept(this)); }
public SqlNode parse(String sql) { try { SqlParser parser = SqlParser.create(sql, parserConfig); return parser.parseStmt().accept(STRING_LITERAL_CONVERTER); } catch (SqlParseException e) { UserException.Builder builder = SqlExceptionHelper.parseError(sql, e); builder.message(isInnerQuery ? SqlExceptionHelper.INNER_QUERY_PARSING_ERROR : SqlExceptionHelper.QUERY_PARSING_ERROR); throw builder.build(logger); } }
private SqlNode parse(String toParse) throws SqlParseException{ ParserConfig config = new ParserConfig(Quoting.DOUBLE_QUOTE, 255); SqlParser parser = SqlParser.create(toParse, config); return parser.parseStmt(); }
private SqlNode parse(String toParse) throws SqlParseException{ ParserConfig config = new ParserConfig(Quoting.DOUBLE_QUOTE, 255); SqlParser parser = SqlParser.create(toParse, config); return parser.parseStmt(); }
public SqlNode parseQuery(String sql) throws Exception { final SqlParser.Config config = SqlParser.configBuilder().setConformance(getConformance()).build(); SqlParser parser = SqlParser.create(sql, config); return parser.parseQuery(); }
protected SqlParser getSqlParser(String sql) { return SqlParser.create(sql, SqlParser.configBuilder() .setParserFactory(parserImplFactory()) .setQuoting(quoting) .setUnquotedCasing(unquotedCasing) .setQuotedCasing(quotedCasing) .setConformance(conformance) .build()); }