@Override
  public boolean revokePrivileges(PrivilegeBag privileges, boolean grantOption)
      throws InvalidObjectException, MetaException, NoSuchObjectException {
    boolean committed = false;
    try {
      openTransaction();
      List<Object> persistentObjs = new ArrayList<>();

      List<HiveObjectPrivilege> privilegeList = privileges.getPrivileges();


      if (CollectionUtils.isNotEmpty(privilegeList)) {
        Iterator<HiveObjectPrivilege> privIter = privilegeList.iterator();

        while (privIter.hasNext()) {
          HiveObjectPrivilege privDef = privIter.next();
          HiveObjectRef hiveObject = privDef.getHiveObject();
          String privilegeStr = privDef.getGrantInfo().getPrivilege();
          if (privilegeStr == null || privilegeStr.trim().equals("")) {
            continue;
          }
          String[] privs = privilegeStr.split(",");
          String userName = privDef.getPrincipalName();
          PrincipalType principalType = privDef.getPrincipalType();

          String catName = hiveObject.isSetCatName() ? hiveObject.getCatName() :
              getDefaultCatalog(conf);
          if (hiveObject.getObjectType() == HiveObjectType.GLOBAL) {
            List<MGlobalPrivilege> mSecUser = this.listPrincipalMGlobalGrants(
                userName, principalType);
            boolean found = false;
            for (String privilege : privs) {
              for (MGlobalPrivilege userGrant : mSecUser) {
                String userGrantPrivs = userGrant.getPrivilege();
                if (privilege.equals(userGrantPrivs)) {
                  found = true;
                  if (grantOption) {
                    if (userGrant.getGrantOption()) {
                      userGrant.setGrantOption(false);
                    } else {
                      throw new MetaException("User " + userName
                          + " does not have grant option with privilege " + privilege);
                    }
                  }
                  persistentObjs.add(userGrant);
                  break;
                }
              }
              if (!found) {
                throw new InvalidObjectException(
                    "No user grant found for privileges " + privilege);
              }
            }

          } else if (hiveObject.getObjectType() == HiveObjectType.DATABASE) {
            MDatabase dbObj = getMDatabase(catName, hiveObject.getDbName());
            String db = hiveObject.getDbName();
            boolean found = false;
            List<MDBPrivilege> dbGrants = this.listPrincipalMDBGrants(
                userName, principalType, catName, db);
            for (String privilege : privs) {
              for (MDBPrivilege dbGrant : dbGrants) {
                String dbGrantPriv = dbGrant.getPrivilege();
                if (privilege.equals(dbGrantPriv)) {
                  found = true;
                  if (grantOption) {
                    if (dbGrant.getGrantOption()) {
                      dbGrant.setGrantOption(false);
                    } else {
                      throw new MetaException("User " + userName
                          + " does not have grant option with privilege " + privilege);
                    }
                  }
                  persistentObjs.add(dbGrant);
                  break;
                }
              }
              if (!found) {
                throw new InvalidObjectException(
                    "No database grant found for privileges " + privilege
                        + " on database " + db);
              }
            }
          } else if (hiveObject.getObjectType() == HiveObjectType.DATACONNECTOR) {
            MDataConnector dCObj = getMDataConnector(hiveObject.getObjectName());
            String dc = hiveObject.getObjectName();
            boolean found = false;
            List<MDCPrivilege> dcGrants = this.listPrincipalMDCGrants(
                    userName, principalType, catName, dc);
            for (String privilege : privs) {
              for (MDCPrivilege dcGrant : dcGrants) {
                String dcGrantPriv = dcGrant.getPrivilege();
                if (privilege.equals(dcGrantPriv)) {
                  found = true;
                  if (grantOption) {
                    if (dcGrant.getGrantOption()) {
                      dcGrant.setGrantOption(false);
                    } else {
                      throw new MetaException("User " + userName
                              + " does not have grant option with privilege " + privilege);
                    }
                  }
                  persistentObjs.add(dcGrant);
                  break;
                }
              }
              if (!found) {
                throw new InvalidObjectException(
                        "No dataconnector grant found for privileges " + privilege
                                + " on data connector " + dc);
              }
            }
          } else if (hiveObject.getObjectType() == HiveObjectType.TABLE) {
            boolean found = false;
            List<MTablePrivilege> tableGrants = this
                .listAllMTableGrants(userName, principalType,
                    catName, hiveObject.getDbName(), hiveObject.getObjectName());
            for (String privilege : privs) {
              for (MTablePrivilege tabGrant : tableGrants) {
                String tableGrantPriv = tabGrant.getPrivilege();
                if (privilege.equalsIgnoreCase(tableGrantPriv)) {
                  found = true;
                  if (grantOption) {
                    if (tabGrant.getGrantOption()) {
                      tabGrant.setGrantOption(false);
                    } else {
                      throw new MetaException("User " + userName
                          + " does not have grant option with privilege " + privilege);
                    }
                  }
                  persistentObjs.add(tabGrant);
                  break;
                }
              }
              if (!found) {
                throw new InvalidObjectException("No grant (" + privilege
                    + ") found " + " on table " + hiveObject.getObjectName()
                    + ", database is " + hiveObject.getDbName());
              }
            }
          } else if (hiveObject.getObjectType() == HiveObjectType.PARTITION) {

            boolean found = false;
            Table tabObj =
                this.getTable(catName, hiveObject.getDbName(),
                     hiveObject.getObjectName(), null);
            String partName = null;
            if (hiveObject.getPartValues() != null) {
              partName = Warehouse.makePartName(tabObj.getPartitionKeys(), hiveObject.getPartValues());
            }
            List<MPartitionPrivilege> partitionGrants = this
                .listPrincipalMPartitionGrants(userName, principalType,
                    catName, hiveObject.getDbName(), hiveObject.getObjectName(), partName);
            for (String privilege : privs) {
              for (MPartitionPrivilege partGrant : partitionGrants) {
                String partPriv = partGrant.getPrivilege();
                if (partPriv.equalsIgnoreCase(privilege)) {
                  found = true;
                  if (grantOption) {
                    if (partGrant.getGrantOption()) {
                      partGrant.setGrantOption(false);
                    } else {
                      throw new MetaException("User " + userName
                          + " does not have grant option with privilege " + privilege);
                    }
                  }
                  persistentObjs.add(partGrant);
                  break;
                }
              }
              if (!found) {
                throw new InvalidObjectException("No grant (" + privilege
                    + ") found " + " on table " + tabObj.getTableName()
                    + ", partition is " + partName + ", database is " + tabObj.getDbName());
              }
            }
          } else if (hiveObject.getObjectType() == HiveObjectType.COLUMN) {

            Table tabObj = this.getTable(catName, hiveObject.getDbName(), hiveObject
                .getObjectName(), null);
            String partName = null;
            if (hiveObject.getPartValues() != null) {
              partName = Warehouse.makePartName(tabObj.getPartitionKeys(),
                  hiveObject.getPartValues());
            }

            if (partName != null) {
              List<MPartitionColumnPrivilege> mSecCol = listPrincipalMPartitionColumnGrants(
                  userName, principalType, catName, hiveObject.getDbName(), hiveObject
                      .getObjectName(), partName, hiveObject.getColumnName());
              boolean found = false;
              for (String privilege : privs) {
                for (MPartitionColumnPrivilege col : mSecCol) {
                  String colPriv = col.getPrivilege();
                  if (colPriv.equalsIgnoreCase(privilege)) {
                    found = true;
                    if (grantOption) {
                      if (col.getGrantOption()) {
                        col.setGrantOption(false);
                      } else {
                        throw new MetaException("User " + userName
                            + " does not have grant option with privilege " + privilege);
                      }
                    }
                    persistentObjs.add(col);
                    break;
                  }
                }
                if (!found) {
                  throw new InvalidObjectException("No grant (" + privilege
                      + ") found " + " on table " + tabObj.getTableName()
                      + ", partition is " + partName + ", column name = "
                      + hiveObject.getColumnName() + ", database is "
                      + tabObj.getDbName());
                }
              }
            } else {
              List<MTableColumnPrivilege> mSecCol = listPrincipalMTableColumnGrants(
                  userName, principalType, catName, hiveObject.getDbName(), hiveObject
                      .getObjectName(), hiveObject.getColumnName());
              boolean found = false;
              for (String privilege : privs) {
                for (MTableColumnPrivilege col : mSecCol) {
                  String colPriv = col.getPrivilege();
                  if (colPriv.equalsIgnoreCase(privilege)) {
                    found = true;
                    if (grantOption) {
                      if (col.getGrantOption()) {
                        col.setGrantOption(false);
                      } else {
                        throw new MetaException("User " + userName
                            + " does not have grant option with privilege " + privilege);
                      }
                    }
                    persistentObjs.add(col);
                    break;
                  }
                }
                if (!found) {
                  throw new InvalidObjectException("No grant (" + privilege
                      + ") found " + " on table " + tabObj.getTableName()
                      + ", column name = "
                      + hiveObject.getColumnName() + ", database is "
                      + tabObj.getDbName());
                }
              }
            }

          }
        }
      }

      if (CollectionUtils.isNotEmpty(persistentObjs)) {
        if (grantOption) {
          // If grant option specified, only update the privilege, don't remove it.
          // Grant option has already been removed from the privileges in the section above
        } else {
          pm.deletePersistentAll(persistentObjs);
        }
      }
      committed = commitTransaction();
    } finally {
      rollbackAndCleanup(committed, null);
    }
    return committed;
  }
Add role names of parentRoles and its parents to processedRoles
standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java