metatable.java

非常棒的java数据库

                if (table.getTemporary()) {
                    if (table.getGlobalTemporary()) {
                        storageType = "GLOBAL TEMPORARY";
                    } else {
                        storageType = "LOCAL TEMPORARY";
                    }
                } else {
                    storageType = table.isPersistent() ? "CACHED" : "MEMORY";
                }
                add(rows, new String[] {
                        catalog, // TABLE_CATALOG
                        identifier(table.getSchema().getName()), // TABLE_SCHEMA
                        tableName, // TABLE_NAME
                        table.getTableType(), // TABLE_TYPE
                        storageType, // STORAGE_TYPE
                        table.getCreateSQL(), // SQL
                        replaceNullWithEmpty(table.getComment()), // REMARKS
                        "" + table.getId() // ID
                });
            }
            break;
        }
        case COLUMNS: {
            ObjectArray tables = getAllTables(session);
            for (int i = 0; i < tables.size(); i++) {
                Table table = (Table) tables.get(i);
                String tableName = identifier(table.getName());
                if (!checkIndex(session, tableName, indexFrom, indexTo)) {
                    continue;
                }
                Column[] cols = table.getColumns();
                String collation = database.getCompareMode().getName();
                for (int j = 0; j < cols.length; j++) {
                    Column c = cols[j];
                    add(rows, new String[]{
                            catalog, // TABLE_CATALOG
                            identifier(table.getSchema().getName()), // TABLE_SCHEMA
                            tableName, // TABLE_NAME
                            identifier(c.getName()), // COLUMN_NAME
                            String.valueOf(j + 1), // ORDINAL_POSITION
                            c.getDefaultSQL(), // COLUMN_DEFAULT
                            c.getNullable() ? "YES" : "NO", // IS_NULLABLE
                            "" + DataType.convertTypeToSQLType(c.getType()), // DATA_TYPE
                            "" + c.getPrecisionAsInt(), // CHARACTER_MAXIMUM_LENGTH
                            "" + c.getPrecisionAsInt(), // CHARACTER_OCTET_LENGTH
                            "" + c.getPrecisionAsInt(), // NUMERIC_PRECISION
                            "10", // NUMERIC_PRECISION_RADIX
                            "" + c.getScale(), // NUMERIC_SCALE
                            Constants.CHARACTER_SET_NAME, // CHARACTER_SET_NAME
                            collation, // COLLATION_NAME
                            identifier(DataType.getDataType(c.getType()).name), // TYPE_NAME
                            "" + (c.getNullable() ? DatabaseMetaData.columnNullable : DatabaseMetaData.columnNoNulls) , // NULLABLE
                            "" + (c.getComputed() ? "TRUE" : "FALSE"), // IS_COMPUTED
                            "" + (c.getSelectivity()), // SELECTIVITY
                            c.getCheckConstraintSQL(session, c.getName()),  // CHECK_CONSTRAINT
                            replaceNullWithEmpty(c.getComment()) // REMARKS
                    });
                }
            }
            break;
        }
        case INDEXES: {
            ObjectArray tables = getAllTables(session);
            for (int i = 0; i < tables.size(); i++) {
                Table table = (Table) tables.get(i);
                String tableName = identifier(table.getName());
                if (!checkIndex(session, tableName, indexFrom, indexTo)) {
                    continue;
                }
                ObjectArray idx = table.getIndexes();
                for (int j = 0; idx != null && j < idx.size(); j++) {
                    Index index = (Index) idx.get(j);
                    if (index.getCreateSQL() == null) {
                        continue;
                    }
                    IndexColumn[] cols = index.getIndexColumns();
                    for (int k = 0; k < cols.length; k++) {
                        IndexColumn idxCol = cols[k];
                        Column column = idxCol.column;
                        add(rows, new String[] {
                                catalog, // TABLE_CATALOG
                                identifier(table.getSchema().getName()), // TABLE_SCHEMA
                                tableName, // TABLE_NAME
                                index.getIndexType().isUnique() ? "FALSE" : "TRUE", // NON_UNIQUE
                                identifier(index.getName()), // INDEX_NAME
                                "" + (k+1), // ORDINAL_POSITION
                                identifier(column.getName()), // COLUMN_NAME
                                "0", // CARDINALITY
                                index.getIndexType().isPrimaryKey() ? "TRUE" : "FALSE", // PRIMARY_KEY
                                index.getIndexType().getSQL(), // INDEX_TYPE_NAME
                                index.getIndexType().belongsToConstraint() ? "TRUE" : "FALSE", // IS_GENERATED
                                "" + DatabaseMetaData.tableIndexOther, // INDEX_TYPE
                                (idxCol.sortType & SortOrder.DESCENDING) != 0 ? "D" : "A", // ASC_OR_DESC
                                "0", // PAGES
                                "", // FILTER_CONDITION
                                replaceNullWithEmpty(index.getComment()), // REMARKS
                                index.getSQL(), // SQL
                                "" + index.getId(), // ID
                                "" + idxCol.sortType, // SORT_TYPE
                            });
                    }
                }
            }
            break;
        }
        case TABLE_TYPES: {
            add(rows, new String[] { Table.TABLE });
            add(rows, new String[] { Table.TABLE_LINK });
            add(rows, new String[] { Table.SYSTEM_TABLE });
            add(rows, new String[] { Table.VIEW });
            break;
        }
        case CATALOGS: {
            add(rows, new String[] { catalog });
            break;
        }
        case SETTINGS: {
            ObjectArray list = database.getAllSettings();
            for (int i = 0; i < list.size(); i++) {
                Setting s = (Setting) list.get(i);
                String value = s.getStringValue();
                if (value == null) {
                    value = "" + s.getIntValue();
                }
                add(rows, new String[] {
                        identifier(s.getName()),
                        value
                });
            }
            add(rows, new String[]{"info.BUILD_ID", "" + Constants.BUILD_ID});
            add(rows, new String[]{"info.VERSION_MAJOR", "" + Constants.VERSION_MAJOR});
            add(rows, new String[]{"info.VERSION_MINOR", "" + Constants.VERSION_MINOR});
            add(rows, new String[]{"info.VERSION", "" + Constants.getVersion()});
            if (session.getUser().getAdmin()) {
                String[] settings = new String[]{
                        "java.runtime.version",
                        "java.vm.name", "java.vendor",
                        "os.name", "os.arch", "os.version", "sun.os.patch.level",
                        "file.separator", "path.separator", "line.separator",
                        "user.country", "user.language", "user.variant", "file.encoding"
                };
                for (int i = 0; i < settings.length; i++) {
                    String s = settings[i];
                    add(rows, new String[] { "property." + s, SysProperties.getStringSetting(s, "") });
                }
            }
            add(rows, new String[] { "EXCLUSIVE", database.getExclusiveSession() == null ? "FALSE" : "TRUE" });
            add(rows, new String[] { "MODE", database.getMode().getName() });
            add(rows, new String[] { "MULTI_THREADED", database.getMultiThreaded() ? "1" : "0"});
            add(rows, new String[] { "MVCC", database.isMultiVersion() ? "TRUE" : "FALSE" });
            add(rows, new String[] { "QUERY_TIMEOUT", "" + session.getQueryTimeout() });
            // the setting for the current database
            add(rows, new String[] { "LOB_FILES_IN_DIRECTORIES", "" + database.getLobFilesInDirectories() });
            add(rows, new String[]{"h2.allowBigDecimalExtensions", "" + SysProperties.ALLOW_BIG_DECIMAL_EXTENSIONS});
            add(rows, new String[]{"h2.baseDir", "" + SysProperties.getBaseDir()});
            add(rows, new String[]{"h2.check", "" + SysProperties.CHECK});
            add(rows, new String[]{"h2.check2", "" + SysProperties.CHECK2});
            add(rows, new String[]{"h2.clientTraceDirectory", SysProperties.CLIENT_TRACE_DIRECTORY});
            add(rows, new String[]{SysProperties.H2_COLLATOR_CACHE_SIZE, "" + SysProperties.getCollatorCacheSize()});
            add(rows, new String[]{"h2.defaultMaxMemoryUndo", "" + SysProperties.DEFAULT_MAX_MEMORY_UNDO});
            add(rows, new String[]{"h2.emergencySpaceInitial", "" + SysProperties.EMERGENCY_SPACE_INITIAL});
            add(rows, new String[]{"h2.emergencySpaceMin", "" + SysProperties.EMERGENCY_SPACE_MIN});
            add(rows, new String[]{"h2.lobFilesInDirectories", "" + SysProperties.LOB_FILES_IN_DIRECTORIES});
            add(rows, new String[]{"h2.lobFilesPerDirectory", "" + SysProperties.LOB_FILES_PER_DIRECTORY});
            add(rows, new String[]{"h2.logAllErrors", "" + SysProperties.LOG_ALL_ERRORS});
            add(rows, new String[]{"h2.logAllErrorsFile", "" + SysProperties.LOG_ALL_ERRORS_FILE});
            add(rows, new String[]{"h2.maxFileRetry", "" + SysProperties.MAX_FILE_RETRY});
            add(rows, new String[]{SysProperties.H2_MAX_QUERY_TIMEOUT, "" + SysProperties.getMaxQueryTimeout()});
            add(rows, new String[]{"h2.lobCloseBetweenReads", "" + SysProperties.lobCloseBetweenReads});
            add(rows, new String[]{"h2.objectCache", "" + SysProperties.OBJECT_CACHE});
            add(rows, new String[]{"h2.objectCacheSize", "" + SysProperties.OBJECT_CACHE_SIZE});
            add(rows, new String[]{"h2.objectCacheMaxPerElementSize", "" + SysProperties.OBJECT_CACHE_MAX_PER_ELEMENT_SIZE});
            add(rows, new String[]{"h2.optimizeIn", "" + SysProperties.OPTIMIZE_IN});
            add(rows, new String[]{"h2.optimizeInJoin", "" + SysProperties.OPTIMIZE_IN_JOIN});
            add(rows, new String[]{"h2.optimizeMinMax", "" + SysProperties.OPTIMIZE_MIN_MAX});
            add(rows, new String[]{"h2.optimizeSubqueryCache", "" + SysProperties.OPTIMIZE_SUBQUERY_CACHE});
            add(rows, new String[]{"h2.overflowExceptions", "" + SysProperties.OVERFLOW_EXCEPTIONS});
            add(rows, new String[]{"h2.recompileAlways", "" + SysProperties.RECOMPILE_ALWAYS});
            add(rows, new String[]{"h2.redoBufferSize", "" + SysProperties.REDO_BUFFER_SIZE});
            add(rows, new String[]{"h2.runFinalize", "" + SysProperties.runFinalize});
            add(rows, new String[]{"h2.scriptDirectory", SysProperties.scriptDirectory});
            add(rows, new String[]{"h2.serverCachedObjects", "" + SysProperties.SERVER_CACHED_OBJECTS});
            add(rows, new String[]{"h2.serverResultSetFetchSize", "" + SysProperties.SERVER_RESULT_SET_FETCH_SIZE});
            DiskFile dataFile = database.getDataFile();
            if (dataFile != null) {
                add(rows, new String[] { "CACHE_TYPE", dataFile.getCache().getTypeName() });
                if (session.getUser().getAdmin()) {
                    add(rows, new String[]{"info.FILE_DISK_WRITE", "" + dataFile.getWriteCount()});
                    add(rows, new String[]{"info.FILE_DISK_READ", "" + dataFile.getReadCount()});
                    add(rows, new String[]{"info.FILE_INDEX_WRITE", "" + database.getIndexFile().getWriteCount()});
                    add(rows, new String[]{"info.FILE_INDEX_READ", "" + database.getIndexFile().getReadCount()});
                }
            }
            break;
        }
        case TYPE_INFO: {
            ObjectArray types = DataType.getTypes();
            for (int i = 0; i < types.size(); i++) {
                DataType t = (DataType) types.get(i);
                if (t.hidden || t.sqlType == Value.NULL) {
                    continue;
                }
                add(rows, new String[] {
                        t.name, // TYPE_NAME
                        String.valueOf(t.sqlType), // DATA_TYPE
                        String.valueOf(t.maxPrecision), // PRECISION
                        t.prefix, // PREFIX
                        t.suffix, // SUFFIX
                        t.params, // PARAMS
                        String.valueOf(t.autoInc), // AUTO_INCREMENT
                        String.valueOf(t.minScale), // MINIMUM_SCALE
                        String.valueOf(t.maxScale), // MAXIMUM_SCALE
                        t.decimal ? "10" : null, // RADIX
                        String.valueOf(t.sqlTypePos), // POS
                        String.valueOf(t.caseSensitive), // CASE_SENSITIVE
                        "" + DatabaseMetaData.typeNullable, // NULLABLE
                        "" + DatabaseMetaData.typeSearchable // SEARCHABLE
                });
            }
            break;
        }
        case HELP: {
            String resource = "/org/h2/res/help.csv";
            try {
                byte[] data = Resources.get(resource);
                Reader reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(data)));
                ResultSet rs = Csv.getInstance().read(reader, null);
                for (int i = 0; rs.next(); i++) {
                    add(rows, new String[] {
                        String.valueOf(i), // ID
                        rs.getString(1).trim(), // SECTION
                        rs.getString(2).trim(), // TOPIC
                        rs.getString(3).trim(), // SYNTAX
                        rs.getString(4).trim(), // TEXT
                        rs.getString(5).trim(), // EXAMPLE
                    });
                }
            } catch (IOException e) {
                throw Message.convertIOException(e, resource);
            }
            break;
        }
        case SEQUENCES: {
            ObjectArray sequences = database.getAllSchemaObjects(DbObject.SEQUENCE);
            for (int i = 0; i < sequences.size(); i++) {
                Sequence s = (Sequence) sequences.get(i);
                add(rows, new String[] {
                        catalog, // SEQUENCE_CATALOG
                        identifier(s.getSchema().getName()), // SEQUENCE_SCHEMA
                        identifier(s.getName()), // SEQUENCE_NAME
                        String.valueOf(s.getCurrentValue()), // CURRENT_VALUE
                        String.valueOf(s.getIncrement()), // INCREMENT
                        s.getBelongsToTable() ? "TRUE" : "FALSE", // IS_GENERATED
                        replaceNullWithEmpty(s.getComment()), // REMARKS
                        String.valueOf(s.getCacheSize()), // CACHE
                        "" + s.getId() // ID
                    });
            }
            break;
        }
        case USERS: {
            ObjectArray users = database.getAllUsers();
            for (int i = 0; i < users.size(); i++) {
                User u = (User) users.get(i);
                add(rows, new String[] {
                        identifier(u.getName()), // NAME
                        String.valueOf(u.getAdmin()), // ADMIN
                        replaceNullWithEmpty(u.getComment()), // REMARKS
                        "" + u.getId() //
                });
            }
            break;
        }
        case ROLES: {
            ObjectArray roles = database.getAllRoles();
            for (int i = 0; i < roles.size(); i++) {
                Role r = (Role) roles.get(i);
                add(rows, new String[] {
                        identifier(r.getName()), // NAME
                        replaceNullWithEmpty(r.getComment()), // REMARKS
                        "" + r.getId() // ID
                });
            }