private DbExpressionBinding VisitExpressionBindingEnterScope(DbExpressionBinding binding)
        {
            var result = VisitExpressionBinding(binding);

            OnEnterScope(new[] { result.Variable });
            return(result);
        }
        internal DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate)
            : base(metadata, dataSpace, target)
        {
            Contract.Requires(predicate != null);

            _predicate = predicate;
        }
        internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target)
            : base(metadata, dataSpace)
        {
            DebugCheck.NotNull(target);

            _target = target;
        }
        internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target)
            : base(metadata, dataSpace)
        {
            Contract.Requires(target != null);

            _target = target;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="DbDeleteCommandTree"/> class.
        /// </summary>
        /// <param name="metadata">The model this command will operate on.</param>
        /// <param name="dataSpace">The data space.</param>
        /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
        /// <param name="predicate">A predicate used to determine which members of the target collection should be deleted.</param>
        public DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(predicate);

            _predicate = predicate;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="DbDeleteCommandTree"/> class.
        /// </summary>
        /// <param name="metadata">The model this command will operate on.</param>
        /// <param name="dataSpace">The data space.</param>
        /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
        /// <param name="predicate">A predicate used to determine which members of the target collection should be deleted.</param>
        public DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(predicate);

            _predicate = predicate;
        }
Beispiel #7
0
        internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target)
            : base(metadata, dataSpace)
        {
            DebugCheck.NotNull(target);

            _target = target;
        }
 internal DbModificationCommandTree(
     MetadataWorkspace metadata,
     DataSpace dataSpace,
     DbExpressionBinding target)
     : base(metadata, dataSpace, true)
 {
     this._target = target;
 }
Beispiel #9
0
 internal DbFilterExpression(
     TypeUsage resultType,
     DbExpressionBinding input,
     DbExpression predicate)
     : base(DbExpressionKind.Filter, resultType, true)
 {
     this._input     = input;
     this._predicate = predicate;
 }
Beispiel #10
0
 internal DbProjectExpression(
     TypeUsage resultType,
     DbExpressionBinding input,
     DbExpression projection)
     : base(DbExpressionKind.Project, resultType, true)
 {
     this._input      = input;
     this._projection = projection;
 }
Beispiel #11
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbDeleteCommandTree" /> class.
 /// </summary>
 /// <param name="metadata">The model this command will operate on.</param>
 /// <param name="dataSpace">The data space.</param>
 /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
 /// <param name="predicate">A predicate used to determine which members of the target collection should be deleted.</param>
 public DbDeleteCommandTree(
     MetadataWorkspace metadata,
     DataSpace dataSpace,
     DbExpressionBinding target,
     DbExpression predicate)
     : base(metadata, dataSpace, target)
 {
     this._predicate = predicate;
 }
 internal DbSortExpression(
     TypeUsage resultType,
     DbExpressionBinding input,
     ReadOnlyCollection <DbSortClause> sortOrder)
     : base(DbExpressionKind.Sort, resultType, true)
 {
     this._input = input;
     this._keys  = sortOrder;
 }
        internal DbProjectExpression(TypeUsage resultType, DbExpressionBinding input, DbExpression projection)
            : base(DbExpressionKind.Project, resultType)
        {
            DebugCheck.NotNull(input);
            DebugCheck.NotNull(projection);

            _input      = input;
            _projection = projection;
        }
 internal DbApplyExpression(
     DbExpressionKind applyKind,
     TypeUsage resultRowCollectionTypeUsage,
     DbExpressionBinding input,
     DbExpressionBinding apply)
     : base(applyKind, resultRowCollectionTypeUsage, true)
 {
     this._input = input;
     this._apply = apply;
 }
        internal DbSortExpression(TypeUsage resultType, DbExpressionBinding input, ReadOnlyCollection <DbSortClause> sortOrder)
            : base(DbExpressionKind.Sort, resultType)
        {
            DebugCheck.NotNull(input);
            DebugCheck.NotNull(sortOrder);
            Debug.Assert(TypeSemantics.IsCollectionType(resultType), "DbSkipExpression requires a collection result type");

            _input = input;
            _keys  = sortOrder;
        }
