2008-11-10 21:21:49 +01:00
|
|
|
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2006-12-23 20:17:15 +01:00
|
|
|
the Free Software Foundation; version 2 of the License.
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2001-12-06 13:10:51 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
|
2007-08-15 17:08:44 +02:00
|
|
|
/**
|
|
|
|
@defgroup Semantic_Analysis Semantic Analysis
|
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
|
|
|
|
/* YACC and LEX Definitions */
|
|
|
|
|
|
|
|
/* These may not be declared yet */
|
|
|
|
class Table_ident;
|
|
|
|
class sql_exchange;
|
|
|
|
class LEX_COLUMN;
|
Simplistic, experimental framework for Stored Procedures (SPs).
Implements creation and dropping of PROCEDUREs, IN, OUT, and INOUT parameters,
single-statement procedures, rudimentary multi-statement (begin-end) prodedures
(when the client can handle it), and local variables.
Missing most of the embedded SQL language, all attributes, FUNCTIONs, error handling,
reparses procedures at each call (no caching), etc, etc.
Certainly buggy too, but procedures can actually be created and called....
2002-12-08 19:59:22 +01:00
|
|
|
class sp_head;
|
2004-02-17 17:36:53 +01:00
|
|
|
class sp_name;
|
Simplistic, experimental framework for Stored Procedures (SPs).
Implements creation and dropping of PROCEDUREs, IN, OUT, and INOUT parameters,
single-statement procedures, rudimentary multi-statement (begin-end) prodedures
(when the client can handle it), and local variables.
Missing most of the embedded SQL language, all attributes, FUNCTIONs, error handling,
reparses procedures at each call (no caching), etc, etc.
Certainly buggy too, but procedures can actually be created and called....
2002-12-08 19:59:22 +01:00
|
|
|
class sp_instr;
|
|
|
|
class sp_pcontext;
|
2006-01-11 11:35:25 +01:00
|
|
|
class st_alter_tablespace;
|
2005-07-18 13:31:02 +02:00
|
|
|
class partition_info;
|
2006-06-27 10:53:26 +02:00
|
|
|
class Event_parse_data;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2006-01-19 22:40:56 +01:00
|
|
|
#ifdef MYSQL_SERVER
|
2002-06-11 10:20:31 +02:00
|
|
|
/*
|
|
|
|
The following hack is needed because mysql_yacc.cc does not define
|
|
|
|
YYSTYPE before including this file
|
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2002-07-23 17:31:22 +02:00
|
|
|
#include "set_var.h"
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
#ifdef MYSQL_YACC
|
|
|
|
#define LEX_YYSTYPE void *
|
|
|
|
#else
|
|
|
|
#include "lex_symbol.h"
|
2006-03-09 19:09:52 +01:00
|
|
|
#if MYSQL_LEX
|
2000-07-31 21:29:14 +02:00
|
|
|
#include "sql_yacc.h"
|
|
|
|
#define LEX_YYSTYPE YYSTYPE *
|
2006-03-09 19:09:52 +01:00
|
|
|
#else
|
|
|
|
#define LEX_YYSTYPE void *
|
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
#endif
|
2006-01-19 22:40:56 +01:00
|
|
|
#endif
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2002-11-29 14:20:25 +01:00
|
|
|
/*
|
|
|
|
When a command is added here, be sure it's also added in mysqld.cc
|
|
|
|
in "struct show_var_st status_vars[]= {" ...
|
2006-03-16 11:50:00 +01:00
|
|
|
|
|
|
|
If the command returns a result set or is not allowed in stored
|
|
|
|
functions or triggers, please also make sure that
|
|
|
|
sp_get_flags_for_command (sp_head.cc) returns proper flags for the
|
|
|
|
added SQLCOM_.
|
2002-11-29 14:20:25 +01:00
|
|
|
*/
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
enum enum_sql_command {
|
2000-11-13 22:55:10 +01:00
|
|
|
SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE,
|
|
|
|
SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT,
|
|
|
|
SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX,
|
|
|
|
|
|
|
|
SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS,
|
2005-11-07 16:25:06 +01:00
|
|
|
SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
|
|
|
|
SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
|
2000-11-13 22:55:10 +01:00
|
|
|
SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
|
2002-06-11 14:40:06 +02:00
|
|
|
SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
|
2004-11-13 11:56:39 +01:00
|
|
|
SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
|
2005-07-19 18:06:49 +02:00
|
|
|
SQLCOM_SHOW_TRIGGERS,
|
2000-11-13 22:55:10 +01:00
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
|
2002-11-29 12:29:27 +01:00
|
|
|
SQLCOM_GRANT,
|
2002-06-27 11:41:02 +02:00
|
|
|
SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
|
2002-11-29 12:29:27 +01:00
|
|
|
SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
|
2000-11-13 22:55:10 +01:00
|
|
|
SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
|
2004-12-27 12:08:22 +01:00
|
|
|
SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
|
2003-07-16 21:30:49 +02:00
|
|
|
SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
|
2003-08-21 16:15:06 +02:00
|
|
|
SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
|
2003-06-15 00:04:28 +02:00
|
|
|
SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
|
2005-02-01 20:48:05 +01:00
|
|
|
SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
|
2003-06-06 03:18:58 +02:00
|
|
|
SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
|
2000-11-13 22:55:10 +01:00
|
|
|
SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
|
2000-10-14 10:16:17 +02:00
|
|
|
SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
|
2003-02-16 17:39:12 +01:00
|
|
|
SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
|
2001-05-29 03:18:23 +02:00
|
|
|
SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
|
2001-05-31 02:50:56 +02:00
|
|
|
SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
|
2002-11-29 12:29:27 +01:00
|
|
|
SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
|
2001-12-17 22:24:51 +01:00
|
|
|
SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
|
2002-08-30 11:40:40 +02:00
|
|
|
SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
|
2003-12-17 23:52:03 +01:00
|
|
|
SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
|
2004-11-25 21:55:49 +01:00
|
|
|
SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
|
|
|
|
SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
|
2003-03-05 19:45:17 +01:00
|
|
|
SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
|
2003-02-21 17:37:05 +01:00
|
|
|
SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
|
2003-11-17 18:21:36 +01:00
|
|
|
SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC,
|
|
|
|
SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC,
|
2004-04-05 17:43:37 +02:00
|
|
|
SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
|
2004-07-16 00:15:55 +02:00
|
|
|
SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
|
2004-09-07 14:29:46 +02:00
|
|
|
SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
|
2005-01-16 13:16:23 +01:00
|
|
|
SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE,
|
|
|
|
SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER,
|
2005-11-17 11:11:48 +01:00
|
|
|
SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
|
2006-01-11 11:35:25 +01:00
|
|
|
SQLCOM_ALTER_TABLESPACE,
|
2005-11-06 13:13:06 +01:00
|
|
|
SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN,
|
2005-12-22 06:39:02 +01:00
|
|
|
SQLCOM_SHOW_AUTHORS, SQLCOM_BINLOG_BASE64_EVENT,
|
|
|
|
SQLCOM_SHOW_PLUGINS,
|
2006-05-03 02:53:26 +02:00
|
|
|
SQLCOM_SHOW_CONTRIBUTORS,
|
2006-12-02 01:47:45 +01:00
|
|
|
SQLCOM_CREATE_SERVER, SQLCOM_DROP_SERVER, SQLCOM_ALTER_SERVER,
|
2005-12-02 13:07:02 +01:00
|
|
|
SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT,
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS,
|
|
|
|
SQLCOM_SHOW_CREATE_TRIGGER,
|
2007-09-11 00:10:37 +02:00
|
|
|
SQLCOM_ALTER_DB_UPGRADE,
|
2007-01-03 23:15:10 +01:00
|
|
|
SQLCOM_SHOW_PROFILE, SQLCOM_SHOW_PROFILES,
|
2006-01-10 21:02:19 +01:00
|
|
|
|
2007-02-22 16:03:08 +01:00
|
|
|
/*
|
|
|
|
When a command is added here, be sure it's also added in mysqld.cc
|
|
|
|
in "struct show_var_st status_vars[]= {" ...
|
|
|
|
*/
|
2002-11-29 14:20:25 +01:00
|
|
|
/* This should be the last !!! */
|
|
|
|
SQLCOM_END
|
2000-07-31 21:29:14 +02:00
|
|
|
};
|
|
|
|
|
2003-10-16 14:54:47 +02:00
|
|
|
// describe/explain types
|
|
|
|
#define DESCRIBE_NORMAL 1
|
|
|
|
#define DESCRIBE_EXTENDED 2
|
2005-12-22 10:29:00 +01:00
|
|
|
/*
|
2005-12-27 13:04:35 +01:00
|
|
|
This is not within #ifdef because we want "EXPLAIN PARTITIONS ..." to produce
|
2005-12-22 10:29:00 +01:00
|
|
|
additional "partitions" column even if partitioning is not compiled in.
|
|
|
|
*/
|
|
|
|
#define DESCRIBE_PARTITIONS 4
|
2003-10-16 14:54:47 +02:00
|
|
|
|
2006-01-19 22:40:56 +01:00
|
|
|
#ifdef MYSQL_SERVER
|
|
|
|
|
2004-10-14 18:07:09 +02:00
|
|
|
enum enum_sp_suid_behaviour
|
2003-11-17 18:21:36 +01:00
|
|
|
{
|
2004-10-14 18:07:09 +02:00
|
|
|
SP_IS_DEFAULT_SUID= 0,
|
|
|
|
SP_IS_NOT_SUID,
|
|
|
|
SP_IS_SUID
|
2003-11-17 18:21:36 +01:00
|
|
|
};
|
2003-11-17 19:53:40 +01:00
|
|
|
|
2004-10-14 18:07:09 +02:00
|
|
|
enum enum_sp_data_access
|
|
|
|
{
|
|
|
|
SP_DEFAULT_ACCESS= 0,
|
|
|
|
SP_CONTAINS_SQL,
|
|
|
|
SP_NO_SQL,
|
|
|
|
SP_READS_SQL_DATA,
|
|
|
|
SP_MODIFIES_SQL_DATA
|
|
|
|
};
|
|
|
|
|
2005-06-16 09:12:47 +02:00
|
|
|
const LEX_STRING sp_data_access_name[]=
|
|
|
|
{
|
2006-08-17 18:13:45 +02:00
|
|
|
{ C_STRING_WITH_LEN("") },
|
|
|
|
{ C_STRING_WITH_LEN("CONTAINS SQL") },
|
|
|
|
{ C_STRING_WITH_LEN("NO SQL") },
|
|
|
|
{ C_STRING_WITH_LEN("READS SQL DATA") },
|
|
|
|
{ C_STRING_WITH_LEN("MODIFIES SQL DATA") }
|
2005-06-16 09:12:47 +02:00
|
|
|
};
|
2004-10-14 18:07:09 +02:00
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
#define DERIVED_SUBQUERY 1
|
|
|
|
#define DERIVED_VIEW 2
|
|
|
|
|
|
|
|
enum enum_view_create_mode
|
|
|
|
{
|
|
|
|
VIEW_CREATE_NEW, // check that there are not such VIEW/table
|
|
|
|
VIEW_ALTER, // check that VIEW .frm with such name exists
|
|
|
|
VIEW_CREATE_OR_REPLACE // check only that there are not such table
|
|
|
|
};
|
|
|
|
|
|
|
|
enum enum_drop_mode
|
|
|
|
{
|
|
|
|
DROP_DEFAULT, // mode is not specified
|
|
|
|
DROP_CASCADE, // CASCADE option
|
|
|
|
DROP_RESTRICT // RESTRICT option
|
|
|
|
};
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
typedef List<Item> List_item;
|
|
|
|
|
2006-12-02 01:47:45 +01:00
|
|
|
/* SERVERS CACHE CHANGES */
|
|
|
|
typedef struct st_lex_server_options
|
|
|
|
{
|
|
|
|
long port;
|
|
|
|
uint server_name_length;
|
|
|
|
char *server_name, *host, *db, *username, *password, *scheme, *socket, *owner;
|
|
|
|
} LEX_SERVER_OPTIONS;
|
|
|
|
|
2009-01-09 13:49:24 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
Structure to hold parameters for CHANGE MASTER or START/STOP SLAVE
|
|
|
|
or SHOW NEW MASTER.
|
|
|
|
|
|
|
|
Remark: this should not be confused with Master_info (and perhaps
|
|
|
|
would better be renamed to st_lex_replication_info). Some fields,
|
|
|
|
e.g., delay, are saved in Relay_log_info, not in Master_info.
|
|
|
|
*/
|
2000-07-31 21:29:14 +02:00
|
|
|
typedef struct st_lex_master_info
|
|
|
|
{
|
2002-06-11 10:20:31 +02:00
|
|
|
char *host, *user, *password, *log_file_name;
|
2000-07-31 21:29:14 +02:00
|
|
|
uint port, connect_retry;
|
|
|
|
ulonglong pos;
|
2001-07-05 01:14:31 +02:00
|
|
|
ulong server_id;
|
2007-03-29 15:09:57 +02:00
|
|
|
/*
|
|
|
|
Enum is used for making it possible to detect if the user
|
|
|
|
changed variable or if it should be left at old value
|
|
|
|
*/
|
|
|
|
enum {SSL_UNCHANGED, SSL_DISABLE, SSL_ENABLE}
|
|
|
|
ssl, ssl_verify_server_cert;
|
2003-09-01 13:16:20 +02:00
|
|
|
char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
|
2002-06-11 10:20:31 +02:00
|
|
|
char *relay_log_name;
|
2002-03-16 02:44:44 +01:00
|
|
|
ulong relay_log_pos;
|
2000-07-31 21:29:14 +02:00
|
|
|
} LEX_MASTER_INFO;
|
|
|
|
|
2001-06-03 16:07:26 +02:00
|
|
|
|
2002-06-11 10:20:31 +02:00
|
|
|
enum sub_select_type
|
|
|
|
{
|
2002-08-30 11:40:40 +02:00
|
|
|
UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
|
|
|
|
EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
|
2002-07-16 21:42:53 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
enum olap_type
|
|
|
|
{
|
2002-07-24 18:55:08 +02:00
|
|
|
UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
|
2002-06-11 10:20:31 +02:00
|
|
|
};
|
2001-06-03 16:07:26 +02:00
|
|
|
|
2003-10-13 10:20:19 +02:00
|
|
|
enum tablespace_op_type
|
|
|
|
{
|
|
|
|
NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
|
|
|
|
};
|
|
|
|
|
2007-03-05 18:08:41 +01:00
|
|
|
/*
|
|
|
|
String names used to print a statement with index hints.
|
|
|
|
Keep in sync with index_hint_type.
|
|
|
|
*/
|
|
|
|
extern const char * index_hint_type_name[];
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
typedef uchar index_clause_map;
|
2007-03-05 18:08:41 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
Bits in index_clause_map : one for each possible FOR clause in
|
|
|
|
USE/FORCE/IGNORE INDEX index hint specification
|
|
|
|
*/
|
|
|
|
#define INDEX_HINT_MASK_JOIN (1)
|
|
|
|
#define INDEX_HINT_MASK_GROUP (1 << 1)
|
|
|
|
#define INDEX_HINT_MASK_ORDER (1 << 2)
|
|
|
|
|
|
|
|
#define INDEX_HINT_MASK_ALL (INDEX_HINT_MASK_JOIN | INDEX_HINT_MASK_GROUP | \
|
|
|
|
INDEX_HINT_MASK_ORDER)
|
|
|
|
|
|
|
|
/* Single element of an USE/FORCE/IGNORE INDEX list specified as a SQL hint */
|
2007-07-23 18:09:48 +02:00
|
|
|
class Index_hint : public Sql_alloc
|
2007-03-05 18:08:41 +01:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/* The type of the hint : USE/FORCE/IGNORE */
|
|
|
|
enum index_hint_type type;
|
|
|
|
/* Where the hit applies to. A bitmask of INDEX_HINT_MASK_<place> values */
|
|
|
|
index_clause_map clause;
|
|
|
|
/*
|
|
|
|
The index name. Empty (str=NULL) name represents an empty list
|
|
|
|
USE INDEX () clause
|
|
|
|
*/
|
|
|
|
LEX_STRING key_name;
|
|
|
|
|
2007-07-23 18:09:48 +02:00
|
|
|
Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,
|
2007-03-05 18:08:41 +01:00
|
|
|
char *str, uint length) :
|
|
|
|
type(type_arg), clause(clause_arg)
|
|
|
|
{
|
|
|
|
key_name.str= str;
|
|
|
|
key_name.length= length;
|
|
|
|
}
|
2007-09-26 18:06:54 +02:00
|
|
|
|
|
|
|
void print(THD *thd, String *str);
|
2007-03-05 18:08:41 +01:00
|
|
|
};
|
|
|
|
|
2002-05-06 23:04:16 +02:00
|
|
|
/*
|
|
|
|
The state of the lex parsing for selects
|
|
|
|
|
2005-02-28 10:59:46 +01:00
|
|
|
master and slaves are pointers to select_lex.
|
|
|
|
master is pointer to upper level node.
|
|
|
|
slave is pointer to lower level node
|
|
|
|
select_lex is a SELECT without union
|
|
|
|
unit is container of either
|
|
|
|
- One SELECT
|
|
|
|
- UNION of selects
|
|
|
|
select_lex and unit are both inherited form select_lex_node
|
|
|
|
neighbors are two select_lex or units on the same level
|
|
|
|
|
2002-05-06 23:04:16 +02:00
|
|
|
All select describing structures linked with following pointers:
|
2005-02-28 10:59:46 +01:00
|
|
|
- list of neighbors (next/prev) (prev of first element point to slave
|
2002-05-06 23:04:16 +02:00
|
|
|
pointer of upper structure)
|
2005-02-28 10:59:46 +01:00
|
|
|
- For select this is a list of UNION's (or one element list)
|
|
|
|
- For units this is a list of sub queries for the upper level select
|
|
|
|
|
|
|
|
- pointer to master (master), which is
|
|
|
|
If this is a unit
|
|
|
|
- pointer to outer select_lex
|
|
|
|
If this is a select_lex
|
|
|
|
- pointer to outer unit structure for select
|
|
|
|
|
|
|
|
- pointer to slave (slave), which is either:
|
|
|
|
If this is a unit:
|
|
|
|
- first SELECT that belong to this unit
|
|
|
|
If this is a select_lex
|
|
|
|
- first unit that belong to this SELECT (subquries or derived tables)
|
|
|
|
|
|
|
|
- list of all select_lex (link_next/link_prev)
|
|
|
|
This is to be used for things like derived tables creation, where we
|
|
|
|
go through this list and create the derived tables.
|
|
|
|
|
|
|
|
If unit contain several selects (UNION now, INTERSECT etc later)
|
|
|
|
then it have special select_lex called fake_select_lex. It used for
|
|
|
|
storing global parameters (like ORDER BY, LIMIT) and executing union.
|
|
|
|
Subqueries used in global ORDER BY clause will be attached to this
|
|
|
|
fake_select_lex, which will allow them correctly resolve fields of
|
|
|
|
'upper' UNION and outer selects.
|
|
|
|
|
|
|
|
For example for following query:
|
2001-06-03 16:07:26 +02:00
|
|
|
|
2002-05-06 23:04:16 +02:00
|
|
|
select *
|
|
|
|
from table1
|
|
|
|
where table1.field IN (select * from table1_1_1 union
|
|
|
|
select * from table1_1_2)
|
|
|
|
union
|
|
|
|
select *
|
|
|
|
from table2
|
|
|
|
where table2.field=(select (select f1 from table2_1_1_1_1
|
|
|
|
where table2_1_1_1_1.f2=table2_1_1.f3)
|
|
|
|
from table2_1_1
|
|
|
|
where table2_1_1.f1=table2.f2)
|
|
|
|
union
|
|
|
|
select * from table3;
|
|
|
|
|
|
|
|
we will have following structure:
|
|
|
|
|
2005-02-28 10:59:46 +01:00
|
|
|
select1: (select * from table1 ...)
|
|
|
|
select2: (select * from table2 ...)
|
|
|
|
select3: (select * from table3)
|
|
|
|
select1.1.1: (select * from table1_1_1)
|
|
|
|
...
|
2002-05-06 23:04:16 +02:00
|
|
|
|
|
|
|
main unit
|
2003-07-03 01:30:52 +02:00
|
|
|
fake0
|
2002-05-06 23:04:16 +02:00
|
|
|
select1 select2 select3
|
|
|
|
|^^ |^
|
|
|
|
s||| ||master
|
|
|
|
l||| |+---------------------------------+
|
|
|
|
a||| +---------------------------------+|
|
|
|
|
v|||master slave ||
|
|
|
|
e||+-------------------------+ ||
|
|
|
|
V| neighbor | V|
|
2003-07-03 01:30:52 +02:00
|
|
|
unit1.1<+==================>unit1.2 unit2.1
|
2004-06-21 23:00:36 +02:00
|
|
|
fake1.1
|
|
|
|
select1.1.1 select 1.1.2 select1.2.1 select2.1.1
|
2002-05-06 23:04:16 +02:00
|
|
|
|^
|
|
|
|
||
|
|
|
|
V|
|
|
|
|
unit2.1.1.1
|
|
|
|
select2.1.1.1.1
|
|
|
|
|
|
|
|
|
|
|
|
relation in main unit will be following:
|
2005-02-28 10:59:46 +01:00
|
|
|
(bigger picture for:
|
|
|
|
main unit
|
|
|
|
fake0
|
|
|
|
select1 select2 select3
|
|
|
|
in the above picture)
|
|
|
|
|
2002-05-06 23:04:16 +02:00
|
|
|
main unit
|
2003-07-03 01:30:52 +02:00
|
|
|
|^^^^|fake_select_lex
|
|
|
|
|||||+--------------------------------------------+
|
|
|
|
||||+--------------------------------------------+|
|
|
|
|
|||+------------------------------+ ||
|
|
|
|
||+--------------+ | ||
|
|
|
|
slave||master | | ||
|
|
|
|
V| neighbor | neighbor | master|V
|
|
|
|
select1<========>select2<========>select3 fake0
|
2002-05-06 23:04:16 +02:00
|
|
|
|
|
|
|
list of all select_lex will be following (as it will be constructed by
|
|
|
|
parser):
|
|
|
|
|
|
|
|
select1->select2->select3->select2.1.1->select 2.1.2->select2.1.1.1.1-+
|
|
|
|
|
|
|
|
|
+---------------------------------------------------------------------+
|
|
|
|
|
|
|
|
|
+->select1.1.1->select1.1.2
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
Base class for st_select_lex (SELECT_LEX) &
|
|
|
|
st_select_lex_unit (SELECT_LEX_UNIT)
|
|
|
|
*/
|
2002-12-15 21:01:09 +01:00
|
|
|
struct st_lex;
|
2002-10-30 12:18:52 +01:00
|
|
|
class st_select_lex;
|
|
|
|
class st_select_lex_unit;
|
2002-05-27 19:52:54 +02:00
|
|
|
class st_select_lex_node {
|
|
|
|
protected:
|
2002-05-06 23:04:16 +02:00
|
|
|
st_select_lex_node *next, **prev, /* neighbor list */
|
|
|
|
*master, *slave, /* vertical links */
|
|
|
|
*link_next, **link_prev; /* list of whole SELECT_LEX */
|
2002-05-27 19:52:54 +02:00
|
|
|
public:
|
2003-05-17 09:05:07 +02:00
|
|
|
|
2005-08-12 12:54:42 +02:00
|
|
|
ulonglong options;
|
2006-06-27 19:28:32 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
In sql_cache we store SQL_CACHE flag as specified by user to be
|
|
|
|
able to restore SELECT statement from internal structures.
|
|
|
|
*/
|
|
|
|
enum e_sql_cache { SQL_CACHE_UNSPECIFIED, SQL_NO_CACHE, SQL_CACHE };
|
|
|
|
e_sql_cache sql_cache;
|
|
|
|
|
2003-11-17 19:53:40 +01:00
|
|
|
/*
|
|
|
|
result of this query can't be cached, bit field, can be :
|
|
|
|
UNCACHEABLE_DEPENDENT
|
|
|
|
UNCACHEABLE_RAND
|
2003-11-18 21:04:01 +01:00
|
|
|
UNCACHEABLE_SIDEEFFECT
|
2004-02-01 19:07:44 +01:00
|
|
|
UNCACHEABLE_EXPLAIN
|
2005-06-07 22:34:53 +02:00
|
|
|
UNCACHEABLE_PREPARE
|
2003-11-17 19:53:40 +01:00
|
|
|
*/
|
|
|
|
uint8 uncacheable;
|
2001-06-03 16:07:26 +02:00
|
|
|
enum sub_select_type linkage;
|
2003-01-14 17:00:34 +01:00
|
|
|
bool no_table_names_allowed; /* used for global order by */
|
2003-06-25 00:19:09 +02:00
|
|
|
bool no_error; /* suppress error message (convert it to warnings) */
|
2002-10-30 12:18:52 +01:00
|
|
|
|
Bug#38296 (low memory crash with many conditions in a query)
This fix is for 5.0 only : back porting the 6.0 patch manually
The parser code in sql/sql_yacc.yy needs to be more robust to out of
memory conditions, so that when parsing a query fails due to OOM,
the thread gracefully returns an error.
Before this fix, a new/alloc returning NULL could:
- cause a crash, if dereferencing the NULL pointer,
- produce a corrupted parsed tree, containing NULL nodes,
- alter the semantic of a query, by silently dropping token values or nodes
With this fix:
- C++ constructors are *not* executed with a NULL "this" pointer
when operator new fails.
This is achieved by declaring "operator new" with a "throw ()" clause,
so that a failed new gracefully returns NULL on OOM conditions.
- calls to new/alloc are tested for a NULL result,
- The thread diagnostic area is set to an error status when OOM occurs.
This ensures that a request failing in the server properly returns an
ER_OUT_OF_RESOURCES error to the client.
- OOM conditions cause the parser to stop immediately (MYSQL_YYABORT).
This prevents causing further crashes when using a partially built parsed
tree in further rules in the parser.
No test scripts are provided, since automating OOM failures is not
instrumented in the server.
Tested under the debugger, to verify that an error in alloc_root cause the
thread to returns gracefully all the way to the client application, with
an ER_OUT_OF_RESOURCES error.
2008-08-11 18:10:00 +02:00
|
|
|
static void *operator new(size_t size) throw ()
|
2002-10-30 12:18:52 +01:00
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
return sql_alloc(size);
|
2002-10-30 12:18:52 +01:00
|
|
|
}
|
Bug#38296 (low memory crash with many conditions in a query)
This fix is for 5.0 only : back porting the 6.0 patch manually
The parser code in sql/sql_yacc.yy needs to be more robust to out of
memory conditions, so that when parsing a query fails due to OOM,
the thread gracefully returns an error.
Before this fix, a new/alloc returning NULL could:
- cause a crash, if dereferencing the NULL pointer,
- produce a corrupted parsed tree, containing NULL nodes,
- alter the semantic of a query, by silently dropping token values or nodes
With this fix:
- C++ constructors are *not* executed with a NULL "this" pointer
when operator new fails.
This is achieved by declaring "operator new" with a "throw ()" clause,
so that a failed new gracefully returns NULL on OOM conditions.
- calls to new/alloc are tested for a NULL result,
- The thread diagnostic area is set to an error status when OOM occurs.
This ensures that a request failing in the server properly returns an
ER_OUT_OF_RESOURCES error to the client.
- OOM conditions cause the parser to stop immediately (MYSQL_YYABORT).
This prevents causing further crashes when using a partially built parsed
tree in further rules in the parser.
No test scripts are provided, since automating OOM failures is not
instrumented in the server.
Tested under the debugger, to verify that an error in alloc_root cause the
thread to returns gracefully all the way to the client application, with
an ER_OUT_OF_RESOURCES error.
2008-08-11 18:10:00 +02:00
|
|
|
static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
|
2003-08-18 23:08:08 +02:00
|
|
|
{ return (void*) alloc_root(mem_root, (uint) size); }
|
2004-11-28 15:53:17 +01:00
|
|
|
static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
|
2005-02-15 01:55:44 +01:00
|
|
|
static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
|
2003-02-14 10:47:41 +01:00
|
|
|
st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
|
2002-10-30 12:18:52 +01:00
|
|
|
virtual ~st_select_lex_node() {}
|
|
|
|
inline st_select_lex_node* get_master() { return master; }
|
|
|
|
virtual void init_query();
|
|
|
|
virtual void init_select();
|
2002-05-06 23:04:16 +02:00
|
|
|
void include_down(st_select_lex_node *upper);
|
|
|
|
void include_neighbour(st_select_lex_node *before);
|
2003-07-03 01:30:52 +02:00
|
|
|
void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
|
2002-05-06 23:04:16 +02:00
|
|
|
void include_global(st_select_lex_node **plink);
|
|
|
|
void exclude();
|
2002-10-30 12:18:52 +01:00
|
|
|
|
|
|
|
virtual st_select_lex_unit* master_unit()= 0;
|
|
|
|
virtual st_select_lex* outer_select()= 0;
|
2003-07-03 01:30:52 +02:00
|
|
|
virtual st_select_lex* return_after_parsing()= 0;
|
2002-10-30 12:18:52 +01:00
|
|
|
|
|
|
|
virtual bool set_braces(bool value);
|
|
|
|
virtual bool inc_in_sum_expr();
|
|
|
|
virtual uint get_in_sum_expr();
|
|
|
|
virtual TABLE_LIST* get_table_list();
|
|
|
|
virtual List<Item>* get_item_list();
|
2003-01-09 21:42:31 +01:00
|
|
|
virtual ulong get_table_join_options();
|
2002-12-06 20:11:27 +01:00
|
|
|
virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
|
2002-10-30 12:18:52 +01:00
|
|
|
LEX_STRING *alias,
|
2003-01-09 02:55:26 +01:00
|
|
|
ulong table_options,
|
2002-10-30 12:18:52 +01:00
|
|
|
thr_lock_type flags= TL_UNLOCK,
|
2007-07-23 18:09:48 +02:00
|
|
|
List<Index_hint> *hints= 0,
|
2003-07-16 21:30:49 +02:00
|
|
|
LEX_STRING *option= 0);
|
2002-11-21 21:25:53 +01:00
|
|
|
virtual void set_lock_for_tables(thr_lock_type lock_type) {}
|
2003-07-02 00:45:22 +02:00
|
|
|
|
2002-11-28 18:29:26 +01:00
|
|
|
friend class st_select_lex_unit;
|
2002-12-15 21:01:09 +01:00
|
|
|
friend bool mysql_new_select(struct st_lex *lex, bool move_down);
|
2005-11-01 14:54:30 +01:00
|
|
|
friend bool mysql_make_view(THD *thd, File_parser *parser,
|
2006-08-08 22:05:42 +02:00
|
|
|
TABLE_LIST *table, uint flags);
|
2002-05-06 23:04:16 +02:00
|
|
|
private:
|
|
|
|
void fast_exclude();
|
|
|
|
};
|
2002-10-30 12:18:52 +01:00
|
|
|
typedef class st_select_lex_node SELECT_LEX_NODE;
|
2002-05-06 23:04:16 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group
|
|
|
|
SELECT_LEXs
|
|
|
|
*/
|
2002-09-03 08:50:36 +02:00
|
|
|
class THD;
|
|
|
|
class select_result;
|
|
|
|
class JOIN;
|
|
|
|
class select_union;
|
2004-10-26 18:30:01 +02:00
|
|
|
class Procedure;
|
2002-05-27 19:52:54 +02:00
|
|
|
class st_select_lex_unit: public st_select_lex_node {
|
2002-09-03 08:50:36 +02:00
|
|
|
protected:
|
|
|
|
TABLE_LIST result_table_list;
|
|
|
|
select_union *union_result;
|
|
|
|
TABLE *table; /* temporary table using for appending UNION results */
|
2003-01-25 01:25:52 +01:00
|
|
|
|
2002-09-03 08:50:36 +02:00
|
|
|
select_result *result;
|
2006-11-30 02:40:42 +01:00
|
|
|
ulonglong found_rows_for_union;
|
2006-12-14 23:51:37 +01:00
|
|
|
bool saved_error;
|
|
|
|
|
2005-10-13 09:53:00 +02:00
|
|
|
public:
|
2003-08-23 20:21:02 +02:00
|
|
|
bool prepared, // prepare phase already performed for UNION (unit)
|
2002-10-27 20:29:40 +01:00
|
|
|
optimized, // optimize phase already performed for UNION (unit)
|
2004-02-10 01:18:22 +01:00
|
|
|
executed, // already executed
|
|
|
|
cleaned;
|
2003-11-23 01:01:15 +01:00
|
|
|
|
|
|
|
// list of fields which points to temporary table for union
|
|
|
|
List<Item> item_list;
|
2003-11-23 20:26:43 +01:00
|
|
|
/*
|
|
|
|
list of types of items inside union (used for union & derived tables)
|
|
|
|
|
|
|
|
Item_type_holders from which this list consist may have pointers to Field,
|
|
|
|
pointers is valid only after preparing SELECTS of this unit and before
|
|
|
|
any SELECT of this unit execution
|
|
|
|
*/
|
2003-11-23 01:01:15 +01:00
|
|
|
List<Item> types;
|
2002-05-06 23:04:16 +02:00
|
|
|
/*
|
|
|
|
Pointer to 'last' select or pointer to unit where stored
|
|
|
|
global parameters for union
|
|
|
|
*/
|
2003-07-03 01:30:52 +02:00
|
|
|
st_select_lex *global_parameters;
|
2003-03-11 00:06:28 +01:00
|
|
|
//node on wich we should return current_select pointer after parsing subquery
|
2003-07-03 01:30:52 +02:00
|
|
|
st_select_lex *return_to;
|
2002-05-06 23:04:16 +02:00
|
|
|
/* LIMIT clause runtime counters */
|
|
|
|
ha_rows select_limit_cnt, offset_limit_cnt;
|
2003-07-07 17:40:19 +02:00
|
|
|
/* not NULL if unit used in subselect, point to subselect item */
|
2002-09-03 08:50:36 +02:00
|
|
|
Item_subselect *item;
|
2003-07-03 01:30:52 +02:00
|
|
|
/* thread handler */
|
2003-01-25 01:25:52 +01:00
|
|
|
THD *thd;
|
2004-05-06 23:32:44 +02:00
|
|
|
/*
|
|
|
|
SELECT_LEX for hidden SELECT in onion which process global
|
|
|
|
ORDER BY and LIMIT
|
|
|
|
*/
|
2003-07-03 01:30:52 +02:00
|
|
|
st_select_lex *fake_select_lex;
|
2003-01-25 01:25:52 +01:00
|
|
|
|
2004-03-23 14:43:24 +01:00
|
|
|
st_select_lex *union_distinct; /* pointer to the last UNION DISTINCT */
|
2004-05-06 19:40:21 +02:00
|
|
|
bool describe; /* union exec() called for EXPLAIN */
|
2004-10-26 18:30:01 +02:00
|
|
|
Procedure *last_procedure; /* Pointer to procedure, if such exists */
|
2002-09-03 08:50:36 +02:00
|
|
|
|
2002-05-06 23:04:16 +02:00
|
|
|
void init_query();
|
2002-10-30 12:18:52 +01:00
|
|
|
st_select_lex_unit* master_unit();
|
|
|
|
st_select_lex* outer_select();
|
2004-05-06 19:55:12 +02:00
|
|
|
st_select_lex* first_select()
|
|
|
|
{
|
|
|
|
return my_reinterpret_cast(st_select_lex*)(slave);
|
|
|
|
}
|
|
|
|
st_select_lex_unit* next_unit()
|
|
|
|
{
|
|
|
|
return my_reinterpret_cast(st_select_lex_unit*)(next);
|
2003-03-06 16:02:10 +01:00
|
|
|
}
|
2003-07-03 01:30:52 +02:00
|
|
|
st_select_lex* return_after_parsing() { return return_to; }
|
2003-01-21 20:07:59 +01:00
|
|
|
void exclude_level();
|
2003-10-17 14:18:57 +02:00
|
|
|
void exclude_tree();
|
2002-05-27 19:52:54 +02:00
|
|
|
|
2002-09-03 08:50:36 +02:00
|
|
|
/* UNION methods */
|
2005-09-22 00:11:21 +02:00
|
|
|
bool prepare(THD *thd, select_result *result, ulong additional_options);
|
2004-10-20 03:04:37 +02:00
|
|
|
bool exec();
|
|
|
|
bool cleanup();
|
2004-02-12 02:10:26 +01:00
|
|
|
inline void unclean() { cleaned= 0; }
|
2004-02-08 19:14:13 +01:00
|
|
|
void reinit_exec_mechanism();
|
2003-10-16 14:54:47 +02:00
|
|
|
|
2008-02-22 11:30:33 +01:00
|
|
|
void print(String *str, enum_query_type query_type);
|
2004-05-06 23:08:21 +02:00
|
|
|
|
2006-04-21 07:15:38 +02:00
|
|
|
bool add_fake_select_lex(THD *thd);
|
2005-05-30 18:54:37 +02:00
|
|
|
void init_prepare_fake_select_lex(THD *thd);
|
2005-01-24 13:25:44 +01:00
|
|
|
inline bool is_prepared() { return prepared; }
|
2004-10-20 03:04:37 +02:00
|
|
|
bool change_result(select_subselect *result, select_subselect *old_result);
|
2005-05-30 18:54:37 +02:00
|
|
|
void set_limit(st_select_lex *values);
|
2005-08-09 22:23:56 +02:00
|
|
|
void set_thd(THD *thd_arg) { thd= thd_arg; }
|
2007-04-20 09:49:45 +02:00
|
|
|
inline bool is_union ();
|
2003-10-16 14:54:47 +02:00
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
friend void lex_start(THD *thd);
|
2007-01-12 21:22:41 +01:00
|
|
|
friend int subselect_union_engine::exec();
|
2005-09-22 00:11:21 +02:00
|
|
|
|
|
|
|
List<Item> *get_unit_column_types();
|
2002-05-06 23:04:16 +02:00
|
|
|
};
|
2005-09-22 00:11:21 +02:00
|
|
|
|
2002-07-05 07:15:57 +02:00
|
|
|
typedef class st_select_lex_unit SELECT_LEX_UNIT;
|
2002-05-06 23:04:16 +02:00
|
|
|
|
|
|
|
/*
|
2005-02-28 10:59:46 +01:00
|
|
|
SELECT_LEX - store information of parsed SELECT statment
|
2002-05-06 23:04:16 +02:00
|
|
|
*/
|
2002-10-02 12:33:08 +02:00
|
|
|
class st_select_lex: public st_select_lex_node
|
|
|
|
{
|
2002-05-27 19:52:54 +02:00
|
|
|
public:
|
2005-07-01 06:05:42 +02:00
|
|
|
Name_resolution_context context;
|
2005-08-12 16:57:19 +02:00
|
|
|
char *db;
|
2002-05-06 23:04:16 +02:00
|
|
|
Item *where, *having; /* WHERE & HAVING clauses */
|
2003-09-02 18:56:55 +02:00
|
|
|
Item *prep_where; /* saved WHERE clause for prepared statement processing */
|
2006-02-01 06:48:32 +01:00
|
|
|
Item *prep_having;/* saved HAVING clause for prepared statement processing */
|
2007-03-07 19:44:58 +01:00
|
|
|
/* Saved values of the WHERE and HAVING clauses*/
|
|
|
|
Item::cond_result cond_value, having_value;
|
2004-07-16 00:15:55 +02:00
|
|
|
/* point on lex in which it was created, used in view subquery detection */
|
|
|
|
st_lex *parent_lex;
|
2002-07-16 21:42:53 +02:00
|
|
|
enum olap_type olap;
|
2005-08-12 16:57:19 +02:00
|
|
|
/* FROM clause - points to the beginning of the TABLE_LIST::next_local list. */
|
|
|
|
SQL_LIST table_list;
|
|
|
|
SQL_LIST group_list; /* GROUP BY clause. */
|
|
|
|
List<Item> item_list; /* list of fields & expressions */
|
2007-03-05 18:08:41 +01:00
|
|
|
List<String> interval_list;
|
2005-10-12 01:32:14 +02:00
|
|
|
bool is_item_list_lookup;
|
2002-09-03 08:50:36 +02:00
|
|
|
/*
|
|
|
|
Usualy it is pointer to ftfunc_list_alloc, but in union used to create fake
|
|
|
|
select_lex for calling mysql_select under results of union
|
|
|
|
*/
|
|
|
|
List<Item_func_match> *ftfunc_list;
|
|
|
|
List<Item_func_match> ftfunc_list_alloc;
|
2002-07-01 18:06:24 +02:00
|
|
|
JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
|
2004-06-11 07:27:21 +02:00
|
|
|
List<TABLE_LIST> top_join_list; /* join list of the top level */
|
2004-07-01 22:46:43 +02:00
|
|
|
List<TABLE_LIST> *join_list; /* list for the currently parsed join */
|
2004-06-11 07:27:21 +02:00
|
|
|
TABLE_LIST *embedding; /* table embedding to the above list */
|
2005-08-12 16:57:19 +02:00
|
|
|
/*
|
|
|
|
Beginning of the list of leaves in a FROM clause, where the leaves
|
|
|
|
inlcude all base tables including view tables. The tables are connected
|
|
|
|
by TABLE_LIST::next_leaf, so leaf_tables points to the left-most leaf.
|
|
|
|
*/
|
|
|
|
TABLE_LIST *leaf_tables;
|
2004-06-11 07:27:21 +02:00
|
|
|
const char *type; /* type of select for EXPLAIN */
|
2003-07-03 01:30:52 +02:00
|
|
|
|
|
|
|
SQL_LIST order_list; /* ORDER clause */
|
2004-04-05 12:56:05 +02:00
|
|
|
SQL_LIST *gorder_list;
|
2005-06-07 12:11:36 +02:00
|
|
|
Item *select_limit, *offset_limit; /* LIMIT clause parameters */
|
2003-07-03 01:30:52 +02:00
|
|
|
// Arrays of pointers to top elements of all_fields list
|
|
|
|
Item **ref_pointer_array;
|
|
|
|
|
2003-08-05 08:56:21 +02:00
|
|
|
/*
|
|
|
|
number of items in select_list and HAVING clause used to get number
|
|
|
|
bigger then can be number of entries that will be added to all item
|
|
|
|
list during split_sum_func
|
|
|
|
*/
|
|
|
|
uint select_n_having_items;
|
2006-10-16 23:25:28 +02:00
|
|
|
uint cond_count; /* number of arguments of and/or/xor in where/having/on */
|
2007-08-15 19:24:18 +02:00
|
|
|
uint between_count; /* number of between predicates in where/having/on */
|
|
|
|
uint max_equal_elems; /* maximal number of elements in multiple equalities */
|
2007-02-24 21:04:15 +01:00
|
|
|
/*
|
|
|
|
Number of fields used in select list or where clause of current select
|
|
|
|
and all inner subselects.
|
|
|
|
*/
|
|
|
|
uint select_n_where_fields;
|
2003-07-03 01:30:52 +02:00
|
|
|
enum_parsing_place parsing_place; /* where we are parsing expression */
|
|
|
|
bool with_sum_func; /* sum function indicator */
|
2004-05-20 01:02:49 +02:00
|
|
|
/*
|
|
|
|
PS or SP cond natural joins was alredy processed with permanent
|
|
|
|
arena and all additional items which we need alredy stored in it
|
|
|
|
*/
|
|
|
|
bool conds_processed_with_permanent_arena;
|
2003-07-03 01:30:52 +02:00
|
|
|
|
2003-01-09 02:55:26 +01:00
|
|
|
ulong table_join_options;
|
2002-05-27 19:52:54 +02:00
|
|
|
uint in_sum_expr;
|
2002-09-26 22:08:22 +02:00
|
|
|
uint select_number; /* number of select (used for EXPLAIN) */
|
2005-10-15 23:32:37 +02:00
|
|
|
int nest_level; /* nesting level of select */
|
|
|
|
Item_sum *inner_sum_func_list; /* list of sum func in nested selects */
|
2003-01-25 01:25:52 +01:00
|
|
|
uint with_wild; /* item list contain '*' */
|
2002-08-30 11:40:40 +02:00
|
|
|
bool braces; /* SELECT ... UNION (SELECT ... ) <- this braces */
|
|
|
|
/* TRUE when having fix field called in processing of this SELECT */
|
|
|
|
bool having_fix_field;
|
2007-02-21 21:00:32 +01:00
|
|
|
/* List of references to fields referenced from inner selects */
|
|
|
|
List<Item_outer_ref> inner_refs_list;
|
2006-09-01 11:23:43 +02:00
|
|
|
/* Number of Item_sum-derived objects in this SELECT */
|
|
|
|
uint n_sum_items;
|
|
|
|
/* Number of Item_sum-derived objects in children and descendant SELECTs */
|
|
|
|
uint n_child_sum_items;
|
|
|
|
|
2004-05-05 20:21:41 +02:00
|
|
|
/* explicit LIMIT clause was used */
|
|
|
|
bool explicit_limit;
|
2004-06-09 22:32:20 +02:00
|
|
|
/*
|
|
|
|
there are subquery in HAVING clause => we can't close tables before
|
|
|
|
query processing end even if we use temporary table
|
|
|
|
*/
|
|
|
|
bool subquery_in_having;
|
2006-10-31 18:51:09 +01:00
|
|
|
/* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
|
|
|
|
bool is_correlated;
|
2005-06-21 19:15:21 +02:00
|
|
|
/*
|
|
|
|
This variable is required to ensure proper work of subqueries and
|
|
|
|
stored procedures. Generally, one should use the states of
|
|
|
|
Query_arena to determine if it's a statement prepare or first
|
|
|
|
execution of a stored procedure. However, in case when there was an
|
|
|
|
error during the first execution of a stored procedure, the SP body
|
|
|
|
is not expelled from the SP cache. Therefore, a deeply nested
|
|
|
|
subquery might be left unoptimized. So we need this per-subquery
|
|
|
|
variable to inidicate the optimization/execution state of every
|
|
|
|
subquery. Prepared statements work OK in that regard, as in
|
|
|
|
case of an error during prepare the PS is not created.
|
|
|
|
*/
|
|
|
|
bool first_execution;
|
2008-10-07 23:34:00 +02:00
|
|
|
bool first_natural_join_processing;
|
2004-06-30 14:54:32 +02:00
|
|
|
bool first_cond_optimization;
|
2004-07-23 08:20:58 +02:00
|
|
|
/* do not wrap view fields with Item_ref */
|
|
|
|
bool no_wrap_view_item;
|
2005-03-28 14:13:31 +02:00
|
|
|
/* exclude this select from check of unique_table() */
|
|
|
|
bool exclude_from_table_unique_test;
|
2007-01-11 21:18:01 +01:00
|
|
|
/* List of fields that aren't under an aggregate function */
|
|
|
|
List<Item_field> non_agg_fields;
|
|
|
|
/* index in the select list of the expression currently being fixed */
|
|
|
|
int cur_pos_in_select_list;
|
2003-07-29 15:59:46 +02:00
|
|
|
|
2006-10-24 14:26:41 +02:00
|
|
|
List<udf_func> udf_list; /* udf function calls stack */
|
2009-03-05 15:22:33 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
Per sub-query locking strategy.
|
|
|
|
Note: This variable might interfer with the corresponding statement-level
|
|
|
|
variable Lex::lock_option because on how different parser rules depend
|
|
|
|
on eachother.
|
|
|
|
*/
|
|
|
|
thr_lock_type lock_option;
|
|
|
|
|
2007-01-31 15:04:38 +01:00
|
|
|
/*
|
|
|
|
This is a copy of the original JOIN USING list that comes from
|
|
|
|
the parser. The parser :
|
|
|
|
1. Sets the natural_join of the second TABLE_LIST in the join
|
|
|
|
and the st_select_lex::prev_join_using.
|
|
|
|
2. Makes a parent TABLE_LIST and sets its is_natural_join/
|
|
|
|
join_using_fields members.
|
|
|
|
3. Uses the wrapper TABLE_LIST as a table in the upper level.
|
|
|
|
We cannot assign directly to join_using_fields in the parser because
|
|
|
|
at stage (1.) the parent TABLE_LIST is not constructed yet and
|
|
|
|
the assignment will override the JOIN USING fields of the lower level
|
|
|
|
joins on the right.
|
|
|
|
*/
|
|
|
|
List<String> *prev_join_using;
|
2008-03-27 17:49:32 +01:00
|
|
|
/*
|
|
|
|
Bitmap used in the ONLY_FULL_GROUP_BY_MODE to prevent mixture of aggregate
|
|
|
|
functions and non aggregated fields when GROUP BY list is absent.
|
|
|
|
Bits:
|
|
|
|
0 - non aggregated fields are used in this select,
|
|
|
|
defined as NON_AGG_FIELD_USED.
|
|
|
|
1 - aggregate functions are used in this select,
|
|
|
|
defined as SUM_FUNC_USED.
|
|
|
|
*/
|
|
|
|
uint8 full_group_by_flag;
|
2002-05-06 23:04:16 +02:00
|
|
|
void init_query();
|
|
|
|
void init_select();
|
2002-10-30 12:18:52 +01:00
|
|
|
st_select_lex_unit* master_unit();
|
2002-05-27 19:52:54 +02:00
|
|
|
st_select_lex_unit* first_inner_unit()
|
|
|
|
{
|
|
|
|
return (st_select_lex_unit*) slave;
|
|
|
|
}
|
2002-10-30 12:18:52 +01:00
|
|
|
st_select_lex* outer_select();
|
2002-05-26 21:50:32 +02:00
|
|
|
st_select_lex* next_select() { return (st_select_lex*) next; }
|
2002-11-13 10:59:03 +01:00
|
|
|
st_select_lex* next_select_in_list()
|
2002-05-27 19:52:54 +02:00
|
|
|
{
|
|
|
|
return (st_select_lex*) link_next;
|
|
|
|
}
|
|
|
|
st_select_lex_node** next_select_in_list_addr()
|
|
|
|
{
|
|
|
|
return &link_next;
|
|
|
|
}
|
2003-07-03 01:30:52 +02:00
|
|
|
st_select_lex* return_after_parsing()
|
2003-03-11 00:06:28 +01:00
|
|
|
{
|
|
|
|
return master_unit()->return_after_parsing();
|
|
|
|
}
|
2002-05-27 19:52:54 +02:00
|
|
|
|
2003-07-03 01:30:52 +02:00
|
|
|
void mark_as_dependent(st_select_lex *last);
|
|
|
|
|
2002-10-30 12:18:52 +01:00
|
|
|
bool set_braces(bool value);
|
|
|
|
bool inc_in_sum_expr();
|
|
|
|
uint get_in_sum_expr();
|
2002-11-04 21:12:45 +01:00
|
|
|
|
2002-12-06 20:11:27 +01:00
|
|
|
bool add_item_to_list(THD *thd, Item *item);
|
|
|
|
bool add_group_to_list(THD *thd, Item *item, bool asc);
|
2002-10-30 12:18:52 +01:00
|
|
|
bool add_ftfunc_to_list(Item_func_match *func);
|
2003-07-03 01:30:52 +02:00
|
|
|
bool add_order_to_list(THD *thd, Item *item, bool asc);
|
2002-12-06 20:11:27 +01:00
|
|
|
TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
|
2002-10-30 12:18:52 +01:00
|
|
|
LEX_STRING *alias,
|
2003-01-09 02:55:26 +01:00
|
|
|
ulong table_options,
|
2002-10-30 12:18:52 +01:00
|
|
|
thr_lock_type flags= TL_UNLOCK,
|
2007-07-23 18:09:48 +02:00
|
|
|
List<Index_hint> *hints= 0,
|
2003-08-27 00:14:13 +02:00
|
|
|
LEX_STRING *option= 0);
|
2003-07-03 01:30:52 +02:00
|
|
|
TABLE_LIST* get_table_list();
|
2004-06-11 07:27:21 +02:00
|
|
|
bool init_nested_join(THD *thd);
|
|
|
|
TABLE_LIST *end_nested_join(THD *thd);
|
|
|
|
TABLE_LIST *nest_last_join(THD *thd);
|
|
|
|
void add_joined_table(TABLE_LIST *table);
|
|
|
|
TABLE_LIST *convert_right_join();
|
2003-07-03 01:30:52 +02:00
|
|
|
List<Item>* get_item_list();
|
|
|
|
ulong get_table_join_options();
|
2002-11-21 21:25:53 +01:00
|
|
|
void set_lock_for_tables(thr_lock_type lock_type);
|
2002-11-05 00:10:05 +01:00
|
|
|
inline void init_order()
|
|
|
|
{
|
|
|
|
order_list.elements= 0;
|
|
|
|
order_list.first= 0;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
order_list.next= (uchar**) &order_list.first;
|
2002-11-05 00:10:05 +01:00
|
|
|
}
|
2005-07-05 12:37:02 +02:00
|
|
|
/*
|
|
|
|
This method created for reiniting LEX in mysql_admin_table() and can be
|
|
|
|
used only if you are going remove all SELECT_LEX & units except belonger
|
|
|
|
to LEX (LEX::unit & LEX::select, for other purposes there are
|
|
|
|
SELECT_LEX_UNIT::exclude_level & SELECT_LEX_UNIT::exclude_tree
|
|
|
|
*/
|
|
|
|
void cut_subtree() { slave= 0; }
|
2003-07-03 01:30:52 +02:00
|
|
|
bool test_limit();
|
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
friend void lex_start(THD *thd);
|
2006-09-01 11:23:43 +02:00
|
|
|
st_select_lex() : n_sum_items(0), n_child_sum_items(0) {}
|
2003-07-03 01:30:52 +02:00
|
|
|
void make_empty_select()
|
2003-03-06 16:02:10 +01:00
|
|
|
{
|
|
|
|
init_query();
|
|
|
|
init_select();
|
|
|
|
}
|
2003-08-16 12:26:48 +02:00
|
|
|
bool setup_ref_array(THD *thd, uint order_group_num);
|
2008-02-22 11:30:33 +01:00
|
|
|
void print(THD *thd, String *str, enum_query_type query_type);
|
|
|
|
static void print_order(String *str,
|
|
|
|
ORDER *order,
|
|
|
|
enum_query_type query_type);
|
|
|
|
void print_limit(THD *thd, String *str, enum_query_type query_type);
|
2006-09-16 18:50:48 +02:00
|
|
|
void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
|
2005-06-24 20:48:12 +02:00
|
|
|
/*
|
|
|
|
Destroy the used execution plan (JOIN) of this subtree (this
|
|
|
|
SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
|
|
|
|
*/
|
|
|
|
bool cleanup();
|
2005-10-13 09:53:00 +02:00
|
|
|
/*
|
|
|
|
Recursively cleanup the join of this select lex and of all nested
|
|
|
|
select lexes.
|
|
|
|
*/
|
|
|
|
void cleanup_all_joins(bool full);
|
2007-03-05 18:08:41 +01:00
|
|
|
|
|
|
|
void set_index_hint_type(enum index_hint_type type, index_clause_map clause);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Add a index hint to the tagged list of hints. The type and clause of the
|
|
|
|
hint will be the current ones (set by set_index_hint())
|
|
|
|
*/
|
|
|
|
bool add_index_hint (THD *thd, char *str, uint length);
|
|
|
|
|
|
|
|
/* make a list to hold index hints */
|
|
|
|
void alloc_index_hints (THD *thd);
|
|
|
|
/* read and clear the index hints */
|
2007-07-23 18:09:48 +02:00
|
|
|
List<Index_hint>* pop_index_hints(void)
|
2007-03-05 18:08:41 +01:00
|
|
|
{
|
2007-07-23 18:09:48 +02:00
|
|
|
List<Index_hint> *hints= index_hints;
|
2007-03-05 18:08:41 +01:00
|
|
|
index_hints= NULL;
|
|
|
|
return hints;
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear_index_hints(void) { index_hints= NULL; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
/* current index hint kind. used in filling up index_hints */
|
|
|
|
enum index_hint_type current_index_hint_type;
|
|
|
|
index_clause_map current_index_hint_clause;
|
|
|
|
/* a list of USE/FORCE/IGNORE INDEX */
|
2007-07-23 18:09:48 +02:00
|
|
|
List<Index_hint> *index_hints;
|
2002-05-06 23:04:16 +02:00
|
|
|
};
|
2002-07-05 07:15:57 +02:00
|
|
|
typedef class st_select_lex SELECT_LEX;
|
2001-06-03 16:07:26 +02:00
|
|
|
|
2007-04-20 09:49:45 +02:00
|
|
|
inline bool st_select_lex_unit::is_union ()
|
|
|
|
{
|
|
|
|
return first_select()->next_select() &&
|
|
|
|
first_select()->next_select()->linkage == UNION_TYPE;
|
|
|
|
}
|
|
|
|
|
2006-01-17 08:40:00 +01:00
|
|
|
#define ALTER_ADD_COLUMN (1L << 0)
|
|
|
|
#define ALTER_DROP_COLUMN (1L << 1)
|
|
|
|
#define ALTER_CHANGE_COLUMN (1L << 2)
|
|
|
|
#define ALTER_ADD_INDEX (1L << 3)
|
|
|
|
#define ALTER_DROP_INDEX (1L << 4)
|
|
|
|
#define ALTER_RENAME (1L << 5)
|
|
|
|
#define ALTER_ORDER (1L << 6)
|
|
|
|
#define ALTER_OPTIONS (1L << 7)
|
|
|
|
#define ALTER_CHANGE_COLUMN_DEFAULT (1L << 8)
|
|
|
|
#define ALTER_KEYS_ONOFF (1L << 9)
|
|
|
|
#define ALTER_CONVERT (1L << 10)
|
|
|
|
#define ALTER_FORCE (1L << 11)
|
|
|
|
#define ALTER_RECREATE (1L << 12)
|
|
|
|
#define ALTER_ADD_PARTITION (1L << 13)
|
|
|
|
#define ALTER_DROP_PARTITION (1L << 14)
|
|
|
|
#define ALTER_COALESCE_PARTITION (1L << 15)
|
|
|
|
#define ALTER_REORGANIZE_PARTITION (1L << 16)
|
|
|
|
#define ALTER_PARTITION (1L << 17)
|
2008-10-10 20:12:38 +02:00
|
|
|
#define ALTER_ADMIN_PARTITION (1L << 18)
|
2006-01-17 08:40:00 +01:00
|
|
|
#define ALTER_TABLE_REORG (1L << 19)
|
|
|
|
#define ALTER_REBUILD_PARTITION (1L << 20)
|
|
|
|
#define ALTER_ALL_PARTITION (1L << 21)
|
2008-10-10 20:12:38 +02:00
|
|
|
#define ALTER_REMOVE_PARTITIONING (1L << 22)
|
|
|
|
#define ALTER_FOREIGN_KEY (1L << 23)
|
2001-06-03 16:07:26 +02:00
|
|
|
|
2007-06-04 12:03:15 +02:00
|
|
|
enum enum_alter_table_change_level
|
|
|
|
{
|
|
|
|
ALTER_TABLE_METADATA_ONLY= 0,
|
|
|
|
ALTER_TABLE_DATA_CHANGED= 1,
|
|
|
|
ALTER_TABLE_INDEX_CHANGED= 2
|
|
|
|
};
|
|
|
|
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
/**
|
|
|
|
@brief Parsing data for CREATE or ALTER TABLE.
|
|
|
|
|
|
|
|
This structure contains a list of columns or indexes to be created,
|
|
|
|
altered or dropped.
|
|
|
|
*/
|
|
|
|
|
|
|
|
class Alter_info
|
2004-05-21 16:57:03 +02:00
|
|
|
{
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
public:
|
2007-06-04 12:03:15 +02:00
|
|
|
List<Alter_drop> drop_list;
|
|
|
|
List<Alter_column> alter_list;
|
|
|
|
List<Key> key_list;
|
2007-06-12 02:08:51 +02:00
|
|
|
List<Create_field> create_list;
|
2007-06-04 12:03:15 +02:00
|
|
|
uint flags;
|
|
|
|
enum enum_enable_or_disable keys_onoff;
|
|
|
|
enum tablespace_op_type tablespace_op;
|
|
|
|
List<char> partition_names;
|
|
|
|
uint no_parts;
|
|
|
|
enum_alter_table_change_level change_level;
|
2007-06-12 02:08:51 +02:00
|
|
|
Create_field *datetime_field;
|
2007-08-15 15:43:08 +02:00
|
|
|
bool error_if_not_empty;
|
|
|
|
|
2004-05-21 16:57:03 +02:00
|
|
|
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
Alter_info() :
|
|
|
|
flags(0),
|
|
|
|
keys_onoff(LEAVE_AS_IS),
|
|
|
|
tablespace_op(NO_TABLESPACE_OP),
|
2007-06-04 12:03:15 +02:00
|
|
|
no_parts(0),
|
|
|
|
change_level(ALTER_TABLE_METADATA_ONLY),
|
|
|
|
datetime_field(NULL),
|
|
|
|
error_if_not_empty(FALSE)
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
{}
|
|
|
|
|
|
|
|
void reset()
|
2005-08-19 16:26:05 +02:00
|
|
|
{
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
drop_list.empty();
|
|
|
|
alter_list.empty();
|
|
|
|
key_list.empty();
|
|
|
|
create_list.empty();
|
|
|
|
flags= 0;
|
2005-08-19 16:26:05 +02:00
|
|
|
keys_onoff= LEAVE_AS_IS;
|
|
|
|
tablespace_op= NO_TABLESPACE_OP;
|
|
|
|
no_parts= 0;
|
|
|
|
partition_names.empty();
|
2007-06-04 12:03:15 +02:00
|
|
|
change_level= ALTER_TABLE_METADATA_ONLY;
|
|
|
|
datetime_field= 0;
|
|
|
|
error_if_not_empty= FALSE;
|
2005-08-19 16:26:05 +02:00
|
|
|
}
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root);
|
|
|
|
private:
|
|
|
|
Alter_info &operator=(const Alter_info &rhs); // not implemented
|
|
|
|
Alter_info(const Alter_info &rhs); // not implemented
|
|
|
|
};
|
2004-05-21 16:57:03 +02:00
|
|
|
|
2003-12-10 19:05:37 +01:00
|
|
|
struct st_sp_chistics
|
|
|
|
{
|
|
|
|
LEX_STRING comment;
|
2004-10-14 18:07:09 +02:00
|
|
|
enum enum_sp_suid_behaviour suid;
|
2003-12-10 19:05:37 +01:00
|
|
|
bool detistic;
|
2004-10-14 18:07:09 +02:00
|
|
|
enum enum_sp_data_access daccess;
|
2003-12-10 19:05:37 +01:00
|
|
|
};
|
|
|
|
|
2004-09-07 14:29:46 +02:00
|
|
|
|
|
|
|
struct st_trg_chistics
|
|
|
|
{
|
|
|
|
enum trg_action_time_type action_time;
|
|
|
|
enum trg_event_type event;
|
|
|
|
};
|
|
|
|
|
2005-11-06 01:36:40 +01:00
|
|
|
extern sys_var *trg_new_row_fake_var;
|
2004-09-07 14:29:46 +02:00
|
|
|
|
2005-01-16 13:16:23 +01:00
|
|
|
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
|
|
|
|
XA_SUSPEND, XA_FOR_MIGRATE};
|
|
|
|
|
2006-05-30 07:45:23 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
Class representing list of all tables used by statement.
|
|
|
|
It also contains information about stored functions used by statement
|
|
|
|
since during its execution we may have to add all tables used by its
|
|
|
|
stored functions/triggers to this list in order to pre-open and lock
|
|
|
|
them.
|
|
|
|
|
|
|
|
Also used by st_lex::reset_n_backup/restore_backup_query_tables_list()
|
|
|
|
methods to save and restore this information.
|
|
|
|
*/
|
|
|
|
|
|
|
|
class Query_tables_list
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/* Global list of all tables used by this statement */
|
|
|
|
TABLE_LIST *query_tables;
|
|
|
|
/* Pointer to next_global member of last element in the previous list. */
|
|
|
|
TABLE_LIST **query_tables_last;
|
|
|
|
/*
|
|
|
|
If non-0 then indicates that query requires prelocking and points to
|
|
|
|
next_global member of last own element in query table list (i.e. last
|
|
|
|
table which was not added to it as part of preparation to prelocking).
|
|
|
|
0 - indicates that this query does not need prelocking.
|
|
|
|
*/
|
|
|
|
TABLE_LIST **query_tables_own_last;
|
2006-11-01 13:41:48 +01:00
|
|
|
/*
|
|
|
|
Set of stored routines called by statement.
|
|
|
|
(Note that we use lazy-initialization for this hash).
|
|
|
|
*/
|
|
|
|
enum { START_SROUTINES_HASH_SIZE= 16 };
|
2006-05-30 07:45:23 +02:00
|
|
|
HASH sroutines;
|
|
|
|
/*
|
|
|
|
List linking elements of 'sroutines' set. Allows you to add new elements
|
|
|
|
to this set as you iterate through the list of existing elements.
|
|
|
|
'sroutines_list_own_last' is pointer to ::next member of last element of
|
|
|
|
this list which represents routine which is explicitly used by query.
|
|
|
|
'sroutines_list_own_elements' number of explicitly used routines.
|
|
|
|
We use these two members for restoring of 'sroutines_list' to the state
|
|
|
|
in which it was right after query parsing.
|
|
|
|
*/
|
|
|
|
SQL_LIST sroutines_list;
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
uchar **sroutines_list_own_last;
|
2006-05-30 07:45:23 +02:00
|
|
|
uint sroutines_list_own_elements;
|
|
|
|
|
|
|
|
/*
|
|
|
|
These constructor and destructor serve for creation/destruction
|
|
|
|
of Query_tables_list instances which are used as backup storage.
|
|
|
|
*/
|
|
|
|
Query_tables_list() {}
|
|
|
|
~Query_tables_list() {}
|
|
|
|
|
|
|
|
/* Initializes (or resets) Query_tables_list object for "real" use. */
|
|
|
|
void reset_query_tables_list(bool init);
|
|
|
|
void destroy_query_tables_list();
|
|
|
|
void set_query_tables_list(Query_tables_list *state)
|
|
|
|
{
|
|
|
|
*this= *state;
|
|
|
|
}
|
|
|
|
|
A fix and a test case for
Bug#19022 "Memory bug when switching db during trigger execution"
Bug#17199 "Problem when view calls function from another database."
Bug#18444 "Fully qualified stored function names don't work correctly in
SELECT statements"
Documentation note: this patch introduces a change in behaviour of prepared
statements.
This patch adds a few new invariants with regard to how THD::db should
be used. These invariants should be preserved in future:
- one should never refer to THD::db by pointer and always make a deep copy
(strmake, strdup)
- one should never compare two databases by pointer, but use strncmp or
my_strncasecmp
- TABLE_LIST object table->db should be always initialized in the parser or
by creator of the object.
For prepared statements it means that if the current database is changed
after a statement is prepared, the database that was current at prepare
remains active. This also means that you can not prepare a statement that
implicitly refers to the current database if the latter is not set.
This is not documented, and therefore needs documentation. This is NOT a
change in behavior for almost all SQL statements except:
- ALTER TABLE t1 RENAME t2
- OPTIMIZE TABLE t1
- ANALYZE TABLE t1
- TRUNCATE TABLE t1 --
until this patch t1 or t2 could be evaluated at the first execution of
prepared statement.
CURRENT_DATABASE() still works OK and is evaluated at every execution
of prepared statement.
Note, that in stored routines this is not an issue as the default
database is the database of the stored procedure and "use" statement
is prohibited in stored routines.
This patch makes obsolete the use of check_db_used (it was never used in the
old code too) and all other places that check for table->db and assign it
from THD::db if it's NULL, except the parser.
How this patch was created: THD::{db,db_length} were replaced with a
LEX_STRING, THD::db. All the places that refer to THD::{db,db_length} were
manually checked and:
- if the place uses thd->db by pointer, it was fixed to make a deep copy
- if a place compared two db pointers, it was fixed to compare them by value
(via strcmp/my_strcasecmp, whatever was approproate)
Then this intermediate patch was used to write a smaller patch that does the
same thing but without a rename.
TODO in 5.1:
- remove check_db_used
- deploy THD::set_db in mysql_change_db
See also comments to individual files.
2006-06-26 22:47:52 +02:00
|
|
|
/*
|
|
|
|
Direct addition to the list of query tables.
|
|
|
|
If you are using this function, you must ensure that the table
|
|
|
|
object, in particular table->db member, is initialized.
|
|
|
|
*/
|
2006-05-30 07:45:23 +02:00
|
|
|
void add_to_query_tables(TABLE_LIST *table)
|
|
|
|
{
|
|
|
|
*(table->prev_global= query_tables_last)= table;
|
|
|
|
query_tables_last= &table->next_global;
|
|
|
|
}
|
|
|
|
bool requires_prelocking()
|
|
|
|
{
|
|
|
|
return test(query_tables_own_last);
|
|
|
|
}
|
|
|
|
void mark_as_requiring_prelocking(TABLE_LIST **tables_own_last)
|
|
|
|
{
|
|
|
|
query_tables_own_last= tables_own_last;
|
|
|
|
}
|
|
|
|
/* Return pointer to first not-own table in query-tables or 0 */
|
|
|
|
TABLE_LIST* first_not_own_table()
|
|
|
|
{
|
|
|
|
return ( query_tables_own_last ? *query_tables_own_last : 0);
|
|
|
|
}
|
|
|
|
void chop_off_not_own_tables()
|
|
|
|
{
|
|
|
|
if (query_tables_own_last)
|
|
|
|
{
|
|
|
|
*query_tables_own_last= 0;
|
|
|
|
query_tables_last= query_tables_own_last;
|
|
|
|
query_tables_own_last= 0;
|
|
|
|
}
|
|
|
|
}
|
2007-05-14 14:45:38 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Has the parser/scanner detected that this statement is unsafe?
|
|
|
|
*/
|
|
|
|
inline bool is_stmt_unsafe() const {
|
|
|
|
return binlog_stmt_flags & (1U << BINLOG_STMT_FLAG_UNSAFE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Flag the current (top-level) statement as unsafe.
|
|
|
|
|
|
|
|
The flag will be reset after the statement has finished.
|
|
|
|
|
|
|
|
*/
|
|
|
|
inline void set_stmt_unsafe() {
|
|
|
|
binlog_stmt_flags|= (1U << BINLOG_STMT_FLAG_UNSAFE);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void clear_stmt_unsafe() {
|
|
|
|
binlog_stmt_flags&= ~(1U << BINLOG_STMT_FLAG_UNSAFE);
|
|
|
|
}
|
|
|
|
|
A fix and a test case for
Bug#21483 "Server abort or deadlock on INSERT DELAYED with another
implicit insert"
Also fixes and adds test cases for bugs:
20497 "Trigger with INSERT DELAYED causes Error 1165"
21714 "Wrong NEW.value and server abort on INSERT DELAYED to a
table with a trigger".
Post-review fixes.
Problem:
In MySQL INSERT DELAYED is a way to pipe all inserts into a
given table through a dedicated thread. This is necessary for
simplistic storage engines like MyISAM, which do not have internal
concurrency control or threading and thus can not
achieve efficient INSERT throughput without support from SQL layer.
DELAYED INSERT works as follows:
For every distinct table, which can accept DELAYED inserts and has
pending data to insert, a dedicated thread is created to write data
to disk. All user connection threads that attempt to
delayed-insert into this table interact with the dedicated thread in
producer/consumer fashion: all records to-be inserted are pushed
into a queue of the dedicated thread, which fetches the records and
writes them.
In this design, client connection threads never open or lock
the delayed insert table.
This functionality was introduced in version 3.23 and does not take
into account existence of triggers, views, or pre-locking.
E.g. if INSERT DELAYED is called from a stored function, which,
in turn, is called from another stored function that uses the delayed
table, a deadlock can occur, because delayed locking by-passes
pre-locking. Besides:
* the delayed thread works directly with the subject table through
the storage engine API and does not invoke triggers
* even if it was patched to invoke triggers, if triggers,
in turn, used other tables, the delayed thread would
have to open and lock involved tables (use pre-locking).
* even if it was patched to use pre-locking, without deadlock
detection the delayed thread could easily lock out user
connection threads in case when the same table is used both
in a trigger and on the right side of the insert query:
the delayed thread would not release locks until all inserts
are complete, and user connection can not complete inserts
without having locks on the tables used on the right side of the
query.
Solution:
These considerations suggest two general alternatives for the
future of INSERT DELAYED:
* it is considered a full-fledged alternative to normal INSERT
* it is regarded as an optimisation that is only relevant
for simplistic engines.
Since we missed our chance to provide complete support of new
features when 5.0 was in development, the first alternative
currently renders infeasible.
However, even the second alternative, which is to detect
new features and convert DELAYED insert into a normal insert,
is not easy to implement.
The catch-22 is that we don't know if the subject table has triggers
or is a view before we open it, and we only open it in the
delayed thread. We don't know if the query involves pre-locking
until we have opened all tables, and we always first create
the delayed thread, and only then open the remaining tables.
This patch detects the problematic scenarios and converts
DELAYED INSERT to a normal INSERT using the following approach:
* if the statement is executed under pre-locking (e.g. from
within a stored function or trigger) or the right
side may require pre-locking, we detect the situation
before creating a delayed insert thread and convert the statement
to a conventional INSERT.
* if the subject table is a view or has triggers, we shutdown
the delayed thread and convert the statement to a conventional
INSERT.
2007-05-16 07:51:05 +02:00
|
|
|
/**
|
|
|
|
true if the parsed tree contains references to stored procedures
|
|
|
|
or functions, false otherwise
|
|
|
|
*/
|
|
|
|
bool uses_stored_routines() const
|
|
|
|
{ return sroutines_list.elements != 0; }
|
2007-05-31 20:17:31 +02:00
|
|
|
|
2007-05-14 14:45:38 +02:00
|
|
|
private:
|
|
|
|
enum enum_binlog_stmt_flag {
|
|
|
|
BINLOG_STMT_FLAG_UNSAFE,
|
|
|
|
BINLOG_STMT_FLAG_COUNT
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Tells if the parsing stage detected properties of the statement,
|
|
|
|
for example: that some items require row-based binlogging to give
|
|
|
|
a reliable binlog/replication, or if we will use stored functions
|
|
|
|
or triggers which themselves need require row-based binlogging.
|
|
|
|
*/
|
|
|
|
uint32 binlog_stmt_flags;
|
2006-05-30 07:45:23 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-10-12 16:02:57 +02:00
|
|
|
/*
|
|
|
|
st_parsing_options contains the flags for constructions that are
|
|
|
|
allowed in the current statement.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct st_parsing_options
|
|
|
|
{
|
|
|
|
bool allows_variable;
|
|
|
|
bool allows_select_into;
|
|
|
|
bool allows_select_procedure;
|
|
|
|
bool allows_derived;
|
|
|
|
|
2007-02-04 14:49:24 +01:00
|
|
|
st_parsing_options() { reset(); }
|
|
|
|
void reset();
|
2006-10-12 16:02:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/**
|
|
|
|
The state of the lexical parser, when parsing comments.
|
|
|
|
*/
|
|
|
|
enum enum_comment_state
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
Not parsing comments.
|
|
|
|
*/
|
|
|
|
NO_COMMENT,
|
|
|
|
/**
|
|
|
|
Parsing comments that need to be preserved.
|
|
|
|
Typically, these are user comments '/' '*' ... '*' '/'.
|
|
|
|
*/
|
|
|
|
PRESERVE_COMMENT,
|
|
|
|
/**
|
|
|
|
Parsing comments that need to be discarded.
|
|
|
|
Typically, these are special comments '/' '*' '!' ... '*' '/',
|
|
|
|
or '/' '*' '!' 'M' 'M' 'm' 'm' 'm' ... '*' '/', where the comment
|
|
|
|
markers should not be expanded.
|
|
|
|
*/
|
|
|
|
DISCARD_COMMENT
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
/**
|
2007-08-15 15:43:08 +02:00
|
|
|
@brief This class represents the character input stream consumed during
|
2007-04-26 05:38:12 +02:00
|
|
|
lexical analysis.
|
2007-08-15 15:43:08 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
In addition to consuming the input stream, this class performs some
|
|
|
|
comment pre processing, by filtering out out of bound special text
|
|
|
|
from the query input stream.
|
|
|
|
Two buffers, with pointers inside each buffers, are maintained in
|
|
|
|
parallel. The 'raw' buffer is the original query text, which may
|
|
|
|
contain out-of-bound comments. The 'cpp' (for comments pre processor)
|
|
|
|
is the pre-processed buffer that contains only the query text that
|
|
|
|
should be seen once out-of-bound data is removed.
|
2007-04-26 05:38:12 +02:00
|
|
|
*/
|
2007-08-15 15:43:08 +02:00
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
class Lex_input_stream
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Lex_input_stream(THD *thd, const char* buff, unsigned int length);
|
|
|
|
~Lex_input_stream();
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/**
|
|
|
|
Set the echo mode.
|
2007-08-15 15:43:08 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
When echo is true, characters parsed from the raw input stream are
|
|
|
|
preserved. When false, characters parsed are silently ignored.
|
|
|
|
@param echo the echo mode.
|
|
|
|
*/
|
|
|
|
void set_echo(bool echo)
|
|
|
|
{
|
|
|
|
m_echo= echo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Skip binary from the input stream.
|
|
|
|
@param n number of bytes to accept.
|
|
|
|
*/
|
|
|
|
void skip_binary(int n)
|
|
|
|
{
|
|
|
|
if (m_echo)
|
|
|
|
{
|
|
|
|
memcpy(m_cpp_ptr, m_ptr, n);
|
|
|
|
m_cpp_ptr += n;
|
|
|
|
}
|
|
|
|
m_ptr += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Get a character, and advance in the stream.
|
|
|
|
@return the next character to parse.
|
|
|
|
*/
|
|
|
|
char yyGet()
|
|
|
|
{
|
|
|
|
char c= *m_ptr++;
|
|
|
|
if (m_echo)
|
|
|
|
*m_cpp_ptr++ = c;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Get the last character accepted.
|
|
|
|
@return the last character accepted.
|
|
|
|
*/
|
|
|
|
char yyGetLast()
|
|
|
|
{
|
|
|
|
return m_ptr[-1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Look at the next character to parse, but do not accept it.
|
|
|
|
*/
|
|
|
|
char yyPeek()
|
|
|
|
{
|
|
|
|
return m_ptr[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Look ahead at some character to parse.
|
|
|
|
@param n offset of the character to look up
|
|
|
|
*/
|
|
|
|
char yyPeekn(int n)
|
|
|
|
{
|
|
|
|
return m_ptr[n];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Cancel the effect of the last yyGet() or yySkip().
|
|
|
|
Note that the echo mode should not change between calls to yyGet / yySkip
|
|
|
|
and yyUnget. The caller is responsible for ensuring that.
|
|
|
|
*/
|
|
|
|
void yyUnget()
|
|
|
|
{
|
|
|
|
m_ptr--;
|
|
|
|
if (m_echo)
|
|
|
|
m_cpp_ptr--;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Accept a character, by advancing the input stream.
|
|
|
|
*/
|
|
|
|
void yySkip()
|
|
|
|
{
|
|
|
|
if (m_echo)
|
|
|
|
*m_cpp_ptr++ = *m_ptr++;
|
|
|
|
else
|
|
|
|
m_ptr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Accept multiple characters at once.
|
|
|
|
@param n the number of characters to accept.
|
|
|
|
*/
|
|
|
|
void yySkipn(int n)
|
|
|
|
{
|
|
|
|
if (m_echo)
|
|
|
|
{
|
|
|
|
memcpy(m_cpp_ptr, m_ptr, n);
|
|
|
|
m_cpp_ptr += n;
|
|
|
|
}
|
|
|
|
m_ptr += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
End of file indicator for the query text to parse.
|
|
|
|
@return true if there are no more characters to parse
|
|
|
|
*/
|
|
|
|
bool eof()
|
|
|
|
{
|
|
|
|
return (m_ptr >= m_end_of_query);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
End of file indicator for the query text to parse.
|
|
|
|
@param n number of characters expected
|
|
|
|
@return true if there are less than n characters to parse
|
|
|
|
*/
|
|
|
|
bool eof(int n)
|
|
|
|
{
|
|
|
|
return ((m_ptr + n) >= m_end_of_query);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the raw query buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_buf()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the pre-processed query buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_cpp_buf()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_cpp_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the end of the raw query buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_end_of_query()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_end_of_query;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Mark the stream position as the start of a new token. */
|
|
|
|
void start_token()
|
|
|
|
{
|
|
|
|
m_tok_start_prev= m_tok_start;
|
|
|
|
m_tok_start= m_ptr;
|
|
|
|
m_tok_end= m_ptr;
|
|
|
|
|
|
|
|
m_cpp_tok_start_prev= m_cpp_tok_start;
|
|
|
|
m_cpp_tok_start= m_cpp_ptr;
|
|
|
|
m_cpp_tok_end= m_cpp_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Adjust the starting position of the current token.
|
|
|
|
This is used to compensate for starting whitespace.
|
|
|
|
*/
|
|
|
|
void restart_token()
|
|
|
|
{
|
|
|
|
m_tok_start= m_ptr;
|
|
|
|
m_cpp_tok_start= m_cpp_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the token start position, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_tok_start()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_tok_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the token start position, in the pre-processed buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_cpp_tok_start()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_cpp_tok_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the token end position, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_tok_end()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_tok_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the token end position, in the pre-processed buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_cpp_tok_end()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_cpp_tok_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the previous token start position, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_tok_start_prev()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_tok_start_prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the current stream pointer, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_ptr()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the current stream pointer, in the pre-processed buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *get_cpp_ptr()
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
{
|
|
|
|
return m_cpp_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the length of the current token, in the raw buffer. */
|
|
|
|
uint yyLength()
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
The assumption is that the lexical analyser is always 1 character ahead,
|
|
|
|
which the -1 account for.
|
|
|
|
*/
|
|
|
|
DBUG_ASSERT(m_ptr > m_tok_start);
|
|
|
|
return (uint) ((m_ptr - m_tok_start) - 1);
|
|
|
|
}
|
|
|
|
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
/** Get the utf8-body string. */
|
|
|
|
const char *get_body_utf8_str()
|
|
|
|
{
|
|
|
|
return m_body_utf8;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the utf8-body length. */
|
|
|
|
uint get_body_utf8_length()
|
|
|
|
{
|
|
|
|
return m_body_utf8_ptr - m_body_utf8;
|
|
|
|
}
|
|
|
|
|
|
|
|
void body_utf8_start(THD *thd, const char *begin_ptr);
|
|
|
|
void body_utf8_append(const char *ptr);
|
|
|
|
void body_utf8_append(const char *ptr, const char *end_ptr);
|
|
|
|
void body_utf8_append_literal(THD *thd,
|
|
|
|
const LEX_STRING *txt,
|
|
|
|
CHARSET_INFO *txt_cs,
|
|
|
|
const char *end_ptr);
|
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
/** Current thread. */
|
|
|
|
THD *m_thd;
|
|
|
|
|
|
|
|
/** Current line number. */
|
|
|
|
uint yylineno;
|
|
|
|
|
|
|
|
/** Length of the last token parsed. */
|
|
|
|
uint yytoklen;
|
|
|
|
|
|
|
|
/** Interface with bison, value of the last token parsed. */
|
|
|
|
LEX_YYSTYPE yylval;
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
private:
|
|
|
|
/** Pointer to the current position in the raw input stream. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_ptr;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/** Starting position of the last token parsed, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_tok_start;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/** Ending position of the previous token parsed, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_tok_end;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/** End of the query text in the input stream, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_end_of_query;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/** Starting position of the previous token parsed, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_tok_start_prev;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/** Begining of the query text in the input stream, in the raw buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_buf;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
/** Length of the raw buffer. */
|
|
|
|
uint m_buf_length;
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/** Echo the parsed stream to the pre-processed buffer. */
|
|
|
|
bool m_echo;
|
|
|
|
|
|
|
|
/** Pre-processed buffer. */
|
2007-07-20 17:52:25 +02:00
|
|
|
char *m_cpp_buf;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/** Pointer to the current position in the pre-processed input stream. */
|
2007-07-20 17:52:25 +02:00
|
|
|
char *m_cpp_ptr;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Starting position of the last token parsed,
|
|
|
|
in the pre-processed buffer.
|
|
|
|
*/
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_cpp_tok_start;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Starting position of the previous token parsed,
|
|
|
|
in the pre-procedded buffer.
|
|
|
|
*/
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_cpp_tok_start_prev;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Ending position of the previous token parsed,
|
|
|
|
in the pre-processed buffer.
|
|
|
|
*/
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *m_cpp_tok_end;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
/** UTF8-body buffer created during parsing. */
|
|
|
|
char *m_body_utf8;
|
|
|
|
|
|
|
|
/** Pointer to the current position in the UTF8-body buffer. */
|
|
|
|
char *m_body_utf8_ptr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
Position in the pre-processed buffer. The query from m_cpp_buf to
|
|
|
|
m_cpp_utf_processed_ptr is converted to UTF8-body.
|
|
|
|
*/
|
|
|
|
const char *m_cpp_utf8_processed_ptr;
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
public:
|
2007-04-26 05:38:12 +02:00
|
|
|
|
|
|
|
/** Current state of the lexical analyser. */
|
|
|
|
enum my_lex_states next_state;
|
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
/**
|
|
|
|
Position of ';' in the stream, to delimit multiple queries.
|
|
|
|
This delimiter is in the raw buffer.
|
|
|
|
*/
|
2007-07-20 17:52:25 +02:00
|
|
|
const char *found_semicolon;
|
2007-04-26 05:38:12 +02:00
|
|
|
|
2007-08-03 12:25:23 +02:00
|
|
|
/** Token character bitmaps, to detect 7bit strings. */
|
|
|
|
uchar tok_bitmap;
|
2007-04-25 19:38:11 +02:00
|
|
|
|
2007-04-26 05:38:12 +02:00
|
|
|
/** SQL_MODE = IGNORE_SPACE. */
|
|
|
|
bool ignore_space;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/**
|
2007-05-11 15:26:12 +02:00
|
|
|
TRUE if we're parsing a prepared statement: in this mode
|
|
|
|
we should allow placeholders and disallow multi-statements.
|
|
|
|
*/
|
|
|
|
bool stmt_prepare_mode;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
/** State of the lexical analyser for comments. */
|
|
|
|
enum_comment_state in_comment;
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Starting position of the TEXT_STRING or IDENT in the pre-processed
|
|
|
|
buffer.
|
|
|
|
|
|
|
|
NOTE: this member must be used within MYSQLlex() function only.
|
|
|
|
*/
|
|
|
|
const char *m_cpp_text_start;
|
|
|
|
|
|
|
|
/**
|
|
|
|
Ending position of the TEXT_STRING or IDENT in the pre-processed
|
|
|
|
buffer.
|
|
|
|
|
|
|
|
NOTE: this member must be used within MYSQLlex() function only.
|
|
|
|
*/
|
|
|
|
const char *m_cpp_text_end;
|
|
|
|
|
|
|
|
/**
|
|
|
|
Character set specified by the character-set-introducer.
|
|
|
|
|
|
|
|
NOTE: this member must be used within MYSQLlex() function only.
|
|
|
|
*/
|
|
|
|
CHARSET_INFO *m_underscore_cs;
|
2007-04-26 05:38:12 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2000-07-31 21:29:14 +02:00
|
|
|
/* The state of the lex parsing. This is saved in the THD struct */
|
|
|
|
|
2006-05-30 07:45:23 +02:00
|
|
|
typedef struct st_lex : public Query_tables_list
|
2002-06-11 10:20:31 +02:00
|
|
|
{
|
2002-05-06 23:04:16 +02:00
|
|
|
SELECT_LEX_UNIT unit; /* most upper unit */
|
2002-10-30 12:18:52 +01:00
|
|
|
SELECT_LEX select_lex; /* first SELECT_LEX */
|
|
|
|
/* current SELECT_LEX in parsing */
|
2003-07-03 01:30:52 +02:00
|
|
|
SELECT_LEX *current_select;
|
2002-11-27 00:12:16 +01:00
|
|
|
/* list of all SELECT_LEX */
|
|
|
|
SELECT_LEX *all_selects_list;
|
2005-08-25 15:34:34 +02:00
|
|
|
|
2006-10-16 18:57:33 +02:00
|
|
|
char *length,*dec,*change;
|
|
|
|
LEX_STRING name;
|
2003-08-05 21:14:15 +02:00
|
|
|
char *help_arg;
|
2000-09-16 18:06:21 +02:00
|
|
|
char *backup_dir; /* For RESTORE/BACKUP */
|
2000-10-27 06:11:55 +02:00
|
|
|
char* to_log; /* For PURGE MASTER LOGS TO */
|
2001-09-30 04:46:20 +02:00
|
|
|
char* x509_subject,*x509_issuer,*ssl_cipher;
|
2000-07-31 21:29:14 +02:00
|
|
|
String *wild;
|
|
|
|
sql_exchange *exchange;
|
2002-10-16 15:55:08 +02:00
|
|
|
select_result *result;
|
2004-04-02 08:12:53 +02:00
|
|
|
Item *default_value, *on_update_value;
|
2005-01-16 13:16:23 +01:00
|
|
|
LEX_STRING comment, ident;
|
2003-08-05 21:14:15 +02:00
|
|
|
LEX_USER *grant_user;
|
2005-04-04 00:50:05 +02:00
|
|
|
XID *xid;
|
2003-08-05 21:14:15 +02:00
|
|
|
THD *thd;
|
2007-03-02 17:43:45 +01:00
|
|
|
|
|
|
|
/* maintain a list of used plugins for this LEX */
|
|
|
|
DYNAMIC_ARRAY plugins;
|
|
|
|
plugin_ref plugins_static_buffer[INITIAL_LEX_PLUGIN_LIST_SIZE];
|
2007-08-03 14:16:02 +02:00
|
|
|
|
Patch for the following bugs:
- BUG#11986: Stored routines and triggers can fail if the code
has a non-ascii symbol
- BUG#16291: mysqldump corrupts string-constants with non-ascii-chars
- BUG#19443: INFORMATION_SCHEMA does not support charsets properly
- BUG#21249: Character set of SP-var can be ignored
- BUG#25212: Character set of string constant is ignored (stored routines)
- BUG#25221: Character set of string constant is ignored (triggers)
There were a few general problems that caused these bugs:
1. Character set information of the original (definition) query for views,
triggers, stored routines and events was lost.
2. mysqldump output query in client character set, which can be
inappropriate to encode definition-query.
3. INFORMATION_SCHEMA used strings with mixed encodings to display object
definition;
1. No query-definition-character set.
In order to compile query into execution code, some extra data (such as
environment variables or the database character set) is used. The problem
here was that this context was not preserved. So, on the next load it can
differ from the original one, thus the result will be different.
The context contains the following data:
- client character set;
- connection collation (character set and collation);
- collation of the owner database;
The fix is to store this context and use it each time we parse (compile)
and execute the object (stored routine, trigger, ...).
2. Wrong mysqldump-output.
The original query can contain several encodings (by means of character set
introducers). The problem here was that we tried to convert original query
to the mysqldump-client character set.
Moreover, we stored queries in different character sets for different
objects (views, for one, used UTF8, triggers used original character set).
The solution is
- to store definition queries in the original character set;
- to change SHOW CREATE statement to output definition query in the
binary character set (i.e. without any conversion);
- introduce SHOW CREATE TRIGGER statement;
- to dump special statements to switch the context to the original one
before dumping and restore it afterwards.
Note, in order to preserve the database collation at the creation time,
additional ALTER DATABASE might be used (to temporary switch the database
collation back to the original value). In this case, ALTER DATABASE
privilege will be required. This is a backward-incompatible change.
3. INFORMATION_SCHEMA showed non-UTF8 strings
The fix is to generate UTF8-query during the parsing, store it in the object
and show it in the INFORMATION_SCHEMA.
Basically, the idea is to create a copy of the original query convert it to
UTF8. Character set introducers are removed and all text literals are
converted to UTF8.
This UTF8 query is intended to provide user-readable output. It must not be
used to recreate the object. Specialized SHOW CREATE statements should be
used for this.
The reason for this limitation is the following: the original query can
contain symbols from several character sets (by means of character set
introducers).
Example:
- original query:
CREATE VIEW v1 AS SELECT _cp1251 'Hello' AS c1;
- UTF8 query (for INFORMATION_SCHEMA):
CREATE VIEW v1 AS SELECT 'Hello' AS c1;
2007-06-28 19:34:54 +02:00
|
|
|
CHARSET_INFO *charset;
|
2007-08-03 12:25:23 +02:00
|
|
|
bool text_string_is_7bit;
|
2004-09-14 18:28:29 +02:00
|
|
|
/* store original leaf_tables for INSERT SELECT and PS/SP */
|
|
|
|
TABLE_LIST *leaf_tables_insert;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
2008-02-20 21:26:50 +01:00
|
|
|
/** SELECT of CREATE VIEW statement */
|
|
|
|
LEX_STRING create_view_select;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
2007-08-16 17:52:55 +02:00
|
|
|
/** Start of 'ON table', in trigger statements. */
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
const char* raw_trg_on_table_name_begin;
|
2007-08-16 17:52:55 +02:00
|
|
|
/** End of 'ON table', in trigger statements. */
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
const char* raw_trg_on_table_name_end;
|
|
|
|
|
2005-07-18 13:31:02 +02:00
|
|
|
/* Partition info structure filled in by PARTITION BY parse part */
|
|
|
|
partition_info *part_info;
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-11-10 20:25:03 +01:00
|
|
|
/*
|
|
|
|
The definer of the object being created (view, trigger, stored routine).
|
|
|
|
I.e. the value of DEFINER clause.
|
|
|
|
*/
|
|
|
|
LEX_USER *definer;
|
|
|
|
|
2007-06-10 12:43:57 +02:00
|
|
|
List<Key_part_spec> col_list;
|
|
|
|
List<Key_part_spec> ref_list;
|
2001-06-03 16:07:26 +02:00
|
|
|
List<String> interval_list;
|
2002-07-23 17:31:22 +02:00
|
|
|
List<LEX_USER> users_list;
|
2000-07-31 21:29:14 +02:00
|
|
|
List<LEX_COLUMN> columns;
|
2004-12-13 13:26:28 +01:00
|
|
|
List<Item> *insert_list,field_list,value_list,update_list;
|
2001-06-03 16:07:26 +02:00
|
|
|
List<List_item> many_values;
|
2002-07-23 17:31:22 +02:00
|
|
|
List<set_var_base> var_list;
|
2008-09-18 10:38:44 +02:00
|
|
|
List<Item_func_set_user_var> set_var_list; // in-query assignment list
|
2004-03-02 20:39:50 +01:00
|
|
|
List<Item_param> param_list;
|
2004-07-16 00:15:55 +02:00
|
|
|
List<LEX_STRING> view_list; // view list (list of field names in view)
|
2005-08-12 16:57:19 +02:00
|
|
|
/*
|
|
|
|
A stack of name resolution contexts for the query. This stack is used
|
|
|
|
at parse time to set local name resolution contexts for various parts
|
|
|
|
of a query. For example, in a JOIN ... ON (some_condition) clause the
|
|
|
|
Items in 'some_condition' must be resolved only against the operands
|
|
|
|
of the the join, and not against the whole clause. Similarly, Items in
|
|
|
|
subqueries should be resolved against the subqueries (and outer queries).
|
|
|
|
The stack is used in the following way: when the parser detects that
|
|
|
|
all Items in some clause need a local context, it creates a new context
|
|
|
|
and pushes it on the stack. All newly created Items always store the
|
|
|
|
top-most context in the stack. Once the parser leaves the clause that
|
|
|
|
required a local context, the parser pops the top-most context.
|
|
|
|
*/
|
|
|
|
List<Name_resolution_context> context_stack;
|
|
|
|
|
2006-07-04 00:07:41 +02:00
|
|
|
SQL_LIST proc_list, auxiliary_table_list, save_list;
|
2007-06-10 12:43:57 +02:00
|
|
|
Create_field *last_field;
|
2005-10-15 23:32:37 +02:00
|
|
|
Item_sum *in_sum_func;
|
2000-07-31 21:29:14 +02:00
|
|
|
udf_func udf;
|
2000-09-14 01:39:07 +02:00
|
|
|
HA_CHECK_OPT check_opt; // check/repair options
|
|
|
|
HA_CREATE_INFO create_info;
|
2006-05-03 18:40:52 +02:00
|
|
|
KEY_CREATE_INFO key_create_info;
|
2000-09-17 02:23:30 +02:00
|
|
|
LEX_MASTER_INFO mi; // used by CHANGE MASTER
|
2006-12-02 01:47:45 +01:00
|
|
|
LEX_SERVER_OPTIONS server_options;
|
2002-05-15 12:50:38 +02:00
|
|
|
USER_RESOURCES mqh;
|
2004-11-25 16:13:06 +01:00
|
|
|
ulong type;
|
2005-10-15 23:32:37 +02:00
|
|
|
/*
|
|
|
|
This variable is used in post-parse stage to declare that sum-functions,
|
|
|
|
or functions which have sense only if GROUP BY is present, are allowed.
|
|
|
|
For example in a query
|
|
|
|
SELECT ... FROM ...WHERE MIN(i) == 1 GROUP BY ... HAVING MIN(i) > 2
|
|
|
|
MIN(i) in the WHERE clause is not allowed in the opposite to MIN(i)
|
|
|
|
in the HAVING clause. Due to possible nesting of select construct
|
|
|
|
the variable can contain 0 or 1 for each nest level.
|
|
|
|
*/
|
|
|
|
nesting_map allow_sum_func;
|
2006-06-20 12:20:32 +02:00
|
|
|
enum_sql_command sql_command;
|
2006-08-23 16:53:04 +02:00
|
|
|
/*
|
|
|
|
Usually `expr` rule of yacc is quite reused but some commands better
|
|
|
|
not support subqueries which comes standard with this rule, like
|
|
|
|
KILL, HA_READ, CREATE/ALTER EVENT etc. Set this to `false` to get
|
|
|
|
syntax error back.
|
|
|
|
*/
|
|
|
|
bool expr_allows_subselect;
|
|
|
|
|
2005-04-15 18:31:47 +02:00
|
|
|
thr_lock_type lock_option;
|
2003-08-05 21:14:15 +02:00
|
|
|
enum SSL_type ssl_type; /* defined in violite.h */
|
2000-09-14 01:39:07 +02:00
|
|
|
enum enum_duplicates duplicates;
|
2001-03-21 00:02:22 +01:00
|
|
|
enum enum_tx_isolation tx_isolation;
|
2001-04-07 00:18:33 +02:00
|
|
|
enum enum_ha_read_modes ha_read_mode;
|
2005-01-16 13:16:23 +01:00
|
|
|
union {
|
2005-04-04 00:50:05 +02:00
|
|
|
enum ha_rkey_function ha_rkey_mode;
|
2005-01-16 13:16:23 +01:00
|
|
|
enum xa_option_words xa_opt;
|
|
|
|
};
|
2002-07-23 17:31:22 +02:00
|
|
|
enum enum_var_type option_type;
|
2004-07-16 00:15:55 +02:00
|
|
|
enum enum_view_create_mode create_view_mode;
|
|
|
|
enum enum_drop_mode drop_mode;
|
2007-02-22 16:03:08 +01:00
|
|
|
|
2007-01-03 23:15:10 +01:00
|
|
|
uint profile_query_id;
|
2007-02-22 16:03:08 +01:00
|
|
|
uint profile_options;
|
2003-08-05 21:14:15 +02:00
|
|
|
uint uint_geom_type;
|
2002-10-26 19:18:37 +02:00
|
|
|
uint grant, grant_tot_col, which_columns;
|
2002-06-02 20:22:20 +02:00
|
|
|
uint fk_delete_opt, fk_update_opt, fk_match_option;
|
2004-11-10 17:56:45 +01:00
|
|
|
uint slave_thd_opt, start_transaction_opt;
|
2005-10-15 23:32:37 +02:00
|
|
|
int nest_level;
|
2005-06-08 23:07:52 +02:00
|
|
|
/*
|
|
|
|
In LEX representing update which were transformed to multi-update
|
|
|
|
stores total number of tables. For LEX representing multi-delete
|
|
|
|
holds number of tables from which we will delete records.
|
|
|
|
*/
|
|
|
|
uint table_count;
|
2003-10-16 14:54:47 +02:00
|
|
|
uint8 describe;
|
2005-10-27 23:18:23 +02:00
|
|
|
/*
|
|
|
|
A flag that indicates what kinds of derived tables are present in the
|
|
|
|
query (0 if no derived tables, otherwise a combination of flags
|
2005-10-29 11:11:34 +02:00
|
|
|
DERIVED_SUBQUERY and DERIVED_VIEW).
|
2005-10-27 23:18:23 +02:00
|
|
|
*/
|
2004-07-16 00:15:55 +02:00
|
|
|
uint8 derived_tables;
|
|
|
|
uint8 create_view_algorithm;
|
2004-09-03 14:18:40 +02:00
|
|
|
uint8 create_view_check;
|
2004-06-03 23:17:18 +02:00
|
|
|
bool drop_if_exists, drop_temporary, local_file, one_shot_set;
|
2007-10-30 23:51:04 +01:00
|
|
|
bool autocommit;
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
bool verbose, no_write_to_binlog;
|
|
|
|
|
* Mixed replication mode * :
1) Fix for BUG#19630 "stored function inserting into two auto_increment breaks
statement-based binlog":
a stored function inserting into two such tables may fail to replicate
(inserting wrong data in the slave's copy of the second table) if the slave's
second table had an internal auto_increment counter different from master's.
Because the auto_increment value autogenerated by master for the 2nd table
does not go into binlog, only the first does, so the slave lacks information.
To fix this, if running in mixed binlogging mode, if the stored function or
trigger plans to update two different tables both having auto_increment
columns, we switch to row-based for the whole function.
We don't have a simple solution for statement-based binlogging mode, there
the bug remains and will be documented as a known problem.
Re-enabling rpl_switch_stm_row_mixed.
2) Fix for BUG#20630 "Mixed binlogging mode does not work with stored
functions, triggers, views", which was a documented limitation (in mixed
mode, we didn't detect that a stored function's execution needed row-based
binlogging (due to some UUID() call for example); same for
triggers, same for views (a view created from a SELECT UUID(), and doing
INSERT INTO sometable SELECT theview; would not replicate row-based).
This is implemented by, after parsing a routine's body, remembering in sp_head
that this routine needs row-based binlogging. Then when this routine is used,
the caller is marked to require row-based binlogging too.
Same for views: when we parse a view and detect that its SELECT needs
row-based binary logging, we mark the calling LEX as such.
3) Fix for BUG#20499 "mixed mode with temporary table breaks binlog":
a temporary table containing e.g. UUID has its changes not binlogged,
so any query updating a permanent table with data from the temporary table
will run wrongly on slave. Solution: in mixed mode we don't switch back
from row-based to statement-based when there exists temporary tables.
4) Attempt to test mysqlbinlog on a binlog generated by mysqlbinlog;
impossible due to BUG#11312 and BUG#20329, but test is in place for when
they are fixed.
2006-07-09 17:00:47 +02:00
|
|
|
bool tx_chain, tx_release;
|
2005-05-23 20:38:12 +02:00
|
|
|
/*
|
|
|
|
Special JOIN::prepare mode: changing of query is prohibited.
|
|
|
|
When creating a view, we need to just check its syntax omitting
|
|
|
|
any optimizations: afterwards definition of the view will be
|
|
|
|
reconstructed by means of ::print() methods and written to
|
|
|
|
to an .frm file. We need this definition to stay untouched.
|
|
|
|
*/
|
2004-07-16 00:15:55 +02:00
|
|
|
bool view_prepare_mode;
|
2002-11-22 14:50:53 +01:00
|
|
|
bool safe_to_cache_query;
|
2004-12-31 11:04:35 +01:00
|
|
|
bool subqueries, ignore;
|
2006-10-12 16:02:57 +02:00
|
|
|
st_parsing_options parsing_options;
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
Alter_info alter_info;
|
2004-04-05 17:43:37 +02:00
|
|
|
/* Prepared statements SQL syntax:*/
|
|
|
|
LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
|
2005-04-04 00:50:05 +02:00
|
|
|
/*
|
2004-05-21 02:27:50 +02:00
|
|
|
Prepared statement query text or name of variable that holds the
|
|
|
|
prepared statement (in PREPARE ... queries)
|
|
|
|
*/
|
2005-04-04 00:50:05 +02:00
|
|
|
LEX_STRING prepared_stmt_code;
|
2004-05-21 02:27:50 +02:00
|
|
|
/* If true, prepared_stmt_code is a name of variable that holds the query */
|
|
|
|
bool prepared_stmt_code_is_varref;
|
2004-04-05 17:43:37 +02:00
|
|
|
/* Names of user variables holding parameters (in EXECUTE) */
|
2005-04-04 00:50:05 +02:00
|
|
|
List<LEX_STRING> prepared_stmt_params;
|
Simplistic, experimental framework for Stored Procedures (SPs).
Implements creation and dropping of PROCEDUREs, IN, OUT, and INOUT parameters,
single-statement procedures, rudimentary multi-statement (begin-end) prodedures
(when the client can handle it), and local variables.
Missing most of the embedded SQL language, all attributes, FUNCTIONs, error handling,
reparses procedures at each call (no caching), etc, etc.
Certainly buggy too, but procedures can actually be created and called....
2002-12-08 19:59:22 +01:00
|
|
|
sp_head *sphead;
|
2004-02-17 17:36:53 +01:00
|
|
|
sp_name *spname;
|
2003-06-29 18:15:17 +02:00
|
|
|
bool sp_lex_in_use; /* Keep track on lex usage in SPs for error handling */
|
2004-12-23 11:46:24 +01:00
|
|
|
bool all_privileges;
|
Simplistic, experimental framework for Stored Procedures (SPs).
Implements creation and dropping of PROCEDUREs, IN, OUT, and INOUT parameters,
single-statement procedures, rudimentary multi-statement (begin-end) prodedures
(when the client can handle it), and local variables.
Missing most of the embedded SQL language, all attributes, FUNCTIONs, error handling,
reparses procedures at each call (no caching), etc, etc.
Certainly buggy too, but procedures can actually be created and called....
2002-12-08 19:59:22 +01:00
|
|
|
sp_pcontext *spcont;
|
2005-07-09 19:51:59 +02:00
|
|
|
|
2003-12-10 19:05:37 +01:00
|
|
|
st_sp_chistics sp_chistics;
|
2005-12-02 13:07:02 +01:00
|
|
|
|
2006-06-27 10:53:26 +02:00
|
|
|
Event_parse_data *event_parse_data;
|
2005-12-02 13:07:02 +01:00
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
bool only_view; /* used for SHOW CREATE TABLE/VIEW */
|
|
|
|
/*
|
|
|
|
field_list was created for view and should be removed before PS/SP
|
|
|
|
rexecuton
|
|
|
|
*/
|
|
|
|
bool empty_field_list_on_rset;
|
2005-09-14 09:53:09 +02:00
|
|
|
/*
|
|
|
|
view created to be run from definer (standard behaviour)
|
|
|
|
*/
|
2006-07-31 16:33:37 +02:00
|
|
|
uint8 create_view_suid;
|
2004-09-07 14:29:46 +02:00
|
|
|
/* Characterstics of trigger being created */
|
|
|
|
st_trg_chistics trg_chistics;
|
|
|
|
/*
|
2004-11-24 10:24:02 +01:00
|
|
|
List of all items (Item_trigger_field objects) representing fields in
|
|
|
|
old/new version of row in trigger. We use this list for checking whenever
|
|
|
|
all such fields are valid at trigger creation time and for binding these
|
|
|
|
fields to TABLE object at table open (altough for latter pointer to table
|
|
|
|
being opened is probably enough).
|
2004-09-07 14:29:46 +02:00
|
|
|
*/
|
2004-11-24 10:24:02 +01:00
|
|
|
SQL_LIST trg_table_fields;
|
2003-07-07 14:55:10 +02:00
|
|
|
|
2005-11-10 20:25:03 +01:00
|
|
|
/*
|
2006-03-02 13:18:49 +01:00
|
|
|
stmt_definition_begin is intended to point to the next word after
|
|
|
|
DEFINER-clause in the following statements:
|
|
|
|
- CREATE TRIGGER (points to "TRIGGER");
|
|
|
|
- CREATE PROCEDURE (points to "PROCEDURE");
|
|
|
|
- CREATE FUNCTION (points to "FUNCTION" or "AGGREGATE");
|
|
|
|
|
|
|
|
This pointer is required to add possibly omitted DEFINER-clause to the
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
DDL-statement before dumping it to the binlog.
|
2005-11-10 20:25:03 +01:00
|
|
|
*/
|
2006-03-02 13:18:49 +01:00
|
|
|
const char *stmt_definition_begin;
|
2005-11-10 20:25:03 +01:00
|
|
|
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
const char *stmt_definition_end;
|
|
|
|
|
2005-03-16 02:32:47 +01:00
|
|
|
/*
|
|
|
|
Pointers to part of LOAD DATA statement that should be rewritten
|
|
|
|
during replication ("LOCAL 'filename' REPLACE INTO" part).
|
|
|
|
*/
|
2007-04-26 05:38:12 +02:00
|
|
|
const char *fname_start;
|
|
|
|
const char *fname_end;
|
2007-10-09 16:16:39 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
During name resolution search only in the table list given by
|
|
|
|
Name_resolution_context::first_name_resolution_table and
|
|
|
|
Name_resolution_context::last_name_resolution_table
|
|
|
|
(see Item_field::fix_fields()).
|
|
|
|
*/
|
|
|
|
bool use_only_table_context;
|
2006-01-11 11:35:25 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
Reference to a struct that contains information in various commands
|
|
|
|
to add/create/drop/change table spaces.
|
|
|
|
*/
|
|
|
|
st_alter_tablespace *alter_tablespace_info;
|
2005-10-21 03:01:52 +02:00
|
|
|
|
|
|
|
bool escape_used;
|
2007-11-05 16:25:40 +01:00
|
|
|
bool is_lex_started; /* If lex_start() did run. For debugging. */
|
2005-03-16 02:32:47 +01:00
|
|
|
|
2005-07-09 19:51:59 +02:00
|
|
|
st_lex();
|
2005-03-04 18:54:24 +01:00
|
|
|
|
|
|
|
virtual ~st_lex()
|
2003-07-07 14:55:10 +02:00
|
|
|
{
|
2006-05-30 07:45:23 +02:00
|
|
|
destroy_query_tables_list();
|
2007-03-02 17:43:45 +01:00
|
|
|
plugin_unlock_list(NULL, (plugin_ref *)plugins.buffer, plugins.elements);
|
|
|
|
delete_dynamic(&plugins);
|
2003-07-07 14:55:10 +02:00
|
|
|
}
|
2003-01-28 13:48:12 +01:00
|
|
|
|
2003-11-17 19:53:40 +01:00
|
|
|
inline void uncacheable(uint8 cause)
|
2003-01-28 13:48:12 +01:00
|
|
|
{
|
|
|
|
safe_to_cache_query= 0;
|
2003-01-30 21:15:44 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
There are no sense to mark select_lex and union fields of LEX,
|
|
|
|
but we should merk all subselects as uncacheable from current till
|
|
|
|
most upper
|
|
|
|
*/
|
2003-07-03 01:30:52 +02:00
|
|
|
SELECT_LEX *sl;
|
2003-03-14 13:16:09 +01:00
|
|
|
SELECT_LEX_UNIT *un;
|
|
|
|
for (sl= current_select, un= sl->master_unit();
|
|
|
|
un != &unit;
|
|
|
|
sl= sl->outer_select(), un= sl->master_unit())
|
2003-01-30 21:15:44 +01:00
|
|
|
{
|
2003-11-17 19:53:40 +01:00
|
|
|
sl->uncacheable|= cause;
|
|
|
|
un->uncacheable|= cause;
|
2003-01-30 21:15:44 +01:00
|
|
|
}
|
2003-01-28 13:48:12 +01:00
|
|
|
}
|
A fix and a test case for Bug#26141 mixing table types in trigger
causes full table lock on innodb table.
Also fixes Bug#28502 Triggers that update another innodb table
will block on X lock unnecessarily (duplciate).
Code review fixes.
Both bugs' synopses are misleading: InnoDB table is
not X locked. The statements, however, cannot proceed concurrently,
but this happens due to lock conflicts for tables used in triggers,
not for the InnoDB table.
If a user had an InnoDB table, and two triggers, AFTER UPDATE and
AFTER INSERT, competing for different resources (e.g. two distinct
MyISAM tables), then these two triggers would not be able to execute
concurrently. Moreover, INSERTS/UPDATES of the InnoDB table would
not be able to run concurrently.
The problem had other side-effects (see respective bug reports).
This behavior was a consequence of a shortcoming of the pre-locking
algorithm, which would not distinguish between different DML operations
(e.g. INSERT and DELETE) and pre-lock all the tables
that are used by any trigger defined on the subject table.
The idea of the fix is to extend the pre-locking algorithm to keep track,
for each table, what DML operation it is used for and not
load triggers that are known to never be fired.
2007-07-12 20:26:41 +02:00
|
|
|
void set_trg_event_type_for_tables();
|
|
|
|
|
2004-07-16 00:15:55 +02:00
|
|
|
TABLE_LIST *unlink_first_table(bool *link_to_local);
|
|
|
|
void link_first_table_back(TABLE_LIST *first, bool link_to_local);
|
|
|
|
void first_lists_tables_same();
|
|
|
|
|
|
|
|
bool can_be_merged();
|
|
|
|
bool can_use_merged();
|
2004-08-24 21:51:23 +02:00
|
|
|
bool can_not_use_merged();
|
2004-07-16 00:15:55 +02:00
|
|
|
bool only_view_structure();
|
2004-11-24 18:48:30 +01:00
|
|
|
bool need_correct_ident();
|
2007-07-06 14:18:49 +02:00
|
|
|
uint8 get_effective_with_check(TABLE_LIST *view);
|
2005-07-01 06:05:42 +02:00
|
|
|
/*
|
|
|
|
Is this update command where 'WHITH CHECK OPTION' clause is important
|
2005-03-04 14:35:28 +01:00
|
|
|
|
2005-07-01 06:05:42 +02:00
|
|
|
SYNOPSIS
|
|
|
|
st_lex::which_check_option_applicable()
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
TRUE have to take 'WHITH CHECK OPTION' clause into account
|
|
|
|
FALSE 'WHITH CHECK OPTION' clause do not need
|
|
|
|
*/
|
|
|
|
inline bool which_check_option_applicable()
|
|
|
|
{
|
|
|
|
switch (sql_command) {
|
|
|
|
case SQLCOM_UPDATE:
|
|
|
|
case SQLCOM_UPDATE_MULTI:
|
|
|
|
case SQLCOM_INSERT:
|
|
|
|
case SQLCOM_INSERT_SELECT:
|
2006-06-07 14:17:56 +02:00
|
|
|
case SQLCOM_REPLACE:
|
|
|
|
case SQLCOM_REPLACE_SELECT:
|
2005-07-01 06:05:42 +02:00
|
|
|
case SQLCOM_LOAD:
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
2006-05-30 07:45:23 +02:00
|
|
|
|
2005-07-05 12:37:02 +02:00
|
|
|
void cleanup_after_one_table_open();
|
2005-08-12 16:57:19 +02:00
|
|
|
|
2005-11-28 20:57:50 +01:00
|
|
|
bool push_context(Name_resolution_context *context)
|
2005-08-12 16:57:19 +02:00
|
|
|
{
|
2005-11-28 20:57:50 +01:00
|
|
|
return context_stack.push_front(context);
|
2005-08-12 16:57:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void pop_context()
|
|
|
|
{
|
|
|
|
context_stack.pop();
|
|
|
|
}
|
|
|
|
|
2007-07-16 23:30:57 +02:00
|
|
|
bool copy_db_to(char **p_db, size_t *p_db_length) const;
|
2007-07-05 09:34:04 +02:00
|
|
|
|
2005-08-12 16:57:19 +02:00
|
|
|
Name_resolution_context *current_context()
|
|
|
|
{
|
|
|
|
return context_stack.head();
|
|
|
|
}
|
A fix for Bug#26750 "valgrind leak in sp_head" (and post-review
fixes).
The legend: on a replication slave, in case a trigger creation
was filtered out because of application of replicate-do-table/
replicate-ignore-table rule, the parsed definition of a trigger was not
cleaned up properly. LEX::sphead member was left around and leaked
memory. Until the actual implementation of support of
replicate-ignore-table rules for triggers by the patch for Bug 24478 it
was never the case that "case SQLCOM_CREATE_TRIGGER"
was not executed once a trigger was parsed,
so the deletion of lex->sphead there worked and the memory did not leak.
The fix:
The real cause of the bug is that there is no 1 or 2 places where
we can clean up the main LEX after parse. And the reason we
can not have just one or two places where we clean up the LEX is
asymmetric behaviour of MYSQLparse in case of success or error.
One of the root causes of this behaviour is the code in Item::Item()
constructor. There, a newly created item adds itself to THD::free_list
- a single-linked list of Items used in a statement. Yuck. This code
is unaware that we may have more than one statement active at a time,
and always assumes that the free_list of the current statement is
located in THD::free_list. One day we need to be able to explicitly
allocate an item in a given Query_arena.
Thus, when parsing a definition of a stored procedure, like
CREATE PROCEDURE p1() BEGIN SELECT a FROM t1; SELECT b FROM t1; END;
we actually need to reset THD::mem_root, THD::free_list and THD::lex
to parse the nested procedure statement (SELECT *).
The actual reset and restore is implemented in semantic actions
attached to sp_proc_stmt grammar rule.
The problem is that in case of a parsing error inside a nested statement
Bison generated parser would abort immediately, without executing the
restore part of the semantic action. This would leave THD in an
in-the-middle-of-parsing state.
This is why we couldn't have had a single place where we clean up the LEX
after MYSQLparse - in case of an error we needed to do a clean up
immediately, in case of success a clean up could have been delayed.
This left the door open for a memory leak.
One of the following possibilities were considered when working on a fix:
- patch the replication logic to do the clean up. Rejected
as breaks module borders, replication code should not need to know the
gory details of clean up procedure after CREATE TRIGGER.
- wrap MYSQLparse with a function that would do a clean up.
Rejected as ideally we should fix the problem when it happens, not
adjust for it outside of the problematic code.
- make sure MYSQLparse cleans up after itself by invoking the clean up
functionality in the appropriate places before return. Implemented in
this patch.
- use %destructor rule for sp_proc_stmt to restore THD - cleaner
than the prevoius approach, but rejected
because needs a careful analysis of the side effects, and this patch is
for 5.0, and long term we need to use the next alternative anyway
- make sure that sp_proc_stmt doesn't juggle with THD - this is a
large work that will affect many modules.
Cleanup: move main_lex and main_mem_root from Statement to its
only two descendants Prepared_statement and THD. This ensures that
when a Statement instance was created for purposes of statement backup,
we do not involve LEX constructor/destructor, which is fairly expensive.
In order to track that the transformation produces equivalent
functionality please check the respective constructors and destructors
of Statement, Prepared_statement and THD - these members were
used only there.
This cleanup is unrelated to the patch.
2007-03-07 10:24:46 +01:00
|
|
|
/*
|
|
|
|
Restore the LEX and THD in case of a parse error.
|
|
|
|
*/
|
|
|
|
static void cleanup_lex_after_parse_error(THD *thd);
|
2006-05-30 07:45:23 +02:00
|
|
|
|
|
|
|
void reset_n_backup_query_tables_list(Query_tables_list *backup);
|
|
|
|
void restore_backup_query_tables_list(Query_tables_list *backup);
|
2006-11-02 13:51:43 +01:00
|
|
|
|
|
|
|
bool table_or_sp_used();
|
5.1 version of a fix and test cases for bugs:
Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a
growing key length" (this bug is not fixed in 5.0)
Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).
In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc
for drop_it.remove() and similar patterns to find evidence.
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement.
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
The problem of crashing bug 22060 stemmed from the fact that the above
metnioned functions were not only modifying HA_CREATE_INFO structure
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.
Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.
2007-05-28 13:30:01 +02:00
|
|
|
bool is_partition_management() const;
|
2007-08-29 10:38:05 +02:00
|
|
|
|
2007-08-28 17:51:03 +02:00
|
|
|
/**
|
|
|
|
@brief check if the statement is a single-level join
|
|
|
|
@return result of the check
|
|
|
|
@retval TRUE The statement doesn't contain subqueries, unions and
|
|
|
|
stored procedure calls.
|
|
|
|
@retval FALSE There are subqueries, UNIONs or stored procedure calls.
|
|
|
|
*/
|
|
|
|
bool is_single_level_stmt()
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
This check exploits the fact that the last added to all_select_list is
|
|
|
|
on its top. So select_lex (as the first added) will be at the tail
|
|
|
|
of the list.
|
|
|
|
*/
|
|
|
|
if (&select_lex == all_selects_list && !sroutines.records)
|
|
|
|
{
|
|
|
|
DBUG_ASSERT(!all_selects_list->next_select_in_list());
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
2000-07-31 21:29:14 +02:00
|
|
|
} LEX;
|
|
|
|
|
2008-07-14 23:41:30 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
The internal state of the syntax parser.
|
|
|
|
This object is only available during parsing,
|
|
|
|
and is private to the syntax parser implementation (sql_yacc.yy).
|
|
|
|
*/
|
|
|
|
class Yacc_state
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Yacc_state()
|
|
|
|
: yacc_yyss(NULL), yacc_yyvs(NULL)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~Yacc_state();
|
|
|
|
|
|
|
|
/**
|
|
|
|
Bison internal state stack, yyss, when dynamically allocated using
|
|
|
|
my_yyoverflow().
|
|
|
|
*/
|
2008-07-15 03:43:12 +02:00
|
|
|
uchar *yacc_yyss;
|
2008-07-14 23:41:30 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
Bison internal semantic value stack, yyvs, when dynamically allocated using
|
|
|
|
my_yyoverflow().
|
|
|
|
*/
|
2008-07-15 03:43:12 +02:00
|
|
|
uchar *yacc_yyvs;
|
2008-07-14 23:41:30 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
TODO: move more attributes from the LEX structure here.
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
Internal state of the parser.
|
|
|
|
The complete state consist of:
|
|
|
|
- state data used during lexical parsing,
|
|
|
|
- state data used during syntactic parsing.
|
|
|
|
*/
|
|
|
|
class Parser_state
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Parser_state(THD *thd, const char* buff, unsigned int length)
|
|
|
|
: m_lip(thd, buff, length), m_yacc()
|
|
|
|
{}
|
|
|
|
|
|
|
|
~Parser_state()
|
|
|
|
{}
|
|
|
|
|
|
|
|
Lex_input_stream m_lip;
|
|
|
|
Yacc_state m_yacc;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2004-07-16 14:20:51 +02:00
|
|
|
struct st_lex_local: public st_lex
|
|
|
|
{
|
2007-11-19 17:59:44 +01:00
|
|
|
static void *operator new(size_t size) throw()
|
2004-07-16 14:20:51 +02:00
|
|
|
{
|
WL#3817: Simplify string / memory area types and make things more consistent (first part)
The following type conversions was done:
- Changed byte to uchar
- Changed gptr to uchar*
- Change my_string to char *
- Change my_size_t to size_t
- Change size_s to size_t
Removed declaration of byte, gptr, my_string, my_size_t and size_s.
Following function parameter changes was done:
- All string functions in mysys/strings was changed to use size_t
instead of uint for string lengths.
- All read()/write() functions changed to use size_t (including vio).
- All protocoll functions changed to use size_t instead of uint
- Functions that used a pointer to a string length was changed to use size_t*
- Changed malloc(), free() and related functions from using gptr to use void *
as this requires fewer casts in the code and is more in line with how the
standard functions work.
- Added extra length argument to dirname_part() to return the length of the
created string.
- Changed (at least) following functions to take uchar* as argument:
- db_dump()
- my_net_write()
- net_write_command()
- net_store_data()
- DBUG_DUMP()
- decimal2bin() & bin2decimal()
- Changed my_compress() and my_uncompress() to use size_t. Changed one
argument to my_uncompress() from a pointer to a value as we only return
one value (makes function easier to use).
- Changed type of 'pack_data' argument to packfrm() to avoid casts.
- Changed in readfrm() and writefrom(), ha_discover and handler::discover()
the type for argument 'frmdata' to uchar** to avoid casts.
- Changed most Field functions to use uchar* instead of char* (reduced a lot of
casts).
- Changed field->val_xxx(xxx, new_ptr) to take const pointers.
Other changes:
- Removed a lot of not needed casts
- Added a few new cast required by other changes
- Added some cast to my_multi_malloc() arguments for safety (as string lengths
needs to be uint, not size_t).
- Fixed all calls to hash-get-key functions to use size_t*. (Needed to be done
explicitely as this conflict was often hided by casting the function to
hash_get_key).
- Changed some buffers to memory regions to uchar* to avoid casts.
- Changed some string lengths from uint to size_t.
- Changed field->ptr to be uchar* instead of char*. This allowed us to
get rid of a lot of casts.
- Some changes from true -> TRUE, false -> FALSE, unsigned char -> uchar
- Include zlib.h in some files as we needed declaration of crc32()
- Changed MY_FILE_ERROR to be (size_t) -1.
- Changed many variables to hold the result of my_read() / my_write() to be
size_t. This was needed to properly detect errors (which are
returned as (size_t) -1).
- Removed some very old VMS code
- Changed packfrm()/unpackfrm() to not be depending on uint size
(portability fix)
- Removed windows specific code to restore cursor position as this
causes slowdown on windows and we should not mix read() and pread()
calls anyway as this is not thread safe. Updated function comment to
reflect this. Changed function that depended on original behavior of
my_pwrite() to itself restore the cursor position (one such case).
- Added some missing checking of return value of malloc().
- Changed definition of MOD_PAD_CHAR_TO_FULL_LENGTH to avoid 'long' overflow.
- Changed type of table_def::m_size from my_size_t to ulong to reflect that
m_size is the number of elements in the array, not a string/memory
length.
- Moved THD::max_row_length() to table.cc (as it's not depending on THD).
Inlined max_row_length_blob() into this function.
- More function comments
- Fixed some compiler warnings when compiled without partitions.
- Removed setting of LEX_STRING() arguments in declaration (portability fix).
- Some trivial indentation/variable name changes.
- Some trivial code simplifications:
- Replaced some calls to alloc_root + memcpy to use
strmake_root()/strdup_root().
- Changed some calls from memdup() to strmake() (Safety fix)
- Simpler loops in client-simple.c
2007-05-10 11:59:39 +02:00
|
|
|
return sql_alloc(size);
|
2004-07-16 14:20:51 +02:00
|
|
|
}
|
2007-11-19 17:59:44 +01:00
|
|
|
static void *operator new(size_t size, MEM_ROOT *mem_root) throw()
|
2004-07-16 14:20:51 +02:00
|
|
|
{
|
|
|
|
return (void*) alloc_root(mem_root, (uint) size);
|
|
|
|
}
|
2004-11-28 15:53:17 +01:00
|
|
|
static void operator delete(void *ptr,size_t size)
|
|
|
|
{ TRASH(ptr, size); }
|
2005-03-19 01:12:25 +01:00
|
|
|
static void operator delete(void *ptr, MEM_ROOT *mem_root)
|
|
|
|
{ /* Never called */ }
|
2004-07-16 14:20:51 +02:00
|
|
|
};
|
2000-07-31 21:29:14 +02:00
|
|
|
|
2005-05-18 18:00:21 +02:00
|
|
|
extern void lex_init(void);
|
|
|
|
extern void lex_free(void);
|
2007-04-26 05:38:12 +02:00
|
|
|
extern void lex_start(THD *thd);
|
2005-05-18 18:00:21 +02:00
|
|
|
extern void lex_end(LEX *lex);
|
2006-03-10 01:44:08 +01:00
|
|
|
extern int MYSQLlex(void *arg, void *yythd);
|
Bug#25411 (trigger code truncated), PART II
Bug 28127 (Some valid identifiers names are not parsed correctly)
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
This patch is the second part of a major cleanup, required to fix
Bug 25411 (trigger code truncated).
The root cause of the issue stems from the function skip_rear_comments,
which was a work around to remove "extra" "*/" characters from the query
text, when parsing a query and reusing the text fragments to represent a
view, trigger, function or stored procedure.
The reason for this work around is that "special comments",
like /*!50002 XXX */, were not parsed properly, so that a query like:
AAA /*!50002 BBB */ CCC
would be seen by the parser as "AAA BBB */ CCC" when the current version
is greater or equal to 5.0.2
The root cause of this stems from how special comments are parsed.
Special comments are really out-of-bound text that appear inside a query,
that affects how the parser behave.
In nature, /*!50002 XXX */ in MySQL is similar to the C concept
of preprocessing :
#if VERSION >= 50002
XXX
#endif
Depending on the current VERSION of the server, either the special comment
should be expanded or it should be ignored, but in all cases the "text" of
the query should be re-written to strip the "/*!50002" and "*/" markers,
which does not belong to the SQL language itself.
Prior to this fix, these markers would leak into :
- the storage format for VIEW,
- the storage format for FUNCTION,
- the storage format for FUNCTION parameters, in mysql.proc (param_list),
- the storage format for PROCEDURE,
- the storage format for PROCEDURE parameters, in mysql.proc (param_list),
- the storage format for TRIGGER,
- the binary log used for replication.
In all cases, not only this cause format corruption, but also provide a vector
for dormant security issues, by allowing to tunnel code that will be activated
after an upgrade.
The proper solution is to deal with special comments strictly during parsing,
when accepting a query from the outside world.
Once a query is parsed and an object is created with a persistant
representation, this object should not arbitrarily mutate after an upgrade.
In short, special comments are a useful but limited feature for MYSQLdump,
when used at an *interface* level to facilitate import/export,
but bloating the server *internal* storage format is *not* the proper way
to deal with configuration management of the user logic.
With this fix:
- the Lex_input_stream class now acts as a comment pre-processor,
and either expands or ignore special comments on the fly.
- MYSQLlex and sql_yacc.yy have been cleaned up to strictly use the
public interface of Lex_input_stream. In particular, how the input stream
accepts or rejects a character is private to Lex_input_stream, and the
internal buffer pointers of that class are strictly private, and should not
be tempered with during parsing.
This caused many changes mostly in sql_lex.cc.
During the code cleanup in case MY_LEX_NUMBER_IDENT,
Bug 28127 (Some valid identifiers names are not parsed correctly)
was found and fixed.
By parsing special comments properly, and removing the function
'skip_rear_comments' [sic],
Bug 26302 (MySQL server cuts off trailing "*/" from comments in SP/func)
has been fixed as well.
2007-06-12 23:23:58 +02:00
|
|
|
|
|
|
|
extern void trim_whitespace(CHARSET_INFO *cs, LEX_STRING *str);
|
2000-07-31 21:29:14 +02:00
|
|
|
|
Bug#18239 (Possible to overload internal functions with stored functions)
Bug#21025 (misleading error message when creating functions named 'x', or 'y')
Bug#22619 (Spaces considered harmful)
This change contains a fix to report warnings or errors, and multiple tests
cases.
Before this fix, name collisions between:
- Native functions
- User Defined Functions
- Stored Functions
were not systematically reported, leading to confusing behavior.
I) Native / User Defined Function
Before this fix, is was possible to create a UDF named "foo", with the same
name as a native function "foo", but it was impossible to invoke the UDF,
since the syntax "foo()" always refer to the native function.
After this fix, creating a UDF fails with an error if there is a name
collision with a native function.
II) Native / Stored Function
Before this fix, is was possible to create a SF named "db.foo", with the same
name as a native function "foo", but this was confusing since the syntax
"foo()" would refer to the native function. To refer to the Stored Function,
the user had to use the "db.foo()" syntax.
After this fix, creating a Stored Function reports a warning if there is a
name collision with a native function.
III) User Defined Function / Stored Function
Before this fix, creating a User Defined Function "foo" and a Stored Function
"db.foo" are mutually exclusive operations. Whenever the second function is
created, an error is reported. However, the test suite did not cover this
behavior.
After this fix, the behavior is unchanged, and is now covered by test cases.
Note that the code change in this patch depends on the fix for Bug 21114.
2006-11-15 03:34:16 +01:00
|
|
|
extern bool is_lex_native_function(const LEX_STRING *name);
|
|
|
|
|
2007-08-15 17:08:44 +02:00
|
|
|
/**
|
|
|
|
@} (End of group Semantic_Analysis)
|
|
|
|
*/
|
|
|
|
|
2006-07-14 23:04:51 +02:00
|
|
|
#endif /* MYSQL_SERVER */
|