org.apache.hadoop.hive.metastore.api.UnknownDBException Java Examples

@Override
// 1.x client doesn't support filtering tables by type, so here we need to get all tables and filter by ourselves
public List<String> getViews(IMetaStoreClient client, String databaseName) throws UnknownDBException, TException {
	// We don't have to use reflection here because client.getAllTables(String) is supposed to be there for
	// all versions.
	List<String> tableNames = client.getAllTables(databaseName);
	List<String> views = new ArrayList<>();
	for (String name : tableNames) {
		Table table = client.getTable(databaseName, name);
		String viewDef = table.getViewOriginalText();
		if (viewDef != null && !viewDef.isEmpty()) {
			views.add(table.getTableName());
		}
	}
	return views;
}
 

@Override
public List<String> getViews(IMetaStoreClient client, String databaseName) throws UnknownDBException, TException {
	try {
		Method method = client.getClass().getMethod("getTables", String.class, String.class, TableType.class);
		return (List<String>) method.invoke(client, databaseName, null, TableType.VIRTUAL_VIEW);
	} catch (InvocationTargetException ite) {
		Throwable targetEx = ite.getTargetException();
		if (targetEx instanceof TException) {
			throw (TException) targetEx;
		} else {
			throw new CatalogException(String.format("Failed to get views for %s", databaseName), targetEx);
		}
	} catch (NoSuchMethodException | IllegalAccessException e) {
		throw new CatalogException(String.format("Failed to get views for %s", databaseName), e);
	}
}
 

@Override
// 1.x client doesn't support filtering tables by type, so here we need to get all tables and filter by ourselves
public List<String> getViews(IMetaStoreClient client, String databaseName) throws UnknownDBException, TException {
	// We don't have to use reflection here because client.getAllTables(String) is supposed to be there for
	// all versions.
	List<String> tableNames = client.getAllTables(databaseName);
	List<String> views = new ArrayList<>();
	for (String name : tableNames) {
		Table table = client.getTable(databaseName, name);
		String viewDef = table.getViewOriginalText();
		if (viewDef != null && !viewDef.isEmpty()) {
			views.add(table.getTableName());
		}
	}
	return views;
}
 

@Override
public List<String> getViews(IMetaStoreClient client, String databaseName) throws UnknownDBException, TException {
	try {
		Method method = client.getClass().getMethod("getTables", String.class, String.class, TableType.class);
		return (List<String>) method.invoke(client, databaseName, null, TableType.VIRTUAL_VIEW);
	} catch (InvocationTargetException ite) {
		Throwable targetEx = ite.getTargetException();
		if (targetEx instanceof TException) {
			throw (TException) targetEx;
		} else {
			throw new CatalogException(String.format("Failed to get views for %s", databaseName), targetEx);
		}
	} catch (NoSuchMethodException | IllegalAccessException e) {
		throw new CatalogException(String.format("Failed to get views for %s", databaseName), e);
	}
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public GetTablesResult get_table_objects_by_name_req(GetTablesRequest req)
    throws MetaException, InvalidOperationException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(req.getDbName());
  GetTablesResult result = mapping
      .getClient()
      .get_table_objects_by_name_req(mapping.transformInboundGetTablesRequest(req));
  return mapping.transformOutboundGetTablesResult(result);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<FieldSchema> get_fields(String db_name, String table_name)
    throws MetaException, UnknownTableException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  return mapping.getClient().get_fields(mapping.transformInboundDatabaseName(db_name), table_name);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<FieldSchema> get_schema(String db_name, String table_name)
    throws MetaException, UnknownTableException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  return mapping.getClient().get_schema(mapping.transformInboundDatabaseName(db_name), table_name);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<Table> get_table_objects_by_name(String dbname, List<String> tbl_names)
    throws MetaException, InvalidOperationException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(dbname);
  List<Table> tables = mapping
      .getClient()
      .get_table_objects_by_name(mapping.transformInboundDatabaseName(dbname), tbl_names);
  List<Table> outboundTables = new ArrayList<>(tables.size());
  for (Table table : tables) {
    outboundTables.add(mapping.transformOutboundTable(table));
  }
  return outboundTables;
}
 

