public static ParseNode parseCondition(String expression) throws SQLException { if (expression == null) return null; SQLParser parser = new SQLParser(expression); return parser.parseExpression(); }
@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(); }
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); } }
private void parseOpen(String sql) throws IOException, SQLException { SQLParser parser = new SQLParser(new StringReader(sql)); BindableStatement stmt = null; try{ stmt = parser.parseOpen(); } catch (SQLException e){ fail("Unable to parse:\n" + sql); } }
@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(); }
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); } }
@Test public void testParseCreateTableOrderWithoutPrimaryKeyFails() throws Exception { for (String order : new String[]{"asc", "desc"}) { String stmt = "create table core.entity_history_archive (id varchar(20) ${o})".replace("${o}", order); try { new SQLParser((stmt)).parseStatement(); fail("Expected parse exception to be thrown"); } catch (SQLException e) { String errorMsg = "ERROR 603 (42P00): Syntax error. Unexpected input. Expecting \"RPAREN\", got \"${o}\"".replace("${o}", order); assertTrue("Expected message to contain \"" + errorMsg + "\" but got \"" + e.getMessage() + "\"", e.getMessage().contains(errorMsg)); } } }
private void parseQuery(String sql) throws IOException, SQLException { SQLParser parser = new SQLParser(new StringReader(sql)); BindableStatement stmt = null; stmt = parser.parseStatement(); if (stmt.getOperation() != Operation.QUERY) { return; } String newSQL = stmt.toString(); SQLParser newParser = new SQLParser(new StringReader(newSQL)); BindableStatement newStmt = null; try { newStmt = newParser.parseStatement(); } catch (SQLException e) { fail("Unable to parse new:\n" + newSQL); } assertEquals("Expected equality:\n" + sql + "\n" + newSQL, stmt, newStmt); }
protected static void assertRoundtrip(String sql) throws SQLException { SQLParser parser = new SQLParser(sql); BindableStatement stmt = null; stmt = parser.parseStatement(); if (stmt.getOperation() != Operation.QUERY) { return; } String newSQL = stmt.toString(); SQLParser newParser = new SQLParser(newSQL); BindableStatement newStmt = null; try { newStmt = newParser.parseStatement(); } catch (SQLException e) { fail("Unable to parse new:\n" + newSQL); } assertEquals("Expected equality:\n" + sql + "\n" + newSQL, stmt, newStmt); } }
@Test public void testParseCreateTableInlinePrimaryKeyWithOrder() throws Exception { for (String order : new String[]{"asc", "desc"}) { String s = "create table core.entity_history_archive (id char(15) primary key ${o})".replace("${o}", order); CreateTableStatement stmt = (CreateTableStatement)new SQLParser((s)).parseStatement(); List<ColumnDef> columnDefs = stmt.getColumnDefs(); assertEquals(1, columnDefs.size()); assertEquals(SortOrder.fromDDLValue(order), columnDefs.iterator().next().getSortOrder()); } }
@Test public void testParseCreateTableCommaBeforePrimaryKeyConstraint() throws Exception { for (String leadingComma : new String[]{",", ""}) { String s = "create table core.entity_history_archive (id CHAR(15), name VARCHAR(150)${o} constraint pk primary key (id))".replace("${o}", leadingComma); CreateTableStatement stmt = (CreateTableStatement)new SQLParser((s)).parseStatement(); assertEquals(2, stmt.getColumnDefs().size()); assertNotNull(stmt.getPrimaryKeyConstraint()); } }
return view; SelectStatement select = new SQLParser(view.getViewStatement()).parseQuery(); ParseNode whereNode = select.getWhere(); ColumnResolver resolver = FromCompiler.getResolver(new TableRef(view));
@Test public void testDelete() throws Exception { Connection conn = DriverManager.getConnection(getUrl()); conn.createStatement().execute("CREATE TABLE t (k INTEGER NOT NULL PRIMARY KEY, v1 VARCHAR, v2 VARCHAR)"); conn.createStatement().execute("CREATE INDEX idx ON t(v1,v2)"); conn.setAutoCommit(true); PhoenixStatement stmt = conn.createStatement().unwrap(PhoenixStatement.class); SQLParser parser = new SQLParser("DELETE FROM t"); DeleteStatement delete = (DeleteStatement) parser.parseStatement(); DeleteCompiler compiler = new DeleteCompiler(stmt, null); MutationPlan plan = compiler.compile(delete); assertEquals("T", plan.getQueryPlan().getTableRef().getTable().getTableName().getString()); assertTrue(plan.getClass().getName().contains("ServerSelectDeleteMutationPlan")); parser = new SQLParser("DELETE FROM t WHERE v1 = 'foo'"); delete = (DeleteStatement) parser.parseStatement(); plan = compiler.compile(delete); assertEquals("IDX", plan.getQueryPlan().getTableRef().getTable().getTableName().getString()); assertTrue(plan.getClass().getName().contains("ClientSelectDeleteMutationPlan")); }
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; }
@Test public void testParseCreateTablePrimaryKeyConstraintWithOrder() throws Exception { for (String order : new String[]{"asc", "desc"}) { String s = "create table core.entity_history_archive (id CHAR(15), name VARCHAR(150), constraint pk primary key (id ${o}, name ${o}))".replace("${o}", order); CreateTableStatement stmt = (CreateTableStatement)new SQLParser((s)).parseStatement(); PrimaryKeyConstraint pkConstraint = stmt.getPrimaryKeyConstraint(); List<Pair<ColumnName,SortOrder>> columns = pkConstraint.getColumnNames(); assertEquals(2, columns.size()); for (Pair<ColumnName,SortOrder> pair : columns) { assertEquals(SortOrder.fromDDLValue(order), pkConstraint.getColumnWithSortOrder(pair.getFirst()).getSecond()); } } }
return null; SelectStatement select = new SQLParser(viewStatement).parseQuery(); ColumnResolver resolver = FromCompiler.getResolver(new TableRef(table)); SelectStatement translatedSelect = IndexStatementRewriter.translate(select, resolver);
ParseNode defaultParseNode = new SQLParser(column.getExpressionStr()).parseExpression(); Expression defaultExpression = defaultParseNode.accept(compiler); if (!ExpressionUtil.isNull(defaultExpression, new ImmutableBytesWritable())) {
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); } }
viewWhere = new SQLParser(table.getViewStatement()).parseQuery().getWhere();
new SQLParser(this.getExpression()).parseExpression(); Expression defaultExpression = defaultParseNode.accept(compiler); if (!defaultParseNode.isStateless()