Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / Data / System / Data / Filter / BinaryNode.cs / 1 / BinaryNode.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data {
using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Globalization;
using System.ComponentModel;
using System.Data.SqlTypes;
using System.Data.Common;
internal class BinaryNode : ExpressionNode {
internal int op;
internal ExpressionNode left;
internal ExpressionNode right;
internal BinaryNode(DataTable table, int op, ExpressionNode left, ExpressionNode right) : base(table) {
this.op = op;
this.left = left;
this.right = right;
}
internal override void Bind(DataTable table, List list) {
BindTable(table);
left.Bind(table, list);
right.Bind(table, list);
}
internal override object Eval() {
return Eval(null, DataRowVersion.Default);
}
internal override object Eval(DataRow row, DataRowVersion version) {
return EvalBinaryOp(op, left, right, row, version, null);
}
internal override object Eval(int[] recordNos) {
return EvalBinaryOp(op, left, right, null, DataRowVersion.Default, recordNos);
}
internal override bool IsConstant() {
//
return(left.IsConstant() && right.IsConstant());
}
internal override bool IsTableConstant() {
return(left.IsTableConstant() && right.IsTableConstant());
}
internal override bool HasLocalAggregate() {
return(left.HasLocalAggregate() || right.HasLocalAggregate());
}
internal override bool HasRemoteAggregate() {
return(left.HasRemoteAggregate() || right.HasRemoteAggregate());
}
internal override bool DependsOn(DataColumn column) {
if (left.DependsOn(column))
return true;
return right.DependsOn(column);
}
internal override ExpressionNode Optimize() {
left = left.Optimize();
if (op == Operators.Is) {
// only 'Is Null' or 'Is Not Null' are valid
if (right is UnaryNode) {
UnaryNode un = (UnaryNode)right;
if (un.op != Operators.Not) {
throw ExprException.InvalidIsSyntax();
}
op = Operators.IsNot;
right = un.right;
}
if (right is ZeroOpNode) {
if (((ZeroOpNode)right).op != Operators.Null) {
throw ExprException.InvalidIsSyntax();
}
}
else {
throw ExprException.InvalidIsSyntax();
}
}
else {
right = right.Optimize();
}
if (this.IsConstant()) {
object val = this.Eval();
if (val == DBNull.Value) {
return new ZeroOpNode(Operators.Null);
}
if (val is bool) {
if ((bool)val)
return new ZeroOpNode(Operators.True);
else
return new ZeroOpNode(Operators.False);
}
return new ConstNode(table, ValueType.Object, val, false);
}
else
return this;
}
internal void SetTypeMismatchError(int op, Type left, Type right) {
throw ExprException.TypeMismatchInBinop(op, left, right);
}
private static object Eval(ExpressionNode expr, DataRow row, DataRowVersion version, int[] recordNos) {
if (recordNos == null) {
return expr.Eval(row, version);
}
else {
return expr.Eval(recordNos);
}
}
internal int BinaryCompare(object vLeft, object vRight, StorageType resultType, int op) {
int result = 0;
try {
if (!DataStorage.IsSqlType(resultType)) {
switch(resultType) {
case StorageType.SByte:
case StorageType.Int16:
case StorageType.Int32:
case StorageType.Byte:
case StorageType.UInt16:
return Convert.ToInt32(vLeft, FormatProvider).CompareTo(Convert.ToInt32(vRight, FormatProvider));
case StorageType.Int64:
case StorageType.UInt32:
case StorageType.UInt64:
case StorageType.Decimal:
return Decimal.Compare(Convert.ToDecimal(vLeft, FormatProvider), Convert.ToDecimal(vRight, FormatProvider));
case StorageType.Char:
return Convert.ToInt32(vLeft, FormatProvider).CompareTo(Convert.ToInt32(vRight, FormatProvider));
case StorageType.Double:
return Convert.ToDouble(vLeft, FormatProvider).CompareTo(Convert.ToDouble(vRight, FormatProvider));
case StorageType.Single:
return Convert.ToSingle(vLeft, FormatProvider).CompareTo(Convert.ToSingle(vRight, FormatProvider));
case StorageType.DateTime:
return DateTime.Compare(Convert.ToDateTime(vLeft, FormatProvider), Convert.ToDateTime(vRight, FormatProvider));
case StorageType.String:
return table.Compare(Convert.ToString(vLeft, FormatProvider), Convert.ToString(vRight, FormatProvider));
case StorageType.Guid:
return ((Guid)vLeft).CompareTo((Guid) vRight);
case StorageType.Boolean:
if (op == Operators.EqualTo || op == Operators.NotEqual) {
return Convert.ToInt32(DataExpression.ToBoolean(vLeft), FormatProvider) -
Convert.ToInt32(DataExpression.ToBoolean(vRight), FormatProvider);
}
break;
}
}
else{
switch(resultType) {
case StorageType.SByte:
case StorageType.Int16:
case StorageType.Int32:
case StorageType.Byte:
case StorageType.UInt16:
case StorageType.SqlByte:
case StorageType.SqlInt16:
case StorageType.SqlInt32:
return SqlConvert.ConvertToSqlInt32(vLeft).CompareTo(SqlConvert.ConvertToSqlInt32(vRight));
case StorageType.Int64:
case StorageType.UInt32:
case StorageType.SqlInt64:
return SqlConvert.ConvertToSqlInt64(vLeft).CompareTo(SqlConvert.ConvertToSqlInt64(vRight));
case StorageType.UInt64:
case StorageType.SqlDecimal:
return SqlConvert.ConvertToSqlDecimal(vLeft).CompareTo(SqlConvert.ConvertToSqlDecimal(vRight));
case StorageType.SqlDouble:
return SqlConvert.ConvertToSqlDouble(vLeft).CompareTo(SqlConvert.ConvertToSqlDouble(vRight));
case StorageType.SqlSingle:
return SqlConvert.ConvertToSqlSingle(vLeft).CompareTo(SqlConvert.ConvertToSqlSingle(vRight));
case StorageType.SqlString:
return table.Compare(vLeft.ToString(), vRight.ToString());
case StorageType.SqlGuid:
return ((SqlGuid)vLeft).CompareTo(vRight);
case StorageType.SqlBoolean:
if (op == Operators.EqualTo || op == Operators.NotEqual) {
result = 1;
if (((vLeft.GetType() == typeof(SqlBoolean)) && ((vRight.GetType() == typeof(SqlBoolean))|| (vRight.GetType() == typeof(Boolean))))||
((vRight.GetType() == typeof(SqlBoolean)) && ((vLeft.GetType() == typeof(SqlBoolean))|| (vLeft.GetType() == typeof(Boolean))))){
return SqlConvert.ConvertToSqlBoolean(vLeft).CompareTo(SqlConvert.ConvertToSqlBoolean(vRight));
}
}
break;
case StorageType.SqlBinary:
return SqlConvert.ConvertToSqlBinary(vLeft).CompareTo(SqlConvert.ConvertToSqlBinary(vRight));
case StorageType.SqlDateTime:
return SqlConvert.ConvertToSqlDateTime(vLeft).CompareTo(SqlConvert.ConvertToSqlDateTime(vRight));
case StorageType.SqlMoney:
return SqlConvert.ConvertToSqlMoney(vLeft).CompareTo(SqlConvert.ConvertToSqlMoney(vRight));
}
}
}
catch (System.ArgumentException e) {
ExceptionBuilder.TraceExceptionWithoutRethrow(e);
}
catch (System.FormatException e) {
ExceptionBuilder.TraceExceptionWithoutRethrow(e);
}
catch (System.InvalidCastException e) {
ExceptionBuilder.TraceExceptionWithoutRethrow(e);
}
catch (System.OverflowException e) {
ExceptionBuilder.TraceExceptionWithoutRethrow(e);
}
catch (System.Data.EvaluateException e) {
ExceptionBuilder.TraceExceptionWithoutRethrow(e);
}
SetTypeMismatchError(op, vLeft.GetType(), vRight.GetType());
return result;
}
private object EvalBinaryOp(int op, ExpressionNode left, ExpressionNode right, DataRow row, DataRowVersion version, int[] recordNos) {
object vLeft;
object vRight;
StorageType resultType;
/*
special case for OR and AND operators: we don't want to evaluate
both right and left operands, because we can shortcut :
for OR operator If one of the operands is true the result is true
for AND operator If one of rhe operands is flase the result is false
*/
if (op != Operators.Or && op != Operators.And && op != Operators.In && op != Operators.Is && op != Operators.IsNot) {
vLeft = BinaryNode.Eval(left, row, version, recordNos);
vRight = BinaryNode.Eval(right, row, version, recordNos);
Type typeofLeft = vLeft.GetType();
Type typeofRight = vRight.GetType();
StorageType leftStorage = DataStorage.GetStorageType(typeofLeft);
StorageType rightStorage = DataStorage.GetStorageType(typeofRight);
bool leftIsSqlType = DataStorage.IsSqlType(leftStorage);
bool rightIsSqlType = DataStorage.IsSqlType(rightStorage);
// special case of handling NULLS, currently only OR operator can work with NULLS
if (leftIsSqlType && DataStorage.IsObjectSqlNull(vLeft)) {
return vLeft;
}
else if (rightIsSqlType && DataStorage.IsObjectSqlNull(vRight)) {
return vRight;
}
else if ((vLeft == DBNull.Value)||(vRight == DBNull.Value)) {
return DBNull.Value;
}
if (leftIsSqlType || rightIsSqlType) {
resultType = ResultSqlType(leftStorage, rightStorage, (left is ConstNode), (right is ConstNode), op);
}
else {
resultType = ResultType(leftStorage, rightStorage, (left is ConstNode), (right is ConstNode), op);
}
if (StorageType.Empty == resultType) {
SetTypeMismatchError(op, typeofLeft, typeofRight);
}
}
else {
vLeft = vRight = DBNull.Value;
resultType = StorageType.Empty; // shouldnt we make it boolean?
}
object value = DBNull.Value;
bool typeMismatch = false;
try {
switch (op) {
case Operators.Plus:
switch(resultType) {
case StorageType.Byte:{
value = Convert.ToByte((Convert.ToByte(vLeft, FormatProvider) + Convert.ToByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SByte:{
value = Convert.ToSByte((Convert.ToSByte(vLeft, FormatProvider) + Convert.ToSByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int16:{
value = Convert.ToInt16((Convert.ToInt16(vLeft, FormatProvider) + Convert.ToInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.UInt16:{
value = Convert.ToUInt16((Convert.ToUInt16(vLeft, FormatProvider) + Convert.ToUInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int32: {
checked {value = Convert.ToInt32(vLeft, FormatProvider) + Convert.ToInt32(vRight, FormatProvider);}
break;}
case StorageType.UInt32: {
checked {value = Convert.ToUInt32(vLeft, FormatProvider) + Convert.ToUInt32(vRight, FormatProvider);}
break;}
case StorageType.UInt64: {
checked {value = Convert.ToUInt64(vLeft, FormatProvider) + Convert.ToUInt64(vRight, FormatProvider);}
break;}
case StorageType.Int64:{
checked {value = Convert.ToInt64(vLeft, FormatProvider) + Convert.ToInt64(vRight, FormatProvider);}
break;}
case StorageType.Decimal:{
checked {value = Convert.ToDecimal(vLeft, FormatProvider) + Convert.ToDecimal(vRight, FormatProvider);}
break;}
case StorageType.Single:{
checked {value = Convert.ToSingle(vLeft, FormatProvider) + Convert.ToSingle(vRight, FormatProvider);}
break;}
case StorageType.Double:{
checked {value = Convert.ToDouble(vLeft, FormatProvider) + Convert.ToDouble(vRight, FormatProvider);}
break;}
case StorageType.String:
case StorageType.Char:{
value = Convert.ToString(vLeft, FormatProvider) + Convert.ToString(vRight, FormatProvider);
break;}
case StorageType.DateTime:{
// one of the operands should be a DateTime, and an other a TimeSpan
if (vLeft is TimeSpan && vRight is DateTime) {
value = (DateTime)vRight + (TimeSpan)vLeft;
}
else if (vLeft is DateTime && vRight is TimeSpan) {
value = (DateTime)vLeft + (TimeSpan)vRight;
}
else {
typeMismatch = true;
}
break;}
case StorageType.TimeSpan:{
value = (TimeSpan)vLeft + (TimeSpan)vRight;
break;}
case StorageType.SqlInt16:{
value = (SqlConvert.ConvertToSqlInt16(vLeft) + SqlConvert.ConvertToSqlInt16(vRight));
break;}
case StorageType.SqlInt32:{
value = ( SqlConvert.ConvertToSqlInt32(vLeft) + SqlConvert.ConvertToSqlInt32(vRight));
break;}
case StorageType.SqlInt64:{
value = (SqlConvert.ConvertToSqlInt64(vLeft) + SqlConvert.ConvertToSqlInt64(vRight));
break;}
case StorageType.SqlDouble:{
value = (SqlConvert.ConvertToSqlDouble(vLeft) + SqlConvert.ConvertToSqlDouble(vRight));
break;}
case StorageType.SqlSingle:{
value = (SqlConvert.ConvertToSqlSingle(vLeft)+ SqlConvert.ConvertToSqlSingle(vRight));
break;}
case StorageType.SqlDecimal:{
value = (SqlConvert.ConvertToSqlDecimal(vLeft) + SqlConvert.ConvertToSqlDecimal(vRight));
break;}
case StorageType.SqlMoney:{
value = (SqlConvert.ConvertToSqlMoney(vLeft) + SqlConvert.ConvertToSqlMoney(vRight));
break;}
case StorageType.SqlByte:{
value = (SqlConvert.ConvertToSqlByte(vLeft) + SqlConvert.ConvertToSqlByte(vRight));
break;}
case StorageType.SqlString:{
value = (SqlConvert.ConvertToSqlString(vLeft) + SqlConvert.ConvertToSqlString(vRight));
break;}
case StorageType.SqlDateTime:{
if (vLeft is TimeSpan && vRight is SqlDateTime) {
SqlDateTime rValue = (SqlDateTime)SqlConvert.ConvertToSqlDateTime(vRight);
value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)rValue.Value + (TimeSpan)vLeft);
}
else if (vLeft is SqlDateTime && vRight is TimeSpan) {
SqlDateTime lValue = (SqlDateTime)SqlConvert.ConvertToSqlDateTime(vLeft);
value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)lValue.Value + (TimeSpan)vRight);
}
else {
typeMismatch = true;
}
break;}
default:{
typeMismatch = true;
break;}
}
break; // Operators.Plus
case Operators.Minus:
switch(resultType) {
case StorageType.Byte: {
value = Convert.ToByte((Convert.ToByte(vLeft, FormatProvider) - Convert.ToByte(vRight, FormatProvider)), FormatProvider);
break; }
case StorageType.SqlByte: {
value = (SqlConvert.ConvertToSqlByte(vLeft) - SqlConvert.ConvertToSqlByte(vRight));
break;}
case StorageType.SByte:{
value = Convert.ToSByte((Convert.ToSByte(vLeft, FormatProvider) - Convert.ToSByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int16:{
value = Convert.ToInt16((Convert.ToInt16(vLeft, FormatProvider) - Convert.ToInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SqlInt16:{
value = (SqlConvert.ConvertToSqlInt16(vLeft) - SqlConvert.ConvertToSqlInt16(vRight));
break;}
case StorageType.UInt16:{
value = Convert.ToUInt16((Convert.ToUInt16(vLeft, FormatProvider) - Convert.ToUInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int32:{
checked {value = Convert.ToInt32(vLeft, FormatProvider) - Convert.ToInt32(vRight, FormatProvider);}
break;}
case StorageType.SqlInt32:{
value = (SqlConvert.ConvertToSqlInt32(vLeft) - SqlConvert.ConvertToSqlInt32(vRight));
break;}
case StorageType.UInt32:{
checked {value = Convert.ToUInt32(vLeft, FormatProvider) - Convert.ToUInt32(vRight, FormatProvider);}
break;}
case StorageType.Int64:{
checked {value = Convert.ToInt64(vLeft, FormatProvider) - Convert.ToInt64(vRight, FormatProvider);}
break;}
case StorageType.SqlInt64:{
value = (SqlConvert.ConvertToSqlInt64(vLeft) - SqlConvert.ConvertToSqlInt64(vRight));
break;}
case StorageType.UInt64:{
checked {value = Convert.ToUInt64(vLeft, FormatProvider) - Convert.ToUInt64(vRight, FormatProvider);}
break;}
case StorageType.Decimal:{
checked {value = Convert.ToDecimal(vLeft, FormatProvider) - Convert.ToDecimal(vRight, FormatProvider);}
break;}
case StorageType.SqlDecimal:{
value = (SqlConvert.ConvertToSqlDecimal(vLeft) - SqlConvert.ConvertToSqlDecimal(vRight));
break;}
case StorageType.Single:{
checked {value = Convert.ToSingle(vLeft, FormatProvider) - Convert.ToSingle(vRight, FormatProvider);}
break;}
case StorageType.SqlSingle:{
value = (SqlConvert.ConvertToSqlSingle(vLeft) - SqlConvert.ConvertToSqlSingle(vRight));
break;}
case StorageType.Double:{
checked {value = Convert.ToDouble(vLeft, FormatProvider) - Convert.ToDouble(vRight, FormatProvider);}
break;}
case StorageType.SqlDouble:{
value = (SqlConvert.ConvertToSqlDouble(vLeft) - SqlConvert.ConvertToSqlDouble(vRight));
break;}
case StorageType.SqlMoney:{
value = (SqlConvert.ConvertToSqlMoney(vLeft) - SqlConvert.ConvertToSqlMoney(vRight));
break;}
case StorageType.DateTime:{
value = (DateTime)vLeft - (TimeSpan)vRight;
break;}
case StorageType.TimeSpan:{
if (vLeft is DateTime) {
value = (DateTime)vLeft - (DateTime)vRight;
}
else
value = (TimeSpan)vLeft - (TimeSpan)vRight;
break;}
case StorageType.SqlDateTime:{
if (vLeft is TimeSpan && vRight is SqlDateTime) {
SqlDateTime rValue = (SqlDateTime)SqlConvert.ConvertToSqlDateTime(vRight);
value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)rValue.Value - (TimeSpan)vLeft);
}
else if (vLeft is SqlDateTime && vRight is TimeSpan) {
SqlDateTime lValue = (SqlDateTime)SqlConvert.ConvertToSqlDateTime(vLeft);
value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)lValue.Value - (TimeSpan)vRight);
}
else {
typeMismatch = true;
}
break;}
default:{
typeMismatch = true;
break;}
}
break; // Operators.Minus
case Operators.Multiply:
switch(resultType) {
case StorageType.Byte:{
value = Convert.ToByte((Convert.ToByte(vLeft, FormatProvider) * Convert.ToByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SqlByte:{
value = (SqlConvert.ConvertToSqlByte(vLeft) * SqlConvert.ConvertToSqlByte(vRight));
break;}
case StorageType.SByte:{
value = Convert.ToSByte((Convert.ToSByte(vLeft, FormatProvider) * Convert.ToSByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int16:{
value = Convert.ToInt16((Convert.ToInt16(vLeft, FormatProvider) * Convert.ToInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SqlInt16:{
value = (SqlConvert.ConvertToSqlInt16(vLeft) * SqlConvert.ConvertToSqlInt16(vRight));
break;}
case StorageType.UInt16:{
value = Convert.ToUInt16((Convert.ToUInt16(vLeft, FormatProvider) * Convert.ToUInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int32:{
checked {value = Convert.ToInt32(vLeft, FormatProvider) * Convert.ToInt32(vRight, FormatProvider);}
break;}
case StorageType.SqlInt32:{
value = (SqlConvert.ConvertToSqlInt32(vLeft) * SqlConvert.ConvertToSqlInt32(vRight));
break;}
case StorageType.UInt32:{
checked {value = Convert.ToUInt32(vLeft, FormatProvider) * Convert.ToUInt32(vRight, FormatProvider);}
break;}
case StorageType.Int64:{
checked {value = Convert.ToInt64(vLeft, FormatProvider) * Convert.ToInt64(vRight, FormatProvider);}
break;}
case StorageType.SqlInt64:{
value = (SqlConvert.ConvertToSqlInt64(vLeft) * SqlConvert.ConvertToSqlInt64(vRight));
break;}
case StorageType.UInt64:{
checked {value = Convert.ToUInt64(vLeft, FormatProvider) * Convert.ToUInt64(vRight, FormatProvider);}
break;}
case StorageType.Decimal:{
checked {value = Convert.ToDecimal(vLeft, FormatProvider) * Convert.ToDecimal(vRight, FormatProvider);}
break;}
case StorageType.SqlDecimal:{
value = (SqlConvert.ConvertToSqlDecimal(vLeft) * SqlConvert.ConvertToSqlDecimal(vRight));
break;}
case StorageType.Single:{
checked {value = Convert.ToSingle(vLeft, FormatProvider) * Convert.ToSingle(vRight, FormatProvider);}
break;}
case StorageType.SqlSingle:{
value = ( SqlConvert.ConvertToSqlSingle(vLeft) * SqlConvert.ConvertToSqlSingle(vRight));
break;}
case StorageType.SqlMoney:{
value = (SqlConvert.ConvertToSqlMoney(vLeft) * SqlConvert.ConvertToSqlMoney(vRight));
break;}
case StorageType.Double:{
checked {value = Convert.ToDouble(vLeft, FormatProvider) * Convert.ToDouble(vRight, FormatProvider);}
break;}
case StorageType.SqlDouble:{
value = (SqlConvert.ConvertToSqlDouble(vLeft) * SqlConvert.ConvertToSqlDouble(vRight));
break;}
default:{
typeMismatch = true;
break;}
}
break; // Operators.Multiply
case Operators.Divide:
switch(resultType) {
case StorageType.Byte:{
value = Convert.ToByte((Convert.ToByte(vLeft, FormatProvider) / Convert.ToByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SqlByte:{
value = (SqlConvert.ConvertToSqlByte(vLeft) / SqlConvert.ConvertToSqlByte(vRight));
break;}
case StorageType.SByte:{
value = Convert.ToSByte((Convert.ToSByte(vLeft, FormatProvider) / Convert.ToSByte(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int16:{
value = Convert.ToInt16((Convert.ToInt16(vLeft, FormatProvider) / Convert.ToInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.SqlInt16:{
value = (SqlConvert.ConvertToSqlInt16(vLeft) / SqlConvert.ConvertToSqlInt16(vRight));
break;}
case StorageType.UInt16:{
value = Convert.ToUInt16((Convert.ToUInt16(vLeft, FormatProvider) / Convert.ToUInt16(vRight, FormatProvider)), FormatProvider);
break;}
case StorageType.Int32:{
checked {value = Convert.ToInt32(vLeft, FormatProvider) / Convert.ToInt32(vRight, FormatProvider);}
break;}
case StorageType.SqlInt32:{
value = (SqlConvert.ConvertToSqlInt32(vLeft) / SqlConvert.ConvertToSqlInt32(vRight));
break;}
case StorageType.UInt32:{
checked {value = Convert.ToUInt32(vLeft, FormatProvider) / Convert.ToUInt32(vRight, FormatProvider);}
break;}
case StorageType.UInt64:{
checked {value = Convert.ToUInt64(vLeft, FormatProvider) / Convert.ToUInt64(vRight, FormatProvider);}
break;}
case StorageType.Int64:{
checked {value = Convert.ToInt64(vLeft, FormatProvider) / Convert.ToInt64(vRight, FormatProvider);}
break;}
case StorageType.SqlInt64:{
value = (SqlConvert.ConvertToSqlInt64(vLeft) / SqlConvert.ConvertToSqlInt64(vRight));
break;}
case StorageType.Decimal:{
checked {value = Convert.ToDecimal(vLeft, FormatProvider) / Convert.ToDecimal(vRight, FormatProvider);}
break;}
case StorageType.SqlDecimal:{
value = (SqlConvert.ConvertToSqlDecimal(vLeft) / SqlConvert.ConvertToSqlDecimal(vRight));
break;}
case StorageType.Single:{
checked {value = Convert.ToSingle(vLeft, FormatProvider) / Convert.ToSingle(vRight, FormatProvider);}
break;}
case StorageType.SqlSingle:{
value = ( SqlConvert.ConvertToSqlSingle(vLeft) / SqlConvert.ConvertToSqlSingle(vRight));
break;}
case StorageType.SqlMoney:{
value = (SqlConvert.ConvertToSqlMoney(vLeft) / SqlConvert.ConvertToSqlMoney(vRight));
break;}
case StorageType.Double:{
Double b = Convert.ToDouble(vRight, FormatProvider);
checked {value = Convert.ToDouble(vLeft, FormatProvider) / b;}
break;}
case StorageType.SqlDouble:{
value = (SqlConvert.ConvertToSqlDouble(vLeft) / SqlConvert.ConvertToSqlDouble(vRight));
break;}
default:{
typeMismatch = true;
break;}
}
break; // Operators.Divide
case Operators.EqualTo:
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)) ||
(vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
return DBNull.Value;
return(0 == BinaryCompare (vLeft, vRight, resultType, Operators.EqualTo));
case Operators.GreaterThen:
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)) ||
(vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
return DBNull.Value;
return(0 < BinaryCompare (vLeft, vRight, resultType, op));
case Operators.LessThen:
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)) ||
(vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
return DBNull.Value;
return(0 > BinaryCompare (vLeft, vRight, resultType, op));
case Operators.GreaterOrEqual:
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)) ||
(vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
return DBNull.Value;
return(0 <= BinaryCompare (vLeft, vRight, resultType, op));
case Operators.LessOrEqual:
if (((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft))) ||
((vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight))))
return DBNull.Value;
return(0 >= BinaryCompare (vLeft, vRight, resultType, op));
case Operators.NotEqual:
if (((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft))) ||
((vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight))))
return DBNull.Value;
return(0 != BinaryCompare (vLeft, vRight, resultType, op));
case Operators.Is:
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft))){
return true;
}
return false;
case Operators.IsNot:
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft))){
return false;
}
return true;
case Operators.And:
/*
special case evaluating of the AND operator: we don't want to evaluate
both right and left operands, because we can shortcut :
If one of the operands is flase the result is false
*/
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)))
return DBNull.Value;
if ((!(vLeft is bool)) && (!(vLeft is SqlBoolean))){
vRight = BinaryNode.Eval(right, row, version, recordNos);
typeMismatch = true;
break;
}
if (vLeft is bool){
if ((bool)vLeft == false){
value = false;
break;
}
}
else{
if (((SqlBoolean) vLeft).IsFalse){
value = false;
break;
}
}
vRight = BinaryNode.Eval(right, row, version, recordNos);
if ((vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight )))
return DBNull.Value;
if ((!(vRight is bool)) && (!(vRight is SqlBoolean))){
typeMismatch = true;
break;
}
if (vRight is bool){
value = (bool)vRight;
break;
}
else{
value = ((SqlBoolean) vRight).IsTrue;
}
break;
case Operators.Or:
/*
special case evaluating the OR operator: we don't want to evaluate
both right and left operands, because we can shortcut :
If one of the operands is true the result is true
*/
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if ((vLeft != DBNull.Value) && (!DataStorage.IsObjectSqlNull(vLeft))) {
if ((!(vLeft is bool)) && (!(vLeft is SqlBoolean))) {
vRight = BinaryNode.Eval(right, row, version, recordNos);
typeMismatch = true;
break;
}
if ((bool)vLeft == true) {
value = true;
break;
}
}
vRight = BinaryNode.Eval(right, row, version, recordNos);
if ((vRight == DBNull.Value)||(DataStorage.IsObjectSqlNull(vRight)))
return vLeft;
if ((vLeft == DBNull.Value)||(DataStorage.IsObjectSqlNull(vLeft)))
return vRight;
if ((!(vRight is bool)) && (!(vRight is SqlBoolean))) {
typeMismatch = true;
break;
}
value = (vRight is bool) ? ((bool)vRight) : (((SqlBoolean)vRight).IsTrue);
break;
/* for M3, use original code , in below, and make sure to have two different code path; increases perf
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if (vLeft != DBNull.Value) {
if (!(vLeft is bool)) {
vRight = BinaryNode.Eval(right, row, version, recordNos);
typeMismatch = true;
break;
}
if ((bool)vLeft == true) {
value = true;
break;
}
}
vRight = BinaryNode.Eval(right, row, version, recordNos);
if (vRight == DBNull.Value)
return vLeft;
if (vLeft == DBNull.Value)
return vRight;
if (!(vRight is bool)) {
typeMismatch = true;
break;
}
value = (bool)vRight;
break;
*/
case Operators.Modulo:
if (ExpressionNode.IsIntegerSql(resultType)) {
if (resultType == StorageType.UInt64) {
value = Convert.ToUInt64(vLeft, FormatProvider) % Convert.ToUInt64(vRight, FormatProvider);
}
else if (DataStorage.IsSqlType(resultType)) {
SqlInt64 res = (SqlConvert.ConvertToSqlInt64(vLeft) % SqlConvert.ConvertToSqlInt64(vRight));
if (resultType == StorageType.SqlInt32){
value = (SqlInt32) res.ToSqlInt32();
}
else if (resultType == StorageType.SqlInt16){
value = (SqlInt16) res.ToSqlInt16();
}
else if (resultType == StorageType.SqlByte){
value = (SqlByte) res.ToSqlByte();
}
else{
value = (SqlInt64) res;
}
}
else {
value = Convert.ToInt64(vLeft, FormatProvider) % Convert.ToInt64(vRight, FormatProvider);
value = Convert.ChangeType(value, DataStorage.GetTypeStorage(resultType), FormatProvider);
}
}
else {
typeMismatch = true;
}
break;
case Operators.In:
/*
special case evaluating of the IN operator: the right have to be IN function node
*/
if (!(right is FunctionNode)) {
// this is more like an Assert: should never happens, so we do not care about "nice" Exseptions
throw ExprException.InWithoutParentheses();
}
vLeft = BinaryNode.Eval(left, row, version, recordNos);
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)))
return DBNull.Value;
/* validate IN parameters : must all be constant expressions */
value = false;
FunctionNode into = (FunctionNode)right;
for (int i = 0; i < into.argumentCount; i++) {
vRight = into.arguments[i].Eval();
if ((vRight == DBNull.Value)||(right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
continue;
Debug.Assert((!DataStorage.IsObjectNull(vLeft))&& (!DataStorage.IsObjectNull(vRight)), "Imposible..");
resultType = DataStorage.GetStorageType(vLeft.GetType());
if (0 == BinaryCompare(vLeft, vRight, resultType, Operators.EqualTo)) {
value = true;
break;
}
}
break;
default:
throw ExprException.UnsupportedOperator(op);
}
}
catch (OverflowException) {
throw ExprException.Overflow(DataStorage.GetTypeStorage(resultType));
}
if (typeMismatch) {
SetTypeMismatchError(op, vLeft.GetType(), vRight.GetType());
}
return value;
}
// Data type precedence rules specify which data type is converted to the other.
// The data type with the lower precedence is converted to the data type with the higher precedence.
// If the conversion is not a supported implicit conversion, an error is returned.
// When both operand expressions have the same data type, the result of the operation has that data type.
// This is the precedence order for the DataSet numeric data types:
private enum DataTypePrecedence {
SqlDateTime = 24,
DateTime = 23,
TimeSpan = 20,
SqlDouble = 19,
Double = 18,
SqlSingle = 17,
Single = 16,
SqlDecimal = 15,
Decimal = 14,
SqlMoney = 13,
UInt64 = 12,
SqlInt64 = 11,
Int64 = 10,
UInt32 = 9,
SqlInt32 = 8,
Int32 = 7,
UInt16 = 6,
SqlInt16 = 5,
Int16 = 4,
Byte = 3,
SqlByte = 2,
SByte = 1,
Error = 0,
SqlBoolean = -1,
Boolean = -2,
SqlGuid = -3,
SqlString = -4,
String = -5,
SqlXml = -6,
SqlChars = -7,
Char = -8,
SqlBytes = -9,
SqlBinary = -10,
}
private DataTypePrecedence GetPrecedence(StorageType storageType) {
switch(storageType) {
case StorageType.Boolean: return DataTypePrecedence.Boolean;
case StorageType.Char: return DataTypePrecedence.Char;
case StorageType.SByte: return DataTypePrecedence.SByte;
case StorageType.Byte: return DataTypePrecedence.Byte;
case StorageType.Int16: return DataTypePrecedence.Int16;
case StorageType.UInt16: return DataTypePrecedence.UInt16;
case StorageType.Int32: return DataTypePrecedence.Int32;
case StorageType.UInt32: return DataTypePrecedence.UInt32;
case StorageType.Int64: return DataTypePrecedence.Int64;
case StorageType.UInt64: return DataTypePrecedence.UInt64;
case StorageType.Single: return DataTypePrecedence.Single;
case StorageType.Double: return DataTypePrecedence.Double;
case StorageType.Decimal: return DataTypePrecedence.Decimal;
case StorageType.DateTime: return DataTypePrecedence.DateTime;
case StorageType.TimeSpan: return DataTypePrecedence.TimeSpan;
case StorageType.String: return DataTypePrecedence.String;
case StorageType.SqlBinary: return DataTypePrecedence.SqlBinary;
case StorageType.SqlBoolean: return DataTypePrecedence.SqlBoolean;
case StorageType.SqlByte: return DataTypePrecedence.SqlByte;
case StorageType.SqlBytes: return DataTypePrecedence.SqlBytes;
case StorageType.SqlChars: return DataTypePrecedence.SqlChars;
case StorageType.SqlDateTime: return DataTypePrecedence.SqlDateTime;
case StorageType.SqlDecimal: return DataTypePrecedence.SqlDecimal;
case StorageType.SqlDouble: return DataTypePrecedence.SqlDouble;
case StorageType.SqlGuid: return DataTypePrecedence.SqlGuid;
case StorageType.SqlInt16: return DataTypePrecedence.SqlInt16;
case StorageType.SqlInt32: return DataTypePrecedence.SqlInt32;
case StorageType.SqlInt64: return DataTypePrecedence.SqlInt64;
case StorageType.SqlMoney: return DataTypePrecedence.SqlMoney;
case StorageType.SqlSingle: return DataTypePrecedence.SqlSingle;
case StorageType.SqlString: return DataTypePrecedence.SqlString;
// case StorageType.SqlXml: return DataTypePrecedence.SqlXml;
case StorageType.Empty:
case StorageType.Object:
case StorageType.DBNull:
default: return DataTypePrecedence.Error;
}
}
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.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;
}
}
private bool IsMixed(StorageType left, StorageType right) {
return ((IsSigned(left) && IsUnsigned(right)) ||
(IsUnsigned(left) && IsSigned(right)));
}
private bool IsMixedSql(StorageType left, StorageType right) {
return ((IsSignedSql(left) && IsUnsignedSql(right)) ||
(IsUnsignedSql(left) && IsSignedSql(right)));
}
internal StorageType ResultType(StorageType left, StorageType right, bool lc, bool rc, int op) {
if ((left == StorageType.Guid) && (right == StorageType.Guid) && Operators.IsRelational(op))
return left;
if ((left == StorageType.String) && (right == StorageType.Guid) && Operators.IsRelational(op))
return left;
if ((left == StorageType.Guid) && (right == StorageType.String) && Operators.IsRelational(op))
return right;
int leftPrecedence = (int)GetPrecedence(left);
if (leftPrecedence == (int)DataTypePrecedence.Error) {
return StorageType.Empty;
}
int rightPrecedence = (int)GetPrecedence(right);
if (rightPrecedence == (int)DataTypePrecedence.Error) {
return StorageType.Empty;
}
if (Operators.IsLogical(op)){
if (left == StorageType.Boolean && right == StorageType.Boolean)
return StorageType.Boolean;
else
return StorageType.Empty;
}
if ((op == Operators.Plus) && ((left == StorageType.String) || (right == StorageType.String)))
return StorageType.String;
DataTypePrecedence higherPrec = (DataTypePrecedence)Math.Max(leftPrecedence, rightPrecedence);
StorageType result = GetPrecedenceType(higherPrec);
if (Operators.IsArithmetical(op)) {
if (result != StorageType.String && result != StorageType.Char) {
if (!IsNumeric(left))
return StorageType.Empty;
if (!IsNumeric(right))
return StorageType.Empty;
}
}
// if the operation is a division the result should be at least a double
if ((op == Operators.Divide) && IsInteger(result)) {
return StorageType.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 = GetPrecedenceType(higherPrec+1);
else
throw ExprException.AmbiguousBinop(op, DataStorage.GetTypeStorage(left), DataStorage.GetTypeStorage(right));
}
}
return result;
}
internal StorageType ResultSqlType(StorageType left, StorageType right, bool lc, bool rc, int op) {
int leftPrecedence = (int)GetPrecedence(left);
if (leftPrecedence == (int)DataTypePrecedence.Error) {
return StorageType.Empty;
}
int rightPrecedence = (int)GetPrecedence(right);
if (rightPrecedence == (int)DataTypePrecedence.Error) {
return StorageType.Empty;
}
if (Operators.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 == Operators.Plus){
if((left == StorageType.SqlString) ||(right == StorageType.SqlString))
return StorageType.SqlString;
if ((left == StorageType.String) || (right == StorageType.String))
return StorageType.String;
}
//SqlBinary is operable just with SqlBinary
if ((left == StorageType.SqlBinary && right != StorageType.SqlBinary) ||(left != StorageType.SqlBinary && right == StorageType.SqlBinary))
return StorageType.Empty;
//SqlGuid is operable just with SqlGuid
if((left == StorageType.SqlGuid && right != StorageType.SqlGuid) ||(left != StorageType.SqlGuid && right == StorageType.SqlGuid))
return StorageType.Empty;
if ((leftPrecedence > (int)DataTypePrecedence.SqlDouble && rightPrecedence <(int) DataTypePrecedence.TimeSpan)){
return StorageType.Empty;
}
if ((leftPrecedence < (int)DataTypePrecedence.TimeSpan && rightPrecedence >(int) DataTypePrecedence.SqlDouble)){
return StorageType.Empty;
}
if (leftPrecedence > (int) DataTypePrecedence.SqlDouble){
if (op == Operators.Plus || op == Operators.Minus){
if (left == StorageType.TimeSpan)
return right;
if (right == StorageType.TimeSpan)
return left;
return StorageType.Empty; // for plus or minus operations for time types, one of them MUST be time span
}
if (!Operators.IsRelational(op))
return StorageType.Empty; // we just have relational operations amoung time types
return left;
}
// time types finished
// continue with numerical types, numbers
DataTypePrecedence higherPrec = (DataTypePrecedence)Math.Max(leftPrecedence, rightPrecedence);
StorageType result = GetPrecedenceType(higherPrec);
// if we have at least one Sql type, the intermediate result should be Sql type
result = GetPrecedenceType((DataTypePrecedence)SqlResultType((int)higherPrec));
if (Operators.IsArithmetical(op)) {
if (result != StorageType.String && result != StorageType.Char && result != StorageType.SqlString) {
if (!IsNumericSql(left))
return StorageType.Empty;
if (!IsNumericSql(right))
return StorageType.Empty;
}
}
// if the operation is a division the result should be at least a double
if ((op == Operators.Divide) && IsIntegerSql(result)) {
return StorageType.SqlDouble;
}
if (result == StorageType.SqlMoney){
if ((left != StorageType.SqlMoney) && (right != StorageType.SqlMoney))
result = StorageType.SqlDecimal;
}
if (IsMixedSql(left, right)) {
// we are dealing with one signed and one unsigned type so
// try to see if one of them is a ConstNode
if (IsUnsignedSql(result)) {
if (higherPrec < DataTypePrecedence.UInt64)
// left and right are mixed integers but with the same length
// so promote to the next signed type
result = GetPrecedenceType(higherPrec+1);
else
throw ExprException.AmbiguousBinop(op, DataStorage.GetTypeStorage(left), DataStorage.GetTypeStorage(right));
}
}
return result;
}
private int SqlResultType(int typeCode){
switch (typeCode){
case 23: return 24;
case 20: return 21;
case 18: return 19;
case 16: return 17;
case 14: return 15;
case 12: return 13;
case 9 :
case 10: return 11;
case 6 :
case 7 : return 8;
case 3 :
case 4 : return 5;
case 1 : return 2;
case -2: return -1;
case -5: return -4;
case -8: return -7;
default : return typeCode;
}
}
}
internal sealed class LikeNode : BinaryNode {
// like kinds
internal const int match_left = 1; // *
internal const int match_right = 2; // *
internal const int match_middle = 3; // **
internal const int match_exact = 4; //
internal const int match_all = 5; // *
int kind;
string pattern = null;
internal LikeNode(DataTable table, int op, ExpressionNode left, ExpressionNode right)
: base (table, op, left, right) {
}
internal override object Eval(DataRow row, DataRowVersion version) {
object vRight;
//
object vLeft = left.Eval(row, version);
string substring;
if ((vLeft == DBNull.Value)||(left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)))
return DBNull.Value;
if (pattern == null) {
vRight = right.Eval(row, version);
if (!(vRight is string) && !(vRight is SqlString)) {
SetTypeMismatchError(op, vLeft.GetType(), vRight.GetType());
}
if (vRight == DBNull.Value || DataStorage.IsObjectSqlNull(vRight))
return DBNull.Value;
string rightStr = (string) SqlConvert.ChangeType2(vRight, StorageType.String, typeof(string), FormatProvider);
// need to convert like pattern to a string
// SSS_WARNINGS_OFF
// Parce the original pattern, and get the constant part of it..
substring = AnalizePattern(rightStr);
// SSS_WARNINGS_ON
if (right.IsConstant())
pattern = substring;
}
else {
substring = pattern;
}
if (!(vLeft is string) && !(vLeft is SqlString)) {
SetTypeMismatchError(op, vLeft.GetType(), typeof(string));
}
// WhiteSpace Chars Include : 0x9, 0xA, 0xB, 0xC, 0xD, 0x20, 0xA0, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x3000, and 0xFEFF.
char[] trimChars = new char[2] {(char)0x20, (char)0x3000};
string tempStr;
if (vLeft is SqlString)
tempStr = ((SqlString)vLeft).Value;
else
tempStr = (string)vLeft;
string s1 = (tempStr).TrimEnd(trimChars);
switch (kind) {
case match_all:
return true;
case match_exact:
return(0 == table.Compare(s1, substring));
case match_middle:
return(0 <= table.IndexOf(s1, substring));
case match_left:
return(0 == table.IndexOf(s1, substring));
case match_right:
string s2 = substring.TrimEnd(trimChars);
return table.IsSuffix(s1, s2);
default:
Debug.Assert(false, "Unexpected LIKE kind");
return DBNull.Value;
}
}
// SSS_WARNINGS_OFF
internal string AnalizePattern(string pat) {
// SSS_WARNINGS_ON
int length = pat.Length;
char[] patchars = new char[length+1];
pat.CopyTo(0, patchars, 0, length);
patchars[length] = (char)0;
string substring = null;
char[] constchars = new char[length+1];
int newLength = 0;
int stars = 0;
int i = 0;
while (i < length) {
if (patchars[i] == '*' || patchars[i] == '%') {
// replace conseq. * or % with one..
while ((patchars[i] == '*' || patchars[i] == '%') && i < length)
i++;
// we allowing only *str* pattern
if ((i < length && newLength > 0) || stars >= 2) {
// we have a star inside string constant..
throw ExprException.InvalidPattern(pat);
}
stars++;
}
else if (patchars[i] == '[') {
i++;
if (i >= length) {
throw ExprException.InvalidPattern(pat);
}
constchars[newLength++] = patchars[i++];
if (i >= length) {
throw ExprException.InvalidPattern(pat);
}
if (patchars[i] != ']') {
throw ExprException.InvalidPattern(pat);
}
i++;
}
else {
constchars[newLength++] = patchars[i];
i++;
}
}
substring = new string(constchars, 0, newLength);
if (stars == 0) {
kind = match_exact;
}
else {
if (newLength > 0) {
if (patchars[0] == '*' || patchars[0] == '%') {
if (patchars[length-1] == '*' || patchars[length-1] == '%') {
kind = match_middle;
}
else {
kind = match_right;
}
}
else {
Debug.Assert(patchars[length-1] == '*' || patchars[length-1] == '%', "Invalid LIKE pattern formed.. ");
kind = match_left;
}
}
else {
kind = match_all;
}
}
return substring;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DoubleCollection.cs
- ExcCanonicalXml.cs
- SchemaNotation.cs
- DelegateCompletionCallbackWrapper.cs
- PathFigureCollection.cs
- ValidationErrorCollection.cs
- DataGridViewRowCollection.cs
- DbDataAdapter.cs
- TextPointer.cs
- AsyncDataRequest.cs
- MediaPlayer.cs
- MailSettingsSection.cs
- BamlResourceDeserializer.cs
- PrimitiveSchema.cs
- WebPartManager.cs
- _SslSessionsCache.cs
- SharedPerformanceCounter.cs
- SqlUtils.cs
- ResourceSetExpression.cs
- WmlPhoneCallAdapter.cs
- ProfileBuildProvider.cs
- SoapCodeExporter.cs
- ScriptMethodAttribute.cs
- BuildTopDownAttribute.cs
- AppDomainProtocolHandler.cs
- OracleException.cs
- ResourceProperty.cs
- _UriSyntax.cs
- RectAnimationUsingKeyFrames.cs
- DefaultValueConverter.cs
- Viewport3DVisual.cs
- Image.cs
- CompressEmulationStream.cs
- ConfigXmlText.cs
- XmlSchemaCollection.cs
- WebMessageEncodingElement.cs
- SoapWriter.cs
- GPRECT.cs
- XmlHelper.cs
- Types.cs
- ApplicationTrust.cs
- ZipIOExtraFieldZip64Element.cs
- DescendantQuery.cs
- PreloadedPackages.cs
- SoapFaultCodes.cs
- InvalidPropValue.cs
- FilterEventArgs.cs
- ListViewItem.cs
- xamlnodes.cs
- Trigger.cs
- TypeUsageBuilder.cs
- FileIOPermission.cs
- TextDecorationCollection.cs
- KoreanCalendar.cs
- SecurityHeaderTokenResolver.cs
- SID.cs
- CroppedBitmap.cs
- LayoutDump.cs
- RuntimeHandles.cs
- BehaviorEditorPart.cs
- ActiveXMessageFormatter.cs
- TranslateTransform.cs
- TextTreeUndo.cs
- BCLDebug.cs
- DetailsViewInsertEventArgs.cs
- xamlnodes.cs
- WindowsGraphicsWrapper.cs
- SystemIPInterfaceProperties.cs
- IpcChannel.cs
- ApplyImportsAction.cs
- InkCollectionBehavior.cs
- Int16AnimationUsingKeyFrames.cs
- Int64.cs
- UnsafePeerToPeerMethods.cs
- TypeInformation.cs
- SystemNetHelpers.cs
- UniformGrid.cs
- StylusEditingBehavior.cs
- FileRegion.cs
- ProfileSection.cs
- WebPartUtil.cs
- TypedElement.cs
- WebServiceHandlerFactory.cs
- SecureStringHasher.cs
- Simplifier.cs
- SettingsPropertyIsReadOnlyException.cs
- PromptBuilder.cs
- TextTreeDeleteContentUndoUnit.cs
- FrameworkPropertyMetadata.cs
- WindowsBrush.cs
- InvalidOperationException.cs
- LayoutManager.cs
- TextServicesDisplayAttribute.cs
- ToolboxControl.cs
- Misc.cs
- GraphicsPath.cs
- ToolboxSnapDragDropEventArgs.cs
- CodeCompiler.cs
- AutoResizedEvent.cs
- DetailsView.cs