diff --git a/VC++Files/mysql.sln b/VC++Files/mysql.sln index fc75dc24723..5b062a31aab 100755 --- a/VC++Files/mysql.sln +++ b/VC++Files/mysql.sln @@ -277,6 +277,17 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mysql_test_run_new", "mysql {D2B00DE0-F6E9-40AF-B90D-A257D014F098} = {D2B00DE0-F6E9-40AF-B90D-A257D014F098} EndProjectSection EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mysqlmanager", "server-tools\instance-manager\mysqlmanager.vcproj", "{6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}" + ProjectSection(ProjectDependencies) = postProject + {EEC1300B-85A5-497C-B3E1-F708021DF859} = {EEC1300B-85A5-497C-B3E1-F708021DF859} + {BA86AE72-0CF5-423D-BBA2-E12B0D72EBFB} = {BA86AE72-0CF5-423D-BBA2-E12B0D72EBFB} + {DB28DE80-837F-4497-9AA9-CC0A20584C98} = {DB28DE80-837F-4497-9AA9-CC0A20584C98} + {8762A9B8-72A9-462E-A9A2-F3265081F8AF} = {8762A9B8-72A9-462E-A9A2-F3265081F8AF} + {F74653C4-8003-4A79-8F53-FC69E0AD7A9B} = {F74653C4-8003-4A79-8F53-FC69E0AD7A9B} + {44D9C7DC-6636-4B82-BD01-6876C64017DF} = {44D9C7DC-6636-4B82-BD01-6876C64017DF} + {FC369DF4-AEB7-4531-BF34-A638C4363BFE} = {FC369DF4-AEB7-4531-BF34-A638C4363BFE} + EndProjectSection +EndProject Global GlobalSection(SolutionConfiguration) = preSolution classic = classic @@ -1204,6 +1215,32 @@ Global {6189F838-21C6-42A1-B2D0-9146316573F7}.pro nt.Build.0 = Release|Win32 {6189F838-21C6-42A1-B2D0-9146316573F7}.Release.ActiveCfg = Release|Win32 {6189F838-21C6-42A1-B2D0-9146316573F7}.Release.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.classic.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.classic.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.classic nt.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.classic nt.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Debug.ActiveCfg = Debug|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Debug.Build.0 = Debug|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Classic.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Classic.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Debug.ActiveCfg = Debug|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Debug.Build.0 = Debug|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Pro.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Pro.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Release.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Embedded_Release.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Max.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Max.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Max nt.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Max nt.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.nt.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.nt.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.pro.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.pro.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.pro nt.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.pro nt.Build.0 = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Release.ActiveCfg = Release|Win32 + {6D524B3E-210A-4FCD-8D41-FEC0D21E83AC}.Release.Build.0 = Release|Win32 EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution EndGlobalSection diff --git a/VC++Files/mysys/mysys.vcproj b/VC++Files/mysys/mysys.vcproj index 3d53fd3923c..87e9338e811 100755 --- a/VC++Files/mysys/mysys.vcproj +++ b/VC++Files/mysys/mysys.vcproj @@ -1638,6 +1638,9 @@ PreprocessorDefinitions=""/> + + *###[[', '2003-03-03 03:03:03'); INSERT INTO federated.t1 (code, fileguts, creation_date) VALUES ('DEUEUEUEUEUEUEUEUEU', '*()w*09*$()*#)(*09*^90*d)(*s()d8g)(s*ned)(*)(s*d)(*hn(d*)(*sbn)D((#$*(#*%%&#&^$#&#&#&#&^&#*&*#$*&^*(&#(&Q*&&(*!&!(*&*(#&*(%&#*###[[', '2004-04-04 04:04:04'); INSERT INTO federated.t1 (code, fileguts, creation_date) VALUES ('DEUEUEUEUEUEUEUEUEU', 'jimbob', '2004-04-04 04:04:04'); @@ -1340,7 +1340,7 @@ DROP TABLE IF EXISTS federated.t1; CREATE TABLE federated.t1 ( `a` BLOB) ENGINE="FEDERATED" -COMMENT='mysql://root@127.0.0.1:SLAVE_PORT/federated/t1'; +CONNECTION='mysql://root@127.0.0.1:SLAVE_PORT/federated/t1'; INSERT INTO federated.t1 VALUES (0x00); INSERT INTO federated.t1 VALUES (0x0001); INSERT INTO federated.t1 VALUES (0x0100); @@ -1378,7 +1378,7 @@ CREATE TABLE federated.t1 ( PRIMARY KEY (`id`), KEY (country_id) ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 -COMMENT='mysql://root@127.0.0.1:SLAVE_PORT/federated/t1'; +CONNECTION='mysql://root@127.0.0.1:SLAVE_PORT/federated/t1'; INSERT INTO federated.t1 (name, country_id, other) VALUES ('Kumar', 1, 11111); INSERT INTO federated.t1 (name, country_id, other) VALUES ('Lenz', 2, 22222); INSERT INTO federated.t1 (name, country_id, other) VALUES ('Marizio', 3, 33333); diff --git a/mysql-test/r/federated_archive.result b/mysql-test/r/federated_archive.result index f0eded42c38..5fc9bfadeb6 100644 --- a/mysql-test/r/federated_archive.result +++ b/mysql-test/r/federated_archive.result @@ -21,7 +21,7 @@ CREATE TABLE federated.t1 ( PRIMARY KEY (`id`) ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 -COMMENT='mysql://root@127.0.0.1:SLAVE_PORT/federated/archive_table'; +CONNECTION='mysql://root@127.0.0.1:SLAVE_PORT/federated/archive_table'; INSERT INTO federated.t1 (id, name) VALUES (1, 'foo'); INSERT INTO federated.t1 (id, name) VALUES (2, 'bar'); SELECT * FROM federated.t1; diff --git a/mysql-test/r/mysqldump.result b/mysql-test/r/mysqldump.result index 2cbceae86b3..fbe538d11e4 100644 --- a/mysql-test/r/mysqldump.result +++ b/mysql-test/r/mysqldump.result @@ -1990,28 +1990,28 @@ a2 DROP TRIGGER testref; DROP TABLE test1; DROP TABLE test2; -CREATE TABLE t1 (id int); -INSERT INTO t1 VALUES(1); -INSERT INTO t1 VALUES(2); -INSERT INTO t1 VALUES(3); -INSERT INTO t1 VALUES(4); -INSERT INTO t1 VALUES(5); +DROP TABLE IF EXISTS t1; DROP FUNCTION IF EXISTS bug9056_func1; -CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11) -RETURN a+b // +DROP FUNCTION IF EXISTS bug9056_func2; +DROP PROCEDURE IF EXISTS bug9056_proc1; +DROP PROCEDURE IF EXISTS bug9056_proc2; +CREATE TABLE t1 (id int); +INSERT INTO t1 VALUES(1), (2), (3), (4), (5); +CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11) RETURN a+b // CREATE PROCEDURE `bug9056_proc1`(IN a INT, IN b INT, OUT c INT) BEGIN SELECT a+b INTO c; end // -DROP FUNCTION IF EXISTS bug9056_func2 // create function bug9056_func2(f1 char binary) returns char binary begin set f1= concat( 'hello', f1 ); return f1; end // -DROP PROCEDURE IF EXISTS bug9056_proc2 // CREATE PROCEDURE bug9056_proc2(OUT a INT) BEGIN select sum(id) from t1 into a; END // +set sql_mode='ansi'; +create procedure `a'b` () select 1; +set sql_mode=''; /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */; /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */; @@ -2036,32 +2036,38 @@ LOCK TABLES `t1` WRITE; INSERT INTO `t1` VALUES (1),(2),(3),(4),(5); UNLOCK TABLES; /*!40000 ALTER TABLE `t1` ENABLE KEYS */; - -/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/; DELIMITER // +/*!50003 DROP FUNCTION IF EXISTS `bug9056_func1` */ // /*!50003 SET SESSION SQL_MODE=""*/ // -/*!50003 DROP FUNCTION IF EXISTS bug9056_func1 */ // /*!50003 CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11) RETURN a+b */ // +/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ // +/*!50003 DROP FUNCTION IF EXISTS `bug9056_func2` */ // /*!50003 SET SESSION SQL_MODE=""*/ // -/*!50003 DROP FUNCTION IF EXISTS bug9056_func2 */ // /*!50003 CREATE FUNCTION `bug9056_func2`(f1 char binary) RETURNS char(1) begin set f1= concat( 'hello', f1 ); return f1; end */ // +/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ // +/*!50003 DROP PROCEDURE IF EXISTS `a'b` */ // +/*!50003 SET SESSION SQL_MODE="REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES,IGNORE_SPACE,ANSI"*/ // +/*!50003 CREATE PROCEDURE "a'b"() +select 1 */ // +/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ // +/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc1` */ // /*!50003 SET SESSION SQL_MODE=""*/ // -/*!50003 DROP PROCEDURE IF EXISTS bug9056_proc1 */ // /*!50003 CREATE PROCEDURE `bug9056_proc1`(IN a INT, IN b INT, OUT c INT) BEGIN SELECT a+b INTO c; end */ // +/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ // +/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc2` */ // /*!50003 SET SESSION SQL_MODE=""*/ // -/*!50003 DROP PROCEDURE IF EXISTS bug9056_proc2 */ // /*!50003 CREATE PROCEDURE `bug9056_proc2`(OUT a INT) BEGIN select sum(id) from t1 into a; END */ // +/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ // DELIMITER ; -/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/; /*!40101 SET SQL_MODE=@OLD_SQL_MODE */; /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */; @@ -2071,8 +2077,8 @@ DELIMITER ; /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */; /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */; -DROP PROCEDURE IF EXISTS bug9056_func1; -DROP PROCEDURE IF EXISTS bug9056_func2; -DROP PROCEDURE IF EXISTS bug9056_proc1; -DROP PROCEDURE IF EXISTS bug9056_proc2; +DROP FUNCTION bug9056_func1; +DROP FUNCTION bug9056_func2; +DROP PROCEDURE bug9056_proc1; +DROP PROCEDURE bug9056_proc2; drop table t1; diff --git a/mysql-test/r/range.result b/mysql-test/r/range.result index e8e30b3653a..f490c2e1383 100644 --- a/mysql-test/r/range.result +++ b/mysql-test/r/range.result @@ -521,8 +521,8 @@ select count(*) from t1 where x = 18446744073709551601; count(*) 1 create table t2 (x bigint not null); -insert into t2(x) values (0xfffffffffffffff0); -insert into t2(x) values (0xfffffffffffffff1); +insert into t2(x) values (cast(0xfffffffffffffff0+0 as signed)); +insert into t2(x) values (cast(0xfffffffffffffff1+0 as signed)); select * from t2; x -16 diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index 3d48a9f2803..0559b45168b 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -3323,4 +3323,12 @@ drop function bug12379| drop procedure bug12379_1| drop procedure bug12379_2| drop procedure bug12379_3| +drop procedure if exists bug13124| +create procedure bug13124() +begin +declare y integer; +set @x=y; +end| +call bug13124()| +drop procedure bug13124| drop table t1,t2; diff --git a/mysql-test/r/strict.result b/mysql-test/r/strict.result index 6299e8dcc88..2b1a47ed337 100644 --- a/mysql-test/r/strict.result +++ b/mysql-test/r/strict.result @@ -667,7 +667,9 @@ INSERT INTO t1 VALUES(-9223372036854774000.0,0.0),(9223372036854775700.0,1844674 INSERT INTO t1 (col1) VALUES(-9223372036854775809); ERROR 22003: Out of range value adjusted for column 'col1' at row 1 INSERT INTO t1 (col1) VALUES(9223372036854775808); +ERROR 22003: Out of range value adjusted for column 'col1' at row 1 INSERT INTO t1 (col2) VALUES(-1); +ERROR 22003: Out of range value adjusted for column 'col2' at row 1 INSERT INTO t1 (col2) VALUES(18446744073709551616); ERROR 22003: Out of range value adjusted for column 'col2' at row 1 INSERT INTO t1 (col1) VALUES('-9223372036854775809'); @@ -706,6 +708,8 @@ Error 1365 Division by 0 INSERT IGNORE INTO t1 VALUES(-9223372036854775809,-1),(9223372036854775808,18446744073709551616); Warnings: Warning 1264 Out of range value adjusted for column 'col1' at row 1 +Warning 1264 Out of range value adjusted for column 'col2' at row 1 +Warning 1264 Out of range value adjusted for column 'col1' at row 2 Warning 1264 Out of range value adjusted for column 'col2' at row 2 INSERT IGNORE INTO t1 VALUES('-9223372036854775809','-1'),('9223372036854775808','18446744073709551616'); Warnings: @@ -729,12 +733,10 @@ col1 col2 9223372036854775807 18446744073709551615 -9223372036854774000 0 9223372036854775700 1844674407370954000 --9223372036854775808 NULL -NULL 18446744073709551615 2 NULL NULL NULL --9223372036854775808 18446744073709551615 --9223372036854775808 18446744073709551615 +-9223372036854775808 0 +9223372036854775807 18446744073709551615 -9223372036854775808 0 9223372036854775807 18446744073709551615 -9223372036854775808 0 diff --git a/mysql-test/r/type_ranges.result b/mysql-test/r/type_ranges.result index 1342603f755..ff07dcca106 100644 --- a/mysql-test/r/type_ranges.result +++ b/mysql-test/r/type_ranges.result @@ -95,6 +95,7 @@ Warning 1264 Out of range value adjusted for column 'utiny' at row 1 Warning 1264 Out of range value adjusted for column 'ushort' at row 1 Warning 1264 Out of range value adjusted for column 'umedium' at row 1 Warning 1264 Out of range value adjusted for column 'ulong' at row 1 +Warning 1264 Out of range value adjusted for column 'ulonglong' at row 1 Warning 1265 Data truncated for column 'options' at row 1 Warning 1265 Data truncated for column 'flags' at row 1 insert into t1 values (0,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,NULL,0,0,0,-4294967295,-4294967295,-4294967295,'-4294967295',0,"one,two,tree"); @@ -108,6 +109,7 @@ Warning 1264 Out of range value adjusted for column 'utiny' at row 1 Warning 1264 Out of range value adjusted for column 'ushort' at row 1 Warning 1264 Out of range value adjusted for column 'umedium' at row 1 Warning 1264 Out of range value adjusted for column 'ulong' at row 1 +Warning 1264 Out of range value adjusted for column 'ulonglong' at row 1 Warning 1265 Data truncated for column 'options' at row 1 insert into t1 values (0,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,NULL,0,0,0,4294967295,4294967295,4294967295,'4294967295',0,0); Warnings: @@ -125,8 +127,8 @@ auto string tiny short medium long_int longlong real_float real_double utiny ush 10 1 1 1 1 1 1 1.0 1.0000 1 00001 1 1 1 0 0000-00-00 00:00:00 0000-00-00 00:00:00 1 1 1 1 11 2 2 2 2 2 2 2.0 2.0000 2 00002 2 2 2 0 NULL NULL NULL NULL NULL 2 2 12 0.33333333 3 3 3 3 3 3.0 3.0000 3 00003 3 3 3 0 1997-03-03 10:10:10 1997-03-03 10:10:10 3 -13 -1 -1 -1 -1 -1 -1 -1.0 -1.0000 0 00000 0 0 18446744073709551615 0 1997-08-07 08:07:06 1997-04-03 09:08:07 -1 -1 -1 -1 -14 -429496729 -128 -32768 -8388608 -2147483648 -4294967295 -4294967296.0 -4294967295.0000 0 00000 0 0 18446744069414584321 0 0000-00-00 00:00:00 0000-00-00 00:00:00 -4294967295 -4294967295 -4294967295 -4294967295 +13 -1 -1 -1 -1 -1 -1 -1.0 -1.0000 0 00000 0 0 0 0 1997-08-07 08:07:06 1997-04-03 09:08:07 -1 -1 -1 -1 +14 -429496729 -128 -32768 -8388608 -2147483648 -4294967295 -4294967296.0 -4294967295.0000 0 00000 0 0 0 0 0000-00-00 00:00:00 0000-00-00 00:00:00 -4294967295 -4294967295 -4294967295 -4294967295 15 4294967295 127 32767 8388607 2147483647 4294967295 4294967296.0 4294967295.0000 255 65535 16777215 4294967295 4294967295 0 0000-00-00 00:00:00 0000-00-00 00:00:00 4294967295 4294967295 4294967295 4294967295 16 hello 1 1 0 0 0 0.0 NULL 0 00000 0 0 0 0 NULL NULL NULL NULL NULL ALTER TABLE t1 diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result index 5572292c68e..258130d1e85 100644 --- a/mysql-test/r/view.result +++ b/mysql-test/r/view.result @@ -2190,3 +2190,9 @@ create table t1 (s1 int); create view abc as select * from t1 as abc; drop table t1; drop view abc; +create table t1(f1 char(1)); +create view v1 as select * from t1; +select * from (select f1 as f2 from v1) v where v.f2='a'; +f2 +drop view v1; +drop table t1; diff --git a/mysql-test/t/bigint.test b/mysql-test/t/bigint.test index 5f21d2b5813..d9c1abd9ba9 100644 --- a/mysql-test/t/bigint.test +++ b/mysql-test/t/bigint.test @@ -35,21 +35,27 @@ drop table t1; create table t1 ( a int not null default 1, big bigint ); insert into t1 (big) values (-1),(12345678901234567),(9223372036854775807),(18446744073709551615); +select * from t1; select min(big),max(big),max(big)-1 from t1; select min(big),max(big),max(big)-1 from t1 group by a; alter table t1 modify big bigint unsigned not null; select min(big),max(big),max(big)-1 from t1; select min(big),max(big),max(big)-1 from t1 group by a; +insert into t1 (big) values (18446744073709551615); +select * from t1; +select min(big),max(big),max(big)-1 from t1; +select min(big),max(big),max(big)-1 from t1 group by a; alter table t1 add key (big); select min(big),max(big),max(big)-1 from t1; select min(big),max(big),max(big)-1 from t1 group by a; alter table t1 modify big bigint not null; +select * from t1; select min(big),max(big),max(big)-1 from t1; select min(big),max(big),max(big)-1 from t1 group by a; drop table t1; # -# Test problem with big values fir auto_increment +# Test problem with big values for auto_increment # create table t1 (id bigint auto_increment primary key, a int) auto_increment=9999999999; @@ -112,6 +118,7 @@ drop table t1, t2; # # Test of CREATE ... SELECT and unsigned integers # + create table t1 select 1 as 'a'; show create table t1; drop table t1; @@ -119,3 +126,147 @@ create table t1 select 9223372036854775809 as 'a'; show create table t1; select * from t1; drop table t1; +DROP DATABASE IF EXISTS `scott`; + + +# +# Check various conversions from/to unsigned bigint. +# + +create table t1 (a char(100), b varchar(100), c text, d blob); +insert into t1 values( + 18446744073709551615,18446744073709551615, + 18446744073709551615, 18446744073709551615 +); + +insert into t1 values (-1 | 0,-1 | 0,-1 | 0 ,-1 | 0); +select * from t1; +drop table t1; + +create table t1 ( quantity decimal(2) unsigned); +insert into t1 values (500), (-500), (~0), (-1); +select * from t1; +drop table t1; + +# +# Test of storing decimal values in BIGINT range +# (Bug #12750: Incorrect storage of 9999999999999999999 in DECIMAL(19, 0)) +# + +CREATE TABLE t1 ( + `col1` INT(1) NULL, + `col2` INT(2) NULL, + `col3` INT(3) NULL, + `col4` INT(4) NULL, + `col5` INT(5) NULL, + `col6` INT(6) NULL, + `col7` INT(7) NULL, + `col8` INT(8) NULL, + `col9` INT(9) NULL, + `col10` BIGINT(10) NULL, + `col11` BIGINT(11) NULL, + `col12` BIGINT(12) NULL, + `col13` BIGINT(13) NULL, + `col14` BIGINT(14) NULL, + `col15` BIGINT(15) NULL, + `col16` BIGINT(16) NULL, + `col17` BIGINT(17) NULL, + `col18` BIGINT(18) NULL, + `col19` DECIMAL(19, 0) NULL, + `col20` DECIMAL(20, 0) NULL, + `col21` DECIMAL(21, 0) NULL, + `col22` DECIMAL(22, 0) NULL, + `col23` DECIMAL(23, 0) NULL, + `col24` DECIMAL(24, 0) NULL, + `col25` DECIMAL(25, 0) NULL, + `col26` DECIMAL(26, 0) NULL, + `col27` DECIMAL(27, 0) NULL, + `col28` DECIMAL(28, 0) NULL, + `col29` DECIMAL(29, 0) NULL, + `col30` DECIMAL(30, 0) NULL, + `col31` DECIMAL(31, 0) NULL, + `col32` DECIMAL(32, 0) NULL, + `col33` DECIMAL(33, 0) NULL, + `col34` DECIMAL(34, 0) NULL, + `col35` DECIMAL(35, 0) NULL, + `col36` DECIMAL(36, 0) NULL, + `col37` DECIMAL(37, 0) NULL, + `col38` DECIMAL(38, 0) NULL, + `fix1` DECIMAL(38, 1) NULL, + `fix2` DECIMAL(38, 2) NULL, + `fix3` DECIMAL(38, 3) NULL, + `fix4` DECIMAL(38, 4) NULL, + `fix5` DECIMAL(38, 5) NULL, + `fix6` DECIMAL(38, 6) NULL, + `fix7` DECIMAL(38, 7) NULL, + `fix8` DECIMAL(38, 8) NULL, + `fix9` DECIMAL(38, 9) NULL, + `fix10` DECIMAL(38, 10) NULL, + `fix11` DECIMAL(38, 11) NULL, + `fix12` DECIMAL(38, 12) NULL, + `fix13` DECIMAL(38, 13) NULL, + `fix14` DECIMAL(38, 14) NULL, + `fix15` DECIMAL(38, 15) NULL, + `fix16` DECIMAL(38, 16) NULL, + `fix17` DECIMAL(38, 17) NULL, + `fix18` DECIMAL(38, 18) NULL, + `fix19` DECIMAL(38, 19) NULL, + `fix20` DECIMAL(38, 20) NULL, + `fix21` DECIMAL(38, 21) NULL, + `fix22` DECIMAL(38, 22) NULL, + `fix23` DECIMAL(38, 23) NULL, + `fix24` DECIMAL(38, 24) NULL, + `fix25` DECIMAL(38, 25) NULL, + `fix26` DECIMAL(38, 26) NULL, + `fix27` DECIMAL(38, 27) NULL, + `fix28` DECIMAL(38, 28) NULL, + `fix29` DECIMAL(38, 29) NULL, + `fix30` DECIMAL(38, 30) NULL +); + +INSERT INTO t1(`col1`, `col2`, `col3`, `col4`, `col5`, `col6`, `col7`, `col8`, `col9`, `col10`, `col11`, `col12`, `col13`, `col14`, `col15`, `col16`, `col17`, `col18`, `col19`, `col20`, `col21`, `col22`, `col23`, `col24`, `col25`, `col26`, `col27`, `col28`, `col29`, `col30`, `col31`, `col32`, `col33`, `col34`, `col35`, `col36`, `col37`, `col38`, `fix1`, `fix2`, `fix3`, `fix4`, `fix5`, `fix6`, `fix7`, `fix8`, `fix9`, `fix10`, `fix11`, `fix12`, `fix13`, `fix14`, `fix15`, `fix16`, `fix17`, `fix18`, `fix19`, `fix20`, `fix21`, `fix22`, `fix23`, `fix24`, `fix25`, `fix26`, `fix27`, `fix28`, `fix29`, `fix30`) +VALUES (9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, +9999999999, 99999999999, 999999999999, 9999999999999, 99999999999999, +999999999999999, 9999999999999999, 99999999999999999, 999999999999999999, +9999999999999999999, 99999999999999999999, 999999999999999999999, +9999999999999999999999, 99999999999999999999999, 999999999999999999999999, +9999999999999999999999999, 99999999999999999999999999, +999999999999999999999999999, 9999999999999999999999999999, +99999999999999999999999999999, 999999999999999999999999999999, +9999999999999999999999999999999, 99999999999999999999999999999999, +999999999999999999999999999999999, 9999999999999999999999999999999999, +99999999999999999999999999999999999, 999999999999999999999999999999999999, +9999999999999999999999999999999999999, 99999999999999999999999999999999999999, +9999999999999999999999999999999999999.9, +999999999999999999999999999999999999.99, +99999999999999999999999999999999999.999, +9999999999999999999999999999999999.9999, +999999999999999999999999999999999.99999, +99999999999999999999999999999999.999999, +9999999999999999999999999999999.9999999, +999999999999999999999999999999.99999999, +99999999999999999999999999999.999999999, +9999999999999999999999999999.9999999999, +999999999999999999999999999.99999999999, +99999999999999999999999999.999999999999, +9999999999999999999999999.9999999999999, +999999999999999999999999.99999999999999, +99999999999999999999999.999999999999999, +9999999999999999999999.9999999999999999, +999999999999999999999.99999999999999999, +99999999999999999999.999999999999999999, +9999999999999999999.9999999999999999999, +999999999999999999.99999999999999999999, +99999999999999999.999999999999999999999, +9999999999999999.9999999999999999999999, +999999999999999.99999999999999999999999, +99999999999999.999999999999999999999999, +9999999999999.9999999999999999999999999, +999999999999.99999999999999999999999999, +99999999999.999999999999999999999999999, +9999999999.9999999999999999999999999999, +999999999.99999999999999999999999999999, +99999999.999999999999999999999999999999); + +SELECT * FROM t1; +DROP TABLE t1; diff --git a/mysql-test/t/federated.test b/mysql-test/t/federated.test index 255b9dc22d7..28091676dd7 100644 --- a/mysql-test/t/federated.test +++ b/mysql-test/t/federated.test @@ -17,7 +17,7 @@ CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:@/too/many/items/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:@/too/many/items/federated/t1'; # test not enough items (malformed) in the comment string url --error 1432 @@ -26,7 +26,7 @@ CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1'; + CONNECTION='mysql://root@127.0.0.1'; # test non-existant table --replace_result $SLAVE_MYPORT SLAVE_PORT @@ -36,7 +36,7 @@ eval CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t3'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t3'; # test bad user/password --replace_result $SLAVE_MYPORT SLAVE_PORT @@ -46,7 +46,7 @@ eval CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://user:pass@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://user:pass@127.0.0.1:$SLAVE_MYPORT/federated/t1'; DROP TABLE IF EXISTS federated.t1; # # correct connection, same named tables @@ -56,7 +56,7 @@ eval CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (id, name) VALUES (1, 'foo'); INSERT INTO federated.t1 (id, name) VALUES (2, 'fee'); @@ -73,7 +73,7 @@ eval CREATE TABLE federated.t2 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t2 (id, name) VALUES (1, 'foo'); INSERT INTO federated.t2 (id, name) VALUES (2, 'fee'); @@ -100,7 +100,7 @@ eval CREATE TABLE federated.t1 ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1%'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1%'; INSERT INTO federated.t1 (id, name) VALUES (1, 'foo'); INSERT INTO federated.t1 (id, name) VALUES (2, 'fee'); @@ -115,7 +115,7 @@ eval CREATE TABLE federated.`t1%` ( `name` varchar(32) NOT NULL default '' ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1%'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1%'; INSERT INTO federated.`t1%` (id, name) VALUES (1, 'foo'); INSERT INTO federated.`t1%` (id, name) VALUES (2, 'fee'); @@ -146,7 +146,7 @@ eval CREATE TABLE federated.t1 ( `created` datetime default '2004-04-04 04:04:04', PRIMARY KEY (`id`)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, other) VALUES ('First Name', 11111); INSERT INTO federated.t1 (name, other) VALUES ('Second Name', 22222); @@ -213,7 +213,7 @@ eval CREATE TABLE federated.t1 ( key other(`other`), key created(`created`)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, other, created) VALUES ('First Name', 11111, '2004-01-01 01:01:01'); @@ -284,7 +284,7 @@ eval CREATE TABLE federated.t1 ( PRIMARY KEY (`id`) ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, other) VALUES ('First Name', 11111); INSERT INTO federated.t1 (name, other) VALUES ('Second Name', NULL); @@ -333,7 +333,7 @@ eval CREATE TABLE federated.t1 ( KEY nameoth (name, other)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, other) VALUES ('First Name', '1111'); INSERT INTO federated.t1 (name, other) VALUES ('Second Name', '2222'); @@ -372,7 +372,7 @@ eval CREATE TABLE federated.t1 ( KEY floatval(floatval)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, bincol, floatval, other) VALUES ('first', 0x65, 11.11, 1111); @@ -421,7 +421,7 @@ eval CREATE TABLE federated.t1 ( key col3(col3), key col4(col4)) ENGINE="FEDERATED" - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (col1, col2, col3, col4) VALUES (1, 'one One', 11, 1111); @@ -515,7 +515,7 @@ eval CREATE TABLE federated.t1 ( key 2key (`col3`,`col4`), key col4(col4)) ENGINE="FEDERATED" - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (col1, col2, col3, col4) VALUES ('aaaa', 'aaaaaaaaaaaaaaaaaaa', 'ababababab', 'acacacacacacacac'); @@ -567,7 +567,7 @@ eval CREATE TABLE federated.t1 ( primary key (`col1`, `col2`, `col3`)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 VALUES ('a00', '110', 'cc0'); INSERT INTO federated.t1 VALUES ('aaa', '111', 'ccc'); @@ -606,7 +606,7 @@ eval CREATE TABLE federated.t1 ( `other` int) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 -COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; +CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; # these both should be the same INSERT INTO federated.t1 values (NULL, NULL, NULL, NULL); @@ -640,7 +640,7 @@ eval CREATE TABLE federated.t1 ( PRIMARY KEY (blurb_id)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 VALUES (1, " MySQL supports a number of column types in several categories: numeric types, date and time types, and string (character) types. This chapter first gives an overview of these column types, and then provides a more detailed description of the properties of the types in each category, and a summary of the column type storage requirements. The overview is intentionally brief. The more detailed descriptions should be consulted for additional information about particular column types, such as the allowable formats in which you can specify values."); INSERT INTO federated.t1 VALUES (2, "All arithmetic is done using signed BIGINT or DOUBLE values, so you should not use unsigned big integers larger than 9223372036854775807 (63 bits) except with bit functions! If you do that, some of the last digits in the result may be wrong because of rounding errors when converting a BIGINT value to a DOUBLE."); @@ -667,7 +667,7 @@ eval CREATE TABLE federated.t1 ( KEY (b)) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 VALUES (3,3,3),(1,1,1),(2,2,2),(4,4,4); @@ -931,7 +931,7 @@ int, i999 int, i1000 int, b varchar(256)) row_format=dynamic ENGINE="FEDERATED" DEFAULT CHARSET=latin1 -COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; +CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 values (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1000,7 +1000,7 @@ eval CREATE TABLE federated.t1 ( index(code), index(fileguts(10))) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (code, fileguts, creation_date) VALUES ('ASDFWERQWETWETAWETA', '*()w*09*$()*#)(*09*^90*d)(*s()d8g)(s*ned)(*)(s*d)(*hn(d*)(*sbn)D((#$*(#*%%&#&^$#&#&#&#&^&#*&*#$*&^*(&#(&Q*&&(*!&!(*&*(#&*(%&#*###[[', '2003-03-03 03:03:03'); INSERT INTO federated.t1 (code, fileguts, creation_date) VALUES ('DEUEUEUEUEUEUEUEUEU', '*()w*09*$()*#)(*09*^90*d)(*s()d8g)(s*ned)(*)(s*d)(*hn(d*)(*sbn)D((#$*(#*%%&#&^$#&#&#&#&^&#*&*#$*&^*(&#(&Q*&&(*!&!(*&*(#&*(%&#*###[[', '2004-04-04 04:04:04'); INSERT INTO federated.t1 (code, fileguts, creation_date) VALUES ('DEUEUEUEUEUEUEUEUEU', 'jimbob', '2004-04-04 04:04:04'); @@ -1019,7 +1019,7 @@ DROP TABLE IF EXISTS federated.t1; eval CREATE TABLE federated.t1 ( `a` BLOB) ENGINE="FEDERATED" -COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; +CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 VALUES (0x00); INSERT INTO federated.t1 VALUES (0x0001); @@ -1031,7 +1031,7 @@ SELECT HEX(a) FROM federated.t1; # --replace_result $SLAVE_MYPORT SLAVE_PORT # eval CREATE TABLE federated.t1 # (a char(20)) charset=cp1251 -# ENGINE="FEDERATED" COMMENT="mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1"; +# ENGINE="FEDERATED" CONNECTION="mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1"; # # # connection slave; # DROP TABLE IF EXISTS federated.t1; @@ -1093,7 +1093,7 @@ eval CREATE TABLE federated.t1 ( PRIMARY KEY (`id`), KEY (country_id) ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1'; INSERT INTO federated.t1 (name, country_id, other) VALUES ('Kumar', 1, 11111); INSERT INTO federated.t1 (name, country_id, other) VALUES ('Lenz', 2, 22222); diff --git a/mysql-test/t/federated_archive.test b/mysql-test/t/federated_archive.test index facddebf558..df0d8c5cca1 100644 --- a/mysql-test/t/federated_archive.test +++ b/mysql-test/t/federated_archive.test @@ -25,7 +25,7 @@ eval CREATE TABLE federated.t1 ( PRIMARY KEY (`id`) ) ENGINE="FEDERATED" DEFAULT CHARSET=latin1 - COMMENT='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/archive_table'; + CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/archive_table'; INSERT INTO federated.t1 (id, name) VALUES (1, 'foo'); INSERT INTO federated.t1 (id, name) VALUES (2, 'bar'); diff --git a/mysql-test/t/innodb.test b/mysql-test/t/innodb.test index ed238f46e0b..beec3b0f8c7 100644 --- a/mysql-test/t/innodb.test +++ b/mysql-test/t/innodb.test @@ -1274,9 +1274,6 @@ select count(*) from t1 where x<0; select count(*) from t1 where x < -16; select count(*) from t1 where x = -16; explain select count(*) from t1 where x > -16; - -# The following result should be (2). To be fixed when we add 'unsigned flag' to -# Field::store(longlong) select count(*) from t1 where x > -16; select * from t1 where x > -16; select count(*) from t1 where x = 18446744073709551601; diff --git a/mysql-test/t/mysqldump.test b/mysql-test/t/mysqldump.test index 985737e14a1..2ce4b1071e2 100644 --- a/mysql-test/t/mysqldump.test +++ b/mysql-test/t/mysqldump.test @@ -829,7 +829,7 @@ DROP TABLE t1, t2; --exec echo "[mysqltest1]" > $MYSQL_TEST_DIR/var/tmp/tmp.cnf --exec echo "port=1234" >> $MYSQL_TEST_DIR/var/tmp/tmp.cnf --exec $MYSQL_MY_PRINT_DEFAULTS -c $MYSQL_TEST_DIR/var/tmp/tmp.cnf mysqltest1 ---exec $MYSQL_MY_PRINT_DEFAULTS -e $MYSQL_TEST_DIR/var/tmp/tmp.cnf mysqltest1 +--exec $MYSQL_MY_PRINT_DEFAULTS -e $MYSQL_TEST_DIR/var/tmp/tmp.cnf mysqltest1 mysqltest1 --exec rm $MYSQL_TEST_DIR/var/tmp/tmp.cnf # @@ -870,34 +870,32 @@ DROP TRIGGER testref; DROP TABLE test1; DROP TABLE test2; -CREATE TABLE t1 (id int); -INSERT INTO t1 VALUES(1); -INSERT INTO t1 VALUES(2); -INSERT INTO t1 VALUES(3); -INSERT INTO t1 VALUES(4); -INSERT INTO t1 VALUES(5); ---disable_warnings -DROP FUNCTION IF EXISTS bug9056_func1; -DELIMITER //; ---enable_warnings -CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11) -RETURN a+b // -CREATE PROCEDURE `bug9056_proc1`(IN a INT, IN b INT, OUT c INT) -BEGIN SELECT a+b INTO c; end // +# +# BUG#9056 - mysqldump does not dump routines +# --disable_warnings -DROP FUNCTION IF EXISTS bug9056_func2 // +DROP TABLE IF EXISTS t1; +DROP FUNCTION IF EXISTS bug9056_func1; +DROP FUNCTION IF EXISTS bug9056_func2; +DROP PROCEDURE IF EXISTS bug9056_proc1; +DROP PROCEDURE IF EXISTS bug9056_proc2; --enable_warnings +CREATE TABLE t1 (id int); +INSERT INTO t1 VALUES(1), (2), (3), (4), (5); + +DELIMITER //; +CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11) RETURN a+b // +CREATE PROCEDURE `bug9056_proc1`(IN a INT, IN b INT, OUT c INT) +BEGIN SELECT a+b INTO c; end // + create function bug9056_func2(f1 char binary) returns char binary begin set f1= concat( 'hello', f1 ); return f1; end // ---disable_warnings -DROP PROCEDURE IF EXISTS bug9056_proc2 // ---enable_warnings CREATE PROCEDURE bug9056_proc2(OUT a INT) BEGIN select sum(id) from t1 into a; @@ -905,14 +903,17 @@ END // DELIMITER ;// +set sql_mode='ansi'; +create procedure `a'b` () select 1; # to fix syntax highlighting :') +set sql_mode=''; + # Dump the DB and ROUTINES --exec $MYSQL_DUMP --skip-comments --routines --databases test # ok, now blow it all away ---disable_warnings -DROP PROCEDURE IF EXISTS bug9056_func1; -DROP PROCEDURE IF EXISTS bug9056_func2; -DROP PROCEDURE IF EXISTS bug9056_proc1; -DROP PROCEDURE IF EXISTS bug9056_proc2; +DROP FUNCTION bug9056_func1; +DROP FUNCTION bug9056_func2; +DROP PROCEDURE bug9056_proc1; +DROP PROCEDURE bug9056_proc2; drop table t1; ---enable-warnings + diff --git a/mysql-test/t/range.test b/mysql-test/t/range.test index 12dda022cb9..bbe5798e7e5 100644 --- a/mysql-test/t/range.test +++ b/mysql-test/t/range.test @@ -406,8 +406,8 @@ select count(*) from t1 where x = 18446744073709551601; create table t2 (x bigint not null); -insert into t2(x) values (0xfffffffffffffff0); -insert into t2(x) values (0xfffffffffffffff1); +insert into t2(x) values (cast(0xfffffffffffffff0+0 as signed)); +insert into t2(x) values (cast(0xfffffffffffffff1+0 as signed)); select * from t2; select count(*) from t2 where x>0; select count(*) from t2 where x=0; diff --git a/mysql-test/t/sp.test b/mysql-test/t/sp.test index 7a9738e8ada..a1e2bf8aa32 100644 --- a/mysql-test/t/sp.test +++ b/mysql-test/t/sp.test @@ -4107,7 +4107,6 @@ select bug131333()| drop procedure bug131333| drop function bug131333| - # # BUG#12379: PROCEDURE with HANDLER calling FUNCTION with error get # strange result @@ -4163,6 +4162,21 @@ drop procedure bug12379_1| drop procedure bug12379_2| drop procedure bug12379_3| +# +# Bug #13124 Stored Procedure using SELECT INTO crashes server +# + +--disable_warnings +drop procedure if exists bug13124| +--enable_warnings +create procedure bug13124() +begin + declare y integer; + set @x=y; +end| +call bug13124()| +drop procedure bug13124| + # # BUG#NNNN: New bug synopsis # diff --git a/mysql-test/t/strict.test b/mysql-test/t/strict.test index 6af0a10d831..d3b36cbc2a8 100644 --- a/mysql-test/t/strict.test +++ b/mysql-test/t/strict.test @@ -659,9 +659,11 @@ INSERT INTO t1 VALUES(-9223372036854775808,0),(0,0),(9223372036854775807,1844674 INSERT INTO t1 VALUES('-9223372036854775808','0'),('9223372036854775807','18446744073709551615'); INSERT INTO t1 VALUES(-9223372036854774000.0,0.0),(9223372036854775700.0,1844674407370954000.0); --- error 1264 +--error 1264 INSERT INTO t1 (col1) VALUES(-9223372036854775809); +--error 1264 INSERT INTO t1 (col1) VALUES(9223372036854775808); +--error 1264 INSERT INTO t1 (col2) VALUES(-1); --error 1264 diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test index 33b77d80020..59e8325a849 100644 --- a/mysql-test/t/view.test +++ b/mysql-test/t/view.test @@ -2068,3 +2068,12 @@ create table t1 (s1 int); create view abc as select * from t1 as abc; drop table t1; drop view abc; + +# +# Bug #12993 View column rename broken in subselect +# +create table t1(f1 char(1)); +create view v1 as select * from t1; +select * from (select f1 as f2 from v1) v where v.f2='a'; +drop view v1; +drop table t1; diff --git a/scripts/make_win_src_distribution.sh b/scripts/make_win_src_distribution.sh index 0d2a8cdd5d7..e75dec55e82 100644 --- a/scripts/make_win_src_distribution.sh +++ b/scripts/make_win_src_distribution.sh @@ -266,7 +266,7 @@ make -C $SOURCE/ndb windoze # Input directories to be copied recursively # -for i in bdb innobase ndb extra/yassl +for i in bdb innobase ndb extra/yassl server-tools do copy_dir_dirs $i done diff --git a/server-tools/instance-manager/IMService.cpp b/server-tools/instance-manager/IMService.cpp index e040a5da8c2..b7ea8e7eb81 100644 --- a/server-tools/instance-manager/IMService.cpp +++ b/server-tools/instance-manager/IMService.cpp @@ -1,12 +1,16 @@ #include +#include #include "log.h" #include "options.h" #include "IMService.h" +#include "manager.h" IMService::IMService(void) { serviceName= "MySqlManager"; displayName= "MySQL Manager"; + username= NULL; + password= NULL; } IMService::~IMService(void) @@ -16,18 +20,25 @@ IMService::~IMService(void) void IMService::Stop() { ReportStatus(SERVICE_STOP_PENDING); + // stop the IM work + raise(SIGTERM); } -void IMService::Run() +void IMService::Run(DWORD argc, LPTSTR *argv) { // report to the SCM that we're about to start ReportStatus((DWORD)SERVICE_START_PENDING); + Options o; + o.load(argc, argv); + // init goes here ReportStatus((DWORD)SERVICE_RUNNING); // wait for main loop to terminate + manager(o); + o.cleanup(); } void IMService::Log(const char *msg) diff --git a/server-tools/instance-manager/IMService.h b/server-tools/instance-manager/IMService.h index 60c202fc561..cad38bebdaf 100644 --- a/server-tools/instance-manager/IMService.h +++ b/server-tools/instance-manager/IMService.h @@ -10,5 +10,5 @@ public: protected: void Log(const char *msg); void Stop(); - void Run(); + void Run(DWORD argc, LPTSTR *argv); }; diff --git a/server-tools/instance-manager/WindowsService.cpp b/server-tools/instance-manager/WindowsService.cpp index fb7e00e0d9b..192045b7a4c 100644 --- a/server-tools/instance-manager/WindowsService.cpp +++ b/server-tools/instance-manager/WindowsService.cpp @@ -8,7 +8,8 @@ WindowsService::WindowsService(void) : statusCheckpoint(0), serviceName(NULL), inited(false), - dwAcceptedControls(SERVICE_ACCEPT_STOP) + dwAcceptedControls(SERVICE_ACCEPT_STOP), + debugging(false) { gService= this; status.dwServiceType= SERVICE_WIN32_OWN_PROCESS; @@ -148,7 +149,7 @@ void WindowsService::RegisterAndRun(DWORD argc, LPTSTR *argv) { statusHandle= ::RegisterServiceCtrlHandler(serviceName, ControlHandler); if (statusHandle && ReportStatus(SERVICE_START_PENDING)) - Run(); + Run(argc, argv); ReportStatus(SERVICE_STOPPED); } diff --git a/server-tools/instance-manager/WindowsService.h b/server-tools/instance-manager/WindowsService.h index 612eeda21e9..1a034ce1351 100644 --- a/server-tools/instance-manager/WindowsService.h +++ b/server-tools/instance-manager/WindowsService.h @@ -30,7 +30,7 @@ public: static void WINAPI ControlHandler(DWORD CtrlType); protected: - virtual void Run()= 0; + virtual void Run(DWORD argc, LPTSTR *argv)= 0; virtual void Stop() {} virtual void Shutdown() {} virtual void Pause() {} diff --git a/server-tools/instance-manager/instance.cc b/server-tools/instance-manager/instance.cc index 0a373429d01..5e1c3d2ea9f 100644 --- a/server-tools/instance-manager/instance.cc +++ b/server-tools/instance-manager/instance.cc @@ -18,9 +18,6 @@ #pragma implementation #endif -#ifdef __WIN__ -#include -#endif #include "instance.h" #include "mysql_manager_error.h" @@ -40,7 +37,7 @@ static void start_and_monitor_instance(Instance_options *old_instance_options, Instance_map *instance_map); -#ifndef _WIN_ +#ifndef __WIN__ typedef pid_t My_process_info; #else typedef PROCESS_INFORMATION My_process_info; @@ -171,25 +168,24 @@ static int start_process(Instance_options *instance_options, ZeroMemory(pi, sizeof(PROCESS_INFORMATION)); int cmdlen= 0; - for (int i= 1; instance_options->argv[i] != 0; i++) - cmdlen+= strlen(instance_options->argv[i]) + 1; - cmdlen++; /* we have to add a single space for CreateProcess (see docs) */ + for (int i= 0; instance_options->argv[i] != 0; i++) + cmdlen+= strlen(instance_options->argv[i]) + 3; + cmdlen++; /* make room for the null */ - char *cmdline= NULL; - if (cmdlen > 0) + char *cmdline= new char[cmdlen]; + if (cmdline == NULL) + return 1; + + for (int i= 0; instance_options->argv[i] != 0; i++) { - cmdline= new char[cmdlen]; - cmdline[0]= 0; - for (int i= 1; instance_options->argv[i] != 0; i++) - { - strcat(cmdline, " "); - strcat(cmdline, instance_options->argv[i]); - } + strcat(cmdline, "\""); + strcat(cmdline, instance_options->argv[i]); + strcat(cmdline, "\" "); } /* Start the child process */ BOOL result= - CreateProcess(instance_options->mysqld_path, /* File to execute */ + CreateProcess(NULL, /* Put it all in cmdline */ cmdline, /* Command line */ NULL, /* Process handle not inheritable */ NULL, /* Thread handle not inheritable */ diff --git a/server-tools/instance-manager/instance_options.cc b/server-tools/instance-manager/instance_options.cc index 124195aad37..70950a91015 100644 --- a/server-tools/instance-manager/instance_options.cc +++ b/server-tools/instance-manager/instance_options.cc @@ -46,8 +46,16 @@ static inline int create_mysqld_command(Buffer *buf, if (buf->get_size()) /* malloc succeeded */ { +#ifdef __WIN__ + buf->append(position, "\"", 1); + position++; +#endif buf->append(position, mysqld_path_str, mysqld_path_len); position+= mysqld_path_len; +#ifdef __WIN__ + buf->append(position, "\"", 1); + position++; +#endif /* here the '\0' character is copied from the option string */ buf->append(position, option, option_len); diff --git a/server-tools/instance-manager/listener.cc b/server-tools/instance-manager/listener.cc index 790770be09e..374946d3b73 100644 --- a/server-tools/instance-manager/listener.cc +++ b/server-tools/instance-manager/listener.cc @@ -121,6 +121,9 @@ void Listener_thread::run() n= max(n, sockets[i]); n++; + timeval tv; + tv.tv_sec= 0; + tv.tv_usec= 100000; while (!thread_registry.is_shutdown()) { fd_set read_fds_arg= read_fds; @@ -130,13 +133,13 @@ void Listener_thread::run() signal during shutdown. This results in failing assert (Thread_registry::~Thread_registry). Valgrind 2.2 works fine. */ - int rc= select(n, &read_fds_arg, 0, 0, 0); + int rc= select(n, &read_fds_arg, 0, 0, &tv); - - if (rc == -1 && errno != EINTR) + if (rc == 0 || rc == -1) { - log_error("Listener_thread::run(): select() failed, %s", - strerror(errno)); + if (rc == -1 && errno != EINTR) + log_error("Listener_thread::run(): select() failed, %s", + strerror(errno)); continue; } diff --git a/server-tools/instance-manager/mysqlmanager.cc b/server-tools/instance-manager/mysqlmanager.cc index a1420a639cb..3d2907f4776 100644 --- a/server-tools/instance-manager/mysqlmanager.cc +++ b/server-tools/instance-manager/mysqlmanager.cc @@ -102,10 +102,12 @@ int main(int argc, char *argv[]) angel(options); } #else -#ifdef NDEBUG - return_value= HandleServiceOptions(options); - goto err; /* this is not always an error but we reuse the label */ -#endif + if (!options.stand_alone) + { + if (HandleServiceOptions(options)) + goto err; + } + else #endif manager(options); diff --git a/server-tools/instance-manager/mysqlmanager.vcproj b/server-tools/instance-manager/mysqlmanager.vcproj index 2ab9a4878c1..a5ef7cb21e3 100644 --- a/server-tools/instance-manager/mysqlmanager.vcproj +++ b/server-tools/instance-manager/mysqlmanager.vcproj @@ -19,7 +19,7 @@ + RelativePath=".\buffer.cpp"> + RelativePath="..\..\sql\client.c"> + + + + + + + RelativePath=".\command.cpp"> + RelativePath=".\commands.cpp"> + RelativePath="..\..\libmysql\get_password.c"> + + + + + + - - + RelativePath=".\guardian.cpp"> + RelativePath=".\instance.cpp"> + RelativePath=".\instance_map.cpp"> + RelativePath=".\instance_options.cpp"> + RelativePath=".\listener.cpp"> + RelativePath=".\log.cpp"> + RelativePath=".\manager.cpp"> + RelativePath=".\messages.cpp"> + RelativePath="..\..\sql\mini_client_errors.c"> + + + + + + + RelativePath=".\mysql_connection.cpp"> + + + + + + + RelativePath=".\mysqlmanager.cpp"> + RelativePath="..\..\sql\net_serv.cpp"> + + + + + + + RelativePath=".\options.cpp"> + RelativePath="..\..\sql\pack.c"> + + + + + + + RelativePath=".\parse.cpp"> + RelativePath=".\parse_output.cpp"> + RelativePath="..\..\sql\password.c"> + + + + + + + RelativePath=".\priv.cpp"> + RelativePath=".\protocol.cpp"> + RelativePath="..\..\sql\sql_state.c"> + RelativePath=".\thread_registry.cpp"> - - + RelativePath=".\user_map.cpp"> diff --git a/server-tools/instance-manager/options.cc b/server-tools/instance-manager/options.cc index 36fe0a89dda..74ccade3a2c 100644 --- a/server-tools/instance-manager/options.cc +++ b/server-tools/instance-manager/options.cc @@ -33,6 +33,7 @@ #ifdef __WIN__ char Options::install_as_service; char Options::remove_service; +char Options::stand_alone; char windows_config_file[FN_REFLEN]; char default_password_file_name[FN_REFLEN]; char default_log_file_name[FN_REFLEN]; @@ -72,6 +73,7 @@ enum options { #else OPT_INSTALL_SERVICE, OPT_REMOVE_SERVICE, + OPT_STAND_ALONE, #endif OPT_MONITORING_INTERVAL, OPT_PORT, @@ -131,6 +133,9 @@ static struct my_option my_long_options[] = { "remove", OPT_REMOVE_SERVICE, "Remove system service.", (gptr *)&Options::remove_service, (gptr*) &Options::remove_service, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 0, 0}, + { "standalone", OPT_STAND_ALONE, "Run the application in stand alone mode.", + (gptr *)&Options::stand_alone, (gptr*) &Options::stand_alone, + 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 0, 0}, #else { "run-as-service", OPT_RUN_AS_SERVICE, "Daemonize and start angel process.", (gptr *) &Options::run_as_service, diff --git a/server-tools/instance-manager/options.h b/server-tools/instance-manager/options.h index 5cc14e7ee7f..a5cd049decf 100644 --- a/server-tools/instance-manager/options.h +++ b/server-tools/instance-manager/options.h @@ -31,6 +31,7 @@ struct Options #ifdef __WIN__ static char install_as_service; static char remove_service; + static char stand_alone; #else static char run_as_service; /* handle_options doesn't support bool */ static const char *user; @@ -52,7 +53,7 @@ struct Options int load(int argc, char **argv); void cleanup(); #ifdef __WIN__ - int setup_windows_defaults(const char *progname); + int setup_windows_defaults(); #endif }; diff --git a/sql-common/client.c b/sql-common/client.c index 43c50f12ae1..08ad906e2b6 100644 --- a/sql-common/client.c +++ b/sql-common/client.c @@ -2203,8 +2203,9 @@ my_bool mysql_reconnect(MYSQL *mysql) DBUG_RETURN(1); } mysql_init(&tmp_mysql); - tmp_mysql.options=mysql->options; - tmp_mysql.rpl_pivot = mysql->rpl_pivot; + tmp_mysql.options= mysql->options; + tmp_mysql.rpl_pivot= mysql->rpl_pivot; + if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd, mysql->db, mysql->port, mysql->unix_socket, mysql->client_flag | CLIENT_REMEMBER_OPTIONS)) @@ -2216,6 +2217,8 @@ my_bool mysql_reconnect(MYSQL *mysql) } if (mysql_set_character_set(&tmp_mysql, mysql->charset->csname)) { + DBUG_PRINT("error", ("mysql_set_character_set() failed")); + bzero((char*) &tmp_mysql.options,sizeof(tmp_mysql.options)); mysql_close(&tmp_mysql); mysql->net.last_errno= tmp_mysql.net.last_errno; strmov(mysql->net.last_error, tmp_mysql.net.last_error); @@ -2223,6 +2226,7 @@ my_bool mysql_reconnect(MYSQL *mysql) DBUG_RETURN(1); } + DBUG_PRINT("info", ("reconnect succeded")); tmp_mysql.reconnect= 1; tmp_mysql.free_me= mysql->free_me; @@ -2286,6 +2290,8 @@ mysql_select_db(MYSQL *mysql, const char *db) static void mysql_close_free_options(MYSQL *mysql) { + DBUG_ENTER("mysql_close_free_options"); + my_free(mysql->options.user,MYF(MY_ALLOW_ZERO_PTR)); my_free(mysql->options.host,MYF(MY_ALLOW_ZERO_PTR)); my_free(mysql->options.password,MYF(MY_ALLOW_ZERO_PTR)); @@ -2314,6 +2320,7 @@ static void mysql_close_free_options(MYSQL *mysql) my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR)); #endif /* HAVE_SMEM */ bzero((char*) &mysql->options,sizeof(mysql->options)); + DBUG_VOID_RETURN; } diff --git a/sql/field.cc b/sql/field.cc index 224b6c279f3..e8731cb0ea5 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -1199,7 +1199,7 @@ static bool test_if_real(const char *str,int length, CHARSET_INFO *cs) This is used for printing bit_fields as numbers while debugging */ -String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_flag) +String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val) { CHARSET_INFO *cs= &my_charset_bin; uint length= 21; @@ -1208,7 +1208,7 @@ String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_flag) return 0; length= (uint) (*cs->cset->longlong10_to_str)(cs, (char*) val_buffer->ptr(), length, - unsigned_flag ? 10 : -10, + unsigned_val ? 10 : -10, value); val_buffer->length(length); return val_buffer; @@ -1360,7 +1360,7 @@ int Field_num::store_decimal(const my_decimal *val) { int err= 0; longlong i= convert_decimal2longlong(val, unsigned_flag, &err); - return test(err | store(i)); + return test(err | store(i, unsigned_flag)); } @@ -2122,36 +2122,37 @@ int Field_decimal::store(double nr) } -int Field_decimal::store(longlong nr) +int Field_decimal::store(longlong nr, bool unsigned_val) { - if (unsigned_flag && nr < 0) + char buff[22]; + uint length, int_part; + char fyllchar, *to; + + if (nr < 0 && unsigned_flag && !unsigned_val) { overflow(1); return 1; } - char buff[22]; - uint length=(uint) (longlong10_to_str(nr,buff,-10)-buff); - uint int_part=field_length- (dec ? dec+1 : 0); + length= (uint) (longlong10_to_str(nr,buff,unsigned_val ? 10 : -10) - buff); + int_part= field_length- (dec ? dec+1 : 0); if (length > int_part) { - overflow(test(nr < 0L)); /* purecov: inspected */ + overflow(!unsigned_val && nr < 0L); /* purecov: inspected */ return 1; } - else + + fyllchar = zerofill ? (char) '0' : (char) ' '; + to= ptr; + for (uint i=int_part-length ; i-- > 0 ;) + *to++ = fyllchar; + memcpy(to,buff,length); + if (dec) { - char fyllchar = zerofill ? (char) '0' : (char) ' '; - char *to=ptr; - for (uint i=int_part-length ; i-- > 0 ;) - *to++ = fyllchar; - memcpy(to,buff,length); - if (dec) - { - to[length]='.'; - bfill(to+length+1,dec,'0'); - } - return 0; + to[length]='.'; + bfill(to+length+1,dec,'0'); } + return 0; } @@ -2482,13 +2483,13 @@ int Field_new_decimal::store(double nr) } -int Field_new_decimal::store(longlong nr) +int Field_new_decimal::store(longlong nr, bool unsigned_val) { my_decimal decimal_value; int err; if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, - nr, FALSE, &decimal_value))) + nr, unsigned_val, &decimal_value))) { if (check_overflow(err)) set_value_on_overflow(&decimal_value, decimal_value.sign()); @@ -2663,18 +2664,20 @@ int Field_tiny::store(double nr) return error; } -int Field_tiny::store(longlong nr) + +int Field_tiny::store(longlong nr, bool unsigned_val) { int error= 0; + if (unsigned_flag) { - if (nr < 0L) + if (nr < 0 && !unsigned_val) { - *ptr=0; + *ptr= 0; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; } - else if (nr > 255L) + else if ((ulonglong) nr > (ulonglong) 255) { *ptr= (char) 255; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); @@ -2685,13 +2688,15 @@ int Field_tiny::store(longlong nr) } else { - if (nr < -128L) + if (nr < 0 && unsigned_val) + nr= 256; // Generate overflow + if (nr < -128) { *ptr= (char) -128; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; } - else if (nr > 127L) + else if (nr > 127) { *ptr=127; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); @@ -2711,6 +2716,7 @@ double Field_tiny::val_real(void) return (double) tmp; } + longlong Field_tiny::val_int(void) { int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] : @@ -2718,6 +2724,7 @@ longlong Field_tiny::val_int(void) return (longlong) tmp; } + String *Field_tiny::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { @@ -2877,19 +2884,21 @@ int Field_short::store(double nr) return error; } -int Field_short::store(longlong nr) + +int Field_short::store(longlong nr, bool unsigned_val) { int error= 0; int16 res; + if (unsigned_flag) { - if (nr < 0L) + if (nr < 0L && !unsigned_val) { res=0; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; } - else if (nr > (longlong) UINT_MAX16) + else if ((ulonglong) nr > (ulonglong) UINT_MAX16) { res=(int16) UINT_MAX16; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); @@ -2900,13 +2909,16 @@ int Field_short::store(longlong nr) } else { + if (nr < 0 && unsigned_val) + nr= UINT_MAX16+1; // Generate overflow + if (nr < INT_MIN16) { res=INT_MIN16; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; } - else if (nr > INT_MAX16) + else if (nr > (longlong) INT_MAX16) { res=INT_MAX16; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); @@ -3134,20 +3146,22 @@ int Field_medium::store(double nr) return error; } -int Field_medium::store(longlong nr) + +int Field_medium::store(longlong nr, bool unsigned_val) { int error= 0; + if (unsigned_flag) { - if (nr < 0L) + if (nr < 0 && !unsigned_val) { int3store(ptr,0); set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; } - else if (nr >= (longlong) (long) (1L << 24)) + else if ((ulonglong) nr >= (ulonglong) (long) (1L << 24)) { - long tmp=(long) (1L << 24)-1L;; + long tmp= (long) (1L << 24)-1L; int3store(ptr,tmp); set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; @@ -3157,9 +3171,12 @@ int Field_medium::store(longlong nr) } else { + if (nr < 0 && unsigned_val) + nr= (ulonglong) (long) (1L << 24); // Generate overflow + if (nr < (longlong) INT_MIN24) { - long tmp=(long) INT_MIN24; + long tmp= (long) INT_MIN24; int3store(ptr,tmp); set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); error= 1; @@ -3397,7 +3414,7 @@ int Field_long::store(double nr) } -int Field_long::store(longlong nr) +int Field_long::store(longlong nr, bool unsigned_val) { int error= 0; int32 res; @@ -3405,12 +3422,12 @@ int Field_long::store(longlong nr) if (unsigned_flag) { - if (nr < 0) + if (nr < 0 && !unsigned_val) { res=0; error= 1; } - else if (nr >= (LL(1) << 32)) + else if ((ulonglong) nr >= (LL(1) << 32)) { res=(int32) (uint32) ~0L; error= 1; @@ -3420,7 +3437,9 @@ int Field_long::store(longlong nr) } else { - if (nr < (longlong) INT_MIN32) + if (nr < 0 && unsigned_val) + nr= INT_MAX32+1; // Generate overflow + if (nr < (longlong) INT_MIN32) { res=(int32) INT_MIN32; error= 1; @@ -3657,8 +3676,24 @@ int Field_longlong::store(double nr) } -int Field_longlong::store(longlong nr) +int Field_longlong::store(longlong nr, bool unsigned_val) { + int error= 0; + + if (nr < 0) // Only possible error + { + /* + if field is unsigned and value is signed (< 0) or + if field is signed and value is unsigned we have an overflow + */ + if (unsigned_flag != unsigned_val) + { + nr= unsigned_flag ? (ulonglong) 0 : (ulonglong) LONGLONG_MAX; + set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); + error= 1; + } + } + #ifdef WORDS_BIGENDIAN if (table->s->db_low_byte_first) { @@ -3667,7 +3702,7 @@ int Field_longlong::store(longlong nr) else #endif longlongstore(ptr,nr); - return 0; + return error; } @@ -3886,11 +3921,12 @@ int Field_float::store(double nr) } -int Field_float::store(longlong nr) +int Field_float::store(longlong nr, bool unsigned_val) { - return store((double)nr); + return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr); } + double Field_float::val_real(void) { float j; @@ -4166,11 +4202,12 @@ int Field_double::store(double nr) } -int Field_double::store(longlong nr) +int Field_double::store(longlong nr, bool unsigned_val) { - return store((double)nr); + return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr); } + int Field_real::store_decimal(const my_decimal *dm) { double dbl; @@ -4529,12 +4566,12 @@ int Field_timestamp::store(double nr) nr= 0; // Avoid overflow on buff error= 1; } - error|= Field_timestamp::store((longlong) rint(nr)); + error|= Field_timestamp::store((longlong) rint(nr), FALSE); return error; } -int Field_timestamp::store(longlong nr) +int Field_timestamp::store(longlong nr, bool unsigned_val) { TIME l_time; my_time_t timestamp= 0; @@ -4829,7 +4866,7 @@ int Field_time::store(const char *from,uint len,CHARSET_INFO *cs) if (ltime.neg) tmp= -tmp; - error |= Field_time::store((longlong) tmp); + error |= Field_time::store((longlong) tmp, FALSE); return error; } @@ -4881,21 +4918,21 @@ int Field_time::store(double nr) } -int Field_time::store(longlong nr) +int Field_time::store(longlong nr, bool unsigned_val) { long tmp; int error= 0; - if (nr > (longlong) 8385959L) + if (nr < (longlong) -8385959L && !unsigned_val) { - tmp=8385959L; + tmp= -8385959L; set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME, 1); error= 1; } - else if (nr < (longlong) -8385959L) + else if (nr > (longlong) 8385959 || nr < 0 && unsigned_val) { - tmp= -8385959L; + tmp=8385959L; set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME, 1); @@ -5076,18 +5113,18 @@ int Field_year::store(double nr) { if (nr < 0.0 || nr >= 2155.0) { - (void) Field_year::store((longlong) -1); + (void) Field_year::store((longlong) -1, FALSE); return 1; } - else - return Field_year::store((longlong) nr); + return Field_year::store((longlong) nr, FALSE); } -int Field_year::store(longlong nr) + +int Field_year::store(longlong nr, bool unsigned_val) { if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155) { - *ptr=0; + *ptr= 0; set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1); return 1; } @@ -5102,17 +5139,20 @@ int Field_year::store(longlong nr) return 0; } + bool Field_year::send_binary(Protocol *protocol) { ulonglong tmp= Field_year::val_int(); return protocol->store_short(tmp); } + double Field_year::val_real(void) { return (double) Field_year::val_int(); } + longlong Field_year::val_int(void) { int tmp= (int) ((uchar*) ptr)[0]; @@ -5123,6 +5163,7 @@ longlong Field_year::val_int(void) return (longlong) tmp; } + String *Field_year::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { @@ -5133,6 +5174,7 @@ String *Field_year::val_str(String *val_buffer, return val_buffer; } + void Field_year::sql_type(String &res) const { CHARSET_INFO *cs=res.charset(); @@ -5203,7 +5245,7 @@ int Field_date::store(double nr) } -int Field_date::store(longlong nr) +int Field_date::store(longlong nr, bool unsigned_val) { TIME not_used; int error; @@ -5262,6 +5304,7 @@ double Field_date::val_real(void) return (double) (uint32) j; } + longlong Field_date::val_int(void) { int32 j; @@ -5274,6 +5317,7 @@ longlong Field_date::val_int(void) return (longlong) (uint32) j; } + String *Field_date::val_str(String *val_buffer, String *val_ptr __attribute__((unused))) { @@ -5382,11 +5426,11 @@ int Field_newdate::store(double nr) WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE); return 1; } - return Field_newdate::store((longlong) rint(nr)); + return Field_newdate::store((longlong) rint(nr), FALSE); } -int Field_newdate::store(longlong nr) +int Field_newdate::store(longlong nr, bool unsigned_val) { TIME l_time; longlong tmp; @@ -5576,12 +5620,12 @@ int Field_datetime::store(double nr) nr= 0.0; error= 1; } - error|= Field_datetime::store((longlong) rint(nr)); + error|= Field_datetime::store((longlong) rint(nr), FALSE); return error; } -int Field_datetime::store(longlong nr) +int Field_datetime::store(longlong nr, bool unsigned_val) { TIME not_used; int error; @@ -5905,12 +5949,13 @@ int Field_str::store(double nr) } -int Field_string::store(longlong nr) +int Field_string::store(longlong nr, bool unsigned_val) { char buff[64]; int l; CHARSET_INFO *cs=charset(); - l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),-10,nr); + l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff), + unsigned_val ? 10 : -10, nr); return Field_string::store(buff,(uint)l,cs); } @@ -6234,14 +6279,16 @@ int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs) } -int Field_varstring::store(longlong nr) +int Field_varstring::store(longlong nr, bool unsigned_val) { char buff[64]; uint length; length= (uint) (field_charset->cset->longlong10_to_str)(field_charset, buff, sizeof(buff), - -10,nr); + (unsigned_val ? 10: + -10), + nr); return Field_varstring::store(buff, length, field_charset); } @@ -6859,13 +6906,17 @@ int Field_blob::store(double nr) } -int Field_blob::store(longlong nr) +int Field_blob::store(longlong nr, bool unsigned_val) { CHARSET_INFO *cs=charset(); - value.set(nr, cs); + if (unsigned_val) + value.set((ulonglong) nr, cs); + else + value.set(nr, cs); return Field_blob::store(value.ptr(), (uint) value.length(), cs); } + double Field_blob::val_real(void) { int not_used; @@ -7330,7 +7381,7 @@ int Field_geom::store(double nr) } -int Field_geom::store(longlong nr) +int Field_geom::store(longlong nr, bool unsigned_val) { my_message(ER_CANT_CREATE_GEOMETRY_OBJECT, ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0)); @@ -7483,14 +7534,14 @@ int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs) int Field_enum::store(double nr) { - return Field_enum::store((longlong) nr); + return Field_enum::store((longlong) nr, FALSE); } -int Field_enum::store(longlong nr) +int Field_enum::store(longlong nr, bool unsigned_val) { int error= 0; - if ((uint) nr > typelib->count || nr == 0) + if ((ulonglong) nr > typelib->count || nr == 0) { set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1); nr=0; @@ -7661,7 +7712,7 @@ int Field_set::store(const char *from,uint length,CHARSET_INFO *cs) } -int Field_set::store(longlong nr) +int Field_set::store(longlong nr, bool unsigned_val) { int error= 0; if ((ulonglong) nr > (ulonglong) (((longlong) 1 << typelib->count) - @@ -7881,11 +7932,11 @@ int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs) int Field_bit::store(double nr) { - return store((longlong) nr); + return store((longlong) nr, FALSE); } -int Field_bit::store(longlong nr) +int Field_bit::store(longlong nr, bool unsigned_val) { char buf[8]; @@ -8466,8 +8517,8 @@ create_field::create_field(Field *old_field,Field *orig_field) else interval=0; def=0; + if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) && - !old_field->is_real_null() && old_field->ptr && orig_field && (sql_type != FIELD_TYPE_TIMESTAMP || /* set def only if */ old_field->table->timestamp_field != old_field || /* timestamp field */ diff --git a/sql/field.h b/sql/field.h index 2b67ed3f599..632169868bc 100644 --- a/sql/field.h +++ b/sql/field.h @@ -97,7 +97,7 @@ public: /* Store functions returns 1 on overflow and -1 on fatal error */ virtual int store(const char *to,uint length,CHARSET_INFO *cs)=0; virtual int store(double nr)=0; - virtual int store(longlong nr)=0; + virtual int store(longlong nr, bool unsigned_val)=0; virtual int store_decimal(const my_decimal *d)=0; virtual int store_time(TIME *ltime, timestamp_type t_type); virtual double val_real(void)=0; @@ -357,7 +357,7 @@ public: Item_result result_type () const { return STRING_RESULT; } uint decimals() const { return NOT_FIXED_DEC; } int store(double nr); - int store(longlong nr)=0; + int store(longlong nr, bool unsigned_val)=0; int store_decimal(const my_decimal *); int store(const char *to,uint length,CHARSET_INFO *cs)=0; uint size_of() const { return sizeof(*this); } @@ -422,7 +422,7 @@ public: void reset(void); int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); double val_real(void); longlong val_int(void); String *val_str(String*,String *); @@ -464,7 +464,7 @@ public: void set_value_on_overflow(my_decimal *decimal_value, bool sign); int store(const char *to, uint length, CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store_decimal(const my_decimal *); double val_real(void); longlong val_int(void); @@ -497,7 +497,7 @@ public: { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=0; } double val_real(void); longlong val_int(void); @@ -533,7 +533,7 @@ public: { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;} int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=0; } double val_real(void); longlong val_int(void); @@ -564,7 +564,7 @@ public: { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; } double val_real(void); longlong val_int(void); @@ -600,7 +600,7 @@ public: { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; } double val_real(void); longlong val_int(void); @@ -638,7 +638,7 @@ public: { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; } double val_real(void); longlong val_int(void); @@ -674,7 +674,7 @@ public: enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { bzero(ptr,sizeof(float)); } double val_real(void); longlong val_int(void); @@ -708,7 +708,7 @@ public: enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { bzero(ptr,sizeof(double)); } double val_real(void); longlong val_int(void); @@ -737,7 +737,7 @@ public: int store(const char *to, uint length, CHARSET_INFO *cs) { null[0]=1; return 0; } int store(double nr) { null[0]=1; return 0; } - int store(longlong nr) { null[0]=1; return 0; } + int store(longlong nr, bool unsigned_val) { null[0]=1; return 0; } int store_decimal(const my_decimal *d) { null[0]=1; return 0; } void reset(void) {} double val_real(void) { return 0.0;} @@ -766,7 +766,7 @@ public: enum Item_result cmp_type () const { return INT_RESULT; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; } double val_real(void); longlong val_int(void); @@ -818,7 +818,7 @@ public: enum_field_types type() const { return FIELD_TYPE_YEAR;} int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); double val_real(void); longlong val_int(void); String *val_str(String*,String *); @@ -845,7 +845,7 @@ public: enum Item_result cmp_type () const { return INT_RESULT; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; } double val_real(void); longlong val_int(void); @@ -873,7 +873,7 @@ public: enum Item_result cmp_type () const { return INT_RESULT; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store_time(TIME *ltime, timestamp_type type); void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; } double val_real(void); @@ -909,7 +909,7 @@ public: int store_time(TIME *ltime, timestamp_type type); int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; } double val_real(void); longlong val_int(void); @@ -946,7 +946,7 @@ public: uint decimals() const { return DATETIME_DEC; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store_time(TIME *ltime, timestamp_type type); void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; } double val_real(void); @@ -990,7 +990,7 @@ public: bool zero_pack() const { return 0; } void reset(void) { charset()->cset->fill(charset(),ptr,field_length,' '); } int store(const char *to,uint length,CHARSET_INFO *charset); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */ double val_real(void); longlong val_int(void); @@ -1049,7 +1049,7 @@ public: uint32 pack_length() const { return (uint32) field_length+length_bytes; } uint32 key_length() const { return (uint32) field_length; } int store(const char *to,uint length,CHARSET_INFO *charset); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store(double nr) { return Field_str::store(nr); } /* QQ: To be deleted */ double val_real(void); longlong val_int(void); @@ -1106,7 +1106,7 @@ public: { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; } int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); double val_real(void); longlong val_int(void); String *val_str(String*,String *); @@ -1201,7 +1201,7 @@ public: void sql_type(String &str) const; int store(const char *to, uint length, CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store_decimal(const my_decimal *); void get_key_image(char *buff,uint length,imagetype type); uint size_of() const { return sizeof(*this); } @@ -1232,7 +1232,7 @@ public: enum ha_base_keytype key_type() const; int store(const char *to,uint length,CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); void reset() { bzero(ptr,packlength); } double val_real(void); longlong val_int(void); @@ -1268,8 +1268,8 @@ public: flags=(flags & ~ENUM_FLAG) | SET_FLAG; } int store(const char *to,uint length,CHARSET_INFO *charset); - int store(double nr) { return Field_set::store((longlong) nr); } - int store(longlong nr); + int store(double nr) { return Field_set::store((longlong) nr, FALSE); } + int store(longlong nr, bool unsigned_val); virtual bool zero_pack() const { return 1; } String *val_str(String*,String *); void sql_type(String &str) const; @@ -1296,7 +1296,7 @@ public: void reset(void) { bzero(ptr, field_length); } int store(const char *to, uint length, CHARSET_INFO *charset); int store(double nr); - int store(longlong nr); + int store(longlong nr, bool unsigned_val); int store_decimal(const my_decimal *); double val_real(void); longlong val_int(void); @@ -1342,7 +1342,8 @@ public: uint size_of() const { return sizeof(*this); } int store(const char *to, uint length, CHARSET_INFO *charset); int store(double nr) { return Field_bit::store(nr); } - int store(longlong nr) { return Field_bit::store(nr); } + int store(longlong nr, bool unsigned_val) + { return Field_bit::store(nr, unsigned_val); } void sql_type(String &str) const; }; diff --git a/sql/field_conv.cc b/sql/field_conv.cc index 40f3ff85c58..bbe2dbe5e9f 100644 --- a/sql/field_conv.cc +++ b/sql/field_conv.cc @@ -311,8 +311,9 @@ static void do_field_string(Copy_field *copy) static void do_field_int(Copy_field *copy) { - longlong value=copy->from_field->val_int(); - copy->to_field->store(value); + longlong value= copy->from_field->val_int(); + copy->to_field->store(value, + test(copy->from_field->flags & UNSIGNED_FLAG)); } static void do_field_real(Copy_field *copy) @@ -689,5 +690,5 @@ void field_conv(Field *to,Field *from) to->store_decimal(from->val_decimal(&buff)); } else - to->store(from->val_int()); + to->store(from->val_int(), test(from->flags & UNSIGNED_FLAG)); } diff --git a/sql/ha_federated.cc b/sql/ha_federated.cc index 96cb81fe3ec..5cc5b7aa32c 100644 --- a/sql/ha_federated.cc +++ b/sql/ha_federated.cc @@ -517,8 +517,27 @@ error: } +static int parse_url_error(FEDERATED_SHARE *share, TABLE *table, int error_num) +{ + char buf[table->s->connect_string.length+1]; + DBUG_ENTER("ha_federated parse_url_error"); + if (share->scheme) + { + DBUG_PRINT("info", + ("error: parse_url. Returning error code %d \ + freeing share->scheme %lx", error_num, share->scheme)); + my_free((gptr) share->scheme, MYF(0)); + share->scheme= 0; + } + + strnmov(buf, table->s->connect_string.str, table->s->connect_string.length+1); + buf[table->s->connect_string.length]= '\0'; + my_error(error_num, MYF(0), buf); + DBUG_RETURN(error_num); +} + /* - Parse connection info from table->s->comment + Parse connection info from table->s->connect_string SYNOPSIS parse_url() @@ -563,119 +582,106 @@ static int parse_url(FEDERATED_SHARE *share, TABLE *table, DBUG_ENTER("ha_federated::parse_url"); share->port= 0; - share->scheme= my_strdup(table->s->comment, MYF(0)); + DBUG_PRINT("info", ("Length %d \n", table->s->connect_string.length)); + DBUG_PRINT("info", ("String %.*s \n", table->s->connect_string.length, + table->s->connect_string.str)); + share->scheme= my_strdup_with_length(table->s->connect_string.str, + table->s->connect_string.length+1, + MYF(0)); + // Add a null for later termination of table name + share->scheme[table->s->connect_string.length]= 0; DBUG_PRINT("info",("parse_url alloced share->scheme %lx", share->scheme)); /* remove addition of null terminator and store length for each string in share */ - if ((share->username= strstr(share->scheme, "://"))) + if (!(share->username= strstr(share->scheme, "://"))) + goto error; + share->scheme[share->username - share->scheme]= '\0'; + + if (strcmp(share->scheme, "mysql") != 0) + goto error; + + share->username+= 3; + + if (!(share->hostname= strchr(share->username, '@'))) + goto error; + + share->username[share->hostname - share->username]= '\0'; + share->hostname++; + + if ((share->password= strchr(share->username, ':'))) { - share->scheme[share->username - share->scheme]= '\0'; - - if (strcmp(share->scheme, "mysql") != 0) - goto error; - - share->username+= 3; - - if ((share->hostname= strchr(share->username, '@'))) - { - share->username[share->hostname - share->username]= '\0'; - share->hostname++; - - if ((share->password= strchr(share->username, ':'))) - { - share->username[share->password - share->username]= '\0'; - share->password++; - share->username= share->username; - /* make sure there isn't an extra / or @ */ - if ((strchr(share->password, '/') || strchr(share->hostname, '@'))) - goto error; - /* - Found that if the string is: - user:@hostname:port/database/table - Then password is a null string, so set to NULL - */ - if ((share->password[0] == '\0')) - share->password= NULL; - } - else - share->username= share->username; - - /* make sure there isn't an extra / or @ */ - if ((strchr(share->username, '/')) || (strchr(share->hostname, '@'))) - goto error; - - if ((share->database= strchr(share->hostname, '/'))) - { - share->hostname[share->database - share->hostname]= '\0'; - share->database++; - - if ((share->sport= strchr(share->hostname, ':'))) - { - share->hostname[share->sport - share->hostname]= '\0'; - share->sport++; - if (share->sport[0] == '\0') - share->sport= NULL; - else - share->port= atoi(share->sport); - } - - if ((share->table_name= strchr(share->database, '/'))) - { - share->database[share->table_name - share->database]= '\0'; - share->table_name++; - } - else - goto error; - - share->table_name_length= strlen(share->table_name); - } - else - goto error; - /* make sure there's not an extra / */ - if ((strchr(share->table_name, '/'))) - goto error; - - if (share->hostname[0] == '\0') - share->hostname= NULL; - - if (!share->port) - { - if (strcmp(share->hostname, my_localhost) == 0) - share->socket= my_strdup(MYSQL_UNIX_ADDR, MYF(0)); - else - share->port= MYSQL_PORT; - } - - DBUG_PRINT("info", - ("scheme %s username %s password %s \ - hostname %s port %d database %s tablename %s\n", - share->scheme, share->username, share->password, - share->hostname, share->port, share->database, - share->table_name)); - } - else + share->username[share->password - share->username]= '\0'; + share->password++; + share->username= share->username; + /* make sure there isn't an extra / or @ */ + if ((strchr(share->password, '/') || strchr(share->hostname, '@'))) goto error; + /* + Found that if the string is: + user:@hostname:port/database/table + Then password is a null string, so set to NULL + */ + if ((share->password[0] == '\0')) + share->password= NULL; } else + share->username= share->username; + + /* make sure there isn't an extra / or @ */ + if ((strchr(share->username, '/')) || (strchr(share->hostname, '@'))) goto error; + if (!(share->database= strchr(share->hostname, '/'))) + goto error; + share->hostname[share->database - share->hostname]= '\0'; + share->database++; + + if ((share->sport= strchr(share->hostname, ':'))) + { + share->hostname[share->sport - share->hostname]= '\0'; + share->sport++; + if (share->sport[0] == '\0') + share->sport= NULL; + else + share->port= atoi(share->sport); + } + + if (!(share->table_name= strchr(share->database, '/'))) + goto error; + share->database[share->table_name - share->database]= '\0'; + share->table_name++; + + share->table_name_length= strlen(share->table_name); + + /* make sure there's not an extra / */ + if ((strchr(share->table_name, '/'))) + goto error; + + if (share->hostname[0] == '\0') + share->hostname= NULL; + + if (!share->port) + { + if (strcmp(share->hostname, my_localhost) == 0) + share->socket= my_strdup(MYSQL_UNIX_ADDR, MYF(0)); + else + share->port= MYSQL_PORT; + } + + DBUG_PRINT("info", + ("scheme %s username %s password %s \ + hostname %s port %d database %s tablename %s\n", + share->scheme, share->username, share->password, + share->hostname, share->port, share->database, + share->table_name)); + DBUG_RETURN(0); error: - if (share->scheme) - { - DBUG_PRINT("info", - ("error: parse_url. Returning error code %d \ - freeing share->scheme %lx", error_num, share->scheme)); - my_free((gptr) share->scheme, MYF(0)); - share->scheme= 0; - } - my_error(error_num, MYF(0), table->s->comment); - DBUG_RETURN(error_num); - + DBUG_RETURN(parse_url_error(share, table, error_num)); } @@ -1313,7 +1319,7 @@ static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table) &share, sizeof(*share), &tmp_table_name, tmp_table_name_length+ 1, &select_query, - query.length()+strlen(table->s->comment)+1, + query.length()+table->s->connect_string.length+1, NullS))) { pthread_mutex_unlock(&federated_mutex); @@ -1918,11 +1924,9 @@ int ha_federated::delete_row(const byte *buf) String delete_string(delete_buffer, sizeof(delete_buffer), &my_charset_bin); String data_string(data_buffer, sizeof(data_buffer), &my_charset_bin); - delete_string.length(0); - data_string.length(0); - DBUG_ENTER("ha_federated::delete_row"); + delete_string.length(0); delete_string.append(FEDERATED_DELETE); delete_string.append(FEDERATED_FROM); delete_string.append(FEDERATED_BTICK); @@ -1932,9 +1936,11 @@ int ha_federated::delete_row(const byte *buf) for (Field **field= table->field; *field; field++) { - delete_string.append((*field)->field_name); + Field *cur_field= *field; + data_string.length(0); + delete_string.append(cur_field->field_name); - if ((*field)->is_null()) + if (cur_field->is_null()) { delete_string.append(FEDERATED_IS); data_string.append(FEDERATED_NULL); @@ -1942,16 +1948,14 @@ int ha_federated::delete_row(const byte *buf) else { delete_string.append(FEDERATED_EQ); - (*field)->val_str(&data_string); - (*field)->quote_data(&data_string); + cur_field->val_str(&data_string); + cur_field->quote_data(&data_string); } delete_string.append(data_string); - data_string.length(0); - - if (*(field + 1)) - delete_string.append(FEDERATED_AND); + delete_string.append(FEDERATED_AND); } + delete_string.length(delete_string.length()-5); // Remove trailing AND delete_string.append(FEDERATED_LIMIT1); DBUG_PRINT("info", diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 146fbee93c8..ff631ac9db8 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -2332,7 +2332,8 @@ void ha_ndbcluster::unpack_record(byte* buf) DBUG_PRINT("info", ("bit field H'%.8X", (*value).rec->u_32_value())); ((Field_bit *) *field)->store((longlong) - (*value).rec->u_32_value()); + (*value).rec->u_32_value(), + FALSE); } else { @@ -2340,7 +2341,8 @@ void ha_ndbcluster::unpack_record(byte* buf) *(Uint32 *)(*value).rec->aRef(), *((Uint32 *)(*value).rec->aRef()+1))); ((Field_bit *) *field)->store((longlong) - (*value).rec->u_64_value()); } + (*value).rec->u_64_value(), TRUE); + } } } else diff --git a/sql/handler.cc b/sql/handler.cc index 3acca812a13..b3754891d05 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -1518,7 +1518,7 @@ bool handler::update_auto_increment() /* Mark that we should clear next_insert_id before next stmt */ thd->clear_next_insert_id= 1; - if (!table->next_number_field->store((longlong) nr)) + if (!table->next_number_field->store((longlong) nr, TRUE)) thd->insert_id((ulonglong) nr); else thd->insert_id(table->next_number_field->val_int()); diff --git a/sql/handler.h b/sql/handler.h index 811791a498b..f1f9ab904d1 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -209,6 +209,7 @@ enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED, #define HA_CREATE_USED_ROW_FORMAT (1L << 15) #define HA_CREATE_USED_COMMENT (1L << 16) #define HA_CREATE_USED_PASSWORD (1L << 17) +#define HA_CREATE_USED_CONNECTION (1L << 18) typedef ulonglong my_xid; // this line is the same as in log_event.h #define MYSQL_XID_PREFIX "MySQLXid" @@ -382,6 +383,7 @@ enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED, typedef struct st_ha_create_information { CHARSET_INFO *table_charset, *default_table_charset; + LEX_STRING connect_string; const char *comment,*password; const char *data_file_name, *index_file_name; const char *alias; diff --git a/sql/item.cc b/sql/item.cc index b2fce8c20ef..df57c301327 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -818,6 +818,8 @@ String *Item_splocal::val_str(String *sp) DBUG_ASSERT(fixed); Item *it= this_item(); String *ret= it->val_str(sp); + + null_value= it->null_value; /* This way we mark returned value of val_str as const, so that various functions (e.g. CONCAT) won't try to @@ -833,9 +835,12 @@ String *Item_splocal::val_str(String *sp) This is intended behaviour of Item_func_concat. Comments to Item_param class contain some more details on the topic. */ + + if (!ret) + return NULL; + str_value_ptr.set(ret->ptr(), ret->length(), ret->charset()); - null_value= it->null_value; return &str_value_ptr; } @@ -2345,7 +2350,7 @@ int Item_param::save_in_field(Field *field, bool no_conversions) switch (state) { case INT_VALUE: - return field->store(value.integer); + return field->store(value.integer, unsigned_flag); case REAL_VALUE: return field->store(value.real); case DECIMAL_VALUE: @@ -3899,7 +3904,7 @@ int Item::save_in_field(Field *field, bool no_conversions) if (null_value) return set_field_to_null_with_conversions(field, no_conversions); field->set_notnull(); - error=field->store(nr); + error=field->store(nr, unsigned_flag); } return error; } @@ -3915,12 +3920,10 @@ int Item_string::save_in_field(Field *field, bool no_conversions) return field->store(result->ptr(),result->length(),collation.collation); } + int Item_uint::save_in_field(Field *field, bool no_conversions) { - /* - TODO: To be fixed when wen have a - field->store(longlong, unsigned_flag) method - */ + /* Item_int::save_in_field handles both signed and unsigned. */ return Item_int::save_in_field(field, no_conversions); } @@ -3931,7 +3934,7 @@ int Item_int::save_in_field(Field *field, bool no_conversions) if (null_value) return set_field_to_null(field); field->set_notnull(); - return field->store(nr); + return field->store(nr, unsigned_flag); } @@ -4138,7 +4141,7 @@ int Item_hex_string::save_in_field(Field *field, bool no_conversions) else { longlong nr=val_int(); - error=field->store(nr); + error=field->store(nr, TRUE); // Assume hex numbers are unsigned } return error; } diff --git a/sql/item_sum.cc b/sql/item_sum.cc index 4f991615bfa..880ab4c8cb1 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -1614,7 +1614,7 @@ void Item_sum_hybrid::reset_field() else result_field->set_notnull(); } - result_field->store(nr); + result_field->store(nr, unsigned_flag); break; } case REAL_RESULT: @@ -1930,7 +1930,7 @@ Item_sum_hybrid::min_max_update_int_field() } else if (result_field->is_null(0)) result_field->set_null(); - result_field->store(old_nr); + result_field->store(old_nr, unsigned_flag); } diff --git a/sql/sp.cc b/sql/sp.cc index 016703662a5..271a5d3a4f8 100644 --- a/sql/sp.cc +++ b/sql/sp.cc @@ -223,7 +223,7 @@ db_find_routine_aux(THD *thd, int type, sp_name *name, TABLE *table) table->field[0]->store(name->m_db.str, name->m_db.length, &my_charset_bin); table->field[1]->store(name->m_name.str, name->m_name.length, &my_charset_bin); - table->field[2]->store((longlong) type); + table->field[2]->store((longlong) type, TRUE); key_copy(key, table->record[0], table->key_info, table->key_info->key_length); diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index 4127129576b..9cd19b8e8e6 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -1800,11 +1800,11 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo, USER_RESOURCES mqh= lex->mqh; if (mqh.specified_limits & USER_RESOURCES::QUERIES_PER_HOUR) - table->field[next_field]->store((longlong) mqh.questions); + table->field[next_field]->store((longlong) mqh.questions, TRUE); if (mqh.specified_limits & USER_RESOURCES::UPDATES_PER_HOUR) - table->field[next_field+1]->store((longlong) mqh.updates); + table->field[next_field+1]->store((longlong) mqh.updates, TRUE); if (mqh.specified_limits & USER_RESOURCES::CONNECTIONS_PER_HOUR) - table->field[next_field+2]->store((longlong) mqh.conn_per_hour); + table->field[next_field+2]->store((longlong) mqh.conn_per_hour, TRUE); if (table->s->fields >= 36 && (mqh.specified_limits & USER_RESOURCES::USER_CONNECTIONS)) table->field[next_field+3]->store((longlong) mqh.user_conn); @@ -2306,7 +2306,7 @@ static int replace_column_table(GRANT_TABLE *g_t, store_record(table,record[1]); // copy original row } - table->field[6]->store((longlong) get_rights_for_column(privileges)); + table->field[6]->store((longlong) get_rights_for_column(privileges), TRUE); if (old_row_exists) { @@ -2373,7 +2373,7 @@ static int replace_column_table(GRANT_TABLE *g_t, privileges&= ~rights; table->field[6]->store((longlong) - get_rights_for_column(privileges)); + get_rights_for_column(privileges), TRUE); table->field[4]->val_str(&column_name); grant_column = column_hash_search(g_t, column_name.ptr(), @@ -2492,8 +2492,8 @@ static int replace_table_table(THD *thd, GRANT_TABLE *grant_table, } table->field[4]->store(grantor,(uint) strlen(grantor), system_charset_info); - table->field[6]->store((longlong) store_table_rights); - table->field[7]->store((longlong) store_col_rights); + table->field[6]->store((longlong) store_table_rights, TRUE); + table->field[7]->store((longlong) store_col_rights, TRUE); rights=fix_rights_for_table(store_table_rights); col_rights=fix_rights_for_column(store_col_rights); @@ -2568,7 +2568,8 @@ static int replace_routine_table(THD *thd, GRANT_NAME *grant_name, table->field[3]->store(routine_name,(uint) strlen(routine_name), &my_charset_latin1); table->field[4]->store((longlong)(is_proc ? - TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION)); + TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION), + TRUE); store_record(table,record[1]); // store at pos 1 if (table->file->index_read_idx(table->record[0],0, @@ -2609,7 +2610,7 @@ static int replace_routine_table(THD *thd, GRANT_NAME *grant_name, } table->field[5]->store(grantor,(uint) strlen(grantor), &my_charset_latin1); - table->field[6]->store((longlong) store_proc_rights); + table->field[6]->store((longlong) store_proc_rights, TRUE); rights=fix_rights_for_procedure(store_proc_rights); if (old_row_exists) diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 766840e667c..ae500018822 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -1030,23 +1030,23 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list) SYNOPSIS open_table() - thd Thread context - table_list Open first table in list - refresh Pointer to memory that will be set to 1 if - we need to close all tables and reopen them - If this is a NULL pointer, then the is no version - number checking and the table is not put in the - thread-open-list - flags Bitmap of flags to modify how open works: - MYSQL_LOCK_IGNORE_FLUSH - Open table even if someone - has done a flush or namelock on it. + thd Thread context. + table_list Open first table in list. + refresh INOUT Pointer to memory that will be set to 1 if + we need to close all tables and reopen them. + If this is a NULL pointer, then the table is not + put in the thread-open-list. + flags Bitmap of flags to modify how open works: + MYSQL_LOCK_IGNORE_FLUSH - Open table even if + someone has done a flush or namelock on it. + No version number checking is done. IMPLEMENTATION Uses a cache of open tables to find a table not in use. RETURN NULL Open failed. If refresh is set then one should close - all other tables and retry the open + all other tables and retry the open. # Success. Pointer to TABLE object for open table. */ @@ -1201,10 +1201,12 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, if (!thd->open_tables) thd->version=refresh_version; - else if (thd->version != refresh_version && refresh) + else if ((thd->version != refresh_version) && + ! (flags & MYSQL_LOCK_IGNORE_FLUSH)) { /* Someone did a refresh while thread was opening tables */ - *refresh=1; + if (refresh) + *refresh=1; VOID(pthread_mutex_unlock(&LOCK_open)); DBUG_RETURN(0); } @@ -2648,10 +2650,15 @@ find_field_in_view(THD *thd, TABLE_LIST *table_list, *ref != NULL means that *ref contains the item that we need to replace. If the item was aliased by the user, set the alias to the replacing item. + We need to set alias on both ref itself and on ref real item. */ if (*ref && !(*ref)->is_autogenerated_name) + { item->set_name((*ref)->name, (*ref)->name_length, system_charset_info); + item->real_item()->set_name((*ref)->name, (*ref)->name_length, + system_charset_info); + } if (register_tree_change) thd->change_item_tree(ref, item); else diff --git a/sql/sql_help.cc b/sql/sql_help.cc index 799758f7d1e..f4d835541cf 100644 --- a/sql/sql_help.cc +++ b/sql/sql_help.cc @@ -289,7 +289,7 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations, topics->file->ha_index_init(iindex_topic); relations->file->ha_index_init(iindex_relations); - rkey_id->store((longlong) key_id); + rkey_id->store((longlong) key_id, TRUE); rkey_id->get_key_image(buff, rkey_id->pack_length(), Field::itRAW); int key_res= relations->file->index_read(relations->record[0], (byte *)buff, rkey_id->pack_length(), @@ -302,7 +302,7 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations, char topic_id_buff[8]; longlong topic_id= rtopic_id->val_int(); Field *field= find_fields[help_topic_help_topic_id].field; - field->store((longlong) topic_id); + field->store((longlong) topic_id, TRUE); field->get_key_image(topic_id_buff, field->pack_length(), Field::itRAW); if (!topics->file->index_read(topics->record[0], (byte *)topic_id_buff, diff --git a/sql/sql_show.cc b/sql/sql_show.cc index fa4b5d314ff..80361e0ed11 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -2271,7 +2271,7 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, } tmp_buff= file->table_type(); table->field[4]->store(tmp_buff, strlen(tmp_buff), cs); - table->field[5]->store((longlong) share->frm_version); + table->field[5]->store((longlong) share->frm_version, TRUE); enum row_type row_type = file->get_row_type(); switch (row_type) { case ROW_TYPE_NOT_USED: @@ -2300,7 +2300,7 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, table->field[6]->store(tmp_buff, strlen(tmp_buff), cs); if (!tables->schema_table) { - table->field[7]->store((longlong) file->records); + table->field[7]->store((longlong) file->records, TRUE); table->field[7]->set_notnull(); } table->field[8]->store((longlong) file->mean_rec_length); @@ -2313,7 +2313,7 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, table->field[12]->store((longlong) file->delete_length); if (show_table->found_next_number_field) { - table->field[13]->store((longlong) file->auto_increment_value); + table->field[13]->store((longlong) file->auto_increment_value, TRUE); table->field[13]->set_notnull(); } if (file->create_time) @@ -2341,7 +2341,7 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, table->field[17]->store(tmp_buff, strlen(tmp_buff), cs); if (file->table_flags() & (ulong) HA_HAS_CHECKSUM) { - table->field[18]->store((longlong) file->checksum()); + table->field[18]->store((longlong) file->checksum(), TRUE); table->field[18]->set_notnull(); } @@ -2492,7 +2492,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, table->field[2]->store(file_name, file_name_length, cs); table->field[3]->store(field->field_name, strlen(field->field_name), cs); - table->field[4]->store((longlong) count); + table->field[4]->store((longlong) count, TRUE); field->sql_type(type); table->field[14]->store(type.ptr(), type.length(), cs); tmp_buff= strchr(type.ptr(), '('); @@ -2536,7 +2536,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, { longlong c_octet_len= is_blob ? (longlong) field->max_length() : (longlong) field->max_length()/field->charset()->mbmaxlen; - table->field[8]->store(c_octet_len); + table->field[8]->store(c_octet_len, TRUE); table->field[8]->set_notnull(); table->field[9]->store((longlong) field->max_length()); table->field[9]->set_notnull(); @@ -2584,7 +2584,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, } if (decimals >= 0) { - table->field[11]->store((longlong) decimals); + table->field[11]->store((longlong) decimals, TRUE); table->field[11]->set_notnull(); } @@ -2640,7 +2640,7 @@ int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond) table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs); comment= tmp_cs->comment ? tmp_cs->comment : ""; table->field[2]->store(comment, strlen(comment), scs); - table->field[3]->store((longlong) tmp_cs->mbmaxlen); + table->field[3]->store((longlong) tmp_cs->mbmaxlen, TRUE); if (schema_table_store_record(thd, table)) return 1; } @@ -2675,12 +2675,12 @@ int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond) restore_record(table, s->default_values); table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs); table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs); - table->field[2]->store((longlong) tmp_cl->number); + table->field[2]->store((longlong) tmp_cl->number, TRUE); tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : ""; table->field[3]->store(tmp_buff, strlen(tmp_buff), scs); tmp_buff= (tmp_cl->state & MY_CS_COMPILED)? "Yes" : ""; table->field[4]->store(tmp_buff, strlen(tmp_buff), scs); - table->field[5]->store((longlong) tmp_cl->strxfrm_multiply); + table->field[5]->store((longlong) tmp_cl->strxfrm_multiply, TRUE); if (schema_table_store_record(thd, table)) return 1; } @@ -2881,10 +2881,10 @@ static int get_schema_stat_record(THD *thd, struct st_table_list *tables, table->field[1]->store(base_name, strlen(base_name), cs); table->field[2]->store(file_name, strlen(file_name), cs); table->field[3]->store((longlong) ((key_info->flags & - HA_NOSAME) ? 0 :1)); + HA_NOSAME) ? 0 : 1), TRUE); table->field[4]->store(base_name, strlen(base_name), cs); table->field[5]->store(key_info->name, strlen(key_info->name), cs); - table->field[6]->store((longlong) (j+1)); + table->field[6]->store((longlong) (j+1), TRUE); str=(key_part->field ? key_part->field->field_name : "?unknown field?"); table->field[7]->store(str, strlen(str), cs); @@ -2900,7 +2900,7 @@ static int get_schema_stat_record(THD *thd, struct st_table_list *tables, { ha_rows records=(show_table->file->records / key->rec_per_key[j]); - table->field[9]->store((longlong) records); + table->field[9]->store((longlong) records, TRUE); table->field[9]->set_notnull(); } if (!(key_info->flags & HA_FULLTEXT) && @@ -3139,7 +3139,7 @@ void store_key_column_usage(TABLE *table, const char*db, const char *tname, table->field[4]->store(db, strlen(db), cs); table->field[5]->store(tname, strlen(tname), cs); table->field[6]->store(con_type, con_len, cs); - table->field[7]->store((longlong) idx); + table->field[7]->store((longlong) idx, TRUE); } @@ -3211,7 +3211,7 @@ static int get_schema_key_column_usage_record(THD *thd, f_key_info->forein_id->length, f_info->str, f_info->length, (longlong) f_idx); - table->field[8]->store((longlong) f_idx); + table->field[8]->store((longlong) f_idx, TRUE); table->field[8]->set_notnull(); table->field[9]->store(f_key_info->referenced_db->str, f_key_info->referenced_db->length, @@ -3249,8 +3249,8 @@ int fill_open_tables(THD *thd, TABLE_LIST *tables, COND *cond) restore_record(table, s->default_values); table->field[0]->store(open_list->db, strlen(open_list->db), cs); table->field[1]->store(open_list->table, strlen(open_list->table), cs); - table->field[2]->store((longlong) open_list->in_use); - table->field[3]->store((longlong) open_list->locked); + table->field[2]->store((longlong) open_list->in_use, TRUE); + table->field[3]->store((longlong) open_list->locked, TRUE); if (schema_table_store_record(thd, table)) DBUG_RETURN(1); } diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 611ab0f16aa..1b97de441e7 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -1712,6 +1712,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, DBUG_ENTER("create_table_from_items"); tmp_table.alias= 0; + tmp_table.timestamp_field= 0; tmp_table.s= &tmp_table.share_not_to_be_used; tmp_table.s->db_create_options=0; tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr; @@ -1756,7 +1757,8 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, create_info, *extra_fields, *keys, 0, select_field_count)) { - if (!(table= open_table(thd, create_table, thd->mem_root, (bool*)0, 0))) + if (! (table= open_table(thd, create_table, thd->mem_root, (bool*) 0, + MYSQL_LOCK_IGNORE_FLUSH))) quick_rm_table(create_info->db_type, create_table->db, table_case_name(create_info, create_table->table_name)); } @@ -3579,7 +3581,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, bzero((void*) &tbl, sizeof(tbl)); tbl.db= new_db; tbl.table_name= tbl.alias= tmp_name; - new_table= open_table(thd, &tbl, thd->mem_root, 0, 0); + new_table= open_table(thd, &tbl, thd->mem_root, (bool*) 0, + MYSQL_LOCK_IGNORE_FLUSH); } else { diff --git a/sql/sql_udf.cc b/sql/sql_udf.cc index e0c3034a58a..ba3c598a784 100644 --- a/sql/sql_udf.cc +++ b/sql/sql_udf.cc @@ -472,10 +472,10 @@ int mysql_create_function(THD *thd,udf_func *udf) restore_record(table, s->default_values); // Default values for fields table->field[0]->store(u_d->name.str, u_d->name.length, system_charset_info); - table->field[1]->store((longlong) u_d->returns); + table->field[1]->store((longlong) u_d->returns, TRUE); table->field[2]->store(u_d->dl,(uint) strlen(u_d->dl), system_charset_info); if (table->s->fields >= 4) // If not old func format - table->field[3]->store((longlong) u_d->type); + table->field[3]->store((longlong) u_d->type, TRUE); error = table->file->write_row(table->record[0]); close_thread_tables(thd); diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 104f9ca8445..538086b2b4f 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -2691,6 +2691,7 @@ create_table_option: | INSERT_METHOD opt_equal merge_insert_types { Lex->create_info.merge_insert_method= $3; Lex->create_info.used_fields|= HA_CREATE_USED_INSERT_METHOD;} | DATA_SYM DIRECTORY_SYM opt_equal TEXT_STRING_sys { Lex->create_info.data_file_name= $4.str; Lex->create_info.used_fields|= HA_CREATE_USED_DATADIR; } | INDEX_SYM DIRECTORY_SYM opt_equal TEXT_STRING_sys { Lex->create_info.index_file_name= $4.str; Lex->create_info.used_fields|= HA_CREATE_USED_INDEXDIR; } + | CONNECTION_SYM opt_equal TEXT_STRING_sys { Lex->create_info.connect_string.str= $3.str; Lex->create_info.connect_string.length= $3.length; Lex->create_info.used_fields|= HA_CREATE_USED_CONNECTION; } ; default_charset: diff --git a/sql/table.cc b/sql/table.cc index 9d681141b1b..6ac5e07daf1 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -71,7 +71,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, uint rec_buff_length,n_length,int_length,records,key_parts,keys, interval_count,interval_parts,read_length,db_create_options; uint key_info_length, com_length; - ulong pos; + ulong pos, record_offset; char index_file[FN_REFLEN], *names, *keynames, *comment_pos; uchar head[288],*disk_buff,new_field_pack_flag; my_string record; @@ -321,11 +321,12 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, rec_buff_length * records))) goto err; /* purecov: inspected */ share->default_values= (byte *) record; + + record_offset= (ulong) (uint2korr(head+6)+ + ((uint2korr(head+14) == 0xffff ? + uint4korr(head+47) : uint2korr(head+14)))); if (my_pread(file,(byte*) record, (uint) share->reclength, - (ulong) (uint2korr(head+6)+ - ((uint2korr(head+14) == 0xffff ? - uint4korr(head+47) : uint2korr(head+14)))), - MYF(MY_NABP))) + record_offset, MYF(MY_NABP))) goto err; /* purecov: inspected */ if (records == 1) @@ -342,6 +343,19 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, outparam->record[1]= outparam->record[0]; // Safety } + if ((n_length= uint2korr(head+55))) + { + /* Read extra block information */ + char *buff; + if (!(buff= alloc_root(&outparam->mem_root, n_length))) + goto err; + if (my_pread(file, buff, n_length, record_offset + share->reclength, + MYF(MY_NABP))) + goto err; + share->connect_string.length= uint2korr(buff); + share->connect_string.str= buff+2; + } + #ifdef HAVE_purify /* We need this because when we read var-length rows, we are not updating @@ -1350,10 +1364,15 @@ File create_frm(THD *thd, my_string name, const char *db, ulong length; char fill[IO_SIZE]; int create_flags= O_RDWR | O_TRUNC; + uint extra_size; if (create_info->options & HA_LEX_CREATE_TMP_TABLE) create_flags|= O_EXCL | O_NOFOLLOW; + extra_size= 0; + if (create_info->connect_string.length) + extra_size= 2+create_info->connect_string.length; + #if SIZEOF_OFF_T > 4 /* Fix this when we have new .frm files; Current limit is 4G rows (QQ) */ if (create_info->max_rows > ~(ulong) 0) @@ -1381,7 +1400,7 @@ File create_frm(THD *thd, my_string name, const char *db, fileinfo[4]=1; int2store(fileinfo+6,IO_SIZE); /* Next block starts here */ key_length=keys*(7+NAME_LEN+MAX_REF_PARTS*9)+16; - length=(ulong) next_io_size((ulong) (IO_SIZE+key_length+reclength)); + length= next_io_size((ulong) (IO_SIZE+key_length+reclength+extra_size)); int4store(fileinfo+10,length); tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff; int2store(fileinfo+14,tmp_key_length); @@ -1403,6 +1422,7 @@ File create_frm(THD *thd, my_string name, const char *db, int4store(fileinfo+47, key_length); tmp= MYSQL_VERSION_ID; // Store to avoid warning from int4store int4store(fileinfo+51, tmp); + int2store(fileinfo+55, extra_size); bzero(fill,IO_SIZE); for (; length > IO_SIZE ; length-= IO_SIZE) { diff --git a/sql/table.h b/sql/table.h index 49104c9c1ff..659986f5b10 100644 --- a/sql/table.h +++ b/sql/table.h @@ -126,6 +126,7 @@ typedef struct st_table_share const char *db; /* Pointer to db */ const char *table_name; /* Table name (for open) */ const char *path; /* Path to .frm file (from datadir) */ + LEX_STRING connect_string; key_map keys_in_use; /* Keys in use for table */ key_map keys_for_keyread; ulong avg_row_length; /* create information */ diff --git a/sql/tztime.cc b/sql/tztime.cc index 5a907f0d170..537050e94db 100644 --- a/sql/tztime.cc +++ b/sql/tztime.cc @@ -1826,7 +1826,7 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables) */ table= tz_tables->table; tz_tables= tz_tables->next_local; - table->field[0]->store((longlong)tzid); + table->field[0]->store((longlong) tzid, TRUE); (void)table->file->ha_index_init(0); if (table->file->index_read(table->record[0], (byte*)table->field[0]->ptr, @@ -1853,7 +1853,7 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables) */ table= tz_tables->table; tz_tables= tz_tables->next_local; - table->field[0]->store((longlong)tzid); + table->field[0]->store((longlong) tzid, TRUE); (void)table->file->ha_index_init(0); // FIXME Is there any better approach than explicitly specifying 4 ??? @@ -1925,7 +1925,7 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables) in ascending order by index scan also satisfies us. */ table= tz_tables->table; - table->field[0]->store((longlong)tzid); + table->field[0]->store((longlong) tzid, TRUE); (void)table->file->ha_index_init(0); // FIXME Is there any better approach than explicitly specifying 4 ??? diff --git a/sql/unireg.cc b/sql/unireg.cc index a89d89426a6..1ac8be0f49a 100644 --- a/sql/unireg.cc +++ b/sql/unireg.cc @@ -149,6 +149,15 @@ bool mysql_create_frm(THD *thd, my_string file_name, if (make_empty_rec(thd,file,create_info->db_type,create_info->table_options, create_fields,reclength, data_offset)) goto err; + if (create_info->connect_string.length) + { + char buff[2]; + int2store(buff,create_info->connect_string.length); + if (my_write(file, buff, sizeof(buff), MYF(MY_NABP)) || + my_write(file, create_info->connect_string.str, + create_info->connect_string.length, MYF(MY_NABP))) + goto err; + } VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0))); if (my_write(file,(byte*) forminfo,288,MYF_RW) || @@ -754,7 +763,7 @@ static bool make_empty_rec(THD *thd, File file,enum db_type table_type, (field->flags & NOT_NULL_FLAG)) { regfield->set_notnull(); - regfield->store((longlong) 1); + regfield->store((longlong) 1, TRUE); } else if (type == Field::YES) // Old unireg type regfield->store(ER(ER_YES),(uint) strlen(ER(ER_YES)),system_charset_info);