import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeCreateTable(PreCreateTableEvent context)
    throws InvalidOperationException, MetaException {
  HierarcyBuilder inputBuilder = new HierarcyBuilder();
  inputBuilder.addDbToOutput(getAuthServer(), context.getTable().getDbName());
  HierarcyBuilder outputBuilder = new HierarcyBuilder();
  outputBuilder.addDbToOutput(getAuthServer(), context.getTable().getDbName());

  if (!StringUtils.isEmpty(context.getTable().getSd().getLocation())) {
    String uriPath;
    try {
      uriPath = PathUtils.parseDFSURI(warehouseDir,
          getSdLocation(context.getTable().getSd()));
    } catch(URISyntaxException e) {
      throw new MetaException(e.getMessage());
    }
    inputBuilder.addUriToOutput(getAuthServer(), uriPath, warehouseDir);
  }
  authorizeMetastoreAccess(HiveOperation.CREATETABLE, inputBuilder.build(),
      outputBuilder.build());
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
static void throwExceptionIfIncompatibleColTypeChange(
    List<FieldSchema> oldCols, List<FieldSchema> newCols)
    throws InvalidOperationException {

  List<String> incompatibleCols = new ArrayList<String>();
  int maxCols = Math.min(oldCols.size(), newCols.size());
  for (int i = 0; i < maxCols; i++) {
    if (!areColTypesCompatible(oldCols.get(i).getType(), newCols.get(i).getType())) {
      incompatibleCols.add(newCols.get(i).getName());
    }
  }
  if (!incompatibleCols.isEmpty()) {
    throw new InvalidOperationException(
        "The following columns have types incompatible with the existing " +
        "columns in their respective positions :\n" +
        Joiner.on(',').join(incompatibleCols)
      );
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
static void throwExceptionIfColAddedDeletedInMiddle(
    List<FieldSchema> oldCols, List<FieldSchema> newCols)
    throws InvalidOperationException {

  if (oldCols.size() == newCols.size()) {
    // Nothing to do since there were no columns added or removed.
    return;
  }

  int maxCols = Math.min(oldCols.size(), newCols.size());
  for (int i = 0; i < maxCols; i++) {
    String oldColName = oldCols.get(i).getName();
    String newColName = newCols.get(i).getName();
    if (!oldColName.equals(newColName)) {
      throw new InvalidOperationException(
          "You can only add/remove columns from the end of a table." +
          "If that is indeed what you are doing here, you are seeing this " +
          "error because you are renaming a column at the same time. " +
          "Please do the rename in a separate DDL operation." +
          "Problematic columns: " +
          "Old Table: " + oldColName + ", " +
          "New Table: " + newColName
        );
    }
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void drop_database() throws NoSuchObjectException, InvalidOperationException, MetaException, TException {
  when(primaryMapping.transformInboundDatabaseName(DB_P)).thenReturn("inbound");
  handler.drop_database(DB_P, false, false);
  verify(primaryMapping).checkWritePermissions(DB_P);
  verify(primaryClient).drop_database("inbound", false, false);
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void get_table_objects_by_name()
  throws MetaException, InvalidOperationException, UnknownDBException, TException {
  when(primaryMapping.transformInboundDatabaseName(DB_P)).thenReturn("inbound");
  Table table = new Table();
  Table outbound = new Table();
  when(primaryClient.get_table_objects_by_name("inbound", Lists.newArrayList("table")))
      .thenReturn(Lists.newArrayList(table));
  when(primaryMapping.transformOutboundTable(table)).thenReturn(outbound);
  List<Table> result = handler.get_table_objects_by_name(DB_P, Lists.newArrayList("table"));
  List<Table> expected = Lists.newArrayList(outbound);
  assertThat(result, is(expected));
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void get_table_names_by_filter()
  throws MetaException, InvalidOperationException, UnknownDBException, TException {
  when(primaryMapping.transformInboundDatabaseName(DB_P)).thenReturn("inbound");
  List<String> tables = Lists.newArrayList("table1");
  when(primaryClient.get_table_names_by_filter("inbound", "*", (short) 2)).thenReturn(tables);
  List<String> result = handler.get_table_names_by_filter(DB_P, "*", (short) 2);
  assertThat(result, is(tables));
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void alter_table() throws InvalidOperationException, MetaException, TException {
  Table table = new Table();
  table.setDbName(DB_P);
  Table inbound = new Table();
  when(primaryMapping.transformInboundDatabaseName(DB_P)).thenReturn("inbound");
  when(primaryMapping.transformInboundTable(table)).thenReturn(inbound);
  handler.alter_table(DB_P, "table", table);
  verify(primaryMapping, times(2)).checkWritePermissions(DB_P);
  verify(primaryClient).alter_table("inbound", "table", inbound);
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void alter_table_with_environment_context() throws InvalidOperationException, MetaException, TException {
  EnvironmentContext environmentContext = new EnvironmentContext();
  Table table = new Table();
  table.setDbName(DB_P);
  Table inbound = new Table();
  when(primaryMapping.transformInboundDatabaseName(DB_P)).thenReturn("inbound");
  when(primaryMapping.transformInboundTable(table)).thenReturn(inbound);
  handler.alter_table_with_environment_context(DB_P, "table", table, environmentContext);
  verify(primaryMapping, times(2)).checkWritePermissions(DB_P);
  verify(primaryClient).alter_table_with_environment_context("inbound", "table", inbound, environmentContext);
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Test
public void get_table_objects_by_name_req()
  throws MetaException, InvalidOperationException, UnknownDBException, TException {
  Table table0 = new Table();
  table0.setDbName(DB_P);
  table0.setTableName("table0");
  Table table1 = new Table();
  table1.setDbName(DB_P);
  table1.setTableName("table1");
  GetTablesRequest request = new GetTablesRequest(DB_P);
  request.setTblNames(Arrays.asList(table0.getTableName(), table1.getTableName()));
  GetTablesResult response = new GetTablesResult(Arrays.asList(table0, table1));
  when(primaryClient.get_table_objects_by_name_req(request)).thenReturn(response);
  when(primaryMapping.transformInboundGetTablesRequest(request)).thenReturn(request);
  when(primaryMapping.transformOutboundGetTablesResult(response)).thenReturn(response);
  GetTablesResult result = handler.get_table_objects_by_name_req(request);
  assertThat(result.getTables().size(), is(2));
  assertThat(result.getTables().get(0).getDbName(), is(DB_P));
  assertThat(result.getTables().get(0).getTableName(), is("table0"));
  assertThat(result.getTables().get(1).getDbName(), is(DB_P));
  assertThat(result.getTables().get(1).getTableName(), is("table1"));
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
public void updatePartitions(String factOrDimtableName, String storageName,
  Map<UpdatePeriod, List<Partition>> partitions) throws HiveException, InvalidOperationException, LensException {
  for (Map.Entry entry : partitions.entrySet()) {
    List<Partition> partitionsToAlter = Lists.newArrayList();
    partitionsToAlter.addAll((List<Partition>) entry.getValue());
    String storageTableName = getStorageTableName(factOrDimtableName, storageName, (UpdatePeriod) entry.getKey());
    partitionsToAlter.addAll(
      getAllLatestPartsEquivalentTo(factOrDimtableName, storageTableName, (List<Partition>) entry.getValue()));
    getStorage(storageName).updatePartitions(storageTableName, getClient(), factOrDimtableName, partitionsToAlter);
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
public void alterHiveTable(String table, Table hiveTable) throws HiveException, LensException {
  try {
    getClient().alterTable(table, hiveTable, null);
  } catch (InvalidOperationException e) {
    throw new HiveException(e);
  }
  if (enableCaching) {
    // refresh the table in cache
    refreshTable(table);
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
/**
 * Update existing partitions
 * @param client          hive client instance
 * @param fact            fact name
 * @param partitions      partitions to be updated
 * @throws InvalidOperationException
 * @throws HiveException
 */
public void updatePartitions(String storageTable, Hive client, String fact, List<Partition> partitions)
  throws InvalidOperationException, HiveException {
  boolean success = false;
  try {
    client.alterPartitions(storageTable, partitions, null);
    success = true;
  } finally {
    if (success) {
      commitUpdatePartition(partitions);
    } else {
      rollbackUpdatePartition(partitions);
    }
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
@Override
public List<String> listTableNamesByFilter(String dbName, String filter,
    short maxTables) throws InvalidOperationException, UnknownDBException,
    TException {
  return filterTables(dbName,
      super.listTableNamesByFilter(dbName, filter, maxTables));
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
/**
 * Main listener callback which is the entry point for Sentry
 */
@Override
public void onEvent(PreEventContext context) throws MetaException,
    NoSuchObjectException, InvalidOperationException {

  if (!needsAuthorization(getUserName())) {
    return;
  }
  switch (context.getEventType()) {
  case CREATE_TABLE:
    authorizeCreateTable((PreCreateTableEvent) context);
    break;
  case DROP_TABLE:
    authorizeDropTable((PreDropTableEvent) context);
    break;
  case ALTER_TABLE:
    authorizeAlterTable((PreAlterTableEvent) context);
    break;
  case ADD_PARTITION:
    authorizeAddPartition((PreAddPartitionEvent) context);
    break;
  case DROP_PARTITION:
    authorizeDropPartition((PreDropPartitionEvent) context);
    break;
  case ALTER_PARTITION:
    authorizeAlterPartition((PreAlterPartitionEvent) context);
    break;
  case CREATE_DATABASE:
    authorizeCreateDatabase();
    break;
  case DROP_DATABASE:
    authorizeDropDatabase((PreDropDatabaseEvent) context);
    break;
  case LOAD_PARTITION_DONE:
    // noop for now
    break;
  default:
    break;
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeDropDatabase(PreDropDatabaseEvent context)
      throws InvalidOperationException, MetaException {
    authorizeMetastoreAccess(HiveOperation.DROPDATABASE,
 new HierarcyBuilder()
.addDbToOutput(getAuthServer(),
            context.getDatabase().getName()).build(),
        new HierarcyBuilder().addDbToOutput(getAuthServer(),
            context.getDatabase().getName()).build());
  }
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeDropTable(PreDropTableEvent context)
    throws InvalidOperationException, MetaException {
  authorizeMetastoreAccess(
      HiveOperation.DROPTABLE,
      new HierarcyBuilder().addTableToOutput(getAuthServer(),
          context.getTable().getDbName(), context.getTable().getTableName())
          .build(),
      new HierarcyBuilder().addTableToOutput(getAuthServer(),
          context.getTable().getDbName(), context.getTable().getTableName())
          .build());
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeAlterTable(PreAlterTableEvent context)
    throws InvalidOperationException, MetaException {
  /*
   * There are multiple alter table options and it's tricky to figure which is
   * attempted here. Currently all alter table needs full level privilege
   * except the for setting location which also needs a privile on URI. Hence
   * we set initially set the operation to ALTERTABLE_ADDCOLS. If the client
   * has specified the location, then change to ALTERTABLE_LOCATION
   */
  HiveOperation operation = HiveOperation.ALTERTABLE_ADDCOLS;
  HierarcyBuilder inputBuilder = new HierarcyBuilder();
  inputBuilder.addTableToOutput(getAuthServer(), context.getOldTable()
      .getDbName(), context.getOldTable().getTableName());
  HierarcyBuilder outputBuilder = new HierarcyBuilder();
  outputBuilder.addTableToOutput(getAuthServer(), context.getOldTable()
      .getDbName(), context.getOldTable().getTableName());

  // if the operation requires location change, then add URI privilege check
  String oldLocationUri;
  String newLocationUri;
  try {
    oldLocationUri = PathUtils.parseDFSURI(warehouseDir,
        getSdLocation(context.getOldTable().getSd()));
    newLocationUri = PathUtils.parseDFSURI(warehouseDir,
        getSdLocation(context.getNewTable().getSd()));
  } catch (URISyntaxException e) {
    throw new MetaException(e.getMessage());
  }
  if (oldLocationUri.compareTo(newLocationUri) != 0) {
    outputBuilder.addUriToOutput(getAuthServer(), newLocationUri,
        warehouseDir);
    operation = HiveOperation.ALTERTABLE_LOCATION;
  }
  authorizeMetastoreAccess(
      operation,
      inputBuilder.build(), outputBuilder.build());

}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeAddPartition(PreAddPartitionEvent context)
    throws InvalidOperationException, MetaException, NoSuchObjectException {
  for (Partition mapiPart : context.getPartitions()) {
   HierarcyBuilder inputBuilder = new HierarcyBuilder();
    inputBuilder.addTableToOutput(getAuthServer(), mapiPart
        .getDbName(), mapiPart.getTableName());
    HierarcyBuilder outputBuilder = new HierarcyBuilder();
   outputBuilder.addTableToOutput(getAuthServer(), mapiPart
       .getDbName(), mapiPart.getTableName());
   // check if we need to validate URI permissions when storage location is
   // non-default, ie something not under the parent table

    String partitionLocation = null;
    if (mapiPart.isSetSd()) {
      partitionLocation = mapiPart.getSd().getLocation();
   }
   if (!StringUtils.isEmpty(partitionLocation)) {
     String tableLocation = context
         .getHandler()
         .get_table(mapiPart.getDbName(),
             mapiPart.getTableName()).getSd().getLocation();
     String uriPath;
     try {
       uriPath = PathUtils.parseDFSURI(warehouseDir, mapiPart
           .getSd().getLocation());
     } catch (URISyntaxException e) {
       throw new MetaException(e.getMessage());
     }
      if (!partitionLocation.equals(tableLocation) &&
          !partitionLocation.startsWith(tableLocation + File.separator)) {
        outputBuilder.addUriToOutput(getAuthServer(), uriPath, warehouseDir);
     }
   }
    authorizeMetastoreAccess(HiveOperation.ALTERTABLE_ADDPARTS,
       inputBuilder.build(), outputBuilder.build());
  }
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
protected void authorizeDropPartition(PreDropPartitionEvent context)
    throws InvalidOperationException, MetaException {
  authorizeMetastoreAccess(
      HiveOperation.ALTERTABLE_DROPPARTS,
      new HierarcyBuilder().addTableToOutput(getAuthServer(),
          context.getPartition().getDbName(),
          context.getPartition().getTableName()).build(),
      new HierarcyBuilder().addTableToOutput(getAuthServer(),
          context.getPartition().getDbName(),
          context.getPartition().getTableName()).build());
}
 

import org.apache.hadoop.hive.metastore.api.InvalidOperationException; //导入依赖的package包/类
private void authorizeAlterPartition(PreAlterPartitionEvent context)
    throws InvalidOperationException, MetaException, NoSuchObjectException {
  /*
   * There are multiple alter partition options and it's tricky to figure out
   * which is attempted here. Currently all alter partition need full level
   * privilege except the for setting location which also needs a privilege on
   * URI. Currently we don't try to distinguish the operation type. All alter
   * partitions are treated as set-location
   */
  HierarcyBuilder inputBuilder = new HierarcyBuilder().addTableToOutput(
      getAuthServer(), context.getDbName(), context.getTableName());
  HierarcyBuilder outputBuilder = new HierarcyBuilder().addTableToOutput(
      getAuthServer(), context.getDbName(), context.getTableName());

  Partition partition = context.getNewPartition();
  String partitionLocation = getSdLocation(partition.getSd());
  if (!StringUtils.isEmpty(partitionLocation)) {
    String tableLocation = context.getHandler().get_table(
        partition.getDbName(), partition.getTableName()).getSd().getLocation();

    String uriPath;
    try {
      uriPath = PathUtils.parseDFSURI(warehouseDir, partitionLocation);
      } catch (URISyntaxException e) {
      throw new MetaException(e.getMessage());
    }
    if (!partitionLocation.startsWith(tableLocation + File.separator)) {
      outputBuilder.addUriToOutput(getAuthServer(), uriPath, warehouseDir);
    }
  }
  authorizeMetastoreAccess(
      HiveOperation.ALTERPARTITION_LOCATION,
      inputBuilder.build(), outputBuilder.build());
}