radon/src/optimizer/simple_optimizer.go at v1.0.7 · radondb/radon · 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
/*
 * Radon
 *
 * Copyright 2018 The Radon Authors.
 * Code is licensed under the GPLv3.
 *
 */

package optimizer

import (
	"planner"
	"router"

	"github.com/pkg/errors"
	"github.com/xelabs/go-mysqlstack/sqlparser"
	"github.com/xelabs/go-mysqlstack/xlog"
)

var (
	_ Optimizer = &SimpleOptimizer{}
)

// SimpleOptimizer is a simple optimizer who dispatches the plans
type SimpleOptimizer struct {
	log      *xlog.Log
	database string
	query    string
	node     sqlparser.Statement
	router   *router.Router
}

// NewSimpleOptimizer creates the new simple optimizer.
func NewSimpleOptimizer(log *xlog.Log, database string, query string, node sqlparser.Statement, router *router.Router) *SimpleOptimizer {
	return &SimpleOptimizer{
		log:      log,
		database: database,
		query:    query,
		node:     node,
		router:   router,
	}
}

// BuildPlanTree used to build plan trees for the query.
func (so *SimpleOptimizer) BuildPlanTree() (*planner.PlanTree, error) {
	log := so.log
	database := so.database
	query := so.query
	node := so.node
	router := so.router

	plans := planner.NewPlanTree()
	switch node.(type) {
	case *sqlparser.DDL:
		node := planner.NewDDLPlan(log, database, query, node.(*sqlparser.DDL), router)
		plans.Add(node)
	case *sqlparser.Insert:
		node := planner.NewInsertPlan(log, database, query, node.(*sqlparser.Insert), router)
		plans.Add(node)
	case *sqlparser.Delete:
		node := planner.NewDeletePlan(log, database, query, node.(*sqlparser.Delete), router)
		plans.Add(node)
	case *sqlparser.Update:
		node := planner.NewUpdatePlan(log, database, query, node.(*sqlparser.Update), router)
		plans.Add(node)
	case *sqlparser.Select:
		nod := node.(*sqlparser.Select)
		selectNode := planner.NewSelectPlan(log, database, query, nod, router)
		plans.Add(selectNode)
	case *sqlparser.Union:
		node := planner.NewUnionPlan(log, database, query, node.(*sqlparser.Union), router)
		plans.Add(node)
	case *sqlparser.Checksum:
		node := planner.NewOthersPlan(log, database, query, node, router)
		plans.Add(node)
	default:
		return nil, errors.Errorf("optimizer.unsupported.query.type[%+v]", node)
	}

	// Build plantree.
	if err := plans.Build(); err != nil {
		return nil, err
	}
	return plans, nil
}