@Test public void testParseDateEquality() throws Exception { SQLParser parser = new SQLParser(new StringReader( "select a from b\n" + "where date '2014-01-04' = date '2014-01-04'" )); parser.parseStatement(); }
@Override public CompilableStatement nextStatement(ParseNodeFactory nodeFactory) throws SQLException { return (CompilableStatement) super.nextStatement(nodeFactory); }
public static ParseNode parseCondition(String expression) throws SQLException { if (expression == null) return null; SQLParser parser = new SQLParser(expression); return parser.parseExpression(); }
private void parseFetch(String sql) throws IOException, SQLException { SQLParser parser = new SQLParser(new StringReader(sql)); BindableStatement stmt = null; try{ stmt = parser.parseFetch(); } catch (SQLException e){ fail("Unable to parse:\n" + sql); } }
return null; SelectStatement select = new SQLParser(viewStatement).parseQuery(); ColumnResolver resolver = FromCompiler.getResolver(new TableRef(table)); SelectStatement translatedSelect = IndexStatementRewriter.translate(select, resolver);
private LiteralExpression getExpFromConstant(String strValue) { LiteralExpression exp = null; if (strValue.length() > 0) { SQLParser parser = new SQLParser(strValue); try { LiteralParseNode node = parser.parseLiteral(); LiteralExpression defaultValue = LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass( allowedTypes[0]), Determinism.ALWAYS); if (this.getAllowedTypes().length > 0) { for (Class<? extends PDataType> type : this.getAllowedTypes()) { if (defaultValue.getDataType() == null || defaultValue.getDataType().isCoercibleTo( PDataTypeFactory.getInstance().instanceFromClass(type), node.getValue())) { return LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass(type), Determinism.ALWAYS); } } throw new IllegalStateException("Unable to coerce default value " + strValue + " to any of the allowed types of " + Arrays.toString(this.getAllowedTypes())); } exp = defaultValue; } catch (SQLException e) { throw new RuntimeException(e); } } return exp; }
private void parseCursor(String sql) throws IOException, SQLException { SQLParser parser = new SQLParser(new StringReader(sql)); BindableStatement stmt = null; try{ stmt = parser.parseDeclareCursor(); } catch (SQLException e){ fail("Unable to parse:\n" + sql); } }
@Override public CompilableStatement parseStatement() throws SQLException { return (CompilableStatement) super.parseStatement(); } }
public IndexExpressionParseNodeRewriter(PTable index, String alias, PhoenixConnection connection, Map<String, UDFParseNode> udfParseNodes) throws SQLException { indexedParseNodeToColumnParseNodeMap = Maps.newHashMapWithExpectedSize(index.getColumns().size()); NamedTableNode tableNode = NamedTableNode.create(alias, TableName.create(index.getParentSchemaName().getString(), index.getParentTableName().getString()), Collections.<ColumnDef> emptyList()); ColumnResolver dataResolver = FromCompiler.getResolver(tableNode, connection, udfParseNodes); StatementContext context = new StatementContext(new PhoenixStatement(connection), dataResolver); IndexStatementRewriter rewriter = new IndexStatementRewriter(dataResolver, null, true); ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); int indexPosOffset = (index.getBucketNum() == null ? 0 : 1) + (index.isMultiTenant() ? 1 : 0) + (index.getViewIndexId() == null ? 0 : 1); List<PColumn> pkColumns = index.getPKColumns(); for (int i=indexPosOffset; i<pkColumns.size(); ++i) { PColumn column = pkColumns.get(i); String expressionStr = IndexUtil.getIndexColumnExpressionStr(column); ParseNode expressionParseNode = SQLParser.parseCondition(expressionStr); String colName = "\"" + column.getName().getString() + "\""; Expression dataExpression = expressionParseNode.accept(expressionCompiler); PDataType expressionDataType = dataExpression.getDataType(); ParseNode indexedParseNode = expressionParseNode.accept(rewriter); PDataType indexColType = IndexUtil.getIndexColumnDataType(dataExpression.isNullable(), expressionDataType); ParseNode columnParseNode = new ColumnParseNode(alias!=null ? TableName.create(null, alias) : null, colName, null); if ( indexColType != expressionDataType) { columnParseNode = NODE_FACTORY.cast(columnParseNode, expressionDataType, null, null); } indexedParseNodeToColumnParseNodeMap.put(indexedParseNode, columnParseNode); } }
return view; SelectStatement select = new SQLParser(view.getViewStatement()).parseQuery(); ParseNode whereNode = select.getWhere(); ColumnResolver resolver = FromCompiler.getResolver(new TableRef(view));
private LiteralExpression getExpFromConstant(String strValue) { LiteralExpression exp = null; if (strValue.length() > 0) { SQLParser parser = new SQLParser(strValue); try { LiteralParseNode node = parser.parseLiteral(); LiteralExpression defaultValue = LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass( allowedTypes[0]), Determinism.ALWAYS); if (this.getAllowedTypes().length > 0) { for (Class<? extends PDataType> type : this.getAllowedTypes()) { if (defaultValue.getDataType() == null || defaultValue.getDataType().isCoercibleTo( PDataTypeFactory.getInstance().instanceFromClass(type), node.getValue())) { return LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass(type), Determinism.ALWAYS); } } throw new IllegalStateException("Unable to coerce default value " + strValue + " to any of the allowed types of " + Arrays.toString(this.getAllowedTypes())); } exp = defaultValue; } catch (SQLException e) { throw new RuntimeException(e); } } return exp; }
@Override public CompilableStatement parseStatement() throws SQLException { return (CompilableStatement) super.parseStatement(); } }
expressionCompiler.reset(); String expressionStr = IndexUtil.getIndexColumnExpressionStr(indexColumn); ParseNode parseNode = SQLParser.parseCondition(expressionStr); parseNode.accept(expressionCompiler); indexRequiredDroppedDataColMap.put(indexColumn,
private static JoinTable getJoinTable(String query, PhoenixConnection connection) throws SQLException { SQLParser parser = new SQLParser(query); SelectStatement select = SubselectRewriter.flatten(parser.parseQuery(), connection); ColumnResolver resolver = FromCompiler.getResolverForQuery(select, connection); select = StatementNormalizer.normalize(select, resolver); SelectStatement transformedSelect = SubqueryRewriter.transform(select, resolver, connection); if (transformedSelect != select) { resolver = FromCompiler.getResolverForQuery(transformedSelect, connection); select = StatementNormalizer.normalize(transformedSelect, resolver); } PhoenixStatement stmt = connection.createStatement().unwrap(PhoenixStatement.class); return JoinCompiler.compile(stmt, select, resolver); } }
@Test public void testParseDateIn() throws Exception { SQLParser parser = new SQLParser(new StringReader( "select a from b\n" + "where date '2014-01-04' in (date '2014-01-04')" )); parser.parseStatement(); }
public static ParseNode parseCondition(String expression) throws SQLException { if (expression == null) return null; SQLParser parser = new SQLParser(expression); return parser.parseExpression(); }
private LiteralExpression getExpFromConstant(String strValue) { LiteralExpression exp = null; if (strValue.length() > 0) { SQLParser parser = new SQLParser(strValue); try { LiteralParseNode node = parser.parseLiteral(); LiteralExpression defaultValue = LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass( allowedTypes[0]), Determinism.ALWAYS); if (this.getAllowedTypes().length > 0) { for (Class<? extends PDataType> type : this.getAllowedTypes()) { if (defaultValue.getDataType() == null || defaultValue.getDataType().isCoercibleTo( PDataTypeFactory.getInstance().instanceFromClass(type), node.getValue())) { return LiteralExpression.newConstant(node.getValue(), PDataTypeFactory.getInstance().instanceFromClass(type), Determinism.ALWAYS); } } throw new IllegalStateException("Unable to coerce default value " + strValue + " to any of the allowed types of " + Arrays.toString(this.getAllowedTypes())); } exp = defaultValue; } catch (SQLException e) { throw new RuntimeException(e); } } return exp; }
@Override public CompilableStatement parseStatement() throws SQLException { return (CompilableStatement) super.parseStatement(); } }
String expressionStr = IndexUtil.getIndexColumnExpressionStr(indexColumn); try { ParseNode parseNode = SQLParser.parseCondition(expressionStr); parseNode.accept(visitor); parseNodes.add(parseNode);