Examples with Command org.h2.command.Command used on opensource projects

Example 46 with Command

use of org.h2.command.Command in project h2database by h2database.

the class Parser method parseCreateSynonym.

private CreateSynonym parseCreateSynonym(boolean orReplace) {
    boolean ifNotExists = readIfNotExists();
    String name = readIdentifierWithSchema();
    Schema synonymSchema = getSchema();
    read("FOR");
    String tableName = readIdentifierWithSchema();
    Schema targetSchema = getSchema();
    CreateSynonym command = new CreateSynonym(session, synonymSchema);
    command.setName(name);
    command.setSynonymFor(tableName);
    command.setSynonymForSchema(targetSchema);
    command.setComment(readCommentIf());
    command.setIfNotExists(ifNotExists);
    command.setOrReplace(orReplace);
    return command;
}

Example 47 with Command

use of org.h2.command.Command in project h2database by h2database.

the class Parser method parseSelect.

private Query parseSelect() {
    Query command = null;
    int paramIndex = parameters.size();
    command = parseSelectUnion();
    ArrayList<Parameter> params = New.arrayList();
    for (int i = paramIndex, size = parameters.size(); i < size; i++) {
        params.add(parameters.get(i));
    }
    command.setParameterList(params);
    command.init();
    return command;
}

Example 48 with Command

use of org.h2.command.Command in project h2database by h2database.

the class Analyze method analyzeTable.

/**
 * Analyze this table.
 *
 * @param session the session
 * @param table the table
 * @param sample the number of sample rows
 * @param manual whether the command was called by the user
 */
public static void analyzeTable(Session session, Table table, int sample, boolean manual) {
    if (table.getTableType() != TableType.TABLE || table.isHidden() || session == null) {
        return;
    }
    if (!manual) {
        if (session.getDatabase().isSysTableLocked()) {
            return;
        }
        if (table.hasSelectTrigger()) {
            return;
        }
    }
    if (table.isTemporary() && !table.isGlobalTemporary() && session.findLocalTempTable(table.getName()) == null) {
        return;
    }
    if (table.isLockedExclusively() && !table.isLockedExclusivelyBy(session)) {
        return;
    }
    if (!session.getUser().hasRight(table, Right.SELECT)) {
        return;
    }
    if (session.getCancel() != 0) {
        // if the connection is closed and there is something to undo
        return;
    }
    Column[] columns = table.getColumns();
    if (columns.length == 0) {
        return;
    }
    Database db = session.getDatabase();
    StatementBuilder buff = new StatementBuilder("SELECT ");
    for (Column col : columns) {
        buff.appendExceptFirst(", ");
        int type = col.getType();
        if (type == Value.BLOB || type == Value.CLOB) {
            // can not index LOB columns, so calculating
            // the selectivity is not required
            buff.append("MAX(NULL)");
        } else {
            buff.append("SELECTIVITY(").append(col.getSQL()).append(')');
        }
    }
    buff.append(" FROM ").append(table.getSQL());
    if (sample > 0) {
        buff.append(" LIMIT ? SAMPLE_SIZE ? ");
    }
    String sql = buff.toString();
    Prepared command = session.prepare(sql);
    if (sample > 0) {
        ArrayList<Parameter> params = command.getParameters();
        params.get(0).setValue(ValueInt.get(1));
        params.get(1).setValue(ValueInt.get(sample));
    }
    ResultInterface result = command.query(0);
    result.next();
    for (int j = 0; j < columns.length; j++) {
        Value v = result.currentRow()[j];
        if (v != ValueNull.INSTANCE) {
            int selectivity = v.getInt();
            columns[j].setSelectivity(selectivity);
        }
    }
    db.updateMeta(session, table);
}

Example 49 with Command

use of org.h2.command.Command in project h2database by h2database.

the class Bnf method parse.