Beispiel #16
0
 internal DbQuantifierExpression(
     DbExpressionKind kind,
     TypeUsage booleanResultType,
     DbExpressionBinding input,
     DbExpression predicate)
     : base(kind, booleanResultType, true)
 {
     this._input     = input;
     this._predicate = predicate;
 }
Beispiel #17
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbInsertCommandTree" /> class.
 /// </summary>
 /// <param name="metadata">The model this command will operate on.</param>
 /// <param name="dataSpace">The data space.</param>
 /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
 /// <param name="setClauses">The list of insert set clauses that define the insert operation. .</param>
 /// <param name="returning">A <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbExpression" /> that specifies a projection of results to be returned, based on the modified rows.</param>
 public DbInsertCommandTree(
     MetadataWorkspace metadata,
     DataSpace dataSpace,
     DbExpressionBinding target,
     ReadOnlyCollection <DbModificationClause> setClauses,
     DbExpression returning)
     : base(metadata, dataSpace, target)
 {
     this._setClauses = setClauses;
     this._returning  = returning;
 }
 internal DbSkipExpression(
     TypeUsage resultType,
     DbExpressionBinding input,
     ReadOnlyCollection <DbSortClause> sortOrder,
     DbExpression count)
     : base(DbExpressionKind.Skip, resultType, true)
 {
     this._input = input;
     this._keys  = sortOrder;
     this._count = count;
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="DbInsertCommandTree"/> class.
        /// </summary>
        /// <param name="metadata">The model this command will operate on.</param>
        /// <param name="dataSpace">The data space.</param>
        /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
        /// <param name="setClauses">The list of insert set clauses that define the insert operation. .</param>
        /// <param name="returning">A <see cref="DbExpression"/> that specifies a projection of results to be returned, based on the modified rows.</param>
        public DbInsertCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses,
            DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(setClauses);
            // returning may be null

            _setClauses = setClauses;
            _returning = returning;
        }
Beispiel #20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DbInsertCommandTree"/> class.
        /// </summary>
        /// <param name="metadata">The model this command will operate on.</param>
        /// <param name="dataSpace">The data space.</param>
        /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
        /// <param name="setClauses">The list of insert set clauses that define the insert operation. .</param>
        /// <param name="returning">A <see cref="DbExpression"/> that specifies a projection of results to be returned, based on the modified rows.</param>
        public DbInsertCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses,
            DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(setClauses);
            // returning may be null

            _setClauses = setClauses;
            _returning  = returning;
        }
        internal DbInsertCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses,
            DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            Contract.Requires(setClauses != null);
            // returning may be null

            _setClauses = setClauses;
            _returning = returning;
        }
Beispiel #22
0
        internal DbFilterExpression(TypeUsage resultType, DbExpressionBinding input, DbExpression predicate)
            : base(DbExpressionKind.Filter, resultType)
        {
            DebugCheck.NotNull(input);
            DebugCheck.NotNull(predicate);
            Debug.Assert(
                TypeSemantics.IsPrimitiveType(predicate.ResultType, PrimitiveTypeKind.Boolean),
                "DbFilterExpression predicate must have a Boolean result type");

            _input     = input;
            _predicate = predicate;
        }
Beispiel #23
0
 internal DbJoinExpression(
     DbExpressionKind joinKind,
     TypeUsage collectionOfRowResultType,
     DbExpressionBinding left,
     DbExpressionBinding right,
     DbExpression condition)
     : base(joinKind, collectionOfRowResultType, true)
 {
     this._left      = left;
     this._right     = right;
     this._condition = condition;
 }
Beispiel #24
0
        internal DbApplyExpression(
            DbExpressionKind applyKind, TypeUsage resultRowCollectionTypeUsage, DbExpressionBinding input, DbExpressionBinding apply)
            : base(applyKind, resultRowCollectionTypeUsage)
        {
            DebugCheck.NotNull(input);
            DebugCheck.NotNull(apply);
            Debug.Assert(
                DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind,
                "Invalid DbExpressionKind for DbApplyExpression");

            _input = input;
            _apply = apply;
        }
        internal DbUpdateCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate,
            ReadOnlyModificationClauses setClauses, DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(predicate);
            DebugCheck.NotNull(setClauses);
            // returning is allowed to be null

            _predicate = predicate;
            _setClauses = setClauses;
            _returning = returning;
        }
