Esempio n. 1
0
        public static string Build(EntityMetadata entityMetadata, SearchRequestDto dto = null)
        {
            var buffer = new StringBuilder();

            buffer.AppendFormat("from {0} ", BaseQueryUtil.AliasEntity(entityMetadata.Name, entityMetadata.Name));
            IEnumerable <EntityAssociation> usedAssociations;
            var fieldsToIncludeInRelationship = new List <string>();

            if (dto != null)
            {
                fieldsToIncludeInRelationship = dto.GetNestedFieldsToConsiderInRelationships;
            }
            if (fieldsToIncludeInRelationship.Any())
            {
                //as we have a filter, let´s give a chance to use collection relationships, as they might be filtered
                usedAssociations = entityMetadata.Associations;
                usedAssociations = FilterByProjectionAndRestrictions(usedAssociations, fieldsToIncludeInRelationship);
            }
            else
            {
                usedAssociations = entityMetadata.NonListAssociations();
            }

            foreach (var association in usedAssociations)
            {
                buffer.Append(QueryJoinBuilder.Build(entityMetadata, association));
            }

            if (dto != null && dto.ExtraLeftJoinSection != null)
            {
                buffer.Append(dto.ExtraLeftJoinSection);
            }

            return(buffer.ToString());
        }
Esempio n. 2
0
        private static string AliasAttribute(EntityMetadata entityMetadata, string alias, EntityAttribute attribute, string context)
        {
            var contextToUse = context ?? entityMetadata.Name;
            var query        = attribute.GetQueryReplacingMarkers(contextToUse);

            query = BaseQueryUtil.EvaluateServiceQuery(query);
            return(string.Format("{0} as {1}", query, alias));
        }
Esempio n. 3
0
        private static string AliasAttribute(EntityMetadata entityMetadata, EntityAttribute attribute)
        {
            var qualifiedName = BaseQueryUtil.QualifyAttribute(entityMetadata, attribute);
            var alias         = string.Format("{0}{1}{0}", AliasDelimiter, attribute.Name);

            if (attribute.Query != null)
            {
                return(AliasAttribute(entityMetadata, alias, attribute, null));
            }
            return(string.Format("{0} as {1}", qualifiedName, alias));
        }
Esempio n. 4
0
        public static string Build(EntityMetadata entityMetadata, EntityAssociation association)
        {
            var sb = new StringBuilder();

            sb.AppendFormat("left join {0} on (", BaseQueryUtil.AliasEntity(association.To, association.Qualifier));

            var attributes = association.Attributes as IList <EntityAssociationAttribute>
                             ?? association.Attributes.ToList();

            for (var i = 0; i < attributes.Count; i++)
            {
                var suffix    = (i < attributes.Count - 1) ? " and " : ")";
                var attribute = attributes[i];

                if (null != attribute.Query)
                {
                    var query = attribute.GetQueryReplacingMarkers(association.Qualifier);
                    query = BaseQueryUtil.EvaluateServiceQuery(query);
                    sb.Append(query + suffix);
                }
                else if (null != attribute.From)
                {
                    var entityNameToUse = association.EntityName ?? entityMetadata.Name;
                    var from            = Parse(entityNameToUse, attribute.From);
                    var to = attribute.To != null?Parse(association.Qualifier, attribute.To) : ParseLiteral(attribute);

                    sb.AppendFormat("{0} = {1}" + suffix, from, to);
                }
                else
                {
                    var value = ParseLiteral(attribute);
                    sb.AppendFormat("{0}.{1} = {2}" + suffix, association.Qualifier, attribute.To, value);
                }
            }
            return(sb.ToString());
        }