Examples with Prepared org.h2.test.db.Db.Prepared used on opensource projects

Example 16 with Prepared

use of org.h2.test.db.Db.Prepared in project h2database by h2database.

the class Parser method prepare.

private static Prepared prepare(Session s, String sql, ArrayList<Value> paramValues) {
    Prepared prep = s.prepare(sql);
    ArrayList<Parameter> params = prep.getParameters();
    if (params != null) {
        for (int i = 0, size = params.size(); i < size; i++) {
            Parameter p = params.get(i);
            p.setValue(paramValues.get(i));
        }
    }
    return prep;
}

Example 17 with Prepared

use of org.h2.test.db.Db.Prepared in project h2database by h2database.

the class Parser method parseMerge.

private Prepared parseMerge() {
    Merge command = new Merge(session);
    currentPrepared = command;
    int start = lastParseIndex;
    read("INTO");
    List<String> excludeIdentifiers = Arrays.asList("USING", "KEY", "VALUES");
    TableFilter targetTableFilter = readSimpleTableFilter(0, excludeIdentifiers);
    command.setTargetTableFilter(targetTableFilter);
    Table table = command.getTargetTable();
    if (readIf("USING")) {
        return parseMergeUsing(command, start);
    }
    if (readIf("(")) {
        if (isSelect()) {
            command.setQuery(parseSelect());
            read(")");
            return command;
        }
        Column[] columns = parseColumnList(table);
        command.setColumns(columns);
    }
    if (readIf("KEY")) {
        read("(");
        Column[] keys = parseColumnList(table);
        command.setKeys(keys);
    }
    if (readIf("VALUES")) {
        do {
            ArrayList<Expression> values = New.arrayList();
            read("(");
            if (!readIf(")")) {
                do {
                    if (readIf("DEFAULT")) {
                        values.add(null);
                    } else {
                        values.add(readExpression());
                    }
                } while (readIfMore(false));
            }
            command.addRow(values.toArray(new Expression[0]));
        } while (readIf(","));
    } else {
        command.setQuery(parseSelect());
    }
    return command;
}

Example 18 with Prepared

use of org.h2.test.db.Db.Prepared in project h2database by h2database.

the class Parser method parsePrepare.

private Prepared parsePrepare() {
    if (readIf("COMMIT")) {
        TransactionCommand command = new TransactionCommand(session, CommandInterface.PREPARE_COMMIT);
        command.setTransactionName(readUniqueIdentifier());
        return command;
    }
    String procedureName = readAliasIdentifier();
    if (readIf("(")) {
        ArrayList<Column> list = New.arrayList();
        for (int i = 0; ; i++) {
            Column column = parseColumnForTable("C" + i, true);
            list.add(column);
            if (readIf(")")) {
                break;
            }
            read(",");
        }
    }
    read("AS");
    Prepared prep = parsePrepared();
    PrepareProcedure command = new PrepareProcedure(session);
    command.setProcedureName(procedureName);
    command.setPrepared(prep);
    return command;
}

Example 19 with Prepared

use of org.h2.test.db.Db.Prepared in project h2database by h2database.

the class Parser method parseBackup.

private Prepared parseBackup() {
    BackupCommand command = new BackupCommand(session);
    read("TO");
    command.setFileName(readExpression());
    return command;
}

Example 20 with Prepared

use of org.h2.test.db.Db.Prepared in project h2database by h2database.

the class Parser method parseMergeUsing.

private MergeUsing parseMergeUsing(Merge oldCommand, int start) {
    MergeUsing command = new MergeUsing(oldCommand);
    currentPrepared = command;
    if (readIf("(")) {
        /* a select query is supplied */
        if (isSelect()) {
            command.setQuery(parseSelect());
            read(")");
        }
        command.setQueryAlias(readFromAlias(null, Collections.singletonList("ON")));
        String[] querySQLOutput = { null };
        List<Column> columnTemplateList = TableView.createQueryColumnTemplateList(null, command.getQuery(), querySQLOutput);
        TableView temporarySourceTableView = createCTEView(command.getQueryAlias(), querySQLOutput[0], columnTemplateList, false, /* no recursion */
        false, /* do not add to session */
        false, /* isPersistent */
        session);
        TableFilter sourceTableFilter = new TableFilter(session, temporarySourceTableView, command.getQueryAlias(), rightsChecked, (Select) command.getQuery(), 0, null);
        command.setSourceTableFilter(sourceTableFilter);
    } else {
        /* Its a table name, simulate a query by building a select query for the table */
        List<String> excludeIdentifiers = Collections.singletonList("ON");
        TableFilter sourceTableFilter = readSimpleTableFilter(0, excludeIdentifiers);
        command.setSourceTableFilter(sourceTableFilter);
        StringBuilder buff = new StringBuilder("SELECT * FROM ");
        appendTableWithSchemaAndAlias(buff, sourceTableFilter.getTable(), sourceTableFilter.getTableAlias());
        Prepared preparedQuery = prepare(session, buff.toString(), null);
        command.setQuery((Select) preparedQuery);
    }
    read("ON");
    read("(");
    Expression condition = readExpression();
    command.setOnCondition(condition);
    read(")");
    if (readIfAll("WHEN", "MATCHED", "THEN")) {
        int startMatched = lastParseIndex;
        if (readIf("UPDATE")) {
            Update updateCommand = new Update(session);
            // currentPrepared = updateCommand;
            TableFilter filter = command.getTargetTableFilter();
            updateCommand.setTableFilter(filter);
            parseUpdateSetClause(updateCommand, filter, startMatched);
            command.setUpdateCommand(updateCommand);
        }
        startMatched = lastParseIndex;
        if (readIf("DELETE")) {
            Delete deleteCommand = new Delete(session);
            TableFilter filter = command.getTargetTableFilter();
            deleteCommand.setTableFilter(filter);
            parseDeleteGivenTable(deleteCommand, null, startMatched);
            command.setDeleteCommand(deleteCommand);
        }
    }
    if (readIfAll("WHEN", "NOT", "MATCHED", "THEN")) {
        if (readIf("INSERT")) {
            Insert insertCommand = new Insert(session);
            insertCommand.setTable(command.getTargetTable());
            parseInsertGivenTable(insertCommand, command.getTargetTable());
            command.setInsertCommand(insertCommand);
        }
    }
    setSQL(command, "MERGE", start);
    // build and prepare the targetMatchQuery ready to test each rows
    // existence in the target table (using source row to match)
    StringBuilder targetMatchQuerySQL = new StringBuilder("SELECT _ROWID_ FROM ");
    appendTableWithSchemaAndAlias(targetMatchQuerySQL, command.getTargetTable(), command.getTargetTableFilter().getTableAlias());
    targetMatchQuerySQL.append(" WHERE ").append(command.getOnCondition().getSQL());
    command.setTargetMatchQuery((Select) parse(targetMatchQuerySQL.toString()));
    return command;
}