/
delete.go
105 lines (89 loc) · 2.75 KB
/
delete.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
package plan
import (
"fmt"
"github.com/fengleng/flight/log"
"github.com/fengleng/flight/server/my_errors"
"github.com/fengleng/flight/server/schema"
"github.com/fengleng/flight/sqlparser/sqlparser"
"github.com/pingcap/errors"
)
func buildDeletePlan(statement *sqlparser.Delete, schema *schema.Schema) (*Plan, error) {
plan := &Plan{}
var err error
var tableName string
stmt := statement
if len(stmt.TableExprs) == 1 {
tableNode, ok := stmt.TableExprs[0].(*sqlparser.AliasedTableExpr)
if ok {
tableNameNode, ok := tableNode.Expr.(sqlparser.TableName)
if ok {
tableName = sqlparser.String(tableNameNode.Name)
} else {
return nil, my_errors.ErrDeleteTableformat
}
} else {
return nil, my_errors.ErrDeleteTableformat
}
} else {
return nil, my_errors.ErrDeleteTableformat
}
plan.Rule = schema.Router.GetRule(tableName, schema.DefaultNode) //根据表名获得分表规则
if stmt.Where != nil {
plan.Criteria = stmt.Where.Expr
} else {
plan.Criteria = nil
}
if err = plan.calRouteIndexList(); err != nil {
log.Error("calRouteIndexList err:%v", err)
return nil, errors.Trace(err)
}
if err = plan.generateDeleteSql(stmt); err != nil {
return plan, err
}
return plan, err
}
func (plan *Plan) generateDeleteSql(stmt *sqlparser.Delete) error {
sqlList := make(map[string][]string)
node := stmt
if len(plan.RouteNodeIndexList) == 0 {
return my_errors.ErrNoRouteNode
}
if len(plan.RouteTableIndexList) == 0 {
buf := sqlparser.NewTrackedBuffer(nil)
stmt.Format(buf)
nodeName := plan.Rule.NodeList[0]
sqlList[nodeName] = []string{buf.String()}
} else {
tableCount := len(plan.RouteTableIndexList)
for i := 0; i < tableCount; i++ {
tableIndex := plan.RouteTableIndexList[i]
nodeIndex := plan.Rule.TableToNode[tableIndex]
nodeName := plan.Rule.NodeList[nodeIndex]
buf := sqlparser.NewTrackedBuffer(nil)
cloneBuf := sqlparser.NewTrackedBuffer(nil)
node.Format(cloneBuf)
node1, err := sqlparser.Parse(cloneBuf.String())
if err != nil {
return err
}
node2 := node1.(*sqlparser.Delete)
tableNode := node2.TableExprs[0].(*sqlparser.AliasedTableExpr)
tableNameNode := tableNode.Expr.(sqlparser.TableName)
node2.TableExprs[0] = &sqlparser.AliasedTableExpr{
Expr: &sqlparser.TableName{
Name: sqlparser.NewTableIdent(fmt.Sprintf("%s_%04d", sqlparser.String(tableNameNode.Name), tableIndex)),
Qualifier: sqlparser.NewTableIdent(sqlparser.String(tableNameNode.Qualifier)),
},
As: tableNode.As,
Hints: tableNode.Hints,
}
node2.Format(buf)
if _, ok := sqlList[nodeName]; ok == false {
sqlList[nodeName] = make([]string, 0, tableCount)
}
sqlList[nodeName] = append(sqlList[nodeName], buf.String())
}
}
plan.RewrittenSqlList = sqlList
return nil
}