protected IASTNode LookupProperty(IASTNode dot, bool root, bool inSelect)
{
DotNode dotNode = (DotNode)dot;
FromReferenceNode lhs = dotNode.GetLhs();
IASTNode rhs = lhs.NextSibling;
switch (rhs.Type)
{
case ELEMENTS:
case INDICES:
if (log.IsDebugEnabled)
{
log.Debug("lookupProperty() " + dotNode.Path + " => " + rhs.Text + "(" + lhs.Path + ")");
}
CollectionFunction f = (CollectionFunction)rhs;
// Re-arrange the tree so that the collection function is the root and the lhs is the path.
f.SetFirstChild(lhs);
lhs.NextSibling = null;
dotNode.SetFirstChild(f);
Resolve(lhs); // Don't forget to resolve the argument!
f.Resolve(inSelect); // Resolve the collection function now.
return(f);
default:
// Resolve everything up to this dot, but don't resolve the placeholders yet.
dotNode.ResolveFirstChild();
return(dotNode);
}
}
private static string GetPropertyPath(DotNode dotNode, IASTNode alias)
{
var lhs = dotNode.GetLhs();
var rhs = (SqlNode)lhs.NextSibling;
if (lhs is DotNode nextDotNode)
{
return(GetPropertyPath(nextDotNode, alias) + "." + rhs.OriginalText);
}
var path = rhs.OriginalText;
if (alias != null && alias.Text == lhs.Text)
{
return(path);
}
return(lhs.Path + "." + path);
}
void CreateFromJoinElement(
IASTNode path,
IASTNode alias,
int joinType,
IASTNode fetchNode,
IASTNode propertyFetch,
IASTNode with)
{
bool fetch = fetchNode != null;
if (fetch && IsSubQuery)
{
throw new QueryException("fetch not allowed in subquery from-elements");
}
// The path AST should be a DotNode, and it should have been evaluated already.
if (path.Type != DOT)
{
throw new SemanticException("Path expected for join!");
}
DotNode dot = ( DotNode )path;
//JoinType hibernateJoinType = JoinProcessor.ToHibernateJoinType( joinType );
JoinType hibernateJoinType = _impliedJoinType;
dot.JoinType = hibernateJoinType; // Tell the dot node about the join type.
dot.Fetch = fetch;
// Generate an explicit join for the root dot node. The implied joins will be collected and passed up
// to the root dot node.
dot.Resolve(true, false, alias == null ? null : alias.Text);
FromElement fromElement;
if (dot.DataType != null && dot.DataType.IsComponentType)
{
var factory = new FromElementFactory(CurrentFromClause, dot.GetLhs().FromElement, dot.PropertyPath, alias == null ? null : alias.Text, null, false);
fromElement = factory.CreateComponentJoin((ComponentType)dot.DataType);
}
else
{
fromElement = dot.GetImpliedJoin();
if (fromElement == null)
{
throw new InvalidPathException("Invalid join: " + dot.Path);
}
fromElement.SetAllPropertyFetch(propertyFetch != null);
if (with != null)
{
if (fetch)
{
throw new SemanticException("with-clause not allowed on fetched associations; use filters");
}
HandleWithFragment(fromElement, with);
}
}
if (log.IsDebugEnabled())
{
log.Debug("createFromJoinElement() : {0}", _printer.ShowAsString(fromElement, "-- join tree --"));
}
}
void CreateFromJoinElement(
IASTNode path,
IASTNode alias,
int joinType,
IASTNode fetchNode,
IASTNode propertyFetch,
IASTNode with)
{
bool fetch = fetchNode != null;
if (fetch && IsSubQuery)
{
throw new QueryException("fetch not allowed in subquery from-elements");
}
// the incoming "path" can be either:
// 1) an implicit join path (join p.address.city)
// 2) an entity-join (join com.acme.User)
//
// so make the proper interpretation here...
var entityJoinReferencedPersister = ResolveEntityJoinReferencedPersister(path);
if (entityJoinReferencedPersister != null)
{
var entityJoin = CreateEntityJoin(entityJoinReferencedPersister, alias, joinType, with);
((FromReferenceNode)path).FromElement = entityJoin;
SetPropertyFetch(entityJoin, propertyFetch, alias);
return;
}
// The path AST should be a DotNode, and it should have been evaluated already.
if (path.Type != DOT)
{
throw new SemanticException("Path expected for join!");
}
DotNode dot = ( DotNode )path;
//JoinType hibernateJoinType = JoinProcessor.ToHibernateJoinType( joinType );
JoinType hibernateJoinType = _impliedJoinType;
dot.JoinType = hibernateJoinType; // Tell the dot node about the join type.
dot.Fetch = fetch;
// Generate an explicit join for the root dot node. The implied joins will be collected and passed up
// to the root dot node.
dot.Resolve(true, false, alias == null ? null : alias.Text);
FromElement fromElement;
if (dot.DataType != null && dot.DataType.IsComponentType)
{
var factory = new FromElementFactory(CurrentFromClause, dot.GetLhs().FromElement, dot.PropertyPath, alias == null ? null : alias.Text, null, false);
fromElement = factory.CreateComponentJoin((ComponentType)dot.DataType);
}
else
{
fromElement = dot.GetImpliedJoin();
if (fromElement == null)
{
throw new InvalidPathException("Invalid join: " + dot.Path);
}
SetPropertyFetch(fromElement, propertyFetch, alias);
if (with != null)
{
if (fetch)
{
throw new SemanticException("with-clause not allowed on fetched associations; use filters");
}
HandleWithFragment(fromElement, with);
}
if (fromElement.Parent == null)
{
fromElement.FromClause.AddChild(fromElement);
}
}
if (log.IsDebugEnabled())
{
log.Debug("createFromJoinElement() : {0}", _printer.ShowAsString(fromElement, "-- join tree --"));
}
}