Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB

10.5-circular-buffer
Alexander Barkov 6 years ago
parent
89bd5623b0
commit
6ea5c2b5b6
27 changed files with 4448 additions and 10 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 34
      plugin/type_inet/mysql-test/type_inet/binlog_stm_type_inet6.result
  2. 28
      plugin/type_inet/mysql-test/type_inet/binlog_stm_type_inet6.test
  3. 17
      plugin/type_inet/mysql-test/type_inet/rpl_type_inet6.result
  4. 16
      plugin/type_inet/mysql-test/type_inet/rpl_type_inet6.test
  5. 18
      plugin/type_inet/mysql-test/type_inet/type_inet6-debug.result
  6. 14
      plugin/type_inet/mysql-test/type_inet/type_inet6-debug.test
  7. 1276
      plugin/type_inet/mysql-test/type_inet/type_inet6.result
  8. 835
      plugin/type_inet/mysql-test/type_inet/type_inet6.test
  9. 38
      plugin/type_inet/mysql-test/type_inet/type_inet6_engines.inc
  10. 104
      plugin/type_inet/mysql-test/type_inet/type_inet6_innodb.result
  11. 18
      plugin/type_inet/mysql-test/type_inet/type_inet6_innodb.test
  12. 163
      plugin/type_inet/mysql-test/type_inet/type_inet6_memory.result
  13. 18
      plugin/type_inet/mysql-test/type_inet/type_inet6_memory.test
  14. 104
      plugin/type_inet/mysql-test/type_inet/type_inet6_myisam.result
  15. 18
      plugin/type_inet/mysql-test/type_inet/type_inet6_myisam.test
  16. 15
      plugin/type_inet/mysql-test/type_inet/type_inet6_mysql.result
  17. 6
      plugin/type_inet/mysql-test/type_inet/type_inet6_mysql.test
  18. 31
      plugin/type_inet/mysql-test/type_inet/type_inet6_plugin.result
  19. 27
      plugin/type_inet/mysql-test/type_inet/type_inet6_plugin.test
  20. 25
      plugin/type_inet/plugin.cc
  21. 933
      plugin/type_inet/sql_type_inet.cc
  22. 682
      plugin/type_inet/sql_type_inet.h
  23. 23
      sql/field.cc
  24. 10
      sql/field.h
  25. 2
      sql/opt_range.cc
  26. 1
      sql/opt_range.h
  27. 2
      storage/innobase/handler/ha_innodb.cc

34
plugin/type_inet/mysql-test/type_inet/binlog_stm_type_inet6.result
View File

@ -0,0 +1,34 @@
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::');
INSERT INTO t1 VALUES ('ffff::ffff');
PREPARE stmt FROM 'INSERT INTO t1 VALUES (?)';
EXECUTE stmt USING CAST('::1' AS INET6);
EXECUTE stmt USING CAST(CONCAT(REPEAT(0x00,15), 0x02) AS INET6);
DEALLOCATE PREPARE stmt;
BEGIN NOT ATOMIC
DECLARE a INET6 DEFAULT '::3';
INSERT INTO t1 VALUES (a);
END;
$$
DROP TABLE t1;
include/show_binlog_events.inc
Log_name Pos Event_type Server_id End_log_pos Info
master-bin.000001 # Gtid # # GTID #-#-#
master-bin.000001 # Query # # use `test`; CREATE TABLE t1 (a INET6)
master-bin.000001 # Gtid # # BEGIN GTID #-#-#
master-bin.000001 # Query # # use `test`; INSERT INTO t1 VALUES ('::')
master-bin.000001 # Query # # COMMIT
master-bin.000001 # Gtid # # BEGIN GTID #-#-#
master-bin.000001 # Query # # use `test`; INSERT INTO t1 VALUES ('ffff::ffff')
master-bin.000001 # Query # # COMMIT
master-bin.000001 # Gtid # # BEGIN GTID #-#-#
master-bin.000001 # Query # # use `test`; INSERT INTO t1 VALUES ('::1')
master-bin.000001 # Query # # COMMIT
master-bin.000001 # Gtid # # BEGIN GTID #-#-#
master-bin.000001 # Query # # use `test`; INSERT INTO t1 VALUES ('::2')
master-bin.000001 # Query # # COMMIT
master-bin.000001 # Gtid # # BEGIN GTID #-#-#
master-bin.000001 # Query # # use `test`; INSERT INTO t1 VALUES ( NAME_CONST('a','::3'))
master-bin.000001 # Query # # COMMIT
master-bin.000001 # Gtid # # GTID #-#-#
master-bin.000001 # Query # # use `test`; DROP TABLE `t1` /* generated by server */

28
plugin/type_inet/mysql-test/type_inet/binlog_stm_type_inet6.test
View File

@ -0,0 +1,28 @@
--source include/not_embedded.inc
--source include/have_binlog_format_statement.inc
--disable_query_log
reset master; # get rid of previous tests binlog
--enable_query_log
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::');
INSERT INTO t1 VALUES ('ffff::ffff');
PREPARE stmt FROM 'INSERT INTO t1 VALUES (?)';
EXECUTE stmt USING CAST('::1' AS INET6);
EXECUTE stmt USING CAST(CONCAT(REPEAT(0x00,15), 0x02) AS INET6);
DEALLOCATE PREPARE stmt;
DELIMITER $$;
BEGIN NOT ATOMIC
DECLARE a INET6 DEFAULT '::3';
INSERT INTO t1 VALUES (a);
END;
$$
DELIMITER ;$$
DROP TABLE t1;
--let $binlog_file = LAST
source include/show_binlog_events.inc;

17
plugin/type_inet/mysql-test/type_inet/rpl_type_inet6.result
View File

@ -0,0 +1,17 @@
include/master-slave.inc
[connection master]
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
connection master;
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('ffff::ffff');
connection slave;
SELECT HEX(a), a FROM t1;
HEX(a) a
00000000000000000000000000000000 ::
FFFF000000000000000000000000FFFF ffff::ffff
connection master;
DROP TABLE t1;
connection slave;
include/rpl_end.inc

16
plugin/type_inet/mysql-test/type_inet/rpl_type_inet6.test
View File

@ -0,0 +1,16 @@
--source include/master-slave.inc
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
connection master;
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('ffff::ffff');
sync_slave_with_master;
SELECT HEX(a), a FROM t1;
connection master;
DROP TABLE t1;
sync_slave_with_master;
--source include/rpl_end.inc

18
plugin/type_inet/mysql-test/type_inet/type_inet6-debug.result
View File

@ -0,0 +1,18 @@
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
SET @old_debug_dbug=@@debug_dbug;
SET debug_dbug="+d,frm_data_type_info";
CREATE TABLE t1 (c01 INET6, c02 INET6);
Warnings:
Note 1105 build_frm_image: Field data type info length: 14
Note 1105 DBUG: [0] name='c01' type_info='inet6'
Note 1105 DBUG: [1] name='c02' type_info='inet6'
SET debug_dbug=@old_debug_dbug;
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`c01` inet6 DEFAULT NULL,
`c02` inet6 DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1;

14
plugin/type_inet/mysql-test/type_inet/type_inet6-debug.test
View File

@ -0,0 +1,14 @@
--source include/have_debug.inc
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
SET @old_debug_dbug=@@debug_dbug;
SET debug_dbug="+d,frm_data_type_info";
CREATE TABLE t1 (c01 INET6, c02 INET6);
SET debug_dbug=@old_debug_dbug;
SHOW CREATE TABLE t1;
DROP TABLE t1;

1276
plugin/type_inet/mysql-test/type_inet/type_inet6.result
File diff suppressed because it is too large
View File

835
plugin/type_inet/mysql-test/type_inet/type_inet6.test
View File

