Partially meeting conditions and sorting by match rank - sql

Question

Given a table where very simplified data looks like the following (but it could include millions of rows with a lot more data in dozens of columns of different types):
+----+----+---+-----+
| ID | X | Y | Z |
+----+----+---+-----+
| 1 | 1 | 1 | "a" |
| 2 | 1 | 0 | "a" |
| 3 | 0 | 1 | "a" |
| 4 | 0 | 0 | "a" |
| 5 | 0 | 0 | "b" |
+----+----+---+-----+
What would be the approach to select only the data with full AND MAYBE partial condition matching but up to a certain match rank, with the results sorted by that match rank?
E.g. when the condition is WHERE ((X = 1) AND (Y = 1) AND (Z = "a")) how would it be possible to get the following results in the following order:
+----+----+---+-----+-------+
| ID | X | Y | Z | MATCH |
+----+----+---+-----+-------+
| 1 | 1 | 1 | "a" | 100% | <- 100% because all conditions matched
| 2 | 1 | 0 | "a" | 66% | <- 66% because X & Z matched but Y didn't
| 3 | 0 | 1 | "a" | 66% | <- 66% because Y & Z matched but X didn't
| 4 | 0 | 0 | "a" | 33% | <- 33% because Z matched but X & Y didn't
| 5 | 0 | 0 | "b" | 0% | <- 0% because nothing matched
+----+----+---+-----+-------+
Or being able to select up to a certain match rank, so with WHERE ((X = 1) AND (Y = 1) AND (Z = "a")) AND (MATCH >= 25) we'd only get the following:
+----+----+---+-----+-------+
| ID | X | Y | Z | MATCH |
+----+----+---+-----+-------+
| 1 | 1 | 1 | "a" | 100% |
| 2 | 1 | 0 | "a" | 66% |
| 3 | 0 | 1 | "a" | 66% |
| 4 | 0 | 0 | "a" | 33% |
+----+----+---+-----+-------+
Or with WHERE ((X = 1) AND (Y = 1) AND (Z = "a")) AND (MATCH >= 75) to get:
+----+----+---+-----+-------+
| ID | X | Y | Z | MATCH |
+----+----+---+-----+-------+
| 1 | 1 | 1 | "a" | 100% |
+----+----+---+-----+-------+
Due to the table having tens of millions of rows iterating over them wouldn't be possible for scalability reasons (but other required conditions could be passed to narrow down the results).
The percentage values are for illustrative purposes only and aren't strictly required (the same applies for the looks of the MATCH >= XX% condition which would likely have to be represented differently).
I guess I'm looking for something like this
SELECT *
FROM xyz
WHERE (X = 1 AND Y = 1 AND Z = "a")
OR (X != 1 AND Y = 1 AND Z = "a")
OR (X = 1 AND Y != 1 AND Z = "a")
OR (X = 1 AND Y = 1 AND Z != "a")
OR (X = 1 AND Y != 1 AND Z != "a")
OR (X != 1 AND Y != 1 AND Z = "a")
OR (X != 1 AND Y = 1 AND Z != "a")
OR (X != 1 AND Y != 1 AND Z != "a")
But it of course wouldn't necessarily sort them in the order of the match rank nor allow specifying the match rank (other than maybe programmatically generating the needed number of OR conditions which is also an option).

Answer 1

This answers the original version of the question.
You can do the calculation in-line:
select t.*
from (select x, y,
((x = ?)::int + (y = ?)::int) / 2.0 as match
from t
) t
where match = ?;
The ? are placeholders for your values.

Answer 2

I can think of one way using JSONB to count the number of matches:
with vals (x,y,z) as (
values (1, 1,'a')
)
select d.*,
(select count(*)
from (
select jsonb_build_object(k,v)
from jsonb_each(to_jsonb(v)) as t1(k,v)
intersect
select jsonb_build_object(k,v)
from jsonb_each(to_jsonb(d) - 'id') as t2(k,v)
)t
) as num_matches
from data d
cross join vals v
where d.x = v.x
or d.y = v.y
or d.z = v.z
order by num_matches desc;
Not very pretty but at least the calculation of the number of matches is dynamic based on the number of columns of the "values" part.
returns:
id | x | y | z | num_matches
---+---+---+---+------------
1 | 1 | 1 | a | 3
2 | 1 | 0 | a | 2
3 | 0 | 1 | a | 2
4 | 0 | 0 | a | 1
If there are more columns that need to be ignored (not just id), you need to extend the to_jsonb(d) - 'id' to also remove the other columns - which makes this only partially "dynamic".
Doing this and calculating the percentage can all be put into a function:
create or replace function match_percent(p_values jsonb, p_row data)
returns int
as
$$
select ((count(*)::numeric / (select count(*) from jsonb_object_keys(p_values)))*100)::int
from (
select jsonb_build_object(k,v)
from jsonb_each(p_values) as t1(k,v)
intersect
select jsonb_build_object(k,v)
from jsonb_each(to_jsonb(p_row)) as t2(k,v)
where t2.k in (select k from jsonb_object_keys(p_values))
) x;
$$
language sql
stable;
Then the query can be simplified to:
with vals (x,y,z) as (
values (1, 1,'a')
)
select d.*,
match_percent(to_jsonb(v), d)
from data d
cross join vals v
where d.x = v.x
or d.y = v.y
or d.z = v.z
order by match_percent desc;