WL#3352, Introducing Column list partitioning, makes it possible to partition...

WL#3352, Introducing Column list partitioning, makes it possible to partition on most data types, makes it possible to prune on multi-field partitioning

BUILD/build_mccge.sh

@@ -556,7 +556,7 @@ parse_package()
       package="pro"
       ;;
     extended )
-      package=""
+      package="extended"
       ;;
     cge )
       package="cge"

mysql-test/r/partition_mgm_err.result

@@ -41,7 +41,7 @@ ERROR HY000: Reorganize of range partitions cannot change total ranges except fo
 ALTER TABLE t1 REORGANIZE PARTITION x0,x1 INTO
 (PARTITION x01 VALUES LESS THAN (4),
 PARTITION x11 VALUES LESS THAN (2));
-ERROR HY000: Reorganize of range partitions cannot change total ranges except for last partition where it can extend the range
+ERROR HY000: VALUES LESS THAN value must be strictly increasing for each partition
 ALTER TABLE t1 REORGANIZE PARTITION x0,x1 INTO
 (PARTITION x01 VALUES LESS THAN (6),
 PARTITION x11 VALUES LESS THAN (4));

mysql-test/r/partition_range.result

 drop table if exists t1, t2;
 create table t1 (a int)
 partition by range (a)
+( partition p0 values less than (NULL),
+partition p1 values less than (MAXVALUE));
+ERROR 42000: Not allowed to use NULL value in VALUES LESS THAN near '),
+partition p1 values less than (MAXVALUE))' at line 3
+create table t1 (a datetime not null)
+partition by range (TO_SECONDS(a))
+( partition p0 VALUES LESS THAN (TO_SECONDS('2007-03-08 00:00:00')),
+partition p1 VALUES LESS THAN (TO_SECONDS('2007-04-01 00:00:00')));
+INSERT INTO t1 VALUES ('2007-03-01 12:00:00'), ('2007-03-07 12:00:00');
+INSERT INTO t1 VALUES ('2007-03-08 12:00:00'), ('2007-03-15 12:00:00');
+explain partitions select * from t1 where a < '2007-03-08 00:00:00';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0	ALL	NULL	NULL	NULL	NULL	2	Using where
+explain partitions select * from t1 where a < '2007-03-08 00:00:01';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0,p1	ALL	NULL	NULL	NULL	NULL	4	Using where
+explain partitions select * from t1 where a <= '2007-03-08 00:00:00';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0,p1	ALL	NULL	NULL	NULL	NULL	4	Using where
+explain partitions select * from t1 where a <= '2007-03-07 23:59:59';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0	ALL	NULL	NULL	NULL	NULL	4	Using where
+explain partitions select * from t1 where a < '2007-03-07 23:59:59';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0	ALL	NULL	NULL	NULL	NULL	4	Using where
+drop table t1;
+create table t1 (a date)
+partition by range(to_seconds(a))
+(partition p0 values less than (to_seconds('2004-01-01')),
+partition p1 values less than (to_seconds('2005-01-01')));
+insert into t1 values ('2003-12-30'),('2004-12-31');
+select * from t1;
+a
+2003-12-30
+2004-12-31
+explain partitions select * from t1 where a <= '2003-12-31';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0	system	NULL	NULL	NULL	NULL	1	
+select * from t1 where a <= '2003-12-31';
+a
+2003-12-30
+explain partitions select * from t1 where a <= '2005-01-01';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0,p1	ALL	NULL	NULL	NULL	NULL	2	Using where
+select * from t1 where a <= '2005-01-01';
+a
+2003-12-30
+2004-12-31
+drop table t1;
+create table t1 (a datetime)
+partition by range(to_seconds(a))
+(partition p0 values less than (to_seconds('2004-01-01 12:00:00')),
+partition p1 values less than (to_seconds('2005-01-01 12:00:00')));
+insert into t1 values ('2004-01-01 11:59:29'),('2005-01-01 11:59:59');
+select * from t1;
+a
+2004-01-01 11:59:29
+2005-01-01 11:59:59
+explain partitions select * from t1 where a <= '2004-01-01 11:59.59';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0	system	NULL	NULL	NULL	NULL	1	
+select * from t1 where a <= '2004-01-01 11:59:59';
+a
+2004-01-01 11:59:29
+explain partitions select * from t1 where a <= '2005-01-01';
+id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	p0,p1	ALL	NULL	NULL	NULL	NULL	2	Using where
+select * from t1 where a <= '2005-01-01';
+a
+2004-01-01 11:59:29
+drop table t1;
+create table t1 (a int, b char(20))
+partition by range column_list(a,b)
+(partition p0 values less than (1));
+ERROR 42000: Inconsistency in usage of column lists for partitioning near '))' at line 3
+create table t1 (a int, b char(20))
+partition by range(a)
+(partition p0 values less than (column_list(1,"b")));
+ERROR HY000: Inconsistency in usage of column lists for partitioning
+create table t1 (a int, b char(20))
+partition by range(a)
+(partition p0 values less than (column_list(1,"b")));
+ERROR HY000: Inconsistency in usage of column lists for partitioning
+create table t1 (a int, b char(20));
+create global index inx on t1 (a,b)
+partition by range (a)
+(partition p0 values less than (1));
+drop table t1;
+create table t1 (a int, b char(20))
+partition by range column_list(b)
+(partition p0 values less than (column_list("b")));
+drop table t1;
+create table t1 (a int)
+partition by range (a)
 ( partition p0 values less than (maxvalue));
 alter table t1 add partition (partition p1 values less than (100000));
 ERROR HY000: MAXVALUE can only be used in last partition definition

