Skip to content

Commit

Permalink
planner/core: get back range columns pruning after last refactor (#15169
Browse files Browse the repository at this point in the history 
)
  • Loading branch information
@tiancaiamao
tiancaiamao authored Mar 18, 2020
1 parent 1ff32ac commit 4481006
Show file tree
Hide file tree
Showing 2 changed files with 304 additions and 47 deletions.
114 changes: 104 additions & 10 deletions planner/core/partition_pruning_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,13 +44,15 @@ func (s *testPartitionPruningSuite) TestCanBePrune(c *C) {
"create table t (d datetime not null)",
"to_days(d)",
)
lessThan := lessThanData{data: []int64{733108, 733132}, maxvalue: false}
lessThan := lessThanDataInt{data: []int64{733108, 733132}, maxvalue: false}
prunner := &rangePruner{lessThan, tc.col, tc.fn}

queryExpr := tc.expr("d < '2000-03-08 00:00:00'")
result := partitionRangeForCNFExpr(tc.sctx, queryExpr, lessThan, tc.col, tc.fn, fullRange(len(lessThan.data)))
result := partitionRangeForCNFExpr(tc.sctx, queryExpr, prunner, fullRange(len(lessThan.data)))
c.Assert(equalPartitionRangeOR(result, partitionRangeOR{{0, 1}}), IsTrue)

queryExpr = tc.expr("d > '2018-03-08 00:00:00'")
result = partitionRangeForCNFExpr(tc.sctx, queryExpr, lessThan, tc.col, tc.fn, fullRange(len(lessThan.data)))
result = partitionRangeForCNFExpr(tc.sctx, queryExpr, prunner, fullRange(len(lessThan.data)))
c.Assert(equalPartitionRangeOR(result, partitionRangeOR{}), IsTrue)

// For the following case:
Expand All @@ -68,13 +70,15 @@ func (s *testPartitionPruningSuite) TestCanBePrune(c *C) {
"create table t (report_updated timestamp)",
"unix_timestamp(report_updated)",
)
lessThan = lessThanData{data: []int64{1199145600, 1207008000, 1262304000, 0}, maxvalue: true}
lessThan = lessThanDataInt{data: []int64{1199145600, 1207008000, 1262304000, 0}, maxvalue: true}
prunner = &rangePruner{lessThan, tc.col, tc.fn}

queryExpr = tc.expr("report_updated > '2008-05-01 00:00:00'")
result = partitionRangeForCNFExpr(tc.sctx, queryExpr, lessThan, tc.col, tc.fn, fullRange(len(lessThan.data)))
result = partitionRangeForCNFExpr(tc.sctx, queryExpr, prunner, fullRange(len(lessThan.data)))
c.Assert(equalPartitionRangeOR(result, partitionRangeOR{{2, 4}}), IsTrue)

queryExpr = tc.expr("report_updated > unix_timestamp('2008-05-01 00:00:00')")
partitionRangeForCNFExpr(tc.sctx, queryExpr, lessThan, tc.col, tc.fn, fullRange(len(lessThan.data)))
partitionRangeForCNFExpr(tc.sctx, queryExpr, prunner, fullRange(len(lessThan.data)))
// TODO: Uncomment the check after fixing issue https://github.com/pingcap/tidb/issues/12028
// c.Assert(equalPartitionRangeOR(result, partitionRangeOR{{2, 4}}), IsTrue)
// report_updated > unix_timestamp('2008-05-01 00:00:00') is converted to gt(t.t.report_updated, <nil>)
Expand All @@ -83,7 +87,7 @@ func (s *testPartitionPruningSuite) TestCanBePrune(c *C) {
}

