~drizzle-trunk/drizzle/development

@note because we risk the chance of deleting the share, we can't assume that it will exist past, this should be modified once we can use a TableShare::shared_ptr here.

660

@note because we risk the chance of deleting the share, we can't assume that it will exist past, this should be modified once we can use a TableSharePtr here.

661

662

663

void Session::unlink_open_table(Table *find)

664

{

665

const TableIdentifier::Key find_key(find->getShare()->getCacheKey());

666

Table **prev;

667

safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

667

safe_mutex_assert_owner(LOCK_open.native_handle());

668

669

670

Note that we need to hold table::Cache::singleton().mutex() while changing the

670

Note that we need to hold LOCK_open while changing the

671

open_tables list. Another thread may work on it.

672

(See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())

673

Closing a MERGE child before the parent would be fatal if the

693

}

694

695

// Notify any 'refresh' threads

696

locking::broadcast_refresh();

696

broadcast_refresh();

697

}

698

699

716

table that was locked with LOCK TABLES.

717

718

719

void Session::drop_open_table(Table *table, const TableIdentifier &identifier)

719

void Session::drop_open_table(Table *table, TableIdentifier &identifier)

720

{

721

if (table->getShare()->getType())

722

{

724

}

725

else

726

{

727

boost_unique_lock_t scoped_lock(table::Cache::singleton().mutex()); /* Close and drop a table (AUX routine) */

727

boost_unique_lock_t scoped_lock(LOCK_open); /* Close and drop a table (AUX routine) */

728

729

unlink_open_table() also tells threads waiting for refresh or close

730

that something has happened.

731

732

unlink_open_table(table);

733

plugin::StorageEngine::dropTable(*this, identifier);

733

quick_rm_table(*this, identifier);

734

}

735

}

736

766

mutex is unlocked

767

768

boost_unique_lock_t scopedLock(mutex, boost::adopt_lock_t());

769

if (not getKilled())

769

if (not killed)

770

{

771

cond.wait(scopedLock);

772

}

793

794

table::Placeholder *Session::table_cache_insert_placeholder(const drizzled::TableIdentifier &arg)

795

{

796

safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

796

safe_mutex_assert_owner(LOCK_open.native_handle());

797

798

799

Create a table entry with the right key and with an old refresh version

833

@retval true Error occured (OOM)

834

@retval false Success. 'table' parameter set according to above rules.

835

836

bool Session::lock_table_name_if_not_cached(const TableIdentifier &identifier, Table **table)

836

bool Session::lock_table_name_if_not_cached(TableIdentifier &identifier, Table **table)

837

{

838

const TableIdentifier::Key &key(identifier.getKey());

839

840

boost_unique_lock_t scope_lock(table::Cache::singleton().mutex()); /* Obtain a name lock even though table is not in cache (like for create table) */

840

boost_unique_lock_t scope_lock(LOCK_open); /* Obtain a name lock even though table is not in cache (like for create table) */

841

842

table::CacheMap::iterator iter;

843

909

if (check_stack_overrun(this, STACK_MIN_SIZE_FOR_OPEN, (unsigned char *)&alias))

910

return NULL;

911

912

if (getKilled())

912

if (killed)

913

return NULL;

914

915

TableIdentifier identifier(table_list->getSchemaName(), table_list->getTableName());

924

TODO -> move this block into a separate function.

925

926

bool reset= false;

927

for (table= getTemporaryTables(); table ; table=table->getNext())

927

for (table= temporary_tables; table ; table=table->getNext())

928

{

929

if (table->getShare()->getCacheKey() == key)

930

{

994

until no one holds a name lock on the table.

995

- if there is no such Table in the name cache, read the table definition

996

and insert it into the cache.

997

We perform all of the above under table::Cache::singleton().mutex() which currently protects

997

We perform all of the above under LOCK_open which currently protects

998

the open cache (also known as table cache) and table definitions stored

999

on disk.

1000

1001

1002

{

1003

table::Cache::singleton().mutex().lock(); /* Lock for FLUSH TABLES for open table */

1003

LOCK_open.lock(); /* Lock for FLUSH TABLES for open table */

1004

1005

1006

Actually try to find the table in the open_cache.

1052

/* Avoid self-deadlocks by detecting self-dependencies. */

1053

if (table->open_placeholder && table->in_use == this)

1054

{

1055

table::Cache::singleton().mutex().unlock();

1055

LOCK_open.unlock();

1056

my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getShare()->getTableName());

1057

return NULL;

1058

}

1085

1086

if (table->in_use != this)

1087

{

1088

/* wait_for_conditionwill unlock table::Cache::singleton().mutex() for us */

1089

wait_for_condition(table::Cache::singleton().mutex(), COND_refresh);

1088

/* wait_for_conditionwill unlock LOCK_open for us */

1089

wait_for_condition(LOCK_open, COND_refresh);

1090

}

1091

else

1092

{

1093

table::Cache::singleton().mutex().unlock();

1093

LOCK_open.unlock();

1094

}

1095

1096

There is a refresh in progress for this table.

1124

1125

if (!(table= table_cache_insert_placeholder(lock_table_identifier)))

1126

{

1127

table::Cache::singleton().mutex().unlock();

1127

LOCK_open.unlock();

1128

return NULL;

1129

}

1130

1135

table->open_placeholder= true;

1136

table->setNext(open_tables);

1137

open_tables= table;

1138

table::Cache::singleton().mutex().unlock();

1138

LOCK_open.unlock();

1139

1140

return table ;

1141

}

1148

table= new_table;

1149

if (new_table == NULL)

1150

{

1151

table::Cache::singleton().mutex().unlock();

1151

LOCK_open.unlock();

1152

return NULL;

1153

}

1154

1156

if (error != 0)

1157

{

1158

delete new_table;

1159

table::Cache::singleton().mutex().unlock();

1159

LOCK_open.unlock();

1160

return NULL;

1161

}

1162

(void)table::Cache::singleton().insert(new_table);

1163

}

1164

}

1165

1166

table::Cache::singleton().mutex().unlock();

1166

LOCK_open.unlock();

1167

}

