public void deleteService(CFSecurityAuthorization Authorization, CFSecurityServiceBuff Buff) {
final String S_ProcName = "CFBamRamServiceTable.deleteService() ";
CFSecurityServicePKey pkey = schema.getFactoryService().newPKey();
pkey.setRequiredClusterId(Buff.getRequiredClusterId());
pkey.setRequiredServiceId(Buff.getRequiredServiceId());
CFSecurityServiceBuff existing = dictByPKey.get(pkey);
if (existing == null) {
return;
}
if (existing.getRequiredRevision() != Buff.getRequiredRevision()) {
throw CFLib.getDefaultExceptionFactory()
.newCollisionDetectedException(getClass(), "deleteService", pkey);
}
CFSecurityServiceByClusterIdxKey keyClusterIdx = schema.getFactoryService().newClusterIdxKey();
keyClusterIdx.setRequiredClusterId(existing.getRequiredClusterId());
CFSecurityServiceByHostIdxKey keyHostIdx = schema.getFactoryService().newHostIdxKey();
keyHostIdx.setRequiredClusterId(existing.getRequiredClusterId());
keyHostIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
CFSecurityServiceByTypeIdxKey keyTypeIdx = schema.getFactoryService().newTypeIdxKey();
keyTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());
CFSecurityServiceByUTypeIdxKey keyUTypeIdx = schema.getFactoryService().newUTypeIdxKey();
keyUTypeIdx.setRequiredClusterId(existing.getRequiredClusterId());
keyUTypeIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
keyUTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());
CFSecurityServiceByUHostPortIdxKey keyUHostPortIdx =
schema.getFactoryService().newUHostPortIdxKey();
keyUHostPortIdx.setRequiredClusterId(existing.getRequiredClusterId());
keyUHostPortIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
keyUHostPortIdx.setRequiredHostPort(existing.getRequiredHostPort());
// Validate reverse foreign keys
// Delete is valid
Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdict;
dictByPKey.remove(pkey);
subdict = dictByClusterIdx.get(keyClusterIdx);
subdict.remove(pkey);
subdict = dictByHostIdx.get(keyHostIdx);
subdict.remove(pkey);
subdict = dictByTypeIdx.get(keyTypeIdx);
subdict.remove(pkey);
dictByUTypeIdx.remove(keyUTypeIdx);
dictByUHostPortIdx.remove(keyUHostPortIdx);
}
public CFBamUuidDefBuff readDerived(CFSecurityAuthorization Authorization, CFBamValuePKey PKey) {
final String S_ProcName = "CFBamRamUuidDef.readDerived";
CFBamValuePKey key = schema.getFactoryValue().newPKey();
key.setRequiredTenantId(PKey.getRequiredTenantId());
key.setRequiredId(PKey.getRequiredId());
CFBamUuidDefBuff buff;
if (dictByPKey.containsKey(key)) {
buff = dictByPKey.get(key);
} else {
buff = null;
}
return (buff);
}
public CFSecurityServiceBuff lockDerived(
CFSecurityAuthorization Authorization, CFSecurityServicePKey PKey) {
final String S_ProcName = "CFBamRamService.readDerived";
CFSecurityServicePKey key = schema.getFactoryService().newPKey();
key.setRequiredClusterId(PKey.getRequiredClusterId());
key.setRequiredServiceId(PKey.getRequiredServiceId());
CFSecurityServiceBuff buff;
if (dictByPKey.containsKey(key)) {
buff = dictByPKey.get(key);
} else {
buff = null;
}
return (buff);
}
public CFSecurityHostNodeBuff readDerivedByIdIdx(
CFSecurityAuthorization Authorization, long ClusterId, long HostNodeId) {
final String S_ProcName = "CFBamRamHostNode.readDerivedByIdIdx() ";
CFSecurityHostNodePKey key = schema.getFactoryHostNode().newPKey();
key.setRequiredClusterId(ClusterId);
key.setRequiredHostNodeId(HostNodeId);
CFSecurityHostNodeBuff buff;
if (dictByPKey.containsKey(key)) {
buff = dictByPKey.get(key);
} else {
buff = null;
}
return (buff);
}
public CFSecurityHostNodeBuff readDerivedByUDescrIdx(
CFSecurityAuthorization Authorization, long ClusterId, String Description) {
final String S_ProcName = "CFBamRamHostNode.readDerivedByUDescrIdx";
CFSecurityHostNodeByUDescrIdxKey key = schema.getFactoryHostNode().newUDescrIdxKey();
key.setRequiredClusterId(ClusterId);
key.setRequiredDescription(Description);
CFSecurityHostNodeBuff buff;
if (dictByUDescrIdx.containsKey(key)) {
buff = dictByUDescrIdx.get(key);
} else {
buff = null;
}
return (buff);
}
public CFSecurityServiceBuff readDerivedByUHostPortIdx(
CFSecurityAuthorization Authorization, long ClusterId, long HostNodeId, short HostPort) {
final String S_ProcName = "CFBamRamService.readDerivedByUHostPortIdx";
CFSecurityServiceByUHostPortIdxKey key = schema.getFactoryService().newUHostPortIdxKey();
key.setRequiredClusterId(ClusterId);
key.setRequiredHostNodeId(HostNodeId);
key.setRequiredHostPort(HostPort);
CFSecurityServiceBuff buff;
if (dictByUHostPortIdx.containsKey(key)) {
buff = dictByUHostPortIdx.get(key);
} else {
buff = null;
}
return (buff);
}
public void deleteUuidDef(CFSecurityAuthorization Authorization, CFBamUuidDefBuff Buff) {
final String S_ProcName = "CFBamRamUuidDefTable.deleteUuidDef() ";
CFBamValuePKey pkey = schema.getFactoryValue().newPKey();
pkey.setRequiredTenantId(Buff.getRequiredTenantId());
pkey.setRequiredId(Buff.getRequiredId());
CFBamUuidDefBuff existing = dictByPKey.get(pkey);
if (existing == null) {
return;
}
if (existing.getRequiredRevision() != Buff.getRequiredRevision()) {
throw CFLib.getDefaultExceptionFactory()
.newCollisionDetectedException(getClass(), "deleteUuidDef", pkey);
}
// Validate reverse foreign keys
if (schema
.getTableUuidCol()
.readDerivedByIdIdx(
Authorization, existing.getRequiredTenantId(), existing.getRequiredId())
!= null) {
throw CFLib.getDefaultExceptionFactory()
.newDependentsDetectedException(
getClass(), "deleteUuidDef", "Superclass", "SuperClass", "UuidCol", pkey);
}
if (schema
.getTableUuidType()
.readDerivedByIdIdx(
Authorization, existing.getRequiredTenantId(), existing.getRequiredId())
!= null) {
throw CFLib.getDefaultExceptionFactory()
.newDependentsDetectedException(
getClass(), "deleteUuidDef", "Superclass", "SuperClass", "UuidType", pkey);
}
// Delete is valid
Map<CFBamValuePKey, CFBamUuidDefBuff> subdict;
dictByPKey.remove(pkey);
schema.getTableAtom().deleteAtom(Authorization, Buff);
}
public void updateUuidDef(CFSecurityAuthorization Authorization, CFBamUuidDefBuff Buff) {
schema.getTableAtom().updateAtom(Authorization, Buff);
CFBamValuePKey pkey = schema.getFactoryValue().newPKey();
pkey.setRequiredTenantId(Buff.getRequiredTenantId());
pkey.setRequiredId(Buff.getRequiredId());
CFBamUuidDefBuff existing = dictByPKey.get(pkey);
if (existing == null) {
throw CFLib.getDefaultExceptionFactory()
.newStaleCacheDetectedException(
getClass(), "updateUuidDef", "Existing record not found", "UuidDef", pkey);
}
// Check unique indexes
// Validate foreign keys
{
boolean allNull = true;
if (allNull) {
if (null
== schema
.getTableAtom()
.readDerivedByIdIdx(
Authorization, Buff.getRequiredTenantId(), Buff.getRequiredId())) {
throw CFLib.getDefaultExceptionFactory()
.newUnresolvedRelationException(
getClass(), "updateUuidDef", "Superclass", "SuperClass", "Atom", null);
}
}
}
// Update is valid
Map<CFBamValuePKey, CFBamUuidDefBuff> subdict;
dictByPKey.remove(pkey);
dictByPKey.put(pkey, Buff);
}
public void updateService(CFSecurityAuthorization Authorization, CFSecurityServiceBuff Buff) {
CFSecurityServicePKey pkey = schema.getFactoryService().newPKey();
pkey.setRequiredClusterId(Buff.getRequiredClusterId());
pkey.setRequiredServiceId(Buff.getRequiredServiceId());
CFSecurityServiceBuff existing = dictByPKey.get(pkey);
if (existing == null) {
throw CFLib.getDefaultExceptionFactory()
.newStaleCacheDetectedException(
getClass(), "updateService", "Existing record not found", "Service", pkey);
}
if (existing.getRequiredRevision() != Buff.getRequiredRevision()) {
throw CFLib.getDefaultExceptionFactory()
.newCollisionDetectedException(getClass(), "updateService", pkey);
}
Buff.setRequiredRevision(Buff.getRequiredRevision() + 1);
CFSecurityServiceByClusterIdxKey existingKeyClusterIdx =
schema.getFactoryService().newClusterIdxKey();
existingKeyClusterIdx.setRequiredClusterId(existing.getRequiredClusterId());
CFSecurityServiceByClusterIdxKey newKeyClusterIdx =
schema.getFactoryService().newClusterIdxKey();
newKeyClusterIdx.setRequiredClusterId(Buff.getRequiredClusterId());
CFSecurityServiceByHostIdxKey existingKeyHostIdx = schema.getFactoryService().newHostIdxKey();
existingKeyHostIdx.setRequiredClusterId(existing.getRequiredClusterId());
existingKeyHostIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
CFSecurityServiceByHostIdxKey newKeyHostIdx = schema.getFactoryService().newHostIdxKey();
newKeyHostIdx.setRequiredClusterId(Buff.getRequiredClusterId());
newKeyHostIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
CFSecurityServiceByTypeIdxKey existingKeyTypeIdx = schema.getFactoryService().newTypeIdxKey();
existingKeyTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());
CFSecurityServiceByTypeIdxKey newKeyTypeIdx = schema.getFactoryService().newTypeIdxKey();
newKeyTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());
CFSecurityServiceByUTypeIdxKey existingKeyUTypeIdx =
schema.getFactoryService().newUTypeIdxKey();
existingKeyUTypeIdx.setRequiredClusterId(existing.getRequiredClusterId());
existingKeyUTypeIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
existingKeyUTypeIdx.setRequiredServiceTypeId(existing.getRequiredServiceTypeId());
CFSecurityServiceByUTypeIdxKey newKeyUTypeIdx = schema.getFactoryService().newUTypeIdxKey();
newKeyUTypeIdx.setRequiredClusterId(Buff.getRequiredClusterId());
newKeyUTypeIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
newKeyUTypeIdx.setRequiredServiceTypeId(Buff.getRequiredServiceTypeId());
CFSecurityServiceByUHostPortIdxKey existingKeyUHostPortIdx =
schema.getFactoryService().newUHostPortIdxKey();
existingKeyUHostPortIdx.setRequiredClusterId(existing.getRequiredClusterId());
existingKeyUHostPortIdx.setRequiredHostNodeId(existing.getRequiredHostNodeId());
existingKeyUHostPortIdx.setRequiredHostPort(existing.getRequiredHostPort());
CFSecurityServiceByUHostPortIdxKey newKeyUHostPortIdx =
schema.getFactoryService().newUHostPortIdxKey();
newKeyUHostPortIdx.setRequiredClusterId(Buff.getRequiredClusterId());
newKeyUHostPortIdx.setRequiredHostNodeId(Buff.getRequiredHostNodeId());
newKeyUHostPortIdx.setRequiredHostPort(Buff.getRequiredHostPort());
// Check unique indexes
if (!existingKeyUTypeIdx.equals(newKeyUTypeIdx)) {
if (dictByUTypeIdx.containsKey(newKeyUTypeIdx)) {
throw CFLib.getDefaultExceptionFactory()
.newUniqueIndexViolationException(
getClass(), "updateService", "ServiceUTypeIdx", newKeyUTypeIdx);
}
}
if (!existingKeyUHostPortIdx.equals(newKeyUHostPortIdx)) {
if (dictByUHostPortIdx.containsKey(newKeyUHostPortIdx)) {
throw CFLib.getDefaultExceptionFactory()
.newUniqueIndexViolationException(
getClass(), "updateService", "ServiceUHostPort", newKeyUHostPortIdx);
}
}
// Validate foreign keys
{
boolean allNull = true;
if (allNull) {
if (null
== schema
.getTableCluster()
.readDerivedByIdIdx(Authorization, Buff.getRequiredClusterId())) {
throw CFLib.getDefaultExceptionFactory()
.newUnresolvedRelationException(
getClass(), "updateService", "Owner", "ServiceCluster", "Cluster", null);
}
}
}
// Update is valid
Map<CFSecurityServicePKey, CFSecurityServiceBuff> subdict;
dictByPKey.remove(pkey);
dictByPKey.put(pkey, Buff);
subdict = dictByClusterIdx.get(existingKeyClusterIdx);
if (subdict != null) {
subdict.remove(pkey);
}
if (dictByClusterIdx.containsKey(newKeyClusterIdx)) {
subdict = dictByClusterIdx.get(newKeyClusterIdx);
} else {
subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
dictByClusterIdx.put(newKeyClusterIdx, subdict);
}
subdict.put(pkey, Buff);
subdict = dictByHostIdx.get(existingKeyHostIdx);
if (subdict != null) {
subdict.remove(pkey);
}
if (dictByHostIdx.containsKey(newKeyHostIdx)) {
subdict = dictByHostIdx.get(newKeyHostIdx);
} else {
subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
dictByHostIdx.put(newKeyHostIdx, subdict);
}
subdict.put(pkey, Buff);
subdict = dictByTypeIdx.get(existingKeyTypeIdx);
if (subdict != null) {
subdict.remove(pkey);
}
if (dictByTypeIdx.containsKey(newKeyTypeIdx)) {
subdict = dictByTypeIdx.get(newKeyTypeIdx);
} else {
subdict = new HashMap<CFSecurityServicePKey, CFSecurityServiceBuff>();
dictByTypeIdx.put(newKeyTypeIdx, subdict);
}
subdict.put(pkey, Buff);
dictByUTypeIdx.remove(existingKeyUTypeIdx);
dictByUTypeIdx.put(newKeyUTypeIdx, Buff);
dictByUHostPortIdx.remove(existingKeyUHostPortIdx);
dictByUHostPortIdx.put(newKeyUHostPortIdx, Buff);
}