← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/locking/global.cc

  • Committer: Brian Aker
  • Date: 2010-11-08 18:54:26 UTC
  • mto: (1921.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 1916.
  • Revision ID: brian@tangent.org-20101108185426-fymkf2xnelupf11x
Rename lock methods to be style + well make sense.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/locking/global.cc
27
27
 
28
28
  When not using LOCK TABLES:
29
29
 
30
 
  - For each SQL statement mysql_lock_tables() is called for all involved
 
30
  - For each SQL statement lockTables() is called for all involved
31
31
    tables.
32
 
    - mysql_lock_tables() will call
 
32
    - lockTables() will call
33
33
      table_handler->external_lock(session,locktype) for each table.
34
34
      This is followed by a call to thr_multi_lock() for all tables.
35
35
 
36
 
  - When statement is done, we call mysql_unlock_tables().
 
36
  - When statement is done, we call unlockTables().
37
37
    This will call DrizzleLock::unlock() followed by
38
38
    table_handler->external_lock(session, F_UNLCK) for each table.
39
39
 
40
 
  - Note that mysql_unlock_tables() may be called several times as
 
40
  - Note that unlockTables() may be called several times as
41
41
    MySQL in some cases can free some tables earlier than others.
42
42
 
43
43
  - The above is true both for normal and temporary tables.
47
47
 
48
48
  When using LOCK TABLES:
49
49
 
50
 
  - LOCK Table will call mysql_lock_tables() for all tables.
51
 
    mysql_lock_tables() will call
 
50
  - LOCK Table will call lockTables() for all tables.
 
51
    lockTables() will call
52
52
    table_handler->external_lock(session,locktype) for each table.
53
53
    This is followed by a call to thr_multi_lock() for all tables.
54
54
 
60
60
 
61
61
  - When statement is done, we will call ha_commit_stmt(session);
62
62
 
63
 
  - When calling UNLOCK TABLES we call mysql_unlock_tables() for all
 
63
  - When calling UNLOCK TABLES we call unlockTables() for all
64
64
    tables used in LOCK TABLES
65
65
 
66
66
  If table_handler->external_lock(session, locktype) fails, we call
111
111
  Lock tables.
112
112
 
113
113
  SYNOPSIS
114
 
    mysql_lock_tables()
 
114
    lockTables()
115
115
    tables                      An array of pointers to the tables to lock.
116
116
    count                       The number of tables to lock.
117
117
    flags                       Options:
119
119
      DRIZZLE_LOCK_IGNORE_FLUSH                 Ignore a flush tables.
120
120
      DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN        Instead of reopening altered
121
121
                                              or dropped tables by itself,
122
 
                                              mysql_lock_tables() should
 
122
                                              lockTables() should
123
123
                                              notify upper level and rely
124
124
                                              on caller doing this.
125
125
    need_reopen                 Out parameter, TRUE if some tables were altered
172
172
}
173
173
 
174
174
 
175
 
DrizzleLock *Session::mysql_lock_tables(Table **tables, uint32_t count, uint32_t flags, bool *need_reopen)
 
175
DrizzleLock *Session::lockTables(Table **tables, uint32_t count, uint32_t flags, bool *need_reopen)
176
176
{
177
177
  DrizzleLock *sql_lock;
178
178
  Table *write_lock_used;
325
325
    send_kill_message();
326
326
    if (sql_lock)
327
327
    {
328
 
      mysql_unlock_tables(sql_lock);
 
328
      unlockTables(sql_lock);
329
329
      sql_lock= NULL;
330
330
    }
331
331
  }
367
367
}
368
368
 
369
369
 
370
 
void Session::mysql_unlock_tables(DrizzleLock *sql_lock)
 
370
void Session::unlockTables(DrizzleLock *sql_lock)
371
371
{
372
372
  if (sql_lock->lock_count)
373
373
    sql_lock->unlock(sql_lock->lock_count);
377
377
}
378
378
 
379
379
/**
380
 
  Unlock some of the tables locked by mysql_lock_tables.
 
380
  Unlock some of the tables locked by lockTables.
381
381
 
382
382
  This will work even if get_lock_data fails (next unlock will free all)
383
383
*/
384
384
 
385
 
void Session::mysql_unlock_some_tables(Table **table, uint32_t count)
 
385
void Session::unlockSomeTables(Table **table, uint32_t count)
386
386
{
387
387
  DrizzleLock *sql_lock;
388
388
  Table *write_lock_used;
389
389
  if ((sql_lock= get_lock_data(table, count, false,
390
390
                               &write_lock_used)))
391
 
    mysql_unlock_tables(sql_lock);
 
391
    unlockTables(sql_lock);
392
392
}
393
393
 
394
394
 
396
396
  unlock all tables locked for read.
397
397
*/
398
398
 
399
 
void Session::mysql_unlock_read_tables(DrizzleLock *sql_lock)
 
399
void Session::unlockReadTables(DrizzleLock *sql_lock)
400
400
{
401
401
  uint32_t i,found;
402
402
 
471
471
                          effect is desired.
472
472
*/
473
473
 
474
 
void Session::mysql_lock_remove(Table *table)
 
474
void Session::removeLock(Table *table)
475
475
{
476
 
  mysql_unlock_some_tables(&table, /* table count */ 1);
 
476
  unlockSomeTables(&table, /* table count */ 1);
477
477
}
478
478
 
479
479
 
480
480
/** Abort all other threads waiting to get lock in table. */
481
481
 
482
 
void Session::mysql_lock_abort(Table *table)
 
482
void Session::abortLock(Table *table)
483
483
{
484
484
  DrizzleLock *locked;
485
485
  Table *write_lock_used;
506
506
    1  Table was locked by at least one other thread
507
507
*/
508
508
 
509
 
bool Session::mysql_lock_abort_for_thread(Table *table)
 
509
bool Session::abortLockForThread(Table *table)
510
510
{
511
511
  DrizzleLock *locked;
512
512
  Table *write_lock_used;