/** * @see org.teiid.query.resolver.CommandResolver#resolveCommand(org.teiid.query.sql.lang.Command, TempMetadataAdapter, boolean) */ public void resolveCommand(Command command, TempMetadataAdapter metadata, boolean resolveNullLiterals) throws QueryMetadataException, QueryResolverException, TeiidComponentException { //by creating a new group context here it means that variables will resolve with a higher precedence than input/changing GroupContext externalGroups = command.getExternalGroupContexts(); List<ElementSymbol> symbols = new LinkedList<ElementSymbol>(); String countVar = ProcedureReservedWords.VARIABLES + Symbol.SEPARATOR + ProcedureReservedWords.ROWCOUNT; ElementSymbol updateCount = new ElementSymbol(countVar); updateCount.setType(DataTypeManager.DefaultDataClasses.INTEGER); symbols.add(updateCount); ProcedureContainerResolver.addScalarGroup(ProcedureReservedWords.VARIABLES, metadata.getMetadataStore(), externalGroups, symbols); if (command instanceof TriggerAction) { TriggerAction ta = (TriggerAction)command; CreateProcedureCommand cmd = new CreateProcedureCommand(ta.getBlock()); cmd.setVirtualGroup(ta.getView()); //TODO: this is not generally correct - we should update the api to set the appropriate type cmd.setUpdateType(Command.TYPE_INSERT); resolveBlock(cmd, ta.getBlock(), ta.getExternalGroupContexts(), metadata); return; } CreateProcedureCommand procCommand = (CreateProcedureCommand) command; resolveBlock(procCommand, procCommand.getBlock(), externalGroups, metadata); }
/** * @see org.teiid.query.sql.lang.Command#areResultsCachable() */ public boolean areResultsCachable() { return Query.areColumnsCachable(getProjectedSymbols()); }
public void visit(CreateProcedureCommand obj) { //check that the procedure does not contain references to itself if (obj.getUpdateType() == Command.TYPE_UNKNOWN) { if (GroupCollectorVisitor.getGroups(obj,true).contains(obj.getVirtualGroup())) { handleValidationError(QueryPlugin.Util.getString("ValidationVisitor.Procedure_has_group_self_reference"),obj); //$NON-NLS-1$ } if (obj.getResultSetColumns() != null) { //some unit tests bypass setting the columns this.createProc = obj; } } }
/** * Compare two CreateUpdateProcedureCommand for equality. They will only evaluate to equal if * they are IDENTICAL: the commandTypes are same and the block objects are equal. * @param obj Other object * @return True if equal */ public boolean equals(Object obj) { // Quick same object test if(this == obj) { return true; } // Quick fail tests if(! (obj instanceof CreateProcedureCommand)) { return false; } CreateProcedureCommand other = (CreateProcedureCommand)obj; // Compare the block return sameOptionAndHint(other) && EquivalenceUtil.areEqual(getBlock(), other.getBlock()); }
@Override public void visit( CreateProcedureCommand obj ) { addCacheHint(obj.getCacheHint()); visitNode(obj.getBlock()); }
cupc.setVirtualGroup(container); if (type == Command.TYPE_STORED_PROCEDURE) { StoredProcedureInfo info = metadata.getStoredProcedureInfoForProcedure(container.getName()); updatable[i++] = param.getParameterType() != ParameterInfo.IN; if (param.getParameterType() == ParameterInfo.RETURN_VALUE) { cupc.setReturnVariable(symbol); if (cupc.getReturnVariable() != null) { ResolverVisitor.resolveLanguageObject(cupc.getReturnVariable(), Arrays.asList(gs), metadata); cupc.setResultSetColumns(rsColumns); cupc.setProjectedSymbols(rsColumns); } else { cupc.setUpdateType(type);
if ((command.getResultSetColumns() != null && command.getResultSetColumns().isEmpty()) || !cmdStmt.isReturnable() || command.getResultSetColumns() == null) { dynCommand.setAsColumns(command.getResultSetColumns()); if (command.getResultSetColumns() == null && cmdStmt.isReturnable() && subCommand.returnsResultSet() && subCommand.getResultSetColumns() != null && !subCommand.getResultSetColumns().isEmpty()) { command.setResultSetColumns(subCommand.getResultSetColumns()); if (command.getProjectedSymbols().isEmpty()) { command.setProjectedSymbols(subCommand.getResultSetColumns()); ReturnStatement rs = (ReturnStatement)statement; if (rs.getExpression() != null) { if (command.getReturnVariable() == null) { throw new QueryResolverException(QueryPlugin.Event.TEIID31125, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31125, rs)); rs.setVariable(command.getReturnVariable().clone());
result.setQueryPlan(queryPlan); result.setLookupMap(RelationalNode.createLookupMap(query.getProjectedSymbols())); CreateProcedureCommand command = new CreateProcedureCommand(ta.getBlock()); command.setVirtualGroup(ta.getView()); command.setUpdateType(userCommand.getType()); ProcedurePlan rowProcedure = (ProcedurePlan)QueryOptimizer.optimizePlan(command, metadata, idGenerator, capFinder, analysisRecord, context); rowProcedure.setRunInContext(false);
private Command asLoopProcedure(GroupSymbol group, QueryCommand query, Statement s, GroupSymbol varGroup, int updateType) throws QueryResolverException, TeiidComponentException, TeiidProcessingException { Block b = new Block(); b.addStatement(s); CreateProcedureCommand cupc = new CreateProcedureCommand(); cupc.setUpdateType(updateType); Block parent = new Block(); parent.setAtomic(true); ElementSymbol rowsUpdated = new ElementSymbol(ProcedureReservedWords.VARIABLES+Symbol.SEPARATOR+"ROWS_UPDATED"); //$NON-NLS-1$ DeclareStatement ds = new DeclareStatement(rowsUpdated, DataTypeManager.DefaultDataTypes.INTEGER, new Constant(0)); parent.addStatement(ds); LoopStatement ls = new LoopStatement(b, query, varGroup.getName()); parent.addStatement(ls); AssignmentStatement as = new AssignmentStatement(); rowsUpdated.setType(DataTypeManager.DefaultDataClasses.INTEGER); as.setVariable(rowsUpdated); as.setExpression(new Function("+", new Expression[] {rowsUpdated, new Constant(1)})); //$NON-NLS-1$ b.addStatement(as); Query returnQuery = new Query(); returnQuery.setSelect(new Select(Arrays.asList(rowsUpdated.clone()))); parent.addStatement(new CommandStatement(returnQuery)); cupc.setBlock(parent); cupc.setVirtualGroup(group); QueryResolver.resolveCommand(cupc, metadata); return rewrite(cupc, metadata, context); }
final public CreateProcedureCommand createProcedure(ParseInfo info) throws ParseException { CreateProcedureCommand procCmd = new CreateProcedureCommand(); Statement stmt = null; jj_consume_token(CREATE); switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case VIRTUAL: jj_consume_token(VIRTUAL); break; default: jj_la1[53] = jj_gen; ; } jj_consume_token(PROCEDURE); stmt = statement(info); procCmd.setBlock(asBlock(stmt)); {if (true) return procCmd;} throw new Error("Missing return statement in function"); }
Block block = cupc.getBlock(); plan.setOutputElements(cupc.getProjectedSymbols());
/** * Deep clone statement to produce a new identical statement. * @return Deep clone */ public Object clone() { CreateProcedureCommand copy = new CreateProcedureCommand(); //Clone this class state if (this.block != null) { copy.setBlock(this.block.clone()); } if (this.projectedSymbols != null) { copy.projectedSymbols = LanguageObject.Util.deepClone(this.projectedSymbols, Expression.class); } if (this.resultSetColumns != null) { copy.resultSetColumns = LanguageObject.Util.deepClone(this.resultSetColumns, Expression.class); } if (this.virtualGroup != null) { copy.virtualGroup = this.virtualGroup.clone(); } if (this.returnVariable != null) { copy.returnVariable = this.returnVariable; } copy.updateType = this.updateType; this.copyMetadataState(copy); return copy; }
comment = getToken(1).specialToken; stmt = statement(info); CreateProcedureCommand cup = new CreateProcedureCommand(asBlock(stmt)); if (comment != null) { cup.setCacheHint(getQueryCacheOption(comment.image)); dbStore.setProcedureDefinition(procedure.getName(), cup.toString(), true); break; default:
@Test public void testCacheProc() { String sql = "/*+ cache */ CREATE VIRTUAL PROCEDURE BEGIN END"; //$NON-NLS-1$ CreateProcedureCommand command = new CreateProcedureCommand(new Block()); command.setCacheHint(new CacheHint()); TestParser.helpTest(sql, "/*+ cache */ BEGIN\nEND", command); //$NON-NLS-1$ }
public static final CreateProcedureCommand sample3() { return new CreateProcedureCommand(TestBlock.sample1()); }
/** * Get hashcode for CreateUpdateProcedureCommand. WARNING: This hash code relies * on the hash codes of the block and the procedure type of this command. Hash code * is only valid after the command has been completely constructed. * @return Hash code */ public int hashCode() { // This hash code relies on the block and the procedure type for this command int myHash = 0; myHash = HashCodeUtil.hashCode(myHash, this.getBlock()); return myHash; }
@Test public void testAnonBlock() throws Exception { String sql = "begin select 1 as something; end"; //$NON-NLS-1$ CreateProcedureCommand sp = (CreateProcedureCommand) TestResolver.helpResolve(sql, RealMetadataFactory.example1Cached()); assertEquals(1, sp.getResultSetColumns().size()); assertEquals("something", Symbol.getName(sp.getResultSetColumns().get(0))); assertEquals(1, sp.getProjectedSymbols().size()); assertTrue(sp.returnsResultSet()); }
@Test public void testReturnAndResultSet() throws Exception { String ddl = "CREATE FOREIGN PROCEDURE proc (OUT param STRING RESULT) RETURNS TABLE (a INTEGER, b STRING);"; //$NON-NLS-1$ TransformationMetadata tm = RealMetadataFactory.fromDDL(ddl, "x", "y"); StoredProcedure sp = (StoredProcedure) TestResolver.helpResolve("exec proc()", tm); assertEquals(2, sp.getProjectedSymbols().size()); assertEquals("y.proc.b", sp.getProjectedSymbols().get(1).toString()); assertTrue(sp.returnsResultSet()); sp.setCallableStatement(true); assertEquals(3, sp.getProjectedSymbols().size()); assertEquals("y.proc.param", sp.getProjectedSymbols().get(2).toString()); CreateProcedureCommand cpc = (CreateProcedureCommand) TestResolver.helpResolve("begin exec proc(); end", tm); assertEquals(2, cpc.getProjectedSymbols().size()); assertEquals(2, ((CommandStatement)cpc.getBlock().getStatements().get(0)).getCommand().getProjectedSymbols().size()); assertTrue(cpc.returnsResultSet()); TestValidator.helpValidate("begin declare string var; var = exec proc(); select var; end", new String[] {"SELECT var;"}, tm); }