@Override public String getToken(String tokenId) { LOG.debug("Begin executing getToken"); boolean committed = false; MDelegationToken token; try{ openTransaction(); token = getTokenFrom(tokenId); if (null != token) { pm.retrieve(token); } committed = commitTransaction(); } finally { if(!committed) { rollbackTransaction(); } } LOG.debug("Done executing getToken with status : {}", committed); return (null == token) ? null : token.getTokenStr(); }
private List<RuntimeStat> getMRuntimeStats(int maxEntries, int maxCreateTime) { Query<MRuntimeStat> query = pm.newQuery(MRuntimeStat.class); query.setOrdering("createTime descending"); if (maxCreateTime > 0) { query.setFilter("createTime < "+maxCreateTime); } if (maxEntries < 0) { maxEntries = Integer.MAX_VALUE; } List<RuntimeStat> ret = new ArrayList<>(); List<MRuntimeStat> res = (List<MRuntimeStat>) query.execute(); int totalEntries = 0; for (MRuntimeStat mRuntimeStat : res) { pm.retrieve(mRuntimeStat); totalEntries += mRuntimeStat.getWeight(); ret.add(MRuntimeStat.toThrift(mRuntimeStat)); if (totalEntries >= maxEntries) { break; } } return ret; }
@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(); } } }
private MSerDeInfo getMSerDeInfo(String serDeName) throws MetaException { Query query = null; try { query = pm.newQuery(MSerDeInfo.class, "name == serDeName"); query.declareParameters("java.lang.String serDeName"); query.setUnique(true); MSerDeInfo mSerDeInfo = (MSerDeInfo)query.execute(serDeName); pm.retrieve(mSerDeInfo); return mSerDeInfo; } finally { if (query != null) { query.closeAll(); } } }
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 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 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 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; }
@Override public Type getType(String typeName) { Type type = null; boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MType.class, "name == typeName"); query.declareParameters("java.lang.String typeName"); query.setUnique(true); MType mtype = (MType) query.execute(typeName.trim()); pm.retrieve(type); if (mtype != null) { type = getType(mtype); } commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return type; }
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; }
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); } }
private MRoleMap getMSecurityUserRoleMap(String userName, PrincipalType principalType, String roleName) { MRoleMap mRoleMember = null; boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MRoleMap.class, "principalName == t1 && principalType == t2 && role.roleName == t3"); query.declareParameters("java.lang.String t1, java.lang.String t2, java.lang.String t3"); query.setUnique(true); mRoleMember = (MRoleMap) query.executeWithArray(userName, principalType.toString(), roleName); pm.retrieve(mRoleMember); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return mRoleMember; }
private MISchema getMISchema(String catName, String dbName, String name) { Query query = null; try { name = normalizeIdentifier(name); dbName = normalizeIdentifier(dbName); catName = normalizeIdentifier(catName); query = pm.newQuery(MISchema.class, "name == schemaName && db.name == dbname && db.catalogName == cat"); query.declareParameters( "java.lang.String schemaName, java.lang.String dbname, java.lang.String cat"); query.setUnique(true); MISchema mSchema = (MISchema)query.execute(name, dbName, catName); pm.retrieve(mSchema); return mSchema; } finally { if (query != null) { query.closeAll(); } } }
private MWMPool getPool(MWMResourcePlan resourcePlan, String poolPath) throws NoSuchObjectException { poolPath = normalizeIdentifier(poolPath); boolean commited = false; Query query = null; try { openTransaction(); query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path == poolPath"); query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); query.setUnique(true); MWMPool mPool = (MWMPool) query.execute(resourcePlan, poolPath); commited = commitTransaction(); if (mPool == null) { throw new NoSuchObjectException("Cannot find pool: " + poolPath); } pm.retrieve(mPool); return mPool; } finally { rollbackAndCleanup(commited, query); } }
private MWMTrigger getTrigger(MWMResourcePlan resourcePlan, String triggerName) throws NoSuchObjectException { triggerName = normalizeIdentifier(triggerName); boolean commited = false; Query query = null; try { openTransaction(); // Get the MWMTrigger object from DN query = pm.newQuery(MWMTrigger.class, "resourcePlan == rp && name == triggerName"); query.declareParameters("MWMResourcePlan rp, java.lang.String triggerName"); query.setUnique(true); MWMTrigger mTrigger = (MWMTrigger) query.execute(resourcePlan, triggerName); if (mTrigger == null) { throw new NoSuchObjectException("Cannot find trigger with name: " + triggerName); } pm.retrieve(mTrigger); commited = commitTransaction(); return mTrigger; } finally { rollbackAndCleanup(commited, query); } }
private MWMResourcePlan getMWMResourcePlan(String name, String ns, boolean editCheck, boolean mustExist) throws NoSuchObjectException, InvalidOperationException { MWMResourcePlan resourcePlan; boolean commited = false; Query query = null; name = normalizeIdentifier(name); try { query = createGetResourcePlanQuery(); ns = getNsOrDefault(ns); resourcePlan = (MWMResourcePlan) query.execute(name, ns); pm.retrieve(resourcePlan); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } if (mustExist && resourcePlan == null) { throw new NoSuchObjectException("There is no resource plan named: " + name + " in " + ns); } if (editCheck && resourcePlan != null && resourcePlan.getStatus() != MWMResourcePlan.Status.DISABLED) { throw new InvalidOperationException("Resource plan must be disabled to edit it."); } return resourcePlan; }
private MCreationMetadata getCreationMetadata(String catName, String dbName, String tblName) { boolean commited = false; MCreationMetadata mcm = null; Query query = null; catName = normalizeIdentifier(catName); dbName = normalizeIdentifier(dbName); tblName = normalizeIdentifier(tblName); try { openTransaction(); query = pm.newQuery( MCreationMetadata.class, "tblName == table && dbName == db && catalogName == cat"); query.declareParameters("java.lang.String table, java.lang.String db, java.lang.String cat"); query.setUnique(true); mcm = (MCreationMetadata) query.execute(tblName, dbName, catName); pm.retrieve(mcm); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return mcm; }
private MFunction getMFunction(String catName, String db, String function) { MFunction mfunc = null; boolean commited = false; Query query = null; try { openTransaction(); catName = normalizeIdentifier(catName); db = normalizeIdentifier(db); function = normalizeIdentifier(function); query = pm.newQuery(MFunction.class, "functionName == function && database.name == db && database.catalogName == catName"); query.declareParameters("java.lang.String function, java.lang.String db, java.lang.String catName"); query.setUnique(true); mfunc = (MFunction) query.execute(function, db, catName); pm.retrieve(mfunc); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } return mfunc; }
@SuppressWarnings("nls") private MDatabase getMDatabase(String catName, String name) throws NoSuchObjectException { MDatabase mdb = null; boolean commited = false; Query query = null; try { openTransaction(); name = normalizeIdentifier(name); catName = normalizeIdentifier(catName); query = pm.newQuery(MDatabase.class, "name == dbname && catalogName == catname"); query.declareParameters("java.lang.String dbname, java.lang.String catname"); query.setUnique(true); mdb = (MDatabase) query.execute(name, catName); pm.retrieve(mdb); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } if (mdb == null) { throw new NoSuchObjectException("There is no database " + catName + "." + name); } return mdb; }
@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); } }