func (s *testPartitionPruningSuite) TestPruneUseBinarySearch(c *C) {
lessThan := lessThanData{data: []int64{4, 7, 11, 14, 17, 0}, maxvalue: true}
lessThan := lessThanDataInt{data: []int64{4, 7, 11, 14, 17, 0}, maxvalue: true}
cases := []struct {
input dataForPrune
result partitionRange
Expand Down Expand Up @@ -126,7 +130,7 @@ type testCtx struct {
schema *expression.Schema
columns []*expression.Column
names types.NameSlice
lessThan lessThanData
lessThan lessThanDataInt
col *expression.Column
fn *expression.ScalarFunction
}
Expand Down Expand Up @@ -165,7 +169,8 @@ func (s *testPartitionPruningSuite) TestPartitionRangeForExpr(c *C) {
"create table t (a int)",
"a",
)
lessThan := lessThanData{data: []int64{4, 7, 11, 14, 17, 0}, maxvalue: true}
lessThan := lessThanDataInt{data: []int64{4, 7, 11, 14, 17, 0}, maxvalue: true}
prunner := &rangePruner{lessThan, tc.columns[0], nil}
cases := []struct {
input string
result partitionRangeOR
Expand All @@ -188,7 +193,7 @@ func (s *testPartitionPruningSuite) TestPartitionRangeForExpr(c *C) {
expr, err := expression.ParseSimpleExprsWithNames(tc.sctx, ca.input, tc.schema, tc.names)
c.Assert(err, IsNil)
result := fullRange(lessThan.length())
result = partitionRangeForExpr(tc.sctx, expr[0], lessThan, tc.columns[0], nil, result)
result = partitionRangeForExpr(tc.sctx, expr[0], prunner, result)
c.Assert(equalPartitionRangeOR(ca.result, result), IsTrue, Commentf("unexpected:", ca.input))
}
}
Expand Down Expand Up @@ -266,3 +271,92 @@ func (s *testPartitionPruningSuite) TestPartitionRangeOperation(c *C) {
c.Assert(equalPartitionRangeOR(ca.result, result), IsTrue, Commentf("failed %d", i))
}
}

func (s *testPartitionPruningSuite) TestPartitionRangePrunner2VarChar(c *C) {
tc := prepareTestCtx(c,
"create table t (a varchar(32))",
"a",
)
lessThanDataInt := []string{"'c'", "'f'", "'h'", "'l'", "'t'"}
lessThan := make([]expression.Expression, len(lessThanDataInt)+1) // +1 for maxvalue
for i, str := range lessThanDataInt {
tmp, err := expression.ParseSimpleExprsWithNames(tc.sctx, str, tc.schema, tc.names)
c.Assert(err, IsNil)
lessThan[i] = tmp[0]
}

prunner := &rangeColumnPruner{lessThan, tc.columns[0], true}
cases := []struct {
input string
result partitionRangeOR
}{
{"a > 'g'", partitionRangeOR{{2, 6}}},
{"a < 'h'", partitionRangeOR{{0, 3}}},
{"a >= 'm'", partitionRangeOR{{4, 6}}},
{"a > 'm'", partitionRangeOR{{4, 6}}},
{"a < 'f'", partitionRangeOR{{0, 2}}},
{"a = 'c'", partitionRangeOR{{1, 2}}},
{"a > 't'", partitionRangeOR{{5, 6}}},
{"a > 'c' and a < 'q'", partitionRangeOR{{1, 5}}},
{"a < 'l' or a >= 'w'", partitionRangeOR{{0, 4}, {5, 6}}},
{"a is null", partitionRangeOR{{0, 1}}},
{"'mm' > a", partitionRangeOR{{0, 5}}},
{"'f' <= a", partitionRangeOR{{2, 6}}},
{"'f' >= a", partitionRangeOR{{0, 3}}},
}

for _, ca := range cases {
expr, err := expression.ParseSimpleExprsWithNames(tc.sctx, ca.input, tc.schema, tc.names)
c.Assert(err, IsNil)
result := fullRange(len(lessThan))
result = partitionRangeForExpr(tc.sctx, expr[0], prunner, result)
c.Assert(equalPartitionRangeOR(ca.result, result), IsTrue, Commentf("unexpected:", ca.input))
}
}

func (s *testPartitionPruningSuite) TestPartitionRangePrunner2Date(c *C) {
tc := prepareTestCtx(c,
"create table t (a date)",
"a",
)
lessThanDataInt := []string{
"'1999-06-01'",
"'2000-05-01'",
"'2008-04-01'",
"'2010-03-01'",
"'2016-02-01'",
"'2020-01-01'"}
lessThan := make([]expression.Expression, len(lessThanDataInt))
for i, str := range lessThanDataInt {
tmp, err := expression.ParseSimpleExprsWithNames(tc.sctx, str, tc.schema, tc.names)
c.Assert(err, IsNil)
lessThan[i] = tmp[0]
}

prunner := &rangeColumnPruner{lessThan, tc.columns[0], false}
cases := []struct {
input string
result partitionRangeOR
}{
{"a < '1943-02-12'", partitionRangeOR{{0, 1}}},
{"a >= '1969-02-13'", partitionRangeOR{{0, 6}}},
{"a > '2003-03-13'", partitionRangeOR{{2, 6}}},
{"a < '2006-02-03'", partitionRangeOR{{0, 3}}},
{"a = '2007-07-07'", partitionRangeOR{{2, 3}}},
{"a > '1949-10-10'", partitionRangeOR{{0, 6}}},
{"a > '2016-02-01' and a < '2000-01-03'", partitionRangeOR{}},
{"a < '1969-11-12' or a >= '2019-09-18'", partitionRangeOR{{0, 1}, {5, 6}}},
{"a is null", partitionRangeOR{{0, 1}}},
{"'2003-02-27' >= a", partitionRangeOR{{0, 3}}},
{"'2014-10-24' < a", partitionRangeOR{{4, 6}}},
{"'2003-03-30' > a", partitionRangeOR{{0, 3}}},
}

for _, ca := range cases {
expr, err := expression.ParseSimpleExprsWithNames(tc.sctx, ca.input, tc.schema, tc.names)
c.Assert(err, IsNil)
result := fullRange(len(lessThan))
result = partitionRangeForExpr(tc.sctx, expr[0], prunner, result)
c.Assert(equalPartitionRangeOR(ca.result, result), IsTrue, Commentf("unexpected:", ca.input))
}
}
Loading

0 comments on commit 4481006

Please sign in to comment.