database/tidb
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[parser] parser: implement Restore for BinaryOperation, WhenClause, CaseExpr and ParenthesesExpr (#81)

Browse Source
This commit is contained in:
haplone
2018-12-18 15:19:12 +08:00
committed by Ti Chi Robot
parent 2ebe4a6713
commit 6451bd93ea
2 changed files with 101 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
parser/ast/expressions.go
View File

@ -154,7 +154,17 @@ type BinaryOperationExpr struct {
// Restore implements Node interface.
func (n *BinaryOperationExpr) Restore(ctx *RestoreCtx) error {
return errors.New("Not implemented")
if err := n.L.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred when restore BinaryOperationExpr.L")
}
if err := n.Op.Restore(ctx.In); err != nil {
return errors.Annotate(err, "An error occurred when restore BinaryOperationExpr.Op")
}
if err := n.R.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred when restore BinaryOperationExpr.R")
}
return nil
}
// Format the ExprNode into a Writer.
@ -200,7 +210,15 @@ type WhenClause struct {
// Restore implements Node interface.
func (n *WhenClause) Restore(ctx *RestoreCtx) error {
return errors.New("Not implemented")
ctx.WriteKeyWord("WHEN ")
if err := n.Expr.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred while restore WhenClauses.Expr")
}
ctx.WriteKeyWord(" THEN ")
if err := n.Result.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred while restore WhenClauses.Result")
}
return nil
}
// Accept implements Node Accept interface.
@ -238,7 +256,28 @@ type CaseExpr struct {
// Restore implements Node interface.
func (n *CaseExpr) Restore(ctx *RestoreCtx) error {
return errors.New("Not implemented")
ctx.WriteKeyWord("CASE")
if n.Value != nil {
ctx.WritePlain(" ")
if err := n.Value.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred while restore CaseExpr.Value")
}
}
for _, clause := range n.WhenClauses {
ctx.WritePlain(" ")
if err := clause.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred while restore CaseExpr.WhenClauses")
}
}
if n.ElseClause != nil {
ctx.WriteKeyWord(" ELSE ")
if err := n.ElseClause.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred while restore CaseExpr.ElseClause")
}
}
ctx.WriteKeyWord(" END")
return nil
}
// Format the ExprNode into a Writer.
@ -777,7 +816,12 @@ type ParenthesesExpr struct {
// Restore implements Node interface.
func (n *ParenthesesExpr) Restore(ctx *RestoreCtx) error {
return errors.New("Not implemented")
ctx.WritePlain("(")
if err := n.Expr.Restore(ctx); err != nil {
return errors.Annotate(err, "An error occurred when restore ParenthesesExpr.Expr")
}
ctx.WritePlain(")")
return nil
}
// Format the ExprNode into a Writer.

53
parser/ast/expressions_test.go
View File

@ -155,3 +155,56 @@ func (tc *testExpressionsSuite) TestBetweenExprRestore(c *C) {
}
RunNodeRestoreTest(c, testCases, "select %s", extractNodeFunc)
}
func (tc *testExpressionsSuite) TestCaseExpr(c *C) {
testCases := []NodeRestoreTestCase{
{"case when 1 then 2 end", "CASE WHEN 1 THEN 2 END"},
{"case when 1 then 'a' when 2 then 'b' end", "CASE WHEN 1 THEN 'a' WHEN 2 THEN 'b' END"},
{"case when 1 then 'a' when 2 then 'b' else 'c' end", "CASE WHEN 1 THEN 'a' WHEN 2 THEN 'b' ELSE 'c' END"},
{"case when 'a'!=1 then true else false end", "CASE WHEN 'a'!=1 THEN TRUE ELSE FALSE END"},
{"case a when 'a' then true else false end", "CASE `a` WHEN 'a' THEN TRUE ELSE FALSE END"},
}
extractNodeFunc := func(node Node) Node {
return node.(*SelectStmt).Fields.Fields[0].Expr
}
RunNodeRestoreTest(c, testCases, "select %s", extractNodeFunc)
}
func (tc *testExpressionsSuite) TestBinaryOperationExpr(c *C) {
testCases := []NodeRestoreTestCase{
{"'a'!=1", "'a'!=1"},
{"a!=1", "`a`!=1"},
{"3<5", "3<5"},
{"10>5", "10>5"},
{"3+5", "3+5"},
{"3-5", "3-5"},
{"a<>5", "`a`!=5"},
}
extractNodeFunc := func(node Node) Node {
return node.(*SelectStmt).Fields.Fields[0].Expr
}
RunNodeRestoreTest(c, testCases, "select %s", extractNodeFunc)
}
func (tc *testExpressionsSuite) TestParenthesesExpr(c *C) {
testCases := []NodeRestoreTestCase{
{"(1+2)*3", "(1+2)*3"},
{"1+2*3", "1+2*3"},
}
extractNodeFunc := func(node Node) Node {
return node.(*SelectStmt).Fields.Fields[0].Expr
}
RunNodeRestoreTest(c, testCases, "select %s", extractNodeFunc)
}
func (tc *testExpressionsSuite) TestWhenClause(c *C) {
testCases := []NodeRestoreTestCase{
{"when 1 then 2", "WHEN 1 THEN 2"},
{"when 1 then 'a'", "WHEN 1 THEN 'a'"},
{"when 'a'!=1 then true", "WHEN 'a'!=1 THEN TRUE"},
}
extractNodeFunc := func(node Node) Node {
return node.(*SelectStmt).Fields.Fields[0].Expr.(*CaseExpr).WhenClauses[0]
}
RunNodeRestoreTest(c, testCases, "select case %s end", extractNodeFunc)
}