~drizzle-trunk/drizzle/development

 

  When using LOCK TABLES:

 

    mysql_lock_tables() will call

    table_handler->external_lock(thd,locktype) for each table.

    This is followed by a call to thr_multi_lock() for all tables.

  Change to use my_malloc() ONLY when using LOCK TABLES command or when

  we are forced to use mysql_lock_merge.

*/

 

/**

  @defgroup Locking Locking

#define GET_LOCK_UNLOCK         1

#define GET_LOCK_STORE_LOCKS    2

 

static void print_lock_error(int error, const char *);

 

/*

    tables                      An array of pointers to the tables to lock.

    count                       The number of tables to lock.

    flags                       Options:

                                              or dropped tables by itself,

                                              mysql_lock_tables() should

                                              notify upper level and rely

static int thr_lock_errno_to_mysql[]=

{ 0, 1, ER_LOCK_WAIT_TIMEOUT, ER_LOCK_DEADLOCK };

 

 

/**

  Reset lock type in lock data and free.

        lock request will set its lock type properly.

*/

 

{

  THR_LOCK_DATA **ldata, **ldata_end;

 

  /* Clear the lock type of all lock data to avoid reusage. */

    /* Reset lock type. */

    (*ldata)->type= TL_UNLOCK;

  }

  *mysql_lock= 0;

}

 

 

{

  int rc;

 

 

  for (;;)

  {

      break;

 

    if (global_read_lock && write_lock_used &&

    {

      /*

        Someone has issued LOCK ALL TABLES FOR READ and we want a write lock

      }

    }

 

        write_lock_used &&

        opt_readonly &&

        !thd->slave_thread)

      break;

    }

 

    if (sql_lock->table_count && lock_external(thd, sql_lock->table,

                                               sql_lock->table_count))

    {

      reset_lock_data_and_free(&sql_lock);

      break;

    }

    /* Copy the lock data array. thr_multi_lock() reorders its contens. */

    memcpy(sql_lock->locks + sql_lock->lock_count, sql_lock->locks,

           sql_lock->lock_count * sizeof(*sql_lock->locks));

    if (rc > 1)                                 /* a timeout or a deadlock */

    {

      if (sql_lock->table_count)

      reset_lock_data_and_free(&sql_lock);

      my_error(rc, MYF(0));

      break;

      sql_lock->lock_count= 0;                  // Locks are already freed

      // Fall through: unlock, reset lock data, free and retry

    }

    {

      /*

        Thread was killed or lock aborted. Let upper level close all

      thd->some_tables_deleted=0;

      break;

    }

 

    /* going to retry, unlock all tables */

    if (sql_lock->lock_count)

        thr_multi_unlock(sql_lock->locks, sql_lock->lock_count);

 

    if (sql_lock->table_count)

 

    /*

      If thr_multi_lock fails it resets lock type for tables, which

    */

    reset_lock_data_and_free(&sql_lock);

retry:

    {

      break;

    }

    if (wait_for_tables(thd))

      break;                                    // Couldn't open tables

  }

  if (thd->killed)

  {

    thd->send_kill_message();

  }

 

  thd->set_time_after_lock();

}

 

 

{

  int lock_type,error;

  for (i=1 ; i <= count ; i++, tables++)

  {

    lock_type=F_WRLCK;                          /* Lock exclusive */

    if ((*tables)->db_stat & HA_READ_ONLY ||

        ((*tables)->reginfo.lock_type >= TL_READ &&

        (*tables)->file->ha_external_lock(thd, F_UNLCK);

        (*tables)->current_lock=F_UNLCK;

      }

    }

    else

    {

      (*tables)->current_lock= lock_type;

    }

  }

}

 

 

{

  if (sql_lock->lock_count)

    thr_multi_unlock(sql_lock->locks,sql_lock->lock_count);

  if (sql_lock->table_count)

}

 

/**

  This will work even if get_lock_data fails (next unlock will free all)

*/

 

{

  if ((sql_lock= get_lock_data(thd, table, count, GET_LOCK_UNLOCK,

                               &write_lock_used)))

    mysql_unlock_tables(thd, sql_lock);

  unlock all tables locked for read.

*/

 

{

 

  /* Move all write locks first */

  THR_LOCK_DATA **lock=sql_lock->locks;

  {

    if (sql_lock->locks[i]->type >= TL_WRITE_ALLOW_READ)

    {

      lock++;

      found++;

    }

 

  /* Then do the same for the external locks */

  /* Move all write locked tables first */

  for (i=found=0 ; i < sql_lock->table_count ; i++)

  {

    if ((uint) sql_lock->table[i]->reginfo.lock_type >= TL_WRITE_ALLOW_READ)

    {

      table++;

      found++;

    }

  /* Unlock all read locked tables */

  if (i != found)

  {

    sql_lock->table_count=found;

  }

  table= sql_lock->table;

  found= 0;

  for (i= 0; i < sql_lock->table_count; i++)

  {

    tbl->lock_position= table - sql_lock->table;

    tbl->lock_data_start= found;

    found+= tbl->lock_count;

    table++;

  }

}

 

 

                          effect is desired.

*/

 

                       bool always_unlock)

{

    mysql_unlock_some_tables(thd, &table, /* table count */ 1);

  if (locked)

  {

    for (i=0; i < locked->table_count; i++)

    {

      if (locked->table[i] == table)

      {

 

 

        /* Unlock if not yet unlocked */

          mysql_unlock_some_tables(thd, &table, /* table count */ 1);

 

        /* Decrement table_count in advance, making below expressions easier */

        removed_locks= table->lock_count;

 

        /* Move down all table pointers above 'i'. */

 

        lock_data_end= table->lock_data_start + table->lock_count;

        /* Move down all lock data pointers above 'table->lock_data_end-1' */

 

        /*

          Fix moved table elements.

        {

          tbl= locked->table[j];

          tbl->lock_position--;

          tbl->lock_data_start-= removed_locks;

        }

 

 

/* Downgrade all locks on a table to new WRITE level from WRITE_ONLY */

 

                                thr_lock_type new_lock_type)

{

  if ((locked = get_lock_data(thd, &table, 1, GET_LOCK_UNLOCK,

                              &write_lock_used)))

  {

      thr_downgrade_write_lock(locked->locks[i], new_lock_type);

  }

}

 

 

/** Abort all other threads waiting to get lock in table. */

 

{

 

  if ((locked= get_lock_data(thd, &table, 1, GET_LOCK_UNLOCK,

                             &write_lock_used)))

  {

      thr_abort_locks(locked->locks[i]->lock, upgrade_lock);

  }

}

 

 

    1  Table was locked by at least one other thread

*/