Fix tests and update Godep

Godeps/Godeps.json

@@ -6,10 +6,6 @@
 	],
 	"Deps": [
 		{
-			"ImportPath": "github.com/pborman/uuid",
-			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
-		},
-		{
 			"ImportPath": "github.com/badgerodon/peg",
 			"Rev": "9e5f7f4d07ca576562618c23e8abadda278b684f"
 		},
@@ -31,6 +27,15 @@
 			"Rev": "b59a38004596b696aca7aa2adccfa68760864d86"
 		},
 		{
+			"ImportPath": "github.com/lib/pq",
+			"Comment": "go1.0-cutoff-58-g0dad96c",
+			"Rev": "0dad96c0b94f8dee039aa40467f767467392a0af"
+		},
+		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
 			"ImportPath": "github.com/peterh/liner",
 			"Rev": "1bb0d1c1a25ed393d8feb09bab039b2b1b1fbced"
 		},

graph/sql/optimizers.go

@@ -78,7 +78,7 @@ func intersectLink(a *SQLLinkIterator, b *SQLLinkIterator, qs *QuadStore) (*SQLI
 	return it, nil
 }
 
-func hasa(aIn sqlIterator, d quad.Direction, qs *QuadStore) (graph.Iterator, error) {
+func hasa(aIn sqlIterator, d quad.Direction, qs *QuadStore) (*SQLIterator, error) {
 	a, ok := aIn.(*SQLLinkIterator)
 	if !ok {
 		return nil, errors.New("Can't take the HASA of a link SQL iterator")
@@ -95,7 +95,7 @@ func hasa(aIn sqlIterator, d quad.Direction, qs *QuadStore) (graph.Iterator, err
 	return it, nil
 }
 
-func linksto(aIn sqlIterator, d quad.Direction, qs *QuadStore) (graph.Iterator, error) {
+func linksto(aIn sqlIterator, d quad.Direction, qs *QuadStore) (*SQLIterator, error) {
 	var a sqlIterator
 	a, ok := aIn.(*SQLNodeIterator)
 	if !ok {

graph/sql/optimizers_test.go

@@ -15,7 +15,6 @@
 package sql
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/google/cayley/graph"
@@ -25,108 +24,105 @@ import (
 func TestBuildIntersect(t *testing.T) {
 	a := NewSQLLinkIterator(nil, quad.Subject, "Foo")
 	b := NewSQLLinkIterator(nil, quad.Predicate, "is_equivalent_to")
-	it, err := intersect(a, b)
+	it, err := intersect(a.sql, b.sql, nil)
-	i := it.(*SQLLinkIterator)
 	if err != nil {
 		t.Error(err)
 	}
-	s, v := i.buildSQL(true, nil)
+	s, v := it.sql.buildSQL(true, nil)
-	fmt.Println(s, v)
+	t.Log(s, v)
 }
 
 func TestBuildHasa(t *testing.T) {
 	a := NewSQLLinkIterator(nil, quad.Subject, "Foo")
-	a.tagger.Add("foo")
+	a.Tagger().Add("foo")
 	b := NewSQLLinkIterator(nil, quad.Predicate, "is_equivalent_to")
-	it1, err := intersect(a, b)
+	it1, err := intersect(a.sql, b.sql, nil)
 	if err != nil {
 		t.Error(err)
 	}
-	it2, err := hasa(it1, quad.Object)
+	it2, err := hasa(it1.sql, quad.Object, nil)
-	i2 := it2.(*SQLNodeIterator)
 	if err != nil {
 		t.Error(err)
 	}
-	s, v := i2.buildSQL(true, nil)
+	s, v := it2.sql.buildSQL(true, nil)
-	fmt.Println(s, v)
+	t.Log(s, v)
 }
 
 func TestBuildLinksTo(t *testing.T) {
 	a := NewSQLLinkIterator(nil, quad.Subject, "Foo")
 	b := NewSQLLinkIterator(nil, quad.Predicate, "is_equivalent_to")
-	it1, err := intersect(a, b)
+	it1, err := intersect(a.sql, b.sql, nil)
 	if err != nil {
 		t.Error(err)
 	}
-	it2, err := hasa(it1, quad.Object)
+	it2, err := hasa(it1.sql, quad.Object, nil)
 	it2.Tagger().Add("foo")
 	if err != nil {
 		t.Error(err)
 	}
-	it3, err := linksto(it2, quad.Subject)
+	it3, err := linksto(it2.sql, quad.Subject, nil)
 	if err != nil {
 		t.Error(err)
 	}
-	i3 := it3.(*SQLLinkIterator)
+	s, v := it3.sql.buildSQL(true, nil)
-	s, v := i3.buildSQL(true, nil)
+	t.Log(s, v)
-	fmt.Println(s, v)
 }
 
 func TestInterestingQuery(t *testing.T) {
-	if *dbpath == "" {
+	if *postgres_path == "" {
 		t.SkipNow()
 	}
-	db, err := newQuadStore(*dbpath, nil)
+	db, err := newQuadStore(*postgres_path, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	a := NewSQLLinkIterator(db.(*QuadStore), quad.Object, "Humphrey Bogart")
+	qs := db.(*QuadStore)
-	b := NewSQLLinkIterator(db.(*QuadStore), quad.Predicate, "name")
+	a := NewSQLLinkIterator(qs, quad.Object, "Humphrey Bogart")
-	it1, err := intersect(a, b)
+	b := NewSQLLinkIterator(qs, quad.Predicate, "name")
+	it1, err := intersect(a.sql, b.sql, qs)
 	if err != nil {
 		t.Error(err)
 	}
-	it2, err := hasa(it1, quad.Subject)
+	it2, err := hasa(it1.sql, quad.Subject, qs)
 	if err != nil {
 		t.Error(err)
 	}
 	it2.Tagger().Add("hb")
-	it3, err := linksto(it2, quad.Object)
+	it3, err := linksto(it2.sql, quad.Object, qs)
 	if err != nil {
 		t.Error(err)
 	}
 	b = NewSQLLinkIterator(db.(*QuadStore), quad.Predicate, "/film/performance/actor")
-	it4, err := intersect(it3, b)
+	it4, err := intersect(it3.sql, b.sql, qs)
 	if err != nil {
 		t.Error(err)
 	}
-	it5, err := hasa(it4, quad.Subject)
+	it5, err := hasa(it4.sql, quad.Subject, qs)
 	if err != nil {
 		t.Error(err)
 	}
-	it6, err := linksto(it5, quad.Object)
+	it6, err := linksto(it5.sql, quad.Object, qs)
 	if err != nil {
 		t.Error(err)
 	}
 	b = NewSQLLinkIterator(db.(*QuadStore), quad.Predicate, "/film/film/starring")
-	it7, err := intersect(it6, b)
+	it7, err := intersect(it6.sql, b.sql, qs)
 	if err != nil {
 		t.Error(err)
 	}
-	it8, err := hasa(it7, quad.Subject)
+	it8, err := hasa(it7.sql, quad.Subject, qs)
 	if err != nil {
 		t.Error(err)
 	}
-	finalIt := it8.(*SQLNodeIterator)
+	s, v := it8.sql.buildSQL(true, nil)
-	s, v := finalIt.buildSQL(true, nil)
+	it8.Tagger().Add("id")
-	finalIt.Tagger().Add("id")
+	t.Log(s, v)
-	fmt.Println(s, v)
+	for graph.Next(it8) {
-	for graph.Next(finalIt) {
+		t.Log(it8.Result())
-		fmt.Println(finalIt.Result())
 		out := make(map[string]graph.Value)
-		finalIt.TagResults(out)
+		it8.TagResults(out)
 		for k, v := range out {
-			fmt.Printf("%s: %v\n", k, v.(string))
+			t.Log("%s: %v\n", k, v.(string))
 		}
 	}
 }

graph/sql/sql_link_iterator_test.go

@@ -24,29 +24,30 @@ import (
 	"github.com/google/cayley/quad"
 )
 
-var dbpath = flag.String("dbpath", "", "Path to running DB")
+var postgres_path = flag.String("postgres_path", "", "Path to running DB")
 
 func TestSQLLink(t *testing.T) {
 	it := NewSQLLinkIterator(nil, quad.Object, "cool")
-	s, v := it.buildSQL(true, nil)
+	s, v := it.sql.buildSQL(true, nil)
-	fmt.Println(s, v)
+	t.Log(s, v)
 }
 
 func TestSQLLinkIteration(t *testing.T) {
-	if *dbpath == "" {
+	if *postgres_path == "" {
 		t.SkipNow()
 	}
-	db, err := newQuadStore(*dbpath, nil)
+	db, err := newQuadStore(*postgres_path, nil)
+	qs := db.(*QuadStore)
 	if err != nil {
 		t.Fatal(err)
 	}
-	it := NewSQLLinkIterator(db.(*QuadStore), quad.Object, "Humphrey Bogart")
+	it := NewSQLLinkIterator(qs, quad.Object, "Humphrey Bogart")
 	for graph.Next(it) {
 		fmt.Println(it.Result())
 	}
-	it = NewSQLLinkIterator(db.(*QuadStore), quad.Subject, "/en/casablanca_1942")
+	it = NewSQLLinkIterator(qs, quad.Subject, "/en/casablanca_1942")
-	s, v := it.buildSQL(true, nil)
+	s, v := it.sql.buildSQL(true, nil)
-	fmt.Println(s, v)
+	t.Log(s, v)
 	c := 0
 	for graph.Next(it) {
 		fmt.Println(it.Result())
@@ -58,29 +59,30 @@ func TestSQLLinkIteration(t *testing.T) {
 }
 
 func TestSQLNodeIteration(t *testing.T) {
-	if *dbpath == "" {
+	if *postgres_path == "" {
 		t.SkipNow()
 	}
-	db, err := newQuadStore(*dbpath, nil)
+	db, err := newQuadStore(*postgres_path, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 	link := NewSQLLinkIterator(db.(*QuadStore), quad.Object, "/en/humphrey_bogart")
-	it := &SQLNodeIterator{
+	it := &SQLIterator{
-		uid:       iterator.NextUID(),
+		uid: iterator.NextUID(),
-		qs:        db.(*QuadStore),
+		qs:  db.(*QuadStore),
-		tableName: newTableName(),
+		sql: &SQLNodeIterator{
-		linkIts: []sqlItDir{
+			tableName: newTableName(),
-			sqlItDir{it: link,
+			linkIt: sqlItDir{
+				it:  link.sql,
 				dir: quad.Subject,
 			},
 		},
 	}
-	s, v := it.buildSQL(true, nil)
+	s, v := it.sql.buildSQL(true, nil)
-	fmt.Println(s, v)
+	t.Log(s, v)
 	c := 0
 	for graph.Next(it) {
-		fmt.Println(it.Result())
+		t.Log(it.Result())
 		c += 1
 	}
 	if c != 56 {