private static Expression _GetMappedExpression(TableChainer source, TableChainer target, DB3 foreignKey)
{
if (foreignKey.IsDefault)
{
foreignKey = source.Node.GetFK();
}
var joinRelation = DbMapping.GetRelation(target.Node.Root.SynonymOrThis.NodeID, source.Node.Root.SynonymOrThis.NodeID,
foreignKey, Text.Method.By);
if (foreignKey.IsDefault)
{
foreignKey = joinRelation.ForeignKey;
}
// determine join operator (for .Join method only)
if (source is SemqJoinChainer && !joinRelation.IsInnerJoin(target.Node.Root.SynonymOrThis.NodeID))
{
((SemqJoinChainer)source).IsLeftOuterJoin = true;
}
// foreign key table = this
if (foreignKey.TableID.Equals(source.Node.NodeID.TableID))
{
return(joinRelation.BuildRelation(foreignKey, source.Alias.Name, target.Alias.Name).E());
}
// foreign key table = target
else
{
return(joinRelation.BuildRelation(foreignKey, target.Alias.Name, source.Alias.Name).E());
}
}
internal static void CheckQuantifierAndThrow(DbNode currentNode, DbNode innerNode, DbNode intermediate, Predicate predicate)
{
if (currentNode == null || innerNode == null)
{
return;
}
Relation relation;
if (intermediate != null)
{
relation = DbMapping.GetRelation(intermediate.NodeID, currentNode.SynonymOrThis.NodeID, intermediate.GetFK());
}
else
{
relation = DbMapping.GetRelation(innerNode.SynonymOrThis.NodeID, currentNode.SynonymOrThis.NodeID, innerNode.SynonymOrThis.GetFK());
}
// one-to-many is ok
if (relation.IsRefTable(currentNode.SynonymOrThis.NodeID))
{
return;
}
// many-to-one is not ok if a predicate type is not existential
if (!predicate.HasDefaultQuantifier())
{
ThrowInvalidQuantifierException(predicate, currentNode, (ISemantic)innerNode, intermediate, null);
}
}
Chainer ISemantic.Translate(SemqContext context, DbNode predecessor)
{
if (context == null)
{
throw new QueryTalkException(this, QueryTalkExceptionType.NullArgumentInnerException,
"context = null", "InternalNode.ISemantic.Translate");
}
if (predecessor == null)
{
throw new QueryTalkException(this, QueryTalkExceptionType.NullArgumentInnerException,
"predecessor = null", "InternalNode.ISemantic.Translate");
}
context.SetIndex(this);
var from = GetDesigner().From(new Table(Map.Name, new AliasAs(Index)));
if (!((IPredicate)this).HasPredicate)
{
return(from);
}
var predicate = ((IPredicate)this).Predicates[0];
var relation = DbMapping.GetRelation(predecessor.SynonymOrThis.NodeID, NodeID, DB3.Default);
var relationExpression = relation.BuildRelation(predecessor.SynonymOrThis.NodeID, predecessor.Index, Index).E();
if (predicate.PredicateType == PredicateType.Cartesian)
{
var innerNode = ((ISemantic)predicate).Subject;
context.SetIndex(innerNode);
innerNode.QueryRoot = context.Subject;
var innerJoinAs = from
.InnerJoin((IOpenView)innerNode)
.As(innerNode.Index);
var joinRelation = DbMapping.GetRelation(NodeID, innerNode.SynonymOrThis.NodeID, DB3.Default);
var joinExpression = joinRelation.BuildRelation(NodeID, Index, innerNode.Index).E();
var on = innerJoinAs
.On(joinExpression);
if (IsFinalizeable)
{
return(on.Where(relationExpression));
}
else
{
return(on);
}
}
else
{
return((Chainer)from.WhereExists(
(INonSelectView)
((ISemantic)predicate).Translate(context, this), true)
.AndWhere(relationExpression, true));
}
}
internal static void Finalize(DbNode predecessor, DbNode currentNode, ref Chainer query)
{
if (!currentNode.IsFinalizeable)
{
return;
}
predecessor = predecessor.SetSynonymOrThis();
currentNode = currentNode.SetSynonymOrThis();
var foreignKey = currentNode.GetFK();
var relation = DbMapping.GetRelation(currentNode.NodeID, predecessor.NodeID, foreignKey);
var relationExpression = relation.BuildRelation(currentNode.NodeID, currentNode.Index, predecessor.Index).E();
if (query is ConditionChainer)
{
query = ((ConditionChainer)query).AndWhere(relationExpression, true);
}
else
{
query = ((IWhere)query).Where(relationExpression, true);
}
}
