public PersistenceQuery createCall(final String spCall, final Class[] types) {
FieldDescriptor[] fields;
String[] jdoFields0;
String[] jdoFields;
String sql;
int[] sqlTypes0;
int[] sqlTypes;
int count;
// changes for the SQL Direct interface begins here
if (spCall.startsWith("SQL")) {
sql = spCall.substring(4);
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.format("jdo.directSQL", sql));
}
return new SQLQuery(this, _factory, sql, types, true);
}
if (LOG.isDebugEnabled()) {
LOG.debug(Messages.format("jdo.spCall", spCall));
}
fields = _clsDesc.getFields();
jdoFields0 = new String[fields.length + 1];
sqlTypes0 = new int[fields.length + 1];
// the first field is the identity
count = 1;
jdoFields0[0] = _clsDesc.getIdentity().getFieldName();
sqlTypes0[0] = ((JDOFieldDescriptor) _clsDesc.getIdentity()).getSQLType()[0];
for (int i = 0; i < fields.length; ++i) {
if (fields[i] instanceof JDOFieldDescriptor) {
jdoFields0[count] = ((JDOFieldDescriptor) fields[i]).getSQLName()[0];
sqlTypes0[count] = ((JDOFieldDescriptor) fields[i]).getSQLType()[0];
++count;
}
}
jdoFields = new String[count];
sqlTypes = new int[count];
System.arraycopy(jdoFields0, 0, jdoFields, 0, count);
System.arraycopy(sqlTypes0, 0, sqlTypes, 0, count);
return ((BaseFactory) _factory)
.getCallQuery(spCall, types, _clsDesc.getJavaClass(), jdoFields, sqlTypes);
}
SQLEngine(
final JDOClassDescriptor clsDesc, final PersistenceFactory factory, final String stampField)
throws MappingException {
_clsDesc = clsDesc;
_factory = factory;
_keyGen = null;
if (_clsDesc.getExtends() == null) {
KeyGeneratorDescriptor keyGenDesc = clsDesc.getKeyGeneratorDescriptor();
if (keyGenDesc != null) {
int[] tempType = ((JDOFieldDescriptor) _clsDesc.getIdentity()).getSQLType();
_keyGen =
keyGenDesc
.getKeyGeneratorRegistry()
.getKeyGenerator(_factory, keyGenDesc, (tempType == null) ? 0 : tempType[0]);
// Does the key generator support the sql type specified in the mapping?
_keyGen.supportsSqlType(tempType[0]);
}
}
// construct field and id info
Vector idsInfo = new Vector();
Vector fieldsInfo = new Vector();
/*
* Implementation Note:
* Extends and Depends has some special mutual exclusive
* properties, which implementator should aware of.
*
* A Depended class may depends on another depended class
* A class should either extends or depends on other class
* A class should not depend on extending class.
* because, it is the same as depends on the base class
* A class may be depended by zero or more classes
* A class may be extended by zero or more classes
* A class may extends only zero or one class
* A class may depends only zero or one class
* A class may depend on extended class
* A class may extend a dependent class.
* A class may extend a depended class.
* No loop or circle should exist
*/
// then, we put depended class ids in the back
JDOClassDescriptor base = clsDesc;
// walk until the base class which this class extends
base = clsDesc;
Stack stack = new Stack();
stack.push(base);
while (base.getExtends() != null) {
// if (base.getDepends() != null) {
// throw new MappingException("Class should not both depends on and extended other
// classes");
// }
base = (JDOClassDescriptor) base.getExtends();
stack.push(base);
// do we need to add loop detection?
}
// now base is either the base of extended class, or
// clsDesc
// we always put the original id info in front
// [oleg] except for SQL name, it may differ.
FieldDescriptor[] baseIdDescriptors = base.getIdentities();
FieldDescriptor[] idDescriptors = clsDesc.getIdentities();
for (int i = 0; i < baseIdDescriptors.length; i++) {
if (baseIdDescriptors[i] instanceof JDOFieldDescriptor) {
String name = baseIdDescriptors[i].getFieldName();
String[] sqlName = ((JDOFieldDescriptor) baseIdDescriptors[i]).getSQLName();
int[] sqlType = ((JDOFieldDescriptor) baseIdDescriptors[i]).getSQLType();
FieldHandlerImpl fh = (FieldHandlerImpl) baseIdDescriptors[i].getHandler();
// The extending class may have other SQL names for identity fields
for (int j = 0; j < idDescriptors.length; j++) {
if (name.equals(idDescriptors[j].getFieldName())
&& (idDescriptors[j] instanceof JDOFieldDescriptor)) {
sqlName = ((JDOFieldDescriptor) idDescriptors[j]).getSQLName();
break;
}
}
idsInfo.add(
new SQLColumnInfo(
sqlName[0],
sqlType[0],
fh.getConvertTo(),
fh.getConvertFrom(),
fh.getConvertParam()));
} else {
throw new MappingException("Except JDOFieldDescriptor");
}
}
// then do the fields
while (!stack.empty()) {
base = (JDOClassDescriptor) stack.pop();
FieldDescriptor[] fieldDescriptors = base.getFields();
for (int i = 0; i < fieldDescriptors.length; i++) {
// fieldDescriptors[i] is persistent in db if it is not transient
// and it is a JDOFieldDescriptor or has a ClassDescriptor
if (!fieldDescriptors[i].isTransient()) {
if ((fieldDescriptors[i] instanceof JDOFieldDescriptor)
|| (fieldDescriptors[i].getClassDescriptor() != null)) {
fieldsInfo.add(
new SQLFieldInfo(
clsDesc, fieldDescriptors[i], base.getTableName(), !stack.empty()));
}
}
}
}
_ids = new SQLColumnInfo[idsInfo.size()];
idsInfo.copyInto(_ids);
_fields = new SQLFieldInfo[fieldsInfo.size()];
fieldsInfo.copyInto(_fields);
_loadStatement = new SQLStatementLoad(this, factory);
_createStatement = new SQLStatementCreate(this, factory);
_removeStatement = new SQLStatementRemove(this, factory);
_storeStatement = new SQLStatementStore(this, factory, _loadStatement.getLoadStatement());
}