private void InsertOpenTypeFiltersWhenRhs(object val) { OpenTypePropertySqlMetaData openTypePropertySqlMetaDatum = this.m_OpenTypeProperties.Pop(); string sqlTypeForClrType = ExpressionUtility.GetSqlTypeForClrType(val.GetType()); string str = string.Format("( CASE WHEN ( Data.exist('(/Properties/{0})[1]') = 1 ) THEN", openTypePropertySqlMetaDatum.PropertyName); str = string.Concat(str, string.Format("\n {0} THEN", this.GetCaseStatementToCheckSqlType(openTypePropertySqlMetaDatum.PropertyName, sqlTypeForClrType))); str = string.Concat(str, string.Format("\n Data.value('(/Properties/{0})[1]','{1}' )", openTypePropertySqlMetaDatum.PropertyName, sqlTypeForClrType)); str = string.Concat(str, " END END)"); this.PartialClause.Insert(openTypePropertySqlMetaDatum.QueryIndex, str); }
protected Expression VisitSelectMethodCall(MethodCallExpression m) { if (m.Arguments[0].NodeType == ExpressionType.Call) { this.Visit(m.Arguments[0]); } this.m_processingState = ProcessingState.Select; LambdaExpression lambdaExpression = (LambdaExpression)ExpressionUtility.StripQuotes(m.Arguments[1]); this.Visit(lambdaExpression.Body); return(m); }
private string GetSqlQueryExpressionOperator(ExpressionType nodeType) { if (nodeType != ExpressionType.Equal || this.IsPointQuery.HasValue) { this.IsPointQuery = new bool?(false); } else { this.IsPointQuery = new bool?(true); } return(ExpressionUtility.GetSqlQueryExpressionOperator(nodeType)); }
private Expression VisitWhere(MethodCallExpression m) { this.m_processingState = ProcessingState.Where; if (m.Arguments[0].NodeType == ExpressionType.Call) { this.Visit(m.Arguments[0]); } this.SqlQuery.AppendFormat(" {0} ", ExpressionUtility.GetSqlQueryExpressionOperator(ExpressionType.AndAlso)); LambdaExpression lambdaExpression = (LambdaExpression)ExpressionUtility.StripQuotes(m.Arguments[1]); this.Visit(lambdaExpression.Body); return(m); }
internal static bool IsConstantExpressionEquivalent(Expression expression) { switch (expression.NodeType) { case ExpressionType.Constant: { return(true); } case ExpressionType.Convert: { return(ExpressionUtility.IsConstantExpressionEquivalent((expression as UnaryExpression).Operand)); } } return(false); }
private void InsertOpenTypeFilters(object val, string sqlParam) { OpenTypePropertySqlMetaData sqlQueryExpressionOperator = this.m_OpenTypeProperties.Pop(); string sqlTypeForClrType = ExpressionUtility.GetSqlTypeForClrType(val.GetType()); string str = string.Format("( 1 = CASE WHEN ( Data.exist('(/Properties/{0})[1]') = 1 ) THEN", sqlQueryExpressionOperator.PropertyName); str = string.Concat(str, string.Format("\n {0} THEN", this.GetCaseStatementToCheckSqlType(sqlQueryExpressionOperator.PropertyName, sqlTypeForClrType))); if (sqlQueryExpressionOperator.ComparisonOperator == null) { sqlQueryExpressionOperator.ComparisonOperator = this.GetSqlQueryExpressionOperator(ExpressionType.Equal); } object[] propertyName = new object[] { sqlQueryExpressionOperator.PropertyName, sqlTypeForClrType, sqlQueryExpressionOperator.ComparisonOperator, sqlParam }; str = string.Concat(str, string.Format("\n CASE WHEN ( Data.value('(/Properties/{0})[1]','{1}') {2} {3} ) THEN 1 ELSE 0", propertyName)); str = string.Concat(str, " END END END )"); this.PartialClause.Insert(sqlQueryExpressionOperator.QueryIndex, str); }
private Expression VisitWhere(MethodCallExpression m) { this.m_hasVisitiedBinary = false; this.m_processingState = ProcessingState.Where; if (m.Arguments[0].NodeType == ExpressionType.Call) { this.RecordCallerAndVisit(m.Arguments[0], m); } this.WhereClause.AppendFormat(" {0} ", this.GetSqlQueryExpressionOperator(ExpressionType.AndAlso)); this.PartialClause.Clear(); LambdaExpression lambdaExpression = (LambdaExpression)ExpressionUtility.StripQuotes(m.Arguments[1]); this.RecordCallerAndVisit(lambdaExpression.Body, lambdaExpression); this.WhereClause.Append(this.PartialClause.ToString()); return(m); }
private Expression VisitOrderBy(MethodCallExpression m) { this.m_HasOrderBy = true; this.RecordCallerAndVisit(m.Arguments[0], m); if (!string.Equals(m.Method.Name, "OrderBy")) { this.OrderByClause.Append(", "); } else { this.m_processingState = ProcessingState.OrderBy; } this.PartialClause.Clear(); LambdaExpression lambdaExpression = (LambdaExpression)ExpressionUtility.StripQuotes(m.Arguments[1]); this.RecordCallerAndVisit(lambdaExpression.Body, lambdaExpression); this.OrderByClause.Append(this.PartialClause.ToString()); return(m); }
private Expression VisitOrderBy(MethodCallExpression m) { this.m_IsOrderByQuery = true; this.Visit(m.Arguments[0]); if (!string.Equals(m.Method.Name, "OrderBy")) { this.SqlQuery.Append(", "); } else { this.m_processingState = ProcessingState.OrderBy; this.SqlQuery.AppendLine(); this.SqlQuery.Append("ORDER BY "); } LambdaExpression lambdaExpression = (LambdaExpression)ExpressionUtility.StripQuotes(m.Arguments[1]); this.Visit(lambdaExpression.Body); return(m); }
protected Expression VisitMethodCall(MethodCallExpression m) { if (m.Method.DeclaringType == typeof(Queryable) && string.Equals(m.Method.Name, "Where")) { return(this.VisitWhere(m)); } if (!string.Equals(m.Method.Name, "GetValue")) { if (string.Equals(m.Method.Name, "Take")) { return(this.VisitTake(m)); } if (string.Equals(m.Method.Name, "OrderBy") || string.Equals(m.Method.Name, "ThenBy")) { return(this.VisitOrderBy(m)); } if (string.Equals(m.Method.Name, "AndAlso") && m.Arguments.Count == 2) { return(this.VisitAndOrCall(m, ExpressionType.AndAlso)); } if (string.Equals(m.Method.Name, "OrElse") && m.Arguments.Count == 2) { return(this.VisitAndOrCall(m, ExpressionType.OrElse)); } if (!string.Equals(m.Method.Name, "Select") || m.Arguments.Count != 2) { throw new NotSupportedException(string.Format("The method '{0}' is not supported", m.Method.Name)); } return(this.VisitSelectMethodCall(m)); } bool flag = true; bool flag1 = false; if (this.m_PreviousExpression != null) { ExpressionType nodeType = this.m_PreviousExpression.NodeType; switch (nodeType) { case ExpressionType.Equal: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: { if ((this.m_PreviousExpression as BinaryExpression).Right == m) { flag1 = true; if (!ExpressionUtility.IsConstantExpressionEquivalent((this.m_PreviousExpression as BinaryExpression).Left)) { throw new NotImplementedException(); } } flag = false; break; } case ExpressionType.ExclusiveOr: case ExpressionType.Invoke: case ExpressionType.Lambda: case ExpressionType.LeftShift: { break; } default: { if (nodeType != ExpressionType.NotEqual) { break; } else { goto case ExpressionType.LessThanOrEqual; } } } } this.ProcessMemberAccess(m); if (flag && this.HasOpenPropertyOnStack()) { this.InsertOpenTypeFilters(true, "1"); } else if (flag1 && this.HasOpenPropertyOnStack()) { this.InsertOpenTypeFiltersWhenRhs(this.Parameters[this.paramIndex - 1].Value); } return(m); }
protected Expression VisitBinary(BinaryExpression b) { int num = 0; ExpressionType nodeType = b.NodeType; switch (nodeType) { case ExpressionType.And: case ExpressionType.AndAlso: { Label0: this.m_needsClosing.Push(true); break; } default: { switch (nodeType) { case ExpressionType.Or: case ExpressionType.OrElse: { goto Label0; } default: { this.m_needsClosing.Push(false); break; } } break; } } if (!this.m_needsClosing.Peek() && !this.m_hasVisitiedBinary) { this.m_hasVisitiedBinary = true; if (b.Right.NodeType == ExpressionType.Constant && b.Right.Type == typeof(object)) { this.RecordCallerAndVisit(b.Left, null); this.m_needsClosing.Pop(); return(b); } } bool flag = false; bool flag1 = false; int count = -1; int count1 = -1; this.PartialClause.Append("( "); this.isKeyAccess = false; bool methodCall = this.IsCompareToMethodCall(b.Left); if (!methodCall) { if (!this.m_needsClosing.Peek()) { ExpressionUtility.ValidateIsSimpleExpression(b.Left); flag = ExpressionUtility.IsConstantExpressionEquivalent(b.Left); } this.RecordCallerAndVisit(b.Left, b); this.CloseBooleanExpression(b.NodeType, b.Left); } else { Expression item = ((MethodCallExpression)b.Left).Arguments[0]; ExpressionUtility.ValidateIsSimpleExpression(item); flag = ExpressionUtility.IsConstantExpressionEquivalent(item); this.RecordCallerAndVisit(item, b.Left); } if (b.Left is ConstantExpression || b.Left.NodeType == ExpressionType.Convert) { num++; } if (flag) { count = this.Parameters.Count - 1; } this.ProcessBinaryExpressionOperator(b.NodeType); if (!methodCall) { this.RecordCallerAndVisit(b.Right, b); if (!this.m_needsClosing.Peek()) { flag1 = ExpressionUtility.IsConstantExpressionEquivalent(b.Right); } this.CloseBooleanExpression(b.NodeType, b.Right); } else { this.RecordCallerAndVisit(((MethodCallExpression)b.Left).Arguments[1], b.Left); if (!this.m_needsClosing.Peek()) { flag1 = ExpressionUtility.IsConstantExpressionEquivalent(((MethodCallExpression)b.Left).Arguments[1]); } } if (!this.m_needsClosing.Peek() && flag ^ flag1) { throw new NotImplementedException(); } if (b.Right is ConstantExpression || b.Right.NodeType == ExpressionType.Convert) { num++; } if (flag1) { count1 = this.Parameters.Count - 1; } if (flag || flag1) { int num1 = -1; if (count != -1 && this.Parameters[count].IsStringValue) { num1 = count; } else if (count1 != -1 && this.Parameters[count1].IsStringValue) { num1 = count1; } if (num1 != -1) { string value = this.Parameters[num1].Value as string; if (value != null) { if (!this.isKeyAccess) { this.Parameters[num1].Value = DevelopmentStorageDbDataContext.EncodeDataString(value); } else { this.Parameters[num1].Value = DevelopmentStorageDbDataContext.EncodeKeyString(value); } } } } this.PartialClause.Append(")"); this.m_needsClosing.Pop(); if ((b.NodeType == ExpressionType.GreaterThan || b.NodeType == ExpressionType.GreaterThanOrEqual || b.NodeType == ExpressionType.LessThan || b.NodeType == ExpressionType.LessThanOrEqual || b.NodeType == ExpressionType.Equal || b.NodeType == ExpressionType.NotEqual) && num < 1) { CultureInfo invariantCulture = CultureInfo.InvariantCulture; object[] mLinqExpression = new object[] { this.m_linqExpression }; throw new NotSupportedException(string.Format(invariantCulture, "Query filter '{0}' not supported. A constant should be provided in a binary expression.", mLinqExpression)); } return(b); }
private string GetSqlQueryExpressionOperator(ExpressionType nodeType) { this.pointQueryTracker.AddOperator(nodeType); return(ExpressionUtility.GetSqlQueryExpressionOperator(nodeType)); }
protected override Expression VisitBinary(BinaryExpression b) { int num = 0; this.SqlQuery.Append("( "); ExpressionType nodeType = b.NodeType; switch (nodeType) { case ExpressionType.And: case ExpressionType.AndAlso: { Label0: this.m_needsClosing.Push(true); break; } default: { switch (nodeType) { case ExpressionType.Or: case ExpressionType.OrElse: { goto Label0; } default: { this.m_needsClosing.Push(false); break; } } break; } } bool methodCall = ExpressionUtility.IsCompareToMethodCall(b.Left); if (!methodCall) { if (!this.m_needsClosing.Peek()) { ExpressionUtility.ValidateIsSimpleExpression(b.Left); } this.Visit(b.Left); } else { Expression item = ((MethodCallExpression)b.Left).Arguments[0]; ExpressionUtility.ValidateIsSimpleExpression(item); this.Visit(item); } if (b.Left is ConstantExpression || b.Left.NodeType == ExpressionType.Convert) { num++; } this.SqlQuery.AppendFormat(" {0} ", this.GetSqlQueryExpressionOperator(b.NodeType)); if (!methodCall) { this.Visit(b.Right); } else { this.Visit(((MethodCallExpression)b.Left).Arguments[1]); } if (b.Right is ConstantExpression || b.Right.NodeType == ExpressionType.Convert) { num++; } this.SqlQuery.Append(")"); this.m_needsClosing.Pop(); if ((b.NodeType == ExpressionType.GreaterThan || b.NodeType == ExpressionType.GreaterThanOrEqual || b.NodeType == ExpressionType.LessThan || b.NodeType == ExpressionType.LessThanOrEqual || b.NodeType == ExpressionType.Equal || b.NodeType == ExpressionType.NotEqual) && num < 1) { CultureInfo invariantCulture = CultureInfo.InvariantCulture; object[] mLinqExpression = new object[] { this.m_linqExpression }; throw new NotSupportedException(string.Format(invariantCulture, "Query filter '{0}' not supported. A constant should be provided in a binary expression.", mLinqExpression)); } return(b); }