Beispiel #26
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DbUpdateCommandTree"/> class.
        /// </summary>
        /// <param name="metadata">The model this command will operate on.</param>
        /// <param name="dataSpace">The data space.</param>
        /// <param name="target">The target table for the data manipulation language (DML) operation.</param>
        /// <param name="predicate">A predicate used to determine which members of the target collection should be updated.</param>
        /// <param name="setClauses">The list of update set clauses that define the update operation.</param>
        /// <param name="returning">A <see cref="DbExpression"/> that specifies a projection of results to be returned, based on the modified rows.</param>
        public DbUpdateCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate,
            ReadOnlyModificationClauses setClauses, DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            DebugCheck.NotNull(predicate);
            DebugCheck.NotNull(setClauses);
            // returning is allowed to be null

            _predicate  = predicate;
            _setClauses = setClauses;
            _returning  = returning;
        }
        internal DbUpdateCommandTree(
            MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate,
            ReadOnlyModificationClauses setClauses, DbExpression returning)
            : base(metadata, dataSpace, target)
        {
            Contract.Requires(predicate != null);
            Contract.Requires(setClauses != null);
            // returning is allowed to be null

            _predicate = predicate;
            _setClauses = setClauses;
            _returning = returning;
        }
        /// <summary>
        /// Helper method creating the correct filter expression based on the supplied parameters
        /// </summary>
        private DbFilterExpression BuildFilterExpression(DbExpressionBinding binding, string column)
        {
            var variableReference = DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName);
            // Create the property based on the variable in order to apply the equality
            var userProperty = DbExpressionBuilder.Property(variableReference, column);
            // Create the parameter which is an object representation of a sql parameter.
            // We have to create a parameter and not perform a direct comparison with Equal function for example
            // as this logic is cached per query and called only once
            var userParameter = DbExpressionBuilder.Parameter(userProperty.Property.TypeUsage,
                UserAwareAttribute.UserIdFilterParameterName);
            // Apply the equality between property and parameter.
            DbExpression newPredicate = DbExpressionBuilder.Equal(userProperty, userParameter);

            return DbExpressionBuilder.Filter(binding, newPredicate);
        }
        protected virtual DbExpressionBinding VisitExpressionBinding(DbExpressionBinding binding)
        {
            var result = binding;

            if (binding != null)
            {
                var newInput = VisitExpression(binding.Expression);
                if (!ReferenceEquals(binding.Expression, newInput))
                {
                    result = CqtBuilder.BindAs(newInput, binding.VariableName);
                    RebindVariable(binding.Variable, result.Variable);
                }
            }
            return(result);
        }
        internal DbJoinExpression(
            DbExpressionKind joinKind, TypeUsage collectionOfRowResultType, DbExpressionBinding left, DbExpressionBinding right,
            DbExpression condition)
            : base(joinKind, collectionOfRowResultType)
        {
            DebugCheck.NotNull(left);
            DebugCheck.NotNull(right);
            DebugCheck.NotNull(condition);
            Debug.Assert(
                DbExpressionKind.InnerJoin == joinKind ||
                DbExpressionKind.LeftOuterJoin == joinKind ||
                DbExpressionKind.FullOuterJoin == joinKind,
                "Invalid DbExpressionKind specified for DbJoinExpression");

            _left      = left;
            _right     = right;
            _condition = condition;
        }
        /// <summary>
        /// Helper method creating the correct filter expression based on the supplied parameters
        /// </summary>
        private DbFilterExpression BuildFilterExpression(DbExpressionBinding binding, DbExpression predicate, string column)
        {
            _injectedDynamicFilter = true;

            var variableReference = DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName);
            // Create the property based on the variable in order to apply the equality
            var tenantProperty = DbExpressionBuilder.Property(variableReference, column);
            // Create the parameter which is an object representation of a sql parameter.
            // We have to create a parameter and not perform a direct comparison with Equal function for example
            // as this logic is cached per query and called only once
            var tenantParameter = DbExpressionBuilder.Parameter(tenantProperty.Property.TypeUsage,
                TenantAwareAttribute.TenantIdFilterParameterName);
            // Apply the equality between property and parameter.
            DbExpression newPredicate = DbExpressionBuilder.Equal(tenantProperty, tenantParameter);

            // If an existing predicate exists (normally when called from DbFilterExpression) execute a logical AND to get the result
            if (predicate != null)
                newPredicate = newPredicate.And(predicate);

            return DbExpressionBuilder.Filter(binding, newPredicate);
        }
