super-graph/psql/select.go

1067 lines
24 KiB
Go
Raw Normal View History

2019-03-24 14:57:29 +01:00
package psql
import (
"bytes"
2019-09-05 06:09:56 +02:00
"encoding/json"
2019-03-24 14:57:29 +01:00
"errors"
"fmt"
"io"
"math"
"strings"
2019-03-24 14:57:29 +01:00
"github.com/cespare/xxhash/v2"
2019-03-24 14:57:29 +01:00
"github.com/dosco/super-graph/qcode"
"github.com/dosco/super-graph/util"
)
2019-05-13 01:27:26 +02:00
const (
2019-06-08 02:53:08 +02:00
empty = ""
closeBlock = 500
2019-05-13 01:27:26 +02:00
)
2019-09-05 06:09:56 +02:00
type Variables map[string]json.RawMessage
2019-04-08 08:47:59 +02:00
type Config struct {
Schema *DBSchema
Vars map[string]string
2019-04-08 08:47:59 +02:00
}
2019-03-24 14:57:29 +01:00
type Compiler struct {
schema *DBSchema
2019-04-08 08:47:59 +02:00
vars map[string]string
2019-03-24 14:57:29 +01:00
}
2019-04-08 08:47:59 +02:00
func NewCompiler(conf Config) *Compiler {
return &Compiler{conf.Schema, conf.Vars}
2019-03-24 14:57:29 +01:00
}
func (c *Compiler) AddRelationship(child, parent string, rel *DBRel) error {
return c.schema.SetRel(child, parent, rel)
2019-05-13 01:27:26 +02:00
}
func (c *Compiler) IDColumn(table string) (string, error) {
t, err := c.schema.GetTable(table)
if err != nil {
return empty, err
2019-05-13 01:27:26 +02:00
}
return t.PrimaryCol, nil
2019-05-13 01:27:26 +02:00
}
2019-06-08 02:53:08 +02:00
type compilerContext struct {
w *bytes.Buffer
s []qcode.Select
*Compiler
}
2019-09-05 06:09:56 +02:00
func (co *Compiler) CompileEx(qc *qcode.QCode, vars Variables) (uint32, []byte, error) {
2019-06-02 01:48:42 +02:00
w := &bytes.Buffer{}
2019-09-05 06:09:56 +02:00
skipped, err := co.Compile(qc, w, vars)
2019-06-02 01:48:42 +02:00
return skipped, w.Bytes(), err
}
2019-09-05 06:09:56 +02:00
func (co *Compiler) Compile(qc *qcode.QCode, w *bytes.Buffer, vars Variables) (uint32, error) {
switch qc.Type {
case qcode.QTQuery:
return co.compileQuery(qc, w)
case qcode.QTMutation:
return co.compileMutation(qc, w, vars)
}
return 0, errors.New("unknown operation")
}
func (co *Compiler) compileQuery(qc *qcode.QCode, w *bytes.Buffer) (uint32, error) {
if len(qc.Selects) == 0 {
2019-06-02 01:48:42 +02:00
return 0, errors.New("empty query")
2019-05-13 01:27:26 +02:00
}
2019-09-05 06:09:56 +02:00
c := &compilerContext{w, qc.Selects, co}
root := &qc.Selects[0]
2019-03-24 14:57:29 +01:00
2019-09-20 06:19:11 +02:00
ti, err := c.schema.GetTable(root.Table)
if err != nil {
return 0, err
}
2019-06-08 02:53:08 +02:00
st := NewStack()
st.Push(root.ID + closeBlock)
st.Push(root.ID)
2019-03-24 14:57:29 +01:00
//fmt.Fprintf(w, `SELECT json_object_agg('%s', %s) FROM (`,
//root.FieldName, root.Table)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`SELECT json_object_agg('`)
c.w.WriteString(root.FieldName)
c.w.WriteString(`', `)
2019-09-20 06:19:11 +02:00
if ti.Singular == false {
c.w.WriteString(root.Table)
} else {
c.w.WriteString("sel_json_")
int2string(c.w, root.ID)
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`) FROM (`)
2019-05-13 01:27:26 +02:00
var ignored uint32
2019-03-24 14:57:29 +01:00
for {
if st.Len() == 0 {
break
}
2019-06-08 02:53:08 +02:00
id := st.Pop()
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
if id < closeBlock {
sel := &c.s[id]
ti, err := c.schema.GetTable(sel.Table)
if err != nil {
return 0, err
}
2019-06-08 02:53:08 +02:00
if sel.ID != 0 {
if err = c.renderJoin(sel); err != nil {
return 0, err
}
}
skipped, err := c.renderSelect(sel, ti)
2019-05-13 01:27:26 +02:00
if err != nil {
2019-06-02 01:48:42 +02:00
return 0, err
2019-05-13 01:27:26 +02:00
}
ignored |= skipped
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
for _, cid := range sel.Children {
if hasBit(skipped, uint32(cid)) {
2019-05-13 01:27:26 +02:00
continue
}
2019-06-08 02:53:08 +02:00
child := &c.s[cid]
2019-06-08 02:53:08 +02:00
st.Push(child.ID + closeBlock)
st.Push(child.ID)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
} else {
sel := &c.s[(id - closeBlock)]
ti, err := c.schema.GetTable(sel.Table)
if err != nil {
return 0, err
}
err = c.renderSelectClose(sel, ti)
if err != nil {
return 0, err
}
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
if sel.ID != 0 {
if err = c.renderJoinClose(sel); err != nil {
return 0, err
}
}
2019-03-24 14:57:29 +01:00
}
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
alias(c.w, `done_1337`)
c.w.WriteString(`;`)
2019-03-24 14:57:29 +01:00
2019-06-02 01:48:42 +02:00
return ignored, nil
2019-03-24 14:57:29 +01:00
}
func (c *compilerContext) processChildren(sel *qcode.Select, ti *DBTableInfo) (uint32, []*qcode.Column) {
2019-05-13 01:27:26 +02:00
var skipped uint32
2019-06-08 02:53:08 +02:00
cols := make([]*qcode.Column, 0, len(sel.Cols))
colmap := make(map[string]struct{}, len(sel.Cols))
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
for i := range sel.Cols {
colmap[sel.Cols[i].Name] = struct{}{}
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
for _, id := range sel.Children {
child := &c.s[id]
2019-03-24 14:57:29 +01:00
rel, err := c.schema.GetRel(child.Table, ti.Name)
if err != nil {
2019-05-13 01:27:26 +02:00
skipped |= (1 << uint(id))
2019-03-24 14:57:29 +01:00
continue
}
2019-05-13 01:27:26 +02:00
switch rel.Type {
case RelOneToMany:
fallthrough
case RelBelongTo:
2019-03-24 14:57:29 +01:00
if _, ok := colmap[rel.Col2]; !ok {
2019-06-08 02:53:08 +02:00
cols = append(cols, &qcode.Column{sel.Table, rel.Col2, rel.Col2})
2019-03-24 14:57:29 +01:00
}
2019-05-13 01:27:26 +02:00
case RelOneToManyThrough:
2019-03-24 14:57:29 +01:00
if _, ok := colmap[rel.Col1]; !ok {
2019-06-08 02:53:08 +02:00
cols = append(cols, &qcode.Column{sel.Table, rel.Col1, rel.Col1})
2019-03-24 14:57:29 +01:00
}
2019-05-13 01:27:26 +02:00
case RelRemote:
if _, ok := colmap[rel.Col1]; !ok {
2019-06-08 02:53:08 +02:00
cols = append(cols, &qcode.Column{sel.Table, rel.Col1, rel.Col2})
2019-05-13 01:27:26 +02:00
}
skipped |= (1 << uint(id))
default:
skipped |= (1 << uint(id))
2019-03-24 14:57:29 +01:00
}
}
2019-05-13 01:27:26 +02:00
return skipped, cols
2019-03-24 14:57:29 +01:00
}
func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo) (uint32, error) {
skipped, childCols := c.processChildren(sel, ti)
2019-06-08 02:53:08 +02:00
hasOrder := len(sel.OrderBy) != 0
2019-03-24 14:57:29 +01:00
// SELECT
if ti.Singular == false {
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `SELECT coalesce(json_agg("%s"`, c.sel.Table)
c.w.WriteString(`SELECT coalesce(json_agg("`)
2019-09-20 06:19:11 +02:00
c.w.WriteString("sel_json_")
int2string(c.w, sel.ID)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`"`)
2019-03-24 14:57:29 +01:00
if hasOrder {
2019-06-08 02:53:08 +02:00
err := c.renderOrderBy(sel)
2019-03-24 14:57:29 +01:00
if err != nil {
2019-05-13 01:27:26 +02:00
return skipped, err
2019-03-24 14:57:29 +01:00
}
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `), '[]') AS "%s" FROM (`, c.sel.Table)
c.w.WriteString(`), '[]')`)
alias(c.w, sel.Table)
c.w.WriteString(` FROM (`)
2019-03-24 14:57:29 +01:00
}
// ROW-TO-JSON
2019-06-08 02:53:08 +02:00
c.w.WriteString(`SELECT `)
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
if len(sel.DistinctOn) != 0 {
c.renderDistinctOn(sel)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`row_to_json((`)
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `SELECT "sel_%d" FROM (SELECT `, c.sel.ID)
c.w.WriteString(`SELECT "sel_`)
int2string(c.w, sel.ID)
c.w.WriteString(`" FROM (SELECT `)
2019-03-24 14:57:29 +01:00
// Combined column names
2019-06-08 02:53:08 +02:00
c.renderColumns(sel)
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
c.renderRemoteRelColumns(sel)
2019-05-13 01:27:26 +02:00
2019-06-08 02:53:08 +02:00
err := c.renderJoinedColumns(sel, skipped)
2019-03-24 14:57:29 +01:00
if err != nil {
2019-05-13 01:27:26 +02:00
return skipped, err
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `) AS "sel_%d"`, c.sel.ID)
c.w.WriteString(`)`)
aliasWithID(c.w, "sel", sel.ID)
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `)) AS "%s"`, c.sel.Table)
c.w.WriteString(`))`)
2019-09-20 06:19:11 +02:00
aliasWithID(c.w, "sel_json", sel.ID)
2019-03-24 14:57:29 +01:00
// END-ROW-TO-JSON
if hasOrder {
2019-06-08 02:53:08 +02:00
c.renderOrderByColumns(sel)
2019-03-24 14:57:29 +01:00
}
// END-SELECT
// FROM (SELECT .... )
err = c.renderBaseSelect(sel, ti, childCols, skipped)
if err != nil {
2019-05-13 01:27:26 +02:00
return skipped, err
2019-03-24 14:57:29 +01:00
}
// END-FROM
2019-05-13 01:27:26 +02:00
return skipped, nil
2019-03-24 14:57:29 +01:00
}
func (c *compilerContext) renderSelectClose(sel *qcode.Select, ti *DBTableInfo) error {
2019-06-08 02:53:08 +02:00
hasOrder := len(sel.OrderBy) != 0
2019-03-24 14:57:29 +01:00
if hasOrder {
2019-06-08 02:53:08 +02:00
err := c.renderOrderBy(sel)
2019-03-24 14:57:29 +01:00
if err != nil {
return err
}
}
2019-06-08 02:53:08 +02:00
if len(sel.Paging.Limit) != 0 {
//fmt.Fprintf(w, ` LIMIT ('%s') :: integer`, c.sel.Paging.Limit)
c.w.WriteString(` LIMIT ('`)
c.w.WriteString(sel.Paging.Limit)
c.w.WriteString(`') :: integer`)
} else if ti.Singular {
c.w.WriteString(` LIMIT ('1') :: integer`)
2019-03-24 14:57:29 +01:00
} else {
2019-06-08 02:53:08 +02:00
c.w.WriteString(` LIMIT ('20') :: integer`)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
if len(sel.Paging.Offset) != 0 {
//fmt.Fprintf(w, ` OFFSET ('%s') :: integer`, c.sel.Paging.Offset)
c.w.WriteString(`OFFSET ('`)
c.w.WriteString(sel.Paging.Offset)
c.w.WriteString(`') :: integer`)
2019-03-24 14:57:29 +01:00
}
if ti.Singular == false {
2019-09-20 06:19:11 +02:00
//fmt.Fprintf(w, `) AS "sel_json_agg_%d"`, c.sel.ID)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
2019-09-20 06:19:11 +02:00
aliasWithID(c.w, "sel_json_agg", sel.ID)
2019-03-24 14:57:29 +01:00
}
return nil
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderJoin(sel *qcode.Select) error {
c.w.WriteString(` LEFT OUTER JOIN LATERAL (`)
2019-03-24 14:57:29 +01:00
return nil
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderJoinClose(sel *qcode.Select) error {
//fmt.Fprintf(w, `) AS "%s_%d_join" ON ('true')`, c.sel.Table, c.sel.ID)
c.w.WriteString(`)`)
aliasWithIDSuffix(c.w, sel.Table, sel.ID, "_join")
c.w.WriteString(` ON ('true')`)
2019-03-24 14:57:29 +01:00
return nil
}
func (c *compilerContext) renderJoinTable(sel *qcode.Select) error {
parent := &c.s[sel.ParentID]
rel, err := c.schema.GetRel(sel.Table, parent.Table)
if err != nil {
return err
2019-03-24 14:57:29 +01:00
}
if rel.Type != RelOneToManyThrough {
return err
2019-03-24 14:57:29 +01:00
}
pt, err := c.schema.GetTable(parent.Table)
if err != nil {
return err
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, ` LEFT OUTER JOIN "%s" ON (("%s"."%s") = ("%s_%d"."%s"))`,
2019-06-08 02:53:08 +02:00
//rel.Through, rel.Through, rel.ColT, c.parent.Table, c.parent.ID, rel.Col1)
c.w.WriteString(` LEFT OUTER JOIN "`)
c.w.WriteString(rel.Through)
c.w.WriteString(`" ON ((`)
colWithTable(c.w, rel.Through, rel.ColT)
c.w.WriteString(`) = (`)
colWithTableID(c.w, pt.Name, parent.ID, rel.Col1)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`))`)
return nil
2019-06-08 02:53:08 +02:00
}
func (c *compilerContext) renderColumns(sel *qcode.Select) {
for i, col := range sel.Cols {
2019-05-13 01:27:26 +02:00
if i != 0 {
2019-06-08 02:53:08 +02:00
io.WriteString(c.w, ", ")
2019-05-13 01:27:26 +02:00
}
//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s"`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, c.sel.ID, col.Name, col.FieldName)
colWithTableIDAlias(c.w, sel.Table, sel.ID, col.Name, col.FieldName)
2019-05-13 01:27:26 +02:00
}
}
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderRemoteRelColumns(sel *qcode.Select) {
2019-05-13 01:27:26 +02:00
i := 0
2019-06-08 02:53:08 +02:00
for _, id := range sel.Children {
child := &c.s[id]
2019-05-13 01:27:26 +02:00
rel, err := c.schema.GetRel(child.Table, sel.Table)
if err != nil || rel.Type != RelRemote {
2019-05-13 01:27:26 +02:00
continue
}
2019-06-08 02:53:08 +02:00
if i != 0 || len(sel.Cols) != 0 {
io.WriteString(c.w, ", ")
2019-03-24 14:57:29 +01:00
}
//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s"`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, c.sel.ID, rel.Col1, rel.Col2)
colWithTableID(c.w, sel.Table, sel.ID, rel.Col1)
alias(c.w, rel.Col2)
2019-05-13 01:27:26 +02:00
i++
2019-03-24 14:57:29 +01:00
}
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderJoinedColumns(sel *qcode.Select, skipped uint32) error {
colsRendered := len(sel.Cols) != 0
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
for _, id := range sel.Children {
skipThis := hasBit(skipped, uint32(id))
2019-03-24 14:57:29 +01:00
2019-05-13 01:27:26 +02:00
if colsRendered && !skipThis {
2019-06-08 02:53:08 +02:00
io.WriteString(c.w, ", ")
2019-03-24 14:57:29 +01:00
}
2019-05-13 01:27:26 +02:00
if skipThis {
continue
}
2019-06-08 02:53:08 +02:00
sel := &c.s[id]
2019-05-13 01:27:26 +02:00
//fmt.Fprintf(w, `"%s_%d_join"."%s" AS "%s"`,
//s.Table, s.ID, s.Table, s.FieldName)
2019-06-08 02:53:08 +02:00
colWithTableIDSuffixAlias(c.w, sel.Table, sel.ID, "_join", sel.Table, sel.FieldName)
2019-03-24 14:57:29 +01:00
}
return nil
}
func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
2019-06-08 02:53:08 +02:00
childCols []*qcode.Column, skipped uint32) error {
var groupBy []int
2019-06-08 02:53:08 +02:00
isRoot := sel.ID == 0
isFil := sel.Where != nil
isSearch := sel.Args["search"] != nil
isAgg := false
2019-06-08 02:53:08 +02:00
c.w.WriteString(` FROM (SELECT `)
2019-06-08 02:53:08 +02:00
for i, col := range sel.Cols {
cn := col.Name
2019-06-08 02:53:08 +02:00
_, isRealCol := ti.Columns[cn]
2019-04-07 07:12:11 +02:00
2019-04-09 03:24:29 +02:00
if !isRealCol {
if isSearch {
switch {
case cn == "search_rank":
2019-06-08 02:53:08 +02:00
cn = ti.TSVCol
arg := sel.Args["search"]
//fmt.Fprintf(w, `ts_rank("%s"."%s", to_tsquery('%s')) AS %s`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, cn, arg.Val, col.Name)
c.w.WriteString(`ts_rank(`)
colWithTable(c.w, sel.Table, cn)
c.w.WriteString(`, to_tsquery('`)
c.w.WriteString(arg.Val)
c.w.WriteString(`')`)
alias(c.w, col.Name)
2019-04-07 07:12:11 +02:00
2019-04-09 03:24:29 +02:00
case strings.HasPrefix(cn, "search_headline_"):
cn = cn[16:]
2019-06-08 02:53:08 +02:00
arg := sel.Args["search"]
//fmt.Fprintf(w, `ts_headline("%s"."%s", to_tsquery('%s')) AS %s`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, cn, arg.Val, col.Name)
c.w.WriteString(`ts_headlinek(`)
colWithTable(c.w, sel.Table, cn)
c.w.WriteString(`, to_tsquery('`)
c.w.WriteString(arg.Val)
c.w.WriteString(`')`)
alias(c.w, col.Name)
2019-04-09 03:24:29 +02:00
}
} else {
pl := funcPrefixLen(cn)
if pl == 0 {
//fmt.Fprintf(w, `'%s not defined' AS %s`, cn, col.Name)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`'`)
c.w.WriteString(cn)
c.w.WriteString(` not defined'`)
alias(c.w, col.Name)
} else {
isAgg = true
fn := cn[0 : pl-1]
cn := cn[pl:]
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `%s("%s"."%s") AS %s`, fn, c.sel.Table, cn, col.Name)
c.w.WriteString(fn)
c.w.WriteString(`(`)
colWithTable(c.w, sel.Table, cn)
c.w.WriteString(`)`)
alias(c.w, col.Name)
}
}
2019-03-24 14:57:29 +01:00
} else {
groupBy = append(groupBy, i)
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Table, cn)
colWithTable(c.w, sel.Table, cn)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
if i < len(sel.Cols)-1 || len(childCols) != 0 {
//io.WriteString(w, ", ")
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-03-24 14:57:29 +01:00
}
}
for i, col := range childCols {
2019-05-13 01:27:26 +02:00
if i != 0 {
//io.WriteString(w, ", ")
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
}
2019-05-13 01:27:26 +02:00
//fmt.Fprintf(w, `"%s"."%s"`, col.Table, col.Name)
2019-06-08 02:53:08 +02:00
colWithTable(c.w, col.Table, col.Name)
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(` FROM `)
if c.schema.IsAlias(sel.Table) || ti.Singular {
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, ` FROM "%s" AS "%s"`, tn, c.sel.Table)
tableWithAlias(c.w, ti.Name, sel.Table)
2019-04-09 03:24:29 +02:00
} else {
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Table)
c.w.WriteString(`"`)
c.w.WriteString(ti.Name)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`"`)
2019-04-09 03:24:29 +02:00
}
// if tn, ok := c.tmap[sel.Table]; ok {
// //fmt.Fprintf(w, ` FROM "%s" AS "%s"`, tn, c.sel.Table)
// tableWithAlias(c.w, ti.Name, sel.Table)
// } else {
// //fmt.Fprintf(w, ` FROM "%s"`, c.sel.Table)
// c.w.WriteString(`"`)
// c.w.WriteString(sel.Table)
// c.w.WriteString(`"`)
// }
2019-04-04 06:53:24 +02:00
if isRoot && isFil {
2019-06-08 02:53:08 +02:00
c.w.WriteString(` WHERE (`)
if err := c.renderWhere(sel, ti); err != nil {
2019-04-04 06:53:24 +02:00
return err
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
}
2019-04-04 06:53:24 +02:00
if !isRoot {
if err := c.renderJoinTable(sel); err != nil {
return err
}
2019-04-04 06:53:24 +02:00
2019-06-08 02:53:08 +02:00
c.w.WriteString(` WHERE (`)
if err := c.renderRelationship(sel); err != nil {
return err
}
2019-04-04 06:53:24 +02:00
if isFil {
2019-06-08 02:53:08 +02:00
c.w.WriteString(` AND `)
if err := c.renderWhere(sel, ti); err != nil {
return err
}
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
}
2019-04-04 06:53:24 +02:00
if isAgg {
if len(groupBy) != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(` GROUP BY `)
2019-04-04 06:53:24 +02:00
for i, id := range groupBy {
2019-05-13 01:27:26 +02:00
if i != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-04-04 06:53:24 +02:00
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Table, c.sel.Cols[id].Name)
colWithTable(c.w, sel.Table, sel.Cols[id].Name)
}
}
}
2019-06-08 02:53:08 +02:00
if len(sel.Paging.Limit) != 0 {
//fmt.Fprintf(w, ` LIMIT ('%s') :: integer`, c.sel.Paging.Limit)
c.w.WriteString(` LIMIT ('`)
c.w.WriteString(sel.Paging.Limit)
c.w.WriteString(`') :: integer`)
} else if ti.Singular {
c.w.WriteString(` LIMIT ('1') :: integer`)
} else {
2019-06-08 02:53:08 +02:00
c.w.WriteString(` LIMIT ('20') :: integer`)
}
2019-06-08 02:53:08 +02:00
if len(sel.Paging.Offset) != 0 {
//fmt.Fprintf(w, ` OFFSET ('%s') :: integer`, c.sel.Paging.Offset)
c.w.WriteString(` OFFSET ('`)
c.w.WriteString(sel.Paging.Offset)
c.w.WriteString(`') :: integer`)
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `) AS "%s_%d"`, c.sel.Table, c.sel.ID)
c.w.WriteString(`)`)
aliasWithID(c.w, sel.Table, sel.ID)
return nil
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderOrderByColumns(sel *qcode.Select) {
colsRendered := len(sel.Cols) != 0
2019-03-24 14:57:29 +01:00
2019-06-08 02:53:08 +02:00
for i := range sel.OrderBy {
2019-05-13 01:27:26 +02:00
if colsRendered {
//io.WriteString(w, ", ")
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-05-13 01:27:26 +02:00
}
2019-06-08 02:53:08 +02:00
col := sel.OrderBy[i].Col
//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s_%d_%s_ob"`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, c.sel.ID, c,
//c.sel.Table, c.sel.ID, c)
colWithTableID(c.w, sel.Table, sel.ID, col)
c.w.WriteString(` AS `)
tableIDColSuffix(c.w, sel.Table, sel.ID, col, "_ob")
2019-03-24 14:57:29 +01:00
}
}
func (c *compilerContext) renderRelationship(sel *qcode.Select) error {
2019-06-08 02:53:08 +02:00
parent := c.s[sel.ParentID]
rel, err := c.schema.GetRel(sel.Table, parent.Table)
if err != nil {
return err
}
2019-03-24 14:57:29 +01:00
switch rel.Type {
case RelBelongTo:
//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, rel.Col1, c.parent.Table, c.parent.ID, rel.Col2)
c.w.WriteString(`((`)
colWithTable(c.w, sel.Table, rel.Col1)
c.w.WriteString(`) = (`)
colWithTableID(c.w, parent.Table, parent.ID, rel.Col2)
c.w.WriteString(`))`)
2019-03-24 14:57:29 +01:00
case RelOneToMany:
//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, rel.Col1, c.parent.Table, c.parent.ID, rel.Col2)
c.w.WriteString(`((`)
colWithTable(c.w, sel.Table, rel.Col1)
c.w.WriteString(`) = (`)
colWithTableID(c.w, parent.Table, parent.ID, rel.Col2)
c.w.WriteString(`))`)
2019-03-24 14:57:29 +01:00
case RelOneToManyThrough:
//fmt.Fprintf(w, `(("%s"."%s") = ("%s"."%s"))`,
2019-06-08 02:53:08 +02:00
//c.sel.Table, rel.Col1, rel.Through, rel.Col2)
c.w.WriteString(`((`)
colWithTable(c.w, sel.Table, rel.Col1)
c.w.WriteString(`) = (`)
colWithTable(c.w, rel.Through, rel.Col2)
c.w.WriteString(`))`)
2019-03-24 14:57:29 +01:00
}
return nil
2019-03-24 14:57:29 +01:00
}
func (c *compilerContext) renderWhere(sel *qcode.Select, ti *DBTableInfo) error {
2019-03-24 14:57:29 +01:00
st := util.NewStack()
2019-06-08 02:53:08 +02:00
if sel.Where != nil {
st.Push(sel.Where)
}
2019-03-24 14:57:29 +01:00
for {
if st.Len() == 0 {
break
}
intf := st.Pop()
switch val := intf.(type) {
case qcode.ExpOp:
switch val {
case qcode.OpAnd:
2019-06-08 02:53:08 +02:00
c.w.WriteString(` AND `)
2019-03-24 14:57:29 +01:00
case qcode.OpOr:
2019-06-08 02:53:08 +02:00
c.w.WriteString(` OR `)
2019-03-24 14:57:29 +01:00
case qcode.OpNot:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`NOT `)
2019-03-24 14:57:29 +01:00
default:
2019-05-13 01:27:26 +02:00
return fmt.Errorf("11: unexpected value %v (%t)", intf, intf)
2019-03-24 14:57:29 +01:00
}
case *qcode.Exp:
switch val.Op {
case qcode.OpAnd, qcode.OpOr:
for i := len(val.Children) - 1; i >= 0; i-- {
st.Push(val.Children[i])
if i > 0 {
st.Push(val.Op)
}
}
qcode.FreeExp(val)
2019-03-24 14:57:29 +01:00
continue
case qcode.OpNot:
st.Push(val.Children[0])
st.Push(qcode.OpNot)
qcode.FreeExp(val)
2019-03-24 14:57:29 +01:00
continue
}
if val.NestedCol {
//fmt.Fprintf(w, `(("%s") `, val.Col)
2019-06-08 02:53:08 +02:00
c.w.WriteString(`(("`)
c.w.WriteString(val.Col)
c.w.WriteString(`") `)
} else if len(val.Col) != 0 {
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `(("%s"."%s") `, c.sel.Table, val.Col)
c.w.WriteString(`((`)
colWithTable(c.w, sel.Table, val.Col)
c.w.WriteString(`) `)
2019-03-24 14:57:29 +01:00
}
valExists := true
2019-03-24 14:57:29 +01:00
switch val.Op {
case qcode.OpEquals:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`=`)
2019-03-24 14:57:29 +01:00
case qcode.OpNotEquals:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`!=`)
2019-03-24 14:57:29 +01:00
case qcode.OpGreaterOrEquals:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`>=`)
2019-03-24 14:57:29 +01:00
case qcode.OpLesserOrEquals:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`<=`)
2019-03-24 14:57:29 +01:00
case qcode.OpGreaterThan:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`>`)
2019-03-24 14:57:29 +01:00
case qcode.OpLesserThan:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`<`)
2019-03-24 14:57:29 +01:00
case qcode.OpIn:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`IN`)
2019-03-24 14:57:29 +01:00
case qcode.OpNotIn:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`NOT IN`)
2019-03-24 14:57:29 +01:00
case qcode.OpLike:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`LIKE`)
2019-03-24 14:57:29 +01:00
case qcode.OpNotLike:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`NOT LIKE`)
2019-03-24 14:57:29 +01:00
case qcode.OpILike:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`ILIKE`)
2019-03-24 14:57:29 +01:00
case qcode.OpNotILike:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`NOT ILIKE`)
2019-03-24 14:57:29 +01:00
case qcode.OpSimilar:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`SIMILAR TO`)
2019-03-24 14:57:29 +01:00
case qcode.OpNotSimilar:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`NOT SIMILAR TO`)
2019-03-24 14:57:29 +01:00
case qcode.OpContains:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`@>`)
2019-03-24 14:57:29 +01:00
case qcode.OpContainedIn:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`<@`)
2019-03-24 14:57:29 +01:00
case qcode.OpHasKey:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`?`)
case qcode.OpHasKeyAny:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`?|`)
case qcode.OpHasKeyAll:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`?&`)
case qcode.OpIsNull:
if strings.EqualFold(val.Val, "true") {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`IS NULL)`)
} else {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`IS NOT NULL)`)
}
valExists = false
case qcode.OpEqID:
2019-06-08 02:53:08 +02:00
if len(ti.PrimaryCol) == 0 {
return fmt.Errorf("no primary key column defined for %s", sel.Table)
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `(("%s") =`, c.ti.PrimaryCol)
c.w.WriteString(`(("`)
c.w.WriteString(ti.PrimaryCol)
c.w.WriteString(`") =`)
case qcode.OpTsQuery:
2019-06-08 02:53:08 +02:00
if len(ti.TSVCol) == 0 {
return fmt.Errorf("no tsv column defined for %s", sel.Table)
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `(("%s") @@ to_tsquery('%s'))`, c.ti.TSVCol, val.Val)
c.w.WriteString(`(("`)
c.w.WriteString(ti.TSVCol)
c.w.WriteString(`") @@ to_tsquery('`)
c.w.WriteString(val.Val)
c.w.WriteString(`'))`)
valExists = false
2019-03-24 14:57:29 +01:00
default:
return fmt.Errorf("[Where] unexpected op code %d", val.Op)
}
if valExists {
if val.Type == qcode.ValList {
2019-06-08 02:53:08 +02:00
c.renderList(val)
} else {
2019-06-08 02:53:08 +02:00
c.renderVal(val, c.vars)
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
2019-03-24 14:57:29 +01:00
}
qcode.FreeExp(val)
2019-03-24 14:57:29 +01:00
default:
2019-05-13 01:27:26 +02:00
return fmt.Errorf("12: unexpected value %v (%t)", intf, intf)
2019-03-24 14:57:29 +01:00
}
2019-03-24 14:57:29 +01:00
}
return nil
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderOrderBy(sel *qcode.Select) error {
c.w.WriteString(` ORDER BY `)
2019-03-24 14:57:29 +01:00
for i := range sel.OrderBy {
2019-05-13 01:27:26 +02:00
if i != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-05-13 01:27:26 +02:00
}
2019-03-24 14:57:29 +01:00
ob := sel.OrderBy[i]
switch ob.Order {
case qcode.OrderAsc:
//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` ASC`)
2019-03-24 14:57:29 +01:00
case qcode.OrderDesc:
//fmt.Fprintf(w, `"%s_%d.ob.%s" DESC`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` DESC`)
2019-03-24 14:57:29 +01:00
case qcode.OrderAscNullsFirst:
//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC NULLS FIRST`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` ASC NULLS FIRST`)
2019-03-24 14:57:29 +01:00
case qcode.OrderDescNullsFirst:
//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS FIRST`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` DESC NULLLS FIRST`)
2019-03-24 14:57:29 +01:00
case qcode.OrderAscNullsLast:
//fmt.Fprintf(w, `"%s_%d.ob.%s ASC NULLS LAST`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` ASC NULLS LAST`)
2019-03-24 14:57:29 +01:00
case qcode.OrderDescNullsLast:
//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS LAST`, sel.Table, sel.ID, ob.Col)
2019-06-08 02:53:08 +02:00
tableIDColSuffix(c.w, sel.Table, sel.ID, ob.Col, "_ob")
c.w.WriteString(` DESC NULLS LAST`)
2019-03-24 14:57:29 +01:00
default:
2019-05-13 06:05:08 +02:00
return fmt.Errorf("13: unexpected value %v", ob.Order)
2019-03-24 14:57:29 +01:00
}
}
return nil
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderDistinctOn(sel *qcode.Select) {
io.WriteString(c.w, `DISTINCT ON (`)
for i := range sel.DistinctOn {
2019-05-13 01:27:26 +02:00
if i != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
//fmt.Fprintf(w, `"%s_%d.ob.%s"`, c.sel.Table, c.sel.ID, c.sel.DistinctOn[i])
tableIDColSuffix(c.w, sel.Table, sel.ID, sel.DistinctOn[i], "_ob")
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`) `)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderList(ex *qcode.Exp) {
io.WriteString(c.w, ` (`)
2019-03-24 14:57:29 +01:00
for i := range ex.ListVal {
2019-05-13 01:27:26 +02:00
if i != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`, `)
2019-05-13 01:27:26 +02:00
}
2019-03-24 14:57:29 +01:00
switch ex.ListType {
case qcode.ValBool, qcode.ValInt, qcode.ValFloat:
2019-06-08 02:53:08 +02:00
c.w.WriteString(ex.ListVal[i])
2019-03-24 14:57:29 +01:00
case qcode.ValStr:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`'`)
c.w.WriteString(ex.ListVal[i])
c.w.WriteString(`'`)
2019-03-24 14:57:29 +01:00
}
}
2019-06-08 02:53:08 +02:00
c.w.WriteString(`)`)
2019-03-24 14:57:29 +01:00
}
2019-06-08 02:53:08 +02:00
func (c *compilerContext) renderVal(ex *qcode.Exp,
vars map[string]string) {
2019-09-05 06:40:52 +02:00
io.WriteString(c.w, ` `)
2019-03-24 14:57:29 +01:00
switch ex.Type {
case qcode.ValBool, qcode.ValInt, qcode.ValFloat:
2019-04-19 07:55:03 +02:00
if len(ex.Val) != 0 {
2019-06-08 02:53:08 +02:00
c.w.WriteString(ex.Val)
2019-04-19 07:55:03 +02:00
} else {
2019-06-08 02:53:08 +02:00
c.w.WriteString(`''`)
2019-04-19 07:55:03 +02:00
}
2019-09-05 06:09:56 +02:00
2019-03-24 14:57:29 +01:00
case qcode.ValStr:
2019-06-08 02:53:08 +02:00
c.w.WriteString(`'`)
c.w.WriteString(ex.Val)
c.w.WriteString(`'`)
2019-09-05 06:09:56 +02:00
2019-03-24 14:57:29 +01:00
case qcode.ValVar:
if val, ok := vars[ex.Val]; ok {
2019-06-08 02:53:08 +02:00
c.w.WriteString(val)
2019-03-24 14:57:29 +01:00
} else {
//fmt.Fprintf(w, `'{{%s}}'`, ex.Val)
2019-09-05 06:09:56 +02:00
c.w.WriteString(`{{`)
2019-06-08 02:53:08 +02:00
c.w.WriteString(ex.Val)
2019-09-05 06:09:56 +02:00
c.w.WriteString(`}}`)
2019-03-24 14:57:29 +01:00
}
}
2019-09-05 06:09:56 +02:00
//c.w.WriteString(`)`)
2019-03-24 14:57:29 +01:00
}
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
}
2019-05-13 01:27:26 +02:00
2019-06-08 02:53:08 +02:00
func hasBit(n uint32, pos uint32) bool {
2019-05-13 01:27:26 +02:00
val := n & (1 << pos)
return (val > 0)
}
func alias(w *bytes.Buffer, alias string) {
w.WriteString(` AS "`)
w.WriteString(alias)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func aliasWithID(w *bytes.Buffer, alias string, id int32) {
w.WriteString(` AS "`)
w.WriteString(alias)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func aliasWithIDSuffix(w *bytes.Buffer, alias string, id int32, suffix string) {
w.WriteString(` AS "`)
w.WriteString(alias)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(suffix)
w.WriteString(`"`)
}
func colWithAlias(w *bytes.Buffer, col, alias string) {
w.WriteString(`"`)
w.WriteString(col)
w.WriteString(`" AS "`)
w.WriteString(alias)
w.WriteString(`"`)
}
func tableWithAlias(w *bytes.Buffer, table, alias string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`" AS "`)
w.WriteString(alias)
w.WriteString(`"`)
}
func colWithTable(w *bytes.Buffer, table, col string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`"."`)
w.WriteString(col)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func colWithTableID(w *bytes.Buffer, table string, id int32, col string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(`"."`)
w.WriteString(col)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func colWithTableIDAlias(w *bytes.Buffer, table string, id int32, col, alias string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(`"."`)
w.WriteString(col)
w.WriteString(`" AS "`)
w.WriteString(alias)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func colWithTableIDSuffixAlias(w *bytes.Buffer, table string, id int32,
suffix, col, alias string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(suffix)
w.WriteString(`"."`)
w.WriteString(col)
w.WriteString(`" AS "`)
w.WriteString(alias)
w.WriteString(`"`)
}
2019-06-08 02:53:08 +02:00
func tableIDColSuffix(w *bytes.Buffer, table string, id int32, col, suffix string) {
w.WriteString(`"`)
w.WriteString(table)
w.WriteString(`_`)
int2string(w, id)
w.WriteString(`_`)
w.WriteString(col)
w.WriteString(suffix)
w.WriteString(`"`)
}
const charset = "0123456789"
2019-06-08 02:53:08 +02:00
func int2string(w *bytes.Buffer, val int32) {
if val < 10 {
w.WriteByte(charset[val])
return
}
2019-06-08 02:53:08 +02:00
temp := int32(0)
val2 := val
for val2 > 0 {
temp *= 10
temp += val2 % 10
2019-06-08 02:53:08 +02:00
val2 = int32(math.Floor(float64(val2 / 10)))
}
val3 := temp
for val3 > 0 {
d := val3 % 10
val3 /= 10
w.WriteByte(charset[d])
}
}
func relID(h *xxhash.Digest, child, parent string) uint64 {
h.WriteString(child)
h.WriteString(parent)
v := h.Sum64()
h.Reset()
return v
}