private void visit(Procedure procedure) { if (this.filter != null && !filter.matcher(procedure.getName()).matches()) { return; } append(CREATE).append(SPACE); if (procedure.isVirtual()) { append(VIRTUAL); } else { append(FOREIGN); } append(SPACE) .append(procedure.isFunction() ? FUNCTION : PROCEDURE) .append(SPACE) .append(SQLStringVisitor.escapeSinglePart(procedure.getName())); append(LPAREN); boolean first = true; for (ProcedureParameter pp : procedure.getParameters()) { if (first) { first = false; } else { append(COMMA).append(SPACE); } visit(pp); } append(RPAREN); if (procedure.getResultSet() != null) { append(SPACE).append(RETURNS); appendOptions(procedure.getResultSet()); append(SPACE).append(TABLE).append(SPACE); addColumns(procedure.getResultSet().getColumns(), true); } /* The parser treats the RETURN clause as optional for a procedure if using the RESULT param for (ProcedureParameter pp: procedure.getParameters()) { if (pp.getType().equals(Type.ReturnValue)) { append(SPACE).append(RETURNS).append(SPACE); appendColumn(buffer, pp, false, true); break; } }*/ // options String options = buildProcedureOptions(procedure); if (!options.isEmpty()) { append(NEWLINE).append(OPTIONS).append(SPACE).append(LPAREN).append(options).append(RPAREN); } // block if (procedure.isVirtual()) { append(NEWLINE).append(SQLConstants.Reserved.AS).append(NEWLINE); String plan = procedure.getQueryPlan(); append(plan); } append(SEMICOLON); }
protected ProcParameter getProcParameter(Database catalog_db, Procedure catalog_proc, int idx) { assertNotNull(catalog_db); assert (idx >= 0) : "Invalid ProcParameter index for " + catalog_proc + ": " + idx; assert (idx < catalog_proc.getParameters().size()) : "Invalid ProcParameter index for " + catalog_proc + ": " + idx; ProcParameter catalog_param = catalog_proc.getParameters().get(idx); assertNotNull("Null ProcParameter index for " + catalog_proc + ": " + idx, catalog_param); return (catalog_param); }
public static String addProcedure() { Procedure A = new Procedure(Procedure.getProcedure(), Procedure.getCost()); p_procList.add(A); String newProcedure = null; for (int i = 0; i < p_procList.size(); i++) { newProcedure = newProcedure + Procedure.getProcedure() + Procedure.getCost(); } return newProcedure; }
/** * Some prepared statements return multiple results; the execute method handles these complex * statements as well as the simpler form of statements handled by executeQuery and executeUpdate. * * @exception SQLException if a database-access error occurs. * @see Statement#execute */ public boolean execute(Tds tds) throws SQLException { // // TDS can handle prepared statements by creating a temporary // procedure. Since procedure must have the datatype specified // in the procedure declaration we will have to defer creating // the actual procedure until the statement is executed. By // that time we know all the types of all of the parameters. // Procedure procedure = null; boolean result = false; // SAfe No need for this either. We'll have to consume all input, nut // just the last ResultSet (if one exists). // closeResults(false); // SAfe No need for this. getMoreResults sets it to -1 at start, anyway // updateCount = -2; // First make sure the caller has filled in all the parameters. ParameterUtils.verifyThatParametersAreSet(parameterList); // Find a stored procedure that is compatible with this set of parameters if one exists. procedure = findCompatibleStoredProcedure(tds, rawQueryString); // now look in tds // if we don't have a suitable match then create a new temporary stored procedure if (procedure == null) { // Create the stored procedure procedure = new Procedure(rawQueryString, tds.getUniqueProcedureName(), parameterList, tds); // SAfe Submit it to the SQL Server before adding it to the cache or procedures of transaction // list. // Otherwise, if submitProcedure fails (e.g. because of a syntax error) it will be in our // procedure // cache, but not on the server. submitProcedure(tds, procedure); // store it in the procedureCache tds.procedureCache.put(rawQueryString, procedure); // MJH Only record the proc name in proceduresOfTra if in manual commit mode if (!getConnection().getAutoCommit()) // MJH tds.proceduresOfTra.add(procedure); } result = internalExecuteCall( procedure.getProcedureName(), procedure.getParameterList(), parameterList, tds, warningChain); return result; }
@SuppressWarnings("unchecked") public void transformProcedure(Procedure proc) { List<ReturnStatement> ret_stmts = (new DFIterator<ReturnStatement>(proc, ReturnStatement.class)).getList(); CompoundStatement body = proc.getBody(); List ret_type = proc.getReturnType(); // Remove scope qualifiers not necessary in type resolution while (ret_type.remove(Specifier.INLINE)) ; while (ret_type.remove(Specifier.STATIC)) ; while (ret_type.remove(Specifier.EXTERN)) ; boolean ret_type_void = (ret_type.contains(Specifier.VOID) && ret_type.size() == 1); Identifier ret_id = null; // add a variable _ret_val of the same type as the procedure return type if (!ret_type_void) { // check for implicit int (TODO - differentiate this from constructors) if (ret_type.isEmpty()) { ret_type.add(Specifier.INT); } ret_id = SymbolTools.getTemp(body, ret_type, "_ret_val"); } // add a labeled return statement to the end of the procedure String done_label = "_done"; body.addStatement(new Label(new NameID(done_label))); if (!ret_type_void) { body.addStatement(new ReturnStatement(ret_id.clone())); } else { body.addStatement(new ReturnStatement()); } // redirect the preexisting return statements to the labeled return for (ReturnStatement ret_stmt : ret_stmts) { // Identify the parent compound statement. CompoundStatement comp_stmt = IRTools.getAncestorOfType(ret_stmt, CompoundStatement.class); // Add goto statement. Statement goto_stmt = new GotoStatement(new NameID(done_label)); comp_stmt.addStatementAfter(ret_stmt, goto_stmt); // Add temporary assignments. if (!ret_type_void) { Statement new_stmt = new ExpressionStatement( new AssignmentExpression( ret_id.clone(), AssignmentOperator.NORMAL, ret_stmt.getExpression().clone())); comp_stmt.addStatementBefore(goto_stmt, new_stmt); } // Remove the original return statement. comp_stmt.removeStatement(ret_stmt); // Add comments. /* CommentAnnotation info = new CommentAnnotation("Normalized Return: " + ret_stmt); info.setOneLiner(true); goto_stmt.annotateBefore(info); */ } }
protected Statement getStatement(Database catalog_db, Procedure catalog_proc, String stmt_name) { assertNotNull(catalog_db); assertNotNull(catalog_proc); Statement catalog_stmt = catalog_proc.getStatements().get(stmt_name); assert (catalog_stmt != null) : "Failed to retrieve Statement '" + stmt_name + "' from Procedure '" + catalog_proc.getName() + "'"; return (catalog_stmt); }
public static final File fileHandle(Value o) { String encoding = "UTF-8"; // always supported try { URL u = url(o); if (!"file".equals(u.getProtocol())) Procedure.throwPrimException(liMessage(IO.IOB, "notafileurl")); String path = URLDecoder.decode(u.getPath(), encoding); return new File(path); } catch (UnsupportedEncodingException use) { Procedure.throwPrimException(liMessage(IO.IOB, "unsupencoding", encoding)); return null; // not reached } }
/** * Some prepared statements return multiple results; the execute method handles these complex * statements as well as the simpler form of statements handled by executeQuery and executeUpdate. * * @exception SQLException if a database-access error occurs. * @see Statement#execute */ public boolean execute(Tds tds) throws SQLException { // // TDS can handle prepared statements by creating a temporary // procedure. Since procedure must have the datatype specified // in the procedure declaration we will have to defer creating // the actual procedure until the statement is executed. By // that time we know all the types of all of the parameters. // Procedure procedure = null; boolean result = false; closeResults(); updateCount = -2; // First make sure the caller has filled in all the parameters. ParameterUtils.verifyThatParametersAreSet(parameterList); // Find a stored procedure that is compatible with this set of // parameters if one exists. procedure = findCompatibleStoredProcedure(tds, rawQueryString); // now look in tds // if we don't have a suitable match then create a new // temporary stored procedure if (procedure == null) { // create the stored procedure procedure = new Procedure(rawQueryString, tds.getUniqueProcedureName(), parameterList, tds); // store it in the procedureCache // procedureCache.addElement(procedure); // store it in the procedureCache tds.procedureCache.put(rawQueryString, procedure); tds.proceduresOfTra.add(procedure); // create it on the SQLServer. submitProcedure(tds, procedure); } result = executeCall( tds, procedure.getProcedureName(), procedure.getParameterList(), // formal params parameterList); // actual params return result; }
public WrongType(Procedure proc, int n, Object argValue, Type expectedType) { this.proc = proc; this.procname = proc.getName(); this.number = n; this.argValue = argValue; this.expectedType = expectedType; }
public int effectiveIndex(int[] indexes) { Object obj; try { obj = proc.apply1(indexes); } catch (Throwable ex) { throw new RuntimeException("index transformer throw " + ex, ex); } if (obj instanceof int[]) return base.effectiveIndex((int[]) obj); IntSequence ind = Sequences.asIntSequenceOrNull(obj); if (ind == null) throw new ClassCastException("not an integer sequence"); if (ind instanceof S32Vector) return base.effectiveIndex(((S32Vector) ind).getBuffer()); else { int rank = ind.size(); switch (rank) { case 0: return base.effectiveIndex(); case 1: return base.effectiveIndex(ind.getInt(0)); case 2: return base.effectiveIndex(ind.getInt(0), ind.getInt(1)); default: int[] rest = rank == 3 ? AbstractSequence.noInts : new int[rank - 3]; for (int i = 3; i < rank; i++) rest[i - 3] = ind.getInt(i); return base.effectiveIndex(ind.getInt(0), ind.getInt(1), ind.getInt(2), rest); } } }
public E get(int[] indexes) { try { return (E) proc.apply1(new S32Vector(indexes)); } catch (Throwable ex) { throw new RuntimeException("caught " + ex + " evaluating array procedure", ex); } }
private String buildProcedureOptions(Procedure procedure) { StringBuilder options = new StringBuilder(); addCommonOptions(options, procedure); if (procedure.getUpdateCount() != Procedure.AUTO_UPDATECOUNT) { addOption(options, UPDATECOUNT, procedure.getUpdateCount()); } if (!procedure.getProperties().isEmpty()) { for (String key : procedure.getProperties().keySet()) { addOption(options, key, procedure.getProperty(key, false)); } } return options.toString(); }
protected T coerce(T newValue) { try { return (T) converter.apply1(newValue); } catch (Throwable ex) { throw WrappedException.rethrow(ex); } }
@Override protected void makeConnectors() { super.makeConnectors(); // Variable variableCon = new Connector(); variableCon.detouch(); variableCon.setWidth(50); variableCon.setHeight(2); variableCon.setHolder(this); variableCon.setPosition(Connector.Position.LEFT); AnchorPane.setTopAnchor(variableCon, 10.0); AnchorPane.setLeftAnchor(variableCon, 10.0); variableCon.toFront(); leftVariableCon = new Connector(); leftVariableCon.detouch(); leftVariableCon.setWidth(50); leftVariableCon.setHeight(2); leftVariableCon.setHolder(this); leftVariableCon.setPosition(Connector.Position.INSIDE_LEFT); AnchorPane.setTopAnchor(leftVariableCon, 10.0); AnchorPane.setLeftAnchor(leftVariableCon, 80.0); leftVariableCon.toFront(); getChildren().addAll(variableCon, leftVariableCon); }
public void lineStart(boolean flag) throws IOException { if (flag) { break MISSING_BLOCK_LABEL_64; } if (tie != null) { tie.freshLine(); } if (prompter == null) { break MISSING_BLOCK_LABEL_64; } Object obj; try { obj = prompter.apply1(this); } catch (Throwable throwable) { throw new IOException( (new StringBuilder()) .append("Error when evaluating prompt:") .append(throwable) .toString()); } if (obj == null) { break MISSING_BLOCK_LABEL_64; } obj = obj.toString(); if (obj == null) { break MISSING_BLOCK_LABEL_64; } if (((String) (obj)).length() > 0) { emitPrompt(((String) (obj))); promptEmitted = true; } }
public void apply(CallContext ctx) throws Throwable { Object proc = func.eval(ctx); int n = args.length; Object[] vals = new Object[n]; for (int i = 0; i < n; i++) vals[i] = args[i].eval(ctx); ((Procedure) proc).checkN(vals, ctx); }
public static void withServerIdImmutability(Procedure fn) { try { SystemEnvironment.enforceServerIdImmutability.set(true); fn.call(); } finally { SystemEnvironment.enforceServerIdImmutability.set(false); } }
@Test public void testTypeLength() throws Exception { String ddl = "CREATE FOREIGN PROCEDURE myProc(OUT p1 boolean, p2 varchar, INOUT p3 decimal) " + "RETURNS (r1 varchar(10), r2 decimal(11,2), r3 object(1), r4 clob(10000))" + "OPTIONS(RANDOM 'any', UUID 'uuid', NAMEINSOURCE 'nis', ANNOTATION 'desc', UPDATECOUNT '2');"; Schema s = helpParse(ddl, "model").getSchema(); Procedure proc = s.getProcedure("myProc"); assertNotNull(proc); List<Column> cols = proc.getResultSet().getColumns(); assertEquals(10, cols.get(0).getLength()); assertEquals(11, cols.get(1).getPrecision()); assertEquals(1, cols.get(2).getLength()); assertEquals(10000, cols.get(3).getLength()); }
@Test public void testMultipleCommands() throws Exception { String ddl = "CREATE VIEW V1 AS SELECT * FROM PM1.G1 " + "CREATE PROCEDURE FOO(P1 integer) RETURNS (e1 integer, e2 varchar) AS SELECT * FROM PM1.G1;"; Schema s = helpParse(ddl, "model").getSchema(); Map<String, Table> tableMap = s.getTables(); Table table = tableMap.get("V1"); assertNotNull(table); assertEquals("SELECT * FROM PM1.G1", table.getSelectTransformation()); Map<String, Procedure> procedureMap = s.getProcedures(); Procedure p = procedureMap.get("FOO"); assertNotNull(p); assertEquals("SELECT * FROM PM1.G1;", p.getQueryPlan()); }
@Test public void testAlterProcedureOptions() throws Exception { String ddl = "CREATE FOREIGN PROCEDURE myProc(OUT p1 boolean, p2 varchar, INOUT p3 decimal) " + "RETURNS (r1 varchar, r2 decimal)" + "OPTIONS(RANDOM 'any', UUID 'uuid', NAMEINSOURCE 'nis', ANNOTATION 'desc', UPDATECOUNT '2');" + "ALTER FOREIGN PROCEDURE myProc OPTIONS(SET NAMEINSOURCE 'x')" + "ALTER FOREIGN PROCEDURE myProc ALTER PARAMETER p2 OPTIONS (ADD x 'y');" + "ALTER FOREIGN PROCEDURE myProc OPTIONS(DROP UPDATECOUNT);"; Schema s = helpParse(ddl, "model").getSchema(); Procedure proc = s.getProcedure("myProc"); assertNotNull(proc); assertEquals("x", proc.getNameInSource()); assertEquals("p2", proc.getParameters().get(1).getName()); assertEquals("y", proc.getParameters().get(1).getProperty("x", false)); assertEquals(1, proc.getUpdateCount()); }
@Override public void toFront() { super.toFront(); if (variable != null) { variable.toFront(); } if (leftVariable != null) { leftVariable.toFront(); } }
/** * passes parameters to relevant setters of a Procedure object to update * * @param myProcedure * @param procName * @param procCostString * @return boolean representing success of operation */ public boolean updateProcedure(Procedure myProcedure, String procName, String procCostString) { if (procName.isEmpty() && procCostString.isEmpty()) // display error if no details entered { JOptionPane.showMessageDialog(null, "No details entered"); return false; } // if any detail is provided, update accordingly if (!procName.isEmpty()) myProcedure.setProcedureName(procName); if (!procCostString.isEmpty()) { try { Double tempProcCost = Double.parseDouble(procCostString); myProcedure.setCost(tempProcCost); } catch (NumberFormatException n) { JOptionPane.showMessageDialog(null, "Please ensure a valid price is entered."); return false; } } JOptionPane.showMessageDialog(null, "Procedure details updated"); return true; }
@Override public void move(double dx, double dy) { if (variable != null) { variable.toFront(); variable.move(dx + 10, dy + 10); } if (leftVariable != null) { leftVariable.toFront(); leftVariable.move(dx + 80, dy + 10); } super.move(dx, dy); }
@Override public void show() { super.show(); if (variable != null) { variable.show(); } if (leftVariable != null) { leftVariable.show(); } }
private static int effectiveIndex(Array array, Procedure proc, Object[] args, int[] work) throws Throwable { Object mapval = proc.applyN(args); if (mapval instanceof Values) { Values mapvals = (Values) mapval; for (int i = 0, j = 0; (i = mapvals.nextPos(i)) != 0; j++) { work[j] = ((Number) mapvals.getPosPrevious(i)).intValue(); } } else work[0] = ((Number) mapval).intValue(); if (array instanceof GeneralArray) return ((GeneralArray) array).resolve(work); else return work[0]; }
@Override public String getCreateStatement() { return "" + "CREATE TRIGGER " + this.name + " " + "AFTER INSERT OR UPDATE OR DELETE ON " + table + " " + "FOR EACH ROW EXECUTE PROCEDURE " + procedure.getName() + "();" + ""; }
@Override public void create(boolean ignoreAlreadyExists) throws SQLException { super.create(ignoreAlreadyExists); PreparedStatement ps = yordifier .getConnection() .prepareStatement( "INSERT INTO " + Yordifier.TRIGGERS + " (NAME, FUNCTION_NAME, TABLE_NAME) VALUES (?, ?, ?)"); ps.setString(1, name); ps.setString(2, procedure.getName()); ps.setString(3, table); ps.execute(); }
public FcudaStreamData( Procedure kernel, ForLoop streamLoop, IDExpression streamLoopVar, IDExpression streamLoopBound, IDExpression streamLoopUpdate) { loops = new LinkedList<ForLoop>(); loops.add(streamLoop); // loopVar = streamLoopVar; loopVars = new LinkedList<IDExpression>(); loopVars.add(streamLoopVar); loopBounds = new LinkedList<IDExpression>(); loopBounds.add(streamLoopBound); // loopUpdate = streamLoopUpdate; loopUpdates = new LinkedList<IDExpression>(); loopUpdates.add(streamLoopUpdate); kernelName = kernel.getName(); mConstMemIDs = new HashSet<IDExpression>(); mConstMemIDs.clear(); }
/** * removes a procedure from the system collections * * @param myProcedure * @return boolean, represents success or failure */ public boolean deleteProcedure(Procedure myProcedure) { for (int i = 0; i < procedureList.size(); i++) { if (procedureList.get(i).getMyProcNo() == myProcedure.getMyProcNo()) { int result = JOptionPane.showConfirmDialog( null, "Are you sure you wish to permanently delete this procedure record?", null, JOptionPane.YES_NO_OPTION); if (result == JOptionPane.YES_OPTION) { procedureList.remove(i); JOptionPane.showMessageDialog(null, "Procedure removed"); return true; } else return false; } } JOptionPane.showMessageDialog(null, "Procedure not found"); return false; }
/** * Inline this ApplyExp if parameters are constant. * * @param proc the procedure bound to this.func. * @return the constant result (as a QuoteExp) if inlining was possible; otherwise this ApplyExp. * If applying proc throws an exception, print a warning on walker.messages. */ public final Expression inlineIfConstant(Procedure proc, SourceMessages messages) { int len = args.length; Object[] vals = new Object[len]; for (int i = len; --i >= 0; ) { Expression arg = args[i]; if (arg instanceof ReferenceExp) { Declaration decl = ((ReferenceExp) arg).getBinding(); if (decl != null) { arg = decl.getValue(); if (arg == QuoteExp.undefined_exp) return this; } } if (!(arg instanceof QuoteExp)) return this; vals[i] = ((QuoteExp) arg).getValue(); } try { return new QuoteExp(proc.applyN(vals), type); } catch (Throwable ex) { if (messages != null) messages.error('w', "call to " + proc + " throws " + ex); return this; } }