private static IEnumerable <MemberMetadataResult> GetAllResults(MemberMetadataResult result)
 {
     if (result.ChildrenResults.Count == 0)
     {
         yield return(result);
     }
     else
     {
         foreach (var childResult in result.ChildrenResults)
         {
             foreach (var childChildrenResult in GetAllResults(childResult))
             {
                 yield return(childChildrenResult);
             }
         }
     }
 }
            private static bool TryGetAllMemberMetadata(
                Expression expression,
                Stack <MemberMetadata> memberPaths,
                System.Type convertType,
                bool hasIndexer,
                out MemberMetadataResult results)
            {
                var extractor = new MemberMetadataExtractor(memberPaths, convertType, hasIndexer);

                extractor.Accept(expression);
                results = extractor._entityName != null || extractor._childrenResults.Count > 0
                                        ? new MemberMetadataResult(
                    extractor._childrenResults,
                    extractor._memberPaths,
                    extractor._entityName,
                    extractor._convertType)
                                        : null;

                return(results != null);
            }
        private static bool ProcessMembersMetadataResult(
            MemberMetadataResult metadataResult,
            ISessionFactoryImplementor sessionFactory,
            out IType mappedType,
            out IEntityPersister entityPersister,
            out IAbstractComponentType component,
            out string memberPath)
        {
            if (!TryGetEntityPersister(metadataResult.EntityName, null, sessionFactory, out var currentEntityPersister))
            {
                // Failed to find the starting entity name, due to:
                // - Querying a type that is not related to any entity e.g. s.Query<NotRelatedType>().Where(a => a.Type == "A")
                memberPath      = null;
                mappedType      = null;
                entityPersister = null;
                component       = null;
                return(false);
            }

            if (metadataResult.MemberPaths.Count == 0)             // The expression do not contain any member expressions
            {
                if (metadataResult.ConvertType != null)
                {
                    mappedType = TryGetEntityPersister(
                        currentEntityPersister,
                        metadataResult.ConvertType,
                        sessionFactory,
                        out var convertPersister)
                                                ? convertPersister.EntityMetamodel.EntityType                // ((Subclass)q)
                                                : TypeFactory.GetDefaultTypeFor(metadataResult.ConvertType); // ((NotMapped)q)
                }
                else
                {
                    mappedType = currentEntityPersister.EntityMetamodel.EntityType;                     // q
                }

                memberPath      = null;
                component       = null;
                entityPersister = currentEntityPersister;
                return(mappedType != null);
            }

            // If there was a cast right after the constant expression that contains the IEntityNameProvider instance, we have
            // to update the entity persister according to it, otherwise use the value returned by TryGetAllMemberMetadata method.
            if (metadataResult.ConvertType != null)
            {
                if (!TryGetEntityPersister(
                        currentEntityPersister,
                        metadataResult.ConvertType,
                        sessionFactory,
                        out var convertPersister))                 // ((NotMapped)q).Id
                {
                    memberPath      = null;
                    mappedType      = null;
                    entityPersister = null;
                    component       = null;
                    return(false);
                }

                currentEntityPersister = convertPersister;                 // ((Subclass)q).Id
            }

            return(TraverseMembers(
                       sessionFactory,
                       metadataResult.MemberPaths,
                       currentEntityPersister,
                       out mappedType,
                       out entityPersister,
                       out component,
                       out memberPath));
        }