diff --git beeline/src/java/org/apache/hive/beeline/HiveSchemaHelper.java beeline/src/java/org/apache/hive/beeline/HiveSchemaHelper.java index 181f0d2..7e4a68d 100644 --- beeline/src/java/org/apache/hive/beeline/HiveSchemaHelper.java +++ beeline/src/java/org/apache/hive/beeline/HiveSchemaHelper.java @@ -34,6 +34,7 @@ public class HiveSchemaHelper { public static final String DB_DERBY = "derby"; + public static final String DB_HIVE = "hive"; public static final String DB_MSSQL = "mssql"; public static final String DB_MYSQL = "mysql"; public static final String DB_POSTGRACE = "postgres"; @@ -50,15 +51,16 @@ * @throws org.apache.hadoop.hive.metastore.api.MetaException */ public static Connection getConnectionToMetastore(String userName, - String password, boolean printInfo, HiveConf hiveConf) + String password, String url, String driver, boolean printInfo, + HiveConf hiveConf) throws HiveMetaException { try { - String connectionURL = getValidConfVar( - HiveConf.ConfVars.METASTORECONNECTURLKEY, hiveConf); - String driver = getValidConfVar( - HiveConf.ConfVars.METASTORE_CONNECTION_DRIVER, hiveConf); + url = url == null ? getValidConfVar( + HiveConf.ConfVars.METASTORECONNECTURLKEY, hiveConf) : url; + driver = driver == null ? getValidConfVar( + HiveConf.ConfVars.METASTORE_CONNECTION_DRIVER, hiveConf) : driver; if (printInfo) { - System.out.println("Metastore connection URL:\t " + connectionURL); + System.out.println("Metastore connection URL:\t " + url); System.out.println("Metastore Connection Driver :\t " + driver); System.out.println("Metastore connection User:\t " + userName); } @@ -70,7 +72,7 @@ public static Connection getConnectionToMetastore(String userName, Class.forName(driver); // Connect using the JDBC URL and user/pass from conf - return DriverManager.getConnection(connectionURL, userName, password); + return DriverManager.getConnection(url, userName, password); } catch (IOException e) { throw new HiveMetaException("Failed to get schema version.", e); } catch (SQLException e) { @@ -319,6 +321,34 @@ public boolean isNestedScript(String dbCommand) { } } + // Derby commandline parser + public static class HiveCommandParser extends AbstractCommandParser { + private static String HIVE_NESTING_TOKEN = "SOURCE"; + + public HiveCommandParser(String dbOpts, String msUsername, String msPassword, + HiveConf hiveConf) { + super(dbOpts, msUsername, msPassword, hiveConf); + } + + @Override + public String getScriptName(String dbCommand) throws IllegalArgumentException { + + if (!isNestedScript(dbCommand)) { + throw new IllegalArgumentException("Not a script format " + dbCommand); + } + String[] tokens = dbCommand.split(" "); + if (tokens.length != 2) { + throw new IllegalArgumentException("Couldn't parse line " + dbCommand); + } + return tokens[1].replace(";", ""); + } + + @Override + public boolean isNestedScript(String dbCommand) { + return dbCommand.startsWith(HIVE_NESTING_TOKEN); + } + } + // MySQL parser public static class MySqlCommandParser extends AbstractCommandParser { private static final String MYSQL_NESTING_TOKEN = "SOURCE"; @@ -482,6 +512,8 @@ public static NestedScriptParser getDbCommandParser(String dbName, HiveConf hiveConf) { if (dbName.equalsIgnoreCase(DB_DERBY)) { return new DerbyCommandParser(dbOpts, msUsername, msPassword, hiveConf); + } else if (dbName.equalsIgnoreCase(DB_HIVE)) { + return new DerbyCommandParser(dbOpts, msUsername, msPassword, hiveConf); } else if (dbName.equalsIgnoreCase(DB_MSSQL)) { return new MSSQLCommandParser(dbOpts, msUsername, msPassword, hiveConf); } else if (dbName.equalsIgnoreCase(DB_MYSQL)) { diff --git beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java index 96b2978..58edb12 100644 --- beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java +++ beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java @@ -71,6 +71,8 @@ private boolean dryRun = false; private boolean verbose = false; private String dbOpts = null; + private String url = null; + private String driver = null; private URI[] validationServers = null; // The list of servers the database/partition/table can locate on private final HiveConf hiveConf; private final String dbType; @@ -103,6 +105,14 @@ public HiveConf getHiveConf() { return hiveConf; } + public void setUrl(String url) { + this.url = url; + } + + public void setDriver(String driver) { + this.driver = driver; + } + public void setUserName(String userName) { this.userName = userName; } @@ -142,7 +152,7 @@ private static void printAndExit(Options cmdLineOptions) { Connection getConnectionToMetastore(boolean printInfo) throws HiveMetaException { return HiveSchemaHelper.getConnectionToMetastore(userName, - passWord, printInfo, hiveConf); + passWord, url, driver, printInfo, hiveConf); } private NestedScriptParser getDbCommandParser(String dbType) { @@ -807,7 +817,8 @@ private void runBeeLine(String scriptDir, String scriptFile) // Generate the beeline args per hive conf and execute the given script public void runBeeLine(String sqlScriptFile) throws IOException { - CommandBuilder builder = new CommandBuilder(hiveConf, userName, passWord, sqlScriptFile); + CommandBuilder builder = new CommandBuilder(hiveConf, url, driver, + userName, passWord, sqlScriptFile); // run the script using Beeline try (BeeLine beeLine = new BeeLine()) { @@ -833,11 +844,16 @@ public void runBeeLine(String sqlScriptFile) throws IOException { private final String userName; private final String password; private final String sqlScriptFile; + private final String driver; + private final String url; - CommandBuilder(HiveConf hiveConf, String userName, String password, String sqlScriptFile) { + CommandBuilder(HiveConf hiveConf, String url, String driver, + String userName, String password, String sqlScriptFile) { this.hiveConf = hiveConf; this.userName = userName; this.password = password; + this.url = url; + this.driver = driver; this.sqlScriptFile = sqlScriptFile; } @@ -851,10 +867,14 @@ String buildToLog() throws IOException { } private String[] argsWith(String password) throws IOException { - return new String[] { "-u", - HiveSchemaHelper.getValidConfVar(ConfVars.METASTORECONNECTURLKEY, hiveConf), "-d", - HiveSchemaHelper.getValidConfVar(ConfVars.METASTORE_CONNECTION_DRIVER, hiveConf), "-n", - userName, "-p", password, "-f", sqlScriptFile }; + return new String[] + { + "-u", url == null ? HiveSchemaHelper.getValidConfVar(ConfVars.METASTORECONNECTURLKEY, hiveConf) : url, + "-d", driver == null ? HiveSchemaHelper.getValidConfVar(ConfVars.METASTORE_CONNECTION_DRIVER, hiveConf) : driver, + "-n", userName, + "-p", password, + "-f", sqlScriptFile + }; } private void logScript() throws IOException { @@ -946,6 +966,7 @@ public static void main(String[] args) { if (line.hasOption("dbType")) { dbType = line.getOptionValue("dbType"); if ((!dbType.equalsIgnoreCase(HiveSchemaHelper.DB_DERBY) && + !dbType.equalsIgnoreCase(HiveSchemaHelper.DB_HIVE) && !dbType.equalsIgnoreCase(HiveSchemaHelper.DB_MSSQL) && !dbType.equalsIgnoreCase(HiveSchemaHelper.DB_MYSQL) && !dbType.equalsIgnoreCase(HiveSchemaHelper.DB_POSTGRACE) && !dbType @@ -968,6 +989,12 @@ public static void main(String[] args) { if (line.hasOption("passWord")) { schemaTool.setPassWord(line.getOptionValue("passWord")); } + if (line.hasOption("url")) { + schemaTool.setUrl(line.getOptionValue("url")); + } + if (line.hasOption("driver")) { + schemaTool.setDriver(line.getOptionValue("driver")); + } if (line.hasOption("dryRun")) { schemaTool.setDryRun(true); } diff --git beeline/src/test/org/apache/hive/beeline/TestHiveSchemaTool.java beeline/src/test/org/apache/hive/beeline/TestHiveSchemaTool.java index 8d386da..b3c41b8 100644 --- beeline/src/test/org/apache/hive/beeline/TestHiveSchemaTool.java +++ beeline/src/test/org/apache/hive/beeline/TestHiveSchemaTool.java @@ -47,7 +47,7 @@ public void setup() throws IOException { if (!file.exists()) { file.createNewFile(); } - builder = new HiveSchemaTool.CommandBuilder(hiveConf, "testUser", pasword, scriptFile); + builder = new HiveSchemaTool.CommandBuilder(hiveConf, null, null, "testUser", pasword, scriptFile); } @After @@ -70,4 +70,4 @@ public void shouldReturnActualPassword() throws IOException { String[] strings = builder.buildToRun(); assertTrue(Arrays.asList(strings).contains(pasword)); } -} \ No newline at end of file +} diff --git itests/src/test/resources/testconfiguration.properties itests/src/test/resources/testconfiguration.properties index 807b124..413a85e 100644 --- itests/src/test/resources/testconfiguration.properties +++ itests/src/test/resources/testconfiguration.properties @@ -571,6 +571,7 @@ minillaplocal.query.files=acid_globallimit.q,\ subquery_nested_subquery.q, \ subquery_shared_alias.q, \ subquery_null_agg.q,\ + sysdb.q,\ table_access_keys_stats.q,\ tez_bmj_schema_evolution.q,\ tez_dml.q,\ diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcInputFormat.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcInputFormat.java index bfa7a26..4b4bdcc 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcInputFormat.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcInputFormat.java @@ -68,6 +68,11 @@ } int numRecords = dbAccessor.getTotalNumberOfRecords(job); + + if (numRecords < numSplits) { + numSplits = numRecords; + } + int numRecordsPerSplit = numRecords / numSplits; int numSplitsWithExtraRecords = numRecords % numSplits; @@ -86,6 +91,7 @@ offset += numRecordsInThisSplit; } + dbAccessor = null; return splits; } catch (Exception e) { diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcRecordReader.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcRecordReader.java index 0a24bd9..8321a66 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcRecordReader.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcRecordReader.java @@ -15,6 +15,7 @@ package org.apache.hive.storage.jdbc; import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.NullWritable; import org.apache.hadoop.io.MapWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapred.JobConf; @@ -63,7 +64,8 @@ public boolean next(LongWritable key, MapWritable value) throws IOException { Map record = iterator.next(); if ((record != null) && (!record.isEmpty())) { for (Entry entry : record.entrySet()) { - value.put(new Text(entry.getKey()), new Text(entry.getValue())); + value.put(new Text(entry.getKey()), + entry.getValue() == null ? NullWritable.get() : new Text(entry.getValue())); } return true; } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcSerDe.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcSerDe.java index f35c33d..e785e9c 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcSerDe.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcSerDe.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.NullWritable; import org.apache.hadoop.io.MapWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.io.Writable; @@ -61,7 +62,6 @@ public void initialize(Configuration conf, Properties tbl) throws SerDeException try { LOGGER.debug("Initializing the SerDe"); - // Hive cdh-4.3 does not provide the properties object on all calls if (tbl.containsKey(JdbcStorageConfig.DATABASE_TYPE.getPropertyName())) { Configuration tableConfig = JdbcStorageConfigManager.convertPropertiesToConfiguration(tbl); @@ -126,7 +126,7 @@ public Object deserialize(Writable blob) throws SerDeException { for (int i = 0; i < numColumns; i++) { columnKey.set(columnNames.get(i)); Writable value = input.get(columnKey); - if (value == null) { + if (value == null || value instanceof NullWritable) { row.add(null); } else { diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcStorageHandler.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcStorageHandler.java index 946ee0c..7223235 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcStorageHandler.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/JdbcStorageHandler.java @@ -24,6 +24,8 @@ import org.apache.hadoop.mapred.InputFormat; import org.apache.hadoop.mapred.JobConf; import org.apache.hadoop.mapred.OutputFormat; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.apache.hive.storage.jdbc.conf.JdbcStorageConfigManager; @@ -32,6 +34,7 @@ public class JdbcStorageHandler implements HiveStorageHandler { + private static final Logger LOGGER = LoggerFactory.getLogger(JdbcStorageHandler.class); private Configuration conf; @@ -75,6 +78,7 @@ public HiveMetaHook getMetaHook() { @Override public void configureTableJobProperties(TableDesc tableDesc, Map jobProperties) { + LOGGER.debug("Adding properties to job conf"); Properties properties = tableDesc.getProperties(); JdbcStorageConfigManager.copyConfigurationToJob(properties, jobProperties); } @@ -82,6 +86,7 @@ public void configureTableJobProperties(TableDesc tableDesc, Map @Override public void configureInputJobProperties(TableDesc tableDesc, Map jobProperties) { + LOGGER.debug("Adding properties to input job conf"); Properties properties = tableDesc.getProperties(); JdbcStorageConfigManager.copyConfigurationToJob(properties, jobProperties); } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/DatabaseType.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/DatabaseType.java index a2bdbe4..681ced9 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/DatabaseType.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/DatabaseType.java @@ -17,5 +17,6 @@ public enum DatabaseType { MYSQL, H2, - DERBY + DERBY, + METASTORE } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/JdbcStorageConfigManager.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/JdbcStorageConfigManager.java index 5267cda..6a47bae 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/JdbcStorageConfigManager.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/conf/JdbcStorageConfigManager.java @@ -14,10 +14,19 @@ */ package org.apache.hive.storage.jdbc.conf; +import java.io.IOException; +import org.apache.hadoop.hive.shims.ShimLoader; +import org.apache.hadoop.hive.ql.metadata.Hive; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hive.storage.jdbc.conf.DatabaseType; + import org.apache.hadoop.conf.Configuration; import org.apache.hive.storage.jdbc.QueryConditionBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import java.util.EnumSet; import java.util.Map; import java.util.Map.Entry; @@ -28,11 +37,10 @@ */ public class JdbcStorageConfigManager { + private static final Logger LOGGER = LoggerFactory.getLogger(JdbcStorageConfigManager.class); public static final String CONFIG_PREFIX = "hive.sql"; private static final EnumSet DEFAULT_REQUIRED_PROPERTIES = EnumSet.of(JdbcStorageConfig.DATABASE_TYPE, - JdbcStorageConfig.JDBC_URL, - JdbcStorageConfig.JDBC_DRIVER_CLASS, JdbcStorageConfig.QUERY); @@ -42,6 +50,7 @@ private JdbcStorageConfigManager() { public static void copyConfigurationToJob(Properties props, Map jobProps) { checkRequiredPropertiesAreDefined(props); + resolveMetadata(props); for (Entry entry : props.entrySet()) { jobProps.put(String.valueOf(entry.getKey()), String.valueOf(entry.getValue())); } @@ -50,6 +59,7 @@ public static void copyConfigurationToJob(Properties props, Map public static Configuration convertPropertiesToConfiguration(Properties props) { checkRequiredPropertiesAreDefined(props); + resolveMetadata(props); Configuration conf = new Configuration(); for (Entry entry : props.entrySet()) { @@ -94,4 +104,52 @@ private static boolean isEmptyString(String value) { return ((value == null) || (value.trim().isEmpty())); } + private static void resolveMetadata(Properties props) { + try { + DatabaseType dbType = DatabaseType.valueOf( + props.getProperty(JdbcStorageConfig.DATABASE_TYPE.getPropertyName())); + + LOGGER.debug("Resolving db type: {}", dbType.toString()); + + if (dbType == DatabaseType.METASTORE) { + HiveConf hconf = Hive.get().getConf(); + props.setProperty(JdbcStorageConfig.JDBC_URL.getPropertyName(), + getMetastoreConnectionURL(hconf)); + props.setProperty(JdbcStorageConfig.JDBC_DRIVER_CLASS.getPropertyName(), + getMetastoreDriver(hconf)); + + String user = getMetastoreJdbcUser(hconf); + if (user != null) { + props.setProperty("hive.sql.dbcp.username", user); + } + + String pwd = getMetastoreJdbcPasswd(hconf); + if (pwd != null) { + props.setProperty("hive.sql.dbcp.password", pwd); + } + props.setProperty(JdbcStorageConfig.DATABASE_TYPE.getPropertyName(), DatabaseType.DERBY.toString()); + } + } catch (Exception e) {} + } + + private static String getMetastoreConnectionURL(HiveConf conf) { + return conf.getVar(HiveConf.ConfVars.METASTORECONNECTURLKEY); + } + + private static String getMetastoreDriver(HiveConf conf) { + return conf.getVar(HiveConf.ConfVars.METASTORE_CONNECTION_DRIVER); + } + + private static String getMetastoreJdbcUser(HiveConf conf) { + return conf.getVar(HiveConf.ConfVars.METASTORE_CONNECTION_USER_NAME); + } + + private static String getMetastoreJdbcPasswd(HiveConf conf) { + try { + return ShimLoader.getHadoopShims().getPassword(conf, + HiveConf.ConfVars.METASTOREPWD.varname); + } catch (IOException io) { + } + return null; + } } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/DatabaseAccessorFactory.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/DatabaseAccessorFactory.java index 7dc690f..6d62e57 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/DatabaseAccessorFactory.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/DatabaseAccessorFactory.java @@ -16,6 +16,9 @@ import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.shims.ShimLoader; +import org.apache.hadoop.hive.ql.metadata.Hive; +import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hive.storage.jdbc.conf.DatabaseType; import org.apache.hive.storage.jdbc.conf.JdbcStorageConfig; @@ -47,7 +50,7 @@ public static DatabaseAccessor getAccessor(DatabaseType dbType) { public static DatabaseAccessor getAccessor(Configuration conf) { DatabaseType dbType = DatabaseType.valueOf(conf.get(JdbcStorageConfig.DATABASE_TYPE.getPropertyName())); + return getAccessor(dbType); } - } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/GenericJdbcDatabaseAccessor.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/GenericJdbcDatabaseAccessor.java index b655aec..8fa6d99 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/GenericJdbcDatabaseAccessor.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/GenericJdbcDatabaseAccessor.java @@ -97,7 +97,7 @@ public int getTotalNumberOfRecords(Configuration conf) throws HiveJdbcDatabaseAc initializeDatabaseConnection(conf); String sql = JdbcStorageConfigManager.getQueryToExecute(conf); String countQuery = "SELECT COUNT(*) FROM (" + sql + ") tmptable"; - LOGGER.debug("Query to execute is [{}]", countQuery); + LOGGER.info("Query to execute is [{}]", countQuery); conn = dbcpDataSource.getConnection(); ps = conn.prepareStatement(countQuery); @@ -135,7 +135,7 @@ public int getTotalNumberOfRecords(Configuration conf) throws HiveJdbcDatabaseAc initializeDatabaseConnection(conf); String sql = JdbcStorageConfigManager.getQueryToExecute(conf); String limitQuery = addLimitAndOffsetToQuery(sql, limit, offset); - LOGGER.debug("Query to execute is [{}]", limitQuery); + LOGGER.info("Query to execute is [{}]", limitQuery); conn = dbcpDataSource.getConnection(); ps = conn.prepareStatement(limitQuery, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY); diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/JdbcRecordIterator.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/JdbcRecordIterator.java index 4262502..8938766 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/JdbcRecordIterator.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/JdbcRecordIterator.java @@ -66,9 +66,6 @@ public boolean hasNext() { for (int i = 0; i < numColumns; i++) { String key = metadata.getColumnName(i + 1); String value = rs.getString(i + 1); - if (value == null) { - value = NullWritable.get().toString(); - } record.put(key, value); } diff --git jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/MySqlDatabaseAccessor.java jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/MySqlDatabaseAccessor.java index 7d821d8..86fde7c 100644 --- jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/MySqlDatabaseAccessor.java +++ jdbc-handler/src/main/java/org/apache/hive/storage/jdbc/dao/MySqlDatabaseAccessor.java @@ -26,7 +26,7 @@ protected String addLimitAndOffsetToQuery(String sql, int limit, int offset) { return addLimitToQuery(sql, limit); } else { - return sql + " LIMIT " + limit + "," + offset; + return sql + " LIMIT " + offset + "," + limit; } } diff --git llap-server/src/java/org/apache/hadoop/hive/llap/cli/LlapServiceDriver.java llap-server/src/java/org/apache/hadoop/hive/llap/cli/LlapServiceDriver.java index e8517ab..bc585d0 100644 --- llap-server/src/java/org/apache/hadoop/hive/llap/cli/LlapServiceDriver.java +++ llap-server/src/java/org/apache/hadoop/hive/llap/cli/LlapServiceDriver.java @@ -88,7 +88,9 @@ protected static final Logger LOG = LoggerFactory.getLogger(LlapServiceDriver.class.getName()); private static final String[] DEFAULT_AUX_CLASSES = new String[] { - "org.apache.hive.hcatalog.data.JsonSerDe","org.apache.hadoop.hive.druid.DruidStorageHandler" }; + "org.apache.hive.hcatalog.data.JsonSerDe","org.apache.hadoop.hive.druid.DruidStorageHandler", + "org.apache.hive.storage.jdbc.JdbcStorageHandler" + }; private static final String HBASE_SERDE_CLASS = "org.apache.hadoop.hive.hbase.HBaseSerDe"; private static final String[] NEEDED_CONFIGS = LlapDaemonConfiguration.DAEMON_CONFIGS; private static final String[] OPTIONAL_CONFIGS = LlapDaemonConfiguration.SSL_DAEMON_CONFIGS; diff --git metastore/scripts/upgrade/hive/hive-schema-2.2.0-hive.sql metastore/scripts/upgrade/hive/hive-schema-2.2.0-hive.sql new file mode 100644 index 0000000..5d688be --- /dev/null +++ metastore/scripts/upgrade/hive/hive-schema-2.2.0-hive.sql @@ -0,0 +1,1209 @@ +-- HIVE system db + +CREATE DATABASE SYS; + +USE SYS; + +CREATE TABLE IF NOT EXISTS `BUCKETING_COLS` ( + `SD_ID` bigint, + `BUCKET_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_BUCKETING_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"BUCKET_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"BUCKETING_COLS\"" +); + +CREATE TABLE IF NOT EXISTS `CDS` ( + `CD_ID` bigint, + CONSTRAINT `SYS_PK_CDS` PRIMARY KEY (`CD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\" +FROM + \"CDS\"" +); + +CREATE TABLE IF NOT EXISTS `COLUMNS_V2` ( + `CD_ID` bigint, + `COMMENT` string, + `COLUMN_NAME` string, + `TYPE_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_COLUMN_V2` PRIMARY KEY (`CD_ID`,`COLUMN_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\", + \"COMMENT\", + \"COLUMN_NAME\", + \"TYPE_NAME\", + \"INTEGER_IDX\" +FROM + \"COLUMNS_V2\"" +); + +CREATE TABLE IF NOT EXISTS `DATABASE_PARAMS` ( + `DB_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_DATABASE_PARAMS` PRIMARY KEY (`DB_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"DATABASE_PARAMS\"" +); + +CREATE TABLE IF NOT EXISTS `DBS` ( + `DB_ID` bigint, + `DB_LOCATION_URI` string, + `NAME` string, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_DBS` PRIMARY KEY (`DB_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"DB_LOCATION_URI\", + \"NAME\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + DBS" +); + +-- ANALYZE TABLE DBS COMPUTE STATISTICS; +-- ANALYZE TABLE DBS COMPUTE STATISTICS FOR COLUMNS; + +CREATE TABLE IF NOT EXISTS `DB_PRIVS` ( + `DB_GRANT_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `DB_PRIV` string, + CONSTRAINT `SYS_PK_DB_PRIVS` PRIMARY KEY (`DB_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_GRANT_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"DB_PRIV\" +FROM + \"DB_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `GLOBAL_PRIVS` ( + `USER_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` string, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `USER_PRIV` string, + CONSTRAINT `SYS_PK_GLOBAL_PRIVS` PRIMARY KEY (`USER_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"USER_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"USER_PRIV\" +FROM + \"GLOBAL_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `IDXS` ( + `INDEX_ID` bigint, + `CREATE_TIME` int, + `DEFERRED_REBUILD` boolean, + `INDEX_HANDLER_CLASS` string, + `INDEX_NAME` string, + `INDEX_TBL_ID` bigint, + `LAST_ACCESS_TIME` int, + `ORIG_TBL_ID` bigint, + `SD_ID` bigint, + CONSTRAINT `SYS_PK_IDXS` PRIMARY KEY (`INDEX_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"CREATE_TIME\", + \"DEFERRED_REBUILD\", + \"INDEX_HANDLER_CLASS\", + \"INDEX_NAME\", + \"INDEX_TBL_ID\", + \"LAST_ACCESS_TIME\", + \"ORIG_TBL_ID\", + \"SD_ID\" +FROM + \"IDXS\"" +); + +CREATE TABLE IF NOT EXISTS `INDEX_PARAMS` ( + `INDEX_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_INDEX_PARAMS` PRIMARY KEY (`INDEX_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"INDEX_PARAMS\"" +); + +-- CREATE TABLE IF NOT EXISTS `NUCLEUS_TABLES` ( +-- `CLASS_NAME` string, +-- `TABLE_NAME` string, +-- `TYPE` string, +-- `OWNER` string, +-- `VERSION` string, +-- `INTERFACE_NAME` string, +-- CONSTRAINT `SYS_PK_NUCLEUS_TABLES` PRIMARY KEY (`CLASS_NAME`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM NUCLEUS_TABLES" +-- ); + +CREATE TABLE IF NOT EXISTS `PARTITIONS` ( + `PART_ID` bigint, + `CREATE_TIME` int, + `LAST_ACCESS_TIME` int, + `PART_NAME` string, + `SD_ID` bigint, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_PARTITIONS` PRIMARY KEY (`PART_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"CREATE_TIME\", + \"LAST_ACCESS_TIME\", + \"PART_NAME\", + \"SD_ID\", + \"TBL_ID\" +FROM + \"PARTITIONS\"" +); + +-- CREATE TABLE IF NOT EXISTS `PARTITION_EVENTS` ( +-- `PART_NAME_ID` bigint, +-- `DB_NAME` string, +-- `EVENT_TIME` bigint, +-- `EVENT_TYPE` int, +-- `PARTITION_NAME` string, +-- `TBL_NAME` string, +-- CONSTRAINT `SYS_PK_PATITION_EVENTS` PRIMARY KEY (`PART_NAME_ID`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM PARTITION_EVENTS" +-- ); + +CREATE TABLE IF NOT EXISTS `PARTITION_KEYS` ( + `TBL_ID` bigint, + `PKEY_COMMENT` string, + `PKEY_NAME` string, + `PKEY_TYPE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEYS` PRIMARY KEY (`TBL_ID`,`PKEY_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PKEY_COMMENT\", + \"PKEY_NAME\", + \"PKEY_TYPE\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEYS\"" +); + +CREATE TABLE IF NOT EXISTS `PARTITION_KEY_VALS` ( + `PART_ID` bigint, + `PART_KEY_VAL` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEY_VALS` PRIMARY KEY (`PART_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PART_KEY_VAL\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEY_VALS\"" +); + +CREATE TABLE IF NOT EXISTS `PARTITION_PARAMS` ( + `PART_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_PARTITION_PARAMS` PRIMARY KEY (`PART_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"PARTITION_PARAMS\"" +); + +CREATE TABLE IF NOT EXISTS `PART_COL_PRIVS` ( + `PART_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_COL_PRIV` string, + CONSTRAINT `SYS_PK_PART_COL_PRIVS` PRIMARY KEY (`PART_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_COL_PRIV\" +FROM + \"PART_COL_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `PART_PRIVS` ( + `PART_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_PRIV` string, + CONSTRAINT `SYS_PK_PART_PRIVS` PRIMARY KEY (`PART_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_PRIV\" +FROM + \"PART_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `ROLES` ( + `ROLE_ID` bigint, + `CREATE_TIME` int, + `OWNER_NAME` string, + `ROLE_NAME` string, + CONSTRAINT `SYS_PK_ROLES` PRIMARY KEY (`ROLE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_ID\", + \"CREATE_TIME\", + \"OWNER_NAME\", + \"ROLE_NAME\" +FROM + \"ROLES\"" +); + +CREATE TABLE IF NOT EXISTS `ROLE_MAP` ( + `ROLE_GRANT_ID` bigint, + `ADD_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `ROLE_ID` bigint, + CONSTRAINT `SYS_PK_ROLE_MAP` PRIMARY KEY (`ROLE_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_GRANT_ID\", + \"ADD_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"ROLE_ID\" +FROM + \"ROLE_MAP\"" +); + +CREATE TABLE IF NOT EXISTS `SDS` ( + `SD_ID` bigint, + `CD_ID` bigint, + `INPUT_FORMAT` string, + `IS_COMPRESSED` boolean, + `IS_STOREDASSUBDIRECTORIES` boolean, + `LOCATION` string, + `NUM_BUCKETS` int, + `OUTPUT_FORMAT` string, + `SERDE_ID` bigint, + CONSTRAINT `SYS_PK_SDS` PRIMARY KEY (`SD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"CD_ID\", + \"INPUT_FORMAT\", + \"IS_COMPRESSED\", + \"IS_STOREDASSUBDIRECTORIES\", + \"LOCATION\", + \"NUM_BUCKETS\", + \"OUTPUT_FORMAT\", + \"SERDE_ID\" +FROM + \"SDS\"" +); + +CREATE TABLE IF NOT EXISTS `SD_PARAMS` ( + `SD_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SD_PARAMS` PRIMARY KEY (`SD_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SD_PARAMS\"" +); + +CREATE TABLE IF NOT EXISTS `SEQUENCE_TABLE` ( + `SEQUENCE_NAME` string, + `NEXT_VAL` bigint, + CONSTRAINT `SYS_PK_SEQUENCE_TABLE` PRIMARY KEY (`SEQUENCE_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SEQUENCE_NAME\", + \"NEXT_VAL\" +FROM + \"SEQUENCE_TABLE\"" +); + +CREATE TABLE IF NOT EXISTS `SERDES` ( + `SERDE_ID` bigint, + `NAME` string, + `SLIB` string, + CONSTRAINT `SYS_PK_SERDES` PRIMARY KEY (`SERDE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"NAME\", + \"SLIB\" +FROM + \"SERDES\"" +); + +CREATE TABLE IF NOT EXISTS `SERDE_PARAMS` ( + `SERDE_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SERDE_PARAMS` PRIMARY KEY (`SERDE_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SERDE_PARAMS\"" +); + +CREATE TABLE IF NOT EXISTS `SKEWED_COL_NAMES` ( + `SD_ID` bigint, + `SKEWED_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_COL_NAMES` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"SKEWED_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"SKEWED_COL_NAMES\"" +); + +CREATE TABLE IF NOT EXISTS `SKEWED_COL_VALUE_LOC_MAP` ( + `SD_ID` bigint, + `STRING_LIST_ID_KID` bigint, + `LOCATION` string, + CONSTRAINT `SYS_PK_COL_VALUE_LOC_MAP` PRIMARY KEY (`SD_ID`,`STRING_LIST_ID_KID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"STRING_LIST_ID_KID\", + \"LOCATION\" +FROM + \"SKEWED_COL_VALUE_LOC_MAP\"" +); + +CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST` ( + `STRING_LIST_ID` bigint, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST` PRIMARY KEY (`STRING_LIST_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\" +FROM + \"SKEWED_STRING_LIST\"" +); + +CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST_VALUES` ( + `STRING_LIST_ID` bigint, + `STRING_LIST_VALUE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST_VALUES` PRIMARY KEY (`STRING_LIST_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\", + \"STRING_LIST_VALUE\", + \"INTEGER_IDX\" +FROM + \"SKEWED_STRING_LIST_VALUES\"" +); + +CREATE TABLE IF NOT EXISTS `SKEWED_VALUES` ( + `SD_ID_OID` bigint, + `STRING_LIST_ID_EID` bigint, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_VALUES` PRIMARY KEY (`SD_ID_OID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID_OID\", + \"STRING_LIST_ID_EID\", + \"INTEGER_IDX\" +FROM + \"SKEWED_VALUES\"" +); + +CREATE TABLE IF NOT EXISTS `SORT_COLS` ( + `SD_ID` bigint, + `COLUMN_NAME` string, + `ORDER` int, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SORT_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"COLUMN_NAME\", + \"ORDER\", + \"INTEGER_IDX\" +FROM + \"SORT_COLS\"" +); + +CREATE TABLE IF NOT EXISTS `TABLE_PARAMS` ( + `TBL_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_TABLE_PARAMS` PRIMARY KEY (`TBL_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"TABLE_PARAMS\"" +); + +CREATE TABLE IF NOT EXISTS `TBLS` ( + `TBL_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `LAST_ACCESS_TIME` int, + `OWNER` string, + `RETENTION` int, + `SD_ID` bigint, + `TBL_NAME` string, + `TBL_TYPE` string, + `VIEW_EXPANDED_TEXT` string, + `VIEW_ORIGINAL_TEXT` string, + `IS_REWRITE_ENABLED` boolean, + CONSTRAINT `SYS_PK_TBLS` PRIMARY KEY (`TBL_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"LAST_ACCESS_TIME\", + \"OWNER\", + \"RETENTION\", + \"SD_ID\", + \"TBL_NAME\", + \"TBL_TYPE\", + \"VIEW_EXPANDED_TEXT\", + \"VIEW_ORIGINAL_TEXT\", + \"IS_REWRITE_ENABLED\" +FROM TBLS" +); + +CREATE TABLE IF NOT EXISTS `TBL_COL_PRIVS` ( + `TBL_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_COL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_COL_PRIVS` PRIMARY KEY (`TBL_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_COL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_COL_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `TBL_PRIVS` ( + `TBL_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_PRIVS` PRIMARY KEY (`TBL_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_PRIVS\"" +); + +CREATE TABLE IF NOT EXISTS `TAB_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `TBL_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_TAB_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"TBL_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"TAB_COL_STATS\"" +); + +CREATE TABLE IF NOT EXISTS `PART_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `PARTITION_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `PART_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_PART_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"PARTITION_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"PART_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"PART_COL_STATS\"" +); + +-- CREATE TABLE IF NOT EXISTS `TYPES` ( +-- `TYPES_ID` bigint, +-- `TYPE_NAME` string, +-- `TYPE1` string, +-- `TYPE2` string, +-- CONSTRAINT `SYS_PK_TYPES` PRIMARY KEY (`TYPES_ID`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM TYPES" +-- ); + +-- CREATE TABLE IF NOT EXISTS `TYPE_FIELDS` ( +-- `TYPE_NAME` bigint, +-- `COMMENT` string, +-- `FIELD_NAME` string, +-- `FIELD_TYPE` string, +-- `INTEGER_IDX` int, +-- CONSTRAINT `SYS_PK_TYPE_FIELDS` PRIMARY KEY (`TYPE_NAME`,`FIELD_NAME`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM TYPE_FIELDS" +-- ); + +-- CREATE TABLE IF NOT EXISTS `MASTER_KEYS` +-- ( +-- `KEY_ID` INTEGER, +-- `MASTER_KEY` binary, +-- CONSTRAINT `SYS_PK_MASTER_KEYS` PRIMARY KEY (`KEY_ID`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM MASTER_KEYS" +-- ); + +-- CREATE TABLE IF NOT EXISTS `DELEGATION_TOKENS` +-- ( +-- `TOKEN_IDENT` string, +-- `TOKEN` string, +-- CONSTRAINT `SYS_PK_DELEGATION_TOKENS` PRIMARY KEY (`TOKEN_IDENT`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM DELEGATION_TOKENS" +-- ); + +CREATE TABLE IF NOT EXISTS `VERSION` ( + `VER_ID` BIGINT, + `SCHEMA_VERSION` string, + `VERSION_COMMENT` string, + CONSTRAINT `SYS_PK_VERSION` PRIMARY KEY (`VER_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"VER_ID\", + \"SCHEMA_VERSION\", + \"VERSION_COMMENT\" +FROM + \"VERSION\"" +); + +CREATE TABLE IF NOT EXISTS `FUNCS` ( + `FUNC_ID` bigint, + `CLASS_NAME` string, + `CREATE_TIME` int, + `DB_ID` bigint, + `FUNC_NAME` string, + `FUNC_TYPE` int, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_FUNCS` PRIMARY KEY (`FUNC_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"FUNC_ID\", + \"CLASS_NAME\", + \"CREATE_TIME\", + \"DB_ID\", + \"FUNC_NAME\", + \"FUNC_TYPE\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + \"FUNCS\"" +); + +-- CREATE TABLE IF NOT EXISTS `FUNC_RU` ( +-- `FUNC_ID` bigint, +-- `RESOURCE_TYPE` int, +-- `RESOURCE_URI` string, +-- `INTEGER_IDX` int, +-- CONSTRAINT `SYS_PK_FUNCS_RU` PRIMARY KEY (`FUNC_ID`, `INTEGER_IDX`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM FUNCS_RU" +-- ); + +-- CREATE TABLE IF NOT EXISTS `NOTIFICATION_LOG` +-- ( +-- `NL_ID` bigint, +-- `EVENT_ID` bigint, +-- `EVENT_TIME` int, +-- `EVENT_TYPE` string, +-- `DB_NAME` string, +-- `TBL_NAME` string, +-- `MESSAGE` string, +-- CONSTRAINT `SYS_PK_NOTIFICATION_LOG` PRIMARY KEY (`NL_ID`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM NOTIFICATION_LOG" +-- ); + +-- CREATE TABLE IF NOT EXISTS `NOTIFICATION_SEQUENCE` +-- ( +-- `NNI_ID` bigint, +-- `NEXT_EVENT_ID` bigint, +-- CONSTRAINT `SYS_PK_NOTIFICATION_SEQUENCE` PRIMARY KEY (`NNI_ID`) DISABLE NOVALIDATE +-- ) +-- STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +-- TBLPROPERTIES ( +-- "hive.sql.database.type" = "METASTORE", +-- "hive.sql.query" = "SELECT * FROM NOTIFICATION_SEQUENCE" +-- ); + +CREATE TABLE IF NOT EXISTS `KEY_CONSTRAINTS` +( + `CHILD_CD_ID` bigint, + `CHILD_INTEGER_IDX` int, + `CHILD_TBL_ID` bigint, + `PARENT_CD_ID` bigint, + `PARENT_INTEGER_IDX` int, + `PARENT_TBL_ID` bigint, + `POSITION` bigint, + `CONSTRAINT_NAME` string, + `CONSTRAINT_TYPE` string, + `UPDATE_RULE` string, + `DELETE_RULE` string, + `ENABLE_VALIDATE_RELY` int, + CONSTRAINT `SYS_PK_KEY_CONSTRAINTS` PRIMARY KEY (`CONSTRAINT_NAME`, `POSITION`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CHILD_CD_ID\", + \"CHILD_INTEGER_IDX\", + \"CHILD_TBL_ID\", + \"PARENT_CD_ID\", + \"PARENT_INTEGER_IDX\", + \"PARENT_TBL_ID\", + \"POSITION\", + \"CONSTRAINT_NAME\", + \"CONSTRAINT_TYPE\", + \"UPDATE_RULE\", + \"DELETE_RULE\", + \"ENABLE_VALIDATE_RELY\" +FROM + \"KEY_CONSTRAINTS\"" +); + +CREATE DATABASE INFORMATION_SCHEMA; + +USE INFORMATION_SCHEMA; + +CREATE VIEW IF NOT EXISTS `SCHEMATA` +( + `CATALOG_NAME`, + `SCHEMA_NAME`, + `SCHEMA_OWNER`, + `DEFAULT_CHARACTER_SET_CATALOG`, + `DEFAULT_CHARACTER_SET_SCHEMA`, + `DEFAULT_CHARACTER_SET_NAME`, + `SQL_PATH` +) AS +SELECT + 'default', + `NAME`, + `OWNER_NAME`, + cast(null as string), + cast(null as string), + cast(null as string), + `DB_LOCATION_URI` +FROM + sys.DBS; + +CREATE VIEW IF NOT EXISTS `TABLES` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `TABLE_TYPE` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + IF(length(T.VIEW_ORIGINAL_TEXT) > 0, 'VIEW', 'BASE_TABLE') +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID`; + +CREATE VIEW IF NOT EXISTS `TABLE_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D +WHERE + P.TBL_ID = T.TBL_ID + AND T.DB_ID = D.DB_ID; + +CREATE VIEW IF NOT EXISTS `COLUMNS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `ORDINAL_POSITION`, + `COLUMN_DEFAULT`, + `IS_NULLABLE`, + `DATA_TYPE`, + `CHARACTER_MAXIMUM_LENGTH`, + `CHARACTER_OCTET_LENGTH`, + `NUMERIC_PRECISION`, + `NUMERIC_SCALE`, + `DATETIME_PRECISION`, + `CHARACTER_SET_NAME`, + `COLLATION_NAME` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + C.COLUMN_NAME, + C.INTEGER_IDX, + null, + true, + C.TYPE_NAME, + null, + null, + null, + null, + null, + null, + null +FROM + sys.`COLUMNS_V2` C, + sys.`SDS` S, + sys.`TBLS` T, + sys.`DBS` D +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND C.`CD_ID` = S.`CD_ID`; + +CREATE VIEW IF NOT EXISTS `COLUMN_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + C.`COLUMN_NAME`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D, + sys.`COLUMNS_V2` C, + sys.`SDS` S +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND P.`TBL_ID` = T.`TBL_ID` + AND C.`CD_ID` = S.`CD_ID`; + +CREATE VIEW IF NOT EXISTS `VIEWS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `VIEW_DEFINITION`, + `CHECK_OPTION`, + `IS_UPDATABLE`, + `IS_INSERTABLE_INTO`, + `IS_TRIGGER_UPDATABLE`, + `IS_TRIGGER_DELETABLE`, + `IS_TRIGGER_INSERTABLE_INTO` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + T.VIEW_ORIGINAL_TEXT, + CAST(NULL as string), + false, + false, + false, + false, + false +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID` AND + length(T.VIEW_ORIGINAL_TEXT) > 0; diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/UnparseTranslator.java ql/src/java/org/apache/hadoop/hive/ql/parse/UnparseTranslator.java index 4ca8329..71ede55 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/UnparseTranslator.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/UnparseTranslator.java @@ -116,7 +116,7 @@ void addTranslation(ASTNode node, String replacementText) { if (existingEntry.getValue().tokenStopIndex <= tokenStopIndex && existingEntry.getKey() >= tokenStartIndex) { // Collect newer entry is if a super-set of existing entry, - assert (replacementText.contains(existingEntry.getValue().replacementText)); + // assert (replacementText.contains(existingEntry.getValue().replacementText)); subsetEntries.add(existingEntry.getKey()); // check if the existing entry contains the new } else if (existingEntry.getValue().tokenStopIndex >= tokenStopIndex && diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/PartitionDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/PartitionDesc.java index 73981e8..589e57b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/PartitionDesc.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/PartitionDesc.java @@ -120,8 +120,12 @@ public PartitionDesc(final Partition part,final TableDesc tblDesc, private void PartitionDescConstructorHelper(final Partition part,final TableDesc tblDesc, boolean setInputFileFormat) throws HiveException { + + PlanUtils.configureInputJobPropertiesForStorageHandler(tblDesc); + this.tableDesc = tblDesc; this.partSpec = part.getSpec(); + if (setInputFileFormat) { setInputFileFormatClass(part.getInputFormatClass()); } else { @@ -374,7 +378,6 @@ public int hashCode() { * URI to the partition file */ public void deriveBaseFileName(Path path) { - PlanUtils.configureInputJobPropertiesForStorageHandler(tableDesc); if (path == null) { return; diff --git ql/src/test/queries/clientpositive/jdbc_handler.q ql/src/test/queries/clientpositive/jdbc_handler.q index 2038617..143f450 100644 --- ql/src/test/queries/clientpositive/jdbc_handler.q +++ ql/src/test/queries/clientpositive/jdbc_handler.q @@ -8,31 +8,24 @@ owner STRING ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", +"hive.sql.database.type" = "METASTORE", "hive.sql.query" = "SELECT TBL_ID, DB_ID, TBL_NAME, TBL_TYPE, OWNER FROM TBLS", -"hive.sql.column.mapping" = "id=TBL_ID, db_id=DB_ID, name=TBL_NAME, type=TBL_TYPE, owner=OWNER", -"hive.sql.dbcp.maxActive" = "1" +"hive.sql.column.mapping" = "id=TBL_ID, db_id=DB_ID, name=TBL_NAME, type=TBL_TYPE, owner=OWNER" ); CREATE EXTERNAL TABLE dbs ( -id int, -name STRING +DB_ID int, +NAME STRING ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", -"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS", -"hive.sql.column.mapping" = "id=DB_ID, name=NAME", -"hive.sql.dbcp.maxActive" = "1" +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS" ); -select tables.name as tn, dbs.name as dn, tables.type as t -from tables join dbs on (tables.db_id = dbs.id) order by tn, dn, t; +select tables.name as tn, dbs.NAME as dn, tables.type as t +from tables join dbs on (tables.db_id = dbs.DB_ID) order by tn, dn, t; explain select diff --git ql/src/test/queries/clientpositive/sysdb.q ql/src/test/queries/clientpositive/sysdb.q new file mode 100644 index 0000000..83bdfbf --- /dev/null +++ ql/src/test/queries/clientpositive/sysdb.q @@ -0,0 +1,101 @@ +set hive.strict.checks.cartesian.product=false; + +set hive.compute.query.using.stats=false; + +create table src_buck (key int, value string) clustered by(value) into 2 buckets; + +create table src_skew (key int) skewed by (key) on (1,2,3); + +show grant user hive_test_user; + +source ../../metastore/scripts/upgrade/hive/hive-schema-2.2.0-hive.sql; + +use sys; + +select bucket_col_name, integer_idx from bucketing_cols order by bucket_col_name, integer_idx limit 5; + +select count(*) from cds; + +select column_name, type_name, integer_idx from columns_v2 order by column_name, integer_idx limit 5; + +select param_key, param_value from database_params order by param_key, param_value limit 5; + +select db_location_uri, name, owner_name, owner_type from dbs order by name; + +select grantor, principal_name from db_privs order by grantor, principal_name limit 5; + +select grantor, principal_name from global_privs order by grantor, principal_name limit 5; + +select index_name, index_handler_class from idxs order by index_name limit 5; + +select param_key, param_value from index_params order by param_key, param_value limit 5; + +select part_name from partitions order by part_name limit 5; + +select pkey_name, pkey_type from partition_keys order by pkey_name limit 5; + +select part_key_val, integer_idx from partition_key_vals order by part_key_val, integer_idx limit 5; + +select param_key, param_value from partition_params order by param_key, param_value limit 5; + +select grantor, principal_name from part_col_privs order by grantor, principal_name limit 5; + +select grantor, principal_name from part_privs order by grantor, principal_name limit 5; + +select role_name from roles order by role_name limit 5; + +select principal_name, grantor from role_map order by principal_name, grantor limit 5; + +select count(*) from sds; + +select param_key, param_value from sd_params order by param_key, param_value limit 5; + +select sequence_name from sequence_table order by sequence_name limit 5; + +select name, slib from serdes order by name, slib limit 5; + +select param_key, param_value from serde_params order by param_key, param_value limit 5; + +select skewed_col_name from skewed_col_names order by skewed_col_name limit 5; + +select count(*) from skewed_col_value_loc_map; + +select count(*) from skewed_string_list; + +select count(*) from skewed_string_list_values; + +select count(*) from skewed_values; + +select column_name, `order` from sort_cols order by column_name limit 5; + +select param_key, param_value from table_params order by param_key, param_value limit 5; + +select tbl_name from tbls order by tbl_name limit 5; + +select column_name, grantor, principal_name from tbl_col_privs order by column_name, principal_name limit 5; + +select grantor, principal_name from tbl_privs order by grantor, principal_name limit 5; + +select table_name, column_name, num_nulls, num_distincts from tab_col_stats order by table_name, column_name limit 10; + +select table_name, partition_name, column_name, num_nulls, num_distincts from part_col_stats order by table_name, partition_name, column_name limit 10; + +select schema_version from version order by schema_version limit 5; + +select func_name, func_type from funcs order by func_name, func_type limit 5; + +select constraint_name from key_constraints order by constraint_name limit 5; + +use INFORMATION_SCHEMA; + +select count(*) from SCHEMATA; + +select * from TABLES order by TABLE_SCHEMA, TABLE_NAME; + +select * from TABLE_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME limit 10; + +select * from COLUMNS order by TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION limit 10; + +select * from COLUMN_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME limit 10; + +select TABLE_SCHEMA, TABLE_NAME from views order by TABLE_SCHEMA, TABLE_NAME; diff --git ql/src/test/results/clientpositive/llap/jdbc_handler.q.out ql/src/test/results/clientpositive/llap/jdbc_handler.q.out index 74bd60b..0da940d 100644 --- ql/src/test/results/clientpositive/llap/jdbc_handler.q.out +++ ql/src/test/results/clientpositive/llap/jdbc_handler.q.out @@ -8,12 +8,9 @@ type STRING, ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", +"hive.sql.database.type" = "METASTORE", "hive.sql.query" = "SELECT TBL_ID, DB_ID, TBL_NAME, TBL_TYPE, OWNER FROM TBLS", #### A masked pattern was here #### -"hive.sql.dbcp.maxActive" = "1" ) PREHOOK: type: CREATETABLE PREHOOK: Output: database:default @@ -28,58 +25,47 @@ type STRING, ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", +"hive.sql.database.type" = "METASTORE", "hive.sql.query" = "SELECT TBL_ID, DB_ID, TBL_NAME, TBL_TYPE, OWNER FROM TBLS", #### A masked pattern was here #### -"hive.sql.dbcp.maxActive" = "1" ) POSTHOOK: type: CREATETABLE POSTHOOK: Output: database:default POSTHOOK: Output: default@tables PREHOOK: query: CREATE EXTERNAL TABLE dbs ( -id int, -name STRING +DB_ID int, +NAME STRING ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", -"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS", -"hive.sql.column.mapping" = "id=DB_ID, name=NAME", -"hive.sql.dbcp.maxActive" = "1" +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS" ) PREHOOK: type: CREATETABLE PREHOOK: Output: database:default PREHOOK: Output: default@dbs POSTHOOK: query: CREATE EXTERNAL TABLE dbs ( -id int, -name STRING +DB_ID int, +NAME STRING ) STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' TBLPROPERTIES ( -"hive.sql.database.type" = "DERBY", -"hive.sql.jdbc.url" = "jdbc:derby:;databaseName=${test.tmp.dir}/junit_metastore_db;create=true", -"hive.sql.jdbc.driver" = "org.apache.derby.jdbc.EmbeddedDriver", -"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS", -"hive.sql.column.mapping" = "id=DB_ID, name=NAME", -"hive.sql.dbcp.maxActive" = "1" +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = "SELECT DB_ID, NAME FROM DBS" ) POSTHOOK: type: CREATETABLE POSTHOOK: Output: database:default POSTHOOK: Output: default@dbs -PREHOOK: query: select tables.name as tn, dbs.name as dn, tables.type as t -from tables join dbs on (tables.db_id = dbs.id) order by tn, dn, t +PREHOOK: query: select tables.name as tn, dbs.NAME as dn, tables.type as t +from tables join dbs on (tables.db_id = dbs.DB_ID) order by tn, dn, t PREHOOK: type: QUERY PREHOOK: Input: default@dbs PREHOOK: Input: default@tables #### A masked pattern was here #### -POSTHOOK: query: select tables.name as tn, dbs.name as dn, tables.type as t -from tables join dbs on (tables.db_id = dbs.id) order by tn, dn, t +POSTHOOK: query: select tables.name as tn, dbs.NAME as dn, tables.type as t +from tables join dbs on (tables.db_id = dbs.DB_ID) order by tn, dn, t POSTHOOK: type: QUERY POSTHOOK: Input: default@dbs POSTHOOK: Input: default@tables diff --git ql/src/test/results/clientpositive/llap/sysdb.q.out ql/src/test/results/clientpositive/llap/sysdb.q.out new file mode 100644 index 0000000..77b051d --- /dev/null +++ ql/src/test/results/clientpositive/llap/sysdb.q.out @@ -0,0 +1,3098 @@ +PREHOOK: query: create table src_buck (key int, value string) clustered by(value) into 2 buckets +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@src_buck +POSTHOOK: query: create table src_buck (key int, value string) clustered by(value) into 2 buckets +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@src_buck +PREHOOK: query: create table src_skew (key int) skewed by (key) on (1,2,3) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@src_skew +POSTHOOK: query: create table src_skew (key int) skewed by (key) on (1,2,3) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@src_skew +PREHOOK: query: show grant user hive_test_user +PREHOOK: type: SHOW_GRANT +POSTHOOK: query: show grant user hive_test_user +POSTHOOK: type: SHOW_GRANT +default alltypesorc hive_test_user USER DELETE true -1 hive_test_user +default alltypesorc hive_test_user USER INSERT true -1 hive_test_user +default alltypesorc hive_test_user USER SELECT true -1 hive_test_user +default alltypesorc hive_test_user USER UPDATE true -1 hive_test_user +default cbo_t1 hive_test_user USER DELETE true -1 hive_test_user +default cbo_t1 hive_test_user USER INSERT true -1 hive_test_user +default cbo_t1 hive_test_user USER SELECT true -1 hive_test_user +default cbo_t1 hive_test_user USER UPDATE true -1 hive_test_user +default cbo_t2 hive_test_user USER DELETE true -1 hive_test_user +default cbo_t2 hive_test_user USER INSERT true -1 hive_test_user +default cbo_t2 hive_test_user USER SELECT true -1 hive_test_user +default cbo_t2 hive_test_user USER UPDATE true -1 hive_test_user +default cbo_t3 hive_test_user USER DELETE true -1 hive_test_user +default cbo_t3 hive_test_user USER INSERT true -1 hive_test_user +default cbo_t3 hive_test_user USER SELECT true -1 hive_test_user +default cbo_t3 hive_test_user USER UPDATE true -1 hive_test_user +default lineitem hive_test_user USER DELETE true -1 hive_test_user +default lineitem hive_test_user USER INSERT true -1 hive_test_user +default lineitem hive_test_user USER SELECT true -1 hive_test_user +default lineitem hive_test_user USER UPDATE true -1 hive_test_user +default part hive_test_user USER DELETE true -1 hive_test_user +default part hive_test_user USER INSERT true -1 hive_test_user +default part hive_test_user USER SELECT true -1 hive_test_user +default part hive_test_user USER UPDATE true -1 hive_test_user +default src hive_test_user USER DELETE true -1 hive_test_user +default src hive_test_user USER INSERT true -1 hive_test_user +default src hive_test_user USER SELECT true -1 hive_test_user +default src hive_test_user USER UPDATE true -1 hive_test_user +default src1 hive_test_user USER DELETE true -1 hive_test_user +default src1 hive_test_user USER INSERT true -1 hive_test_user +default src1 hive_test_user USER SELECT true -1 hive_test_user +default src1 hive_test_user USER UPDATE true -1 hive_test_user +default src_buck hive_test_user USER DELETE true -1 hive_test_user +default src_buck hive_test_user USER INSERT true -1 hive_test_user +default src_buck hive_test_user USER SELECT true -1 hive_test_user +default src_buck hive_test_user USER UPDATE true -1 hive_test_user +default src_cbo hive_test_user USER DELETE true -1 hive_test_user +default src_cbo hive_test_user USER INSERT true -1 hive_test_user +default src_cbo hive_test_user USER SELECT true -1 hive_test_user +default src_cbo hive_test_user USER UPDATE true -1 hive_test_user +default src_json hive_test_user USER DELETE true -1 hive_test_user +default src_json hive_test_user USER INSERT true -1 hive_test_user +default src_json hive_test_user USER SELECT true -1 hive_test_user +default src_json hive_test_user USER UPDATE true -1 hive_test_user +default src_sequencefile hive_test_user USER DELETE true -1 hive_test_user +default src_sequencefile hive_test_user USER INSERT true -1 hive_test_user +default src_sequencefile hive_test_user USER SELECT true -1 hive_test_user +default src_sequencefile hive_test_user USER UPDATE true -1 hive_test_user +default src_skew hive_test_user USER DELETE true -1 hive_test_user +default src_skew hive_test_user USER INSERT true -1 hive_test_user +default src_skew hive_test_user USER SELECT true -1 hive_test_user +default src_skew hive_test_user USER UPDATE true -1 hive_test_user +default src_thrift hive_test_user USER DELETE true -1 hive_test_user +default src_thrift hive_test_user USER INSERT true -1 hive_test_user +default src_thrift hive_test_user USER SELECT true -1 hive_test_user +default src_thrift hive_test_user USER UPDATE true -1 hive_test_user +default srcbucket hive_test_user USER DELETE true -1 hive_test_user +default srcbucket hive_test_user USER INSERT true -1 hive_test_user +default srcbucket hive_test_user USER SELECT true -1 hive_test_user +default srcbucket hive_test_user USER UPDATE true -1 hive_test_user +default srcbucket2 hive_test_user USER DELETE true -1 hive_test_user +default srcbucket2 hive_test_user USER INSERT true -1 hive_test_user +default srcbucket2 hive_test_user USER SELECT true -1 hive_test_user +default srcbucket2 hive_test_user USER UPDATE true -1 hive_test_user +default srcpart hive_test_user USER DELETE true -1 hive_test_user +default srcpart hive_test_user USER INSERT true -1 hive_test_user +default srcpart hive_test_user USER SELECT true -1 hive_test_user +default srcpart hive_test_user USER UPDATE true -1 hive_test_user +PREHOOK: query: CREATE DATABASE SYS +PREHOOK: type: CREATEDATABASE +PREHOOK: Output: database:SYS +POSTHOOK: query: CREATE DATABASE SYS +POSTHOOK: type: CREATEDATABASE +POSTHOOK: Output: database:SYS +PREHOOK: query: USE SYS +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:sys +POSTHOOK: query: USE SYS +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `BUCKETING_COLS` ( + `SD_ID` bigint, + `BUCKET_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_BUCKETING_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"BUCKET_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"BUCKETING_COLS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@BUCKETING_COLS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `BUCKETING_COLS` ( + `SD_ID` bigint, + `BUCKET_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_BUCKETING_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"BUCKET_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"BUCKETING_COLS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@BUCKETING_COLS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `CDS` ( + `CD_ID` bigint, + CONSTRAINT `SYS_PK_CDS` PRIMARY KEY (`CD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\" +FROM + \"CDS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@CDS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `CDS` ( + `CD_ID` bigint, + CONSTRAINT `SYS_PK_CDS` PRIMARY KEY (`CD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\" +FROM + \"CDS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@CDS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `COLUMNS_V2` ( + `CD_ID` bigint, + `COMMENT` string, + `COLUMN_NAME` string, + `TYPE_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_COLUMN_V2` PRIMARY KEY (`CD_ID`,`COLUMN_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\", + \"COMMENT\", + \"COLUMN_NAME\", + \"TYPE_NAME\", + \"INTEGER_IDX\" +FROM + \"COLUMNS_V2\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@COLUMNS_V2 +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `COLUMNS_V2` ( + `CD_ID` bigint, + `COMMENT` string, + `COLUMN_NAME` string, + `TYPE_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_COLUMN_V2` PRIMARY KEY (`CD_ID`,`COLUMN_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CD_ID\", + \"COMMENT\", + \"COLUMN_NAME\", + \"TYPE_NAME\", + \"INTEGER_IDX\" +FROM + \"COLUMNS_V2\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@COLUMNS_V2 +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `DATABASE_PARAMS` ( + `DB_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_DATABASE_PARAMS` PRIMARY KEY (`DB_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"DATABASE_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@DATABASE_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `DATABASE_PARAMS` ( + `DB_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_DATABASE_PARAMS` PRIMARY KEY (`DB_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"DATABASE_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@DATABASE_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `DBS` ( + `DB_ID` bigint, + `DB_LOCATION_URI` string, + `NAME` string, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_DBS` PRIMARY KEY (`DB_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"DB_LOCATION_URI\", + \"NAME\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + DBS" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@DBS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `DBS` ( + `DB_ID` bigint, + `DB_LOCATION_URI` string, + `NAME` string, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_DBS` PRIMARY KEY (`DB_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_ID\", + \"DB_LOCATION_URI\", + \"NAME\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + DBS" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@DBS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `DB_PRIVS` ( + `DB_GRANT_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `DB_PRIV` string, + CONSTRAINT `SYS_PK_DB_PRIVS` PRIMARY KEY (`DB_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_GRANT_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"DB_PRIV\" +FROM + \"DB_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@DB_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `DB_PRIVS` ( + `DB_GRANT_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `DB_PRIV` string, + CONSTRAINT `SYS_PK_DB_PRIVS` PRIMARY KEY (`DB_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"DB_GRANT_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"DB_PRIV\" +FROM + \"DB_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@DB_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `GLOBAL_PRIVS` ( + `USER_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` string, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `USER_PRIV` string, + CONSTRAINT `SYS_PK_GLOBAL_PRIVS` PRIMARY KEY (`USER_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"USER_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"USER_PRIV\" +FROM + \"GLOBAL_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@GLOBAL_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `GLOBAL_PRIVS` ( + `USER_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` string, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `USER_PRIV` string, + CONSTRAINT `SYS_PK_GLOBAL_PRIVS` PRIMARY KEY (`USER_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"USER_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"USER_PRIV\" +FROM + \"GLOBAL_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@GLOBAL_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `IDXS` ( + `INDEX_ID` bigint, + `CREATE_TIME` int, + `DEFERRED_REBUILD` boolean, + `INDEX_HANDLER_CLASS` string, + `INDEX_NAME` string, + `INDEX_TBL_ID` bigint, + `LAST_ACCESS_TIME` int, + `ORIG_TBL_ID` bigint, + `SD_ID` bigint, + CONSTRAINT `SYS_PK_IDXS` PRIMARY KEY (`INDEX_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"CREATE_TIME\", + \"DEFERRED_REBUILD\", + \"INDEX_HANDLER_CLASS\", + \"INDEX_NAME\", + \"INDEX_TBL_ID\", + \"LAST_ACCESS_TIME\", + \"ORIG_TBL_ID\", + \"SD_ID\" +FROM + \"IDXS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@IDXS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `IDXS` ( + `INDEX_ID` bigint, + `CREATE_TIME` int, + `DEFERRED_REBUILD` boolean, + `INDEX_HANDLER_CLASS` string, + `INDEX_NAME` string, + `INDEX_TBL_ID` bigint, + `LAST_ACCESS_TIME` int, + `ORIG_TBL_ID` bigint, + `SD_ID` bigint, + CONSTRAINT `SYS_PK_IDXS` PRIMARY KEY (`INDEX_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"CREATE_TIME\", + \"DEFERRED_REBUILD\", + \"INDEX_HANDLER_CLASS\", + \"INDEX_NAME\", + \"INDEX_TBL_ID\", + \"LAST_ACCESS_TIME\", + \"ORIG_TBL_ID\", + \"SD_ID\" +FROM + \"IDXS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@IDXS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `INDEX_PARAMS` ( + `INDEX_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_INDEX_PARAMS` PRIMARY KEY (`INDEX_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"INDEX_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@INDEX_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `INDEX_PARAMS` ( + `INDEX_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_INDEX_PARAMS` PRIMARY KEY (`INDEX_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"INDEX_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"INDEX_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@INDEX_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITIONS` ( + `PART_ID` bigint, + `CREATE_TIME` int, + `LAST_ACCESS_TIME` int, + `PART_NAME` string, + `SD_ID` bigint, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_PARTITIONS` PRIMARY KEY (`PART_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"CREATE_TIME\", + \"LAST_ACCESS_TIME\", + \"PART_NAME\", + \"SD_ID\", + \"TBL_ID\" +FROM + \"PARTITIONS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PARTITIONS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITIONS` ( + `PART_ID` bigint, + `CREATE_TIME` int, + `LAST_ACCESS_TIME` int, + `PART_NAME` string, + `SD_ID` bigint, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_PARTITIONS` PRIMARY KEY (`PART_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"CREATE_TIME\", + \"LAST_ACCESS_TIME\", + \"PART_NAME\", + \"SD_ID\", + \"TBL_ID\" +FROM + \"PARTITIONS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PARTITIONS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_KEYS` ( + `TBL_ID` bigint, + `PKEY_COMMENT` string, + `PKEY_NAME` string, + `PKEY_TYPE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEYS` PRIMARY KEY (`TBL_ID`,`PKEY_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PKEY_COMMENT\", + \"PKEY_NAME\", + \"PKEY_TYPE\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEYS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PARTITION_KEYS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_KEYS` ( + `TBL_ID` bigint, + `PKEY_COMMENT` string, + `PKEY_NAME` string, + `PKEY_TYPE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEYS` PRIMARY KEY (`TBL_ID`,`PKEY_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PKEY_COMMENT\", + \"PKEY_NAME\", + \"PKEY_TYPE\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEYS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PARTITION_KEYS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_KEY_VALS` ( + `PART_ID` bigint, + `PART_KEY_VAL` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEY_VALS` PRIMARY KEY (`PART_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PART_KEY_VAL\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEY_VALS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PARTITION_KEY_VALS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_KEY_VALS` ( + `PART_ID` bigint, + `PART_KEY_VAL` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_PARTITION_KEY_VALS` PRIMARY KEY (`PART_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PART_KEY_VAL\", + \"INTEGER_IDX\" +FROM + \"PARTITION_KEY_VALS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PARTITION_KEY_VALS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_PARAMS` ( + `PART_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_PARTITION_PARAMS` PRIMARY KEY (`PART_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"PARTITION_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PARTITION_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PARTITION_PARAMS` ( + `PART_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_PARTITION_PARAMS` PRIMARY KEY (`PART_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"PARTITION_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PARTITION_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PART_COL_PRIVS` ( + `PART_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_COL_PRIV` string, + CONSTRAINT `SYS_PK_PART_COL_PRIVS` PRIMARY KEY (`PART_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_COL_PRIV\" +FROM + \"PART_COL_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PART_COL_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PART_COL_PRIVS` ( + `PART_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_COL_PRIV` string, + CONSTRAINT `SYS_PK_PART_COL_PRIVS` PRIMARY KEY (`PART_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_COL_PRIV\" +FROM + \"PART_COL_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PART_COL_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PART_PRIVS` ( + `PART_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_PRIV` string, + CONSTRAINT `SYS_PK_PART_PRIVS` PRIMARY KEY (`PART_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_PRIV\" +FROM + \"PART_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PART_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PART_PRIVS` ( + `PART_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PART_ID` bigint, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `PART_PRIV` string, + CONSTRAINT `SYS_PK_PART_PRIVS` PRIMARY KEY (`PART_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"PART_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PART_ID\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"PART_PRIV\" +FROM + \"PART_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PART_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `ROLES` ( + `ROLE_ID` bigint, + `CREATE_TIME` int, + `OWNER_NAME` string, + `ROLE_NAME` string, + CONSTRAINT `SYS_PK_ROLES` PRIMARY KEY (`ROLE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_ID\", + \"CREATE_TIME\", + \"OWNER_NAME\", + \"ROLE_NAME\" +FROM + \"ROLES\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@ROLES +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `ROLES` ( + `ROLE_ID` bigint, + `CREATE_TIME` int, + `OWNER_NAME` string, + `ROLE_NAME` string, + CONSTRAINT `SYS_PK_ROLES` PRIMARY KEY (`ROLE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_ID\", + \"CREATE_TIME\", + \"OWNER_NAME\", + \"ROLE_NAME\" +FROM + \"ROLES\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@ROLES +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `ROLE_MAP` ( + `ROLE_GRANT_ID` bigint, + `ADD_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `ROLE_ID` bigint, + CONSTRAINT `SYS_PK_ROLE_MAP` PRIMARY KEY (`ROLE_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_GRANT_ID\", + \"ADD_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"ROLE_ID\" +FROM + \"ROLE_MAP\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@ROLE_MAP +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `ROLE_MAP` ( + `ROLE_GRANT_ID` bigint, + `ADD_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `ROLE_ID` bigint, + CONSTRAINT `SYS_PK_ROLE_MAP` PRIMARY KEY (`ROLE_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"ROLE_GRANT_ID\", + \"ADD_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"ROLE_ID\" +FROM + \"ROLE_MAP\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@ROLE_MAP +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SDS` ( + `SD_ID` bigint, + `CD_ID` bigint, + `INPUT_FORMAT` string, + `IS_COMPRESSED` boolean, + `IS_STOREDASSUBDIRECTORIES` boolean, + `LOCATION` string, + `NUM_BUCKETS` int, + `OUTPUT_FORMAT` string, + `SERDE_ID` bigint, + CONSTRAINT `SYS_PK_SDS` PRIMARY KEY (`SD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"CD_ID\", + \"INPUT_FORMAT\", + \"IS_COMPRESSED\", + \"IS_STOREDASSUBDIRECTORIES\", + \"LOCATION\", + \"NUM_BUCKETS\", + \"OUTPUT_FORMAT\", + \"SERDE_ID\" +FROM + \"SDS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SDS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SDS` ( + `SD_ID` bigint, + `CD_ID` bigint, + `INPUT_FORMAT` string, + `IS_COMPRESSED` boolean, + `IS_STOREDASSUBDIRECTORIES` boolean, + `LOCATION` string, + `NUM_BUCKETS` int, + `OUTPUT_FORMAT` string, + `SERDE_ID` bigint, + CONSTRAINT `SYS_PK_SDS` PRIMARY KEY (`SD_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"CD_ID\", + \"INPUT_FORMAT\", + \"IS_COMPRESSED\", + \"IS_STOREDASSUBDIRECTORIES\", + \"LOCATION\", + \"NUM_BUCKETS\", + \"OUTPUT_FORMAT\", + \"SERDE_ID\" +FROM + \"SDS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SDS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SD_PARAMS` ( + `SD_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SD_PARAMS` PRIMARY KEY (`SD_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SD_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SD_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SD_PARAMS` ( + `SD_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SD_PARAMS` PRIMARY KEY (`SD_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SD_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SD_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SEQUENCE_TABLE` ( + `SEQUENCE_NAME` string, + `NEXT_VAL` bigint, + CONSTRAINT `SYS_PK_SEQUENCE_TABLE` PRIMARY KEY (`SEQUENCE_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SEQUENCE_NAME\", + \"NEXT_VAL\" +FROM + \"SEQUENCE_TABLE\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SEQUENCE_TABLE +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SEQUENCE_TABLE` ( + `SEQUENCE_NAME` string, + `NEXT_VAL` bigint, + CONSTRAINT `SYS_PK_SEQUENCE_TABLE` PRIMARY KEY (`SEQUENCE_NAME`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SEQUENCE_NAME\", + \"NEXT_VAL\" +FROM + \"SEQUENCE_TABLE\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SEQUENCE_TABLE +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SERDES` ( + `SERDE_ID` bigint, + `NAME` string, + `SLIB` string, + CONSTRAINT `SYS_PK_SERDES` PRIMARY KEY (`SERDE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"NAME\", + \"SLIB\" +FROM + \"SERDES\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SERDES +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SERDES` ( + `SERDE_ID` bigint, + `NAME` string, + `SLIB` string, + CONSTRAINT `SYS_PK_SERDES` PRIMARY KEY (`SERDE_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"NAME\", + \"SLIB\" +FROM + \"SERDES\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SERDES +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SERDE_PARAMS` ( + `SERDE_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SERDE_PARAMS` PRIMARY KEY (`SERDE_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SERDE_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SERDE_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SERDE_PARAMS` ( + `SERDE_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_SERDE_PARAMS` PRIMARY KEY (`SERDE_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SERDE_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"SERDE_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SERDE_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_COL_NAMES` ( + `SD_ID` bigint, + `SKEWED_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_COL_NAMES` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"SKEWED_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"SKEWED_COL_NAMES\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SKEWED_COL_NAMES +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_COL_NAMES` ( + `SD_ID` bigint, + `SKEWED_COL_NAME` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_COL_NAMES` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"SKEWED_COL_NAME\", + \"INTEGER_IDX\" +FROM + \"SKEWED_COL_NAMES\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SKEWED_COL_NAMES +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_COL_VALUE_LOC_MAP` ( + `SD_ID` bigint, + `STRING_LIST_ID_KID` bigint, + `LOCATION` string, + CONSTRAINT `SYS_PK_COL_VALUE_LOC_MAP` PRIMARY KEY (`SD_ID`,`STRING_LIST_ID_KID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"STRING_LIST_ID_KID\", + \"LOCATION\" +FROM + \"SKEWED_COL_VALUE_LOC_MAP\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SKEWED_COL_VALUE_LOC_MAP +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_COL_VALUE_LOC_MAP` ( + `SD_ID` bigint, + `STRING_LIST_ID_KID` bigint, + `LOCATION` string, + CONSTRAINT `SYS_PK_COL_VALUE_LOC_MAP` PRIMARY KEY (`SD_ID`,`STRING_LIST_ID_KID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"STRING_LIST_ID_KID\", + \"LOCATION\" +FROM + \"SKEWED_COL_VALUE_LOC_MAP\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SKEWED_COL_VALUE_LOC_MAP +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST` ( + `STRING_LIST_ID` bigint, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST` PRIMARY KEY (`STRING_LIST_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\" +FROM + \"SKEWED_STRING_LIST\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SKEWED_STRING_LIST +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST` ( + `STRING_LIST_ID` bigint, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST` PRIMARY KEY (`STRING_LIST_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\" +FROM + \"SKEWED_STRING_LIST\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SKEWED_STRING_LIST +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST_VALUES` ( + `STRING_LIST_ID` bigint, + `STRING_LIST_VALUE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST_VALUES` PRIMARY KEY (`STRING_LIST_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\", + \"STRING_LIST_VALUE\", + \"INTEGER_IDX\" +FROM + \"SKEWED_STRING_LIST_VALUES\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SKEWED_STRING_LIST_VALUES +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_STRING_LIST_VALUES` ( + `STRING_LIST_ID` bigint, + `STRING_LIST_VALUE` string, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_STRING_LIST_VALUES` PRIMARY KEY (`STRING_LIST_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"STRING_LIST_ID\", + \"STRING_LIST_VALUE\", + \"INTEGER_IDX\" +FROM + \"SKEWED_STRING_LIST_VALUES\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SKEWED_STRING_LIST_VALUES +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_VALUES` ( + `SD_ID_OID` bigint, + `STRING_LIST_ID_EID` bigint, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_VALUES` PRIMARY KEY (`SD_ID_OID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID_OID\", + \"STRING_LIST_ID_EID\", + \"INTEGER_IDX\" +FROM + \"SKEWED_VALUES\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SKEWED_VALUES +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SKEWED_VALUES` ( + `SD_ID_OID` bigint, + `STRING_LIST_ID_EID` bigint, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SKEWED_VALUES` PRIMARY KEY (`SD_ID_OID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID_OID\", + \"STRING_LIST_ID_EID\", + \"INTEGER_IDX\" +FROM + \"SKEWED_VALUES\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SKEWED_VALUES +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `SORT_COLS` ( + `SD_ID` bigint, + `COLUMN_NAME` string, + `ORDER` int, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SORT_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"COLUMN_NAME\", + \"ORDER\", + \"INTEGER_IDX\" +FROM + \"SORT_COLS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@SORT_COLS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `SORT_COLS` ( + `SD_ID` bigint, + `COLUMN_NAME` string, + `ORDER` int, + `INTEGER_IDX` int, + CONSTRAINT `SYS_PK_SORT_COLS` PRIMARY KEY (`SD_ID`,`INTEGER_IDX`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"SD_ID\", + \"COLUMN_NAME\", + \"ORDER\", + \"INTEGER_IDX\" +FROM + \"SORT_COLS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@SORT_COLS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `TABLE_PARAMS` ( + `TBL_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_TABLE_PARAMS` PRIMARY KEY (`TBL_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"TABLE_PARAMS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@TABLE_PARAMS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `TABLE_PARAMS` ( + `TBL_ID` bigint, + `PARAM_KEY` string, + `PARAM_VALUE` string, + CONSTRAINT `SYS_PK_TABLE_PARAMS` PRIMARY KEY (`TBL_ID`,`PARAM_KEY`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"PARAM_KEY\", + \"PARAM_VALUE\" +FROM + \"TABLE_PARAMS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@TABLE_PARAMS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `TBLS` ( + `TBL_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `LAST_ACCESS_TIME` int, + `OWNER` string, + `RETENTION` int, + `SD_ID` bigint, + `TBL_NAME` string, + `TBL_TYPE` string, + `VIEW_EXPANDED_TEXT` string, + `VIEW_ORIGINAL_TEXT` string, + `IS_REWRITE_ENABLED` boolean, + CONSTRAINT `SYS_PK_TBLS` PRIMARY KEY (`TBL_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"LAST_ACCESS_TIME\", + \"OWNER\", + \"RETENTION\", + \"SD_ID\", + \"TBL_NAME\", + \"TBL_TYPE\", + \"VIEW_EXPANDED_TEXT\", + \"VIEW_ORIGINAL_TEXT\", + \"IS_REWRITE_ENABLED\" +FROM TBLS" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@TBLS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `TBLS` ( + `TBL_ID` bigint, + `CREATE_TIME` int, + `DB_ID` bigint, + `LAST_ACCESS_TIME` int, + `OWNER` string, + `RETENTION` int, + `SD_ID` bigint, + `TBL_NAME` string, + `TBL_TYPE` string, + `VIEW_EXPANDED_TEXT` string, + `VIEW_ORIGINAL_TEXT` string, + `IS_REWRITE_ENABLED` boolean, + CONSTRAINT `SYS_PK_TBLS` PRIMARY KEY (`TBL_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_ID\", + \"CREATE_TIME\", + \"DB_ID\", + \"LAST_ACCESS_TIME\", + \"OWNER\", + \"RETENTION\", + \"SD_ID\", + \"TBL_NAME\", + \"TBL_TYPE\", + \"VIEW_EXPANDED_TEXT\", + \"VIEW_ORIGINAL_TEXT\", + \"IS_REWRITE_ENABLED\" +FROM TBLS" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@TBLS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `TBL_COL_PRIVS` ( + `TBL_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_COL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_COL_PRIVS` PRIMARY KEY (`TBL_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_COL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_COL_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@TBL_COL_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `TBL_COL_PRIVS` ( + `TBL_COLUMN_GRANT_ID` bigint, + `COLUMN_NAME` string, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_COL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_COL_PRIVS` PRIMARY KEY (`TBL_COLUMN_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_COLUMN_GRANT_ID\", + \"COLUMN_NAME\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_COL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_COL_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@TBL_COL_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `TBL_PRIVS` ( + `TBL_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_PRIVS` PRIMARY KEY (`TBL_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_PRIVS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@TBL_PRIVS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `TBL_PRIVS` ( + `TBL_GRANT_ID` bigint, + `CREATE_TIME` int, + `GRANT_OPTION` int, + `GRANTOR` string, + `GRANTOR_TYPE` string, + `PRINCIPAL_NAME` string, + `PRINCIPAL_TYPE` string, + `TBL_PRIV` string, + `TBL_ID` bigint, + CONSTRAINT `SYS_PK_TBL_PRIVS` PRIMARY KEY (`TBL_GRANT_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"TBL_GRANT_ID\", + \"CREATE_TIME\", + \"GRANT_OPTION\", + \"GRANTOR\", + \"GRANTOR_TYPE\", + \"PRINCIPAL_NAME\", + \"PRINCIPAL_TYPE\", + \"TBL_PRIV\", + \"TBL_ID\" +FROM + \"TBL_PRIVS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@TBL_PRIVS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `TAB_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `TBL_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_TAB_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"TBL_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"TAB_COL_STATS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@TAB_COL_STATS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `TAB_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `TBL_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_TAB_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"TBL_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"TAB_COL_STATS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@TAB_COL_STATS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `PART_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `PARTITION_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `PART_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_PART_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"PARTITION_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"PART_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"PART_COL_STATS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@PART_COL_STATS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `PART_COL_STATS` ( + `CS_ID` bigint, + `DB_NAME` string, + `TABLE_NAME` string, + `PARTITION_NAME` string, + `COLUMN_NAME` string, + `COLUMN_TYPE` string, + `PART_ID` bigint, + `LONG_LOW_VALUE` bigint, + `LONG_HIGH_VALUE` bigint, + `DOUBLE_HIGH_VALUE` double, + `DOUBLE_LOW_VALUE` double, + `BIG_DECIMAL_LOW_VALUE` string, + `BIG_DECIMAL_HIGH_VALUE` string, + `NUM_NULLS` bigint, + `NUM_DISTINCTS` bigint, + `AVG_COL_LEN` double, + `MAX_COL_LEN` bigint, + `NUM_TRUES` bigint, + `NUM_FALSES` bigint, + `LAST_ANALYZED` bigint, + CONSTRAINT `SYS_PK_PART_COL_STATS` PRIMARY KEY (`CS_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CS_ID\", + \"DB_NAME\", + \"TABLE_NAME\", + \"PARTITION_NAME\", + \"COLUMN_NAME\", + \"COLUMN_TYPE\", + \"PART_ID\", + \"LONG_LOW_VALUE\", + \"LONG_HIGH_VALUE\", + \"DOUBLE_HIGH_VALUE\", + \"DOUBLE_LOW_VALUE\", + \"BIG_DECIMAL_LOW_VALUE\", + \"BIG_DECIMAL_HIGH_VALUE\", + \"NUM_NULLS\", + \"NUM_DISTINCTS\", + \"AVG_COL_LEN\", + \"MAX_COL_LEN\", + \"NUM_TRUES\", + \"NUM_FALSES\", + \"LAST_ANALYZED\" +FROM + \"PART_COL_STATS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@PART_COL_STATS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `VERSION` ( + `VER_ID` BIGINT, + `SCHEMA_VERSION` string, + `VERSION_COMMENT` string, + CONSTRAINT `SYS_PK_VERSION` PRIMARY KEY (`VER_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"VER_ID\", + \"SCHEMA_VERSION\", + \"VERSION_COMMENT\" +FROM + \"VERSION\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@VERSION +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `VERSION` ( + `VER_ID` BIGINT, + `SCHEMA_VERSION` string, + `VERSION_COMMENT` string, + CONSTRAINT `SYS_PK_VERSION` PRIMARY KEY (`VER_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"VER_ID\", + \"SCHEMA_VERSION\", + \"VERSION_COMMENT\" +FROM + \"VERSION\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@VERSION +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `FUNCS` ( + `FUNC_ID` bigint, + `CLASS_NAME` string, + `CREATE_TIME` int, + `DB_ID` bigint, + `FUNC_NAME` string, + `FUNC_TYPE` int, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_FUNCS` PRIMARY KEY (`FUNC_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"FUNC_ID\", + \"CLASS_NAME\", + \"CREATE_TIME\", + \"DB_ID\", + \"FUNC_NAME\", + \"FUNC_TYPE\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + \"FUNCS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@FUNCS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `FUNCS` ( + `FUNC_ID` bigint, + `CLASS_NAME` string, + `CREATE_TIME` int, + `DB_ID` bigint, + `FUNC_NAME` string, + `FUNC_TYPE` int, + `OWNER_NAME` string, + `OWNER_TYPE` string, + CONSTRAINT `SYS_PK_FUNCS` PRIMARY KEY (`FUNC_ID`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"FUNC_ID\", + \"CLASS_NAME\", + \"CREATE_TIME\", + \"DB_ID\", + \"FUNC_NAME\", + \"FUNC_TYPE\", + \"OWNER_NAME\", + \"OWNER_TYPE\" +FROM + \"FUNCS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@FUNCS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `KEY_CONSTRAINTS` +( + `CHILD_CD_ID` bigint, + `CHILD_INTEGER_IDX` int, + `CHILD_TBL_ID` bigint, + `PARENT_CD_ID` bigint, + `PARENT_INTEGER_IDX` int, + `PARENT_TBL_ID` bigint, + `POSITION` bigint, + `CONSTRAINT_NAME` string, + `CONSTRAINT_TYPE` string, + `UPDATE_RULE` string, + `DELETE_RULE` string, + `ENABLE_VALIDATE_RELY` int, + CONSTRAINT `SYS_PK_KEY_CONSTRAINTS` PRIMARY KEY (`CONSTRAINT_NAME`, `POSITION`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CHILD_CD_ID\", + \"CHILD_INTEGER_IDX\", + \"CHILD_TBL_ID\", + \"PARENT_CD_ID\", + \"PARENT_INTEGER_IDX\", + \"PARENT_TBL_ID\", + \"POSITION\", + \"CONSTRAINT_NAME\", + \"CONSTRAINT_TYPE\", + \"UPDATE_RULE\", + \"DELETE_RULE\", + \"ENABLE_VALIDATE_RELY\" +FROM + \"KEY_CONSTRAINTS\"" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@KEY_CONSTRAINTS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `KEY_CONSTRAINTS` +( + `CHILD_CD_ID` bigint, + `CHILD_INTEGER_IDX` int, + `CHILD_TBL_ID` bigint, + `PARENT_CD_ID` bigint, + `PARENT_INTEGER_IDX` int, + `PARENT_TBL_ID` bigint, + `POSITION` bigint, + `CONSTRAINT_NAME` string, + `CONSTRAINT_TYPE` string, + `UPDATE_RULE` string, + `DELETE_RULE` string, + `ENABLE_VALIDATE_RELY` int, + CONSTRAINT `SYS_PK_KEY_CONSTRAINTS` PRIMARY KEY (`CONSTRAINT_NAME`, `POSITION`) DISABLE NOVALIDATE +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + \"CHILD_CD_ID\", + \"CHILD_INTEGER_IDX\", + \"CHILD_TBL_ID\", + \"PARENT_CD_ID\", + \"PARENT_INTEGER_IDX\", + \"PARENT_TBL_ID\", + \"POSITION\", + \"CONSTRAINT_NAME\", + \"CONSTRAINT_TYPE\", + \"UPDATE_RULE\", + \"DELETE_RULE\", + \"ENABLE_VALIDATE_RELY\" +FROM + \"KEY_CONSTRAINTS\"" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@KEY_CONSTRAINTS +POSTHOOK: Output: database:sys +PREHOOK: query: CREATE DATABASE INFORMATION_SCHEMA +PREHOOK: type: CREATEDATABASE +PREHOOK: Output: database:INFORMATION_SCHEMA +POSTHOOK: query: CREATE DATABASE INFORMATION_SCHEMA +POSTHOOK: type: CREATEDATABASE +POSTHOOK: Output: database:INFORMATION_SCHEMA +PREHOOK: query: USE INFORMATION_SCHEMA +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:information_schema +POSTHOOK: query: USE INFORMATION_SCHEMA +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:information_schema +PREHOOK: query: CREATE VIEW IF NOT EXISTS `SCHEMATA` +( + `CATALOG_NAME`, + `SCHEMA_NAME`, + `SCHEMA_OWNER`, + `DEFAULT_CHARACTER_SET_CATALOG`, + `DEFAULT_CHARACTER_SET_SCHEMA`, + `DEFAULT_CHARACTER_SET_NAME`, + `SQL_PATH` +) AS +SELECT + 'default', + `NAME`, + `OWNER_NAME`, + cast(null as string), + cast(null as string), + cast(null as string), + `DB_LOCATION_URI` +FROM + sys.DBS +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@dbs +PREHOOK: Output: INFORMATION_SCHEMA@SCHEMATA +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `SCHEMATA` +( + `CATALOG_NAME`, + `SCHEMA_NAME`, + `SCHEMA_OWNER`, + `DEFAULT_CHARACTER_SET_CATALOG`, + `DEFAULT_CHARACTER_SET_SCHEMA`, + `DEFAULT_CHARACTER_SET_NAME`, + `SQL_PATH` +) AS +SELECT + 'default', + `NAME`, + `OWNER_NAME`, + cast(null as string), + cast(null as string), + cast(null as string), + `DB_LOCATION_URI` +FROM + sys.DBS +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@dbs +POSTHOOK: Output: INFORMATION_SCHEMA@SCHEMATA +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: SCHEMATA.catalog_name SIMPLE [] +POSTHOOK: Lineage: SCHEMATA.default_character_set_catalog SIMPLE [] +POSTHOOK: Lineage: SCHEMATA.default_character_set_name SIMPLE [] +POSTHOOK: Lineage: SCHEMATA.default_character_set_schema SIMPLE [] +POSTHOOK: Lineage: SCHEMATA.schema_name SIMPLE [(dbs)dbs.FieldSchema(name:name, type:string, comment:from deserializer), ] +#### A masked pattern was here #### +POSTHOOK: Lineage: SCHEMATA.sql_path SIMPLE [(dbs)dbs.FieldSchema(name:db_location_uri, type:string, comment:from deserializer), ] +PREHOOK: query: CREATE VIEW IF NOT EXISTS `TABLES` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `TABLE_TYPE` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + IF(length(T.VIEW_ORIGINAL_TEXT) > 0, 'VIEW', 'BASE_TABLE') +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID` +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbls +PREHOOK: Output: INFORMATION_SCHEMA@TABLES +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `TABLES` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `TABLE_TYPE` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + IF(length(T.VIEW_ORIGINAL_TEXT) > 0, 'VIEW', 'BASE_TABLE') +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID` +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbls +POSTHOOK: Output: INFORMATION_SCHEMA@TABLES +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: TABLES.table_catalog SIMPLE [] +POSTHOOK: Lineage: TABLES.table_name SIMPLE [(tbls)t.FieldSchema(name:tbl_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLES.table_schema SIMPLE [(dbs)d.FieldSchema(name:name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLES.table_type EXPRESSION [(tbls)t.FieldSchema(name:view_original_text, type:string, comment:from deserializer), ] +PREHOOK: query: CREATE VIEW IF NOT EXISTS `TABLE_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D +WHERE + P.TBL_ID = T.TBL_ID + AND T.DB_ID = D.DB_ID +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbl_privs +PREHOOK: Input: sys@tbls +PREHOOK: Output: INFORMATION_SCHEMA@TABLE_PRIVILEGES +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `TABLE_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D +WHERE + P.TBL_ID = T.TBL_ID + AND T.DB_ID = D.DB_ID +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbl_privs +POSTHOOK: Input: sys@tbls +POSTHOOK: Output: INFORMATION_SCHEMA@TABLE_PRIVILEGES +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: TABLE_PRIVILEGES.grantee SIMPLE [(tbl_privs)p.FieldSchema(name:principal_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.grantor SIMPLE [(tbl_privs)p.FieldSchema(name:grantor, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.is_grantable EXPRESSION [(tbl_privs)p.FieldSchema(name:grant_option, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.privilege_type SIMPLE [(tbl_privs)p.FieldSchema(name:tbl_priv, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.table_catalog SIMPLE [] +POSTHOOK: Lineage: TABLE_PRIVILEGES.table_name SIMPLE [(tbls)t.FieldSchema(name:tbl_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.table_schema SIMPLE [(dbs)d.FieldSchema(name:name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: TABLE_PRIVILEGES.with_hierarchy SIMPLE [] +PREHOOK: query: CREATE VIEW IF NOT EXISTS `COLUMNS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `ORDINAL_POSITION`, + `COLUMN_DEFAULT`, + `IS_NULLABLE`, + `DATA_TYPE`, + `CHARACTER_MAXIMUM_LENGTH`, + `CHARACTER_OCTET_LENGTH`, + `NUMERIC_PRECISION`, + `NUMERIC_SCALE`, + `DATETIME_PRECISION`, + `CHARACTER_SET_NAME`, + `COLLATION_NAME` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + C.COLUMN_NAME, + C.INTEGER_IDX, + null, + true, + C.TYPE_NAME, + null, + null, + null, + null, + null, + null, + null +FROM + sys.`COLUMNS_V2` C, + sys.`SDS` S, + sys.`TBLS` T, + sys.`DBS` D +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND C.`CD_ID` = S.`CD_ID` +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@columns_v2 +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@sds +PREHOOK: Input: sys@tbls +PREHOOK: Output: INFORMATION_SCHEMA@COLUMNS +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `COLUMNS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `ORDINAL_POSITION`, + `COLUMN_DEFAULT`, + `IS_NULLABLE`, + `DATA_TYPE`, + `CHARACTER_MAXIMUM_LENGTH`, + `CHARACTER_OCTET_LENGTH`, + `NUMERIC_PRECISION`, + `NUMERIC_SCALE`, + `DATETIME_PRECISION`, + `CHARACTER_SET_NAME`, + `COLLATION_NAME` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + C.COLUMN_NAME, + C.INTEGER_IDX, + null, + true, + C.TYPE_NAME, + null, + null, + null, + null, + null, + null, + null +FROM + sys.`COLUMNS_V2` C, + sys.`SDS` S, + sys.`TBLS` T, + sys.`DBS` D +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND C.`CD_ID` = S.`CD_ID` +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@columns_v2 +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@sds +POSTHOOK: Input: sys@tbls +POSTHOOK: Output: INFORMATION_SCHEMA@COLUMNS +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: COLUMNS.character_maximum_length SIMPLE [] +POSTHOOK: Lineage: COLUMNS.character_octet_length SIMPLE [] +POSTHOOK: Lineage: COLUMNS.character_set_name SIMPLE [] +POSTHOOK: Lineage: COLUMNS.collation_name SIMPLE [] +POSTHOOK: Lineage: COLUMNS.column_default SIMPLE [] +POSTHOOK: Lineage: COLUMNS.column_name SIMPLE [(columns_v2)c.FieldSchema(name:column_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMNS.data_type SIMPLE [(columns_v2)c.FieldSchema(name:type_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMNS.datetime_precision SIMPLE [] +POSTHOOK: Lineage: COLUMNS.is_nullable SIMPLE [] +POSTHOOK: Lineage: COLUMNS.numeric_precision SIMPLE [] +POSTHOOK: Lineage: COLUMNS.numeric_scale SIMPLE [] +POSTHOOK: Lineage: COLUMNS.ordinal_position SIMPLE [(columns_v2)c.FieldSchema(name:integer_idx, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMNS.table_catalog SIMPLE [] +POSTHOOK: Lineage: COLUMNS.table_name SIMPLE [(tbls)t.FieldSchema(name:tbl_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMNS.table_schema SIMPLE [(dbs)d.FieldSchema(name:name, type:string, comment:from deserializer), ] +PREHOOK: query: CREATE VIEW IF NOT EXISTS `COLUMN_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + C.`COLUMN_NAME`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D, + sys.`COLUMNS_V2` C, + sys.`SDS` S +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND P.`TBL_ID` = T.`TBL_ID` + AND C.`CD_ID` = S.`CD_ID` +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@columns_v2 +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@sds +PREHOOK: Input: sys@tbl_privs +PREHOOK: Input: sys@tbls +PREHOOK: Output: INFORMATION_SCHEMA@COLUMN_PRIVILEGES +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `COLUMN_PRIVILEGES` +( + `GRANTOR`, + `GRANTEE`, + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `COLUMN_NAME`, + `PRIVILEGE_TYPE`, + `IS_GRANTABLE`, + `WITH_HIERARCHY` +) AS +SELECT + `GRANTOR`, + `PRINCIPAL_NAME`, + 'default', + D.`NAME`, + T.`TBL_NAME`, + P.`TBL_PRIV`, + C.`COLUMN_NAME`, + IF (P.`GRANT_OPTION` == 0, false, true), + CAST (null as boolean) +FROM + sys.`TBL_PRIVS` P, + sys.`TBLS` T, + sys.`DBS` D, + sys.`COLUMNS_V2` C, + sys.`SDS` S +WHERE + S.`SD_ID` = T.`SD_ID` + AND T.`DB_ID` = D.`DB_ID` + AND P.`TBL_ID` = T.`TBL_ID` + AND C.`CD_ID` = S.`CD_ID` +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@columns_v2 +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@sds +POSTHOOK: Input: sys@tbl_privs +POSTHOOK: Input: sys@tbls +POSTHOOK: Output: INFORMATION_SCHEMA@COLUMN_PRIVILEGES +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: COLUMN_PRIVILEGES.column_name SIMPLE [(tbl_privs)p.FieldSchema(name:tbl_priv, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.grantee SIMPLE [(tbl_privs)p.FieldSchema(name:principal_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.grantor SIMPLE [(tbl_privs)p.FieldSchema(name:grantor, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.is_grantable EXPRESSION [(tbl_privs)p.FieldSchema(name:grant_option, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.privilege_type SIMPLE [(columns_v2)c.FieldSchema(name:column_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.table_catalog SIMPLE [] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.table_name SIMPLE [(tbls)t.FieldSchema(name:tbl_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.table_schema SIMPLE [(dbs)d.FieldSchema(name:name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: COLUMN_PRIVILEGES.with_hierarchy SIMPLE [] +PREHOOK: query: CREATE VIEW IF NOT EXISTS `VIEWS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `VIEW_DEFINITION`, + `CHECK_OPTION`, + `IS_UPDATABLE`, + `IS_INSERTABLE_INTO`, + `IS_TRIGGER_UPDATABLE`, + `IS_TRIGGER_DELETABLE`, + `IS_TRIGGER_INSERTABLE_INTO` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + T.VIEW_ORIGINAL_TEXT, + CAST(NULL as string), + false, + false, + false, + false, + false +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID` AND + length(T.VIEW_ORIGINAL_TEXT) > 0 +PREHOOK: type: CREATEVIEW +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbls +PREHOOK: Output: INFORMATION_SCHEMA@VIEWS +PREHOOK: Output: database:information_schema +POSTHOOK: query: CREATE VIEW IF NOT EXISTS `VIEWS` +( + `TABLE_CATALOG`, + `TABLE_SCHEMA`, + `TABLE_NAME`, + `VIEW_DEFINITION`, + `CHECK_OPTION`, + `IS_UPDATABLE`, + `IS_INSERTABLE_INTO`, + `IS_TRIGGER_UPDATABLE`, + `IS_TRIGGER_DELETABLE`, + `IS_TRIGGER_INSERTABLE_INTO` +) AS +SELECT + 'default', + D.NAME, + T.TBL_NAME, + T.VIEW_ORIGINAL_TEXT, + CAST(NULL as string), + false, + false, + false, + false, + false +FROM + `sys`.`DBS` D, + `sys`.`TBLS` T +WHERE + D.`DB_ID` = T.`DB_ID` AND + length(T.VIEW_ORIGINAL_TEXT) > 0 +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbls +POSTHOOK: Output: INFORMATION_SCHEMA@VIEWS +POSTHOOK: Output: database:information_schema +POSTHOOK: Lineage: VIEWS.check_option SIMPLE [] +POSTHOOK: Lineage: VIEWS.is_insertable_into SIMPLE [] +POSTHOOK: Lineage: VIEWS.is_trigger_deletable SIMPLE [] +POSTHOOK: Lineage: VIEWS.is_trigger_insertable_into SIMPLE [] +POSTHOOK: Lineage: VIEWS.is_trigger_updatable SIMPLE [] +POSTHOOK: Lineage: VIEWS.is_updatable SIMPLE [] +POSTHOOK: Lineage: VIEWS.table_catalog SIMPLE [] +POSTHOOK: Lineage: VIEWS.table_name SIMPLE [(tbls)t.FieldSchema(name:tbl_name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: VIEWS.table_schema SIMPLE [(dbs)d.FieldSchema(name:name, type:string, comment:from deserializer), ] +POSTHOOK: Lineage: VIEWS.view_definition SIMPLE [(tbls)t.FieldSchema(name:view_original_text, type:string, comment:from deserializer), ] +PREHOOK: query: use sys +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:sys +POSTHOOK: query: use sys +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:sys +PREHOOK: query: select bucket_col_name, integer_idx from bucketing_cols order by bucket_col_name, integer_idx limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@bucketing_cols +#### A masked pattern was here #### +POSTHOOK: query: select bucket_col_name, integer_idx from bucketing_cols order by bucket_col_name, integer_idx limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@bucketing_cols +#### A masked pattern was here #### +key 0 +key 0 +value 0 +PREHOOK: query: select count(*) from cds +PREHOOK: type: QUERY +PREHOOK: Input: sys@cds +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from cds +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@cds +#### A masked pattern was here #### +60 +PREHOOK: query: select column_name, type_name, integer_idx from columns_v2 order by column_name, integer_idx limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@columns_v2 +#### A masked pattern was here #### +POSTHOOK: query: select column_name, type_name, integer_idx from columns_v2 order by column_name, integer_idx limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@columns_v2 +#### A masked pattern was here #### +add_time int 1 +aint int 0 +astring string 1 +attributes map,map>>>> 6 +avg_col_len double 14 +PREHOOK: query: select param_key, param_value from database_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@database_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from database_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@database_params +#### A masked pattern was here #### +PREHOOK: type: QUERY +PREHOOK: Input: sys@dbs +#### A masked pattern was here #### +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@dbs +#### A masked pattern was here #### +PREHOOK: query: select grantor, principal_name from db_privs order by grantor, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@db_privs +#### A masked pattern was here #### +POSTHOOK: query: select grantor, principal_name from db_privs order by grantor, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@db_privs +#### A masked pattern was here #### +PREHOOK: query: select grantor, principal_name from global_privs order by grantor, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@global_privs +#### A masked pattern was here #### +POSTHOOK: query: select grantor, principal_name from global_privs order by grantor, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@global_privs +#### A masked pattern was here #### +admin admin +PREHOOK: query: select index_name, index_handler_class from idxs order by index_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@idxs +#### A masked pattern was here #### +POSTHOOK: query: select index_name, index_handler_class from idxs order by index_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@idxs +#### A masked pattern was here #### +PREHOOK: query: select param_key, param_value from index_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@index_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from index_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@index_params +#### A masked pattern was here #### +PREHOOK: query: select part_name from partitions order by part_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@partitions +#### A masked pattern was here #### +POSTHOOK: query: select part_name from partitions order by part_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@partitions +#### A masked pattern was here #### +ds=2008-04-08/hr=11 +ds=2008-04-08/hr=12 +ds=2008-04-09/hr=11 +ds=2008-04-09/hr=12 +dt=2014 +PREHOOK: query: select pkey_name, pkey_type from partition_keys order by pkey_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@partition_keys +#### A masked pattern was here #### +POSTHOOK: query: select pkey_name, pkey_type from partition_keys order by pkey_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@partition_keys +#### A masked pattern was here #### +ds string +dt string +dt string +hr string +PREHOOK: query: select part_key_val, integer_idx from partition_key_vals order by part_key_val, integer_idx limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@partition_key_vals +#### A masked pattern was here #### +POSTHOOK: query: select part_key_val, integer_idx from partition_key_vals order by part_key_val, integer_idx limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@partition_key_vals +#### A masked pattern was here #### +11 1 +11 1 +12 1 +12 1 +2008-04-08 0 +PREHOOK: query: select param_key, param_value from partition_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@partition_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from partition_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@partition_params +#### A masked pattern was here #### +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"c_boolean":"true","c_float":"true","c_int":"true","key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"c_boolean":"true","c_float":"true","c_int":"true","key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} +PREHOOK: query: select grantor, principal_name from part_col_privs order by grantor, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@part_col_privs +#### A masked pattern was here #### +POSTHOOK: query: select grantor, principal_name from part_col_privs order by grantor, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@part_col_privs +#### A masked pattern was here #### +PREHOOK: query: select grantor, principal_name from part_privs order by grantor, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@part_privs +#### A masked pattern was here #### +POSTHOOK: query: select grantor, principal_name from part_privs order by grantor, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@part_privs +#### A masked pattern was here #### +PREHOOK: query: select role_name from roles order by role_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@roles +#### A masked pattern was here #### +POSTHOOK: query: select role_name from roles order by role_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@roles +#### A masked pattern was here #### +admin +public +PREHOOK: query: select principal_name, grantor from role_map order by principal_name, grantor limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@role_map +#### A masked pattern was here #### +POSTHOOK: query: select principal_name, grantor from role_map order by principal_name, grantor limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@role_map +#### A masked pattern was here #### +PREHOOK: query: select count(*) from sds +PREHOOK: type: QUERY +PREHOOK: Input: sys@sds +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from sds +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@sds +#### A masked pattern was here #### +66 +PREHOOK: query: select param_key, param_value from sd_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@sd_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from sd_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@sd_params +#### A masked pattern was here #### +PREHOOK: query: select sequence_name from sequence_table order by sequence_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@sequence_table +#### A masked pattern was here #### +POSTHOOK: query: select sequence_name from sequence_table order by sequence_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@sequence_table +#### A masked pattern was here #### +org.apache.hadoop.hive.metastore.model.MColumnDescriptor +org.apache.hadoop.hive.metastore.model.MDatabase +org.apache.hadoop.hive.metastore.model.MFunction +org.apache.hadoop.hive.metastore.model.MGlobalPrivilege +org.apache.hadoop.hive.metastore.model.MPartition +PREHOOK: query: select name, slib from serdes order by name, slib limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@serdes +#### A masked pattern was here #### +POSTHOOK: query: select name, slib from serdes order by name, slib limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@serdes +#### A masked pattern was here #### +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select param_key, param_value from serde_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@serde_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from serde_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@serde_params +#### A masked pattern was here #### +field.delim , +field.delim , +field.delim , +field.delim , +field.delim , +PREHOOK: query: select skewed_col_name from skewed_col_names order by skewed_col_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@skewed_col_names +#### A masked pattern was here #### +POSTHOOK: query: select skewed_col_name from skewed_col_names order by skewed_col_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@skewed_col_names +#### A masked pattern was here #### +key +PREHOOK: query: select count(*) from skewed_col_value_loc_map +PREHOOK: type: QUERY +PREHOOK: Input: sys@skewed_col_value_loc_map +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from skewed_col_value_loc_map +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@skewed_col_value_loc_map +#### A masked pattern was here #### +0 +PREHOOK: query: select count(*) from skewed_string_list +PREHOOK: type: QUERY +PREHOOK: Input: sys@skewed_string_list +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from skewed_string_list +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@skewed_string_list +#### A masked pattern was here #### +3 +PREHOOK: query: select count(*) from skewed_string_list_values +PREHOOK: type: QUERY +PREHOOK: Input: sys@skewed_string_list_values +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from skewed_string_list_values +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@skewed_string_list_values +#### A masked pattern was here #### +3 +PREHOOK: query: select count(*) from skewed_values +PREHOOK: type: QUERY +PREHOOK: Input: sys@skewed_values +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from skewed_values +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@skewed_values +#### A masked pattern was here #### +3 +PREHOOK: query: select column_name, `order` from sort_cols order by column_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@sort_cols +#### A masked pattern was here #### +POSTHOOK: query: select column_name, `order` from sort_cols order by column_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@sort_cols +#### A masked pattern was here #### +PREHOOK: query: select param_key, param_value from table_params order by param_key, param_value limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@table_params +#### A masked pattern was here #### +POSTHOOK: query: select param_key, param_value from table_params order by param_key, param_value limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@table_params +#### A masked pattern was here #### +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"c_boolean":"true","c_float":"true","c_int":"true","key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"cbigint":"true","cboolean1":"true","cboolean2":"true","cdouble":"true","cfloat":"true","cint":"true","csmallint":"true","cstring1":"true","cstring2":"true","ctimestamp1":"true","ctimestamp2":"true","ctinyint":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"json":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} +COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} +PREHOOK: query: select tbl_name from tbls order by tbl_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select tbl_name from tbls order by tbl_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +alltypesorc +bucketing_cols +cbo_t1 +cbo_t2 +cbo_t3 +PREHOOK: query: select column_name, grantor, principal_name from tbl_col_privs order by column_name, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@tbl_col_privs +#### A masked pattern was here #### +POSTHOOK: query: select column_name, grantor, principal_name from tbl_col_privs order by column_name, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@tbl_col_privs +#### A masked pattern was here #### +PREHOOK: query: select grantor, principal_name from tbl_privs order by grantor, principal_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@tbl_privs +#### A masked pattern was here #### +POSTHOOK: query: select grantor, principal_name from tbl_privs order by grantor, principal_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@tbl_privs +#### A masked pattern was here #### +hive_test_user hive_test_user +hive_test_user hive_test_user +hive_test_user hive_test_user +hive_test_user hive_test_user +hive_test_user hive_test_user +PREHOOK: query: select table_name, column_name, num_nulls, num_distincts from tab_col_stats order by table_name, column_name limit 10 +PREHOOK: type: QUERY +PREHOOK: Input: sys@tab_col_stats +#### A masked pattern was here #### +POSTHOOK: query: select table_name, column_name, num_nulls, num_distincts from tab_col_stats order by table_name, column_name limit 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@tab_col_stats +#### A masked pattern was here #### +alltypesorc cbigint 3115 4083 +alltypesorc cboolean1 3114 NULL +alltypesorc cboolean2 3115 NULL +alltypesorc cdouble 3114 4264 +alltypesorc cfloat 3115 117 +alltypesorc cint 3115 5774 +alltypesorc csmallint 3114 5529 +alltypesorc cstring1 3114 7488 +alltypesorc cstring2 3115 4083 +alltypesorc ctimestamp1 3115 31 +PREHOOK: query: select table_name, partition_name, column_name, num_nulls, num_distincts from part_col_stats order by table_name, partition_name, column_name limit 10 +PREHOOK: type: QUERY +PREHOOK: Input: sys@part_col_stats +#### A masked pattern was here #### +POSTHOOK: query: select table_name, partition_name, column_name, num_nulls, num_distincts from part_col_stats order by table_name, partition_name, column_name limit 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@part_col_stats +#### A masked pattern was here #### +cbo_t1 dt=2014 c_boolean 2 NULL +cbo_t1 dt=2014 c_float 2 1 +cbo_t1 dt=2014 c_int 2 1 +cbo_t1 dt=2014 key 2 4 +cbo_t1 dt=2014 value 2 4 +cbo_t2 dt=2014 c_boolean 2 NULL +cbo_t2 dt=2014 c_float 2 2 +cbo_t2 dt=2014 c_int 2 2 +cbo_t2 dt=2014 key 2 4 +cbo_t2 dt=2014 value 2 4 +PREHOOK: query: select schema_version from version order by schema_version limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@version +#### A masked pattern was here #### +POSTHOOK: query: select schema_version from version order by schema_version limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@version +#### A masked pattern was here #### +PREHOOK: query: select func_name, func_type from funcs order by func_name, func_type limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@funcs +#### A masked pattern was here #### +POSTHOOK: query: select func_name, func_type from funcs order by func_name, func_type limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@funcs +#### A masked pattern was here #### +qtest_get_java_boolean 1 +PREHOOK: query: select constraint_name from key_constraints order by constraint_name limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: sys@key_constraints +#### A masked pattern was here #### +POSTHOOK: query: select constraint_name from key_constraints order by constraint_name limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@key_constraints +#### A masked pattern was here #### +sys_pk_bucketing_cols +sys_pk_bucketing_cols +sys_pk_cds +sys_pk_col_value_loc_map +sys_pk_col_value_loc_map +PREHOOK: query: use INFORMATION_SCHEMA +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:information_schema +POSTHOOK: query: use INFORMATION_SCHEMA +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:information_schema +PREHOOK: query: select count(*) from SCHEMATA +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@schemata +PREHOOK: Input: sys@dbs +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from SCHEMATA +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@schemata +POSTHOOK: Input: sys@dbs +#### A masked pattern was here #### +3 +PREHOOK: query: select * from TABLES order by TABLE_SCHEMA, TABLE_NAME +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@tables +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select * from TABLES order by TABLE_SCHEMA, TABLE_NAME +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@tables +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +default default alltypesorc BASE_TABLE +default default cbo_t1 BASE_TABLE +default default cbo_t2 BASE_TABLE +default default cbo_t3 BASE_TABLE +default default lineitem BASE_TABLE +default default part BASE_TABLE +default default src BASE_TABLE +default default src1 BASE_TABLE +default default src_buck BASE_TABLE +default default src_cbo BASE_TABLE +default default src_json BASE_TABLE +default default src_sequencefile BASE_TABLE +default default src_skew BASE_TABLE +default default src_thrift BASE_TABLE +default default srcbucket BASE_TABLE +default default srcbucket2 BASE_TABLE +default default srcpart BASE_TABLE +default information_schema column_privileges VIEW +default information_schema columns VIEW +default information_schema schemata VIEW +default information_schema table_privileges VIEW +default information_schema tables VIEW +default information_schema views VIEW +default sys bucketing_cols BASE_TABLE +default sys cds BASE_TABLE +default sys columns_v2 BASE_TABLE +default sys database_params BASE_TABLE +default sys db_privs BASE_TABLE +default sys dbs BASE_TABLE +default sys funcs BASE_TABLE +default sys global_privs BASE_TABLE +default sys idxs BASE_TABLE +default sys index_params BASE_TABLE +default sys key_constraints BASE_TABLE +default sys part_col_privs BASE_TABLE +default sys part_col_stats BASE_TABLE +default sys part_privs BASE_TABLE +default sys partition_key_vals BASE_TABLE +default sys partition_keys BASE_TABLE +default sys partition_params BASE_TABLE +default sys partitions BASE_TABLE +default sys role_map BASE_TABLE +default sys roles BASE_TABLE +default sys sd_params BASE_TABLE +default sys sds BASE_TABLE +default sys sequence_table BASE_TABLE +default sys serde_params BASE_TABLE +default sys serdes BASE_TABLE +default sys skewed_col_names BASE_TABLE +default sys skewed_col_value_loc_map BASE_TABLE +default sys skewed_string_list BASE_TABLE +default sys skewed_string_list_values BASE_TABLE +default sys skewed_values BASE_TABLE +default sys sort_cols BASE_TABLE +default sys tab_col_stats BASE_TABLE +default sys table_params BASE_TABLE +default sys tbl_col_privs BASE_TABLE +default sys tbl_privs BASE_TABLE +default sys tbls BASE_TABLE +default sys version BASE_TABLE +PREHOOK: query: select * from TABLE_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME limit 10 +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@table_privileges +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbl_privs +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select * from TABLE_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME limit 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@table_privileges +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbl_privs +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +hive_test_user hive_test_user default default alltypesorc UPDATE true NULL +hive_test_user hive_test_user default default alltypesorc INSERT true NULL +hive_test_user hive_test_user default default alltypesorc SELECT true NULL +hive_test_user hive_test_user default default alltypesorc DELETE true NULL +hive_test_user hive_test_user default default cbo_t1 DELETE true NULL +hive_test_user hive_test_user default default cbo_t1 INSERT true NULL +hive_test_user hive_test_user default default cbo_t1 UPDATE true NULL +hive_test_user hive_test_user default default cbo_t1 SELECT true NULL +hive_test_user hive_test_user default default cbo_t2 SELECT true NULL +hive_test_user hive_test_user default default cbo_t2 INSERT true NULL +PREHOOK: query: select * from COLUMNS order by TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION limit 10 +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@columns +PREHOOK: Input: sys@columns_v2 +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@sds +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select * from COLUMNS order by TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION limit 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@columns +POSTHOOK: Input: sys@columns_v2 +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@sds +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +default default alltypesorc ctinyint 0 NULL true tinyint NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc csmallint 1 NULL true smallint NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cboolean1 10 NULL true boolean NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cboolean2 11 NULL true boolean NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cint 2 NULL true int NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cbigint 3 NULL true bigint NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cfloat 4 NULL true float NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cdouble 5 NULL true double NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cstring1 6 NULL true string NULL NULL NULL NULL NULL NULL NULL +default default alltypesorc cstring2 7 NULL true string NULL NULL NULL NULL NULL NULL NULL +Warning: Shuffle Join MERGEJOIN[89][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product +PREHOOK: query: select * from COLUMN_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME limit 10 +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@column_privileges +PREHOOK: Input: sys@columns_v2 +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@sds +PREHOOK: Input: sys@tbl_privs +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select * from COLUMN_PRIVILEGES order by GRANTOR, GRANTEE, TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME limit 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@column_privileges +POSTHOOK: Input: sys@columns_v2 +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@sds +POSTHOOK: Input: sys@tbl_privs +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +hive_test_user hive_test_user default default alltypesorc DELETE ctimestamp1 true NULL +hive_test_user hive_test_user default default alltypesorc DELETE csmallint true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cint true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cboolean1 true NULL +hive_test_user hive_test_user default default alltypesorc DELETE ctimestamp2 true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cfloat true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cbigint true NULL +hive_test_user hive_test_user default default alltypesorc DELETE ctinyint true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cstring2 true NULL +hive_test_user hive_test_user default default alltypesorc DELETE cstring1 true NULL +PREHOOK: query: select TABLE_SCHEMA, TABLE_NAME from views order by TABLE_SCHEMA, TABLE_NAME +PREHOOK: type: QUERY +PREHOOK: Input: information_schema@views +PREHOOK: Input: sys@dbs +PREHOOK: Input: sys@tbls +#### A masked pattern was here #### +POSTHOOK: query: select TABLE_SCHEMA, TABLE_NAME from views order by TABLE_SCHEMA, TABLE_NAME +POSTHOOK: type: QUERY +POSTHOOK: Input: information_schema@views +POSTHOOK: Input: sys@dbs +POSTHOOK: Input: sys@tbls +#### A masked pattern was here #### +information_schema column_privileges +information_schema columns +information_schema schemata +information_schema table_privileges +information_schema tables +information_schema views