Documentation
¶
Index ¶
- type Table
- func (t *Table) Add(u map[string]any) error
- func (t *Table) Delete(u map[string]any)
- func (t *Table) Difference(u *Table) (*Table, error)
- func (t *Table) Has(u map[string]any) bool
- func (t *Table) List() iter.Seq[map[string]any]
- func (t *Table) NaturalJoin(u *Table) *Table
- func (t *Table) Projection(p ...string) (*Table, error)
- func (t *Table) Rename1(old, new string) (*Table, error)
- func (t *Table) Union(u *Table) (*Table, error)
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Table ¶
type Table struct {
schema.Schema
relation.RelationSet
}
Example ¶
package main
import (
"fmt"
"github.com/martindrlik/rex/schema"
"github.com/martindrlik/rex/table"
"github.com/martindrlik/rex/tuple"
)
func main() {
foo := map[string]any{"foo": 1}
bar := map[string]any{"bar": 2.0}
foobar := tuple.Merge(foo, bar)
q, _ := table.New(schema.FromTuple(foobar))
q.Add(foo)
q.Add(bar)
q.Add(foobar)
for t := range q.List() {
fmt.Println(t)
}
}
Output: map[foo:1] map[bar:2] map[bar:2 foo:1]
func (*Table) Add ¶
Add adds a tuple to the table. If the tuple is already in the table, it does nothing.
Example ¶
package main
import (
"fmt"
"github.com/martindrlik/rex/schema"
"github.com/martindrlik/rex/table"
"github.com/martindrlik/rex/tuple"
)
func main() {
foo := map[string]any{"foo": 1}
bar := map[string]any{"bar": 2.0}
q, _ := table.New(schema.FromTuple(foo))
fmt.Println(q.Add(bar) == schema.ErrMismatch)
r, _ := table.New(schema.FromTuple(tuple.Merge(foo, bar)))
baz := map[string]any{"baz": "3"}
fmt.Println(r.Add(baz) == schema.ErrMismatch)
fmt.Println(r.Add(bar) == nil)
}
Output: true true true
func (*Table) NaturalJoin ¶
Example ¶
package main
import (
"fmt"
"github.com/martindrlik/rex/schema"
"github.com/martindrlik/rex/table"
)
func main() {
foobar := map[string]any{"foo": 1, "bar": 2.0}
barbaz := map[string]any{"bar": 2.0, "baz": "3"}
q, _ := table.New(schema.FromTuple(foobar))
q.Add(foobar)
r, _ := table.New(schema.FromTuple(barbaz))
r.Add(barbaz)
s := q.NaturalJoin(r)
for t := range s.List() {
fmt.Println(t)
}
}
Output: map[bar:2 baz:3 foo:1]
func (*Table) Projection ¶
Example ¶
package main
import (
"fmt"
"github.com/martindrlik/rex/schema"
"github.com/martindrlik/rex/table"
"github.com/martindrlik/rex/tuple"
)
func main() {
foo := map[string]any{"foo": 1}
foo2 := map[string]any{"foo": 2}
bar := map[string]any{"bar": 3.0}
foobar := tuple.Merge(foo, bar)
foo2bar := tuple.Merge(foo2, bar)
q, _ := table.New(schema.FromTuple(foobar))
_ = q.Add(foo)
_ = q.Add(foo2)
_ = q.Add(bar)
_ = q.Add(foobar)
_ = q.Add(foo2bar)
s, _ := q.Projection("foo")
for t := range s.List() {
fmt.Println(t)
}
}
Output: map[foo:1] map[foo:2]
Source Files
Click to show internal directories.
Click to hide internal directories.