public int ExecuteNonQuery(ActionContext context)
        {
            ITable table = null;

            Expression expr = DbCommandActionHelper.GetEnumeratorExpression(this.commandTree.Predicate, this.commandTree, context.DbContainer, out table);
            IQueryable entitiesToDelete = DatabaseReflectionHelper.CreateTableQuery(expr, context.DbContainer.Internal);

            return DatabaseReflectionHelper.DeleteEntities(entitiesToDelete, context.Transaction);
        }
        public DbDataReader ExecuteDataReader(ActionContext context)
        {
            // Find returning fields
            FieldDescription[] returningFields = DbCommandActionHelper.GetReturningFields(this.commandTree.Returning);
            List<IDictionary<string, object>> returningValues = new List<IDictionary<string, object>>();

            // Find NMemory table
            ITable table = DbCommandActionHelper.GetTable(this.commandTree, context.DbContainer);

            // Collect the SetClause DbExpressions into a dictionary
            IDictionary<string, DbExpression> setClauses = DbCommandActionHelper.GetSetClauseExpressions(this.commandTree.SetClauses);

            // Collection for collection member bindings
            IList<MemberBinding> memberBindings = new List<MemberBinding>();
            TransformVisitor transform = new TransformVisitor(context.DbContainer.TypeConverter);

            // Initialize member bindings
            foreach (PropertyInfo property in table.EntityType.GetProperties())
            {
                Expression setter = null;

                // Check if member has set clause
                if (setClauses.ContainsKey(property.Name))
                {
                    setter = transform.Visit(setClauses[property.Name]);
                }

                // If setter was found, insert it
                if (setter != null)
                {
                    // Type correction
                    setter = ExpressionHelper.CorrectType(setter, property.PropertyType);

                    // Register binding
                    memberBindings.Add(Expression.Bind(property, setter));
                }
            }

            object entity = CreateAndInsertEntity(table, memberBindings, context.Transaction);

            Dictionary<string, object> entityReturningValues = DbCommandActionHelper.CreateReturningEntity(context, returningFields, entity);
            returningValues.Add(entityReturningValues);

            return new EffortDataReader(
                returningValues.ToArray(),
                1,
                returningFields,
                context.DbContainer);
        }
        public DbDataReader ExecuteDataReader(ActionContext context)
        {
            TransformVisitor visitor = new TransformVisitor(context.DbContainer.TypeConverter);
            visitor.TableProvider = context.DbContainer;

            // Transform command tree
            Expression queryExpression =
                visitor.Visit(this.commandTree.Query);

            LambdaExpression query =
                Expression.Lambda(queryExpression, Expression.Parameter(typeof(IDatabase)));

            // Create a stored procedure from the expression
            ISharedStoredProcedure procedure =
                DatabaseReflectionHelper.CreateSharedStoredProcedure(query);

            // Format the parameter values
            IDictionary<string, object> parameters =
                DbCommandActionHelper.FormatParameters(
                    context.Parameters,
                    procedure.Parameters,
                    context.DbContainer.TypeConverter);

            IEnumerable result = null;

            if (context.Transaction != null)
            {
                result = procedure.Execute(
                    context.DbContainer.Internal,
                    parameters,
                    context.Transaction);
            }
            else
            {
                result = procedure.Execute(
                    context.DbContainer.Internal,
                    parameters);
            }

            List<FieldDescription> fields = GetReturningFields(this.commandTree);

            return new EffortDataReader(
                result,
                -1,
                fields.ToArray(),
                context.DbContainer);
        }
        public static Dictionary<string, object> CreateReturningEntity(
            ActionContext context,
            FieldDescription[] returningFields,
            object entity)
        {
            Dictionary<string, object> entityReturningValues = new Dictionary<string, object>();

            for (int i = 0; i < returningFields.Length; i++)
            {
                string property = returningFields[i].Name;

                object value = entity.GetType().GetProperty(property).GetValue(entity, null);

                entityReturningValues[property] = context
                    .DbContainer
                    .TypeConverter
                    .ConvertClrObject(value, returningFields[i].Type);
            }

            return entityReturningValues;
        }
        public DbDataReader ExecuteDataReader(ActionContext context)
        {
            FieldDescription[] returningFields = DbCommandActionHelper.GetReturningFields(this.commandTree.Returning);
            IList<IDictionary<string, object>> returningEntities = new List<IDictionary<string, object>>();

            ITable table = null;

            Expression expr = DbCommandActionHelper.GetEnumeratorExpression(this.commandTree.Predicate, this.commandTree, context.DbContainer, out table);
            IQueryable entitiesToUpdate = DatabaseReflectionHelper.CreateTableQuery(expr, context.DbContainer.Internal);

            Type type = TypeHelper.GetElementType(table.GetType());

            // Collect the SetClause DbExpressions into a dictionary
            IDictionary<string, DbExpression> setClauses = DbCommandActionHelper.GetSetClauseExpressions(this.commandTree.SetClauses);

            // Collection for collection member bindings
            IList<MemberBinding> memberBindings = new List<MemberBinding>();

            TransformVisitor transform = new TransformVisitor(context.DbContainer.TypeConverter);

            // Setup context for the predicate
            ParameterExpression param = Expression.Parameter(type, "context");
            using (transform.CreateVariable(param, this.commandTree.Target.VariableName))
            {
                // Initialize member bindings
                foreach (PropertyInfo property in type.GetProperties())
                {
                    Expression setter = null;

                    // Check if member has set clause
                    if (setClauses.ContainsKey(property.Name))
                    {
                        setter = transform.Visit(setClauses[property.Name]);
                    }

                    // If setter was found, insert it
                    if (setter != null)
                    {
                        // Type correction
                        setter = ExpressionHelper.CorrectType(setter, property.PropertyType);

                        memberBindings.Add(Expression.Bind(property, setter));
                    }
                }
            }

            Expression updater =
                Expression.Lambda(
                    Expression.MemberInit(Expression.New(type), memberBindings),
                    param);

            IEnumerable<object> updatedEntities = DatabaseReflectionHelper.UpdateEntities(entitiesToUpdate, updater, context.Transaction);
            int affectedRecords = 0;

            foreach (object entity in updatedEntities)
            {
                affectedRecords++;
                Dictionary<string, object> returningEntity = 
                    DbCommandActionHelper.CreateReturningEntity(context, returningFields, entity);

                returningEntities.Add(returningEntity);
            }

            return new EffortDataReader(
                returningEntities,
                affectedRecords,
                returningFields, 
                context.DbContainer);
        }
 public object ExecuteScalar(ActionContext context)
 {
     throw new NotSupportedException();
 }
