bk commit into 5.1 tree (acurtis:1.2489) BUG#26241

[antony]

Below is the list of changes that have just been committed into a local
5.1 repository of antony. When antony does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-05-02 09:57:16-07:00, acurtis@stripped +5 -0
  Bug#26241
    "Blackhole tables don't honor table locks"
    Implement neccessary shared lock structure for table locks.
    Imported test case created by Giuseppe Maxia

  mysql-test/include/rpl_bh_lock.inc@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped
+57 -0
    New BitKeeper file ``mysql-test/include/rpl_bh_lock.inc''

  mysql-test/include/rpl_bh_lock.inc@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +0
-0

  mysql-test/r/rpl_bh_lock.result@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +112
-0
    New BitKeeper file ``mysql-test/r/rpl_bh_lock.result''

  mysql-test/r/rpl_bh_lock.result@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +0 -0

  mysql-test/t/rpl_bh_lock.test@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +55 -0
    New BitKeeper file ``mysql-test/t/rpl_bh_lock.test''

  mysql-test/t/rpl_bh_lock.test@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +0 -0

  storage/blackhole/ha_blackhole.cc@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped
+130 -10
    bug26241 - blackhole locks don't work
      Implement shared structure for table locks.
      Used row-lock code from archive.

  storage/blackhole/ha_blackhole.h@stripped, 2007-05-02 09:57:13-07:00, acurtis@stripped +12
-2
    bug26241 - blackhole locks don't work
      Implement shared structure for table locks.

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	acurtis
# Host:	ltamd64.xiphis.org
# Root:	/home/antony/work2/p2-bug26241.1
--- New file ---
+++ mysql-test/include/rpl_bh_lock.inc	07/05/02 09:57:13
connection master;
show create table t1;
show create table t2;

lock table t1 write, t2 write;
insert into t1 values ('original',1);

--echo #
--echo # a second session will try inserting into the *locked* table
--echo #
connection master1;
if ($immediate)
{
insert into t1 values('while locked',2);
}
if (!$immediate)
{
send insert into t1 values('while locked',2);
}
--echo # 
--echo # the main session does some operation based on the assumption that the tables
--echo # are locked
--echo # 

connection master;
delimiter //;
send insert into t2 select * from t1; unlock tables; //
delimiter ;//

--sleep 1
--echo #
--echo # the second session changes data before
--echo # the main session can finish its work
--echo #
connection master1;
if (!$immediate)
{
--reap
}

--echo #
--echo # the main session collects the results and unlocks the tables
--echo #
connection master;
--reap
--sleep 1

--echo #
--echo # let's see the results on the slave
--echo # the count should be 1
--echo #
save_master_pos;
sync_with_master;
connection slave;
select count(*) from t2;



--- New file ---
+++ mysql-test/r/rpl_bh_lock.result	07/05/02 09:57:13
set global binlog_format=statement;
stop slave;
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
reset master;
reset slave;
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
start slave;
drop table if exists t1,t2;
create table t1 (a varchar(100), b int) engine=blackhole;
create table t2 (a varchar(100), b int) engine=blackhole;
alter table t1 engine= myisam;
alter table t2 engine= myisam;
show create table t1;
Table	Create Table
t1	CREATE TABLE `t1` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
show create table t2;
Table	Create Table
t2	CREATE TABLE `t2` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
#
# with BlackHole table
#
show create table t1;
Table	Create Table
t1	CREATE TABLE `t1` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=BLACKHOLE DEFAULT CHARSET=latin1
show create table t2;
Table	Create Table
t2	CREATE TABLE `t2` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=BLACKHOLE DEFAULT CHARSET=latin1
lock table t1 write, t2 write;
insert into t1 values ('original',1);
#
# a second session will try inserting into the *locked* table
#
insert into t1 values('while locked',2);
# 
# the main session does some operation based on the assumption that the tables
# are locked
# 
insert into t2 select * from t1; unlock tables; //
#
# the second session changes data before
# the main session can finish its work
#
#
# the main session collects the results and unlocks the tables
#
#
# let's see the results on the slave
# the count should be 1
#
select count(*) from t2;
count(*)
1
#
# with MyIsam table
#
alter table t1 engine=myisam;
alter table t2 engine=myisam;
truncate t1;
truncate t2;
show create table t1;
Table	Create Table
t1	CREATE TABLE `t1` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
show create table t2;
Table	Create Table
t2	CREATE TABLE `t2` (
  `a` varchar(100) DEFAULT NULL,
  `b` int(11) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
lock table t1 write, t2 write;
insert into t1 values ('original',1);
#
# a second session will try inserting into the *locked* table
#
insert into t1 values('while locked',2);
# 
# the main session does some operation based on the assumption that the tables
# are locked
# 
insert into t2 select * from t1; unlock tables; //
#
# the second session changes data before
# the main session can finish its work
#
#
# the main session collects the results and unlocks the tables
#
#
# let's see the results on the slave
# the count should be 1
#
select count(*) from t2;
count(*)
1
#
# cleaning up
#
drop table t1,t2;

--- New file ---
+++ mysql-test/t/rpl_bh_lock.test	07/05/02 09:57:13
# Replication of Blackhole tables with locks

set global binlog_format=statement;

-- source include/have_blackhole.inc
-- source include/master-slave.inc

--disable_warnings
drop table if exists t1,t2;
--enable_warnings

connection master;

create table t1 (a varchar(100), b int) engine=blackhole;
create table t2 (a varchar(100), b int) engine=blackhole;

sleep 1;
save_master_pos;
connection slave;
sync_with_master;

alter table t1 engine= myisam;
alter table t2 engine= myisam;
show create table t1;
show create table t2;

--echo #
--echo # with BlackHole table
--echo #

let $immediate=0;
connection master;
--source include/rpl_bh_lock.inc

--echo #
--echo # with MyIsam table
--echo #

let $immediate=0;
connection master;

alter table t1 engine=myisam;
alter table t2 engine=myisam;
truncate t1;
truncate t2;

--source include/rpl_bh_lock.inc

--echo #
--echo # cleaning up
--echo #
connection master;

drop table t1,t2;



--- 1.49/storage/blackhole/ha_blackhole.cc	2007-05-02 09:57:31 -07:00
+++ 1.50/storage/blackhole/ha_blackhole.cc	2007-05-02 09:57:31 -07:00
@@ -31,6 +31,14 @@
 }
 
 
