/**
* Return the SQL statement. TODO Allow this to work in different catalog/schema
*
* @return statement
*/
private String getStatement() {
RDBMSStoreManager srm = (RDBMSStoreManager) storeMgr;
StringBuilder stmt = new StringBuilder();
stmt.append("SELECT max(");
stmt.append(
srm.getIdentifierFactory()
.getIdentifierInAdapterCase((String) properties.get("column-name")));
stmt.append(") FROM ");
stmt.append(
srm.getIdentifierFactory()
.getIdentifierInAdapterCase((String) properties.get("table-name")));
return stmt.toString();
}
/** Method to initialise the sequence table used for storing the sequence values. */
protected void initialiseSequenceTable() {
// Set catalog/schema name (using properties, and if not specified using the values for the
// table)
String catalogName = properties.getProperty("sequence-catalog-name");
if (catalogName == null) {
catalogName = properties.getProperty("catalog-name");
}
String schemaName = properties.getProperty("sequence-schema-name");
if (schemaName == null) {
schemaName = properties.getProperty("schema-name");
}
String tableName =
(properties.getProperty("sequence-table-name") == null
? DEFAULT_TABLE_NAME
: properties.getProperty("sequence-table-name"));
RDBMSStoreManager storeMgr = (RDBMSStoreManager) this.storeMgr;
DatastoreAdapter dba = storeMgr.getDatastoreAdapter();
DatastoreIdentifier identifier = storeMgr.getIdentifierFactory().newTableIdentifier(tableName);
if (dba.supportsOption(DatastoreAdapter.CATALOGS_IN_TABLE_DEFINITIONS) && catalogName != null) {
identifier.setCatalogName(catalogName);
}
if (dba.supportsOption(DatastoreAdapter.SCHEMAS_IN_TABLE_DEFINITIONS) && schemaName != null) {
identifier.setSchemaName(schemaName);
}
DatastoreClass table = storeMgr.getDatastoreClass(identifier);
if (table != null) {
sequenceTable = (SequenceTable) table;
} else {
String sequenceNameColumnName = DEFAULT_SEQUENCE_COLUMN_NAME;
String nextValColumnName = DEFAULT_NEXTVALUE_COLUMN_NAME;
if (properties.getProperty("sequence-name-column-name") != null) {
sequenceNameColumnName = properties.getProperty("sequence-name-column-name");
}
if (properties.getProperty("sequence-nextval-column-name") != null) {
nextValColumnName = properties.getProperty("sequence-nextval-column-name");
}
sequenceTable =
new SequenceTable(identifier, storeMgr, sequenceNameColumnName, nextValColumnName);
sequenceTable.initialize(storeMgr.getNucleusContext().getClassLoaderResolver(null));
}
}
/**
* Method to return a statement selecting the candidate table(s) required to cover all possible
* types for this candidates inheritance strategy.
*
* @param storeMgr RDBMS StoreManager
* @param parentStmt Parent statement (if there is one)
* @param cmd Metadata for the class
* @param clsMapping Mapping for the results of the statement
* @param ec ExecutionContext
* @param candidateCls Candidate class
* @param subclasses Whether to create a statement for subclasses of the candidate too
* @param result The result clause
* @param candidateAlias alias for the candidate (if any)
* @param candidateTableGroupName TableGroup name for the candidate (if any)
* @return The SQLStatement
* @throws NucleusException if there are no tables for concrete classes in this query (hence would
* return null)
*/
public static SQLStatement getStatementForCandidates(
RDBMSStoreManager storeMgr,
SQLStatement parentStmt,
AbstractClassMetaData cmd,
StatementClassMapping clsMapping,
ExecutionContext ec,
Class candidateCls,
boolean subclasses,
String result,
String candidateAlias,
String candidateTableGroupName) {
SQLStatement stmt = null;
DatastoreIdentifier candidateAliasId = null;
if (candidateAlias != null) {
candidateAliasId = storeMgr.getIdentifierFactory().newTableIdentifier(candidateAlias);
}
ClassLoaderResolver clr = ec.getClassLoaderResolver();
List<DatastoreClass> candidateTables = new ArrayList<DatastoreClass>();
if (cmd.getInheritanceMetaData().getStrategy() == InheritanceStrategy.COMPLETE_TABLE) {
DatastoreClass candidateTable = storeMgr.getDatastoreClass(cmd.getFullClassName(), clr);
if (candidateTable != null) {
candidateTables.add(candidateTable);
}
if (subclasses) {
Collection<String> subclassNames =
storeMgr.getSubClassesForClass(cmd.getFullClassName(), subclasses, clr);
if (subclassNames != null) {
Iterator<String> subclassIter = subclassNames.iterator();
while (subclassIter.hasNext()) {
String subclassName = subclassIter.next();
DatastoreClass tbl = storeMgr.getDatastoreClass(subclassName, clr);
if (tbl != null) {
candidateTables.add(tbl);
}
}
}
}
Iterator<DatastoreClass> iter = candidateTables.iterator();
int maxClassNameLength = cmd.getFullClassName().length();
while (iter.hasNext()) {
DatastoreClass cls = iter.next();
String className = cls.getType();
if (className.length() > maxClassNameLength) {
maxClassNameLength = className.length();
}
}
iter = candidateTables.iterator();
while (iter.hasNext()) {
DatastoreClass cls = iter.next();
SQLStatement tblStmt =
new SQLStatement(parentStmt, storeMgr, cls, candidateAliasId, candidateTableGroupName);
tblStmt.setClassLoaderResolver(clr);
tblStmt.setCandidateClassName(cls.getType());
// Add SELECT of dummy column accessible as "NUCLEUS_TYPE" containing the classname
JavaTypeMapping m = storeMgr.getMappingManager().getMapping(String.class);
String nuctypeName = cls.getType();
if (maxClassNameLength > nuctypeName.length()) {
nuctypeName = StringUtils.leftAlignedPaddedString(nuctypeName, maxClassNameLength);
}
StringLiteral lit = new StringLiteral(tblStmt, m, nuctypeName, null);
tblStmt.select(lit, UnionStatementGenerator.NUC_TYPE_COLUMN);
if (stmt == null) {
stmt = tblStmt;
} else {
stmt.union(tblStmt);
}
}
if (clsMapping != null) {
clsMapping.setNucleusTypeColumnName(UnionStatementGenerator.NUC_TYPE_COLUMN);
}
} else {
// "new-table", "superclass-table", "subclass-table"
List<Class> candidateClasses = new ArrayList<Class>();
if (ClassUtils.isReferenceType(candidateCls)) {
// Persistent interface, so find all persistent implementations
String[] clsNames =
storeMgr
.getNucleusContext()
.getMetaDataManager()
.getClassesImplementingInterface(candidateCls.getName(), clr);
for (int i = 0; i < clsNames.length; i++) {
Class cls = clr.classForName(clsNames[i]);
DatastoreClass table = storeMgr.getDatastoreClass(clsNames[i], clr);
candidateClasses.add(cls);
candidateTables.add(table);
AbstractClassMetaData implCmd =
storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForClass(cls, clr);
if (implCmd.getIdentityType() != cmd.getIdentityType()) {
throw new NucleusUserException(
"You are querying an interface ("
+ cmd.getFullClassName()
+ ") "
+ "yet one of its implementations ("
+ implCmd.getFullClassName()
+ ") "
+ " uses a different identity type!");
} else if (cmd.getIdentityType() == IdentityType.APPLICATION) {
if (cmd.getPKMemberPositions().length != implCmd.getPKMemberPositions().length) {
throw new NucleusUserException(
"You are querying an interface ("
+ cmd.getFullClassName()
+ ") "
+ "yet one of its implementations ("
+ implCmd.getFullClassName()
+ ") "
+ " has a different number of PK members!");
}
}
}
} else {
DatastoreClass candidateTable = storeMgr.getDatastoreClass(cmd.getFullClassName(), clr);
if (candidateTable != null) {
// Candidate has own table
candidateClasses.add(candidateCls);
candidateTables.add(candidateTable);
} else {
// Candidate stored in subclass tables
AbstractClassMetaData[] cmds = storeMgr.getClassesManagingTableForClass(cmd, clr);
if (cmds != null && cmds.length > 0) {
for (int i = 0; i < cmds.length; i++) {
DatastoreClass table = storeMgr.getDatastoreClass(cmds[i].getFullClassName(), clr);
Class cls = clr.classForName(cmds[i].getFullClassName());
candidateClasses.add(cls);
candidateTables.add(table);
}
} else {
throw new UnsupportedOperationException(
"No tables for query of " + cmd.getFullClassName());
}
}
}
for (int i = 0; i < candidateTables.size(); i++) {
DatastoreClass tbl = candidateTables.get(i);
Class cls = candidateClasses.get(i);
StatementGenerator stmtGen = null;
if (tbl.getDiscriminatorMapping(true) != null
|| QueryUtils.resultHasOnlyAggregates(result)) {
// Either has a discriminator, or only selecting aggregates so need single select
stmtGen =
new DiscriminatorStatementGenerator(
storeMgr, clr, cls, subclasses, candidateAliasId, candidateTableGroupName);
stmtGen.setOption(StatementGenerator.OPTION_RESTRICT_DISCRIM);
} else {
stmtGen =
new UnionStatementGenerator(
storeMgr, clr, cls, subclasses, candidateAliasId, candidateTableGroupName);
if (result == null) {
// Returning one row per candidate so include distinguisher column
stmtGen.setOption(StatementGenerator.OPTION_SELECT_NUCLEUS_TYPE);
clsMapping.setNucleusTypeColumnName(UnionStatementGenerator.NUC_TYPE_COLUMN);
}
}
stmtGen.setParentStatement(parentStmt);
SQLStatement tblStmt = stmtGen.getStatement();
if (stmt == null) {
stmt = tblStmt;
} else {
stmt.union(tblStmt);
}
}
}
return stmt;
}
