sqlbuilder/table.go at master · deoxxa/sqlbuilder · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package sqlbuilder

import "fmt"

type Table struct {
	name    string
	columns []*BasicColumn
}

func NewTable(name string, columns ...string) *Table {
	t := &Table{name: name}

	for _, c := range columns {
		t.columns = append(t.columns, &BasicColumn{
			table: t,
			name:  c,
		})
	}

	return t
}

func (t *Table) C(name string) *BasicColumn {
	for _, c := range t.columns {
		if c.name == name {
			return c
		}
	}

	panic(fmt.Errorf("Requested column %s does not exist in table %s", name, t.name))

	return nil
}

func (t *Table) Join(kind string, right AsTableOrSubquery) *JoinExpr {
	return Join(kind, t, right)
}

func (t *Table) LeftJoin(right AsTableOrSubquery) *JoinExpr {
	return LeftJoin(t, right)
}

func (t *Table) CrossJoin(right AsTableOrSubquery) *JoinExpr {
	return CrossJoin(t, right)
}

func (t *Table) AsNamed(s *Serializer) {
	s.N(t.name)
}

func (t *Table) AsTableOrSubquery(s *Serializer) {
	s.N(t.name)
}

type AsTableOrSubqueryAndWithColumns interface {
	AsTableOrSubquery
	WithColumns
}

type TableAlias struct {
	from    AsTableOrSubqueryAndWithColumns
	name    string
	columns map[string]*BasicColumn
}

func AliasTable(t AsTableOrSubqueryAndWithColumns, name string) *TableAlias {
	a := &TableAlias{
		from:    t,
		name:    name,
		columns: make(map[string]*BasicColumn),
	}

	return a
}

func (a *TableAlias) AsNamed(s *Serializer) {
	s.N(a.name)
}

func (a *TableAlias) AsTableOrSubquery(s *Serializer) {
	s.F(a.from.AsTableOrSubquery).D(" ").N(a.name)
}

func (a *TableAlias) C(name string) *BasicColumn {
	if a.columns[name] != nil {
		return a.columns[name]
	}

	if c := a.from.C(name); c != nil {
		a.columns[name] = &BasicColumn{table: a, name: name}
	}

	return a.columns[name]
}

func (a *TableAlias) Join(kind string, right AsTableOrSubquery) *JoinExpr {
	return Join(kind, a, right)
}

func (a *TableAlias) LeftJoin(right AsTableOrSubquery) *JoinExpr {
	return LeftJoin(a, right)
}

func (a *TableAlias) CrossJoin(right AsTableOrSubquery) *JoinExpr {
	return CrossJoin(a, right)
}