Beispiel #32
0
 // <summary>
 // Marks current scope region as performing group/folding operation.
 // </summary>
 internal void EnterGroupOperation(DbExpressionBinding groupAggregateBinding)
 {
     Debug.Assert(!IsAggregating, "Scope region group operation is not reentrant.");
     _groupAggregateBinding = groupAggregateBinding;
 }
        // Utility translator method for lambda expressions. Given a lambda expression and its translated
        // inputs, translates the lambda expression, assuming the input is a collection
        private DbExpression TranslateLambda(
            LambdaExpression lambda, DbExpression input, string bindingName, out DbExpressionBinding binding)
        {
            input = NormalizeSetSource(input);

            // create binding context for this lambda expression
            binding = input.BindAs(bindingName);

            return TranslateLambda(lambda, binding.Variable);
        }
 internal DbExpression Filter(DbExpressionBinding input, DbExpression predicate)
 {
     var lifter = GetLifter(input.Expression);
     return lifter.Filter(input.Filter(predicate));
 }
 internal DbExpression Project(DbExpressionBinding input, DbExpression projection)
 {
     var lifter = GetLifter(input.Expression);
     return lifter.Project(input.Project(projection));
 }
        private DbFilterExpression BuildFilterExpressionWithDynamicFilters(string entityName, IEnumerable<DynamicFilterDefinition> filterList, DbExpressionBinding binding, DbExpression predicate)
        {
            if (!filterList.Any())
                return null;

            var edmType = binding.VariableType.EdmType as EntityType;
            if (edmType == null)
                return null;

            List<DbExpression> conditionList = new List<DbExpression>();

            HashSet<string> processedFilterNames = new HashSet<string>(); 
            foreach (var filter in filterList)
            {
                if (processedFilterNames.Contains(filter.FilterName))
                    continue;       //  Already processed this filter - attribute was probably inherited in a base class
                processedFilterNames.Add(filter.FilterName);

                DbExpression dbExpression;
                if (!string.IsNullOrEmpty(filter.ColumnName))
                {
                    //  Single column equality filter
                    //  Need to map through the EdmType properties to find the actual database/cspace name for the entity property.
                    //  It may be different from the entity property!
                    var edmProp = edmType.Properties.Where(p => p.MetadataProperties.Any(m => m.Name == "PreferredName" && m.Value.Equals(filter.ColumnName))).FirstOrDefault();
                    if (edmProp == null)
                        continue;       //  ???
                    //  database column name is now in edmProp.Name.  Use that instead of filter.ColumnName

                    var columnProperty = DbExpressionBuilder.Property(DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName), edmProp.Name);
                    var param = columnProperty.Property.TypeUsage.Parameter(filter.CreateDynamicFilterName(filter.ColumnName));

                    if ((columnProperty.ResultType.EdmType.FullName == "Edm.Boolean") 
                        && param.ResultType.EdmType.FullName.StartsWith("Oracle", StringComparison.CurrentCultureIgnoreCase) && (param.ResultType.EdmType.Name == "number"))    //  Don't trust Oracle's type name to stay the same...
                    {
                        //  Special handling needed for columnProperty boolean.  For some reason, the Oracle EF driver does not correctly
                        //  set the ResultType to a number(1) in columnProperty like it does in columnProperty.Property.TypeUsage.  That
                        //  results in us trying to do a comparison of a Boolean to a number(1) which causes DbExpressionBuilder.Equal
                        //  to throw an exception.  To get this to process correctly, we need to do a cast on the columnProperty to
                        //  "number(1)" so that it matches the param.ResultType.  And that results in the sql sent to Oracle converting
                        //  the column to the type that it already is...
                        dbExpression = DbExpressionBuilder.Equal(DbExpressionBuilder.CastTo(columnProperty, param.ResultType), param);
                    }
                    else
                        dbExpression = DbExpressionBuilder.Equal(columnProperty, param);
                }
                else if (filter.Predicate != null)
                {
                    //  Lambda expression filter
                    dbExpression = LambdaToDbExpressionVisitor.Convert(filter, binding, _ObjectContext);
                }
                else
                    throw new System.ArgumentException(string.Format("Filter {0} does not contain a ColumnName or a Predicate!", filter.FilterName));

                //  Create an expression to check to see if the filter has been disabled and include that check with the rest of the filter expression.
                //  When this parameter is null, the filter is enabled.  It will be set to true (in DynamicFilterExtensions.GetFilterParameterValue) if
                //  the filter has been disabled.
                var boolPrimitiveType = LambdaToDbExpressionVisitor.TypeUsageForPrimitiveType(typeof(bool?), _ObjectContext);
                var isDisabledParam = boolPrimitiveType.Parameter(filter.CreateFilterDisabledParameterName());

                conditionList.Add(DbExpressionBuilder.Or(dbExpression, DbExpressionBuilder.Not(DbExpressionBuilder.IsNull(isDisabledParam))));
            }

            int numConditions = conditionList.Count;
            DbExpression newPredicate; 
            switch (numConditions)
            {
                case 0:
                    return null;

                case 1:
                    newPredicate = conditionList.First();
                    break;

                default:
                    //  Have multiple conditions.  Need to append them together using 'and' conditions.
                    newPredicate = conditionList.First();

                    for (int i = 1; i < numConditions; i++)
                        newPredicate = newPredicate.And(conditionList[i]);
                    break;
            }

            //  'and' the existing Predicate if there is one
            if (predicate != null)
                newPredicate = newPredicate.And(predicate);

            return DbExpressionBuilder.Filter(binding, newPredicate);
        }
 internal DbExpression Skip(DbExpressionBinding input, DbExpression skipCount)
 {
     var lifter = GetLifter(input.Expression);
     return lifter.Skip(skipCount);
 }
 public BindingNormalizer(DbExpressionBinding binding)
 {
     _binding = binding;
 }
 /// <summary>
 /// Convenience method to visit the specified <see cref="DbExpressionBinding"/>.
 /// </summary>
 /// <param name="binding">The DbExpressionBinding to visit.</param>
 /// <exception cref="ArgumentNullException"><paramref name="binding"/> is null</exception>
 protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
 {
     ADP1.CheckArgumentNull(binding, "binding");
     VisitExpression(binding.Expression);
 }
 /// <summary>
 ///     Convenience method to visit the specified <see cref="DbExpressionBinding" />.
 /// </summary>
 /// <param name="binding"> The DbExpressionBinding to visit. </param>
 /// <exception cref="ArgumentNullException">
 ///     <paramref name="binding" />
 ///     is null
 /// </exception>
 protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
 {
     Check.NotNull(binding, "binding");
     VisitExpression(binding.Expression);
 }
    private SqlFragment HandleJoinExpression(DbExpressionBinding left, DbExpressionBinding right,
        DbExpressionKind joinType, DbExpression joinCondition)
    {
      JoinFragment join = new JoinFragment();
      join.JoinType = Metadata.GetOperator(joinType);

      join.Left = VisitInputExpression(left.Expression, left.VariableName, left.VariableType);
      join.Left = WrapJoinInputIfNecessary(join.Left, false);

      join.Right = VisitInputExpression(right.Expression, right.VariableName, right.VariableType);
      join.Right = WrapJoinInputIfNecessary(join.Right, true);

      if (join.Right is SelectStatement)
      {
        SelectStatement select = join.Right as SelectStatement;
        if (select.IsWrapped)
          select.Name = right.VariableName;
      }

      // now handle the ON case
      if (joinCondition != null)
        join.Condition = joinCondition.Accept(this);
      return join;
    }
 private DbExpression Skip(DbExpressionBinding input, DbExpression skipCount)
 {
     var retExpr = _orderByLifter.Skip(input, skipCount);
     ApplySpanMapping(input.Expression, retExpr);
     return retExpr;
 }
 private DbSortExpression Sort(DbExpressionBinding input, IList<DbSortClause> keys)
 {
     var retExpr = input.Sort(keys);
     ApplySpanMapping(input.Expression, retExpr);
     return retExpr;
 }
 private DbExpression Project(DbExpressionBinding input, DbExpression projection)
 {
     var retExpr = _orderByLifter.Project(input, projection);
     // For identity projection only, the Span is preserved
     if (projection.ExpressionKind == DbExpressionKind.VariableReference
         &&
         ((DbVariableReferenceExpression)projection).VariableName.Equals(input.VariableName, StringComparison.Ordinal))
     {
         ApplySpanMapping(input.Expression, retExpr);
     }
     return retExpr;
 }
