internal override SqlExpression VisitUnaryOperator(SqlUnary fc) {
// process the arguments
SqlExpression result = base.VisitUnaryOperator(fc);
if (result is SqlUnary) {
SqlUnary unary = (SqlUnary)result;
switch (unary.NodeType) {
case SqlNodeType.ClrLength:
SqlExpression expr = unary.Operand;
result = sql.DATALENGTH(expr);
if (expr.SqlType.IsUnicodeType) {
result = sql.Divide(result, sql.ValueFromObject(2, expr.SourceExpression));
}
result = sql.ConvertToInt(result);
break;
default:
break;
}
}
return result;
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
base.VisitUnaryOperator(uo);
if (uo.NodeType != SqlNodeType.Convert && uo.Operand != null && uo.Operand.SqlType != null) {
uo.SetSqlType(this.typeProvider.PredictTypeForUnary(uo.NodeType, uo.Operand.SqlType));
}
return uo;
}
public void Visit(SqlUnary node)
{
if (!node.Operand.IsNullReference())
{
Visit(node.Operand);
}
}
internal override SqlExpression VisitTreat(SqlUnary t)
{
t.Operand = this.VisitExpression(t.Operand);
Type treatType = t.ClrType;
Type originalType = model.GetMetaType(t.Operand.ClrType).InheritanceRoot.Type;
// .NET nullability rules are that typeof(int)==typeof(int?). Let's be consistent with that:
treatType = TypeSystem.GetNonNullableType(treatType);
originalType = TypeSystem.GetNonNullableType(originalType);
if (treatType == originalType)
{
return(t.Operand);
}
if (treatType.IsAssignableFrom(originalType))
{
t.Operand.SetClrType(treatType);
return(t.Operand);
}
if (!treatType.IsAssignableFrom(originalType) && !originalType.IsAssignableFrom(treatType))
{
if (!treatType.IsInterface && !originalType.IsInterface)
{ // You can't tell when there's an interface involved.
// We statically know the TREAT will result in NULL.
return(sql.TypedLiteralNull(treatType, t.SourceExpression));
}
}
//return base.VisitTreat(t);
return(t);
}
internal SqlExpression TranslateLinkIsNull(SqlUnary expr)
{
System.Diagnostics.Debug.Assert(expr.NodeType == SqlNodeType.IsNull || expr.NodeType == SqlNodeType.IsNotNull);
SqlLink link = expr.Operand as SqlLink;
if (!(link != null && link.Member.IsAssociation && link.Member.Association.IsForeignKey))
{
return(expr);
}
List <SqlExpression> exprs = link.KeyExpressions;
System.Diagnostics.Debug.Assert(exprs.Count > 0);
SqlExpression exp = null;
SqlNodeType combo = (expr.NodeType == SqlNodeType.IsNull) ? SqlNodeType.Or : SqlNodeType.And;
for (int i = 0, n = exprs.Count; i < n; i++)
{
SqlExpression compare = sql.Unary(expr.NodeType, sql.DoNotVisitExpression(exprs[i]), expr.SourceExpression);
if (exp == null)
{
exp = compare;
}
else
{
exp = sql.Binary(combo, exp, compare);
}
}
return(exp);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
//if (uo.NodeType == SqlNodeType.Convert)
//{
// this.Visit(uo.Operand);
// return uo;
//}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
//IFNULL
//if (!TypeSystem.IsNullableType(uo.ClrType))
//{
sb.Append("COALESCE(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
if (uo.Operand == null)
{
sb.Append("*");
}
else
{
Visit(uo.Operand);
}
sb.Append("),0)");
return(uo);
//}
}
return(base.VisitUnaryOperator(uo));
}
public override string Translate(SqlCompilerContext context, SqlUnary node, NodeSection section)
{
//substitute UNIQUE predicate with a more complex EXISTS predicate,
//because UNIQUE is not supported
if (node.NodeType == SqlNodeType.Unique)
{
if (node.Operand is SqlSubQuery origSubselect)
{
var origQuery = SqlDml.QueryRef(origSubselect.Query);
var existsOp = SqlDml.Select(origQuery);
existsOp.Columns.Add(1);
existsOp.Where = true;
foreach (SqlColumn col in origQuery.Columns)
{
existsOp.Where = existsOp.Where && SqlDml.IsNotNull(col);
existsOp.GroupBy.Add(col);
}
existsOp.Having = SqlDml.Count(SqlDml.Asterisk) > 1;
existsOp.Limit = 1;
node.ReplaceWith(SqlDml.Not(SqlDml.Exists(existsOp)));
}
}
return(base.Translate(context, node, section));
}
private static SqlColumn UnwrapColumn(SqlExpression expr)
{
System.Diagnostics.Debug.Assert(expr != null);
SqlUnary exprAsUnary = expr as SqlUnary;
if (exprAsUnary != null)
{
expr = exprAsUnary.Operand;
}
SqlColumn exprAsColumn = expr as SqlColumn;
if (exprAsColumn != null)
{
return(exprAsColumn);
}
SqlColumnRef exprAsColumnRef = expr as SqlColumnRef;
if (exprAsColumnRef != null)
{
return(exprAsColumnRef.GetRootColumn());
}
//
// For all other types return null to revert to default behavior for Equals()
// and GetHashCode()
//
return(null);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
SqlNodeType nodeType = uo.NodeType;
if (nodeType <= SqlNodeType.LongCount)
{
switch (nodeType)
{
case SqlNodeType.Avg:
case SqlNodeType.Count:
case SqlNodeType.LongCount:
goto Label_002B;
}
goto Label_0034;
}
if (((nodeType != SqlNodeType.Max) && (nodeType != SqlNodeType.Min)) && (nodeType != SqlNodeType.Sum))
{
goto Label_0034;
}
Label_002B:
this.hasAggregates = true;
return(uo);
Label_0034:
return(base.VisitUnaryOperator(uo));
}
internal override SqlExpression VisitUnaryOperator(SqlUnary fc)
{
// process the arguments
SqlExpression result = base.VisitUnaryOperator(fc);
if (result is SqlUnary)
{
SqlUnary unary = (SqlUnary)result;
switch (unary.NodeType)
{
case SqlNodeType.ClrLength:
SqlExpression expr = unary.Operand;
result = sql.FunctionCallDataLength(expr);
if (expr.SqlType.IsUnicodeType)
{
result = sql.Divide(result, sql.ValueFromObject(2, expr.SourceExpression));
}
result = sql.ConvertToInt(result);
break;
default:
break;
}
}
return(result);
}
public void SqlUnaryCloneTest()
{
SqlUnary u = -SqlDml.Literal(1);
SqlUnary uClone = (SqlUnary)u.Clone();
Assert.AreNotEqual(u, uClone);
Assert.AreEqual(u.NodeType, uClone.NodeType);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
if (uo.NodeType.IsUnaryOperatorExpectingPredicateOperand()) {
uo.Operand = this.VisitPredicate(uo.Operand);
} else {
uo.Operand = this.VisitExpression(uo.Operand);
}
return uo;
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType == SqlNodeType.Convert)
{
return(VisitExpression(uo.Operand));
}
return(base.VisitUnaryOperator(uo));
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
base.VisitUnaryOperator(uo);
if (uo.NodeType != SqlNodeType.Convert && uo.Operand != null && uo.Operand.SqlType != null)
{
uo.SetSqlType(this.typeProvider.PredictTypeForUnary(uo.NodeType, uo.Operand.SqlType));
}
return(uo);
}
/// <inheritdoc/>
public override void Visit(SqlUnary node)
{
if (node.NodeType == SqlNodeType.BitNot)
{
Visit(BitNot(node.Operand));
return;
}
base.Visit(node);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType.IsUnaryOperatorExpectingPredicateOperand())
{
uo.Operand = this.VisitPredicate(uo.Operand);
return(uo);
}
uo.Operand = this.VisitExpression(uo.Operand);
return(uo);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType == SqlNodeType.Max || uo.NodeType == SqlNodeType.Min ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
Debug.Assert(uo.ClrType != null);
sb.Append("IIF(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
if (uo.Operand == null)
{
sb.Append("*");
}
else
{
Visit(uo.Operand);
}
sb.Append(")");
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format(" IS NULL, '{0}', ", ((DateTime)defaultValue).ToShortDateString()));
}
else if (defaultValue is string)
{
sb.Append(string.Format(" IS NULL, '{0}', ", defaultValue));
}
else
{
sb.Append(string.Format(" IS NULL, {0}, ", defaultValue));
}
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
if (uo.Operand == null)
{
sb.Append("*");
}
else
{
Visit(uo.Operand);
}
sb.Append(")");
sb.Append(")");
return(uo);
}
return(base.VisitUnaryOperator(uo));
}
protected override SqlExpression TranslateConverter(SqlUnary uo)
{
sb.Append("CAST(");
QueryFormatOptions none = QueryFormatOptions.None;
if (uo.Operand.SqlType.CanSuppressSizeForConversionToString)
{
none = QueryFormatOptions.SuppressSize;
}
Visit(uo.Operand);
sb.Append(" AS ");
var sqlType = (MySqlDataType)uo.SqlType;
switch (sqlType.Category)
{
case DBTypeCategory.Binary:
sb.Append("BINARY");
break;
case DBTypeCategory.Numeric:
switch (sqlType.SqlDbType)
{
case MySqlDbType.Decimal:
case MySqlDbType.Double:
case MySqlDbType.Float:
sb.Append("DECIMAL");
break;
default:
if (sqlType.SqlDbType.ToString()[0] == 'U')
{
sb.Append("UNSIGNED");
}
else
{
sb.Append("SIGNED");
}
break;
}
break;
case DBTypeCategory.Text:
sb.Append("CHAR");
break;
case DBTypeCategory.DateTime:
sb.Append("DATETIME");
break;
}
sb.Append(")");
return(uo);
}
public override void Visit(SqlUnary node)
{
switch (node.NodeType)
{
case SqlNodeType.BitNot:
BitNot(node.Operand).AcceptVisitor(this);
return;
default:
base.Visit(node);
return;
}
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType == SqlNodeType.BitNot)
{
sb.Append("BITNOT(");
Visit(uo.Operand);
sb.Append(")");
return(uo);
}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
Debug.Assert(uo.Operand != null);
sb.Append("NVL(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
Visit(uo.Operand);
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format("), TO_DATE('{0}', 'YYYY-MM-DD'))", ((DateTime)defaultValue).ToString("yyyy-MM-dd")));
}
else if (defaultValue is string)
{
sb.Append(string.Format("),'{0}')", defaultValue));
}
else
{
sb.Append(string.Format("),{0})", defaultValue));
}
//sb.Append("),0)");
return(uo);
}
//if (uo.Operand.NodeType == SqlNodeType.Convert)
//{
// var dbType1 = uo.SqlType;
// var dbType2 = uo.SqlType;
// if (dbType1.IsNumeric && dbType2.IsNumeric)
// {
// base.Visit(uo.Operand);
// return uo;
// }
//}
return(base.VisitUnaryOperator(uo));
}
protected override SqlExpression TranslateConverter(SqlUnary uo)
{
if (uo.SqlType.IsNumeric)
{
if (prevConvert != ConvertType.Number)
{
sb.Append("TO_NUMBER(");
prevConvert = ConvertType.Number;
Visit(uo.Operand);
sb.Append(")");
}
else
{
Visit(uo.Operand);
}
}
else if (uo.SqlType.IsString || uo.SqlType.IsChar)
{
if (prevConvert != ConvertType.Char)
{
prevConvert = ConvertType.Char;
sb.Append("TO_CHAR(");
Visit(uo.Operand);
sb.Append(")");
}
else
{
Visit(uo.Operand);
}
}
else if (uo.ClrType == typeof(DateTime))
{
if (prevConvert != ConvertType.Date)
{
prevConvert = ConvertType.Date;
sb.Append("TO_DATE(");
Visit(uo.Operand);
sb.Append(",'YYYY-MM-DD HH24:MI:SS')");
}
else
{
Visit(uo.Operand);
}
}
else
{
Visit(uo.Operand);
}
return(uo);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
switch (uo.NodeType) {
case SqlNodeType.Min:
case SqlNodeType.Max:
case SqlNodeType.Avg:
case SqlNodeType.Sum:
case SqlNodeType.Count:
case SqlNodeType.LongCount:
this.hasAggregates = true;
return uo;
default:
return base.VisitUnaryOperator(uo);
}
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
uo.Operand = this.VisitExpression(uo.Operand);
if (uo.NodeType != SqlNodeType.Convert) {
return uo;
}
ProviderType oldSqlType = uo.Operand.SqlType;
ProviderType newSqlType = uo.SqlType;
Type oldClrType = TypeSystem.GetNonNullableType(uo.Operand.ClrType);
Type newClrType = TypeSystem.GetNonNullableType(uo.ClrType);
if (newClrType == typeof(char)) {
if (oldClrType == typeof(bool)) {
throw Error.ConvertToCharFromBoolNotSupported();
}
if (oldSqlType.IsNumeric) {
// numeric --> char
return sql.FunctionCall(uo.ClrType, "NCHAR", new SqlExpression[] { uo.Operand }, uo.SourceExpression);
}
if (StringConversionIsSafe(oldSqlType, newSqlType)) {
if (StringConversionIsNeeded(oldSqlType, newSqlType)) {
// set the new size to the (potentially smaller) oldSqlType.Size
uo.SetSqlType(sql.TypeProvider.From(uo.ClrType, oldSqlType.HasSizeOrIsLarge ? oldSqlType.Size : (int?)null));
}
} else {
throw Error.UnsafeStringConversion(oldSqlType.ToQueryString(), newSqlType.ToQueryString());
}
} else if (oldClrType == typeof(char) && (oldSqlType.IsChar || oldSqlType.IsString) && newSqlType.IsNumeric) {
// char --> int
return sql.FunctionCall(newClrType, sql.TypeProvider.From(typeof(int)), "UNICODE", new SqlExpression[] { uo.Operand }, uo.SourceExpression);
} else if (newClrType == typeof(string)) {
if (oldClrType == typeof(double)) {
// use longer format if it was a double in the CLR expression
return ConvertDoubleToString(uo.Operand, uo.ClrType);
} else if (oldClrType == typeof(bool)) {
// use 'true' or 'false' if it was a bool in the CLR expression
return ConvertBitToString(uo.Operand, uo.ClrType);
} else if (StringConversionIsSafe(oldSqlType, newSqlType)) {
if (StringConversionIsNeeded(oldSqlType, newSqlType)) {
// set the new size to the (potentially smaller) oldSqlType.Size
uo.SetSqlType(sql.TypeProvider.From(uo.ClrType, oldSqlType.HasSizeOrIsLarge ? oldSqlType.Size : (int?)null));
}
} else {
throw Error.UnsafeStringConversion(oldSqlType.ToQueryString(), newSqlType.ToQueryString());
}
}
return uo;
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
//if (uo.NodeType == SqlNodeType.Convert)
//{
// this.Visit(uo.Operand);
// return uo;
//}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
//IFNULL
//if (!TypeSystem.IsNullableType(uo.ClrType))
//{
sb.Append("COALESCE(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
if (uo.Operand == null)
{
sb.Append("*");
}
else
{
Visit(uo.Operand);
}
//============================================================
// 说明：增加对类型的判断
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format("),'{0}') ", ((DateTime)defaultValue).ToShortDateString()));
}
else if (defaultValue is string)
{
sb.Append(string.Format("),'{0}') ", defaultValue));
}
else
{
sb.Append(string.Format("),{0}) ", defaultValue));
}
//============================================================
//sb.Append("),0)"); 旧代码
//============================================================
return(uo);
//}
}
return(base.VisitUnaryOperator(uo));
}
protected override SqlExpression TranslateConverter(SqlUnary uo)
{
sb.Append("CAST(");
QueryFormatOptions none = QueryFormatOptions.None;
if (uo.Operand.SqlType.CanSuppressSizeForConversionToString)
{
none = QueryFormatOptions.SuppressSize;
}
Visit(uo.Operand);
sb.Append(" AS ");
sb.Append(uo.SqlType.ToQueryString(none));
sb.Append(")");
return(uo);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
switch (uo.NodeType)
{
case SqlNodeType.Min:
case SqlNodeType.Max:
case SqlNodeType.Avg:
case SqlNodeType.Sum:
case SqlNodeType.Count:
case SqlNodeType.LongCount:
this.hasAggregates = true;
return(uo);
default:
return(base.VisitUnaryOperator(uo));
}
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType == SqlNodeType.BitNot)
{
sb.Append("BITNOT(");
Visit(uo.Operand);
sb.Append(")");
return(uo);
}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
Debug.Assert(uo.Operand != null);
sb.Append("NVL(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
Visit(uo.Operand);
//============================================================
// 说明：增加对类型的判断
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format("), CAST('{0}' AS DATE))", ((DateTime)defaultValue).ToShortDateString()));
}
else if (defaultValue is string)
{
sb.Append(string.Format("),'{0}')", defaultValue));
}
else
{
sb.Append(string.Format("),{0})", defaultValue));
}
//============================================================
//sb.Append("),0)"); 旧代码
//============================================================
return(uo);
}
return(base.VisitUnaryOperator(uo));
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
//if (uo.NodeType == SqlNodeType.Convert)
//{
//
// base.Visit(uo.Operand);
// return uo;
//}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
//if (!TypeSystem.IsNullableType(uo.ClrType))
//{
sb.Append("IFNULL(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
if (uo.Operand == null)
{
sb.Append("*");
}
else
{
Visit(uo.Operand);
}
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format("), CAST('{0}' AS DATETIME))", ((DateTime)defaultValue).ToShortDateString()));
}
// sb.Append(string.Format("), DATE('{0}'))", ((DateTime)defaultValue).ToString("yyyy-MM-dd")));
else if (defaultValue is string)
{
sb.Append(string.Format("),'{0}')", defaultValue));
}
else
{
sb.Append(string.Format("),{0})", defaultValue));
}
return(uo);
}
return(base.VisitUnaryOperator(uo));
}
//禁用转换
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
//dont's use convert function
if (uo.NodeType == SqlNodeType.Convert)
{
Visit(uo.Operand);
return(uo);
}
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
//if (!TypeSystem.IsNullableType(uo.ClrType))
//{
Debug.Assert(uo.Operand != null);
sb.Append("IFNULL(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
Visit(uo.Operand);
//============================================================
// 说明：增加对类型的判断
var defaultValue = TypeSystem.GetDefaultValue(uo.ClrType);
if (defaultValue is DateTime)
{
sb.Append(string.Format("), DATE('{0}'))", ((DateTime)defaultValue).ToShortDateString()));
}
else if (defaultValue is string)
{
sb.Append(string.Format("),'{0}')", defaultValue));
}
else
{
sb.Append(string.Format("),{0})", defaultValue));
}
//============================================================
//sb.Append("),0)"); 旧代码
//============================================================
return(uo);
//}
}
return(base.VisitUnaryOperator(uo));
}
protected override SqlExpression VisitUnary(SqlUnary expr)
{
string op = GetUnaryOperator(expr.Operation);
switch (expr.Operation)
{
case SqlUnaryOperation.IsNull:
case SqlUnaryOperation.IsNotNull:
AddParentheses(expr.Operand, expr);
_builder.Append(op);
break;
default:
_builder.Append(op);
AddParentheses(expr.Operand, expr);
break;
}
return(expr);
}
//internal override string GetBoolValue(bool value)
//{
// return value ? "true" : "false";
//}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo)
{
if (uo.NodeType == SqlNodeType.Min || uo.NodeType == SqlNodeType.Max ||
uo.NodeType == SqlNodeType.Avg || uo.NodeType == SqlNodeType.Sum)
{
//if (!TypeSystem.IsNullableType(uo.ClrType))
//{
Debug.Assert(uo.Operand != null);
sb.Append("IFNULL(");
sb.Append(GetOperator(uo.NodeType));
sb.Append("(");
Visit(uo.Operand);
sb.Append("),0)");
return(uo);
//}
}
return(base.VisitUnaryOperator(uo));
}
public void SqlUnaryReplacingTest()
{
SqlUnary u = -SqlDml.Literal(1);
SqlUnary uReplacing = ~SqlDml.Literal(2);
u.ReplaceWith(uReplacing);
bool passed = false;
try {
u.ReplaceWith(1);
}
catch {
passed = true;
}
Assert.IsTrue(passed);
Assert.AreNotEqual(u, uReplacing);
Assert.AreEqual(u.NodeType, uReplacing.NodeType);
Assert.AreEqual(u.Operand, uReplacing.Operand);
}
protected override SqlExpression TranslateConverter(SqlUnary uo)
{
//兼容类型，无需转换
switch (((SqlDataType <DB2Type>)uo.SqlType).Category)
{
case DBTypeCategory.Text:
if (uo.Operand.ClrType == typeof(char) || uo.Operand.ClrType == typeof(string))
{
Visit(uo.Operand);
return(uo);
}
break;
case DBTypeCategory.Numeric:
//if (uo.Operand.ClrType == typeof(int) || uo.Operand.ClrType == typeof(Int16) ||
// uo.Operand.ClrType == typeof(long) || uo.Operand.ClrType == typeof(byte))
if (uo.Operand.ClrType.IsValueType)
{
Visit(uo.Operand);
return(uo);
}
break;
}
sb.Append("CAST(");
QueryFormatOptions none = QueryFormatOptions.None;
if (uo.Operand.SqlType.CanSuppressSizeForConversionToString)
{
none = QueryFormatOptions.SuppressSize;
}
Visit(uo.Operand);
sb.Append(" AS ");
sb.Append(uo.SqlType.ToQueryString(none));
sb.Append(")");
return(uo);
}
internal override SqlExpression VisitCast(SqlUnary c) {
sb.Append("CAST(");
this.Visit(c.Operand);
sb.Append(" AS ");
QueryFormatOptions options = QueryFormatOptions.None;
if (c.Operand.SqlType.CanSuppressSizeForConversionToString) {
options = QueryFormatOptions.SuppressSize;
}
sb.Append(c.SqlType.ToQueryString(options));
sb.Append(")");
return c;
}
protected virtual SqlExpression VisitUnary(SqlUnary expr)
{
return expr;
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
switch (uo.NodeType) {
case SqlNodeType.Not:
case SqlNodeType.Not2V:
this.sb.Append(GetOperator(uo.NodeType));
this.sb.Append(" ");
this.VisitWithParens(uo.Operand, uo);
break;
case SqlNodeType.Negate:
case SqlNodeType.BitNot:
this.sb.Append(GetOperator(uo.NodeType));
this.VisitWithParens(uo.Operand, uo);
break;
case SqlNodeType.Count:
case SqlNodeType.LongCount:
case SqlNodeType.Max:
case SqlNodeType.Min:
case SqlNodeType.Sum:
case SqlNodeType.Avg:
case SqlNodeType.Stddev:
case SqlNodeType.ClrLength:{
this.sb.Append(GetOperator(uo.NodeType));
this.sb.Append("(");
if (uo.Operand == null) {
this.sb.Append("*");
} else {
this.Visit(uo.Operand);
}
this.sb.Append(")");
break;
}
case SqlNodeType.IsNull:
case SqlNodeType.IsNotNull: {
this.VisitWithParens(uo.Operand, uo);
sb.Append(" ");
sb.Append(GetOperator(uo.NodeType));
break;
}
case SqlNodeType.Convert: {
this.sb.Append("CONVERT(");
QueryFormatOptions options = QueryFormatOptions.None;
if(uo.Operand.SqlType.CanSuppressSizeForConversionToString) {
options = QueryFormatOptions.SuppressSize;
}
this.sb.Append(uo.SqlType.ToQueryString(options));
this.sb.Append(",");
this.Visit(uo.Operand);
this.sb.Append(")");
break;
}
case SqlNodeType.ValueOf:
case SqlNodeType.OuterJoinedValue:
this.Visit(uo.Operand); // no op
break;
default:
throw Error.InvalidFormatNode(uo.NodeType);
}
return uo;
}
internal virtual SqlExpression VisitCast(SqlUnary c) {
c.Operand = this.VisitExpression(c.Operand);
return c;
}
// transform type conversion if necessary
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
if (uo.NodeType == SqlNodeType.Convert) {
Type newType = uo.ClrType;
SqlExpression expr = uo.Operand;
if (newType == typeof(char) || expr.ClrType == typeof(char)) {
expr = this.VisitExpression(uo.Operand);
uo.Operand = expr;
return sql.ConvertTo(newType, uo.SqlType, expr);
}
}
return base.VisitUnaryOperator(uo);
}
internal virtual SqlExpression VisitTreat(SqlUnary t) {
t.Operand = this.VisitExpression(t.Operand);
return t;
}
internal virtual SqlExpression VisitTreat(SqlUnary t) {
t.Operand = this.VisitExpression(t.Operand);
return t;
}
internal SqlExpression TranslateLinkIsNull(SqlUnary expr) {
System.Diagnostics.Debug.Assert(expr.NodeType == SqlNodeType.IsNull || expr.NodeType == SqlNodeType.IsNotNull);
SqlLink link = expr.Operand as SqlLink;
if (!(link != null && link.Member.IsAssociation && link.Member.Association.IsForeignKey)) {
return expr;
}
List<SqlExpression> exprs = link.KeyExpressions;
System.Diagnostics.Debug.Assert(exprs.Count > 0);
SqlExpression exp = null;
SqlNodeType combo = (expr.NodeType == SqlNodeType.IsNull) ? SqlNodeType.Or : SqlNodeType.And;
for (int i = 0, n = exprs.Count; i < n; i++) {
SqlExpression compare = sql.Unary(expr.NodeType, sql.DoNotVisitExpression(exprs[i]), expr.SourceExpression);
if (exp == null) {
exp = compare;
}
else {
exp = sql.Binary(combo, exp, compare);
}
}
return exp;
}
internal virtual SqlExpression VisitCast(SqlUnary c) {
c.Operand = this.VisitExpression(c.Operand);
return c;
}
internal override SqlExpression VisitTreat(SqlUnary t) {
return new SqlUnary(SqlNodeType.Treat, t.ClrType, t.SqlType, (SqlExpression)this.Visit(t.Operand), t.SourceExpression);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
return new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, (SqlExpression)this.Visit(uo.Operand), uo.Method, uo.SourceExpression);
}
protected override SqlExpression VisitUnary(SqlUnary expr)
{
string op = GetUnaryOperator(expr.Operation);
switch (expr.Operation)
{
case SqlUnaryOperation.IsNull:
case SqlUnaryOperation.IsNotNull:
AddParentheses(expr.Operand, expr);
_builder.Append(op);
break;
default:
_builder.Append(op);
AddParentheses(expr.Operand, expr);
break;
}
return expr;
}
private static bool IsSupportedUnary(SqlUnary uo) {
return uo.NodeType == SqlNodeType.Convert &&
uo.ClrType == typeof(char) || uo.Operand.ClrType == typeof(char);
}
internal override SqlExpression VisitTreat(SqlUnary t) {
sb.Append("TREAT(");
this.Visit(t.Operand);
sb.Append(" AS ");
this.FormatType(t.SqlType);
sb.Append(")");
return t;
}
internal override SqlExpression VisitTreat(SqlUnary a) {
return VisitUnaryOperator(a);
}
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
uo.Operand = this.VisitExpression(uo.Operand);
// ------------------------------------------------------------
// PHASE 1: If possible, evaluate without fetching the operand.
// This is preferred because fetching LINKs causes them to not
// be deferred.
// ------------------------------------------------------------
if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) {
SqlExpression translated = this.translator.TranslateLinkIsNull(uo);
if (translated != uo) {
return this.VisitExpression(translated);
}
if (uo.Operand.NodeType==SqlNodeType.OuterJoinedValue) {
SqlUnary ojv = uo.Operand as SqlUnary;
if (ojv.Operand.NodeType == SqlNodeType.OptionalValue) {
SqlOptionalValue ov = (SqlOptionalValue)ojv.Operand;
return this.VisitUnaryOperator(
new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType,
new SqlUnary(SqlNodeType.OuterJoinedValue, ov.ClrType, ov.SqlType, ov.HasValue, ov.SourceExpression)
, uo.SourceExpression)
);
}
else if (ojv.Operand.NodeType == SqlNodeType.TypeCase) {
SqlTypeCase tc = (SqlTypeCase)ojv.Operand;
return new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType,
new SqlUnary(SqlNodeType.OuterJoinedValue, tc.Discriminator.ClrType, tc.Discriminator.SqlType, tc.Discriminator, tc.SourceExpression),
uo.SourceExpression
);
}
}
}
// Fetch the expression.
uo.Operand = this.ConvertToFetchedExpression(uo.Operand);
// ------------------------------------------------------------
// PHASE 2: Evaluate operator on fetched expression.
// ------------------------------------------------------------
if ((uo.NodeType == SqlNodeType.Not || uo.NodeType == SqlNodeType.Not2V) && uo.Operand.NodeType == SqlNodeType.Value) {
SqlValue val = (SqlValue)uo.Operand;
return sql.Value(typeof(bool), val.SqlType, !(bool)val.Value, val.IsClientSpecified, val.SourceExpression);
}
else if (uo.NodeType == SqlNodeType.Not2V) {
if (SqlExpressionNullability.CanBeNull(uo.Operand) != false) {
SqlSearchedCase c = new SqlSearchedCase(
typeof(int),
new [] { new SqlWhen(uo.Operand, sql.ValueFromObject(1, false, uo.SourceExpression)) },
sql.ValueFromObject(0, false, uo.SourceExpression),
uo.SourceExpression
);
return sql.Binary(SqlNodeType.EQ, c, sql.ValueFromObject(0, false, uo.SourceExpression));
}
else {
return sql.Unary(SqlNodeType.Not, uo.Operand);
}
}
// push converts of client-expressions inside the client-expression (to be evaluated client side)
else if (uo.NodeType == SqlNodeType.Convert && uo.Operand.NodeType == SqlNodeType.Value) {
SqlValue val = (SqlValue)uo.Operand;
return sql.Value(uo.ClrType, uo.SqlType, DBConvert.ChangeType(val.Value, uo.ClrType), val.IsClientSpecified, val.SourceExpression);
}
else if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) {
bool? canBeNull = SqlExpressionNullability.CanBeNull(uo.Operand);
if (canBeNull == false) {
return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression);
}
SqlExpression exp = uo.Operand;
switch (exp.NodeType) {
case SqlNodeType.Element:
exp = sql.SubSelect(SqlNodeType.Exists, ((SqlSubSelect)exp).Select);
if (uo.NodeType == SqlNodeType.IsNull) {
exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression);
}
return exp;
case SqlNodeType.ClientQuery: {
SqlClientQuery cq = (SqlClientQuery)exp;
if (cq.Query.NodeType == SqlNodeType.Element) {
exp = sql.SubSelect(SqlNodeType.Exists, cq.Query.Select);
if (uo.NodeType == SqlNodeType.IsNull) {
exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression);
}
return exp;
}
return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression);
}
case SqlNodeType.OptionalValue:
uo.Operand = ((SqlOptionalValue)exp).HasValue;
return uo;
case SqlNodeType.ClientCase: {
// Distribute unary into simple case.
SqlClientCase sc = (SqlClientCase)uo.Operand;
List<SqlExpression> matches = new List<SqlExpression>();
List<SqlExpression> values = new List<SqlExpression>();
foreach (SqlClientWhen when in sc.Whens) {
matches.Add(when.Match);
values.Add(VisitUnaryOperator(sql.Unary(uo.NodeType, when.Value, when.Value.SourceExpression)));
}
return sql.Case(sc.ClrType, sc.Expression, matches, values, sc.SourceExpression);
}
case SqlNodeType.TypeCase: {
// Distribute unary into type case. In the process, convert to simple case.
SqlTypeCase tc = (SqlTypeCase)uo.Operand;
List<SqlExpression> newMatches = new List<SqlExpression>();
List<SqlExpression> newValues = new List<SqlExpression>();
foreach (SqlTypeCaseWhen when in tc.Whens) {
SqlUnary un = new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, when.TypeBinding, when.TypeBinding.SourceExpression);
SqlExpression expr = VisitUnaryOperator(un);
if (expr is SqlNew) {
throw Error.DidNotExpectTypeBinding();
}
newMatches.Add(when.Match);
newValues.Add(expr);
}
return sql.Case(uo.ClrType, tc.Discriminator, newMatches, newValues, tc.SourceExpression);
}
case SqlNodeType.Value: {
SqlValue val = (SqlValue)uo.Operand;
return sql.Value(typeof(bool), this.typeProvider.From(typeof(int)), (val.Value == null) == (uo.NodeType == SqlNodeType.IsNull), val.IsClientSpecified, uo.SourceExpression);
}
}
}
else if (uo.NodeType == SqlNodeType.Treat) {
return ApplyTreat(VisitExpression(uo.Operand), uo.ClrType);
}
return uo;
}
internal virtual SqlExpression VisitUnaryOperator(SqlUnary uo) {
uo.Operand = this.VisitExpression(uo.Operand);
return uo;
}
internal override SqlExpression VisitTreat(SqlUnary t) {
t.Operand = this.VisitExpression(t.Operand);
Type treatType = t.ClrType;
Type originalType = model.GetMetaType(t.Operand.ClrType).InheritanceRoot.Type;
// .NET nullability rules are that typeof(int)==typeof(int?). Let's be consistent with that:
treatType = TypeSystem.GetNonNullableType(treatType);
originalType = TypeSystem.GetNonNullableType(originalType);
if (treatType == originalType) {
return t.Operand;
}
else if (treatType.IsAssignableFrom(originalType)) {
t.Operand.SetClrType(treatType);
return t.Operand;
}
else if (!treatType.IsAssignableFrom(originalType) && !originalType.IsAssignableFrom(treatType)) {
if (!treatType.IsInterface && !originalType.IsInterface) { // You can't tell when there's an interface involved.
// We statically know the TREAT will result in NULL.
return sql.TypedLiteralNull(treatType, t.SourceExpression);
}
}
//return base.VisitTreat(t);
return t;
}