private void parse(Reader reader) throws SQLException, IOException {
    Rule functions = null;
    statements = New.arrayList();
    Csv csv = new Csv();
    csv.setLineCommentCharacter('#');
    ResultSet rs = csv.read(reader, null);
    while (rs.next()) {
        String section = rs.getString("SECTION").trim();
        if (section.startsWith("System")) {
            continue;
        }
        String topic = rs.getString("TOPIC");
        syntax = rs.getString("SYNTAX").trim();
        currentTopic = section;
        tokens = tokenize();
        index = 0;
        Rule rule = parseRule();
        if (section.startsWith("Command")) {
            rule = new RuleList(rule, new RuleElement(";\n\n", currentTopic), false);
        }
        RuleHead head = addRule(topic, section, rule);
        if (section.startsWith("Function")) {
            if (functions == null) {
                functions = rule;
            } else {
                functions = new RuleList(rule, functions, true);
            }
        } else if (section.startsWith("Commands")) {
            statements.add(head);
        }
    }
    addRule("@func@", "Function", functions);
    addFixedRule("@ymd@", RuleFixed.YMD);
    addFixedRule("@hms@", RuleFixed.HMS);
    addFixedRule("@nanos@", RuleFixed.NANOS);
    addFixedRule("anything_except_single_quote", RuleFixed.ANY_EXCEPT_SINGLE_QUOTE);
    addFixedRule("anything_except_double_quote", RuleFixed.ANY_EXCEPT_DOUBLE_QUOTE);
    addFixedRule("anything_until_end_of_line", RuleFixed.ANY_UNTIL_EOL);
    addFixedRule("anything_until_end_comment", RuleFixed.ANY_UNTIL_END);
    addFixedRule("anything_except_two_dollar_signs", RuleFixed.ANY_EXCEPT_2_DOLLAR);
    addFixedRule("anything", RuleFixed.ANY_WORD);
    addFixedRule("@hex_start@", RuleFixed.HEX_START);
    addFixedRule("@concat@", RuleFixed.CONCAT);
    addFixedRule("@az_@", RuleFixed.AZ_UNDERSCORE);
    addFixedRule("@af@", RuleFixed.AF);
    addFixedRule("@digit@", RuleFixed.DIGIT);
    addFixedRule("@open_bracket@", RuleFixed.OPEN_BRACKET);
    addFixedRule("@close_bracket@", RuleFixed.CLOSE_BRACKET);
}

Example 50 with Command

use of org.h2.command.Command in project h2database by h2database.

the class Set method update.

