axiom

relation = Axiom::Relation.new(
  [[:id, String], [:name, String], [:color, String], [:weight, Float], [:city, String]],
  [
    ['P1', 'Nut',   'Red',   12.0, 'London'],
    ['P2', 'Bolt',  'Green', 17.0, 'Paris' ],
    ['P3', 'Screw', 'Blue',  17.0, 'Oslo'  ],
    ['P4', 'Screw', 'Red',   14.0, 'London'],
    ['P5', 'Cam',   'Blue',  12.0, 'Paris' ],
    ['P6', 'Cog',   'Red',   19.0, 'London'],
 ]
)

# Relational Operators
# --------------------

# projection
new_relation = relation.project([:id])

# removal
new_relation = relation.remove([:name])

# rename
new_relation = relation.rename(id: :other_id, name: :other_name)

# restriction
new_relation = relation.restrict { |r| r.name.eq('Screw').or(r.city.eq('London')) }
new_relation = relation.restrict(relation.name.eq('Screw'))
new_relation = relation.restrict(name: 'Screw')
new_relation = relation.restrict([[:name, 'Screw']])

# natural join
new_relation = relation.join(other)        # OR relation + other

# product
new_relation = relation.product(other)     # OR relation * other

# intersection
new_relation = relation.intersect(other)   # OR relation & other

# union
new_relation = relation.union(other)       # OR relation | other

# difference
new_relation = relation.difference(other)  # OR relation - other

# theta-join
#
# NOTE: theta-join is effectively restricting a product of the relations
new_relation = relation.join(other) { |r| r.id.gte(r.other_id) }

# group
grouped = relation.group(products: [:product_name])

# ungroup
ungrouped = relation.ungroup(:products)

# wrap
wrapped = relation.wrap(address: [:street, :city, :state, :zip, :country])

# unwrap
unwrapped = relation.unwrap(:address)

# extend
new_relation = relation.extend { |r| r.add(:pounds, r.weight * 2.2) }
new_relation = relation.extend { |r| r.add(:pounds) { |t| t[:weight] * 2.2 } }

# summarize
new_relation = relation.summarize(relation.project([:city])) { |r| r.add(:count, r.id.count) }
new_relation = relation.summarize(relation.project([:city])) { |r| r.add(:count) { |acc, t| acc.to_i + 1 } }

# Non-Relational Operators
# ------------------------

# returns a set that represents the relation header
header = relation.header

# each subset of unique keys as header objects
key_headers = header.keys

# a relation is Enumerable
relation = relation.each { |tuple| ... }

# order by attributes in the header
sorted = relation.sort

# order by attribute and direction
sorted = relation.sort_by { |r| [r.city.desc, r.name, r.color, r.id, r.weight] }

# reverse the relation (only allowed if sorted)
new_relation = sorted.reverse

# offset (only allowed if sorted)
new_relation = sorted.drop(5)

# limiting (only allowed if sorted)
new_relation = sorted.take(10)

# get the first n tuples (only allowed if sorted)
new_relation = sorted.first     # default is 1
new_relation = sorted.first(5)

# get the last n tuples (only allowed if sorted)
new_relation = sorted.last      # default is 1
new_relation = sorted.last(5)

# get a tuple from a relation containing exactly one tuple
tuple = relation.one
tuple = relation.one { ... }

# Updatable Views
# ---------------

# add a set to a relation variable
new_relation = relation.insert(other)

# remove a set from a relation variable
new_relation = relation.delete(other)

# replace a relation variable with another set
new_relation = relation.replace(other)