mysql-test/suite/parts/inc/partition_key_32col.inc

---error ER_TOO_MANY_KEY_PARTS
+--error ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR
 eval create table t1 (a date not null, b varchar(50) not null, c varchar(50) not null, d enum('m', 'w') not null, e int not null, f decimal (18,2) not null, g bigint not null, h tinyint not null, a1 date not null, b1 varchar(50) not null, c1 varchar(50) not null, d1 enum('m', 'w') not null, e1 int not null, f1 decimal (18,2) not null, g1 bigint not null, h1 tinyint not null, a2 date not null, b2 varchar(50) not null, c2 varchar(50) not null, d2 enum('m', 'w') not null, e2 int not null, f2 decimal (18,2) not null, g2 bigint not null, h2 tinyint not null, a3 date not null, b3 varchar(50) not null, c3 varchar(50) not null, d3 enum('m', 'w') not null, e3 int not null, f3 decimal (18,2) not null, g3 bigint not null, h3 tinyint not null, i char(255), primary key(a,b,c,d,e,f,g,h,a1,b1,c1,d1,e1,f1,g1,h1,a2,b2,c2,d2,e2,f2,g2,h2,a3,b3,c3,d3,e3,f3,g3,h3)) engine=$engine 
 partition by key(a,b,c,d,e,f,g,h,a1,b1,c1,d1,e1,f1,g1,h1,a2,b2,c2,d2,e2,f2,g2,h2,a3,b3,c3,d3,e3,f3,g3,h3) (
 partition pa1 max_rows=20 min_rows=2,

mysql-test/t/partition_column.test

+#
+# Tests for the new column list partitioning introduced in second
+# version for partitioning.
+#
+--source include/have_partition.inc
+
+--disable_warnings
+drop table if exists t1;
+--enable_warnings
+
+create table t1 (a int, b char(10), c varchar(25), d datetime)
+partition by range column_list(a,b,c,d)
+subpartition by hash (to_seconds(d))
+subpartitions 4
+( partition p0 values less than (column_list(1, NULL, MAXVALUE, NULL)),
+  partition p1 values less than (column_list(1, 'a', MAXVALUE, TO_DAYS('1999-01-01'))),
+  partition p2 values less than (column_list(1, 'a', MAXVALUE, MAXVALUE)),
+  partition p3 values less than (column_list(1, MAXVALUE, MAXVALUE, MAXVALUE)));
+drop table t1;
+
+create table t1 (a int, b char(10), c varchar(5), d int)
+partition by range column_list(a,b,c)
+subpartition by key (c,d)
+subpartitions 3
+( partition p0 values less than (column_list(1,'abc','abc')),
+  partition p1 values less than (column_list(2,'abc','abc')),
+  partition p2 values less than (column_list(3,'abc','abc')),
+  partition p3 values less than (column_list(4,'abc','abc')));
+
+insert into t1 values (1,'a','b',1),(2,'a','b',2),(3,'a','b',3);
+insert into t1 values (1,'b','c',1),(2,'b','c',2),(3,'b','c',3);
+insert into t1 values (1,'c','d',1),(2,'c','d',2),(3,'c','d',3);
+insert into t1 values (1,'d','e',1),(2,'d','e',2),(3,'d','e',3);
+select * from t1 where (a = 1 AND b < 'd' AND (c = 'b' OR (c = 'c' AND d = 1)) OR
+                       (a = 1 AND b >= 'a' AND (c = 'c' OR (c = 'd' AND d = 2))));
+drop table t1;
+
+create table t1 (a int, b varchar(2), c int)
+partition by range column_list (a, b, c)
+(partition p0 values less than (column_list(1, 'A', 1)),
+ partition p1 values less than (column_list(1, 'B', 1)));
+insert into t1 values (1, 'A', 1);
+explain partitions select * from t1 where a = 1 AND b <= 'A' and c = 1;
+select * from t1 where a = 1 AND b <= 'A' and c = 1;
+drop table t1;
+
+create table t1 (a char, b char, c char)
+partition by list column_list(a)
+( partition p0 values in (column_list('a')));
+insert into t1 (a) values ('a');
+select * from t1 where a = 'a';
+drop table t1;
+
+--error ER_WRONG_TYPE_COLUMN_VALUE_ERROR
+create table t1 (d timestamp)
+partition by range column_list(d)
+( partition p0 values less than (column_list('2000-01-01')),
+  partition p1 values less than (column_list('2040-01-01')));
+
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p0 values less than (column_list(null, 10)));
+drop table t1;
+
+create table t1 (d date)
+partition by range column_list(d)
+( partition p0 values less than (column_list('2000-01-01')),
+  partition p1 values less than (column_list('2009-01-01')));
+drop table t1;
+
+create table t1 (d date)
+partition by range column_list(d)
+( partition p0 values less than (column_list('1999-01-01')),
+  partition p1 values less than (column_list('2000-01-01')));
+drop table t1;
+
+create table t1 (d date)
+partition by range column_list(d)
+( partition p0 values less than (column_list('2000-01-01')),
+  partition p1 values less than (column_list('3000-01-01')));
+drop table t1;
+
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p2 values less than (column_list(99,99)),
+ partition p1 values less than (column_list(99,999)));
+
+insert into t1 values (99,998);
+select * from t1 where b = 998;
+drop table t1;
+
+create table t1 as select to_seconds(null) as to_seconds;
+select data_type from information_schema.columns
+where column_name='to_seconds';
+drop table t1;
+
+--error ER_PARSE_ERROR
+create table t1 (a int, b int)
+partition by list column_list(a,b)
+(partition p0 values in (column_list(maxvalue,maxvalue)));
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p0 values less than (column_list(maxvalue,maxvalue)));
+drop table t1;
+
+create table t1 (a int)
+partition by list column_list(a)
+(partition p0 values in (column_list(0)));
+select partition_method from information_schema.partitions where table_name='t1';
+drop table t1;
+
+create table t1 (a char(6))
+partition by range column_list(a)
+(partition p0 values less than (column_list('H23456')),
+ partition p1 values less than (column_list('M23456')));
+insert into t1 values ('F23456');
+select * from t1;
+drop table t1;
+
+-- error 1054
+create table t1 (a char(6))
+partition by range column_list(a)
+(partition p0 values less than (column_list(H23456)),
+ partition p1 values less than (column_list(M23456)));
+
+-- error ER_RANGE_NOT_INCREASING_ERROR
+create table t1 (a char(6))
+partition by range column_list(a)
+(partition p0 values less than (column_list(23456)),
+ partition p1 values less than (column_list(23456)));
+
+-- error 1064
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p0 values less than (10));
+
+-- error ER_PARTITION_COLUMN_LIST_ERROR
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p0 values less than (column_list(1,1,1));
+
+create table t1 (a int, b int)
+partition by range column_list(a,b)
+(partition p0 values less than (column_list(1, NULL)),
+ partition p1 values less than (column_list(2, maxvalue)),
+ partition p2 values less than (column_list(3, 3)),
+ partition p3 values less than (column_list(10, NULL)));
+
+-- error ER_NO_PARTITION_FOR_GIVEN_VALUE
+insert into t1 values (10,0);
+insert into t1 values (0,1),(1,1),(2,1),(3,1),(3,4),(4,9),(9,1);
+select * from t1;
+
+alter table t1
+partition by range column_list(b,a)
+(partition p0 values less than (column_list(1,2)),
+ partition p1 values less than (column_list(3,3)),
+ partition p2 values less than (column_list(9,5)));
+explain partitions select * from t1 where b < 2;
+select * from t1 where b < 2;
+explain partitions select * from t1 where b < 4;
+select * from t1 where b < 4;
+
+alter table t1 reorganize partition p1 into
+(partition p11 values less than (column_list(2,2)),
+ partition p12 values less than (column_list(3,3)));
+
+-- error ER_REORG_OUTSIDE_RANGE
+alter table t1 reorganize partition p0 into
+(partition p01 values less than (column_list(0,3)),
+ partition p02 values less than (column_list(1,1)));
+
+-- error ER_PARTITION_COLUMN_LIST_ERROR
+alter table t1 reorganize partition p2 into
+(partition p2 values less than(column_list(9,6,1)));
+
+-- error ER_PARTITION_COLUMN_LIST_ERROR
+alter table t1 reorganize partition p2 into
+(partition p2 values less than (10));
+
+alter table t1 reorganize partition p2 into
+(partition p21 values less than (column_list(4,7)),
+ partition p22 values less than (column_list(9,5)));
+explain partitions select * from t1 where b < 4;
+select * from t1 where b < 4;
+drop table t1;
+
+#create table t1 (a int, b int)
+#partition by range column_list(a,b)
+#(partition p0 values less than (column_list(99,99)),
+# partition p1 values less than (column_list(99,maxvalue)));
+#drop table t1;
+
+create table t1 (a int, b int)
+partition by list column_list(a,b)
+subpartition by hash (b)
+subpartitions 2
+(partition p0 values in (column_list(0,0), column_list(1,1)),
+ partition p1 values in (column_list(1000,1000)));
+insert into t1 values (1000,1000);
+#select * from t1 where a = 0 and b = 0;
+drop table t1;
+
+create table t1 (a char, b char, c char)
+partition by range column_list(a,b,c)
+( partition p0 values less than (column_list('a','b','c')));
+alter table t1 add partition
+(partition p1 values less than (column_list('b','c','d')));
+drop table t1;

