private static bool IsSupportedDateTimeNew(SqlNew sox)
{
if(sox.ClrType == typeof(DateTime)
&& sox.Args.Count >= 3
&& sox.Args[0].ClrType == typeof(int)
&& sox.Args[1].ClrType == typeof(int)
&& sox.Args[2].ClrType == typeof(int))
{
if(sox.Args.Count == 3)
{
return true;
}
if(sox.Args.Count >= 6 &&
sox.Args[3].ClrType == typeof(int) && sox.Args[4].ClrType == typeof(int) && sox.Args[5].ClrType == typeof(int))
{
if(sox.Args.Count == 6)
{
return true;
}
if((sox.Args.Count == 7) && (sox.Args[6].ClrType == typeof(int)))
{
return true;
}
}
}
return false;
}
private static bool IsSupportedNew(SqlNew snew)
{
if(snew.ClrType == typeof(string))
{
return IsSupportedStringNew(snew);
}
else if(snew.ClrType == typeof(TimeSpan))
{
return IsSupportedTimeSpanNew(snew);
}
else if(snew.ClrType == typeof(DateTime))
{
return IsSupportedDateTimeNew(snew);
}
return false;
}
internal override SqlExpression VisitNew(SqlNew sox)
{
if(!_isDebugMode)
{
throw Error.InvalidFormatNode("New");
}
_commandStringBuilder.Append("new ");
_commandStringBuilder.Append(sox.ClrType.Name);
_commandStringBuilder.Append("{ ");
// Visit Args
for(int i = 0, n = sox.Args.Count; i < n; i++)
{
SqlExpression argExpr = sox.Args[i];
if(i > 0) _commandStringBuilder.Append(", ");
_commandStringBuilder.Append(sox.ArgMembers[i].Name);
_commandStringBuilder.Append(" = ");
this.Visit(argExpr);
}
// Visit Members
for(int i = 0, n = sox.Members.Count; i < n; i++)
{
SqlMemberAssign ma = sox.Members[i];
if(i > 0) _commandStringBuilder.Append(", ");
string ename = this.InferName(ma.Expression, null);
if(ename != ma.Member.Name)
{
_commandStringBuilder.Append(ma.Member.Name);
_commandStringBuilder.Append(" = ");
}
this.Visit(ma.Expression);
}
_commandStringBuilder.Append(" }");
return sox;
}
internal override SqlExpression VisitNew(SqlNew sox)
{
SqlExpression[] args = new SqlExpression[sox.Args.Count];
SqlMemberAssign[] bindings = new SqlMemberAssign[sox.Members.Count];
for(int i = 0, n = args.Length; i < n; i++)
{
args[i] = this.VisitExpression(sox.Args[i]);
}
for(int i = 0, n = bindings.Length; i < n; i++)
{
bindings[i] = this.VisitMemberAssign(sox.Members[i]);
}
return new SqlNew(sox.MetaType, sox.SqlType, sox.Constructor, args, sox.ArgMembers, bindings, sox.SourceExpression);
}
internal override SqlExpression VisitNew(SqlNew sox)
{
if(sox.Constructor != null)
{
Reflection.ParameterInfo[] pis = sox.Constructor.GetParameters();
for(int i = 0, n = sox.Args.Count; i < n; i++)
{
sox.Args[i] = this.VisitNamedExpression(sox.Args[i], pis[i].Name);
}
}
else
{
for(int i = 0, n = sox.Args.Count; i < n; i++)
{
sox.Args[i] = this.VisitExpression(sox.Args[i]);
}
}
foreach(SqlMemberAssign ma in sox.Members)
{
string n = ma.Member.Name;
if(this.useMappedNames)
{
n = sox.MetaType.GetDataMember(ma.Member).MappedName;
}
ma.Expression = this.VisitNamedExpression(ma.Expression, n);
}
return sox;
}
internal override SqlExpression VisitNew(SqlNew sox)
{
// check the args for the PKs
foreach(MemberInfo column in _identityMembers)
{
// assume we're invalid unless we find a matching argument which is
// a bare column/columnRef to the PK
bool isMatch = false;
// find a matching arg
foreach(SqlExpression expr in sox.Args)
{
isMatch = IsColumnMatch(column, expr);
if(isMatch)
{
break;
}
}
if(!isMatch)
{
foreach(SqlMemberAssign ma in sox.Members)
{
SqlExpression expr = ma.Expression;
isMatch = IsColumnMatch(column, expr);
if(isMatch)
{
break;
}
}
}
_isValid &= isMatch;
if(!_isValid)
{
break;
}
}
return sox;
}
internal override SqlExpression VisitNew(SqlNew sox) {
for (int i = 0, n = sox.Args.Count; i < n; i++) {
if (inGroupBy) {
// we don't want to fetch expressions for group by,
// since we want links to remain links so SqlFlattener
// can deal with them properly
sox.Args[i] = this.VisitExpression(sox.Args[i]);
}
else {
sox.Args[i] = this.FetchExpression(sox.Args[i]);
}
}
for (int i = 0, n = sox.Members.Count; i < n; i++) {
SqlMemberAssign ma = sox.Members[i];
MetaDataMember mm = sox.MetaType.GetDataMember(ma.Member);
MetaType otherType = mm.DeclaringType.InheritanceRoot;
if (mm.IsAssociation && ma.Expression != null && ma.Expression.NodeType != SqlNodeType.Link
&& this.shape != null && this.shape.IsPreloaded(mm.Member) && mm.LoadMethod == null
&& this.alreadyIncluded != null && !this.alreadyIncluded.Contains(otherType)) {
// The expression is already fetched, add it to the alreadyIncluded set.
this.alreadyIncluded.Add(otherType);
ma.Expression = this.VisitExpression(ma.Expression);
this.alreadyIncluded.Remove(otherType);
}
else if (mm.IsAssociation || mm.IsDeferred) {
ma.Expression = this.VisitExpression(ma.Expression);
}
else {
ma.Expression = this.FetchExpression(ma.Expression);
}
}
return sox;
}
private static bool IsSupportedTimeSpanNew(SqlNew sox)
{
if(sox.Args.Count == 1)
{
return true;
}
else if(sox.Args.Count == 3)
{
return true;
}
else
{
if(sox.Args.Count == 4)
{
return true;
}
else if(sox.Args.Count == 5)
{
return true;
}
}
return false;
}
internal virtual SqlExpression VisitNew(SqlNew sox) {
for (int i = 0, n = sox.Args.Count; i < n; i++) {
sox.Args[i] = this.VisitExpression(sox.Args[i]);
}
for (int i = 0, n = sox.Members.Count; i < n; i++) {
sox.Members[i].Expression = this.VisitExpression(sox.Members[i].Expression);
}
return sox;
}
private SqlExpression TranslateNewDateTime(SqlNew sox)
{
Expression source = sox.SourceExpression;
// DateTime(int year, int month, int day)
// --> CONVERT(DATETIME, CONVERT(nchar(2),@month) + '/' + CONVERT(nchar(2),@day) + '/' + CONVERT(nchar(4),@year),101)
if(sox.ClrType == typeof(DateTime) && sox.Args.Count >= 3 &&
sox.Args[0].ClrType == typeof(int) && sox.Args[1].ClrType == typeof(int) && sox.Args[2].ClrType == typeof(int))
{
SqlExpression char2 = sql.FunctionCall(typeof(void), "NCHAR", new SqlExpression[1] { sql.ValueFromObject(2, false, source) }, source);
SqlExpression char4 = sql.FunctionCall(typeof(void), "NCHAR", new SqlExpression[1] { sql.ValueFromObject(4, false, source) }, source);
SqlExpression year = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char4, sox.Args[0] }, source);
SqlExpression month = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[1] }, source);
SqlExpression day = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[2] }, source);
SqlExpression datetime = new SqlVariable(typeof(void), null, "DATETIME", source);
if(sox.Args.Count == 3)
{
SqlExpression date = sql.Concat(month, sql.ValueFromObject("/", false, source), day, sql.ValueFromObject("/", false, source), year);
return sql.FunctionCall(typeof(DateTime), "CONVERT", new SqlExpression[3] { datetime, date, sql.ValueFromObject(101, false, source) }, source);
}
if(sox.Args.Count >= 6 &&
sox.Args[3].ClrType == typeof(int) && sox.Args[4].ClrType == typeof(int) && sox.Args[5].ClrType == typeof(int))
{
// DateTime(year, month, day, hour, minute, second )
// --> CONVERT(DATETIME, CONVERT(nchar(2),@month) + '-' + CONVERT(nchar(2),@day) + '-' + CONVERT(nchar(4),@year) +
// ' ' + CONVERT(nchar(2),@hour) + ':' + CONVERT(nchar(2),@minute) + ':' + CONVERT(nchar(2),@second) ,120)
SqlExpression hour = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[3] }, source);
SqlExpression minute = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[4] }, source);
SqlExpression second = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[5] }, source);
SqlExpression date = sql.Concat(year, sql.ValueFromObject("-", false, source), month, sql.ValueFromObject("-", false, source), day);
SqlExpression time = sql.Concat(hour, sql.ValueFromObject(":", false, source), minute, sql.ValueFromObject(":", false, source), second);
SqlExpression dateAndTime = sql.Concat(date, sql.ValueFromObject(' ', false, source), time);
if(sox.Args.Count == 6)
{
return sql.FunctionCall(typeof(DateTime), "CONVERT", new SqlExpression[3] { datetime, dateAndTime, sql.ValueFromObject(120, false, source) }, source);
}
if((sox.Args.Count == 7) && (sox.Args[6].ClrType == typeof(int)))
{
// DateTime(year, month, day, hour, minute, second, millisecond )
// add leading zeros to milliseconds by RIGHT(CONVERT(NCHAR(4),1000+@ms),3)
SqlExpression msRaw = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] {char4,
sql.Add(sql.ValueFromObject(1000, false, source),sox.Args[6])}, source);
SqlExpression ms;
if(this.providerMode == SqlServerProviderMode.SqlCE)
{
//SqlCE doesn't have "RIGHT", so need to use "SUBSTRING"
SqlExpression len = sql.FunctionCall(typeof(int), "LEN", new SqlExpression[1] { msRaw }, source);
SqlExpression startIndex = sql.Binary(SqlNodeType.Sub, len, sql.ValueFromObject(2, false, source));
ms = sql.FunctionCall(typeof(string), "SUBSTRING", new SqlExpression[3] { msRaw, startIndex, sql.ValueFromObject(3, false, source) }, source);
}
else
{
ms = sql.FunctionCall(typeof(string), "RIGHT", new SqlExpression[2] { msRaw, sql.ValueFromObject(3, false, source) }, source);
}
dateAndTime = sql.Concat(dateAndTime, sql.ValueFromObject('.', false, source), ms);
return sql.FunctionCall(typeof(DateTime), "CONVERT", new SqlExpression[3] { datetime, dateAndTime, sql.ValueFromObject(121, false, source) }, source);
}
}
}
throw Error.UnsupportedDateTimeConstructorForm();
}
private SqlExpression TranslateNewString(SqlNew sox)
{
// string(char c, int i)
// --> REPLICATE(@c,@i)
if(sox.ClrType == typeof(string) && sox.Args.Count == 2
&& sox.Args[0].ClrType == typeof(char) && sox.Args[1].ClrType == typeof(int))
{
return sql.FunctionCall(typeof(string), "REPLICATE", new SqlExpression[] { sox.Args[0], sox.Args[1] }, sox.SourceExpression);
}
throw Error.UnsupportedStringConstructorForm();
}
// transform constructors if necessary
internal override SqlExpression VisitNew(SqlNew sox)
{
sox = (SqlNew)base.VisitNew(sox);
if(sox.ClrType == typeof(string))
{
return TranslateNewString(sox);
}
else if(sox.ClrType == typeof(TimeSpan))
{
return TranslateNewTimeSpan(sox);
}
else if(sox.ClrType == typeof(DateTime))
{
return TranslateNewDateTime(sox);
}
else if(sox.ClrType == typeof(DateTimeOffset))
{
return TranslateNewDateTimeOffset(sox);
}
return sox;
}
private static bool IsSupportedStringNew(SqlNew snew)
{
return snew.Args.Count == 2 && snew.Args[0].ClrType == typeof(char) && snew.Args[1].ClrType == typeof(int);
}
private Type GenerateNew(SqlNew sn)
{
LocalBuilder locInstance = gen.DeclareLocal(sn.ClrType);
LocalBuilder locStoreInMember = null;
Label labNewExit = gen.DefineLabel();
Label labAlreadyCached = gen.DefineLabel();
// read all arg values
if(sn.Args.Count > 0)
{
ParameterInfo[] pis = sn.Constructor.GetParameters();
for(int i = 0, n = sn.Args.Count; i < n; i++)
{
this.GenerateExpressionForType(sn.Args[i], pis[i].ParameterType);
}
}
// construct the new instance
if(sn.Constructor != null)
{
gen.Emit(OpCodes.Newobj, sn.Constructor);
gen.Emit(OpCodes.Stloc, locInstance);
}
else if(sn.ClrType.IsValueType)
{
gen.Emit(OpCodes.Ldloca, locInstance);
gen.Emit(OpCodes.Initobj, sn.ClrType);
}
else
{
ConstructorInfo ci = sn.ClrType.GetConstructor(System.Type.EmptyTypes);
gen.Emit(OpCodes.Newobj, ci);
gen.Emit(OpCodes.Stloc, locInstance);
}
// read/write key bindings if there are any
foreach(SqlMemberAssign ma in sn.Members.OrderBy(m => sn.MetaType.GetDataMember(m.Member).Ordinal))
{
MetaDataMember mm = sn.MetaType.GetDataMember(ma.Member);
if(mm.IsPrimaryKey)
{
this.GenerateMemberAssignment(mm, locInstance, ma.Expression, null);
}
}
int iMeta = 0;
if(sn.MetaType.IsEntity)
{
LocalBuilder locCached = gen.DeclareLocal(sn.ClrType);
locStoreInMember = gen.DeclareLocal(typeof(bool));
Label labExit = gen.DefineLabel();
iMeta = this.AddGlobal(typeof(MetaType), sn.MetaType);
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.DataReaderType);
// this.InsertLookup(metaType, locInstance)
gen.Emit(OpCodes.Ldarg_0);
this.GenerateConstInt(iMeta);
gen.Emit(OpCodes.Ldloc, locInstance);
MethodInfo miInsertLookup = orbType.GetMethod(
"InsertLookup",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
null,
new Type[] { typeof(int), typeof(object) },
null
);
Diagnostics.Debug.Assert(miInsertLookup != null);
gen.Emit(GetMethodCallOpCode(miInsertLookup), miInsertLookup);
gen.Emit(OpCodes.Castclass, sn.ClrType);
gen.Emit(OpCodes.Stloc, locCached);
// if cached != instance then already cached
gen.Emit(OpCodes.Ldloc, locCached);
gen.Emit(OpCodes.Ldloc, locInstance);
gen.Emit(OpCodes.Ceq);
gen.Emit(OpCodes.Brfalse, labAlreadyCached);
this.GenerateConstInt(1);
gen.Emit(OpCodes.Stloc, locStoreInMember);
gen.Emit(OpCodes.Br_S, labExit);
gen.MarkLabel(labAlreadyCached);
gen.Emit(OpCodes.Ldloc, locCached);
gen.Emit(OpCodes.Stloc, locInstance);
// signal to not store loaded values in instance...
this.GenerateConstInt(0);
gen.Emit(OpCodes.Stloc, locStoreInMember);
gen.MarkLabel(labExit);
}
// read/write non-key bindings
foreach(SqlMemberAssign ma in sn.Members.OrderBy(m => sn.MetaType.GetDataMember(m.Member).Ordinal))
{
MetaDataMember mm = sn.MetaType.GetDataMember(ma.Member);
if(!mm.IsPrimaryKey)
{
this.GenerateMemberAssignment(mm, locInstance, ma.Expression, locStoreInMember);
}
}
if(sn.MetaType.IsEntity)
{
// don't call SendEntityMaterialized if we already had the instance cached
gen.Emit(OpCodes.Ldloc, locStoreInMember);
this.GenerateConstInt(0);
gen.Emit(OpCodes.Ceq);
gen.Emit(OpCodes.Brtrue, labNewExit);
// send entity materialized event
gen.Emit(OpCodes.Ldarg_0);
this.GenerateConstInt(iMeta);
gen.Emit(OpCodes.Ldloc, locInstance);
Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.compiler.DataReaderType);
MethodInfo miRaiseEvent = orbType.GetMethod(
"SendEntityMaterialized",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
null,
new Type[] { typeof(int), typeof(object) },
null
);
Diagnostics.Debug.Assert(miRaiseEvent != null);
gen.Emit(GetMethodCallOpCode(miRaiseEvent), miRaiseEvent);
}
gen.MarkLabel(labNewExit);
gen.Emit(OpCodes.Ldloc, locInstance);
return sn.ClrType;
}
private SqlExpression TranslateNewDateTimeOffset(SqlNew sox)
{
Expression source = sox.SourceExpression;
if(sox.ClrType == typeof(DateTimeOffset))
{
// DateTimeOffset(DateTime dateTime)
// --> CONVERT(DATETIMEOFFSET, @dateTime)
if(sox.Args.Count == 1 && sox.Args[0].ClrType == typeof(DateTime))
{
return sql.FunctionCall(typeof(DateTimeOffset), "TODATETIMEOFFSET",
new SqlExpression[2] { sox.Args[0], sql.ValueFromObject(0, false, source) },
source);
}
// DateTimeOffset(DateTime dateTime, TimeSpan timeSpan)
// --> DATEADD(DATETIMEOFFSET, @dateTimePart)
if(sox.Args.Count == 2 && sox.Args[0].ClrType == typeof(DateTime) && sox.Args[1].ClrType == typeof(TimeSpan))
{
return sql.FunctionCall(typeof(DateTimeOffset), "TODATETIMEOFFSET",
new SqlExpression[2]
{
sox.Args[0],
sql.ConvertToInt(sql.ConvertToBigint(sql.Divide(sql.ConvertTimeToDouble(sox.Args[1]), TimeSpan.TicksPerMinute)))
},
source);
}
// DateTimeOffset(year, month, day, hour, minute, second, [millisecond,] timeSpan)
//
if(sox.Args.Count >= 7 &&
sox.Args[0].ClrType == typeof(int) && sox.Args[1].ClrType == typeof(int) && sox.Args[2].ClrType == typeof(int) &&
sox.Args[3].ClrType == typeof(int) && sox.Args[4].ClrType == typeof(int) && sox.Args[5].ClrType == typeof(int))
{
SqlExpression char2 = sql.FunctionCall(typeof(void), "NCHAR", new SqlExpression[1] { sql.ValueFromObject(2, false, source) }, source);
SqlExpression char4 = sql.FunctionCall(typeof(void), "NCHAR", new SqlExpression[1] { sql.ValueFromObject(4, false, source) }, source);
SqlExpression char5 = sql.FunctionCall(typeof(void), "NCHAR", new SqlExpression[1] { sql.ValueFromObject(5, false, source) }, source);
// add leading zeros to year by RIGHT(CONVERT(NCHAR(5),10000+@ms),4)
SqlExpression yyRaw = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] {char5,
sql.Add(sql.ValueFromObject(10000, false, source),sox.Args[0])}, source);
SqlExpression year = sql.FunctionCall(typeof(string), "RIGHT", new SqlExpression[2] { yyRaw, sql.ValueFromObject(4, false, source) }, source);
SqlExpression month = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[1] }, source);
SqlExpression day = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[2] }, source);
SqlExpression hour = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[3] }, source);
SqlExpression minute = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[4] }, source);
SqlExpression second = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] { char2, sox.Args[5] }, source);
SqlExpression date = sql.Concat(year, sql.ValueFromObject("-", false, source), month, sql.ValueFromObject("-", false, source), day);
SqlExpression time = sql.Concat(hour, sql.ValueFromObject(":", false, source), minute, sql.ValueFromObject(":", false, source), second);
SqlExpression datetimeoffset = new SqlVariable(typeof(void), null, "DATETIMEOFFSET", source);
SqlExpression result, dateAndTime;
int timeSpanIndex;
if(sox.Args.Count == 7 && sox.Args[6].ClrType == typeof(TimeSpan))
{
timeSpanIndex = 6;
dateAndTime = sql.Concat(date, sql.ValueFromObject(' ', false, source), time);
result = sql.FunctionCall(typeof(DateTimeOffset), "CONVERT", new SqlExpression[3] { datetimeoffset, dateAndTime, sql.ValueFromObject(120, false, source) }, source);
}
else if(sox.Args.Count == 8 && sox.Args[6].ClrType == typeof(int) && sox.Args[7].ClrType == typeof(TimeSpan))
{
timeSpanIndex = 7;
// add leading zeros to milliseconds by RIGHT(CONVERT(NCHAR(4),1000+@ms),3)
SqlExpression msRaw = sql.FunctionCall(typeof(string), "CONVERT", new SqlExpression[2] {char4,
sql.Add(sql.ValueFromObject(1000, false, source),sox.Args[6])}, source);
SqlExpression ms = sql.FunctionCall(typeof(string), "RIGHT", new SqlExpression[2] { msRaw, sql.ValueFromObject(3, false, source) }, source);
dateAndTime = sql.Concat(date, sql.ValueFromObject(' ', false, source), time, sql.ValueFromObject('.', false, source), ms);
result = sql.FunctionCall(typeof(DateTimeOffset), "CONVERT", new SqlExpression[3] { datetimeoffset, dateAndTime, sql.ValueFromObject(121, false, source) }, source);
}
else
{
throw Error.UnsupportedDateTimeOffsetConstructorForm();
}
return sql.FunctionCall(typeof(DateTimeOffset), "TODATETIMEOFFSET",
new SqlExpression[2]
{
result,
sql.ConvertToInt(sql.ConvertToBigint(sql.Divide(sql.ConvertTimeToDouble(sox.Args[timeSpanIndex]), TimeSpan.TicksPerMinute)))
},
source);
}
}
throw Error.UnsupportedDateTimeOffsetConstructorForm();
}
private SqlExpression ExpandTogether(List<SqlExpression> exprs)
{
switch(exprs[0].NodeType)
{
case SqlNodeType.MethodCall:
{
SqlMethodCall[] mcs = new SqlMethodCall[exprs.Count];
for(int i = 0; i < mcs.Length; ++i)
{
mcs[i] = (SqlMethodCall)exprs[i];
}
List<SqlExpression> expandedArgs = new List<SqlExpression>();
for(int i = 0; i < mcs[0].Arguments.Count; ++i)
{
List<SqlExpression> args = new List<SqlExpression>();
for(int j = 0; j < mcs.Length; ++j)
{
args.Add(mcs[j].Arguments[i]);
}
SqlExpression expanded = this.ExpandTogether(args);
expandedArgs.Add(expanded);
}
return factory.MethodCall(mcs[0].Method, mcs[0].Object, expandedArgs.ToArray(), mcs[0].SourceExpression);
}
case SqlNodeType.ClientCase:
{
// Are they all the same?
SqlClientCase[] scs = new SqlClientCase[exprs.Count];
scs[0] = (SqlClientCase)exprs[0];
for(int i = 1; i < scs.Length; ++i)
{
scs[i] = (SqlClientCase)exprs[i];
}
// Expand expressions together.
List<SqlExpression> expressions = new List<SqlExpression>();
for(int i = 0; i < scs.Length; ++i)
{
expressions.Add(scs[i].Expression);
}
SqlExpression expression = this.ExpandTogether(expressions);
// Expand individual expressions together.
List<SqlClientWhen> whens = new List<SqlClientWhen>();
for(int i = 0; i < scs[0].Whens.Count; ++i)
{
List<SqlExpression> scos = new List<SqlExpression>();
for(int j = 0; j < scs.Length; ++j)
{
SqlClientWhen when = scs[j].Whens[i];
scos.Add(when.Value);
}
whens.Add(new SqlClientWhen(scs[0].Whens[i].Match, this.ExpandTogether(scos)));
}
return new SqlClientCase(scs[0].ClrType, expression, whens, scs[0].SourceExpression);
}
case SqlNodeType.TypeCase:
{
// Are they all the same?
SqlTypeCase[] tcs = new SqlTypeCase[exprs.Count];
tcs[0] = (SqlTypeCase)exprs[0];
for(int i = 1; i < tcs.Length; ++i)
{
tcs[i] = (SqlTypeCase)exprs[i];
}
// Expand discriminators together.
List<SqlExpression> discriminators = new List<SqlExpression>();
for(int i = 0; i < tcs.Length; ++i)
{
discriminators.Add(tcs[i].Discriminator);
}
SqlExpression discriminator = this.ExpandTogether(discriminators);
// Write expanded discriminators back in.
for(int i = 0; i < tcs.Length; ++i)
{
tcs[i].Discriminator = discriminators[i];
}
// Expand individual type bindings together.
List<SqlTypeCaseWhen> whens = new List<SqlTypeCaseWhen>();
for(int i = 0; i < tcs[0].Whens.Count; ++i)
{
List<SqlExpression> scos = new List<SqlExpression>();
for(int j = 0; j < tcs.Length; ++j)
{
SqlTypeCaseWhen when = tcs[j].Whens[i];
scos.Add(when.TypeBinding);
}
SqlExpression expanded = this.ExpandTogether(scos);
whens.Add(new SqlTypeCaseWhen(tcs[0].Whens[i].Match, expanded));
}
return factory.TypeCase(tcs[0].ClrType, tcs[0].RowType, discriminator, whens, tcs[0].SourceExpression);
}
case SqlNodeType.New:
{
// first verify all are similar client objects...
SqlNew[] cobs = new SqlNew[exprs.Count];
cobs[0] = (SqlNew)exprs[0];
for(int i = 1, n = exprs.Count; i < n; i++)
{
if(exprs[i] == null || exprs[i].NodeType != SqlNodeType.New)
throw Error.UnionIncompatibleConstruction();
cobs[i] = (SqlNew)exprs[1];
if(cobs[i].Members.Count != cobs[0].Members.Count)
throw Error.UnionDifferentMembers();
for(int m = 0, mn = cobs[0].Members.Count; m < mn; m++)
{
if(cobs[i].Members[m].Member != cobs[0].Members[m].Member)
{
throw Error.UnionDifferentMemberOrder();
}
}
}
SqlMemberAssign[] bindings = new SqlMemberAssign[cobs[0].Members.Count];
for(int m = 0, mn = bindings.Length; m < mn; m++)
{
List<SqlExpression> mexprs = new List<SqlExpression>();
for(int i = 0, n = exprs.Count; i < n; i++)
{
mexprs.Add(cobs[i].Members[m].Expression);
}
bindings[m] = new SqlMemberAssign(cobs[0].Members[m].Member, this.ExpandTogether(mexprs));
for(int i = 0, n = exprs.Count; i < n; i++)
{
cobs[i].Members[m].Expression = mexprs[i];
}
}
SqlExpression[] arguments = new SqlExpression[cobs[0].Args.Count];
for(int m = 0, mn = arguments.Length; m < mn; ++m)
{
List<SqlExpression> mexprs = new List<SqlExpression>();
for(int i = 0, n = exprs.Count; i < n; i++)
{
mexprs.Add(cobs[i].Args[m]);
}
arguments[m] = ExpandTogether(mexprs);
}
return factory.New(cobs[0].MetaType, cobs[0].Constructor, arguments, cobs[0].ArgMembers, bindings, exprs[0].SourceExpression);
}
case SqlNodeType.Link:
{
SqlLink[] links = new SqlLink[exprs.Count];
links[0] = (SqlLink)exprs[0];
for(int i = 1, n = exprs.Count; i < n; i++)
{
if(exprs[i] == null || exprs[i].NodeType != SqlNodeType.Link)
throw Error.UnionIncompatibleConstruction();
links[i] = (SqlLink)exprs[i];
if(links[i].KeyExpressions.Count != links[0].KeyExpressions.Count ||
links[i].Member != links[0].Member ||
(links[i].Expansion != null) != (links[0].Expansion != null))
throw Error.UnionIncompatibleConstruction();
}
SqlExpression[] kexprs = new SqlExpression[links[0].KeyExpressions.Count];
List<SqlExpression> lexprs = new List<SqlExpression>();
for(int k = 0, nk = links[0].KeyExpressions.Count; k < nk; k++)
{
lexprs.Clear();
for(int i = 0, n = exprs.Count; i < n; i++)
{
lexprs.Add(links[i].KeyExpressions[k]);
}
kexprs[k] = this.ExpandTogether(lexprs);
for(int i = 0, n = exprs.Count; i < n; i++)
{
links[i].KeyExpressions[k] = lexprs[i];
}
}
SqlExpression expansion = null;
if(links[0].Expansion != null)
{
lexprs.Clear();
for(int i = 0, n = exprs.Count; i < n; i++)
{
lexprs.Add(links[i].Expansion);
}
expansion = this.ExpandTogether(lexprs);
for(int i = 0, n = exprs.Count; i < n; i++)
{
links[i].Expansion = lexprs[i];
}
}
return new SqlLink(links[0].Id, links[0].RowType, links[0].ClrType, links[0].SqlType, links[0].Expression, links[0].Member, kexprs, expansion, links[0].SourceExpression);
}
case SqlNodeType.Value:
{
/*
* ExprSet of all literals of the same value reduce to just a single literal.
*/
SqlValue val0 = (SqlValue)exprs[0];
for(int i = 1; i < exprs.Count; ++i)
{
SqlValue val = (SqlValue)exprs[i];
if(!Equals(val.Value, val0.Value))
return this.ExpandIntoExprSet(exprs);
}
return val0;
}
case SqlNodeType.OptionalValue:
{
if(exprs[0].SqlType.CanBeColumn)
{
goto default;
}
List<SqlExpression> hvals = new List<SqlExpression>(exprs.Count);
List<SqlExpression> vals = new List<SqlExpression>(exprs.Count);
for(int i = 0, n = exprs.Count; i < n; i++)
{
if(exprs[i] == null || exprs[i].NodeType != SqlNodeType.OptionalValue)
{
throw Error.UnionIncompatibleConstruction();
}
SqlOptionalValue sov = (SqlOptionalValue)exprs[i];
hvals.Add(sov.HasValue);
vals.Add(sov.Value);
}
return new SqlOptionalValue(this.ExpandTogether(hvals), this.ExpandTogether(vals));
}
case SqlNodeType.OuterJoinedValue:
{
if(exprs[0].SqlType.CanBeColumn)
{
goto default;
}
List<SqlExpression> values = new List<SqlExpression>(exprs.Count);
for(int i = 0, n = exprs.Count; i < n; i++)
{
if(exprs[i] == null || exprs[i].NodeType != SqlNodeType.OuterJoinedValue)
{
throw Error.UnionIncompatibleConstruction();
}
SqlUnary su = (SqlUnary)exprs[i];
values.Add(su.Operand);
}
return factory.Unary(SqlNodeType.OuterJoinedValue, this.ExpandTogether(values));
}
case SqlNodeType.DiscriminatedType:
{
SqlDiscriminatedType sdt0 = (SqlDiscriminatedType)exprs[0];
List<SqlExpression> foos = new List<SqlExpression>(exprs.Count);
foos.Add(sdt0.Discriminator);
for(int i = 1, n = exprs.Count; i < n; i++)
{
SqlDiscriminatedType sdtN = (SqlDiscriminatedType)exprs[i];
if(sdtN.TargetType != sdt0.TargetType)
{
throw Error.UnionIncompatibleConstruction();
}
foos.Add(sdtN.Discriminator);
}
return factory.DiscriminatedType(this.ExpandTogether(foos), ((SqlDiscriminatedType)exprs[0]).TargetType);
}
case SqlNodeType.ClientQuery:
case SqlNodeType.Multiset:
case SqlNodeType.Element:
case SqlNodeType.Grouping:
throw Error.UnionWithHierarchy();
default:
return this.ExpandIntoExprSet(exprs);
}
}
internal SqlNew New(MetaType type, ConstructorInfo cons, IEnumerable<SqlExpression> args, IEnumerable<MemberInfo> argMembers, IEnumerable<SqlMemberAssign> bindings, Expression sourceExpression)
{
SqlNew tb = new SqlNew(type, typeProvider.From(type.Type), cons, args, argMembers, bindings, sourceExpression);
return tb;
}
internal override SqlExpression VisitNew(SqlNew sox)
{
this.isNew = true;
return base.VisitNew(sox);
}
private SqlExpression TranslateNewTimeSpan(SqlNew sox)
{
if(sox.Args.Count == 1)
{
return sql.ConvertTo(typeof(TimeSpan), sox.Args[0]);
}
else if(sox.Args.Count == 3)
{
// TimeSpan(hours, minutes, seconds)
SqlExpression hours = sql.ConvertToBigint(sox.Args[0]);
SqlExpression minutes = sql.ConvertToBigint(sox.Args[1]);
SqlExpression seconds = sql.ConvertToBigint(sox.Args[2]);
SqlExpression TicksFromHours = sql.Multiply(hours, TimeSpan.TicksPerHour);
SqlExpression TicksFromMinutes = sql.Multiply(minutes, TimeSpan.TicksPerMinute);
SqlExpression TicksFromSeconds = sql.Multiply(seconds, TimeSpan.TicksPerSecond);
return sql.ConvertTo(typeof(TimeSpan), sql.Add(TicksFromHours, TicksFromMinutes, TicksFromSeconds));
}
else
{
SqlExpression days = sql.ConvertToBigint(sox.Args[0]);
SqlExpression hours = sql.ConvertToBigint(sox.Args[1]);
SqlExpression minutes = sql.ConvertToBigint(sox.Args[2]);
SqlExpression seconds = sql.ConvertToBigint(sox.Args[3]);
SqlExpression TicksFromDays = sql.Multiply(days, TimeSpan.TicksPerDay);
SqlExpression TicksFromHours = sql.Multiply(hours, TimeSpan.TicksPerHour);
SqlExpression TicksFromMinutes = sql.Multiply(minutes, TimeSpan.TicksPerMinute);
SqlExpression TicksFromSeconds = sql.Multiply(seconds, TimeSpan.TicksPerSecond);
SqlExpression totalTicks = sql.Add(TicksFromDays, TicksFromHours, TicksFromMinutes, TicksFromSeconds);
if(sox.Args.Count == 4)
{
// TimeSpan(days, hours, minutes, seconds)
return sql.ConvertTo(typeof(TimeSpan), totalTicks);
}
else if(sox.Args.Count == 5)
{
// TimeSpan(days, hours, minutes, seconds, milliseconds)
SqlExpression milliseconds = sql.ConvertToBigint(sox.Args[4]);
SqlExpression ticksFromMs = sql.Multiply(milliseconds, TimeSpan.TicksPerMillisecond);
return sql.ConvertTo(typeof(TimeSpan), sql.Add(totalTicks, ticksFromMs));
}
}
throw Error.UnsupportedTimeSpanConstructorForm();
}