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
2282 lines
75 KiB
C#
2282 lines
75 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Linq.Expressions;
|
|
using System.Diagnostics;
|
|
using System.Data;
|
|
|
|
namespace System.Data.Linq.SqlClient {
|
|
using System.Data.Linq.Mapping;
|
|
using System.Data.Linq.Provider;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
internal enum SqlNodeType {
|
|
Add,
|
|
Alias,
|
|
AliasRef,
|
|
And,
|
|
Assign,
|
|
Avg,
|
|
Between,
|
|
BitAnd,
|
|
BitNot,
|
|
BitOr,
|
|
BitXor,
|
|
Block,
|
|
ClientArray,
|
|
ClientCase,
|
|
ClientParameter,
|
|
ClientQuery,
|
|
ClrLength,
|
|
Coalesce,
|
|
Column,
|
|
ColumnRef,
|
|
Concat,
|
|
Convert,
|
|
Count,
|
|
Delete,
|
|
DiscriminatedType,
|
|
DiscriminatorOf,
|
|
Div,
|
|
DoNotVisit,
|
|
Element,
|
|
ExprSet,
|
|
EQ,
|
|
EQ2V,
|
|
Exists,
|
|
FunctionCall,
|
|
In,
|
|
IncludeScope,
|
|
IsNotNull,
|
|
IsNull,
|
|
LE,
|
|
Lift,
|
|
Link,
|
|
Like,
|
|
LongCount,
|
|
LT,
|
|
GE,
|
|
Grouping,
|
|
GT,
|
|
Insert,
|
|
Join,
|
|
JoinedCollection,
|
|
Max,
|
|
MethodCall,
|
|
Member,
|
|
MemberAssign,
|
|
Min,
|
|
Mod,
|
|
Mul,
|
|
Multiset,
|
|
NE,
|
|
NE2V,
|
|
Negate,
|
|
New,
|
|
Not,
|
|
Not2V,
|
|
Nop,
|
|
Or,
|
|
OptionalValue,
|
|
OuterJoinedValue,
|
|
Parameter,
|
|
Property,
|
|
Row,
|
|
RowNumber,
|
|
ScalarSubSelect,
|
|
SearchedCase,
|
|
Select,
|
|
SharedExpression,
|
|
SharedExpressionRef,
|
|
SimpleCase,
|
|
SimpleExpression,
|
|
Stddev,
|
|
StoredProcedureCall,
|
|
Sub,
|
|
Sum,
|
|
Table,
|
|
TableValuedFunctionCall,
|
|
Treat,
|
|
TypeCase,
|
|
Union,
|
|
Update,
|
|
UserColumn,
|
|
UserQuery,
|
|
UserRow,
|
|
Variable,
|
|
Value,
|
|
ValueOf
|
|
}
|
|
|
|
[System.Diagnostics.DebuggerDisplay("text = {Text}, \r\nsource = {SourceExpression}")]
|
|
internal abstract class SqlNode {
|
|
private SqlNodeType nodeType;
|
|
private Expression sourceExpression;
|
|
|
|
internal SqlNode(SqlNodeType nodeType, Expression sourceExpression) {
|
|
this.nodeType = nodeType;
|
|
this.sourceExpression = sourceExpression;
|
|
}
|
|
|
|
internal Expression SourceExpression {
|
|
get { return this.sourceExpression; }
|
|
}
|
|
|
|
internal void ClearSourceExpression() {
|
|
this.sourceExpression = null;
|
|
}
|
|
|
|
internal SqlNodeType NodeType {
|
|
get { return this.nodeType; }
|
|
}
|
|
|
|
#if DEBUG
|
|
private static DbFormatter formatter;
|
|
internal static DbFormatter Formatter {
|
|
get { return formatter; }
|
|
set { formatter = value; }
|
|
}
|
|
|
|
internal string Text {
|
|
get {
|
|
if (Formatter == null)
|
|
return "SqlNode.Formatter is not assigned";
|
|
return SqlNode.Formatter.Format(this, true);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
internal abstract class SqlExpression : SqlNode {
|
|
private Type clrType;
|
|
internal SqlExpression(SqlNodeType nodeType, Type clrType, Expression sourceExpression)
|
|
: base(nodeType, sourceExpression) {
|
|
this.clrType = clrType;
|
|
}
|
|
|
|
internal Type ClrType {
|
|
get { return this.clrType; }
|
|
}
|
|
|
|
// note: changing the CLR type of a node is potentially dangerous
|
|
internal void SetClrType(Type type) {
|
|
this.clrType = type;
|
|
}
|
|
|
|
internal abstract ProviderType SqlType { get; }
|
|
|
|
/// <summary>
|
|
/// Drill down looking for a constant root expression, returning true if found.
|
|
/// </summary>
|
|
internal bool IsConstantColumn {
|
|
get {
|
|
if (this.NodeType == SqlNodeType.Column) {
|
|
SqlColumn col = (SqlColumn)this;
|
|
if (col.Expression != null) {
|
|
return col.Expression.IsConstantColumn;
|
|
}
|
|
}
|
|
else if (this.NodeType == SqlNodeType.ColumnRef) {
|
|
return ((SqlColumnRef)this).Column.IsConstantColumn;
|
|
}
|
|
else if (this.NodeType == SqlNodeType.OptionalValue) {
|
|
return ((SqlOptionalValue)this).Value.IsConstantColumn;
|
|
}
|
|
else if (this.NodeType == SqlNodeType.Value ||
|
|
this.NodeType == SqlNodeType.Parameter) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A SqlExpression with a simple implementation of ClrType and SqlType.
|
|
/// </summary>
|
|
internal abstract class SqlSimpleTypeExpression : SqlExpression {
|
|
private ProviderType sqlType;
|
|
|
|
internal SqlSimpleTypeExpression(SqlNodeType nodeType, Type clrType, ProviderType sqlType, Expression sourceExpression)
|
|
: base(nodeType, clrType, sourceExpression) {
|
|
this.sqlType = sqlType;
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.sqlType; }
|
|
}
|
|
|
|
internal void SetSqlType(ProviderType type) {
|
|
this.sqlType = type;
|
|
}
|
|
}
|
|
|
|
internal class SqlDiscriminatorOf : SqlSimpleTypeExpression {
|
|
SqlExpression obj;
|
|
internal SqlDiscriminatorOf(SqlExpression obj, Type clrType, ProviderType sqlType, Expression sourceExpression)
|
|
: base(SqlNodeType.DiscriminatorOf, clrType, sqlType, sourceExpression) {
|
|
this.obj = obj;
|
|
}
|
|
internal SqlExpression Object {
|
|
get { return this.obj; }
|
|
set { this.obj = value; }
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents a dynamic CLR type that is chosen based on a discriminator expression.
|
|
/// </summary>
|
|
internal class SqlDiscriminatedType : SqlExpression {
|
|
private ProviderType sqlType;
|
|
private SqlExpression discriminator;
|
|
private MetaType targetType;
|
|
internal SqlDiscriminatedType(ProviderType sqlType, SqlExpression discriminator, MetaType targetType, Expression sourceExpression)
|
|
: base(SqlNodeType.DiscriminatedType,
|
|
typeof(Type),
|
|
sourceExpression) {
|
|
if (discriminator == null)
|
|
throw Error.ArgumentNull("discriminator");
|
|
this.discriminator = discriminator;
|
|
this.targetType = targetType;
|
|
this.sqlType = sqlType;
|
|
}
|
|
internal override ProviderType SqlType {
|
|
get { return this.sqlType; }
|
|
}
|
|
internal SqlExpression Discriminator {
|
|
get { return this.discriminator; }
|
|
set { this.discriminator = value; }
|
|
}
|
|
|
|
internal MetaType TargetType {
|
|
get { return this.targetType; }
|
|
}
|
|
}
|
|
|
|
internal abstract class SqlStatement : SqlNode {
|
|
internal SqlStatement(SqlNodeType nodeType, Expression sourceExpression)
|
|
: base(nodeType, sourceExpression) {
|
|
}
|
|
}
|
|
|
|
internal abstract class SqlSource : SqlNode {
|
|
internal SqlSource(SqlNodeType nt, Expression sourceExpression)
|
|
: base(nt, sourceExpression) {
|
|
}
|
|
}
|
|
|
|
internal class SqlSelect : SqlStatement {
|
|
private SqlExpression top;
|
|
private bool isPercent;
|
|
private bool isDistinct;
|
|
private SqlExpression selection;
|
|
private SqlRow row;
|
|
private SqlSource from;
|
|
private SqlExpression where;
|
|
private List<SqlExpression> groupBy;
|
|
private SqlExpression having;
|
|
private List<SqlOrderExpression> orderBy;
|
|
private SqlOrderingType orderingType;
|
|
private bool squelch;
|
|
|
|
internal SqlSelect(SqlExpression selection, SqlSource from, Expression sourceExpression)
|
|
: base(SqlNodeType.Select, sourceExpression) {
|
|
this.Row = new SqlRow(sourceExpression);
|
|
this.Selection = selection;
|
|
this.From = from;
|
|
this.groupBy = new List<SqlExpression>();
|
|
this.orderBy = new List<SqlOrderExpression>();
|
|
this.orderingType = SqlOrderingType.Default;
|
|
}
|
|
|
|
internal SqlExpression Top {
|
|
get { return this.top; }
|
|
set { this.top = value; }
|
|
}
|
|
|
|
internal bool IsPercent {
|
|
get { return this.isPercent; }
|
|
set { this.isPercent = value; }
|
|
}
|
|
|
|
internal bool IsDistinct {
|
|
get { return this.isDistinct; }
|
|
set { this.isDistinct = value; }
|
|
}
|
|
|
|
internal SqlExpression Selection {
|
|
get { return this.selection; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.selection = value;
|
|
}
|
|
}
|
|
|
|
internal SqlRow Row {
|
|
get { return this.row; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.row = value;
|
|
}
|
|
}
|
|
|
|
internal SqlSource From {
|
|
get { return this.from; }
|
|
set { this.from = value; }
|
|
}
|
|
|
|
internal SqlExpression Where {
|
|
get { return this.where; }
|
|
set {
|
|
if (value != null && TypeSystem.GetNonNullableType(value.ClrType) != typeof(bool)) {
|
|
throw Error.ArgumentWrongType("value", "bool", value.ClrType);
|
|
}
|
|
this.where = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlExpression> GroupBy {
|
|
get { return this.groupBy; }
|
|
}
|
|
|
|
internal SqlExpression Having {
|
|
get { return this.having; }
|
|
set {
|
|
if (value != null && TypeSystem.GetNonNullableType(value.ClrType) != typeof(bool)) {
|
|
throw Error.ArgumentWrongType("value", "bool", value.ClrType);
|
|
}
|
|
this.having = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlOrderExpression> OrderBy {
|
|
get { return this.orderBy; }
|
|
}
|
|
|
|
internal SqlOrderingType OrderingType {
|
|
get { return this.orderingType; }
|
|
set { this.orderingType = value; }
|
|
}
|
|
|
|
internal bool DoNotOutput {
|
|
get { return this.squelch; }
|
|
set { this.squelch = value; }
|
|
}
|
|
}
|
|
|
|
internal enum SqlOrderingType {
|
|
Default,
|
|
Never,
|
|
Blocked,
|
|
Always
|
|
}
|
|
|
|
internal class SqlTable : SqlNode {
|
|
private MetaTable table;
|
|
private MetaType rowType;
|
|
private ProviderType sqlRowType;
|
|
private List<SqlColumn> columns;
|
|
|
|
internal SqlTable(MetaTable table, MetaType rowType, ProviderType sqlRowType, Expression sourceExpression)
|
|
: base(SqlNodeType.Table, sourceExpression) {
|
|
this.table = table;
|
|
this.rowType = rowType;
|
|
this.sqlRowType = sqlRowType;
|
|
this.columns = new List<SqlColumn>();
|
|
}
|
|
|
|
internal MetaTable MetaTable {
|
|
get { return this.table; }
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.table.TableName; }
|
|
}
|
|
|
|
internal List<SqlColumn> Columns {
|
|
get { return this.columns; }
|
|
}
|
|
|
|
internal MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
|
|
internal ProviderType SqlRowType {
|
|
get { return this.sqlRowType; }
|
|
}
|
|
|
|
internal SqlColumn Find(string columnName) {
|
|
foreach (SqlColumn c in this.Columns) {
|
|
if (c.Name == columnName)
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
internal class SqlUserQuery : SqlNode {
|
|
private string queryText;
|
|
private SqlExpression projection;
|
|
private List<SqlExpression> args;
|
|
private List<SqlUserColumn> columns;
|
|
|
|
internal SqlUserQuery(SqlNodeType nt, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
|
|
: base(nt, source) {
|
|
this.Projection = projection;
|
|
this.args = (args != null) ? new List<SqlExpression>(args) : new List<SqlExpression>();
|
|
this.columns = new List<SqlUserColumn>();
|
|
}
|
|
|
|
internal SqlUserQuery(string queryText, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
|
|
: base(SqlNodeType.UserQuery, source) {
|
|
this.queryText = queryText;
|
|
this.Projection = projection;
|
|
this.args = (args != null) ? new List<SqlExpression>(args) : new List<SqlExpression>();
|
|
this.columns = new List<SqlUserColumn>();
|
|
}
|
|
|
|
internal string QueryText {
|
|
get { return this.queryText; }
|
|
}
|
|
|
|
internal SqlExpression Projection {
|
|
get { return this.projection; }
|
|
set {
|
|
if (this.projection != null && this.projection.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.projection.ClrType, value.ClrType);
|
|
this.projection = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlExpression> Arguments {
|
|
get { return this.args; }
|
|
}
|
|
|
|
internal List<SqlUserColumn> Columns {
|
|
get { return this.columns; }
|
|
}
|
|
|
|
internal SqlUserColumn Find(string name) {
|
|
foreach (SqlUserColumn c in this.Columns) {
|
|
if (c.Name == name)
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal class SqlStoredProcedureCall : SqlUserQuery {
|
|
private MetaFunction function;
|
|
|
|
internal SqlStoredProcedureCall(MetaFunction function, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
|
|
: base(SqlNodeType.StoredProcedureCall, projection, args, source) {
|
|
if (function == null)
|
|
throw Error.ArgumentNull("function");
|
|
this.function = function;
|
|
}
|
|
|
|
internal MetaFunction Function {
|
|
get { return this.function; }
|
|
}
|
|
}
|
|
|
|
internal class SqlUserRow : SqlSimpleTypeExpression {
|
|
private SqlUserQuery query;
|
|
private MetaType rowType;
|
|
|
|
internal SqlUserRow(MetaType rowType, ProviderType sqlType, SqlUserQuery query, Expression source)
|
|
: base(SqlNodeType.UserRow, rowType.Type, sqlType, source) {
|
|
this.Query = query;
|
|
this.rowType = rowType;
|
|
}
|
|
|
|
internal MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
|
|
internal SqlUserQuery Query {
|
|
get { return this.query; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.Projection != null && value.Projection.ClrType != this.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.ClrType, value.Projection.ClrType);
|
|
this.query = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlUserColumn : SqlSimpleTypeExpression {
|
|
private SqlUserQuery query;
|
|
private string name;
|
|
private bool isRequired;
|
|
|
|
internal SqlUserColumn(Type clrType, ProviderType sqlType, SqlUserQuery query, string name, bool isRequired, Expression source)
|
|
: base(SqlNodeType.UserColumn, clrType, sqlType, source) {
|
|
this.Query = query;
|
|
this.name = name;
|
|
this.isRequired = isRequired;
|
|
}
|
|
|
|
internal SqlUserQuery Query {
|
|
get { return this.query; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.query != null && this.query != value)
|
|
throw Error.ArgumentWrongValue("value");
|
|
this.query = value;
|
|
}
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
}
|
|
|
|
internal bool IsRequired {
|
|
get { return this.isRequired; }
|
|
}
|
|
}
|
|
|
|
internal class SqlAlias : SqlSource {
|
|
private string name;
|
|
private SqlNode node;
|
|
|
|
internal SqlAlias(SqlNode node)
|
|
: base(SqlNodeType.Alias, node.SourceExpression) {
|
|
this.Node = node;
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
set { this.name = value; }
|
|
}
|
|
|
|
internal SqlNode Node {
|
|
get { return this.node; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (!(value is SqlExpression || value is SqlSelect || value is SqlTable || value is SqlUnion))
|
|
throw Error.UnexpectedNode(value.NodeType);
|
|
this.node = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlAliasRef : SqlExpression {
|
|
private SqlAlias alias;
|
|
|
|
internal SqlAliasRef(SqlAlias alias)
|
|
: base(SqlNodeType.AliasRef, GetClrType(alias.Node), alias.SourceExpression) {
|
|
if (alias == null)
|
|
throw Error.ArgumentNull("alias");
|
|
this.alias = alias;
|
|
}
|
|
|
|
internal SqlAlias Alias {
|
|
get { return this.alias; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return GetSqlType(this.alias.Node); }
|
|
}
|
|
|
|
private static Type GetClrType(SqlNode node) {
|
|
SqlTableValuedFunctionCall tvf = node as SqlTableValuedFunctionCall;
|
|
if (tvf != null)
|
|
return tvf.RowType.Type;
|
|
SqlExpression exp = node as SqlExpression;
|
|
if (exp != null) {
|
|
if (TypeSystem.IsSequenceType(exp.ClrType))
|
|
return TypeSystem.GetElementType(exp.ClrType);
|
|
return exp.ClrType;
|
|
}
|
|
SqlSelect sel = node as SqlSelect;
|
|
if (sel != null)
|
|
return sel.Selection.ClrType;
|
|
SqlTable tab = node as SqlTable;
|
|
if (tab != null)
|
|
return tab.RowType.Type;
|
|
SqlUnion su = node as SqlUnion;
|
|
if (su != null)
|
|
return su.GetClrType();
|
|
throw Error.UnexpectedNode(node.NodeType);
|
|
}
|
|
|
|
private static ProviderType GetSqlType(SqlNode node) {
|
|
SqlExpression exp = node as SqlExpression;
|
|
if (exp != null)
|
|
return exp.SqlType;
|
|
SqlSelect sel = node as SqlSelect;
|
|
if (sel != null)
|
|
return sel.Selection.SqlType;
|
|
SqlTable tab = node as SqlTable;
|
|
if (tab != null)
|
|
return tab.SqlRowType;
|
|
SqlUnion su = node as SqlUnion;
|
|
if (su != null)
|
|
return su.GetSqlType();
|
|
throw Error.UnexpectedNode(node.NodeType);
|
|
}
|
|
}
|
|
|
|
internal class SqlJoin : SqlSource {
|
|
private SqlJoinType joinType;
|
|
private SqlSource left;
|
|
private SqlSource right;
|
|
private SqlExpression condition;
|
|
|
|
internal SqlJoin(SqlJoinType type, SqlSource left, SqlSource right, SqlExpression cond, Expression sourceExpression)
|
|
: base(SqlNodeType.Join, sourceExpression) {
|
|
this.JoinType = type;
|
|
this.Left = left;
|
|
this.Right = right;
|
|
this.Condition = cond;
|
|
}
|
|
|
|
internal SqlJoinType JoinType {
|
|
get { return this.joinType; }
|
|
set { this.joinType = value; }
|
|
}
|
|
|
|
internal SqlSource Left {
|
|
get { return this.left; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.left = value;
|
|
}
|
|
}
|
|
|
|
internal SqlSource Right {
|
|
get { return this.right; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.right = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Condition {
|
|
get { return this.condition; }
|
|
set { this.condition = value; }
|
|
}
|
|
}
|
|
|
|
internal enum SqlJoinType {
|
|
Cross,
|
|
Inner,
|
|
LeftOuter,
|
|
CrossApply,
|
|
OuterApply
|
|
}
|
|
|
|
internal class SqlUnion : SqlNode {
|
|
private SqlNode left;
|
|
private SqlNode right;
|
|
private bool all;
|
|
|
|
internal SqlUnion(SqlNode left, SqlNode right, bool all)
|
|
: base(SqlNodeType.Union, right.SourceExpression) {
|
|
this.Left = left;
|
|
this.Right = right;
|
|
this.All = all;
|
|
}
|
|
|
|
internal SqlNode Left {
|
|
get { return this.left; }
|
|
set {
|
|
Validate(value);
|
|
this.left = value;
|
|
}
|
|
}
|
|
|
|
internal SqlNode Right {
|
|
get { return this.right; }
|
|
set {
|
|
Validate(value);
|
|
this.right = value;
|
|
}
|
|
}
|
|
|
|
internal bool All {
|
|
get { return this.all; }
|
|
set { this.all = value; }
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
|
|
private void Validate(SqlNode node) {
|
|
if (node == null)
|
|
throw Error.ArgumentNull("node");
|
|
if (!(node is SqlExpression || node is SqlSelect || node is SqlUnion))
|
|
throw Error.UnexpectedNode(node.NodeType);
|
|
}
|
|
|
|
internal Type GetClrType() {
|
|
SqlExpression exp = this.Left as SqlExpression;
|
|
if (exp != null)
|
|
return exp.ClrType;
|
|
SqlSelect sel = this.Left as SqlSelect;
|
|
if (sel != null)
|
|
return sel.Selection.ClrType;
|
|
throw Error.CouldNotGetClrType();
|
|
}
|
|
|
|
internal ProviderType GetSqlType() {
|
|
SqlExpression exp = this.Left as SqlExpression;
|
|
if (exp != null)
|
|
return exp.SqlType;
|
|
SqlSelect sel = this.Left as SqlSelect;
|
|
if (sel != null)
|
|
return sel.Selection.SqlType;
|
|
throw Error.CouldNotGetSqlType();
|
|
}
|
|
}
|
|
|
|
internal class SqlNop : SqlSimpleTypeExpression {
|
|
internal SqlNop(Type clrType, ProviderType sqlType, Expression sourceExpression)
|
|
: base(SqlNodeType.Nop, clrType, sqlType, sourceExpression) {
|
|
}
|
|
}
|
|
|
|
internal class SqlLift : SqlExpression {
|
|
internal SqlExpression liftedExpression;
|
|
|
|
internal SqlLift(Type type, SqlExpression liftedExpression, Expression sourceExpression)
|
|
: base(SqlNodeType.Lift, type, sourceExpression) {
|
|
if (liftedExpression == null)
|
|
throw Error.ArgumentNull("liftedExpression");
|
|
this.liftedExpression = liftedExpression;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.liftedExpression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.liftedExpression = value;
|
|
}
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.liftedExpression.SqlType; }
|
|
}
|
|
}
|
|
|
|
internal enum SqlOrderType {
|
|
Ascending,
|
|
Descending
|
|
}
|
|
|
|
internal class SqlOrderExpression : IEquatable<SqlOrderExpression> {
|
|
private SqlOrderType orderType;
|
|
private SqlExpression expression;
|
|
|
|
internal SqlOrderExpression(SqlOrderType type, SqlExpression expr) {
|
|
this.OrderType = type;
|
|
this.Expression = expr;
|
|
}
|
|
|
|
internal SqlOrderType OrderType {
|
|
get { return this.orderType; }
|
|
set { this.orderType = value; }
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.expression != null && !this.expression.ClrType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object obj) {
|
|
if (this.EqualsTo(obj as SqlOrderExpression))
|
|
return true;
|
|
|
|
return base.Equals(obj);
|
|
}
|
|
|
|
public bool Equals(SqlOrderExpression other) {
|
|
if (this.EqualsTo(other))
|
|
return true;
|
|
|
|
return base.Equals(other);
|
|
}
|
|
|
|
private bool EqualsTo(SqlOrderExpression other) {
|
|
if (other == null)
|
|
return false;
|
|
if (object.ReferenceEquals(this, other))
|
|
return true;
|
|
if (this.OrderType != other.OrderType)
|
|
return false;
|
|
if (!this.Expression.SqlType.Equals(other.Expression.SqlType))
|
|
return false;
|
|
|
|
SqlColumn col1 = SqlOrderExpression.UnwrapColumn(this.Expression);
|
|
SqlColumn col2 = SqlOrderExpression.UnwrapColumn(other.Expression);
|
|
|
|
if (col1 == null || col2 == null)
|
|
return false;
|
|
|
|
return col1 == col2;
|
|
}
|
|
|
|
public override int GetHashCode() {
|
|
SqlColumn col = SqlOrderExpression.UnwrapColumn(this.Expression);
|
|
if (col != null)
|
|
return col.GetHashCode();
|
|
|
|
return base.GetHashCode();
|
|
}
|
|
|
|
private static SqlColumn UnwrapColumn(SqlExpression expr) {
|
|
System.Diagnostics.Debug.Assert(expr != null);
|
|
|
|
SqlUnary exprAsUnary = expr as SqlUnary;
|
|
if (exprAsUnary != null) {
|
|
expr = exprAsUnary.Operand;
|
|
}
|
|
|
|
SqlColumn exprAsColumn = expr as SqlColumn;
|
|
if (exprAsColumn != null) {
|
|
return exprAsColumn;
|
|
}
|
|
|
|
SqlColumnRef exprAsColumnRef = expr as SqlColumnRef;
|
|
if (exprAsColumnRef != null) {
|
|
return exprAsColumnRef.GetRootColumn();
|
|
}
|
|
//
|
|
// For all other types return null to revert to default behavior for Equals()
|
|
// and GetHashCode()
|
|
//
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal class SqlRowNumber : SqlSimpleTypeExpression {
|
|
private List<SqlOrderExpression> orderBy;
|
|
|
|
internal List<SqlOrderExpression> OrderBy {
|
|
get { return orderBy; }
|
|
}
|
|
|
|
internal SqlRowNumber(Type clrType, ProviderType sqlType, List<SqlOrderExpression> orderByList, Expression sourceExpression)
|
|
: base(SqlNodeType.RowNumber, clrType, sqlType, sourceExpression) {
|
|
if (orderByList == null) {
|
|
throw Error.ArgumentNull("orderByList");
|
|
}
|
|
|
|
this.orderBy = orderByList;
|
|
}
|
|
}
|
|
|
|
internal class SqlUnary : SqlSimpleTypeExpression {
|
|
private SqlExpression operand;
|
|
private MethodInfo method;
|
|
|
|
[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 SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, Expression sourceExpression)
|
|
: this(nt, clrType, sqlType, expr, null, sourceExpression) {
|
|
}
|
|
|
|
internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, MethodInfo method, Expression sourceExpression)
|
|
: base(nt, clrType, sqlType, sourceExpression) {
|
|
switch (nt) {
|
|
case SqlNodeType.Not:
|
|
case SqlNodeType.Not2V:
|
|
case SqlNodeType.Negate:
|
|
case SqlNodeType.BitNot:
|
|
case SqlNodeType.IsNull:
|
|
case SqlNodeType.IsNotNull:
|
|
case SqlNodeType.Count:
|
|
case SqlNodeType.LongCount:
|
|
case SqlNodeType.Max:
|
|
case SqlNodeType.Min:
|
|
case SqlNodeType.Sum:
|
|
case SqlNodeType.Avg:
|
|
case SqlNodeType.Stddev:
|
|
case SqlNodeType.Convert:
|
|
case SqlNodeType.ValueOf:
|
|
case SqlNodeType.Treat:
|
|
case SqlNodeType.OuterJoinedValue:
|
|
case SqlNodeType.ClrLength:
|
|
break;
|
|
default:
|
|
throw Error.UnexpectedNode(nt);
|
|
}
|
|
this.Operand = expr;
|
|
this.method = method;
|
|
}
|
|
|
|
internal SqlExpression Operand {
|
|
get { return this.operand; }
|
|
set {
|
|
if (value == null && (this.NodeType != SqlNodeType.Count && this.NodeType != SqlNodeType.LongCount))
|
|
throw Error.ArgumentNull("value");
|
|
this.operand = value;
|
|
}
|
|
}
|
|
|
|
internal MethodInfo Method {
|
|
get { return this.method; }
|
|
}
|
|
}
|
|
|
|
internal class SqlBinary : SqlSimpleTypeExpression {
|
|
private SqlExpression left;
|
|
private SqlExpression right;
|
|
private MethodInfo method;
|
|
|
|
[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 SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right)
|
|
: this(nt, clrType, sqlType, left, right, null) {
|
|
}
|
|
|
|
internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right, MethodInfo method)
|
|
: base(nt, clrType, sqlType, right.SourceExpression) {
|
|
switch (nt) {
|
|
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.And:
|
|
case SqlNodeType.Or:
|
|
case SqlNodeType.GE:
|
|
case SqlNodeType.GT:
|
|
case SqlNodeType.LE:
|
|
case SqlNodeType.LT:
|
|
case SqlNodeType.EQ:
|
|
case SqlNodeType.NE:
|
|
case SqlNodeType.EQ2V:
|
|
case SqlNodeType.NE2V:
|
|
case SqlNodeType.Concat:
|
|
case SqlNodeType.Coalesce:
|
|
break;
|
|
default:
|
|
throw Error.UnexpectedNode(nt);
|
|
}
|
|
this.Left = left;
|
|
this.Right = right;
|
|
this.method = method;
|
|
}
|
|
|
|
internal SqlExpression Left {
|
|
get { return this.left; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.left = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Right {
|
|
get { return this.right; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.right = value;
|
|
}
|
|
}
|
|
|
|
internal MethodInfo Method {
|
|
get { return this.method; }
|
|
}
|
|
}
|
|
|
|
internal class SqlBetween : SqlSimpleTypeExpression {
|
|
SqlExpression expression;
|
|
SqlExpression start;
|
|
SqlExpression end;
|
|
|
|
internal SqlBetween(Type clrType, ProviderType sqlType, SqlExpression expr, SqlExpression start, SqlExpression end, Expression source)
|
|
: base(SqlNodeType.Between, clrType, sqlType, source) {
|
|
this.expression = expr;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set { this.expression = value; }
|
|
}
|
|
|
|
internal SqlExpression Start {
|
|
get { return this.start; }
|
|
set { this.start = value; }
|
|
}
|
|
|
|
internal SqlExpression End {
|
|
get { return this.end; }
|
|
set { this.end = value; }
|
|
}
|
|
}
|
|
|
|
internal class SqlIn : SqlSimpleTypeExpression {
|
|
private SqlExpression expression;
|
|
private List<SqlExpression> values;
|
|
|
|
internal SqlIn(Type clrType, ProviderType sqlType, SqlExpression expression, IEnumerable<SqlExpression> values, Expression sourceExpression)
|
|
:base(SqlNodeType.In, clrType, sqlType, sourceExpression) {
|
|
this.expression = expression;
|
|
this.values = values != null ? new List<SqlExpression>(values) : new List<SqlExpression>(0);
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null) {
|
|
throw Error.ArgumentNull("value");
|
|
}
|
|
this.expression = value;
|
|
}
|
|
}
|
|
internal List<SqlExpression> Values {
|
|
get { return this.values; }
|
|
}
|
|
}
|
|
|
|
internal class SqlLike : SqlSimpleTypeExpression {
|
|
private SqlExpression expression;
|
|
private SqlExpression pattern;
|
|
private SqlExpression escape;
|
|
|
|
internal SqlLike(Type clrType, ProviderType sqlType, SqlExpression expr, SqlExpression pattern, SqlExpression escape, Expression source)
|
|
: base(SqlNodeType.Like, clrType, sqlType, source) {
|
|
if (expr == null)
|
|
throw Error.ArgumentNull("expr");
|
|
if (pattern == null)
|
|
throw Error.ArgumentNull("pattern");
|
|
this.Expression = expr;
|
|
this.Pattern = pattern;
|
|
this.Escape = escape;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.ClrType != typeof(string))
|
|
throw Error.ArgumentWrongType("value", "string", value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Pattern {
|
|
get { return this.pattern; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.ClrType != typeof(string))
|
|
throw Error.ArgumentWrongType("value", "string", value.ClrType);
|
|
this.pattern = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Escape {
|
|
get { return this.escape; }
|
|
set {
|
|
if (value != null && value.ClrType != typeof(string))
|
|
throw Error.ArgumentWrongType("value", "string", value.ClrType);
|
|
this.escape = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlWhen {
|
|
private SqlExpression matchExpression;
|
|
private SqlExpression valueExpression;
|
|
|
|
internal SqlWhen(SqlExpression match, SqlExpression value) {
|
|
// 'match' may be null when this when represents the ELSE condition.
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.Match = match;
|
|
this.Value = value;
|
|
}
|
|
|
|
internal SqlExpression Match {
|
|
get { return this.matchExpression; }
|
|
set {
|
|
if (this.matchExpression != null && value != null && this.matchExpression.ClrType != value.ClrType
|
|
// Exception: bool types, because predicates can have type bool or bool?
|
|
&& !TypeSystem.GetNonNullableType(this.matchExpression.ClrType).Equals(typeof(bool))
|
|
&& !TypeSystem.GetNonNullableType(value.ClrType).Equals(typeof(bool)))
|
|
throw Error.ArgumentWrongType("value", this.matchExpression.ClrType, value.ClrType);
|
|
this.matchExpression = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Value {
|
|
get { return this.valueExpression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.valueExpression != null && !this.valueExpression.ClrType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.valueExpression.ClrType, value.ClrType);
|
|
this.valueExpression = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Searched CASE function:
|
|
* CASE
|
|
* WHEN BooleanExpression THEN resultExpression
|
|
* [ ...n ]
|
|
* [
|
|
* ELSE elseResultExpression
|
|
* ]
|
|
* END
|
|
*/
|
|
internal class SqlSearchedCase : SqlExpression {
|
|
private List<SqlWhen> whens;
|
|
private SqlExpression @else;
|
|
|
|
internal SqlSearchedCase(Type clrType, IEnumerable<SqlWhen> whens, SqlExpression @else, Expression sourceExpression)
|
|
: base(SqlNodeType.SearchedCase, clrType, sourceExpression) {
|
|
if (whens == null)
|
|
throw Error.ArgumentNull("whens");
|
|
this.whens = new List<SqlWhen>(whens);
|
|
if (this.whens.Count == 0)
|
|
throw Error.ArgumentOutOfRange("whens");
|
|
this.Else = @else;
|
|
}
|
|
|
|
internal List<SqlWhen> Whens {
|
|
get { return this.whens; }
|
|
}
|
|
|
|
internal SqlExpression Else {
|
|
get { return this.@else; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.@else != null && !this.@else.ClrType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.@else.ClrType, value.ClrType);
|
|
this.@else = value;
|
|
}
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.whens[0].Value.SqlType; }
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Simple CASE function:
|
|
* CASE inputExpression
|
|
* WHEN whenExpression THEN resultExpression
|
|
* [ ...n ]
|
|
* [
|
|
* ELSE elseResultExpression
|
|
* ]
|
|
* END
|
|
*/
|
|
internal class SqlSimpleCase : SqlExpression {
|
|
private SqlExpression expression;
|
|
private List<SqlWhen> whens = new List<SqlWhen>();
|
|
|
|
internal SqlSimpleCase(Type clrType, SqlExpression expr, IEnumerable<SqlWhen> whens, Expression sourceExpression)
|
|
: base(SqlNodeType.SimpleCase, clrType, sourceExpression) {
|
|
this.Expression = expr;
|
|
if (whens == null)
|
|
throw Error.ArgumentNull("whens");
|
|
this.whens.AddRange(whens);
|
|
if (this.whens.Count == 0)
|
|
throw Error.ArgumentOutOfRange("whens");
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.expression != null && this.expression.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlWhen> Whens {
|
|
get { return this.whens; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.whens[0].Value.SqlType; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A case statement that must be evaluated on the client. For example, a case statement
|
|
/// that contains values of LINK, Element, or Multi-set are not directly handleable by
|
|
/// SQL.
|
|
///
|
|
/// CASE inputExpression
|
|
/// WHEN whenExpression THEN resultExpression
|
|
/// [ ...n ]
|
|
/// END
|
|
/// </summary>
|
|
internal class SqlClientCase : SqlExpression {
|
|
private SqlExpression expression;
|
|
private List<SqlClientWhen> whens = new List<SqlClientWhen>();
|
|
|
|
internal SqlClientCase(Type clrType, SqlExpression expr, IEnumerable<SqlClientWhen> whens, Expression sourceExpression)
|
|
: base(SqlNodeType.ClientCase, clrType, sourceExpression) {
|
|
this.Expression = expr;
|
|
if (whens == null)
|
|
throw Error.ArgumentNull("whens");
|
|
this.whens.AddRange(whens);
|
|
if (this.whens.Count == 0)
|
|
throw Error.ArgumentOutOfRange("whens");
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.expression != null && this.expression.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlClientWhen> Whens {
|
|
get { return this.whens; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.whens[0].Value.SqlType; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A single WHEN clause for ClientCase.
|
|
/// </summary>
|
|
internal class SqlClientWhen {
|
|
private SqlExpression matchExpression;
|
|
private SqlExpression matchValue;
|
|
|
|
internal SqlClientWhen(SqlExpression match, SqlExpression value) {
|
|
// 'match' may be null when this when represents the ELSE condition.
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.Match = match;
|
|
this.Value = value;
|
|
}
|
|
|
|
internal SqlExpression Match {
|
|
get { return this.matchExpression; }
|
|
set {
|
|
if (this.matchExpression != null && value != null && this.matchExpression.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.matchExpression.ClrType, value.ClrType);
|
|
this.matchExpression = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Value {
|
|
get { return this.matchValue; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.matchValue != null && this.matchValue.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.matchValue.ClrType, value.ClrType);
|
|
this.matchValue = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents the construction of an object in abstract 'super sql'.
|
|
/// The type may be polymorphic. A discriminator field is used to determine
|
|
/// which type in a hierarchy should be instantiated.
|
|
/// In the common degenerate case where the inheritance hierarchy is 1-deep
|
|
/// the discriminator will be a constant SqlValue and there will be one
|
|
/// type-case-when corresponding to that type.
|
|
/// </summary>
|
|
internal class SqlTypeCase : SqlExpression {
|
|
private MetaType rowType;
|
|
private SqlExpression discriminator;
|
|
private List<SqlTypeCaseWhen> whens = new List<SqlTypeCaseWhen>();
|
|
ProviderType sqlType;
|
|
|
|
internal SqlTypeCase(Type clrType, ProviderType sqlType, MetaType rowType, SqlExpression discriminator, IEnumerable<SqlTypeCaseWhen> whens, Expression sourceExpression)
|
|
: base(SqlNodeType.TypeCase, clrType, sourceExpression) {
|
|
this.Discriminator = discriminator;
|
|
if (whens == null)
|
|
throw Error.ArgumentNull("whens");
|
|
this.whens.AddRange(whens);
|
|
if (this.whens.Count == 0)
|
|
throw Error.ArgumentOutOfRange("whens");
|
|
this.sqlType = sqlType;
|
|
this.rowType = rowType;
|
|
}
|
|
|
|
internal SqlExpression Discriminator {
|
|
get { return this.discriminator; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.discriminator != null && this.discriminator.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.discriminator.ClrType, value.ClrType);
|
|
this.discriminator = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlTypeCaseWhen> Whens {
|
|
get { return this.whens; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return sqlType; }
|
|
}
|
|
|
|
internal MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents one choice of object instantiation type in a type case.
|
|
/// When 'match' is the same as type case Discriminator then the corresponding
|
|
/// type binding is the one used for instantiation.
|
|
/// </summary>
|
|
internal class SqlTypeCaseWhen {
|
|
private SqlExpression match;
|
|
private SqlExpression @new;
|
|
|
|
internal SqlTypeCaseWhen(SqlExpression match, SqlExpression typeBinding) {
|
|
this.Match = match;
|
|
this.TypeBinding = typeBinding;
|
|
}
|
|
internal SqlExpression Match {
|
|
get { return this.match; }
|
|
set {
|
|
if (this.match != null && value != null && this.match.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.match.ClrType, value.ClrType);
|
|
this.match = value;
|
|
}
|
|
}
|
|
internal SqlExpression TypeBinding {
|
|
get { return this.@new; }
|
|
set { this.@new = value; }
|
|
}
|
|
}
|
|
|
|
internal class SqlValue : SqlSimpleTypeExpression {
|
|
private object value;
|
|
private bool isClient;
|
|
|
|
internal SqlValue(Type clrType, ProviderType sqlType, object value, bool isClientSpecified, Expression sourceExpression)
|
|
: base(SqlNodeType.Value, clrType, sqlType, sourceExpression) {
|
|
this.value = value;
|
|
this.isClient = isClientSpecified;
|
|
}
|
|
|
|
internal object Value {
|
|
get { return this.value; }
|
|
}
|
|
|
|
internal bool IsClientSpecified {
|
|
get { return this.isClient; }
|
|
}
|
|
}
|
|
|
|
internal class SqlParameter : SqlSimpleTypeExpression {
|
|
private string name;
|
|
private System.Data.ParameterDirection direction;
|
|
|
|
internal SqlParameter(Type clrType, ProviderType sqlType, string name, Expression sourceExpression)
|
|
: base(SqlNodeType.Parameter, clrType, sqlType, sourceExpression) {
|
|
if (name == null)
|
|
throw Error.ArgumentNull("name");
|
|
if (typeof(Type).IsAssignableFrom(clrType))
|
|
throw Error.ArgumentWrongValue("clrType");
|
|
this.name = name;
|
|
this.direction = System.Data.ParameterDirection.Input;
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
}
|
|
|
|
internal System.Data.ParameterDirection Direction {
|
|
get { return this.direction; }
|
|
set { this.direction = value; }
|
|
}
|
|
}
|
|
|
|
internal class SqlVariable : SqlSimpleTypeExpression {
|
|
private string name;
|
|
|
|
internal SqlVariable(Type clrType, ProviderType sqlType, string name, Expression sourceExpression)
|
|
: base(SqlNodeType.Variable, clrType, sqlType, sourceExpression) {
|
|
if (name == null)
|
|
throw Error.ArgumentNull("name");
|
|
this.name = name;
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
}
|
|
}
|
|
|
|
internal class SqlMember : SqlSimpleTypeExpression {
|
|
private SqlExpression expression;
|
|
private MemberInfo member;
|
|
|
|
internal SqlMember(Type clrType, ProviderType sqlType, SqlExpression expr, MemberInfo member)
|
|
: base(SqlNodeType.Member, clrType, sqlType, expr.SourceExpression) {
|
|
this.member = member;
|
|
this.Expression = expr;
|
|
}
|
|
|
|
internal MemberInfo Member {
|
|
get { return this.member; }
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get {
|
|
return this.expression;
|
|
}
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (!this.member.ReflectedType.IsAssignableFrom(value.ClrType) &&
|
|
!value.ClrType.IsAssignableFrom(this.member.ReflectedType))
|
|
throw Error.MemberAccessIllegal(this.member, this.member.ReflectedType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlColumn : SqlExpression {
|
|
private SqlAlias alias;
|
|
private string name;
|
|
private int ordinal;
|
|
private MetaDataMember member;
|
|
private SqlExpression expression;
|
|
private ProviderType sqlType;
|
|
|
|
internal SqlColumn(Type clrType, ProviderType sqlType, string name, MetaDataMember member, SqlExpression expr, Expression sourceExpression)
|
|
: base(SqlNodeType.Column, clrType, sourceExpression) {
|
|
if (typeof(Type).IsAssignableFrom(clrType))
|
|
throw Error.ArgumentWrongValue("clrType");
|
|
this.Name = name;
|
|
this.member = member;
|
|
this.Expression = expr;
|
|
this.Ordinal = -1;
|
|
if (sqlType == null)
|
|
throw Error.ArgumentNull("sqlType");
|
|
this.sqlType = sqlType;
|
|
System.Diagnostics.Debug.Assert(sqlType.CanBeColumn);
|
|
}
|
|
|
|
internal SqlColumn(string name, SqlExpression expr)
|
|
: this(expr.ClrType, expr.SqlType, name, null, expr, expr.SourceExpression) {
|
|
System.Diagnostics.Debug.Assert(expr != null);
|
|
}
|
|
|
|
internal SqlAlias Alias {
|
|
get { return this.alias; }
|
|
set { this.alias = value; }
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
set { this.name = value; }
|
|
}
|
|
|
|
internal int Ordinal {
|
|
get { return this.ordinal; }
|
|
set { this.ordinal = value; }
|
|
}
|
|
|
|
internal MetaDataMember MetaMember {
|
|
get { return this.member; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the column's Expression. This can change the type of the column.
|
|
/// </summary>
|
|
internal SqlExpression Expression {
|
|
get {
|
|
return this.expression;
|
|
}
|
|
set {
|
|
if (value != null) {
|
|
if (!this.ClrType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
|
|
SqlColumnRef cref = value as SqlColumnRef;
|
|
if (cref != null && cref.Column == this)
|
|
throw Error.ColumnCannotReferToItself();
|
|
}
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get {
|
|
if (this.expression != null)
|
|
return this.expression.SqlType;
|
|
return this.sqlType;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlColumnRef : SqlExpression {
|
|
private SqlColumn column;
|
|
internal SqlColumnRef(SqlColumn col)
|
|
: base(SqlNodeType.ColumnRef, col.ClrType, col.SourceExpression) {
|
|
this.column = col;
|
|
}
|
|
|
|
internal SqlColumn Column {
|
|
get { return this.column; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.column.SqlType; }
|
|
}
|
|
|
|
public override bool Equals(object obj) {
|
|
SqlColumnRef cref = obj as SqlColumnRef;
|
|
return cref != null && cref.Column == this.column;
|
|
}
|
|
|
|
public override int GetHashCode() {
|
|
return this.column.GetHashCode();
|
|
}
|
|
|
|
internal SqlColumn GetRootColumn() {
|
|
SqlColumn c = this.column;
|
|
while (c.Expression != null && c.Expression.NodeType == SqlNodeType.ColumnRef) {
|
|
c = ((SqlColumnRef)c.Expression).Column;
|
|
}
|
|
return c;
|
|
}
|
|
}
|
|
|
|
internal class SqlRow : SqlNode {
|
|
private List<SqlColumn> columns;
|
|
|
|
internal SqlRow(Expression sourceExpression)
|
|
: base(SqlNodeType.Row, sourceExpression) {
|
|
this.columns = new List<SqlColumn>();
|
|
}
|
|
|
|
internal List<SqlColumn> Columns {
|
|
get { return this.columns; }
|
|
}
|
|
|
|
internal SqlColumn Find(string name) {
|
|
foreach (SqlColumn c in this.columns) {
|
|
if (name == c.Name)
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal class SqlMemberAssign : SqlNode {
|
|
private MemberInfo member;
|
|
private SqlExpression expression;
|
|
|
|
internal SqlMemberAssign(MemberInfo member, SqlExpression expr)
|
|
: base(SqlNodeType.MemberAssign, expr.SourceExpression) {
|
|
if (member == null)
|
|
throw Error.ArgumentNull("member");
|
|
this.member = member;
|
|
this.Expression = expr;
|
|
}
|
|
|
|
internal MemberInfo Member {
|
|
get { return this.member; }
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.expression = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlGrouping : SqlSimpleTypeExpression {
|
|
private SqlExpression key;
|
|
private SqlExpression group;
|
|
|
|
internal SqlGrouping(Type clrType, ProviderType sqlType, SqlExpression key, SqlExpression group, Expression sourceExpression)
|
|
: base(SqlNodeType.Grouping, clrType, sqlType, sourceExpression) {
|
|
if (key == null) throw Error.ArgumentNull("key");
|
|
if (group == null) throw Error.ArgumentNull("group");
|
|
this.key = key;
|
|
this.group = group;
|
|
}
|
|
|
|
internal SqlExpression Key {
|
|
get { return this.key; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (!this.key.ClrType.IsAssignableFrom(value.ClrType)
|
|
&& !value.ClrType.IsAssignableFrom(this.key.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.key.ClrType, value.ClrType);
|
|
this.key = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Group {
|
|
get { return this.group; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.ClrType != this.group.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.group.ClrType, value.ClrType);
|
|
this.group = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlNew : SqlSimpleTypeExpression {
|
|
private MetaType metaType;
|
|
private ConstructorInfo constructor;
|
|
private List<SqlExpression> args;
|
|
private List<MemberInfo> argMembers;
|
|
private List<SqlMemberAssign> members;
|
|
|
|
internal SqlNew(MetaType metaType, ProviderType sqlType, ConstructorInfo cons, IEnumerable<SqlExpression> args, IEnumerable<MemberInfo> argMembers, IEnumerable<SqlMemberAssign> members, Expression sourceExpression)
|
|
: base(SqlNodeType.New, metaType.Type, sqlType, sourceExpression) {
|
|
this.metaType = metaType;
|
|
|
|
if (cons == null && metaType.Type.IsClass) { // structs do not need to have a constructor
|
|
throw Error.ArgumentNull("cons");
|
|
}
|
|
this.constructor = cons;
|
|
this.args = new List<SqlExpression>();
|
|
this.argMembers = new List<MemberInfo>();
|
|
this.members = new List<SqlMemberAssign>();
|
|
if (args != null) {
|
|
this.args.AddRange(args);
|
|
}
|
|
if (argMembers != null) {
|
|
this.argMembers.AddRange(argMembers);
|
|
}
|
|
if (members != null) {
|
|
this.members.AddRange(members);
|
|
}
|
|
}
|
|
|
|
internal MetaType MetaType {
|
|
get { return this.metaType; }
|
|
}
|
|
|
|
internal ConstructorInfo Constructor {
|
|
get { return this.constructor; }
|
|
}
|
|
|
|
internal List<SqlExpression> Args {
|
|
get { return this.args; }
|
|
}
|
|
|
|
internal List<MemberInfo> ArgMembers {
|
|
get { return this.argMembers; }
|
|
}
|
|
|
|
internal List<SqlMemberAssign> Members {
|
|
get { return this.members; }
|
|
}
|
|
|
|
internal SqlExpression Find(MemberInfo mi) {
|
|
for (int i = 0, n = this.argMembers.Count; i < n; i++) {
|
|
MemberInfo argmi = this.argMembers[i];
|
|
if (argmi.Name == mi.Name) {
|
|
return this.args[i];
|
|
}
|
|
}
|
|
|
|
foreach (SqlMemberAssign ma in this.Members) {
|
|
if (ma.Member.Name == mi.Name) {
|
|
return ma.Expression;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal class SqlMethodCall : SqlSimpleTypeExpression {
|
|
private MethodInfo method;
|
|
private SqlExpression obj;
|
|
private List<SqlExpression> arguments;
|
|
|
|
internal SqlMethodCall(Type clrType, ProviderType sqlType, MethodInfo method, SqlExpression obj, IEnumerable<SqlExpression> args, Expression sourceExpression)
|
|
: base(SqlNodeType.MethodCall, clrType, sqlType, sourceExpression) {
|
|
if (method == null)
|
|
throw Error.ArgumentNull("method");
|
|
this.method = method;
|
|
this.Object = obj;
|
|
this.arguments = new List<SqlExpression>();
|
|
if (args != null)
|
|
this.arguments.AddRange(args);
|
|
}
|
|
|
|
internal MethodInfo Method {
|
|
get { return this.method; }
|
|
}
|
|
|
|
internal SqlExpression Object {
|
|
get { return this.obj; }
|
|
set {
|
|
if (value == null && !this.method.IsStatic)
|
|
throw Error.ArgumentNull("value");
|
|
if (value != null && !this.method.DeclaringType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.method.DeclaringType, value.ClrType);
|
|
this.obj = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlExpression> Arguments {
|
|
get { return this.arguments; }
|
|
}
|
|
}
|
|
|
|
internal class SqlIncludeScope : SqlNode {
|
|
SqlNode child;
|
|
internal SqlIncludeScope(SqlNode child, Expression sourceExpression)
|
|
: base(SqlNodeType.IncludeScope, sourceExpression) {
|
|
this.child = child;
|
|
}
|
|
internal SqlNode Child {
|
|
get {return this.child;}
|
|
set {this.child = value;}
|
|
}
|
|
}
|
|
|
|
internal class SqlClientArray : SqlSimpleTypeExpression {
|
|
private List<SqlExpression> expressions;
|
|
|
|
internal SqlClientArray(Type clrType, ProviderType sqlType, SqlExpression[ ] exprs, Expression sourceExpression)
|
|
: base(SqlNodeType.ClientArray, clrType, sqlType, sourceExpression) {
|
|
this.expressions = new List<SqlExpression>();
|
|
if (exprs != null)
|
|
this.Expressions.AddRange(exprs);
|
|
}
|
|
|
|
internal List<SqlExpression> Expressions {
|
|
get { return this.expressions; }
|
|
}
|
|
}
|
|
|
|
internal class SqlLink : SqlSimpleTypeExpression {
|
|
private MetaType rowType;
|
|
private SqlExpression expression;
|
|
private MetaDataMember member;
|
|
private List<SqlExpression> keyExpressions;
|
|
private SqlExpression expansion;
|
|
private object id;
|
|
|
|
internal SqlLink(object id, MetaType rowType, Type clrType, ProviderType sqlType, SqlExpression expression, MetaDataMember member, IEnumerable<SqlExpression> keyExpressions, SqlExpression expansion, Expression sourceExpression)
|
|
: base(SqlNodeType.Link, clrType, sqlType, sourceExpression) {
|
|
this.id = id;
|
|
this.rowType = rowType;
|
|
this.expansion = expansion;
|
|
this.expression = expression;
|
|
this.member = member;
|
|
this.keyExpressions = new List<SqlExpression>();
|
|
if (keyExpressions != null)
|
|
this.keyExpressions.AddRange(keyExpressions);
|
|
}
|
|
|
|
internal MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
|
|
internal SqlExpression Expansion {
|
|
get { return this.expansion; }
|
|
set { this.expansion = value; }
|
|
}
|
|
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set { this.expression = value; }
|
|
}
|
|
|
|
internal MetaDataMember Member {
|
|
get { return this.member; }
|
|
}
|
|
|
|
internal List<SqlExpression> KeyExpressions {
|
|
get { return this.keyExpressions; }
|
|
}
|
|
|
|
internal object Id {
|
|
get { return this.id; }
|
|
}
|
|
}
|
|
|
|
internal class SqlExprSet : SqlExpression {
|
|
private List<SqlExpression> expressions;
|
|
|
|
internal SqlExprSet(Type clrType, IEnumerable <SqlExpression> exprs, Expression sourceExpression)
|
|
: base(SqlNodeType.ExprSet, clrType, sourceExpression) {
|
|
this.expressions = new List<SqlExpression>(exprs);
|
|
}
|
|
|
|
internal List<SqlExpression> Expressions {
|
|
get { return this.expressions; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the first non-set expression of the set by drilling
|
|
/// down the left expressions.
|
|
/// </summary>
|
|
internal SqlExpression GetFirstExpression() {
|
|
SqlExpression expr = expressions[0];
|
|
while (expr is SqlExprSet) {
|
|
expr = ((SqlExprSet)expr).Expressions[0];
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.expressions[0].SqlType; }
|
|
}
|
|
}
|
|
|
|
internal class SqlSubSelect : SqlSimpleTypeExpression {
|
|
private SqlSelect select;
|
|
|
|
internal SqlSubSelect(SqlNodeType nt , Type clrType, ProviderType sqlType , SqlSelect select)
|
|
: base(nt, clrType, sqlType, select.SourceExpression) {
|
|
switch (nt) {
|
|
case SqlNodeType.Multiset:
|
|
case SqlNodeType.ScalarSubSelect:
|
|
case SqlNodeType.Element:
|
|
case SqlNodeType.Exists:
|
|
break;
|
|
default:
|
|
throw Error.UnexpectedNode(nt);
|
|
}
|
|
this.Select = select;
|
|
}
|
|
|
|
internal SqlSelect Select {
|
|
get { return this.select; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.select = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlClientQuery : SqlSimpleTypeExpression {
|
|
private SqlSubSelect query;
|
|
private List<SqlExpression> arguments;
|
|
private List<SqlParameter> parameters;
|
|
int ordinal;
|
|
|
|
internal SqlClientQuery(SqlSubSelect subquery)
|
|
: base(SqlNodeType.ClientQuery, subquery.ClrType, subquery.SqlType, subquery.SourceExpression) {
|
|
this.query = subquery;
|
|
this.arguments = new List<SqlExpression>();
|
|
this.parameters = new List<SqlParameter>();
|
|
}
|
|
|
|
internal SqlSubSelect Query {
|
|
get { return this.query; }
|
|
set {
|
|
if (value == null || (this.query != null && this.query.ClrType != value.ClrType))
|
|
throw Error.ArgumentWrongType(value, this.query.ClrType, value.ClrType);
|
|
this.query = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlExpression> Arguments {
|
|
get { return this.arguments; }
|
|
}
|
|
|
|
internal List<SqlParameter> Parameters {
|
|
get { return this.parameters; }
|
|
}
|
|
|
|
internal int Ordinal {
|
|
get { return this.ordinal; }
|
|
set { this.ordinal = value; }
|
|
}
|
|
}
|
|
|
|
internal class SqlJoinedCollection : SqlSimpleTypeExpression {
|
|
private SqlExpression expression;
|
|
private SqlExpression count;
|
|
|
|
internal SqlJoinedCollection(Type clrType, ProviderType sqlType, SqlExpression expression, SqlExpression count, Expression sourceExpression)
|
|
: base(SqlNodeType.JoinedCollection, clrType, sqlType, sourceExpression) {
|
|
this.expression = expression;
|
|
this.count = count;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null || this.expression != null && this.expression.ClrType != value.ClrType)
|
|
throw Error.ArgumentWrongType(value, this.expression.ClrType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Count {
|
|
get { return this.count; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.ClrType != typeof(int))
|
|
throw Error.ArgumentWrongType(value, typeof(int), value.ClrType);
|
|
this.count = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlUpdate : SqlStatement {
|
|
private SqlSelect select;
|
|
private List<SqlAssign> assignments;
|
|
|
|
internal SqlUpdate(SqlSelect select, IEnumerable<SqlAssign> assignments, Expression sourceExpression)
|
|
: base(SqlNodeType.Update, sourceExpression) {
|
|
this.Select = select;
|
|
this.assignments = new List<SqlAssign>(assignments);
|
|
}
|
|
|
|
internal SqlSelect Select {
|
|
get { return this.select; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.select = value;
|
|
}
|
|
}
|
|
|
|
internal List<SqlAssign> Assignments {
|
|
get { return this.assignments; }
|
|
}
|
|
}
|
|
|
|
internal class SqlInsert : SqlStatement {
|
|
private SqlTable table;
|
|
private SqlRow row;
|
|
private SqlExpression expression;
|
|
private SqlColumn outputKey;
|
|
private bool outputToLocal;
|
|
|
|
internal SqlInsert(SqlTable table, SqlExpression expr, Expression sourceExpression)
|
|
: base(SqlNodeType.Insert, sourceExpression) {
|
|
this.Table = table;
|
|
this.Expression = expr;
|
|
this.Row = new SqlRow(sourceExpression);
|
|
}
|
|
|
|
internal SqlTable Table {
|
|
get { return this.table; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("null");
|
|
this.table = value;
|
|
}
|
|
}
|
|
|
|
internal SqlRow Row {
|
|
get { return this.row; }
|
|
set { this.row = value; }
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("null");
|
|
if (!this.table.RowType.Type.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.table.RowType, value.ClrType);
|
|
this.expression = value;
|
|
}
|
|
}
|
|
|
|
internal SqlColumn OutputKey {
|
|
get { return this.outputKey; }
|
|
set { this.outputKey = value; }
|
|
}
|
|
|
|
internal bool OutputToLocal {
|
|
get { return this.outputToLocal; }
|
|
set { this.outputToLocal = value; }
|
|
}
|
|
}
|
|
|
|
internal class SqlDelete : SqlStatement {
|
|
private SqlSelect select;
|
|
|
|
internal SqlDelete(SqlSelect select, Expression sourceExpression)
|
|
: base(SqlNodeType.Delete, sourceExpression) {
|
|
this.Select = select;
|
|
}
|
|
|
|
internal SqlSelect Select {
|
|
get { return this.select; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.select = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlBlock : SqlStatement {
|
|
private List<SqlStatement> statements;
|
|
|
|
internal SqlBlock(Expression sourceExpression)
|
|
: base(SqlNodeType.Block, sourceExpression) {
|
|
this.statements = new List<SqlStatement>();
|
|
}
|
|
|
|
internal List<SqlStatement> Statements {
|
|
get { return this.statements; }
|
|
}
|
|
}
|
|
|
|
internal class SqlAssign : SqlStatement {
|
|
private SqlExpression leftValue;
|
|
private SqlExpression rightValue;
|
|
|
|
internal SqlAssign(SqlExpression lValue, SqlExpression rValue, Expression sourceExpression)
|
|
: base(SqlNodeType.Assign, sourceExpression) {
|
|
this.LValue = lValue;
|
|
this.RValue = rValue;
|
|
}
|
|
|
|
internal SqlExpression LValue {
|
|
get { return this.leftValue; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.rightValue != null && !value.ClrType.IsAssignableFrom(this.rightValue.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.rightValue.ClrType, value.ClrType);
|
|
this.leftValue = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression RValue {
|
|
get { return this.rightValue; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (this.leftValue != null && !this.leftValue.ClrType.IsAssignableFrom(value.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.leftValue.ClrType, value.ClrType);
|
|
this.rightValue = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlDoNotVisitExpression : SqlExpression {
|
|
private SqlExpression expression;
|
|
|
|
internal SqlDoNotVisitExpression(SqlExpression expr)
|
|
: base(SqlNodeType.DoNotVisit, expr.ClrType, expr.SourceExpression) {
|
|
if (expr == null)
|
|
throw Error.ArgumentNull("expr");
|
|
this.expression = expr;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expression; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.expression.SqlType; }
|
|
}
|
|
}
|
|
|
|
internal class SqlOptionalValue : SqlSimpleTypeExpression {
|
|
private SqlExpression hasValue;
|
|
private SqlExpression expressionValue;
|
|
|
|
internal SqlOptionalValue( SqlExpression hasValue, SqlExpression value)
|
|
: base(SqlNodeType.OptionalValue, value.ClrType, value.SqlType, value.SourceExpression) {
|
|
this.HasValue = hasValue;
|
|
this.Value = value;
|
|
}
|
|
|
|
internal SqlExpression HasValue {
|
|
get { return this.hasValue; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
this.hasValue = value;
|
|
}
|
|
}
|
|
|
|
internal SqlExpression Value {
|
|
get { return this.expressionValue; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (value.ClrType != this.ClrType)
|
|
throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
|
|
this.expressionValue = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SqlFunctionCall : SqlSimpleTypeExpression {
|
|
private string name;
|
|
private List<SqlExpression> arguments;
|
|
|
|
internal SqlFunctionCall(Type clrType, ProviderType sqlType, string name, IEnumerable <SqlExpression > args , Expression source)
|
|
: this(SqlNodeType.FunctionCall, clrType , sqlType, name, args, source) {
|
|
}
|
|
|
|
internal SqlFunctionCall(SqlNodeType nodeType, Type clrType, ProviderType sqlType, string name , IEnumerable <SqlExpression> args , Expression source)
|
|
: base(nodeType, clrType, sqlType, source) {
|
|
this.name = name;
|
|
this.arguments = new List<SqlExpression>(args);
|
|
}
|
|
|
|
internal string Name {
|
|
get { return this.name; }
|
|
}
|
|
|
|
internal List<SqlExpression> Arguments {
|
|
get { return this.arguments; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class is used to represent a table value function. It inherits normal function
|
|
/// call functionality, and adds TVF specific members.
|
|
/// </summary>
|
|
internal class SqlTableValuedFunctionCall : SqlFunctionCall {
|
|
private MetaType rowType;
|
|
private List<SqlColumn> columns;
|
|
|
|
internal SqlTableValuedFunctionCall(MetaType rowType, Type clrType, ProviderType sqlType, string name, IEnumerable <SqlExpression > args , Expression source)
|
|
: base(SqlNodeType.TableValuedFunctionCall, clrType , sqlType, name, args, source) {
|
|
this.rowType = rowType;
|
|
this.columns = new List<SqlColumn>();
|
|
}
|
|
|
|
internal MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
|
|
internal List<SqlColumn> Columns {
|
|
get { return this.columns; }
|
|
}
|
|
|
|
internal SqlColumn Find(string name) {
|
|
foreach (SqlColumn c in this.Columns) {
|
|
if (c.Name == name)
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
internal class SqlSharedExpression : SqlExpression {
|
|
private SqlExpression expr;
|
|
|
|
internal SqlSharedExpression(SqlExpression expr)
|
|
: base(SqlNodeType.SharedExpression, expr.ClrType, expr.SourceExpression) {
|
|
this.expr = expr;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expr; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (!this.ClrType.IsAssignableFrom(value.ClrType)
|
|
&& !value.ClrType.IsAssignableFrom(this.ClrType))
|
|
throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
|
|
this.expr = value;
|
|
}
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.expr.SqlType; }
|
|
}
|
|
}
|
|
|
|
internal class SqlSharedExpressionRef : SqlExpression {
|
|
private SqlSharedExpression expr;
|
|
|
|
internal SqlSharedExpressionRef(SqlSharedExpression expr)
|
|
: base(SqlNodeType.SharedExpressionRef, expr.ClrType, expr.SourceExpression) {
|
|
this.expr = expr;
|
|
}
|
|
|
|
internal SqlSharedExpression SharedExpression {
|
|
get { return this.expr; }
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.expr.SqlType; }
|
|
}
|
|
}
|
|
|
|
internal class SqlSimpleExpression : SqlExpression {
|
|
private SqlExpression expr;
|
|
|
|
internal SqlSimpleExpression(SqlExpression expr)
|
|
: base(SqlNodeType.SimpleExpression, expr.ClrType, expr.SourceExpression) {
|
|
this.expr = expr;
|
|
}
|
|
|
|
internal SqlExpression Expression {
|
|
get { return this.expr; }
|
|
set {
|
|
if (value == null)
|
|
throw Error.ArgumentNull("value");
|
|
if (!TypeSystem.GetNonNullableType(this.ClrType).IsAssignableFrom(TypeSystem.GetNonNullableType(value.ClrType)))
|
|
throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
|
|
this.expr = value;
|
|
}
|
|
}
|
|
|
|
internal override ProviderType SqlType {
|
|
get { return this.expr.SqlType; }
|
|
}
|
|
}
|
|
|
|
internal class SqlClientParameter : SqlSimpleTypeExpression {
|
|
// Expression<Func<object[], T>>
|
|
LambdaExpression accessor;
|
|
internal SqlClientParameter(Type clrType, ProviderType sqlType, LambdaExpression accessor, Expression sourceExpression):
|
|
base(SqlNodeType.ClientParameter, clrType, sqlType, sourceExpression) {
|
|
this.accessor = accessor;
|
|
}
|
|
internal LambdaExpression Accessor {
|
|
get { return this.accessor; }
|
|
}
|
|
}
|
|
}
|