mysql-test/t/partition_column_prune.test

+#
+# Partition pruning tests for new COLUMN LIST feature
+#
+-- source include/have_partition.inc
+
+--disable_warnings
+drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
+--enable_warnings
+
+create table t1 (a char, b char, c char)
+partition by range column_list(a,b,c)
+( partition p0 values less than (column_list('a','b','c')));
+insert into t1 values ('a', NULL, 'd');
+explain partitions select * from t1 where a = 'a' AND c = 'd';
+select * from t1 where a = 'a' AND c = 'd';
+drop table t1;
+
+## COLUMN_LIST partition pruning tests
+create table t1 (a int not null) partition by range column_list(a) (
+  partition p0 values less than (column_list(10)),
+  partition p1 values less than (column_list(20)),
+  partition p2 values less than (column_list(30)),
+  partition p3 values less than (column_list(40)),
+  partition p4 values less than (column_list(50)),
+  partition p5 values less than (column_list(60)),
+  partition p6 values less than (column_list(70))
+);
+insert into t1 values (5),(15),(25),(35),(45),(55),(65);
+insert into t1 values (5),(15),(25),(35),(45),(55),(65);
+
+create table t2 (a int not null) partition by range(a) (
+  partition p0 values less than (10),
+  partition p1 values less than (20),
+  partition p2 values less than (30),
+  partition p3 values less than (40),
+  partition p4 values less than (50),
+  partition p5 values less than (60),
+  partition p6 values less than (70)
+);
+insert into t2 values (5),(15),(25),(35),(45),(55),(65);
+insert into t2 values (5),(15),(25),(35),(45),(55),(65);
+
+explain partitions select * from t1 where a > 35 and a < 45;
+explain partitions select * from t2 where a > 35 and a < 45;
+
+drop table t1, t2;
+
+create table t1 (a int not null, b int not null ) 
+partition by range column_list(a,b) (
+  partition p01 values less than (column_list(2,10)),
+  partition p02 values less than (column_list(2,20)),
+  partition p03 values less than (column_list(2,30)),
+
+  partition p11 values less than (column_list(4,10)),
+  partition p12 values less than (column_list(4,20)),
+  partition p13 values less than (column_list(4,30)),
+
+  partition p21 values less than (column_list(6,10)),
+  partition p22 values less than (column_list(6,20)),
+  partition p23 values less than (column_list(6,30))
+);
+
+insert into t1 values (2,5), (2,15), (2,25),
+  (4,5), (4,15), (4,25), (6,5), (6,15), (6,25);
+insert into t1 select * from t1;
+
+explain partitions select * from t1 where a=2;
+explain partitions select * from t1 where a=4;
+explain partitions select * from t1 where a=2 and b < 22;
+
+drop table t1;

