Example #1
0
        private void AddChildStatements(IComplexCommandBuilder parentBuilder, EntityInfo entityInfo, IFilter filter)
        {
            foreach (var childInfo in entityInfo.Children)
            {
                var childBuilder = new ComplexCommandBuilder(childInfo.Name, childInfo.Type);
                childBuilder.AddStatement(new SelectStatement(childInfo, filter));
                foreach (var parameter in filter.Parameters)
                {
                    childBuilder.AddParameter(parameter);
                    //logger.Debug("  parameter name=" + parameter.Name + "value=" + parameter.Value.ToString());
                }

                parentBuilder.AddChild(childBuilder);

                AddChildStatements(childBuilder, childInfo, filter);
            }

            foreach (var valueInfo in entityInfo.Values)
            {
                var valueBuilder = new ComplexCommandBuilder(valueInfo.Name, valueInfo.Type);
                valueBuilder.AddStatement(new SelectStatement(valueInfo, filter));
                foreach (var parameter in filter.Parameters)
                {
                    valueBuilder.AddParameter(parameter);
                    //logger.Debug("  parameter name=" + parameter.Name + "value=" + parameter.Value.ToString());
                }

                parentBuilder.AddChild(valueBuilder);
            }
        }
        private void AddChildStatements(IComplexCommandBuilder parentBuilder, EntityInfo entityInfo)
        {
            foreach (var childInfo in entityInfo.Children)
            {
                var childBuilder = new ComplexCommandBuilder(childInfo.Name, childInfo.Type);
                childBuilder.AddStatement(new SelectStatement(childInfo, rootName, rootIdAlias));

                parentBuilder.AddChild(childBuilder);

                AddChildStatements(childBuilder, childInfo);
            }

            foreach (var valueInfo in entityInfo.Values)
            {
                var valueBuilder = new ComplexCommandBuilder(valueInfo.Name, valueInfo.Type);
                valueBuilder.AddStatement(new SelectStatement(valueInfo, rootName, rootIdAlias));

                parentBuilder.AddChild(valueBuilder);
            }
        }
Example #3
0
        private void AddChildren(IDbConnection connection, IComplexCommandBuilder parentBuilder, IEnumerable <IEntity> parents)
        {
            //logger.Info("  Query.AddChildren");
            foreach (var childBuilder in parentBuilder.Children)
            {
                if (childBuilder.Type == null)
                {
                    continue;
                }

                var isChildType = childBuilder.Type.IsChildType();

                var children    = new Dictionary <Guid, IList <IChild> >();
                var values      = new Dictionary <Guid, IList <IValue> >();
                var allChildren = new List <IEntity>();

                using (var command = childBuilder.GetCommand(connection))
                {
                    //logger.Debug("    " + command.CommandText.Trim());
                    using (var reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            if (isChildType)
                            {
                                var child = factory.CreateChild(childBuilder.Type, reader);

                                if (!children.ContainsKey(child.Parent))
                                {
                                    children.Add(child.Parent, new List <IChild>());
                                }

                                children[child.Parent].Add(child);
                                allChildren.Add(child);
                            }
                            else
                            {
                                var value = factory.CreateValue(childBuilder.Type, reader);

                                if (!values.ContainsKey(value.Parent))
                                {
                                    values.Add(value.Parent, new List <IValue>());
                                }

                                values[value.Parent].Add(value);
                            }
                        }
                    }
                }

                if (isChildType)
                {
                    foreach (var parent in parents)
                    {
                        if (children.ContainsKey(parent.Id))
                        {
                            var theseChildren = children[parent.Id];
                            parent.InitializeChildren(childBuilder.Name, theseChildren);
                        }
                    }

                    AddChildren(connection, childBuilder, allChildren);
                }
                else
                {
                    foreach (var parent in parents)
                    {
                        if (values.ContainsKey(parent.Id))
                        {
                            var theseValues = values[parent.Id];
                            parent.InitializeValues(childBuilder.Name, theseValues);
                        }
                    }
                }
            }
        }
Example #4
0
 public void Add(IComplexCommandBuilder builder)
 {
     builders.Add(builder);
 }
 public void AddChild(IComplexCommandBuilder child)
 {
     children.Add(child);
 }
Example #6
0
 public void Add(IComplexCommandBuilder builder)
 {
     builders.Add(builder);
 }
Example #7
0
 public void AddChild(IComplexCommandBuilder child)
 {
     children.Add(child);
 }