Question

I have a relation e.g. R(Owner,Car). How can I return the owners who hold three cars in relational algebra? (and without using aggregate functions)

e.g. something like σ(COUNT(Car)=3)(R) but without using aggregate functions?

e.g.
given            return
+-+----+         +-+----+
|a|attX|         |a|attX|
+-+----+         +-+----+
|a|attY|   ==>   |a|attY|
+-+----+         +-+----+
|a|attZ|         |a|attZ|
+-+----+         +-+----+
|b|attX|
+-+----+
|c|attW|
+-+----+
|c|attX|
+-+----+
|c|attY|
+-+----+
|c|attZ|
+-+----+

Edit: Thanks for your answers, but I am looking for how to write this in relational algebra. This means in the form using operators like σ, π, X, ⋈, and so on.

Answer 1

Here’s one way of doing it, in SQL using operators that are easy to translate to relational algebra, and using slightly different test data (different types, same names):

WITH R 
     AS
     (
      SELECT * 
        FROM (
              VALUES (1, 1), 
                     (2, 2), (2, 3),
                     (3, 1), (3, 2), (3, 3),
                     (4, 1), (4, 2), (4, 3), (4, 4)
             ) AS T (Owner, Car)
     ),
     OwnersWithAtLeastThreeCars
     AS
     (
      SELECT DISTINCT R1.Owner
        FROM R AS R1, R AS R2, R AS R3
       WHERE R1.Owner = R2.Owner
             AND R2.Owner = R3.Owner
             AND R1.Car <> R2.Car
             AND R1.Car <> R3.Car
             AND R2.Car <> R3.Car
     ),
     OwnersWithAtLeastFourCars
     AS
     (
      SELECT DISTINCT R1.Owner
        FROM R AS R1, R AS R2, R AS R3, R AS R4
       WHERE R1.Owner = R2.Owner
             AND R2.Owner = R3.Owner
             AND R3.Owner = R4.Owner
             AND R1.Car <> R2.Car
             AND R1.Car <> R3.Car
             AND R1.Car <> R4.Car
             AND R2.Car <> R3.Car
             AND R2.Car <> R4.Car
             AND R3.Car <> R4.Car
     )
SELECT * FROM OwnersWithAtLeastThreeCars
EXCEPT       
SELECT * FROM OwnersWithAtLeastFourCars;

---

p.s. I’m using ‘old style’ (i.e. pre-1992) standard SQL joins, which are widely condemned on Stackoverflow. I’m using them not only because it fits with the OP’s list of available operators but, frankly, in these circumstances I find them much easier to write than using infix INNER JOIN notation.