Exemple #7
0
        private ActionContext CreateActionContext()
        {
            ActionContext context = new ActionContext(this.EffortConnection.DbContainer);

            // Store parameters in the context
            foreach (DbParameter parameter in this.Parameters)
            {
                string name = parameter.ParameterName;
                object value = parameter.Value;

                if (value != null)
                {
                    Type originalType = value.GetType();

                    // Resolve enum types
                    if (originalType.IsEnum)
                    {
                        Type primitive = Enum.GetUnderlyingType(originalType);
                        value = Convert.ChangeType(value, primitive);
                    }
                }

                CommandActionParameter commandActionParameter =
                    new CommandActionParameter(name, value);

                context.Parameters.Add(commandActionParameter);
            }

            if (this.EffortTransaction != null)
            {
                context.Transaction = this.EffortTransaction.InternalTransaction;
            }

            return context;
        }
 public int ExecuteNonQuery(ActionContext context)
 {
     throw new NotSupportedException();
 }
        public int ExecuteNonQuery(ActionContext context)
        {
            // Get the source table
            ITable table = DbCommandActionHelper.GetTable(this.commandTree, context.DbContainer);

            // Collect the SetClause DbExpressions into a dictionary
            IDictionary<string, DbExpression> setClauses =
                DbCommandActionHelper.GetSetClauseExpressions(this.commandTree.SetClauses);

            // Collection for collection member bindings
            IList<MemberBinding> memberBindings = new List<MemberBinding>();
            TransformVisitor transform = new TransformVisitor(context.DbContainer.TypeConverter);

            // Initialize member bindings
            foreach (PropertyInfo property in table.EntityType.GetProperties())
            {
                Expression setter = null;

                // Check if member has set clause
                if (setClauses.ContainsKey(property.Name))
                {
                    setter = transform.Visit(setClauses[property.Name]);
                }

                // If setter was found, insert it
                if (setter != null)
                {
                    // Type correction
                    setter = ExpressionHelper.CorrectType(setter, property.PropertyType);

                    // Register binding
                    memberBindings.Add(Expression.Bind(property, setter));
                }
            }

            CreateAndInsertEntity(table, memberBindings, context.Transaction);

            return 1;
        }
 public DbDataReader ExecuteDataReader(ActionContext context)
 {
     throw new NotSupportedException();
 }