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

private List<Partition> dropPartitionsCoreNoTxn(
        final RawStore ms, final Table tbl, final List<List<String>> partsValues)
        throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException {
    final List<Partition> deletedPartitions = new ArrayList<Partition>();
    Partition part = null;
    final String dbName = tbl.getDbName();
    final String tblName = tbl.getTableName();

    for (List<String> partValues : partsValues) {
        part = ms.getPartition(dbName, tblName, partValues);
        if (part == null) {
            throw new NoSuchObjectException("Partition doesn't exist. "
                    + partValues);
        }
        if (!ms.dropPartition(dbName, tblName, partValues)) {
            throw new MetaException("Unable to drop partition");
        }
        deletedPartitions.add(part);
    }
    return deletedPartitions;
}
 

@Test
public void testDeletePartitionsThrowsInvalidInputException() throws Exception {
  Exception e = new com.amazonaws.services.glue.model.InvalidInputException("foo");
  mockBatchDeleteThrowsException(e);

  List<String> values1 = Lists.newArrayList("val1");
  List<String> values2 = Lists.newArrayList("val2");
  List<Partition> partitions = Lists.newArrayList(
        TestObjects.getTestPartition(NAMESPACE_NAME, TABLE_NAME, values1),
        TestObjects.getTestPartition(NAMESPACE_NAME, TABLE_NAME, values2));
  batchDeletePartitionsHelper = new BatchDeletePartitionsHelper(client, NAMESPACE_NAME, TABLE_NAME, null, partitions);

  batchDeletePartitionsHelper.deletePartitions();
  assertTrue(batchDeletePartitionsHelper.getPartitionsDeleted().isEmpty());
  assertThat(batchDeletePartitionsHelper.getFirstTException(), is(instanceOf(InvalidObjectException.class)));
}
 

