From 50aa9d2bb2bced9d92f4f95fc5e9870836d58305 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 10 May 2007 14:54:55 +0200 Subject: [PATCH 1/2] Corrected merge error; missing line in debug statement. --- sql/sql_cache.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index 96a8dc577df..33d658ce6a1 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -871,6 +871,7 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used) CS client: %u, CS result: %u, CS conn: %u, limit: %lu, TZ: 0x%lx, \ sql mode: 0x%lx, sort len: %lu, conncat len: %lu, div_precision: %lu, \ def_week_frmt: %lu", + (int)flags.client_long_flag, (int)flags.client_protocol_41, (int)flags.more_results_exists, flags.pkt_nr, From 30184f9624b93b12844f2076ae6b113a0cf1d619 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 10 May 2007 18:27:36 +0400 Subject: [PATCH 2/2] Follow the coding style with class names. sql/sql_insert.cc: delayed_insert -> Delayed_insert --- sql/sql_class.h | 4 ++-- sql/sql_insert.cc | 46 +++++++++++++++++++++++----------------------- 2 files changed, 25 insertions(+), 25 deletions(-) diff --git a/sql/sql_class.h b/sql/sql_class.h index 7f195d5a048..ad9315ae5eb 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -495,7 +495,7 @@ public: }; -class delayed_insert; +class Delayed_insert; class select_result; #define THD_SENTRY_MAGIC 0xfeedd1ff @@ -1248,7 +1248,7 @@ public: time_t start_time,time_after_lock,user_time; time_t connect_time,thr_create_time; // track down slow pthread_create thr_lock_type update_lock_default; - delayed_insert *di; + Delayed_insert *di; /* <> 0 if we are inside of trigger or stored function. */ uint in_sub_stmt; diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index 1154e98475d..db4c2f64d6a 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -29,7 +29,7 @@ waited for to open and lock the table. If accessing the thread succeeded, in - delayed_insert::get_local_table() the table of the thread is copied + Delayed_insert::get_local_table() the table of the thread is copied for local use. A copy is required because the normal insert logic works on a target table, but the other threads table object must not be used. The insert logic uses the record buffer to create a record. @@ -1507,13 +1507,13 @@ public: }; /** - delayed_insert - context of a thread responsible for delayed insert + Delayed_insert - context of a thread responsible for delayed insert into one table. When processing delayed inserts, we create an own thread for every distinct table. Later on all delayed inserts directed into that table are handled by a dedicated thread. */ -class delayed_insert :public ilink { +class Delayed_insert :public ilink { uint locks_in_memory; public: THD thd; @@ -1527,7 +1527,7 @@ public: ulong group_count; TABLE_LIST table_list; // Argument - delayed_insert() + Delayed_insert() :locks_in_memory(0), table(0),tables_in_use(0),stacked_inserts(0), status(0), dead(0), group_count(0) @@ -1552,7 +1552,7 @@ public: delayed_insert_threads++; VOID(pthread_mutex_unlock(&LOCK_thread_count)); } - ~delayed_insert() + ~Delayed_insert() { /* The following is not really needed, but just for safety */ delayed_row *row; @@ -1600,7 +1600,7 @@ public: }; -I_List delayed_threads; +I_List delayed_threads; /** @@ -1609,12 +1609,12 @@ I_List delayed_threads; */ static -delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list) +Delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list) { thd->proc_info="waiting for delay_list"; pthread_mutex_lock(&LOCK_delayed_insert); // Protect master list - I_List_iterator it(delayed_threads); - delayed_insert *tmp; + I_List_iterator it(delayed_threads); + Delayed_insert *tmp; while ((tmp=it++)) { if (!strcmp(tmp->thd.db,table_list->db) && @@ -1633,7 +1633,7 @@ delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list) Attempt to find or create a delayed insert thread to handle inserts into this table. - @return Return an instance of the table in the delayed thread + @return Return a local copy of the table in the delayed thread @retval NULL too many delayed threads OR this thread ran out of resources OR a newly created delayed insert thread ran out of resources OR @@ -1644,7 +1644,7 @@ delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list) static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list) { int error; - delayed_insert *tmp; + Delayed_insert *tmp; TABLE *table; DBUG_ENTER("delayed_get_table"); @@ -1668,9 +1668,9 @@ static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list) */ if (! (tmp= find_handler(thd, table_list))) { - if (!(tmp=new delayed_insert())) + if (!(tmp=new Delayed_insert())) { - my_error(ER_OUTOFMEMORY,MYF(0),sizeof(delayed_insert)); + my_error(ER_OUTOFMEMORY,MYF(0),sizeof(Delayed_insert)); goto err1; } pthread_mutex_lock(&LOCK_thread_count); @@ -1762,12 +1762,12 @@ static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list) function. */ -TABLE *delayed_insert::get_local_table(THD* client_thd) +TABLE *Delayed_insert::get_local_table(THD* client_thd) { my_ptrdiff_t adjust_ptrs; Field **field,**org_field, *found_next_number_field; TABLE *copy; - DBUG_ENTER("delayed_insert::get_local_table"); + DBUG_ENTER("Delayed_insert::get_local_table"); /* First request insert thread to get a lock */ status=1; @@ -1875,7 +1875,7 @@ static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic, bool igno char *query, uint query_length, bool log_on) { delayed_row *row=0; - delayed_insert *di=thd->di; + Delayed_insert *di=thd->di; DBUG_ENTER("write_delayed"); thd->proc_info="waiting for handler insert"; @@ -1943,7 +1943,7 @@ static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic, bool igno static void end_delayed_insert(THD *thd) { DBUG_ENTER("end_delayed_insert"); - delayed_insert *di=thd->di; + Delayed_insert *di=thd->di; pthread_mutex_lock(&di->mutex); DBUG_PRINT("info",("tables in use: %d",di->tables_in_use)); if (!--di->tables_in_use || di->thd.killed) @@ -1962,8 +1962,8 @@ void kill_delayed_threads(void) { VOID(pthread_mutex_lock(&LOCK_delayed_insert)); // For unlink from list - I_List_iterator it(delayed_threads); - delayed_insert *tmp; + I_List_iterator it(delayed_threads); + Delayed_insert *tmp; while ((tmp=it++)) { tmp->thd.killed= THD::KILL_CONNECTION; @@ -1995,7 +1995,7 @@ void kill_delayed_threads(void) pthread_handler_t handle_delayed_insert(void *arg) { - delayed_insert *di=(delayed_insert*) arg; + Delayed_insert *di=(Delayed_insert*) arg; THD *thd= &di->thd; pthread_detach_this_thread(); @@ -2231,7 +2231,7 @@ static void free_delayed_insert_blobs(register TABLE *table) } -bool delayed_insert::handle_inserts(void) +bool Delayed_insert::handle_inserts(void) { int error; ulong max_rows; @@ -3152,8 +3152,8 @@ void select_create::abort() #ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION template class List_iterator_fast; #ifndef EMBEDDED_LIBRARY -template class I_List; -template class I_List_iterator; +template class I_List; +template class I_List_iterator; template class I_List; #endif /* EMBEDDED_LIBRARY */ #endif /* HAVE_EXPLICIT_TEMPLATE_INSTANTIATION */