+/* Static declarations for shared structures */
+
+static pthread_mutex_t blackhole_mutex;
+static HASH blackhole_open_tables;
+
+static st_blackhole_share *get_share(const char *table_name);
+static void free_share(st_blackhole_share *share);
+
 /*****************************************************************************
 ** BLACKHOLE tables
 *****************************************************************************/
@@ -53,15 +61,18 @@
 int ha_blackhole::open(const char *name, int mode, uint test_if_locked)
 {
   DBUG_ENTER("ha_blackhole::open");
-  thr_lock_init(&thr_lock);
-  thr_lock_data_init(&thr_lock,&lock,NULL);
+
+  if (!(share= get_share(name)))
+    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+  thr_lock_data_init(&share->lock, &lock, (void*) this);
   DBUG_RETURN(0);
 }
 
 int ha_blackhole::close(void)
 {
   DBUG_ENTER("ha_blackhole::close");
-  thr_lock_delete(&thr_lock);
+  free_share(share);
   DBUG_RETURN(0);
 }
 
@@ -136,17 +147,39 @@
 }
 
 
-uint ha_blackhole::lock_count(void) const
-{
-  DBUG_ENTER("ha_blackhole::lock_count");
-  DBUG_RETURN(0);
-}
-
 THR_LOCK_DATA **ha_blackhole::store_lock(THD *thd,
                                          THR_LOCK_DATA **to,
                                          enum thr_lock_type lock_type)
 {
   DBUG_ENTER("ha_blackhole::store_lock");
+  if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
+  {
+    /*
+      Here is where we get into the guts of a row level lock.
+      If TL_UNLOCK is set
+      If we are not doing a LOCK TABLE or DISCARD/IMPORT
+      TABLESPACE, then allow multiple writers
+    */
+
+    if ((lock_type >= TL_WRITE_CONCURRENT_INSERT &&
+         lock_type <= TL_WRITE) && !thd_in_lock_tables(thd)
+        && !thd_tablespace_op(thd))
+      lock_type = TL_WRITE_ALLOW_WRITE;
+
+    /*
+      In queries of type INSERT INTO t1 SELECT ... FROM t2 ...
+      MySQL would use the lock TL_READ_NO_INSERT on t2, and that
+      would conflict with TL_WRITE_ALLOW_WRITE, blocking all inserts
+      to t2. Convert the lock to a normal read lock to allow
+      concurrent inserts to t2.
+    */
+
+    if (lock_type == TL_READ_NO_INSERT && !thd_in_lock_tables(thd))
+      lock_type = TL_READ;
+
+    lock.type= lock_type;
+}
+  *to++= &lock;
   DBUG_RETURN(to);
 }
 
@@ -204,6 +237,80 @@
   DBUG_RETURN(HA_ERR_END_OF_FILE);
 }
 
