Refactor Super Graph into a library #26

core/internal/allow/allow.go

@@ -0,0 +1,361 @@
+package allow
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"sort"
+	"strings"
+)
+
+const (
+	AL_QUERY int = iota + 1
+	AL_VARS
+)
+
+type Item struct {
+	Name    string
+	key     string
+	Query   string
+	Vars    json.RawMessage
+	Comment string
+}
+
+type List struct {
+	filepath string
+	saveChan chan Item
+}
+
+type Config struct {
+	CreateIfNotExists bool
+	Persist           bool
+}
+
+func New(cpath string, conf Config) (*List, error) {
+	al := List{}
+
+	if len(cpath) != 0 {
+		fp := path.Join(cpath, "allow.list")
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		fp := "./allow.list"
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		fp := "./config/allow.list"
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		if !conf.CreateIfNotExists {
+			return nil, errors.New("allow.list not found")
+		}
+
+		if len(cpath) == 0 {
+			al.filepath = "./config/allow.list"
+		} else {
+			al.filepath = path.Join(cpath, "allow.list")
+		}
+	}
+
+	var err error
+
+	if conf.Persist {
+		al.saveChan = make(chan Item)
+
+		go func() {
+			for v := range al.saveChan {
+				if err = al.save(v); err != nil {
+					break
+				}
+			}
+		}()
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &al, nil
+}
+
+func (al *List) IsPersist() bool {
+	return al.saveChan != nil
+}
+
+func (al *List) Set(vars []byte, query, comment string) error {
+	if al.saveChan == nil {
+		return errors.New("allow.list is read-only")
+	}
+
+	if len(query) == 0 {
+		return errors.New("empty query")
+	}
+
+	var q string
+
+	for i := 0; i < len(query); i++ {
+		c := query[i]
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' {
+			q = query
+			break
+
+		} else if c == '{' {
+			q = "query " + query
+			break
+		}
+	}
+
+	al.saveChan <- Item{
+		Comment: comment,
+		Query:   q,
+		Vars:    vars,
+	}
+
+	return nil
+}
+
+func (al *List) Load() ([]Item, error) {
+	var list []Item
+
+	b, err := ioutil.ReadFile(al.filepath)
+	if err != nil {
+		return list, err
+	}
+
+	if len(b) == 0 {
+		return list, nil
+	}
+
+	var comment bytes.Buffer
+	var varBytes []byte
+
+	itemMap := make(map[string]struct{})
+
+	s, e, c := 0, 0, 0
+	ty := 0
+
+	for {
+		fq := false
+
+		if c == 0 && b[e] == '#' {
+			s = e
+			for e < len(b) && b[e] != '\n' {
+				e++
+			}
+			if (e - s) > 2 {
+				comment.Write(b[(s + 1):(e + 1)])
+			}
+		}
+
+		if e >= len(b) {
+			break
+		}
+
+		if matchPrefix(b, e, "query") || matchPrefix(b, e, "mutation") {
+			if c == 0 {
+				s = e
+			}
+			ty = AL_QUERY
+		} else if matchPrefix(b, e, "variables") {
+			if c == 0 {
+				s = e + len("variables") + 1
+			}
+			ty = AL_VARS
+		} else if b[e] == '{' {
+			c++
+
+		} else if b[e] == '}' {
+			c--
+
+			if c == 0 {
+				if ty == AL_QUERY {
+					fq = true
+				} else if ty == AL_VARS {
+					varBytes = b[s:(e + 1)]
+				}
+				ty = 0
+			}
+		}
+
+		if fq {
+			query := string(b[s:(e + 1)])
+			name := QueryName(query)
+			key := strings.ToLower(name)
+
+			if _, ok := itemMap[key]; !ok {
+				v := Item{
+					Name:    name,
+					key:     key,
+					Query:   query,
+					Vars:    varBytes,
+					Comment: comment.String(),
+				}
+				list = append(list, v)
+				comment.Reset()
+			}
+
+			varBytes = nil
+
+		}
+
+		e++
+		if e >= len(b) {
+			break
+		}
+	}
+
+	return list, nil
+}
+
+func (al *List) save(item Item) error {
+	item.Name = QueryName(item.Query)
+	item.key = strings.ToLower(item.Name)
+
+	if len(item.Name) == 0 {
+		return nil
+	}
+
+	list, err := al.Load()
+	if err != nil {
+		return err
+	}
+
+	index := -1
+
+	for i, v := range list {
+		if strings.EqualFold(v.Name, item.Name) {
+			index = i
+			break
+		}
+	}
+
+	if index != -1 {
+		if len(list[index].Comment) != 0 {
+			item.Comment = list[index].Comment
+		}
+		list[index] = item
+	} else {
+		list = append(list, item)
+	}
+
+	f, err := os.Create(al.filepath)
+	if err != nil {
+		return err
+	}
+
+	defer f.Close()
+
+	sort.Slice(list, func(i, j int) bool {
+		return strings.Compare(list[i].key, list[j].key) == -1
+	})
+
+	for _, v := range list {
+		cmtLines := strings.Split(v.Comment, "\n")
+
+		i := 0
+		for _, c := range cmtLines {
+			if c = strings.TrimSpace(c); len(c) == 0 {
+				continue
+			}
+
+			_, err := f.WriteString(fmt.Sprintf("# %s\n", c))
+			if err != nil {
+				return err
+			}
+			i++
+		}
+
+		if i != 0 {
+			if _, err := f.WriteString("\n"); err != nil {
+				return err
+			}
+		} else {
+			if _, err := f.WriteString(fmt.Sprintf("# Query named %s\n\n", v.Name)); err != nil {
+				return err
+			}
+		}
+
+		if len(v.Vars) != 0 && !bytes.Equal(v.Vars, []byte("{}")) {
+			vj, err := json.MarshalIndent(v.Vars, "", "  ")
+			if err != nil {
+				return fmt.Errorf("failed to marshal vars: %v", err)
+			}
+
+			_, err = f.WriteString(fmt.Sprintf("variables %s\n\n", vj))
+			if err != nil {
+				return err
+			}
+		}
+
+		if v.Query[0] == '{' {
+			_, err = f.WriteString(fmt.Sprintf("query %s\n\n", v.Query))
+		} else {
+			_, err = f.WriteString(fmt.Sprintf("%s\n\n", v.Query))
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func matchPrefix(b []byte, i int, s string) bool {
+	if (len(b) - i) < len(s) {
+		return false
+	}
+	for n := 0; n < len(s); n++ {
+		if b[(i+n)] != s[n] {
+			return false
+		}
+	}
+	return true
+}
+
+func QueryName(b string) string {
+	state, s := 0, 0
+
+	for i := 0; i < len(b); i++ {
+		switch {
+		case state == 2 && !isValidNameChar(b[i]):
+			return b[s:i]
+		case state == 1 && b[i] == '{':
+			return ""
+		case state == 1 && isValidNameChar(b[i]):
+			s = i
+			state = 2
+		case i != 0 && b[i] == ' ' && (b[i-1] == 'n' || b[i-1] == 'y'):
+			state = 1
+		}
+	}
+
+	return ""
+}
+
+func isValidNameChar(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
+}

core/internal/allow/allow_test.go

@@ -0,0 +1,84 @@
+package allow
+
+import (
+	"testing"
+)
+
+func TestGQLName1(t *testing.T) {
+	var q = `
+	query {
+		products(
+			distinct: [price]
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
+		) { id name } }`
+
+	name := QueryName(q)
+
+	if len(name) != 0 {
+		t.Fatal("Name should be empty, not ", name)
+	}
+}
+
+func TestGQLName2(t *testing.T) {
+	var q = `
+	query hakuna_matata
+	
+	{
+		products(
+			distinct: [price]
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
+		) {
+			id
+			name
+		}
+	}`
+
+	name := QueryName(q)
+
+	if name != "hakuna_matata" {
+		t.Fatal("Name should be 'hakuna_matata', not ", name)
+	}
+}
+
+func TestGQLName3(t *testing.T) {
+	var q = `
+	mutation means{ users { id } }`
+
+	// var v2 = `   { products( limit: 30, order_by: { price: desc }, distinct: [ price ] where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) { id name price user { id email } } } `
+
+	name := QueryName(q)
+
+	if name != "means" {
+		t.Fatal("Name should be 'means', not ", name)
+	}
+}
+
+func TestGQLName4(t *testing.T) {
+	var q = `
+	query no_worries 
+		users {
+			id
+		}
+	}`
+
+	name := QueryName(q)
+
+	if name != "no_worries" {
+		t.Fatal("Name should be 'no_worries', not ", name)
+	}
+}
+
+func TestGQLName5(t *testing.T) {
+	var q = `
+	    {
+		users {
+			id
+		}
+	}`
+
+	name := QueryName(q)
+
+	if len(name) != 0 {
+		t.Fatal("Name should be empty, not ", name)
+	}
+}

core/internal/allow/fuzz_test.go

@@ -0,0 +1,15 @@
+package allow
+
+import "testing"
+
+func TestFuzzCrashers(t *testing.T) {
+	var crashers = []string{
+		"query",
+		"q",
+		"que",
+	}
+
+	for _, f := range crashers {
+		_ = QueryName(f)
+	}
+}

core/internal/crypto/encrypt.go

@@ -0,0 +1,80 @@
+// cryptopasta - basic cryptography examples
+//
+// Written in 2015 by George Tankersley <george.tankersley@gmail.com>
+//
+// To the extent possible under law, the author(s) have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication along
+// with this software. If not, see // <http://creativecommons.org/publicdomain/zero/1.0/>.
+
+// Provides symmetric authenticated encryption using 256-bit AES-GCM with a random nonce.
+package crypto
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"errors"
+	"io"
+)
+
+// NewEncryptionKey generates a random 256-bit key for Encrypt() and
+// Decrypt(). It panics if the source of randomness fails.
+func NewEncryptionKey() [32]byte {
+	key := [32]byte{}
+	_, err := io.ReadFull(rand.Reader, key[:])
+	if err != nil {
+		panic(err)
+	}
+	return key
+}
+
+// Encrypt encrypts data using 256-bit AES-GCM.  This both hides the content of
+// the data and provides a check that it hasn't been altered. Output takes the
+// form nonce|ciphertext|tag where '|' indicates concatenation.
+func Encrypt(plaintext []byte, key *[32]byte) (ciphertext []byte, err error) {
+	block, err := aes.NewCipher(key[:])
+	if err != nil {
+		return nil, err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	_, err = io.ReadFull(rand.Reader, nonce)
+	if err != nil {
+		return nil, err
+	}
+
+	return gcm.Seal(nonce, nonce, plaintext, nil), nil
+}
+
+// Decrypt decrypts data using 256-bit AES-GCM.  This both hides the content of
+// the data and provides a check that it hasn't been altered. Expects input
+// form nonce|ciphertext|tag where '|' indicates concatenation.
+func Decrypt(ciphertext []byte, key *[32]byte) (plaintext []byte, err error) {
+	block, err := aes.NewCipher(key[:])
+	if err != nil {
+		return nil, err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ciphertext) < gcm.NonceSize() {
+		return nil, errors.New("malformed ciphertext")
+	}
+
+	return gcm.Open(nil,
+		ciphertext[:gcm.NonceSize()],
+		ciphertext[gcm.NonceSize():],
+		nil,
+	)
+}

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
+}

core/internal/qcode/bench.0

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/qcode
+BenchmarkQCompile-8    	  100000	     18528 ns/op	    9208 B/op	     107 allocs/op
+BenchmarkQCompileP-8   	  300000	      5952 ns/op	    9208 B/op	     107 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/qcode	3.893s

core/internal/qcode/bench.1

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/qcode
+BenchmarkQCompile-8    	  100000	     18240 ns/op	    7454 B/op	      88 allocs/op
+BenchmarkQCompileP-8   	  300000	      5788 ns/op	    7494 B/op	      88 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/qcode	3.813s

core/internal/qcode/bench.2

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/qcode
+BenchmarkQCompile-8    	  100000	     17231 ns/op	    3352 B/op	      87 allocs/op
+BenchmarkQCompileP-8   	  300000	      5023 ns/op	    3387 B/op	      87 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/qcode	3.462s

core/internal/qcode/bench.3

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/qcode
+BenchmarkQCompile-8    	  200000	     10029 ns/op	    2291 B/op	      38 allocs/op
+BenchmarkQCompileP-8   	  500000	      2925 ns/op	    2298 B/op	      38 allocs/op
+PASS
+ok  	github.com/dosco/super-graph/qcode	3.616s

core/internal/qcode/cleanup.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+cd corpus && rm -rf $(find . ! -name '00?.gql')

core/internal/qcode/config.go

@@ -0,0 +1,136 @@
+package qcode
+
+import (
+	"regexp"
+	"sort"
+	"strings"
+)
+
+type Config struct {
+	Blocklist []string
+}
+
+type QueryConfig struct {
+	Limit            int
+	Filters          []string
+	Columns          []string
+	DisableFunctions bool
+}
+
+type InsertConfig struct {
+	Filters []string
+	Columns []string
+	Presets map[string]string
+}
+
+type UpdateConfig struct {
+	Filters []string
+	Columns []string
+	Presets map[string]string
+}
+
+type DeleteConfig struct {
+	Filters []string
+	Columns []string
+}
+
+type TRConfig struct {
+	Query  QueryConfig
+	Insert InsertConfig
+	Update UpdateConfig
+	Delete DeleteConfig
+}
+
+type trval struct {
+	query struct {
+		limit   string
+		fil     *Exp
+		filNU   bool
+		cols    map[string]struct{}
+		disable struct {
+			funcs bool
+		}
+	}
+
+	insert struct {
+		fil    *Exp
+		filNU  bool
+		cols   map[string]struct{}
+		psmap  map[string]string
+		pslist []string
+	}
+
+	update struct {
+		fil    *Exp
+		filNU  bool
+		cols   map[string]struct{}
+		psmap  map[string]string
+		pslist []string
+	}
+
+	delete struct {
+		fil   *Exp
+		filNU bool
+		cols  map[string]struct{}
+	}
+}
+
+func (trv *trval) allowedColumns(qt QType) map[string]struct{} {
+	switch qt {
+	case QTQuery:
+		return trv.query.cols
+	case QTInsert:
+		return trv.insert.cols
+	case QTUpdate:
+		return trv.update.cols
+	case QTDelete:
+		return trv.delete.cols
+	case QTUpsert:
+		return trv.insert.cols
+	}
+
+	return nil
+}
+
+func (trv *trval) filter(qt QType) (*Exp, bool) {
+	switch qt {
+	case QTQuery:
+		return trv.query.fil, trv.query.filNU
+	case QTInsert:
+		return trv.insert.fil, trv.insert.filNU
+	case QTUpdate:
+		return trv.update.fil, trv.update.filNU
+	case QTDelete:
+		return trv.delete.fil, trv.delete.filNU
+	case QTUpsert:
+		return trv.insert.fil, trv.insert.filNU
+	}
+
+	return nil, false
+}
+
+func listToMap(list []string) map[string]struct{} {
+	m := make(map[string]struct{}, len(list))
+	for i := range list {
+		m[strings.ToLower(list[i])] = struct{}{}
+	}
+	return m
+}
+
+func mapToList(m map[string]string) []string {
+	list := []string{}
+	for k := range m {
+		list = append(list, strings.ToLower(k))
+	}
+	sort.Strings(list)
+	return list
+}
+
+var varRe = regexp.MustCompile(`\$([a-zA-Z0-9_]+)`)
+
+func parsePresets(m map[string]string) map[string]string {
+	for k, v := range m {
+		m[k] = varRe.ReplaceAllString(v, `{{$1}}`)
+	}
+	return m
+}

core/internal/qcode/corpus/001.gql

@@ -0,0 +1,21 @@
+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 >= 30 and < 30 are returned
+    where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) {
+    id
+    name
+    price
+  }
+}