@ -0,0 +1,835 @@
--echo #
--echo # Basic CREATE functionality, defaults, metadata
--echo #
--error ER_WRONG_FIELD_SPEC
CREATE TABLE t1 (a INET6 AUTO_INCREMENT);
CREATE TABLE t1 (a INET6);
SHOW CREATE TABLE t1;
DESCRIBE t1;
--vertical_results
--replace_column 19 #
SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema='test' AND table_name='t1';
--horizontal_results
DROP TABLE t1;
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::1');
--enable_metadata
SELECT * FROM t1;
SELECT CAST('::' AS INET6) AS a;
--disable_metadata
DROP TABLE t1;
CREATE TABLE t1 (
c1 INET6 DEFAULT 0x00000000000000000000000000000000,
c2 INET6 DEFAULT 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
c3 INET6 DEFAULT '::',
c4 INET6 DEFAULT 'FFFF::ffff',
c5 INET6 DEFAULT CAST(X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' AS INET6)
);
SHOW CREATE TABLE t1;
DESCRIBE t1;
--vertical_results
--replace_column 19 #
SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema='test' AND table_name='t1';
--horizontal_results
DROP TABLE t1;
--error ER_INVALID_DEFAULT
CREATE TABLE t1 (c1 INET6 DEFAULT 0x00);
--error ER_INVALID_DEFAULT
CREATE TABLE t1 (c1 INET6 DEFAULT '');
CREATE TABLE t1 (a INET6);
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t1 VALUES ('x');
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t1 VALUES (1);
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t1 VALUES (TIME'10:20:30');
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t1 VALUES (0x00);
DROP TABLE t1;
--echo #
--echo # CAST
--echo #
SELECT CAST('garbage' AS INET6);
SELECT CAST(0x01 AS INET6);
SELECT CAST(REPEAT(0x00,16) AS INET6);
SELECT CAST(REPEAT(0x11,16) AS INET6);
CREATE TABLE t1 AS SELECT CAST('::' AS INET6);
SHOW CREATE TABLE t1;
DROP TABLE t1;
--echo #
--echo # Text and binary formats, comparison operators
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES (0x00000000000000000000000000000000);
INSERT INTO t1 VALUES (0x00000000000000000000000000000001);
INSERT INTO t1 VALUES (0xFFFF0000000000000000000000000001);
INSERT INTO t1 VALUES (0xFFFF0000000000000000000000000002);
SELECT * FROM t1 ORDER BY a;
SELECT * FROM t1 ORDER BY a DESC;
SELECT HEX(a),a FROM t1 ORDER BY a;
SELECT * FROM t1 WHERE a='::';
SELECT * FROM t1 WHERE a='::1';
SELECT * FROM t1 WHERE a='ffff::1';
SELECT * FROM t1 WHERE a='ffff::2';
SELECT * FROM t1 WHERE a=0x00000000000000000000000000000000;
SELECT * FROM t1 WHERE a=0x00000000000000000000000000000001;
SELECT * FROM t1 WHERE a=0xffff0000000000000000000000000001;
SELECT * FROM t1 WHERE a=0xffff0000000000000000000000000002;
SELECT * FROM t1 WHERE a<'::';
SELECT * FROM t1 WHERE a<='::';
SELECT * FROM t1 WHERE a>='ffff::2';
SELECT * FROM t1 WHERE a>'ffff::2';
SELECT * FROM t1 WHERE a IN ('::', 'ffff::1') ORDER BY a;
SELECT * FROM t1 WHERE a IN ('::', 0xffff0000000000000000000000000002) ORDER BY a;
SELECT * FROM t1 WHERE a<'garbage';
SELECT * FROM t1 WHERE a<='garbage';
SELECT * FROM t1 WHERE a='garbage';
SELECT * FROM t1 WHERE a>='garbage';
SELECT * FROM t1 WHERE a>'garbage';
SELECT * FROM t1 WHERE a<0x01;
SELECT * FROM t1 WHERE a<=0x01;
SELECT * FROM t1 WHERE a=0x01;
SELECT * FROM t1 WHERE a>=0x01;
SELECT * FROM t1 WHERE a>0x01;
SELECT * FROM t1 WHERE a='0::0';
SELECT * FROM t1 WHERE a='0::00';
SELECT * FROM t1 WHERE a='0::000';
SELECT * FROM t1 WHERE a='0::0000';
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a=0;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a=0.0;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a=0e0;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a=TIME'10:20:30';
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a IN ('::', 10);
DROP TABLE t1;
--echo #
--echo # cmp_item_inet6: IN for non-constants
--echo #
CREATE TABLE t1 (a INET6, b INET6);
INSERT INTO t1 VALUES ('::1', '::2');
SELECT * FROM t1 WHERE '::' IN (a, b);
SELECT * FROM t1 WHERE '::1' IN (a, b);
SELECT * FROM t1 WHERE '::01' IN (a, b);
SELECT * FROM t1 WHERE '00::01' IN (a, b);
DROP TABLE t1;
--echo #
--echo # cmp_item_inet6: DECODE_ORACLE
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES (NULL),('::01'),('::02');
SELECT a, DECODE_ORACLE(a, '::01', '01') AS d FROM t1;
SELECT
a,
DECODE_ORACLE(a, '::01', '01') AS d0,
DECODE_ORACLE(a, NULL, '<NULL>', '::01', '01') AS d1,
DECODE_ORACLE(a, 'garbage', '<NULL>', '::01', '01') AS d2
FROM t1;
DROP TABLE t1;
--echo #
--echo # CASE abbreviations
--echo #
CREATE TABLE t1 (
c INET6,
c_char CHAR(32),
c_varchar VARCHAR(32),
c_tinytext TINYTEXT,
c_text TEXT,
c_mediumtext TEXT,
c_longtext LONGTEXT
);
CREATE TABLE t2 AS SELECT
COALESCE(c, c_char),
COALESCE(c, c_varchar),
COALESCE(c, c_tinytext),
COALESCE(c, c_text),
COALESCE(c, c_mediumtext),
COALESCE(c, c_longtext)
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT
LEAST(c, c_char),
LEAST(c, c_varchar),
LEAST(c, c_tinytext),
LEAST(c, c_text),
LEAST(c, c_mediumtext),
LEAST(c, c_longtext)
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
DROP TABLE t1;
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES (NULL),('::1'),('::2');
SELECT COALESCE(a, '::') FROM t1 ORDER BY a;
SELECT a, LEAST(a,'::0'), LEAST(a,'::f') FROM t1 ORDER BY a;
SELECT a, GREATEST(a,'::0'), GREATEST(a,'::f') FROM t1 ORDER BY a;
CREATE TABLE t2 AS SELECT
COALESCE(a, '::'),
LEAST(a,'::'),
GREATEST(a,'::')
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
SELECT COALESCE(a, 0x00000000000000000000000000000000) FROM t1 ORDER BY a;
SELECT a,
LEAST(a, 0x00000000000000000000000000000000),
LEAST(a, 0x0000000000000000000000000000000f)
FROM t1 ORDER BY a;
SELECT a,
GREATEST(a, 0x00000000000000000000000000000000),
GREATEST(a, 0x0000000000000000000000000000000f)
FROM t1 ORDER BY a;
CREATE TABLE t2 AS SELECT
COALESCE(a, 0x00000000000000000000000000000000),
LEAST(a,0x00000000000000000000000000000000),
GREATEST(a,0x00000000000000000000000000000000)
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT COALESCE(a, 10) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT LEAST(a, 10) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT GREATEST(a, 10) FROM t1;
DROP TABLE t1;
SELECT COALESCE('garbage', CAST('::1' AS INET6));
SELECT COALESCE(0x01, CAST('::1' AS INET6));
--echo #
--echo # Uniqueness
--echo #
CREATE TABLE t1 (a INET6 NOT NULL PRIMARY KEY);
INSERT INTO t1 VALUES ('41::1'),('61::1');
--error ER_DUP_ENTRY
INSERT INTO t1 VALUES ('41::1');
SELECT * FROM t1;
DROP TABLE t1;
--echo #
--echo # Indexes
--echo #
--error ER_WRONG_SUB_KEY
CREATE TABLE t1 (a INET6, KEY(a(1)));
--echo #
--echo # Explicit CAST on INSERT
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES (CAST('1::1' AS INET6));
INSERT INTO t1 VALUES (CAST('1::2' AS INET6));
INSERT INTO t1 VALUES (CAST('1::3' AS INET6));
INSERT INTO t1 VALUES (CAST(CONCAT('2','::1') AS INET6));
INSERT INTO t1 VALUES (CAST(CONCAT('2','::2') AS INET6));
INSERT INTO t1 VALUES (CAST(CONCAT('2','::3') AS INET6));
SELECT * FROM t1 ORDER BY a;
DROP TABLE t1;
--echo #
--echo # Explicit CAST and implicit CAST on ALTER
--echo #
CREATE TABLE t1 (a VARCHAR(64));
INSERT INTO t1 VALUES ('garbage'),('::'),('::1'),('ffff::1'),('ffff::2');
SELECT a, CAST(a AS INET6) FROM t1 ORDER BY a;
SELECT a, CAST(a AS INET6) FROM t1 ORDER BY CAST(a AS INET6);
--error ER_TRUNCATED_WRONG_VALUE
ALTER TABLE t1 MODIFY a INET6;
SET sql_mode='';
ALTER TABLE t1 MODIFY a INET6;
SET sql_mode=DEFAULT;
SELECT * FROM t1 ORDER BY a;
DROP TABLE t1;
CREATE TABLE t1 (a BINARY(16));
INSERT INTO t1 VALUES (0x00000000000000000000000000000000);
INSERT INTO t1 VALUES (0x00000000000000000000000000000001);
INSERT INTO t1 VALUES (0xffff0000000000000000000000000001);
INSERT INTO t1 VALUES (0xffff0000000000000000000000000002);
SELECT HEX(a), CAST(a AS INET6) FROM t1 ORDER BY a;
ALTER TABLE t1 MODIFY a INET6;
SELECT * FROM t1 ORDER BY a;
DROP TABLE t1;
--echo #
--echo # INSERT..SELECT, same data types
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::1'),('::2');
CREATE TABLE t2 (a INET6);
INSERT INTO t2 SELECT a FROM t1;
SELECT * FROM t2;
DROP TABLE t1,t2;
--echo #
--echo # Implicit CAST on INSERT..SELECT, text format
--echo #
CREATE TABLE t1 (a VARCHAR(64));
INSERT INTO t1 VALUES ('garbage'),('::'),('::1'),('ffff::1'),('ffff::2');
CREATE TABLE t2 (a INET6);
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t2 SELECT a FROM t1;
SET sql_mode='';
INSERT INTO t2 SELECT a FROM t1;
SELECT * FROM t2 ORDER BY a;
SET sql_mode=DEFAULT;
DROP TABLE t2;
CREATE TABLE t2 (a INET6 NOT NULL);
--error ER_TRUNCATED_WRONG_VALUE
INSERT INTO t2 SELECT a FROM t1;
SET sql_mode='';
INSERT INTO t2 SELECT a FROM t1;
SELECT * FROM t2 ORDER BY a;
SET sql_mode=DEFAULT;
DROP TABLE t2;
DROP TABLE t1;
--echo #
--echo # Implicit CAST on INSERT..SELECT, binary format
--echo #
CREATE TABLE t1 (a BINARY(16));
INSERT INTO t1 VALUES (0x00000000000000000000000000000000);
INSERT INTO t1 VALUES (0x00000000000000000000000000000001);
INSERT INTO t1 VALUES (0xffff0000000000000000000000000001);
INSERT INTO t1 VALUES (0xffff0000000000000000000000000002);
CREATE TABLE t2 (a INET6);
INSERT INTO t2 SELECT a FROM t1;
SELECT a FROM t2 ORDER BY a;
DROP TABLE t1,t2;
--echo #
--echo # CAST to other data types
--echo #
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS DOUBLE);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS DECIMAL);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS SIGNED);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS UNSIGNED);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS TIME);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS DATE);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CAST(CAST('::' AS INET6) AS DATETIME);
SELECT CAST(CAST('::' AS INET6) AS CHAR);
CREATE TABLE t1 AS SELECT CAST(CAST('::' AS INET6) AS CHAR) AS a;
SHOW CREATE TABLE t1;
DROP TABLE t1;
--echo #
--echo # Implicit conversion to other types in INSERT
--echo #
CREATE TABLE t1 (a INT);
--error ER_TRUNCATED_WRONG_VALUE_FOR_FIELD
INSERT INTO t1 VALUES (CAST('::' AS INET6));
DROP TABLE t1;
CREATE TABLE t1 (a DOUBLE);
--error ER_TRUNCATED_WRONG_VALUE_FOR_FIELD
INSERT INTO t1 VALUES (CAST('::' AS INET6));
DROP TABLE t1;
CREATE TABLE t1 (a DECIMAL(32,0));
--error ER_TRUNCATED_WRONG_VALUE_FOR_FIELD
INSERT INTO t1 VALUES (CAST('::' AS INET6));
DROP TABLE t1;
CREATE TABLE t1 (a VARCHAR(64));
INSERT INTO t1 VALUES (CAST('::' AS INET6));
DROP TABLE t1;
CREATE TABLE t1 (a TEXT);
INSERT INTO t1 VALUES (CAST('::' AS INET6));
DROP TABLE t1;
--echo #
--echo # Boolean context
--echo #
SELECT
CAST('::' AS INET6) IS TRUE,
CAST('::' AS INET6) IS FALSE,
CAST('::1' AS INET6) IS TRUE,
CAST('::1' AS INET6) IS FALSE;
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::1');
SELECT a, a IS TRUE, a IS FALSE FROM t1 ORDER BY a;
DROP TABLE t1;
#
# TODO: Error looks like a bug. This should return rows where a<>'::'.
# The same problem is repeatable with GEOMETRY.
#
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::1'),('::2');
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT * FROM t1 WHERE a;
DROP TABLE t1;
--echo #
--echo # GROUP BY
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::');
INSERT INTO t1 VALUES ('::1'),('::01'),('::0001');
INSERT INTO t1 VALUES ('::2'),('::2'),('::2'),('::2');
SELECT a, COUNT(*) FROM t1 GROUP BY a;
DROP TABLE t1;
--echo #
--echo # Aggregate functions
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::');
INSERT INTO t1 VALUES ('::1'),('::01'),('::0001');
INSERT INTO t1 VALUES ('::2'),('::2'),('::2'),('::2');
SELECT MIN(a),MAX(a) FROM t1;
CREATE TABLE t2 AS SELECT MIN(a), MAX(a) FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT AVG(a) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT AVG(DISTINCT a) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT SUM(a) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT SUM(DISTINCT a) FROM t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT STDDEV(a) FROM t1;
SELECT GROUP_CONCAT(a ORDER BY a) FROM t1;
SELECT a, GROUP_CONCAT(a ORDER BY a) FROM t1 GROUP BY a;
DROP TABLE t1;
--echo #
--echo # Window functions
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::1'),('::2'),('::3'),('::4');
SELECT
a,
LAG(a) OVER (ORDER BY a),
LEAD(a) OVER (ORDER BY a)
FROM t1 ORDER BY a;
SELECT
a,
FIRST_VALUE(a) OVER (ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING),
LAST_VALUE(a) OVER (ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING)
FROM t1 ORDER BY a;
DROP TABLE t1;
--echo #
--echo # Prepared statements
--echo #
EXECUTE IMMEDIATE 'CREATE TABLE t1 AS SELECT ? AS a' USING CAST('::' AS INET6);
SHOW CREATE TABLE t1;
EXECUTE IMMEDIATE 'INSERT INTO t1 VALUES (?)' USING '::1';
EXECUTE IMMEDIATE 'INSERT INTO t1 VALUES (?)' USING CAST('::2' AS INET6);
EXECUTE IMMEDIATE 'INSERT INTO t1 VALUES (?)' USING 0x00000000000000000000000000000003;
SELECT a FROM t1 ORDER BY a;
EXECUTE IMMEDIATE 'SELECT * FROM t1 WHERE a=?' USING '::1';
EXECUTE IMMEDIATE 'SELECT * FROM t1 WHERE a=?' USING CAST('::2' AS INET6);
EXECUTE IMMEDIATE 'SELECT * FROM t1 WHERE a=?' USING 0x00000000000000000000000000000003;
DROP TABLE t1;
--echo #
--echo # Character set and collation aggregation
--echo #
CREATE TABLE t1 (a INET6);
CREATE TABLE t2 AS SELECT
CONCAT(a) AS c1,
CONCAT(CAST('::' AS INET6)) AS c2
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT
CONCAT(_utf8'1', a) AS c1,
CONCAT(_utf8'1', CAST('::1' AS INET6)) AS c2,
CONCAT(_utf8'1', COALESCE(a)) AS c3
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
CREATE TABLE t2 AS SELECT
CONCAT(_latin1'1', a) AS c1,
CONCAT(_latin1'1', CAST('::1' AS INET6)) AS c2,
CONCAT(_latin1'1', COALESCE(a)) AS c3
FROM t1;
SHOW CREATE TABLE t2;
DROP TABLE t2;
DROP TABLE t1;
--echo #
--echo # UNION
--echo #
CREATE TABLE t1 AS SELECT CAST('::' AS INET6) AS c UNION SELECT CAST('::1' AS INET6);
SHOW CREATE TABLE t1;
DROP TABLE t1;
CREATE TABLE t1 AS SELECT CAST('::' AS INET6) AS c UNION SELECT '::1';
SHOW CREATE TABLE t1;
DROP TABLE t1;
CREATE TABLE t1 AS SELECT '::' AS c UNION SELECT CAST('::1' AS INET6);
SHOW CREATE TABLE t1;
DROP TABLE t1;
CREATE TABLE t1 AS SELECT CAST('::' AS INET6) AS c UNION SELECT 0x00000000000000000000000000000001;
SELECT * FROM t1;
DROP TABLE t1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
CREATE TABLE t1 AS SELECT CAST('::' AS INET6) AS c UNION SELECT 1;
--echo #
--echo # Unary operators
--echo #
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT -CAST('::' AS INET6);
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT ABS(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT ROUND(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT CEILING(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT FLOOR(CAST('::' AS INET6));
--echo #
--echo # Arithmetic operators
--echo #
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT CAST('::' AS INET6) + 1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT CAST('::' AS INET6) - 1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT CAST('::' AS INET6) * 1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT CAST('::' AS INET6) / 1;
--error ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION
SELECT CAST('::' AS INET6) MOD 1;
--echo #
--echo # Misc
--echo #
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT RAND(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT FROM_UNIXTIME(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT HOUR(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT YEAR(CAST('::' AS INET6));
--error ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION
SELECT RELEASE_LOCK(CAST('::' AS INET6));
SELECT JSON_LENGTH(CAST('::' AS INET6));
--echo #
--echo # Virtual columns
--echo #
--error ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED
CREATE TABLE t1 (
a INT,
b INET6 GENERATED ALWAYS AS (CAST(CONCAT(RAND(),a) AS INET6)), INDEX(b)
);
CREATE TABLE t1 (
a INT,
b INET6 GENERATED ALWAYS AS (CAST(CONCAT('::',HEX(a)) AS INET6)), INDEX(b)
);
INSERT INTO t1 (a) VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15);
SELECT * FROM t1;
DROP TABLE t1;
--echo #
--echo # VIEW
--echo #
CREATE TABLE t1 (a INT DEFAULT 0);
INSERT INTO t1 (a) VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15);
SELECT * FROM t1 ORDER BY a;
CREATE VIEW v1 AS SELECT (CAST(CONCAT('::',HEX(a)) AS INET6)) AS c FROM t1;
SELECT * FROM v1 ORDER BY c;
DROP VIEW v1;
DROP TABLE t1;
CREATE TABLE t1 (a INET6 DEFAULT '::');
CREATE VIEW v1 AS SELECT * FROM t1;
SHOW CREATE VIEW v1;
DESCRIBE v1;
INSERT INTO v1 VALUES ('::'),('::1'),('::2');
SELECT * FROM t1;
DROP VIEW v1;
DROP TABLE t1;
CREATE TABLE t1 (a INET6 DEFAULT CAST('::' AS INET6));
CREATE VIEW v1 AS SELECT * FROM t1;
SHOW CREATE VIEW v1;
DESCRIBE v1;
INSERT INTO v1 VALUES ('::'),('::1'),('::2');
SELECT * FROM t1;
DROP VIEW v1;
DROP TABLE t1;
--echo #
--echo # Subqueries
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::'),('::1'),('::2');
SELECT * FROM t1 WHERE a=(SELECT MIN(a) FROM t1) ORDER BY a;
SELECT * FROM t1 WHERE a=(SELECT MAX(a) FROM t1) ORDER BY a;
SELECT * FROM t1 WHERE a IN (SELECT a FROM t1 WHERE a>'::') ORDER BY a;
DROP TABLE t1;
--echo #
--echo # Stored routines
--echo #
DELIMITER $$;
CREATE PROCEDURE p1(a INET6)
BEGIN
DECLARE b INET6 DEFAULT CONCAT('1', a);
SELECT a, b;
END;
$$
DELIMITER ;$$
CALL p1('::1');
CALL p1(CAST('::2' AS INET6));
DROP PROCEDURE p1;
DELIMITER $$;
CREATE FUNCTION f1(a INET6) RETURNS INET6
BEGIN
RETURN CONCAT('1',a);
END;
$$
DELIMITER ;$$
SELECT f1('::1');
SELECT f1(CAST('::1' AS INET6));
DROP FUNCTION f1;
--echo #
--echo # Anchored data types in SP variables
--echo #
CREATE TABLE t1 (a INET6);
INSERT INTO t1 VALUES ('::1');
DELIMITER $$;
CREATE PROCEDURE p1()
BEGIN
DECLARE va TYPE OF t1.a;
SELECT MAX(a) INTO va FROM t1;
SELECT va;
END;
$$
DELIMITER ;$$
CALL p1;
DROP PROCEDURE p1;
DROP TABLE t1;
CREATE TABLE t1 (a INET6, b INET6);
INSERT INTO t1 VALUES ('::a', '::b');
DELIMITER $$;
CREATE PROCEDURE p1()
BEGIN
DECLARE va ROW TYPE OF t1;
SELECT MAX(a), MAX(b) INTO va FROM t1;
SELECT va.a, va.b;
END;
$$
DELIMITER ;$$
CALL p1;
DROP PROCEDURE p1;
DROP TABLE t1;
--echo #
--echo # Optimizer: make_const_item_for_comparison
--echo #
CREATE TABLE t1 (id INT, a INET6);
INSERT INTO t1 VALUES (1,'::1'),(2,'::2');
EXPLAIN EXTENDED SELECT * FROM t1 WHERE a=COALESCE(CAST('::1' AS INET6)) AND id>0;
DROP TABLE t1;
--echo #
--echo # Optimizer: equal field propagation
--echo #
CREATE TABLE t1 (id INT, a INET6);
INSERT INTO t1 VALUES (1,'::1'),(2,'::2');
EXPLAIN EXTENDED SELECT * FROM t1
WHERE a=COALESCE(CAST('::1' AS INET6))
AND LENGTH(CONCAT(a,RAND()))>1;
EXPLAIN EXTENDED SELECT * FROM t1
WHERE a=COALESCE(CAST('::1' AS INET6))
AND LENGTH(a)>1;
DROP TABLE t1;
--echo #
--echo # Optimizer: equal expression propagation
--echo #
CREATE TABLE t1 (id INT, a INET6);
INSERT INTO t1 VALUES (1,'::1'),(2,'::2');
EXPLAIN EXTENDED SELECT * FROM t1
WHERE COALESCE(a)='::1' AND COALESCE(a)=CONCAT(a);
DROP TABLE t1;
--echo #
--echo # Subquery materialization
--echo #
CREATE TABLE t1 (a INET6, b VARCHAR(32), KEY (a), KEY(b)) ;
INSERT INTO t1 VALUES ('::a','::a'),('::a','::b');
SET @@optimizer_switch='semijoin=off,materialization=on,in_to_exists=off,subquery_cache=off';
EXPLAIN SELECT * FROM t1 WHERE a IN (SELECT a AS a_inner FROM t1 GROUP BY a_inner);
EXPLAIN SELECT * FROM t1 WHERE b IN (SELECT a AS a_inner FROM t1 GROUP BY a_inner);
SET @@optimizer_switch=DEFAULT;
DROP TABLE t1;
--echo #
--echo # IS_IPV4_MAPPED(), IS_IPV4_COMPAT() now understand text notation
--echo #
CREATE TABLE t1 (id SERIAL, a VARCHAR(32));
INSERT INTO t1 (a) VALUES ('::192.168.0.1'),('::192.168.10.111'),('::ffff:10.10.0.1'),('::ffff:192.168.0.1');
--echo # This is a text notation
SELECT id, length(a), a, IS_IPV4_MAPPED(a) FROM t1 ORDER BY id;
SELECT id, length(a), a, IS_IPV4_COMPAT(a) FROM t1 ORDER BY id;
--echo # This is not a text notation: it is a binary input only looking like text notation
SELECT id, length(a), a, IS_IPV4_MAPPED(BINARY a) FROM t1 ORDER BY id;
SELECT id, length(a), a, IS_IPV4_COMPAT(BINARY a) FROM t1 ORDER BY id;
DROP TABLE t1;
--echo #
--echo # Limit clause parameter
--echo # TODO: this should fail.
--echo # The test for a valid data type should be moved
--echo # from parse time to fix_fields() time, and performed
--echo # for both Item_splocal and Item_param.
--echo #
EXECUTE IMMEDIATE 'SELECT 1 FROM DUAL LIMIT ?' USING CAST('::' AS INET6);
## TODO:
## - Add hooks to run mysql_client_test with pluggable data types
##
## - This should fail with the "illegal data type" error:
##SELECT CAST('::' AS INET6) DIV 1;
##
## - This should fail with the "illegal data type" error:
## EXTRACT(MINUTE...)
##

38
plugin/type_inet/mysql-test/type_inet/type_inet6_engines.inc
View File

@ -0,0 +1,38 @@
--echo #
--echo # Range optimizer
--echo #
CREATE TABLE t1 (a INET6, INDEX(a));
SHOW CREATE TABLE t1;
DELIMITER $$;
FOR i IN 0..255
DO
INSERT INTO t1 VALUES (CONCAT('::', HEX(i)));
END FOR
$$
DELIMITER ;$$
SELECT * FROM t1 WHERE a='::ff';
EXPLAIN SELECT * FROM t1 WHERE a='::ff';
SELECT * FROM t1 WHERE a='garbage';
EXPLAIN SELECT * FROM t1 WHERE a='garbage';
SELECT * FROM t1 WHERE a>='::fe';
EXPLAIN SELECT * FROM t1 WHERE a>='::fe';
SELECT * FROM t1 WHERE a>='garbage';
EXPLAIN SELECT * FROM t1 WHERE a>='garbage';
SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
EXPLAIN EXTENDED SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
DROP TABLE t1;

104
plugin/type_inet/mysql-test/type_inet/type_inet6_innodb.result
View File

@ -0,0 +1,104 @@
#
# Start of 10.5 tests
#
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
SET default_storage_engine=InnoDB;
#
# Range optimizer
#
CREATE TABLE t1 (a INET6, INDEX(a));
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` inet6 DEFAULT NULL,
KEY `a` (`a`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1
FOR i IN 0..255
DO
INSERT INTO t1 VALUES (CONCAT('::', HEX(i)));
END FOR
$$
SELECT * FROM t1 WHERE a='::ff';
a
::ff
EXPLAIN SELECT * FROM t1 WHERE a='::ff';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ref a a 17 const 1 Using where; Using index
SELECT * FROM t1 WHERE a='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a>='::fe';
a
::fe
::ff
EXPLAIN SELECT * FROM t1 WHERE a>='::fe';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
SELECT * FROM t1 WHERE a>='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a>='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
a
::80
::a0
::f0
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 3 Using where; Using index
SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
a
::80
::a0
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
a
::80
::81
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
a
::ff
EXPLAIN EXTENDED SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
id select_type table type possible_keys key key_len ref rows filtered Extra
1 SIMPLE t1 ref a a 17 const 1 100.00 Using where; Using index
Warnings:
Note 1003 select `test`.`t1`.`a` AS `a` from `test`.`t1` where `test`.`t1`.`a` = INET6'::ff'
DROP TABLE t1;
#
# End of 10.5 tests
#

18
plugin/type_inet/mysql-test/type_inet/type_inet6_innodb.test
View File

@ -0,0 +1,18 @@
--source include/have_innodb.inc
--echo #
--echo # Start of 10.5 tests
--echo #
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
SET default_storage_engine=InnoDB;
--source type_inet6_engines.inc
--echo #
--echo # End of 10.5 tests
--echo #

163
plugin/type_inet/mysql-test/type_inet/type_inet6_memory.result
View File

@ -0,0 +1,163 @@
#
# Start of 10.5 tests
#
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
SET default_storage_engine=MEMORY;
#
# Range optimizer
#
CREATE TABLE t1 (a INET6, INDEX(a));
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` inet6 DEFAULT NULL,
KEY `a` (`a`)
) ENGINE=MEMORY DEFAULT CHARSET=latin1
FOR i IN 0..255
DO
INSERT INTO t1 VALUES (CONCAT('::', HEX(i)));
END FOR
$$
SELECT * FROM t1 WHERE a='::ff';
a
::ff
EXPLAIN SELECT * FROM t1 WHERE a='::ff';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ref a a 17 const 2 Using where
SELECT * FROM t1 WHERE a='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a>='::fe';
a
::fe
::ff
EXPLAIN SELECT * FROM t1 WHERE a>='::fe';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ALL a NULL NULL NULL 256 Using where
SELECT * FROM t1 WHERE a>='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
EXPLAIN SELECT * FROM t1 WHERE a>='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ALL a NULL NULL NULL 256 Using where
SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
a
::80
::a0
::f0
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 6 Using where
SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
a
::80
::a0
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 4 Using where
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
a
::80
::81
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ALL a NULL NULL NULL 256 Using where
SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage'
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ALL a NULL NULL NULL 256 Using where
SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
a
::ff
EXPLAIN EXTENDED SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
id select_type table type possible_keys key key_len ref rows filtered Extra
1 SIMPLE t1 ref a a 17 const 2 100.00 Using where
Warnings:
Note 1003 select `test`.`t1`.`a` AS `a` from `test`.`t1` where `test`.`t1`.`a` = INET6'::ff'
DROP TABLE t1;
#
# End of 10.5 tests
#

18
plugin/type_inet/mysql-test/type_inet/type_inet6_memory.test
View File

@ -0,0 +1,18 @@
--source include/have_innodb.inc
--echo #
--echo # Start of 10.5 tests
--echo #
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
SET default_storage_engine=MEMORY;
--source type_inet6_engines.inc
--echo #
--echo # End of 10.5 tests
--echo #

104
plugin/type_inet/mysql-test/type_inet/type_inet6_myisam.result
View File

@ -0,0 +1,104 @@
#
# Start of 10.5 tests
#
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
SET default_storage_engine=MyISAM;
#
# Range optimizer
#
CREATE TABLE t1 (a INET6, INDEX(a));
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` inet6 DEFAULT NULL,
KEY `a` (`a`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1
FOR i IN 0..255
DO
INSERT INTO t1 VALUES (CONCAT('::', HEX(i)));
END FOR
$$
SELECT * FROM t1 WHERE a='::ff';
a
::ff
EXPLAIN SELECT * FROM t1 WHERE a='::ff';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 ref a a 17 const 1 Using where; Using index
SELECT * FROM t1 WHERE a='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a>='::fe';
a
::fe
::ff
EXPLAIN SELECT * FROM t1 WHERE a>='::fe';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
SELECT * FROM t1 WHERE a>='garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a>='garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
a
::80
::a0
::f0
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','::f0');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 3 Using where; Using index
SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
a
::80
::a0
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a IN ('::80','::a0','garbage');
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage'
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
a
::80
::81
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND '::81';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t1 range a a 17 NULL 2 Using where; Using index
SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
a
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
EXPLAIN SELECT * FROM t1 WHERE a BETWEEN '::80' AND 'garbage';
id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables
Warnings:
Warning 1292 Incorrect inet6 value: 'garbage' for column `test`.`t1`.`a` at row 1
SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
a
::ff
EXPLAIN EXTENDED SELECT * FROM t1 WHERE a=CAST('::ff' AS INET6);
id select_type table type possible_keys key key_len ref rows filtered Extra
1 SIMPLE t1 ref a a 17 const 1 100.00 Using where; Using index
Warnings:
Note 1003 select `test`.`t1`.`a` AS `a` from `test`.`t1` where `test`.`t1`.`a` = INET6'::ff'
DROP TABLE t1;
#
# End of 10.5 tests
#

18
plugin/type_inet/mysql-test/type_inet/type_inet6_myisam.test
View File

@ -0,0 +1,18 @@
--source include/have_innodb.inc
--echo #
--echo # Start of 10.5 tests
--echo #
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
SET default_storage_engine=MyISAM;
--source type_inet6_engines.inc
--echo #
--echo # End of 10.5 tests
--echo #

15
plugin/type_inet/mysql-test/type_inet/type_inet6_mysql.result
View File

@ -0,0 +1,15 @@
CREATE TABLE t1 (a INET6);
Field 1: `a`
Catalog: `def`
Database: `test`
Table: `t1`
Org_table: `t1`
Type: STRING
Collation: latin1_swedish_ci (8)
Length: 39
Max_length: 0
Decimals: 0
Flags: UNSIGNED BINARY
DROP TABLE t1;

6
plugin/type_inet/mysql-test/type_inet/type_inet6_mysql.test
View File

@ -0,0 +1,6 @@
-- source include/have_working_dns.inc
-- source include/not_embedded.inc
CREATE TABLE t1 (a INET6);
--exec $MYSQL -t test --column-type-info -e "SELECT * FROM t1" 2>&1
DROP TABLE t1;

31
plugin/type_inet/mysql-test/type_inet/type_inet6_plugin.result
View File

@ -0,0 +1,31 @@
#
# Start of 10.5 tests
#
#
# MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
#
SELECT
PLUGIN_NAME,
PLUGIN_VERSION,
PLUGIN_STATUS,
PLUGIN_TYPE,
PLUGIN_AUTHOR,
PLUGIN_DESCRIPTION,
PLUGIN_LICENSE,
PLUGIN_MATURITY,
PLUGIN_AUTH_VERSION
FROM INFORMATION_SCHEMA.PLUGINS
WHERE PLUGIN_TYPE='DATA TYPE'
AND PLUGIN_NAME='inet6';
PLUGIN_NAME inet6
PLUGIN_VERSION 1.0
PLUGIN_STATUS ACTIVE
PLUGIN_TYPE DATA TYPE
PLUGIN_AUTHOR MariaDB Corporation
PLUGIN_DESCRIPTION Data type TEST_INT8
PLUGIN_LICENSE GPL
PLUGIN_MATURITY Experimental
PLUGIN_AUTH_VERSION 1.0
#
# End of 10.5 tests
#

27
plugin/type_inet/mysql-test/type_inet/type_inet6_plugin.test
View File

@ -0,0 +1,27 @@
--echo #
--echo # Start of 10.5 tests
--echo #
--echo #
--echo # MDEV-274 The data type for IPv6/IPv4 addresses in MariaDB
--echo #
--vertical_results
SELECT
PLUGIN_NAME,
PLUGIN_VERSION,
PLUGIN_STATUS,
PLUGIN_TYPE,
PLUGIN_AUTHOR,
PLUGIN_DESCRIPTION,
PLUGIN_LICENSE,
PLUGIN_MATURITY,
PLUGIN_AUTH_VERSION
FROM INFORMATION_SCHEMA.PLUGINS
WHERE PLUGIN_TYPE='DATA TYPE'
AND PLUGIN_NAME='inet6';
--horizontal_results
--echo #
--echo # End of 10.5 tests
--echo #

25
plugin/type_inet/plugin.cc
View File

@ -24,6 +24,16 @@
#include <mysql/plugin_function_collection.h>
Type_handler_inet6 type_handler_inet6;
static struct st_mariadb_data_type plugin_descriptor_type_inet6=
{
MariaDB_DATA_TYPE_INTERFACE_VERSION,
&type_handler_inet6
};
/*************************************************************************/
class Create_func_inet_ntoa : public Create_func_arg1
@ -186,5 +196,20 @@ maria_declare_plugin(type_inet)
NULL, // System variables
"1.0", // String version representation
MariaDB_PLUGIN_MATURITY_EXPERIMENTAL // Maturity(see include/mysql/plugin.h)*/
},
{
MariaDB_DATA_TYPE_PLUGIN, // the plugin type (see include/mysql/plugin.h)
&plugin_descriptor_type_inet6,// pointer to type-specific plugin descriptor
type_handler_inet6.name().ptr(),// plugin name
"MariaDB Corporation", // plugin author
"Data type TEST_INT8", // the plugin description
PLUGIN_LICENSE_GPL, // the plugin license (see include/mysql/plugin.h)
0, // Pointer to plugin initialization function
0, // Pointer to plugin deinitialization function
0x0100, // Numeric version 0xAABB means AA.BB veriosn
NULL, // Status variables
NULL, // System variables
"1.0", // String version representation
MariaDB_PLUGIN_MATURITY_EXPERIMENTAL // Maturity(see include/mysql/plugin.h)*/
}
maria_declare_plugin_end;

933
plugin/type_inet/sql_type_inet.cc
View File

@ -510,6 +510,17 @@ size_t Inet6::to_string(char *dst, size_t dstsize) const
bool Inet6::make_from_item(Item *item)
{
if (item->type_handler() == &type_handler_inet6)
{
Native tmp(m_buffer, sizeof(m_buffer));
bool rc= item->val_native(current_thd, &tmp);
if (rc)
return true;
DBUG_ASSERT(tmp.length() == sizeof(m_buffer));
if (tmp.ptr() != m_buffer)
memcpy(m_buffer, tmp.ptr(), sizeof(m_buffer));
return false;
}
StringBufferInet6 tmp;
String *str= item->val_str(&tmp);
return str ? make_from_character_or_binary_string(str) : true;
@ -518,7 +529,7 @@ bool Inet6::make_from_item(Item *item)
bool Inet6::make_from_character_or_binary_string(const String *str)
{
static Name name= Name(STRING_WITH_LEN("inet6"));
static Name name= type_handler_inet6.name();
if (str->charset() != &my_charset_bin)
{
bool rc= character_string_to_ipv6(str->ptr(), str->length(),
@ -540,3 +551,923 @@ bool Inet6::make_from_character_or_binary_string(const String *str)
memcpy(m_buffer, str->ptr(), sizeof(m_buffer));
return false;
};
/********************************************************************/
class cmp_item_inet6: public cmp_item_scalar
{
Inet6 m_native;
public:
cmp_item_inet6()
:cmp_item_scalar(),
m_native(Inet6_zero())
{ }
void store_value(Item *item) override
{
m_native= Inet6(item, &m_null_value);
}
int cmp_not_null(const Value *val) override
{
DBUG_ASSERT(!val->is_null());
DBUG_ASSERT(val->is_string());
Inet6_null tmp(val->m_string);
DBUG_ASSERT(!tmp.is_null());
return m_native.cmp(tmp);
}
int cmp(Item *arg) override
{
Inet6_null tmp(arg);
return m_null_value || tmp.is_null() ? UNKNOWN : m_native.cmp(tmp) != 0;
}
int compare(cmp_item *ci) override
{
cmp_item_inet6 *tmp= static_cast<cmp_item_inet6*>(ci);
DBUG_ASSERT(!m_null_value);
DBUG_ASSERT(!tmp->m_null_value);
return m_native.cmp(tmp->m_native);
}
cmp_item *make_same() override
{
return new cmp_item_inet6();
}
};
class Field_inet6: public Field
{
static void set_min_value(char *ptr)
{
memset(ptr, 0, Inet6::binary_length());
}
static void set_max_value(char *ptr)
{
memset(ptr, 0xFF, Inet6::binary_length());
}
void store_warning(const ErrConv &str,
Sql_condition::enum_warning_level level)
{
static const Name type_name= type_handler_inet6.name();
get_thd()->push_warning_truncated_value_for_field(level, type_name.ptr(),
str.ptr(), table->s,
field_name.str);
}
int set_null_with_warn(const ErrConv &str)
{
store_warning(str, Sql_condition::WARN_LEVEL_WARN);
set_null();
return 1;
}
int set_min_value_with_warn(const ErrConv &str)
{
store_warning(str, Sql_condition::WARN_LEVEL_WARN);
set_min_value((char*) ptr);
return 1;
}
int set_max_value_with_warn(const ErrConv &str)
{
store_warning(str, Sql_condition::WARN_LEVEL_WARN);
set_max_value((char*) ptr);
return 1;
}
public:
Field_inet6(const LEX_CSTRING *field_name_arg, const Record_addr &rec)
:Field(rec.ptr(), Inet6::max_char_length(),
rec.null_ptr(), rec.null_bit(), Field::NONE, field_name_arg)
{
flags|= BINARY_FLAG | UNSIGNED_FLAG;
}
const Type_handler *type_handler() const override
{
return &type_handler_inet6;
}
uint32 max_display_length() const override { return field_length; }
bool str_needs_quotes() const override { return true; }
const DTCollation &dtcollation() const override
{
static DTCollation_numeric c;
return c;
}
CHARSET_INFO *charset(void) const override { return &my_charset_numeric; }
const CHARSET_INFO *sort_charset(void) const override { return &my_charset_bin; }
/**
This makes client-server protocol convert the value according
to @@character_set_client.
*/
bool binary() const override { return false; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BINARY; }
bool is_equal(const Column_definition &new_field) const override
{
return new_field.type_handler() == type_handler();
}
bool eq_def(const Field *field) const override
{
return Field::eq_def(field);
}
double pos_in_interval(Field *min, Field *max) override
{
return pos_in_interval_val_str(min, max, 0);
}
int cmp(const uchar *a, const uchar *b) const override
{ return memcmp(a, b, pack_length()); }
void sort_string(uchar *to, uint length) override
{
DBUG_ASSERT(length == pack_length());
memcpy(to, ptr, length);
}
uint32 pack_length() const override
{
return Inet6::binary_length();
}
uint pack_length_from_metadata(uint field_metadata) const override
{
return Inet6::binary_length();
}
void sql_type(String &str) const override
{
static Name name= type_handler_inet6.name();
str.set_ascii(name.ptr(), name.length());
}
bool validate_value_in_record(THD *thd, const uchar *record) const override
{
return false;
}
String *val_str(String *val_buffer,
String *val_ptr __attribute__((unused))) override
{
DBUG_ASSERT(marked_for_read());
Inet6_null tmp((const char *) ptr, pack_length());
return tmp.to_string(val_buffer) ? NULL : val_buffer;
}
my_decimal *val_decimal(my_decimal *to) override
{
DBUG_ASSERT(marked_for_read());
my_decimal_set_zero(to);
return to;
}
longlong val_int() override
{
DBUG_ASSERT(marked_for_read());
return 0;
}
double val_real() override
{
DBUG_ASSERT(marked_for_read());
return 0;
}
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{
DBUG_ASSERT(marked_for_read());
set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
return false;
}
bool val_bool(void) override
{
DBUG_ASSERT(marked_for_read());
return !Inet6::only_zero_bytes((const char *) ptr, Inet6::binary_length());
}
int store_native(const Native &value) override
{
DBUG_ASSERT(marked_for_write_or_computed());
DBUG_ASSERT(value.length() == Inet6::binary_length());
memcpy(ptr, value.ptr(), value.length());
return 0;
}
int store(const char *str, size_t length, CHARSET_INFO *cs) override
{
DBUG_ASSERT(marked_for_write_or_computed());
Inet6_null tmp= cs == &my_charset_bin ?
Inet6_null(str, length) :
Inet6_null(str, length, cs);
if (tmp.is_null())
{
return maybe_null() ?
set_null_with_warn(ErrConvString(str, length, cs)) :
set_min_value_with_warn(ErrConvString(str, length, cs));
}
tmp.to_binary((char *) ptr, Inet6::binary_length());
return 0;
}
int store_hex_hybrid(const char *str, size_t length) override
{
return store(str, length, &my_charset_bin);
}
int store_decimal(const my_decimal *num) override
{
DBUG_ASSERT(marked_for_write_or_computed());
return set_min_value_with_warn(ErrConvDecimal(num));
}
int store(longlong nr, bool unsigned_flag) override
{
DBUG_ASSERT(marked_for_write_or_computed());
return set_min_value_with_warn(
ErrConvInteger(Longlong_hybrid(nr, unsigned_flag)));
}
int store(double nr) override
{
DBUG_ASSERT(marked_for_write_or_computed());
return set_min_value_with_warn(ErrConvDouble(nr));
}
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override
{
DBUG_ASSERT(marked_for_write_or_computed());
return set_min_value_with_warn(ErrConvTime(ltime));
}
/*** Field conversion routines ***/
int store_field(Field *from) override
{
// INSERT INTO t1 (inet6_field) SELECT different_field_type FROM t2;
return from->save_in_field(this);
}
int save_in_field(Field *to) override
{
// INSERT INTO t2 (different_field_type) SELECT inet6_field FROM t1;
switch (to->cmp_type()) {
case INT_RESULT:
case REAL_RESULT:
case DECIMAL_RESULT:
case TIME_RESULT:
{
my_decimal buff;
return to->store_decimal(val_decimal(&buff));
}
case STRING_RESULT:
return save_in_field_str(to);
case ROW_RESULT:
break;
}
DBUG_ASSERT(0);
to->reset();
return 0;
}
Copy_func *get_copy_func(const Field *from) const override
{
// ALTER to INET6 from another field
/*
if (eq_def(from))
return get_identical_copy_func();
switch (from->cmp_type()) {
case STRING_RESULT:
return do_field_string;
case TIME_RESULT:
return do_field_temporal;
case DECIMAL_RESULT:
return do_field_decimal;
case REAL_RESULT:
return do_field_real;
case INT_RESULT:
return do_field_int;
case ROW_RESULT:
DBUG_ASSERT(0);
break;
}
*/
return do_field_string;//QQ
}
bool memcpy_field_possible(const Field *from) const override
{
// INSERT INTO t1 (inet6_field) SELECT field2 FROM t2;
return type_handler() == from->type_handler();
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param &param) const
{
if (type_handler() == source.type_handler() ||
(source.type_handler() == &type_handler_string &&
source.type_handler()->max_display_length_for_field(source) ==
Inet6::binary_length()))
return rpl_conv_type_from_same_data_type(source.metadata(), rli, param);
return CONV_TYPE_IMPOSSIBLE;
}
/*** Optimizer routines ***/
bool test_if_equality_guarantees_uniqueness(const Item *const_item) const override
{
/*
This condition:
WHERE inet6_field=const
should return a single distinct value only,
as comparison is done according to INET6.
*/
return true;
}
bool can_be_substituted_to_equal_item(const Context &ctx,
const Item_equal *item_equal)
override
{
switch (ctx.subst_constraint()) {
case ANY_SUBST:
return ctx.compare_type_handler() == item_equal->compare_type_handler();
case IDENTITY_SUBST:
return true;
}
return false;
}
Item *get_equal_const_item(THD *thd, const Context &ctx,
Item *const_item) override;
bool can_optimize_keypart_ref(const Item_bool_func *cond,
const Item *item) const override
{
/*
Mixing of two different non-traditional types is currently prevented.
This may change in the future. For example, INET4 and INET6
data types can be made comparable.
*/
DBUG_ASSERT(item->type_handler()->is_traditional_scalar_type() ||
item->type_handler() == type_handler());
return true;
}
/**
Test if Field can use range optimizer for a standard comparison operation:
<=, <, =, <=>, >, >=
Note, this method does not cover spatial operations.
*/
bool can_optimize_range(const Item_bool_func *cond,
const Item *item,
bool is_eq_func) const override
{
// See the DBUG_ASSERT comment in can_optimize_keypart_ref()
DBUG_ASSERT(item->type_handler()->is_traditional_scalar_type() ||
item->type_handler() == type_handler());
return true;
}
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *prm, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override
{
DBUG_ENTER("Field_inet6::get_mm_leaf");
if (!can_optimize_scalar_range(prm, key_part, cond, op, value))
DBUG_RETURN(0);
int err= value->save_in_field_no_warnings(this, 1);
if ((op != SCALAR_CMP_EQUAL && is_real_null()) || err < 0)
DBUG_RETURN(&null_element);
if (err > 0)
{
if (op == SCALAR_CMP_EQ || op == SCALAR_CMP_EQUAL)
DBUG_RETURN(new (prm->mem_root) SEL_ARG_IMPOSSIBLE(this));
DBUG_RETURN(NULL); /* Cannot infer anything */
}
DBUG_RETURN(stored_field_make_mm_leaf(prm, key_part, op, value));
}
bool can_optimize_hash_join(const Item_bool_func *cond,
const Item *item) const override
{
return can_optimize_keypart_ref(cond, item);
}
bool can_optimize_group_min_max(const Item_bool_func *cond,
const Item *const_item) const override
{
return true;
}
uint row_pack_length() const override { return pack_length(); }
Binlog_type_info binlog_type_info() const
{
DBUG_ASSERT(type() == binlog_type());
return Binlog_type_info_fixed_string(Field_inet6::binlog_type(),
Inet6::binary_length(),
&my_charset_bin);
}
/**********/
uint size_of() const override { return sizeof(*this); }
};
class Item_typecast_inet6: public Item_func
{
public:
Item_typecast_inet6(THD *thd, Item *a) :Item_func(thd, a) {}
const Type_handler *type_handler() const override
{ return &type_handler_inet6; }
enum Functype functype() const override { return CHAR_TYPECAST_FUNC; }
bool eq(const Item *item, bool binary_cmp) const override
{
if (this == item)
return true;
if (item->type() != FUNC_ITEM ||
functype() != ((Item_func*)item)->functype())
return false;
if (type_handler() != item->type_handler())
return false;
Item_typecast_inet6 *cast= (Item_typecast_inet6*) item;
return args[0]->eq(cast->args[0], binary_cmp);
}
const char *func_name() const override { return "cast_as_inet6"; }
void print(String *str, enum_query_type query_type)
{
str->append(STRING_WITH_LEN("cast("));
args[0]->print(str, query_type);
str->append(STRING_WITH_LEN(" as inet6)"));
}
bool fix_length_and_dec()
{
Type_std_attributes::operator=(Type_std_attributes_inet6());
return false;
}
String *val_str(String *to)
{
Inet6_null tmp(args[0]);
return (null_value= tmp.is_null() || tmp.to_string(to)) ? NULL : to;
}
longlong val_int()
{
return 0;
}
double val_real()
{
return 0;
}
my_decimal *val_decimal(my_decimal *to)
{
my_decimal_set_zero(to);
return to;
}
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
{
set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
return false;
}
bool val_native(THD *thd, Native *to)
{
Inet6_null tmp(args[0]);
return null_value= tmp.is_null() || tmp.to_native(to);
}
Item *get_copy(THD *thd)
{ return get_item_copy<Item_typecast_inet6>(thd, this); }
};
class Item_cache_inet6: public Item_cache
{
NativeBufferInet6 m_value;
public:
Item_cache_inet6(THD *thd)
:Item_cache(thd, &type_handler_inet6)
{ }
Item *get_copy(THD *thd)
{ return get_item_copy<Item_cache_inet6>(thd, this); }
bool cache_value()
{
if (!example)
return false;
value_cached= true;
null_value= example->val_native_with_conversion_result(current_thd,
&m_value,
type_handler());
return true;
}
String* val_str(String *to)
{
if (!has_value())
return NULL;
Inet6_null tmp(m_value.ptr(), m_value.length());
return tmp.is_null() || tmp.to_string(to) ? NULL : to;
}
my_decimal *val_decimal(my_decimal *to)
{
if (!has_value())
return NULL;
my_decimal_set_zero(to);
return to;
}
longlong val_int()
{
if (!has_value())
return 0;
return 0;
}
double val_real()
{
if (!has_value())
return 0;
return 0;
}
longlong val_datetime_packed(THD *thd)
{
DBUG_ASSERT(0);
if (!has_value())
return 0;
return 0;
}
longlong val_time_packed(THD *thd)
{
DBUG_ASSERT(0);
if (!has_value())
return 0;
return 0;
}
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
{
if (!has_value())
return true;
set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
return false;
}
bool val_native(THD *thd, Native *to)
{
if (!has_value())
return true;
return to->copy(m_value.ptr(), m_value.length());
}
};
class Item_literal_inet6: public Item_literal
{
Inet6 m_value;
public:
Item_literal_inet6(THD *thd)
:Item_literal(thd),
m_value(Inet6_zero())
{ }
Item_literal_inet6(THD *thd, const Inet6 &value)
:Item_literal(thd),
m_value(value)
{ }
const Type_handler *type_handler() const override
{
return &type_handler_inet6;
}
longlong val_int() override
{
return 0;
}
double val_real() override
{
return 0;
}
String *val_str(String *to) override
{
return m_value.to_string(to) ? NULL : to;
}
my_decimal *val_decimal(my_decimal *to) override
{
my_decimal_set_zero(to);
return to;
}
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{
set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
return false;
}
bool val_native(THD *thd, Native *to) override
{
return m_value.to_native(to);
}
void print(String *str, enum_query_type query_type) override
{
StringBufferInet6 tmp;
m_value.to_string(&tmp);
str->append("INET6'");
str->append(tmp);
str->append('\'');
}
Item *get_copy(THD *thd) override
{ return get_item_copy<Item_literal_inet6>(thd, this); }
// Non-overriding methods
void set_value(const Inet6 &value)
{
m_value= value;
}
};
class in_inet6 :public in_vector
{
Inet6 m_value;
static int cmp_inet6(void *cmp_arg, Inet6 *a, Inet6 *b)
{
return a->cmp(*b);
}
public:
in_inet6(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(Inet6), (qsort2_cmp) cmp_inet6, 0),
m_value(Inet6_zero())
{ }
const Type_handler *type_handler() const override
{
return &type_handler_inet6;
}
void set(uint pos, Item *item) override
{
Inet6 *buff= &((Inet6 *) base)[pos];
Inet6_null value(item);
if (value.is_null())
*buff= Inet6_zero();
else
*buff= value;
}
uchar *get_value(Item *item) override
{
Inet6_null value(item);
if (value.is_null())
return 0;
m_value= value;
return (uchar *) &m_value;
}
Item* create_item(THD *thd) override
{
return new (thd->mem_root) Item_literal_inet6(thd);
}
void value_to_item(uint pos, Item *item) override
{
const Inet6 &buff= (((Inet6*) base)[pos]);
static_cast<Item_literal_inet6*>(item)->set_value(buff);
}
};
bool
Type_handler_inet6::character_or_binary_string_to_native(THD *thd,
const String *str,
Native *to) const
{
if (str->charset() == &my_charset_bin)
{
// Convert from a binary string
if (str->length() != Inet6::binary_length() ||
to->copy(str->ptr(), str->length()))
{
thd->push_warning_wrong_value(Sql_condition::WARN_LEVEL_WARN,
name().ptr(),
ErrConvString(str).ptr());
return true;
}
return false;
}
// Convert from a character string
Inet6_null tmp(*str);
if (tmp.is_null())
thd->push_warning_wrong_value(Sql_condition::WARN_LEVEL_WARN,
name().ptr(),
ErrConvString(str).ptr());
return tmp.is_null() || tmp.to_native(to);
}
bool
Type_handler_inet6::Item_save_in_value(THD *thd,
Item *item,
st_value *value) const
{
value->m_type= DYN_COL_STRING;
String *str= item->val_str(&value->m_string);
if (str != &value->m_string && !item->null_value)
{
// "item" returned a non-NULL value
if (Inet6_null(*str).is_null())
{
/*
The value was not-null, but conversion to INET6 failed:
SELECT a, DECODE_ORACLE(inet6col, 'garbage', '<NULL>', '::01', '01')
FROM t1;
*/
thd->push_warning_wrong_value(Sql_condition::WARN_LEVEL_WARN,
name().ptr(),
ErrConvString(str).ptr());
value->m_type= DYN_COL_NULL;
return true;
}
// "item" returned a non-NULL value, and it was a valid INET6
value->m_string.set(str->ptr(), str->length(), str->charset());
}
return check_null(item, value);
}
void Type_handler_inet6::Item_param_setup_conversion(THD *thd,
Item_param *param) const
{
param->setup_conversion_string(thd, thd->variables.character_set_client);
}
void Type_handler_inet6::make_sort_key(uchar *to, Item *item,
const SORT_FIELD_ATTR *sort_field,
Sort_param *param) const
{
DBUG_ASSERT(item->type_handler() == this);
NativeBufferInet6 tmp;
item->val_native_result(current_thd, &tmp);
if (item->maybe_null)
{
if (item->null_value)
{
memset(to, 0, Inet6::binary_length() + 1);
return;
}
*to++= 1;
}
DBUG_ASSERT(!item->null_value);
DBUG_ASSERT(Inet6::binary_length() == tmp.length());
DBUG_ASSERT(Inet6::binary_length() == sort_field->length);
memcpy(to, tmp.ptr(), tmp.length());
}
void Type_handler_inet6::sortlength(THD *thd,
const Type_std_attributes *item,
SORT_FIELD_ATTR *attr) const
{
attr->length= Inet6::binary_length();
attr->suffix_length= 0;
}
cmp_item *Type_handler_inet6::make_cmp_item(THD *thd, CHARSET_INFO *cs) const
{
return new (thd->mem_root) cmp_item_inet6;
}
in_vector *
Type_handler_inet6::make_in_vector(THD *thd, const Item_func_in *func,
uint nargs) const
{
return new (thd->mem_root) in_inet6(thd, nargs);
}
Item *Type_handler_inet6::create_typecast_item(THD *thd, Item *item,
const Type_cast_attributes &attr)
const
{
return new (thd->mem_root) Item_typecast_inet6(thd, item);
}
Item_cache *Type_handler_inet6::Item_get_cache(THD *thd, const Item *item) const
{
return new (thd->mem_root) Item_cache_inet6(thd);
}
Item *
Type_handler_inet6::make_const_item_for_comparison(THD *thd,
Item *src,
const Item *cmp) const
{
Inet6_null tmp(src);
if (tmp.is_null())
return new (thd->mem_root) Item_null(thd, src->name.str);
return new (thd->mem_root) Item_literal_inet6(thd, tmp);
}
Item *Field_inet6::get_equal_const_item(THD *thd, const Context &ctx,
Item *const_item)
{
Inet6_null tmp(const_item);
if (tmp.is_null())
return NULL;
return new (thd->mem_root) Item_literal_inet6(thd, tmp);
}
Field *
Type_handler_inet6::make_table_field_from_def(
TABLE_SHARE *share,
MEM_ROOT *mem_root,
const LEX_CSTRING *name,
const Record_addr &addr,
const Bit_addr &bit,
const Column_definition_attributes *attr,
uint32 flags) const
{
return new (mem_root) Field_inet6(name, addr);
}
Field *Type_handler_inet6::make_table_field(MEM_ROOT *root,
const LEX_CSTRING *name,
const Record_addr &addr,
const Type_all_attributes &attr,
TABLE_SHARE *share) const
{
return new (root) Field_inet6(name, addr);
}
Field *Type_handler_inet6::make_conversion_table_field(MEM_ROOT *root,
TABLE *table,
uint metadata,
const Field *target)
const
{
const Record_addr tmp(NULL, Bit_addr(true));
return new (table->in_use->mem_root) Field_inet6(&empty_clex_str, tmp);
}
/***************************************************************/
class Type_collection_inet: public Type_collection
{
const Type_handler *aggregate_common(const Type_handler *a,
const Type_handler *b) const
{
if (a == b)
return a;
return NULL;
}
const Type_handler *aggregate_if_string(const Type_handler *a,
const Type_handler *b) const
{
static const Type_aggregator::Pair agg[]=
{
{&type_handler_inet6, &type_handler_null, &type_handler_inet6},
{&type_handler_inet6, &type_handler_varchar, &type_handler_inet6},
{&type_handler_inet6, &type_handler_string, &type_handler_inet6},
{&type_handler_inet6, &type_handler_tiny_blob, &type_handler_inet6},
{&type_handler_inet6, &type_handler_blob, &type_handler_inet6},
{&type_handler_inet6, &type_handler_medium_blob, &type_handler_inet6},
{&type_handler_inet6, &type_handler_long_blob, &type_handler_inet6},
{&type_handler_inet6, &type_handler_hex_hybrid, &type_handler_inet6},
{NULL,NULL,NULL}
};
return Type_aggregator::find_handler_in_array(agg, a, b, true);
}
public:
const Type_handler *aggregate_for_result(const Type_handler *a,
const Type_handler *b)
const override
{
const Type_handler *h;
if ((h= aggregate_common(a, b)) ||
(h= aggregate_if_string(a, b)))
return h;
return NULL;
}
const Type_handler *aggregate_for_min_max(const Type_handler *a,
const Type_handler *b)
const override
{
return aggregate_for_result(a, b);
}
const Type_handler *aggregate_for_comparison(const Type_handler *a,
const Type_handler *b)
const override
{
if (const Type_handler *h= aggregate_common(a, b))
return h;
static const Type_aggregator::Pair agg[]=
{
{&type_handler_inet6, &type_handler_null, &type_handler_inet6},
{&type_handler_inet6, &type_handler_long_blob, &type_handler_inet6},
{NULL,NULL,NULL}
};
return Type_aggregator::find_handler_in_array(agg, a, b, true);
}
const Type_handler *aggregate_for_num_op(const Type_handler *a,
const Type_handler *b)
const override
{
return NULL;
}
const Type_handler *handler_by_name(const LEX_CSTRING &name) const override
{
if (type_handler_inet6.name().eq(name))
return &type_handler_inet6;
return NULL;
}
};
const Type_collection *Type_handler_inet6::type_collection() const
{
static Type_collection_inet type_collection_inet;
return &type_collection_inet;
}

682
plugin/type_inet/sql_type_inet.h
View File

@ -300,4 +300,686 @@ public:
};
class Type_std_attributes_inet6: public Type_std_attributes
{
public:
Type_std_attributes_inet6()
:Type_std_attributes(
Type_numeric_attributes(Inet6::max_char_length(), 0, true),
DTCollation_numeric())
{ }
};
class Type_handler_inet6: public Type_handler
{
bool character_or_binary_string_to_native(THD *thd, const String *str,
Native *to) const;
public:
~Type_handler_inet6() override {}
const Name name() const override
{
static const Name name(STRING_WITH_LEN("inet6"));
return name;
}
const Type_collection *type_collection() const override;
const Name &default_value() const override
{
static Name def(STRING_WITH_LEN("::"));
return def;
}
protocol_send_type_t protocol_send_type() const override
{
return PROTOCOL_SEND_STRING;
}
enum_field_types field_type() const override
{
return MYSQL_TYPE_STRING;
}
Item_result result_type() const override
{
return STRING_RESULT;
}
Item_result cmp_type() const override
{
return STRING_RESULT;
}
enum_dynamic_column_type dyncol_type(const Type_all_attributes *attr)
const override
{
return DYN_COL_STRING;
}
uint32 max_display_length_for_field(const Conv_source &src) const
{
return Inet6::max_char_length();
}
const Type_handler *type_handler_for_comparison() const override
{
return this;
}
int
stored_field_cmp_to_item(THD *thd, Field *field, Item *item) const override
{
DBUG_ASSERT(field->type_handler() == this);
Inet6_null ni(item); // Convert Item to INET6
if (ni.is_null())
return 0;
NativeBufferInet6 tmp;
if (field->val_native(&tmp))
{
DBUG_ASSERT(0);
return 0;
}
return -ni.cmp(tmp);
}
CHARSET_INFO *charset_for_protocol(const Item *item) const override
{
return item->collation.collation;
}
bool is_scalar_type() const override { return true; }
bool can_return_int() const override { return false; }
bool can_return_decimal() const override { return false; }
bool can_return_real() const override { return false; }
bool can_return_str() const override { return true; }
bool can_return_text() const override { return true; }
bool can_return_date() const override { return false; }
bool can_return_time() const override { return false; }
uint Item_time_precision(THD *thd, Item *item) const override
{
return 0;
}
uint Item_datetime_precision(THD *thd, Item *item) const override
{
return 0;
}
uint Item_decimal_scale(const Item *item) const override
{
return 0;
}
uint Item_decimal_precision(const Item *item) const override
{
/*
This will be needed if we ever allow cast from INET6 to DECIMAL.
Decimal precision of INET6 is 39 digits:
'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' =
340282366920938463463374607431768211456 = 39 digits
*/
return 39;
}
/*
Returns how many digits a divisor adds into a division result.
See Item::divisor_precision_increment() in item.h for more comments.
*/
uint Item_divisor_precision_increment(const Item *) const override
{
return 0;
}
/**
Makes a temporary table Field to handle numeric aggregate functions,
e.g. SUM(DISTINCT expr), AVG(DISTINCT expr), etc.
*/
Field *make_num_distinct_aggregator_field(MEM_ROOT *,
const Item *) const override
{
DBUG_ASSERT(0);
return 0;
}
Field *make_conversion_table_field(MEM_ROOT *root,
TABLE *TABLE,
uint metadata,
const Field *target) const override;
// Fix attributes after the parser
bool Column_definition_fix_attributes(Column_definition *c) const override
{
c->length= Inet6::max_char_length();
return false;
}
bool Column_definition_prepare_stage1(THD *thd,
MEM_ROOT *mem_root,
Column_definition *def,
handler *file,
ulonglong table_flags) const override
{
def->create_length_to_internal_length_simple();
return false;
}
bool Column_definition_redefine_stage1(Column_definition *def,
const Column_definition *dup,
const handler *file,
const Schema_specification_st *schema)
const override
{
def->redefine_stage1_common(dup, file, schema);
def->set_compression_method(dup->compression_method());
def->create_length_to_internal_length_string();
return false;
}
bool Column_definition_prepare_stage2(Column_definition *def,
handler *file,
ulonglong table_flags) const override
{
def->pack_flag= FIELDFLAG_BINARY;
return false;
}
Field *make_table_field(MEM_ROOT *root,
const LEX_CSTRING *name,
const Record_addr &addr,
const Type_all_attributes &attr,
TABLE_SHARE *table) const override;
Field *
make_table_field_from_def(TABLE_SHARE *share,
MEM_ROOT *mem_root,
const LEX_CSTRING *name,
const Record_addr &addr,
const Bit_addr &bit,
const Column_definition_attributes *attr,
uint32 flags) const override;
void
Column_definition_attributes_frm_pack(const Column_definition_attributes *def,
uchar *buff) const override
{
def->frm_pack_basic(buff);
def->frm_pack_charset(buff);
}
bool
Column_definition_attributes_frm_unpack(Column_definition_attributes *def,
TABLE_SHARE *share,
const uchar *buffer,
LEX_CUSTRING *gis_options)
const override
{
def->frm_unpack_basic(buffer);
return def->frm_unpack_charset(share, buffer);
}
void make_sort_key(uchar *to, Item *item,
const SORT_FIELD_ATTR *sort_field, Sort_param *param)
const override;
void sortlength(THD *thd,
const Type_std_attributes *item,
SORT_FIELD_ATTR *attr) const override;
uint32 max_display_length(const Item *item) const override
{
return Inet6::max_char_length();
}
uint32 calc_pack_length(uint32 length) const override
{
return Inet6::binary_length();
}
void Item_update_null_value(Item *item) const override
{
NativeBufferInet6 tmp;
item->val_native(current_thd, &tmp);
}
bool Item_save_in_value(THD *thd, Item *item, st_value *value) const override;
void Item_param_setup_conversion(THD *thd, Item_param *param) const override;
void Item_param_set_param_func(Item_param *param,
uchar **pos, ulong len) const override
{
param->set_param_str(pos, len);
}
bool Item_param_set_from_value(THD *thd,
Item_param *param,
const Type_all_attributes *attr,
const st_value *val) const override
{
param->unsigned_flag= false;//QQ
param->setup_conversion_string(thd, attr->collation.collation);
/*
Exact value of max_length is not known unless data is converted to
charset of connection, so we have to set it later.
*/
return param->set_str(val->m_string.ptr(), val->m_string.length(),
attr->collation.collation,
attr->collation.collation);
}
bool Item_param_val_native(THD *thd, Item_param *item, Native *to)
const override
{
StringBufferInet6 buffer;
String *str= item->val_str(&buffer);
if (!str)
return true;
Inet6_null tmp(*str);
return tmp.is_null() || tmp.to_native(to);
}
bool Item_send(Item *item, Protocol *p, st_value *buf) const override
{
return Item_send_str(item, p, buf);
}
int Item_save_in_field(Item *item, Field *field, bool no_conversions)
const override
{
if (field->type_handler() == this)
{
NativeBuffer<MAX_FIELD_WIDTH> tmp;
bool rc= item->val_native(current_thd, &tmp);
if (rc || item->null_value)
return set_field_to_null_with_conversions(field, no_conversions);
field->set_notnull();
return field->store_native(tmp);
}
return item->save_str_in_field(field, no_conversions);
}
String *print_item_value(THD *thd, Item *item, String *str) const override
{
StringBufferInet6 buf;
String *result= item->val_str(&buf);
/*
TODO: This should eventually use one of these notations:
1. CAST('::' AS INET6)
Problem: CAST is not supported as a NAME_CONST() argument.
2. INET6'::
Problem: This syntax is not supported by the parser yet.
*/
return !result ||
str->realloc(result->length() + 2) ||
str->append(STRING_WITH_LEN("'")) ||
str->append(result->ptr(), result->length()) ||
str->append(STRING_WITH_LEN("'")) ?
NULL :
str;
}
/**
Check if
WHERE expr=value AND expr=const
can be rewritten as:
WHERE const=value AND expr=const
"this" is the comparison handler that is used by "target".
@param target - the predicate expr=value,
whose "expr" argument will be replaced to "const".
@param target_expr - the target's "expr" which will be replaced to "const".
@param target_value - the target's second argument, it will remain unchanged.
@param source - the equality predicate expr=const (or expr<=>const)
that can be used to rewrite the "target" part
(under certain conditions, see the code).
@param source_expr - the source's "expr". It should be exactly equal to
the target's "expr" to make condition rewrite possible.
@param source_const - the source's "const" argument, it will be inserted
into "target" instead of "expr".
*/
bool
can_change_cond_ref_to_const(Item_bool_func2 *target,
Item *target_expr, Item *target_value,
Item_bool_func2 *source,
Item *source_expr, Item *source_const)
const override
{
/*
WHERE COALESCE(inet6_col)='::1' AND COALESCE(inet6_col)=CONCAT(a); -->
WHERE COALESCE(inet6_col)='::1' AND '::1'=CONCAT(a);
*/
return target->compare_type_handler() == source->compare_type_handler();
}
bool
subquery_type_allows_materialization(const Item *inner,
const Item *outer) const override
{
/*
Example:
SELECT * FROM t1 WHERE a IN (SELECT inet6col FROM t1 GROUP BY inet6col);
Allow materialization only if the outer column is also INET6.
This can be changed for more relaxed rules in the future.
*/
DBUG_ASSERT(inner->type_handler() == this);
return outer->type_handler() == this;
}
/**
Make a simple constant replacement item for a constant "src",
so the new item can futher be used for comparison with "cmp", e.g.:
src = cmp -> replacement = cmp
"this" is the type handler that is used to compare "src" and "cmp".
@param thd - current thread, for mem_root
@param src - The item that we want to replace. It's a const item,
but it can be complex enough to calculate on every row.
@param cmp - The src's comparand.
@retval - a pointer to the created replacement Item
@retval - NULL, if could not create a replacement (e.g. on EOM).
NULL is also returned for ROWs, because instead of replacing
a Item_row to a new Item_row, Type_handler_row just replaces
its elements.
*/
Item *make_const_item_for_comparison(THD *thd,
Item *src,
const Item *cmp) const override;
Item_cache *Item_get_cache(THD *thd, const Item *item) const override;
Item *create_typecast_item(THD *thd, Item *item,
const Type_cast_attributes &attr) const override;
int cmp_native(const Native &a, const Native &b) const override
{
DBUG_ASSERT(a.length() == Inet6::binary_length());
DBUG_ASSERT(b.length() == Inet6::binary_length());
return memcmp(a.ptr(), b.ptr(), Inet6::binary_length());
}
bool set_comparator_func(Arg_comparator *cmp) const override
{
return cmp->set_cmp_func_native();
}
bool Item_const_eq(const Item_const *a, const Item_const *b,
bool binary_cmp) const override
{
return false;//QQ
}
bool Item_eq_value(THD *thd, const Type_cmp_attributes *attr,
Item *a, Item *b) const override
{
Inet6_null na(a);
Inet6_null nb(b);
return !na.is_null() && !nb.is_null() && !na.cmp(nb);
}
bool Item_hybrid_func_fix_attributes(THD *thd,
const char *name,
Type_handler_hybrid_field_type *h,
Type_all_attributes *attr,
Item **items,
uint nitems) const override
{
attr->Type_std_attributes::operator=(Type_std_attributes_inet6());
h->set_handler(this);
return false;
}
bool Item_func_min_max_fix_attributes(THD *thd,
Item_func_min_max *func,
Item **items,
uint nitems) const override
{
return Item_hybrid_func_fix_attributes(thd, func->func_name(),
func, func, items, nitems);
}
bool Item_sum_hybrid_fix_length_and_dec(Item_sum_hybrid *func) const override
{
func->Type_std_attributes::operator=(Type_std_attributes_inet6());
func->set_handler(this);
return false;
}
bool Item_sum_sum_fix_length_and_dec(Item_sum_sum *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool Item_sum_avg_fix_length_and_dec(Item_sum_avg *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool Item_sum_variance_fix_length_and_dec(Item_sum_variance *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool Item_val_native_with_conversion(THD *thd, Item *item,
Native *to) const override
{
if (item->type_handler() == this)
return item->val_native(thd, to); // No conversion needed
StringBufferInet6 buffer;
String *str= item->val_str(&buffer);
return str ? character_or_binary_string_to_native(thd, str, to) : true;
}
bool Item_val_native_with_conversion_result(THD *thd, Item *item,
Native *to) const override
{
if (item->type_handler() == this)
return item->val_native_result(thd, to); // No conversion needed
StringBufferInet6 buffer;
String *str= item->str_result(&buffer);
return str ? character_or_binary_string_to_native(thd, str, to) : true;
}
bool Item_val_bool(Item *item) const override
{
NativeBufferInet6 tmp;
if (item->val_native(current_thd, &tmp))
return false;
return !Inet6::only_zero_bytes(tmp.ptr(), tmp.length());
}
void Item_get_date(THD *thd, Item *item,
Temporal::Warn *buff, MYSQL_TIME *ltime,
date_mode_t fuzzydate) const override
{
set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
}
longlong Item_val_int_signed_typecast(Item *item) const override
{
DBUG_ASSERT(0);
return 0;
}
longlong Item_val_int_unsigned_typecast(Item *item) const override
{
DBUG_ASSERT(0);
return 0;
}
String *Item_func_hex_val_str_ascii(Item_func_hex *item, String *str)
const override
{
NativeBufferInet6 tmp;
if ((item->null_value= item->arguments()[0]->val_native(current_thd, &tmp)))
return NULL;
DBUG_ASSERT(tmp.length() == Inet6::binary_length());
if (str->set_hex(tmp.ptr(), tmp.length()))
{
str->length(0);
str->set_charset(item->collation.collation);
}
return str;
}
String *Item_func_hybrid_field_type_val_str(Item_func_hybrid_field_type *item,
String *str) const override
{
NativeBufferInet6 native;
if (item->val_native(current_thd, &native))
{
DBUG_ASSERT(item->null_value);
return NULL;
}
DBUG_ASSERT(native.length() == Inet6::binary_length());
Inet6_null tmp(native.ptr(), native.length());
return tmp.is_null() || tmp.to_string(str) ? NULL : str;
}
double Item_func_hybrid_field_type_val_real(Item_func_hybrid_field_type *)
const override
{
return 0;
}
longlong Item_func_hybrid_field_type_val_int(Item_func_hybrid_field_type *)
const override
{
return 0;
}
my_decimal *
Item_func_hybrid_field_type_val_decimal(Item_func_hybrid_field_type *,
my_decimal *to) const override
{
my_decimal_set_zero(to);
return to;
}
void Item_func_hybrid_field_type_get_date(THD *,
Item_func_hybrid_field_type *,
Temporal::Warn *,
MYSQL_TIME *to,
date_mode_t fuzzydate)
const override
{
set_zero_time(to, MYSQL_TIMESTAMP_TIME);
}
// WHERE is Item_func_min_max_val_native???
String *Item_func_min_max_val_str(Item_func_min_max *func, String *str)
const override
{
Inet6_null tmp(func);
return tmp.is_null() || tmp.to_string(str) ? NULL : str;
}
double Item_func_min_max_val_real(Item_func_min_max *) const override
{
return 0;
}
longlong Item_func_min_max_val_int(Item_func_min_max *) const override
{
return 0;
}
my_decimal *Item_func_min_max_val_decimal(Item_func_min_max *,
my_decimal *to) const override
{
my_decimal_set_zero(to);
return to;
}
bool Item_func_min_max_get_date(THD *thd, Item_func_min_max*,
MYSQL_TIME *to, date_mode_t fuzzydate)
const override
{
set_zero_time(to, MYSQL_TIMESTAMP_TIME);
return false;
}
bool
Item_func_between_fix_length_and_dec(Item_func_between *func) const override
{
return false;
}
longlong Item_func_between_val_int(Item_func_between *func) const override
{
return func->val_int_cmp_native();
}
cmp_item *make_cmp_item(THD *thd, CHARSET_INFO *cs) const override;
in_vector *make_in_vector(THD *thd, const Item_func_in *func,
uint nargs) const override;
bool Item_func_in_fix_comparator_compatible_types(THD *thd,
Item_func_in *func)
const override
{
if (func->compatible_types_scalar_bisection_possible())
{
return func->value_list_convert_const_to_int(thd) ||
func->fix_for_scalar_comparison_using_bisection(thd);
}
return
func->fix_for_scalar_comparison_using_cmp_items(thd,
1U << (uint) STRING_RESULT);
}
bool
Item_func_round_fix_length_and_dec(Item_func_round *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool
Item_func_int_val_fix_length_and_dec(Item_func_int_val *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool Item_func_abs_fix_length_and_dec(Item_func_abs *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool Item_func_neg_fix_length_and_dec(Item_func_neg *func) const override
{
return Item_func_or_sum_illegal_param(func);
}
bool
Item_func_signed_fix_length_and_dec(Item_func_signed *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_unsigned_fix_length_and_dec(Item_func_unsigned *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_double_typecast_fix_length_and_dec(Item_double_typecast *item)
const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_decimal_typecast_fix_length_and_dec(Item_decimal_typecast *item)
const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_char_typecast_fix_length_and_dec(Item_char_typecast *item)
const override
{
item->fix_length_and_dec_str();
return false;
}
bool
Item_time_typecast_fix_length_and_dec(Item_time_typecast *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_date_typecast_fix_length_and_dec(Item_date_typecast *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_datetime_typecast_fix_length_and_dec(Item_datetime_typecast *item)
const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_plus_fix_length_and_dec(Item_func_plus *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_minus_fix_length_and_dec(Item_func_minus *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_mul_fix_length_and_dec(Item_func_mul *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_div_fix_length_and_dec(Item_func_div *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
bool
Item_func_mod_fix_length_and_dec(Item_func_mod *item) const override
{
return Item_func_or_sum_illegal_param(item);
}
};
extern MYSQL_PLUGIN_IMPORT Type_handler_inet6 type_handler_inet6;
#endif /* SQL_TYPE_INET_H */

23
sql/field.cc
View File

@ -7525,16 +7525,25 @@ Field_string::unpack(uchar *to, const uchar *from, const uchar *from_end,
@returns number of bytes written to metadata_ptr
*/
Binlog_type_info_fixed_string::Binlog_type_info_fixed_string(uchar type_code,
uint32 octets,
CHARSET_INFO *cs)
:Binlog_type_info(type_code, 0, 2, cs)
{
DBUG_ASSERT(octets < 1024);
DBUG_ASSERT((type_code & 0xF0) == 0xF0);
DBUG_PRINT("debug", ("octets: %u, type_code: %u", octets, type_code));
m_metadata= (type_code ^ ((octets & 0x300) >> 4)) +
(((uint)(octets & 0xFF)) << 8);
}
Binlog_type_info Field_string::binlog_type_info() const
{
uint16 a;
DBUG_ASSERT(field_length < 1024);
DBUG_ASSERT((real_type() & 0xF0) == 0xF0);
DBUG_PRINT("debug", ("field_length: %u, real_type: %u",
field_length, real_type()));
a= (real_type() ^ ((field_length & 0x300) >> 4)) + (((uint)(field_length & 0xFF)) << 8);
DBUG_ASSERT(Field_string::type() == binlog_type());
return Binlog_type_info(Field_string::type(), a, 2, charset());
return Binlog_type_info_fixed_string(Field_string::binlog_type(),
field_length, charset());
}

10
sql/field.h
View File

@ -719,6 +719,16 @@ public:
{ return alloc_root(mem_root, size); }
};
class Binlog_type_info_fixed_string: public Binlog_type_info
{
public:
Binlog_type_info_fixed_string(uchar type_code,
uint32 octet_length,
CHARSET_INFO *cs);
};
class Field: public Value_source
{
Field(const Item &); /* Prevent use of these */

2
sql/opt_range.cc
View File

@ -405,7 +405,7 @@ bool get_quick_keys(PARAM *param,QUICK_RANGE_SELECT *quick,KEY_PART *key,
uchar *max_key,uint max_key_flag);
static bool eq_tree(SEL_ARG* a,SEL_ARG *b);
static SEL_ARG null_element(SEL_ARG::IMPOSSIBLE);
SEL_ARG null_element(SEL_ARG::IMPOSSIBLE);
static bool null_part_in_key(KEY_PART *key_part, const uchar *key,
uint length);
static bool is_key_scan_ror(PARAM *param, uint keynr, uint8 nparts);

1
sql/opt_range.h
View File

@ -598,6 +598,7 @@ public:
SEL_ARG *clone_tree(RANGE_OPT_PARAM *param);
};
extern MYSQL_PLUGIN_IMPORT SEL_ARG null_element;
class SEL_ARG_IMPOSSIBLE: public SEL_ARG
{

2
storage/innobase/handler/ha_innodb.cc
View File

@ -6731,7 +6731,7 @@ get_innobase_type_from_mysql_type(
}
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_STRING:
if (field->binary()) {
if (field->binary() || field->key_type() == HA_KEYTYPE_BINARY) {
return(DATA_FIXBINARY);
} else if (field->charset() == &my_charset_latin1) {
return(DATA_CHAR);

Write Preview
Loading…
Cancel
Save