alf 0.9.3 → 0.10.0

data/doc/operators/relational/matching.md

@@ -0,0 +1,20 @@
+
+Relational matching (join + project back on left)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator restricts its LEFT operand to tuples for which there exists 
+at least one tuple in RIGHT that (naturally) joins. This is a shortcut 
+operator for the following longer expression:
+
+    (project (join xxx, yyy), [xxx's attributes])
+
+EXAMPLE
+
+    # Which suppliers supply at least one part?
+    !(alf matching suppliers supplies)
+

data/doc/operators/relational/minus.md

@@ -0,0 +1,12 @@
+
+Relational minus (aka difference)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator computes the difference between its two operands. The 
+difference is simply the set of LEFT tuples non present in RIGHT.
+

data/doc/operators/relational/not-matching.md

@@ -0,0 +1,20 @@
+
+Relational not matching (inverse of matching)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator restricts LEFT tuples to those for which there does not 
+exist any tuple in RIGHT that (naturally) joins. This is a shortcut 
+operator for the following longer expression: 
+
+    (minus xxx, (matching xxx, yyy))
+
+EXAMPLE
+
+    # Which suppliers do not supply any part?
+    !(alf not-matching suppliers supplies)
+

data/doc/operators/relational/project.md

@@ -0,0 +1,28 @@
+
+Relational projection (clip + compact)
+
+SYNOPSIS
+
+    #(signature)
+
+OPTIONS
+
+    #(summarized_options)
+
+DESCRIPTION
+
+This operator projects tuples on attributes whose names are specified in 
+ATTRIBUTES. Unlike SQL, this operator **always** removes duplicates in the
+result so that the output is a set of tuples, that is, a relation.
+
+With the allbut option, the operator projects ATTRIBUTES away instead of 
+keeping them. 
+
+EXAMPLE
+
+    # What are supplier cities ?
+    !(alf project suppliers -- city)
+
+    # What are all but supplier's id and name
+    !(alf project --allbut suppliers -- sid name)
+

data/doc/operators/relational/quota.md

@@ -0,0 +1,21 @@
+
+Generalized quota-queries (position, sum progression, etc.)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+**This operator is a work in progress and should be used with care.**
+
+This operator is an attempt to generalize RANK in two directions:
+
+* Use a full SUMMARIZATION instead of hard-coding a ranking attribute via count()
+* Providing a BY key so that summarizations can actually be done on sub-groups
+
+EXAMPLE
+
+    # Compute linear progression of quantities by supplier number
+    !(alf quota supplies -- sid -- qty -- position count  sum_qty "sum{ qty }")
+

data/doc/operators/relational/rank.md

@@ -0,0 +1,27 @@
+
+Relational ranking (explicit tuple positions)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator computes the ranking of input tuples, according to ORDER. 
+
+Precisely, it extends its operand with an attribute called AS whose value 
+is the number of tuples which are considered strictly less according to the
+order relation denoted by ORDER.
+
+Note that, unless the ordering includes a candidate key for the input relation, 
+the new AS attribute is not necessarily a candidate key for the output. 
+
+EXAMPLE
+
+    # Rank parts by weight 
+    !(alf rank parts -- weight -- position)
+
+    # Rank parts by weight in descending order. Ensure that position is a 
+    # candidate key by including a key in ordering
+    !(alf rank parts -- weight desc pid asc -- position)
+

data/doc/operators/relational/rename.md

@@ -0,0 +1,17 @@
+
+Relational renaming (rename some attributes)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This command renames attributes as specified in RENAMING, taken as successive 
+(old name, new name) pairs
+
+EXAMPLE
+
+    # Rename a few supplier attributes
+    !(alf rename suppliers -- name supplier_name  city supplier_city)
+

data/doc/operators/relational/restrict.md

@@ -0,0 +1,25 @@
+
+Relational restriction (aka where, predicate filtering)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This command restricts tuples to those for which PREDICATE evaluates to 
+true.
+
+PREDICATE must be a valid tuple expression that returns a truth-value. It 
+may be specified as a ruby code literal, or a mapping between (name, value) 
+pairs. In the latter case, PREDICATE is built as a conjunction of attribute 
+equalities.
+
+EXAMPLE
+
+    # Who are suppliers with a status greater than 20?
+    !(alf restrict suppliers -- "status > 20")
+
+    # Which suppliers live in London?
+    !(alf restrict suppliers -- city "'London'")
+

data/doc/operators/relational/summarize.md

@@ -0,0 +1,25 @@
+
+Relational summarization (group-by + aggregate ops)
+
+SYNOPSIS
+
+    #(signature)
+
+OPTIONS
+
+    #(summarized_options)
+
+DESCRIPTION
+
+This operator summarizes input tuples over a projection given by BY. 
+SUMMARIZATION is a mapping between attribute names and summarizing 
+expressions.
+
+With the allbut option, the operator uses all attributes not specified 
+in BY as the projection key.
+
+EXAMPLE
+
+    # Compute the sum of supplied quantities, by supplier id
+    !(alf summarize supplies -- sid -- total_qty "sum{ qty }")
+

data/doc/operators/relational/ungroup.md

@@ -0,0 +1,20 @@
+
+Relational un-grouping (inverse of group)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator flattens its operand by ungrouping the relation-valued 
+attribute ATTR. 
+
+EXAMPLE
+
+    # Given `pid` and `qty` groupped as `supplying`
+    !(alf group supplies -- pid qty -- supplying)
+
+    # Let's ungroup them
+    !(alf group supplies -- pid qty -- supplying | alf ungroup -- supplying)
+

data/doc/operators/relational/union.md

@@ -0,0 +1,14 @@
+
+Relational union
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator computes the union of its operands, that is the set of 
+tuples that appear in LEFT or in RIGHT. 
+
+The result is a valid relation in that it never contains duplicates.
+

data/doc/operators/relational/unwrap.md

@@ -0,0 +1,20 @@
+
+Relational un-wrapping (inverse of wrap)
+
+SYNOPSIS
+
+    #(signature)
+
+DESCRIPTION
+
+This operator flattens its operand by unwrapping the tuple-valued 
+attribute ATTR.
+
+EXAMPLE
+
+    # Given, `city` and `status` wrapped as `loc_and_status` 
+    !(alf wrap suppliers -- city status -- loc_and_status)
+
+    # Let's unwrap them
+    !(alf wrap suppliers -- city status -- loc_and_status | alf unwrap -- loc_and_status)
+

data/doc/operators/relational/wrap.md

@@ -0,0 +1,24 @@
+
+Relational wrapping (tuple-valued attributes)
+
+SYNOPSIS
+
+    #(signature)
+
+OPTIONS
+
+    #(summarized_options)
+
+DESCRIPTION
+
+This operator wraps attributes in ATTRIBUTES as a new, tuple-valued attribute 
+named AS.
+
+With the allbut option, it wraps all attributes not specified in ATTRIBUTES 
+instead.
+
+EXAMPLE
+
+    # Wrap `city` and `status` and a tuple-value attribute named `loc_and_status` 
+    !(alf wrap suppliers -- city status -- loc_and_status)
+

data/examples/csv/suppliers.csv

@@ -0,0 +1,6 @@
+sid,name,status,city
+S1,Smith,20,London
+S2,Jones,10,Paris
+S3,Blake,30,Paris
+S4,Clark,20,London
+S5,Adams,30,Athens