Refactor Super Graph into a library #26

core/internal/psql/bench.0

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/psql
+BenchmarkCompile-8           	   50000	     38531 ns/op	    5175 B/op	     148 allocs/op
+BenchmarkCompileParallel-8   	  200000	     11472 ns/op	    5237 B/op	     148 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/psql	4.686s

core/internal/psql/bench.8

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/psql
+BenchmarkCompile-8           	  100000	     15092 ns/op	    3562 B/op	      36 allocs/op
+BenchmarkCompileParallel-8   	  300000	      4684 ns/op	    3592 B/op	      36 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/psql	3.133s

core/internal/psql/columns.go

@@ -0,0 +1,216 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+func (c *compilerContext) renderBaseColumns(
+	sel *qcode.Select,
+	ti *DBTableInfo,
+	childCols []*qcode.Column,
+	skipped uint32) ([]int, bool, error) {
+
+	var realColsRendered []int
+
+	colcount := (len(sel.Cols) + len(sel.OrderBy) + 1)
+	colmap := make(map[string]struct{}, colcount)
+
+	isSearch := sel.Args["search"] != nil
+	isCursorPaged := sel.Paging.Type != qcode.PtOffset
+	isAgg := false
+
+	i := 0
+	for n, col := range sel.Cols {
+		cn := col.Name
+		colmap[cn] = struct{}{}
+
+		_, isRealCol := ti.ColMap[cn]
+
+		if isRealCol {
+			c.renderComma(i)
+			realColsRendered = append(realColsRendered, n)
+			colWithTable(c.w, ti.Name, cn)
+
+		} else {
+			switch {
+			case isSearch && cn == "search_rank":
+				if err := c.renderColumnSearchRank(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case isSearch && strings.HasPrefix(cn, "search_headline_"):
+				if err := c.renderColumnSearchHeadline(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case cn == "__typename":
+				if err := c.renderColumnTypename(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case strings.HasSuffix(cn, "_cursor"):
+				continue
+
+			default:
+				if err := c.renderColumnFunction(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+				isAgg = true
+			}
+		}
+		i++
+
+	}
+
+	if isCursorPaged {
+		if _, ok := colmap[ti.PrimaryCol.Key]; !ok {
+			colmap[ti.PrimaryCol.Key] = struct{}{}
+			c.renderComma(i)
+			colWithTable(c.w, ti.Name, ti.PrimaryCol.Name)
+		}
+		i++
+	}
+
+	for _, ob := range sel.OrderBy {
+		if _, ok := colmap[ob.Col]; ok {
+			continue
+		}
+		colmap[ob.Col] = struct{}{}
+		c.renderComma(i)
+		colWithTable(c.w, ti.Name, ob.Col)
+		i++
+	}
+
+	for _, col := range childCols {
+		if _, ok := colmap[col.Name]; ok {
+			continue
+		}
+		c.renderComma(i)
+		colWithTable(c.w, col.Table, col.Name)
+		i++
+	}
+
+	return realColsRendered, isAgg, nil
+}
+
+func (c *compilerContext) renderColumnSearchRank(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	if isColumnBlocked(sel, col.Name) {
+		return nil
+	}
+
+	if ti.TSVCol == nil {
+		return errors.New("no ts_vector column found")
+	}
+	cn := ti.TSVCol.Name
+	arg := sel.Args["search"]
+
+	c.renderComma(columnsRendered)
+	//fmt.Fprintf(w, `ts_rank("%s"."%s", websearch_to_tsquery('%s')) AS %s`,
+	//c.sel.Name, cn, arg.Val, col.Name)
+	io.WriteString(c.w, `ts_rank(`)
+	colWithTable(c.w, ti.Name, cn)
+	if c.schema.ver >= 110000 {
+		io.WriteString(c.w, `, websearch_to_tsquery('{{`)
+	} else {
+		io.WriteString(c.w, `, to_tsquery('{{`)
+	}
+	io.WriteString(c.w, arg.Val)
+	io.WriteString(c.w, `}}'))`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnSearchHeadline(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	cn := col.Name[16:]
+
+	if isColumnBlocked(sel, cn) {
+		return nil
+	}
+	arg := sel.Args["search"]
+
+	c.renderComma(columnsRendered)
+	//fmt.Fprintf(w, `ts_headline("%s"."%s", websearch_to_tsquery('%s')) AS %s`,
+	//c.sel.Name, cn, arg.Val, col.Name)
+	io.WriteString(c.w, `ts_headline(`)
+	colWithTable(c.w, ti.Name, cn)
+	if c.schema.ver >= 110000 {
+		io.WriteString(c.w, `, websearch_to_tsquery('{{`)
+	} else {
+		io.WriteString(c.w, `, to_tsquery('{{`)
+	}
+	io.WriteString(c.w, arg.Val)
+	io.WriteString(c.w, `}}'))`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnTypename(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	if isColumnBlocked(sel, col.Name) {
+		return nil
+	}
+
+	c.renderComma(columnsRendered)
+	io.WriteString(c.w, `(`)
+	squoted(c.w, ti.Name)
+	io.WriteString(c.w, ` :: text)`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnFunction(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	pl := funcPrefixLen(col.Name)
+	// if pl == 0 {
+	// 	//fmt.Fprintf(w, `'%s not defined' AS %s`, cn, col.Name)
+	// 	io.WriteString(c.w, `'`)
+	// 	io.WriteString(c.w, col.Name)
+	// 	io.WriteString(c.w, ` not defined'`)
+	// 	alias(c.w, col.Name)
+	// }
+
+	if pl == 0 || !sel.Functions {
+		return nil
+	}
+
+	cn := col.Name[pl:]
+
+	if isColumnBlocked(sel, cn) {
+		return nil
+	}
+
+	fn := col.Name[:pl-1]
+
+	c.renderComma(columnsRendered)
+
+	//fmt.Fprintf(w, `%s("%s"."%s") AS %s`, fn, c.sel.Name, cn, col.Name)
+	io.WriteString(c.w, fn)
+	io.WriteString(c.w, `(`)
+	colWithTable(c.w, ti.Name, cn)
+	io.WriteString(c.w, `)`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderComma(columnsRendered int) {
+	if columnsRendered != 0 {
+		io.WriteString(c.w, `, `)
+	}
+}
+
+func isColumnBlocked(sel *qcode.Select, name string) bool {
+	if len(sel.Allowed) != 0 {
+		if _, ok := sel.Allowed[name]; !ok {
+			return true
+		}
+	}
+	return false
+}

core/internal/psql/fuzz.go

@@ -0,0 +1,54 @@
+// +build gofuzz
+
+package psql
+
+import (
+	"encoding/json"
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+var (
+	qcompileTest, _ = qcode.NewCompiler(qcode.Config{})
+
+	schema = getTestSchema()
+
+	vars = NewVariables(map[string]string{
+		"admin_account_id": "5",
+	})
+
+	pcompileTest = NewCompiler(Config{
+		Schema: schema,
+		Vars:   vars,
+	})
+)
+
+// FuzzerEntrypoint for Fuzzbuzz
+func Fuzz(data []byte) int {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	qc, err := qcompileTest.Compile([]byte(gql), "user")
+	if err != nil {
+		panic("qcompile can't fail")
+	}
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(data),
+	}
+
+	_, _, err = pcompileTest.CompileEx(qc, vars)
+	if err != nil {
+		return 0
+	}
+
+	return 1
+}

core/internal/psql/insert.go

@@ -0,0 +1,196 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+func (c *compilerContext) renderInsert(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+
+	insert, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not defined", qc.ActionVar)
+	}
+	if len(insert) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	io.WriteString(c.w, `WITH "_sg_input" AS (SELECT '{{`)
+	io.WriteString(c.w, qc.ActionVar)
+	io.WriteString(c.w, `}}' :: json AS j)`)
+
+	st := util.NewStack()
+	st.Push(kvitem{_type: itemInsert, key: ti.Name, val: insert, ti: ti})
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+		if insert[0] == '[' && st.Len() > 1 {
+			return 0, errors.New("Nested bulk insert not supported")
+		}
+		intf := st.Pop()
+
+		switch item := intf.(type) {
+		case kvitem:
+			if err := c.handleKVItem(st, item); err != nil {
+				return 0, err
+			}
+
+		case renitem:
+			var err error
+
+			// if w := qc.Selects[0].Where; w != nil && w.Op == qcode.OpFalse {
+			// 	io.WriteString(c.w, ` WHERE false`)
+			// }
+
+			switch item._type {
+			case itemInsert:
+				err = c.renderInsertStmt(qc, w, item)
+			case itemConnect:
+				err = c.renderConnectStmt(qc, w, item)
+			case itemUnion:
+				err = c.renderUnionStmt(w, item)
+			}
+
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	io.WriteString(c.w, ` `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderInsertStmt(qc *qcode.QCode, w io.Writer, item renitem) error {
+
+	ti := item.ti
+	jt := item.data
+	sk := nestedInsertRelColumnsMap(item.kvitem)
+
+	io.WriteString(c.w, `, `)
+	renderCteName(w, item.kvitem)
+	io.WriteString(w, ` AS (`)
+
+	io.WriteString(w, `INSERT INTO `)
+	quoted(w, ti.Name)
+	io.WriteString(w, ` (`)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, false)
+	renderNestedInsertRelColumns(w, item.kvitem, false)
+	io.WriteString(w, `)`)
+
+	io.WriteString(w, ` SELECT `)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, true)
+	renderNestedInsertRelColumns(w, item.kvitem, true)
+
+	io.WriteString(w, ` FROM "_sg_input" i, `)
+	renderNestedInsertRelTables(w, item.kvitem)
+
+	if item.array {
+		io.WriteString(w, `json_populate_recordset`)
+	} else {
+		io.WriteString(w, `json_populate_record`)
+	}
+
+	io.WriteString(w, `(NULL::`)
+	io.WriteString(w, ti.Name)
+
+	if len(item.path) == 0 {
+		io.WriteString(w, `, i.j) t RETURNING *)`)
+	} else {
+		io.WriteString(w, `, i.j->`)
+		joinPath(w, item.path)
+		io.WriteString(w, `) t RETURNING *)`)
+	}
+
+	return nil
+}
+
+func nestedInsertRelColumnsMap(item kvitem) map[string]struct{} {
+	sk := make(map[string]struct{}, len(item.items))
+
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			sk[item.relPC.Right.Col] = struct{}{}
+		}
+	} else {
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				sk[v.relCP.Right.Col] = struct{}{}
+			}
+		}
+	}
+
+	return sk
+}
+
+func renderNestedInsertRelColumns(w io.Writer, item kvitem, values bool) error {
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			if values {
+				colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+			} else {
+				quoted(w, item.relPC.Right.Col)
+			}
+		}
+	} else {
+		// Render child foreign key columns if child-to-parent
+		// relationship is one-to-many
+		i := 0
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				if i != 0 {
+					io.WriteString(w, `, `)
+				}
+				if values {
+					if v._ctype > 0 {
+						io.WriteString(w, `"_x_`)
+						io.WriteString(w, v.relCP.Left.Table)
+						io.WriteString(w, `".`)
+						quoted(w, v.relCP.Left.Col)
+					} else {
+						colWithTable(w, v.relCP.Left.Table, v.relCP.Left.Col)
+					}
+				} else {
+					quoted(w, v.relCP.Right.Col)
+				}
+				i++
+			}
+		}
+	}
+
+	return nil
+}
+
+func renderNestedInsertRelTables(w io.Writer, item kvitem) error {
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			quoted(w, item.relPC.Left.Table)
+			io.WriteString(w, `, `)
+		}
+	} else {
+		// Render tables needed to set values if child-to-parent
+		// relationship is one-to-many
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				if v._ctype > 0 {
+					io.WriteString(w, `"_x_`)
+					io.WriteString(w, v.relCP.Left.Table)
+					io.WriteString(w, `", `)
+				} else {
+					quoted(w, v.relCP.Left.Table)
+					io.WriteString(w, `, `)
+				}
+			}
+		}
+	}
+
+	return nil
+}

core/internal/psql/insert_test.go