1168

if (refresh)

1169

{

1222

the strings are used in a loop even after the share may be freed.

1223

1224

1225

void Session::close_data_files_and_morph_locks(const TableIdentifier &identifier)

1225

void Session::close_data_files_and_morph_locks(TableIdentifier &identifier)

1226

{

1227

safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle()); /* Adjust locks at the end of ALTER TABLEL */

1227

safe_mutex_assert_owner(LOCK_open.native_handle()); /* Adjust locks at the end of ALTER TABLEL */

1228

1229

if (lock)

1230

{

1232

If we are not under LOCK TABLES we should have only one table

1233

open and locked so it makes sense to remove the lock at once.

1234

1235

unlockTables(lock);

1235

mysql_unlock_tables(this, lock);

1236

lock= 0;

1237

}

1238

1267

combination when one needs tables to be reopened (for

1268

example see openTablesLock()).

1269

1270

@note One should have lock on table::Cache::singleton().mutex() when calling this.

1270

@note One should have lock on LOCK_open when calling this.

1271

1272

@return false in case of success, true - otherwise.

1273

1284

if (open_tables == NULL)

1285

return false;

1286

1287

safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

1287

safe_mutex_assert_owner(LOCK_open.native_handle());

1288

if (get_locks)

1289

{

1290

1320

DrizzleLock *local_lock;

1321

1322

We should always get these locks. Anyway, we must not go into

1323

wait_for_tables() as it tries to acquire table::Cache::singleton().mutex(), which is

1323

wait_for_tables() as it tries to acquire LOCK_open, which is

1324

already locked.

1325

1326

some_tables_deleted= false;

1327

1328

if ((local_lock= lockTables(tables, (uint32_t) (tables_ptr - tables),

1329

flags, &not_used)))

1328

if ((local_lock= mysql_lock_tables(this, tables, (uint32_t) (tables_ptr - tables),

1329

flags, &not_used)))

1330

{

1331

/* unused */

1332

}

1345

if (get_locks && tables)

1346

delete [] tables;

1347

1348

locking::broadcast_refresh();

1348

broadcast_refresh();

1349

1350

return(error);

1351

}

1392

lock on it. This will also give them a chance to close their

1393

instances of this table.

1394

1395

abortLock(ulcktbl);

1396

removeLock(ulcktbl);

1395

mysql_lock_abort(this, ulcktbl);

1396

mysql_lock_remove(this, ulcktbl);

1397

ulcktbl->lock_count= 0;

1398

}

1399

if ((ulcktbl != table) && ulcktbl->db_stat)

1433

}

1434

}

1435

if (found)

1436

locking::broadcast_refresh();

1436

broadcast_refresh();

1437

}

1438

1439

1445

1446

session->set_proc_info("Waiting for tables");

1447

{

1448

boost_unique_lock_t lock(table::Cache::singleton().mutex());

1449

while (not session->getKilled())

1448

boost_unique_lock_t lock(LOCK_open);

1449

while (!session->killed)

1450

{

1451

session->some_tables_deleted= false;

1452

session->close_old_data_files(false, dropping_tables != 0);

1456

}

1457

COND_refresh.wait(lock);

1458

}

1459

if (session->getKilled())

1459

if (session->killed)

1460

result= true; // aborted

1461

else

1462

{

1502

prev= &session->open_tables;

1503

1504

1505

Note that we need to hold table::Cache::singleton().mutex() while changing the

1505

Note that we need to hold LOCK_open while changing the

1506

open_tables list. Another thread may work on it.

1507

(See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())

1508

Closing a MERGE child before the parent would be fatal if the

1513

next=table->getNext();

1514

if (table->getShare()->getCacheKey() == identifier.getKey())

1515

{

1516

session->removeLock(table);

1516

mysql_lock_remove(session, table);

1517

1518

if (!found)

1519

{

1539

}

1540

*prev=0;

1541

if (found)

1542

locking::broadcast_refresh();

1542

broadcast_refresh();

1543

1544

return(found);

1545

}

1559

if (table->getShare()->getCacheKey() == identifier.getKey())

1560

{

1561

/* If MERGE child, forward lock handling to parent. */

1562

session->abortLock(table);

1562

mysql_lock_abort(session, table);

1563

break;

1564

}

1565

}

