forked from umisama/go-sqlbuilder
-
Notifications
You must be signed in to change notification settings - Fork 0
/
create-index.go
132 lines (114 loc) · 2.8 KB
/
create-index.go
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package sqlbuilder
// CreateIndexBuilder is the Buildable interface wrapping of CreateTable
type CreateIndexBuilder interface {
IfNotExists() CreateIndexBuilder
Columns(columns ...Column) CreateIndexBuilder
Name(name string) CreateIndexBuilder
ToSql() (query string, args []interface{}, err error)
privateCreateIndex()
}
// CreateIndexStatement represents a "CREATE INDEX" statement.
type CreateIndexStatement struct {
table Table
columns []Column
name string
ifNotExists bool
err error
dialect Dialect
}
// CreateIndex returns new "CREATE INDEX" statement. The table is Table object to create index.
func CreateIndex(tbl Table) CreateIndexBuilder {
return createIndex(tbl, dialect())
}
func createIndex(tbl Table, d Dialect) *CreateIndexStatement {
if d == nil {
d = dialect()
}
if tbl == nil {
return &CreateIndexStatement{
err: newError("table is nil."),
}
}
if _, ok := tbl.(*table); !ok {
return &CreateIndexStatement{
err: newError("CreateTable can use only natural table."),
}
}
return &CreateIndexStatement{
table: tbl,
dialect: d,
}
}
func (b *CreateIndexStatement) privateCreateIndex() {
// nop
}
// IfNotExists sets "IF NOT EXISTS" clause.
func (b *CreateIndexStatement) IfNotExists() CreateIndexBuilder {
if b.err != nil {
return b
}
b.ifNotExists = true
return b
}
// IfNotExists sets "IF NOT EXISTS" clause. If not set this, returns error on ToSql().
func (b *CreateIndexStatement) Columns(columns ...Column) CreateIndexBuilder {
if b.err != nil {
return b
}
b.columns = columns
return b
}
// Name sets name for index.
// If not set this, auto generated name will be used.
func (b *CreateIndexStatement) Name(name string) CreateIndexBuilder {
if b.err != nil {
return b
}
b.name = name
return b
}
// ToSql generates query string, placeholder arguments, and returns err on errors.
func (b *CreateIndexStatement) ToSql() (query string, args []interface{}, err error) {
bldr := newBuilder(b.dialect)
defer func() {
query, args, err = bldr.Query(), bldr.Args(), bldr.Err()
}()
if b.err != nil {
bldr.SetError(b.err)
return
}
bldr.Append("CREATE INDEX ")
if b.ifNotExists {
bldr.Append("IF NOT EXISTS ")
}
if len(b.name) != 0 {
bldr.Append(b.dialect.QuoteField(b.name))
} else {
bldr.SetError(newError("name was not setted."))
return
}
bldr.Append(" ON ")
bldr.AppendItem(b.table)
if len(b.columns) != 0 {
bldr.Append(" ( ")
bldr.AppendItem(createIndexColumnList(b.columns))
bldr.Append(" )")
} else {
bldr.SetError(newError("columns was not setted."))
return
}
return
}
type createIndexColumnList []Column
func (m createIndexColumnList) serialize(bldr *builder) {
first := true
for _, column := range m {
if first {
first = false
} else {
bldr.Append(", ")
}
cc := column.config()
bldr.AppendItem(cc)
}
}