~vlad-lesin/percona-server/pintables

   DBUG_RETURN(error);

 }

 

       dup_ref=ref+ALIGN_SIZE(ref_length);

     cached_table_flags= table_flags();

   }

   DBUG_RETURN(error);

 }

 

   return;

 }

 

diff -ruN a/sql/handler.h b/sql/handler.h

--- a/sql/handler.h     2011-04-10 12:23:52.000000000 +0400

+++ b/sql/handler.h     2011-04-10 12:24:34.000000000 +0400

 #include <ft_global.h>

 #include <keycache.h>

 

 // 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; }

 

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

--- a/sql/mysqld.cc     2011-04-10 12:23:56.000000000 +0400

+++ b/sql/mysqld.cc     2011-04-10 12:24:34.000000000 +0400

 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_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), 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 ulong what_to_log,flush_time;

 extern ulong max_prepared_stmt_count, prepared_stmt_count;

 extern ulong open_files_limit;

 extern struct system_variables max_system_variables;

 extern struct system_status_var global_status_var;

 extern struct rand_struct sql_rand;

 extern const char *opt_date_time_formats[];

 extern handlerton *partition_hton;

 extern handlerton *myisam_hton;

   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_logger, key_LOCK_manager,

   key_LOCK_prepared_stmt_count,

        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,

        LOCK_slave_list, LOCK_active_mi, LOCK_manager,

        LOCK_global_system_variables, LOCK_user_conn,

 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  2011-04-10 12:23:56.000000000 +0400

+++ b/sql/sql_class.cc  2011-04-10 12:24:34.000000000 +0400

   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;

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

--- a/sql/sql_class.h   2011-04-10 12:23:56.000000000 +0400

+++ b/sql/sql_class.h   2011-04-10 12:24:34.000000000 +0400

   */

   enum enum_server_command command;

   uint32     server_id;

   uint32     file_id;                  // for LOAD DATA INFILE

   /* remote (peer) port */

   uint16 peer_port;

   */

   enum_tx_isolation tx_isolation;

   enum_check_fields count_cuted_fields;

 

   DYNAMIC_ARRAY user_var_events;        /* For user variables replication */

   MEM_ROOT      *user_var_events_alloc; /* Allocate above array elements here */

   */

   LOG_INFO*  current_linfo;

   NET*       slave_net;                        // network connection from slave -> m.

   /* Used by the sys_var class to store temporary values */

   union

   {

     alloc_root. 

   */

   void init_for_queries();

   void change_user(void);

   void cleanup(void);

   void cleanup_after_query();

   }

   thd_scheduler scheduler;

 

 public:

   inline Internal_error_handler *get_internal_handler()

   { return m_internal_handler; }

   LEX_STRING invoker_host;

 };

 

 

 /* 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},

diff -ruN a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc

--- a/storage/myisam/ha_myisam.cc       2011-04-10 12:16:42.000000000 +0400

+++ b/storage/myisam/ha_myisam.cc       2011-04-10 12:24:34.000000000 +0400

 

 int ha_myisam::write_row(uchar *buf)

 {

   ha_statistic_increment(&SSV::ha_write_count);

 

   /* If we have a timestamp column, update it to the current time */

   */

   if (table->next_number_field && buf == table->record[0])

   {

 }

 

 int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)

 

 int ha_myisam::update_row(const uchar *old_data, uchar *new_data)

 {

 }

 

 int ha_myisam::index_read_map(uchar *buf, const uchar *key,

   ha_statistic_increment(&SSV::ha_read_key_count);

   int error=mi_rkey(file, buf, active_index, key, keypart_map, find_flag);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_key_count);

   int error=mi_rkey(file, buf, index, key, keypart_map, find_flag);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   int error=mi_rkey(file, buf, active_index, key, keypart_map,

                     HA_READ_PREFIX_LAST);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   DBUG_RETURN(error);

 }

   ha_statistic_increment(&SSV::ha_read_next_count);

   int error=mi_rnext(file,buf,active_index);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_prev_count);

   int error=mi_rprev(file,buf, active_index);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_first_count);

   int error=mi_rfirst(file, buf, active_index);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_last_count);

   int error=mi_rlast(file, buf, active_index);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

     error= mi_rnext_same(file,buf);

   } while (error == HA_ERR_RECORD_DELETED);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_INDEX_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_rnd_next_count);

   int error=mi_scan(file, buf);

   table->status=error ? STATUS_NOT_FOUND: 0;

   MYSQL_READ_ROW_DONE(error);

   return error;

 }

   ha_statistic_increment(&SSV::ha_read_rnd_count);

   int error=mi_rrnd(file, buf, my_get_ptr(pos,ref_length));

   table->status=error ? STATUS_NOT_FOUND: 0;