public TableJoinAttribute(string tableName, string rightFieldName, string leftFieldName)
{
this._tableName = tableName;
this._rightFieldName = rightFieldName;
this._leftFieldName = leftFieldName;
this._joinType = TableJoinType.InnerJoin;
}
internal JoinedTables(TableJoinType joinType, FromSource left, FromSource right, SqlBooleanExpression joinCondition)
{
JoinType = joinType;
Left = left;
Right = right;
JoinCondition = joinCondition;
}
/// <summary>
/// Set table join
/// </summary>
/// <param name="joinType"></param>
/// <param name="joinedTable"></param>
/// <param name="joinExpression"></param>
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression)
{
//RI: special case - inner joins on top of outer joins should become outer joins as well
if (joinedTable.JoinedTable != null && (joinedTable.JoinType & TableJoinType.FullOuter) != 0)
joinType |= joinedTable.JoinType;
JoinExpression = joinExpression;
JoinType = joinType;
JoinedTable = joinedTable;
}
/// <summary>
/// Set table join
/// </summary>
/// <param name="joinType"></param>
/// <param name="joinedTable"></param>
/// <param name="joinExpression"></param>
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression)
{
//RI: special case - inner joins on top of outer joins should become outer joins as well
if (joinedTable.JoinedTable != null && (joinedTable.JoinType & TableJoinType.FullOuter) != 0)
{
joinType |= joinedTable.JoinType;
}
JoinExpression = joinExpression;
JoinType = joinType;
JoinedTable = joinedTable;
}
public void Join(TableJoinType joinType, Expression joinedExpr, Expression joinExpression)
{
//RI: special case - inner joins on top of outer joins should become outer joins as well
var joinedTable = joinedExpr as TableExpression;
if (joinedTable == null)
{
Util.Check(false, "Joins with subqueries not supported, joined expr: {0}", joinedExpr);
}
if (joinedTable != null && joinedTable.JoinedTable != null && (joinedTable.JoinType & TableJoinType.FullOuter) != 0)
{
joinType |= joinedTable.JoinType;
}
JoinExpression = joinExpression;
JoinType = joinType;
JoinedTable = joinedTable;
}
/// <summary>
/// �õ��������SQL���
/// </summary>
/// <param name="joinType"></param>
/// <returns></returns>
public static string TableJOINTypeToString(TableJoinType joinType)
{
switch (joinType)
{
case TableJoinType.InnerJoin:
return "INNER JOIN";
case TableJoinType.LeftOuterJoin:
return "LEFT JOIN";
case TableJoinType.RightOuterJoin:
return "RIGHT JOIN";
case TableJoinType.FullOuterJoin:
return "FULL JOIN";
}
return "";
}
protected virtual SqlFragment BuildTableJoin(TableJoinType joinType, SqlFragment tableRef, SqlFragment joinCond)
{
SqlFragment joinDecl = null;
switch (joinType)
{
case TableJoinType.Inner: joinDecl = SqlTerms.InnerJoin; break;
case TableJoinType.LeftOuter: joinDecl = SqlTerms.LeftJoin; break;
case TableJoinType.RightOuter: joinDecl = SqlTerms.RightJoin; break;
default:
Util.Check(false, "Join type {0} not supported.", joinType);
break;
}
return(new CompositeSqlFragment(SqlTerms.NewLine, SqlTerms.Indent, joinDecl, tableRef, SqlTerms.On, joinCond));
}
public static string TranslateJoinType(TableJoinType joinType)
{
switch (joinType)
{
case TableJoinType.LeftJoin:
return("LEFT JOIN");
case TableJoinType.InnerJoin:
return("INNER JOIN");
case TableJoinType.RightJoin:
return("RIGHT JOIN");
case TableJoinType.FullJoin:
return("FULL JOIN");
default:
throw new NotImplementedException($"Unsupported join type {Enum.GetName(typeof(TableJoinType), joinType)}");
}
}
protected virtual string GetJoinOperator(TableJoinType joinType)
{
switch (joinType)
{
case TableJoinType.CrossJoin:
return("CROSS JOIN");
case TableJoinType.InnerJoin:
return("INNER JOIN");
case TableJoinType.LeftOuterJoin:
return("LEFT OUTER JOIN");
case TableJoinType.RightOuterJoin:
return("RIGHT OUTER JOIN");
case TableJoinType.FullOuterJoin:
return("FULL OUTER JOIN");
default:
throw new InvalidOperationException();
}
}
private Expression AnalyzeJoin(IList<Expression> parameters, TableJoinType joinType, TranslationContext context)
{
if (parameters.Count == 5)
{
var outerExpr = Analyze(parameters[0], context);
var innerExpr = Analyze(parameters[1], context);
var innerTable = innerExpr as TableExpression;
// TODO: fix this. When joined table is a subquery, we have this exception
if (innerTable == null)
Util.Throw("Join with sub-query is not supported. Sub-query: {0}.", innerExpr);
// RI: check if key selectors return Entity: if yes, change to PK
var outerSel = CheckJoinKeySelector(parameters[2], context);
var innerSel = CheckJoinKeySelector(parameters[3], context);
var outerKeySelector = Analyze(outerSel, outerExpr, context);
var innerKeySelector = Analyze(innerSel, innerTable, context);
// from here, we have two options to join:
// 1. left and right are tables, we can use generic expressions (most common)
// 2. left is something else (a meta table)
var outerTable = outerExpr as TableExpression;
if (outerTable == null)
{
var outerKeyColumn = outerKeySelector as ColumnExpression;
if (outerKeyColumn == null)
Util.Throw("S0701: No way to find left table for Join");
outerTable = outerKeyColumn.Table;
}
var joinExpr = ExpressionUtil.MakeBinary(ExpressionType.Equal, outerKeySelector, innerKeySelector);
innerTable.Join(joinType, outerTable, joinExpr,
string.Format("join{0}", context.EnumerateAllTables().Count()));
// last part is lambda, with two tables as parameters
var metaTableDefinitionBuilderContext = new TranslationContext(context);
//metaTableDefinitionBuilderContext.ExpectMetaTableDefinition = true;
var expression = Analyze(parameters[4], new[] { outerExpr, innerTable }, metaTableDefinitionBuilderContext);
return expression;
}
Util.Throw("S0530: Don't know how to handle GroupJoin() with {0} parameters", parameters.Count);
return null;
}
/// <summary>
/// Returns association definition, if any
/// </summary>
/// <param name="thisTableExpression">The table referenced by the assocation (the type holding the member)</param>
/// <param name="memberInfo">The memberInfo related to association</param>
/// <param name="thisKey">The keys in the joined table</param>
/// <param name="otherKey">The keys in the associated table</param>
/// <param name="joinType"></param>
/// <param name="joinID"></param>
/// <param name="dataContext"></param>
/// <returns></returns>
public virtual Type GetAssociation(TableExpression thisTableExpression, MemberInfo memberInfo,
out IList<MemberInfo> thisKey, out IList<MemberInfo> otherKey,
out TableJoinType joinType, out string joinID, DataContext dataContext)
{
var thisTableDescription = dataContext.Mapping.GetTable(thisTableExpression.Type);
var thisAssociation =
(from association in thisTableDescription.RowType.Associations
where association.ThisMember.Member == memberInfo
select association).SingleOrDefault();
if (thisAssociation != null)
{
joinType = TableJoinType.Inner;
joinID = thisAssociation.ThisMember.MappedName;
if (string.IsNullOrEmpty(joinID))
throw Error.BadArgument("S0108: Association name is required to ensure join uniqueness");
var otherType = thisAssociation.ThisMember.Type;
if (otherType.IsGenericType) // TODO: something serious here
otherType = otherType.GetGenericArguments()[0];
var otherTableDescription = dataContext.Mapping.GetTable(otherType);
thisKey = GetAssociationKeys(thisTableDescription, thisAssociation.ThisKey, dataContext);
otherKey = GetAssociationKeys(otherTableDescription, thisAssociation.OtherKey, dataContext);
return otherType;
}
thisKey = null;
otherKey = null;
joinType = TableJoinType.Default;
joinID = null;
return null;
}
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression, string joinID)
{
Join(joinType, joinedTable, joinExpression);
JoinID = joinID;
}
/// <summary>
/// Set table join
/// </summary>
/// <param name="joinType"></param>
/// <param name="joinedTable"></param>
/// <param name="joinExpression"></param>
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression)
{
JoinExpression = joinExpression;
JoinType = joinType;
JoinedTable = joinedTable;
}
/// <summary>
/// Set table join
/// </summary>
/// <param name="joinType"></param>
/// <param name="joinedTable"></param>
/// <param name="joinExpression"></param>
/// <param name="joinID"></param>
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression, string joinID)
{
Join(joinType, joinedTable, joinExpression);
JoinID = joinID;
}
private IList <EntityMemberInfo> GetAssociationMembers(TableExpression thisTableExpression, EntityMemberInfo member,
out IList <EntityMemberInfo> otherKey, out TableJoinType joinType, out string joinID)
{
switch (member.Kind)
{
case EntityMemberKind.EntityRef:
// by default, join is inner
joinType = TableJoinType.Inner;
joinID = member.MemberName;
var otherType = member.ReferenceInfo.ToKey.Entity.ClassInfo.Type;
otherKey = member.ReferenceInfo.ToKey.ExpandedKeyMembers.Select(km => km.Member).ToList();
var thisKey = member.ReferenceInfo.FromKey.ExpandedKeyMembers.Select(km => km.Member).ToList();
if (member.Flags.IsSet(EntityMemberFlags.Nullable))
{
joinType |= TableJoinType.LeftOuter;
}
return(thisKey);
case EntityMemberKind.Transient:
if (!member.Flags.IsSet(EntityMemberFlags.FromOneToOneRef))
{
break;
}
joinType = TableJoinType.LeftOuter;
joinID = member.MemberName;
var targetEnt = _dbModel.EntityModel.GetEntityInfo(member.DataType, throwIfNotFound: true);
otherKey = targetEnt.PrimaryKey.ExpandedKeyMembers.Select(km => km.Member).ToList();
var thisPk = member.Entity.PrimaryKey.ExpandedKeyMembers.Select(km => km.Member).ToList();
return(thisPk);
}
Util.Throw("Cannot create JOIN expression for property {0}, property not supported in LINQ.", member);
//just to satisfy
otherKey = null;
joinType = TableJoinType.Default;
joinID = null;
return(null);
}
/// <summary>
/// Returns association definition, if any
/// </summary>
/// <param name="thisTableExpression">The table referenced by the assocation (the type holding the member)</param>
/// <param name="memberInfo">The memberInfo related to association</param>
/// <param name="otherType"></param>
/// <param name="otherKey">The keys in the associated table</param>
/// <param name="joinType"></param>
/// <param name="joinID"></param>
/// <param name="dataContext"></param>
/// <returns>ThisKey</returns>
public virtual IList<MemberInfo> GetAssociation(TableExpression thisTableExpression, MemberInfo memberInfo, Type otherType, out IList<MemberInfo> otherKey, out TableJoinType joinType, out string joinID, DataContext dataContext)
{
var thisTableDescription = dataContext.Mapping.GetTable(thisTableExpression.Type);
var thisAssociation =
(from association in thisTableDescription.RowType.Associations
where association.ThisMember.Member == memberInfo
select association).SingleOrDefault();
if (thisAssociation != null)
{
// by default, join is inner
joinType = TableJoinType.Inner;
joinID = thisAssociation.ThisMember.MappedName;
if (string.IsNullOrEmpty(joinID))
throw Error.BadArgument("S0108: Association name is required to ensure join uniqueness");
var otherTableDescription = dataContext.Mapping.GetTable(otherType);
bool thisKeyHasNullables, otherKeyHasNullables;
var thisKey = GetAssociationKeys(thisTableDescription, thisAssociation.ThisKey, dataContext,
out thisKeyHasNullables);
otherKey = GetAssociationKeys(otherTableDescription, thisAssociation.OtherKey, dataContext,
out otherKeyHasNullables);
// we just test here the left join (since associations are symmetric,
// we can only find left joins here, and the otherKeyHasNullables is
// always equal to thisKeyHasNullables)
if (thisKeyHasNullables)
joinType |= TableJoinType.LeftOuter;
return thisKey;
}
otherKey = null;
joinType = TableJoinType.Default;
joinID = null;
return null;
}
/// <summary>
/// Set table join
/// </summary>
/// <param name="joinType"></param>
/// <param name="joinedTable"></param>
/// <param name="joinExpression"></param>
public void Join(TableJoinType joinType, TableExpression joinedTable, Expression joinExpression)
{
JoinExpression = joinExpression;
JoinType = joinType;
JoinedTable = joinedTable;
}
private JoinWithoutOnExpression(TableJoinType joinType, TableSource left, TableSource right)
{
this.joinType = joinType;
this.left = left;
this.right = right;
}
/// <summary>
/// Returns association definition, if any
/// </summary>
/// <param name="thisTableExpression">The table referenced by the assocation (the type holding the member)</param>
/// <param name="memberInfo">The memberInfo related to association</param>
/// <param name="otherType"></param>
/// <param name="otherKey">The keys in the associated table</param>
/// <param name="joinType"></param>
/// <param name="joinID"></param>
/// <param name="dataContext"></param>
/// <returns>ThisKey</returns>
public virtual IList <MemberInfo> GetAssociation(TableExpression thisTableExpression, MemberInfo memberInfo, Type otherType, out IList <MemberInfo> otherKey, out TableJoinType joinType, out string joinID, DataContext dataContext)
{
var thisTableDescription = dataContext.Mapping.GetTable(thisTableExpression.Type);
var thisAssociation =
(from association in thisTableDescription.RowType.Associations
where association.ThisMember.Member == memberInfo
select association).SingleOrDefault();
if (thisAssociation != null)
{
// by default, join is inner
joinType = TableJoinType.Inner;
joinID = thisAssociation.ThisMember.MappedName;
if (string.IsNullOrEmpty(joinID))
{
throw Error.BadArgument("S0108: Association name is required to ensure join uniqueness");
}
var otherTableDescription = dataContext.Mapping.GetTable(otherType);
bool thisKeyHasNullables, otherKeyHasNullables;
var thisKey = GetAssociationKeys(thisTableDescription, thisAssociation.ThisKey, dataContext,
out thisKeyHasNullables);
otherKey = GetAssociationKeys(otherTableDescription, thisAssociation.OtherKey, dataContext,
out otherKeyHasNullables);
// we just test here the left join (since associations are symmetric,
// we can only find left joins here, and the otherKeyHasNullables is
// always equal to thisKeyHasNullables)
if (thisKeyHasNullables)
{
joinType |= TableJoinType.LeftOuter;
}
return(thisKey);
}
otherKey = null;
joinType = TableJoinType.Default;
joinID = null;
return(null);
}
// Methods
public RelationReflectMapping(string tableName, string sourceTableName)
{
this.tableName = tableName;
this.tableAlias = tableName;
this.sourceTableName = sourceTableName;
this.sourceTableAlias = sourceTableName;
this.joinType = TableJoinType.InnerJoin;
}
private IList<MemberInfo> GetAssociationMembers(TableExpression thisTableExpression, EntityMemberInfo member,
out IList<MemberInfo> otherKey, out TableJoinType joinType, out string joinID)
{
switch(member.Kind) {
case MemberKind.EntityRef:
// by default, join is inner
joinType = TableJoinType.Inner;
joinID = member.MemberName;
var otherType = member.ReferenceInfo.ToKey.Entity.ClassInfo.Type;
otherKey = member.ReferenceInfo.ToKey.ExpandedKeyMembers.Select(km => (MemberInfo) km.Member.ClrClassMemberInfo).ToList();
var thisKey = member.ReferenceInfo.FromKey.ExpandedKeyMembers.Select(km => (MemberInfo)km.Member.ClrClassMemberInfo).ToList();
if(member.Flags.IsSet(EntityMemberFlags.Nullable))
joinType |= TableJoinType.LeftOuter;
return thisKey;
case MemberKind.Transient:
if(!member.Flags.IsSet(EntityMemberFlags.FromOneToOneRef))
break;
joinType = TableJoinType.LeftOuter;
joinID = member.MemberName;
var targetEnt = this._dbModel.EntityApp.Model.GetEntityInfo(member.DataType, throwIfNotFound: true);
otherKey = targetEnt.PrimaryKey.ExpandedKeyMembers.Select(km => km.Member.ClrClassMemberInfo).ToList();
var thisPk = member.Entity.PrimaryKey.ExpandedKeyMembers.Select(km => km.Member.ClrClassMemberInfo).ToList();
return thisPk;
}
Util.Throw("Cannot create JOIN expression for property {0}, property not supported in LINQ.", member);
otherKey = null;
joinType = TableJoinType.Default;
joinID = null;
return null;
}