mysql-test/t/partition_error.test

@@ -180,7 +180,7 @@ partitions 3
 (partition x1, partition x2);
 
 #
-# Partition by key specified 3 partitions but only defined 2 => error
+# Partition by hash, random function
 #
 --error 1064
 CREATE TABLE t1 (
@@ -193,7 +193,7 @@ partitions 2
 (partition x1, partition x2);
 
 #
-# Partition by key specified 3 partitions but only defined 2 => error
+# Partition by range, random function
 #
 --error 1064
 CREATE TABLE t1 (
@@ -206,7 +206,7 @@ partitions 2
 (partition x1 values less than (0), partition x2 values less than (2));
 
 #
-# Partition by key specified 3 partitions but only defined 2 => error
+# Partition by list, random function
 #
 --error 1064
 CREATE TABLE t1 (

mysql-test/t/partition_mgm_err.test

@@ -61,7 +61,7 @@ ALTER TABLE t1 REORGANIZE PARTITION x0, x1, x1 INTO
 ALTER TABLE t1 REORGANIZE PARTITION x0,x1 INTO
 (PARTITION x01 VALUES LESS THAN (5));
 
---error ER_REORG_OUTSIDE_RANGE
+--error ER_RANGE_NOT_INCREASING_ERROR
 ALTER TABLE t1 REORGANIZE PARTITION x0,x1 INTO
 (PARTITION x01 VALUES LESS THAN (4),
  PARTITION x11 VALUES LESS THAN (2));

mysql-test/t/partition_range.test

@@ -9,6 +9,82 @@
 drop table if exists t1, t2;
 --enable_warnings
 
+--error ER_PARSE_ERROR
+create table t1 (a int)
+partition by range (a)
+( partition p0 values less than (NULL),
+  partition p1 values less than (MAXVALUE));
+#
+# Merge fix of bug#27927 for TO_SECONDS function
+#
+create table t1 (a datetime not null)
+partition by range (TO_SECONDS(a))
+( partition p0 VALUES LESS THAN (TO_SECONDS('2007-03-08 00:00:00')),
+  partition p1 VALUES LESS THAN (TO_SECONDS('2007-04-01 00:00:00')));
+INSERT INTO t1 VALUES ('2007-03-01 12:00:00'), ('2007-03-07 12:00:00');
+INSERT INTO t1 VALUES ('2007-03-08 12:00:00'), ('2007-03-15 12:00:00');
+explain partitions select * from t1 where a < '2007-03-08 00:00:00';
+explain partitions select * from t1 where a < '2007-03-08 00:00:01';
+explain partitions select * from t1 where a <= '2007-03-08 00:00:00';
+explain partitions select * from t1 where a <= '2007-03-07 23:59:59';
+explain partitions select * from t1 where a < '2007-03-07 23:59:59';
+drop table t1;
+#
+# New test cases for new function to_seconds
+#
+create table t1 (a date)
+partition by range(to_seconds(a))
+(partition p0 values less than (to_seconds('2004-01-01')),
+ partition p1 values less than (to_seconds('2005-01-01')));
+insert into t1 values ('2003-12-30'),('2004-12-31');
+select * from t1;
+explain partitions select * from t1 where a <= '2003-12-31';
+select * from t1 where a <= '2003-12-31';
+explain partitions select * from t1 where a <= '2005-01-01';
+select * from t1 where a <= '2005-01-01';
+drop table t1;
+
+create table t1 (a datetime)
+partition by range(to_seconds(a))
+(partition p0 values less than (to_seconds('2004-01-01 12:00:00')),
+ partition p1 values less than (to_seconds('2005-01-01 12:00:00')));
+insert into t1 values ('2004-01-01 11:59:29'),('2005-01-01 11:59:59');
+select * from t1;
+explain partitions select * from t1 where a <= '2004-01-01 11:59.59';
+select * from t1 where a <= '2004-01-01 11:59:59';
+explain partitions select * from t1 where a <= '2005-01-01';
+select * from t1 where a <= '2005-01-01';
+drop table t1;
+
+#
+# Adding new test cases for column list variant for partitioning
+#
+--error 1064
+create table t1 (a int, b char(20))
+partition by range column_list(a,b)
+(partition p0 values less than (1));
+
+--error ER_PARTITION_COLUMN_LIST_ERROR
+create table t1 (a int, b char(20))
+partition by range(a)
+(partition p0 values less than (column_list(1,"b")));
+
+--error ER_PARTITION_COLUMN_LIST_ERROR
+create table t1 (a int, b char(20))
+partition by range(a)
+(partition p0 values less than (column_list(1,"b")));
+
+create table t1 (a int, b char(20));
+create global index inx on t1 (a,b)
+partition by range (a)
+(partition p0 values less than (1));
+drop table t1;
+
+create table t1 (a int, b char(20))
+partition by range column_list(b)
+(partition p0 values less than (column_list("b")));
+drop table t1;
+
 #
 # BUG 33429: Succeeds in  adding partition when maxvalue on last partition
 #

mysql-test/t/type_decimal.test

@@ -8,13 +8,13 @@ SET SQL_WARNINGS=1;
 CREATE TABLE t1 (
    id int(11) NOT NULL auto_increment,
    datatype_id int(11) DEFAULT '0' NOT NULL,
-   minvalue decimal(20,10) DEFAULT '0.0000000000' NOT NULL,
-   maxvalue decimal(20,10) DEFAULT '0.0000000000' NOT NULL,
+   min_value decimal(20,10) DEFAULT '0.0000000000' NOT NULL,
+   max_value decimal(20,10) DEFAULT '0.0000000000' NOT NULL,
    valuename varchar(20),
    forecolor int(11),
    backcolor int(11),
    PRIMARY KEY (id),
-   UNIQUE datatype_id (datatype_id, minvalue, maxvalue)
+   UNIQUE datatype_id (datatype_id, min_value, max_value)
 );
 INSERT INTO t1 VALUES ( '1', '4', '0.0000000000', '0.0000000000', 'Ei saja', '0', '16776960');
 INSERT INTO t1 VALUES ( '2', '4', '1.0000000000', '1.0000000000', 'Sajab', '16777215', '255');
@@ -148,8 +148,8 @@ INSERT INTO t1 VALUES ( '139', '21', '326.0000000000', '326.0000000000', 'Lumine
 INSERT INTO t1 VALUES ( '143', '16', '-4.9000000000', '-0.1000000000', '', NULL, '15774720');
 INSERT INTO t1 VALUES ( '145', '15', '0.0000000000', '1.9000000000', '', '0', '16769024');
 INSERT INTO t1 VALUES ( '146', '16', '0.0000000000', '1.9000000000', '', '0', '16769024');
-select * from t1 where minvalue<=1 and maxvalue>=-1 and datatype_id=16;
-select * from t1 where minvalue<=-1 and maxvalue>=-1 and datatype_id=16;
+select * from t1 where min_value<=1 and max_value>=-1 and datatype_id=16;
+select * from t1 where min_value<=-1 and max_value>=-1 and datatype_id=16;
 drop table t1;
 
 #

sql/ha_partition.h

@@ -19,7 +19,8 @@
 
 enum partition_keywords
 { 
-  PKW_HASH= 0, PKW_RANGE, PKW_LIST, PKW_KEY, PKW_MAXVALUE, PKW_LINEAR
+  PKW_HASH= 0, PKW_RANGE, PKW_LIST, PKW_KEY, PKW_MAXVALUE, PKW_LINEAR,
+  PKW_COLUMNS
 };
 
 /*

sql/item_create.cc

@@ -2052,6 +2052,18 @@ class Create_func_to_days : public Create_func_arg1
   virtual ~Create_func_to_days() {}
 };
 
+class Create_func_to_seconds : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_to_seconds s_singleton;
+
+protected:
+  Create_func_to_seconds() {}
+  virtual ~Create_func_to_seconds() {}
+};
+
 
 #ifdef HAVE_SPATIAL
 class Create_func_touches : public Create_func_arg2
@@ -4480,6 +4492,15 @@ Create_func_to_days::create(THD *thd, Item *arg1)
 }
 
 
+Create_func_to_seconds Create_func_to_seconds::s_singleton;
+
+Item*
+Create_func_to_seconds::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_to_seconds(arg1);
+}
+
+
 #ifdef HAVE_SPATIAL
 Create_func_touches Create_func_touches::s_singleton;
 
@@ -4917,6 +4938,7 @@ static Native_func_registry func_array[] =
   { { C_STRING_WITH_LEN("TIME_TO_SEC") }, BUILDER(Create_func_time_to_sec)},
   { { C_STRING_WITH_LEN("TOUCHES") }, GEOM_BUILDER(Create_func_touches)},
   { { C_STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)},
+  { { C_STRING_WITH_LEN("TO_SECONDS") }, BUILDER(Create_func_to_seconds)},
   { { C_STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)},
   { { C_STRING_WITH_LEN("UNCOMPRESS") }, BUILDER(Create_func_uncompress)},
   { { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH") }, BUILDER(Create_func_uncompressed_length)},

sql/item_timefunc.cc

@@ -941,6 +941,27 @@ longlong Item_func_to_days::val_int()
 }
 
 
+longlong Item_func_to_seconds::val_int_endpoint(bool left_endp,
+                                                bool *incl_endp)
+{
+  longlong res= val_int();
+  return null_value ? LONGLONG_MIN : res;
+}
+
+longlong Item_func_to_seconds::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  MYSQL_TIME ltime;
+  longlong seconds;
+  longlong days;
+  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
+    return 0;
+  seconds=ltime.hour*3600L+ltime.minute*60+ltime.second;
+  seconds=ltime.neg ? -seconds : seconds;
+  days= (longlong) calc_daynr(ltime.year,ltime.month,ltime.day);
+  return (seconds + days * (24L * 3600L));
+}
+
 /*
   Get information about this Item tree monotonicity
 
@@ -967,6 +988,18 @@ enum_monotonicity_info Item_func_to_days::get_monotonicity_info() const
   return NON_MONOTONIC;
 }
 
+enum_monotonicity_info Item_func_to_seconds::get_monotonicity_info() const
+{
+  if (args[0]->type() == Item::FIELD_ITEM)
+  {
+    if (args[0]->field_type() == MYSQL_TYPE_DATE)
+      return MONOTONIC_STRICT_INCREASING;
+    if (args[0]->field_type() == MYSQL_TYPE_DATETIME)
+      return MONOTONIC_INCREASING;
+  }
+  return NON_MONOTONIC;
+}
+
 
 longlong Item_func_to_days::val_int_endpoint(bool left_endp, bool *incl_endp)
 {

sql/item_timefunc.h

@@ -73,6 +73,24 @@ class Item_func_to_days :public Item_int_func
 };
 
 
+class Item_func_to_seconds :public Item_int_func
+{
+public:
+  Item_func_to_seconds(Item *a) :Item_int_func(a) {}
+  longlong val_int();
+  const char *func_name() const { return "to_seconds"; }
+  void fix_length_and_dec() 
+  { 
+    decimals=0; 
+    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
+    maybe_null=1; 
+  }
+  enum_monotonicity_info get_monotonicity_info() const;
+  longlong val_int_endpoint(bool left_endp, bool *incl_endp);
+  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
+};
+
+
 class Item_func_dayofmonth :public Item_int_func
 {
 public:

sql/lex.h

@@ -113,6 +113,7 @@ static SYMBOL symbols[] = {
   { "COLLATION",	SYM(COLLATION_SYM)},
   { "COLUMN",		SYM(COLUMN_SYM)},
   { "COLUMNS",		SYM(COLUMNS)},
+  { "COLUMN_LIST",	SYM(COLUMN_LIST_SYM)},
   { "COMMENT",		SYM(COMMENT_SYM)},
   { "COMMIT",		SYM(COMMIT_SYM)},
   { "COMMITTED",	SYM(COMMITTED_SYM)},

sql/partition_element.h

-/* Copyright (C) 2006 MySQL AB
+/* Copyright (C) 2006-2009 MySQL AB
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -35,6 +35,35 @@ enum partition_state {
   PART_IS_ADDED= 8
 };
 
+/*
+  This struct is used to keep track of column expressions as part
+  of the COLUMNS concept in conjunction with RANGE and LIST partitioning.
+  The value can be either of MINVALUE, MAXVALUE and an expression that
+  must be constant and evaluate to the same type as the column it
+  represents.
+
+  The data in this fixed in two steps. The parser will only fill in whether
+  it is a max_value or provide an expression. Filling in
+  column_value, part_info, partition_id, null_value is done by the
+  function fix_column_value_function. However the item tree needs
+  fixed also before writing it into the frm file (in add_column_list_values).
+  To distinguish between those two variants, fixed= 1 after the
+  fixing in add_column_list_values and fixed= 2 otherwise. This is
+  since the fixing in add_column_list_values isn't a complete fixing.
+*/
+
+typedef struct p_column_list_val
+{
+  void* column_value;
+  Item* item_expression;
+  partition_info *part_info;
+  uint partition_id;
+  bool max_value;
+  bool null_value;
+  char fixed;
+} part_column_list_val;
+
+
 /*
   This struct is used to contain the value of an element
   in the VALUES IN struct. It needs to keep knowledge of
@@ -47,6 +76,7 @@ typedef struct p_elem_val
   longlong value;
   bool null_value;
   bool unsigned_flag;
+  part_column_list_val *col_val_array;
 } part_elem_value;
 
 struct st_ddl_log_memory_entry;
@@ -68,8 +98,9 @@ class partition_element :public Sql_alloc {
   enum partition_state part_state;
   uint16 nodegroup_id;
   bool has_null_value;
-  bool signed_flag;/* Indicate whether this partition uses signed constants */
-  bool max_value;  /* Indicate whether this partition uses MAXVALUE */
+  /* signed_flag and max_value only relevant for subpartitions */
+  bool signed_flag;
+  bool max_value;
 
   partition_element()
   : part_max_rows(0), part_min_rows(0), range_value(0),

sql/partition_info.h

@@ -19,6 +19,8 @@
 
 #include "partition_element.h"
 
+#define MAX_STR_SIZE_PF 512
+
 class partition_info;
 
 /* Some function typedefs */
@@ -64,10 +66,9 @@ class partition_info : public Sql_alloc
   /*
     When we have various string fields we might need some preparation
     before and clean-up after calling the get_part_id_func's. We need
-    one such method for get_partition_id and one for
-    get_part_partition_id and one for get_subpartition_id.
+    one such method for get_part_partition_id and one for
+    get_subpartition_id.
   */
-  get_part_id_func get_partition_id_charset;
   get_part_id_func get_part_partition_id_charset;
   get_subpart_id_func get_subpartition_id_charset;
 
@@ -81,7 +82,6 @@ class partition_info : public Sql_alloc
     without duplicates, NULL-terminated.
   */
   Field **full_part_field_array;
-  Field **full_part_charset_field_array;
   /*
     Set of all fields used in partition and subpartition expression.
     Required for testing of partition fields in write_set when
@@ -97,10 +97,8 @@ class partition_info : public Sql_alloc
   */
   uchar **part_field_buffers;
   uchar **subpart_field_buffers;
-  uchar **full_part_field_buffers;
   uchar **restore_part_field_ptrs;
   uchar **restore_subpart_field_ptrs;
-  uchar **restore_full_part_field_ptrs;
 
   Item *part_expr;
   Item *subpart_expr;
@@ -124,6 +122,8 @@ class partition_info : public Sql_alloc
   union {
     longlong *range_int_array;
     LIST_PART_ENTRY *list_array;
+    part_column_list_val *range_col_array;
+    part_column_list_val *list_col_array;
   };
   
   /********************************************
@@ -154,6 +154,10 @@ class partition_info : public Sql_alloc
 
   partition_element *curr_part_elem;
   partition_element *current_partition;
+  part_elem_value *curr_list_val;
+  uint curr_list_object;
+  uint num_columns;
+
   /*
     These key_map's are used for Partitioning to enable quick decisions
     on whether we can derive more information about which partition to
@@ -205,7 +209,7 @@ class partition_info : public Sql_alloc
   bool is_auto_partitioned;
   bool from_openfrm;
   bool has_null_value;
-
+  bool column_list;
 
   partition_info()
   : get_partition_id(NULL), get_part_partition_id(NULL),
@@ -214,11 +218,8 @@ class partition_info : public Sql_alloc
     part_charset_field_array(NULL),
     subpart_charset_field_array(NULL),
     full_part_field_array(NULL),
-    full_part_charset_field_array(NULL),
     part_field_buffers(NULL), subpart_field_buffers(NULL),
-    full_part_field_buffers(NULL),
     restore_part_field_ptrs(NULL), restore_subpart_field_ptrs(NULL),
-    restore_full_part_field_ptrs(NULL),
     part_expr(NULL), subpart_expr(NULL), item_free_list(NULL),
     first_log_entry(NULL), exec_log_entry(NULL), frm_log_entry(NULL),
     list_array(NULL), err_value(0),
@@ -226,6 +227,7 @@ class partition_info : public Sql_alloc
     part_func_string(NULL), subpart_func_string(NULL),
     part_state(NULL),
     curr_part_elem(NULL), current_partition(NULL),
+    curr_list_object(0), num_columns(0),
     default_engine_type(NULL),
     part_result_type(INT_RESULT),
     part_type(NOT_A_PARTITION), subpart_type(NOT_A_PARTITION),
@@ -241,7 +243,7 @@ class partition_info : public Sql_alloc
     list_of_part_fields(FALSE), list_of_subpart_fields(FALSE),
     linear_hash_ind(FALSE), fixed(FALSE),
     is_auto_partitioned(FALSE), from_openfrm(FALSE),
-    has_null_value(FALSE)
+    has_null_value(FALSE), column_list(FALSE)
   {
     all_fields_in_PF.clear_all();
     all_fields_in_PPF.clear_all();
@@ -271,16 +273,19 @@ class partition_info : public Sql_alloc
                                         uint start_no);
   char *has_unique_names();
   bool check_engine_mix(handlerton *engine_type, bool default_engine);
-  bool check_range_constants();
-  bool check_list_constants();
+  bool check_range_constants(THD *thd);
+  bool check_list_constants(THD *thd);
   bool check_partition_info(THD *thd, handlerton **eng_type,
                             handler *file, HA_CREATE_INFO *info,
                             bool check_partition_function);
   void print_no_partition_found(TABLE *table);
+  part_column_list_val *add_column_value();
+  bool set_part_expr(char *start_token, Item *item_ptr,
+                     char *end_token, bool is_subpart);
+  static int compare_column_values(const void *a, const void *b);
   bool set_up_charset_field_preps();
 private:
   static int list_part_cmp(const void* a, const void* b);
-  static int list_part_cmp_unsigned(const void* a, const void* b);
   bool set_up_default_partitions(handler *file, HA_CREATE_INFO *info,
                                  uint start_no);
   bool set_up_default_subpartitions(handler *file, HA_CREATE_INFO *info);
@@ -288,6 +293,9 @@ class partition_info : public Sql_alloc
                                        uint start_no);
   char *create_subpartition_name(uint subpart_no, const char *part_name);
   bool has_unique_name(partition_element *element);
+  bool fix_column_value_functions(THD *thd,
+                                  part_column_list_val *col_val,
+                                  uint part_id);
 };
 
 uint32 get_next_partition_id_range(struct st_partition_iter* part_iter);

sql/share/errmsg.txt

@@ -6180,6 +6180,16 @@ ER_TOO_LONG_FIELD_COMMENT
 
 ER_FUNC_INEXISTENT_NAME_COLLISION 42000 
   eng "FUNCTION %s does not exist. Check the 'Function Name Parsing and Resolution' section in the Reference Manual"
+ER_GLOBAL_PARTITION_INDEX_ERROR
+  eng "Partitioning of indexes only supported for global indexes"
+ER_PARTITION_COLUMN_LIST_ERROR
+  eng "Inconsistency in usage of column lists for partitioning"
+ER_WRONG_TYPE_COLUMN_VALUE_ERROR
+  eng "Partition column values of incorrect type"
+ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR
+  eng "Too many fields in '%s'"
+ER_MAXVALUE_IN_LIST_PARTITIONING_ERROR
+  eng "Cannot use MAXVALUE as value in List partitioning"
 
 # When updating these, please update EXPLAIN_FILENAME_MAX_EXTRA_LENGTH in
 # mysql_priv.h with the new maximal additional length for explain_filename.

sql/sql_lex.cc

@@ -323,6 +323,7 @@ void lex_start(THD *thd)
   lex->select_lex.select_number= 1;
   lex->length=0;
   lex->part_info= 0;
+  lex->global_flag= 0;
   lex->select_lex.in_sum_expr=0;
   lex->select_lex.ftfunc_list_alloc.empty();
   lex->select_lex.ftfunc_list= &lex->select_lex.ftfunc_list_alloc;

sql/sql_lex.h

@@ -1565,6 +1565,9 @@ typedef struct st_lex : public Query_tables_list
   /* Partition info structure filled in by PARTITION BY parse part */
   partition_info *part_info;
 
+  /* Flag to index a global index created */
+  bool global_flag;
+
   /*
     The definer of the object being created (view, trigger, stored routine).
     I.e. the value of DEFINER clause.

sql/sql_partition.h

@@ -174,8 +174,11 @@ typedef struct st_partition_iter
     get_partitions_in_range_iter()
       part_info   Partitioning info
       is_subpart
+      store_length_array Length of fields packed in opt_range_key format
       min_val     Left edge,  field value in opt_range_key format.
       max_val     Right edge, field value in opt_range_key format.
+      min_len     Length of minimum value
+      max_len     Length of maximum value
       flags       Some combination of NEAR_MIN, NEAR_MAX, NO_MIN_RANGE,
                   NO_MAX_RANGE.
       part_iter   Iterator structure to be initialized
@@ -191,8 +194,9 @@ typedef struct st_partition_iter
     The set of partitions is returned by initializing an iterator in *part_iter
 
   NOTES
-    There are currently two functions of this type:
+    There are currently three functions of this type:
      - get_part_iter_for_interval_via_walking
+     - get_part_iter_for_interval_cols_via_map
      - get_part_iter_for_interval_via_mapping
 
   RETURN 
@@ -203,7 +207,9 @@ typedef struct st_partition_iter
 
 typedef int (*get_partitions_in_range_iter)(partition_info *part_info,
                                             bool is_subpart,
+                                            uint32 *store_length_array,
                                             uchar *min_val, uchar *max_val,
+                                            uint min_len, uint max_len,
                                             uint flags,
                                             PARTITION_ITERATOR *part_iter);
 

sql/sql_show.cc

@@ -4869,12 +4869,18 @@ static int get_schema_partitions_record(THD *thd, TABLE_LIST *tables,
     /* Partition method*/
     switch (part_info->part_type) {
     case RANGE_PARTITION:
-      table->field[7]->store(partition_keywords[PKW_RANGE].str,
-                             partition_keywords[PKW_RANGE].length, cs);
-      break;
     case LIST_PARTITION:
-      table->field[7]->store(partition_keywords[PKW_LIST].str,
-                             partition_keywords[PKW_LIST].length, cs);
+      tmp_res.length(0);
+      if (part_info->part_type == RANGE_PARTITION)
+        tmp_res.append(partition_keywords[PKW_RANGE].str,
+                       partition_keywords[PKW_RANGE].length);
+      else
+        tmp_res.append(partition_keywords[PKW_LIST].str,
+                       partition_keywords[PKW_LIST].length);
+      if (part_info->column_list)
+        tmp_res.append(partition_keywords[PKW_COLUMNS].str,
+                       partition_keywords[PKW_COLUMNS].length);
+      table->field[7]->store(tmp_res.ptr(), tmp_res.length(), cs);
       break;
     case HASH_PARTITION:
       tmp_res.length(0);
@@ -6484,7 +6490,7 @@ ST_FIELD_INFO partitions_fields_info[]=
    (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FULL_TABLE},
   {"SUBPARTITION_ORDINAL_POSITION", 21 , MYSQL_TYPE_LONGLONG, 0,
    (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED), 0, OPEN_FULL_TABLE},
-  {"PARTITION_METHOD", 12, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
+  {"PARTITION_METHOD", 18, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
   {"SUBPARTITION_METHOD", 12, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
   {"PARTITION_EXPRESSION", 65535, MYSQL_TYPE_STRING, 0, 1, 0, OPEN_FULL_TABLE},
   {"SUBPARTITION_EXPRESSION", 65535, MYSQL_TYPE_STRING, 0, 1, 0,

sql/sql_table.cc

@@ -3664,7 +3664,7 @@ bool mysql_create_table_no_lock(THD *thd,
              ha_resolve_storage_engine_name(part_info->default_engine_type),
              ha_resolve_storage_engine_name(create_info->db_type)));
     if (part_info->check_partition_info(thd, &engine_type, file,
-                                        create_info, TRUE))
+                                        create_info, FALSE))
       goto err;
     part_info->default_engine_type= engine_type;