1742

1743

assert(lock == 0); // You must lock everything at once

1744

if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)

1745

if (! (lock= lockTables(&table_list->table, 1, 0, &refresh)))

1745

if (! (lock= mysql_lock_tables(this, &table_list->table, 1, 0, &refresh)))

1746

table= 0;

1747

}

1748

1805

*(ptr++)= table->table;

1806

}

1807

1808

if (!(session->lock= session->lockTables(start, (uint32_t) (ptr - start), lock_flag, need_reopen)))

1808

if (!(session->lock= mysql_lock_tables(session, start, (uint32_t) (ptr - start),

1809

lock_flag, need_reopen)))

1809

1810

{

1810

1811

return -1;

1811

1812

}

1834

1835

# Table object

1835

1836

1837

Table *Open_tables_state::open_temporary_table(const TableIdentifier &identifier,

1838

bool link_in_list)

1838

Table *Session::open_temporary_table(TableIdentifier &identifier,

1839

bool link_in_list)

1839

1840

{

1840

1841

assert(identifier.isTmp());

1841

1842

1843

1844

table::Temporary *new_tmp_table= new table::Temporary(identifier.getType(),

1844

1845

identifier,

1845

const_cast<char *>(const_cast<TableIdentifier&>(identifier).getPath().c_str()),

1846

const_cast<char *>(identifier.getPath().c_str()),

1846

1847

static_cast<uint32_t>(identifier.getPath().length()));

1847

1848

if (not new_tmp_table)

1848

1849

return NULL;

1850

1851

1852

First open the share, and then open the table from the share we just opened.

1852

1853

if (new_tmp_table->getMutableShare()->open_table_def(*static_cast<Session *>(this), identifier) ||

1854

new_tmp_table->getMutableShare()->open_table_from_share(static_cast<Session *>(this), identifier, identifier.getTableName().c_str(),

1854

if (new_tmp_table->getMutableShare()->open_table_def(*this, identifier) ||

1855

new_tmp_table->getMutableShare()->open_table_from_share(this, identifier, identifier.getTableName().c_str(),

1855

1856

(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |

1856

1857

HA_GET_INDEX),

1857

1858

ha_open_options,

1919

1920

current_bitmap= table->write_set;

1920

1921

}

1921

1922

//if (current_bitmap->testAndSet(field->position()))

1923

if (current_bitmap->test(field->position()))

1923

//if (current_bitmap->testAndSet(field->field_index))

1924

if (current_bitmap->test(field->field_index))

1924

1925

{

1925

1926

if (session->mark_used_columns == MARK_COLUMNS_WRITE)

1926

1927

session->dup_field= field;

2230

2231

{

2231

2232

Table *table= field_to_set->getTable();

2232

2233

if (session->mark_used_columns == MARK_COLUMNS_READ)

2233

table->setReadSet(field_to_set->position());

2234

table->setReadSet(field_to_set->field_index);

2234

2235

else

2235

table->setWriteSet(field_to_set->position());

2236

table->setWriteSet(field_to_set->field_index);

2236

2237

}

2237

2238

}

2238

2239

}

2904

2905

{

2905

2906

Table *table_1= nj_col_1->table_ref->table;

2906

2907

/* Mark field_1 used for table cache. */

2907

table_1->setReadSet(field_1->position());

2908

table_1->setReadSet(field_1->field_index);

2908

2909

table_1->covering_keys&= field_1->part_of_key;

2909

2910

table_1->merge_keys|= field_1->part_of_key;

2910

2911

}

2912

2913

{

2913

2914

Table *table_2= nj_col_2->table_ref->table;

2914

2915

/* Mark field_2 used for table cache. */

2915

table_2->setReadSet(field_2->position());

2916

table_2->setReadSet(field_2->field_index);

2916

2917

table_2->covering_keys&= field_2->part_of_key;

2917

2918

table_2->merge_keys|= field_2->part_of_key;

2918

2919

}

3658

3659

if ((field= field_iterator.field()))

3659

3660

{

3660

3661

/* Mark fields as used to allow storage engine to optimze access */

3661

field->getTable()->setReadSet(field->position());

3662

field->getTable()->setReadSet(field->field_index);

3662

3663

if (table)

3663

3664

{

3664

3665

table->covering_keys&= field->part_of_key;

3947

3948

3949

plugin::StorageEngine::removeLostTemporaryTables(*session, drizzle_tmpdir.c_str());

3949

3950

3951

session->lockForDelete();

3950

3952

delete session;

3951

3953

3952

3954

return false;

Older »