Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
BinaryNode.cs
Go to the documentation of this file.
1using System.Collections.Generic;
2using System.Data.Common;
3using System.Data.SqlTypes;
4using System.Diagnostics.CodeAnalysis;
5using System.Globalization;
6
7namespace System.Data;
8
9internal class BinaryNode : ExpressionNode
10{
11 private enum DataTypePrecedence
12 {
13 SqlDateTime = 25,
14 DateTimeOffset = 24,
15 DateTime = 23,
16 TimeSpan = 20,
17 SqlDouble = 19,
18 Double = 18,
19 SqlSingle = 17,
20 Single = 16,
21 SqlDecimal = 15,
22 Decimal = 14,
23 SqlMoney = 13,
24 UInt64 = 12,
25 SqlInt64 = 11,
26 Int64 = 10,
27 UInt32 = 9,
28 SqlInt32 = 8,
29 Int32 = 7,
30 UInt16 = 6,
31 SqlInt16 = 5,
32 Int16 = 4,
33 Byte = 3,
34 SqlByte = 2,
35 SByte = 1,
36 Error = 0,
37 SqlBoolean = -1,
38 Boolean = -2,
39 SqlGuid = -3,
40 SqlString = -4,
41 String = -5,
42 SqlXml = -6,
43 SqlChars = -7,
44 Char = -8,
45 SqlBytes = -9,
46 SqlBinary = -10
47 }
48
49 internal int _op;
50
51 internal ExpressionNode _left;
52
53 internal ExpressionNode _right;
54
55 internal BinaryNode(DataTable table, int op, ExpressionNode left, ExpressionNode right)
56 : base(table)
57 {
58 _op = op;
59 _left = left;
60 _right = right;
61 }
62
63 internal override void Bind(DataTable table, List<DataColumn> list)
64 {
65 BindTable(table);
66 _left.Bind(table, list);
67 _right.Bind(table, list);
68 }
69
70 [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
71 internal override object Eval()
72 {
73 return Eval(null, DataRowVersion.Default);
74 }
75
76 [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
77 internal override object Eval(DataRow row, DataRowVersion version)
78 {
79 return EvalBinaryOp(_op, _left, _right, row, version, null);
80 }
81
82 [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
83 internal override object Eval(int[] recordNos)
84 {
85 return EvalBinaryOp(_op, _left, _right, null, DataRowVersion.Default, recordNos);
86 }
87
88 internal override bool IsConstant()
89 {
90 if (_left.IsConstant())
91 {
92 return _right.IsConstant();
93 }
94 return false;
95 }
96
97 internal override bool IsTableConstant()
98 {
99 if (_left.IsTableConstant())
100 {
101 return _right.IsTableConstant();
102 }
103 return false;
104 }
105
106 internal override bool HasLocalAggregate()
107 {
108 if (!_left.HasLocalAggregate())
109 {
110 return _right.HasLocalAggregate();
111 }
112 return true;
113 }
114
115 internal override bool HasRemoteAggregate()
116 {
117 if (!_left.HasRemoteAggregate())
118 {
119 return _right.HasRemoteAggregate();
120 }
121 return true;
122 }
123
124 internal override bool DependsOn(DataColumn column)
125 {
126 if (_left.DependsOn(column))
127 {
128 return true;
129 }
130 return _right.DependsOn(column);
131 }
132
133 internal override ExpressionNode Optimize()
134 {
135 _left = _left.Optimize();
136 if (_op == 13)
137 {
138 if (_right is UnaryNode)
139 {
140 UnaryNode unaryNode = (UnaryNode)_right;
141 if (unaryNode._op != 3)
142 {
143 throw ExprException.InvalidIsSyntax();
144 }
145 _op = 39;
146 _right = unaryNode._right;
147 }
148 if (!(_right is ZeroOpNode))
149 {
150 throw ExprException.InvalidIsSyntax();
151 }
152 if (((ZeroOpNode)_right)._op != 32)
153 {
154 throw ExprException.InvalidIsSyntax();
155 }
156 }
157 else
158 {
159 _right = _right.Optimize();
160 }
161 if (IsConstant())
162 {
163 object obj = EvalConstant();
164 if (obj == DBNull.Value)
165 {
166 return new ZeroOpNode(32);
167 }
168 if (obj is bool)
169 {
170 if ((bool)obj)
171 {
172 return new ZeroOpNode(33);
173 }
174 return new ZeroOpNode(34);
175 }
176 return new ConstNode(base.table, ValueType.Object, obj, fParseQuotes: false);
177 }
178 return this;
179 }
180
181 internal void SetTypeMismatchError(int op, Type left, Type right)
182 {
183 throw ExprException.TypeMismatchInBinop(op, left, right);
184 }
185
186 [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Evaluating constant expression is safe.")]
187 private object EvalConstant()
188 {
189 return Eval();
190 }
191
192 [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
193 private static object Eval(ExpressionNode expr, DataRow row, DataRowVersion version, int[] recordNos)
194 {
195 if (recordNos == null)
196 {
197 return expr.Eval(row, version);
198 }
199 return expr.Eval(recordNos);
200 }
201
202 internal int BinaryCompare(object vLeft, object vRight, StorageType resultType, int op)
203 {
204 return BinaryCompare(vLeft, vRight, resultType, op, null);
205 }
206
207 internal int BinaryCompare(object vLeft, object vRight, StorageType resultType, int op, CompareInfo comparer)
208 {
209 int result = 0;
210 try
211 {
212 if (!DataStorage.IsSqlType(resultType))
213 {
214 switch (resultType)
215 {
216 case StorageType.SByte:
217 case StorageType.Byte:
218 case StorageType.Int16:
219 case StorageType.UInt16:
220 case StorageType.Int32:
221 return Convert.ToInt32(vLeft, base.FormatProvider).CompareTo(Convert.ToInt32(vRight, base.FormatProvider));
222 case StorageType.UInt32:
223 case StorageType.Int64:
224 case StorageType.UInt64:
225 case StorageType.Decimal:
226 return decimal.Compare(Convert.ToDecimal(vLeft, base.FormatProvider), Convert.ToDecimal(vRight, base.FormatProvider));
227 case StorageType.Char:
228 return Convert.ToInt32(vLeft, base.FormatProvider).CompareTo(Convert.ToInt32(vRight, base.FormatProvider));
229 case StorageType.Double:
230 return Convert.ToDouble(vLeft, base.FormatProvider).CompareTo(Convert.ToDouble(vRight, base.FormatProvider));
231 case StorageType.Single:
232 return Convert.ToSingle(vLeft, base.FormatProvider).CompareTo(Convert.ToSingle(vRight, base.FormatProvider));
233 case StorageType.DateTime:
234 return DateTime.Compare(Convert.ToDateTime(vLeft, base.FormatProvider), Convert.ToDateTime(vRight, base.FormatProvider));
235 case StorageType.DateTimeOffset:
236 return DateTimeOffset.Compare((DateTimeOffset)vLeft, (DateTimeOffset)vRight);
237 case StorageType.String:
238 return base.table.Compare(Convert.ToString(vLeft, base.FormatProvider), Convert.ToString(vRight, base.FormatProvider), comparer);
239 case StorageType.Guid:
240 return ((Guid)vLeft).CompareTo((Guid)vRight);
241 case StorageType.Boolean:
242 if (op == 7 || op == 12)
243 {
244 return Convert.ToInt32(DataExpression.ToBoolean(vLeft), base.FormatProvider) - Convert.ToInt32(DataExpression.ToBoolean(vRight), base.FormatProvider);
245 }
246 break;
247 case StorageType.TimeSpan:
248 case StorageType.ByteArray:
249 case StorageType.CharArray:
250 case StorageType.Type:
251 break;
252 }
253 }
254 else
255 {
256 switch (resultType)
257 {
258 case StorageType.SByte:
259 case StorageType.Byte:
260 case StorageType.Int16:
261 case StorageType.UInt16:
262 case StorageType.Int32:
263 case StorageType.SqlByte:
264 case StorageType.SqlInt16:
265 case StorageType.SqlInt32:
266 return SqlConvert.ConvertToSqlInt32(vLeft).CompareTo(SqlConvert.ConvertToSqlInt32(vRight));
267 case StorageType.UInt32:
268 case StorageType.Int64:
269 case StorageType.SqlInt64:
270 return SqlConvert.ConvertToSqlInt64(vLeft).CompareTo(SqlConvert.ConvertToSqlInt64(vRight));
271 case StorageType.UInt64:
272 case StorageType.SqlDecimal:
273 return SqlConvert.ConvertToSqlDecimal(vLeft).CompareTo(SqlConvert.ConvertToSqlDecimal(vRight));
274 case StorageType.SqlDouble:
275 return SqlConvert.ConvertToSqlDouble(vLeft).CompareTo(SqlConvert.ConvertToSqlDouble(vRight));
276 case StorageType.SqlSingle:
277 return SqlConvert.ConvertToSqlSingle(vLeft).CompareTo(SqlConvert.ConvertToSqlSingle(vRight));
278 case StorageType.SqlString:
279 return base.table.Compare(vLeft.ToString(), vRight.ToString());
280 case StorageType.SqlGuid:
281 return ((SqlGuid)vLeft).CompareTo(vRight);
282 case StorageType.SqlBoolean:
283 if (op == 7 || op == 12)
284 {
285 result = 1;
286 if ((vLeft.GetType() == typeof(SqlBoolean) && (vRight.GetType() == typeof(SqlBoolean) || vRight.GetType() == typeof(bool))) || (vRight.GetType() == typeof(SqlBoolean) && (vLeft.GetType() == typeof(SqlBoolean) || vLeft.GetType() == typeof(bool))))
287 {
288 return SqlConvert.ConvertToSqlBoolean(vLeft).CompareTo(SqlConvert.ConvertToSqlBoolean(vRight));
289 }
290 }
291 break;
292 case StorageType.SqlBinary:
293 return SqlConvert.ConvertToSqlBinary(vLeft).CompareTo(SqlConvert.ConvertToSqlBinary(vRight));
294 case StorageType.SqlDateTime:
295 return SqlConvert.ConvertToSqlDateTime(vLeft).CompareTo(SqlConvert.ConvertToSqlDateTime(vRight));
296 case StorageType.SqlMoney:
297 return SqlConvert.ConvertToSqlMoney(vLeft).CompareTo(SqlConvert.ConvertToSqlMoney(vRight));
298 case StorageType.Single:
299 case StorageType.Double:
300 case StorageType.Decimal:
301 case StorageType.DateTime:
302 case StorageType.TimeSpan:
303 case StorageType.String:
304 case StorageType.Guid:
305 case StorageType.ByteArray:
306 case StorageType.CharArray:
307 case StorageType.Type:
308 case StorageType.DateTimeOffset:
309 case StorageType.BigInteger:
310 case StorageType.Uri:
311 case StorageType.SqlBytes:
312 case StorageType.SqlChars:
313 break;
314 }
315 }
316 }
317 catch (ArgumentException e)
318 {
319 ExceptionBuilder.TraceExceptionWithoutRethrow(e);
320 }
321 catch (FormatException e2)
322 {
323 ExceptionBuilder.TraceExceptionWithoutRethrow(e2);
324 }
325 catch (InvalidCastException e3)
326 {
327 ExceptionBuilder.TraceExceptionWithoutRethrow(e3);
328 }
329 catch (OverflowException e4)
330 {
331 ExceptionBuilder.TraceExceptionWithoutRethrow(e4);
332 }
333 catch (EvaluateException e5)
334 {
335 ExceptionBuilder.TraceExceptionWithoutRethrow(e5);
336 }
337 SetTypeMismatchError(op, vLeft.GetType(), vRight.GetType());
338 return result;
339 }
340
341 [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
342 private object EvalBinaryOp(int op, ExpressionNode left, ExpressionNode right, DataRow row, DataRowVersion version, int[] recordNos)
343 {
344 object obj2;
345 StorageType storageType3;
346 object obj;
347 if (op != 27 && op != 26 && op != 5 && op != 13 && op != 39)
348 {
349 obj = Eval(left, row, version, recordNos);
350 obj2 = Eval(right, row, version, recordNos);
351 Type type = obj.GetType();
352 Type type2 = obj2.GetType();
353 StorageType storageType = DataStorage.GetStorageType(type);
354 StorageType storageType2 = DataStorage.GetStorageType(type2);
355 bool flag = DataStorage.IsSqlType(storageType);
356 bool flag2 = DataStorage.IsSqlType(storageType2);
357 if (flag && DataStorage.IsObjectSqlNull(obj))
358 {
359 return obj;
360 }
361 if (flag2 && DataStorage.IsObjectSqlNull(obj2))
362 {
363 return obj2;
364 }
365 if (obj == DBNull.Value || obj2 == DBNull.Value)
366 {
367 return DBNull.Value;
368 }
369 storageType3 = ((!(flag || flag2)) ? ResultType(storageType, storageType2, left is ConstNode, right is ConstNode, op) : ResultSqlType(storageType, storageType2, left is ConstNode, right is ConstNode, op));
370 if (storageType3 == StorageType.Empty)
371 {
372 SetTypeMismatchError(op, type, type2);
373 }
374 }
375 else
376 {
377 obj = (obj2 = DBNull.Value);
378 storageType3 = StorageType.Empty;
379 }
380 object result = DBNull.Value;
381 bool flag3 = false;
382 try
383 {
384 switch (op)
385 {
386 case 15:
387 switch (storageType3)
388 {
389 case StorageType.Byte:
390 result = Convert.ToByte(Convert.ToByte(obj, base.FormatProvider) + Convert.ToByte(obj2, base.FormatProvider), base.FormatProvider);
391 break;
392 case StorageType.SByte:
393 result = Convert.ToSByte(Convert.ToSByte(obj, base.FormatProvider) + Convert.ToSByte(obj2, base.FormatProvider), base.FormatProvider);
394 break;
395 case StorageType.Int16:
396 result = Convert.ToInt16(Convert.ToInt16(obj, base.FormatProvider) + Convert.ToInt16(obj2, base.FormatProvider), base.FormatProvider);
397 break;
398 case StorageType.UInt16:
399 result = Convert.ToUInt16(Convert.ToUInt16(obj, base.FormatProvider) + Convert.ToUInt16(obj2, base.FormatProvider), base.FormatProvider);
400 break;
401 case StorageType.Int32:
402 result = checked(Convert.ToInt32(obj, base.FormatProvider) + Convert.ToInt32(obj2, base.FormatProvider));
403 break;
404 case StorageType.UInt32:
405 result = checked(Convert.ToUInt32(obj, base.FormatProvider) + Convert.ToUInt32(obj2, base.FormatProvider));
406 break;
407 case StorageType.UInt64:
408 result = checked(Convert.ToUInt64(obj, base.FormatProvider) + Convert.ToUInt64(obj2, base.FormatProvider));
409 break;
410 case StorageType.Int64:
411 result = checked(Convert.ToInt64(obj, base.FormatProvider) + Convert.ToInt64(obj2, base.FormatProvider));
412 break;
413 case StorageType.Decimal:
414 result = Convert.ToDecimal(obj, base.FormatProvider) + Convert.ToDecimal(obj2, base.FormatProvider);
415 break;
416 case StorageType.Single:
417 result = Convert.ToSingle(obj, base.FormatProvider) + Convert.ToSingle(obj2, base.FormatProvider);
418 break;
419 case StorageType.Double:
420 result = Convert.ToDouble(obj, base.FormatProvider) + Convert.ToDouble(obj2, base.FormatProvider);
421 break;
422 case StorageType.Char:
423 case StorageType.String:
424 result = Convert.ToString(obj, base.FormatProvider) + Convert.ToString(obj2, base.FormatProvider);
425 break;
426 case StorageType.DateTime:
427 if (obj is TimeSpan && obj2 is DateTime)
428 {
429 result = (DateTime)obj2 + (TimeSpan)obj;
430 }
431 else if (obj is DateTime && obj2 is TimeSpan)
432 {
433 result = (DateTime)obj + (TimeSpan)obj2;
434 }
435 else
436 {
437 flag3 = true;
438 }
439 break;
440 case StorageType.TimeSpan:
441 result = (TimeSpan)obj + (TimeSpan)obj2;
442 break;
443 case StorageType.SqlInt16:
444 result = SqlConvert.ConvertToSqlInt16(obj) + SqlConvert.ConvertToSqlInt16(obj2);
445 break;
446 case StorageType.SqlInt32:
447 result = SqlConvert.ConvertToSqlInt32(obj) + SqlConvert.ConvertToSqlInt32(obj2);
448 break;
449 case StorageType.SqlInt64:
450 result = SqlConvert.ConvertToSqlInt64(obj) + SqlConvert.ConvertToSqlInt64(obj2);
451 break;
452 case StorageType.SqlDouble:
453 result = SqlConvert.ConvertToSqlDouble(obj) + SqlConvert.ConvertToSqlDouble(obj2);
454 break;
455 case StorageType.SqlSingle:
456 result = SqlConvert.ConvertToSqlSingle(obj) + SqlConvert.ConvertToSqlSingle(obj2);
457 break;
458 case StorageType.SqlDecimal:
459 result = SqlConvert.ConvertToSqlDecimal(obj) + SqlConvert.ConvertToSqlDecimal(obj2);
460 break;
461 case StorageType.SqlMoney:
462 result = SqlConvert.ConvertToSqlMoney(obj) + SqlConvert.ConvertToSqlMoney(obj2);
463 break;
464 case StorageType.SqlByte:
465 result = SqlConvert.ConvertToSqlByte(obj) + SqlConvert.ConvertToSqlByte(obj2);
466 break;
467 case StorageType.SqlString:
468 result = SqlConvert.ConvertToSqlString(obj) + SqlConvert.ConvertToSqlString(obj2);
469 break;
470 case StorageType.SqlDateTime:
471 if (obj is TimeSpan && obj2 is SqlDateTime)
472 {
473 result = SqlConvert.ConvertToSqlDateTime(SqlConvert.ConvertToSqlDateTime(obj2).Value + (TimeSpan)obj);
474 }
475 else if (obj is SqlDateTime && obj2 is TimeSpan)
476 {
477 result = SqlConvert.ConvertToSqlDateTime(SqlConvert.ConvertToSqlDateTime(obj).Value + (TimeSpan)obj2);
478 }
479 else
480 {
481 flag3 = true;
482 }
483 break;
484 default:
485 flag3 = true;
486 break;
487 }
488 break;
489 case 16:
490 switch (storageType3)
491 {
492 case StorageType.Byte:
493 result = Convert.ToByte(Convert.ToByte(obj, base.FormatProvider) - Convert.ToByte(obj2, base.FormatProvider), base.FormatProvider);
494 break;
495 case StorageType.SqlByte:
496 result = SqlConvert.ConvertToSqlByte(obj) - SqlConvert.ConvertToSqlByte(obj2);
497 break;
498 case StorageType.SByte:
499 result = Convert.ToSByte(Convert.ToSByte(obj, base.FormatProvider) - Convert.ToSByte(obj2, base.FormatProvider), base.FormatProvider);
500 break;
501 case StorageType.Int16:
502 result = Convert.ToInt16(Convert.ToInt16(obj, base.FormatProvider) - Convert.ToInt16(obj2, base.FormatProvider), base.FormatProvider);
503 break;
504 case StorageType.SqlInt16:
505 result = SqlConvert.ConvertToSqlInt16(obj) - SqlConvert.ConvertToSqlInt16(obj2);
506 break;
507 case StorageType.UInt16:
508 result = Convert.ToUInt16(Convert.ToUInt16(obj, base.FormatProvider) - Convert.ToUInt16(obj2, base.FormatProvider), base.FormatProvider);
509 break;
510 case StorageType.Int32:
511 result = checked(Convert.ToInt32(obj, base.FormatProvider) - Convert.ToInt32(obj2, base.FormatProvider));
512 break;
513 case StorageType.SqlInt32:
514 result = SqlConvert.ConvertToSqlInt32(obj) - SqlConvert.ConvertToSqlInt32(obj2);
515 break;
516 case StorageType.UInt32:
517 result = checked(Convert.ToUInt32(obj, base.FormatProvider) - Convert.ToUInt32(obj2, base.FormatProvider));
518 break;
519 case StorageType.Int64:
520 result = checked(Convert.ToInt64(obj, base.FormatProvider) - Convert.ToInt64(obj2, base.FormatProvider));
521 break;
522 case StorageType.SqlInt64:
523 result = SqlConvert.ConvertToSqlInt64(obj) - SqlConvert.ConvertToSqlInt64(obj2);
524 break;
525 case StorageType.UInt64:
526 result = checked(Convert.ToUInt64(obj, base.FormatProvider) - Convert.ToUInt64(obj2, base.FormatProvider));
527 break;
528 case StorageType.Decimal:
529 result = Convert.ToDecimal(obj, base.FormatProvider) - Convert.ToDecimal(obj2, base.FormatProvider);
530 break;
531 case StorageType.SqlDecimal:
532 result = SqlConvert.ConvertToSqlDecimal(obj) - SqlConvert.ConvertToSqlDecimal(obj2);
533 break;
534 case StorageType.Single:
535 result = Convert.ToSingle(obj, base.FormatProvider) - Convert.ToSingle(obj2, base.FormatProvider);
536 break;
537 case StorageType.SqlSingle:
538 result = SqlConvert.ConvertToSqlSingle(obj) - SqlConvert.ConvertToSqlSingle(obj2);
539 break;
540 case StorageType.Double:
541 result = Convert.ToDouble(obj, base.FormatProvider) - Convert.ToDouble(obj2, base.FormatProvider);
542 break;
543 case StorageType.SqlDouble:
544 result = SqlConvert.ConvertToSqlDouble(obj) - SqlConvert.ConvertToSqlDouble(obj2);
545 break;
546 case StorageType.SqlMoney:
547 result = SqlConvert.ConvertToSqlMoney(obj) - SqlConvert.ConvertToSqlMoney(obj2);
548 break;
549 case StorageType.DateTime:
550 result = (DateTime)obj - (TimeSpan)obj2;
551 break;
552 case StorageType.TimeSpan:
553 result = ((!(obj is DateTime)) ? ((object)((TimeSpan)obj - (TimeSpan)obj2)) : ((object)((DateTime)obj - (DateTime)obj2)));
554 break;
555 case StorageType.SqlDateTime:
556 if (obj is TimeSpan && obj2 is SqlDateTime)
557 {
558 result = SqlConvert.ConvertToSqlDateTime(SqlConvert.ConvertToSqlDateTime(obj2).Value - (TimeSpan)obj);
559 }
560 else if (obj is SqlDateTime && obj2 is TimeSpan)
561 {
562 result = SqlConvert.ConvertToSqlDateTime(SqlConvert.ConvertToSqlDateTime(obj).Value - (TimeSpan)obj2);
563 }
564 else
565 {
566 flag3 = true;
567 }
568 break;
569 default:
570 flag3 = true;
571 break;
572 }
573 break;
574 case 17:
575 switch (storageType3)
576 {
577 case StorageType.Byte:
578 result = Convert.ToByte(Convert.ToByte(obj, base.FormatProvider) * Convert.ToByte(obj2, base.FormatProvider), base.FormatProvider);
579 break;
580 case StorageType.SqlByte:
581 result = SqlConvert.ConvertToSqlByte(obj) * SqlConvert.ConvertToSqlByte(obj2);
582 break;
583 case StorageType.SByte:
584 result = Convert.ToSByte(Convert.ToSByte(obj, base.FormatProvider) * Convert.ToSByte(obj2, base.FormatProvider), base.FormatProvider);
585 break;
586 case StorageType.Int16:
587 result = Convert.ToInt16(Convert.ToInt16(obj, base.FormatProvider) * Convert.ToInt16(obj2, base.FormatProvider), base.FormatProvider);
588 break;
589 case StorageType.SqlInt16:
590 result = SqlConvert.ConvertToSqlInt16(obj) * SqlConvert.ConvertToSqlInt16(obj2);
591 break;
592 case StorageType.UInt16:
593 result = Convert.ToUInt16(Convert.ToUInt16(obj, base.FormatProvider) * Convert.ToUInt16(obj2, base.FormatProvider), base.FormatProvider);
594 break;
595 case StorageType.Int32:
596 result = checked(Convert.ToInt32(obj, base.FormatProvider) * Convert.ToInt32(obj2, base.FormatProvider));
597 break;
598 case StorageType.SqlInt32:
599 result = SqlConvert.ConvertToSqlInt32(obj) * SqlConvert.ConvertToSqlInt32(obj2);
600 break;
601 case StorageType.UInt32:
602 result = checked(Convert.ToUInt32(obj, base.FormatProvider) * Convert.ToUInt32(obj2, base.FormatProvider));
603 break;
604 case StorageType.Int64:
605 result = checked(Convert.ToInt64(obj, base.FormatProvider) * Convert.ToInt64(obj2, base.FormatProvider));
606 break;
607 case StorageType.SqlInt64:
608 result = SqlConvert.ConvertToSqlInt64(obj) * SqlConvert.ConvertToSqlInt64(obj2);
609 break;
610 case StorageType.UInt64:
611 result = checked(Convert.ToUInt64(obj, base.FormatProvider) * Convert.ToUInt64(obj2, base.FormatProvider));
612 break;
613 case StorageType.Decimal:
614 result = Convert.ToDecimal(obj, base.FormatProvider) * Convert.ToDecimal(obj2, base.FormatProvider);
615 break;
616 case StorageType.SqlDecimal:
617 result = SqlConvert.ConvertToSqlDecimal(obj) * SqlConvert.ConvertToSqlDecimal(obj2);
618 break;
619 case StorageType.Single:
620 result = Convert.ToSingle(obj, base.FormatProvider) * Convert.ToSingle(obj2, base.FormatProvider);
621 break;
622 case StorageType.SqlSingle:
623 result = SqlConvert.ConvertToSqlSingle(obj) * SqlConvert.ConvertToSqlSingle(obj2);
624 break;
625 case StorageType.SqlMoney:
626 result = SqlConvert.ConvertToSqlMoney(obj) * SqlConvert.ConvertToSqlMoney(obj2);
627 break;
628 case StorageType.Double:
629 result = Convert.ToDouble(obj, base.FormatProvider) * Convert.ToDouble(obj2, base.FormatProvider);
630 break;
631 case StorageType.SqlDouble:
632 result = SqlConvert.ConvertToSqlDouble(obj) * SqlConvert.ConvertToSqlDouble(obj2);
633 break;
634 default:
635 flag3 = true;
636 break;
637 }
638 break;
639 case 18:
640 switch (storageType3)
641 {
642 case StorageType.Byte:
643 result = Convert.ToByte(Convert.ToByte(obj, base.FormatProvider) / Convert.ToByte(obj2, base.FormatProvider), base.FormatProvider);
644 break;
645 case StorageType.SqlByte:
646 result = SqlConvert.ConvertToSqlByte(obj) / SqlConvert.ConvertToSqlByte(obj2);
647 break;
648 case StorageType.SByte:
649 result = Convert.ToSByte(Convert.ToSByte(obj, base.FormatProvider) / Convert.ToSByte(obj2, base.FormatProvider), base.FormatProvider);
650 break;
651 case StorageType.Int16:
652 result = Convert.ToInt16(Convert.ToInt16(obj, base.FormatProvider) / Convert.ToInt16(obj2, base.FormatProvider), base.FormatProvider);
653 break;
654 case StorageType.SqlInt16:
655 result = SqlConvert.ConvertToSqlInt16(obj) / SqlConvert.ConvertToSqlInt16(obj2);
656 break;
657 case StorageType.UInt16:
658 result = Convert.ToUInt16(Convert.ToUInt16(obj, base.FormatProvider) / Convert.ToUInt16(obj2, base.FormatProvider), base.FormatProvider);
659 break;
660 case StorageType.Int32:
661 result = Convert.ToInt32(obj, base.FormatProvider) / Convert.ToInt32(obj2, base.FormatProvider);
662 break;
663 case StorageType.SqlInt32:
664 result = SqlConvert.ConvertToSqlInt32(obj) / SqlConvert.ConvertToSqlInt32(obj2);
665 break;
666 case StorageType.UInt32:
667 result = Convert.ToUInt32(obj, base.FormatProvider) / Convert.ToUInt32(obj2, base.FormatProvider);
668 break;
669 case StorageType.UInt64:
670 result = Convert.ToUInt64(obj, base.FormatProvider) / Convert.ToUInt64(obj2, base.FormatProvider);
671 break;
672 case StorageType.Int64:
673 result = Convert.ToInt64(obj, base.FormatProvider) / Convert.ToInt64(obj2, base.FormatProvider);
674 break;
675 case StorageType.SqlInt64:
676 result = SqlConvert.ConvertToSqlInt64(obj) / SqlConvert.ConvertToSqlInt64(obj2);
677 break;
678 case StorageType.Decimal:
679 result = Convert.ToDecimal(obj, base.FormatProvider) / Convert.ToDecimal(obj2, base.FormatProvider);
680 break;
681 case StorageType.SqlDecimal:
682 result = SqlConvert.ConvertToSqlDecimal(obj) / SqlConvert.ConvertToSqlDecimal(obj2);
683 break;
684 case StorageType.Single:
685 result = Convert.ToSingle(obj, base.FormatProvider) / Convert.ToSingle(obj2, base.FormatProvider);
686 break;
687 case StorageType.SqlSingle:
688 result = SqlConvert.ConvertToSqlSingle(obj) / SqlConvert.ConvertToSqlSingle(obj2);
689 break;
690 case StorageType.SqlMoney:
691 result = SqlConvert.ConvertToSqlMoney(obj) / SqlConvert.ConvertToSqlMoney(obj2);
692 break;
693 case StorageType.Double:
694 {
695 double num = Convert.ToDouble(obj2, base.FormatProvider);
696 result = Convert.ToDouble(obj, base.FormatProvider) / num;
697 break;
698 }
699 case StorageType.SqlDouble:
700 result = SqlConvert.ConvertToSqlDouble(obj) / SqlConvert.ConvertToSqlDouble(obj2);
701 break;
702 default:
703 flag3 = true;
704 break;
705 }
706 break;
707 case 7:
708 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
709 {
710 return DBNull.Value;
711 }
712 return BinaryCompare(obj, obj2, storageType3, 7) == 0;
713 case 8:
714 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
715 {
716 return DBNull.Value;
717 }
718 return 0 < BinaryCompare(obj, obj2, storageType3, op);
719 case 9:
720 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
721 {
722 return DBNull.Value;
723 }
724 return 0 > BinaryCompare(obj, obj2, storageType3, op);
725 case 10:
726 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
727 {
728 return DBNull.Value;
729 }
730 return 0 <= BinaryCompare(obj, obj2, storageType3, op);
731 case 11:
732 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
733 {
734 return DBNull.Value;
735 }
736 return 0 >= BinaryCompare(obj, obj2, storageType3, op);
737 case 12:
738 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)) || obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
739 {
740 return DBNull.Value;
741 }
742 return BinaryCompare(obj, obj2, storageType3, op) != 0;
743 case 13:
744 obj = Eval(left, row, version, recordNos);
745 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)))
746 {
747 return true;
748 }
749 return false;
750 case 39:
751 obj = Eval(left, row, version, recordNos);
752 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)))
753 {
754 return false;
755 }
756 return true;
757 case 26:
758 obj = Eval(left, row, version, recordNos);
759 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)))
760 {
761 return DBNull.Value;
762 }
763 if (!(obj is bool) && !(obj is SqlBoolean))
764 {
765 obj2 = Eval(right, row, version, recordNos);
766 flag3 = true;
767 break;
768 }
769 if (obj is bool)
770 {
771 if (!(bool)obj)
772 {
773 result = false;
774 break;
775 }
776 }
777 else if (((SqlBoolean)obj).IsFalse)
778 {
779 result = false;
780 break;
781 }
782 obj2 = Eval(right, row, version, recordNos);
783 if (obj2 == DBNull.Value || (right.IsSqlColumn && DataStorage.IsObjectSqlNull(obj2)))
784 {
785 return DBNull.Value;
786 }
787 if (obj2 is bool || obj2 is SqlBoolean)
788 {
789 result = ((!(obj2 is bool)) ? ((object)((SqlBoolean)obj2).IsTrue) : ((object)(bool)obj2));
790 }
791 else
792 {
793 flag3 = true;
794 }
795 break;
796 case 27:
797 obj = Eval(left, row, version, recordNos);
798 if (obj != DBNull.Value && !DataStorage.IsObjectSqlNull(obj))
799 {
800 if (!(obj is bool) && !(obj is SqlBoolean))
801 {
802 obj2 = Eval(right, row, version, recordNos);
803 flag3 = true;
804 break;
805 }
806 if ((bool)obj)
807 {
808 result = true;
809 break;
810 }
811 }
812 obj2 = Eval(right, row, version, recordNos);
813 if (obj2 == DBNull.Value || DataStorage.IsObjectSqlNull(obj2))
814 {
815 return obj;
816 }
817 if (obj == DBNull.Value || DataStorage.IsObjectSqlNull(obj))
818 {
819 return obj2;
820 }
821 if (!(obj2 is bool) && !(obj2 is SqlBoolean))
822 {
823 flag3 = true;
824 }
825 else
826 {
827 result = ((obj2 is bool) ? ((bool)obj2) : ((SqlBoolean)obj2).IsTrue);
828 }
829 break;
830 case 20:
831 if (ExpressionNode.IsIntegerSql(storageType3))
832 {
833 if (storageType3 == StorageType.UInt64)
834 {
835 result = Convert.ToUInt64(obj, base.FormatProvider) % Convert.ToUInt64(obj2, base.FormatProvider);
836 }
837 else if (DataStorage.IsSqlType(storageType3))
838 {
839 SqlInt64 sqlInt = SqlConvert.ConvertToSqlInt64(obj) % SqlConvert.ConvertToSqlInt64(obj2);
840 result = storageType3 switch
841 {
842 StorageType.SqlInt32 => sqlInt.ToSqlInt32(),
843 StorageType.SqlInt16 => sqlInt.ToSqlInt16(),
844 StorageType.SqlByte => sqlInt.ToSqlByte(),
845 _ => sqlInt,
846 };
847 }
848 else
849 {
850 result = Convert.ToInt64(obj, base.FormatProvider) % Convert.ToInt64(obj2, base.FormatProvider);
851 result = Convert.ChangeType(result, DataStorage.GetTypeStorage(storageType3), base.FormatProvider);
852 }
853 }
854 else
855 {
856 flag3 = true;
857 }
858 break;
859 case 5:
860 {
861 if (!(right is FunctionNode))
862 {
863 throw ExprException.InWithoutParentheses();
864 }
865 obj = Eval(left, row, version, recordNos);
866 if (obj == DBNull.Value || (left.IsSqlColumn && DataStorage.IsObjectSqlNull(obj)))
867 {
868 return DBNull.Value;
869 }
870 result = false;
871 FunctionNode functionNode = (FunctionNode)right;
872 for (int i = 0; i < functionNode._argumentCount; i++)
873 {
874 obj2 = functionNode._arguments[i].Eval();
875 if (obj2 != DBNull.Value && (!right.IsSqlColumn || !DataStorage.IsObjectSqlNull(obj2)))
876 {
877 storageType3 = DataStorage.GetStorageType(obj.GetType());
878 if (BinaryCompare(obj, obj2, storageType3, 7) == 0)
879 {
880 result = true;
881 break;
882 }
883 }
884 }
885 break;
886 }
887 default:
888 throw ExprException.UnsupportedOperator(op);
889 }
890 }
891 catch (OverflowException)
892 {
893 throw ExprException.Overflow(DataStorage.GetTypeStorage(storageType3));
894 }
895 if (flag3)
896 {
897 SetTypeMismatchError(op, obj.GetType(), obj2.GetType());
898 }
899 return result;
900 }
901
902 private DataTypePrecedence GetPrecedence(StorageType storageType)
903 {
904 return storageType switch
905 {
906 StorageType.Boolean => DataTypePrecedence.Boolean,
907 StorageType.Char => DataTypePrecedence.Char,
908 StorageType.SByte => DataTypePrecedence.SByte,
909 StorageType.Byte => DataTypePrecedence.Byte,
910 StorageType.Int16 => DataTypePrecedence.Int16,
911 StorageType.UInt16 => DataTypePrecedence.UInt16,
912 StorageType.Int32 => DataTypePrecedence.Int32,
913 StorageType.UInt32 => DataTypePrecedence.UInt32,
914 StorageType.Int64 => DataTypePrecedence.Int64,
915 StorageType.UInt64 => DataTypePrecedence.UInt64,
916 StorageType.Single => DataTypePrecedence.Single,
917 StorageType.Double => DataTypePrecedence.Double,
918 StorageType.Decimal => DataTypePrecedence.Decimal,
919 StorageType.DateTime => DataTypePrecedence.DateTime,
920 StorageType.DateTimeOffset => DataTypePrecedence.DateTimeOffset,
921 StorageType.TimeSpan => DataTypePrecedence.TimeSpan,
922 StorageType.String => DataTypePrecedence.String,
923 StorageType.SqlBinary => DataTypePrecedence.SqlBinary,
924 StorageType.SqlBoolean => DataTypePrecedence.SqlBoolean,
925 StorageType.SqlByte => DataTypePrecedence.SqlByte,
926 StorageType.SqlBytes => DataTypePrecedence.SqlBytes,
927 StorageType.SqlChars => DataTypePrecedence.SqlChars,
928 StorageType.SqlDateTime => DataTypePrecedence.SqlDateTime,
929 StorageType.SqlDecimal => DataTypePrecedence.SqlDecimal,
930 StorageType.SqlDouble => DataTypePrecedence.SqlDouble,
931 StorageType.SqlGuid => DataTypePrecedence.SqlGuid,
932 StorageType.SqlInt16 => DataTypePrecedence.SqlInt16,
933 StorageType.SqlInt32 => DataTypePrecedence.SqlInt32,
934 StorageType.SqlInt64 => DataTypePrecedence.SqlInt64,
935 StorageType.SqlMoney => DataTypePrecedence.SqlMoney,
936 StorageType.SqlSingle => DataTypePrecedence.SqlSingle,
937 StorageType.SqlString => DataTypePrecedence.SqlString,
938 _ => DataTypePrecedence.Error,
939 };
940 }
941
942 private static StorageType GetPrecedenceType(DataTypePrecedence code)
943 {
944 return code switch
945 {
946 DataTypePrecedence.SByte => StorageType.SByte,
947 DataTypePrecedence.Byte => StorageType.Byte,
948 DataTypePrecedence.Int16 => StorageType.Int16,
949 DataTypePrecedence.UInt16 => StorageType.UInt16,
950 DataTypePrecedence.Int32 => StorageType.Int32,
951 DataTypePrecedence.UInt32 => StorageType.UInt32,
952 DataTypePrecedence.Int64 => StorageType.Int64,
953 DataTypePrecedence.UInt64 => StorageType.UInt64,
954 DataTypePrecedence.Decimal => StorageType.Decimal,
955 DataTypePrecedence.Single => StorageType.Single,
956 DataTypePrecedence.Double => StorageType.Double,
957 DataTypePrecedence.Boolean => StorageType.Boolean,
958 DataTypePrecedence.String => StorageType.String,
959 DataTypePrecedence.Char => StorageType.Char,
960 DataTypePrecedence.DateTimeOffset => StorageType.DateTimeOffset,
961 DataTypePrecedence.DateTime => StorageType.DateTime,
962 DataTypePrecedence.TimeSpan => StorageType.TimeSpan,
963 DataTypePrecedence.SqlDateTime => StorageType.SqlDateTime,
964 DataTypePrecedence.SqlDouble => StorageType.SqlDouble,
965 DataTypePrecedence.SqlSingle => StorageType.SqlSingle,
966 DataTypePrecedence.SqlDecimal => StorageType.SqlDecimal,
967 DataTypePrecedence.SqlInt64 => StorageType.SqlInt64,
968 DataTypePrecedence.SqlInt32 => StorageType.SqlInt32,
969 DataTypePrecedence.SqlInt16 => StorageType.SqlInt16,
970 DataTypePrecedence.SqlByte => StorageType.SqlByte,
971 DataTypePrecedence.SqlBoolean => StorageType.SqlBoolean,
972 DataTypePrecedence.SqlString => StorageType.SqlString,
973 DataTypePrecedence.SqlGuid => StorageType.SqlGuid,
974 DataTypePrecedence.SqlBinary => StorageType.SqlBinary,
975 DataTypePrecedence.SqlMoney => StorageType.SqlMoney,
976 _ => StorageType.Empty,
977 };
978 }
979
980 private bool IsMixed(StorageType left, StorageType right)
981 {
982 if (!ExpressionNode.IsSigned(left) || !ExpressionNode.IsUnsigned(right))
983 {
984 if (ExpressionNode.IsUnsigned(left))
985 {
986 return ExpressionNode.IsSigned(right);
987 }
988 return false;
989 }
990 return true;
991 }
992
993 private bool IsMixedSql(StorageType left, StorageType right)
994 {
995 if (!ExpressionNode.IsSignedSql(left) || !ExpressionNode.IsUnsignedSql(right))
996 {
997 if (ExpressionNode.IsUnsignedSql(left))
998 {
999 return ExpressionNode.IsSignedSql(right);
1000 }
1001 return false;
1002 }
1003 return true;
1004 }
1005
1006 internal StorageType ResultType(StorageType left, StorageType right, bool lc, bool rc, int op)
1007 {
1008 if (left == StorageType.Guid && right == StorageType.Guid && Operators.IsRelational(op))
1009 {
1010 return left;
1011 }
1012 if (left == StorageType.String && right == StorageType.Guid && Operators.IsRelational(op))
1013 {
1014 return left;
1015 }
1016 if (left == StorageType.Guid && right == StorageType.String && Operators.IsRelational(op))
1017 {
1018 return right;
1019 }
1020 int precedence = (int)GetPrecedence(left);
1021 if (precedence == 0)
1022 {
1023 return StorageType.Empty;
1024 }
1025 int precedence2 = (int)GetPrecedence(right);
1026 if (precedence2 == 0)
1027 {
1028 return StorageType.Empty;
1029 }
1030 if (Operators.IsLogical(op))
1031 {
1032 if (left == StorageType.Boolean && right == StorageType.Boolean)
1033 {
1034 return StorageType.Boolean;
1035 }
1036 return StorageType.Empty;
1037 }
1038 if (left == StorageType.DateTimeOffset || right == StorageType.DateTimeOffset)
1039 {
1040 if (Operators.IsRelational(op) && left == StorageType.DateTimeOffset && right == StorageType.DateTimeOffset)
1041 {
1042 return StorageType.DateTimeOffset;
1043 }
1044 return StorageType.Empty;
1045 }
1046 if (op == 15 && (left == StorageType.String || right == StorageType.String))
1047 {
1048 return StorageType.String;
1049 }
1050 DataTypePrecedence dataTypePrecedence = (DataTypePrecedence)Math.Max(precedence, precedence2);
1051 StorageType precedenceType = GetPrecedenceType(dataTypePrecedence);
1052 if (Operators.IsArithmetical(op) && precedenceType != StorageType.String && precedenceType != StorageType.Char)
1053 {
1054 if (!ExpressionNode.IsNumeric(left))
1055 {
1056 return StorageType.Empty;
1057 }
1058 if (!ExpressionNode.IsNumeric(right))
1059 {
1060 return StorageType.Empty;
1061 }
1062 }
1063 if (op == 18 && ExpressionNode.IsInteger(precedenceType))
1064 {
1065 return StorageType.Double;
1066 }
1067 if (IsMixed(left, right))
1068 {
1069 if (lc && !rc)
1070 {
1071 return right;
1072 }
1073 if (!lc && rc)
1074 {
1075 return left;
1076 }
1077 if (ExpressionNode.IsUnsigned(precedenceType))
1078 {
1079 if (dataTypePrecedence >= DataTypePrecedence.UInt64)
1080 {
1081 throw ExprException.AmbiguousBinop(op, DataStorage.GetTypeStorage(left), DataStorage.GetTypeStorage(right));
1082 }
1083 precedenceType = GetPrecedenceType(dataTypePrecedence + 1);
1084 }
1085 }
1086 return precedenceType;
1087 }
1088
1089 internal StorageType ResultSqlType(StorageType left, StorageType right, bool lc, bool rc, int op)
1090 {
1091 int precedence = (int)GetPrecedence(left);
1092 if (precedence == 0)
1093 {
1094 return StorageType.Empty;
1095 }
1096 int precedence2 = (int)GetPrecedence(right);
1097 if (precedence2 == 0)
1098 {
1099 return StorageType.Empty;
1100 }
1101 if (Operators.IsLogical(op))
1102 {
1103 if ((left != StorageType.Boolean && left != StorageType.SqlBoolean) || (right != StorageType.Boolean && right != StorageType.SqlBoolean))
1104 {
1105 return StorageType.Empty;
1106 }
1107 if (left == StorageType.Boolean && right == StorageType.Boolean)
1108 {
1109 return StorageType.Boolean;
1110 }
1111 return StorageType.SqlBoolean;
1112 }
1113 if (op == 15)
1114 {
1115 if (left == StorageType.SqlString || right == StorageType.SqlString)
1116 {
1117 return StorageType.SqlString;
1118 }
1119 if (left == StorageType.String || right == StorageType.String)
1120 {
1121 return StorageType.String;
1122 }
1123 }
1124 if ((left == StorageType.SqlBinary && right != StorageType.SqlBinary) || (left != StorageType.SqlBinary && right == StorageType.SqlBinary))
1125 {
1126 return StorageType.Empty;
1127 }
1128 if ((left == StorageType.SqlGuid && right != StorageType.SqlGuid) || (left != StorageType.SqlGuid && right == StorageType.SqlGuid))
1129 {
1130 return StorageType.Empty;
1131 }
1132 if (precedence > 19 && precedence2 < 20)
1133 {
1134 return StorageType.Empty;
1135 }
1136 if (precedence < 20 && precedence2 > 19)
1137 {
1138 return StorageType.Empty;
1139 }
1140 if (precedence > 19)
1141 {
1142 if (op == 15 || op == 16)
1143 {
1144 if (left == StorageType.TimeSpan)
1145 {
1146 return right;
1147 }
1148 if (right == StorageType.TimeSpan)
1149 {
1150 return left;
1151 }
1152 return StorageType.Empty;
1153 }
1154 if (!Operators.IsRelational(op))
1155 {
1156 return StorageType.Empty;
1157 }
1158 return left;
1159 }
1160 DataTypePrecedence dataTypePrecedence = (DataTypePrecedence)Math.Max(precedence, precedence2);
1161 StorageType precedenceType = GetPrecedenceType(dataTypePrecedence);
1162 precedenceType = GetPrecedenceType((DataTypePrecedence)SqlResultType((int)dataTypePrecedence));
1163 if (Operators.IsArithmetical(op) && precedenceType != StorageType.String && precedenceType != StorageType.Char && precedenceType != StorageType.SqlString)
1164 {
1165 if (!ExpressionNode.IsNumericSql(left))
1166 {
1167 return StorageType.Empty;
1168 }
1169 if (!ExpressionNode.IsNumericSql(right))
1170 {
1171 return StorageType.Empty;
1172 }
1173 }
1174 if (op == 18 && ExpressionNode.IsIntegerSql(precedenceType))
1175 {
1176 return StorageType.SqlDouble;
1177 }
1178 if (precedenceType == StorageType.SqlMoney && left != StorageType.SqlMoney && right != StorageType.SqlMoney)
1179 {
1180 precedenceType = StorageType.SqlDecimal;
1181 }
1182 if (IsMixedSql(left, right) && ExpressionNode.IsUnsignedSql(precedenceType))
1183 {
1184 if (dataTypePrecedence >= DataTypePrecedence.UInt64)
1185 {
1186 throw ExprException.AmbiguousBinop(op, DataStorage.GetTypeStorage(left), DataStorage.GetTypeStorage(right));
1187 }
1188 precedenceType = GetPrecedenceType(dataTypePrecedence + 1);
1189 }
1190 return precedenceType;
1191 }
1192
1193 private int SqlResultType(int typeCode)
1194 {
1195 switch (typeCode)
1196 {
1197 case 23:
1198 return 24;
1199 case 20:
1200 return 21;
1201 case 18:
1202 return 19;
1203 case 16:
1204 return 17;
1205 case 14:
1206 return 15;
1207 case 12:
1208 return 13;
1209 case 9:
1210 case 10:
1211 return 11;
1212 case 6:
1213 case 7:
1214 return 8;
1215 case 3:
1216 case 4:
1217 return 5;
1218 case 1:
1219 return 2;
1220 case -2:
1221 return -1;
1222 case -5:
1223 return -4;
1224 case -8:
1225 return -7;
1226 default:
1227 return typeCode;
1228 }
1229 }
1230}
System.Convert.ToString
static ? string ToString(object? value)
Definition Convert.cs:2321
System.Convert.ToDecimal
static decimal ToDecimal(object? value)
Definition Convert.cs:2101
System.Convert.ToInt64
static long ToInt64(object? value)
Definition Convert.cs:1623
System.Convert.ToSingle
static float ToSingle(object? value)
Definition Convert.cs:1881
System.Convert.ToInt32
static int ToInt32(object? value)
Definition Convert.cs:1320
System.Convert.ToDateTime
static DateTime ToDateTime(DateTime value)
Definition Convert.cs:2211
System.Convert.ToInt16
static short ToInt16(object? value)
Definition Convert.cs:1038
System.Convert.ToByte
static byte ToByte(object? value)
Definition Convert.cs:900
System.Convert.ToUInt32
static uint ToUInt32(object? value)
Definition Convert.cs:1470
System.Convert.ToUInt64
static ulong ToUInt64(object? value)
Definition Convert.cs:1738
System.Convert.ToUInt16
static ushort ToUInt16(object? value)
Definition Convert.cs:1177
System.Convert.ChangeType
static ? object ChangeType(object? value, TypeCode typeCode)
Definition Convert.cs:229
System.Convert.ToSByte
static sbyte ToSByte(object? value)
Definition Convert.cs:745
System.Convert.ToDouble
static double ToDouble(object? value)
Definition Convert.cs:1991
System.DBNull.Value
static readonly DBNull Value
Definition DBNull.cs:8
System.Data.BinaryNode.HasLocalAggregate
override bool HasLocalAggregate()
Definition BinaryNode.cs:106
System.Data.BinaryNode.IsConstant
override bool IsConstant()
Definition BinaryNode.cs:88
System.Data.BinaryNode.Eval
override object Eval(int[] recordNos)
Definition BinaryNode.cs:83
System.Data.BinaryNode.GetPrecedence
DataTypePrecedence GetPrecedence(StorageType storageType)
Definition BinaryNode.cs:902
System.Data.BinaryNode.ResultSqlType
StorageType ResultSqlType(StorageType left, StorageType right, bool lc, bool rc, int op)
Definition BinaryNode.cs:1089
System.Data.BinaryNode.BinaryCompare
int BinaryCompare(object vLeft, object vRight, StorageType resultType, int op, CompareInfo comparer)
Definition BinaryNode.cs:207
System.Data.BinaryNode.EvalBinaryOp
object EvalBinaryOp(int op, ExpressionNode left, ExpressionNode right, DataRow row, DataRowVersion version, int[] recordNos)
Definition BinaryNode.cs:342
System.Data.BinaryNode.IsMixed
bool IsMixed(StorageType left, StorageType right)
Definition BinaryNode.cs:980
System.Data.BinaryNode.HasRemoteAggregate
override bool HasRemoteAggregate()
Definition BinaryNode.cs:115
System.Data.BinaryNode.Eval
override object Eval(DataRow row, DataRowVersion version)
Definition BinaryNode.cs:77
System.Data.BinaryNode.Eval
static object Eval(ExpressionNode expr, DataRow row, DataRowVersion version, int[] recordNos)
Definition BinaryNode.cs:193
System.Data.BinaryNode.Optimize
override ExpressionNode Optimize()
Definition BinaryNode.cs:133
System.Data.BinaryNode.ResultType
StorageType ResultType(StorageType left, StorageType right, bool lc, bool rc, int op)
Definition BinaryNode.cs:1006
System.Data.BinaryNode._left
ExpressionNode _left
Definition BinaryNode.cs:51
System.Data.BinaryNode.IsMixedSql
bool IsMixedSql(StorageType left, StorageType right)
Definition BinaryNode.cs:993
System.Data.BinaryNode.BinaryNode
BinaryNode(DataTable table, int op, ExpressionNode left, ExpressionNode right)
Definition BinaryNode.cs:55
System.Data.BinaryNode.Bind
override void Bind(DataTable table, List< DataColumn > list)
Definition BinaryNode.cs:63
System.Data.BinaryNode.BinaryCompare
int BinaryCompare(object vLeft, object vRight, StorageType resultType, int op)
Definition BinaryNode.cs:202
System.Data.BinaryNode.SqlResultType
int SqlResultType(int typeCode)
Definition BinaryNode.cs:1193
System.Data.BinaryNode.GetPrecedenceType
static StorageType GetPrecedenceType(DataTypePrecedence code)
Definition BinaryNode.cs:942
System.Data.BinaryNode.Eval
override object Eval()
Definition BinaryNode.cs:71
System.Data.BinaryNode.SetTypeMismatchError
void SetTypeMismatchError(int op, Type left, Type right)
Definition BinaryNode.cs:181
System.Data.BinaryNode.IsTableConstant
override bool IsTableConstant()
Definition BinaryNode.cs:97
System.Data.BinaryNode._right
ExpressionNode _right
Definition BinaryNode.cs:53
System.Data.BinaryNode.DependsOn
override bool DependsOn(DataColumn column)
Definition BinaryNode.cs:124
System.Data.Common.DataStorage.GetTypeStorage
static Type GetTypeStorage(StorageType storageType)
Definition DataStorage.cs:302
System.Data.Common.DataStorage.IsObjectSqlNull
static bool IsObjectSqlNull(object value)
Definition DataStorage.cs:439
System.Data.Common.DataStorage.IsSqlType
static bool IsSqlType(StorageType storageType)
Definition DataStorage.cs:321
System.Data.Common.DataStorage.GetStorageType
static StorageType GetStorageType(Type dataType)
Definition DataStorage.cs:285
System.Data.Common.SqlConvert.ConvertToSqlBoolean
static SqlBoolean ConvertToSqlBoolean(object value)
Definition SqlConvert.cs:211
System.Data.Common.SqlConvert.ConvertToSqlBinary
static SqlBinary ConvertToSqlBinary(object value)
Definition SqlConvert.cs:241
System.Data.Common.SqlConvert.ConvertToSqlDouble
static SqlDouble ConvertToSqlDouble(object value)
Definition SqlConvert.cs:85
System.Data.Common.SqlConvert.ConvertToSqlDecimal
static SqlDecimal ConvertToSqlDecimal(object value)
Definition SqlConvert.cs:115
System.Data.Common.SqlConvert.ConvertToSqlString
static SqlString ConvertToSqlString(object value)
Definition SqlConvert.cs:256
System.Data.Common.SqlConvert.ConvertToSqlMoney
static SqlMoney ConvertToSqlMoney(object value)
Definition SqlConvert.cs:170
System.Data.Common.SqlConvert.ConvertToSqlInt32
static SqlInt32 ConvertToSqlInt32(object value)
Definition SqlConvert.cs:42
System.Data.Common.SqlConvert.ConvertToSqlByte
static SqlByte ConvertToSqlByte(object value)
Definition SqlConvert.cs:10
System.Data.Common.SqlConvert.ConvertToSqlInt16
static SqlInt16 ConvertToSqlInt16(object value)
Definition SqlConvert.cs:25
System.Data.Common.SqlConvert.ConvertToSqlDateTime
static SqlDateTime ConvertToSqlDateTime(object value)
Definition SqlConvert.cs:196
System.Data.Common.SqlConvert.ConvertToSqlInt64
static SqlInt64 ConvertToSqlInt64(object value)
Definition SqlConvert.cs:62
System.Data.Common.SqlConvert.ConvertToSqlSingle
static SqlSingle ConvertToSqlSingle(object value)
Definition SqlConvert.cs:142
System.Data.DataExpression.ToBoolean
static bool ToBoolean(object value)
Definition DataExpression.cs:225
System.Data.ExceptionBuilder.TraceExceptionWithoutRethrow
static Exception TraceExceptionWithoutRethrow(Exception e)
Definition ExceptionBuilder.cs:29
System.Data.ExprException.Overflow
static Exception Overflow(Type type)
Definition ExprException.cs:163
System.Data.ExprException.UnsupportedOperator
static Exception UnsupportedOperator(int op)
Definition ExprException.cs:188
System.Data.ExprException.InWithoutParentheses
static Exception InWithoutParentheses()
Definition ExprException.cs:148
System.Data.ExprException.TypeMismatchInBinop
static Exception TypeMismatchInBinop(int op, Type type1, Type type2)
Definition ExprException.cs:178
System.Data.ExprException.AmbiguousBinop
static Exception AmbiguousBinop(int op, Type type1, Type type2)
Definition ExprException.cs:183
System.Data.ExprException.InvalidIsSyntax
static Exception InvalidIsSyntax()
Definition ExprException.cs:158
System.Data.ExpressionNode.IsInteger
static bool IsInteger(StorageType type)
Definition ExpressionNode.cs:64
System.Data.ExpressionNode.IsNumericSql
static bool IsNumericSql(StorageType type)
Definition ExpressionNode.cs:127
System.Data.ExpressionNode.IsSignedSql
static bool IsSignedSql(StorageType type)
Definition ExpressionNode.cs:91
System.Data.ExpressionNode.IsUnsignedSql
static bool IsUnsignedSql(StorageType type)
Definition ExpressionNode.cs:109
System.Data.ExpressionNode.IsSigned
static bool IsSigned(StorageType type)
Definition ExpressionNode.cs:82
System.Data.ExpressionNode.Bind
void Bind(DataTable table, List< DataColumn > list)
System.Data.ExpressionNode.IsUnsigned
static bool IsUnsigned(StorageType type)
Definition ExpressionNode.cs:100
System.Data.ExpressionNode.BindTable
void BindTable(DataTable table)
Definition ExpressionNode.cs:33
System.Data.ExpressionNode.IsIntegerSql
static bool IsIntegerSql(StorageType type)
Definition ExpressionNode.cs:73
System.Data.ExpressionNode.DependsOn
virtual bool DependsOn(DataColumn column)
Definition ExpressionNode.cs:59
System.Data.ExpressionNode.IsNumeric
static bool IsNumeric(StorageType type)
Definition ExpressionNode.cs:118
System.Data.ExpressionNode.Optimize
ExpressionNode Optimize()
System.Data.Operators.IsArithmetical
static bool IsArithmetical(int op)
Definition Operators.cs:22
System.Data.Operators.IsRelational
static bool IsRelational(int op)
Definition Operators.cs:40
System.Data.Operators.IsLogical
static bool IsLogical(int op)
Definition Operators.cs:31
System.Math.Max
static byte Max(byte val1, byte val2)
Definition Math.cs:738
System.Type.GetType
static ? Type GetType(string typeName, bool throwOnError, bool ignoreCase)
Definition Type.cs:408
System.DateTimeOffset.Compare
static int Compare(DateTimeOffset first, DateTimeOffset second)
Definition DateTimeOffset.cs:211
System.DateTime.Compare
static int Compare(DateTime t1, DateTime t2)
Definition DateTime.cs:546