@Override
public List<org.apache.hadoop.hive.metastore.api.Table> getTableObjectsByName(String dbName, List<String> tableNames) throws MetaException,
      InvalidOperationException, UnknownDBException, TException {
  List<org.apache.hadoop.hive.metastore.api.Table> hiveTables = Lists.newArrayList();
  for(String tableName : tableNames) {
    hiveTables.add(getTable(dbName, tableName));
  }

  return hiveTables;
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<String> get_table_names_by_filter(String dbname, String filter, short max_tables)
    throws MetaException, InvalidOperationException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(dbname);
  return mapping
      .getClient()
      .get_table_names_by_filter(mapping.transformInboundDatabaseName(dbname), filter, max_tables);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public void markPartitionForEvent(
    String db_name,
    String tbl_name,
    Map<String, String> part_vals,
    PartitionEventType eventType)
    throws MetaException, NoSuchObjectException, UnknownDBException, UnknownTableException, UnknownPartitionException,
    InvalidPartitionException, TException {
  DatabaseMapping mapping = checkWritePermissions(db_name);
  mapping
      .getClient()
      .markPartitionForEvent(mapping.transformInboundDatabaseName(db_name), tbl_name, part_vals, eventType);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean isPartitionMarkedForEvent(
    String db_name,
    String tbl_name,
    Map<String, String> part_vals,
    PartitionEventType eventType)
    throws MetaException, NoSuchObjectException, UnknownDBException, UnknownTableException, UnknownPartitionException,
    InvalidPartitionException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  return mapping
      .getClient()
      .isPartitionMarkedForEvent(mapping.transformInboundDatabaseName(db_name), tbl_name, part_vals, eventType);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<FieldSchema> get_fields_with_environment_context(
    String db_name,
    String table_name,
    EnvironmentContext environment_context)
    throws MetaException, UnknownTableException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  return mapping
      .getClient()
      .get_fields_with_environment_context(mapping.transformInboundDatabaseName(db_name), table_name,
          environment_context);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<FieldSchema> get_schema_with_environment_context(
    String db_name,
    String table_name,
    EnvironmentContext environment_context)
    throws MetaException, UnknownTableException, UnknownDBException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  return mapping
      .getClient()
      .get_schema_with_environment_context(mapping.transformInboundDatabaseName(db_name), table_name,
          environment_context);
}
 

@Test (expected = UnknownDBException.class)
public void alterTableInvalidDB() throws Exception {
  String newType = "newType";
  Table newHiveTable = CatalogToHiveConverter.convertTable(getTestTable(), hiveTable.getDbName());
  newHiveTable.setTableName(hiveTable.getTableName());
  newHiveTable.setTableType(newType);
  metastoreClient.createTable(hiveTable);
  metastoreClient.alter_table(invalidDatabase, hiveTable.getTableName(), newHiveTable);
}
 

@Override
public void markPartitionForEvent(
    String dbName,
    String tblName,
    Map<String, String> partKVs,
    PartitionEventType eventType
) throws MetaException, NoSuchObjectException, TException, UnknownTableException, UnknownDBException,
    UnknownPartitionException, InvalidPartitionException {
  glueMetastoreClientDelegate.markPartitionForEvent(dbName, tblName, partKVs, eventType);
}
 

@Override
public void markPartitionForEvent(
    String dbName,
    String tblName,
    Map<String, String> partKVs,
    PartitionEventType eventType
) throws MetaException, NoSuchObjectException, TException, UnknownTableException, UnknownDBException,
    UnknownPartitionException, InvalidPartitionException {
  glueMetastoreClientDelegate.markPartitionForEvent(dbName, tblName, partKVs, eventType);
}
 

@Override
public List<String> listTableNamesByFilter(String dbName, String filter,
    short maxTables) throws InvalidOperationException, UnknownDBException,
    TException {
  return filterTables(dbName,
      super.listTableNamesByFilter(dbName, filter, maxTables));
}
 

@Override
public List<org.apache.hadoop.hive.metastore.api.Table> getTableObjectsByName(String dbName, List<String> tableNames) throws MetaException,
      InvalidOperationException, UnknownDBException, TException {
    List<org.apache.hadoop.hive.metastore.api.Table> hiveTables = Lists.newArrayList();
    for(String tableName : tableNames) {
        hiveTables.add(getTable(dbName, tableName));
    }

    return hiveTables;
}
 

public List<String> getViews(String databaseName) throws UnknownDBException, TException {
	HiveShim hiveShim = HiveShimLoader.loadHiveShim(hiveVersion);
	return hiveShim.getViews(client, databaseName);
}
 

GetTablesResult get_table_objects_by_name_req(GetTablesRequest req)
throws MetaException, InvalidOperationException, UnknownDBException, TException;
 

@Override
public boolean tableExists(String databaseName, String tableName) throws MetaException, TException,
      UnknownDBException {
  return glueMetastoreClientDelegate.tableExists(databaseName, tableName);
}
 

@Override
public GetTablesResult get_table_objects_by_name_req(GetTablesRequest req)
  throws MetaException, InvalidOperationException, UnknownDBException, TException {
  List<Table> tables = client.get_table_objects_by_name(req.getDbName(), req.getTblNames());
  return new GetTablesResult(tables);
}
 

public List<String> getAllTables(String databaseName) throws MetaException, TException, UnknownDBException {
	return client.getAllTables(databaseName);
}
 

public boolean tableExists(String databaseName, String tableName)
		throws MetaException, TException, UnknownDBException {
	return client.tableExists(databaseName, tableName);
}
 

public List<String> getViews(String databaseName) throws UnknownDBException, TException {
	return hiveShim.getViews(client, databaseName);
}
 

@Override
public List<Table> getTableObjectsByName(String dbname, List<String> tableNames)
    throws MetaException, UnknownDBException {
  return super.getTableObjectsByName(dbname, filterTables(dbname, tableNames));
}
 

@Override
public List<Table> getTableObjectsByName(String dbname, List<String> tableNames)
    throws MetaException, UnknownDBException {
  return super.getTableObjectsByName(dbname, filterTables(dbname, tableNames));
}
 

@Override
public List<String> getAllTables(String dbname) throws MetaException, TException, UnknownDBException {
  return getTables(dbname, ".*");
}
 

@Override
public List<FieldSchema> getFields(String db, String tableName) throws MetaException, TException,
      UnknownTableException, UnknownDBException {
    return glueMetastoreClientDelegate.getFields(db, tableName);
}