@Test
public void testDeletePartitionsWithFailures() throws Exception {
  List<String> values1 = Lists.newArrayList("val1");
  List<String> values2 = Lists.newArrayList("val2");
  Partition partition1 = TestObjects.getTestPartition(NAMESPACE_NAME, TABLE_NAME, values1);
  Partition partition2 = TestObjects.getTestPartition(NAMESPACE_NAME, TABLE_NAME, values2);
  List<Partition> partitions = Lists.newArrayList(partition1, partition2);

  PartitionError error1 = getPartitionError(values1, new EntityNotFoundException("foo error msg"));
  PartitionError error2 = getPartitionError(values2, new InvalidInputException("foo error msg2"));
  mockBatchDeleteWithFailures(Lists.newArrayList(error1, error2));

  batchDeletePartitionsHelper = new BatchDeletePartitionsHelper(client, NAMESPACE_NAME, TABLE_NAME, null, partitions)
        .deletePartitions();

  assertEquals(0, batchDeletePartitionsHelper.getPartitionsDeleted().size());
  assertTrue(batchDeletePartitionsHelper.getFirstTException() instanceof NoSuchObjectException);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public List<Partition> exchange_partitions(
    Map<String, String> partitionSpecs,
    String source_db,
    String source_table_name,
    String dest_db,
    String dest_table_name)
    throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(source_db);
  mapping.checkWritePermissions(dest_db);
  List<Partition> result = mapping
      .getClient()
      .exchange_partitions(partitionSpecs, mapping.transformInboundDatabaseName(source_db), source_table_name,
          mapping.transformInboundDatabaseName(dest_db), dest_table_name);
  return mapping.transformOutboundPartitions(result);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public Partition exchange_partition(
    Map<String, String> partitionSpecs,
    String source_db,
    String source_table_name,
    String dest_db,
    String dest_table_name)
    throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(source_db);
  mapping.checkWritePermissions(dest_db);
  Partition result = mapping
      .getClient()
      .exchange_partition(partitionSpecs, mapping.transformInboundDatabaseName(source_db), source_table_name,
          mapping.transformInboundDatabaseName(dest_db), dest_table_name);
  return mapping.transformOutboundPartition(result);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean update_table_column_statistics(ColumnStatistics stats_obj)
    throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(stats_obj.getStatsDesc().getDbName());
  return mapping.getClient().update_table_column_statistics(mapping.transformInboundColumnStatistics(stats_obj));
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean delete_table_column_statistics(String db_name, String tbl_name, String col_name)
    throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(db_name);
  return mapping
      .getClient()
      .delete_table_column_statistics(mapping.transformInboundDatabaseName(db_name), tbl_name, col_name);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean delete_partition_column_statistics(String db_name, String tbl_name, String part_name, String col_name)
    throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(db_name);
  return mapping
      .getClient()
      .delete_partition_column_statistics(mapping.transformInboundDatabaseName(db_name), tbl_name, part_name,
          col_name);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean set_aggr_stats_for(SetPartitionsStatsRequest request)
    throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, TException {
  if (!request.getColStats().isEmpty()) {
    DatabaseMapping mapping = databaseMappingService
        .databaseMapping(request.getColStats().get(0).getStatsDesc().getDbName());
    for (ColumnStatistics stats : request.getColStats()) {
      mapping.checkWritePermissions(stats.getStatsDesc().getDbName());
    }
    return mapping.getClient().set_aggr_stats_for(mapping.transformInboundSetPartitionStatsRequest(request));
  }
  return false;
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public ColumnStatistics get_partition_column_statistics(
    String db_name,
    String tbl_name,
    String part_name,
    String col_name)
    throws NoSuchObjectException, MetaException, InvalidInputException, InvalidObjectException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  ColumnStatistics result = mapping
      .getClient()
      .get_partition_column_statistics(mapping.transformInboundDatabaseName(db_name), tbl_name, part_name, col_name);
  return mapping.transformOutboundColumnStatistics(result);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public ColumnStatistics get_table_column_statistics(String db_name, String tbl_name, String col_name)
    throws NoSuchObjectException, MetaException, InvalidInputException, InvalidObjectException, TException {
  DatabaseMapping mapping = databaseMappingService.databaseMapping(db_name);
  ColumnStatistics result = mapping
      .getClient()
      .get_table_column_statistics(mapping.transformInboundDatabaseName(db_name), tbl_name, col_name);
  return mapping.transformOutboundColumnStatistics(result);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean update_partition_column_statistics(ColumnStatistics stats_obj)
    throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, TException {
  DatabaseMapping mapping = checkWritePermissions(stats_obj.getStatsDesc().getDbName());
  return mapping.getClient().update_partition_column_statistics(mapping.transformInboundColumnStatistics(stats_obj));
}
 

/**
 * {@inheritDoc}
 */
@Override
public void alter_database(final String dbname, final Database db) throws TException {
    requestWrapper("update_database", new Object[]{db}, () -> {
        if (dbname == null || db == null) {
            throw new InvalidInputException("Invalid database request");
        }
        v1.updateDatabase(catalogName, normalizeIdentifier(dbname),
            DatabaseCreateRequestDto.builder().metadata(db.getParameters()).uri(db.getLocationUri()).build());
        return null;
    });
}
 

public boolean updatePartitionColumnStatistics(ColumnStatistics columnStatistics)
		throws NoSuchObjectException, InvalidObjectException, MetaException, TException, InvalidInputException {
	return client.updatePartitionColumnStatistics(columnStatistics);
}
 

public void dropFunction(String databaseName, String functionName)
		throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, TException {
	client.dropFunction(databaseName, functionName);
}
 

public boolean updateTableColumnStatistics(ColumnStatistics columnStatistics)
		throws NoSuchObjectException, InvalidObjectException, MetaException, TException, InvalidInputException {
	return client.updateTableColumnStatistics(columnStatistics);
}
 

public boolean dropTable(String dbName, String tableName)
    throws MetaException, InvalidObjectException, NoSuchObjectException, InvalidInputException {
  boolean result = rs.dropTable(dbName, tableName);
  return result;
}
 

private boolean addDropPartitionsCore(
        final RawStore ms, final String databaseName, final String tableName, final List<Partition> addParts,
        final List<List<String>> dropParts, final boolean ifNotExists, final EnvironmentContext envContext)
        throws MetaException, InvalidObjectException, NoSuchObjectException, AlreadyExistsException,
        IOException, InvalidInputException, TException {
    logInfo("add_drop_partitions : db=" + databaseName + " tbl=" + tableName);
    boolean success = false;
    Table tbl = null;
    // Ensures that the list doesn't have dups, and keeps track of directories we have created.
    final Map<PartValEqWrapper, Boolean> addedPartitions = new HashMap<PartValEqWrapper, Boolean>();
    final List<Partition> existingParts = new ArrayList<Partition>();
    List<Partition> result = null;
    try {
        ms.openTransaction();
        tbl = get_table(databaseName, tableName);
        if (tbl == null) {
            throw new NoSuchObjectException("Unable to add partitions because "
                    + "database or table " + databaseName + "." + tableName + " does not exist");
        }
        // Drop the parts first
        dropPartitionsCoreNoTxn(ms, tbl, dropParts);

        // Now add the parts
        result = addPartitionsCoreNoTxn(ms, tbl, addParts, ifNotExists, addedPartitions, existingParts);

        if (!result.isEmpty() && !ms.addPartitions(databaseName, tableName, result)) {
            throw new MetaException("Unable to add partitions");
        }
        success = ms.commitTransaction();
    } finally {
        if (!success) {
            ms.rollbackTransaction();
            // Clean up the result of adding partitions
            for (Map.Entry<PartValEqWrapper, Boolean> e : addedPartitions.entrySet()) {
                if (e.getValue()) {
                    getWh().deleteDir(new Path(e.getKey().partition.getSd().getLocation()), true);
                    // we just created this directory - it's not a case of pre-creation, so we nuke
                }
            }
        }
    }
    return success;
}
 

public boolean updatePartitionColumnStatistics(ColumnStatistics columnStatistics)
		throws NoSuchObjectException, InvalidObjectException, MetaException, TException, InvalidInputException {
	return client.updatePartitionColumnStatistics(columnStatistics);
}
 

public boolean updateTableColumnStatistics(ColumnStatistics columnStatistics)
		throws NoSuchObjectException, InvalidObjectException, MetaException, TException, InvalidInputException {
	return client.updateTableColumnStatistics(columnStatistics);
}
 

public void dropFunction(String databaseName, String functionName)
		throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, TException {
	client.dropFunction(databaseName, functionName);
}
 

public boolean dropPartition(String dbName, String tableName, List<String> partVals)
    throws MetaException, NoSuchObjectException, InvalidObjectException,
    InvalidInputException {
  boolean result = rs.dropPartition(dbName, tableName, partVals);
  return result;
}