summaryrefslogtreecommitdiffstats
path: root/sql/structs.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 12:24:36 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-13 12:24:36 +0000
commit06eaf7232e9a920468c0f8d74dcf2fe8b555501c (patch)
treee2c7b5777f728320e5b5542b6213fd3591ba51e2 /sql/structs.h
parentInitial commit. (diff)
downloadmariadb-06eaf7232e9a920468c0f8d74dcf2fe8b555501c.tar.xz
mariadb-06eaf7232e9a920468c0f8d74dcf2fe8b555501c.zip
Adding upstream version 1:10.11.6.upstream/1%10.11.6
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sql/structs.h')
-rw-r--r--sql/structs.h1040
1 files changed, 1040 insertions, 0 deletions
diff --git a/sql/structs.h b/sql/structs.h
new file mode 100644
index 00000000..a77bb8cb
--- /dev/null
+++ b/sql/structs.h
@@ -0,0 +1,1040 @@
+#ifndef STRUCTS_INCLUDED
+#define STRUCTS_INCLUDED
+
+/* Copyright (c) 2000, 2010, Oracle and/or its affiliates.
+ Copyright (c) 2009, 2019, MariaDB Corporation.
+
+ 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
+ the Free Software Foundation; version 2 of the License.
+
+ 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.
+
+ 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+
+
+/* The old structures from unireg */
+
+#include "sql_plugin.h" /* plugin_ref */
+#include "sql_const.h" /* MAX_REFLENGTH */
+#include "my_time.h" /* enum_mysql_timestamp_type */
+#include "thr_lock.h" /* thr_lock_type */
+#include "my_base.h" /* ha_rows, ha_key_alg */
+#include <mysql_com.h> /* USERNAME_LENGTH */
+#include "sql_bitmap.h"
+#include "lex_charset.h"
+
+struct TABLE;
+class Type_handler;
+class Field;
+class Index_statistics;
+
+class THD;
+
+/* Array index type for table.field[] */
+typedef uint16 field_index_t;
+
+typedef struct st_date_time_format {
+ uchar positions[8];
+ char time_separator; /* Separator between hour and minute */
+ uint flag; /* For future */
+ LEX_CSTRING format;
+} DATE_TIME_FORMAT;
+
+
+typedef struct st_keyfile_info { /* used with ha_info() */
+ uchar ref[MAX_REFLENGTH]; /* Pointer to current row */
+ uchar dupp_ref[MAX_REFLENGTH]; /* Pointer to dupp row */
+ uint ref_length; /* Length of ref (1-8) */
+ uint block_size; /* index block size */
+ File filenr; /* (uniq) filenr for table */
+ ha_rows records; /* Records i datafilen */
+ ha_rows deleted; /* Deleted records */
+ ulonglong data_file_length; /* Length off data file */
+ ulonglong max_data_file_length; /* Length off data file */
+ ulonglong index_file_length;
+ ulonglong max_index_file_length;
+ ulonglong delete_length; /* Free bytes */
+ ulonglong auto_increment_value;
+ int errkey,sortkey; /* Last errorkey and sorted by */
+ time_t create_time; /* When table was created */
+ time_t check_time;
+ time_t update_time;
+ ulong mean_rec_length; /* physical reclength */
+} KEYFILE_INFO;
+
+
+typedef struct st_key_part_info { /* Info about a key part */
+ Field *field; /* the Field object for the indexed
+ prefix of the original table Field.
+ NOT necessarily the original Field */
+ uint offset; /* Offset in record (from 0) */
+ uint null_offset; /* Offset to null_bit in record */
+ /* Length of key part in bytes, excluding NULL flag and length bytes */
+ uint length;
+ /*
+ Number of bytes required to store the keypart value. This may be
+ different from the "length" field as it also counts
+ - possible NULL-flag byte (see HA_KEY_NULL_LENGTH)
+ - possible HA_KEY_BLOB_LENGTH bytes needed to store actual value length.
+ */
+ uint store_length;
+ uint16 key_type;
+ field_index_t fieldnr; /* Fieldnr begins counting from 1 */
+ uint16 key_part_flag; /* 0 or HA_REVERSE_SORT */
+ uint8 type;
+ uint8 null_bit; /* Position to null_bit */
+} KEY_PART_INFO ;
+
+class engine_option_value;
+struct ha_index_option_struct;
+
+typedef struct st_key {
+ uint key_length; /* total length of user defined key parts */
+ ulong flags; /* dupp key and pack flags */
+ uint user_defined_key_parts; /* How many key_parts */
+ uint usable_key_parts; /* Should normally be = user_defined_key_parts */
+ uint ext_key_parts; /* Number of key parts in extended key */
+ ulong ext_key_flags; /* Flags for extended key */
+ /*
+ Parts of primary key that are in the extension of this index.
+
+ Example: if this structure describes idx1, which is defined as
+ INDEX idx1 (pk2, col2)
+ and pk is defined as:
+ PRIMARY KEY (pk1, pk2)
+ then
+ pk1 is in the extension idx1, ext_key_part_map.is_set(0) == true
+ pk2 is explicitly present in idx1, it is not in the extension, so
+ ext_key_part_map.is_set(1) == false
+ */
+ key_part_map ext_key_part_map;
+ /*
+ Bitmap of indexes having common parts with this index
+ (only key parts from key definitions are taken into account)
+ */
+ key_map overlapped;
+ /* Set of keys constraint correlated with this key */
+ key_map constraint_correlated;
+ LEX_CSTRING name;
+ uint block_size;
+ enum ha_key_alg algorithm;
+ /*
+ The flag is on if statistical data for the index prefixes
+ has to be taken from the system statistical tables.
+ */
+ bool is_statistics_from_stat_tables;
+ /*
+ Note that parser is used when the table is opened for use, and
+ parser_name is used when the table is being created.
+ */
+ union
+ {
+ plugin_ref parser; /* Fulltext [pre]parser */
+ LEX_CSTRING *parser_name; /* Fulltext [pre]parser name */
+ };
+ KEY_PART_INFO *key_part;
+ /* Unique name for cache; db + \0 + table_name + \0 + key_name + \0 */
+ uchar *cache_name;
+ /*
+ Array of AVG(#records with the same field value) for 1st ... Nth key part.
+ 0 means 'not known'.
+ For temporary heap tables this member is NULL.
+ */
+ ulong *rec_per_key;
+
+ /*
+ This structure is used for statistical data on the index
+ that has been read from the statistical table index_stat
+ */
+ Index_statistics *read_stats;
+ /*
+ This structure is used for statistical data on the index that
+ is collected by the function collect_statistics_for_table
+ */
+ Index_statistics *collected_stats;
+
+ TABLE *table;
+ LEX_CSTRING comment;
+ /** reference to the list of options or NULL */
+ engine_option_value *option_list;
+ ha_index_option_struct *option_struct; /* structure with parsed options */
+
+ double actual_rec_per_key(uint i);
+
+ bool without_overlaps;
+ /*
+ TRUE if index needs to be ignored
+ */
+ bool is_ignored;
+} KEY;
+
+
+struct st_join_table;
+
+typedef struct st_reginfo { /* Extra info about reg */
+ struct st_join_table *join_tab; /* Used by SELECT() */
+ enum thr_lock_type lock_type; /* How database is used */
+ bool skip_locked;
+ bool not_exists_optimize;
+ /*
+ TRUE <=> range optimizer found that there is no rows satisfying
+ table conditions.
+ */
+ bool impossible_range;
+} REGINFO;
+
+
+/*
+ Originally MySQL used MYSQL_TIME structure inside server only, but since
+ 4.1 it's exported to user in the new client API. Define aliases for
+ new names to keep existing code simple.
+*/
+
+typedef enum enum_mysql_timestamp_type timestamp_type;
+
+
+typedef struct {
+ ulong year,month,day,hour;
+ ulonglong minute,second,second_part;
+ bool neg;
+} INTERVAL;
+
+
+typedef struct st_known_date_time_format {
+ const char *format_name;
+ const char *date_format;
+ const char *datetime_format;
+ const char *time_format;
+} KNOWN_DATE_TIME_FORMAT;
+
+extern const char *show_comp_option_name[];
+
+typedef int *(*update_var)(THD *, struct st_mysql_show_var *);
+
+struct USER_AUTH : public Sql_alloc
+{
+ LEX_CSTRING plugin, auth_str, pwtext;
+ USER_AUTH *next;
+ USER_AUTH() : next(NULL)
+ {
+ plugin.str= auth_str.str= "";
+ pwtext.str= NULL;
+ plugin.length= auth_str.length= pwtext.length= 0;
+ }
+};
+
+struct AUTHID
+{
+ LEX_CSTRING user, host;
+ void init() { memset(this, 0, sizeof(*this)); }
+ void copy(MEM_ROOT *root, const LEX_CSTRING *usr, const LEX_CSTRING *host);
+ bool is_role() const { return user.str[0] && !host.str[0]; }
+ void set_lex_string(LEX_CSTRING *l, char *buf)
+ {
+ if (is_role())
+ *l= user;
+ else
+ {
+ l->str= buf;
+ l->length= strxmov(buf, user.str, "@", host.str, NullS) - buf;
+ }
+ }
+ void parse(const char *str, size_t length);
+ bool read_from_mysql_proc_row(THD *thd, TABLE *table);
+};
+
+
+struct LEX_USER: public AUTHID
+{
+ USER_AUTH *auth;
+ bool has_auth()
+ {
+ return auth && (auth->plugin.length || auth->auth_str.length || auth->pwtext.length);
+ }
+};
+
+/*
+ This structure specifies the maximum amount of resources which
+ can be consumed by each account. Zero value of a member means
+ there is no limit.
+*/
+typedef struct user_resources {
+ /* Maximum number of queries/statements per hour. */
+ uint questions;
+ /*
+ Maximum number of updating statements per hour (which statements are
+ updating is defined by sql_command_flags array).
+ */
+ uint updates;
+ /* Maximum number of connections established per hour. */
+ uint conn_per_hour;
+ /*
+ Maximum number of concurrent connections. If -1 then no new
+ connections allowed
+ */
+ int user_conn;
+ /* Max query timeout */
+ double max_statement_time;
+
+ /*
+ Values of this enum and specified_limits member are used by the
+ parser to store which user limits were specified in GRANT statement.
+ */
+ enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4,
+ USER_CONNECTIONS= 8, MAX_STATEMENT_TIME= 16};
+ uint specified_limits;
+} USER_RESOURCES;
+
+
+/*
+ This structure is used for counting resources consumed and for checking
+ them against specified user limits.
+*/
+typedef struct user_conn {
+ /*
+ Pointer to user+host key (pair separated by '\0') defining the entity
+ for which resources are counted (By default it is user account thus
+ priv_user/priv_host pair is used. If --old-style-user-limits option
+ is enabled, resources are counted for each user+host separately).
+ */
+ char *user;
+ /* Pointer to host part of the key. */
+ char *host;
+ /**
+ The moment of time when per hour counters were reset last time
+ (i.e. start of "hour" for conn_per_hour, updates, questions counters).
+ */
+ ulonglong reset_utime;
+ /* Total length of the key. */
+ uint len;
+ /* Current amount of concurrent connections for this account. */
+ int connections;
+ /*
+ Current number of connections per hour, number of updating statements
+ per hour and total number of statements per hour for this account.
+ */
+ uint conn_per_hour, updates, questions;
+ /* Maximum amount of resources which account is allowed to consume. */
+ USER_RESOURCES user_resources;
+} USER_CONN;
+
+typedef struct st_user_stats
+{
+ char user[MY_MAX(USERNAME_LENGTH, LIST_PROCESS_HOST_LEN) + 1];
+ // Account name the user is mapped to when this is a user from mapped_user.
+ // Otherwise, the same value as user.
+ char priv_user[MY_MAX(USERNAME_LENGTH, LIST_PROCESS_HOST_LEN) + 1];
+ uint user_name_length;
+ uint total_connections;
+ uint total_ssl_connections;
+ uint concurrent_connections;
+ time_t connected_time; // in seconds
+ ha_rows rows_read, rows_sent;
+ ha_rows rows_updated, rows_deleted, rows_inserted;
+ ulonglong bytes_received;
+ ulonglong bytes_sent;
+ ulonglong binlog_bytes_written;
+ ulonglong select_commands, update_commands, other_commands;
+ ulonglong commit_trans, rollback_trans;
+ ulonglong denied_connections, lost_connections, max_statement_time_exceeded;
+ ulonglong access_denied_errors;
+ ulonglong empty_queries;
+ double busy_time; // in seconds
+ double cpu_time; // in seconds
+} USER_STATS;
+
+typedef struct st_table_stats
+{
+ char table[NAME_LEN * 2 + 2]; // [db] + '\0' + [table] + '\0'
+ size_t table_name_length;
+ ulonglong rows_read, rows_changed;
+ ulonglong rows_changed_x_indexes;
+ /* Stores enum db_type, but forward declarations cannot be done */
+ int engine_type;
+} TABLE_STATS;
+
+typedef struct st_index_stats
+{
+ // [db] + '\0' + [table] + '\0' + [index] + '\0'
+ char index[NAME_LEN * 3 + 3];
+ size_t index_name_length; /* Length of 'index' */
+ ulonglong rows_read;
+} INDEX_STATS;
+
+
+ /* Bits in form->update */
+#define REG_MAKE_DUPP 1U /* Make a copy of record when read */
+#define REG_NEW_RECORD 2U /* Write a new record if not found */
+#define REG_UPDATE 4U /* Uppdate record */
+#define REG_DELETE 8U /* Delete found record */
+#define REG_PROG 16U /* User is updating database */
+#define REG_CLEAR_AFTER_WRITE 32U
+#define REG_MAY_BE_UPDATED 64U
+#define REG_AUTO_UPDATE 64U /* Used in D-forms for scroll-tables */
+#define REG_OVERWRITE 128U
+#define REG_SKIP_DUP 256U
+
+ /* Bits in form->status */
+#define STATUS_NO_RECORD (1U+2U) /* Record isn't usable */
+#define STATUS_GARBAGE 1U
+#define STATUS_NOT_FOUND 2U /* No record in database when needed */
+#define STATUS_NO_PARENT 4U /* Parent record wasn't found */
+#define STATUS_NOT_READ 8U /* Record isn't read */
+#define STATUS_UPDATED 16U /* Record is updated by formula */
+#define STATUS_NULL_ROW 32U /* table->null_row is set */
+#define STATUS_DELETED 64U
+
+/*
+ Such interval is "discrete": it is the set of
+ { auto_inc_interval_min + k * increment,
+ 0 <= k <= (auto_inc_interval_values-1) }
+ Where "increment" is maintained separately by the user of this class (and is
+ currently only thd->variables.auto_increment_increment).
+ It mustn't derive from Sql_alloc, because SET INSERT_ID needs to
+ allocate memory which must stay allocated for use by the next statement.
+*/
+class Discrete_interval {
+private:
+ ulonglong interval_min;
+ ulonglong interval_values;
+ ulonglong interval_max; // excluded bound. Redundant.
+public:
+ Discrete_interval *next; // used when linked into Discrete_intervals_list
+ void replace(ulonglong start, ulonglong val, ulonglong incr)
+ {
+ interval_min= start;
+ interval_values= val;
+ interval_max= (val == ULONGLONG_MAX) ? val : start + val * incr;
+ }
+ Discrete_interval(ulonglong start, ulonglong val, ulonglong incr) :
+ next(NULL) { replace(start, val, incr); };
+ Discrete_interval() : next(NULL) { replace(0, 0, 0); };
+ ulonglong minimum() const { return interval_min; };
+ ulonglong values() const { return interval_values; };
+ ulonglong maximum() const { return interval_max; };
+ /*
+ If appending [3,5] to [1,2], we merge both in [1,5] (they should have the
+ same increment for that, user of the class has to ensure that). That is
+ just a space optimization. Returns 0 if merge succeeded.
+ */
+ bool merge_if_contiguous(ulonglong start, ulonglong val, ulonglong incr)
+ {
+ if (interval_max == start)
+ {
+ if (val == ULONGLONG_MAX)
+ {
+ interval_values= interval_max= val;
+ }
+ else
+ {
+ interval_values+= val;
+ interval_max= start + val * incr;
+ }
+ return 0;
+ }
+ return 1;
+ };
+};
+
+/* List of Discrete_interval objects */
+class Discrete_intervals_list {
+private:
+ Discrete_interval *head;
+ Discrete_interval *tail;
+ /*
+ When many intervals are provided at the beginning of the execution of a
+ statement (in a replication slave or SET INSERT_ID), "current" points to
+ the interval being consumed by the thread now (so "current" goes from
+ "head" to "tail" then to NULL).
+ */
+ Discrete_interval *current;
+ uint elements; // number of elements
+ void set_members(Discrete_interval *h, Discrete_interval *t,
+ Discrete_interval *c, uint el)
+ {
+ head= h;
+ tail= t;
+ current= c;
+ elements= el;
+ }
+ void operator=(Discrete_intervals_list &); /* prevent use of these */
+ Discrete_intervals_list(const Discrete_intervals_list &);
+
+public:
+ Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {};
+ void empty_no_free()
+ {
+ set_members(NULL, NULL, NULL, 0);
+ }
+ void empty()
+ {
+ for (Discrete_interval *i= head; i;)
+ {
+ Discrete_interval *next= i->next;
+ delete i;
+ i= next;
+ }
+ empty_no_free();
+ }
+ void copy_shallow(const Discrete_intervals_list * dli)
+ {
+ head= dli->get_head();
+ tail= dli->get_tail();
+ current= dli->get_current();
+ elements= dli->nb_elements();
+ }
+ void swap (Discrete_intervals_list * dli)
+ {
+ Discrete_interval *h, *t, *c;
+ uint el;
+ h= dli->get_head();
+ t= dli->get_tail();
+ c= dli->get_current();
+ el= dli->nb_elements();
+ dli->copy_shallow(this);
+ set_members(h, t, c, el);
+ }
+ const Discrete_interval* get_next()
+ {
+ Discrete_interval *tmp= current;
+ if (current != NULL)
+ current= current->next;
+ return tmp;
+ }
+ ~Discrete_intervals_list() { empty(); };
+ bool append(ulonglong start, ulonglong val, ulonglong incr);
+ bool append(Discrete_interval *interval);
+ ulonglong minimum() const { return (head ? head->minimum() : 0); };
+ ulonglong maximum() const { return (head ? tail->maximum() : 0); };
+ uint nb_elements() const { return elements; }
+ Discrete_interval* get_head() const { return head; };
+ Discrete_interval* get_tail() const { return tail; };
+ Discrete_interval* get_current() const { return current; };
+};
+
+
+/*
+ DDL options:
+ - CREATE IF NOT EXISTS
+ - DROP IF EXISTS
+ - CREATE LIKE
+ - REPLACE
+*/
+struct DDL_options_st
+{
+public:
+ enum Options
+ {
+ OPT_NONE= 0,
+ OPT_IF_NOT_EXISTS= 2, // CREATE TABLE IF NOT EXISTS
+ OPT_LIKE= 4, // CREATE TABLE LIKE
+ OPT_OR_REPLACE= 16, // CREATE OR REPLACE TABLE
+ OPT_OR_REPLACE_SLAVE_GENERATED= 32,// REPLACE was added on slave, it was
+ // not in the original query on master.
+ OPT_IF_EXISTS= 64,
+ OPT_CREATE_SELECT= 128 // CREATE ... SELECT
+ };
+
+private:
+ Options m_options;
+
+public:
+ Options create_like_options() const
+ {
+ return (DDL_options_st::Options)
+ (((uint) m_options) & (OPT_IF_NOT_EXISTS | OPT_OR_REPLACE));
+ }
+ void init() { m_options= OPT_NONE; }
+ void init(Options options) { m_options= options; }
+ void set(Options other)
+ {
+ m_options= other;
+ }
+ void set(const DDL_options_st other)
+ {
+ m_options= other.m_options;
+ }
+ bool if_not_exists() const { return m_options & OPT_IF_NOT_EXISTS; }
+ bool or_replace() const { return m_options & OPT_OR_REPLACE; }
+ bool or_replace_slave_generated() const
+ { return m_options & OPT_OR_REPLACE_SLAVE_GENERATED; }
+ bool like() const { return m_options & OPT_LIKE; }
+ bool if_exists() const { return m_options & OPT_IF_EXISTS; }
+ bool is_create_select() const { return m_options & OPT_CREATE_SELECT; }
+
+ void add(const DDL_options_st::Options other)
+ {
+ m_options= (Options) ((uint) m_options | (uint) other);
+ }
+ void add(const DDL_options_st &other)
+ {
+ add(other.m_options);
+ }
+ DDL_options_st operator|(const DDL_options_st &other)
+ {
+ add(other.m_options);
+ return *this;
+ }
+ DDL_options_st operator|=(DDL_options_st::Options other)
+ {
+ add(other);
+ return *this;
+ }
+};
+
+
+class DDL_options: public DDL_options_st
+{
+public:
+ DDL_options() { init(); }
+ DDL_options(Options options) { init(options); }
+ DDL_options(const DDL_options_st &options)
+ { DDL_options_st::operator=(options); }
+};
+
+
+struct Lex_length_and_dec_st
+{
+protected:
+ uint32 m_length;
+ uint8 m_dec;
+ uint8 m_collation_type:LEX_CHARSET_COLLATION_TYPE_BITS;
+ bool m_has_explicit_length:1;
+ bool m_has_explicit_dec:1;
+ bool m_length_overflowed:1;
+ bool m_dec_overflowed:1;
+
+ static_assert(LEX_CHARSET_COLLATION_TYPE_BITS <= 8,
+ "Lex_length_and_dec_st::m_collation_type bits check");
+
+public:
+ void reset()
+ {
+ m_length= 0;
+ m_dec= 0;
+ m_collation_type= 0;
+ m_has_explicit_length= false;
+ m_has_explicit_dec= false;
+ m_length_overflowed= false;
+ m_dec_overflowed= false;
+ }
+ void set_length_only(uint32 length)
+ {
+ m_length= length;
+ m_dec= 0;
+ m_collation_type= 0;
+ m_has_explicit_length= true;
+ m_has_explicit_dec= false;
+ m_length_overflowed= false;
+ m_dec_overflowed= false;
+ }
+ void set_dec_only(uint8 dec)
+ {
+ m_length= 0;
+ m_dec= dec;
+ m_collation_type= 0;
+ m_has_explicit_length= false;
+ m_has_explicit_dec= true;
+ m_length_overflowed= false;
+ m_dec_overflowed= false;
+ }
+ void set_length_and_dec(uint32 length, uint8 dec)
+ {
+ m_length= length;
+ m_dec= dec;
+ m_collation_type= 0;
+ m_has_explicit_length= true;
+ m_has_explicit_dec= true;
+ m_length_overflowed= false;
+ m_dec_overflowed= false;
+ }
+ void set(const char *length, const char *dec);
+ uint32 length() const
+ {
+ return m_length;
+ }
+ uint8 dec() const
+ {
+ return m_dec;
+ }
+ bool has_explicit_length() const
+ {
+ return m_has_explicit_length;
+ }
+ bool has_explicit_dec() const
+ {
+ return m_has_explicit_dec;
+ }
+ bool length_overflowed() const
+ {
+ return m_length_overflowed;
+ }
+ bool dec_overflowed() const
+ {
+ return m_dec_overflowed;
+ }
+};
+
+
+struct Lex_field_type_st: public Lex_length_and_dec_st
+{
+private:
+ const Type_handler *m_handler;
+ CHARSET_INFO *m_ci;
+public:
+ void set(const Type_handler *handler,
+ Lex_length_and_dec_st length_and_dec,
+ CHARSET_INFO *cs= NULL)
+ {
+ m_handler= handler;
+ m_ci= cs;
+ Lex_length_and_dec_st::operator=(length_and_dec);
+ }
+ void set(const Type_handler *handler,
+ const Lex_length_and_dec_st &length_and_dec,
+ const Lex_column_charset_collation_attrs_st &coll)
+ {
+ m_handler= handler;
+ m_ci= coll.charset_info();
+ Lex_length_and_dec_st::operator=(length_and_dec);
+ // Using bit-and to avoid the warning:
+ // conversion from ‘uint8’ to ‘unsigned char:3’ may change value
+ m_collation_type= ((uint8) coll.type()) & LEX_CHARSET_COLLATION_TYPE_MASK;
+ }
+ void set(const Type_handler *handler,
+ const Lex_column_charset_collation_attrs_st &coll)
+ {
+ m_handler= handler;
+ m_ci= coll.charset_info();
+ Lex_length_and_dec_st::reset();
+ // Using bit-and to avoid the warning:
+ // conversion from ‘uint8’ to ‘unsigned char:3’ may change value
+ m_collation_type= ((uint8) coll.type()) & LEX_CHARSET_COLLATION_TYPE_MASK;
+ }
+ void set(const Type_handler *handler, CHARSET_INFO *cs= NULL)
+ {
+ m_handler= handler;
+ m_ci= cs;
+ Lex_length_and_dec_st::reset();
+ }
+ void set_handler_length_flags(const Type_handler *handler,
+ const Lex_length_and_dec_st &length,
+ uint32 flags);
+ void set_handler_length(const Type_handler *handler, uint32 length)
+ {
+ m_handler= handler;
+ m_ci= NULL;
+ Lex_length_and_dec_st::set_length_only(length);
+ }
+ void set_handler(const Type_handler *handler)
+ {
+ m_handler= handler;
+ }
+ const Type_handler *type_handler() const { return m_handler; }
+ CHARSET_INFO *charset_collation() const { return m_ci; }
+ Lex_column_charset_collation_attrs charset_collation_attrs() const
+ {
+ return Lex_column_charset_collation_attrs(m_ci,
+ (Lex_column_charset_collation_attrs_st::Type)
+ m_collation_type);
+ }
+};
+
+
+struct Lex_dyncol_type_st: public Lex_length_and_dec_st
+{
+private:
+ int m_type; // enum_dynamic_column_type is not visible here, so use int
+ CHARSET_INFO *m_ci;
+public:
+ void set(int type, Lex_length_and_dec_st length_and_dec,
+ CHARSET_INFO *cs= NULL)
+ {
+ m_type= type;
+ m_ci= cs;
+ Lex_length_and_dec_st::operator=(length_and_dec);
+ }
+ void set(int type)
+ {
+ m_type= type;
+ m_ci= NULL;
+ Lex_length_and_dec_st::reset();
+ }
+ void set(int type, CHARSET_INFO *cs)
+ {
+ m_type= type;
+ m_ci= cs;
+ Lex_length_and_dec_st::reset();
+ }
+ bool set(int type, const Lex_column_charset_collation_attrs_st &collation,
+ CHARSET_INFO *charset)
+ {
+ CHARSET_INFO *tmp= collation.resolved_to_character_set(charset);
+ if (!tmp)
+ return true;
+ set(type, tmp);
+ return false;
+ }
+ int dyncol_type() const { return m_type; }
+ CHARSET_INFO *charset_collation() const { return m_ci; }
+};
+
+
+struct Lex_spblock_handlers_st
+{
+public:
+ int hndlrs;
+ void init(int count) { hndlrs= count; }
+};
+
+
+struct Lex_spblock_st: public Lex_spblock_handlers_st
+{
+public:
+ int vars;
+ int conds;
+ int curs;
+ void init()
+ {
+ vars= conds= hndlrs= curs= 0;
+ }
+ void init_using_vars(uint nvars)
+ {
+ vars= nvars;
+ conds= hndlrs= curs= 0;
+ }
+ void join(const Lex_spblock_st &b1, const Lex_spblock_st &b2)
+ {
+ vars= b1.vars + b2.vars;
+ conds= b1.conds + b2.conds;
+ hndlrs= b1.hndlrs + b2.hndlrs;
+ curs= b1.curs + b2.curs;
+ }
+};
+
+
+class Lex_spblock: public Lex_spblock_st
+{
+public:
+ Lex_spblock() { init(); }
+ Lex_spblock(const Lex_spblock_handlers_st &other)
+ {
+ vars= conds= curs= 0;
+ hndlrs= other.hndlrs;
+ }
+};
+
+
+struct Lex_for_loop_bounds_st
+{
+public:
+ class sp_assignment_lex *m_index; // The first iteration value (or cursor)
+ class sp_assignment_lex *m_target_bound; // The last iteration value
+ int8 m_direction;
+ bool m_implicit_cursor;
+ bool is_for_loop_cursor() const { return m_target_bound == NULL; }
+};
+
+
+class Lex_for_loop_bounds_intrange: public Lex_for_loop_bounds_st
+{
+public:
+ Lex_for_loop_bounds_intrange(int8 direction,
+ class sp_assignment_lex *left_expr,
+ class sp_assignment_lex *right_expr)
+ {
+ m_direction= direction;
+ m_index= direction > 0 ? left_expr : right_expr;
+ m_target_bound= direction > 0 ? right_expr : left_expr;
+ m_implicit_cursor= false;
+ }
+};
+
+
+struct Lex_for_loop_st
+{
+public:
+ class sp_variable *m_index; // The first iteration value (or cursor)
+ class sp_variable *m_target_bound; // The last iteration value
+ int m_cursor_offset;
+ int8 m_direction;
+ bool m_implicit_cursor;
+ void init()
+ {
+ m_index= 0;
+ m_target_bound= 0;
+ m_cursor_offset= 0;
+ m_direction= 0;
+ m_implicit_cursor= false;
+ }
+ bool is_for_loop_cursor() const { return m_target_bound == NULL; }
+ bool is_for_loop_explicit_cursor() const
+ {
+ return is_for_loop_cursor() && !m_implicit_cursor;
+ }
+};
+
+
+enum trim_spec { TRIM_LEADING, TRIM_TRAILING, TRIM_BOTH };
+
+struct Lex_trim_st
+{
+ Item *m_remove;
+ Item *m_source;
+ trim_spec m_spec;
+public:
+ void set(trim_spec spec, Item *remove, Item *source)
+ {
+ m_spec= spec;
+ m_remove= remove;
+ m_source= source;
+ }
+ void set(trim_spec spec, Item *source)
+ {
+ set(spec, NULL, source);
+ }
+ Item *make_item_func_trim_std(THD *thd) const;
+ Item *make_item_func_trim_oracle(THD *thd) const;
+ /*
+ This method is still used to handle LTRIM and RTRIM,
+ while the special syntax TRIM(... BOTH|LEADING|TRAILING)
+ is now handled by Schema::make_item_func_trim().
+ */
+ Item *make_item_func_trim(THD *thd) const;
+};
+
+
+class Lex_trim: public Lex_trim_st
+{
+public:
+ Lex_trim(trim_spec spec, Item *source) { set(spec, source); }
+};
+
+
+class Lex_substring_spec_st
+{
+public:
+ Item *m_subject;
+ Item *m_from;
+ Item *m_for;
+ static Lex_substring_spec_st init(Item *subject,
+ Item *from,
+ Item *xfor= NULL)
+ {
+ Lex_substring_spec_st res;
+ res.m_subject= subject;
+ res.m_from= from;
+ res.m_for= xfor;
+ return res;
+ }
+};
+
+
+class st_select_lex;
+
+class Lex_select_lock
+{
+public:
+ struct
+ {
+ uint defined_lock:1;
+ uint update_lock:1;
+ uint defined_timeout:1;
+ uint skip_locked:1;
+ };
+ ulong timeout;
+
+
+ void empty()
+ {
+ defined_lock= update_lock= defined_timeout= skip_locked= FALSE;
+ timeout= 0;
+ }
+ void set_to(st_select_lex *sel);
+};
+
+class Lex_select_limit
+{
+public:
+ /* explicit LIMIT clause was used */
+ bool explicit_limit;
+ bool with_ties;
+ Item *select_limit, *offset_limit;
+
+ void clear()
+ {
+ explicit_limit= FALSE; // No explicit limit given by user
+ with_ties= FALSE; // No use of WITH TIES operator
+ select_limit= NULL; // denotes the default limit = HA_POS_ERROR
+ offset_limit= NULL; // denotes the default offset = 0
+ }
+};
+
+struct st_order;
+
+class Load_data_param
+{
+protected:
+ CHARSET_INFO *m_charset; // Character set of the file
+ ulonglong m_fixed_length; // Sum of target field lengths for fixed format
+ bool m_is_fixed_length;
+ bool m_use_blobs;
+public:
+ Load_data_param(CHARSET_INFO *cs, bool is_fixed_length):
+ m_charset(cs),
+ m_fixed_length(0),
+ m_is_fixed_length(is_fixed_length),
+ m_use_blobs(false)
+ { }
+ bool add_outvar_field(THD *thd, const Field *field);
+ bool add_outvar_user_var(THD *thd);
+ CHARSET_INFO *charset() const { return m_charset; }
+ bool is_fixed_length() const { return m_is_fixed_length; }
+ bool use_blobs() const { return m_use_blobs; }
+};
+
+
+class Load_data_outvar
+{
+public:
+ virtual ~Load_data_outvar() = default;
+ virtual bool load_data_set_null(THD *thd, const Load_data_param *param)= 0;
+ virtual bool load_data_set_value(THD *thd, const char *pos, uint length,
+ const Load_data_param *param)= 0;
+ virtual bool load_data_set_no_data(THD *thd, const Load_data_param *param)= 0;
+ virtual void load_data_print_for_log_event(THD *thd, class String *to) const= 0;
+ virtual bool load_data_add_outvar(THD *thd, Load_data_param *param) const= 0;
+ virtual uint load_data_fixed_length() const= 0;
+};
+
+
+class Timeval: public timeval
+{
+protected:
+ Timeval() = default;
+public:
+ Timeval(my_time_t sec, ulong usec)
+ {
+ tv_sec= sec;
+ /*
+ Since tv_usec is not always of type ulong, cast usec parameter
+ explicitly to uint to avoid compiler warnings about losing
+ integer precision.
+ */
+ DBUG_ASSERT(usec < 1000000);
+ tv_usec= (uint)usec;
+ }
+ explicit Timeval(const timeval &tv)
+ :timeval(tv)
+ { }
+};
+
+
+#endif /* STRUCTS_INCLUDED */