/** * This generates a logical plan. * * @param expr A relational algebraic expression for a query. * @return A logical plan */ public LogicalPlan createPlan(OverridableConf context, Expr expr) throws TajoException { return createPlan(context, expr, false); }
/** * This generates a logical plan. * * @param expr A relational algebraic expression for a query. * @return A logical plan */ public LogicalPlan createPlan(OverridableConf context, Expr expr) throws TajoException { return createPlan(context, expr, false); }
public static List<Target> getRawTargets(String query) { LogicalPlan plan = null; try { Expr expr = analyzer.parse(query); plan = planner.createPlan(defaultContext, expr); } catch (TajoException e) { throw new RuntimeException(e); } return plan.getRootBlock().getRawTargets(); }
@Test public final void testProjectionPushWithInnerJoin() throws TajoException { // two relations Expr expr = sqlAnalyzer.parse(QUERIES[5]); LogicalPlan newPlan = planner.createPlan(defaultContext, expr); optimizer.optimize(newPlan); }
@Test public final void testInsertInto() throws CloneNotSupportedException, TajoException { Expr expr = sqlAnalyzer.parse(TestLogicalPlanner.insertStatements[0]); LogicalPlan newPlan = planner.createPlan(defaultContext, expr); optimizer.optimize(newPlan); }
@Test public final void testAlias2() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(ALIAS[1]); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); LogicalRootNode root = (LogicalRootNode) plan; Schema finalSchema = root.getOutSchema(); Iterator<Column> it = finalSchema.getRootColumns().iterator(); Column col = it.next(); assertEquals("id", col.getSimpleName()); col = it.next(); assertEquals("total", col.getSimpleName()); }
private static VerificationState verify(String query) throws TajoException { VerificationState state = new VerificationState(); QueryContext context = LocalTajoTestingUtility.createDummyContext(conf); Expr expr = sqlParser.parse(query); verifier.verify(context, state, expr); if (state.getErrors().size() > 0) { return state; } LogicalPlan plan = planner.createPlan(context, expr); optimizer.optimize(plan); postVerifier.verify(state, plan); return state; }
@Test public final void testSPJ() throws CloneNotSupportedException, TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(QUERIES[6]); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); testCloneLogicalNode(plan); }
@Test public final void testMultipleJoin() throws IOException, TajoException { Expr expr = sqlAnalyzer.parse( FileUtil.readTextFile(new File("src/test/resources/queries/TestJoinQuery/testTPCHQ2Join.sql"))); QueryContext qc = createQueryContext(); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); Schema expected = tpch.getOutSchema("q2"); assertSchema(expected, plan.getOutSchema()); }
@Test public final void testInsertInto3() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[3]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); assertFalse(insertNode.isOverwrite()); assertTrue(insertNode.hasUri()); }
@Test public final void testInsertInto5() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[5]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); assertTrue(insertNode.isOverwrite()); assertTrue(insertNode.hasUri()); }
@Test public final void testInsertInto1() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[1]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); assertFalse(insertNode.isOverwrite()); assertEquals(IdentifierUtil.buildFQName(DEFAULT_DATABASE_NAME, "score"), insertNode.getTableName()); }
@Test public final void testInsertInto0() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[0]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); assertFalse(insertNode.isOverwrite()); assertTrue(insertNode.hasTargetTable()); assertEquals(IdentifierUtil.buildFQName(DEFAULT_DATABASE_NAME, "score"), insertNode.getTableName()); }
public static EvalNode getRootSelection(String query) throws TajoException { Expr block = analyzer.parse(query); LogicalPlan plan = planner.createPlan(defaultContext, block); LogicalPlanner.PlanContext context = new LogicalPlanner.PlanContext(defaultContext, plan, plan.getRootBlock(), new EvalTreeOptimizer(), true); Selection selection = plan.getRootBlock().getSingletonExpr(OpType.Filter); return planner.getExprAnnotator().createEvalNode(context, selection.getQual(), NameResolvingMode.RELS_AND_SUBEXPRS); }
@Test public final void testStoreTable() throws CloneNotSupportedException, TajoException { QueryContext qc = createQueryContext(); Expr context = sqlAnalyzer.parse(QUERIES[8]); LogicalNode plan = planner.createPlan(qc, context).getRootBlock().getRoot(); testCloneLogicalNode(plan); assertEquals(NodeType.ROOT, plan.getType()); LogicalRootNode root = (LogicalRootNode) plan; assertEquals(NodeType.CREATE_TABLE, root.getChild().getType()); StoreTableNode storeNode = root.getChild(); testQuery7(storeNode.getChild()); }
private void isSimpleQuery(String queryStr, boolean expected) throws Exception { GlobalEngine globalEngine = testingCluster.getMaster().getContext().getGlobalEngine(); QueryContext queryContext = LocalTajoTestingUtility.createDummyContext(conf); Session session = testingCluster.getMaster().getContext().getSessionManager().getSession(client.getSessionId()); LogicalPlan plan = globalEngine.getLogicalPlanner(). createPlan(queryContext, globalEngine.buildExpressionFromSql(queryStr, session)); globalEngine.getLogicalOptimizer().optimize(plan); assertEquals(expected, PlannerUtil.checkIfSimpleQuery(plan)); }
@Test public final void testInsertInto2() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[2]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); assertFalse(insertNode.isOverwrite()); assertEquals(IdentifierUtil.buildFQName(DEFAULT_DATABASE_NAME, "employee"), insertNode.getTableName()); assertTrue(insertNode.hasTargetSchema()); assertEquals(insertNode.getTargetSchema().getColumn(0).getSimpleName(), "name"); assertEquals(insertNode.getTargetSchema().getColumn(1).getSimpleName(), "deptname"); }
@Test public final void testAlterTableRepairPartiton() throws TajoException { QueryContext qc = createQueryContext(); String sql = "ALTER TABLE table1 REPAIR PARTITION"; Expr expr = sqlAnalyzer.parse(sql); LogicalPlan rootNode = planner.createPlan(qc, expr); LogicalNode plan = rootNode.getRootBlock().getRoot(); assertEquals(NodeType.ROOT, plan.getType()); LogicalRootNode root = (LogicalRootNode) plan; assertEquals(NodeType.ALTER_TABLE, root.getChild().getType()); AlterTableNode msckNode = root.getChild(); assertEquals(msckNode.getAlterTableOpType(), AlterTableOpType.REPAIR_PARTITION); assertEquals(msckNode.getTableName(), "table1"); }
@Test public final void testSetPlan() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(setStatements[0]); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); assertEquals(NodeType.ROOT, plan.getType()); LogicalRootNode root = (LogicalRootNode) plan; assertEquals(NodeType.UNION, root.getChild().getType()); UnionNode union = root.getChild(); assertEquals(NodeType.PROJECTION, union.getLeftChild().getType()); assertEquals(NodeType.PROJECTION, union.getRightChild().getType()); }
@Test public final void testLimit() throws CloneNotSupportedException, TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(QUERIES[12]); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); testCloneLogicalNode(plan); assertEquals(NodeType.ROOT, plan.getType()); LogicalRootNode root = (LogicalRootNode) plan; assertEquals(NodeType.PROJECTION, root.getChild().getType()); ProjectionNode projNode = root.getChild(); assertEquals(NodeType.LIMIT, projNode.getChild().getType()); LimitNode limitNode = projNode.getChild(); assertEquals(NodeType.SORT, limitNode.getChild().getType()); }