sqlalchemy.orm.subqueryload_all - python examples

Here are the examples of the python api sqlalchemy.orm.subqueryload_all taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

8 Examples 7

3 View Complete Implementation : build_bundlestats.py
Copyright Apache License 2.0
Author : getsentry
    def get(self, build: Build):
        """
        Return bundle stats for a given build.
        """
        job_ids = db.session.query(Job.id).filter(Job.build_id == build.id).subquery()

        query = (
            Bundle.query.filter(Bundle.job_id.in_(job_ids))
            .options(subqueryload_all(Bundle.astets))
            .order_by(Bundle.name.asc())
        )

        return self.paginate_with_schema(bundle_schema, query)

3 View Complete Implementation : build_jobs.py
Copyright Apache License 2.0
Author : getsentry
    def get(self, build: Build):
        """
        Return a list of jobs for a given build.
        """
        query = (
            Job.query.options(subqueryload_all("stats"), subqueryload_all("failures"))
            .filter(Job.build_id == build.id)
            .order_by(Job.number.asc())
        )
        return self.respond_with_schema(jobs_schema, query)

3 View Complete Implementation : revision_jobs.py
Copyright Apache License 2.0
Author : getsentry
    def get(self, revision: Revision):
        """
        Return a list of jobs for a given revision.
        """
        build = fetch_build_for_revision(revision)
        if not build:
            return self.respond(status=404)

        build_ids = [original.id for original in build.original]
        query = (
            Job.query.options(subqueryload_all("stats"), subqueryload_all("failures"))
            .filter(Job.build_id.in_(build_ids))
            .order_by(Job.number.asc())
        )
        return self.respond_with_schema(jobs_schema, query)

0 View Complete Implementation : build_index.py
Copyright Apache License 2.0
Author : getsentry
    def get(self):
        """
        Return a list of builds.
        """
        # tenants automatically restrict this query but we dont want
        # to include public repos
        tenant = auth.get_current_tenant()
        if not tenant.repository_ids:
            return self.respond([])

        query = (
            Build.query.options(
                joinedload("repository"),
                joinedload("revision"),
                joinedload("revision").joinedload("author"),
                subqueryload_all("stats"),
            )
            .filter(Build.repository_id.in_(tenant.repository_ids))
            .order_by(Build.date_created.desc())
        )
        user = request.args.get("user")
        if user:
            if user == "me":
                user = auth.get_current_user()
            else:
                user = User.query.get(user)
            if not user:
                return self.respond([])

            query = query.filter(
                Build.author_id.in_(
                    db.session.query(Author.id).filter(
                        Author.email.in_(
                            db.session.query(Email.email).filter(
                                Email.user_id == user.id, Email.verified == True  # NOQA
                            )
                        )
                    )
                )
            )
        repository = request.args.get("repository")
        if repository:
            repo = Repository.from_full_name(repository)
            if not repo:
                return self.respond([])
            query = query.filter(Build.repository_id == repo.id)
        return self.paginate_with_schema(builds_schema, query)

0 View Complete Implementation : repository_builds.py
Copyright Apache License 2.0
Author : getsentry
    def get(self, repo: Repository):
        """
        Return a list of builds for the given repository.
        """
        user = auth.get_current_user()

        query = (
            Build.query.options(
                joinedload("revision"),
                joinedload("revision").joinedload("author"),
                subqueryload_all("stats"),
            )
            .filter(Build.repository_id == repo.id)
            .order_by(Build.number.desc())
        )
        show = request.args.get("show")
        if show == "mine":
            query = query.filter(
                Revision.author_id.in_(
                    db.session.query(Author.id).filter(
                        Author.email.in_(
                            db.session.query(Email.email).filter(
                                Email.user_id == user.id, Email.verified == True  # NOQA
                            )
                        )
                    )
                )
            )

        return self.paginate_with_schema(builds_schema, query)

0 View Complete Implementation : revision_bundlestats.py
Copyright Apache License 2.0
Author : getsentry
    def get(self, revision: Revision):
        """
        Return bundle stats for a given revision.
        """
        build = fetch_build_for_revision(revision)
        if not build:
            return self.respond(status=404)

        build_ids = [original.id for original in build.original]

        job_ids = (
            db.session.query(Job.id).filter(Job.build_id.in_(build_ids)).subquery()
        )

        query = (
            Bundle.query.filter(Bundle.job_id.in_(job_ids))
            .options(subqueryload_all(Bundle.astets))
            .order_by(Bundle.name.asc())
        )

        return self.paginate_with_schema(bundle_schema, query)

0 View Complete Implementation : repository.py
Copyright Apache License 2.0
Author : getsentry
def get_latest_builds(repo_list: List[Repository], result: Result):
    # TODO(dcramer): this should find the 'last build in [default branch]'
    if not repo_list:
        return {}

    build_query = (
        db.session.query(Build.id)
        .filter(Build.status == Status.finished, Build.result == result)
        .order_by(Build.date_created.desc())
    )

    build_map = dict(
        db.session.query(
            Repository.id,
            build_query.filter(Build.repository_id == Repository.id)
            .limit(1)
            .as_scalar(),
        ).filter(Repository.id.in_(r.id for r in repo_list))
    )

    if not build_map:
        return {}

    return {
        b.repository_id: b
        for b in Build.query.unrestricted_unsafe()
        .filter(Build.id.in_(build_map.values()))
        .options(
            joinedload("revision"),
            joinedload("revision").joinedload("author"),
            subqueryload_all("stats"),
        )
    }

0 View Complete Implementation : builds.py
Copyright Apache License 2.0
Author : getsentry
def fetch_builds_for_revisions(
    revisions: List[Revision], with_relations=True
) -> Mapping[str, Build]:
    # we query extra builds here, but its a lot easier than trying to get
    # sqlalchemy to do a ``select (subquery)`` clause and maintain tenant
    # constraints
    if not revisions:
        return {}

    lookups = []
    for revision in revisions:
        lookups.append(
            and_(
                Build.repository_id == revision.repository_id,
                Build.revision_sha == revision.sha,
            )
        )

    base_qs = Build.query
    if with_relations:
        base_qs = base_qs.options(
            joinedload("revision"),
            joinedload("revision").joinedload("author"),
            joinedload("author"),
            subqueryload_all("stats"),
        )

    builds = list(
        (base_qs.filter(reduce(or_, lookups)).order_by(Build.revision_sha))  # NOQA
    )
    build_groups = groupby(
        builds, lambda build: (build.repository_id, build.revision_sha)
    )
    required_hook_ids = set()
    for build in builds:
        required_hook_ids.update(build.data.get("required_hook_ids") or ())
    return [
        (
            ident,
            merge_build_group(
                list(group), required_hook_ids, with_relations=with_relations
            ),
        )
        for ident, group in build_groups
    ]