/
delete_plan.go
157 lines (132 loc) · 3.14 KB
/
delete_plan.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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
/*
* Radon
*
* Copyright 2018 The Radon Authors.
* Code is licensed under the GPLv3.
*
*/
package planner
import (
"encoding/json"
"router"
"xcontext"
"github.com/pkg/errors"
"github.com/xelabs/go-mysqlstack/sqlparser"
"github.com/xelabs/go-mysqlstack/sqlparser/depends/hack"
"github.com/xelabs/go-mysqlstack/xlog"
)
var (
_ Plan = &DeletePlan{}
)
// DeletePlan represents delete plan
type DeletePlan struct {
log *xlog.Log
// router
router *router.Router
// delete ast
node *sqlparser.Delete
// database
database string
// raw query
RawQuery string
// type
typ PlanType
// mode
ReqMode xcontext.RequestMode
// query and backend tuple
Querys []xcontext.QueryTuple
}
// NewDeletePlan used to create DeletePlan
func NewDeletePlan(log *xlog.Log, database string, query string, node *sqlparser.Delete, router *router.Router) *DeletePlan {
return &DeletePlan{
log: log,
node: node,
router: router,
database: database,
RawQuery: query,
typ: PlanTypeDelete,
Querys: make([]xcontext.QueryTuple, 0, 16),
}
}
// analyze used to analyze the 'delete' is at the support level.
func (p *DeletePlan) analyze() error {
node := p.node
// analyze subquery.
if hasSubquery(node) {
return errors.New("unsupported: subqueries.in.delete")
}
if node.Where == nil {
return errors.New("unsupported: missing.where.clause.in.DML")
}
return nil
}
// Build used to build distributed querys.
func (p *DeletePlan) Build() error {
if err := p.analyze(); err != nil {
return err
}
node := p.node
// Database.
database := p.database
if !node.Table.Qualifier.IsEmpty() {
database = node.Table.Qualifier.String()
}
table := node.Table.Name.String()
// Sharding key.
shardkey, err := p.router.ShardKey(database, table)
if err != nil {
return err
}
// Get the routing segments info.
segments, err := getDMLRouting(database, table, shardkey, node.Where, p.router)
if err != nil {
return err
}
// Rewritten the query.
for _, segment := range segments {
buf := sqlparser.NewTrackedBuffer(nil)
buf.Myprintf("delete %vfrom %s.%s%v%v%v", node.Comments, database, segment.Table, node.Where, node.OrderBy, node.Limit)
tuple := xcontext.QueryTuple{
Query: buf.String(),
Backend: segment.Backend,
Range: segment.Range.String(),
}
p.Querys = append(p.Querys, tuple)
}
return nil
}
// Type returns the type of the plan.
func (p *DeletePlan) Type() PlanType {
return p.typ
}
// JSON returns the plan info.
func (p *DeletePlan) JSON() string {
type explain struct {
RawQuery string `json:",omitempty"`
Partitions []xcontext.QueryTuple `json:",omitempty"`
}
// Partitions.
var parts []xcontext.QueryTuple
parts = append(parts, p.Querys...)
exp := &explain{
RawQuery: p.RawQuery,
Partitions: parts,
}
bout, err := json.MarshalIndent(exp, "", "\t")
if err != nil {
return err.Error()
}
return hack.String(bout)
}
// Children returns the children of the plan.
func (p *DeletePlan) Children() *PlanTree {
return nil
}
// Size returns the memory size.
func (p *DeletePlan) Size() int {
size := len(p.RawQuery)
for _, q := range p.Querys {
size += len(q.Query)
}
return size
}