mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
121 lines
4.7 KiB
C#
121 lines
4.7 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Data.Linq;
|
|
using System.Data.Linq.Provider;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
namespace System.Data.Linq.SqlClient {
|
|
|
|
internal static class SqlExpressionNullability {
|
|
|
|
/// <summary>
|
|
/// Determines whether the given expression may return a null result.
|
|
/// </summary>
|
|
/// <param name="expr">The expression to check.</param>
|
|
/// <returns>null means that it couldn't be determined</returns>
|
|
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification="These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
|
|
internal static bool? CanBeNull(SqlExpression expr) {
|
|
switch (expr.NodeType) {
|
|
case SqlNodeType.ExprSet:
|
|
SqlExprSet exprSet = (SqlExprSet)expr;
|
|
return CanBeNull(exprSet.Expressions);
|
|
|
|
case SqlNodeType.SimpleCase:
|
|
SqlSimpleCase sc = (SqlSimpleCase)expr;
|
|
return CanBeNull(sc.Whens.Select(w => w.Value));
|
|
|
|
case SqlNodeType.Column:
|
|
SqlColumn col = (SqlColumn)expr;
|
|
if (col.MetaMember != null) {
|
|
return col.MetaMember.CanBeNull;
|
|
}
|
|
else if (col.Expression != null) {
|
|
return CanBeNull(col.Expression);
|
|
}
|
|
return null; // Don't know.
|
|
|
|
case SqlNodeType.ColumnRef:
|
|
SqlColumnRef cref = (SqlColumnRef)expr;
|
|
return CanBeNull(cref.Column);
|
|
|
|
case SqlNodeType.Value:
|
|
return ((SqlValue)expr).Value == null;
|
|
|
|
case SqlNodeType.New:
|
|
case SqlNodeType.Multiset:
|
|
case SqlNodeType.Grouping:
|
|
case SqlNodeType.DiscriminatedType:
|
|
case SqlNodeType.IsNotNull: // IsNull\IsNotNull always return true or false and can never return NULL.
|
|
case SqlNodeType.IsNull:
|
|
case SqlNodeType.Exists:
|
|
return false;
|
|
|
|
case SqlNodeType.Add:
|
|
case SqlNodeType.Sub:
|
|
case SqlNodeType.Mul:
|
|
case SqlNodeType.Div:
|
|
case SqlNodeType.Mod:
|
|
case SqlNodeType.BitAnd:
|
|
case SqlNodeType.BitOr:
|
|
case SqlNodeType.BitXor:
|
|
case SqlNodeType.Concat: {
|
|
SqlBinary bop = (SqlBinary)expr;
|
|
bool? left = CanBeNull(bop.Left);
|
|
bool? right = CanBeNull(bop.Right);
|
|
return (left != false) || (right != false);
|
|
}
|
|
|
|
case SqlNodeType.Negate:
|
|
case SqlNodeType.BitNot: {
|
|
SqlUnary uop = (SqlUnary)expr;
|
|
return CanBeNull(uop.Operand);
|
|
}
|
|
|
|
case SqlNodeType.Lift: {
|
|
SqlLift lift = (SqlLift)expr;
|
|
return CanBeNull(lift.Expression);
|
|
}
|
|
|
|
case SqlNodeType.OuterJoinedValue:
|
|
return true;
|
|
|
|
default:
|
|
return null; // Don't know.
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used to determine nullability for a collection of expressions.
|
|
/// * If at least one of the expressions is nullable, the collection is nullable.
|
|
/// * If no expressions are nullable, but at least one is 'don't know', the collection is 'don't know'.
|
|
/// * Otherwise all expressions are non-nullable and the nullability is false.
|
|
/// </summary>
|
|
private static bool? CanBeNull(IEnumerable<SqlExpression> exprs) {
|
|
bool hasAtleastOneUnknown = false;
|
|
foreach(SqlExpression e in exprs) {
|
|
bool? nullability = CanBeNull(e);
|
|
|
|
// Even one expression that could return null means the
|
|
// collection can return null.
|
|
if (nullability == true)
|
|
return true;
|
|
|
|
// If there is one or more 'unknown' and no definitely nullable
|
|
// results then the collection nullability is 'unknown'.
|
|
if (nullability == null)
|
|
hasAtleastOneUnknown = true;
|
|
}
|
|
if (hasAtleastOneUnknown)
|
|
return null;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|