Calculate ratios of counts of rows with subqueries - sql

Question

(I could not think of a better title for this question. Suggestions welcome.)
(In case versions matter, I'm using SQLAlchemy 1.4.4 and Postgresql 13.1.)
I have a table ('test') of multiple instances of boolean values for multiple persons, representing test results (pass or fail), and I want to create a query returning a result set representing pass/fail ratios for each of them.
I.e., for this table:
id | person | passed
----+--------+--------
1 | p1 | t
2 | p1 | f
3 | p1 | f
4 | p2 | t
5 | p2 | t
6 | p2 | t
7 | p2 | t
8 | p2 | t
9 | p2 | f
10 | p2 | f
11 | p2 | f
the query should return:
person | pass_fail_ratio
-------+-------------------
p1 | 0.5
p2 | 1.6666666666666667
Here is the solution I have been able to come up with so far. (I'm appending a complete MWE to the end.)
results_count = (
sa.select(
test.person,
test.passed,
sa.func.count(test.passed).label('count')
).group_by(test.person).group_by(test.passed)
).subquery()
pass_count = (
sa.select(results_count.c.person, results_count.c.count)
.filter(results_count.c.passed == True) # noqa
).subquery()
fail_count = (
sa.select(results_count.c.person, results_count.c.count)
.filter(results_count.c.passed == False) # noqa
).subquery()
pass_fail_ratio = (
sa.select(
pass_count.c.person,
(
sa.cast(pass_count.c.count, sa.Float)
/ sa.cast(fail_count.c.count, sa.Float)
).label('success_failure_ratio')
)
).filter(fail_count.c.person == pass_count.c.person)
To me, this looks overly complicated for what would seem to be a conceptually rather simple thing. Is there a better solution?
MWE:
# To change database name, modify 'dbname'.
# Expected output:
# ('p1', 0.5)
# ('p2', 1.6666666666666667)
# Lots of constraints and checks omitted for brevity.
# To view generated SQL, uncomment the line containing "echo" below.
import sqlalchemy as sa
import sqlalchemy.orm as orm
import sqlalchemy.types as types
dbname = 'test'
base = orm.declarative_base()
class test(base):
__tablename__ = 'test'
id = sa.Column(sa.Integer, primary_key=True)
person = sa.Column(sa.String)
passed = sa.Column(types.Boolean)
pass
engine = sa.create_engine(
f"postgresql://localhost:5432/{dbname}", future=True
)
base.metadata.drop_all(engine)
base.metadata.create_all(engine)
session = orm.Session(engine)
# Add some data.
session.add(test(person='p1', passed=True))
session.add(test(person='p1', passed=False))
session.add(test(person='p1', passed=False))
session.add(test(person='p2', passed=True))
session.add(test(person='p2', passed=True))
session.add(test(person='p2', passed=True))
session.add(test(person='p2', passed=True))
session.add(test(person='p2', passed=True))
session.add(test(person='p2', passed=False))
session.add(test(person='p2', passed=False))
session.add(test(person='p2', passed=False))
session.commit()
results_count = (
sa.select(
test.person,
test.passed,
sa.func.count(test.passed).label('count')
).group_by(test.person).group_by(test.passed)
).subquery()
pass_count = (
sa.select(results_count.c.person, results_count.c.count)
.filter(results_count.c.passed == True) # noqa
).subquery()
fail_count = (
sa.select(results_count.c.person, results_count.c.count)
.filter(results_count.c.passed == False) # noqa
).subquery()
pass_fail_ratio = (
sa.select(
pass_count.c.person,
(
sa.cast(pass_count.c.count, sa.Float)
/ sa.cast(fail_count.c.count, sa.Float)
).label('success_failure_ratio')
)
).filter(fail_count.c.person == pass_count.c.person)
# engine.echo = True
with orm.Session(engine) as session:
res = session.execute(pass_fail_ratio)
for row in res:
print(row)
pass
pass
pass

Answer 1

That is soooo complicated. I wouldn't use subqueries. One method is:
select person,
count(*) filter (where passed) * 1.0 / count(*) filter (where not passed)
from test t
group by person;
You might find it more convenient to express this "in the old-fashioned way" without filter:
select person,
sum( passed::int ) * 1.0 / sum( (not passed)::int )
from test t
group by person;
Note that the pass ratio is more commonly used than the ratio of passes to fails. That is simply:
select person,
avg( passed::int ) as pass_ratio
from test t
group by person;

Answer 2

Got Gordon Linoff's answer working in SQLAlchemy. Here is my final solution:
import sqlalchemy as sa
pass_fail_ratio_query = sa.select(
test.person,
(
sa.cast(
sa.funcfilter(sa.func.count(), test.passed == True), # noqa
sa.Float
)
/ sa.cast(
sa.funcfilter(sa.func.count(), test.passed == False), # noqa
sa.Float
)
)
).group_by(test.person)