@Override
public int update() {
    Database database = session.getDatabase();
    String name = SetTypes.getTypeName(type);
    switch(type) {
        case SetTypes.ALLOW_LITERALS:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                if (value < 0 || value > 2) {
                    throw DbException.getInvalidValueException("ALLOW_LITERALS", getIntValue());
                }
                database.setAllowLiterals(value);
                addOrUpdateSetting(name, null, value);
                break;
            }
        case SetTypes.CACHE_SIZE:
            if (getIntValue() < 0) {
                throw DbException.getInvalidValueException("CACHE_SIZE", getIntValue());
            }
            session.getUser().checkAdmin();
            database.setCacheSize(getIntValue());
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.CLUSTER:
            {
                if (Constants.CLUSTERING_ENABLED.equals(stringValue)) {
                    // ignore, as the cluster setting is checked later
                    break;
                }
                String value = StringUtils.quoteStringSQL(stringValue);
                if (!value.equals(database.getCluster())) {
                    if (!value.equals(Constants.CLUSTERING_DISABLED)) {
                        // anybody can disable the cluster
                        // (if he can't access a cluster node)
                        session.getUser().checkAdmin();
                    }
                    database.setCluster(value);
                    // use the system session so that the current transaction
                    // (if any) is not committed
                    Session sysSession = database.getSystemSession();
                    synchronized (sysSession) {
                        synchronized (database) {
                            addOrUpdateSetting(sysSession, name, value, 0);
                            sysSession.commit(true);
                        }
                    }
                }
                break;
            }
        case SetTypes.COLLATION:
            {
                session.getUser().checkAdmin();
                final boolean binaryUnsigned = database.getCompareMode().isBinaryUnsigned();
                CompareMode compareMode;
                StringBuilder buff = new StringBuilder(stringValue);
                if (stringValue.equals(CompareMode.OFF)) {
                    compareMode = CompareMode.getInstance(null, 0, binaryUnsigned);
                } else {
                    int strength = getIntValue();
                    buff.append(" STRENGTH ");
                    if (strength == Collator.IDENTICAL) {
                        buff.append("IDENTICAL");
                    } else if (strength == Collator.PRIMARY) {
                        buff.append("PRIMARY");
                    } else if (strength == Collator.SECONDARY) {
                        buff.append("SECONDARY");
                    } else if (strength == Collator.TERTIARY) {
                        buff.append("TERTIARY");
                    }
                    compareMode = CompareMode.getInstance(stringValue, strength, binaryUnsigned);
                }
                CompareMode old = database.getCompareMode();
                if (old.equals(compareMode)) {
                    break;
                }
                Table table = database.getFirstUserTable();
                if (table != null) {
                    throw DbException.get(ErrorCode.COLLATION_CHANGE_WITH_DATA_TABLE_1, table.getSQL());
                }
                addOrUpdateSetting(name, buff.toString(), 0);
                database.setCompareMode(compareMode);
                break;
            }
        case SetTypes.BINARY_COLLATION:
            {
                session.getUser().checkAdmin();
                Table table = database.getFirstUserTable();
                if (table != null) {
                    throw DbException.get(ErrorCode.COLLATION_CHANGE_WITH_DATA_TABLE_1, table.getSQL());
                }
                CompareMode currentMode = database.getCompareMode();
                CompareMode newMode;
                if (stringValue.equals(CompareMode.SIGNED)) {
                    newMode = CompareMode.getInstance(currentMode.getName(), currentMode.getStrength(), false);
                } else if (stringValue.equals(CompareMode.UNSIGNED)) {
                    newMode = CompareMode.getInstance(currentMode.getName(), currentMode.getStrength(), true);
                } else {
                    throw DbException.getInvalidValueException("BINARY_COLLATION", stringValue);
                }
                addOrUpdateSetting(name, stringValue, 0);
                database.setCompareMode(newMode);
                break;
            }
        case SetTypes.COMPRESS_LOB:
            {
                session.getUser().checkAdmin();
                int algo = CompressTool.getCompressAlgorithm(stringValue);
                database.setLobCompressionAlgorithm(algo == Compressor.NO ? null : stringValue);
                addOrUpdateSetting(name, stringValue, 0);
                break;
            }
        case SetTypes.CREATE_BUILD:
            {
                session.getUser().checkAdmin();
                if (database.isStarting()) {
                    // just ignore the command if not starting
                    // this avoids problems when running recovery scripts
                    int value = getIntValue();
                    addOrUpdateSetting(name, null, value);
                }
                break;
            }
        case SetTypes.DATABASE_EVENT_LISTENER:
            {
                session.getUser().checkAdmin();
                database.setEventListenerClass(stringValue);
                break;
            }
        case SetTypes.DB_CLOSE_DELAY:
            {
                int x = getIntValue();
                if (x == -1) {
                // -1 is a special value for in-memory databases,
                // which means "keep the DB alive and use the same
                // DB for all connections"
                } else if (x < 0) {
                    throw DbException.getInvalidValueException("DB_CLOSE_DELAY", x);
                }
                session.getUser().checkAdmin();
                database.setCloseDelay(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.DEFAULT_LOCK_TIMEOUT:
            if (getIntValue() < 0) {
                throw DbException.getInvalidValueException("DEFAULT_LOCK_TIMEOUT", getIntValue());
            }
            session.getUser().checkAdmin();
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.DEFAULT_TABLE_TYPE:
            session.getUser().checkAdmin();
            database.setDefaultTableType(getIntValue());
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.EXCLUSIVE:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                switch(value) {
                    case 0:
                        database.setExclusiveSession(null, false);
                        break;
                    case 1:
                        database.setExclusiveSession(session, false);
                        break;
                    case 2:
                        database.setExclusiveSession(session, true);
                        break;
                    default:
                        throw DbException.getInvalidValueException("EXCLUSIVE", value);
                }
                break;
            }
        case SetTypes.JAVA_OBJECT_SERIALIZER:
            {
                session.getUser().checkAdmin();
                Table table = database.getFirstUserTable();
                if (table != null) {
                    throw DbException.get(ErrorCode.JAVA_OBJECT_SERIALIZER_CHANGE_WITH_DATA_TABLE, table.getSQL());
                }
                database.setJavaObjectSerializerName(stringValue);
                addOrUpdateSetting(name, stringValue, 0);
                break;
            }
        case SetTypes.IGNORECASE:
            session.getUser().checkAdmin();
            database.setIgnoreCase(getIntValue() == 1);
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.LOCK_MODE:
            session.getUser().checkAdmin();
            database.setLockMode(getIntValue());
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.LOCK_TIMEOUT:
            if (getIntValue() < 0) {
                throw DbException.getInvalidValueException("LOCK_TIMEOUT", getIntValue());
            }
            session.setLockTimeout(getIntValue());
            break;
        case SetTypes.LOG:
            {
                int value = getIntValue();
                if (database.isPersistent() && value != database.getLogMode()) {
                    session.getUser().checkAdmin();
                    database.setLogMode(value);
                }
                break;
            }
        case SetTypes.MAX_LENGTH_INPLACE_LOB:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("MAX_LENGTH_INPLACE_LOB", getIntValue());
                }
                session.getUser().checkAdmin();
                database.setMaxLengthInplaceLob(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.MAX_LOG_SIZE:
            if (getIntValue() < 0) {
                throw DbException.getInvalidValueException("MAX_LOG_SIZE", getIntValue());
            }
            session.getUser().checkAdmin();
            database.setMaxLogSize((long) getIntValue() * 1024 * 1024);
            addOrUpdateSetting(name, null, getIntValue());
            break;
        case SetTypes.MAX_MEMORY_ROWS:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("MAX_MEMORY_ROWS", getIntValue());
                }
                session.getUser().checkAdmin();
                database.setMaxMemoryRows(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.MAX_MEMORY_UNDO:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("MAX_MEMORY_UNDO", getIntValue());
                }
                session.getUser().checkAdmin();
                database.setMaxMemoryUndo(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.MAX_OPERATION_MEMORY:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("MAX_OPERATION_MEMORY", getIntValue());
                }
                session.getUser().checkAdmin();
                int value = getIntValue();
                database.setMaxOperationMemory(value);
                break;
            }
        case SetTypes.MODE:
            Mode mode = Mode.getInstance(stringValue);
            if (mode == null) {
                throw DbException.get(ErrorCode.UNKNOWN_MODE_1, stringValue);
            }
            if (database.getMode() != mode) {
                session.getUser().checkAdmin();
                database.setMode(mode);
                session.getColumnNamerConfiguration().configure(mode.getEnum());
            }
            break;
        case SetTypes.MULTI_THREADED:
            {
                session.getUser().checkAdmin();
                database.setMultiThreaded(getIntValue() == 1);
                break;
            }
        case SetTypes.MVCC:
            {
                if (database.isMultiVersion() != (getIntValue() == 1)) {
                    throw DbException.get(ErrorCode.CANNOT_CHANGE_SETTING_WHEN_OPEN_1, "MVCC");
                }
                break;
            }
        case SetTypes.OPTIMIZE_REUSE_RESULTS:
            {
                session.getUser().checkAdmin();
                database.setOptimizeReuseResults(getIntValue() != 0);
                break;
            }
        case SetTypes.QUERY_TIMEOUT:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("QUERY_TIMEOUT", getIntValue());
                }
                int value = getIntValue();
                session.setQueryTimeout(value);
                break;
            }
        case SetTypes.REDO_LOG_BINARY:
            {
                int value = getIntValue();
                session.setRedoLogBinary(value == 1);
                break;
            }
        case SetTypes.REFERENTIAL_INTEGRITY:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                if (value < 0 || value > 1) {
                    throw DbException.getInvalidValueException("REFERENTIAL_INTEGRITY", getIntValue());
                }
                database.setReferentialIntegrity(value == 1);
                break;
            }
        case SetTypes.QUERY_STATISTICS:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                if (value < 0 || value > 1) {
                    throw DbException.getInvalidValueException("QUERY_STATISTICS", getIntValue());
                }
                database.setQueryStatistics(value == 1);
                break;
            }
        case SetTypes.QUERY_STATISTICS_MAX_ENTRIES:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                if (value < 1) {
                    throw DbException.getInvalidValueException("QUERY_STATISTICS_MAX_ENTRIES", getIntValue());
                }
                database.setQueryStatisticsMaxEntries(value);
                break;
            }
        case SetTypes.SCHEMA:
            {
                Schema schema = database.getSchema(stringValue);
                session.setCurrentSchema(schema);
                break;
            }
        case SetTypes.SCHEMA_SEARCH_PATH:
            {
                session.setSchemaSearchPath(stringValueList);
                break;
            }
        case SetTypes.TRACE_LEVEL_FILE:
            session.getUser().checkAdmin();
            if (getCurrentObjectId() == 0) {
                // don't set the property when opening the database
                // this is for compatibility with older versions, because
                // this setting was persistent
                database.getTraceSystem().setLevelFile(getIntValue());
            }
            break;
        case SetTypes.TRACE_LEVEL_SYSTEM_OUT:
            session.getUser().checkAdmin();
            if (getCurrentObjectId() == 0) {
                // don't set the property when opening the database
                // this is for compatibility with older versions, because
                // this setting was persistent
                database.getTraceSystem().setLevelSystemOut(getIntValue());
            }
            break;
        case SetTypes.TRACE_MAX_FILE_SIZE:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("TRACE_MAX_FILE_SIZE", getIntValue());
                }
                session.getUser().checkAdmin();
                int size = getIntValue() * 1024 * 1024;
                database.getTraceSystem().setMaxFileSize(size);
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.THROTTLE:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("THROTTLE", getIntValue());
                }
                session.setThrottle(getIntValue());
                break;
            }
        case SetTypes.UNDO_LOG:
            {
                int value = getIntValue();
                if (value < 0 || value > 1) {
                    throw DbException.getInvalidValueException("UNDO_LOG", getIntValue());
                }
                session.setUndoLogEnabled(value == 1);
                break;
            }
        case SetTypes.VARIABLE:
            {
                Expression expr = expression.optimize(session);
                session.setVariable(stringValue, expr.getValue(session));
                break;
            }
        case SetTypes.WRITE_DELAY:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("WRITE_DELAY", getIntValue());
                }
                session.getUser().checkAdmin();
                database.setWriteDelay(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.RETENTION_TIME:
            {
                if (getIntValue() < 0) {
                    throw DbException.getInvalidValueException("RETENTION_TIME", getIntValue());
                }
                session.getUser().checkAdmin();
                database.setRetentionTime(getIntValue());
                addOrUpdateSetting(name, null, getIntValue());
                break;
            }
        case SetTypes.ROW_FACTORY:
            {
                session.getUser().checkAdmin();
                String rowFactoryName = expression.getColumnName();
                Class<RowFactory> rowFactoryClass = JdbcUtils.loadUserClass(rowFactoryName);
                RowFactory rowFactory;
                try {
                    rowFactory = rowFactoryClass.newInstance();
                } catch (Exception e) {
                    throw DbException.convert(e);
                }
                database.setRowFactory(rowFactory);
                break;
            }
        case SetTypes.BATCH_JOINS:
            {
                int value = getIntValue();
                if (value != 0 && value != 1) {
                    throw DbException.getInvalidValueException("BATCH_JOINS", getIntValue());
                }
                session.setJoinBatchEnabled(value == 1);
                break;
            }
        case SetTypes.FORCE_JOIN_ORDER:
            {
                int value = getIntValue();
                if (value != 0 && value != 1) {
                    throw DbException.getInvalidValueException("FORCE_JOIN_ORDER", value);
                }
                session.setForceJoinOrder(value == 1);
                break;
            }
        case SetTypes.LAZY_QUERY_EXECUTION:
            {
                int value = getIntValue();
                if (value != 0 && value != 1) {
                    throw DbException.getInvalidValueException("LAZY_QUERY_EXECUTION", value);
                }
                session.setLazyQueryExecution(value == 1);
                break;
            }
        case SetTypes.BUILTIN_ALIAS_OVERRIDE:
            {
                session.getUser().checkAdmin();
                int value = getIntValue();
                if (value != 0 && value != 1) {
                    throw DbException.getInvalidValueException("BUILTIN_ALIAS_OVERRIDE", value);
                }
                database.setAllowBuiltinAliasOverride(value == 1);
                break;
            }
        case SetTypes.COLUMN_NAME_RULES:
            {
                session.getUser().checkAdmin();
                session.getColumnNamerConfiguration().configure(expression.getColumnName());
                break;
            }
        default:
            DbException.throwInternalError("type=" + type);
    }
    // the meta data information has changed
    database.getNextModificationDataId();
    // query caches might be affected as well, for example
    // when changing the compatibility mode
    database.getNextModificationMetaId();
    return 0;
}