summaryrefslogtreecommitdiff
path: root/sql
diff options
context:
space:
mode:
Diffstat (limited to 'sql')
-rw-r--r--sql/ha_partition.cc102
-rw-r--r--sql/handler.cc337
-rw-r--r--sql/handler.h243
-rw-r--r--sql/item.cc3
-rw-r--r--sql/item_func.cc12
-rw-r--r--sql/item_sum.cc2
-rw-r--r--sql/mysqld.cc7
-rw-r--r--sql/sp_head.cc6
-rw-r--r--sql/sp_head.h5
-rw-r--r--sql/sp_rcontext.cc76
-rw-r--r--sql/sp_rcontext.h40
-rw-r--r--sql/sql_base.cc6
-rw-r--r--sql/sql_cache.cc59
-rw-r--r--sql/sql_delete.cc4
-rw-r--r--sql/sql_insert.cc4
-rw-r--r--sql/sql_partition.cc18
-rw-r--r--sql/sql_select.cc48
-rw-r--r--sql/sql_show.cc2
-rw-r--r--sql/sql_table.cc52
-rw-r--r--sql/sql_union.cc6
-rw-r--r--sql/sql_update.cc10
-rw-r--r--sql/sql_yacc.yy157
-rw-r--r--sql/unireg.cc4
23 files changed, 888 insertions, 315 deletions
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 3f1634a6ad1..51070a525c5 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -367,7 +367,7 @@ bool ha_partition::initialise_partition(MEM_ROOT *mem_root)
HA_CAN_GEOMETRY, HA_CAN_FULLTEXT, HA_CAN_SQL_HANDLER, HA_DUPLICATE_POS,
HA_CAN_INSERT_DELAYED is disabled until further investigated.
*/
- m_table_flags= (ulong)m_file[0]->table_flags();
+ m_table_flags= (ulong)m_file[0]->ha_table_flags();
m_low_byte_first= m_file[0]->low_byte_first();
m_pkey_is_clustered= TRUE;
file_array= m_file;
@@ -382,7 +382,7 @@ bool ha_partition::initialise_partition(MEM_ROOT *mem_root)
}
if (!file->primary_key_is_clustered())
m_pkey_is_clustered= FALSE;
- m_table_flags&= file->table_flags();
+ m_table_flags&= file->ha_table_flags();
} while (*(++file_array));
m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS |
HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED |
@@ -616,7 +616,7 @@ int ha_partition::drop_partitions(const char *path)
sub_elem->partition_name, name_variant);
file= m_file[part];
DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff));
- if ((ret_error= file->delete_table((const char *) part_name_buff)))
+ if ((ret_error= file->ha_delete_table(part_name_buff)))
error= ret_error;
if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
@@ -629,7 +629,7 @@ int ha_partition::drop_partitions(const char *path)
TRUE);
file= m_file[i];
DBUG_PRINT("info", ("Drop partition %s", part_name_buff));
- if ((ret_error= file->delete_table((const char *) part_name_buff)))
+ if ((ret_error= file->ha_delete_table(part_name_buff)))
error= ret_error;
if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
@@ -707,7 +707,7 @@ int ha_partition::rename_partitions(const char *path)
sub_elem->partition_name,
NORMAL_PART_NAME);
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
- if ((ret_error= file->delete_table((const char *) norm_name_buff)))
+ if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
@@ -722,7 +722,7 @@ int ha_partition::rename_partitions(const char *path)
part_elem->partition_name, NORMAL_PART_NAME,
TRUE);
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
- if ((ret_error= file->delete_table((const char *) norm_name_buff)))
+ if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
@@ -778,7 +778,7 @@ int ha_partition::rename_partitions(const char *path)
{
file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
- if ((ret_error= file->delete_table((const char *) norm_name_buff)))
+ if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
@@ -791,8 +791,8 @@ int ha_partition::rename_partitions(const char *path)
TEMP_PART_NAME);
DBUG_PRINT("info", ("Rename subpartition from %s to %s",
part_name_buff, norm_name_buff));
- if ((ret_error= file->rename_table((const char *) part_name_buff,
- (const char *) norm_name_buff)))
+ if ((ret_error= file->ha_rename_table(part_name_buff,
+ norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
@@ -809,7 +809,7 @@ int ha_partition::rename_partitions(const char *path)
{
file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
- if ((ret_error= file->delete_table((const char *) norm_name_buff)))
+ if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
@@ -821,8 +821,8 @@ int ha_partition::rename_partitions(const char *path)
TRUE);
DBUG_PRINT("info", ("Rename partition from %s to %s",
part_name_buff, norm_name_buff));
- if ((ret_error= file->rename_table((const char *) part_name_buff,
- (const char *) norm_name_buff)))
+ if ((ret_error= file->ha_rename_table(part_name_buff,
+ norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
@@ -1036,9 +1036,9 @@ static int handle_opt_part(THD *thd, HA_CHECK_OPT *check_opt,
DBUG_PRINT("enter", ("flag = %u", flag));
if (flag == OPTIMIZE_PARTS)
- error= file->optimize(thd, check_opt);
+ error= file->ha_optimize(thd, check_opt);
else if (flag == ANALYZE_PARTS)
- error= file->analyze(thd, check_opt);
+ error= file->ha_analyze(thd, check_opt);
else if (flag == CHECK_PARTS)
error= file->ha_check(thd, check_opt);
else if (flag == REPAIR_PARTS)
@@ -1139,7 +1139,7 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
if ((error= set_up_table_before_create(tbl, part_name, create_info,
0, p_elem)))
goto error;
- if ((error= file->create(part_name, tbl, create_info)))
+ if ((error= file->ha_create(part_name, tbl, create_info)))
goto error;
create_flag= TRUE;
if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock)))
@@ -1150,13 +1150,13 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
assumes that external_lock() is last call that may fail here.
Otherwise see description for cleanup_new_partition().
*/
- if ((error= file->external_lock(current_thd, m_lock_type)))
+ if ((error= file->ha_external_lock(current_thd, m_lock_type)))
goto error;
DBUG_RETURN(0);
error:
if (create_flag)
- VOID(file->delete_table(part_name));
+ VOID(file->ha_delete_table(part_name));
DBUG_RETURN(error);
}
@@ -1574,14 +1574,18 @@ int ha_partition::copy_partitions(ulonglong *copied, ulonglong *deleted)
}
else
{
+ THD *thd= ha_thd();
/* Copy record to new handler */
copied++;
- if ((result= m_new_file[new_part]->write_row(m_rec0)))
+ tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
+ result= m_new_file[new_part]->ha_write_row(m_rec0);
+ reenable_binlog(thd);
+ if (result)
goto error;
}
}
late_extra_no_cache(reorg_part);
- file->rnd_end();
+ file->ha_rnd_end();
reorg_part++;
}
DBUG_RETURN(FALSE);
@@ -1698,16 +1702,15 @@ uint ha_partition::del_ren_cre_table(const char *from,
{ // Rename branch
create_partition_name(to_buff, to, name_buffer_ptr, NORMAL_PART_NAME,
FALSE);
- error= (*file)->rename_table((const char*) from_buff,
- (const char*) to_buff);
+ error= (*file)->ha_rename_table(from_buff, to_buff);
}
else if (table_arg == NULL) // delete branch
- error= (*file)->delete_table((const char*) from_buff);
+ error= (*file)->ha_delete_table(from_buff);
else
{
if ((error= set_up_table_before_create(table_arg, from_buff,
create_info, i, NULL)) ||
- ((error= (*file)->create(from_buff, table_arg, create_info))))
+ ((error= (*file)->ha_create(from_buff, table_arg, create_info))))
goto create_error;
}
name_buffer_ptr= strend(name_buffer_ptr) + 1;
@@ -1722,7 +1725,7 @@ create_error:
{
create_partition_name(from_buff, from, name_buffer_ptr, NORMAL_PART_NAME,
FALSE);
- VOID((*file)->delete_table((const char*) from_buff));
+ VOID((*file)->ha_delete_table((const char*) from_buff));
name_buffer_ptr= strend(name_buffer_ptr) + 1;
}
DBUG_RETURN(error);
@@ -2314,7 +2317,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
}
/* Recalculate table flags as they may change after open */
- m_table_flags= m_file[0]->table_flags();
+ m_table_flags= m_file[0]->ha_table_flags();
file= m_file;
do
{
@@ -2326,7 +2329,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
m_no_locks+= (*file)->lock_count();
name_buffer_ptr+= strlen(name_buffer_ptr) + 1;
set_if_bigger(ref_length, ((*file)->ref_length));
- m_table_flags&= (*file)->table_flags();
+ m_table_flags&= (*file)->ha_table_flags();
} while (*(++file));
m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS |
HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED);
@@ -2482,7 +2485,7 @@ repeat:
{
DBUG_PRINT("info", ("external_lock(thd, %d) iteration %d",
lock_type, (int) (file - m_file)));
- if ((error= (*file)->external_lock(thd, lock_type)))
+ if ((error= (*file)->ha_external_lock(thd, lock_type)))
{
if (F_UNLCK != lock_type)
goto err_handler;
@@ -2501,7 +2504,7 @@ repeat:
err_handler:
while (file-- != m_file)
{
- (*file)->external_lock(thd, F_UNLCK);
+ (*file)->ha_external_lock(thd, F_UNLCK);
}
DBUG_RETURN(error);
}
@@ -2694,6 +2697,7 @@ int ha_partition::write_row(uchar * buf)
longlong func_value;
bool autoincrement_lock= FALSE;
my_bitmap_map *old_map;
+ THD *thd= ha_thd();
#ifdef NOT_NEEDED
uchar *rec0= m_rec0;
#endif
@@ -2765,7 +2769,9 @@ int ha_partition::write_row(uchar * buf)
}
m_last_part= part_id;
DBUG_PRINT("info", ("Insert in partition %d", part_id));
- error= m_file[part_id]->write_row(buf);
+ tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
+ error= m_file[part_id]->ha_write_row(buf);
+ reenable_binlog(thd);
exit:
if (autoincrement_lock)
pthread_mutex_unlock(&table_share->mutex);
@@ -2806,6 +2812,7 @@ exit:
int ha_partition::update_row(const uchar *old_data, uchar *new_data)
{
+ THD *thd= ha_thd();
uint32 new_part_id, old_part_id;
int error= 0;
longlong func_value;
@@ -2840,16 +2847,25 @@ int ha_partition::update_row(const uchar *old_data, uchar *new_data)
if (new_part_id == old_part_id)
{
DBUG_PRINT("info", ("Update in partition %d", new_part_id));
- error= m_file[new_part_id]->update_row(old_data, new_data);
+ tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
+ error= m_file[new_part_id]->ha_update_row(old_data, new_data);
+ reenable_binlog(thd);
goto exit;
}
else
{
DBUG_PRINT("info", ("Update from partition %d to partition %d",
old_part_id, new_part_id));
- if ((error= m_file[new_part_id]->write_row(new_data)))
+ tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
+ error= m_file[new_part_id]->ha_write_row(new_data);
+ reenable_binlog(thd);
+ if (error)
goto exit;
- if ((error= m_file[old_part_id]->delete_row(old_data)))
+
+ tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */
+ error= m_file[old_part_id]->ha_delete_row(old_data);
+ reenable_binlog(thd);
+ if (error)
{
#ifdef IN_THE_FUTURE
(void) m_file[new_part_id]->delete_last_inserted_row(new_data);
@@ -2896,6 +2912,7 @@ int ha_partition::delete_row(const uchar *buf)
{
uint32 part_id;
int error;
+ THD *thd= ha_thd();
DBUG_ENTER("ha_partition::delete_row");
if ((error= get_part_for_delete(buf, m_rec0, m_part_info, &part_id)))
@@ -2903,7 +2920,10 @@ int ha_partition::delete_row(const uchar *buf)
DBUG_RETURN(error);
}
m_last_part= part_id;
- DBUG_RETURN(m_file[part_id]->delete_row(buf));
+ tmp_disable_binlog(thd);
+ error= m_file[part_id]->ha_delete_row(buf);
+ reenable_binlog(thd);
+ DBUG_RETURN(error);
}
@@ -2938,7 +2958,7 @@ int ha_partition::delete_all_rows()
file= m_file;
do
{
- if ((error= (*file)->delete_all_rows()))
+ if ((error= (*file)->ha_delete_all_rows()))
DBUG_RETURN(error);
} while (*(++file));
DBUG_RETURN(0);
@@ -3980,7 +4000,7 @@ int ha_partition::partition_scan_set_up(uchar * buf, bool idx_read_flag)
int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
{
- handler *file= file= m_file[m_part_spec.start_part];
+ handler *file= m_file[m_part_spec.start_part];
int error;
DBUG_ENTER("ha_partition::handle_unordered_next");
@@ -3999,7 +4019,7 @@ int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
}
else if (!(error= file->index_next(buf)))
{
- if (!(file->table_flags() & HA_READ_ORDER) ||
+ if (!(file->ha_table_flags() & HA_READ_ORDER) ||
compare_key(end_range) <= 0)
{
m_last_part= m_part_spec.start_part;
@@ -4077,7 +4097,7 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
}
if (!error)
{
- if (!(file->table_flags() & HA_READ_ORDER) ||
+ if (!(file->ha_table_flags() & HA_READ_ORDER) ||
compare_key(end_range) <= 0)
{
m_last_part= i;
@@ -4999,7 +5019,7 @@ int ha_partition::reset(void)
file= m_file;
do
{
- if ((tmp= (*file)->reset()))
+ if ((tmp= (*file)->ha_reset()))
result= tmp;
} while (*(++file));
DBUG_RETURN(result);
@@ -5641,7 +5661,7 @@ void ha_partition::release_auto_increment()
for (uint i= 0; i < m_tot_parts; i++)
{
- m_file[i]->release_auto_increment();
+ m_file[i]->ha_release_auto_increment();
}
DBUG_VOID_RETURN;
}
@@ -5677,7 +5697,7 @@ int ha_partition::disable_indexes(uint mode)
for (file= m_file; *file; file++)
{
- if ((error= (*file)->disable_indexes(mode)))
+ if ((error= (*file)->ha_disable_indexes(mode)))
break;
}
return error;
@@ -5701,7 +5721,7 @@ int ha_partition::enable_indexes(uint mode)
for (file= m_file; *file; file++)
{
- if ((error= (*file)->enable_indexes(mode)))
+ if ((error= (*file)->ha_enable_indexes(mode)))
break;
}
return error;
diff --git a/sql/handler.cc b/sql/handler.cc
index 0715ef3cc9c..95d63740039 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -1479,7 +1479,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
DBUG_RETURN(ENOENT);
path= check_lowercase_names(file, path, tmp_path);
- if ((error= file->delete_table(path)) && generate_warning)
+ if ((error= file->ha_delete_table(path)) && generate_warning)
{
/*
Because file->print_error() use my_error() to generate the error message
@@ -1498,8 +1498,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
dummy_share.table_name.length= strlen(alias);
dummy_table.alias= alias;
- file->table_share= &dummy_share;
- file->table= &dummy_table;
+ file->change_table_ptr(&dummy_table, &dummy_share);
thd->push_internal_handler(&ha_delete_table_error_handler);
file->print_error(error, 0);
@@ -2508,6 +2507,12 @@ int handler::ha_check(THD *thd, HA_CHECK_OPT *check_opt)
}
+/**
+ Repair table: public interface.
+
+ @sa handler::repair()
+*/
+
int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
int result;
@@ -2518,6 +2523,328 @@ int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
/**
+ Bulk update row: public interface.
+
+ @sa handler::bulk_update_row()
+*/
+
+int
+handler::ha_bulk_update_row(const uchar *old_data, uchar *new_data,
+ uint *dup_key_found)
+{
+ return bulk_update_row(old_data, new_data, dup_key_found);
+}
+
+
+/**
+ Delete all rows: public interface.
+
+ @sa handler::delete_all_rows()
+*/
+
+int
+handler::ha_delete_all_rows()
+{
+ return delete_all_rows();
+}
+
+
+/**
+ Reset auto increment: public interface.
+
+ @sa handler::reset_auto_increment()
+*/
+
+int
+handler::ha_reset_auto_increment(ulonglong value)
+{
+ return reset_auto_increment(value);
+}
+
+
+/**
+ Backup table: public interface.
+
+ @sa handler::backup()
+*/
+
+int
+handler::ha_backup(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ return backup(thd, check_opt);
+}
+
+
+/**
+ Restore table: public interface.
+
+ @sa handler::restore()
+*/
+
+int
+handler::ha_restore(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ return restore(thd, check_opt);
+}
+
+
+/**
+ Optimize table: public interface.
+
+ @sa handler::optimize()
+*/
+
+int
+handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ return optimize(thd, check_opt);
+}
+
+
+/**
+ Analyze table: public interface.
+
+ @sa handler::analyze()
+*/
+
+int
+handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ return analyze(thd, check_opt);
+}
+
+
+/**
+ Check and repair table: public interface.
+
+ @sa handler::check_and_repair()
+*/
+
+bool
+handler::ha_check_and_repair(THD *thd)
+{
+ return check_and_repair(thd);
+}
+
+
+/**
+ Disable indexes: public interface.
+
+ @sa handler::disable_indexes()
+*/
+
+int
+handler::ha_disable_indexes(uint mode)
+{
+ return disable_indexes(mode);
+}
+
+
+/**
+ Enable indexes: public interface.
+
+ @sa handler::enable_indexes()
+*/
+
+int
+handler::ha_enable_indexes(uint mode)
+{
+ return enable_indexes(mode);
+}
+
+
+/**
+ Discard or import tablespace: public interface.
+
+ @sa handler::discard_or_import_tablespace()
+*/
+
+int
+handler::ha_discard_or_import_tablespace(my_bool discard)
+{
+ return discard_or_import_tablespace(discard);
+}
+
+
+/**
+ Prepare for alter: public interface.
+
+ Called to prepare an *online* ALTER.
+
+ @sa handler::prepare_for_alter()
+*/
+
+void
+handler::ha_prepare_for_alter()
+{
+ prepare_for_alter();
+}
+
+
+/**
+ Rename table: public interface.
+
+ @sa handler::rename_table()
+*/
+
+int
+handler::ha_rename_table(const char *from, const char *to)
+{
+ return rename_table(from, to);
+}
+
+
+/**
+ Delete table: public interface.
+
+ @sa handler::delete_table()
+*/
+
+int
+handler::ha_delete_table(const char *name)
+{
+ return delete_table(name);
+}
+
+
+/**
+ Drop table in the engine: public interface.
+
+ @sa handler::drop_table()
+*/
+
+void
+handler::ha_drop_table(const char *name)
+{
+ return drop_table(name);
+}
+
+
+/**
+ Create a table in the engine: public interface.
+
+ @sa handler::create()
+*/
+
+int
+handler::ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info)
+{
+ return create(name, form, info);
+}
+
+
+/**
+ Create handler files for CREATE TABLE: public interface.
+
+ @sa handler::create_handler_files()
+*/
+
+int
+handler::ha_create_handler_files(const char *name, const char *old_name,
+ int action_flag, HA_CREATE_INFO *info)
+{
+ return create_handler_files(name, old_name, action_flag, info);
+}
+
+
+/**
+ Change partitions: public interface.
+
+ @sa handler::change_partitions()
+*/
+
+int
+handler::ha_change_partitions(HA_CREATE_INFO *create_info,
+ const char *path,
+ ulonglong *copied,
+ ulonglong *deleted,
+ const uchar *pack_frm_data,
+ size_t pack_frm_len)
+{
+ return change_partitions(create_info, path, copied, deleted,
+ pack_frm_data, pack_frm_len);
+}
+
+
+/**
+ Drop partitions: public interface.
+
+ @sa handler::drop_partitions()
+*/
+
+int
+handler::ha_drop_partitions(const char *path)
+{
+ return drop_partitions(path);
+}
+
+
+/**
+ Rename partitions: public interface.
+
+ @sa handler::rename_partitions()
+*/
+
+int
+handler::ha_rename_partitions(const char *path)
+{
+ return rename_partitions(path);
+}
+
+
+/**
+ Optimize partitions: public interface.
+
+ @sa handler::optimize_partitions()
+*/
+
+int
+handler::ha_optimize_partitions(THD *thd)
+{
+ return optimize_partitions(thd);
+}
+
+
+/**
+ Analyze partitions: public interface.
+
+ @sa handler::analyze_partitions()
+*/
+
+int
+handler::ha_analyze_partitions(THD *thd)
+{
+ return analyze_partitions(thd);
+}
+
+
+/**
+ Check partitions: public interface.
+
+ @sa handler::check_partitions()
+*/
+
+int
+handler::ha_check_partitions(THD *thd)
+{
+ return check_partitions(thd);
+}
+
+
+/**
+ Repair partitions: public interface.
+
+ @sa handler::repair_partitions()
+*/
+
+int
+handler::ha_repair_partitions(THD *thd)
+{
+ return repair_partitions(thd);
+}
+
+
+/**
Tell the storage engine that it is allowed to "disable transaction" in the
handler. It is a hint that ACID is not required - it is used in NDB for
ALTER TABLE, for example, when data are copied to temporary table.
@@ -2657,7 +2984,7 @@ int ha_create_table(THD *thd, const char *path,
name= check_lowercase_names(table.file, share.path.str, name_buff);
- error= table.file->create(name, &table, create_info);
+ error= table.file->ha_create(name, &table, create_info);
VOID(closefrm(&table, 0));
if (error)
{
@@ -2728,7 +3055,7 @@ int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
check_lowercase_names(table.file, path, path);
- error=table.file->create(path,&table,&create_info);
+ error=table.file->ha_create(path, &table, &create_info);
VOID(closefrm(&table, 1));
DBUG_RETURN(error != 0);
diff --git a/sql/handler.h b/sql/handler.h
index c5b867e315f..b3a4b408589 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -967,10 +967,6 @@ uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map);
class handler :public Sql_alloc
{
- friend class ha_partition;
- friend int ha_delete_table(THD*,handlerton*,const char*,const char*,
- const char*,bool);
-
public:
typedef ulonglong Table_flags;
protected:
@@ -1118,6 +1114,40 @@ public:
estimation_rows_to_insert= 0;
return end_bulk_insert();
}
+ int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
+ uint *dup_key_found);
+ int ha_delete_all_rows();
+ int ha_reset_auto_increment(ulonglong value);
+ int ha_backup(THD* thd, HA_CHECK_OPT* check_opt);
+ int ha_restore(THD* thd, HA_CHECK_OPT* check_opt);
+ int ha_optimize(THD* thd, HA_CHECK_OPT* check_opt);
+ int ha_analyze(THD* thd, HA_CHECK_OPT* check_opt);
+ bool ha_check_and_repair(THD *thd);
+ int ha_disable_indexes(uint mode);
+ int ha_enable_indexes(uint mode);
+ int ha_discard_or_import_tablespace(my_bool discard);
+ void ha_prepare_for_alter();
+ int ha_rename_table(const char *from, const char *to);
+ int ha_delete_table(const char *name);
+ void ha_drop_table(const char *name);
+
+ int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info);
+
+ int ha_create_handler_files(const char *name, const char *old_name,
+ int action_flag, HA_CREATE_INFO *info);
+
+ int ha_change_partitions(HA_CREATE_INFO *create_info,
+ const char *path,
+ ulonglong *copied,
+ ulonglong *deleted,
+ const uchar *pack_frm_data,
+ size_t pack_frm_len);
+ int ha_drop_partitions(const char *path);
+ int ha_rename_partitions(const char *path);
+ int ha_optimize_partitions(THD *thd);
+ int ha_analyze_partitions(THD *thd);
+ int ha_check_partitions(THD *thd);
+ int ha_repair_partitions(THD *thd);
void adjust_next_insert_id_after_explicit_value(ulonglong nr);
int update_auto_increment();
@@ -1204,25 +1234,6 @@ public:
*/
virtual bool start_bulk_delete() { return 1; }
/**
- This method is similar to update_row, however the handler doesn't need
- to execute the updates at this point in time. The handler can be certain
- that another call to bulk_update_row will occur OR a call to
- exec_bulk_update before the set of updates in this query is concluded.
-
- @param old_data Old record
- @param new_data New record
- @param dup_key_found Number of duplicate keys found
-
- @retval 0 Bulk delete used by handler
- @retval 1 Bulk delete not used, normal operation used
- */
- virtual int bulk_update_row(const uchar *old_data, uchar *new_data,
- uint *dup_key_found)
- {
- DBUG_ASSERT(FALSE);
- return HA_ERR_WRONG_COMMAND;
- }
- /**
After this call all outstanding updates must be performed. The number
of duplicate key errors are reported in the duplicate key parameter.
It is allowed to continue to the batched update after this call, the
@@ -1365,14 +1376,6 @@ public:
virtual void try_semi_consistent_read(bool) {}
virtual void unlock_row() {}
virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
- /**
- This is called to delete all rows in a table
- If the handler don't support this, then this function will
- return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
- by one.
- */
- virtual int delete_all_rows()
- { return (my_errno=HA_ERR_WRONG_COMMAND); }
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
@@ -1397,42 +1400,17 @@ public:
next_insert_id= (prev_insert_id > 0) ? prev_insert_id :
insert_id_for_cur_row;
}
- /**
- Reset the auto-increment counter to the given value, i.e. the next row
- inserted will get the given value. This is called e.g. after TRUNCATE
- is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
- returned by storage engines that don't support this operation.
- */
- virtual int reset_auto_increment(ulonglong value)
- { return HA_ERR_WRONG_COMMAND; }
virtual void update_create_info(HA_CREATE_INFO *create_info) {}
int check_old_types();
- virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
- { return HA_ADMIN_NOT_IMPLEMENTED; }
- /**
- Restore assumes .frm file must exist, and that generate_table() has been
- called; It will just copy the data file and run repair.
- */
- virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
- { return HA_ADMIN_NOT_IMPLEMENTED; }
- virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt)
- { return HA_ADMIN_NOT_IMPLEMENTED; }
- virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt)
- { return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
/* end of the list of admin commands */
- virtual bool check_and_repair(THD *thd) { return HA_ERR_WRONG_COMMAND; }
virtual int dump(THD* thd, int fd = -1) { return HA_ERR_WRONG_COMMAND; }
- virtual int disable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
- virtual int enable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
virtual int indexes_are_disabled(void) {return 0;}
- virtual int discard_or_import_tablespace(my_bool discard)
- {return HA_ERR_WRONG_COMMAND;}
virtual int net_read_dump(NET* net) { return HA_ERR_WRONG_COMMAND; }
virtual char *update_table_comment(const char * comment)
{ return (char*) comment;}
@@ -1489,7 +1467,6 @@ public:
virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
- virtual void prepare_for_alter() { return; }
virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
{ return (HA_ERR_WRONG_COMMAND); }
virtual int prepare_drop_index(TABLE *table_arg, uint *key_num,
@@ -1521,44 +1498,12 @@ public:
virtual bool is_crashed() const { return 0; }
virtual bool auto_repair() const { return 0; }
- /**
- default rename_table() and delete_table() rename/delete files with a
- given name and extensions from bas_ext()
- */
- virtual int rename_table(const char *from, const char *to);
- virtual int delete_table(const char *name);
- virtual void drop_table(const char *name);
-
- virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
#define CHF_CREATE_FLAG 0
#define CHF_DELETE_FLAG 1
#define CHF_RENAME_FLAG 2
#define CHF_INDEX_FLAG 3
- virtual int create_handler_files(const char *name, const char *old_name,
- int action_flag, HA_CREATE_INFO *info)
- { return FALSE; }
-
- virtual int change_partitions(HA_CREATE_INFO *create_info,
- const char *path,
- ulonglong *copied,
- ulonglong *deleted,
- const uchar *pack_frm_data,
- size_t pack_frm_len)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int drop_partitions(const char *path)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int rename_partitions(const char *path)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int optimize_partitions(THD *thd)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int analyze_partitions(THD *thd)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int check_partitions(THD *thd)
- { return HA_ERR_WRONG_COMMAND; }
- virtual int repair_partitions(THD *thd)
- { return HA_ERR_WRONG_COMMAND; }
/**
@note lock_count() can return > 1 if the table is MERGE or partitioned.
@@ -1674,22 +1619,6 @@ public:
uint table_changes)
{ return COMPATIBLE_DATA_NO; }
- /** These are only called from sql_select for internal temporary tables */
- virtual int write_row(uchar *buf __attribute__((unused)))
- {
- return HA_ERR_WRONG_COMMAND;
- }
-
- virtual int update_row(const uchar *old_data __attribute__((unused)),
- uchar *new_data __attribute__((unused)))
- {
- return HA_ERR_WRONG_COMMAND;
- }
-
- virtual int delete_row(const uchar *buf __attribute__((unused)))
- {
- return HA_ERR_WRONG_COMMAND;
- }
/**
use_hidden_primary_key() is called in case of an update/delete when
(table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
@@ -1702,6 +1631,16 @@ protected:
void ha_statistic_increment(ulong SSV::*offset) const;
void **ha_data(THD *) const;
THD *ha_thd(void) const;
+
+ /**
+ Default rename_table() and delete_table() rename/delete files with a
+ given name and extensions from bas_ext().
+
+ These methods can be overridden, but their default implementation
+ provide useful functionality.
+ */
+ virtual int rename_table(const char *from, const char *to);
+ virtual int delete_table(const char *name);
private:
/*
Low-level primitives for storage engines. These should be
@@ -1721,6 +1660,21 @@ private:
*/
virtual int rnd_init(bool scan)= 0;
virtual int rnd_end() { return 0; }
+ virtual int write_row(uchar *buf __attribute__((unused)))
+ {
+ return HA_ERR_WRONG_COMMAND;
+ }
+
+ virtual int update_row(const uchar *old_data __attribute__((unused)),
+ uchar *new_data __attribute__((unused)))
+ {
+ return HA_ERR_WRONG_COMMAND;
+ }
+
+ virtual int delete_row(const uchar *buf __attribute__((unused)))
+ {
+ return HA_ERR_WRONG_COMMAND;
+ }
/**
Reset state of file to after 'open'.
This function is called after every statement for all tables used
@@ -1776,6 +1730,85 @@ private:
{ return HA_ERR_WRONG_COMMAND; }
virtual int index_read_last(uchar * buf, const uchar * key, uint key_len)
{ return (my_errno= HA_ERR_WRONG_COMMAND); }
+ /**
+ This method is similar to update_row, however the handler doesn't need
+ to execute the updates at this point in time. The handler can be certain
+ that another call to bulk_update_row will occur OR a call to
+ exec_bulk_update before the set of updates in this query is concluded.
+
+ @param old_data Old record
+ @param new_data New record
+ @param dup_key_found Number of duplicate keys found
+
+ @retval 0 Bulk delete used by handler
+ @retval 1 Bulk delete not used, normal operation used
+ */
+ virtual int bulk_update_row(const uchar *old_data, uchar *new_data,
+ uint *dup_key_found)
+ {
+ DBUG_ASSERT(FALSE);
+ return HA_ERR_WRONG_COMMAND;
+ }
+ /**
+ This is called to delete all rows in a table
+ If the handler don't support this, then this function will
+ return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
+ by one.
+ */
+ virtual int delete_all_rows()
+ { return (my_errno=HA_ERR_WRONG_COMMAND); }
+ /**
+ Reset the auto-increment counter to the given value, i.e. the next row
+ inserted will get the given value. This is called e.g. after TRUNCATE
+ is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
+ returned by storage engines that don't support this operation.
+ */
+ virtual int reset_auto_increment(ulonglong value)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
+ { return HA_ADMIN_NOT_IMPLEMENTED; }
+ /**
+ Restore assumes .frm file must exist, and that generate_table() has been
+ called; It will just copy the data file and run repair.
+ */
+ virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
+ { return HA_ADMIN_NOT_IMPLEMENTED; }
+ virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt)
+ { return HA_ADMIN_NOT_IMPLEMENTED; }
+ virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt)
+ { return HA_ADMIN_NOT_IMPLEMENTED; }
+ virtual bool check_and_repair(THD *thd) { return HA_ERR_WRONG_COMMAND; }
+ virtual int disable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
+ virtual int enable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
+ virtual int discard_or_import_tablespace(my_bool discard)
+ { return (my_errno=HA_ERR_WRONG_COMMAND); }
+ virtual void prepare_for_alter() { return; }
+ virtual void drop_table(const char *name);
+ virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
+
+ virtual int create_handler_files(const char *name, const char *old_name,
+ int action_flag, HA_CREATE_INFO *info)
+ { return FALSE; }
+
+ virtual int change_partitions(HA_CREATE_INFO *create_info,
+ const char *path,
+ ulonglong *copied,
+ ulonglong *deleted,
+ const uchar *pack_frm_data,
+ size_t pack_frm_len)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int drop_partitions(const char *path)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int rename_partitions(const char *path)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int optimize_partitions(THD *thd)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int analyze_partitions(THD *thd)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int check_partitions(THD *thd)
+ { return HA_ERR_WRONG_COMMAND; }
+ virtual int repair_partitions(THD *thd)
+ { return HA_ERR_WRONG_COMMAND; }
};
diff --git a/sql/item.cc b/sql/item.cc
index 463de3e1c52..c546badd8e7 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -3418,7 +3418,7 @@ static Item** find_field_in_group_list(Item *find_item, ORDER *group_list)
@param thd current thread
@param ref column reference being resolved
- @param select the sub-select that ref is resolved against
+ @param select the select that ref is resolved against
@note
The resolution procedure is:
@@ -3478,6 +3478,7 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
}
if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
+ select->having_fix_field &&
select_ref != not_found_item && !group_by_ref)
{
/*
diff --git a/sql/item_func.cc b/sql/item_func.cc
index be8966598d6..6e9371de9dc 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -1994,7 +1994,7 @@ void Item_func_round::fix_length_and_dec()
int length_increase= ((decimals_delta <= 0) || truncate) ? 0:1;
precision-= decimals_delta - length_increase;
- decimals= decimals_to_set;
+ decimals= min(decimals_to_set, DECIMAL_MAX_SCALE);
max_length= my_decimal_precision_to_length(precision, decimals,
unsigned_flag);
break;
@@ -2093,18 +2093,18 @@ my_decimal *Item_func_round::decimal_op(my_decimal *decimal_value)
{
my_decimal val, *value= args[0]->val_decimal(&val);
longlong dec= args[1]->val_int();
- if (dec > 0 || (dec < 0 && args[1]->unsigned_flag))
- {
+ if (dec >= 0 || args[1]->unsigned_flag)
dec= min((ulonglong) dec, decimals);
- decimals= (uint8) dec; // to get correct output
- }
else if (dec < INT_MIN)
dec= INT_MIN;
if (!(null_value= (args[0]->null_value || args[1]->null_value ||
my_decimal_round(E_DEC_FATAL_ERROR, value, (int) dec,
- truncate, decimal_value) > 1)))
+ truncate, decimal_value) > 1)))
+ {
+ decimal_value->frac= decimals;
return decimal_value;
+ }
return 0;
}
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 91198d0fb7e..27b964a9e15 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -2617,7 +2617,7 @@ void Item_sum_count_distinct::clear()
else if (table)
{
table->file->extra(HA_EXTRA_NO_CACHE);
- table->file->delete_all_rows();
+ table->file->ha_delete_all_rows();
table->file->extra(HA_EXTRA_WRITE_CACHE);
}
}
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 2471ab3f81f..7b331d42941 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -608,7 +608,10 @@ char *opt_logname, *opt_slow_logname;
/* Static variables */
static bool kill_in_progress, segfaulted;
-static my_bool opt_do_pstack, opt_bootstrap, opt_myisam_log;
+#ifdef HAVE_STACK_TRACE_ON_SEGV
+static my_bool opt_do_pstack;
+#endif /* HAVE_STACK_TRACE_ON_SEGV */
+static my_bool opt_bootstrap, opt_myisam_log;
static int cleanup_done;
static ulong opt_specialflag, opt_myisam_block_size;
static char *opt_update_logname, *opt_binlog_index_name;
@@ -5461,9 +5464,11 @@ struct my_option my_long_options[] =
(uchar**) &opt_enable_named_pipe, (uchar**) &opt_enable_named_pipe, 0, GET_BOOL,
NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
+#ifdef HAVE_STACK_TRACE_ON_SEGV
{"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
(uchar**) &opt_do_pstack, (uchar**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
0, 0, 0, 0},
+#endif /* HAVE_STACK_TRACE_ON_SEGV */
{"engine-condition-pushdown",
OPT_ENGINE_CONDITION_PUSHDOWN,
"Push supported query conditions to the storage engine.",
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 4a0e18129ad..0edb566ed9f 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -2120,11 +2120,17 @@ sp_head::backpatch(sp_label_t *lab)
uint dest= instructions();
List_iterator_fast<bp_t> li(m_backpatch);
+ DBUG_ENTER("sp_head::backpatch");
while ((bp= li++))
{
if (bp->lab == lab)
+ {
+ DBUG_PRINT("info", ("backpatch: (m_ip %d, label 0x%lx <%s>) to dest %d",
+ bp->instr->m_ip, (ulong) lab, lab->name, dest));
bp->instr->backpatch(dest, lab->ctx);
+ }
}
+ DBUG_VOID_RETURN;
}
/**
diff --git a/sql/sp_head.h b/sql/sp_head.h
index 01a4cb73704..8d7062740c8 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -888,8 +888,9 @@ public:
virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
{
- if (m_dest == 0) // Don't reset
- m_dest= dest;
+ /* Calling backpatch twice is a logic flaw in jump resolution. */
+ DBUG_ASSERT(m_dest == 0);
+ m_dest= dest;
}
/**
diff --git a/sql/sp_rcontext.cc b/sql/sp_rcontext.cc
index 8395648689b..9b237b3e7cc 100644
--- a/sql/sp_rcontext.cc
+++ b/sql/sp_rcontext.cc
@@ -314,17 +314,91 @@ sp_rcontext::handle_error(uint sql_errno,
void
sp_rcontext::push_cursor(sp_lex_keeper *lex_keeper, sp_instr_cpush *i)
{
+ DBUG_ENTER("sp_rcontext::push_cursor");
+ DBUG_ASSERT(m_ccount < m_root_parsing_ctx->max_cursor_index());
m_cstack[m_ccount++]= new sp_cursor(lex_keeper, i);
+ DBUG_PRINT("info", ("m_ccount: %d", m_ccount));
+ DBUG_VOID_RETURN;
}
-
void
sp_rcontext::pop_cursors(uint count)
{
+ DBUG_ENTER("sp_rcontext::pop_cursors");
+ DBUG_ASSERT(m_ccount >= count);
while (count--)
{
delete m_cstack[--m_ccount];
}
+ DBUG_PRINT("info", ("m_ccount: %d", m_ccount));
+ DBUG_VOID_RETURN;
+}
+
+void
+sp_rcontext::push_handler(struct sp_cond_type *cond, uint h, int type, uint f)
+{
+ DBUG_ENTER("sp_rcontext::push_handler");
+ DBUG_ASSERT(m_hcount < m_root_parsing_ctx->max_handler_index());
+
+ m_handler[m_hcount].cond= cond;
+ m_handler[m_hcount].handler= h;
+ m_handler[m_hcount].type= type;
+ m_handler[m_hcount].foffset= f;
+ m_hcount+= 1;
+
+ DBUG_PRINT("info", ("m_hcount: %d", m_hcount));
+ DBUG_VOID_RETURN;
+}
+
+void
+sp_rcontext::pop_handlers(uint count)
+{
+ DBUG_ENTER("sp_rcontext::pop_handlers");
+ DBUG_ASSERT(m_hcount >= count);
+ m_hcount-= count;
+ DBUG_PRINT("info", ("m_hcount: %d", m_hcount));
+ DBUG_VOID_RETURN;
+}
+
+void
+sp_rcontext::push_hstack(uint h)
+{
+ DBUG_ENTER("sp_rcontext::push_hstack");
+ DBUG_ASSERT(m_hsp < m_root_parsing_ctx->max_handler_index());
+ m_hstack[m_hsp++]= h;
+ DBUG_PRINT("info", ("m_hsp: %d", m_hsp));
+ DBUG_VOID_RETURN;
+}
+
+uint
+sp_rcontext::pop_hstack()
+{
+ uint handler;
+ DBUG_ENTER("sp_rcontext::pop_hstack");
+ DBUG_ASSERT(m_hsp);
+ handler= m_hstack[--m_hsp];
+ DBUG_PRINT("info", ("m_hsp: %d", m_hsp));
+ DBUG_RETURN(handler);
+}
+
+void
+sp_rcontext::enter_handler(int hid)
+{
+ DBUG_ENTER("sp_rcontext::enter_handler");
+ DBUG_ASSERT(m_ihsp < m_root_parsing_ctx->max_handler_index());
+ m_in_handler[m_ihsp++]= hid;
+ DBUG_PRINT("info", ("m_ihsp: %d", m_ihsp));
+ DBUG_VOID_RETURN;
+}
+
+void
+sp_rcontext::exit_handler()
+{
+ DBUG_ENTER("sp_rcontext::exit_handler");
+ DBUG_ASSERT(m_ihsp);
+ m_ihsp-= 1;
+ DBUG_PRINT("info", ("m_ihsp: %d", m_ihsp));
+ DBUG_VOID_RETURN;
}
diff --git a/sql/sp_rcontext.h b/sql/sp_rcontext.h
index 43102cfeeb2..368a017da21 100644
--- a/sql/sp_rcontext.h
+++ b/sql/sp_rcontext.h
@@ -107,21 +107,9 @@ class sp_rcontext : public Sql_alloc
return m_return_value_set;
}
- inline void
- push_handler(struct sp_cond_type *cond, uint h, int type, uint f)
- {
- m_handler[m_hcount].cond= cond;
- m_handler[m_hcount].handler= h;
- m_handler[m_hcount].type= type;
- m_handler[m_hcount].foffset= f;
- m_hcount+= 1;
- }
+ void push_handler(struct sp_cond_type *cond, uint h, int type, uint f);
- inline void
- pop_handlers(uint count)
- {
- m_hcount-= count;
- }
+ void pop_handlers(uint count);
// Returns 1 if a handler was found, 0 otherwise.
bool
@@ -158,29 +146,13 @@ class sp_rcontext : public Sql_alloc
m_hfound= -1;
}
- inline void
- push_hstack(uint h)
- {
- m_hstack[m_hsp++]= h;
- }
+ void push_hstack(uint h);
- inline uint
- pop_hstack()
- {
- return m_hstack[--m_hsp];
- }
+ uint pop_hstack();
- inline void
- enter_handler(int hid)
- {
- m_in_handler[m_ihsp++]= hid;
- }
+ void enter_handler(int hid);
- inline void
- exit_handler()
- {
- m_ihsp-= 1;
- }
+ void exit_handler();
void
push_cursor(sp_lex_keeper *lex_keeper, sp_instr_cpush *i);
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 41596b4faf2..799cb673a0e 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -3934,7 +3934,7 @@ retry:
READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
ha_open_options | HA_OPEN_FOR_REPAIR,
entry, FALSE) || ! entry->file ||
- (entry->file->is_crashed() && entry->file->check_and_repair(thd)))
+ (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
{
/* Give right error message */
thd->clear_error();
@@ -5400,7 +5400,7 @@ bool rm_temporary_table(handlerton *base, char *path)
error=1; /* purecov: inspected */
*ext= 0; // remove extension
file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
- if (file && file->delete_table(path))
+ if (file && file->ha_delete_table(path))
{
error=1;
sql_print_warning("Could not remove temporary table: '%s', error: %d",
@@ -8099,7 +8099,7 @@ my_bool mysql_rm_tmp_tables(void)
((handler_file= get_new_handler(&share, thd->mem_root,
share.db_type()))))
{
- handler_file->delete_table(filePathCopy);
+ handler_file->ha_delete_table(filePathCopy);
delete handler_file;
}
free_table_share(&share);
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index e51c53f644e..7e54f87fe14 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -371,6 +371,32 @@ TODO list:
__LINE__,(ulong)(B)));B->query()->unlock_reading();}
#define DUMP(C) DBUG_EXECUTE("qcache", {\
(C)->cache_dump(); (C)->queries_dump();(C)->tables_dump();})
+
+
+/**
+ Causes the thread to wait in a spin lock for a query kill signal.
+ This function is used by the test frame work to identify race conditions.
+
+ The signal is caught and ignored and the thread is not killed.
+*/
+
+static void debug_wait_for_kill(const char *info)
+{
+ DBUG_ENTER("debug_wait_for_kill");
+ const char *prev_info;
+ THD *thd;
+ thd= current_thd;
+ prev_info= thd->proc_info;
+ thd->proc_info= info;
+ sql_print_information(info);
+ while(!thd->killed)
+ my_sleep(1000);
+ thd->killed= THD::NOT_KILLED;
+ sql_print_information("Exit debug_wait_for_kill");
+ thd->proc_info= prev_info;
+ DBUG_VOID_RETURN;
+}
+
#else
#define MUTEX_LOCK(M) pthread_mutex_lock(M)
#define MUTEX_UNLOCK(M) pthread_mutex_unlock(M)
@@ -647,13 +673,16 @@ void query_cache_insert(NET *net, const char *packet, ulong length)
if (net->query_cache_query == 0)
DBUG_VOID_RETURN;
+ DBUG_EXECUTE_IF("wait_in_query_cache_insert",
+ debug_wait_for_kill("wait_in_query_cache_insert"); );
+
STRUCT_LOCK(&query_cache.structure_guard_mutex);
bool interrupt;
query_cache.wait_while_table_flush_is_in_progress(&interrupt);
if (interrupt)
{
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
- return;
+ DBUG_VOID_RETURN;
}
Query_cache_block *query_block= (Query_cache_block*)net->query_cache_query;
@@ -667,11 +696,11 @@ void query_cache_insert(NET *net, const char *packet, ulong length)
DBUG_VOID_RETURN;
}
+ BLOCK_LOCK_WR(query_block);
Query_cache_query *header= query_block->query();
Query_cache_block *result= header->result();
DUMP(&query_cache);
- BLOCK_LOCK_WR(query_block);
DBUG_PRINT("qcache", ("insert packet %lu bytes long",length));
/*
@@ -687,6 +716,7 @@ void query_cache_insert(NET *net, const char *packet, ulong length)
DBUG_PRINT("qcache", ("free query 0x%lx", (ulong) query_block));
// The following call will remove the lock on query_block
query_cache.free_query(query_block);
+ query_cache.refused++;
// append_result_data no success => we need unlock
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
DBUG_VOID_RETURN;
@@ -886,6 +916,31 @@ ulong Query_cache::resize(ulong query_cache_size_arg)
m_cache_status= Query_cache::FLUSH_IN_PROGRESS;
STRUCT_UNLOCK(&structure_guard_mutex);
+ /*
+ Wait for all readers and writers to exit. When the list of all queries
+ is iterated over with a block level lock, we are done.
+ */
+ Query_cache_block *block= queries_blocks;
+ if (block)
+ {
+ do
+ {
+ BLOCK_LOCK_WR(block);
+ Query_cache_query *query= block->query();
+ if (query && query->writer())
+ {
+ /*
+ Drop the writer; this will cancel any attempts to store
+ the processed statement associated with this writer.
+ */
+ query->writer()->query_cache_query= 0;
+ query->writer(0);
+ refused++;
+ }
+ BLOCK_UNLOCK_WR(block);
+ block= block->next;
+ } while (block != queries_blocks);
+ }
free_cache();
query_cache_size= query_cache_size_arg;
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 56748772523..c6435387f44 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -123,7 +123,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
ha_rows const maybe_deleted= table->file->stats.records;
DBUG_PRINT("debug", ("Trying to use delete_all_rows()"));
- if (!(error=table->file->delete_all_rows()))
+ if (!(error=table->file->ha_delete_all_rows()))
{
error= -1; // ok
deleted= maybe_deleted;
@@ -328,7 +328,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
We're really doing a truncate and need to reset the table's
auto-increment counter.
*/
- int error2= table->file->reset_auto_increment(0);
+ int error2= table->file->ha_reset_auto_increment(0);
if (error2 && (error2 != HA_ERR_WRONG_COMMAND))
{
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index f9dbd402de7..c2b1990f6c7 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -619,7 +619,8 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list,
if (mysql_prepare_insert(thd, table_list, table, fields, values,
update_fields, update_values, duplic, &unused_conds,
FALSE,
- (fields.elements || !value_count),
+ (fields.elements || !value_count ||
+ table_list->view != 0),
!ignore && (thd->variables.sql_mode &
(MODE_STRICT_TRANS_TABLES |
MODE_STRICT_ALL_TABLES))))
@@ -1862,7 +1863,6 @@ bool delayed_get_table(THD *thd, TABLE_LIST *table_list)
{
if (!(di= new Delayed_insert()))
{
- my_error(ER_OUTOFMEMORY,MYF(0),sizeof(Delayed_insert));
thd->fatal_error();
goto end_create;
}
diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc
index ce70e177a85..eabf4526f7b 100644
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -5108,9 +5108,9 @@ static bool mysql_change_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_change_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
- if ((error= file->change_partitions(lpt->create_info, path, &lpt->copied,
- &lpt->deleted, lpt->pack_frm_data,
- lpt->pack_frm_len)))
+ if ((error= file->ha_change_partitions(lpt->create_info, path, &lpt->copied,
+ &lpt->deleted, lpt->pack_frm_data,
+ lpt->pack_frm_len)))
{
if (error != ER_OUTOFMEMORY)
file->print_error(error, MYF(0));
@@ -5148,7 +5148,7 @@ static bool mysql_rename_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_rename_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
- if ((error= lpt->table->file->rename_partitions(path)))
+ if ((error= lpt->table->file->ha_rename_partitions(path)))
{
if (error != 1)
lpt->table->file->print_error(error, MYF(0));
@@ -5189,7 +5189,7 @@ static bool mysql_drop_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_drop_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
- if ((error= lpt->table->file->drop_partitions(path)))
+ if ((error= lpt->table->file->ha_drop_partitions(path)))
{
lpt->table->file->print_error(error, MYF(0));
DBUG_RETURN(TRUE);
@@ -6105,13 +6105,13 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
int error;
written_bin_log= FALSE;
if (((alter_info->flags & ALTER_OPTIMIZE_PARTITION) &&
- (error= table->file->optimize_partitions(thd))) ||
+ (error= table->file->ha_optimize_partitions(thd))) ||
((alter_info->flags & ALTER_ANALYZE_PARTITION) &&
- (error= table->file->analyze_partitions(thd))) ||
+ (error= table->file->ha_analyze_partitions(thd))) ||
((alter_info->flags & ALTER_CHECK_PARTITION) &&
- (error= table->file->check_partitions(thd))) ||
+ (error= table->file->ha_check_partitions(thd))) ||
((alter_info->flags & ALTER_REPAIR_PARTITION) &&
- (error= table->file->repair_partitions(thd))))
+ (error= table->file->ha_repair_partitions(thd))))
{
table->file->print_error(error, MYF(0));
goto err;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index d77fa6bbb04..d7e7be87d23 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1567,14 +1567,14 @@ JOIN::reinit()
if (exec_tmp_table1)
{
exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE);
- exec_tmp_table1->file->delete_all_rows();
+ exec_tmp_table1->file->ha_delete_all_rows();
free_io_cache(exec_tmp_table1);
filesort_free_buffers(exec_tmp_table1,0);
}
if (exec_tmp_table2)
{
exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE);
- exec_tmp_table2->file->delete_all_rows();
+ exec_tmp_table2->file->ha_delete_all_rows();
free_io_cache(exec_tmp_table2);
filesort_free_buffers(exec_tmp_table2,0);
}
@@ -5618,7 +5618,8 @@ get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
(keyuse->val->type() == Item::REF_ITEM &&
((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&
(*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==
- Item_ref::DIRECT_REF) )
+ Item_ref::DIRECT_REF &&
+ keyuse->val->real_item()->type() == Item::FIELD_ITEM))
return new store_key_field(thd,
key_part->field,
key_buff + maybe_null,
@@ -10526,9 +10527,9 @@ free_tmp_table(THD *thd, TABLE *entry)
if (entry->file)
{
if (entry->db_stat)
- entry->file->drop_table(entry->s->table_name.str);
+ entry->file->ha_drop_table(entry->s->table_name.str);
else
- entry->file->delete_table(entry->s->table_name.str);
+ entry->file->ha_delete_table(entry->s->table_name.str);
delete entry->file;
}
@@ -10585,7 +10586,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
if (open_tmp_table(&new_table))
goto err1;
if (table->file->indexes_are_disabled())
- new_table.file->disable_indexes(HA_KEY_SWITCH_ALL);
+ new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
table->file->ha_index_or_rnd_end();
table->file->ha_rnd_init(1);
if (table->no_rows)
@@ -10614,13 +10615,13 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
*/
while (!table->file->rnd_next(new_table.record[1]))
{
- write_err= new_table.file->write_row(new_table.record[1]);
+ write_err= new_table.file->ha_write_row(new_table.record[1]);
DBUG_EXECUTE_IF("raise_error", write_err= HA_ERR_FOUND_DUPP_KEY ;);
if (write_err)
goto err;
}
/* copy row that filled HEAP table */
- if ((write_err=new_table.file->write_row(table->record[0])))
+ if ((write_err=new_table.file->ha_write_row(table->record[0])))
{
if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||
!ignore_last_dupp_key_error)
@@ -10651,7 +10652,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
(void) table->file->ha_rnd_end();
(void) new_table.file->close();
err1:
- new_table.file->delete_table(new_table.s->table_name.str);
+ new_table.file->ha_delete_table(new_table.s->table_name.str);
err2:
delete new_table.file;
thd_proc_info(thd, save_proc_info);
@@ -12093,7 +12094,7 @@ end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
{
int error;
join->found_records++;
- if ((error=table->file->write_row(table->record[0])))
+ if ((error=table->file->ha_write_row(table->record[0])))
{
if (!table->file->is_fatal_error(error, HA_CHECK_DUP))
goto end;
@@ -12155,8 +12156,8 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
{ /* Update old record */
restore_record(table,record[1]);
update_tmptable_sum_func(join->sum_funcs,table);
- if ((error=table->file->update_row(table->record[1],
- table->record[0])))
+ if ((error=table->file->ha_update_row(table->record[1],
+ table->record[0])))
{
table->file->print_error(error,MYF(0)); /* purecov: inspected */
DBUG_RETURN(NESTED_LOOP_ERROR); /* purecov: inspected */
@@ -12179,7 +12180,7 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
}
init_tmptable_sum_functions(join->sum_funcs);
copy_funcs(join->tmp_table_param.items_to_copy);
- if ((error=table->file->write_row(table->record[0])))
+ if ((error=table->file->ha_write_row(table->record[0])))
{
if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param,
error, 0))
@@ -12215,7 +12216,7 @@ end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
copy_fields(&join->tmp_table_param); // Groups are copied twice.
copy_funcs(join->tmp_table_param.items_to_copy);
- if (!(error=table->file->write_row(table->record[0])))
+ if (!(error=table->file->ha_write_row(table->record[0])))
join->send_records++; // New group
else
{
@@ -12231,8 +12232,8 @@ end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
}
restore_record(table,record[1]);
update_tmptable_sum_func(join->sum_funcs,table);
- if ((error=table->file->update_row(table->record[1],
- table->record[0])))
+ if ((error=table->file->ha_update_row(table->record[1],
+ table->record[0])))
{
table->file->print_error(error,MYF(0)); /* purecov: inspected */
DBUG_RETURN(NESTED_LOOP_ERROR); /* purecov: inspected */
@@ -12275,7 +12276,7 @@ end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
join->sum_funcs_end[send_group_parts]);
if (!join->having || join->having->val_int())
{
- int error= table->file->write_row(table->record[0]);
+ int error= table->file->ha_write_row(table->record[0]);
if (error && create_myisam_from_heap(join->thd, table,
&join->tmp_table_param,
error, 0))
@@ -13190,7 +13191,8 @@ check_reverse_order:
select->quick=tmp;
}
}
- else if (tab->ref.key >= 0 && tab->ref.key_parts <= used_key_parts)
+ else if (tab->type != JT_NEXT &&
+ tab->ref.key >= 0 && tab->ref.key_parts <= used_key_parts)
{
/*
SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC
@@ -13503,7 +13505,7 @@ static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field,
}
if (having && !having->val_int())
{
- if ((error=file->delete_row(record)))
+ if ((error=file->ha_delete_row(record)))
goto err;
error=file->rnd_next(record);
continue;
@@ -13530,7 +13532,7 @@ static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field,
}
if (compare_record(table, first_field) == 0)
{
- if ((error=file->delete_row(record)))
+ if ((error=file->ha_delete_row(record)))
goto err;
}
else if (!found)
@@ -13629,7 +13631,7 @@ static int remove_dup_with_hash_index(THD *thd, TABLE *table,
}
if (having && !having->val_int())
{
- if ((error=file->delete_row(record)))
+ if ((error=file->ha_delete_row(record)))
goto err;
continue;
}
@@ -13646,7 +13648,7 @@ static int remove_dup_with_hash_index(THD *thd, TABLE *table,
if (hash_search(&hash, org_key_pos, key_length))
{
/* Duplicated found ; Remove the row */
- if ((error=file->delete_row(record)))
+ if ((error=file->ha_delete_row(record)))
goto err;
}
else
@@ -15670,7 +15672,7 @@ int JOIN::rollup_write_data(uint idx, TABLE *table_arg)
item->save_in_result_field(1);
}
copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
- if ((write_error= table_arg->file->write_row(table_arg->record[0])))
+ if ((write_error= table_arg->file->ha_write_row(table_arg->record[0])))
{
if (create_myisam_from_heap(thd, table_arg, &tmp_table_param,
write_error, 0))
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 177e84ab0a7..ee0a6d3c2ab 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -5871,7 +5871,7 @@ bool get_schema_tables_result(JOIN *join,
{
table_list->table->file->extra(HA_EXTRA_NO_CACHE);
table_list->table->file->extra(HA_EXTRA_RESET_STATE);
- table_list->table->file->delete_all_rows();
+ table_list->table->file->ha_delete_all_rows();
free_io_cache(table_list->table);
filesort_free_buffers(table_list->table,1);
table_list->table->null_row= 0;
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 5bd7d446cbd..505bcd1b421 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -630,7 +630,7 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
}
else
{
- if ((error= file->delete_table(ddl_log_entry->name)))
+ if ((error= file->ha_delete_table(ddl_log_entry->name)))
{
if (error != ENOENT && error != HA_ERR_NO_SUCH_TABLE)
break;
@@ -667,8 +667,8 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
}
else
{
- if (file->rename_table(ddl_log_entry->from_name,
- ddl_log_entry->name))
+ if (file->ha_rename_table(ddl_log_entry->from_name,
+ ddl_log_entry->name))
break;
}
if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
@@ -1299,9 +1299,9 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
lpt->table_name, lpt->create_info,
lpt->alter_info->create_list, lpt->key_count,
lpt->key_info_buffer, lpt->table->file)) ||
- lpt->table->file->create_handler_files(shadow_path, NULL,
- CHF_CREATE_FLAG,
- lpt->create_info))
+ lpt->table->file->ha_create_handler_files(shadow_path, NULL,
+ CHF_CREATE_FLAG,
+ lpt->create_info))
{
my_delete(shadow_frm_name, MYF(0));
error= 1;
@@ -1353,15 +1353,15 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
VOID(pthread_mutex_lock(&LOCK_open));
if (my_delete(frm_name, MYF(MY_WME)) ||
#ifdef WITH_PARTITION_STORAGE_ENGINE
- lpt->table->file->create_handler_files(path, shadow_path,
- CHF_DELETE_FLAG, NULL) ||
+ lpt->table->file->ha_create_handler_files(path, shadow_path,
+ CHF_DELETE_FLAG, NULL) ||
deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) ||
(sync_ddl_log(), FALSE) ||
#endif
#ifdef WITH_PARTITION_STORAGE_ENGINE
my_rename(shadow_frm_name, frm_name, MYF(MY_WME)) ||
- lpt->table->file->create_handler_files(path, shadow_path,
- CHF_RENAME_FLAG, NULL))
+ lpt->table->file->ha_create_handler_files(path, shadow_path,
+ CHF_RENAME_FLAG, NULL))
#else
my_rename(shadow_frm_name, frm_name, MYF(MY_WME)))
#endif
@@ -3718,14 +3718,14 @@ mysql_rename_table(handlerton *base, const char *old_db,
to_base= lc_to;
}
- if (!file || !(error=file->rename_table(from_base, to_base)))
+ if (!file || !(error=file->ha_rename_table(from_base, to_base)))
{
if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext))
{
error=my_errno;
/* Restore old file name */
if (file)
- file->rename_table(to_base, from_base);
+ file->ha_rename_table(to_base, from_base);
}
}
delete file;
@@ -4376,7 +4376,7 @@ send_result_message:
if (!result_code) // recreation went ok
{
if ((table->table= open_ltable(thd, table, lock_type, 0)) &&
- ((result_code= table->table->file->analyze(thd, check_opt)) > 0))
+ ((result_code= table->table->file->ha_analyze(thd, check_opt)) > 0))
result_code= 0; // analyze went ok
}
if (result_code) // either mysql_recreate_table or analyze failed
@@ -4486,7 +4486,7 @@ bool mysql_backup_table(THD* thd, TABLE_LIST* table_list)
"MySQL Administrator (mysqldump, mysql)");
DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
"backup", TL_READ, 0, 0, 0, 0,
- &handler::backup, 0));
+ &handler::ha_backup, 0));
}
@@ -4498,7 +4498,7 @@ bool mysql_restore_table(THD* thd, TABLE_LIST* table_list)
DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
"restore", TL_WRITE, 1, 1, 0,
&prepare_for_restore,
- &handler::restore, 0));
+ &handler::ha_restore, 0));
}
@@ -4519,7 +4519,7 @@ bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
DBUG_ENTER("mysql_optimize_table");
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"optimize", TL_WRITE, 1,0,0,0,
- &handler::optimize, 0));
+ &handler::ha_optimize, 0));
}
@@ -4933,7 +4933,7 @@ bool mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
DBUG_ENTER("mysql_analyze_table");
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"analyze", lock_type, 1, 0, 0, 0,
- &handler::analyze, 0));
+ &handler::ha_analyze, 0));
}
@@ -4980,7 +4980,7 @@ mysql_discard_or_import_tablespace(THD *thd,
DBUG_RETURN(-1);
}
- error=table->file->discard_or_import_tablespace(discard);
+ error= table->file->ha_discard_or_import_tablespace(discard);
thd_proc_info(thd, "end");
@@ -5353,14 +5353,14 @@ bool alter_table_manage_keys(TABLE *table, int indexes_were_disabled,
switch (keys_onoff) {
case ENABLE:
- error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
+ error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
break;
case LEAVE_AS_IS:
if (!indexes_were_disabled)
break;
/* fall-through: disabled indexes */
case DISABLE:
- error= table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
+ error= table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
}
if (error == HA_ERR_WRONG_COMMAND)
@@ -6130,14 +6130,14 @@ view_err:
wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
VOID(pthread_mutex_unlock(&LOCK_open));
DBUG_EXECUTE_IF("sleep_alter_enable_indexes", my_sleep(6000000););
- error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
+ error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
/* COND_refresh will be signaled in close_thread_tables() */
break;
case DISABLE:
VOID(pthread_mutex_lock(&LOCK_open));
wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
VOID(pthread_mutex_unlock(&LOCK_open));
- error=table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
+ error=table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
/* COND_refresh will be signaled in close_thread_tables() */
break;
default:
@@ -6545,7 +6545,7 @@ view_err:
KEY_PART_INFO *part_end;
DBUG_PRINT("info", ("No new_table, checking add/drop index"));
- table->file->prepare_for_alter();
+ table->file->ha_prepare_for_alter();
if (index_add_count)
{
/* The add_index() method takes an array of KEY structs. */
@@ -6763,8 +6763,8 @@ view_err:
t_table= table;
}
/* Tell the handler that a new frm file is in place. */
- if (t_table->file->create_handler_files(path, NULL, CHF_INDEX_FLAG,
- create_info))
+ if (t_table->file->ha_create_handler_files(path, NULL, CHF_INDEX_FLAG,
+ create_info))
goto err_with_placeholders;
if (thd->locked_tables && new_name == table_name && new_db == db)
{
@@ -7064,7 +7064,7 @@ copy_data_between_tables(TABLE *from,TABLE *to,
copy_ptr->do_copy(copy_ptr);
}
prev_insert_id= to->file->next_insert_id;
- error=to->file->write_row(to->record[0]);
+ error=to->file->ha_write_row(to->record[0]);
to->auto_increment_field_not_null= FALSE;
if (error)
{
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index a48cff82715..5f7e3c5b620 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -440,10 +440,10 @@ bool st_select_lex_unit::exec()
{
item->assigned(0); // We will reinit & rexecute unit
item->reset();
- table->file->delete_all_rows();
+ table->file->ha_delete_all_rows();
}
/* re-enabling indexes for next subselect iteration */
- if (union_distinct && table->file->enable_indexes(HA_KEY_SWITCH_ALL))
+ if (union_distinct && table->file->ha_enable_indexes(HA_KEY_SWITCH_ALL))
{
DBUG_ASSERT(0);
}
@@ -485,7 +485,7 @@ bool st_select_lex_unit::exec()
sl->join->exec();
if (sl == union_distinct)
{
- if (table->file->disable_indexes(HA_KEY_SWITCH_ALL))
+ if (table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL))
DBUG_RETURN(TRUE);
table->no_keyread=1;
}
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 78dea6b7cdb..4d075e3308d 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -526,7 +526,9 @@ int mysql_update(THD *thd,
init_read_record(&info,thd,table,select,0,1);
updated= found= 0;
- thd->count_cuted_fields= CHECK_FIELD_WARN; /* calc cuted fields */
+ /* Generate an error when trying to set a NOT NULL field to NULL. */
+ thd->count_cuted_fields= ignore ? CHECK_FIELD_WARN
+ : CHECK_FIELD_ERROR_FOR_NULL;
thd->cuted_fields=0L;
thd_proc_info(thd, "Updating");
@@ -623,9 +625,9 @@ int mysql_update(THD *thd,
call then it should be included in the count of dup_key_found
and error should be set to 0 (only if these errors are ignored).
*/
- error= table->file->bulk_update_row(table->record[1],
- table->record[0],
- &dup_key_found);
+ error= table->file->ha_bulk_update_row(table->record[1],
+ table->record[0],
+ &dup_key_found);
limit+= dup_key_found;
updated-= dup_key_found;
}
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 9cccc7c724e..c98228424a5 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -508,10 +508,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%pure_parser /* We have threads */
/*
- Currently there are 177 shift/reduce conflicts.
+ Currently there are 169 shift/reduce conflicts.
We should not introduce new conflicts any more.
*/
-%expect 177
+%expect 169
/*
Comments for TOKENS.
@@ -1204,7 +1204,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%type <table_list>
join_table_list join_table
- table_factor table_ref
+ table_factor table_ref esc_table_ref
select_derived derived_table_list
%type <date_time_type> date_time_type;
@@ -1295,7 +1295,9 @@ END_OF_INPUT
%type <NONE> call sp_proc_stmts sp_proc_stmts1 sp_proc_stmt
%type <NONE> sp_proc_stmt_statement sp_proc_stmt_return
%type <NONE> sp_proc_stmt_if
-%type <NONE> sp_labeled_control sp_proc_stmt_unlabeled sp_proc_stmt_leave
+%type <NONE> sp_labeled_control sp_proc_stmt_unlabeled
+%type <NONE> sp_labeled_block sp_unlabeled_block
+%type <NONE> sp_proc_stmt_leave
%type <NONE> sp_proc_stmt_iterate
%type <NONE> sp_proc_stmt_open sp_proc_stmt_fetch sp_proc_stmt_close
%type <NONE> case_stmt_specification simple_case_stmt searched_case_stmt
@@ -1956,6 +1958,8 @@ ev_sql_stmt_inner:
| sp_proc_stmt_return
| sp_proc_stmt_if
| case_stmt_specification
+ | sp_labeled_block
+ | sp_unlabeled_block
| sp_labeled_control
| sp_proc_stmt_unlabeled
| sp_proc_stmt_leave
@@ -2530,6 +2534,8 @@ sp_proc_stmt:
| sp_proc_stmt_return
| sp_proc_stmt_if
| case_stmt_specification
+ | sp_labeled_block
+ | sp_unlabeled_block
| sp_labeled_control
| sp_proc_stmt_unlabeled
| sp_proc_stmt_leave
@@ -2656,14 +2662,35 @@ sp_proc_stmt_leave:
sp_instr_jump *i;
uint ip= sp->instructions();
uint n;
+ /*
+ When jumping to a BEGIN-END block end, the target jump
+ points to the block hpop/cpop cleanup instructions,
+ so we should exclude the block context here.
+ When jumping to something else (i.e., SP_LAB_ITER),
+ there are no hpop/cpop at the jump destination,
+ so we should include the block context here for cleanup.
+ */
+ bool exclusive= (lab->type == SP_LAB_BEGIN);
- n= ctx->diff_handlers(lab->ctx, TRUE); /* Exclusive the dest. */
+ n= ctx->diff_handlers(lab->ctx, exclusive);
if (n)
- sp->add_instr(new sp_instr_hpop(ip++, ctx, n));
- n= ctx->diff_cursors(lab->ctx, TRUE); /* Exclusive the dest. */
+ {
+ sp_instr_hpop *hpop= new sp_instr_hpop(ip++, ctx, n);
+ if (hpop == NULL)
+ MYSQL_YYABORT;
+ sp->add_instr(hpop);
+ }
+ n= ctx->diff_cursors(lab->ctx, exclusive);
if (n)
- sp->add_instr(new sp_instr_cpop(ip++, ctx, n));
+ {
+ sp_instr_cpop *cpop= new sp_instr_cpop(ip++, ctx, n);
+ if (cpop == NULL)
+ MYSQL_YYABORT;
+ sp->add_instr(cpop);
+ }
i= new sp_instr_jump(ip, ctx);
+ if (i == NULL)
+ MYSQL_YYABORT;
sp->push_backpatch(i, lab); /* Jumping forward */
sp->add_instr(i);
}
@@ -2691,10 +2718,20 @@ sp_proc_stmt_iterate:
n= ctx->diff_handlers(lab->ctx, FALSE); /* Inclusive the dest. */
if (n)
- sp->add_instr(new sp_instr_hpop(ip++, ctx, n));
+ {
+ sp_instr_hpop *hpop= new sp_instr_hpop(ip++, ctx, n);
+ if (hpop == NULL)
+ MYSQL_YYABORT;
+ sp->add_instr(hpop);
+ }
n= ctx->diff_cursors(lab->ctx, FALSE); /* Inclusive the dest. */
if (n)
- sp->add_instr(new sp_instr_cpop(ip++, ctx, n));
+ {
+ sp_instr_cpop *cpop= new sp_instr_cpop(ip++, ctx, n);
+ if (cpop == NULL)
+ MYSQL_YYABORT;
+ sp->add_instr(cpop);
+ }
i= new sp_instr_jump(ip, ctx, lab->ip); /* Jump back */
sp->add_instr(i);
}
@@ -2978,19 +3015,17 @@ sp_labeled_control:
sp_unlabeled_control sp_opt_label
{
LEX *lex= Lex;
+ sp_label_t *lab= lex->spcont->pop_label();
if ($5.str)
{
- sp_label_t *lab= lex->spcont->find_label($5.str);
-
- if (!lab ||
- my_strcasecmp(system_charset_info, $5.str, lab->name) != 0)
+ if (my_strcasecmp(system_charset_info, $5.str, lab->name) != 0)
{
my_error(ER_SP_LABEL_MISMATCH, MYF(0), $5.str);
MYSQL_YYABORT;
}
}
- lex->sphead->backpatch(lex->spcont->pop_label());
+ lex->sphead->backpatch(lab);
}
;
@@ -2999,15 +3034,59 @@ sp_opt_label:
| label_ident { $$= $1; }
;
-sp_unlabeled_control:
+sp_labeled_block:
+ label_ident ':'
+ {
+ LEX *lex= Lex;
+ sp_pcontext *ctx= lex->spcont;
+ sp_label_t *lab= ctx->find_label($1.str);
+
+ if (lab)
+ {
+ my_error(ER_SP_LABEL_REDEFINE, MYF(0), $1.str);
+ MYSQL_YYABORT;
+ }
+
+ lab= lex->spcont->push_label($1.str,
+ lex->sphead->instructions());
+ lab->type= SP_LAB_BEGIN;
+ }
+ sp_block_content sp_opt_label
+ {
+ LEX *lex= Lex;
+ sp_label_t *lab= lex->spcont->pop_label();
+
+ if ($5.str)
+ {
+ if (my_strcasecmp(system_charset_info, $5.str, lab->name) != 0)
+ {
+ my_error(ER_SP_LABEL_MISMATCH, MYF(0), $5.str);
+ MYSQL_YYABORT;
+ }
+ }
+ }
+ ;
+
+sp_unlabeled_block:
+ { /* Unlabeled blocks get a secret label. */
+ LEX *lex= Lex;
+ uint ip= lex->sphead->instructions();
+ sp_label_t *lab= lex->spcont->push_label((char *)"", ip);
+ lab->type= SP_LAB_BEGIN;
+ }
+ sp_block_content
+ {
+ LEX *lex= Lex;
+ lex->spcont->pop_label();
+ }
+ ;
+
+sp_block_content:
BEGIN_SYM
{ /* QQ This is just a dummy for grouping declarations and statements
together. No [[NOT] ATOMIC] yet, and we need to figure out how
make it coexist with the existing BEGIN COMMIT/ROLLBACK. */
LEX *lex= Lex;
- sp_label_t *lab= lex->spcont->last_label();
-
- lab->type= SP_LAB_BEGIN;
lex->spcont= lex->spcont->push_context(LABEL_DEFAULT_SCOPE);
}
sp_decls
@@ -3027,7 +3106,10 @@ sp_unlabeled_control:
$3.curs));
lex->spcont= ctx->pop_context();
}
- | LOOP_SYM
+ ;
+
+sp_unlabeled_control:
+ LOOP_SYM
sp_proc_stmts1 END LOOP_SYM
{
LEX *lex= Lex;
@@ -7463,10 +7545,22 @@ join_table_list:
derived_table_list { MYSQL_YYABORT_UNLESS($$=$1); }
;
+/*
+ The ODBC escape syntax for Outer Join is: '{' OJ join_table '}'
+ The parser does not define OJ as a token, any ident is accepted
+ instead in $2 (ident). Also, all productions from table_ref can
+ be escaped, not only join_table. Both syntax extensions are safe
+ and are ignored.
+*/
+esc_table_ref:
+ table_ref { $$=$1; }
+ | '{' ident table_ref '}' { $$=$3; }
+ ;
+
/* Warning - may return NULL in case of incomplete SELECT */
derived_table_list:
- table_ref { $$=$1; }
- | derived_table_list ',' table_ref
+ esc_table_ref { $$=$1; }
+ | derived_table_list ',' esc_table_ref
{
MYSQL_YYABORT_UNLESS($1 && ($$=$3));
}
@@ -7631,25 +7725,6 @@ table_factor:
MYSQL_YYABORT;
Select->add_joined_table($$);
}
- | '{' ident table_ref LEFT OUTER JOIN_SYM table_ref
- ON
- {
- /* Change the current name resolution context to a local context. */
- if (push_new_name_resolution_context(YYTHD, $3, $7))
- MYSQL_YYABORT;
-
- }
- expr '}'
- {
- LEX *lex= Lex;
- MYSQL_YYABORT_UNLESS($3 && $7);
- add_join_on($7,$10);
- Lex->pop_context();
- $7->outer_join|=JOIN_TYPE_LEFT;
- $$=$7;
- if (!($$= lex->current_select->nest_last_join(lex->thd)))
- MYSQL_YYABORT;
- }
| select_derived_init get_select_lex select_derived2
{
LEX *lex= Lex;
diff --git a/sql/unireg.cc b/sql/unireg.cc
index aab3f5606a8..38f09a7946c 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -401,7 +401,7 @@ int rea_create_table(THD *thd, const char *path,
DBUG_ASSERT(*fn_rext(frm_name));
if (thd->variables.keep_files_on_create)
create_info->options|= HA_CREATE_KEEP_FILES;
- if (file->create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))
+ if (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))
goto err_handler;
if (!create_info->frm_only && ha_create_table(thd, path, db, table_name,
create_info,0))
@@ -409,7 +409,7 @@ int rea_create_table(THD *thd, const char *path,
DBUG_RETURN(0);
err_handler:
- VOID(file->create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
+ VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
my_delete(frm_name, MYF(0));
DBUG_RETURN(1);
} /* rea_create_table */
View Lorry Controller Status