@@ -0,0 +1,271 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func simpleInsert(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func singleInsert(t *testing.T) {
+	gql := `mutation {
+		product(id: $id, insert: $insert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"insert": json.RawMessage(` { "name": "my_name", "price": 6.95, "description": "my_desc", "user_id": 5 }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func bulkInsert(t *testing.T) {
+	gql := `mutation {
+		product(name: "test", id: $id, insert: $insert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"insert": json.RawMessage(` [{ "name": "my_name", "description": "my_desc"  }]`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func simpleInsertWithPresets(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"name": "Tomato", "price": 5.76}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func nestedInsertManyToMany(t *testing.T) {
+	gql := `mutation {
+		purchase(insert: $data) {
+			sale_type
+			quantity
+			due_date
+			customer {
+				id
+				full_name
+				email
+			}
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(` {
+			"sale_type": "bought",
+			"quantity": 5,
+			"due_date": "now",
+			"customer": {
+				"email": "thedude@rug.com",
+				"full_name": "The Dude"
+			},
+			"product": {
+				"name": "Apple",
+				"price": 1.25
+			}
+		}
+	`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToMany(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"name": "Apple",
+				"price": 1.25,
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOne(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"hey": {
+					"now": "what's the matter"
+				},
+				"email": "thedude@rug.com",
+				"full_name": "The Dude",
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToManyWithConnect(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"connect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOneWithConnect(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			tags {
+				id
+				name
+			}
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOneWithConnectArray(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": { "id": [1,2] }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func TestCompileInsert(t *testing.T) {
+	t.Run("simpleInsert", simpleInsert)
+	t.Run("singleInsert", singleInsert)
+	t.Run("bulkInsert", bulkInsert)
+	t.Run("simpleInsertWithPresets", simpleInsertWithPresets)
+	t.Run("nestedInsertManyToMany", nestedInsertManyToMany)
+	t.Run("nestedInsertOneToMany", nestedInsertOneToMany)
+	t.Run("nestedInsertOneToOne", nestedInsertOneToOne)
+	t.Run("nestedInsertOneToManyWithConnect", nestedInsertOneToManyWithConnect)
+	t.Run("nestedInsertOneToOneWithConnect", nestedInsertOneToOneWithConnect)
+	t.Run("nestedInsertOneToOneWithConnectArray", nestedInsertOneToOneWithConnectArray)
+}

core/internal/psql/mutate.go

@@ -0,0 +1,694 @@
+//nolint:errcheck
+package psql
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/jsn"
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+type itemType int
+
+const (
+	itemInsert itemType = iota + 1
+	itemUpdate
+	itemConnect
+	itemDisconnect
+	itemUnion
+)
+
+var insertTypes = map[string]itemType{
+	"connect": itemConnect,
+}
+
+var updateTypes = map[string]itemType{
+	"connect":    itemConnect,
+	"disconnect": itemDisconnect,
+}
+
+var noLimit = qcode.Paging{NoLimit: true}
+
+func (co *Compiler) compileMutation(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	if len(qc.Selects) == 0 {
+		return 0, errors.New("empty query")
+	}
+
+	c := &compilerContext{w, qc.Selects, co}
+	root := &qc.Selects[0]
+
+	ti, err := c.schema.GetTable(root.Name)
+	if err != nil {
+		return 0, err
+	}
+
+	switch qc.Type {
+	case qcode.QTInsert:
+		if _, err := c.renderInsert(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTUpdate:
+		if _, err := c.renderUpdate(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTUpsert:
+		if _, err := c.renderUpsert(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTDelete:
+		if _, err := c.renderDelete(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	default:
+		return 0, errors.New("valid mutations are 'insert', 'update', 'upsert' and 'delete'")
+	}
+
+	root.Paging = noLimit
+	root.DistinctOn = root.DistinctOn[:]
+	root.OrderBy = root.OrderBy[:]
+	root.Where = nil
+	root.Args = nil
+
+	return c.compileQuery(qc, w, vars)
+}
+
+type kvitem struct {
+	id     int32
+	_type  itemType
+	_ctype int
+	key    string
+	path   []string
+	val    json.RawMessage
+	data   map[string]json.RawMessage
+	array  bool
+	ti     *DBTableInfo
+	relCP  *DBRel
+	relPC  *DBRel
+	items  []kvitem
+}
+
+type renitem struct {
+	kvitem
+	array bool
+	data  map[string]json.RawMessage
+}
+
+// TODO: Handle cases where a column name matches the child table name
+// the child path needs to be exluded in the json sent to insert or update
+
+func (c *compilerContext) handleKVItem(st *util.Stack, item kvitem) error {
+	var data map[string]json.RawMessage
+	var array bool
+	var err error
+
+	if item.data == nil {
+		data, array, err = jsn.Tree(item.val)
+		if err != nil {
+			return err
+		}
+	} else {
+		data, array = item.data, item.array
+	}
+
+	var unionize bool
+	id := item.id + 1
+
+	item.items = make([]kvitem, 0, len(data))
+
+	for k, v := range data {
+		if v[0] != '{' && v[0] != '[' {
+			continue
+		}
+
+		// Get child-to-parent relationship
+		relCP, err := c.schema.GetRel(k, item.key)
+		if err != nil {
+			var ty itemType
+			var ok bool
+
+			switch item._type {
+			case itemInsert:
+				ty, ok = insertTypes[k]
+			case itemUpdate:
+				ty, ok = updateTypes[k]
+			}
+
+			if ok {
+				unionize = true
+				item1 := item
+				item1._type = ty
+				item1.id = id
+				item1.val = v
+
+				item.items = append(item.items, item1)
+				id++
+			}
+
+			// Get parent-to-child relationship
+		} else if relPC, err := c.schema.GetRel(item.key, k); err == nil {
+			ti, err := c.schema.GetTable(k)
+			if err != nil {
+				return err
+			}
+
+			item1 := kvitem{
+				id:    id,
+				_type: item._type,
+				key:   k,
+				val:   v,
+				path:  append(item.path, k),
+				ti:    ti,
+				relCP: relCP,
+				relPC: relPC,
+			}
+
+			if v[0] == '{' {
+				item1.data, item1.array, err = jsn.Tree(v)
+				if err != nil {
+					return err
+				}
+				if v1, ok := item1.data["connect"]; ok && (v1[0] == '{' || v1[0] == '[') {
+					item1._ctype |= (1 << itemConnect)
+				}
+				if v1, ok := item1.data["disconnect"]; ok && (v1[0] == '{' || v1[0] == '[') {
+					item1._ctype |= (1 << itemDisconnect)
+				}
+			}
+
+			item.items = append(item.items, item1)
+			id++
+		}
+	}
+
+	if unionize {
+		item._type = itemUnion
+	}
+
+	// For inserts order the children according to
+	// the creation order required by the parent-to-child
+	// relationships. For example users need to be created
+	// before the products they own.
+
+	// For updates the order defined in the query must be
+	// the order used.
+	switch item._type {
+	case itemInsert:
+		for _, v := range item.items {
+			if v.relPC.Type == RelOneToMany {
+				st.Push(v)
+			}
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			if v.relPC.Type == RelOneToOne {
+				st.Push(v)
+			}
+		}
+
+	case itemUpdate:
+		for _, v := range item.items {
+			if !(v._ctype > 0 && v.relPC.Type == RelOneToOne) {
+				st.Push(v)
+			}
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			if v._ctype > 0 && v.relPC.Type == RelOneToOne {
+				st.Push(v)
+			}
+		}
+
+	case itemUnion:
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			st.Push(v)
+		}
+
+	default:
+		for _, v := range item.items {
+			st.Push(v)
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderUnionStmt(w io.Writer, item renitem) error {
+	var connect, disconnect bool
+
+	// Render only for parent-to-child relationship of one-to-many
+	if item.relPC.Type != RelOneToMany {
+		return nil
+	}
+
+	for _, v := range item.items {
+		if v._type == itemConnect {
+			connect = true
+		} else if v._type == itemDisconnect {
+			disconnect = true
+		}
+		if connect && disconnect {
+			break
+		}
+	}
+
+	if connect {
+		io.WriteString(w, `, `)
+		if connect && disconnect {
+			renderCteNameWithSuffix(w, item.kvitem, "c")
+		} else {
+			quoted(w, item.ti.Name)
+		}
+		io.WriteString(w, ` AS ( UPDATE `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` SET `)
+		quoted(w, item.relPC.Right.Col)
+		io.WriteString(w, ` = `)
+
+		// When setting the id of the connected table in a one-to-many setting
+		// we always overwrite the value including for array columns
+		colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+
+		io.WriteString(w, ` FROM `)
+		quoted(w, item.relPC.Left.Table)
+		io.WriteString(w, ` WHERE`)
+
+		i := 0
+		for _, v := range item.items {
+			if v._type == itemConnect {
+				if i != 0 {
+					io.WriteString(w, ` OR (`)
+				} else {
+					io.WriteString(w, ` (`)
+				}
+				if err := renderWhereFromJSON(w, v, "connect", v.val); err != nil {
+					return err
+				}
+				io.WriteString(w, `)`)
+				i++
+			}
+		}
+		io.WriteString(w, ` RETURNING `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, `.*)`)
+	}
+
+	if disconnect {
+		io.WriteString(w, `, `)
+		if connect && disconnect {
+			renderCteNameWithSuffix(w, item.kvitem, "d")
+		} else {
+			quoted(w, item.ti.Name)
+		}
+		io.WriteString(w, ` AS ( UPDATE `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` SET `)
+		quoted(w, item.relPC.Right.Col)
+		io.WriteString(w, ` = `)
+
+		if item.relPC.Right.Array {
+			io.WriteString(w, ` array_remove(`)
+			quoted(w, item.relPC.Right.Col)
+			io.WriteString(w, `, `)
+			colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+			io.WriteString(w, `)`)
+
+		} else {
+			io.WriteString(w, ` NULL`)
+		}
+
+		io.WriteString(w, ` FROM `)
+		quoted(w, item.relPC.Left.Table)
+		io.WriteString(w, ` WHERE`)
+
+		i := 0
+		for _, v := range item.items {
+			if v._type == itemDisconnect {
+				if i != 0 {
+					io.WriteString(w, ` OR (`)
+				} else {
+					io.WriteString(w, ` (`)
+				}
+				if err := renderWhereFromJSON(w, v, "disconnect", v.val); err != nil {
+					return err
+				}
+				io.WriteString(w, `)`)
+				i++
+			}
+		}
+		io.WriteString(w, ` RETURNING `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, `.*)`)
+	}
+
+	if connect && disconnect {
+		io.WriteString(w, `, `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` AS (`)
+		io.WriteString(w, `SELECT * FROM `)
+		renderCteNameWithSuffix(w, item.kvitem, "c")
+		io.WriteString(w, ` UNION ALL `)
+		io.WriteString(w, `SELECT * FROM `)
+		renderCteNameWithSuffix(w, item.kvitem, "d")
+		io.WriteString(w, `)`)
+	}
+
+	return nil
+}
+
+func renderInsertUpdateColumns(w io.Writer,
+	qc *qcode.QCode,
+	jt map[string]json.RawMessage,
+	ti *DBTableInfo,
+	skipcols map[string]struct{},
+	values bool) (uint32, error) {
+
+	root := &qc.Selects[0]
+	renderedCol := false
+
+	n := 0
+	for _, cn := range ti.Columns {
+		if _, ok := skipcols[cn.Name]; ok {
+			continue
+		}
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+		if _, ok := root.PresetMap[cn.Key]; ok {
+			continue
+		}
+		if len(root.Allowed) != 0 {
+			if _, ok := root.Allowed[cn.Key]; !ok {
+				continue
+			}
+		}
+		if n != 0 {
+			io.WriteString(w, `, `)
+		}
+
+		if values {
+			colWithTable(w, "t", cn.Name)
+		} else {
+			quoted(w, cn.Name)
+		}
+
+		if !renderedCol {
+			renderedCol = true
+		}
+		n++
+	}
+
+	for i := range root.PresetList {
+		cn := root.PresetList[i]
+		col, ok := ti.ColMap[cn]
+		if !ok {
+			continue
+		}
+		if _, ok := skipcols[col.Name]; ok {
+			continue
+		}
+		if i != 0 || n != 0 {
+			io.WriteString(w, `, `)
+		}
+
+		if values {
+			io.WriteString(w, `'`)
+			io.WriteString(w, root.PresetMap[cn])
+			io.WriteString(w, `' :: `)
+			io.WriteString(w, col.Type)
+		} else {
+			quoted(w, cn)
+		}
+
+		if !renderedCol {
+			renderedCol = true
+		}
+	}
+
+	if len(skipcols) != 0 && renderedCol {
+		io.WriteString(w, `, `)
+	}
+	return 0, nil
+}
+
+func (c *compilerContext) renderUpsert(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+	root := &qc.Selects[0]
+
+	upsert, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not defined", qc.ActionVar)
+	}
+	if len(upsert) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	if ti.PrimaryCol == nil {
+		return 0, fmt.Errorf("no primary key column found")
+	}
+
+	jt, _, err := jsn.Tree(upsert)
+	if err != nil {
+		return 0, err
+	}
+
+	if _, err := c.renderInsert(qc, w, vars, ti); err != nil {
+		return 0, err
+	}
+
+	io.WriteString(c.w, ` ON CONFLICT (`)
+	i := 0
+
+	for _, cn := range ti.Columns {
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+
+		if col, ok := ti.ColMap[cn.Key]; !ok || !(col.UniqueKey || col.PrimaryKey) {
+			continue
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, cn.Name)
+		i++
+	}
+	if i == 0 {
+		io.WriteString(c.w, ti.PrimaryCol.Name)
+	}
+	io.WriteString(c.w, `)`)
+
+	if root.Where != nil {
+		io.WriteString(c.w, ` WHERE `)
+
+		if err := c.renderWhere(root, ti); err != nil {
+			return 0, err
+		}
+	}
+
+	io.WriteString(c.w, ` DO UPDATE SET `)
+
+	i = 0
+	for _, cn := range ti.Columns {
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, cn.Name)
+		io.WriteString(c.w, ` = EXCLUDED.`)
+		io.WriteString(c.w, cn.Name)
+		i++
+	}
+
+	io.WriteString(c.w, ` RETURNING *) `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderConnectStmt(qc *qcode.QCode, w io.Writer,
+	item renitem) error {
+
+	rel := item.relPC
+
+	// Render only for parent-to-child relationship of one-to-one
+	// For this to work the child needs to found first so it's primary key
+	// can be set in the related column on the parent object.
+	// Eg. Create product and connect a user to it.
+	if rel.Type != RelOneToOne {
+		return nil
+	}
+
+	io.WriteString(w, `, "_x_`)
+	io.WriteString(c.w, item.ti.Name)
+	io.WriteString(c.w, `" AS (SELECT `)
+
+	if rel.Left.Array {
+		io.WriteString(w, `array_agg(DISTINCT `)
+		quoted(w, rel.Right.Col)
+		io.WriteString(w, `) AS `)
+		quoted(w, rel.Right.Col)
+
+	} else {
+		quoted(w, rel.Right.Col)
+
+	}
+
+	io.WriteString(c.w, ` FROM "_sg_input" i,`)
+	quoted(c.w, item.ti.Name)
+
+	io.WriteString(c.w, ` WHERE `)
+	if err := renderWhereFromJSON(c.w, item.kvitem, "connect", item.kvitem.val); err != nil {
+		return err
+	}
+	io.WriteString(c.w, ` LIMIT 1)`)
+
+	return nil
+}
+
+func (c *compilerContext) renderDisconnectStmt(qc *qcode.QCode, w io.Writer,
+	item renitem) error {
+
+	rel := item.relPC
+
+	// Render only for parent-to-child relationship of one-to-one
+	// For this to work the child needs to found first so it's
+	// null value can beset in the related column on the parent object.
+	// Eg. Update product and diconnect the user from it.
+	if rel.Type != RelOneToOne {
+		return nil
+	}
+	io.WriteString(w, `, "_x_`)
+	io.WriteString(c.w, item.ti.Name)
+	io.WriteString(c.w, `" AS (`)
+
+	if rel.Right.Array {
+		io.WriteString(c.w, `SELECT `)
+		quoted(w, rel.Right.Col)
+		io.WriteString(c.w, ` FROM "_sg_input" i,`)
+		quoted(c.w, item.ti.Name)
+		io.WriteString(c.w, ` WHERE `)
+		if err := renderWhereFromJSON(c.w, item.kvitem, "connect", item.kvitem.val); err != nil {
+			return err
+		}
+		io.WriteString(c.w, ` LIMIT 1))`)
+
+	} else {
+		io.WriteString(c.w, `SELECT * FROM (VALUES(NULL::`)
+		io.WriteString(w, rel.Right.col.Type)
+		io.WriteString(c.w, `)) AS LOOKUP(`)
+		quoted(w, rel.Right.Col)
+		io.WriteString(c.w, `))`)
+	}
+
+	return nil
+}
+
+func renderWhereFromJSON(w io.Writer, item kvitem, key string, val []byte) error {
+	var kv map[string]json.RawMessage
+	ti := item.ti
+
+	if err := json.Unmarshal(val, &kv); err != nil {
+		return err
+	}
+	i := 0
+	for k, v := range kv {
+		col, ok := ti.ColMap[k]
+		if !ok {
+			continue
+		}
+		if i != 0 {
+			io.WriteString(w, ` AND `)
+		}
+
+		if v[0] == '[' {
+			colWithTable(w, ti.Name, k)
+
+			if col.Array {
+				io.WriteString(w, ` && `)
+			} else {
+				io.WriteString(w, ` = `)
+			}
+
+			io.WriteString(w, `ANY((select a::`)
+			io.WriteString(w, col.Type)
+
+			io.WriteString(w, ` AS list from json_array_elements_text(`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `::json) AS a))`)
+
+		} else if col.Array {
+			io.WriteString(w, `(`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `)::`)
+			io.WriteString(w, col.Type)
+
+			io.WriteString(w, ` = ANY(`)
+			colWithTable(w, ti.Name, k)
+			io.WriteString(w, `)`)
+
+		} else {
+			colWithTable(w, ti.Name, k)
+
+			io.WriteString(w, `= (`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `)::`)
+			io.WriteString(w, col.Type)
+		}
+
+		i++
+	}
+	return nil
+}
+
+func renderPathJSON(w io.Writer, item kvitem, key1, key2 string) {
+	io.WriteString(w, `(i.j->`)
+	joinPath(w, item.path)
+	io.WriteString(w, `->'`)
+	io.WriteString(w, key1)
+	io.WriteString(w, `'->>'`)
+	io.WriteString(w, key2)
+	io.WriteString(w, `')`)
+}
+
+func renderCteName(w io.Writer, item kvitem) error {
+	io.WriteString(w, `"`)
+	io.WriteString(w, item.ti.Name)
+	if item._type == itemConnect || item._type == itemDisconnect {
+		io.WriteString(w, `_`)
+		int2string(w, item.id)
+	}
+	io.WriteString(w, `"`)
+	return nil
+}
+
+func renderCteNameWithSuffix(w io.Writer, item kvitem, suffix string) error {
+	io.WriteString(w, `"`)
+	io.WriteString(w, item.ti.Name)
+	io.WriteString(w, `_`)
+	io.WriteString(w, suffix)
+	io.WriteString(w, `"`)
+	return nil
+}
+
+func joinPath(w io.Writer, path []string) {
+	for i := range path {
+		if i != 0 {
+			io.WriteString(w, `->`)
+		}
+		io.WriteString(w, `'`)
+		io.WriteString(w, path[i])
+		io.WriteString(w, `'`)
+	}
+}

core/internal/psql/mutate_test.go

@@ -0,0 +1,123 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func singleUpsert(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func singleUpsertWhere(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert, where: { price : { gt: 3 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` { "name": "my_name",  "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func bulkUpsert(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` [{ "name": "my_name",  "description": "my_desc"  }]`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func delete(t *testing.T) {
+	gql := `mutation {
+		product(delete: true, where: { id: { eq: 1 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"update": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+// func blockedInsert(t *testing.T) {
+// 	gql := `mutation {
+// 		user(insert: $data) {
+// 			id
+// 		}
+// 	}`
+
+// 	sql := `WITH "users" AS (WITH "input" AS (SELECT '{{data}}' :: json AS j) INSERT INTO "users" ("full_name", "email") SELECT "full_name", "email" FROM input i, json_populate_record(NULL::users, i.j) t WHERE false RETURNING *) SELECT json_object_agg('user', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."id" AS "id") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."id" FROM "users" LIMIT ('1') :: integer) AS "users_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "bad_dude")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+// 	fmt.Println(string(resSQL))
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+// func blockedUpdate(t *testing.T) {
+// 	gql := `mutation {
+// 		user(where: { id: { lt: 5 } }, update: $data) {
+// 			id
+// 			email
+// 		}
+// 	}`
+
+// 	sql := `WITH "users" AS (WITH "input" AS (SELECT '{{data}}' :: json AS j) UPDATE "users" SET ("full_name", "email") = (SELECT "full_name", "email" FROM input i, json_populate_record(NULL::users, i.j) t) WHERE false RETURNING *) SELECT json_object_agg('user', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."id" AS "id", "users_0"."email" AS "email") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."id", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "bad_dude")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+func TestCompileMutate(t *testing.T) {
+	t.Run("singleUpsert", singleUpsert)
+	t.Run("singleUpsertWhere", singleUpsertWhere)
+	t.Run("bulkUpsert", bulkUpsert)
+	t.Run("delete", delete)
+	// t.Run("blockedInsert", blockedInsert)
+	// t.Run("blockedUpdate", blockedUpdate)
+}

core/internal/psql/pprof_cpu.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+go test -bench=. -benchmem -cpuprofile cpu.out  -run=XXX
+go tool pprof -cum cpu.out

core/internal/psql/pprof_mem.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+go test -bench=. -benchmem -memprofile mem.out -run=XXX
+go tool pprof -cum mem.out

core/internal/psql/psql_test.go

@@ -0,0 +1,237 @@
+package psql
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+const (
+	errNotExpected = "Generated SQL did not match what was expected"
+	headerMarker   = "=== RUN"
+	commentMarker  = "---"
+)
+
+var (
+	qcompile *qcode.Compiler
+	pcompile *Compiler
+	expected map[string][]string
+)
+
+func TestMain(m *testing.M) {
+	var err error
+
+	qcompile, err = qcode.NewCompiler(qcode.Config{
+		Blocklist: []string{
+			"secret",
+			"password",
+			"token",
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "name", "price", "users", "customers"},
+			Filters: []string{
+				"{ price: { gt: 0 } }",
+				"{ price: { lt: 8 } }",
+			},
+		},
+		Insert: qcode.InsertConfig{
+			Presets: map[string]string{
+				"user_id":    "$user_id",
+				"created_at": "now",
+				"updated_at": "now",
+			},
+		},
+		Update: qcode.UpdateConfig{
+			Filters: []string{"{ user_id: { eq: $user_id } }"},
+			Presets: map[string]string{"updated_at": "now"},
+		},
+		Delete: qcode.DeleteConfig{
+			Filters: []string{
+				"{ price: { gt: 0 } }",
+				"{ price: { lt: 8 } }",
+			},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("anon", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "name"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("anon1", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns:          []string{"id", "name", "price"},
+			DisableFunctions: true,
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "users", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "full_name", "avatar", "email", "products"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("bad_dude", "users", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Filters:          []string{"false"},
+			DisableFunctions: true,
+		},
+		Insert: qcode.InsertConfig{
+			Filters: []string{"false"},
+		},
+		Update: qcode.UpdateConfig{
+			Filters: []string{"false"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "mes", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "full_name", "avatar"},
+			Filters: []string{
+				"{ id: { eq: $user_id } }",
+			},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "customers", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "email", "full_name", "products"},
+		},
+	})
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	schema := getTestSchema()
+
+	vars := NewVariables(map[string]string{
+		"admin_account_id": "5",
+	})
+
+	pcompile = NewCompiler(Config{
+		Schema: schema,
+		Vars:   vars,
+	})
+
+	expected = make(map[string][]string)
+
+	b, err := ioutil.ReadFile("tests.sql")
+	if err != nil {
+		log.Fatal(err)
+	}
+	text := string(b)
+	lines := strings.Split(text, "\n")
+
+	var h string
+
+	for _, v := range lines {
+		switch {
+		case strings.HasPrefix(v, headerMarker):
+			h = strings.TrimSpace(v[len(headerMarker):])
+
+		case strings.HasPrefix(v, commentMarker):
+			break
+
+		default:
+			v := strings.TrimSpace(v)
+			if len(v) != 0 {
+				expected[h] = append(expected[h], v)
+			}
+		}
+	}
+	os.Exit(m.Run())
+}
+
+func compileGQLToPSQL(t *testing.T, gql string, vars Variables, role string) {
+	generateTestFile := false
+
+	if generateTestFile {
+		var sqlStmts []string
+
+		for i := 0; i < 100; i++ {
+			qc, err := qcompile.Compile([]byte(gql), role)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			_, sqlB, err := pcompile.CompileEx(qc, vars)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			sql := string(sqlB)
+
+			match := false
+			for _, s := range sqlStmts {
+				if sql == s {
+					match = true
+					break
+				}
+			}
+
+			if !match {
+				s := string(sql)
+				sqlStmts = append(sqlStmts, s)
+				fmt.Println(s)
+			}
+		}
+
+		return
+	}
+
+	for i := 0; i < 200; i++ {
+		qc, err := qcompile.Compile([]byte(gql), role)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		_, sqlStmt, err := pcompile.CompileEx(qc, vars)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		failed := true
+
+		for _, sql := range expected[t.Name()] {
+			if string(sqlStmt) == sql {
+				failed = false
+			}
+		}
+
+		if failed {
+			fmt.Println(string(sqlStmt))
+			t.Fatal(errNotExpected)
+		}
+	}
+}

core/internal/psql/query.go

@@ -0,0 +1,1297 @@
+//nolint:errcheck
+package psql
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+const (
+	closeBlock = 500
+)
+
+var (
+	ErrAllTablesSkipped = errors.New("all tables skipped. cannot render query")
+)
+
+type Variables map[string]json.RawMessage
+
+type Config struct {
+	Schema *DBSchema
+	Vars   map[string]string
+}
+
+type Compiler struct {
+	schema *DBSchema
+	vars   map[string]string
+}
+
+func NewCompiler(conf Config) *Compiler {
+	return &Compiler{
+		schema: conf.Schema,
+		vars:   conf.Vars,
+	}
+}
+
+func (c *Compiler) AddRelationship(child, parent string, rel *DBRel) error {
+	return c.schema.SetRel(child, parent, rel)
+}
+
+func (c *Compiler) IDColumn(table string) (*DBColumn, error) {
+	ti, err := c.schema.GetTable(table)
+	if err != nil {
+		return nil, err
+	}
+
+	if ti.PrimaryCol == nil {
+		return nil, fmt.Errorf("no primary key column found")
+	}
+
+	return ti.PrimaryCol, nil
+}
+
+type compilerContext struct {
+	w io.Writer
+	s []qcode.Select
+	*Compiler
+}
+
+func (co *Compiler) CompileEx(qc *qcode.QCode, vars Variables) (uint32, []byte, error) {
+	w := &bytes.Buffer{}
+	skipped, err := co.Compile(qc, w, vars)
+	return skipped, w.Bytes(), err
+}
+
+func (co *Compiler) Compile(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	switch qc.Type {
+	case qcode.QTQuery:
+		return co.compileQuery(qc, w, vars)
+	case qcode.QTInsert, qcode.QTUpdate, qcode.QTDelete, qcode.QTUpsert:
+		return co.compileMutation(qc, w, vars)
+	}
+
+	return 0, fmt.Errorf("Unknown operation type %d", qc.Type)
+}
+
+func (co *Compiler) compileQuery(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	if len(qc.Selects) == 0 {
+		return 0, errors.New("empty query")
+	}
+
+	c := &compilerContext{w, qc.Selects, co}
+
+	st := NewIntStack()
+	i := 0
+
+	io.WriteString(c.w, `SELECT jsonb_build_object(`)
+	for _, id := range qc.Roots {
+		root := &qc.Selects[id]
+		if root.SkipRender || len(root.Cols) == 0 {
+			continue
+		}
+
+		st.Push(root.ID + closeBlock)
+		st.Push(root.ID)
+
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+
+		c.renderRootSelect(root)
+		i++
+	}
+
+	io.WriteString(c.w, `) as "__root" FROM `)
+
+	if i == 0 {
+		return 0, ErrAllTablesSkipped
+	}
+
+	var ignored uint32
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		id := st.Pop()
+
+		if id < closeBlock {
+			sel := &c.s[id]
+
+			if len(sel.Cols) == 0 {
+				continue
+			}
+
+			ti, err := c.schema.GetTable(sel.Name)
+			if err != nil {
+				return 0, err
+			}
+
+			if sel.ParentID == -1 {
+				io.WriteString(c.w, `(`)
+			} else {
+				c.renderLateralJoin(sel)
+			}
+
+			if !ti.Singular {
+				c.renderPluralSelect(sel, ti)
+			}
+
+			skipped, err := c.renderSelect(sel, ti, vars)
+			if err != nil {
+				return 0, err
+			}
+			ignored |= skipped
+
+			for _, cid := range sel.Children {
+				if hasBit(skipped, uint32(cid)) {
+					continue
+				}
+				child := &c.s[cid]
+				if child.SkipRender {
+					continue
+				}
+
+				st.Push(child.ID + closeBlock)
+				st.Push(child.ID)
+			}
+
+		} else {
+			sel := &c.s[(id - closeBlock)]
+
+			ti, err := c.schema.GetTable(sel.Name)
+			if err != nil {
+				return 0, err
+			}
+
+			io.WriteString(c.w, `)`)
+			aliasWithID(c.w, "__sr", sel.ID)
+
+			io.WriteString(c.w, `)`)
+			aliasWithID(c.w, "__sj", sel.ID)
+
+			if !ti.Singular {
+				io.WriteString(c.w, `)`)
+				aliasWithID(c.w, "__sj", sel.ID)
+			}
+
+			if sel.ParentID == -1 {
+				if st.Len() != 0 {
+					io.WriteString(c.w, `, `)
+				}
+			} else {
+				c.renderLateralJoinClose(sel)
+			}
+
+			if len(sel.Args) != 0 {
+				i := 0
+				for _, v := range sel.Args {
+					qcode.FreeNode(v, 500)
+					i++
+				}
+			}
+		}
+	}
+
+	return ignored, nil
+}
+
+func (c *compilerContext) renderPluralSelect(sel *qcode.Select, ti *DBTableInfo) error {
+	io.WriteString(c.w, `SELECT coalesce(jsonb_agg("__sj_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `"."json"), '[]') as "json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		n := 0
+
+		// check if primary key already included in order by
+		// query argument
+		for _, ob := range sel.OrderBy {
+			if ob.Col == ti.PrimaryCol.Key {
+				n = 1
+				break
+			}
+		}
+
+		if n == 1 {
+			n = len(sel.OrderBy)
+		} else {
+			n = len(sel.OrderBy) + 1
+		}
+
+		io.WriteString(c.w, `, CONCAT_WS(','`)
+		for i := 0; i < n; i++ {
+			io.WriteString(c.w, `, max("__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `")`)
+		}
+		io.WriteString(c.w, `) as "cursor"`)
+	}
+
+	io.WriteString(c.w, ` FROM (`)
+	return nil
+}
+
+func (c *compilerContext) renderRootSelect(sel *qcode.Select) error {
+	io.WriteString(c.w, `'`)
+	io.WriteString(c.w, sel.FieldName)
+	io.WriteString(c.w, `', `)
+
+	io.WriteString(c.w, `"__sj_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `"."json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		io.WriteString(c.w, `, '`)
+		io.WriteString(c.w, sel.FieldName)
+		io.WriteString(c.w, `_cursor', `)
+
+		io.WriteString(c.w, `"__sj_`)
+		int2string(c.w, sel.ID)
+		io.WriteString(c.w, `"."cursor"`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) initSelect(sel *qcode.Select, ti *DBTableInfo, vars Variables) (uint32, []*qcode.Column, error) {
+	var skipped uint32
+
+	cols := make([]*qcode.Column, 0, len(sel.Cols))
+	colmap := make(map[string]struct{}, len(sel.Cols))
+
+	for i := range sel.Cols {
+		colmap[sel.Cols[i].Name] = struct{}{}
+	}
+
+	for i := range sel.OrderBy {
+		colmap[sel.OrderBy[i].Col] = struct{}{}
+	}
+
+	if sel.Paging.Type != qcode.PtOffset {
+		colmap[ti.PrimaryCol.Key] = struct{}{}
+		addPrimaryKey := true
+
+		for _, ob := range sel.OrderBy {
+			if ob.Col == ti.PrimaryCol.Key {
+				addPrimaryKey = false
+				break
+			}
+		}
+
+		if addPrimaryKey {
+			ob := &qcode.OrderBy{Col: ti.PrimaryCol.Name, Order: qcode.OrderAsc}
+
+			if sel.Paging.Type == qcode.PtBackward {
+				ob.Order = qcode.OrderDesc
+			}
+			sel.OrderBy = append(sel.OrderBy, ob)
+		}
+	}
+
+	if sel.Paging.Cursor {
+		c.addSeekPredicate(sel)
+	}
+
+	for _, id := range sel.Children {
+		child := &c.s[id]
+
+		rel, err := c.schema.GetRel(child.Name, ti.Name)
+		if err != nil {
+			return 0, nil, err
+			//skipped |= (1 << uint(id))
+			//continue
+		}
+
+		switch rel.Type {
+		case RelOneToOne, RelOneToMany:
+			if _, ok := colmap[rel.Right.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Right.Col, FieldName: rel.Right.Col})
+				colmap[rel.Right.Col] = struct{}{}
+			}
+
+		case RelOneToManyThrough:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Left.Col})
+				colmap[rel.Left.Col] = struct{}{}
+			}
+
+		case RelEmbedded:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Left.Col})
+				colmap[rel.Left.Col] = struct{}{}
+			}
+
+		case RelRemote:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Right.Col})
+				colmap[rel.Left.Col] = struct{}{}
+				skipped |= (1 << uint(id))
+			}
+
+		default:
+			return 0, nil, fmt.Errorf("unknown relationship %s", rel)
+			//skipped |= (1 << uint(id))
+		}
+	}
+
+	return skipped, cols, nil
+}
+
+// This
+// (A, B, C) >= (X, Y, Z)
+//
+// Becomes
+// (A > X)
+//   OR ((A = X) AND (B > Y))
+//   OR ((A = X) AND (B = Y) AND (C > Z))
+//   OR ((A = X) AND (B = Y) AND (C = Z))
+
+func (c *compilerContext) addSeekPredicate(sel *qcode.Select) error {
+	var or, and *qcode.Exp
+
+	obLen := len(sel.OrderBy)
+
+	if obLen > 1 {
+		or = qcode.NewFilter()
+		or.Op = qcode.OpOr
+	}
+
+	for i := 0; i < obLen; i++ {
+		if i > 0 {
+			and = qcode.NewFilter()
+			and.Op = qcode.OpAnd
+		}
+
+		for n, ob := range sel.OrderBy {
+			f := qcode.NewFilter()
+			f.Col = ob.Col
+			f.Type = qcode.ValRef
+			f.Table = "__cur"
+			f.Val = ob.Col
+
+			if obLen == 1 {
+				qcode.AddFilter(sel, f)
+				return nil
+			}
+
+			switch {
+			case i > 0 && n != i:
+				f.Op = qcode.OpEquals
+			case ob.Order == qcode.OrderDesc:
+				f.Op = qcode.OpLesserThan
+			default:
+				f.Op = qcode.OpGreaterThan
+			}
+
+			if and != nil {
+				and.Children = append(and.Children, f)
+			} else {
+				or.Children = append(or.Children, f)
+			}
+
+			if n == i {
+				break
+			}
+		}
+
+		if and != nil {
+			or.Children = append(or.Children, and)
+		}
+	}
+
+	qcode.AddFilter(sel, or)
+	return nil
+}
+
+func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo, vars Variables) (uint32, error) {
+	var rel *DBRel
+	var err error
+
+	if sel.ParentID != -1 {
+		parent := c.s[sel.ParentID]
+
+		rel, err = c.schema.GetRel(ti.Name, parent.Name)
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	skipped, childCols, err := c.initSelect(sel, ti, vars)
+	if err != nil {
+		return 0, err
+	}
+
+	// SELECT
+	// io.WriteString(c.w, `SELECT jsonb_build_object(`)
+	// if err := c.renderColumns(sel, ti, skipped); err != nil {
+	// 	return 0, err
+	// }
+
+	io.WriteString(c.w, `SELECT to_jsonb("__sr_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `") `)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i := range sel.OrderBy {
+			io.WriteString(c.w, `- '__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `' `)
+		}
+	}
+
+	io.WriteString(c.w, `AS "json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i := range sel.OrderBy {
+			io.WriteString(c.w, `, "__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `"`)
+		}
+	}
+
+	io.WriteString(c.w, `FROM (SELECT `)
+
+	if err := c.renderColumns(sel, ti, skipped); err != nil {
+		return 0, err
+	}
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i, ob := range sel.OrderBy {
+			io.WriteString(c.w, `, LAST_VALUE(`)
+			colWithTableID(c.w, ti.Name, sel.ID, ob.Col)
+			io.WriteString(c.w, `) OVER() AS "__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `"`)
+		}
+	}
+
+	io.WriteString(c.w, ` FROM (`)
+
+	// FROM (SELECT .... )
+	err = c.renderBaseSelect(sel, ti, rel, childCols, skipped)
+	if err != nil {
+		return skipped, err
+	}
+
+	//fmt.Fprintf(w, `) AS "%s_%d"`, c.sel.Name, c.sel.ID)
+	io.WriteString(c.w, `)`)
+	aliasWithID(c.w, ti.Name, sel.ID)
+
+	// END-FROM
+
+	return skipped, nil
+}
+
+func (c *compilerContext) renderLateralJoin(sel *qcode.Select) error {
+	io.WriteString(c.w, ` LEFT OUTER JOIN LATERAL (`)
+	return nil
+}
+
+func (c *compilerContext) renderLateralJoinClose(sel *qcode.Select) error {
+	// io.WriteString(c.w, `) `)
+	// aliasWithID(c.w, "__sj", sel.ID)
+	io.WriteString(c.w, ` ON ('true')`)
+	return nil
+}
+
+func (c *compilerContext) renderJoin(sel *qcode.Select, ti *DBTableInfo) error {
+	parent := &c.s[sel.ParentID]
+	return c.renderJoinByName(ti.Name, parent.Name, parent.ID)
+}
+
+func (c *compilerContext) renderJoinByName(table, parent string, id int32) error {
+	rel, err := c.schema.GetRel(table, parent)
+	if err != nil {
+		return err
+	}
+
+	// This join is only required for one-to-many relations since
+	// these make use of join tables that need to be pulled in.
+	if rel.Type != RelOneToManyThrough {
+		return err
+	}
+
+	pt, err := c.schema.GetTable(parent)
+	if err != nil {
+		return err
+	}
+
+	//fmt.Fprintf(w, ` LEFT OUTER JOIN "%s" ON (("%s"."%s") = ("%s_%d"."%s"))`,
+	//rel.Through, rel.Through, rel.ColT, c.parent.Name, c.parent.ID, rel.Left.Col)
+	io.WriteString(c.w, ` LEFT OUTER JOIN "`)
+	io.WriteString(c.w, rel.Through)
+	io.WriteString(c.w, `" ON ((`)
+	colWithTable(c.w, rel.Through, rel.ColT)
+	io.WriteString(c.w, `) = (`)
+	colWithTableID(c.w, pt.Name, id, rel.Left.Col)
+	io.WriteString(c.w, `))`)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumns(sel *qcode.Select, ti *DBTableInfo, skipped uint32) error {
+	i := 0
+	var cn string
+
+	for _, col := range sel.Cols {
+		if n := funcPrefixLen(col.Name); n != 0 {
+			if !sel.Functions {
+				continue
+			}
+			cn = col.Name[n:]
+		} else {
+			cn = col.Name
+
+			if strings.HasSuffix(cn, "_cursor") {
+				continue
+			}
+		}
+
+		if len(sel.Allowed) != 0 {
+			if _, ok := sel.Allowed[cn]; !ok {
+				continue
+			}
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		colWithTableID(c.w, ti.Name, sel.ID, col.Name)
+		alias(c.w, col.FieldName)
+
+		i++
+	}
+
+	i += c.renderRemoteRelColumns(sel, ti, i)
+
+	return c.renderJoinColumns(sel, ti, skipped, i)
+}
+
+func (c *compilerContext) renderRemoteRelColumns(sel *qcode.Select, ti *DBTableInfo, colsRendered int) int {
+	i := colsRendered
+
+	for _, id := range sel.Children {
+		child := &c.s[id]
+
+		rel, err := c.schema.GetRel(child.Name, sel.Name)
+		if err != nil || rel.Type != RelRemote {
+			continue
+		}
+		if i != 0 || len(sel.Cols) != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		colWithTableID(c.w, ti.Name, sel.ID, rel.Left.Col)
+		alias(c.w, rel.Right.Col)
+		i++
+	}
+
+	return i
+}
+
+func (c *compilerContext) renderJoinColumns(sel *qcode.Select, ti *DBTableInfo, skipped uint32, colsRendered int) error {
+	// columns previously rendered
+	i := colsRendered
+
+	for _, id := range sel.Children {
+		if hasBit(skipped, uint32(id)) {
+			continue
+		}
+		childSel := &c.s[id]
+
+		if i != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		if childSel.SkipRender {
+			io.WriteString(c.w, `NULL`)
+			alias(c.w, childSel.FieldName)
+			continue
+		}
+
+		io.WriteString(c.w, `"__sj_`)
+		int2string(c.w, childSel.ID)
+		io.WriteString(c.w, `"."json"`)
+		alias(c.w, childSel.FieldName)
+
+		if childSel.Paging.Type != qcode.PtOffset {
+			io.WriteString(c.w, `, "__sj_`)
+			int2string(c.w, childSel.ID)
+			io.WriteString(c.w, `"."cursor" AS "`)
+			io.WriteString(c.w, childSel.FieldName)
+			io.WriteString(c.w, `_cursor"`)
+		}
+
+		i++
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo, rel *DBRel,
+	childCols []*qcode.Column, skipped uint32) error {
+	isRoot := (rel == nil)
+	isFil := (sel.Where != nil && sel.Where.Op != qcode.OpNop)
+	hasOrder := len(sel.OrderBy) != 0
+
+	if sel.Paging.Cursor {
+		c.renderCursorCTE(sel)
+	}
+
+	io.WriteString(c.w, `SELECT `)
+
+	if len(sel.DistinctOn) != 0 {
+		c.renderDistinctOn(sel, ti)
+	}
+
+	realColsRendered, isAgg, err := c.renderBaseColumns(sel, ti, childCols, skipped)
+	if err != nil {
+		return err
+	}
+
+	io.WriteString(c.w, ` FROM `)
+
+	c.renderFrom(sel, ti, rel)
+
+	if isRoot && isFil {
+		io.WriteString(c.w, ` WHERE (`)
+		if err := c.renderWhere(sel, ti); err != nil {
+			return err
+		}
+		io.WriteString(c.w, `)`)
+	}
+
+	if !isRoot {
+		if err := c.renderJoin(sel, ti); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` WHERE (`)
+		if err := c.renderRelationship(sel, ti); err != nil {
+			return err
+		}
+		if isFil {
+			io.WriteString(c.w, ` AND `)
+			if err := c.renderWhere(sel, ti); err != nil {
+				return err
+			}
+		}
+		io.WriteString(c.w, `)`)
+	}
+
+	if isAgg && len(realColsRendered) != 0 {
+		io.WriteString(c.w, ` GROUP BY `)
+
+		for i, id := range realColsRendered {
+			c.renderComma(i)
+			//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Name, c.sel.Cols[id].Name)
+			colWithTable(c.w, ti.Name, sel.Cols[id].Name)
+		}
+	}
+
+	if hasOrder {
+		if err := c.renderOrderBy(sel, ti); err != nil {
+			return err
+		}
+	}
+
+	switch {
+	case ti.Singular:
+		io.WriteString(c.w, ` LIMIT ('1') :: integer`)
+
+	case len(sel.Paging.Limit) != 0:
+		//fmt.Fprintf(w, ` LIMIT ('%s') :: integer`, c.sel.Paging.Limit)
+		io.WriteString(c.w, ` LIMIT ('`)
+		io.WriteString(c.w, sel.Paging.Limit)
+		io.WriteString(c.w, `') :: integer`)
+
+	case sel.Paging.NoLimit:
+		break
+
+	default:
+		io.WriteString(c.w, ` LIMIT ('20') :: integer`)
+	}
+
+	if len(sel.Paging.Offset) != 0 {
+		//fmt.Fprintf(w, ` OFFSET ('%s') :: integer`, c.sel.Paging.Offset)
+		io.WriteString(c.w, ` OFFSET ('`)
+		io.WriteString(c.w, sel.Paging.Offset)
+		io.WriteString(c.w, `') :: integer`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderFrom(sel *qcode.Select, ti *DBTableInfo, rel *DBRel) error {
+	if rel != nil && rel.Type == RelEmbedded {
+		// jsonb_to_recordset('[{"a":1,"b":[1,2,3],"c":"bar"}, {"a":2,"b":[1,2,3],"c":"bar"}]') as x(a int, b text, d text);
+
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, rel.Left.Table)
+		io.WriteString(c.w, `", `)
+
+		io.WriteString(c.w, ti.Type)
+		io.WriteString(c.w, `_to_recordset(`)
+		colWithTable(c.w, rel.Left.Table, rel.Right.Col)
+		io.WriteString(c.w, `) AS `)
+
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, ti.Name)
+		io.WriteString(c.w, `"`)
+
+		io.WriteString(c.w, `(`)
+		for i, col := range ti.Columns {
+			if i != 0 {
+				io.WriteString(c.w, `, `)
+			}
+			io.WriteString(c.w, col.Name)
+			io.WriteString(c.w, ` `)
+			io.WriteString(c.w, col.Type)
+		}
+		io.WriteString(c.w, `)`)
+
+	} else {
+		//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Name)
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, ti.Name)
+		io.WriteString(c.w, `"`)
+	}
+
+	if sel.Paging.Cursor {
+		io.WriteString(c.w, `, "__cur"`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderCursorCTE(sel *qcode.Select) error {
+	io.WriteString(c.w, `WITH "__cur" AS (SELECT `)
+	for i, ob := range sel.OrderBy {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, `a[`)
+		int2string(c.w, int32(i+1))
+		io.WriteString(c.w, `] as `)
+		quoted(c.w, ob.Col)
+	}
+	io.WriteString(c.w, ` FROM string_to_array('{{cursor}}', ',') as a) `)
+	return nil
+}
+
+func (c *compilerContext) renderRelationship(sel *qcode.Select, ti *DBTableInfo) error {
+	parent := c.s[sel.ParentID]
+
+	pti, err := c.schema.GetTable(parent.Name)
+	if err != nil {
+		return err
+	}
+
+	return c.renderRelationshipByName(ti.Name, pti.Name, parent.ID)
+}
+
+func (c *compilerContext) renderRelationshipByName(table, parent string, id int32) error {
+	rel, err := c.schema.GetRel(table, parent)
+	if err != nil {
+		return err
+	}
+
+	io.WriteString(c.w, `((`)
+
+	switch rel.Type {
+	case RelOneToOne, RelOneToMany:
+
+		//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
+		//c.sel.Name, rel.Left.Col, c.parent.Name, c.parent.ID, rel.Right.Col)
+
+		switch {
+		case !rel.Left.Array && rel.Right.Array:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+
+		case rel.Left.Array && !rel.Right.Array:
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, table, rel.Left.Col)
+
+		default:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = (`)
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+		}
+
+	case RelOneToManyThrough:
+		// This requires the through table to be joined onto this select
+		//fmt.Fprintf(w, `(("%s"."%s") = ("%s"."%s"))`,
+		//c.sel.Name, rel.Left.Col, rel.Through, rel.Right.Col)
+
+		switch {
+		case !rel.Left.Array && rel.Right.Array:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+
+		case rel.Left.Array && !rel.Right.Array:
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, table, rel.Left.Col)
+
+		default:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = (`)
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+		}
+
+	case RelEmbedded:
+		colWithTable(c.w, rel.Left.Table, rel.Left.Col)
+		io.WriteString(c.w, `) = (`)
+		colWithTableID(c.w, parent, id, rel.Left.Col)
+	}
+
+	io.WriteString(c.w, `))`)
+
+	return nil
+}
+
+func (c *compilerContext) renderWhere(sel *qcode.Select, ti *DBTableInfo) error {
+	if sel.Where != nil {
+		return c.renderExp(sel.Where, ti, false)
+	}
+	return nil
+}
+
+func (c *compilerContext) renderExp(ex *qcode.Exp, ti *DBTableInfo, skipNested bool) error {
+	st := util.NewStack()
+	st.Push(ex)
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		intf := st.Pop()
+
+		switch val := intf.(type) {
+		case int32:
+			switch val {
+			case '(':
+				io.WriteString(c.w, `(`)
+			case ')':
+				io.WriteString(c.w, `)`)
+			}
+
+		case qcode.ExpOp:
+			switch val {
+			case qcode.OpAnd:
+				io.WriteString(c.w, ` AND `)
+			case qcode.OpOr:
+				io.WriteString(c.w, ` OR `)
+			case qcode.OpNot:
+				io.WriteString(c.w, `NOT `)
+			case qcode.OpFalse:
+				io.WriteString(c.w, `false`)
+			default:
+				return fmt.Errorf("11: unexpected value %v (%t)", intf, intf)
+			}
+
+		case *qcode.Exp:
+			switch val.Op {
+			case qcode.OpFalse:
+				st.Push(val.Op)
+
+			case qcode.OpAnd, qcode.OpOr:
+				st.Push(')')
+				for i := len(val.Children) - 1; i >= 0; i-- {
+					st.Push(val.Children[i])
+					if i > 0 {
+						st.Push(val.Op)
+					}
+				}
+				st.Push('(')
+
+			case qcode.OpNot:
+				//fmt.Printf("1> %s %d %s %s\n", val.Op, len(val.Children), val.Children[0].Op, val.Children[1].Op)
+
+				st.Push(val.Children[0])
+				st.Push(qcode.OpNot)
+
+			default:
+				if !skipNested && len(val.NestedCols) != 0 {
+					io.WriteString(c.w, `EXISTS `)
+
+					if err := c.renderNestedWhere(val, ti); err != nil {
+						return err
+					}
+
+				} else {
+					//fmt.Fprintf(w, `(("%s"."%s") `, c.sel.Name, val.Col)
+					if err := c.renderOp(val, ti); err != nil {
+						return err
+					}
+				}
+			}
+			//qcode.FreeExp(val)
+
+		default:
+			return fmt.Errorf("12: unexpected value %v (%t)", intf, intf)
+		}
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderNestedWhere(ex *qcode.Exp, ti *DBTableInfo) error {
+	for i := 0; i < len(ex.NestedCols)-1; i++ {
+		cti, err := c.schema.GetTable(ex.NestedCols[i])
+		if err != nil {
+			return err
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, ` AND `)
+		}
+
+		io.WriteString(c.w, `(SELECT 1 FROM `)
+		io.WriteString(c.w, cti.Name)
+
+		if err := c.renderJoinByName(cti.Name, ti.Name, -1); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` WHERE `)
+
+		if err := c.renderRelationshipByName(cti.Name, ti.Name, -1); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` AND (`)
+
+		if err := c.renderExp(ex, cti, true); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, `)`)
+
+	}
+
+	for i := 0; i < len(ex.NestedCols)-1; i++ {
+		io.WriteString(c.w, `)`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderOp(ex *qcode.Exp, ti *DBTableInfo) error {
+	var col *DBColumn
+	var ok bool
+
+	if ex.Op == qcode.OpNop {
+		return nil
+	}
+
+	if len(ex.Col) != 0 {
+		if col, ok = ti.ColMap[ex.Col]; !ok {
+			return fmt.Errorf("no column '%s' found ", ex.Col)
+		}
+
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ex.Col)
+		io.WriteString(c.w, `) `)
+	}
+
+	switch ex.Op {
+	case qcode.OpEquals:
+		io.WriteString(c.w, `=`)
+	case qcode.OpNotEquals:
+		io.WriteString(c.w, `!=`)
+	case qcode.OpNotDistinct:
+		io.WriteString(c.w, `IS NOT DISTINCT FROM`)
+	case qcode.OpDistinct:
+		io.WriteString(c.w, `IS DISTINCT FROM`)
+	case qcode.OpGreaterOrEquals:
+		io.WriteString(c.w, `>=`)
+	case qcode.OpLesserOrEquals:
+		io.WriteString(c.w, `<=`)
+	case qcode.OpGreaterThan:
+		io.WriteString(c.w, `>`)
+	case qcode.OpLesserThan:
+		io.WriteString(c.w, `<`)
+	case qcode.OpIn:
+		io.WriteString(c.w, `IN`)
+	case qcode.OpNotIn:
+		io.WriteString(c.w, `NOT IN`)
+	case qcode.OpLike:
+		io.WriteString(c.w, `LIKE`)
+	case qcode.OpNotLike:
+		io.WriteString(c.w, `NOT LIKE`)
+	case qcode.OpILike:
+		io.WriteString(c.w, `ILIKE`)
+	case qcode.OpNotILike:
+		io.WriteString(c.w, `NOT ILIKE`)
+	case qcode.OpSimilar:
+		io.WriteString(c.w, `SIMILAR TO`)
+	case qcode.OpNotSimilar:
+		io.WriteString(c.w, `NOT SIMILAR TO`)
+	case qcode.OpContains:
+		io.WriteString(c.w, `@>`)
+	case qcode.OpContainedIn:
+		io.WriteString(c.w, `<@`)
+	case qcode.OpHasKey:
+		io.WriteString(c.w, `?`)
+	case qcode.OpHasKeyAny:
+		io.WriteString(c.w, `?|`)
+	case qcode.OpHasKeyAll:
+		io.WriteString(c.w, `?&`)
+	case qcode.OpIsNull:
+		if strings.EqualFold(ex.Val, "true") {
+			io.WriteString(c.w, `IS NULL)`)
+		} else {
+			io.WriteString(c.w, `IS NOT NULL)`)
+		}
+		return nil
+
+	case qcode.OpEqID:
+		if ti.PrimaryCol == nil {
+			return fmt.Errorf("no primary key column defined for %s", ti.Name)
+		}
+		col = ti.PrimaryCol
+		//fmt.Fprintf(w, `(("%s") =`, c.ti.PrimaryCol)
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ti.PrimaryCol.Name)
+		//io.WriteString(c.w, ti.PrimaryCol)
+		io.WriteString(c.w, `) =`)
+
+	case qcode.OpTsQuery:
+		if ti.PrimaryCol == nil {
+			return fmt.Errorf("no tsv column defined for %s", ti.Name)
+		}
+		//fmt.Fprintf(w, `(("%s") @@ websearch_to_tsquery('%s'))`, c.ti.TSVCol, val.Val)
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ti.TSVCol.Name)
+		if c.schema.ver >= 110000 {
+			io.WriteString(c.w, `) @@ websearch_to_tsquery('{{`)
+		} else {
+			io.WriteString(c.w, `) @@ to_tsquery('{{`)
+		}
+		io.WriteString(c.w, ex.Val)
+		io.WriteString(c.w, `}}'))`)
+		return nil
+
+	default:
+		return fmt.Errorf("[Where] unexpected op code %d", ex.Op)
+	}
+
+	switch {
+	case ex.Type == qcode.ValList:
+		c.renderList(ex)
+	case col == nil:
+		return errors.New("no column found for expression value")
+	default:
+		c.renderVal(ex, c.vars, col)
+	}
+
+	io.WriteString(c.w, `)`)
+	return nil
+}
+
+func (c *compilerContext) renderOrderBy(sel *qcode.Select, ti *DBTableInfo) error {
+	io.WriteString(c.w, ` ORDER BY `)
+	for i := range sel.OrderBy {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		ob := sel.OrderBy[i]
+		colWithTable(c.w, ti.Name, ob.Col)
+
+		switch ob.Order {
+		case qcode.OrderAsc:
+			io.WriteString(c.w, ` ASC`)
+		case qcode.OrderDesc:
+			io.WriteString(c.w, ` DESC`)
+		case qcode.OrderAscNullsFirst:
+			io.WriteString(c.w, ` ASC NULLS FIRST`)
+		case qcode.OrderDescNullsFirst:
+			io.WriteString(c.w, ` DESC NULLLS FIRST`)
+		case qcode.OrderAscNullsLast:
+			io.WriteString(c.w, ` ASC NULLS LAST`)
+		case qcode.OrderDescNullsLast:
+			io.WriteString(c.w, ` DESC NULLS LAST`)
+		default:
+			return fmt.Errorf("13: unexpected value %v", ob.Order)
+		}
+	}
+	return nil
+}
+
+func (c *compilerContext) renderDistinctOn(sel *qcode.Select, ti *DBTableInfo) {
+	io.WriteString(c.w, `DISTINCT ON (`)
+	for i := range sel.DistinctOn {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		colWithTable(c.w, ti.Name, sel.DistinctOn[i])
+	}
+	io.WriteString(c.w, `) `)
+}
+
+func (c *compilerContext) renderList(ex *qcode.Exp) {
+	io.WriteString(c.w, ` (`)
+	for i := range ex.ListVal {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		switch ex.ListType {
+		case qcode.ValBool, qcode.ValInt, qcode.ValFloat:
+			io.WriteString(c.w, ex.ListVal[i])
+		case qcode.ValStr:
+			io.WriteString(c.w, `'`)
+			io.WriteString(c.w, ex.ListVal[i])
+			io.WriteString(c.w, `'`)
+		}
+	}
+	io.WriteString(c.w, `)`)
+}
+
+func (c *compilerContext) renderVal(ex *qcode.Exp, vars map[string]string, col *DBColumn) {
+	io.WriteString(c.w, ` `)
+
+	switch ex.Type {
+	case qcode.ValVar:
+		val, ok := vars[ex.Val]
+		switch {
+		case ok && strings.HasPrefix(val, "sql:"):
+			io.WriteString(c.w, ` (`)
+			io.WriteString(c.w, val[4:])
+			io.WriteString(c.w, `)`)
+		case ok:
+			squoted(c.w, val)
+		default:
+			io.WriteString(c.w, ` '{{`)
+			io.WriteString(c.w, ex.Val)
+			io.WriteString(c.w, `}}'`)
+		}
+
+	case qcode.ValRef:
+		colWithTable(c.w, ex.Table, ex.Col)
+
+	default:
+		squoted(c.w, ex.Val)
+	}
+
+	io.WriteString(c.w, ` :: `)
+	io.WriteString(c.w, col.Type)
+}
+
+func funcPrefixLen(fn string) int {
+	switch {
+	case strings.HasPrefix(fn, "avg_"):
+		return 4
+	case strings.HasPrefix(fn, "count_"):
+		return 6
+	case strings.HasPrefix(fn, "max_"):
+		return 4
+	case strings.HasPrefix(fn, "min_"):
+		return 4
+	case strings.HasPrefix(fn, "sum_"):
+		return 4
+	case strings.HasPrefix(fn, "stddev_"):
+		return 7
+	case strings.HasPrefix(fn, "stddev_pop_"):
+		return 11
+	case strings.HasPrefix(fn, "stddev_samp_"):
+		return 12
+	case strings.HasPrefix(fn, "variance_"):
+		return 9
+	case strings.HasPrefix(fn, "var_pop_"):
+		return 8
+	case strings.HasPrefix(fn, "var_samp_"):
+		return 9
+	}
+	return 0
+}
+
+func hasBit(n uint32, pos uint32) bool {
+	val := n & (1 << pos)
+	return (val > 0)
+}
+
+func alias(w io.Writer, alias string) {
+	io.WriteString(w, ` AS "`)
+	io.WriteString(w, alias)
+	io.WriteString(w, `"`)
+}
+
+func aliasWithID(w io.Writer, alias string, id int32) {
+	io.WriteString(w, ` AS "`)
+	io.WriteString(w, alias)
+	io.WriteString(w, `_`)
+	int2string(w, id)
+	io.WriteString(w, `"`)
+}
+
+func colWithTable(w io.Writer, table, col string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, table)
+	io.WriteString(w, `"."`)
+	io.WriteString(w, col)
+	io.WriteString(w, `"`)
+}
+
+func colWithTableID(w io.Writer, table string, id int32, col string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, table)
+	if id >= 0 {
+		io.WriteString(w, `_`)
+		int2string(w, id)
+	}
+	io.WriteString(w, `"."`)
+	io.WriteString(w, col)
+	io.WriteString(w, `"`)
+}
+
+func quoted(w io.Writer, identifier string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, identifier)
+	io.WriteString(w, `"`)
+}
+
+func squoted(w io.Writer, identifier string) {
+	io.WriteString(w, `'`)
+	io.WriteString(w, identifier)
+	io.WriteString(w, `'`)
+}
+
+const charset = "0123456789"
+
+func int2string(w io.Writer, val int32) {
+	if val < 10 {
+		w.Write([]byte{charset[val]})
+		return
+	}
+
+	temp := int32(0)
+	val2 := val
+	for val2 > 0 {
+		temp *= 10
+		temp += val2 % 10
+		val2 = int32(float64(val2 / 10))
+	}
+
+	val3 := temp
+	for val3 > 0 {
+		d := val3 % 10
+		val3 /= 10
+		w.Write([]byte{charset[d]})
+	}
+}

core/internal/psql/query_test.go

@@ -0,0 +1,459 @@
+package psql
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+)
+
+func withComplexArgs(t *testing.T) {
+	gql := `query {
+		proDUcts(
+			# returns only 30 items
+			limit: 30,
+
+			# starts from item 10, commented out for now
+			# offset: 10,
+
+			# orders the response items by highest price
+			order_by: { price: desc },
+
+			# no duplicate prices returned
+			distinct: [ price ]
+
+			# only items with an id >= 20 and < 28 are returned
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) {
+			id
+			NAME
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereAndList(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				and: [
+					{ not: { id: { is_null: true } } },
+					{ price: { gt: 10 } },
+				] } ) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereIsNull(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				and: {
+					not: { id: { is_null: true } },
+					price: { gt: 10 }
+				}}) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereMultiOr(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				or: {
+					not: { id: { is_null: true } },
+					price: { gt: 10 },
+					price: { lt: 20 }
+				} }
+			) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func fetchByID(t *testing.T) {
+	gql := `query {
+		product(id: $id) {
+			id
+			name
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func searchQuery(t *testing.T) {
+	gql := `query {
+		products(search: $query) {
+			id
+			name
+			search_rank
+			search_headline_description
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func oneToMany(t *testing.T) {
+	gql := `query {
+		users {
+			email
+			products {
+				name
+				price
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func oneToManyReverse(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			price
+			users {
+				email
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func oneToManyArray(t *testing.T) {
+	gql := `
+	query {
+		product {
+			name
+			price
+			tags {
+				id
+				name
+			}
+		}
+		tags {
+			name
+			product {
+				name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func manyToMany(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			customers {
+				email
+				full_name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func manyToManyReverse(t *testing.T) {
+	gql := `query {
+		customers {
+			email
+			full_name
+			products {
+				name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func aggFunction(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func aggFunctionBlockedByCol(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon")
+}
+
+func aggFunctionDisabled(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon1")
+}
+
+func aggFunctionWithFilter(t *testing.T) {
+	gql := `query {
+		products(where: { id: { gt: 10 } }) {
+			id
+			max_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func syntheticTables(t *testing.T) {
+	gql := `query {
+		me {
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func queryWithVariables(t *testing.T) {
+	gql := `query {
+		product(id: $PRODUCT_ID, where: { price: { eq: $PRODUCT_PRICE } }) {
+			id
+			name
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereOnRelations(t *testing.T) {
+	gql := `query {
+		users(where: { 
+				not: { 
+					products: { 
+						price: { gt: 3 }
+					} 
+				} 
+			}) {
+			id
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func multiRoot(t *testing.T) {
+	gql := `query {
+		product {
+			id
+			name
+			customer {
+				email
+			}
+			customers {
+				email
+			}
+		}
+		user {
+			id
+			email
+		}
+		customer {
+			id
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withCursor(t *testing.T) {
+	gql := `query {
+		Products(
+			first: 20
+			after: $cursor
+			order_by: { price: desc }) {
+			Name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"cursor": json.RawMessage(`"0,1"`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func jsonColumnAsTable(t *testing.T) {
+	gql := `query {
+		products {
+			id
+			name
+			tag_count {
+				count
+				tags {
+					name
+				}
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func nullForAuthRequiredInAnon(t *testing.T) {
+	gql := `query {
+		products {
+			id
+			name
+			user(where: { id: { eq: $user_id } }) {
+				id
+				email
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon")
+}
+
+func blockedQuery(t *testing.T) {
+	gql := `query {
+		user(id: $id, where: { id: { gt: 3 } }) {
+			id
+			full_name
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "bad_dude")
+}
+
+func blockedFunctions(t *testing.T) {
+	gql := `query {
+		users {
+			count_id
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "bad_dude")
+}
+
+func TestCompileQuery(t *testing.T) {
+	t.Run("withComplexArgs", withComplexArgs)
+	t.Run("withWhereAndList", withWhereAndList)
+	t.Run("withWhereIsNull", withWhereIsNull)
+	t.Run("withWhereMultiOr", withWhereMultiOr)
+	t.Run("fetchByID", fetchByID)
+	t.Run("searchQuery", searchQuery)
+	t.Run("oneToMany", oneToMany)
+	t.Run("oneToManyReverse", oneToManyReverse)
+	t.Run("oneToManyArray", oneToManyArray)
+	t.Run("manyToMany", manyToMany)
+	t.Run("manyToManyReverse", manyToManyReverse)
+	t.Run("aggFunction", aggFunction)
+	t.Run("aggFunctionBlockedByCol", aggFunctionBlockedByCol)
+	t.Run("aggFunctionDisabled", aggFunctionDisabled)
+	t.Run("aggFunctionWithFilter", aggFunctionWithFilter)
+	t.Run("syntheticTables", syntheticTables)
+	t.Run("queryWithVariables", queryWithVariables)
+	t.Run("withWhereOnRelations", withWhereOnRelations)
+	t.Run("multiRoot", multiRoot)
+	t.Run("jsonColumnAsTable", jsonColumnAsTable)
+	t.Run("withCursor", withCursor)
+	t.Run("nullForAuthRequiredInAnon", nullForAuthRequiredInAnon)
+	t.Run("blockedQuery", blockedQuery)
+	t.Run("blockedFunctions", blockedFunctions)
+}
+
+var benchGQL = []byte(`query {
+	proDUcts(
+		# returns only 30 items
+		limit: 30,
+
+		# starts from item 10, commented out for now
+		# offset: 10,
+
+		# orders the response items by highest price
+		order_by: { price: desc },
+
+		# only items with an id >= 30 and < 30 are returned
+		where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) {
+		id
+		NAME
+		price
+		user {
+			full_name
+			picture : avatar
+		}
+	}
+}`)
+
+func BenchmarkCompile(b *testing.B) {
+	w := &bytes.Buffer{}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for n := 0; n < b.N; n++ {
+		w.Reset()
+
+		qc, err := qcompile.Compile(benchGQL, "user")
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		_, err = pcompile.Compile(qc, w, nil)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkCompileParallel(b *testing.B) {
+	b.ReportAllocs()
+
+	b.RunParallel(func(pb *testing.PB) {
+		w := &bytes.Buffer{}
+
+		for pb.Next() {
+			w.Reset()
+
+			qc, err := qcompile.Compile(benchGQL, "user")
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			_, err = pcompile.Compile(qc, w, nil)
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}

core/internal/psql/schema.go

@@ -0,0 +1,426 @@
+package psql
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gobuffalo/flect"
+)
+
+type DBSchema struct {
+	ver int
+	t   map[string]*DBTableInfo
+	rm  map[string]map[string]*DBRel
+}
+
+type DBTableInfo struct {
+	Name       string
+	Type       string
+	Singular   bool
+	Columns    []DBColumn
+	PrimaryCol *DBColumn
+	TSVCol     *DBColumn
+	ColMap     map[string]*DBColumn
+	ColIDMap   map[int16]*DBColumn
+}
+
+type RelType int
+
+const (
+	RelOneToOne RelType = iota + 1
+	RelOneToMany
+	RelOneToManyThrough
+	RelEmbedded
+	RelRemote
+)
+
+type DBRel struct {
+	Type    RelType
+	Through string
+	ColT    string
+	Left    struct {
+		col   *DBColumn
+		Table string
+		Col   string
+		Array bool
+	}
+	Right struct {
+		col   *DBColumn
+		Table string
+		Col   string
+		Array bool
+	}
+}
+
+func NewDBSchema(info *DBInfo, aliases map[string][]string) (*DBSchema, error) {
+	schema := &DBSchema{
+		t:  make(map[string]*DBTableInfo),
+		rm: make(map[string]map[string]*DBRel),
+	}
+
+	for i, t := range info.Tables {
+		err := schema.addTable(t, info.Columns[i], aliases)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i, t := range info.Tables {
+		err := schema.firstDegreeRels(t, info.Columns[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i, t := range info.Tables {
+		err := schema.secondDegreeRels(t, info.Columns[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return schema, nil
+}
+
+func (s *DBSchema) addTable(
+	t DBTable, cols []DBColumn, aliases map[string][]string) error {
+
+	colmap := make(map[string]*DBColumn, len(cols))
+	colidmap := make(map[int16]*DBColumn, len(cols))
+
+	singular := flect.Singularize(t.Key)
+	s.t[singular] = &DBTableInfo{
+		Name:     t.Name,
+		Type:     t.Type,
+		Singular: true,
+		Columns:  cols,
+		ColMap:   colmap,
+		ColIDMap: colidmap,
+	}
+
+	plural := flect.Pluralize(t.Key)
+	s.t[plural] = &DBTableInfo{
+		Name:     t.Name,
+		Type:     t.Type,
+		Singular: false,
+		Columns:  cols,
+		ColMap:   colmap,
+		ColIDMap: colidmap,
+	}
+
+	if al, ok := aliases[t.Key]; ok {
+		for i := range al {
+			k1 := flect.Singularize(al[i])
+			s.t[k1] = s.t[singular]
+
+			k2 := flect.Pluralize(al[i])
+			s.t[k2] = s.t[plural]
+		}
+	}
+
+	for i := range cols {
+		c := &cols[i]
+
+		switch {
+		case c.Type == "tsvector":
+			s.t[singular].TSVCol = c
+			s.t[plural].TSVCol = c
+
+		case c.PrimaryKey:
+			s.t[singular].PrimaryCol = c
+			s.t[plural].PrimaryCol = c
+		}
+
+		colmap[c.Key] = c
+		colidmap[c.ID] = c
+	}
+
+	return nil
+}
+
+func (s *DBSchema) firstDegreeRels(t DBTable, cols []DBColumn) error {
+	ct := t.Key
+	cti, ok := s.t[ct]
+	if !ok {
+		return fmt.Errorf("invalid foreign key table '%s'", ct)
+	}
+
+	for i := range cols {
+		c := cols[i]
+
+		if len(c.FKeyTable) == 0 {
+			continue
+		}
+
+		// Foreign key column name
+		ft := strings.ToLower(c.FKeyTable)
+
+		ti, ok := s.t[ft]
+		if !ok {
+			return fmt.Errorf("invalid foreign key table '%s'", ft)
+		}
+
+		// This is an embedded relationship like when a json/jsonb column
+		// is exposed as a table
+		if c.Name == c.FKeyTable && len(c.FKeyColID) == 0 {
+			rel := &DBRel{Type: RelEmbedded}
+			rel.Left.col = cti.PrimaryCol
+			rel.Left.Table = cti.Name
+			rel.Left.Col = cti.PrimaryCol.Name
+
+			rel.Right.col = &c
+			rel.Right.Table = ti.Name
+			rel.Right.Col = c.Name
+
+			if err := s.SetRel(ft, ct, rel); err != nil {
+				return err
+			}
+			continue
+		}
+
+		if len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		// Foreign key column id
+		fcid := c.FKeyColID[0]
+
+		fc, ok := ti.ColIDMap[fcid]
+		if !ok {
+			return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+				fcid, ti.Name)
+		}
+
+		var rel1, rel2 *DBRel
+
+		// One-to-many relation between current table and the
+		// table in the foreign key
+		if fc.UniqueKey {
+			rel1 = &DBRel{Type: RelOneToOne}
+		} else {
+			rel1 = &DBRel{Type: RelOneToMany}
+		}
+
+		rel1.Left.col = &c
+		rel1.Left.Table = t.Name
+		rel1.Left.Col = c.Name
+		rel1.Left.Array = c.Array
+
+		rel1.Right.col = fc
+		rel1.Right.Table = c.FKeyTable
+		rel1.Right.Col = fc.Name
+		rel1.Right.Array = fc.Array
+
+		if err := s.SetRel(ct, ft, rel1); err != nil {
+			return err
+		}
+
+		// One-to-many reverse relation between the foreign key table and the
+		// the current table
+		if c.UniqueKey {
+			rel2 = &DBRel{Type: RelOneToOne}
+		} else {
+			rel2 = &DBRel{Type: RelOneToMany}
+		}
+
+		rel2.Left.col = fc
+		rel2.Left.Table = c.FKeyTable
+		rel2.Left.Col = fc.Name
+		rel2.Left.Array = fc.Array
+
+		rel2.Right.col = &c
+		rel2.Right.Table = t.Name
+		rel2.Right.Col = c.Name
+		rel2.Right.Array = c.Array
+
+		if err := s.SetRel(ft, ct, rel2); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *DBSchema) secondDegreeRels(t DBTable, cols []DBColumn) error {
+	jcols := make([]DBColumn, 0, len(cols))
+	ct := t.Key
+	cti, ok := s.t[ct]
+	if !ok {
+		return fmt.Errorf("invalid foreign key table '%s'", ct)
+	}
+
+	for i := range cols {
+		c := cols[i]
+
+		if len(c.FKeyTable) == 0 {
+			continue
+		}
+
+		// Foreign key column name
+		ft := strings.ToLower(c.FKeyTable)
+
+		ti, ok := s.t[ft]
+		if !ok {
+			return fmt.Errorf("invalid foreign key table '%s'", ft)
+		}
+
+		// This is an embedded relationship like when a json/jsonb column
+		// is exposed as a table
+		if c.Name == c.FKeyTable && len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		if len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		// Foreign key column id
+		fcid := c.FKeyColID[0]
+
+		if _, ok := ti.ColIDMap[fcid]; !ok {
+			return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+				fcid, ti.Name)
+		}
+
+		jcols = append(jcols, c)
+	}
+
+	// If table contains multiple foreign key columns it's a possible
+	// join table for many-to-many relationships or multiple one-to-many
+	// relations
+
+	// Below one-to-many relations use the current table as the
+	// join table aka through table.
+	if len(jcols) > 1 {
+		for i := range jcols {
+			for n := range jcols {
+				if n == i {
+					continue
+				}
+				err := s.updateSchemaOTMT(cti, jcols[i], jcols[n])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *DBSchema) updateSchemaOTMT(
+	ti *DBTableInfo, col1, col2 DBColumn) error {
+
+	t1 := strings.ToLower(col1.FKeyTable)
+	t2 := strings.ToLower(col2.FKeyTable)
+
+	fc1, ok := s.t[t1].ColIDMap[col1.FKeyColID[0]]
+	if !ok {
+		return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+			col1.FKeyColID[0], ti.Name)
+	}
+	fc2, ok := s.t[t2].ColIDMap[col2.FKeyColID[0]]
+	if !ok {
+		return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+			col2.FKeyColID[0], ti.Name)
+	}
+
+	// One-to-many-through relation between 1nd foreign key table and the
+	// 2nd foreign key table
+	rel1 := &DBRel{Type: RelOneToManyThrough}
+	rel1.Through = ti.Name
+	rel1.ColT = col2.Name
+
+	rel1.Left.col = &col2
+	rel1.Left.Table = col2.FKeyTable
+	rel1.Left.Col = fc2.Name
+
+	rel1.Right.col = &col1
+	rel1.Right.Table = ti.Name
+	rel1.Right.Col = col1.Name
+
+	if err := s.SetRel(t1, t2, rel1); err != nil {
+		return err
+	}
+
+	// One-to-many-through relation between 2nd foreign key table and the
+	// 1nd foreign key table
+	rel2 := &DBRel{Type: RelOneToManyThrough}
+	rel2.Through = ti.Name
+	rel2.ColT = col1.Name
+
+	rel1.Left.col = fc1
+	rel2.Left.Table = col1.FKeyTable
+	rel2.Left.Col = fc1.Name
+
+	rel1.Right.col = &col2
+	rel2.Right.Table = ti.Name
+	rel2.Right.Col = col2.Name
+
+	if err := s.SetRel(t2, t1, rel2); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *DBSchema) GetTable(table string) (*DBTableInfo, error) {
+	t, ok := s.t[table]
+	if !ok {
+		return nil, fmt.Errorf("unknown table '%s'", table)
+	}
+	return t, nil
+}
+
+func (s *DBSchema) SetRel(child, parent string, rel *DBRel) error {
+	sp := strings.ToLower(flect.Singularize(parent))
+	pp := strings.ToLower(flect.Pluralize(parent))
+
+	sc := strings.ToLower(flect.Singularize(child))
+	pc := strings.ToLower(flect.Pluralize(child))
+
+	if _, ok := s.rm[sc]; !ok {
+		s.rm[sc] = make(map[string]*DBRel)
+	}
+
+	if _, ok := s.rm[pc]; !ok {
+		s.rm[pc] = make(map[string]*DBRel)
+	}
+
+	if _, ok := s.rm[sc][sp]; !ok {
+		s.rm[sc][sp] = rel
+	}
+	if _, ok := s.rm[sc][pp]; !ok {
+		s.rm[sc][pp] = rel
+	}
+	if _, ok := s.rm[pc][sp]; !ok {
+		s.rm[pc][sp] = rel
+	}
+	if _, ok := s.rm[pc][pp]; !ok {
+		s.rm[pc][pp] = rel
+	}
+
+	return nil
+}
+
+func (s *DBSchema) GetRel(child, parent string) (*DBRel, error) {
+	rel, ok := s.rm[child][parent]
+	if !ok {
+		// No relationship found so this time fetch the table info
+		// and try again in case child or parent was an alias
+		ct, err := s.GetTable(child)
+		if err != nil {
+			return nil, err
+		}
+		pt, err := s.GetTable(parent)
+		if err != nil {
+			return nil, err
+		}
+		rel, ok = s.rm[ct.Name][pt.Name]
+		if !ok {
+			return nil, fmt.Errorf("unknown relationship '%s' -> '%s'",
+				child, parent)
+		}
+	}
+	return rel, nil
+}

core/internal/psql/stack_int.go

@@ -0,0 +1,47 @@
+package psql
+
+type IntStack struct {
+	stA [20]int32
+	st  []int32
+	top int
+}
+
+// Create a new IntStack
+func NewIntStack() *IntStack {
+	s := &IntStack{top: -1}
+	s.st = s.stA[:0]
+	return s
+}
+
+// Return the number of items in the IntStack
+func (s *IntStack) Len() int {
+	return (s.top + 1)
+}
+
+// View the top item on the IntStack
+func (s *IntStack) Peek() int32 {
+	if s.top == -1 {
+		return -1
+	}
+	return s.st[s.top]
+}
+
+// Pop the top item of the IntStack and return it
+func (s *IntStack) Pop() int32 {
+	if s.top == -1 {
+		return -1
+	}
+
+	s.top--
+	return s.st[(s.top + 1)]
+}
+
+// Push a value onto the top of the IntStack
+func (s *IntStack) Push(value int32) {
+	s.top++
+	if len(s.st) <= s.top {
+		s.st = append(s.st, value)
+	} else {
+		s.st[s.top] = value
+	}
+}

core/internal/psql/strings.go

@@ -0,0 +1,28 @@
+package psql
+
+import "fmt"
+
+func (rt RelType) String() string {
+	switch rt {
+	case RelOneToOne:
+		return "one to one"
+	case RelOneToMany:
+		return "one to many"
+	case RelOneToManyThrough:
+		return "one to many through"
+	case RelRemote:
+		return "remote"
+	case RelEmbedded:
+		return "embedded"
+	}
+	return ""
+}
+
+func (re *DBRel) String() string {
+	if re.Type == RelOneToManyThrough {
+		return fmt.Sprintf("'%s.%s' --(Through: %s)--> '%s.%s'",
+			re.Left.Table, re.Left.Col, re.Through, re.Right.Table, re.Right.Col)
+	}
+	return fmt.Sprintf("'%s.%s' --(%s)--> '%s.%s'",
+		re.Left.Table, re.Left.Col, re.Type, re.Right.Table, re.Right.Col)
+}

core/internal/psql/tables.go

@@ -0,0 +1,248 @@
+package psql
+
+import (
+	"database/sql"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/jackc/pgtype"
+)
+
+type DBInfo struct {
+	Version int
+	Tables  []DBTable
+	Columns [][]DBColumn
+	colmap  map[string]map[string]*DBColumn
+}
+
+func GetDBInfo(db *sql.DB) (*DBInfo, error) {
+	di := &DBInfo{}
+	var version string
+
+	err := db.QueryRow(`SHOW server_version_num`).Scan(&version)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching version: %w", err)
+	}
+
+	di.Version, err = strconv.Atoi(version)
+	if err != nil {
+		return nil, err
+	}
+
+	di.Tables, err = GetTables(db)
+	if err != nil {
+		return nil, err
+	}
+
+	di.colmap = make(map[string]map[string]*DBColumn, len(di.Tables))
+
+	for i, t := range di.Tables {
+		cols, err := GetColumns(db, "public", t.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		di.Columns = append(di.Columns, cols)
+		di.colmap[t.Key] = make(map[string]*DBColumn, len(cols))
+
+		for n, c := range di.Columns[i] {
+			di.colmap[t.Key][c.Key] = &di.Columns[i][n]
+		}
+	}
+
+	return di, nil
+}
+
+func (di *DBInfo) AddTable(t DBTable, cols []DBColumn) {
+	t.ID = di.Tables[len(di.Tables)-1].ID
+
+	di.Tables = append(di.Tables, t)
+	di.colmap[t.Key] = make(map[string]*DBColumn, len(cols))
+
+	for i := range cols {
+		cols[i].ID = int16(i)
+		c := &cols[i]
+		di.colmap[t.Key][c.Key] = c
+	}
+	di.Columns = append(di.Columns, cols)
+}
+
+func (di *DBInfo) GetColumn(table, column string) (*DBColumn, bool) {
+	v, ok := di.colmap[strings.ToLower(table)][strings.ToLower(column)]
+	return v, ok
+}
+
+type DBTable struct {
+	ID   int
+	Name string
+	Key  string
+	Type string
+}
+
+func GetTables(db *sql.DB) ([]DBTable, error) {
+	sqlStmt := `
+SELECT
+	c.relname as "name",
+	CASE c.relkind WHEN 'r' THEN 'table'
+		WHEN 'v' THEN 'view'
+		WHEN 'm' THEN 'materialized view'
+		WHEN 'f' THEN 'foreign table' 
+	END as "type"
+FROM pg_catalog.pg_class c
+	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind IN ('r','v','m','f','')
+	AND n.nspname <> ('pg_catalog')
+	AND n.nspname <> ('information_schema')
+	AND n.nspname !~ ('^pg_toast')
+AND pg_catalog.pg_table_is_visible(c.oid);`
+
+	var tables []DBTable
+
+	rows, err := db.Query(sqlStmt)
+	if err != nil {
+		return nil, fmt.Errorf("Error fetching tables: %s", err)
+	}
+	defer rows.Close()
+
+	for i := 0; rows.Next(); i++ {
+		t := DBTable{ID: i}
+		err = rows.Scan(&t.Name, &t.Type)
+		if err != nil {
+			return nil, err
+		}
+		t.Key = strings.ToLower(t.Name)
+		if t.Key != "schema_migrations" && t.Key != "ar_internal_metadata" {
+			tables = append(tables, t)
+		}
+	}
+
+	return tables, nil
+}
+
+type DBColumn struct {
+	ID         int16
+	Name       string
+	Key        string
+	Type       string
+	Array      bool
+	NotNull    bool
+	PrimaryKey bool
+	UniqueKey  bool
+	FKeyTable  string
+	FKeyColID  []int16
+	fKeyColID  pgtype.Int2Array
+}
+
+func GetColumns(db *sql.DB, schema, table string) ([]DBColumn, error) {
+	sqlStmt := `
+SELECT  
+	f.attnum AS id,  
+	f.attname AS name,  
+	f.attnotnull AS notnull,  
+	pg_catalog.format_type(f.atttypid,f.atttypmod) AS type,  
+	CASE
+	 WHEN f.attndims != 0 THEN true
+	 WHEN right(pg_catalog.format_type(f.atttypid,f.atttypmod), 2) = '[]' THEN true
+	 ELSE false
+	END AS array,
+	CASE  
+		WHEN p.contype = ('p'::char) THEN true  
+		ELSE false 
+	END AS primarykey,  
+	CASE  
+		WHEN p.contype = ('u'::char) THEN true  
+		ELSE false
+	END AS uniquekey,
+	CASE
+		WHEN p.contype = ('f'::char) THEN g.relname 
+		ELSE ''::text
+	END AS foreignkey,
+	CASE
+		WHEN p.contype = ('f'::char) THEN p.confkey::int2[]
+		ELSE ARRAY[]::int2[]
+	END AS foreignkey_fieldnum
+FROM pg_attribute f
+	JOIN pg_class c ON c.oid = f.attrelid  
+	LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum  
+	LEFT JOIN pg_namespace n ON n.oid = c.relnamespace  
+	LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)  
+	LEFT JOIN pg_class AS g ON p.confrelid = g.oid  
+WHERE c.relkind IN ('r', 'v', 'm', 'f')
+	AND n.nspname = $1  -- Replace with Schema name  
+	AND c.relname = $2  -- Replace with table name  
+	AND f.attnum > 0
+	AND f.attisdropped = false
+ORDER BY id;`
+
+	rows, err := db.Query(sqlStmt, schema, table)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching columns: %s", err)
+	}
+	defer rows.Close()
+
+	cmap := make(map[int16]DBColumn)
+
+	for rows.Next() {
+		c := DBColumn{}
+
+		err = rows.Scan(&c.ID, &c.Name, &c.NotNull, &c.Type, &c.Array, &c.PrimaryKey, &c.UniqueKey, &c.FKeyTable, &c.fKeyColID)
+		if err != nil {
+			return nil, err
+		}
+
+		if v, ok := cmap[c.ID]; ok {
+			if c.PrimaryKey {
+				v.PrimaryKey = true
+				v.UniqueKey = true
+			}
+			if c.NotNull {
+				v.NotNull = true
+			}
+			if c.UniqueKey {
+				v.UniqueKey = true
+			}
+			if c.Array {
+				v.Array = true
+			}
+			if len(c.FKeyTable) != 0 {
+				v.FKeyTable = c.FKeyTable
+			}
+			if c.fKeyColID.Elements != nil {
+				v.fKeyColID = c.fKeyColID
+				err := v.fKeyColID.AssignTo(&v.FKeyColID)
+				if err != nil {
+					return nil, err
+				}
+			}
+			cmap[c.ID] = v
+		} else {
+			err := c.fKeyColID.AssignTo(&c.FKeyColID)
+			if err != nil {
+				return nil, err
+			}
+			c.Key = strings.ToLower(c.Name)
+			if c.PrimaryKey {
+				c.UniqueKey = true
+			}
+			cmap[c.ID] = c
+		}
+	}
+
+	cols := make([]DBColumn, 0, len(cmap))
+	for i := range cmap {
+		cols = append(cols, cmap[i])
+	}
+
+	return cols, nil
+}
+
+// func GetValType(type string) qcode.ValType {
+// 	switch {
+// 		case "bigint", "integer", "smallint", "numeric", "bigserial":
+// 			return qcode.ValInt
+// 		case "double precision", "real":
+// 			return qcode.ValFloat
+// 		case ""
+// 	}
+// }

core/internal/psql/test_schema.go

@@ -0,0 +1,109 @@
+package psql
+
+import (
+	"log"
+	"strings"
+)
+
+func getTestSchema() *DBSchema {
+	tables := []DBTable{
+		DBTable{Name: "customers", Type: "table"},
+		DBTable{Name: "users", Type: "table"},
+		DBTable{Name: "products", Type: "table"},
+		DBTable{Name: "purchases", Type: "table"},
+		DBTable{Name: "tags", Type: "table"},
+		DBTable{Name: "tag_count", Type: "json"},
+	}
+
+	columns := [][]DBColumn{
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "full_name", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "phone", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "email", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "encrypted_password", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "reset_password_token", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "reset_password_sent_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "remember_created_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 10, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "full_name", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "phone", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "avatar", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "email", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "encrypted_password", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "reset_password_token", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "reset_password_sent_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "remember_created_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 10, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 11, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "name", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "description", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "price", Type: "numeric(7,2)", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "user_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "users", FKeyColID: []int16{1}},
+			DBColumn{ID: 6, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "tsv", Type: "tsvector", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "tags", Type: "text[]", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tags", FKeyColID: []int16{3}, Array: true},
+			DBColumn{ID: 9, Name: "tag_count", Type: "json", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tag_count", FKeyColID: []int16{}}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "customer_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "customers", FKeyColID: []int16{1}},
+			DBColumn{ID: 3, Name: "product_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "products", FKeyColID: []int16{1}},
+			DBColumn{ID: 4, Name: "sale_type", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "quantity", Type: "integer", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "due_date", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "returned", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "name", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "slug", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "tag_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tags", FKeyColID: []int16{1}},
+			DBColumn{ID: 2, Name: "count", Type: "int", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+	}
+
+	for i := range tables {
+		tables[i].Key = strings.ToLower(tables[i].Name)
+		for n := range columns[i] {
+			columns[i][n].Key = strings.ToLower(columns[i][n].Name)
+		}
+	}
+
+	schema := &DBSchema{
+		ver: 110000,
+		t:   make(map[string]*DBTableInfo),
+		rm:  make(map[string]map[string]*DBRel),
+	}
+
+	aliases := map[string][]string{
+		"users": []string{"mes"},
+	}
+
+	for i, t := range tables {
+		err := schema.addTable(t, columns[i], aliases)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	for i, t := range tables {
+		err := schema.firstDegreeRels(t, columns[i])
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	for i, t := range tables {
+		err := schema.secondDegreeRels(t, columns[i])
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	return schema
+}

core/internal/psql/tests.sql

@@ -0,0 +1,151 @@
+=== RUN   TestCompileInsert
+=== RUN   TestCompileInsert/simpleInsert
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email") SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t RETURNING *) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id" FROM (SELECT "users"."id" FROM "users" LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/singleInsert
+WITH "_sg_input" AS (SELECT '{{insert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description", "price", "user_id") SELECT "t"."name", "t"."description", "t"."price", "t"."user_id" FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/bulkInsert
+WITH "_sg_input" AS (SELECT '{{insert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT "t"."name", "t"."description" FROM "_sg_input" i, json_populate_recordset(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/simpleInsertWithPresets
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT "t"."name", "t"."price", 'now' :: timestamp without time zone, 'now' :: timestamp without time zone, '{{user_id}}' :: bigint FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id" FROM (SELECT "products"."id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertManyToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "price") SELECT "t"."name", "t"."price" FROM "_sg_input" i, json_populate_record(NULL::products, i.j->'product') t RETURNING *), "customers" AS (INSERT INTO "customers" ("full_name", "email") SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::customers, i.j->'customer') t RETURNING *), "purchases" AS (INSERT INTO "purchases" ("sale_type", "quantity", "due_date", "customer_id", "product_id") SELECT "t"."sale_type", "t"."quantity", "t"."due_date", "customers"."id", "products"."id" FROM "_sg_input" i, "customers", "products", json_populate_record(NULL::purchases, i.j) t RETURNING *) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "customers" AS (INSERT INTO "customers" ("full_name", "email") SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::customers, i.j->'customer') t RETURNING *), "products" AS (INSERT INTO "products" ("name", "price") SELECT "t"."name", "t"."price" FROM "_sg_input" i, json_populate_record(NULL::products, i.j->'product') t RETURNING *), "purchases" AS (INSERT INTO "purchases" ("sale_type", "quantity", "due_date", "product_id", "customer_id") SELECT "t"."sale_type", "t"."quantity", "t"."due_date", "products"."id", "customers"."id" FROM "_sg_input" i, "products", "customers", json_populate_record(NULL::purchases, i.j) t RETURNING *) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT "t"."full_name", "t"."email", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t RETURNING *), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at", "users"."id" FROM "_sg_input" i, "users", json_populate_record(NULL::products, i.j->'product') t RETURNING *) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOne
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT "t"."full_name", "t"."email", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::users, i.j->'user') t RETURNING *), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at", "users"."id" FROM "_sg_input" i, "users", json_populate_record(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToManyWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT "t"."full_name", "t"."email", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t RETURNING *), "products" AS ( UPDATE "products" SET "user_id" = "users"."id" FROM "users" WHERE ("products"."id"= ((i.j->'product'->'connect'->>'id'))::bigint) RETURNING "products".*) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOneWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint LIMIT 1), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at", "_x_users"."id" FROM "_sg_input" i, "_x_users", json_populate_record(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user", "__sj_2"."json" AS "tags" FROM (SELECT "products"."id", "products"."name", "products"."user_id", "products"."tags" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_2"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "tags_2"."id" AS "id", "tags_2"."name" AS "name" FROM (SELECT "tags"."id", "tags"."name" FROM "tags" WHERE ((("tags"."slug") = any ("products_0"."tags"))) LIMIT ('20') :: integer) AS "tags_2") AS "__sr_2") AS "__sj_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOneWithConnectArray
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id" = ANY((select a::bigint AS list from json_array_elements_text((i.j->'user'->'connect'->>'id')::json) AS a)) LIMIT 1), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at", "_x_users"."id" FROM "_sg_input" i, "_x_users", json_populate_record(NULL::products, i.j) t RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileInsert (0.02s)
+    --- PASS: TestCompileInsert/simpleInsert (0.00s)
+    --- PASS: TestCompileInsert/singleInsert (0.00s)
+    --- PASS: TestCompileInsert/bulkInsert (0.00s)
+    --- PASS: TestCompileInsert/simpleInsertWithPresets (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertManyToMany (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToMany (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOne (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToManyWithConnect (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOneWithConnect (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOneWithConnectArray (0.00s)
+=== RUN   TestCompileMutate
+=== RUN   TestCompileMutate/singleUpsert
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT "t"."name", "t"."description" FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t RETURNING *)  ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/singleUpsertWhere
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT "t"."name", "t"."description" FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t RETURNING *)  ON CONFLICT (id) WHERE (("products"."price") > '3' :: numeric(7,2)) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/bulkUpsert
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT "t"."name", "t"."description" FROM "_sg_input" i, json_populate_recordset(NULL::products, i.j) t RETURNING *)  ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/delete
+WITH "products" AS (DELETE FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") = '1' :: bigint)) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileMutate (0.01s)
+    --- PASS: TestCompileMutate/singleUpsert (0.00s)
+    --- PASS: TestCompileMutate/singleUpsertWhere (0.00s)
+    --- PASS: TestCompileMutate/bulkUpsert (0.00s)
+    --- PASS: TestCompileMutate/delete (0.00s)
+=== RUN   TestCompileQuery
+=== RUN   TestCompileQuery/withComplexArgs
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT DISTINCT ON ("products"."price") "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."id") < '28' :: bigint) AND (("products"."id") >= '20' :: bigint) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) ORDER BY "products"."price" DESC LIMIT ('30') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereAndList
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."price") > '10' :: numeric(7,2)) AND NOT (("products"."id") IS NULL) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereIsNull
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."price") > '10' :: numeric(7,2)) AND NOT (("products"."id") IS NULL) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereMultiOr
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND ((("products"."price") < '20' :: numeric(7,2)) OR (("products"."price") > '10' :: numeric(7,2)) OR NOT (("products"."id") IS NULL)))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/fetchByID
+SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") =  '{{id}}' :: bigint))) LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/searchQuery
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."search_rank" AS "search_rank", "products_0"."search_headline_description" AS "search_headline_description" FROM (SELECT "products"."id", "products"."name", ts_rank("products"."tsv", websearch_to_tsquery('{{query}}')) AS "search_rank", ts_headline("products"."description", websearch_to_tsquery('{{query}}')) AS "search_headline_description" FROM "products" WHERE ((("products"."tsv") @@ websearch_to_tsquery('{{query}}'))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToMany
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."email" AS "email", "__sj_1"."json" AS "products" FROM (SELECT "users"."email", "users"."id" FROM "users" LIMIT ('20') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id")) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToManyReverse
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."name" AS "name", "products_0"."price" AS "price", "__sj_1"."json" AS "users" FROM (SELECT "products"."name", "products"."price", "products"."user_id" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."email" AS "email" FROM (SELECT "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('20') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToManyArray
+SELECT jsonb_build_object('tags', "__sj_0"."json", 'product', "__sj_2"."json") as "__root" FROM (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "products_2"."name" AS "name", "products_2"."price" AS "price", "__sj_3"."json" AS "tags" FROM (SELECT "products"."name", "products"."price", "products"."tags" FROM "products" LIMIT ('1') :: integer) AS "products_2" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_3"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_3") AS "json"FROM (SELECT "tags_3"."id" AS "id", "tags_3"."name" AS "name" FROM (SELECT "tags"."id", "tags"."name" FROM "tags" WHERE ((("tags"."slug") = any ("products_2"."tags"))) LIMIT ('20') :: integer) AS "tags_3") AS "__sr_3") AS "__sj_3") AS "__sj_3" ON ('true')) AS "__sr_2") AS "__sj_2", (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "tags_0"."name" AS "name", "__sj_1"."json" AS "product" FROM (SELECT "tags"."name", "tags"."slug" FROM "tags" LIMIT ('20') :: integer) AS "tags_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."name" AS "name" FROM (SELECT "products"."name" FROM "products" WHERE ((("tags_0"."slug") = any ("products"."tags"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/manyToMany
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."name" AS "name", "__sj_1"."json" AS "customers" FROM (SELECT "products"."name", "products"."id" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "customers_1"."email" AS "email", "customers_1"."full_name" AS "full_name" FROM (SELECT "customers"."email", "customers"."full_name" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_0"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('20') :: integer) AS "customers_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/manyToManyReverse
+SELECT jsonb_build_object('customers', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "customers_0"."email" AS "email", "customers_0"."full_name" AS "full_name", "__sj_1"."json" AS "products" FROM (SELECT "customers"."email", "customers"."full_name", "customers"."id" FROM "customers" LIMIT ('20') :: integer) AS "customers_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."name" AS "name" FROM (SELECT "products"."name" FROM "products" LEFT OUTER JOIN "purchases" ON (("purchases"."customer_id") = ("customers_0"."id")) WHERE ((("products"."id") = ("purchases"."product_id")) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunction
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."name" AS "name", "products_0"."count_price" AS "count_price" FROM (SELECT "products"."name", count("products"."price") AS "count_price" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionBlockedByCol
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."name" AS "name" FROM (SELECT "products"."name" FROM "products" GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionDisabled
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."name" AS "name" FROM (SELECT "products"."name" FROM "products" GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionWithFilter
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."max_price" AS "max_price" FROM (SELECT "products"."id", max("products"."price") AS "max_price" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") > '10' :: bigint))) GROUP BY "products"."id" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/syntheticTables
+SELECT jsonb_build_object('me', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT  FROM (SELECT "users"."email" FROM "users" WHERE ((("users"."id") =  '{{user_id}}' :: bigint)) LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/queryWithVariables
+SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE (((("products"."price") =  '{{product_price}}' :: numeric(7,2)) AND (("products"."id") =  '{{product_id}}' :: bigint) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereOnRelations
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."email" AS "email" FROM (SELECT "users"."id", "users"."email" FROM "users" WHERE (NOT EXISTS (SELECT 1 FROM products WHERE (("products"."user_id") = ("users"."id")) AND ((("products"."price") > '3' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/multiRoot
+SELECT jsonb_build_object('customer', "__sj_0"."json", 'user', "__sj_1"."json", 'product', "__sj_2"."json") as "__root" FROM (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "products_2"."id" AS "id", "products_2"."name" AS "name", "__sj_3"."json" AS "customers", "__sj_4"."json" AS "customer" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('1') :: integer) AS "products_2" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_4") AS "json"FROM (SELECT "customers_4"."email" AS "email" FROM (SELECT "customers"."email" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_2"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('1') :: integer) AS "customers_4") AS "__sr_4") AS "__sj_4" ON ('true') LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_3"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_3") AS "json"FROM (SELECT "customers_3"."email" AS "email" FROM (SELECT "customers"."email" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_2"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('20') :: integer) AS "customers_3") AS "__sr_3") AS "__sj_3") AS "__sj_3" ON ('true')) AS "__sr_2") AS "__sj_2", (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1", (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "customers_0"."id" AS "id" FROM (SELECT "customers"."id" FROM "customers" LIMIT ('1') :: integer) AS "customers_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/jsonColumnAsTable
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "tag_count" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "tag_count_1"."count" AS "count", "__sj_2"."json" AS "tags" FROM (SELECT "tag_count"."count", "tag_count"."tag_id" FROM "products", json_to_recordset("products"."tag_count") AS "tag_count"(tag_id bigint, count int) WHERE ((("products"."id") = ("products_0"."id"))) LIMIT ('1') :: integer) AS "tag_count_1" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_2"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "tags_2"."name" AS "name" FROM (SELECT "tags"."name" FROM "tags" WHERE ((("tags"."id") = ("tag_count_1"."tag_id"))) LIMIT ('20') :: integer) AS "tags_2") AS "__sr_2") AS "__sj_2") AS "__sj_2" ON ('true')) AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withCursor
+SELECT jsonb_build_object('products', "__sj_0"."json", 'products_cursor', "__sj_0"."cursor") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json", CONCAT_WS(',', max("__cur_0"), max("__cur_1")) as "cursor" FROM (SELECT to_jsonb("__sr_0") - '__cur_0' - '__cur_1' AS "json", "__cur_0", "__cur_1"FROM (SELECT "products_0"."name" AS "name", LAST_VALUE("products_0"."price") OVER() AS "__cur_0", LAST_VALUE("products_0"."id") OVER() AS "__cur_1" FROM (WITH "__cur" AS (SELECT a[1] as "price", a[2] as "id" FROM string_to_array('{{cursor}}', ',') as a) SELECT "products"."name", "products"."id", "products"."price" FROM "products", "__cur" WHERE (((("products"."price") < "__cur"."price" :: numeric(7,2)) OR ((("products"."price") = "__cur"."price" :: numeric(7,2)) AND (("products"."id") > "__cur"."id" :: bigint)))) ORDER BY "products"."price" DESC, "products"."id" ASC LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/nullForAuthRequiredInAnon
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", NULL AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/blockedQuery
+SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE (false) LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/blockedFunctions
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."email" AS "email" FROM (SELECT , "users"."email" FROM "users" WHERE (false) GROUP BY "users"."email" LIMIT ('20') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+--- PASS: TestCompileQuery (0.02s)
+    --- PASS: TestCompileQuery/withComplexArgs (0.00s)
+    --- PASS: TestCompileQuery/withWhereAndList (0.00s)
+    --- PASS: TestCompileQuery/withWhereIsNull (0.00s)
+    --- PASS: TestCompileQuery/withWhereMultiOr (0.00s)
+    --- PASS: TestCompileQuery/fetchByID (0.00s)
+    --- PASS: TestCompileQuery/searchQuery (0.00s)
+    --- PASS: TestCompileQuery/oneToMany (0.00s)
+    --- PASS: TestCompileQuery/oneToManyReverse (0.00s)
+    --- PASS: TestCompileQuery/oneToManyArray (0.00s)
+    --- PASS: TestCompileQuery/manyToMany (0.00s)
+    --- PASS: TestCompileQuery/manyToManyReverse (0.00s)
+    --- PASS: TestCompileQuery/aggFunction (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionBlockedByCol (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionDisabled (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionWithFilter (0.00s)
+    --- PASS: TestCompileQuery/syntheticTables (0.00s)
+    --- PASS: TestCompileQuery/queryWithVariables (0.00s)
+    --- PASS: TestCompileQuery/withWhereOnRelations (0.00s)
+    --- PASS: TestCompileQuery/multiRoot (0.00s)
+    --- PASS: TestCompileQuery/jsonColumnAsTable (0.00s)
+    --- PASS: TestCompileQuery/withCursor (0.00s)
+    --- PASS: TestCompileQuery/nullForAuthRequiredInAnon (0.00s)
+    --- PASS: TestCompileQuery/blockedQuery (0.00s)
+    --- PASS: TestCompileQuery/blockedFunctions (0.00s)
+=== RUN   TestCompileUpdate
+=== RUN   TestCompileUpdate/singleUpdate
+WITH "_sg_input" AS (SELECT '{{update}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "description") = (SELECT "t"."name", "t"."description" FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t) WHERE ((("products"."id") = '1' :: bigint) AND (("products"."id") =  '{{id}}' :: bigint)) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/simpleUpdateWithPresets
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "price", "updated_at") = (SELECT "t"."name", "t"."price", 'now' :: timestamp without time zone FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t) WHERE (("products"."user_id") =  '{{user_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id" FROM (SELECT "products"."id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateManyToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "purchases" AS (UPDATE "purchases" SET ("sale_type", "quantity", "due_date") = (SELECT "t"."sale_type", "t"."quantity", "t"."due_date" FROM "_sg_input" i, json_populate_record(NULL::purchases, i.j) t) WHERE (("purchases"."id") =  '{{id}}' :: bigint) RETURNING "purchases".*), "products" AS (UPDATE "products" SET ("name", "price") = (SELECT "t"."name", "t"."price" FROM "_sg_input" i, json_populate_record(NULL::products, i.j->'product') t) FROM "purchases" WHERE (("products"."id") = ("purchases"."product_id")) RETURNING "products".*), "customers" AS (UPDATE "customers" SET ("full_name", "email") = (SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::customers, i.j->'customer') t) FROM "purchases" WHERE (("customers"."id") = ("purchases"."customer_id")) RETURNING "customers".*) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "purchases" AS (UPDATE "purchases" SET ("sale_type", "quantity", "due_date") = (SELECT "t"."sale_type", "t"."quantity", "t"."due_date" FROM "_sg_input" i, json_populate_record(NULL::purchases, i.j) t) WHERE (("purchases"."id") =  '{{id}}' :: bigint) RETURNING "purchases".*), "customers" AS (UPDATE "customers" SET ("full_name", "email") = (SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::customers, i.j->'customer') t) FROM "purchases" WHERE (("customers"."id") = ("purchases"."customer_id")) RETURNING "customers".*), "products" AS (UPDATE "products" SET ("name", "price") = (SELECT "t"."name", "t"."price" FROM "_sg_input" i, json_populate_record(NULL::products, i.j->'product') t) FROM "purchases" WHERE (("products"."id") = ("purchases"."product_id")) RETURNING "products".*) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2") AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (UPDATE "users" SET ("full_name", "email", "created_at", "updated_at") = (SELECT "t"."full_name", "t"."email", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t) WHERE (("users"."id") = '8' :: bigint) RETURNING "users".*), "products" AS (UPDATE "products" SET ("name", "price", "created_at", "updated_at") = (SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::products, i.j->'product') t) FROM "users" WHERE (("products"."user_id") = ("users"."id") AND "products"."id"= ((i.j->'product'->'where'->>'id'))::bigint) RETURNING "products".*) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOne
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "price", "created_at", "updated_at") = (SELECT "t"."name", "t"."price", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") =  '{{id}}' :: bigint) RETURNING "products".*), "users" AS (UPDATE "users" SET ("email") = (SELECT "t"."email" FROM "_sg_input" i, json_populate_record(NULL::users, i.j->'user') t) FROM "products" WHERE (("users"."id") = ("products"."user_id")) RETURNING "users".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToManyWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (UPDATE "users" SET ("full_name", "email", "created_at", "updated_at") = (SELECT "t"."full_name", "t"."email", "t"."created_at", "t"."updated_at" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t) WHERE (("users"."id") =  '{{id}}' :: bigint) RETURNING "users".*), "products_c" AS ( UPDATE "products" SET "user_id" = "users"."id" FROM "users" WHERE ("products"."id"= ((i.j->'product'->'connect'->>'id'))::bigint) RETURNING "products".*), "products_d" AS ( UPDATE "products" SET "user_id" =  NULL FROM "users" WHERE ("products"."id"= ((i.j->'product'->'disconnect'->>'id'))::bigint) RETURNING "products".*), "products" AS (SELECT * FROM "products_c" UNION ALL SELECT * FROM "products_d") SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOneWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint AND "users"."email"= ((i.j->'user'->'connect'->>'email'))::character varying LIMIT 1), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT "t"."name", "t"."price", "_x_users"."id" FROM "_sg_input" i, "_x_users", json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") =  '{{product_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."email"= ((i.j->'user'->'connect'->>'email'))::character varying AND "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint LIMIT 1), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT "t"."name", "t"."price", "_x_users"."id" FROM "_sg_input" i, "_x_users", json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") =  '{{product_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1") AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOneWithDisconnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT * FROM (VALUES(NULL::bigint)) AS LOOKUP("id")), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT "t"."name", "t"."price", "_x_users"."id" FROM "_sg_input" i, "_x_users", json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") =  '{{id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0") AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."user_id" AS "user_id" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileUpdate (0.02s)
+    --- PASS: TestCompileUpdate/singleUpdate (0.00s)
+    --- PASS: TestCompileUpdate/simpleUpdateWithPresets (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateManyToMany (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToMany (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOne (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToManyWithConnect (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOneWithConnect (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOneWithDisconnect (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/core/internal/psql	0.320s

core/internal/psql/update.go

@@ -0,0 +1,237 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+func (c *compilerContext) renderUpdate(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+
+	update, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not !defined", qc.ActionVar)
+	}
+	if len(update) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	io.WriteString(c.w, `WITH "_sg_input" AS (SELECT '{{`)
+	io.WriteString(c.w, qc.ActionVar)
+	io.WriteString(c.w, `}}' :: json AS j)`)
+
+	st := util.NewStack()
+	st.Push(kvitem{_type: itemUpdate, key: ti.Name, val: update, ti: ti})
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+		if update[0] == '[' && st.Len() > 1 {
+			return 0, errors.New("Nested bulk update not supported")
+		}
+		intf := st.Pop()
+
+		switch item := intf.(type) {
+		case kvitem:
+			if err := c.handleKVItem(st, item); err != nil {
+				return 0, err
+			}
+
+		case renitem:
+			var err error
+
+			// if w := qc.Selects[0].Where; w != nil && w.Op == qcode.OpFalse {
+			// 	io.WriteString(c.w, ` WHERE false`)
+			// }
+
+			switch item._type {
+			case itemUpdate:
+				err = c.renderUpdateStmt(w, qc, item)
+			case itemConnect:
+				err = c.renderConnectStmt(qc, w, item)
+			case itemDisconnect:
+				err = c.renderDisconnectStmt(qc, w, item)
+			case itemUnion:
+				err = c.renderUnionStmt(w, item)
+			}
+
+			if err != nil {
+				return 0, err
+			}
+
+		}
+	}
+	io.WriteString(c.w, ` `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderUpdateStmt(w io.Writer, qc *qcode.QCode, item renitem) error {
+	ti := item.ti
+	jt := item.data
+	sk := nestedUpdateRelColumnsMap(item.kvitem)
+
+	io.WriteString(c.w, `, `)
+	renderCteName(c.w, item.kvitem)
+	io.WriteString(c.w, ` AS (`)
+
+	io.WriteString(w, `UPDATE `)
+	quoted(w, ti.Name)
+	io.WriteString(w, ` SET (`)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, false)
+	renderNestedUpdateRelColumns(w, item.kvitem, false)
+
+	io.WriteString(w, `) = (SELECT `)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, true)
+	renderNestedUpdateRelColumns(w, item.kvitem, true)
+
+	io.WriteString(w, ` FROM "_sg_input" i, `)
+	renderNestedUpdateRelTables(w, item.kvitem)
+
+	if item.array {
+		io.WriteString(w, `json_populate_recordset`)
+	} else {
+		io.WriteString(w, `json_populate_record`)
+	}
+
+	io.WriteString(w, `(NULL::`)
+	io.WriteString(w, ti.Name)
+
+	if len(item.path) == 0 {
+		io.WriteString(w, `, i.j) t)`)
+	} else {
+		io.WriteString(w, `, i.j->`)
+		joinPath(w, item.path)
+		io.WriteString(w, `) t) `)
+	}
+
+	if item.id != 0 {
+		// Render sql to set id values if child-to-parent
+		// relationship is one-to-one
+		rel := item.relCP
+
+		io.WriteString(w, `FROM `)
+		quoted(w, rel.Right.Table)
+
+		io.WriteString(w, ` WHERE ((`)
+		colWithTable(w, rel.Left.Table, rel.Left.Col)
+		io.WriteString(w, `) = (`)
+		colWithTable(w, rel.Right.Table, rel.Right.Col)
+		io.WriteString(w, `)`)
+
+		if item.relPC.Type == RelOneToMany {
+			if conn, ok := item.data["where"]; ok {
+				io.WriteString(w, ` AND `)
+				renderWhereFromJSON(w, item.kvitem, "where", conn)
+			} else if conn, ok := item.data["_where"]; ok {
+				io.WriteString(w, ` AND `)
+				renderWhereFromJSON(w, item.kvitem, "_where", conn)
+			}
+		}
+		io.WriteString(w, `)`)
+
+	} else {
+		io.WriteString(w, ` WHERE `)
+		if err := c.renderWhere(&qc.Selects[0], ti); err != nil {
+			return err
+		}
+	}
+
+	io.WriteString(w, ` RETURNING `)
+	quoted(w, ti.Name)
+	io.WriteString(w, `.*)`)
+
+	return nil
+}
+
+func nestedUpdateRelColumnsMap(item kvitem) map[string]struct{} {
+	sk := make(map[string]struct{}, len(item.items))
+
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			sk[v.relCP.Right.Col] = struct{}{}
+		}
+	}
+
+	return sk
+}
+
+func renderNestedUpdateRelColumns(w io.Writer, item kvitem, values bool) error {
+	// Render child foreign key columns if child-to-parent
+	// relationship is one-to-many
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			if values {
+				// if v.relCP.Right.Array {
+				// 	io.WriteString(w, `array_diff(`)
+				// 	colWithTable(w, v.relCP.Right.Table, v.relCP.Right.Col)
+				// 	io.WriteString(w, `, `)
+				// }
+
+				if v._ctype > 0 {
+					io.WriteString(w, `"_x_`)
+					io.WriteString(w, v.relCP.Left.Table)
+					io.WriteString(w, `".`)
+					quoted(w, v.relCP.Left.Col)
+				} else {
+					colWithTable(w, v.relCP.Left.Table, v.relCP.Left.Col)
+				}
+
+				// if v.relCP.Right.Array {
+				// 	io.WriteString(w, `)`)
+				// }
+			} else {
+
+				quoted(w, v.relCP.Right.Col)
+
+			}
+		}
+	}
+
+	return nil
+}
+
+func renderNestedUpdateRelTables(w io.Writer, item kvitem) error {
+	// Render tables needed to set values if child-to-parent
+	// relationship is one-to-many
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			io.WriteString(w, `"_x_`)
+			io.WriteString(w, v.relCP.Left.Table)
+			io.WriteString(w, `", `)
+		}
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderDelete(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+	root := &qc.Selects[0]
+
+	io.WriteString(c.w, `WITH `)
+	quoted(c.w, ti.Name)
+
+	io.WriteString(c.w, ` AS (DELETE FROM `)
+	quoted(c.w, ti.Name)
+	io.WriteString(c.w, ` WHERE `)
+
+	if root.Where == nil {
+		return 0, errors.New("'where' clause missing in delete mutation")
+	}
+
+	if err := c.renderWhere(root, ti); err != nil {
+		return 0, err
+	}
+
+	io.WriteString(w, ` RETURNING `)
+	quoted(w, ti.Name)
+	io.WriteString(w, `.*) `)
+	return 0, nil
+}

core/internal/psql/update_test.go

@@ -0,0 +1,258 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func singleUpdate(t *testing.T) {
+	gql := `mutation {
+		product(id: $id, update: $update, where: { id: { eq: 1 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"update": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func simpleUpdateWithPresets(t *testing.T) {
+	gql := `mutation {
+		product(update: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"name": "Apple", "price": 1.25}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func nestedUpdateManyToMany(t *testing.T) {
+	gql := `mutation {
+		purchase(update: $data, id: $id) {
+			sale_type
+			quantity
+			due_date
+			customer {
+				id
+				full_name
+				email
+			}
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(` {
+			"sale_type": "bought",
+			"quantity": 5,
+			"due_date": "now",
+			"customer": {
+				"email": "thedude@rug.com",
+				"full_name": "The Dude"
+			},
+			"product": {
+				"name": "Apple",
+				"price": 1.25
+			}
+		}
+	`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToMany(t *testing.T) {
+	gql := `mutation {
+		user(update: $data, where: { id: { eq: 8 } }) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"where": {
+					"id": 2
+				},
+				"name": "Apple",
+				"price": 1.25,
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOne(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $id) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"email": "thedude@rug.com"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+
+}
+
+func nestedUpdateOneToManyWithConnect(t *testing.T) {
+	gql := `mutation {
+		user(update: $data, id: $id) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"connect": { "id": 7 },
+				"disconnect": { "id": 8 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOneWithConnect(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $product_id) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"user": {
+				"connect": { "id": 5, "email": "test@test.com" }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOneWithDisconnect(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $id) {
+			id
+			name
+			user_id
+		}
+	}`
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"user": {
+				"disconnect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+// func nestedUpdateOneToOneWithDisconnectArray(t *testing.T) {
+// 	gql := `mutation {
+// 		product(update: $data, id: 2) {
+// 			id
+// 			name
+// 			user_id
+// 		}
+// 	}`
+
+// 	sql := `WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (SELECT * FROM (VALUES(NULL::bigint)) AS LOOKUP("id")), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT "t"."name", "t"."price", "users"."id" FROM "_sg_input" i, "users", json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") = 2) RETURNING "products".*) SELECT json_object_agg('product', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."user_id" AS "user_id") AS "json_row_0")) AS "json_0" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{
+// 			"name": "Apple",
+// 			"price": 1.25,
+// 			"user": {
+// 				"disconnect": { "id": 5 }
+// 			}
+// 		}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "admin")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+func TestCompileUpdate(t *testing.T) {
+	t.Run("singleUpdate", singleUpdate)
+	t.Run("simpleUpdateWithPresets", simpleUpdateWithPresets)
+	t.Run("nestedUpdateManyToMany", nestedUpdateManyToMany)
+	t.Run("nestedUpdateOneToMany", nestedUpdateOneToMany)
+	t.Run("nestedUpdateOneToOne", nestedUpdateOneToOne)
+	t.Run("nestedUpdateOneToManyWithConnect", nestedUpdateOneToManyWithConnect)
+	t.Run("nestedUpdateOneToOneWithConnect", nestedUpdateOneToOneWithConnect)
+	t.Run("nestedUpdateOneToOneWithDisconnect", nestedUpdateOneToOneWithDisconnect)
+	//t.Run("nestedUpdateOneToOneWithDisconnectArray", nestedUpdateOneToOneWithDisconnectArray)
+}

core/internal/psql/utils.go

@@ -0,0 +1,13 @@
+package psql
+
+import "regexp"
+
+func NewVariables(varlist map[string]string) map[string]string {
+	re := regexp.MustCompile(`(?mi)\$([a-zA-Z0-9_.]+)`)
+	vars := make(map[string]string, len(varlist))
+
+	for k, v := range varlist {
+		vars[k] = re.ReplaceAllString(v, `{{$1}}`)
+	}
+	return vars
+}