barak/cayley
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

First reasonably fast integration test

Browse source
This commit is contained in:
Barak Michener 2015-07-27 16:53:34 -04:00
parent 13d4d8b7b4
commit 425292811b
7 changed files with 209 additions and 833 deletions
Download patch file Download diff file Expand all files Collapse all files

153
graph/sql/sql_node_iterator.go
View file

@ -18,6 +18,7 @@ import (
"database/sql"
"fmt"
"strings"
"sync/atomic"
"github.com/barakmich/glog"
"github.com/google/cayley/graph"
@ -26,9 +27,16 @@ import (
)
var sqlNodeType graph.Type
var sqlNodeTableID uint64
func init() {
sqlNodeType = graph.RegisterIterator("sqlnode")
atomic.StoreUint64(&sqlNodeTableID, 0)
}
func newNodeTableName() string {
id := atomic.AddUint64(&sqlNodeTableID, 1)
return fmt.Sprintf("n_%d", id)
}
type SQLNodeIterator struct {
@ -38,10 +46,10 @@ type SQLNodeIterator struct {
tableName string
err error
cursor *sql.Rows
linkIts []sqlItDir
size int64
tagdirs []tagDir
cursor *sql.Rows
linkIts []sqlItDir
nodetables []string
size int64
result map[string]string
resultIndex int
@ -67,7 +75,6 @@ func (n *SQLNodeIterator) Clone() graph.Iterator {
it: i.it.sqlClone(),
})
}
copy(n.tagdirs, m.tagdirs)
m.tagger.CopyFrom(n)
return m
}
@ -173,47 +180,106 @@ func (n *SQLNodeIterator) buildResult(i int) {
}
}
func (n *SQLNodeIterator) getTables() []string {
var out []string
for _, i := range n.linkIts {
out = append(out, i.it.getTables()...)
func (n *SQLNodeIterator) makeNodeTableNames() {
if n.nodetables != nil {
return
}
n.nodetables = make([]string, len(n.linkIts))
for i, _ := range n.nodetables {
n.nodetables[i] = newNodeTableName()
}
}
func (n *SQLNodeIterator) getTables() []tableDef {
var out []tableDef
switch len(n.linkIts) {
case 0:
return []tableDef{tableDef{table: "quads", name: n.tableName}}
case 1:
out = n.linkIts[0].it.getTables()
default:
return n.buildSubqueries()
}
if len(out) == 0 {
out = append(out, n.tableName)
out = append(out, tableDef{table: "quads", name: n.tableName})
}
return out
}
func (n *SQLNodeIterator) buildSubqueries() []tableDef {
var out []tableDef
n.makeNodeTableNames()
for i, it := range n.linkIts {
var td tableDef
// TODO(barakmich): This is a dirty hack. The real implementation is to
// separate SQL iterators to build a similar tree as we're doing here, and
// have a single graph.Iterator 'caddy' structure around it.
subNode := &SQLNodeIterator{
uid: iterator.NextUID(),
tableName: newTableName(),
linkIts: []sqlItDir{it},
}
var table string
table, td.values = subNode.buildSQL(true, nil)
td.table = fmt.Sprintf("\n(%s)", table[:len(table)-1])
td.name = n.nodetables[i]
out = append(out, td)
}
return out
}
func (n *SQLNodeIterator) tableID() tagDir {
if len(n.linkIts) == 0 {
switch len(n.linkIts) {
case 0:
return tagDir{
table: n.tableName,
dir: quad.Any,
tag: "__execd",
}
case 1:
return tagDir{
table: n.linkIts[0].it.tableID().table,
dir: n.linkIts[0].dir,
tag: "__execd",
}
default:
n.makeNodeTableNames()
return tagDir{
table: n.nodetables[0],
dir: quad.Any,
tag: "__execd",
}
}
return tagDir{
table: n.linkIts[0].it.tableID().table,
dir: n.linkIts[0].dir,
}
}
func (n *SQLNodeIterator) getTags() []tagDir {
func (n *SQLNodeIterator) getLocalTags() []tagDir {
myTag := n.tableID()
var out []tagDir
for _, tag := range n.tagger.Tags() {
out = append(out, tagDir{
dir: myTag.dir,
table: myTag.table,
tag: tag,
dir: myTag.dir,
table: myTag.table,
tag: tag,
justLocal: true,
})
}
for _, tag := range n.tagdirs {
out = append(out, tagDir{
dir: tag.dir,
table: myTag.table,
tag: tag.tag,
})
return out
}
func (n *SQLNodeIterator) getTags() []tagDir {
out := n.getLocalTags()
if len(n.linkIts) > 1 {
n.makeNodeTableNames()
for i, it := range n.linkIts {
for _, v := range it.it.getTags() {
out = append(out, tagDir{
tag: v.tag,
dir: quad.Any,
table: n.nodetables[i],
})
}
}
return out
}
for _, i := range n.linkIts {
out = append(out, i.it.getTags()...)
@ -225,18 +291,15 @@ func (n *SQLNodeIterator) buildWhere() (string, []string) {
var q []string
var vals []string
if len(n.linkIts) > 1 {
baseTable := n.linkIts[0].it.tableID().table
baseDir := n.linkIts[0].dir
for _, i := range n.linkIts[1:] {
table := i.it.tableID().table
dir := i.dir
q = append(q, fmt.Sprintf("%s.%s = %s.%s", baseTable, baseDir, table, dir))
for _, tb := range n.nodetables[1:] {
q = append(q, fmt.Sprintf("%s.__execd = %s.__execd", n.nodetables[0], tb))
}
} else {
for _, i := range n.linkIts {
s, v := i.it.buildWhere()
q = append(q, s)
vals = append(vals, v...)
}
}
for _, i := range n.linkIts {
s, v := i.it.buildWhere()
q = append(q, s)
vals = append(vals, v...)
}
query := strings.Join(q, " AND ")
return query, vals
@ -244,21 +307,26 @@ func (n *SQLNodeIterator) buildWhere() (string, []string) {
func (n *SQLNodeIterator) buildSQL(next bool, val graph.Value) (string, []string) {
topData := n.tableID()
query := "SELECT "
tags := []tagDir{topData}
tags = append(tags, n.getTags()...)
query := "SELECT DISTINCT "
var t []string
t = append(t, fmt.Sprintf("%s.%s as __execd", topData.table, topData.dir))
for _, v := range n.getTags() {
t = append(t, fmt.Sprintf("%s.%s as %s", v.table, v.dir, v.tag))
for _, v := range tags {
t = append(t, v.String())
}
query += strings.Join(t, ", ")
query += " FROM "
t = []string{}
var values []string
for _, k := range n.getTables() {
t = append(t, fmt.Sprintf("quads as %s", k))
values = append(values, k.values...)
t = append(t, fmt.Sprintf("%s as %s", k.table, k.name))
}
query += strings.Join(t, ", ")
query += " WHERE "
constraint, values := n.buildWhere()
constraint, wherevalues := n.buildWhere()
values = append(values, wherevalues...)
if !next {
v := val.(string)
@ -368,6 +436,7 @@ func (n *SQLNodeIterator) makeCursor(next bool, value graph.Value) error {
cursor, err := n.qs.db.Query(q, ivalues...)
if err != nil {
glog.Errorf("Couldn't get cursor from SQL database: %v", err)
glog.Errorf("Query: %v", q)
cursor = nil
return err
}