@Override public void cleanNotificationEvents(int olderThan) { boolean commited = false; Query query = null; try { openTransaction(); long tmp = System.currentTimeMillis() / 1000 - olderThan; int tooOld = (tmp > Integer.MAX_VALUE) ? 0 : (int) tmp; query = pm.newQuery(MNotificationLog.class, "eventTime < tooOld"); query.declareParameters("java.lang.Integer tooOld"); Collection<MNotificationLog> toBeRemoved = (Collection) query.execute(tooOld); if (CollectionUtils.isNotEmpty(toBeRemoved)) { pm.deletePersistentAll(toBeRemoved); } commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } }
@Override public void cleanWriteNotificationEvents(int olderThan) { boolean commited = false; Query query = null; try { openTransaction(); long tmp = System.currentTimeMillis() / 1000 - olderThan; int tooOld = (tmp > Integer.MAX_VALUE) ? 0 : (int) tmp; query = pm.newQuery(MTxnWriteNotificationLog.class, "eventTime < tooOld"); query.declareParameters("java.lang.Integer tooOld"); Collection<MTxnWriteNotificationLog> toBeRemoved = (Collection) query.execute(tooOld); if (CollectionUtils.isNotEmpty(toBeRemoved)) { pm.deletePersistentAll(toBeRemoved); } commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } }
@Override public void dropConstraint(String catName, String dbName, String tableName, String constraintName, boolean missingOk) throws NoSuchObjectException { boolean success = false; try { openTransaction(); List<MConstraint> tabConstraints = listAllTableConstraintsWithOptionalConstraintName(catName, dbName, tableName, constraintName); if (CollectionUtils.isNotEmpty(tabConstraints)) { pm.deletePersistentAll(tabConstraints); } else if (!missingOk) { throw new NoSuchObjectException("The constraint: " + constraintName + " does not exist for the associated table: " + dbName + "." + tableName); } success = commitTransaction(); } finally { if (!success) { rollbackTransaction(); } } }
pm.deletePersistentAll(tabGrants); pm.deletePersistentAll(tblColGrants); pm.deletePersistentAll(partGrants); tableName); if (CollectionUtils.isNotEmpty(partColGrants)) { pm.deletePersistentAll(partColGrants); catName, dbName, tableName, null); if (CollectionUtils.isNotEmpty(tabConstraints)) { pm.deletePersistentAll(tabConstraints); pm.deletePersistentAll(tbl);
pm.deletePersistentAll(roleMap); pm.deletePersistentAll(roleMember); mRol.getRoleName(), PrincipalType.ROLE); if (CollectionUtils.isNotEmpty(userGrants)) { pm.deletePersistentAll(userGrants); pm.deletePersistentAll(dbGrants); mRol.getRoleName(), PrincipalType.ROLE, queryWrapper); if (CollectionUtils.isNotEmpty(tabPartGrants)) { pm.deletePersistentAll(tabPartGrants); mRol.getRoleName(), PrincipalType.ROLE, queryWrapper); if (CollectionUtils.isNotEmpty(partGrants)) { pm.deletePersistentAll(partGrants); mRol.getRoleName(), PrincipalType.ROLE, queryWrapper); if (CollectionUtils.isNotEmpty(tblColumnGrants)) { pm.deletePersistentAll(tblColumnGrants); mRol.getRoleName(), PrincipalType.ROLE, queryWrapper); if (CollectionUtils.isNotEmpty(partColumnGrants)) { pm.deletePersistentAll(partColumnGrants);
@Override public void dropFunction(String catName, String dbName, String funcName) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException { boolean success = false; try { openTransaction(); MFunction mfunc = getMFunction(catName, dbName, funcName); pm.retrieve(mfunc); if (mfunc != null) { // TODO: When function privileges are implemented, they should be deleted here. pm.deletePersistentAll(mfunc); } success = commitTransaction(); } finally { if (!success) { rollbackTransaction(); } } }
private boolean dropCreationMetadata(String catName, String dbName, String tableName) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException { boolean success = false; try { openTransaction(); MCreationMetadata mcm = getCreationMetadata(catName, dbName, tableName); pm.retrieve(mcm); if (mcm != null) { pm.deletePersistentAll(mcm); } success = commitTransaction(); } finally { if (!success) { rollbackTransaction(); } } 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); } }
@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 dropISchema(ISchemaName schemaName) throws NoSuchObjectException, MetaException { boolean committed = false; try { openTransaction(); MISchema mSchema = getMISchema(schemaName.getCatName(), schemaName.getDbName(), schemaName.getSchemaName()); if (mSchema != null) { pm.deletePersistentAll(mSchema); } else { throw new NoSuchObjectException("Schema " + schemaName + " does not exist"); } committed = commitTransaction(); } finally { if (!committed) { rollbackTransaction(); } } }
pm.deletePersistentAll(partGrants); Lists.newArrayList(partName)); if (CollectionUtils.isNotEmpty(partColumnGrants)) { pm.deletePersistentAll(partColumnGrants);
@Override public void dropSchemaVersion(SchemaVersionDescriptor version) throws NoSuchObjectException, MetaException { boolean committed = false; try { openTransaction(); MSchemaVersion mSchemaVersion = getMSchemaVersion(version.getSchema().getCatName(), version.getSchema().getDbName(), version.getSchema().getSchemaName(), version.getVersion()); if (mSchemaVersion != null) { pm.deletePersistentAll(mSchemaVersion); } else { throw new NoSuchObjectException("Schema version " + version + "does not exist"); } committed = commitTransaction(); } finally { if (!committed) { rollbackTransaction(); } } }
pm.deletePersistentAll(persistentObjs);
pm.retrieveAll(mStatsObjColl); if (mStatsObjColl != null) { pm.deletePersistentAll(mStatsObjColl); } else { throw new NoSuchObjectException("Column stats don't exist for table="
pm.retrieveAll(mStatsObjColl); if (mStatsObjColl != null) { pm.deletePersistentAll(mStatsObjColl); } else { throw new NoSuchObjectException("Column stats doesn't exist for db=" + dbName + " table="
public Object doInJdo(PersistenceManager pm) throws JDOException { pm.deletePersistentAll(entities); return null; } }, true);
@Override public Void call() { getJdoPersistenceManager().deletePersistentAll(instances); return null; } });
public void deletePersistentAll(Object... pcs) { getPM().deletePersistentAll(pcs); }
private void removeStaledPrivileges(PersistenceManager pm, List<MSentryPrivilege> privilegesCopy) { List<MSentryPrivilege> stalePrivileges = new ArrayList<>(0); for (MSentryPrivilege privilege : privilegesCopy) { if (isPrivilegeStale(privilege)) { stalePrivileges.add(privilege); } } if(!stalePrivileges.isEmpty()) { pm.deletePersistentAll(stalePrivileges); } }
public final class PMF { private static final PersistenceManagerFactory pmfInstance = JDOHelper.getPersistenceManagerFactory("transactions-optional"); private PMF() { PersistenceManagerFactory pmfInstance = PMF.get(); PersistenceManager pm = pmfInstance.getPersistenceManager(); pm.deletePersistentAll();/* by using this all the entities which are created earlier will be deleted*/ } public static PersistenceManagerFactory get() { return pmfInstance; } }