+/* this should exist and return 0 for concurrent insert to work */
+static my_bool blackhole_check_status(void *param)
+{
+  return 0;
+}
+
+static void blackhole_get_status(void* param, int concurrent_insert)
+{
+}
+
+static void blackhole_update_status(void* param)
+{
+}
+
+
+static st_blackhole_share *get_share(const char *table_name)
+{
+  st_blackhole_share *share;
+  uint length;
+
+  length= (uint) strlen(table_name);
+  pthread_mutex_lock(&blackhole_mutex);
+    
+  if (!(share= (st_blackhole_share*) hash_search(&blackhole_open_tables,
+                                                 (byte*) table_name, length)))
+  {
+    if (!(share= (st_blackhole_share*) my_malloc(sizeof(st_blackhole_share) +
+                                                 length,
+                                                 MYF(MY_WME | MY_ZEROFILL))))
+      goto error;
+
+    share->table_name_length= length;
+    strmov(share->table_name, table_name);
+    
+    if (my_hash_insert(&blackhole_open_tables, (byte*) share))
+    {
+      my_free((gptr) share, MYF(0));
+      share= NULL;
+      goto error;
+    }
+    
+    thr_lock_init(&share->lock);
+    
+    /* support concurrent insert */
+    share->lock.get_status= blackhole_get_status;
+    share->lock.update_status= blackhole_update_status;
+    share->lock.check_status= blackhole_check_status;
+  }
+  share->use_count++;
+  
+error:
+  pthread_mutex_unlock(&blackhole_mutex);
+  return share;
+}
+
+static void free_share(st_blackhole_share *share)
+{
+  pthread_mutex_lock(&blackhole_mutex);
+  if (!--share->use_count)
+  {
+    hash_delete(&blackhole_open_tables, (byte*) share);
+    thr_lock_delete(&share->lock);
+    my_free((gptr) share, MYF(0));
+  }
+  pthread_mutex_unlock(&blackhole_mutex);
+}
+
+static byte* blackhole_get_key(st_blackhole_share *share, uint *length,
+                               my_bool not_used __attribute__((unused)))
+{
+  *length= share->table_name_length;
+  return (byte*) share->table_name;
+}
+
 static int blackhole_init(void *p)
 {
   handlerton *blackhole_hton;
@@ -212,6 +319,19 @@
   blackhole_hton->db_type= DB_TYPE_BLACKHOLE_DB;
   blackhole_hton->create= blackhole_create_handler;
   blackhole_hton->flags= HTON_CAN_RECREATE;
+  
+  VOID(pthread_mutex_init(&blackhole_mutex, MY_MUTEX_INIT_FAST));
+  (void) hash_init(&blackhole_open_tables, system_charset_info,32,0,0,
+                   (hash_get_key) blackhole_get_key,0,0);
+
+  return 0;
+}
+
+static int blackhole_fini(void *p)
+{
+  hash_free(&blackhole_open_tables);
+  pthread_mutex_destroy(&blackhole_mutex);
+
   return 0;
 }
 
@@ -227,7 +347,7 @@
   "/dev/null storage engine (anything you write to it disappears)",
   PLUGIN_LICENSE_GPL,
   blackhole_init, /* Plugin Init */
-  NULL, /* Plugin Deinit */
+  blackhole_fini, /* Plugin Deinit */
   0x0100 /* 1.0 */,
   NULL,                       /* status variables                */
   NULL,                       /* system variables                */

--- 1.14/storage/blackhole/ha_blackhole.h	2007-05-02 09:57:31 -07:00
+++ 1.15/storage/blackhole/ha_blackhole.h	2007-05-02 09:57:31 -07:00
@@ -18,13 +18,24 @@
 #endif
 
 /*
+  Shared structure for correct LOCK operation
+*/
+struct st_blackhole_share {
+  THR_LOCK lock;
+  uint use_count;
+  uint table_name_length;
+  char table_name[1];
+};
+
+
+/*
   Class definition for the blackhole storage engine
   "Dumbest named feature ever"
 */
 class ha_blackhole: public handler
 {
   THR_LOCK_DATA lock;      /* MySQL lock */
-  THR_LOCK thr_lock;
+  st_blackhole_share *share;
 
 public:
   ha_blackhole(handlerton *hton, TABLE_SHARE *table_arg);
@@ -76,7 +87,6 @@
   void position(const byte *record);
   int info(uint flag);
   int external_lock(THD *thd, int lock_type);
-  uint lock_count(void) const;
   int create(const char *name, TABLE *table_arg,
              HA_CREATE_INFO *create_info);
   THR_LOCK_DATA **store_lock(THD *thd,