mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 03:52:35 +01:00
misc fixes for compile-time errors
sql/item_sum.cc: "unused variable" warning sql/item_timefunc.cc: "unused variable" warning sql/log_event.h: const bool is_valid() -> bool is_valid() const sql/opt_range.cc: cast log's argument to double (otherwise an error on some compilers) sql/opt_range.h: get_quick_select_for_ref should be declared in the global scope to be visible.
This commit is contained in:
unknown
parent
362ce6a8aa
commit
d0c693999b
5 changed files with 691 additions and 691 deletions
|
|
@ -2088,7 +2088,7 @@ Item_func_group_concat::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
|
|||
result_field= 0;
|
||||
null_value= 1;
|
||||
max_length= group_concat_max_len;
|
||||
thd->allow_sum_func= 1;
|
||||
thd->allow_sum_func= 1;
|
||||
if (!(tmp_table_param= new TMP_TABLE_PARAM))
|
||||
return 1;
|
||||
tables_list= tables;
|
||||
|
|
@ -2102,7 +2102,6 @@ bool Item_func_group_concat::setup(THD *thd)
|
|||
List<Item> list;
|
||||
SELECT_LEX *select_lex= thd->lex->current_select;
|
||||
uint const_fields;
|
||||
byte *record;
|
||||
qsort_cmp2 compare_key;
|
||||
DBUG_ENTER("Item_func_group_concat::setup");
|
||||
|
||||
|
|
@ -2111,7 +2110,7 @@ bool Item_func_group_concat::setup(THD *thd)
|
|||
|
||||
/*
|
||||
push all not constant fields to list and create temp table
|
||||
*/
|
||||
*/
|
||||
const_fields= 0;
|
||||
always_null= 0;
|
||||
for (uint i= 0; i < arg_count_field; i++)
|
||||
|
|
@ -2129,15 +2128,15 @@ bool Item_func_group_concat::setup(THD *thd)
|
|||
}
|
||||
if (always_null)
|
||||
DBUG_RETURN(0);
|
||||
|
||||
|
||||
List<Item> all_fields(list);
|
||||
if (arg_count_order)
|
||||
if (arg_count_order)
|
||||
{
|
||||
bool hidden_group_fields;
|
||||
setup_group(thd, args, tables_list, list, all_fields, *order,
|
||||
&hidden_group_fields);
|
||||
}
|
||||
|
||||
|
||||
count_field_types(tmp_table_param,all_fields,0);
|
||||
if (table)
|
||||
{
|
||||
|
|
@ -2163,7 +2162,6 @@ bool Item_func_group_concat::setup(THD *thd)
|
|||
table->no_rows= 1;
|
||||
|
||||
key_length= table->reclength;
|
||||
record= table->record[0];
|
||||
|
||||
/* Offset to first result field in table */
|
||||
field_list_offset= table->fields - (list.elements - const_fields);
|
||||
|
|
|
|||
|
|
@ -2519,7 +2519,6 @@ longlong Item_func_timestamp_diff::val_int()
|
|||
uint year;
|
||||
uint year_beg, year_end, month_beg, month_end;
|
||||
uint diff_days= (uint) (seconds/86400L);
|
||||
uint diff_months= 0;
|
||||
uint diff_years= 0;
|
||||
if (neg == -1)
|
||||
{
|
||||
|
|
|
|||
208
sql/log_event.h
208
sql/log_event.h
|
|
@ -1,15 +1,15 @@
|
|||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
||||
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
|
||||
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
|
@ -34,8 +34,8 @@
|
|||
#define LOG_READ_TOO_LARGE -7
|
||||
|
||||
#define LOG_EVENT_OFFSET 4
|
||||
|
||||
/*
|
||||
|
||||
/*
|
||||
3 is MySQL 4.x; 4 is MySQL 5.0.0.
|
||||
Compared to version 3, version 4 has:
|
||||
- a different Start_log_event, which includes info about the binary log
|
||||
|
|
@ -58,12 +58,12 @@
|
|||
timestamp_when_the_master_started (4 bytes), a counter (a sequence number
|
||||
which increments every time we write an event to the binlog) (3 bytes).
|
||||
Q: how do we handle when the counter is overflowed and restarts from 0 ?
|
||||
|
||||
|
||||
- Query and Load (Create or Execute) events may have a more precise timestamp
|
||||
(with microseconds), number of matched/affected/warnings rows
|
||||
(with microseconds), number of matched/affected/warnings rows
|
||||
and fields of session variables: SQL_MODE,
|
||||
FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and
|
||||
charsets, the PASSWORD() version (old/new/...).
|
||||
charsets, the PASSWORD() version (old/new/...).
|
||||
*/
|
||||
#define BINLOG_VERSION 4
|
||||
|
||||
|
|
@ -128,11 +128,11 @@ struct sql_ex_info
|
|||
char* escaped;
|
||||
int cached_new_format;
|
||||
uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
|
||||
char opt_flags;
|
||||
char opt_flags;
|
||||
char empty_flags;
|
||||
|
||||
|
||||
// store in new format even if old is possible
|
||||
void force_new_format() { cached_new_format = 1;}
|
||||
void force_new_format() { cached_new_format = 1;}
|
||||
int data_size()
|
||||
{
|
||||
return (new_format() ?
|
||||
|
|
@ -172,20 +172,20 @@ struct sql_ex_info
|
|||
|
||||
#define LOG_EVENT_HEADER_LEN 19 /* the fixed header length */
|
||||
#define OLD_HEADER_LEN 13 /* the fixed header length in 3.23 */
|
||||
/*
|
||||
/*
|
||||
Fixed header length, where 4.x and 5.0 agree. That is, 5.0 may have a longer
|
||||
header (it will for sure when we have the unique event's ID), but at least
|
||||
the first 19 bytes are the same in 4.x and 5.0. So when we have the unique
|
||||
event's ID, LOG_EVENT_HEADER_LEN will be something like 26, but
|
||||
LOG_EVENT_MINIMAL_HEADER_LEN will remain 19.
|
||||
*/
|
||||
#define LOG_EVENT_MINIMAL_HEADER_LEN 19
|
||||
|
||||
#define LOG_EVENT_MINIMAL_HEADER_LEN 19
|
||||
|
||||
/* event-specific post-header sizes */
|
||||
// where 3.23, 4.x and 5.0 agree
|
||||
#define QUERY_HEADER_MINIMAL_LEN (4 + 4 + 1 + 2)
|
||||
// where 5.0 differs: 2 for len of N-bytes vars.
|
||||
#define QUERY_HEADER_LEN (QUERY_HEADER_MINIMAL_LEN + 2)
|
||||
#define QUERY_HEADER_LEN (QUERY_HEADER_MINIMAL_LEN + 2)
|
||||
#define LOAD_HEADER_LEN (4 + 4 + 4 + 1 +1 + 4)
|
||||
#define START_V3_HEADER_LEN (2 + ST_SERVER_VER_LEN + 4)
|
||||
#define ROTATE_HEADER_LEN 8 // this is FROZEN (the Rotate post-header is frozen)
|
||||
|
|
@ -195,8 +195,8 @@ struct sql_ex_info
|
|||
#define DELETE_FILE_HEADER_LEN 4
|
||||
#define FORMAT_DESCRIPTION_HEADER_LEN (START_V3_HEADER_LEN+1+LOG_EVENT_TYPES)
|
||||
|
||||
/*
|
||||
Event header offsets;
|
||||
/*
|
||||
Event header offsets;
|
||||
these point to places inside the fixed header.
|
||||
*/
|
||||
|
||||
|
|
@ -294,22 +294,22 @@ struct sql_ex_info
|
|||
So they are now removed and their place may later be reused for other
|
||||
flags. Then one must remember that Rotate events in 4.x have
|
||||
LOG_EVENT_FORCED_ROTATE_F set, so one should not rely on the value of the
|
||||
replacing flag when reading a Rotate event.
|
||||
replacing flag when reading a Rotate event.
|
||||
I keep the defines here just to remember what they were.
|
||||
*/
|
||||
#ifdef TO_BE_REMOVED
|
||||
#define LOG_EVENT_TIME_F 0x1
|
||||
#define LOG_EVENT_FORCED_ROTATE_F 0x2
|
||||
#define LOG_EVENT_FORCED_ROTATE_F 0x2
|
||||
#endif
|
||||
/*
|
||||
/*
|
||||
If the query depends on the thread (for example: TEMPORARY TABLE).
|
||||
Currently this is used by mysqlbinlog to know it must print
|
||||
SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it
|
||||
for every query but this would be slow).
|
||||
*/
|
||||
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
|
||||
#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
|
||||
|
||||
/*
|
||||
/*
|
||||
OPTIONS_WRITTEN_TO_BIN_LOG are the bits of thd->options which must be written
|
||||
to the binlog. OPTIONS_WRITTEN_TO_BINLOG could be written into the
|
||||
Format_description_log_event, so that if later we don't want to replicate a
|
||||
|
|
@ -317,7 +317,7 @@ struct sql_ex_info
|
|||
too hard to decide once for all of what we replicate and what we don't, among
|
||||
the fixed 32 bits of thd->options.
|
||||
I (Guilhem) have read through every option's usage, and it looks like
|
||||
OPTION_AUTO_IS_NULL and OPTION_NO_FOREIGN_KEYS are the only ones which alter
|
||||
OPTION_AUTO_IS_NULL and OPTION_NO_FOREIGN_KEYS are the only ones which alter
|
||||
how the query modifies the table. It's good to replicate
|
||||
OPTION_RELAXED_UNIQUE_CHECKS too because otherwise, the slave may insert data
|
||||
slower than the master, in InnoDB.
|
||||
|
|
@ -325,7 +325,7 @@ struct sql_ex_info
|
|||
max_join_size=HA_POS_ERROR) and OPTION_BIG_TABLES is not needed either, as
|
||||
the manual says (because a too big in-memory temp table is automatically
|
||||
written to disk).
|
||||
*/
|
||||
*/
|
||||
#define OPTIONS_WRITTEN_TO_BIN_LOG (OPTION_AUTO_IS_NULL | \
|
||||
OPTION_NO_FOREIGN_KEY_CHECKS | OPTION_RELAXED_UNIQUE_CHECKS)
|
||||
|
||||
|
|
@ -344,13 +344,13 @@ enum Log_event_type
|
|||
allowing multibyte TERMINATED BY etc; both types share the same class
|
||||
(Load_log_event)
|
||||
*/
|
||||
NEW_LOAD_EVENT,
|
||||
NEW_LOAD_EVENT,
|
||||
RAND_EVENT, USER_VAR_EVENT,
|
||||
FORMAT_DESCRIPTION_EVENT,
|
||||
FORMAT_DESCRIPTION_EVENT,
|
||||
ENUM_END_EVENT /* end marker */
|
||||
};
|
||||
|
||||
/*
|
||||
/*
|
||||
The number of types we handle in Format_description_log_event (UNKNOWN_EVENT
|
||||
is not to be handled, it does not exist in binlogs, it does not have a
|
||||
format).
|
||||
|
|
@ -388,7 +388,7 @@ typedef struct st_last_event_info
|
|||
bool sql_mode_inited;
|
||||
ulong sql_mode; /* must be same as THD.variables.sql_mode */
|
||||
st_last_event_info()
|
||||
: flags2_inited(0), flags2(0), sql_mode_inited(0), sql_mode(0)
|
||||
: flags2_inited(0), flags2(0), sql_mode_inited(0), sql_mode(0)
|
||||
{
|
||||
db[0]= 0; /* initially, the db is unknown */
|
||||
}
|
||||
|
|
@ -406,7 +406,7 @@ typedef struct st_last_event_info
|
|||
class Log_event
|
||||
{
|
||||
public:
|
||||
/*
|
||||
/*
|
||||
The offset in the log where this event originally appeared (it is preserved
|
||||
in relay logs, making SHOW SLAVE STATUS able to print coordinates of the
|
||||
event in the master's binlog). Note: when a transaction is written by the
|
||||
|
|
@ -416,13 +416,13 @@ public:
|
|||
may occur), except the COMMIT query which has its real offset.
|
||||
*/
|
||||
my_off_t log_pos;
|
||||
/*
|
||||
/*
|
||||
A temp buffer for read_log_event; it is later analysed according to the
|
||||
event's type, and its content is distributed in the event-specific fields.
|
||||
*/
|
||||
char *temp_buf;
|
||||
char *temp_buf;
|
||||
/*
|
||||
Timestamp on the master(for debugging and replication of NOW()/TIMESTAMP).
|
||||
Timestamp on the master(for debugging and replication of NOW()/TIMESTAMP).
|
||||
It is important for queries and LOAD DATA INFILE. This is set at the event's
|
||||
creation time, except for Query and Load (et al.) events where this is set
|
||||
at the query's execution time, which guarantees good replication (otherwise,
|
||||
|
|
@ -431,9 +431,9 @@ public:
|
|||
time_t when;
|
||||
/* The number of seconds the query took to run on the master. */
|
||||
ulong exec_time;
|
||||
/*
|
||||
/*
|
||||
The master's server id (is preserved in the relay log; used to prevent from
|
||||
infinite loops in circular replication).
|
||||
infinite loops in circular replication).
|
||||
*/
|
||||
uint32 server_id;
|
||||
uint cached_event_len;
|
||||
|
|
@ -501,7 +501,7 @@ public:
|
|||
virtual void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0) = 0;
|
||||
void print_timestamp(FILE* file, time_t *ts = 0);
|
||||
void print_header(FILE* file);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static void *operator new(size_t size)
|
||||
{
|
||||
|
|
@ -511,7 +511,7 @@ public:
|
|||
{
|
||||
my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
|
||||
}
|
||||
|
||||
|
||||
int write(IO_CACHE* file);
|
||||
int write_header(IO_CACHE* file);
|
||||
virtual int write_data(IO_CACHE* file)
|
||||
|
|
@ -521,7 +521,7 @@ public:
|
|||
virtual int write_data_body(IO_CACHE* file __attribute__((unused)))
|
||||
{ return 0; }
|
||||
virtual Log_event_type get_type_code() = 0;
|
||||
virtual const bool is_valid() = 0;
|
||||
virtual bool is_valid() const = 0;
|
||||
inline bool get_cache_stmt() { return cache_stmt; }
|
||||
Log_event(const char* buf, const Format_description_log_event* description_event);
|
||||
virtual ~Log_event() { free_temp_buf();}
|
||||
|
|
@ -549,12 +549,12 @@ public:
|
|||
static Log_event* read_log_event(const char* buf, uint event_len,
|
||||
const char **error,
|
||||
const Format_description_log_event
|
||||
*description_event);
|
||||
*description_event);
|
||||
/* returns the human readable name of the event's type */
|
||||
const char* get_type_str();
|
||||
};
|
||||
|
||||
/*
|
||||
/*
|
||||
One class for each type of event.
|
||||
Two constructors for each class:
|
||||
- one to create the event for logging (when the server acts as a master),
|
||||
|
|
@ -591,21 +591,21 @@ public:
|
|||
uint32 db_len;
|
||||
uint16 error_code;
|
||||
ulong thread_id;
|
||||
/*
|
||||
/*
|
||||
For events created by Query_log_event::exec_event (and
|
||||
Load_log_event::exec_event()) we need the *original* thread id, to be able
|
||||
to log the event with the original (=master's) thread id (fix for
|
||||
BUG#1686).
|
||||
*/
|
||||
ulong slave_proxy_id;
|
||||
|
||||
/*
|
||||
|
||||
/*
|
||||
Binlog format 3 and 4 start to differ (as far as class members are
|
||||
concerned) from here.
|
||||
concerned) from here.
|
||||
*/
|
||||
|
||||
|
||||
uint catalog_len; /* <= 255 char */
|
||||
|
||||
|
||||
/*
|
||||
We want to be able to store a variable number of N-bit status vars:
|
||||
(generally N=32; but N=64 for SQL_MODE) a user may want to log the number of
|
||||
|
|
@ -627,7 +627,7 @@ public:
|
|||
status variables in Query_log_event.
|
||||
*/
|
||||
uint16 status_vars_len;
|
||||
|
||||
|
||||
/*
|
||||
'flags2' is a second set of flags (on top of those in Log_event), for
|
||||
session variables. These are thd->options which is & against a mask
|
||||
|
|
@ -637,13 +637,13 @@ public:
|
|||
flags2==0 (5.0 master, we know this has a meaning of flags all down which
|
||||
must influence the query).
|
||||
*/
|
||||
bool flags2_inited;
|
||||
bool flags2_inited;
|
||||
bool sql_mode_inited;
|
||||
|
||||
uint32 flags2;
|
||||
|
||||
uint32 flags2;
|
||||
/* In connections sql_mode is 32 bits now but will be 64 bits soon */
|
||||
ulong sql_mode;
|
||||
|
||||
|
||||
#ifndef MYSQL_CLIENT
|
||||
|
||||
Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
|
||||
|
|
@ -669,11 +669,11 @@ public:
|
|||
Log_event_type get_type_code() { return QUERY_EVENT; }
|
||||
int write(IO_CACHE* file);
|
||||
int write_data(IO_CACHE* file); // returns 0 on success, -1 on error
|
||||
const bool is_valid() { return query != 0; }
|
||||
bool is_valid() const { return query != 0; }
|
||||
int get_data_size()
|
||||
{
|
||||
/* Note that the "1" below is the db's length. */
|
||||
return (q_len + db_len + 1 + status_vars_len + QUERY_HEADER_LEN);
|
||||
return (q_len + db_len + 1 + status_vars_len + QUERY_HEADER_LEN);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -700,18 +700,18 @@ public:
|
|||
int master_log_len;
|
||||
uint16 master_port;
|
||||
|
||||
#ifndef MYSQL_CLIENT
|
||||
#ifndef MYSQL_CLIENT
|
||||
Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
|
||||
void pack_info(Protocol* protocol);
|
||||
int exec_event(struct st_relay_log_info* rli);
|
||||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
Slave_log_event(const char* buf, uint event_len);
|
||||
~Slave_log_event();
|
||||
int get_data_size();
|
||||
const bool is_valid() { return master_host != 0; }
|
||||
bool is_valid() const { return master_host != 0; }
|
||||
Log_event_type get_type_code() { return SLAVE_EVENT; }
|
||||
int write_data(IO_CACHE* file );
|
||||
};
|
||||
|
|
@ -727,7 +727,7 @@ public:
|
|||
class Load_log_event: public Log_event
|
||||
{
|
||||
protected:
|
||||
int copy_log_event(const char *buf, ulong event_len,
|
||||
int copy_log_event(const char *buf, ulong event_len,
|
||||
int body_offset, const Format_description_log_event* description_event);
|
||||
|
||||
public:
|
||||
|
|
@ -769,7 +769,7 @@ public:
|
|||
#ifndef MYSQL_CLIENT
|
||||
String field_lens_buf;
|
||||
String fields_buf;
|
||||
|
||||
|
||||
Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
|
||||
const char* table_name_arg,
|
||||
List<Item>& fields_arg, enum enum_duplicates handle_dup,
|
||||
|
|
@ -782,7 +782,7 @@ public:
|
|||
{
|
||||
return exec_event(thd->slave_net,rli,0);
|
||||
}
|
||||
int exec_event(NET* net, struct st_relay_log_info* rli,
|
||||
int exec_event(NET* net, struct st_relay_log_info* rli,
|
||||
bool use_rli_only_for_errors);
|
||||
#endif /* HAVE_REPLICATION */
|
||||
#else
|
||||
|
|
@ -797,16 +797,16 @@ public:
|
|||
for the common_header_len (post_header_len will not be changed).
|
||||
*/
|
||||
Load_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
const Format_description_log_event* description_event);
|
||||
~Load_log_event()
|
||||
{}
|
||||
Log_event_type get_type_code()
|
||||
{
|
||||
return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
|
||||
}
|
||||
int write_data_header(IO_CACHE* file);
|
||||
int write_data_body(IO_CACHE* file);
|
||||
const bool is_valid() { return table_name != 0; }
|
||||
int write_data_header(IO_CACHE* file);
|
||||
int write_data_body(IO_CACHE* file);
|
||||
bool is_valid() const { return table_name != 0; }
|
||||
int get_data_size()
|
||||
{
|
||||
return (table_name_len + db_len + 2 + fname_len
|
||||
|
|
@ -828,22 +828,22 @@ extern char server_version[SERVER_VERSION_LENGTH];
|
|||
describes the other events' header/postheader lengths. This event is sent by
|
||||
MySQL 5.0 whenever it starts sending a new binlog if the requested position
|
||||
is >4 (otherwise if ==4 the event will be sent naturally).
|
||||
|
||||
|
||||
****************************************************************************/
|
||||
class Start_log_event_v3: public Log_event
|
||||
{
|
||||
public:
|
||||
/*
|
||||
/*
|
||||
If this event is at the start of the first binary log since server startup
|
||||
'created' should be the timestamp when the event (and the binary log) was
|
||||
created.
|
||||
created.
|
||||
In the other case (i.e. this event is at the start of a binary log created
|
||||
by FLUSH LOGS or automatic rotation), 'created' should be 0.
|
||||
This "trick" is used by MySQL >=4.0.14 slaves to know if they must drop the
|
||||
stale temporary tables or not.
|
||||
Note that when 'created'!=0, it is always equal to the event's timestamp;
|
||||
indeed Start_log_event is written only in log.cc where the first
|
||||
constructor below is called, in which 'created' is set to 'when'.
|
||||
constructor below is called, in which 'created' is set to 'when'.
|
||||
So in fact 'created' is a useless variable. When it is 0
|
||||
we can read the actual value from timestamp ('when') and when it is
|
||||
non-zero we can read the same value from timestamp ('when'). Conclusion:
|
||||
|
|
@ -866,21 +866,21 @@ public:
|
|||
#else
|
||||
Start_log_event_v3() {}
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
Start_log_event_v3(const char* buf,
|
||||
const Format_description_log_event* description_event);
|
||||
~Start_log_event_v3() {}
|
||||
Log_event_type get_type_code() { return START_EVENT_V3;}
|
||||
int write_data(IO_CACHE* file);
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
int get_data_size()
|
||||
{
|
||||
return START_V3_HEADER_LEN; //no variable-sized part
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
/*
|
||||
For binlog version 4.
|
||||
This event is saved by threads which read it, as they need it for future
|
||||
use (to decode the ordinary events).
|
||||
|
|
@ -889,7 +889,7 @@ public:
|
|||
class Format_description_log_event: public Start_log_event_v3
|
||||
{
|
||||
public:
|
||||
/*
|
||||
/*
|
||||
The size of the fixed header which _all_ events have
|
||||
(for binlogs written by this version, this is equal to
|
||||
LOG_EVENT_HEADER_LEN), except FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT
|
||||
|
|
@ -906,18 +906,18 @@ public:
|
|||
#ifdef HAVE_REPLICATION
|
||||
int exec_event(struct st_relay_log_info* rli);
|
||||
#endif /* HAVE_REPLICATION */
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Format_description_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
~Format_description_log_event() { my_free((gptr)post_header_len, MYF(0)); }
|
||||
Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
|
||||
int write_data(IO_CACHE* file);
|
||||
const bool is_valid()
|
||||
{
|
||||
bool is_valid() const
|
||||
{
|
||||
return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
|
||||
LOG_EVENT_MINIMAL_HEADER_LEN)) &&
|
||||
(post_header_len != NULL));
|
||||
LOG_EVENT_MINIMAL_HEADER_LEN)) &&
|
||||
(post_header_len != NULL));
|
||||
}
|
||||
int get_event_len()
|
||||
{
|
||||
|
|
@ -950,7 +950,7 @@ public:
|
|||
ulonglong val;
|
||||
uchar type;
|
||||
|
||||
#ifndef MYSQL_CLIENT
|
||||
#ifndef MYSQL_CLIENT
|
||||
Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
|
||||
:Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
|
||||
{}
|
||||
|
|
@ -960,7 +960,7 @@ public:
|
|||
#endif /* HAVE_REPLICATION */
|
||||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
Intvar_log_event(const char* buf, const Format_description_log_event* description_event);
|
||||
~Intvar_log_event() {}
|
||||
|
|
@ -968,14 +968,14 @@ public:
|
|||
const char* get_var_type_name();
|
||||
int get_data_size() { return 9; /* sizeof(type) + sizeof(val) */;}
|
||||
int write_data(IO_CACHE* file);
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
};
|
||||
|
||||
/*****************************************************************************
|
||||
|
||||
Rand Log Event class
|
||||
|
||||
Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
|
||||
Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
|
||||
4.1.1 does not need it (it's repeatable again) so this event needn't be
|
||||
written in 4.1.1 for PASSWORD() (but the fact that it is written is just a
|
||||
waste, it does not cause bugs).
|
||||
|
|
@ -1004,7 +1004,7 @@ class Rand_log_event: public Log_event
|
|||
Log_event_type get_type_code() { return RAND_EVENT;}
|
||||
int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
|
||||
int write_data(IO_CACHE* file);
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
};
|
||||
|
||||
/*****************************************************************************
|
||||
|
|
@ -1051,7 +1051,7 @@ public:
|
|||
UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE + val_len);
|
||||
}
|
||||
int write_data(IO_CACHE* file);
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
};
|
||||
|
||||
/*****************************************************************************
|
||||
|
|
@ -1070,14 +1070,14 @@ public:
|
|||
int exec_event(struct st_relay_log_info* rli);
|
||||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
Stop_log_event(const char* buf, const Format_description_log_event* description_event):
|
||||
Log_event(buf, description_event)
|
||||
{}
|
||||
~Stop_log_event() {}
|
||||
Log_event_type get_type_code() { return STOP_EVENT;}
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
};
|
||||
|
||||
#endif /* HAVE_REPLICATION */
|
||||
|
|
@ -1097,7 +1097,7 @@ public:
|
|||
ulonglong pos;
|
||||
uint ident_len;
|
||||
bool alloced;
|
||||
#ifndef MYSQL_CLIENT
|
||||
#ifndef MYSQL_CLIENT
|
||||
Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
|
||||
uint ident_len_arg = 0,
|
||||
ulonglong pos_arg = LOG_EVENT_OFFSET)
|
||||
|
|
@ -1126,7 +1126,7 @@ public:
|
|||
return (LOG_EVENT_MINIMAL_HEADER_LEN + get_data_size());
|
||||
}
|
||||
int get_data_size() { return ident_len + ROTATE_HEADER_LEN;}
|
||||
const bool is_valid() { return new_log_ident != 0; }
|
||||
bool is_valid() const { return new_log_ident != 0; }
|
||||
int write_data(IO_CACHE* file);
|
||||
};
|
||||
|
||||
|
|
@ -1145,7 +1145,7 @@ protected:
|
|||
our Load part - used on the slave when writing event out to
|
||||
SQL_LOAD-*.info file
|
||||
*/
|
||||
bool fake_base;
|
||||
bool fake_base;
|
||||
public:
|
||||
char* block;
|
||||
const char *event_buf;
|
||||
|
|
@ -1167,8 +1167,8 @@ public:
|
|||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
void print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info, bool enable_local);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Create_file_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
~Create_file_log_event()
|
||||
|
|
@ -1186,7 +1186,7 @@ public:
|
|||
Load_log_event::get_data_size() +
|
||||
4 + 1 + block_len);
|
||||
}
|
||||
const bool is_valid() { return inited_from_old || block != 0; }
|
||||
bool is_valid() const { return inited_from_old || block != 0; }
|
||||
int write_data_header(IO_CACHE* file);
|
||||
int write_data_body(IO_CACHE* file);
|
||||
/*
|
||||
|
|
@ -1230,13 +1230,13 @@ public:
|
|||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
|
||||
Append_block_log_event(const char* buf, uint event_len,
|
||||
|
||||
Append_block_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
~Append_block_log_event() {}
|
||||
Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
|
||||
int get_data_size() { return block_len + APPEND_BLOCK_HEADER_LEN ;}
|
||||
const bool is_valid() { return block != 0; }
|
||||
bool is_valid() const { return block != 0; }
|
||||
int write_data(IO_CACHE* file);
|
||||
const char* get_db() { return db; }
|
||||
};
|
||||
|
|
@ -1251,7 +1251,7 @@ class Delete_file_log_event: public Log_event
|
|||
public:
|
||||
uint file_id;
|
||||
const char* db; /* see comment in Append_block_log_event */
|
||||
|
||||
|
||||
#ifndef MYSQL_CLIENT
|
||||
Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
|
||||
#ifdef HAVE_REPLICATION
|
||||
|
|
@ -1261,14 +1261,14 @@ public:
|
|||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
void print(FILE* file, bool short_form, LAST_EVENT_INFO* last_event_info, bool enable_local);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Delete_file_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
~Delete_file_log_event() {}
|
||||
Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
|
||||
int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
|
||||
const bool is_valid() { return file_id != 0; }
|
||||
bool is_valid() const { return file_id != 0; }
|
||||
int write_data(IO_CACHE* file);
|
||||
const char* get_db() { return db; }
|
||||
};
|
||||
|
|
@ -1282,7 +1282,7 @@ class Execute_load_log_event: public Log_event
|
|||
{
|
||||
public:
|
||||
uint file_id;
|
||||
const char* db; /* see comment in Append_block_log_event */
|
||||
const char* db; /* see comment in Append_block_log_event */
|
||||
|
||||
#ifndef MYSQL_CLIENT
|
||||
Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
|
||||
|
|
@ -1292,14 +1292,14 @@ public:
|
|||
#endif /* HAVE_REPLICATION */
|
||||
#else
|
||||
void print(FILE* file, bool short_form = 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
#endif
|
||||
|
||||
Execute_load_log_event(const char* buf, uint event_len,
|
||||
#endif
|
||||
|
||||
Execute_load_log_event(const char* buf, uint event_len,
|
||||
const Format_description_log_event* description_event);
|
||||
~Execute_load_log_event() {}
|
||||
Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
|
||||
int get_data_size() { return EXEC_LOAD_HEADER_LEN ;}
|
||||
const bool is_valid() { return file_id != 0; }
|
||||
bool is_valid() const { return file_id != 0; }
|
||||
int write_data(IO_CACHE* file);
|
||||
const char* get_db() { return db; }
|
||||
};
|
||||
|
|
@ -1319,8 +1319,8 @@ public:
|
|||
~Unknown_log_event() {}
|
||||
void print(FILE* file, bool short_form= 0, LAST_EVENT_INFO* last_event_info= 0);
|
||||
Log_event_type get_type_code() { return UNKNOWN_EVENT;}
|
||||
const bool is_valid() { return 1; }
|
||||
bool is_valid() const { return 1; }
|
||||
};
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* _log_event_h */
|
||||
|
|
|
|||
1023
sql/opt_range.cc
1023
sql/opt_range.cc
File diff suppressed because it is too large
Load diff
138
sql/opt_range.h
138
sql/opt_range.h
|
|
@ -67,7 +67,7 @@ class QUICK_RANGE :public Sql_alloc {
|
|||
|
||||
|
||||
/*
|
||||
Quick select interface.
|
||||
Quick select interface.
|
||||
This class is a parent for all QUICK_*_SELECT and FT_SELECT classes.
|
||||
*/
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ public:
|
|||
double read_time; /* time to perform this retrieval */
|
||||
TABLE *head;
|
||||
/*
|
||||
Index this quick select uses, or MAX_KEY for quick selects
|
||||
Index this quick select uses, or MAX_KEY for quick selects
|
||||
that use several indexes
|
||||
*/
|
||||
uint index;
|
||||
|
|
@ -99,35 +99,35 @@ public:
|
|||
|
||||
QUICK_SELECT_I();
|
||||
virtual ~QUICK_SELECT_I(){};
|
||||
|
||||
|
||||
/*
|
||||
Do post-constructor initialization.
|
||||
SYNOPSIS
|
||||
init()
|
||||
|
||||
init() performs initializations that should have been in constructor if
|
||||
it was possible to return errors from constructors. The join optimizer may
|
||||
|
||||
init() performs initializations that should have been in constructor if
|
||||
it was possible to return errors from constructors. The join optimizer may
|
||||
create and then delete quick selects without retrieving any rows so init()
|
||||
must not contain any IO or CPU intensive code.
|
||||
|
||||
If init() call fails the only valid action is to delete this quick select,
|
||||
If init() call fails the only valid action is to delete this quick select,
|
||||
reset() and get_next() must not be called.
|
||||
|
||||
|
||||
RETURN
|
||||
0 OK
|
||||
other Error code
|
||||
*/
|
||||
virtual int init() = 0;
|
||||
|
||||
/*
|
||||
|
||||
/*
|
||||
Initialize quick select for row retrieval.
|
||||
SYNOPSIS
|
||||
reset()
|
||||
|
||||
reset() should be called when it is certain that row retrieval will be
|
||||
|
||||
reset() should be called when it is certain that row retrieval will be
|
||||
necessary. This call may do heavyweight initialization like buffering first
|
||||
N records etc. If reset() call fails get_next() must not be called.
|
||||
|
||||
|
||||
RETURN
|
||||
0 OK
|
||||
other Error code
|
||||
|
|
@ -140,7 +140,7 @@ public:
|
|||
virtual bool reverse_sorted() = 0;
|
||||
virtual bool unique_key_range() { return false; }
|
||||
|
||||
enum {
|
||||
enum {
|
||||
QS_TYPE_RANGE = 0,
|
||||
QS_TYPE_INDEX_MERGE = 1,
|
||||
QS_TYPE_RANGE_DESC = 2,
|
||||
|
|
@ -154,7 +154,7 @@ public:
|
|||
|
||||
/*
|
||||
Initialize this quick select as a merged scan inside a ROR-union or a ROR-
|
||||
intersection scan. The caller must not additionally call init() if this
|
||||
intersection scan. The caller must not additionally call init() if this
|
||||
function is called.
|
||||
SYNOPSIS
|
||||
init_ror_merged_scan()
|
||||
|
|
@ -162,55 +162,55 @@ public:
|
|||
it must create and use a separate handler object.
|
||||
RETURN
|
||||
0 Ok
|
||||
other Error
|
||||
other Error
|
||||
*/
|
||||
virtual int init_ror_merged_scan(bool reuse_handler)
|
||||
{ DBUG_ASSERT(0); return 1; }
|
||||
|
||||
|
||||
/*
|
||||
Save ROWID of last retrieved row in file->ref. This used in ROR-merging.
|
||||
*/
|
||||
virtual void save_last_pos(){};
|
||||
|
||||
/*
|
||||
/*
|
||||
Append comma-separated list of keys this quick select uses to key_names;
|
||||
append comma-separated list of corresponding used lengths to used_lengths.
|
||||
This is used by select_describe.
|
||||
*/
|
||||
virtual void add_keys_and_lengths(String *key_names,
|
||||
virtual void add_keys_and_lengths(String *key_names,
|
||||
String *used_lengths)=0;
|
||||
|
||||
/*
|
||||
Append text representation of quick select structure (what and how is
|
||||
|
||||
/*
|
||||
Append text representation of quick select structure (what and how is
|
||||
merged) to str. The result is added to "Extra" field in EXPLAIN output.
|
||||
This function is implemented only by quick selects that merge other quick
|
||||
selects output and/or can produce output suitable for merging.
|
||||
*/
|
||||
virtual void add_info_string(String *str) {};
|
||||
/*
|
||||
Return 1 if any index used by this quick select
|
||||
a) uses field that is listed in passed field list or
|
||||
Return 1 if any index used by this quick select
|
||||
a) uses field that is listed in passed field list or
|
||||
b) is automatically updated (like a timestamp)
|
||||
*/
|
||||
virtual bool check_if_keys_used(List<Item> *fields);
|
||||
|
||||
/*
|
||||
rowid of last row retrieved by this quick select. This is used only when
|
||||
doing ROR-index_merge selects
|
||||
rowid of last row retrieved by this quick select. This is used only when
|
||||
doing ROR-index_merge selects
|
||||
*/
|
||||
byte *last_rowid;
|
||||
|
||||
/*
|
||||
Table record buffer used by this quick select.
|
||||
Table record buffer used by this quick select.
|
||||
*/
|
||||
byte *record;
|
||||
#ifndef DBUG_OFF
|
||||
/*
|
||||
Print quick select information to DBUG_FILE. Caller is responsible
|
||||
Print quick select information to DBUG_FILE. Caller is responsible
|
||||
for locking DBUG_FILE before this call and unlocking it afterwards.
|
||||
*/
|
||||
virtual void dbug_dump(int indent, bool verbose)= 0;
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -218,7 +218,7 @@ struct st_qsel_param;
|
|||
class SEL_ARG;
|
||||
|
||||
/*
|
||||
Quick select that does a range scan on a single key. The records are
|
||||
Quick select that does a range scan on a single key. The records are
|
||||
returned in key order.
|
||||
*/
|
||||
class QUICK_RANGE_SELECT : public QUICK_SELECT_I
|
||||
|
|
@ -237,7 +237,7 @@ protected:
|
|||
|
||||
protected:
|
||||
friend
|
||||
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
|
||||
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
|
||||
struct st_table_ref *ref);
|
||||
friend bool get_quick_keys(struct st_qsel_param *param,
|
||||
QUICK_RANGE_SELECT *quick,KEY_PART *key,
|
||||
|
|
@ -255,7 +255,7 @@ protected:
|
|||
QUICK_RANGE **cur_range; /* current element in ranges */
|
||||
|
||||
QUICK_RANGE *range;
|
||||
KEY_PART *key_parts;
|
||||
KEY_PART *key_parts;
|
||||
KEY_PART_INFO *key_part_info;
|
||||
int cmp_next(QUICK_RANGE *range);
|
||||
int cmp_prev(QUICK_RANGE *range);
|
||||
|
|
@ -266,11 +266,11 @@ public:
|
|||
QUICK_RANGE_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc=0,
|
||||
MEM_ROOT *parent_alloc=NULL);
|
||||
~QUICK_RANGE_SELECT();
|
||||
|
||||
|
||||
int reset(void)
|
||||
{
|
||||
next=0;
|
||||
range= NULL;
|
||||
next=0;
|
||||
range= NULL;
|
||||
cur_range= NULL;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -308,29 +308,29 @@ public:
|
|||
/*
|
||||
QUICK_INDEX_MERGE_SELECT - index_merge access method quick select.
|
||||
|
||||
QUICK_INDEX_MERGE_SELECT uses
|
||||
QUICK_INDEX_MERGE_SELECT uses
|
||||
* QUICK_RANGE_SELECTs to get rows
|
||||
* Unique class to remove duplicate rows
|
||||
|
||||
INDEX MERGE OPTIMIZER
|
||||
Current implementation doesn't detect all cases where index_merge could
|
||||
Current implementation doesn't detect all cases where index_merge could
|
||||
be used, in particular:
|
||||
* index_merge will never be used if range scan is possible (even if
|
||||
* index_merge will never be used if range scan is possible (even if
|
||||
range scan is more expensive)
|
||||
|
||||
* index_merge+'using index' is not supported (this the consequence of
|
||||
* index_merge+'using index' is not supported (this the consequence of
|
||||
the above restriction)
|
||||
|
||||
|
||||
* If WHERE part contains complex nested AND and OR conditions, some ways
|
||||
to retrieve rows using index_merge will not be considered. The choice
|
||||
of read plan may depend on the order of conjuncts/disjuncts in WHERE
|
||||
to retrieve rows using index_merge will not be considered. The choice
|
||||
of read plan may depend on the order of conjuncts/disjuncts in WHERE
|
||||
part of the query, see comments near imerge_list_or_list and
|
||||
SEL_IMERGE::or_sel_tree_with_checks functions for details.
|
||||
|
||||
* There is no "index_merge_ref" method (but index_merge on non-first
|
||||
table in join is possible with 'range checked for each record').
|
||||
|
||||
See comments around SEL_IMERGE class and test_quick_select for more
|
||||
See comments around SEL_IMERGE class and test_quick_select for more
|
||||
details.
|
||||
|
||||
ROW RETRIEVAL ALGORITHM
|
||||
|
|
@ -352,7 +352,7 @@ public:
|
|||
}
|
||||
deactivate 'index only';
|
||||
}
|
||||
|
||||
|
||||
Phase 2 (implemented as sequence of QUICK_INDEX_MERGE_SELECT::get_next
|
||||
calls):
|
||||
|
||||
|
|
@ -364,7 +364,7 @@ public:
|
|||
}
|
||||
*/
|
||||
|
||||
class QUICK_INDEX_MERGE_SELECT : public QUICK_SELECT_I
|
||||
class QUICK_INDEX_MERGE_SELECT : public QUICK_SELECT_I
|
||||
{
|
||||
public:
|
||||
QUICK_INDEX_MERGE_SELECT(THD *thd, TABLE *table);
|
||||
|
|
@ -387,23 +387,23 @@ public:
|
|||
|
||||
/* range quick selects this index_merge read consists of */
|
||||
List<QUICK_RANGE_SELECT> quick_selects;
|
||||
|
||||
|
||||
/* quick select which is currently used for rows retrieval */
|
||||
List_iterator_fast<QUICK_RANGE_SELECT> cur_quick_it;
|
||||
QUICK_RANGE_SELECT* cur_quick_select;
|
||||
|
||||
|
||||
/* quick select that uses clustered primary key (NULL if none) */
|
||||
QUICK_RANGE_SELECT* pk_quick_select;
|
||||
|
||||
|
||||
/* true if this select is currently doing a clustered PK scan */
|
||||
bool doing_pk_scan;
|
||||
|
||||
|
||||
Unique *unique;
|
||||
MEM_ROOT alloc;
|
||||
|
||||
THD *thd;
|
||||
int prepare_unique();
|
||||
|
||||
|
||||
/* used to get rows collected in Unique */
|
||||
READ_RECORD read_record;
|
||||
};
|
||||
|
|
@ -411,26 +411,26 @@ public:
|
|||
|
||||
/*
|
||||
Rowid-Ordered Retrieval (ROR) index intersection quick select.
|
||||
This quick select produces intersection of row sequences returned
|
||||
This quick select produces intersection of row sequences returned
|
||||
by several QUICK_RANGE_SELECTs it "merges".
|
||||
|
||||
All merged QUICK_RANGE_SELECTs must return rowids in rowid order.
|
||||
|
||||
All merged QUICK_RANGE_SELECTs must return rowids in rowid order.
|
||||
QUICK_ROR_INTERSECT_SELECT will return rows in rowid order, too.
|
||||
|
||||
All merged quick selects retrieve {rowid, covered_fields} tuples (not full
|
||||
All merged quick selects retrieve {rowid, covered_fields} tuples (not full
|
||||
table records).
|
||||
QUICK_ROR_INTERSECT_SELECT retrieves full records if it is not being used
|
||||
by QUICK_ROR_INTERSECT_SELECT and all merged quick selects together don't
|
||||
QUICK_ROR_INTERSECT_SELECT retrieves full records if it is not being used
|
||||
by QUICK_ROR_INTERSECT_SELECT and all merged quick selects together don't
|
||||
cover needed all fields.
|
||||
|
||||
|
||||
If one of the merged quick selects is a Clustered PK range scan, it is
|
||||
used only to filter rowid sequence produced by other merged quick selects.
|
||||
*/
|
||||
|
||||
class QUICK_ROR_INTERSECT_SELECT : public QUICK_SELECT_I
|
||||
class QUICK_ROR_INTERSECT_SELECT : public QUICK_SELECT_I
|
||||
{
|
||||
public:
|
||||
QUICK_ROR_INTERSECT_SELECT(THD *thd, TABLE *table,
|
||||
QUICK_ROR_INTERSECT_SELECT(THD *thd, TABLE *table,
|
||||
bool retrieve_full_rows,
|
||||
MEM_ROOT *parent_alloc);
|
||||
~QUICK_ROR_INTERSECT_SELECT();
|
||||
|
|
@ -450,14 +450,14 @@ public:
|
|||
int init_ror_merged_scan(bool reuse_handler);
|
||||
bool push_quick_back(QUICK_RANGE_SELECT *quick_sel_range);
|
||||
|
||||
/*
|
||||
/*
|
||||
Range quick selects this intersection consists of, not including
|
||||
cpk_quick.
|
||||
*/
|
||||
List<QUICK_RANGE_SELECT> quick_selects;
|
||||
|
||||
/*
|
||||
Merged quick select that uses Clustered PK, if there is one. This quick
|
||||
|
||||
/*
|
||||
Merged quick select that uses Clustered PK, if there is one. This quick
|
||||
select is not used for row retrieval, it is used for row retrieval.
|
||||
*/
|
||||
QUICK_RANGE_SELECT *cpk_quick;
|
||||
|
|
@ -473,15 +473,15 @@ public:
|
|||
This quick select produces union of row sequences returned by several
|
||||
quick select it "merges".
|
||||
|
||||
All merged quick selects must return rowids in rowid order.
|
||||
All merged quick selects must return rowids in rowid order.
|
||||
QUICK_ROR_UNION_SELECT will return rows in rowid order, too.
|
||||
|
||||
All merged quick selects are set not to retrieve full table records.
|
||||
ROR-union quick select always retrieves full records.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
class QUICK_ROR_UNION_SELECT : public QUICK_SELECT_I
|
||||
class QUICK_ROR_UNION_SELECT : public QUICK_SELECT_I
|
||||
{
|
||||
public:
|
||||
QUICK_ROR_UNION_SELECT(THD *thd, TABLE *table);
|
||||
|
|
@ -503,7 +503,7 @@ public:
|
|||
bool push_quick_back(QUICK_SELECT_I *quick_sel_range);
|
||||
|
||||
List<QUICK_SELECT_I> quick_selects; /* Merged quick selects */
|
||||
|
||||
|
||||
QUEUE queue; /* Priority queue for merge operation */
|
||||
MEM_ROOT alloc; /* Memory pool for this and merged quick selects data. */
|
||||
|
||||
|
|
@ -511,7 +511,7 @@ public:
|
|||
byte *cur_rowid; /* buffer used in get_next() */
|
||||
byte *prev_rowid; /* rowid of last row returned by get_next() */
|
||||
bool have_prev_rowid; /* true if prev_rowid has valid data */
|
||||
uint rowid_length; /* table rowid length */
|
||||
uint rowid_length; /* table rowid length */
|
||||
private:
|
||||
static int queue_cmp(void *arg, byte *val1, byte *val2);
|
||||
};
|
||||
|
|
@ -569,4 +569,6 @@ public:
|
|||
int get_type() { return QS_TYPE_FULLTEXT; }
|
||||
};
|
||||
|
||||
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
|
||||
struct st_table_ref *ref);
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in a new issue