core/internal/qcode/corpus/002.gql

@@ -0,0 +1,14 @@
+query {
+  products(
+    where: { 
+      or: { 
+        not: { id: { is_null: true } }, 
+        price: { gt: 10 },
+        price: { lt: 20 } 
+      } }
+    ) {
+    id
+    name
+    price
+  }
+}

core/internal/qcode/corpus/003.gql

@@ -0,0 +1,12 @@
+query {
+  products(
+    where: { 
+      and: { 
+        not: { id: { is_null: true } }, 
+        price: { gt: 10 } 
+      }}) {
+    id
+    name
+    price
+  }
+}

core/internal/qcode/fuzz.go

@@ -0,0 +1,20 @@
+// +build gofuzz
+
+package qcode
+
+// FuzzerEntrypoint for Fuzzbuzz
+func Fuzz(data []byte) int {
+	qt := GetQType(string(data))
+
+	if qt > QTUpsert {
+		panic("qt > QTUpsert")
+	}
+
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile(data, "user")
+	if err != nil {
+		return 0
+	}
+
+	return 1
+}

core/internal/qcode/lex.go

@@ -0,0 +1,495 @@
+package qcode
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"unicode"
+	"unicode/utf8"
+)
+
+var (
+	queryToken        = []byte("query")
+	mutationToken     = []byte("mutation")
+	subscriptionToken = []byte("subscription")
+	trueToken         = []byte("true")
+	falseToken        = []byte("false")
+	quotesToken       = []byte(`'"`)
+	signsToken        = []byte(`+-`)
+	punctuatorToken   = []byte(`!():=[]{|}`)
+	spreadToken       = []byte(`...`)
+	digitToken        = []byte(`0123456789`)
+	dotToken          = []byte(`.`)
+)
+
+// Pos represents a byte position in the original input text from which
+// this template was parsed.
+type Pos int
+
+// item represents a token or text string returned from the scanner.
+type item struct {
+	_type itemType // The type of this item.
+	pos   Pos      // The starting position, in bytes, of this item in the input string.
+	end   Pos      // The ending position, in bytes, of this item in the input string.
+	line  int16    // The line number at the start of this item.
+}
+
+// itemType identifies the type of lex items.
+type itemType int
+
+const (
+	itemError itemType = iota // error occurred; value is text of error
+	itemEOF
+	itemName
+	itemQuery
+	itemMutation
+	itemSub
+	itemPunctuator
+	itemArgsOpen
+	itemArgsClose
+	itemListOpen
+	itemListClose
+	itemObjOpen
+	itemObjClose
+	itemColon
+	itemEquals
+	itemDirective
+	itemVariable
+	itemSpread
+	itemIntVal
+	itemFloatVal
+	itemStringVal
+	itemBoolVal
+)
+
+// !$():=@[]{|}
+var punctuators = map[rune]itemType{
+	'{': itemObjOpen,
+	'}': itemObjClose,
+	'[': itemListOpen,
+	']': itemListClose,
+	'(': itemArgsOpen,
+	')': itemArgsClose,
+	':': itemColon,
+	'=': itemEquals,
+}
+
+const eof = -1
+
+// stateFn represents the state of the scanner as a function that returns the next state.
+type stateFn func(*lexer) stateFn
+
+// lexer holds the state of the scanner.
+type lexer struct {
+	input  []byte // the string being scanned
+	pos    Pos    // current position in the input
+	start  Pos    // start position of this item
+	width  Pos    // width of last rune read from input
+	items  []item // array of scanned items
+	itemsA [50]item
+	line   int16 // 1+number of newlines seen
+	err    error
+}
+
+var zeroLex = lexer{}
+
+func (l *lexer) Reset() {
+	*l = zeroLex
+}
+
+// next returns the next byte in the input.
+func (l *lexer) next() rune {
+	if int(l.pos) >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+	r, w := utf8.DecodeRune(l.input[l.pos:])
+	l.width = Pos(w)
+	l.pos += l.width
+	if r == '\n' {
+		l.line++
+	}
+	return r
+}
+
+// peek returns but does not consume the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per call of next.
+func (l *lexer) backup() {
+	l.pos -= l.width
+	// Correct newline count.
+	if l.width == 1 && l.input[l.pos] == '\n' {
+		l.line--
+	}
+}
+
+func (l *lexer) current() (Pos, Pos) {
+	return l.start, l.pos
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items = append(l.items, item{t, l.start, l.pos, l.line})
+	// Some items contain text internally. If so, count their newlines.
+	switch t {
+	case itemStringVal:
+		for i := l.start; i < l.pos; i++ {
+			if l.input[i] == '\n' {
+				l.line++
+			}
+		}
+	}
+	l.start = l.pos
+}
+
+func (l *lexer) emitL(t itemType) {
+	s, e := l.current()
+	lowercase(l.input, s, e)
+	l.emit(t)
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// accept consumes the next rune if it's from the valid set.
+func (l *lexer) accept(valid []byte) bool {
+	if bytes.ContainsRune(valid, l.next()) {
+		return true
+	}
+	l.backup()
+	return false
+}
+
+// acceptAlphaNum consumes a run of runes while they are alpha nums
+func (l *lexer) acceptAlphaNum() bool {
+	n := 0
+	for r := l.next(); isAlphaNumeric(r); r = l.next() {
+		n++
+	}
+	l.backup()
+	return (n != 0)
+}
+
+// acceptComment consumes a run of runes while till the end of line
+func (l *lexer) acceptComment() {
+	n := 0
+	for r := l.next(); !isEndOfLine(r); r = l.next() {
+		n++
+	}
+}
+
+// acceptRun consumes a run of runes from the valid set.
+func (l *lexer) acceptRun(valid []byte) {
+	for bytes.ContainsRune(valid, l.next()) {
+	}
+	l.backup()
+}
+
+// errorf returns an error token and terminates the scan by passing
+// back a nil pointer that will be the next state, terminating l.nextItem.
+func (l *lexer) errorf(format string, args ...interface{}) stateFn {
+	l.err = fmt.Errorf(format, args...)
+	l.items = append(l.items, item{itemError, l.start, l.pos, l.line})
+	return nil
+}
+
+// lex creates a new scanner for the input string.
+func lex(l *lexer, input []byte) error {
+	if len(input) == 0 {
+		return errors.New("empty query")
+	}
+
+	l.input = input
+	l.items = l.itemsA[:0]
+	l.line = 1
+
+	l.run()
+
+	if last := l.items[len(l.items)-1]; last._type == itemError {
+		return l.err
+	}
+	return nil
+}
+
+// run runs the state machine for the lexer.
+func (l *lexer) run() {
+	for state := lexRoot; state != nil; {
+		state = state(l)
+	}
+}
+
+// lexInsideAction scans the elements inside action delimiters.
+func lexRoot(l *lexer) stateFn {
+	r := l.next()
+
+	switch {
+	case r == eof:
+		l.emit(itemEOF)
+		return nil
+	case isEndOfLine(r):
+		l.ignore()
+	case isSpace(r):
+		l.ignore()
+	case r == '#':
+		l.ignore()
+		l.acceptComment()
+		l.ignore()
+	case r == '@':
+		l.ignore()
+		if l.acceptAlphaNum() {
+			l.emit(itemDirective)
+		}
+	case r == '$':
+		l.ignore()
+		if l.acceptAlphaNum() {
+			s, e := l.current()
+			lowercase(l.input, s, e)
+			l.emit(itemVariable)
+		}
+	case contains(l.input, l.start, l.pos, punctuatorToken):
+		if item, ok := punctuators[r]; ok {
+			l.emit(item)
+		} else {
+			l.emit(itemPunctuator)
+		}
+	case r == '"' || r == '\'':
+		l.backup()
+		return lexString
+	case r == '.':
+		if len(l.input) >= 3 {
+			if equals(l.input, 0, 3, spreadToken) {
+				l.emit(itemSpread)
+				return lexRoot
+			}
+		}
+		fallthrough // '.' can start a number.
+	case r == '+' || r == '-' || ('0' <= r && r <= '9'):
+		l.backup()
+		return lexNumber
+	case isAlphaNumeric(r):
+		l.backup()
+		return lexName
+	default:
+		return l.errorf("unrecognized character in action: %#U", r)
+	}
+	return lexRoot
+}
+
+// lexName scans a name.
+func lexName(l *lexer) stateFn {
+	for {
+		r := l.next()
+
+		if r == eof {
+			l.emit(itemEOF)
+			return nil
+		}
+
+		if !isAlphaNumeric(r) {
+			l.backup()
+			s, e := l.current()
+
+			switch {
+			case equals(l.input, s, e, queryToken):
+				l.emitL(itemQuery)
+			case equals(l.input, s, e, mutationToken):
+				l.emitL(itemMutation)
+			case equals(l.input, s, e, subscriptionToken):
+				l.emitL(itemSub)
+			case equals(l.input, s, e, trueToken):
+				l.emitL(itemBoolVal)
+			case equals(l.input, s, e, falseToken):
+				l.emitL(itemBoolVal)
+			default:
+				l.emit(itemName)
+			}
+			break
+		}
+	}
+	return lexRoot
+}
+
+// lexString scans a string.
+func lexString(l *lexer) stateFn {
+	if l.accept([]byte(quotesToken)) {
+		l.ignore()
+
+		for {
+			r := l.next()
+			if r == eof {
+				l.emit(itemEOF)
+				return nil
+			}
+			if r == '\'' || r == '"' {
+				l.backup()
+				l.emit(itemStringVal)
+				if l.accept(quotesToken) {
+					l.ignore()
+				}
+				break
+			}
+		}
+	}
+	return lexRoot
+}
+
+// lexNumber scans a number: decimal, octal, hex, float, or imaginary. This
+// isn't a perfect number scanner - for instance it accepts "." and "0x0.2"
+// and "089" - but when it's wrong the input is invalid and the parser (via
+// strconv) will notice.
+func lexNumber(l *lexer) stateFn {
+	var it itemType
+	// Optional leading sign.
+	l.accept(signsToken)
+
+	// Is it integer
+	if l.accept(digitToken) {
+		l.acceptRun(digitToken)
+		it = itemIntVal
+	}
+
+	// Is it float
+	if l.peek() == '.' {
+		if l.accept(dotToken) {
+			if l.accept(digitToken) {
+				l.acceptRun(digitToken)
+				it = itemFloatVal
+			}
+		} else {
+			l.backup()
+		}
+	}
+
+	// Next thing mustn't be alphanumeric.
+	if isAlphaNumeric(l.peek()) {
+		l.next()
+		return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
+	}
+
+	if it != 0 {
+		l.emit(it)
+	}
+
+	return lexRoot
+}
+
+// isSpace reports whether r is a space character.
+func isSpace(r rune) bool {
+	return r == ',' || r == ' ' || r == '\t'
+}
+
+// isEndOfLine reports whether r is an end-of-line character.
+func isEndOfLine(r rune) bool {
+	return r == '\r' || r == '\n' || r == eof
+}
+
+// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
+func isAlphaNumeric(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+func equals(b []byte, s Pos, e Pos, val []byte) bool {
+	n := 0
+	for i := s; i < e; i++ {
+		if n >= len(val) {
+			return true
+		}
+		switch {
+		case b[i] >= 'A' && b[i] <= 'Z' && ('a'+(b[i]-'A')) != val[n]:
+			return false
+		case b[i] != val[n]:
+			return false
+		}
+		n++
+	}
+	return true
+}
+
+func contains(b []byte, s Pos, e Pos, val []byte) bool {
+	for i := s; i < e; i++ {
+		for n := 0; n < len(val); n++ {
+			if b[i] == val[n] {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func lowercase(b []byte, s Pos, e Pos) {
+	for i := s; i < e; i++ {
+		if b[i] >= 'A' && b[i] <= 'Z' {
+			b[i] = ('a' + (b[i] - 'A'))
+		}
+	}
+}
+
+func (i item) String() string {
+	var v string
+
+	switch i._type {
+	case itemEOF:
+		v = "EOF"
+	case itemError:
+		v = "error"
+	case itemName:
+		v = "name"
+	case itemQuery:
+		v = "query"
+	case itemMutation:
+		v = "mutation"
+	case itemSub:
+		v = "subscription"
+	case itemPunctuator:
+		v = "punctuator"
+	case itemDirective:
+		v = "directive"
+	case itemVariable:
+		v = "variable"
+	case itemIntVal:
+		v = "int"
+	case itemFloatVal:
+		v = "float"
+	case itemStringVal:
+		v = "string"
+	}
+	return v
+}
+
+/*
+
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/

core/internal/qcode/parse.go

@@ -0,0 +1,611 @@
+package qcode
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"unsafe"
+
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+var (
+	errEOT = errors.New("end of tokens")
+)
+
+type parserType int32
+
+const (
+	maxFields = 1200
+	maxArgs   = 25
+)
+
+const (
+	parserError parserType = iota
+	parserEOF
+	opQuery
+	opMutate
+	opSub
+	NodeStr
+	NodeInt
+	NodeFloat
+	NodeBool
+	NodeObj
+	NodeList
+	NodeVar
+)
+
+type Operation struct {
+	Type    parserType
+	Name    string
+	Args    []Arg
+	argsA   [10]Arg
+	Fields  []Field
+	fieldsA [10]Field
+}
+
+var zeroOperation = Operation{}
+
+func (o *Operation) Reset() {
+	*o = zeroOperation
+}
+
+type Field struct {
+	ID        int32
+	ParentID  int32
+	Name      string
+	Alias     string
+	Args      []Arg
+	argsA     [5]Arg
+	Children  []int32
+	childrenA [5]int32
+}
+
+type Arg struct {
+	Name string
+	Val  *Node
+}
+
+type Node struct {
+	Type     parserType
+	Name     string
+	Val      string
+	Parent   *Node
+	Children []*Node
+	exp      *Exp
+}
+
+var zeroNode = Node{}
+
+func (n *Node) Reset() {
+	*n = zeroNode
+}
+
+type Parser struct {
+	input []byte // the string being scanned
+	pos   int
+	items []item
+	err   error
+}
+
+var nodePool = sync.Pool{
+	New: func() interface{} { return new(Node) },
+}
+
+var opPool = sync.Pool{
+	New: func() interface{} { return new(Operation) },
+}
+
+var lexPool = sync.Pool{
+	New: func() interface{} { return new(lexer) },
+}
+
+func Parse(gql []byte) (*Operation, error) {
+	return parseSelectionSet(gql)
+}
+
+func ParseArgValue(argVal string) (*Node, error) {
+	l := lexPool.Get().(*lexer)
+	l.Reset()
+
+	if err := lex(l, []byte(argVal)); err != nil {
+		return nil, err
+	}
+
+	p := &Parser{
+		input: l.input,
+		pos:   -1,
+		items: l.items,
+	}
+	op, err := p.parseValue()
+	lexPool.Put(l)
+
+	return op, err
+}
+
+func parseSelectionSet(gql []byte) (*Operation, error) {
+	var err error
+
+	if len(gql) == 0 {
+		return nil, errors.New("blank query")
+	}
+
+	l := lexPool.Get().(*lexer)
+	l.Reset()
+
+	if err = lex(l, gql); err != nil {
+		return nil, err
+	}
+
+	p := &Parser{
+		input: l.input,
+		pos:   -1,
+		items: l.items,
+	}
+
+	var op *Operation
+
+	if p.peek(itemObjOpen) {
+		p.ignore()
+		op, err = p.parseQueryOp()
+	} else {
+		op, err = p.parseOp()
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if p.peek(itemObjClose) {
+		p.ignore()
+	} else {
+		return nil, fmt.Errorf("operation missing closing '}'")
+	}
+
+	if !p.peek(itemEOF) {
+		p.ignore()
+		return nil, fmt.Errorf("invalid '%s' found after closing '}'", p.current())
+	}
+
+	lexPool.Put(l)
+
+	return op, err
+}
+
+func (p *Parser) next() item {
+	n := p.pos + 1
+	if n >= len(p.items) {
+		p.err = errEOT
+		return item{_type: itemEOF}
+	}
+	p.pos = n
+	return p.items[p.pos]
+}
+
+func (p *Parser) ignore() {
+	n := p.pos + 1
+	if n >= len(p.items) {
+		p.err = errEOT
+		return
+	}
+	p.pos = n
+}
+
+func (p *Parser) current() string {
+	item := p.items[p.pos]
+	return b2s(p.input[item.pos:item.end])
+}
+
+func (p *Parser) peek(types ...itemType) bool {
+	n := p.pos + 1
+	// if p.items[n]._type == itemEOF {
+	// 	return false
+	// }
+	if n >= len(p.items) {
+		return false
+	}
+	for i := 0; i < len(types); i++ {
+		if p.items[n]._type == types[i] {
+			return true
+		}
+	}
+	return false
+}
+
+func (p *Parser) parseOp() (*Operation, error) {
+	if !p.peek(itemQuery, itemMutation, itemSub) {
+		err := errors.New("expecting a query, mutation or subscription")
+		return nil, err
+	}
+	item := p.next()
+
+	op := opPool.Get().(*Operation)
+	op.Reset()
+
+	switch item._type {
+	case itemQuery:
+		op.Type = opQuery
+	case itemMutation:
+		op.Type = opMutate
+	case itemSub:
+		op.Type = opSub
+	}
+
+	op.Fields = op.fieldsA[:0]
+	op.Args = op.argsA[:0]
+
+	var err error
+
+	if p.peek(itemName) {
+		op.Name = p.val(p.next())
+	}
+
+	if p.peek(itemArgsOpen) {
+		p.ignore()
+
+		op.Args, err = p.parseOpParams(op.Args)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if p.peek(itemObjOpen) {
+		p.ignore()
+
+		for n := 0; n < 10; n++ {
+			if !p.peek(itemName) {
+				break
+			}
+
+			op.Fields, err = p.parseFields(op.Fields)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return op, nil
+}
+
+func (p *Parser) parseQueryOp() (*Operation, error) {
+	op := opPool.Get().(*Operation)
+	op.Reset()
+
+	op.Type = opQuery
+	op.Fields = op.fieldsA[:0]
+	op.Args = op.argsA[:0]
+
+	var err error
+
+	for n := 0; n < 10; n++ {
+		if !p.peek(itemName) {
+			break
+		}
+
+		op.Fields, err = p.parseFields(op.Fields)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return op, nil
+}
+
+func (p *Parser) parseFields(fields []Field) ([]Field, error) {
+	st := util.NewStack()
+
+	for {
+		if len(fields) >= maxFields {
+			return nil, fmt.Errorf("too many fields (max %d)", maxFields)
+		}
+
+		if p.peek(itemObjClose) {
+			p.ignore()
+			st.Pop()
+
+			if st.Len() == 0 {
+				break
+			} else {
+				continue
+			}
+		}
+
+		if !p.peek(itemName) {
+			return nil, errors.New("expecting an alias or field name")
+		}
+
+		fields = append(fields, Field{ID: int32(len(fields))})
+
+		f := &fields[(len(fields) - 1)]
+		f.Args = f.argsA[:0]
+		f.Children = f.childrenA[:0]
+
+		// Parse the inside of the the fields () parentheses
+		// in short parse the args like id, where, etc
+		if err := p.parseField(f); err != nil {
+			return nil, err
+		}
+
+		intf := st.Peek()
+		if pid, ok := intf.(int32); ok {
+			f.ParentID = pid
+			fields[pid].Children = append(fields[pid].Children, f.ID)
+		} else {
+			f.ParentID = -1
+		}
+
+		// The first opening curley brackets after this
+		// comes the columns or child fields
+		if p.peek(itemObjOpen) {
+			p.ignore()
+			st.Push(f.ID)
+
+		} else if p.peek(itemObjClose) {
+			if st.Len() == 0 {
+				break
+			} else {
+				continue
+			}
+		}
+	}
+
+	return fields, nil
+}
+
+func (p *Parser) parseField(f *Field) error {
+	var err error
+	v := p.next()
+
+	if p.peek(itemColon) {
+		p.ignore()
+
+		if p.peek(itemName) {
+			f.Alias = p.val(v)
+			f.Name = p.vall(p.next())
+		} else {
+			return errors.New("expecting an aliased field name")
+		}
+	} else {
+		f.Name = p.vall(v)
+	}
+
+	if p.peek(itemArgsOpen) {
+		p.ignore()
+		if f.Args, err = p.parseArgs(f.Args); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p *Parser) parseOpParams(args []Arg) ([]Arg, error) {
+	for {
+		if len(args) >= maxArgs {
+			return nil, fmt.Errorf("too many args (max %d)", maxArgs)
+		}
+
+		if p.peek(itemArgsClose) {
+			p.ignore()
+			break
+		}
+		p.next()
+	}
+
+	return args, nil
+}
+
+func (p *Parser) parseArgs(args []Arg) ([]Arg, error) {
+	var err error
+
+	for {
+		if len(args) >= maxArgs {
+			return nil, fmt.Errorf("too many args (max %d)", maxArgs)
+		}
+
+		if p.peek(itemArgsClose) {
+			p.ignore()
+			break
+		}
+
+		if !p.peek(itemName) {
+			return nil, errors.New("expecting an argument name")
+		}
+		args = append(args, Arg{Name: p.val(p.next())})
+		arg := &args[(len(args) - 1)]
+
+		if !p.peek(itemColon) {
+			return nil, errors.New("missing ':' after argument name")
+		}
+		p.ignore()
+
+		arg.Val, err = p.parseValue()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return args, nil
+}
+
+func (p *Parser) parseList() (*Node, error) {
+	nodes := []*Node{}
+
+	parent := nodePool.Get().(*Node)
+	parent.Reset()
+
+	var ty parserType
+	for {
+		if p.peek(itemListClose) {
+			p.ignore()
+			break
+		}
+		node, err := p.parseValue()
+		if err != nil {
+			return nil, err
+		}
+		if ty == 0 {
+			ty = node.Type
+		} else {
+			if ty != node.Type {
+				return nil, errors.New("All values in a list must be of the same type")
+			}
+		}
+		node.Parent = parent
+		nodes = append(nodes, node)
+	}
+	if len(nodes) == 0 {
+		return nil, errors.New("List cannot be empty")
+	}
+
+	parent.Type = NodeList
+	parent.Children = nodes
+
+	return parent, nil
+}
+
+func (p *Parser) parseObj() (*Node, error) {
+	nodes := []*Node{}
+
+	parent := nodePool.Get().(*Node)
+	parent.Reset()
+
+	for {
+		if p.peek(itemObjClose) {
+			p.ignore()
+			break
+		}
+
+		if !p.peek(itemName) {
+			return nil, errors.New("expecting an argument name")
+		}
+		nodeName := p.val(p.next())
+
+		if !p.peek(itemColon) {
+			return nil, errors.New("missing ':' after Field argument name")
+		}
+		p.ignore()
+
+		node, err := p.parseValue()
+		if err != nil {
+			return nil, err
+		}
+		node.Name = nodeName
+		node.Parent = parent
+		nodes = append(nodes, node)
+	}
+
+	parent.Type = NodeObj
+	parent.Children = nodes
+
+	return parent, nil
+}
+
+func (p *Parser) parseValue() (*Node, error) {
+	if p.peek(itemListOpen) {
+		p.ignore()
+		return p.parseList()
+	}
+
+	if p.peek(itemObjOpen) {
+		p.ignore()
+		return p.parseObj()
+	}
+
+	item := p.next()
+	node := nodePool.Get().(*Node)
+	node.Reset()
+
+	switch item._type {
+	case itemIntVal:
+		node.Type = NodeInt
+	case itemFloatVal:
+		node.Type = NodeFloat
+	case itemStringVal:
+		node.Type = NodeStr
+	case itemBoolVal:
+		node.Type = NodeBool
+	case itemName:
+		node.Type = NodeStr
+	case itemVariable:
+		node.Type = NodeVar
+	default:
+		return nil, fmt.Errorf("expecting a number, string, object, list or variable as an argument value (not %s)", p.val(p.next()))
+	}
+	node.Val = p.val(item)
+
+	return node, nil
+}
+
+func (p *Parser) val(v item) string {
+	return b2s(p.input[v.pos:v.end])
+}
+
+func (p *Parser) vall(v item) string {
+	lowercase(p.input, v.pos, v.end)
+	return b2s(p.input[v.pos:v.end])
+}
+
+func b2s(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+func (t parserType) String() string {
+	var v string
+
+	switch t {
+	case parserEOF:
+		v = "EOF"
+	case parserError:
+		v = "error"
+	case opQuery:
+		v = "query"
+	case opMutate:
+		v = "mutation"
+	case opSub:
+		v = "subscription"
+	case NodeStr:
+		v = "node-string"
+	case NodeInt:
+		v = "node-int"
+	case NodeFloat:
+		v = "node-float"
+	case NodeBool:
+		v = "node-bool"
+	case NodeVar:
+		v = "node-var"
+	case NodeObj:
+		v = "node-obj"
+	case NodeList:
+		v = "node-list"
+	}
+	return fmt.Sprintf("<%s>", v)
+}
+
+// type Frees struct {
+// 	n   *Node
+// 	loc int
+// }
+
+// var freeList []Frees
+
+// func FreeNode(n *Node, loc int) {
+// 	j := -1
+
+// 	for i := range freeList {
+// 		if n == freeList[i].n {
+// 			j = i
+// 			break
+// 		}
+// 	}
+
+// 	if j == -1 {
+// 		nodePool.Put(n)
+// 		freeList = append(freeList, Frees{n, loc})
+// 	} else {
+// 		fmt.Printf(">>>>(%d) RE_FREE %d %p %s %s\n", loc, freeList[j].loc, freeList[j].n, n.Name, n.Type)
+// 	}
+// }
+
+func FreeNode(n *Node, loc int) {
+	nodePool.Put(n)
+}

core/internal/qcode/parse_test.go

@@ -0,0 +1,183 @@
+package qcode
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestCompile1(t *testing.T) {
+	qc, _ := NewCompiler(Config{})
+	err := qc.AddRole("user", "product", TRConfig{
+		Query: QueryConfig{
+			Columns: []string{"id", "Name"},
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = qc.Compile([]byte(`
+	query { product(id: 15) {
+			id
+			name
+		} }`), "user")
+
+	if err == nil {
+		t.Fatal(errors.New("this should be an error id must be a variable"))
+	}
+}
+
+func TestCompile2(t *testing.T) {
+	qc, _ := NewCompiler(Config{})
+	err := qc.AddRole("user", "product", TRConfig{
+		Query: QueryConfig{
+			Columns: []string{"ID"},
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = qc.Compile([]byte(`
+	query { product(id: $id) {
+			id
+			name
+		} }`), "user")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCompile3(t *testing.T) {
+	qc, _ := NewCompiler(Config{})
+	err := qc.AddRole("user", "product", TRConfig{
+		Query: QueryConfig{
+			Columns: []string{"ID"},
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = qc.Compile([]byte(`
+	mutation {
+		product(id: $test, name: "Test") {
+			id
+			name
+		}
+	}`), "user")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInvalidCompile1(t *testing.T) {
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile([]byte(`#`), "user")
+
+	if err == nil {
+		t.Fatal(errors.New("expecting an error"))
+	}
+}
+
+func TestInvalidCompile2(t *testing.T) {
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile([]byte(`{u(where:{not:0})}`), "user")
+
+	if err == nil {
+		t.Fatal(errors.New("expecting an error"))
+	}
+}
+
+func TestEmptyCompile(t *testing.T) {
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile([]byte(``), "user")
+
+	if err == nil {
+		t.Fatal(errors.New("expecting an error"))
+	}
+}
+
+func TestInvalidPostfixCompile(t *testing.T) {
+	gql := `mutation 
+updateThread {
+  thread(update: $data, where: { slug: { eq: $slug } }) {
+    slug
+    title
+    published
+    createdAt : created_at
+    totalVotes : cached_votes_total
+    totalPosts : cached_posts_total
+    vote : thread_vote(where: { user_id: { eq: $user_id } }) {
+     id
+    }
+    topics {
+      slug
+      name
+    }
+	}
+}
+}`
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile([]byte(gql), "anon")
+
+	if err == nil {
+		t.Fatal(errors.New("expecting an error"))
+	}
+
+}
+
+var gql = []byte(`
+	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 >= 30 and < 30 are returned
+		where: { id: { AND: { greater_or_equals: 20, lt: 28 } } }) {
+		id
+		name
+		price
+	}`)
+
+func BenchmarkQCompile(b *testing.B) {
+	qcompile, _ := NewCompiler(Config{})
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for n := 0; n < b.N; n++ {
+		_, err := qcompile.Compile(gql, "user")
+
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkQCompileP(b *testing.B) {
+	qcompile, _ := NewCompiler(Config{})
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := qcompile.Compile(gql, "user")
+
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}

core/internal/qcode/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/qcode/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/qcode/qcode.go

@@ -0,0 +1,1177 @@
+package qcode
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/dosco/super-graph/core/internal/util"
+	"github.com/gobuffalo/flect"
+)
+
+type QType int
+type Action int
+
+const (
+	maxSelectors = 30
+)
+
+const (
+	QTQuery QType = iota + 1
+	QTMutation
+	QTInsert
+	QTUpdate
+	QTDelete
+	QTUpsert
+)
+
+type QCode struct {
+	Type      QType
+	ActionVar string
+	Selects   []Select
+	Roots     []int32
+	rootsA    [5]int32
+}
+
+type Select struct {
+	ID         int32
+	ParentID   int32
+	Args       map[string]*Node
+	Name       string
+	FieldName  string
+	Cols       []Column
+	Where      *Exp
+	OrderBy    []*OrderBy
+	DistinctOn []string
+	Paging     Paging
+	Children   []int32
+	Functions  bool
+	Allowed    map[string]struct{}
+	PresetMap  map[string]string
+	PresetList []string
+	SkipRender bool
+}
+
+type Column struct {
+	Table     string
+	Name      string
+	FieldName string
+}
+
+type Exp struct {
+	Op         ExpOp
+	Col        string
+	NestedCols []string
+	Type       ValType
+	Table      string
+	Val        string
+	ListType   ValType
+	ListVal    []string
+	Children   []*Exp
+	childrenA  [5]*Exp
+	doFree     bool
+}
+
+var zeroExp = Exp{doFree: true}
+
+func (ex *Exp) Reset() {
+	*ex = zeroExp
+}
+
+type OrderBy struct {
+	Col   string
+	Order Order
+}
+
+type PagingType int
+
+const (
+	PtOffset PagingType = iota
+	PtForward
+	PtBackward
+)
+
+type Paging struct {
+	Type    PagingType
+	Limit   string
+	Offset  string
+	Cursor  bool
+	NoLimit bool
+}
+
+type ExpOp int
+
+const (
+	OpNop ExpOp = iota
+	OpAnd
+	OpOr
+	OpNot
+	OpEquals
+	OpNotEquals
+	OpGreaterOrEquals
+	OpLesserOrEquals
+	OpGreaterThan
+	OpLesserThan
+	OpIn
+	OpNotIn
+	OpLike
+	OpNotLike
+	OpILike
+	OpNotILike
+	OpSimilar
+	OpNotSimilar
+	OpContains
+	OpContainedIn
+	OpHasKey
+	OpHasKeyAny
+	OpHasKeyAll
+	OpIsNull
+	OpEqID
+	OpTsQuery
+	OpFalse
+	OpNotDistinct
+	OpDistinct
+)
+
+type ValType int
+
+const (
+	ValStr ValType = iota + 1
+	ValInt
+	ValFloat
+	ValBool
+	ValList
+	ValVar
+	ValNone
+	ValRef
+)
+
+type AggregrateOp int
+
+const (
+	AgCount AggregrateOp = iota + 1
+	AgSum
+	AgAvg
+	AgMax
+	AgMin
+)
+
+type Order int
+
+const (
+	OrderAsc Order = iota + 1
+	OrderDesc
+	OrderAscNullsFirst
+	OrderAscNullsLast
+	OrderDescNullsFirst
+	OrderDescNullsLast
+)
+
+type Compiler struct {
+	tr map[string]map[string]*trval
+	bl map[string]struct{}
+}
+
+var expPool = sync.Pool{
+	New: func() interface{} { return &Exp{doFree: true} },
+}
+
+func NewCompiler(c Config) (*Compiler, error) {
+	co := &Compiler{}
+	co.tr = make(map[string]map[string]*trval)
+	co.bl = make(map[string]struct{}, len(c.Blocklist))
+
+	for i := range c.Blocklist {
+		co.bl[strings.ToLower(c.Blocklist[i])] = struct{}{}
+	}
+
+	seedExp := [100]Exp{}
+
+	for i := range seedExp {
+		seedExp[i].doFree = true
+		expPool.Put(&seedExp[i])
+	}
+
+	return co, nil
+}
+
+func NewFilter() *Exp {
+	ex := expPool.Get().(*Exp)
+	ex.Reset()
+
+	return ex
+}
+
+func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
+	var err error
+	trv := &trval{}
+
+	// query config
+	trv.query.fil, trv.query.filNU, err = compileFilter(trc.Query.Filters)
+	if err != nil {
+		return err
+	}
+	if trc.Query.Limit > 0 {
+		trv.query.limit = strconv.Itoa(trc.Query.Limit)
+	}
+	trv.query.cols = listToMap(trc.Query.Columns)
+	trv.query.disable.funcs = trc.Query.DisableFunctions
+
+	// insert config
+	trv.insert.fil, trv.insert.filNU, err = compileFilter(trc.Insert.Filters)
+	if err != nil {
+		return err
+	}
+	trv.insert.cols = listToMap(trc.Insert.Columns)
+	trv.insert.psmap = parsePresets(trc.Insert.Presets)
+	trv.insert.pslist = mapToList(trv.insert.psmap)
+
+	// update config
+	trv.update.fil, trv.update.filNU, err = compileFilter(trc.Update.Filters)
+	if err != nil {
+		return err
+	}
+	trv.update.cols = listToMap(trc.Update.Columns)
+	trv.update.psmap = parsePresets(trc.Update.Presets)
+	trv.update.pslist = mapToList(trv.update.psmap)
+
+	// delete config
+	trv.delete.fil, trv.delete.filNU, err = compileFilter(trc.Delete.Filters)
+	if err != nil {
+		return err
+	}
+	trv.delete.cols = listToMap(trc.Delete.Columns)
+
+	singular := flect.Singularize(table)
+	plural := flect.Pluralize(table)
+
+	if _, ok := com.tr[role]; !ok {
+		com.tr[role] = make(map[string]*trval)
+	}
+
+	com.tr[role][singular] = trv
+	com.tr[role][plural] = trv
+	return nil
+}
+
+func (com *Compiler) Compile(query []byte, role string) (*QCode, error) {
+	var err error
+
+	qc := QCode{Type: QTQuery}
+	qc.Roots = qc.rootsA[:0]
+
+	op, err := Parse(query)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = com.compileQuery(&qc, op, role); err != nil {
+		return nil, err
+	}
+
+	opPool.Put(op)
+
+	return &qc, nil
+}
+
+func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
+	id := int32(0)
+
+	if len(op.Fields) == 0 {
+		return errors.New("invalid graphql no query found")
+	}
+
+	if op.Type == opMutate {
+		if err := com.setMutationType(qc, op.Fields[0].Args); err != nil {
+			return err
+		}
+	}
+
+	selects := make([]Select, 0, 5)
+	st := NewStack()
+	action := qc.Type
+
+	if len(op.Fields) == 0 {
+		return errors.New("empty query")
+	}
+
+	for i := range op.Fields {
+		if op.Fields[i].ParentID == -1 {
+			val := op.Fields[i].ID | (-1 << 16)
+			st.Push(val)
+		}
+	}
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		if id >= maxSelectors {
+			return fmt.Errorf("selector limit reached (%d)", maxSelectors)
+		}
+
+		val := st.Pop()
+		fid := val & 0xFFFF
+		parentID := (val >> 16) & 0xFFFF
+
+		field := &op.Fields[fid]
+
+		if _, ok := com.bl[field.Name]; ok {
+			continue
+		}
+
+		if field.ParentID == -1 {
+			parentID = -1
+		}
+
+		trv := com.getRole(role, field.Name)
+
+		selects = append(selects, Select{
+			ID:        id,
+			ParentID:  parentID,
+			Name:      field.Name,
+			Children:  make([]int32, 0, 5),
+			Allowed:   trv.allowedColumns(action),
+			Functions: true,
+		})
+		s := &selects[(len(selects) - 1)]
+
+		switch action {
+		case QTQuery:
+			s.Functions = !trv.query.disable.funcs
+			s.Paging.Limit = trv.query.limit
+
+		case QTInsert:
+			s.PresetMap = trv.insert.psmap
+			s.PresetList = trv.insert.pslist
+
+		case QTUpdate:
+			s.PresetMap = trv.update.psmap
+			s.PresetList = trv.update.pslist
+		}
+
+		if len(field.Alias) != 0 {
+			s.FieldName = field.Alias
+		} else {
+			s.FieldName = s.Name
+		}
+
+		err := com.compileArgs(qc, s, field.Args, role)
+		if err != nil {
+			return err
+		}
+
+		// Order is important AddFilters must come after compileArgs
+		com.AddFilters(qc, s, role)
+
+		if s.ParentID == -1 {
+			qc.Roots = append(qc.Roots, s.ID)
+		} else {
+			p := &selects[s.ParentID]
+			p.Children = append(p.Children, s.ID)
+		}
+
+		s.Cols = make([]Column, 0, len(field.Children))
+		action = QTQuery
+
+		for _, cid := range field.Children {
+			f := op.Fields[cid]
+
+			if _, ok := com.bl[f.Name]; ok {
+				continue
+			}
+
+			if len(f.Children) != 0 {
+				val := f.ID | (s.ID << 16)
+				st.Push(val)
+				continue
+			}
+
+			col := Column{Name: f.Name}
+
+			if len(f.Alias) != 0 {
+				col.FieldName = f.Alias
+			} else {
+				col.FieldName = f.Name
+			}
+			s.Cols = append(s.Cols, col)
+		}
+
+		id++
+	}
+
+	if id == 0 {
+		return errors.New("invalid query")
+	}
+
+	qc.Selects = selects[:id]
+	return nil
+}
+
+func (com *Compiler) AddFilters(qc *QCode, sel *Select, role string) {
+	var fil *Exp
+	var nu bool
+
+	if trv, ok := com.tr[role][sel.Name]; ok {
+		fil, nu = trv.filter(qc.Type)
+
+	} else if role == "anon" {
+		// Tables not defined under the anon role will not be rendered
+		sel.SkipRender = true
+	}
+
+	if fil == nil {
+		return
+	}
+
+	if nu && role == "anon" {
+		sel.SkipRender = true
+	}
+
+	switch fil.Op {
+	case OpNop:
+	case OpFalse:
+		sel.Where = fil
+	default:
+		AddFilter(sel, fil)
+	}
+}
+
+func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg, role string) error {
+	var err error
+
+	// don't free this arg either previously done or will be free'd
+	// in the future like in psql
+	var df bool
+
+	for i := range args {
+		arg := &args[i]
+
+		switch arg.Name {
+		case "id":
+			err, df = com.compileArgID(sel, arg)
+
+		case "search":
+			err, df = com.compileArgSearch(sel, arg)
+
+		case "where":
+			err, df = com.compileArgWhere(sel, arg, role)
+
+		case "orderby", "order_by", "order":
+			err, df = com.compileArgOrderBy(sel, arg)
+
+		case "distinct_on", "distinct":
+			err, df = com.compileArgDistinctOn(sel, arg)
+
+		case "limit":
+			err, df = com.compileArgLimit(sel, arg)
+
+		case "offset":
+			err, df = com.compileArgOffset(sel, arg)
+
+		case "first":
+			err, df = com.compileArgFirstLast(sel, arg, PtForward)
+
+		case "last":
+			err, df = com.compileArgFirstLast(sel, arg, PtBackward)
+
+		case "after":
+			err, df = com.compileArgAfterBefore(sel, arg, PtForward)
+
+		case "before":
+			err, df = com.compileArgAfterBefore(sel, arg, PtBackward)
+		}
+
+		if !df {
+			FreeNode(arg.Val, 5)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
+	setActionVar := func(arg *Arg) error {
+		if arg.Val.Type != NodeVar {
+			return argErr(arg.Name, "variable")
+		}
+		qc.ActionVar = arg.Val.Val
+		return nil
+	}
+
+	for i := range args {
+		arg := &args[i]
+
+		switch arg.Name {
+		case "insert":
+			qc.Type = QTInsert
+			return setActionVar(arg)
+		case "update":
+			qc.Type = QTUpdate
+			return setActionVar(arg)
+		case "upsert":
+			qc.Type = QTUpsert
+			return setActionVar(arg)
+		case "delete":
+			qc.Type = QTDelete
+
+			if arg.Val.Type != NodeBool {
+				return argErr(arg.Name, "boolen")
+			}
+
+			if arg.Val.Val == "false" {
+				qc.Type = QTQuery
+			}
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (com *Compiler) compileArgObj(st *util.Stack, arg *Arg) (*Exp, bool, error) {
+	if arg.Val.Type != NodeObj {
+		return nil, false, fmt.Errorf("expecting an object")
+	}
+
+	return com.compileArgNode(st, arg.Val, true)
+}
+
+func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*Exp, bool, error) {
+	var root *Exp
+	var needsUser bool
+
+	if node == nil || len(node.Children) == 0 {
+		return nil, false, errors.New("invalid argument value")
+	}
+
+	pushChild(st, nil, node)
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		intf := st.Pop()
+
+		node, ok := intf.(*Node)
+		if !ok || node == nil {
+			return nil, needsUser, fmt.Errorf("16: unexpected value %v (%t)", intf, intf)
+		}
+
+		// Objects inside a list
+		if len(node.Name) == 0 {
+			pushChildren(st, node.exp, node)
+			continue
+
+		} else {
+			if _, ok := com.bl[node.Name]; ok {
+				continue
+			}
+		}
+
+		ex, err := newExp(st, node, usePool)
+		if err != nil {
+			return nil, needsUser, err
+		}
+
+		if ex == nil {
+			continue
+		}
+
+		if ex.Type == ValVar && ex.Val == "user_id" {
+			needsUser = true
+		}
+
+		if node.exp == nil {
+			root = ex
+		} else {
+			node.exp.Children = append(node.exp.Children, ex)
+		}
+	}
+
+	if usePool {
+		st.Push(node)
+
+		for {
+			if st.Len() == 0 {
+				break
+			}
+			intf := st.Pop()
+			node, ok := intf.(*Node)
+			if !ok || node == nil {
+				continue
+			}
+			for i := range node.Children {
+				st.Push(node.Children[i])
+			}
+			FreeNode(node, 1)
+		}
+	}
+
+	return root, needsUser, nil
+}
+
+func (com *Compiler) compileArgID(sel *Select, arg *Arg) (error, bool) {
+	if sel.ID != 0 {
+		return nil, false
+	}
+
+	if sel.Where != nil && sel.Where.Op == OpEqID {
+		return nil, false
+	}
+
+	if arg.Val.Type != NodeVar {
+		return argErr("id", "variable"), false
+	}
+
+	ex := expPool.Get().(*Exp)
+	ex.Reset()
+
+	ex.Op = OpEqID
+	ex.Type = ValVar
+	ex.Val = arg.Val.Val
+
+	sel.Where = ex
+	return nil, false
+}
+
+func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) (error, bool) {
+	if arg.Val.Type != NodeVar {
+		return argErr("search", "variable"), false
+	}
+
+	ex := expPool.Get().(*Exp)
+	ex.Reset()
+
+	ex.Op = OpTsQuery
+	ex.Type = ValVar
+	ex.Val = arg.Val.Val
+
+	if sel.Args == nil {
+		sel.Args = make(map[string]*Node)
+	}
+
+	sel.Args[arg.Name] = arg.Val
+	AddFilter(sel, ex)
+
+	return nil, true
+}
+
+func (com *Compiler) compileArgWhere(sel *Select, arg *Arg, role string) (error, bool) {
+	st := util.NewStack()
+	var err error
+
+	ex, nu, err := com.compileArgObj(st, arg)
+	if err != nil {
+		return err, false
+	}
+
+	if nu && role == "anon" {
+		sel.SkipRender = true
+	}
+	AddFilter(sel, ex)
+
+	return nil, true
+}
+
+func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) (error, bool) {
+	if arg.Val.Type != NodeObj {
+		return fmt.Errorf("expecting an object"), false
+	}
+
+	st := util.NewStack()
+
+	for i := range arg.Val.Children {
+		st.Push(arg.Val.Children[i])
+	}
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		intf := st.Pop()
+		node, ok := intf.(*Node)
+
+		if !ok || node == nil {
+			return fmt.Errorf("17: unexpected value %v (%t)", intf, intf), false
+		}
+
+		if _, ok := com.bl[node.Name]; ok {
+			FreeNode(node, 2)
+			continue
+		}
+
+		if node.Type != NodeStr && node.Type != NodeVar {
+			return fmt.Errorf("expecting a string or variable"), false
+		}
+
+		ob := &OrderBy{}
+
+		switch node.Val {
+		case "asc":
+			ob.Order = OrderAsc
+		case "desc":
+			ob.Order = OrderDesc
+		case "asc_nulls_first":
+			ob.Order = OrderAscNullsFirst
+		case "desc_nulls_first":
+			ob.Order = OrderDescNullsFirst
+		case "asc_nulls_last":
+			ob.Order = OrderAscNullsLast
+		case "desc_nulls_last":
+			ob.Order = OrderDescNullsLast
+		default:
+			return fmt.Errorf("valid values include asc, desc, asc_nulls_first and desc_nulls_first"), false
+		}
+
+		setOrderByColName(ob, node)
+		sel.OrderBy = append(sel.OrderBy, ob)
+		FreeNode(node, 3)
+	}
+	return nil, false
+}
+
+func (com *Compiler) compileArgDistinctOn(sel *Select, arg *Arg) (error, bool) {
+	node := arg.Val
+
+	if _, ok := com.bl[node.Name]; ok {
+		return nil, false
+	}
+
+	if node.Type != NodeList && node.Type != NodeStr {
+		return fmt.Errorf("expecting a list of strings or just a string"), false
+	}
+
+	if node.Type == NodeStr {
+		sel.DistinctOn = append(sel.DistinctOn, node.Val)
+	}
+
+	for i := range node.Children {
+		sel.DistinctOn = append(sel.DistinctOn, node.Children[i].Val)
+		FreeNode(node.Children[i], 5)
+	}
+
+	return nil, false
+}
+
+func (com *Compiler) compileArgLimit(sel *Select, arg *Arg) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeInt {
+		return argErr("limit", "number"), false
+	}
+
+	sel.Paging.Limit = node.Val
+
+	return nil, false
+}
+
+func (com *Compiler) compileArgOffset(sel *Select, arg *Arg) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeVar {
+		return argErr("offset", "variable"), false
+	}
+
+	sel.Paging.Offset = node.Val
+	return nil, false
+}
+
+func (com *Compiler) compileArgFirstLast(sel *Select, arg *Arg, pt PagingType) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeInt {
+		return argErr(arg.Name, "number"), false
+	}
+
+	sel.Paging.Type = pt
+	sel.Paging.Limit = node.Val
+
+	return nil, false
+}
+
+func (com *Compiler) compileArgAfterBefore(sel *Select, arg *Arg, pt PagingType) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeVar || node.Val != "cursor" {
+		return fmt.Errorf("value for argument '%s' must be a variable named $cursor", arg.Name), false
+	}
+	sel.Paging.Type = pt
+	sel.Paging.Cursor = true
+
+	return nil, false
+}
+
+var zeroTrv = &trval{}
+
+func (com *Compiler) getRole(role, field string) *trval {
+	if trv, ok := com.tr[role][field]; ok {
+		return trv
+	} else {
+		return zeroTrv
+	}
+}
+
+func AddFilter(sel *Select, fil *Exp) {
+	if sel.Where != nil {
+		ow := sel.Where
+
+		if sel.Where.Op != OpAnd || !sel.Where.doFree {
+			sel.Where = expPool.Get().(*Exp)
+			sel.Where.Reset()
+			sel.Where.Op = OpAnd
+			sel.Where.Children = sel.Where.childrenA[:2]
+			sel.Where.Children[0] = fil
+			sel.Where.Children[1] = ow
+
+		} else {
+			sel.Where.Children = append(sel.Where.Children, fil)
+		}
+
+	} else {
+		sel.Where = fil
+	}
+}
+
+func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
+	name := node.Name
+	if name[0] == '_' {
+		name = name[1:]
+	}
+
+	var ex *Exp
+
+	if usePool {
+		ex = expPool.Get().(*Exp)
+		ex.Reset()
+	} else {
+		ex = &Exp{doFree: false}
+	}
+
+	ex.Children = ex.childrenA[:0]
+
+	switch name {
+	case "and":
+		if len(node.Children) == 0 {
+			return nil, errors.New("missing expression after 'AND' operator")
+		}
+		ex.Op = OpAnd
+		pushChildren(st, ex, node)
+	case "or":
+		if len(node.Children) == 0 {
+			return nil, errors.New("missing expression after 'OR' operator")
+		}
+		ex.Op = OpOr
+		pushChildren(st, ex, node)
+	case "not":
+		if len(node.Children) == 0 {
+			return nil, errors.New("missing expression after 'NOT' operator")
+		}
+		ex.Op = OpNot
+		pushChild(st, ex, node)
+	case "eq", "equals":
+		ex.Op = OpEquals
+		ex.Val = node.Val
+	case "neq", "not_equals":
+		ex.Op = OpNotEquals
+		ex.Val = node.Val
+	case "gt", "greater_than":
+		ex.Op = OpGreaterThan
+		ex.Val = node.Val
+	case "lt", "lesser_than":
+		ex.Op = OpLesserThan
+		ex.Val = node.Val
+	case "gte", "greater_or_equals":
+		ex.Op = OpGreaterOrEquals
+		ex.Val = node.Val
+	case "lte", "lesser_or_equals":
+		ex.Op = OpLesserOrEquals
+		ex.Val = node.Val
+	case "in":
+		ex.Op = OpIn
+		setListVal(ex, node)
+	case "nin", "not_in":
+		ex.Op = OpNotIn
+		setListVal(ex, node)
+	case "like":
+		ex.Op = OpLike
+		ex.Val = node.Val
+	case "nlike", "not_like":
+		ex.Op = OpNotLike
+		ex.Val = node.Val
+	case "ilike":
+		ex.Op = OpILike
+		ex.Val = node.Val
+	case "nilike", "not_ilike":
+		ex.Op = OpILike
+		ex.Val = node.Val
+	case "similar":
+		ex.Op = OpSimilar
+		ex.Val = node.Val
+	case "nsimilar", "not_similar":
+		ex.Op = OpNotSimilar
+		ex.Val = node.Val
+	case "contains":
+		ex.Op = OpContains
+		ex.Val = node.Val
+	case "contained_in":
+		ex.Op = OpContainedIn
+		ex.Val = node.Val
+	case "has_key":
+		ex.Op = OpHasKey
+		ex.Val = node.Val
+	case "has_key_any":
+		ex.Op = OpHasKeyAny
+		ex.Val = node.Val
+	case "has_key_all":
+		ex.Op = OpHasKeyAll
+		ex.Val = node.Val
+	case "is_null":
+		ex.Op = OpIsNull
+		ex.Val = node.Val
+	case "null_eq", "ndis", "not_distinct":
+		ex.Op = OpNotDistinct
+		ex.Val = node.Val
+	case "null_neq", "dis", "distinct":
+		ex.Op = OpDistinct
+		ex.Val = node.Val
+	default:
+		pushChildren(st, node.exp, node)
+		return nil, nil // skip node
+	}
+
+	if ex.Op != OpAnd && ex.Op != OpOr && ex.Op != OpNot {
+		switch node.Type {
+		case NodeStr:
+			ex.Type = ValStr
+		case NodeInt:
+			ex.Type = ValInt
+		case NodeBool:
+			ex.Type = ValBool
+		case NodeFloat:
+			ex.Type = ValFloat
+		case NodeList:
+			ex.Type = ValList
+		case NodeVar:
+			ex.Type = ValVar
+		default:
+			return nil, fmt.Errorf("[Where] valid values include string, int, float, boolean and list: %s", node.Type)
+		}
+		setWhereColName(ex, node)
+	}
+
+	return ex, nil
+}
+
+func setListVal(ex *Exp, node *Node) {
+	if len(node.Children) != 0 {
+		switch node.Children[0].Type {
+		case NodeStr:
+			ex.ListType = ValStr
+		case NodeInt:
+			ex.ListType = ValInt
+		case NodeBool:
+			ex.ListType = ValBool
+		case NodeFloat:
+			ex.ListType = ValFloat
+		}
+	}
+	for i := range node.Children {
+		ex.ListVal = append(ex.ListVal, node.Children[i].Val)
+	}
+}
+
+func setWhereColName(ex *Exp, node *Node) {
+	var list []string
+
+	for n := node.Parent; n != nil; n = n.Parent {
+		if n.Type != NodeObj {
+			continue
+		}
+		if len(n.Name) != 0 {
+			k := n.Name
+			if k == "and" || k == "or" || k == "not" ||
+				k == "_and" || k == "_or" || k == "_not" {
+				continue
+			}
+			list = append([]string{k}, list...)
+		}
+	}
+	listlen := len(list)
+
+	if listlen == 1 {
+		ex.Col = list[0]
+	} else if listlen > 1 {
+		ex.Col = list[listlen-1]
+		ex.NestedCols = list[:listlen]
+	}
+}
+
+func setOrderByColName(ob *OrderBy, node *Node) {
+	var list []string
+
+	for n := node; n != nil; n = n.Parent {
+		if len(n.Name) != 0 {
+			list = append([]string{n.Name}, list...)
+		}
+	}
+	if len(list) != 0 {
+		ob.Col = buildPath(list)
+	}
+}
+
+func pushChildren(st *util.Stack, exp *Exp, node *Node) {
+	for i := range node.Children {
+		node.Children[i].exp = exp
+		st.Push(node.Children[i])
+	}
+}
+
+func pushChild(st *util.Stack, exp *Exp, node *Node) {
+	node.Children[0].exp = exp
+	st.Push(node.Children[0])
+}
+
+func compileFilter(filter []string) (*Exp, bool, error) {
+	var fl *Exp
+	var needsUser bool
+
+	com := &Compiler{}
+	st := util.NewStack()
+
+	if len(filter) == 0 {
+		return &Exp{Op: OpNop, doFree: false}, false, nil
+	}
+
+	for i := range filter {
+		if filter[i] == "false" {
+			return &Exp{Op: OpFalse, doFree: false}, false, nil
+		}
+
+		node, err := ParseArgValue(filter[i])
+		if err != nil {
+			return nil, false, err
+		}
+		f, nu, err := com.compileArgNode(st, node, false)
+		if err != nil {
+			return nil, false, err
+		}
+		if nu {
+			needsUser = true
+		}
+
+		// TODO: Invalid table names in nested where causes fail silently
+		// returning a nil 'f' this needs to be fixed
+
+		// TODO: Invalid where clauses such as missing op (eg. eq) also fail silently
+
+		if fl == nil {
+			fl = f
+		} else {
+			fl = &Exp{Op: OpAnd, Children: []*Exp{fl, f}, doFree: false}
+		}
+	}
+	return fl, needsUser, nil
+}
+
+func buildPath(a []string) string {
+	switch len(a) {
+	case 0:
+		return ""
+	case 1:
+		return a[0]
+	}
+
+	n := len(a) - 1
+	for i := 0; i < len(a); i++ {
+		n += len(a[i])
+	}
+
+	var b strings.Builder
+	b.Grow(n)
+	b.WriteString(a[0])
+	for _, s := range a[1:] {
+		b.WriteRune('.')
+		b.WriteString(s)
+	}
+	return b.String()
+}
+
+func (t ExpOp) String() string {
+	var v string
+
+	switch t {
+	case OpNop:
+		v = "op-nop"
+	case OpAnd:
+		v = "op-and"
+	case OpOr:
+		v = "op-or"
+	case OpNot:
+		v = "op-not"
+	case OpEquals:
+		v = "op-equals"
+	case OpNotEquals:
+		v = "op-not-equals"
+	case OpGreaterOrEquals:
+		v = "op-greater-or-equals"
+	case OpLesserOrEquals:
+		v = "op-lesser-or-equals"
+	case OpGreaterThan:
+		v = "op-greater-than"
+	case OpLesserThan:
+		v = "op-lesser-than"
+	case OpIn:
+		v = "op-in"
+	case OpNotIn:
+		v = "op-not-in"
+	case OpLike:
+		v = "op-like"
+	case OpNotLike:
+		v = "op-not-like"
+	case OpILike:
+		v = "op-i-like"
+	case OpNotILike:
+		v = "op-not-i-like"
+	case OpSimilar:
+		v = "op-similar"
+	case OpNotSimilar:
+		v = "op-not-similar"
+	case OpContains:
+		v = "op-contains"
+	case OpContainedIn:
+		v = "op-contained-in"
+	case OpHasKey:
+		v = "op-has-key"
+	case OpHasKeyAny:
+		v = "op-has-key-any"
+	case OpHasKeyAll:
+		v = "op-has-key-all"
+	case OpIsNull:
+		v = "op-is-null"
+	case OpEqID:
+		v = "op-eq-id"
+	case OpTsQuery:
+		v = "op-ts-query"
+	}
+	return fmt.Sprintf("<%s>", v)
+}
+
+func FreeExp(ex *Exp) {
+	if ex.doFree {
+		expPool.Put(ex)
+	}
+}
+
+func argErr(name, ty string) error {
+	return fmt.Errorf("value for argument '%s' must be a %s", name, ty)
+}

core/internal/qcode/stack.go

@@ -0,0 +1,47 @@
+package qcode
+
+type Stack struct {
+	stA [20]int32
+	st  []int32
+	top int
+}
+
+// Create a new Stack
+func NewStack() *Stack {
+	s := &Stack{top: -1}
+	s.st = s.stA[:0]
+	return s
+}
+
+// Return the number of items in the Stack
+func (s *Stack) Len() int {
+	return (s.top + 1)
+}
+
+// View the top item on the Stack
+func (s *Stack) Peek() int32 {
+	if s.top == -1 {
+		return -1
+	}
+	return s.st[s.top]
+}
+
+// Pop the top item of the Stack and return it
+func (s *Stack) Pop() int32 {
+	if s.top == -1 {
+		return -1
+	}
+
+	s.top--
+	return s.st[(s.top + 1)]
+}
+
+// Push a value onto the top of the Stack
+func (s *Stack) 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/qcode/utils.go

@@ -0,0 +1,42 @@
+package qcode
+
+func GetQType(gql string) QType {
+	for i := range gql {
+		b := gql[i]
+		if b == '{' {
+			return QTQuery
+		}
+		if al(b) {
+			switch b {
+			case 'm', 'M':
+				return QTMutation
+			case 'q', 'Q':
+				return QTQuery
+			}
+		}
+	}
+	return -1
+}
+
+func al(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9')
+}
+
+func (qt QType) String() string {
+	switch qt {
+	case QTQuery:
+		return "query"
+	case QTMutation:
+		return "mutation"
+	case QTInsert:
+		return "insert"
+	case QTUpdate:
+		return "update"
+	case QTDelete:
+		return "delete"
+	case QTUpsert:
+		return "upsert"
+	}
+
+	return ""
+}

core/internal/util/stack.go

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