Commit 9a26412c authored by unknown's avatar unknown
Browse files

Merge mysql.com:/home/bkroot/mysql-5.1-new 

into  mysql.com:/home/bk/fix-mysql-5.1-release


sql/log_event.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/sql_base.cc:
  Auto merged
parents e2393aa2 b9697b20

sql/ha_ndbcluster_binlog.cc

+1 −1
Original line number Diff line number Diff line
@@ -261,7 +261,7 @@ ndbcluster_binlog_open_table(THD *thd, NDB_SHARE *share, 
    my_free((gptr) table, MYF(0));

    DBUG_RETURN(error);

  }

  assign_new_table_id(table);

  assign_new_table_id(share);

  if (!table->record[1] || table->record[1] == table->record[0])

  {

    table->record[1]= alloc_root(&table->mem_root,

sql/log_event.cc

+11 −10
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#endif /* MYSQL_CLIENT */

#include <base64.h>

#include <my_bitmap.h>

#include <my_vle.h>



#define log_cs	&my_charset_latin1
@@ -5128,7 +5127,8 @@ Rows_log_event::Rows_log_event(const char *buf, uint event_len, 
  byte const *const var_start= (const byte *)buf + common_header_len + 

    post_header_len;

  byte const *const ptr_width= var_start;

  byte const *const ptr_after_width= my_vle_decode(&m_width, ptr_width);

  uchar *ptr_after_width= (uchar*) ptr_width;

  m_width = net_field_length(&ptr_after_width);



  const uint byte_count= (m_width + 7) / 8;

  const byte* const ptr_rows_data= var_start + byte_count + 1;
@@ -5598,13 +5598,13 @@ bool Rows_log_event::write_data_body(IO_CACHE*file) 
     Note that this should be the number of *bits*, not the number of

     bytes.

  */

  byte sbuf[my_vle_sizeof(m_width)];

  byte sbuf[sizeof(m_width)];

  my_ptrdiff_t const data_size= m_rows_cur - m_rows_buf;



  char *const sbuf_end= (char *const)my_vle_encode(sbuf, sizeof(sbuf), m_width);

  DBUG_ASSERT(static_cast<my_size_t>(sbuf_end - (char *const)sbuf) <= sizeof(sbuf));

  char *const sbuf_end= net_store_length(sbuf, (uint) m_width);

  DBUG_ASSERT(static_cast<my_size_t>(sbuf_end - (char*) sbuf) <= sizeof(sbuf));



  return (my_b_safe_write(file, sbuf, sbuf_end - (char *const)sbuf) ||

  return (my_b_safe_write(file, sbuf, sbuf_end - (char*) sbuf) ||

          my_b_safe_write(file, reinterpret_cast<byte*>(m_cols.bitmap),

                          no_bytes_in_map(&m_cols)) ||

          my_b_safe_write(file, m_rows_buf, data_size));
@@ -5731,7 +5731,8 @@ Table_map_log_event::Table_map_log_event(const char *buf, uint event_len, 


  /* Length of table name + counter + terminating null */

  byte const* const ptr_colcnt= ptr_tbllen + m_tbllen + 2;

  byte const* const ptr_after_colcnt= my_vle_decode(&m_colcnt, ptr_colcnt);

  uchar *ptr_after_colcnt= (uchar*) ptr_colcnt;

  m_colcnt= net_field_length(&ptr_after_colcnt);



  DBUG_PRINT("info",("m_dblen=%d off=%d m_tbllen=%d off=%d m_colcnt=%d off=%d",

                     m_dblen, ptr_dblen-(const byte*)vpart,
@@ -6047,9 +6048,9 @@ bool Table_map_log_event::write_data_body(IO_CACHE *file) 
  byte const dbuf[]= { m_dblen };

  byte const tbuf[]= { m_tbllen };



  byte cbuf[my_vle_sizeof(m_colcnt)];

  byte *const cbuf_end= my_vle_encode(cbuf, sizeof(cbuf), m_colcnt);

  DBUG_ASSERT(static_cast<my_size_t>(cbuf_end - cbuf) <= sizeof(cbuf));

  byte cbuf[sizeof(m_colcnt)];

  char *const cbuf_end= net_store_length(cbuf, (uint) m_colcnt);

  DBUG_ASSERT(static_cast<my_size_t>(cbuf_end - (char*) cbuf) <= sizeof(cbuf));



  return (my_b_safe_write(file, dbuf,      sizeof(dbuf)) ||

          my_b_safe_write(file, (const byte*)m_dbnam,   m_dblen+1) ||

sql/mysql_priv.h

+1 −1
Original line number Diff line number Diff line
@@ -660,7 +660,7 @@ bool table_cache_init(void); 
void table_cache_free(void);

bool table_def_init(void);

void table_def_free(void);

void assign_new_table_id(TABLE *table);

void assign_new_table_id(TABLE_SHARE *share);

uint cached_open_tables(void);

uint cached_table_definitions(void);

void kill_mysql(void);

sql/sql_base.cc

+35 −26
Original line number Diff line number Diff line
@@ -313,6 +313,22 @@ TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key, 
    conflicts

  */

  (void) pthread_mutex_lock(&share->mutex);



  /*

    We assign a new table id under the protection of the LOCK_open and

    the share's own mutex.  We do this insted of creating a new mutex

    and using it for the sole purpose of serializing accesses to a

    static variable, we assign the table id here.  We assign it to the

    share before inserting it into the table_def_cache to be really

    sure that it cannot be read from the cache without having a table

    id assigned.



    CAVEAT. This means that the table cannot be used for

    binlogging/replication purposes, unless get_table_share() has been

    called directly or indirectly.

   */

  assign_new_table_id(share);



  if (my_hash_insert(&table_def_cache, (byte*) share))

  {

#ifdef NOT_YET
@@ -2392,43 +2408,50 @@ void abort_locked_tables(THD *thd,const char *db, const char *table_name) 




/*

  Function to assign a new table map id to a table.

  Function to assign a new table map id to a table share.



  PARAMETERS



    table - Pointer to table structure

    share - Pointer to table share structure



  PRE-CONDITION(S)



    table is non-NULL

    share is non-NULL

    The LOCK_open mutex is locked

    The share->mutex is locked



  POST-CONDITION(S)



    table->s->table_map_id is given a value that with a high certainty

    is not used by any other table.

    share->table_map_id is given a value that with a high certainty is

    not used by any other table (the only case where a table id can be

    reused is on wrap-around, which means more than 4 billion table

    shares open at the same time).



    table->s->table_map_id is not ULONG_MAX.

    share->table_map_id is not ULONG_MAX.

 */

void assign_new_table_id(TABLE *table)

void assign_new_table_id(TABLE_SHARE *share)

{

  static ulong last_table_id= ULONG_MAX;



  DBUG_ENTER("assign_new_table_id(TABLE*)");

  DBUG_ENTER("assign_new_table_id");



  /* Preconditions */

  DBUG_ASSERT(table != NULL);

  DBUG_ASSERT(share != NULL);

  safe_mutex_assert_owner(&LOCK_open);

  safe_mutex_assert_owner(&share->mutex);



  ulong tid= ++last_table_id;                   /* get next id */

  /* There is one reserved number that cannot be used. */

  /*

    There is one reserved number that cannot be used.  Remember to

    change this when 6-byte global table id's are introduced.

  */

  if (unlikely(tid == ULONG_MAX))

    tid= ++last_table_id;

  table->s->table_map_id= tid;

  share->table_map_id= tid;

  DBUG_PRINT("info", ("table_id=%lu", tid));



  /* Post conditions */

  DBUG_ASSERT(table->s->table_map_id != ULONG_MAX);

  DBUG_ASSERT(share->table_map_id != ULONG_MAX);



  DBUG_VOID_RETURN;

}
@@ -2582,20 +2605,6 @@ static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list, 
     break;

   }



  /*

    We assign a new table id under the protection of the LOCK_open

    mutex.  We assign a new table id here instead of inside openfrm()

    since that function can be used without acquiring any lock (e.g.,

    inside ha_create_table()).  Insted of creatint a new mutex and

    using it for the sole purpose of serializing accesses to a static

    variable, we assign the table id here.



    CAVEAT. This means that the table cannot be used for

    binlogging/replication purposes, unless open_table() has been called

    directly or indirectly.

   */

  assign_new_table_id(entry);



  if (Table_triggers_list::check_n_load(thd, share->db.str,

                                        share->table_name.str, entry, 0))

  {

sql/table.cc

+28 −18
Original line number Diff line number Diff line
@@ -130,6 +130,24 @@ TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key, 
    share->version=       refresh_version;

    share->flush_version= flush_version;



#ifdef HAVE_ROW_BASED_REPLICATION

    /*

      This constant is used to mark that no table map version has been

      assigned.  No arithmetic is done on the value: it will be

      overwritten with a value taken from MYSQL_BIN_LOG.

    */

    share->table_map_version= ~(ulonglong)0;



    /*

      Since alloc_table_share() can be called without any locking (for

      example, ha_create_table... functions), we do not assign a table

      map id here.  Instead we assign a value that is not used

      elsewhere, and then assign a table map id inside open_table()

      under the protection of the LOCK_open mutex.

    */

    share->table_map_id= ULONG_MAX;

#endif



    memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));

    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);

    pthread_cond_init(&share->cond, NULL);
@@ -180,6 +198,15 @@ void init_tmp_table_share(TABLE_SHARE *share, const char *key, 
  share->path.length= share->normalized_path.length= strlen(path);

  share->frm_version= 		 FRM_VER_TRUE_VARCHAR;



#ifdef HAVE_ROW_BASED_REPLICATION

  /*

    Temporary tables are not replicated, but we set up these fields

    anyway to be able to catch errors.

   */

  share->table_map_version= ~(ulonglong)0;

  share->table_map_id= ULONG_MAX;

#endif



  DBUG_VOID_RETURN;

}
@@ -371,6 +398,7 @@ int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags) 
    share->error= error;

    open_table_error(share, error, (share->open_errno= my_errno), 0);

  }



  DBUG_RETURN(error);

}
@@ -1503,24 +1531,6 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias, 


  *root_ptr= old_root;

  thd->status_var.opened_tables++;

#ifdef HAVE_REPLICATION



  /*

     This constant is used to mark that no table map version has been

     assigned.  No arithmetic is done on the value: it will be

     overwritten with a value taken from MYSQL_BIN_LOG.

  */

  share->table_map_version= ~(ulonglong)0;



  /*

    Since openfrm() can be called without any locking (for example,

    ha_create_table... functions), we do not assign a table map id

    here.  Instead we assign a value that is not used elsewhere, and

    then assign a table map id inside open_table() under the

    protection of the LOCK_open mutex.

   */

  share->table_map_id= ULONG_MAX;

#endif



  DBUG_RETURN (0);