table based declarative reactive programming

Is there a programming language or package that supports table based reactive declarative programming in memory very similar to the SQL language and trigger facility?

For example, I could define PERSON and JOB tables as functions

name: PERSON -> STRING
 female: PERSON -> BOOLEAN
 mother: PERSON -> PEOPLE
 father: PERSON -> PEOPLE
 
 title: JOB -> STRING
 company: JOB -> STRING
 salary: JOB -> INTEGER
 empoyee: JOB -> PERSON
 

Then I would like to calculate functions like:

childcount: PERSON -> INTEGER
 childcount(P) = |{ Q in PERSON : father(Q) = P or mather(Q) = P }|
 
 income: PERSON -> INTEGER
 income(P) = SUM { salary(J) : J in JOB and empoyee(J) = P }
 
 incomeperchild: PERSON -> INTEGER
 incomeperchild(P) = income(P) / childcount(P)
 
 parent: PERSON x PERSON -> BOOLEAN
 person(P,Q) = (P = father(Q)) or (P = mother(Q))
 
 error: PERSON -> BOOLEAN
 error(P) = (female(P) and (exists Q in PERSON)(father(Q) = P))
    or (not female(P) and (exists Q in PERSON)(mother(Q) = P))
    or (exists Q in PERSON)(parent(P,Q) and error(Q))
 

So essentially I would like to have calculated columns in tables that are automatically updated whenever values in the tables change. Similar things could be expressed with SQL triggers, but I would like to have such functionality built into a language and executed in memory. The propagation of changes need to be optimized. Are there frameworks to do this?

The observer patter and reactive programming focuses on individual objects. But I do not want to maintain pointers and extra structure for each row in my tables as there could be million of rows. All the rules are generic (although they can refer to different rows via parent/children relations, etc), so some form of recursion is required.

---