Patentable/Patents/US-9418111
US-9418111

Recursive aggregates

PublishedAugust 16, 2016
Assigneenot available in USPTO data we have
Inventorsnot available in USPTO data we have
Technical Abstract

Methods, systems, and apparatus, including computer programs encoded on computer storage media, for expressing and evaluating aggregation functions, including aggregation functions in the context of recursive aggregates, in data languages that implement fixed point semantics. One of the methods includes receiving input specifying, explicitly or implicitly, an aggregation function agg having an input type and an output type, a relation s that has a domain and a range and that represents one or more entities to be aggregated over, and a relation t that is a relation from the range of s to the input type of the aggregation function agg; and evaluating an aggregation construct agg* to calculate a relation between the domain of s and the output type of the aggregation function agg according to agg*(s,t)={(m,agg(n))|∃d:(m,d)εs,nεΠ{|t(y)|yεs(m)|}}.

Patent Claims
42 claims

Legal claims defining the scope of protection, as filed with the USPTO.

2

2. The method of claim 1 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

3

3. The method of claim 1 , wherein the input comprises expressions in a data language that uses fixed point semantics.

4

4. The method of claim 3 , wherein the data language is SQL or Datalog.

5

5. The method of claim 3 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

6

6. The method of claim 1 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

7

7. The method of claim 1 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

8

8. The method of claim 1 , wherein receiving input comprises: receiving programming language input comprising language elements specifying, explicitly or implicitly, the aggregation construct agg* for the aggregation function agg.

9

9. The method of claim 8 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

11

11. The method of claim 10 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

12

12. The method of claim 10 , wherein only <term> contains a recursive reference.

13

13. The method of claim 10 , further comprising: receiving input specifying <to_agg> explicitly.

14

14. The method of claim 10 , wherein the input is program input comprising an expression in a data language that used fixed point semantics.

15

15. The method of claim 14 , wherein the data language is SQL or Datalog.

16

16. The method of claim 10 , wherein receiving input comprises: receiving input specifying arguments for the aggregation construct agg* that explicitly include <to_agg>, <variables>, <range>, and <term>.

18

18. The one or more non-transitory computer-readable storage media of claim 17 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

19

19. The one or more non-transitory computer-readable storage media of claim 17 , wherein the input comprises expressions in a data language that uses fixed point semantics.

20

20. The one or more non-transitory computer-readable storage media of claim 19 , wherein the data language is SQL or Datalog.

21

21. The one or more non-transitory computer-readable storage media of claim 19 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

22

22. The one or more non-transitory computer-readable storage media of claim 17 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

23

23. The one or more non-transitory computer-readable storage media of claim 17 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

24

24. The one or more non-transitory computer-readable storage media of claim 17 , wherein receiving input comprises: receiving programming language input comprising language elements specifying, explicitly or implicitly, the aggregation construct agg* for the aggregation function agg.

25

25. The one or more non-transitory computer-readable storage media of claim 24 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

27

27. The one or more non-transitory computer-readable storage media of claim 26 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

28

28. The one or more non-transitory computer-readable storage media of claim 26 , wherein only <term> contains a recursive reference.

29

29. The one or more non-transitory computer-readable storage media of claim 26 , further comprising: receiving input specifying <to_agg> explicitly.

30

30. The one or more non-transitory computer-readable storage media of claim 26 , wherein the input is program input comprising an expression in a data language that used fixed point semantics.

31

31. The one or more non-transitory computer-readable storage media of claim 30 , wherein the data language is SQL or Datalog.

32

32. The one or more non-transitory computer-readable storage media of claim 26 , wherein receiving input comprises: receiving input specifying arguments for the aggregation construct agg* that explicitly include <to_agg>, <variables>, <range>, and <term>.

34

34. The system of claim 33 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

35

35. The system of claim 33 , wherein the input comprises expressions in a data language that uses fixed point semantics.

36

36. The system of claim 35 , wherein the data language is SQL or Datalog.

37

37. The system of claim 35 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

38

38. The system of claim 33 , wherein receiving input comprises: receiving input that explicitly specifies the aggregation function agg, the relation s, the relation t, and the aggregation construct agg*.

39

39. The system of claim 33 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

40

40. The system of claim 33 , wherein receiving input comprises: receiving programming language input comprising language elements specifying, explicitly or implicitly, the aggregation construct agg* for the aggregation function agg.

41

41. The system of claim 40 , wherein the aggregation function agg has multiple input types, and the relation t is a relation from the range of s to the multiple input types of the aggregation function agg.

43

43. The system of claim 42 , wherein the aggregation function agg is a sum, average, count, min, max, product, or concatenation function.

44

44. The system of claim 42 , wherein only <term> contains a recursive reference.

45

45. The system of claim 42 , further comprising: receiving input specifying <to_agg> explicitly.

46

46. The system of claim 42 , wherein the input is program input comprising an expression in a data language that used fixed point semantics.

47

47. The system of claim 46 , wherein the data language is SQL or Datalog.

48

48. The system of claim 42 , wherein receiving input comprises: receiving input specifying arguments for the aggregation construct agg* that explicitly include <to_agg>, <variables>, <range>, and <term>.

Classification Codes (CPC)

Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.

Patent Metadata

Filing Date

April 6, 2015

Publication Date

August 16, 2016

Want to explore more patents?

Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.

Citation & reuse

Analysis on this page is generated by Patentable — an AI-powered patent intelligence platform. AI-generated summaries, explanations, and analysis may be reused with attribution and a visible link back to the canonical URL below. Patent abstracts and claims are USPTO public domain.

Cite as: Patentable. “Recursive aggregates” (US-9418111). https://patentable.app/patents/US-9418111

© 2026 Patentable. All rights reserved.

Patentable is a research and drafting-assistant tool, not a law firm, and does not provide legal advice. Documents we generate are drafts for review by a licensed patent attorney.