sqlalchemy.sql_func.count

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

6 Examples 7

Example 1

Project: debsources Source File: query.py
def count_files_checksum(session, checksum, pkg=None, suite=None):
    '''Count files with `checksum`

    '''
    result = (session.query(sql_func.count(Checksum.id))
              .filter(Checksum.sha256 == checksum)
              )
    if pkg is not None and pkg is not "":
        result = (result.filter(PackageName.name == pkg)
                  .filter(Checksum.package_id == Package.id)
                  .filter(Package.name_id == PackageName.id))
    if suite is not None and suite is not "":
        result = (result.filter(Suite.suite == suite)
                  .filter(Suite.package_id == Checksum.package_id))
    return result

Example 2

Project: debsources Source File: statistics.py
def ctags(session, suite=None, areas=None):
    """ctags count

    only count ctags in suite, if given

    only count packages in archive `areas`, if given

    """
    logging.debug('count ctags for suite %s...' % suite)
    q = session.query(sql_func.count(Ctag.id))
    if suite or areas:
        q = q.join(Package)
    if suite:
        q = q.join(Suite) \
             .filter(Suite.suite == suite)
    if areas:
        q = q.filter(Package.area.in_(areas))
    return _count(q)

Example 3

Project: debsources Source File: statistics.py
def source_packages(session, suite=None, areas=None):
    """(versioned) source package count

    only count packages in suite, if given

    only count packages in archive `areas`, if given

    multiple versions of the same source package count adds up to the result of
    this query. When doing per-suite queries that doesn't (shouldn't) happen,
    as each suite is (usually) guaranteed to contain at most one version of
    each packages

    """
    logging.debug('count source packages for suite %s...' % suite)
    q = session.query(sql_func.count(Package.id))
    if suite:
        q = q.join(Suite) \
            .filter(Suite.suite == suite)
    if areas:
        q = q.filter(Package.area.in_(areas))
    return _count(q)

Example 4

Project: debsources Source File: statistics.py
Function: source_files
def source_files(session, suite=None, areas=None):
    """source files count

    only count source files in suite, if given

    only count packages in archive `areas`, if given

    Return 0 if the checksum plugin is not enabled

    """
    # TODO when a separate File table will be present, this will need to be
    # adapted to use that instead of Checksum
    logging.debug('count source files for suite %s...' % suite)
    q = session.query(sql_func.count(Checksum.id))
    if suite or areas:
        q = q.join(Package)
    if suite:
        q = q.join(Suite) \
             .filter(Suite.suite == suite)
    if areas:
        q = q.filter(Package.area.in_(areas))
    return _count(q)

Example 5

Project: debsources Source File: statistics.py
def stats_grouped_by(session, stat, areas=None):
    ''' Compute statistics `stat` query using grouped by
        to minimize time execution.

        Reference doc/update-stats-query.bench.sql
    '''
    logging.debug('Compute %s stats for all suites' % stat)
    if stat is 'source_packages':
        q = (session.query(Suite.suite.label("suite"),
                           sql_func.count(Package.id))
             .join(Package)
             .group_by(Suite.suite)
             )
    elif stat is 'source_files':
        q = (session.query(Suite.suite.label("suite"),
                           sql_func.count(Checksum.id))
             .join(Package)
             .join(Checksum)
             .group_by(Suite.suite)
             )
    elif stat is 'disk_usage':
        q = (session.query(Suite.suite.label("suite"),
                           sql_func.sum(Metric.value))
             .filter(Metric.metric == 'size')
             .join(Package)
             .join(Metric)
             .group_by(Suite.suite)
             )
    elif stat is 'ctags':
        q = (session.query(Suite.suite.label('suite'),
                           sql_func.count(Ctag.id))
             .join(Package)
             .join(Ctag)
             .group_by(Suite.suite)
             )
    elif stat is 'sloccount':
        q = (session.query(Suite.suite.label('suite'),
                           SlocCount.language.label('language'),
                           sql_func.sum(SlocCount.count))
             .join(Package)
             .join(SlocCount)
             .group_by(Suite.suite, SlocCount.language)
             )
    else:
        logging.warn("Unrecognised stat %s" % stat)
        return 0
    if areas:
        q = q.filter(Package.area.in_(areas))
    return q.all()

Example 6

Project: debsources Source File: statistics.py
Function: get_licenses
def get_licenses(session, suite=None):
    """ Count files per license filtered by `suite`

    """
    logging.debug('grouped by license summary')
    if not suite:
        q = (session.query(FileCopyright.license, Suite.suite,
                           sql_func.count(FileCopyright.id))
             .join(File)
             .join(Package)
             .join(Suite)
             .group_by(Suite.suite)
             .group_by(FileCopyright.license)
             .order_by(Suite.suite))
        return q.all()
    else:
        q = (session.query(FileCopyright.license,
                           sql_func.count(FileCopyright.id))
             .join(File)
             .join(Package))
        if suite != 'ALL':
            q = q.join(Suite) \
                 .filter(Suite.suite == suite)
        q = q.group_by(FileCopyright.license)
        return dict(q.all())