github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/pingcap/tidb/ast/functions_test.go (about)

     1  package ast
     2  
     3  import (
     4  	. "github.com/insionng/yougam/libraries/pingcap/check"
     5  	"github.com/insionng/yougam/libraries/pingcap/tidb/model"
     6  	"github.com/insionng/yougam/libraries/pingcap/tidb/mysql"
     7  )
     8  
     9  var _ = Suite(&testFunctionsSuite{})
    10  
    11  type testFunctionsSuite struct {
    12  }
    13  
    14  func (ts *testFunctionsSuite) TestAggregateFuncExtractor(c *C) {
    15  	var expr Node
    16  
    17  	extractor := &AggregateFuncExtractor{}
    18  	expr = &AggregateFuncExpr{}
    19  	expr.Accept(extractor)
    20  	c.Assert(extractor.AggFuncs, HasLen, 1)
    21  	c.Assert(extractor.AggFuncs[0], Equals, expr)
    22  
    23  	extractor = &AggregateFuncExtractor{}
    24  	expr = &FuncCallExpr{
    25  		FnName: model.NewCIStr("DATE_ARITH"),
    26  	}
    27  	expr.Accept(extractor)
    28  	c.Assert(extractor.AggFuncs, HasLen, 0)
    29  
    30  	extractor = &AggregateFuncExtractor{}
    31  	r := &AggregateFuncExpr{}
    32  	expr = &BinaryOperationExpr{
    33  		L: &FuncCallExpr{
    34  			FnName: model.NewCIStr("DATE_ARITH"),
    35  		},
    36  		R: r,
    37  	}
    38  	expr.Accept(extractor)
    39  	c.Assert(extractor.AggFuncs, HasLen, 1)
    40  	c.Assert(extractor.AggFuncs[0], Equals, r)
    41  
    42  	// convert ColumnNameExpr to AggregateFuncExpr
    43  	extractor = &AggregateFuncExtractor{}
    44  	expr = &ColumnNameExpr{}
    45  	f := &SelectField{Expr: expr.(ExprNode)}
    46  	f.Accept(extractor)
    47  	c.Assert(extractor.AggFuncs, HasLen, 1)
    48  	e := extractor.AggFuncs[0]
    49  	c.Assert(e, NotNil)
    50  	c.Assert(e.F, Equals, AggFuncFirstRow)
    51  
    52  	// select exists(select count(c) from t) from t
    53  	// subquery contains aggregate function
    54  	expr1 := &AggregateFuncExpr{}
    55  	field1 := &SelectField{Expr: expr1}
    56  	fields1 := &FieldList{Fields: []*SelectField{field1}}
    57  	subSel := &SelectStmt{Fields: fields1}
    58  
    59  	subExpr := &ExistsSubqueryExpr{
    60  		Sel: &SubqueryExpr{Query: subSel},
    61  	}
    62  	field := &SelectField{Expr: subExpr}
    63  	fields := &FieldList{Fields: []*SelectField{field}}
    64  	sel := &SelectStmt{Fields: fields}
    65  
    66  	extractor = &AggregateFuncExtractor{}
    67  	sel.Accept(extractor)
    68  	c.Assert(extractor.AggFuncs, HasLen, 0)
    69  	extractor = &AggregateFuncExtractor{}
    70  	subSel.Accept(extractor)
    71  	c.Assert(extractor.AggFuncs, HasLen, 1)
    72  }
    73  
    74  func (ts *testFunctionsSuite) TestAggFuncCount(c *C) {
    75  	args := make([]ExprNode, 1)
    76  	// count with distinct
    77  	agg := &AggregateFuncExpr{
    78  		Args:     args,
    79  		F:        AggFuncCount,
    80  		Distinct: true,
    81  	}
    82  	agg.CurrentGroup = "xx"
    83  	expr := NewValueExpr(1)
    84  	expr1 := NewValueExpr(nil)
    85  	expr2 := NewValueExpr(1)
    86  	exprs := []ExprNode{expr, expr1, expr2}
    87  	for _, e := range exprs {
    88  		args[0] = e
    89  		agg.Update()
    90  	}
    91  	ctx := agg.GetContext()
    92  	c.Assert(ctx.Count, Equals, int64(1))
    93  	// count without distinct
    94  	agg = &AggregateFuncExpr{
    95  		Args: args,
    96  		F:    AggFuncCount,
    97  	}
    98  	agg.CurrentGroup = "xx"
    99  	expr = NewValueExpr(1)
   100  	expr1 = NewValueExpr(nil)
   101  	expr2 = NewValueExpr(1)
   102  	exprs = []ExprNode{expr, expr1, expr2}
   103  	for _, e := range exprs {
   104  		args[0] = e
   105  		agg.Update()
   106  	}
   107  	ctx = agg.GetContext()
   108  	c.Assert(ctx.Count, Equals, int64(2))
   109  }
   110  
   111  func (ts *testFunctionsSuite) TestAggFuncSum(c *C) {
   112  	args := make([]ExprNode, 1)
   113  	// sum with distinct
   114  	agg := &AggregateFuncExpr{
   115  		Args:     args,
   116  		F:        AggFuncSum,
   117  		Distinct: true,
   118  	}
   119  	agg.CurrentGroup = "xx"
   120  	expr := NewValueExpr(1)
   121  	expr1 := NewValueExpr(nil)
   122  	expr2 := NewValueExpr(1)
   123  	exprs := []ExprNode{expr, expr1, expr2}
   124  	for _, e := range exprs {
   125  		args[0] = e
   126  		agg.Update()
   127  	}
   128  	ctx := agg.GetContext()
   129  	expect, _ := mysql.ConvertToDecimal(1)
   130  	v, ok := ctx.Value.(mysql.Decimal)
   131  	c.Assert(ok, IsTrue)
   132  	c.Assert(v.Equals(expect), IsTrue)
   133  	// sum without distinct
   134  	agg = &AggregateFuncExpr{
   135  		Args: args,
   136  		F:    AggFuncSum,
   137  	}
   138  	agg.CurrentGroup = "xx"
   139  	expr = NewValueExpr(2)
   140  	expr1 = NewValueExpr(nil)
   141  	expr2 = NewValueExpr(2)
   142  	exprs = []ExprNode{expr, expr1, expr2}
   143  	for _, e := range exprs {
   144  		args[0] = e
   145  		agg.Update()
   146  	}
   147  	ctx = agg.GetContext()
   148  	expect, _ = mysql.ConvertToDecimal(4)
   149  	v, ok = ctx.Value.(mysql.Decimal)
   150  	c.Assert(ok, IsTrue)
   151  	c.Assert(v.Equals(expect), IsTrue)
   152  }