Beispiel #45
0
 /// <summary>
 /// Convenience method to visit the specified <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbExpressionBinding" />.
 /// </summary>
 /// <param name="binding"> The DbExpressionBinding to visit. </param>
 /// <exception cref="T:System.ArgumentNullException">
 /// <paramref name="binding" />
 /// is null
 /// </exception>
 protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
 {
     Check.NotNull <DbExpressionBinding>(binding, nameof(binding));
     this.VisitExpression(binding.Expression);
 }
Beispiel #46
0
 /// <summary>
 ///     Convenience method for post-processing after a DbExpressionBinding has been visited.
 /// </summary>
 /// <param name="binding"> The previously visited DbExpressionBinding. </param>
 protected virtual void VisitExpressionBindingPost(DbExpressionBinding binding)
 {
 }
 /// <summary>
 ///     Convenience method for post-processing after a DbExpressionBinding has been visited.
 /// </summary>
 /// <param name="binding"> The previously visited DbExpressionBinding. </param>
 protected virtual void VisitExpressionBindingPost(DbExpressionBinding binding)
 {
 }
        // Effects: given a "clause" in the form of a property/value pair, produces an equality expression. If the
        // value is null, creates an IsNull expression
        // Requires: all arguments are set
        private DbExpression GenerateEqualityExpression(DbExpressionBinding target, EdmProperty property, PropagatorResult value)
        {
            DebugCheck.NotNull(target);
            DebugCheck.NotNull(property);
            DebugCheck.NotNull(value);

            var propertyExpression = GeneratePropertyExpression(target, property);
            var valueExpression = GenerateValueExpression(property, value);
            if (valueExpression.ExpressionKind
                == DbExpressionKind.Null)
            {
                return propertyExpression.IsNull();
            }
            return propertyExpression.Equal(valueExpression);
        }
        /// <summary>
        /// Helper method for <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/>
        /// Creates a <see cref="DbProjectExpression"/> over the given inputBinding that projects out the given flattenedProperties.
        /// and updates the flattenedProperties to be over the newly created project.
        /// </summary>
        /// <param name="inputBinding"></param>
        /// <param name="flattenedProperties"></param>
        /// <returns>An <see cref="DbExpressionBinding"/> over the newly created <see cref="DbProjectExpression"/></returns>
        private static DbExpressionBinding CapWithProject(DbExpressionBinding inputBinding, IList<DbPropertyExpression> flattenedProperties)
        {
            var projectColumns = new List<KeyValuePair<string, DbExpression>>(flattenedProperties.Count);

            //List of all the columnNames used in the projection.
            var columnNames = new Dictionary<string, int>(flattenedProperties.Count);

            foreach (var pe in flattenedProperties)
            {
                //There may be conflicting property names, thus we may need to rename.
                var name = pe.Property.Name;
                int i;
                if (columnNames.TryGetValue(name, out i))
                {
                    string newName;
                    do
                    {
                        ++i;
                        newName = name + i.ToString(CultureInfo.InvariantCulture);
                    }
                    while (columnNames.ContainsKey(newName));

                    columnNames[name] = i;
                    name = newName;
                }

                // Add this column name to list of known names so that there are no subsequent
                // collisions
                columnNames[name] = 0;
                projectColumns.Add(new KeyValuePair<string, DbExpression>(name, pe));
            }

            //Build the project
            DbExpression rowExpr = DbExpressionBuilder.NewRow(projectColumns);
            var projectExpression = inputBinding.Project(rowExpr);

            //Create the new inputBinding
            var resultBinding = projectExpression.Bind();

            //Create the list of flattenedProperties over the new project
            flattenedProperties.Clear();
            var rowExprType = (RowType)rowExpr.ResultType.EdmType;

            foreach (var column in projectColumns)
            {
                var prop = rowExprType.Properties[column.Key];
                flattenedProperties.Add(resultBinding.Variable.Property(prop));
            }
            return resultBinding;
        }
        private DbFilterExpression BuildFilterExpressionWithDynamicFilters(string entityName, IEnumerable<DynamicFilterDefinition> filterList, DbExpressionBinding binding, DbExpression predicate)
        {
            if (!filterList.Any())
                return null;

            var edmType = binding.VariableType.EdmType as EntityType;
            if (edmType == null)
                return null;

            List<DbExpression> conditionList = new List<DbExpression>();

            HashSet<string> processedFilterNames = new HashSet<string>(); 
            foreach (var filter in filterList)
            {
                if (processedFilterNames.Contains(filter.FilterName))
                    continue;       //  Already processed this filter - attribute was probably inherited in a base class
                processedFilterNames.Add(filter.FilterName);

                DbExpression dbExpression;
                if (!string.IsNullOrEmpty(filter.ColumnName))
                {
                    //  Single column equality filter
                    //  Need to map through the EdmType properties to find the actual database/cspace name for the entity property.
                    //  It may be different from the entity property!
                    var edmProp = edmType.Properties.Where(p => p.MetadataProperties.Any(m => m.Name == "PreferredName" && m.Value.Equals(filter.ColumnName))).FirstOrDefault();
                    if (edmProp == null)
                        continue;       //  ???
                    //  database column name is now in edmProp.Name.  Use that instead of filter.ColumnName

                    var columnProperty = DbExpressionBuilder.Property(DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName), edmProp.Name);
                    var param = columnProperty.Property.TypeUsage.Parameter(filter.CreateDynamicFilterName(filter.ColumnName));

                    dbExpression = DbExpressionBuilder.Equal(columnProperty, param);
                }
                else if (filter.Predicate != null)
                {
                    //  Lambda expression filter
                    dbExpression = LambdaToDbExpressionVisitor.Convert(filter, binding, _ObjectContext);
                }
                else
                    throw new System.ArgumentException(string.Format("Filter {0} does not contain a ColumnName or a Predicate!", filter.FilterName));

                //  Create an expression to check to see if the filter has been disabled and include that check with the rest of the filter expression.
                //  When this parameter is null, the filter is enabled.  It will be set to true (in DynamicFilterExtensions.GetFilterParameterValue) if
                //  the filter has been disabled.
                var boolPrimitiveType = LambdaToDbExpressionVisitor.TypeUsageForPrimitiveType(typeof(bool?), _ObjectContext);
                var isDisabledParam = boolPrimitiveType.Parameter(filter.CreateFilterDisabledParameterName());

                conditionList.Add(DbExpressionBuilder.Or(dbExpression, DbExpressionBuilder.Not(DbExpressionBuilder.IsNull(isDisabledParam))));
            }

            int numConditions = conditionList.Count;
            DbExpression newPredicate; 
            switch (numConditions)
            {
                case 0:
                    return null;

                case 1:
                    newPredicate = conditionList.First();
                    break;

                default:
                    //  Have multiple conditions.  Need to append them together using 'and' conditions.
                    newPredicate = conditionList.First();

                    for (int i = 1; i < numConditions; i++)
                        newPredicate = newPredicate.And(conditionList[i]);
                    break;
            }

            //  'and' the existing Predicate if there is one
            if (predicate != null)
                newPredicate = newPredicate.And(predicate);

            return DbExpressionBuilder.Filter(binding, newPredicate);
        }
Beispiel #51
0
 /// <summary>
 ///     Convenience method to visit the specified <see cref="DbExpressionBinding" />.
 /// </summary>
 /// <param name="binding"> The DbExpressionBinding to visit. </param>
 /// <exception cref="ArgumentNullException">
 ///     <paramref name="binding" />
 ///     is null
 /// </exception>
 protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
 {
     Check.NotNull(binding, "binding");
     VisitExpression(binding.Expression);
 }
 private DbExpression Filter(DbExpressionBinding input, DbExpression predicate)
 {
     var retExpr = _orderByLifter.Filter(input, predicate);
     ApplySpanMapping(input.Expression, retExpr);
     return retExpr;
 }
 protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
 {
   if (binding == null) throw new ArgumentException("binding");
   VisitExpression(binding.Expression);
 }
        // Effects: given a property, produces a property expression
        // Requires: all arguments are set
        private static DbExpression GeneratePropertyExpression(DbExpressionBinding target, EdmProperty property)
        {
            DebugCheck.NotNull(target);
            DebugCheck.NotNull(property);

            return target.Variable.Property(property);
        }