private static Type GetType(DataTypePrecedence code)
{
switch (code)
{
case DataTypePrecedence.Error: return(null);
case DataTypePrecedence.SByte: return(typeof(SByte));
case DataTypePrecedence.Byte: return(typeof(Byte));
case DataTypePrecedence.Int16: return(typeof(Int16));
case DataTypePrecedence.UInt16: return(typeof(UInt16));
case DataTypePrecedence.Int32: return(typeof(Int32));
case DataTypePrecedence.UInt32: return(typeof(UInt32));
case DataTypePrecedence.Int64: return(typeof(Int64));
case DataTypePrecedence.UInt64: return(typeof(UInt64));
case DataTypePrecedence.Decimal: return(typeof(Decimal));
case DataTypePrecedence.Single: return(typeof(Single));
case DataTypePrecedence.Double: return(typeof(Double));
case DataTypePrecedence.Boolean: return(typeof(Boolean));
case DataTypePrecedence.String: return(typeof(String));
case DataTypePrecedence.Char: return(typeof(Char));
case DataTypePrecedence.DateTime: return(typeof(DateTime));
case DataTypePrecedence.TimeSpan: return(typeof(TimeSpan));
}
Debug.Assert(false, "Invalid (unmapped) precedence " + code.ToString());
return(null);
}
public static StorageType GetPrecedenceType(DataTypePrecedence code)
{
switch (code)
{
case DataTypePrecedence.SqlBinary:
return(StorageType.SqlBinary);
case DataTypePrecedence.Char:
return(StorageType.Char);
case DataTypePrecedence.String:
return(StorageType.String);
case DataTypePrecedence.SqlString:
return(StorageType.SqlString);
case DataTypePrecedence.SqlGuid:
return(StorageType.SqlGuid);
case DataTypePrecedence.Boolean:
return(StorageType.Boolean);
case DataTypePrecedence.SqlBoolean:
return(StorageType.SqlBoolean);
case DataTypePrecedence.SByte:
return(StorageType.SByte);
case DataTypePrecedence.SqlByte:
return(StorageType.SqlByte);
case DataTypePrecedence.Byte:
return(StorageType.Byte);
case DataTypePrecedence.Int16:
return(StorageType.Int16);
case DataTypePrecedence.SqlInt16:
return(StorageType.SqlInt16);
case DataTypePrecedence.UInt16:
return(StorageType.UInt16);
case DataTypePrecedence.Int32:
return(StorageType.Int32);
case DataTypePrecedence.SqlInt32:
return(StorageType.SqlInt32);
case DataTypePrecedence.UInt32:
return(StorageType.UInt32);
case DataTypePrecedence.Int64:
return(StorageType.Int64);
case DataTypePrecedence.SqlInt64:
return(StorageType.SqlInt64);
case DataTypePrecedence.UInt64:
return(StorageType.UInt64);
case DataTypePrecedence.SqlMoney:
return(StorageType.SqlMoney);
case DataTypePrecedence.Decimal:
return(StorageType.Decimal);
case DataTypePrecedence.SqlDecimal:
return(StorageType.SqlDecimal);
case DataTypePrecedence.Single:
return(StorageType.Single);
case DataTypePrecedence.SqlSingle:
return(StorageType.SqlSingle);
case DataTypePrecedence.Double:
return(StorageType.Double);
case DataTypePrecedence.SqlDouble:
return(StorageType.SqlDouble);
case DataTypePrecedence.TimeSpan:
return(StorageType.TimeSpan);
case DataTypePrecedence.DateTime:
return(StorageType.DateTime);
case DataTypePrecedence.SqlDateTime:
return(StorageType.SqlDateTime);
default:
return(StorageType.Empty);
}
}
public static StorageType ResultType(
StorageType left,
StorageType right,
bool lc,
bool rc,
Operator op)
{
if (left == StorageType.Guid && right == StorageType.Guid && Operator.IsRelational(op) || left == StorageType.String && right == StorageType.Guid && Operator.IsRelational(op))
{
return(left);
}
if (left == StorageType.Guid && right == StorageType.String && Operator.IsRelational(op))
{
return(right);
}
int precedence1 = (int)DataStorageHelper.GetPrecedence(left);
if (precedence1 == 0)
{
return(StorageType.Empty);
}
int precedence2 = (int)DataStorageHelper.GetPrecedence(right);
if (precedence2 == 0)
{
return(StorageType.Empty);
}
if (Operator.IsLogical(op))
{
return(left == StorageType.Boolean && right == StorageType.Boolean ? StorageType.Boolean : StorageType.Empty);
}
if (op == Operator.Plus && (left == StorageType.String || right == StorageType.String))
{
return(StorageType.String);
}
DataTypePrecedence code = (DataTypePrecedence)Math.Max(precedence1, precedence2);
StorageType precedenceType = DataStorageHelper.GetPrecedenceType(code);
if (Operator.IsArithmetical(op) && precedenceType != StorageType.String && precedenceType != StorageType.Char && (!DataStorageHelper.IsNumeric(left) || !DataStorageHelper.IsNumeric(right)))
{
return(StorageType.Empty);
}
if (op == Operator.Multiply && DataStorageHelper.IsInteger(precedenceType))
{
return(StorageType.Double);
}
if (!DataStorageHelper.IsMixed(left, right))
{
return(precedenceType);
}
if (lc && !rc)
{
return(right);
}
if (!lc && rc)
{
return(left);
}
if (!DataStorageHelper.IsUnsigned(precedenceType))
{
return(precedenceType);
}
if (code >= DataTypePrecedence.UInt64)
{
throw InvalidExpressionException.AmbiguousBinop(op, DataStorageHelper.GetTypeStorage(left), DataStorageHelper.GetTypeStorage(right));
}
return(DataStorageHelper.GetPrecedenceType(code + 1));
}
public static StorageType ResultSqlType(
StorageType left,
StorageType right,
bool lc,
bool rc,
Operator op)
{
int precedence1 = (int)DataStorageHelper.GetPrecedence(left);
if (precedence1 == 0)
{
return(StorageType.Empty);
}
int precedence2 = (int)DataStorageHelper.GetPrecedence(right);
if (precedence2 == 0)
{
return(StorageType.Empty);
}
if (Operator.IsLogical(op))
{
if (left != StorageType.Boolean && left != StorageType.SqlBoolean || right != StorageType.Boolean && right != StorageType.SqlBoolean)
{
return(StorageType.Empty);
}
return(left == StorageType.Boolean && right == StorageType.Boolean ? StorageType.Boolean : StorageType.SqlBoolean);
}
if (op == Operator.Plus)
{
if (left == StorageType.SqlString || right == StorageType.SqlString)
{
return(StorageType.SqlString);
}
if (left == StorageType.String || right == StorageType.String)
{
return(StorageType.String);
}
}
if (left == StorageType.SqlBinary && right != StorageType.SqlBinary || left != StorageType.SqlBinary && right == StorageType.SqlBinary || (left == StorageType.SqlGuid && right != StorageType.SqlGuid || left != StorageType.SqlGuid && right == StorageType.SqlGuid) || (precedence1 > 19 && precedence2 < 20 || precedence1 < 20 && precedence2 > 19))
{
return(StorageType.Empty);
}
if (precedence1 > 19)
{
if (op == Operator.Plus || op == Operator.Minus)
{
if (left == StorageType.TimeSpan)
{
return(right);
}
if (right == StorageType.TimeSpan)
{
return(left);
}
return(StorageType.Empty);
}
if (!Operator.IsRelational(op))
{
return(StorageType.Empty);
}
return(left);
}
DataTypePrecedence code = (DataTypePrecedence)Math.Max(precedence1, precedence2);
DataStorageHelper.GetPrecedenceType(code);
StorageType type = DataStorageHelper.GetPrecedenceType((DataTypePrecedence)DataStorageHelper.SqlResultType((int)code));
if (Operator.IsArithmetical(op) && type != StorageType.String && (type != StorageType.Char && type != StorageType.SqlString) && (!DataStorageHelper.IsNumericSql(left) || !DataStorageHelper.IsNumericSql(right)))
{
return(StorageType.Empty);
}
if (op == Operator.Multiply && DataStorageHelper.IsIntegerSql(type))
{
return(StorageType.SqlDouble);
}
if (type == StorageType.SqlMoney && left != StorageType.SqlMoney && right != StorageType.SqlMoney)
{
type = StorageType.SqlDecimal;
}
if (!DataStorageHelper.IsMixedSql(left, right) || !DataStorageHelper.IsUnsignedSql(type))
{
return(type);
}
if (code >= DataTypePrecedence.UInt64)
{
throw InvalidExpressionException.AmbiguousBinop(op, DataStorageHelper.GetTypeStorage(left), DataStorageHelper.GetTypeStorage(right));
}
return(DataStorageHelper.GetPrecedenceType(code + 1));
}
private static StorageType GetPrecedenceType(DataTypePrecedence code)
{
switch (code)
{
case DataTypePrecedence.Error: return StorageType.Empty;
case DataTypePrecedence.SByte: return StorageType.SByte;
case DataTypePrecedence.Byte: return StorageType.Byte;
case DataTypePrecedence.Int16: return StorageType.Int16;
case DataTypePrecedence.UInt16: return StorageType.UInt16;
case DataTypePrecedence.Int32: return StorageType.Int32;
case DataTypePrecedence.UInt32: return StorageType.UInt32;
case DataTypePrecedence.Int64: return StorageType.Int64;
case DataTypePrecedence.UInt64: return StorageType.UInt64;
case DataTypePrecedence.Decimal: return StorageType.Decimal;
case DataTypePrecedence.Single: return StorageType.Single;
case DataTypePrecedence.Double: return StorageType.Double;
case DataTypePrecedence.Boolean: return StorageType.Boolean;
case DataTypePrecedence.String: return StorageType.String;
case DataTypePrecedence.Char: return StorageType.Char;
case DataTypePrecedence.DateTimeOffset: return StorageType.DateTimeOffset;
case DataTypePrecedence.DateTime: return StorageType.DateTime;
case DataTypePrecedence.TimeSpan: return StorageType.TimeSpan;
case DataTypePrecedence.SqlDateTime: return StorageType.SqlDateTime;
case DataTypePrecedence.SqlDouble: return StorageType.SqlDouble;
case DataTypePrecedence.SqlSingle: return StorageType.SqlSingle;
case DataTypePrecedence.SqlDecimal: return StorageType.SqlDecimal;
case DataTypePrecedence.SqlInt64: return StorageType.SqlInt64;
case DataTypePrecedence.SqlInt32: return StorageType.SqlInt32;
case DataTypePrecedence.SqlInt16: return StorageType.SqlInt16;
case DataTypePrecedence.SqlByte: return StorageType.SqlByte;
case DataTypePrecedence.SqlBoolean: return StorageType.SqlBoolean;
case DataTypePrecedence.SqlString: return StorageType.SqlString;
case DataTypePrecedence.SqlGuid: return StorageType.SqlGuid;
case DataTypePrecedence.SqlBinary: return StorageType.SqlBinary;
case DataTypePrecedence.SqlMoney: return StorageType.SqlMoney;
default:
Debug.Assert(false, "Invalid (unmapped) precedence " + code.ToString());
goto case DataTypePrecedence.Error;
}
}
internal Type ResultType(Type left, Type right, bool lc, bool rc, int op)
{
if ((left == typeof(System.Guid)) && (right == typeof(System.Guid)) && Operators.IsRelational(op))
{
return(left);
}
if ((left == typeof(System.String)) && (right == typeof(System.Guid)) && Operators.IsRelational(op))
{
return(left);
}
if ((left == typeof(System.Guid)) && (right == typeof(System.String)) && Operators.IsRelational(op))
{
return(right);
}
int leftPrecedence = (int)GetPrecedence(left);
if (leftPrecedence == (int)DataTypePrecedence.Error)
{
return(null);
}
int rightPrecedence = (int)GetPrecedence(right);
if (rightPrecedence == (int)DataTypePrecedence.Error)
{
return(null);
}
if (Operators.IsLogical(op))
{
if (left == typeof(Boolean) && right == typeof(Boolean))
{
return(typeof(Boolean));
}
else
{
return(null);
}
}
if ((op == Operators.Plus) && ((left == typeof(String)) || (right == typeof(String))))
{
return(typeof(string));
}
DataTypePrecedence higherPrec = (DataTypePrecedence)Math.Max(leftPrecedence, rightPrecedence);
Type result = GetType(higherPrec);
if (Operators.IsArithmetical(op))
{
if (result != typeof(string) && result != typeof(char))
{
if (!IsNumeric(left))
{
return(null);
}
if (!IsNumeric(right))
{
return(null);
}
}
}
// if the operation is a division the result should be at least a double
if ((op == Operators.Divide) && IsInteger(result))
{
return(typeof(double));
}
if (IsMixed(left, right))
{
// we are dealing with one signed and one unsigned type so
// try to see if one of them is a ConstNode
if (lc && (!rc))
{
return(right);
}
else if ((!lc) && rc)
{
return(left);
}
if (IsUnsigned(result))
{
if (higherPrec < DataTypePrecedence.UInt64)
{
// left and right are mixed integers but with the same length
// so promote to the next signed type
result = GetType(higherPrec + 1);
}
else
{
throw ExprException.AmbiguousBinop(op, left, right);
}
}
}
return(result);
}
private static StorageType GetPrecedenceType(DataTypePrecedence code)
{
switch (code)
{
case DataTypePrecedence.SqlBinary:
return StorageType.SqlBinary;
case DataTypePrecedence.Char:
return StorageType.Char;
case DataTypePrecedence.String:
return StorageType.String;
case DataTypePrecedence.SqlString:
return StorageType.SqlString;
case DataTypePrecedence.SqlGuid:
return StorageType.SqlGuid;
case DataTypePrecedence.Boolean:
return StorageType.Boolean;
case DataTypePrecedence.SqlBoolean:
return StorageType.SqlBoolean;
case DataTypePrecedence.SByte:
return StorageType.SByte;
case DataTypePrecedence.SqlByte:
return StorageType.SqlByte;
case DataTypePrecedence.Byte:
return StorageType.Byte;
case DataTypePrecedence.Int16:
return StorageType.Int16;
case DataTypePrecedence.SqlInt16:
return StorageType.SqlInt16;
case DataTypePrecedence.UInt16:
return StorageType.UInt16;
case DataTypePrecedence.Int32:
return StorageType.Int32;
case DataTypePrecedence.SqlInt32:
return StorageType.SqlInt32;
case DataTypePrecedence.UInt32:
return StorageType.UInt32;
case DataTypePrecedence.Int64:
return StorageType.Int64;
case DataTypePrecedence.SqlInt64:
return StorageType.SqlInt64;
case DataTypePrecedence.UInt64:
return StorageType.UInt64;
case DataTypePrecedence.SqlMoney:
return StorageType.SqlMoney;
case DataTypePrecedence.Decimal:
return StorageType.Decimal;
case DataTypePrecedence.SqlDecimal:
return StorageType.SqlDecimal;
case DataTypePrecedence.Single:
return StorageType.Single;
case DataTypePrecedence.SqlSingle:
return StorageType.SqlSingle;
case DataTypePrecedence.Double:
return StorageType.Double;
case DataTypePrecedence.SqlDouble:
return StorageType.SqlDouble;
case DataTypePrecedence.TimeSpan:
return StorageType.TimeSpan;
case DataTypePrecedence.DateTime:
return StorageType.DateTime;
case DataTypePrecedence.DateTimeOffset:
return StorageType.DateTimeOffset;
case DataTypePrecedence.SqlDateTime:
return StorageType.SqlDateTime;
}
return StorageType.Empty;
}
/// <summary>
///
/// </summary>
public static StorageType ResultSqlType(StorageType left
, StorageType right
, bool lc
, bool rc
, Operator op)
{
int leftOpPrecedence = (int)DataStorageHelper.GetPrecedence(left);
if (leftOpPrecedence == 0)
{
return(StorageType.Empty);
}
int rightOpPrecedence = (int)DataStorageHelper.GetPrecedence(right);
if (rightOpPrecedence == 0)
{
return(StorageType.Empty);
}
if (Operator.IsLogical(op))
{
if (((left != StorageType.Boolean) && (left != StorageType.SqlBoolean)) ||
((right != StorageType.Boolean) && (right != StorageType.SqlBoolean)))
{
return(StorageType.Empty);
}
if ((left == StorageType.Boolean) && (right == StorageType.Boolean))
{
return(StorageType.Boolean);
}
return(StorageType.SqlBoolean);
}
if (op == Operator.Plus)
{
if ((left == StorageType.SqlString) || (right == StorageType.SqlString))
{
return(StorageType.SqlString);
}
if ((left == StorageType.String) || (right == StorageType.String))
{
return(StorageType.String);
}
}
if (((left == StorageType.SqlBinary) && (right != StorageType.SqlBinary)) || ((left != StorageType.SqlBinary) && (right == StorageType.SqlBinary)))
{
return(StorageType.Empty);
}
if (((left == StorageType.SqlGuid) && (right != StorageType.SqlGuid)) || ((left != StorageType.SqlGuid) && (right == StorageType.SqlGuid)))
{
return(StorageType.Empty);
}
if ((leftOpPrecedence > 0x13) && (rightOpPrecedence < 20))
{
return(StorageType.Empty);
}
if ((leftOpPrecedence < 20) && (rightOpPrecedence > 0x13))
{
return(StorageType.Empty);
}
if (leftOpPrecedence > 0x13)
{
if ((op == Operator.Plus) || (op == Operator.Minus))
{
if (left == StorageType.TimeSpan)
{
return(right);
}
if (right == StorageType.TimeSpan)
{
return(left);
}
return(StorageType.Empty);
}
if (!Operator.IsRelational(op))
{
return(StorageType.Empty);
}
return(left);
}
DataTypePrecedence code = (DataTypePrecedence)Math.Max(leftOpPrecedence, rightOpPrecedence);
StorageType precedenceType = DataStorageHelper.GetPrecedenceType(code);
precedenceType = DataStorageHelper.GetPrecedenceType((DataTypePrecedence)DataStorageHelper.SqlResultType((int)code));
if ((Operator.IsArithmetical(op) && (precedenceType != StorageType.String)) && ((precedenceType != StorageType.Char) && (precedenceType != StorageType.SqlString)))
{
if (!DataStorageHelper.IsNumericSql(left))
{
return(StorageType.Empty);
}
if (!DataStorageHelper.IsNumericSql(right))
{
return(StorageType.Empty);
}
}
if ((op == Operator.Multiply) && DataStorageHelper.IsIntegerSql(precedenceType))
{
return(StorageType.SqlDouble);
}
if (((precedenceType == StorageType.SqlMoney) && (left != StorageType.SqlMoney)) && (right != StorageType.SqlMoney))
{
precedenceType = StorageType.SqlDecimal;
}
if (!DataStorageHelper.IsMixedSql(left, right) || !DataStorageHelper.IsUnsignedSql(precedenceType))
{
return(precedenceType);
}
if (code >= DataTypePrecedence.UInt64)
{
throw InvalidExpressionException.AmbiguousBinop(op
, DataStorageHelper.GetTypeStorage(left)
, DataStorageHelper.GetTypeStorage(right));
}
return(DataStorageHelper.GetPrecedenceType(code + 1));
}
