internal override SqlExpression VisitMultiset(SqlSubSelect sms)
{
// allow one big-join per query?
if ((this.options & Options.EnableBigJoin) != 0 &&
!this.hasBigJoin && this.canJoin && this.isTopLevel && this.outerSelect != null &&
!MultisetChecker.HasMultiset(sms.Select.Selection) &&
BigJoinChecker.CanBigJoin(sms.Select))
{
sms.Select = this.VisitSelect(sms.Select);
SqlAlias alias = new SqlAlias(sms.Select);
SqlJoin join = new SqlJoin(SqlJoinType.OuterApply, this.outerSelect.From, alias, null, sms.SourceExpression);
this.outerSelect.From = join;
this.outerSelect.OrderingType = SqlOrderingType.Always;
// make joined expression
SqlExpression expr = (SqlExpression)SqlDuplicator.Copy(sms.Select.Selection);
// make count expression
SqlSelect copySelect = (SqlSelect)SqlDuplicator.Copy(sms.Select);
SqlAlias copyAlias = new SqlAlias(copySelect);
SqlSelect countSelect = new SqlSelect(sql.Unary(SqlNodeType.Count, null, sms.SourceExpression), copyAlias, sms.SourceExpression);
countSelect.OrderingType = SqlOrderingType.Never;
SqlExpression count = sql.SubSelect(SqlNodeType.ScalarSubSelect, countSelect);
// make joined collection
SqlJoinedCollection jc = new SqlJoinedCollection(sms.ClrType, sms.SqlType, expr, count, sms.SourceExpression);
this.hasBigJoin = true;
return(jc);
}
else
{
return(QueryExtractor.Extract(sms, this.parentParameters));
}
}
internal SqlExpression TranslateEquals(SqlBinary expr)
{
System.Diagnostics.Debug.Assert(
expr.NodeType == SqlNodeType.EQ || expr.NodeType == SqlNodeType.NE ||
expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V);
SqlExpression eLeft = expr.Left;
SqlExpression eRight = expr.Right;
if (eRight.NodeType == SqlNodeType.Element)
{
SqlSubSelect sub = (SqlSubSelect)eRight;
SqlAlias alias = new SqlAlias(sub.Select);
SqlAliasRef aref = new SqlAliasRef(alias);
SqlSelect select = new SqlSelect(aref, alias, expr.SourceExpression);
select.Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(eLeft), aref);
return(sql.SubSelect(SqlNodeType.Exists, select));
}
else if (eLeft.NodeType == SqlNodeType.Element)
{
SqlSubSelect sub = (SqlSubSelect)eLeft;
SqlAlias alias = new SqlAlias(sub.Select);
SqlAliasRef aref = new SqlAliasRef(alias);
SqlSelect select = new SqlSelect(aref, alias, expr.SourceExpression);
select.Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(eRight), aref);
return(sql.SubSelect(SqlNodeType.Exists, select));
}
MetaType mtLeft = TypeSource.GetSourceMetaType(eLeft, this.services.Model);
MetaType mtRight = TypeSource.GetSourceMetaType(eRight, this.services.Model);
if (eLeft.NodeType == SqlNodeType.TypeCase)
{
eLeft = BestIdentityNode((SqlTypeCase)eLeft);
}
if (eRight.NodeType == SqlNodeType.TypeCase)
{
eRight = BestIdentityNode((SqlTypeCase)eRight);
}
if (mtLeft.IsEntity && mtRight.IsEntity && mtLeft.Table != mtRight.Table)
{
throw Error.CannotCompareItemsAssociatedWithDifferentTable();
}
// do simple or no translation for non-structural types
if (!mtLeft.IsEntity && !mtRight.IsEntity &&
(eLeft.NodeType != SqlNodeType.New || eLeft.SqlType.CanBeColumn) &&
(eRight.NodeType != SqlNodeType.New || eRight.SqlType.CanBeColumn))
{
if (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V)
{
return(this.TranslateEqualsOp(expr.NodeType, sql.DoNotVisitExpression(expr.Left), sql.DoNotVisitExpression(expr.Right), false));
}
return(expr);
}
// If the two types are not comparable, we return the predicate "1=0".
if ((mtLeft != mtRight) && (mtLeft.InheritanceRoot != mtRight.InheritanceRoot))
{
return(sql.Binary(SqlNodeType.EQ, sql.ValueFromObject(0, expr.SourceExpression), sql.ValueFromObject(1, expr.SourceExpression)));
}
List <SqlExpression> exprs1;
List <SqlExpression> exprs2;
SqlLink link1 = eLeft as SqlLink;
if (link1 != null && link1.Member.IsAssociation && link1.Member.Association.IsForeignKey)
{
exprs1 = link1.KeyExpressions;
}
else
{
exprs1 = this.GetIdentityExpressions(mtLeft, sql.DoNotVisitExpression(eLeft));
}
SqlLink link2 = eRight as SqlLink;
if (link2 != null && link2.Member.IsAssociation && link2.Member.Association.IsForeignKey)
{
exprs2 = link2.KeyExpressions;
}
else
{
exprs2 = this.GetIdentityExpressions(mtRight, sql.DoNotVisitExpression(eRight));
}
System.Diagnostics.Debug.Assert(exprs1.Count > 0);
System.Diagnostics.Debug.Assert(exprs2.Count > 0);
System.Diagnostics.Debug.Assert(exprs1.Count == exprs2.Count);
SqlExpression exp = null;
SqlNodeType eqKind = (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V) ? SqlNodeType.EQ2V : SqlNodeType.EQ;
for (int i = 0, n = exprs1.Count; i < n; i++)
{
SqlExpression eq = this.TranslateEqualsOp(eqKind, exprs1[i], exprs2[i], !mtLeft.IsEntity);
if (exp == null)
{
exp = eq;
}
else
{
exp = sql.Binary(SqlNodeType.And, exp, eq);
}
}
if (expr.NodeType == SqlNodeType.NE || expr.NodeType == SqlNodeType.NE2V)
{
exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression);
}
return(exp);
}
internal SqlExpression TranslateEquals(SqlBinary expr)
{
var sqlExpression = expr.Left;
var sqlExpression2 = expr.Right;
if (sqlExpression2.NodeType == SqlNodeType.Element)
{
var sqlSubSelect = (SqlSubSelect)sqlExpression2;
var sqlAlias = new SqlAlias(sqlSubSelect.Select);
var sqlAliasRef = new SqlAliasRef(sqlAlias);
var sqlSelect = new SqlSelect(sqlAliasRef, sqlAlias, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(sqlExpression), sqlAliasRef)
};
return(sql.SubSelect(SqlNodeType.Exists, sqlSelect));
}
if (sqlExpression.NodeType == SqlNodeType.Element)
{
var sqlSubSelect2 = (SqlSubSelect)sqlExpression;
var sqlAlias2 = new SqlAlias(sqlSubSelect2.Select);
var sqlAliasRef2 = new SqlAliasRef(sqlAlias2);
var sqlSelect2 = new SqlSelect(sqlAliasRef2, sqlAlias2, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(sqlExpression2), sqlAliasRef2)
};
return(sql.SubSelect(SqlNodeType.Exists, sqlSelect2));
}
MetaType sourceMetaType = TypeSource.GetSourceMetaType(sqlExpression, services.Model);
MetaType sourceMetaType2 = TypeSource.GetSourceMetaType(sqlExpression2, services.Model);
if (sqlExpression.NodeType == SqlNodeType.TypeCase)
{
sqlExpression = BestIdentityNode((SqlTypeCase)sqlExpression);
}
if (sqlExpression2.NodeType == SqlNodeType.TypeCase)
{
sqlExpression2 = BestIdentityNode((SqlTypeCase)sqlExpression2);
}
if (sourceMetaType.IsEntity && sourceMetaType2.IsEntity && sourceMetaType.Table != sourceMetaType2.Table)
{
throw Error.CannotCompareItemsAssociatedWithDifferentTable();
}
if (!sourceMetaType.IsEntity && !sourceMetaType2.IsEntity && (sqlExpression.NodeType != SqlNodeType.New || sqlExpression.SqlType.CanBeColumn) && (sqlExpression2.NodeType != SqlNodeType.New || sqlExpression2.SqlType.CanBeColumn))
{
if (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V)
{
return(TranslateEqualsOp(expr.NodeType, sql.DoNotVisitExpression(expr.Left), sql.DoNotVisitExpression(expr.Right), false));
}
return(expr);
}
if (sourceMetaType != sourceMetaType2 && sourceMetaType.InheritanceRoot != sourceMetaType2.InheritanceRoot)
{
return(sql.Binary(SqlNodeType.EQ, sql.ValueFromObject(0, expr.SourceExpression), sql.ValueFromObject(1, expr.SourceExpression)));
}
var sqlLink = sqlExpression as SqlLink;
var list = (sqlLink == null || !sqlLink.Member.IsAssociation || !sqlLink.Member.Association.IsForeignKey) ? GetIdentityExpressions(sourceMetaType, sql.DoNotVisitExpression(sqlExpression)) : sqlLink.KeyExpressions;
var sqlLink2 = sqlExpression2 as SqlLink;
var list2 = (sqlLink2 == null || !sqlLink2.Member.IsAssociation || !sqlLink2.Member.Association.IsForeignKey) ? GetIdentityExpressions(sourceMetaType2, sql.DoNotVisitExpression(sqlExpression2)) : sqlLink2.KeyExpressions;
SqlExpression sqlExpression3 = null;
var op = (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V) ? SqlNodeType.EQ2V : SqlNodeType.EQ;
var i = 0;
for (var count = list.Count; i < count; i++)
{
var sqlExpression4 = TranslateEqualsOp(op, list[i], list2[i], !sourceMetaType.IsEntity);
sqlExpression3 = ((sqlExpression3 != null) ? sql.Binary(SqlNodeType.And, sqlExpression3, sqlExpression4) : sqlExpression4);
}
if (expr.NodeType == SqlNodeType.NE || expr.NodeType == SqlNodeType.NE2V)
{
sqlExpression3 = sql.Unary(SqlNodeType.Not, sqlExpression3, sqlExpression3.SourceExpression);
}
return(sqlExpression3);
}
