@Override public List<String> listPartitionNamesPs(String catName, String dbName, String tableName, List<String> part_vals, short max_parts) throws MetaException, NoSuchObjectException { List<String> partitionNames = new ArrayList<>(); boolean success = false; QueryWrapper queryWrapper = new QueryWrapper(); try { openTransaction(); LOG.debug("Executing listPartitionNamesPs"); Collection<String> names = getPartitionPsQueryResults(catName, dbName, tableName, part_vals, max_parts, "partitionName", queryWrapper); partitionNames.addAll(names); success = commitTransaction(); } finally { rollbackAndCleanup(success, queryWrapper); } return partitionNames; }
@Override public WMFullResourcePlan getResourcePlan(String name, String ns) throws NoSuchObjectException { boolean commited = false; try { openTransaction(); WMFullResourcePlan fullRp = fullFromMResourcePlan(getMWMResourcePlan(name, ns, false)); commited = commitTransaction(); return fullRp; } catch (InvalidOperationException e) { // Should not happen, edit check is false. throw new RuntimeException(e); } finally { rollbackAndCleanup(commited, (Query)null); } }
@Override public List<String> getCatalogs() throws MetaException { LOG.debug("Fetching all catalog names"); boolean commited = false; List<String> catalogs = null; String queryStr = "select name from org.apache.hadoop.hive.metastore.model.MCatalog"; Query query = null; openTransaction(); try { query = pm.newQuery(queryStr); query.setResult("name"); catalogs = new ArrayList<>((Collection<String>) query.execute()); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } Collections.sort(catalogs); return catalogs; }
private int getObjectCount(String fieldName, String objName) { Long result = 0L; boolean commited = false; Query query = null; try { openTransaction(); String queryStr = "select count(" + fieldName + ") from " + objName; query = pm.newQuery(queryStr); result = (Long) query.execute(); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return result.intValue(); }
@Override public CurrentNotificationEventId getCurrentNotificationEventId() { boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MNotificationNextId.class); Collection<MNotificationNextId> ids = (Collection) query.execute(); long id = 0; if (CollectionUtils.isNotEmpty(ids)) { id = ids.iterator().next().getNextEventId() - 1; } commited = commitTransaction(); return new CurrentNotificationEventId(id); } finally { rollbackAndCleanup(commited, query); } }
@Override public Function getFunction(String catName, String dbName, String funcName) throws MetaException { boolean commited = false; Function func = null; Query query = null; try { openTransaction(); func = convertToFunction(getMFunction(catName, dbName, funcName)); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return func; }
@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 dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, String poolPath, String ns) throws NoSuchObjectException, InvalidOperationException, MetaException { boolean commited = false; try { openTransaction(); MWMResourcePlan resourcePlan = getMWMResourcePlan(resourcePlanName, ns, true); MWMPool pool = getPool(resourcePlan, poolPath); MWMTrigger trigger = getTrigger(resourcePlan, triggerName); pool.getTriggers().remove(trigger); trigger.getPools().remove(pool); pm.makePersistent(pool); pm.makePersistent(trigger); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, (Query)null); } }
@Override public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, String poolPath, String ns) throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, MetaException { boolean commited = false; try { openTransaction(); MWMResourcePlan resourcePlan = getMWMResourcePlan(resourcePlanName, ns, true); MWMPool pool = getPool(resourcePlan, poolPath); MWMTrigger trigger = getTrigger(resourcePlan, triggerName); pool.getTriggers().add(trigger); trigger.getPools().add(pool); pm.makePersistent(pool); pm.makePersistent(trigger); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, (Query)null); } }
private MWMResourcePlan getActiveMWMResourcePlan(String ns) throws MetaException { boolean commited = false; Query query = null; MWMResourcePlan result = null; try { query = createActivePlanQuery(); result = (MWMResourcePlan) query.execute( Status.ACTIVE.toString(), getNsOrDefault(ns)); pm.retrieve(result); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return result; }
@Override public List<HiveObjectPrivilege> listGlobalGrantsAll() { boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MGlobalPrivilege.class); List<MGlobalPrivilege> userNameDbPriv = (List<MGlobalPrivilege>) query.execute(); pm.retrieveAll(userNameDbPriv); commited = commitTransaction(); return convertGlobal(userNameDbPriv); } finally { rollbackAndCleanup(commited, query); } }
private void deactivateActiveResourcePlan(String ns) { boolean commited = false; Query query = null; try { query = createActivePlanQuery(); MWMResourcePlan mResourcePlan = (MWMResourcePlan) query.execute( Status.ACTIVE.toString(), getNsOrDefault(ns)); // We may not have an active resource plan in the start. if (mResourcePlan != null) { mResourcePlan.setStatus(Status.ENABLED); } commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } }
private boolean constraintNameAlreadyExists(String name) { boolean commited = false; Query constraintExistsQuery = null; String constraintNameIfExists = null; try { openTransaction(); name = normalizeIdentifier(name); constraintExistsQuery = pm.newQuery(MConstraint.class, "constraintName == name"); constraintExistsQuery.declareParameters("java.lang.String name"); constraintExistsQuery.setUnique(true); constraintExistsQuery.setResult("name"); constraintNameIfExists = (String) constraintExistsQuery.execute(name); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, constraintExistsQuery); } return constraintNameIfExists != null && !constraintNameIfExists.isEmpty(); }
@Test public void testQueryCloseOnError() throws Exception { ObjectStore spy = Mockito.spy(objectStore); spy.getAllDatabases(DEFAULT_CATALOG_NAME); spy.getAllFunctions(DEFAULT_CATALOG_NAME); spy.getAllTables(DEFAULT_CATALOG_NAME, DB1); spy.getPartitionCount(); Mockito.verify(spy, Mockito.times(3)) .rollbackAndCleanup(Mockito.anyBoolean(), Mockito.<Query>anyObject()); }
@Override public WMValidateResourcePlanResponse validateResourcePlan(String name, String ns) throws NoSuchObjectException, InvalidObjectException, MetaException { name = normalizeIdentifier(name); boolean committed = false; Query query = null; try { query = createGetResourcePlanQuery(); MWMResourcePlan mResourcePlan = (MWMResourcePlan) query.execute(name, ns); if (mResourcePlan == null) { throw new NoSuchObjectException("Cannot find resourcePlan: " + name + " in " + ns); } WMValidateResourcePlanResponse result = getResourcePlanErrors(mResourcePlan); committed = commitTransaction(); return result; } finally { rollbackAndCleanup(committed, query); } }
private boolean poolHasChildren(MWMResourcePlan resourcePlan, String poolPath) { boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path.startsWith(poolPath)"); query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); query.setResult("count(this)"); query.setUnique(true); Long count = (Long) query.execute(resourcePlan, poolPath + "."); commited = commitTransaction(); return count != null && count > 0; } finally { rollbackAndCleanup(commited, query); } }
private MRole getMRole(String roleName) { MRole mrole = null; boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MRole.class, "roleName == t1"); query.declareParameters("java.lang.String t1"); query.setUnique(true); mrole = (MRole) query.execute(roleName); pm.retrieve(mrole); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return mrole; }
@Override public List<Function> getAllFunctions(String catName) throws MetaException { boolean commited = false; Query query = null; try { openTransaction(); catName = normalizeIdentifier(catName); query = pm.newQuery(MFunction.class, "database.catalogName == catName"); query.declareParameters("java.lang.String catName"); List<MFunction> allFunctions = (List<MFunction>) query.execute(catName); pm.retrieveAll(allFunctions); commited = commitTransaction(); return convertToFunctions(allFunctions); } finally { rollbackAndCleanup(commited, query); } }
private MCatalog getMCatalog(String catalogName) throws MetaException { boolean committed = false; Query query = null; try { openTransaction(); catalogName = normalizeIdentifier(catalogName); query = pm.newQuery(MCatalog.class, "name == catname"); query.declareParameters("java.lang.String catname"); query.setUnique(true); MCatalog mCat = (MCatalog)query.execute(catalogName); pm.retrieve(mCat); committed = commitTransaction(); return mCat; } finally { rollbackAndCleanup(committed, query); } }