~percona-dev/percona-server/release-5.5.11-20.2-fix-bug-764138

 // the following is for checking tables

 

 #define HA_ADMIN_ALREADY_DONE    1

 enum enum_schema_tables

 {

   SCH_CHARSETS= 0,

   SCH_ENGINES,

   SCH_EVENTS,

   SCH_FILES,

   SCH_TABLE_CONSTRAINTS,

   SCH_TABLE_NAMES,

   SCH_TABLE_PRIVILEGES,

   SCH_VARIABLES,

   SCH_VIEWS

 };

   bool locked;

   bool implicit_emptied;                /* Can be !=0 only if HEAP */

   const COND *pushed_cond;

   /**

     next_insert_id is the next value which should be inserted into the

     auto_increment column: in a inserting-multi-row statement (like INSERT

     ref_length(sizeof(my_off_t)),

     ft_handler(0), inited(NONE),

     locked(FALSE), implicit_emptied(0),

   virtual ~handler(void)

   {

     DBUG_ASSERT(locked == FALSE);

   {

     table= table_arg;

     table_share= share;

   }

   virtual double scan_time()

   { return ulonglong2double(stats.data_file_length) / IO_SIZE + 2; }

   virtual bool is_crashed() const  { return 0; }

   virtual bool auto_repair() const { return 0; }

 

 /*

   Log error with all enabled log event handlers

 

                              thd->first_successful_insert_id_in_prev_stmt_for_binlog);

           if (e.write(file))

             goto err;

         }

         if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)

         {

                              minimum());

           if (e.write(file))

             goto err;

         }

         if (thd->user_var_events.elements)

         {

                                  flags);

             if (e.write(file))

               goto err;

           }

         }

       }

     if (event_info->write(file) ||

         DBUG_EVALUATE_IF("injecting_fault_writing", 1, 0))

       goto err;

 

     error= 0;

 err:

     be reset as a READ_CACHE to be able to read the contents from it.

  */

 

 {

   Mutex_sentry sentry(lock_log ? &LOCK_log : NULL);

 

       /* write the first half of the split header */

       if (my_b_write(&log_file, header, carry))

         return ER_ERROR_ON_WRITE;

 

       /*

         copy fixed second half of header to cache so the correct

     /* Write data to the binary log file */

     if (my_b_write(&log_file, cache->read_pos, length))

       return ER_ERROR_ON_WRITE;

     cache->read_pos=cache->read_end;           // Mark buffer used up

   } while ((length= my_b_fill(cache)));

 

       Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), TRUE, FALSE, TRUE, 0);

       if (qinfo.write(&log_file))

         goto err;

diff -ruN a/sql/mysqld.cc b/sql/mysqld.cc

--- a/sql/mysqld.cc     2010-12-03 20:58:26.000000000 +0300

+++ b/sql/mysqld.cc     2010-12-30 02:04:50.000000000 +0300

 uint    opt_debug_sync_timeout= 0;

 #endif /* defined(ENABLED_DEBUG_SYNC) */

 my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;

 my_bool opt_optimizer_fix= 0;

 /*

   True if there is at least one per-hour limit for some user, so we should

 ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;

 ulong binlog_stmt_cache_use= 0, binlog_stmt_cache_disk_use= 0;

 ulong max_connections, max_connect_errors;

 

 /* flashcache */

 int cachedev_fd;

   LOCK_crypt,

   LOCK_global_system_variables,

   LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,

 /**

   The below lock protects access to two global server variables:

   max_prepared_stmt_count and prepared_stmt_count. These variables

 #ifdef HAVE_RESPONSE_TIME_DISTRIBUTION

   query_response_time_free();

 #endif // HAVE_RESPONSE_TIME_DISTRIBUTION

 #ifdef HAVE_REPLICATION

   end_slave_list();

 #endif

   mysql_cond_destroy(&COND_thread_cache);

   mysql_cond_destroy(&COND_flush_thread_cache);

   mysql_cond_destroy(&COND_manager);

 }

 #endif /*EMBEDDED_LIBRARY*/

 

   {"show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},

   {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},

   {"show_charsets",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},

   {"show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},

   {"show_contributors",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CONTRIBUTORS]), SHOW_LONG_STATUS},

   {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},

 #endif

   {"show_function_status", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS_FUNC]), SHOW_LONG_STATUS},

   {"show_grants",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_GRANTS]), SHOW_LONG_STATUS},

   {"show_keys",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},

   {"show_master_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_MASTER_STAT]), SHOW_LONG_STATUS},

   {"show_new_master",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_NEW_MASTER]), SHOW_LONG_STATUS},

   {"show_slave_status_nolock", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_NOLOCK_STAT]), SHOW_LONG_STATUS},

   {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},

   {"show_storage_engines", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STORAGE_ENGINES]), SHOW_LONG_STATUS},

   {"show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},

   {"show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},

   {"slave_start",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},

   mysql_mutex_init(key_LOCK_server_started,

                    &LOCK_server_started, MY_MUTEX_INIT_FAST);

   mysql_cond_init(key_COND_server_started, &COND_server_started, NULL);

   sp_cache_init();

 #ifdef HAVE_EVENT_SCHEDULER

   Events::init_mutexes();

   query_response_time_init();

 #endif // HAVE_RESPONSE_TIME_DISTRIBUTION

   /* We have to initialize the storage engines before CSV logging */

   if (ha_init())

   {

     sql_print_error("Can't init databases");

 

   init_max_user_conn();

   init_update_queries();

   DBUG_RETURN(0);

 }

 

     {

       sql_print_warning("%s", ER_DEFAULT(ER_CON_COUNT_ERROR));

     }

     delete thd;

     DBUG_VOID_RETURN;

   }

   key_delayed_insert_mutex, key_hash_filo_lock, key_LOCK_active_mi,

   key_LOCK_connection_count, key_LOCK_crypt, key_LOCK_delayed_create,

   key_LOCK_delayed_insert, key_LOCK_delayed_status, key_LOCK_error_log,

   key_LOCK_gdl, key_LOCK_global_system_variables,

   key_LOCK_manager,

   key_LOCK_prepared_stmt_count,

   { &key_LOCK_delayed_insert, "LOCK_delayed_insert", PSI_FLAG_GLOBAL},

   { &key_LOCK_delayed_status, "LOCK_delayed_status", PSI_FLAG_GLOBAL},

   { &key_LOCK_error_log, "LOCK_error_log", PSI_FLAG_GLOBAL},

 extern MYSQL_PLUGIN_IMPORT mysql_mutex_t LOCK_thread_count;

 #ifdef HAVE_OPENSSL

 extern mysql_mutex_t LOCK_des_key_file;

   return id;

 }

 

