use of org.datanucleus.metadata.AbstractClassMetaData in project datanucleus-core by datanucleus.
the class ObjectProviderFactoryImpl method newForPNewToBeDeleted.
/**
* Constructor for creating an ObjectProvider to manage a persistable object that is not persistent yet
* is about to be deleted. Consequently the initial lifecycle state will be P_NEW, but will soon
* move to P_NEW_DELETED.
* @param ec Execution Context
* @param pc the object being deleted from persistence
*/
public <T> ObjectProvider<T> newForPNewToBeDeleted(ExecutionContext ec, T pc) {
AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pc.getClass(), ec.getClassLoaderResolver());
ObjectProvider op = getObjectProvider(ec, cmd);
op.initialiseForPNewToBeDeleted(pc);
return op;
}
use of org.datanucleus.metadata.AbstractClassMetaData in project datanucleus-core by datanucleus.
the class ObjectProviderFactoryImpl method newForHollowPopulatedAppId.
/**
* Constructs an ObjectProvider to manage a hollow (or P-clean) instance having the given FieldValues.
* This constructor is used for creating new instances of existing persistent objects using application identity.
* @param ec ExecutionContext
* @param pcClass the class of the new instance to be created.
* @param fv the initial field values of the object.
* @deprecated Use newForHollowPopulated instead
*/
public <T> ObjectProvider<T> newForHollowPopulatedAppId(ExecutionContext ec, Class<T> pcClass, final FieldValues fv) {
Class cls = getInitialisedClassForClass(pcClass, ec.getClassLoaderResolver());
AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pcClass, ec.getClassLoaderResolver());
ObjectProvider op = getObjectProvider(ec, cmd);
op.initialiseForHollowAppId(fv, cls);
return op;
}
use of org.datanucleus.metadata.AbstractClassMetaData in project datanucleus-core by datanucleus.
the class ObjectProviderFactoryImpl method newForTransactionalTransient.
/**
* Constructs an ObjectProvider to manage a transactional-transient instance.
* A new object ID for the instance is obtained from the store manager and the object is inserted in
* the data store. This constructor is used for assigning an ObjectProvider to a transient instance
* that is transitioning to a transient clean state.
* @param ec ExecutionContext
* @param pc the instance being make persistent.
*/
public <T> ObjectProvider<T> newForTransactionalTransient(ExecutionContext ec, T pc) {
AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pc.getClass(), ec.getClassLoaderResolver());
ObjectProvider op = getObjectProvider(ec, cmd);
op.initialiseForTransactionalTransient(pc);
return op;
}
use of org.datanucleus.metadata.AbstractClassMetaData in project datanucleus-core by datanucleus.
the class JavaQueryCompiler method getClassForSubqueryClassExpression.
/**
* Convenience method to find the class that a subquery class expression refers to.
* Allows for reference to the parent query candidate class, or to a class name.
* @param classExpr The class expression
* @return The class that it refers to
*/
private Class getClassForSubqueryClassExpression(String classExpr) {
if (classExpr == null) {
return null;
}
Class cls = null;
String[] tokens = StringUtils.split(classExpr, ".");
if (tokens[0].equalsIgnoreCase(parentCompiler.candidateAlias)) {
// Starts with candidate of parent query
cls = parentCompiler.candidateClass;
} else {
// Try alias from parent query
Symbol sym = parentCompiler.symtbl.getSymbolIgnoreCase(tokens[0]);
if (sym != null) {
cls = sym.getValueType();
} else {
// Must be a class name
return resolveClass(classExpr);
}
}
AbstractClassMetaData cmd = metaDataManager.getMetaDataForClass(cls, clr);
for (int i = 1; i < tokens.length; i++) {
AbstractMemberMetaData mmd = cmd.getMetaDataForMember(tokens[i]);
RelationType relationType = mmd.getRelationType(clr);
if (RelationType.isRelationSingleValued(relationType)) {
cls = mmd.getType();
} else if (RelationType.isRelationMultiValued(relationType)) {
if (mmd.hasCollection()) {
cls = clr.classForName(mmd.getCollection().getElementType());
} else if (mmd.hasMap()) {
// Assume we're using the value
cls = clr.classForName(mmd.getMap().getValueType());
} else if (mmd.hasArray()) {
cls = clr.classForName(mmd.getArray().getElementType());
}
}
if (i < tokens.length - 1) {
cmd = metaDataManager.getMetaDataForClass(cls, clr);
}
}
return cls;
}
use of org.datanucleus.metadata.AbstractClassMetaData in project datanucleus-core by datanucleus.
the class JavaQueryCompiler method compileFrom.
/**
* Method to compile the "from" clause (if present for the query language).
* @return The compiled from expression(s)
*/
protected Expression[] compileFrom() {
if (from == null) {
return null;
}
Node[] node = parser.parseFrom(from);
Expression[] expr = new Expression[node.length];
for (int i = 0; i < node.length; i++) {
String className = (String) node[i].getNodeValue();
String classAlias = null;
Class cls = null;
if (parentCompiler != null) {
cls = getClassForSubqueryClassExpression(className);
} else {
cls = resolveClass(className);
}
List<Node> children = node[i].getChildNodes();
for (Node child : children) {
if (// Alias - maybe should assume it is the first child
child.getNodeType() == NodeType.NAME) {
classAlias = (String) child.getNodeValue();
}
}
if (i == 0 && classAlias == null) {
throw new QueryCompilerSyntaxException("FROM clause of query has class " + cls.getName() + " but no alias");
}
if (classAlias != null) {
if (i == 0) {
// First expression so set up candidateClass/alias
candidateClass = cls;
if (parentCompiler != null && parentCompiler.candidateAlias.equals(classAlias)) {
// The defined alias is the same as the parent query, so rename
candidateAliasOrig = classAlias;
candidateAlias = "sub_" + candidateAlias;
classAlias = candidateAlias;
swapCandidateAliasNodeName(node[i].getChildNode(0));
} else {
candidateAlias = classAlias;
}
}
if (symtbl.getSymbol(classAlias) == null) {
// Add symbol for this candidate under its alias
symtbl.addSymbol(new PropertySymbol(classAlias, cls));
}
}
for (Node childNode : children) {
// Add entries in symbol table for any joined aliases
if (childNode.getNodeType() == NodeType.OPERATOR) {
Node joinedNode = childNode.getFirstChild();
// Extract alias node
Node aliasNode = childNode.getNextChild();
// Extract ON node (if present)
Node onExprNode = null;
if (childNode.hasNextChild()) {
onExprNode = childNode.getNextChild();
}
String joinedAlias = (String) joinedNode.getNodeValue();
boolean rootNode = false;
Symbol joinedSym = caseSensitiveAliases ? symtbl.getSymbol(joinedAlias) : symtbl.getSymbolIgnoreCase(joinedAlias);
if (joinedSym == null) {
// DN Extension : Check for FROM clause including join to a new root
if (aliasNode != null) {
joinedAlias = (String) aliasNode.getNodeValue();
cls = resolveClass((String) joinedNode.getNodeValue());
if (symtbl.getSymbol(joinedAlias) == null) {
// Add symbol for this candidate under its alias
symtbl.addSymbol(new PropertySymbol(joinedAlias, cls));
rootNode = true;
NucleusLogger.QUERY.debug("Found suspected ROOT node joined to in FROM clause : attempting to process as alias=" + joinedAlias);
}
joinedSym = caseSensitiveAliases ? symtbl.getSymbol(joinedAlias) : symtbl.getSymbolIgnoreCase(joinedAlias);
}
if (joinedSym == null) {
throw new QueryCompilerSyntaxException("FROM clause has identifier " + joinedNode.getNodeValue() + " but this is unknown");
}
}
if (!rootNode) {
AbstractClassMetaData joinedCmd = metaDataManager.getMetaDataForClass(joinedSym.getValueType(), clr);
Class joinedCls = joinedSym.getValueType();
AbstractMemberMetaData joinedMmd = null;
while (joinedNode.getFirstChild() != null) {
joinedNode = joinedNode.getFirstChild();
String joinedMember = (String) joinedNode.getNodeValue();
if (joinedNode.getNodeType() == NodeType.CAST) {
// JOIN to "TREAT(identifier AS subcls)"
String castTypeName = (String) joinedNode.getNodeValue();
if (castTypeName.indexOf('.') < 0) {
// Fully-qualify with the current class name?
castTypeName = ClassUtils.createFullClassName(joinedCmd.getPackageName(), castTypeName);
}
joinedCls = clr.classForName(castTypeName);
// Update cast type now that we have resolved it
joinedNode.setNodeValue(castTypeName);
} else {
// Allow for multi-field joins
String[] joinedMembers = joinedMember.contains(".") ? StringUtils.split(joinedMember, ".") : new String[] { joinedMember };
for (int k = 0; k < joinedMembers.length; k++) {
String memberName = joinedMembers[k];
if (joinedCmd == null) {
throw new NucleusUserException("Query has JOIN to " + memberName + " but previous element (" + joinedCls.getName() + ") has no metadata");
}
if (memberName.endsWith("#KEY")) {
memberName = memberName.substring(0, memberName.length() - 4);
} else if (memberName.endsWith("#VALUE")) {
memberName = memberName.substring(0, memberName.length() - 6);
}
AbstractMemberMetaData mmd = joinedCmd.getMetaDataForMember(memberName);
if (mmd == null) {
if (childNode.getNodeValue().equals(JOIN_OUTER) || childNode.getNodeValue().equals(JOIN_OUTER_FETCH)) {
// Polymorphic join, where the field exists in a subclass (doable since we have outer join)
String[] subclasses = metaDataManager.getSubclassesForClass(joinedCmd.getFullClassName(), true);
if (subclasses != null) {
for (int l = 0; l < subclasses.length; l++) {
AbstractClassMetaData subCmd = metaDataManager.getMetaDataForClass(subclasses[l], clr);
if (subCmd != null) {
mmd = subCmd.getMetaDataForMember(memberName);
if (mmd != null) {
NucleusLogger.QUERY.debug("Polymorphic join found at " + memberName + " of " + subCmd.getFullClassName());
joinedCmd = subCmd;
break;
}
}
}
}
}
if (mmd == null) {
throw new QueryCompilerSyntaxException("FROM clause has reference to " + joinedCmd.getFullClassName() + "." + joinedMembers[k] + " but it doesn't exist!");
}
}
RelationType relationType = mmd.getRelationType(clr);
joinedMmd = mmd;
if (RelationType.isRelationSingleValued(relationType)) {
joinedCls = mmd.getType();
joinedCmd = metaDataManager.getMetaDataForClass(joinedCls, clr);
} else if (RelationType.isRelationMultiValued(relationType)) {
if (mmd.hasCollection()) {
// TODO Don't currently allow interface field navigation
joinedCmd = mmd.getCollection().getElementClassMetaData(clr);
if (joinedCmd != null) {
joinedCls = clr.classForName(joinedCmd.getFullClassName());
} else {
joinedCls = clr.classForName(mmd.getCollection().getElementType());
}
} else if (mmd.hasMap()) {
if (joinedMembers[k].endsWith("#KEY")) {
joinedCmd = mmd.getMap().getKeyClassMetaData(clr);
// TODO Set joinedCls
} else {
joinedCmd = mmd.getMap().getValueClassMetaData(clr);
if (joinedCmd != null) {
// JPA assumption that the value is an entity ... but it may not be!
joinedCls = clr.classForName(joinedCmd.getFullClassName());
} else {
joinedCls = clr.classForName(mmd.getMap().getValueType());
}
}
} else if (mmd.hasArray()) {
// TODO Don't currently allow interface field navigation
joinedCmd = mmd.getArray().getElementClassMetaData(clr);
if (joinedCmd != null) {
joinedCls = clr.classForName(joinedCmd.getFullClassName());
} else {
joinedCls = clr.classForName(mmd.getArray().getElementType());
}
}
}
}
}
}
if (aliasNode != null && aliasNode.getNodeType() == NodeType.NAME) {
// Add JOIN alias to symbol table
String alias = (String) aliasNode.getNodeValue();
symtbl.addSymbol(new PropertySymbol(alias, joinedCls));
if (joinedMmd != null && joinedMmd.hasMap()) {
Class keyCls = clr.classForName(joinedMmd.getMap().getKeyType());
// Add the KEY so that we can have joins to the key from the value alias
symtbl.addSymbol(new PropertySymbol(alias + "#KEY", keyCls));
Class valueCls = clr.classForName(joinedMmd.getMap().getValueType());
// Add the VALUE so that we can have joins to the value from the key alias
symtbl.addSymbol(new PropertySymbol(alias + "#VALUE", valueCls));
}
}
}
if (onExprNode != null) {
// ON condition
ExpressionCompiler comp = new ExpressionCompiler();
comp.setSymbolTable(symtbl);
comp.setMethodAliases(queryMgr.getQueryMethodAliasesByPrefix());
Expression nextExpr = comp.compileExpression(onExprNode);
nextExpr.bind(symtbl);
}
}
}
boolean classIsExpression = false;
String[] tokens = StringUtils.split(className, ".");
if (symtbl.getParentSymbolTable() != null) {
if (symtbl.getParentSymbolTable().hasSymbol(tokens[0])) {
classIsExpression = true;
}
}
ExpressionCompiler comp = new ExpressionCompiler();
comp.setSymbolTable(symtbl);
comp.setMethodAliases(queryMgr.getQueryMethodAliasesByPrefix());
expr[i] = comp.compileFromExpression(node[i], classIsExpression);
if (expr[i] != null) {
expr[i].bind(symtbl);
}
}
return expr;
}
Aggregations