@Override public boolean removeToken(String tokenId) { LOG.debug("Begin executing removeToken"); boolean committed = false; MDelegationToken token; try{ openTransaction(); token = getTokenFrom(tokenId); if (null != token) { pm.deletePersistent(token); } committed = commitTransaction(); } finally { if(!committed) { rollbackTransaction(); } } LOG.debug("Done executing removeToken with status : {}", committed); return committed && (token != null); }
@Override public boolean dropDatabase(String catName, String dbname) throws NoSuchObjectException, MetaException { boolean success = false; LOG.info("Dropping database {}.{} along with all tables", catName, dbname); dbname = normalizeIdentifier(dbname); catName = normalizeIdentifier(catName); QueryWrapper queryWrapper = new QueryWrapper(); try { openTransaction(); // then drop the database MDatabase db = getMDatabase(catName, dbname); pm.retrieve(db); if (db != null) { List<MDBPrivilege> dbGrants = this.listDatabaseGrants(catName, dbname, null, queryWrapper); if (CollectionUtils.isNotEmpty(dbGrants)) { pm.deletePersistentAll(dbGrants); } pm.deletePersistent(db); } success = commitTransaction(); } finally { rollbackAndCleanup(success, queryWrapper); } return success; }
@Override public void dropResourcePlan(String name, String ns) throws NoSuchObjectException, MetaException { name = normalizeIdentifier(name); boolean commited = false; Query query = null; try { query = createGetResourcePlanQuery(); MWMResourcePlan resourcePlan = (MWMResourcePlan) query.execute(name, getNsOrDefault(ns)); pm.retrieve(resourcePlan); // TODO: why do some codepaths call retrieve and some don't? if (resourcePlan == null) { throw new NoSuchObjectException("There is no resource plan named: " + name + " in " + ns); } if (resourcePlan.getStatus() == Status.ACTIVE) { throw new MetaException("Cannot drop an active resource plan"); } // First, drop all the dependencies. resourcePlan.setDefaultPool(null); pm.deletePersistentAll(resourcePlan.getTriggers()); pm.deletePersistentAll(resourcePlan.getMappings()); pm.deletePersistentAll(resourcePlan.getPools()); pm.deletePersistent(resourcePlan); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } }
/** * Checks if a column descriptor has any remaining references by storage descriptors * in the db. If it does not, then delete the CD. If it does, then do nothing. * @param oldCD the column descriptor to delete if it is no longer referenced anywhere */ private void removeUnusedColumnDescriptor(MColumnDescriptor oldCD) { if (oldCD == null) { return; } boolean success = false; Query query = null; try { openTransaction(); LOG.debug("execute removeUnusedColumnDescriptor"); query = pm.newQuery("select count(1) from " + "org.apache.hadoop.hive.metastore.model.MStorageDescriptor where (this.cd == inCD)"); query.declareParameters("MColumnDescriptor inCD"); long count = ((Long)query.execute(oldCD)).longValue(); //if no other SD references this CD, we can throw it out. if (count == 0) { pm.retrieve(oldCD); pm.deletePersistent(oldCD); } success = commitTransaction(); LOG.debug("successfully deleted a CD in removeUnusedColumnDescriptor"); } finally { rollbackAndCleanup(success, query); } }
pm.deletePersistent(mRol);
@Override public void dropCatalog(String catalogName) throws NoSuchObjectException, MetaException { LOG.debug("Dropping catalog " + catalogName); boolean committed = false; try { openTransaction(); MCatalog mCat = getMCatalog(catalogName); pm.retrieve(mCat); if (mCat == null) { throw new NoSuchObjectException("No catalog " + catalogName); } pm.deletePersistent(mCat); committed = commitTransaction(); } finally { if (!committed) { rollbackTransaction(); } } }
pm.deletePersistent(part);
@Override public boolean removeMasterKey(Integer id) { LOG.debug("Begin executing removeMasterKey"); boolean success = false; Query query = null; MMasterKey masterKey; try { openTransaction(); query = pm.newQuery(MMasterKey.class, "keyId == id"); query.declareParameters("java.lang.Integer id"); query.setUnique(true); masterKey = (MMasterKey) query.execute(id); if (null != masterKey) { pm.deletePersistent(masterKey); } success = commitTransaction(); } finally { rollbackAndCleanup(success, query); } LOG.debug("Done executing removeMasterKey with status : {}", success); return (null != masterKey) && success; }
pm.retrieve(mStatsObj); if (mStatsObj != null) { pm.deletePersistent(mStatsObj); } else { throw new NoSuchObjectException("Column stats doesn't exist for table="
@Override public boolean dropType(String typeName) { boolean success = false; Query query = null; try { openTransaction(); query = pm.newQuery(MType.class, "name == typeName"); query.declareParameters("java.lang.String typeName"); query.setUnique(true); MType type = (MType) query.execute(typeName.trim()); pm.retrieve(type); if (type != null) { pm.deletePersistent(type); } success = commitTransaction(); } catch (JDOObjectNotFoundException e) { success = commitTransaction(); LOG.debug("type not found {}", typeName, e); } finally { rollbackAndCleanup(success, query); } return success; }
pm.deletePersistent(mStatsObj); } else { throw new NoSuchObjectException("Column stats doesn't exist for db=" + dbName + " table="
@Override public boolean revokeRole(Role role, String userName, PrincipalType principalType, boolean grantOption) throws MetaException, NoSuchObjectException { boolean success = false; try { openTransaction(); MRoleMap roleMember = getMSecurityUserRoleMap(userName, principalType, role.getRoleName()); if (grantOption) { // Revoke with grant option - only remove the grant option but keep the role. if (roleMember.getGrantOption()) { roleMember.setGrantOption(false); } else { throw new MetaException("User " + userName + " does not have grant option with role " + role.getRoleName()); } } else { // No grant option in revoke, remove the whole role. pm.deletePersistent(roleMember); } success = commitTransaction(); } finally { if (!success) { rollbackTransaction(); } } return success; }
public Object doInJdo(PersistenceManager pm) throws JDOException { pm.deletePersistent(entity); return null; } }, true);
public void deletePersistent(Object obj) { getPM().deletePersistent(obj); }
public <T> void deleteRecord(Class<T> type, T s) { PersistenceManager pm = PMF.get().getPersistenceManager(); try { T p = pm.getObjectById(type, s.getId()); pm.deletePersistent(p); } finally { pm.close(); } }
public void deleteRecord(Class classOfProduct, Object id) { PersistenceManager pm = PMF.get().getPersistenceManager(); try { Object p = pm.getObjectById(classOfProduct, id); pm.deletePersistent(p); } finally { pm.close(); } }
private void persistPrivilege(PersistenceManager pm, MSentryPrivilege privilege) { if (isPrivilegeStale(privilege)) { pm.deletePersistent(privilege); return; } pm.makePersistent(privilege); }
private void dropSentryUserCore(PersistenceManager pm, String userName) throws SentryNoSuchObjectException { String lUserName = userName.trim(); MSentryUser sentryUser = getUser(pm, lUserName); if (sentryUser == null) { throw noSuchUser(lUserName); } removePrivilegesForUser(pm, sentryUser); pm.deletePersistent(sentryUser); }
@Override public void execute(final PersistenceCommandContext context) { if (LOG.isDebugEnabled()) { LOG.debug("destroy object - executing command for {}", onAdapter()); } getPersistenceManager().deletePersistent(onAdapter().getObject()); }
public void deleteRecord(Identifier s) { PersistenceManager pm = PMF.get().getPersistenceManager(); try { Identifier p = pm.getObjectById(s.getClass(), s.getId()); pm.deletePersistent(p); } finally { pm.close(); } }