diff -ruN a/sql/sql_class.cc b/sql/sql_class.cc

--- a/sql/sql_class.cc  2010-12-03 20:58:26.000000000 +0300

+++ b/sql/sql_class.cc  2010-12-30 02:41:40.000000000 +0300

   mysys_var=0;

   binlog_evt_union.do_union= FALSE;

   enable_slow_log= 0;

 #ifndef DBUG_OFF

   dbug_sentry=THD_SENTRY_MAGIC;

 #endif

     variables.option_bits|= OPTION_BIN_LOG;

   else

     variables.option_bits&= ~OPTION_BIN_LOG;

 

 #if defined(ENABLED_DEBUG_SYNC)

   /* Initialize the Debug Sync Facility. See debug_sync.cc. */

 #endif /* defined(ENABLED_DEBUG_SYNC) */

 }

 

 

 /*

   Init THD for query processing.

 }

 #endif

 

 

 struct Item_change_record: public ilink

 {

   }

 

   thd->sent_row_count++;

 

   if (thd->vio_ok())

     DBUG_RETURN(protocol->write());

 select_export::~select_export()

 {

   thd->sent_row_count=row_count;

 }

 

 

   if (likely(thd != 0))

   { /* current_thd==0 when close_connection() calls net_send_error() */

     thd->status_var.bytes_sent+= length;

   }

 }

 

 void thd_increment_bytes_received(ulong length)

 {

   current_thd->status_var.bytes_received+= length;

 /***************************************************************************

 ** List all table types supported

 ***************************************************************************/

                sctx->master_access);

   if (!(db_access & DB_ACLS) && check_grant_db(thd,dbname))

   {

     my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),

              sctx->priv_user, sctx->host_or_ip, dbname);

     general_log_print(thd,COM_INIT_DB,ER(ER_DBACCESS_DENIED_ERROR),

   DBUG_RETURN(res);

 }

 

 

 /* collect status for all running threads */

 

 };

 

 

 ST_FIELD_INFO processlist_fields_info[]=

 {

   {"ID", 4, MYSQL_TYPE_LONGLONG, 0, 0, "Id", SKIP_OPEN_TABLE},

 {

   {"CHARACTER_SETS", charsets_fields_info, create_schema_table, 

    fill_schema_charsets, make_character_sets_old_format, 0, -1, -1, 0, 0},

   {"COLLATIONS", collation_fields_info, create_schema_table, 

    fill_schema_collation, make_old_format, 0, -1, -1, 0, 0},

   {"COLLATION_CHARACTER_SET_APPLICABILITY", coll_charset_app_fields_info,

    OPTIMIZE_I_S_TABLE|OPEN_VIEW_FULL},

   {"COLUMN_PRIVILEGES", column_privileges_fields_info, create_schema_table,

    fill_schema_column_privileges, 0, 0, -1, -1, 0, 0},

   {"ENGINES", engines_fields_info, create_schema_table,

    fill_schema_engines, make_old_format, 0, -1, -1, 0, 0},

 #ifdef HAVE_EVENT_SCHEDULER

    get_all_tables, make_table_names_old_format, 0, 1, 2, 1, 0},

   {"TABLE_PRIVILEGES", table_privileges_fields_info, create_schema_table,

    fill_schema_table_privileges, 0, 0, -1, -1, 0, 0},