~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.

665

852

666

853

667

854

void Session::unlink_open_table(Table *find)

668

855

{

669

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

670

Table **prev;

671

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

856

char key[MAX_DBKEY_LENGTH];

857

uint32_t key_length= find->getShare()->getCacheKeySize();

858

Table *list, **prev;

859

safe_mutex_assert_owner(LOCK_open.native_handle());

672

860

861

memcpy(key, &find->getMutableShare()->getCacheKey()[0], key_length);

673

862

674

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

863

Note that we need to hold LOCK_open while changing the

675

864

open_tables list. Another thread may work on it.

676

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

865

(See: remove_table_from_cache(), mysql_wait_completed_table())

677

866

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

678

867

other thread tries to abort the MERGE lock in between.

679

868

680

869

for (prev= &open_tables; *prev; )

681

870

{

682

Table *list= *prev;

871

list= *prev;

683

872

684

if (list->getShare()->getCacheKey() == find_key)

873

if (list->getShare()->getCacheKeySize() == key_length &&

874

not memcmp(&list->getShare()->getCacheKey()[0], key, key_length))

685

875

{

686

876

/* Remove table from open_tables list. */

687

877

*prev= list->getNext();

688

878

689

879

/* Close table. */

690

table::remove_table(static_cast<table::Concurrent *>(list));

880

remove_table(list);

691

881

}

692

882

else

693

883

{

697

887

}

698

888

699

889

// Notify any 'refresh' threads

700

locking::broadcast_refresh();

890

broadcast_refresh();

701

891

}

702

892

703

893

720

910

table that was locked with LOCK TABLES.

721

911

722

912

723

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

913

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

724

914

{

725

915

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

726

916

{

728

918

}

729

919

else

730

920

{

731

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

921

boost::mutex::scoped_lock scoped_lock(LOCK_open); /* Close and drop a table (AUX routine) */

732

922

733

923

unlink_open_table() also tells threads waiting for refresh or close

734

924

that something has happened.

735

925

736

926

unlink_open_table(table);

737

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

927

quick_rm_table(*this, identifier);

738

928

}

739

929

}

740

930

750

940

cond Condition to wait for

751

941

752

942

753

void Session::wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond)

943

void Session::wait_for_condition(boost::mutex &mutex, boost::condition_variable &cond)

754

944

{

755

945

/* Wait until the current table is up to date */

756

946

const char *saved_proc_info;

769

959

condition variables that are guranteed to not disapper (freed) even if this

770

960

mutex is unlocked

771

961

772

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

773

if (not getKilled())

962

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

963

if (not killed)

774

964

{

775

965

cond.wait(scopedLock);

776

966

}

777

967

}

778

boost_unique_lock_t mysys_scopedLock(mysys_var->mutex);

968

boost::mutex::scoped_lock (mysys_var->mutex);

779

969

mysys_var->current_mutex= 0;

780

970

mysys_var->current_cond= 0;

781

971

set_proc_info(saved_proc_info);

782

972

}

783

973

784

974

975

976

Open table which is already name-locked by this thread.

977

978

SYNOPSIS

979

reopen_name_locked_table()

980

session Thread handle

981

table_list TableList object for table to be open, TableList::table

982

member should point to Table object which was used for

983

name-locking.

984

link_in true - if Table object for table to be opened should be

985

linked into Session::open_tables list.

986

false - placeholder used for name-locking is already in

987

this list so we only need to preserve Table::next

988

pointer.

989

990

NOTE

991

This function assumes that its caller already acquired LOCK_open mutex.

992

993

RETURN VALUE

994

false - Success

995

true - Error

996

997

998

bool Session::reopen_name_locked_table(TableList* table_list, bool link_in)

999

{

1000

Table *table= table_list->table;

1001

TableShare *share;

1002

char *table_name= table_list->table_name;

1003

Table orig_table;

1004

1005

safe_mutex_assert_owner(LOCK_open.native_handle());

1006

1007

if (killed || !table)

1008

return true;

1009

1010

orig_table= *table;

1011

1012

TableIdentifier identifier(table_list->db, table_list->table_name);

1013

if (open_unireg_entry(this, table, table_name, identifier))

1014

{

1015

table->intern_close_table();

1016

1017

If there was an error during opening of table (for example if it

1018

does not exist) '*table' object can be wiped out. To be able

1019

properly release name-lock in this case we should restore this

1020

object to its original state.

1021

1022

*table= orig_table;

1023

return true;

1024

}

1025

1026

share= table->getMutableShare();

1027

1028

We want to prevent other connections from opening this table until end

1029

of statement as it is likely that modifications of table's metadata are

1030

not yet finished (for example CREATE TRIGGER have to change .TRG cursor,

1031

or we might want to drop table if CREATE TABLE ... SELECT fails).

1032

This also allows us to assume that no other connection will sneak in

1033

before we will get table-level lock on this table.

1034

1035

share->resetVersion();

1036

table->in_use = this;

1037

1038

if (link_in)

1039

{

1040

table->setNext(open_tables);

1041

open_tables= table;

1042

}

1043

else

1044

{

1045

1046

Table object should be already in Session::open_tables list so we just

1047

need to set Table::next correctly.

1048

1049

table->setNext(orig_table.getNext());

1050

}

1051

1052

table->tablenr= current_tablenr++;

1053

table->used_fields= 0;

1054

table->const_table= 0;

1055

table->null_row= false;

1056

table->maybe_null= false;

1057

table->force_index= false;

1058

table->status= STATUS_NO_RECORD;

1059

1060

return false;

1061

}

1062

1063

785

1064

/**

786

1065

Create and insert into table cache placeholder for table

787

1066

which will prevent its opening (or creation) (a.k.a lock

795

1074

case of failure.

796

1075

797

1076

798

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

1077

Table *Session::table_cache_insert_placeholder(const char *db_name, const char *table_name)

799

1078

{

800

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

1079

safe_mutex_assert_owner(LOCK_open.native_handle());

801

1080

802

1081

803

1082

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

804

1083

805

identifier::Table identifier(arg.getSchemaName(), arg.getTableName(), message::Table::INTERNAL);

806

table::Placeholder *table= new table::Placeholder(this, identifier);

1084

TableIdentifier identifier(db_name, table_name, message::Table::INTERNAL);

1085

TablePlaceholder *table= new TablePlaceholder(this, identifier);

807

1086

808

if (not table::Cache::singleton().insert(table))

1087

if (not add_table(table))

809

1088

{

810

1089

delete table;

811

1090

837

1116

@retval true Error occured (OOM)

838

1117

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

839

1118

840

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

1119

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

841

1120

{

842

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

843

844

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) */

845

846

table::CacheMap::iterator iter;

847

848

iter= table::getCache().find(key);

849

850

if (iter != table::getCache().end())

1121

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

1122

1123

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

1124

1125

TableOpenCache::iterator iter;

1126

1127

iter= get_open_cache().find(key);

1128

1129

if (iter != get_open_cache().end())

851

1130

{

852

1131

*table= 0;

853

1132

return false;

854

1133

}

855

1134

856

if (not (*table= table_cache_insert_placeholder(identifier)))

1135

if (not (*table= table_cache_insert_placeholder(identifier.getSchemaName().c_str(), identifier.getTableName().c_str())))

857

1136

{

858

1137

return true;

859

1138

}

913

1192

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

914

1193

return NULL;

915

1194

916

if (getKilled())

1195

if (killed)

917

1196

return NULL;

918

1197

919

identifier::Table identifier(table_list->getSchemaName(), table_list->getTableName());

920

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

921

table::CacheRange ppp;

1198

TableIdentifier identifier(table_list->db, table_list->table_name);

1199

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

1200

TableOpenCacheRange ppp;

922

1201

923

1202

924

1203

Unless requested otherwise, try to resolve this table in the list

928

1207

TODO -> move this block into a separate function.

929

1208

930

1209

bool reset= false;

931

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

1210

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

932

1211

{

933

1212

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

934

1213

{

953

1232

{

954

1233

if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)

955

1234

{

956

my_error(ER_TABLE_UNKNOWN, identifier);

1235

my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);

957

1236

return NULL;

958

1237

}

959

1238

998

1277

until no one holds a name lock on the table.

999

1278

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

1000

1279

and insert it into the cache.

1001

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

1280

We perform all of the above under LOCK_open which currently protects

1002

1281

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

1003

1282

on disk.

1004

1283

1005

1284

1006

1285

{

1007

boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex());

1286

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

1008

1287

1009

1288

1010

1289

Actually try to find the table in the open_cache.

1016

1295

an implicit "pending locks queue" - see

1017

1296

wait_for_locked_table_names for details.

1018

1297

1019

ppp= table::getCache().equal_range(key);

1298

ppp= get_open_cache().equal_range(key);

1020

1299

1021

1300

table= NULL;

1022

for (table::CacheMap::const_iterator iter= ppp.first;

1301

for (TableOpenCache::const_iterator iter= ppp.first;

1023

1302

iter != ppp.second; ++iter, table= NULL)

1024

1303

{

1025

1304

table= (*iter).second;

1056

1335

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

1057

1336

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

1058

1337

{

1059

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

1338

LOCK_open.unlock();

1339

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

1060

1340

return NULL;

1061

1341

}

1062

1342

1088

1368

1089

1369

if (table->in_use != this)

1090

1370

{

1091

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

1092

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

1093

scopedLock.release();

1371

/* wait_for_conditionwill unlock LOCK_open for us */

1372

wait_for_condition(LOCK_open, COND_refresh);

1094

1373

}

1095

1374

else

1096

1375

{

1097

scopedLock.unlock();

1376

LOCK_open.unlock();

1098

1377

}

1099

1100

1378

1101

1379

There is a refresh in progress for this table.

1102

1380

Signal the caller that it has to try again.

1103

1381

1104

1382

if (refresh)

1105

1383

*refresh= true;

1106

1107

1384

return NULL;

1108

1385

}

1109

1386

}

1110

1111

1387

if (table)

1112

1388

{

1113

table::getUnused().unlink(static_cast<table::Concurrent *>(table));

1389

unused_tables.unlink(table);

1114

1390

table->in_use= this;

1115

1391

}

1116

1392

else

1118

1394

/* Insert a new Table instance into the open cache */

1119

1395

int error;

1120

1396

/* Free cache if too big */

1121

table::getUnused().cull();

1397

unused_tables.cull();

1122

1398

1123

1399

if (table_list->isCreate())

1124

1400

{

1125

identifier::Table lock_table_identifier(table_list->getSchemaName(), table_list->getTableName(), message::Table::STANDARD);

1401

TableIdentifier lock_table_identifier(table_list->db, table_list->table_name, message::Table::STANDARD);

1126

1402

1127

1403

if (not plugin::StorageEngine::doesTableExist(*this, lock_table_identifier))

1128

1404

{

1129

1405

1130

1406

Table to be created, so we need to create placeholder in table-cache.

1131

1407

1132

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

1408

if (!(table= table_cache_insert_placeholder(table_list->db, table_list->table_name)))

1133

1409

{

1410

LOCK_open.unlock();

1134

1411

return NULL;

1135

1412

}

1136

1413

1141

1418

table->open_placeholder= true;

1142

1419

table->setNext(open_tables);

1143

1420

open_tables= table;

1421

LOCK_open.unlock();

1144

1422

1145

1423

return table ;

1146

1424

}

1148

1426

}

1149

1427

1150

1428

/* make a new table */

1429

table= new Table;

1430

if (table == NULL)

1151

1431

{

1152

table::Concurrent *new_table= new table::Concurrent;

1153

table= new_table;

1154

if (new_table == NULL)

1155

{

1156

return NULL;

1157

}

1432

LOCK_open.unlock();

1433

return NULL;

1434

}

1158

1435

1159

error= new_table->open_unireg_entry(this, alias, identifier);

1160

if (error != 0)

1161

{

1162

delete new_table;

1163

return NULL;

1164

}

1165

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

1436

error= open_unireg_entry(this, table, alias, identifier);

1437

if (error != 0)

1438

{

1439

delete table;

1440

LOCK_open.unlock();

1441

return NULL;

1166

1442

}

1443

(void)add_table(table);

1167

1444

}

1445

1446

LOCK_open.unlock();

1168

1447

}

1169

1170

1448

if (refresh)

1171

1449

{

1172

1450

table->setNext(open_tables); /* Link into simple list */

1177

1455

}

1178

1456

assert(table->getShare()->getTableCount() > 0 || table->getShare()->getType() != message::Table::STANDARD);

1179

1457

1458

if (lex->need_correct_ident())

1459

table->alias_name_used= my_strcasecmp(table_alias_charset,

1460

table->getMutableShare()->getTableName(), alias);

1180

1461

/* Fix alias if table name changes */

1181

1462

if (strcmp(table->getAlias(), alias))

1182

1463

{

1183

table->setAlias(alias);

1464

uint32_t length=(uint32_t) strlen(alias)+1;

1465

table->alias= (char*) realloc((char*) table->alias, length);

1466

memcpy((void*) table->alias, alias, length);

1184

1467

}

1185

1468

1186

1469

/* These variables are also set in reopen_table() */

1224

1507

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

1225

1508

1226

1509

1227

void Session::close_data_files_and_morph_locks(const identifier::Table &identifier)

1510

void Session::close_data_files_and_morph_locks(TableIdentifier &identifier)

1228

1511

{

1229

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

1512

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

1230

1513

1231

1514

if (lock)

1232

1515

{

1234

1517

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

1235

1518

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

1236

1519

1237

unlockTables(lock);

1520

mysql_unlock_tables(this, lock);

1238

1521

lock= 0;

1239

1522

}

1240

1523

1269

1552

combination when one needs tables to be reopened (for

1270

1553

example see openTablesLock()).

1271

1554

1272

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

1555

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

1273

1556

1274

1557

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

1275

1558

1276

1559

1277

bool Session::reopen_tables()

1560

bool Session::reopen_tables(bool get_locks, bool)

1278

1561

{

1279

1562

Table *table,*next,**prev;

1280

Table **tables= 0; // For locks

1281

Table **tables_ptr= 0; // For locks

1282

bool error= false;

1563

Table **tables,**tables_ptr; // For locks

1564

bool error=0, not_used;

1283

1565

const uint32_t flags= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN |

1284

1566

DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |

1285

1567

DRIZZLE_LOCK_IGNORE_FLUSH;

1287

1569

if (open_tables == NULL)

1288

1570

return false;

1289

1571

1290

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

1572

safe_mutex_assert_owner(LOCK_open.native_handle());

1573

if (get_locks)

1291

1574

{

1292

1575

1293

1576

The ptr is checked later

1301

1584

}

1302

1585

tables= new Table *[opens];

1303

1586

}

1304

1587

else

1588

{

1589

tables= &open_tables;

1590

}

1305

1591

tables_ptr =tables;

1306

1592

1307

1593

prev= &open_tables;

1310

1596

next= table->getNext();

1311

1597

1312

1598

my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());

1313

table::remove_table(static_cast<table::Concurrent *>(table));

1599

remove_table(table);

1314

1600

error= 1;

1315

1601

}

1316

1602

*prev=0;

1317

1318

1603

if (tables != tables_ptr) // Should we get back old locks

1319

1604

{

1320

1605

DrizzleLock *local_lock;

1321

1606

1322

1607

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

1608

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

1324

1609

already locked.

1325

1610

1326

1611

some_tables_deleted= false;

1327

1612

1328

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

1613

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

1614

flags, &not_used)))

1329

1615

{

1330

1616

/* unused */

1331

1617

}

1341

1627

}

1342

1628

}

1343

1629

1344

delete [] tables;

1345

1346

locking::broadcast_refresh();

1347

1348

return error;

1630

if (get_locks && tables)

1631

delete [] tables;

1632

1633

broadcast_refresh();

1634

1635

return(error);

1349

1636

}

1350

1637

1351

1638

1376

1663

1377

1664

if (table->needs_reopen_or_name_lock())

1378

1665

{

1379

found= true;

1666

found=1;

1380

1667

if (table->db_stat)

1381

1668

{

1382

1669

if (morph_locks)

1390

1677

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

1391

1678

instances of this table.

1392

1679

1393

abortLock(ulcktbl);

1394

removeLock(ulcktbl);

1680

mysql_lock_abort(this, ulcktbl);

1681

mysql_lock_remove(this, ulcktbl);

1395

1682

ulcktbl->lock_count= 0;

1396

1683

}

1397

1684

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

1431

1718

}

1432

1719

}

1433

1720

if (found)

1434

locking::broadcast_refresh();

1721

broadcast_refresh();

1722

}

1723

1724

1725

1726

Wait until all threads has closed the tables in the list

1727

We have also to wait if there is thread that has a lock on this table even

1728

if the table is closed

1729

1730

1731

bool table_is_used(Table *table, bool wait_for_name_lock)

1732

{

1733

1734

{

1735

const TableIdentifier::Key &key(table->getShare()->getCacheKey());

1736

1737

TableOpenCacheRange ppp;

1738

ppp= get_open_cache().equal_range(key);

1739

1740

for (TableOpenCache::const_iterator iter= ppp.first;

1741

iter != ppp.second; ++iter)

1742

{

1743

Table *search= (*iter).second;

1744

if (search->in_use == table->in_use)

1745

continue; // Name locked by this thread

1746

1747

We can't use the table under any of the following conditions:

1748

- There is an name lock on it (Table is to be deleted or altered)

1749

- If we are in flush table and we didn't execute the flush

1750

- If the table engine is open and it's an old version

1751

(We must wait until all engines are shut down to use the table)

1752

1753

if ( (search->locked_by_name && wait_for_name_lock) ||

1754

(search->is_name_opened() && search->needs_reopen_or_name_lock()))

1755

return 1;

1756

}

1757

} while ((table=table->getNext()));

1758

return 0;

1759

}

1760

1761

1762

/* Wait until all used tables are refreshed */

1763

1764

bool wait_for_tables(Session *session)

1765

{

1766

bool result;

1767

1768

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

1769

{

1770

boost::mutex::scoped_lock lock(LOCK_open);

1771

while (!session->killed)

1772

{

1773

session->some_tables_deleted= false;

1774

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

1775

if (!table_is_used(session->open_tables, 1))

1776

break;

1777

COND_refresh.wait(lock);

1778

}

1779

if (session->killed)

1780

result= true; // aborted

1781

else

1782

{

1783

/* Now we can open all tables without any interference */

1784

session->set_proc_info("Reopen tables");

1785

session->version= refresh_version;

1786

result= session->reopen_tables(false, false);

1787

}

1788

}

1789

session->set_proc_info(0);

1790

1791

return result;

1435

1792

}

1436

1793

1437

1794

1459

1816

1460

1817

1461

1818

1462

Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier)

1819

Table *drop_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)

1463

1820

{

1464

1821

Table *table,*next,**prev, *found= 0;

1465

1822

prev= &session->open_tables;

1466

1823

1467

1824

1468

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

1825

Note that we need to hold LOCK_open while changing the

1469

1826

open_tables list. Another thread may work on it.

1470

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

1827

(See: remove_table_from_cache(), mysql_wait_completed_table())

1471

1828

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

1472

1829

other thread tries to abort the MERGE lock in between.

1473

1830

1476

1833

next=table->getNext();

1477

1834

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

1478

1835

{

1479

session->removeLock(table);

1836

mysql_lock_remove(session, table);

1480

1837

1481

1838

if (!found)

1482

1839

{

1491

1848

else

1492

1849

{

1493

1850

/* We already have a name lock, remove copy */

1494

table::remove_table(static_cast<table::Concurrent *>(table));

1851

remove_table(table);

1495

1852

}

1496

1853

}

1497

1854

else

1501

1858

}

1502

1859

}

1503

1860

*prev=0;

1504

1505

1861

if (found)

1506

locking::broadcast_refresh();

1862

broadcast_refresh();

1507

1863

1508

return found;

1864

return(found);

1509

1865

}

1510

1866

1511

1867

1515

1871

other threads trying to get the lock.

1516

1872

1517

1873

1518

void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier)

1874

void abort_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)

1519

1875

{

1520

1876

Table *table;

1521

1877

for (table= session->open_tables; table ; table= table->getNext())

1523

1879

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

1524

1880

{

1525

1881

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

1526

session->abortLock(table);

1527

assert(0);

1882

mysql_lock_abort(session, table);

1528

1883

break;

1529

1884

}

1530

1885

}

1531

1886

}

1532

1887

1888

1889

Load a table definition from cursor and open unireg table

1890

1891

SYNOPSIS

1892

open_unireg_entry()

1893

session Thread handle

1894

entry Store open table definition here

1895

table_list TableList with db, table_name

1896

alias Alias name

1897

cache_key Key for share_cache

1898

cache_key_length length of cache_key

1899

1900

NOTES

1901

Extra argument for open is taken from session->open_options

1902

One must have a lock on LOCK_open when calling this function

1903

1904

RETURN

1905

0 ok

1906

# Error

1907

1908

1909

static int open_unireg_entry(Session *session,

1910

Table *entry,

1911

const char *alias,

1912

TableIdentifier &identifier)

1913

{

1914

int error;

1915

TableShare *share;

1916

uint32_t discover_retry_count= 0;

1917

1918

safe_mutex_assert_owner(LOCK_open.native_handle());

1919

retry:

1920

if (not (share= TableShare::getShareCreate(session,

1921

identifier,

1922

&error)))

1923

return 1;

1924

1925

while ((error= share->open_table_from_share(session,

1926

identifier,

1927

alias,

1928

(uint32_t) (HA_OPEN_KEYFILE |

1929

HA_OPEN_RNDFILE |

1930

HA_GET_INDEX |

1931

HA_TRY_READ_ONLY),

1932

session->open_options, *entry)))

1933

{

1934

if (error == 7) // Table def changed

1935

{

1936

share->resetVersion(); // Mark share as old

1937

if (discover_retry_count++) // Retry once

1938

goto err;

1939

1940

1941

TODO->

1942

Here we should wait until all threads has released the table.

1943

For now we do one retry. This may cause a deadlock if there

1944

is other threads waiting for other tables used by this thread.

1945

1946

Proper fix would be to if the second retry failed:

1947

- Mark that table def changed

1948

- Return from open table

1949

- Close all tables used by this thread

1950

- Start waiting that the share is released

1951

- Retry by opening all tables again

1952

1953

1954

1955

TO BE FIXED

1956

To avoid deadlock, only wait for release if no one else is

1957

using the share.

1958

1959

if (share->getTableCount() != 1)

1960

goto err;

1961

/* Free share and wait until it's released by all threads */

1962

TableShare::release(share);

1963

1964

if (!session->killed)

1965

{

1966

drizzle_reset_errors(session, 1); // Clear warnings

1967

session->clear_error(); // Clear error message

1968

goto retry;

1969

}

1970

return 1;

1971

}

1972

1973

goto err;

1974

}

1975

1976

return 0;

1977

1978

err:

1979

TableShare::release(share);

1980

1981

return 1;

1982

}

1983

1533

1984

1534

1985

1535

1986

Open all tables in list

1597

2048

* to see if it exists so that an unauthorized user cannot phish for

1598

2049

* table/schema information via error messages

1599

2050

1600

identifier::Table the_table(tables->getSchemaName(), tables->getTableName());

1601

if (not plugin::Authorization::isAuthorized(user(), the_table))

2051

TableIdentifier the_table(tables->db, tables->table_name);

2052

if (not plugin::Authorization::isAuthorized(getSecurityContext(),

2053

the_table))

1602

2054

{

1603

2055

result= -1; // Fatal error

1604

2056

break;

1695

2147

1696

2148

set_proc_info("Opening table");

1697

2149

current_tablenr= 0;

1698

while (!(table= openTable(table_list, &refresh)) && refresh) ;

2150

while (!(table= openTable(table_list, &refresh)) &&

2151

refresh)

2152

;

1699

2153

1700

2154

if (table)

1701

2155

{

1704

2158

1705

2159

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

1706

2160

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

1707

{

1708

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

1709

table= NULL;

1710

}

2161

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

2162

table= 0;

1711

2163

}

1712

2164

1713

2165

set_proc_info(0);

1761

2213

Table **start,**ptr;

1762

2214

uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;

1763

2215

1764

if (!(ptr=start=(Table**) session->getMemRoot()->allocate(sizeof(Table*)*count)))

2216

if (!(ptr=start=(Table**) session->alloc(sizeof(Table*)*count)))

1765

2217

return -1;

1766

1767

2218

for (table= tables; table; table= table->next_global)

1768

2219

{

1769

2220

if (!table->placeholder())

1770

2221

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

1771

2222

}

1772

2223

1773

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

2224

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

2225

lock_flag, need_reopen)))

1774

2226

{

1775

2227

return -1;

1776

2228

}

1799

2251

# Table object

1800

2252

1801

2253

1802

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

1803

bool link_in_list)

2254

Table *Session::open_temporary_table(TableIdentifier &identifier,

2255

bool link_in_list)

1804

2256

{

2257

TableShare *share;

2258

1805

2259

assert(identifier.isTmp());

1806

1807

1808

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

1809

identifier,

1810

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

1811

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

2260

share= new TableShare(identifier.getType(),

2261

identifier,

2262

const_cast<char *>(identifier.getPath().c_str()), static_cast<uint32_t>(identifier.getPath().length()));

2263

2264

2265

Table *new_tmp_table= new Table;

1812

2266

if (not new_tmp_table)

1813

2267

return NULL;

1814

2268

1815

2269

1816

2270

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

1817

2271

1818

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

1819

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

1820

(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |

1821

HA_GET_INDEX),

1822

ha_open_options,

1823

*new_tmp_table))

2272

if (share->open_table_def(*this, identifier) ||

2273

share->open_table_from_share(this, identifier, identifier.getTableName().c_str(),

2274

(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |

2275

HA_GET_INDEX),

2276

ha_open_options,

2277

*new_tmp_table))

1824

2278

{

1825

2279

/* No need to lock share->mutex as this is not needed for tmp tables */

1826

delete new_tmp_table->getMutableShare();

2280

delete share;

1827

2281

delete new_tmp_table;

1828

2282

1829

2283

return 0;

1865

2319

{

1866

2320

if (session->mark_used_columns != MARK_COLUMNS_NONE)

1867

2321

{

1868

boost::dynamic_bitset<> *current_bitmap= NULL;

2322

MyBitmap *current_bitmap, *other_bitmap;

1869

2323

1870

2324

1871

2325

We always want to register the used keys, as the column bitmap may have

1878

2332

if (session->mark_used_columns == MARK_COLUMNS_READ)

1879

2333

{

1880

2334

current_bitmap= table->read_set;

2335

other_bitmap= table->write_set;

1881

2336

}

1882

2337

else

1883

2338

{

1884

2339

current_bitmap= table->write_set;

2340

other_bitmap= table->read_set;

1885

2341

}

1886

2342

1887

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

1888

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

2343

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

1889

2344

{

1890

2345

if (session->mark_used_columns == MARK_COLUMNS_WRITE)

1891

2346

session->dup_field= field;

1944

2399

{

1945

2400

if (nj_col)

1946

2401

{

1947

my_error(ER_NON_UNIQ_ERROR, MYF(0), name, session->where());

2402

my_error(ER_NON_UNIQ_ERROR, MYF(0), name, session->where);

1948

2403

return NULL;

1949

2404

}

1950

2405

nj_col= curr_nj_col;

2119

2574

2120

2575

table_name && table_name[0] &&

2121

2576

(my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||

2122

(db_name && db_name[0] && table_list->getSchemaName() && table_list->getSchemaName()[0] &&

2123

strcmp(db_name, table_list->getSchemaName()))))

2577

(db_name && db_name[0] && table_list->db && table_list->db[0] &&

2578

strcmp(db_name, table_list->db))))

2124

2579

return 0;

2125

2580

2126

2581

*actual_table= NULL;

2195

2650

{

2196

2651

Table *table= field_to_set->getTable();

2197

2652

if (session->mark_used_columns == MARK_COLUMNS_READ)

2198

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

2653

table->setReadSet(field_to_set->field_index);

2199

2654

else

2200

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

2655

table->setWriteSet(field_to_set->field_index);

2201

2656

}

2202

2657

}

2203

2658

}

2341

2796

2342

2797

item->cached_table= found ? 0 : actual_table;

2343

2798

2344

assert(session->where());

2799

assert(session->where);

2345

2800

2346

2801

If we found a fully qualified field we return it directly as it can't

2347

2802

have duplicates.

2354

2809

if (report_error == REPORT_ALL_ERRORS ||

2355

2810

report_error == IGNORE_EXCEPT_NON_UNIQUE)

2356

2811

my_error(ER_NON_UNIQ_ERROR, MYF(0),

2357

table_name ? item->full_name() : name, session->where());

2812

table_name ? item->full_name() : name, session->where);

2358

2813

return (Field*) 0;

2359

2814

}

2360

2815

found= cur_field;

2387

2842

strcat(buff, table_name);

2388

2843

table_name=buff;

2389

2844

}

2390

my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, session->where());

2845

my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, session->where);

2391

2846

}

2392

2847

else

2393

2848

{

2394

2849

if (report_error == REPORT_ALL_ERRORS ||

2395

2850

report_error == REPORT_EXCEPT_NON_UNIQUE)

2396

my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), session->where());

2851

my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), session->where);

2397

2852

else

2398

2853

found= not_found_field;

2399

2854

}

2520

2975

2521

2976

if (report_error != IGNORE_ERRORS)

2522

2977

my_error(ER_NON_UNIQ_ERROR, MYF(0),

2523

find->full_name(), session->where());

2978

find->full_name(), session->where);

2524

2979

return (Item**) 0;

2525

2980

}

2526

2981

found_unaliased= li.ref();

2551

3006

continue; // Same field twice

2552

3007

if (report_error != IGNORE_ERRORS)

2553

3008

my_error(ER_NON_UNIQ_ERROR, MYF(0),

2554

find->full_name(), session->where());

3009

find->full_name(), session->where);

2555

3010

return (Item**) 0;

2556

3011

}

2557

3012

found= li.ref();

2603

3058

{

2604

3059

if (report_error != IGNORE_ERRORS)

2605

3060

my_error(ER_NON_UNIQ_ERROR, MYF(0),

2606

find->full_name(), session->where());

3061

find->full_name(), session->where);

2607

3062

return (Item **) 0;

2608

3063

}

2609

3064

if (found_unaliased)

2619

3074

{

2620

3075

if (report_error == REPORT_ALL_ERRORS)

2621

3076

my_error(ER_BAD_FIELD_ERROR, MYF(0),

2622

find->full_name(), session->where());

3077

find->full_name(), session->where);

2623

3078

return (Item **) 0;

2624

3079

}

2625

3080

else

2753

3208

/* true if field_name_1 is a member of using_fields */

2754

3209

bool is_using_column_1;

2755

3210

if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))

2756

return(result);

3211

goto err;

2757

3212

field_name_1= nj_col_1->name();

2758

3213

is_using_column_1= using_fields &&

2759

3214

test_if_string_in_list(field_name_1, using_fields);

2771

3226

Natural_join_column *cur_nj_col_2;

2772

3227

const char *cur_field_name_2;

2773

3228

if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))

2774

return(result);

3229

goto err;

2775

3230

cur_field_name_2= cur_nj_col_2->name();

2776

3231

2777

3232

2790

3245

if (cur_nj_col_2->is_common ||

2791

3246

(found && (!using_fields || is_using_column_1)))

2792

3247

{

2793

my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, session->where());

2794

return(result);

3248

my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, session->where);

3249

goto err;

2795

3250

}

2796

3251

nj_col_2= cur_nj_col_2;

2797

3252

found= true;

2824

3279

Item_func_eq *eq_cond;

2825

3280

2826

3281

if (!item_1 || !item_2)

2827

return(result); // out of memory

3282

goto err; // out of memory

2828

3283

2829

3284

2830

3285

In the case of no_wrap_view_item == 0, the created items must be

2849

3304

2850

3305

if (set_new_item_local_context(session, item_ident_1, nj_col_1->table_ref) ||

2851

3306

set_new_item_local_context(session, item_ident_2, nj_col_2->table_ref))

2852

return(result);

3307

goto err;

2853

3308

2854

3309

if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))

2855

return(result); /* Out of memory. */

3310

goto err; /* Out of memory. */

2856

3311

2857

3312

2858

3313

Add the new equi-join condition to the ON clause. Notice that

2869

3324

{

2870

3325

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

2871

3326

/* Mark field_1 used for table cache. */

2872

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

3327

table_1->setReadSet(field_1->field_index);

2873

3328

table_1->covering_keys&= field_1->part_of_key;

2874

3329

table_1->merge_keys|= field_1->part_of_key;

2875

3330

}

2877

3332

{

2878

3333

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

2879

3334

/* Mark field_2 used for table cache. */

2880

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

3335

table_2->setReadSet(field_2->field_index);

2881

3336

table_2->covering_keys&= field_2->part_of_key;

2882

3337

table_2->merge_keys|= field_2->part_of_key;

2883

3338

}

2898

3353

2899

3354

result= false;

2900

3355

3356

err:

2901

3357

return(result);

2902

3358

}

2903

3359

2955

3411

2956

3412

if (!(non_join_columns= new List<Natural_join_column>) ||

2957

3413

!(natural_using_join->join_columns= new List<Natural_join_column>))

2958

{

2959

return(result);

2960

}

3414

goto err;

2961

3415

2962

3416

/* Append the columns of the first join operand. */

2963

3417

for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())

2995

3449

if (!(common_field= it++))

2996

3450

{

2997

3451

my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,

2998

session->where());

2999

return(result);

3452

session->where);

3453

goto err;

3000

3454

}

3001

3455

if (!my_strcasecmp(system_charset_info,

3002

3456

common_field->name(), using_field_name_ptr))

3024

3478

3025

3479

result= false;

3026

3480

3481

err:

3027

3482

return(result);

3028

3483

}

3029

3484

3109

3564

if (cur_table_ref->getNestedJoin() &&

3110

3565

store_top_level_join_columns(session, cur_table_ref,

3111

3566

real_left_neighbor, real_right_neighbor))

3112

return(result);

3567

goto err;

3113

3568

same_level_right_neighbor= cur_table_ref;

3114

3569

}

3115

3570

}

3141

3596

std::swap(table_ref_1, table_ref_2);

3142

3597

if (mark_common_columns(session, table_ref_1, table_ref_2,

3143

3598

using_fields, &found_using_fields))

3144

return(result);

3599

goto err;

3145

3600

3146

3601

3147

3602

Swap the join operands back, so that we pick the columns of the second

3153

3608

if (store_natural_using_join_columns(session, table_ref, table_ref_1,

3154

3609

table_ref_2, using_fields,

3155

3610

found_using_fields))

3156

return(result);

3611

goto err;

3157

3612

3158

3613

3159

3614

Change NATURAL JOIN to JOIN ... ON. We do this for both operands

3186

3641

}

3187

3642

result= false; /* All is OK. */

3188

3643

3644

err:

3189

3645

return(result);

3190

3646

}

3191

3647

3218

3674

List<TableList> *from_clause,

3219

3675

Name_resolution_context *context)

3220

3676

{

3221

session->setWhere("from clause");

3677

session->where= "from clause";

3222

3678

if (from_clause->elements == 0)

3223

3679

return false; /* We come here in the case of UNIONs. */

3224

3680

3339

3795

session->mark_used_columns= mark_used_columns;

3340

3796

if (allow_sum_func)

3341

3797

session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;

3342

session->setWhere(Session::DEFAULT_WHERE);

3798

session->where= Session::DEFAULT_WHERE;

3343

3799

save_is_item_list_lookup= session->lex->current_select->is_item_list_lookup;

3344

3800

session->lex->current_select->is_item_list_lookup= 0;

3345

3801

3351

3807

There is other way to solve problem: fill array with pointers to list,

3352

3808

but it will be slower.

3353

3809

3354

TODO-> remove it when (if) we made one list for allfields and ref_pointer_array

3810

TODO: remove it when (if) we made one list for allfields and

3811

ref_pointer_array

3355

3812

3356

3813

if (ref_pointer_array)

3357

{

3358

3814

memset(ref_pointer_array, 0, sizeof(Item *) * fields.elements);

3359

}

3360

3815

3361

3816

Item **ref= ref_pointer_array;

3362

3817

session->lex->current_select->cur_pos_in_select_list= 0;

3588

4043

assert(tables->is_leaf_for_name_resolution());

3589

4044

3590

4045

if ((table_name && my_strcasecmp(table_alias_charset, table_name, tables->alias)) ||

3591

(db_name && my_strcasecmp(system_charset_info, tables->getSchemaName(),db_name)))

4046

(db_name && strcasecmp(tables->db,db_name)))

3592

4047

continue;

3593

4048

3594

4049

3624

4079

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

3625

4080

{

3626

4081

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

3627

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

4082

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

3628

4083

if (table)

3629

4084

{

3630

4085

table->covering_keys&= field->part_of_key;

3652

4107

}

3653

4108

}

3654

4109

else

3655

{

3656

4110

session->used_tables|= item->used_tables();

3657

}

3658

3659

4111

session->lex->current_select->cur_pos_in_select_list++;

3660

4112

}

3661

4113

3675

4127

qualified '*', and all columns were coalesced, we have to give a more

3676

4128

meaningful message than ER_BAD_TABLE_ERROR.

3677

4129

3678

if (not table_name)

3679

{

4130

if (!table_name)

3680

4131

my_message(ER_NO_TABLES_USED, ER(ER_NO_TABLES_USED), MYF(0));

3681

}

3682

4132

else

3683

{

3684

4133

my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);

3685

}

3686

4134

3687

4135

return true;

3688

4136

}

3731

4179

session->session_marker= (void*)1;

3732

4180

if (*conds)

3733

4181

{

3734

session->setWhere("where clause");

4182

session->where="where clause";

3735

4183

if ((!(*conds)->fixed && (*conds)->fix_fields(session, conds)) ||

3736

4184

(*conds)->check_cols(1))

3737

4185

goto err_no_arena;

3753

4201

{

3754

4202

/* Make a join an a expression */

3755

4203

session->session_marker= (void*)embedded;

3756

session->setWhere("on clause");

4204

session->where="on clause";

3757

4205

if ((!embedded->on_expr->fixed && embedded->on_expr->fix_fields(session, &embedded->on_expr)) ||

3758

4206

embedded->on_expr->check_cols(1))

3759

4207

goto err_no_arena;

3838

4286

if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)

3839

4287

{

3840

4288

my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));

3841

if (table)

3842

table->auto_increment_field_not_null= false;

3843

3844

return true;

4289

goto err;

3845

4290

}

3846

4291

}

3847

4292

3848

4293

return session->is_error();

4294

4295

err:

4296

if (table)

4297

table->auto_increment_field_not_null= false;

4298

4299

return true;

3849

4300

}

3850

4301

3851

4302

3888

4339

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

3889

4340

table->auto_increment_field_not_null= false;

3890

4341

}

3891

3892

4342

while ((field = *ptr++) && ! session->is_error())

3893

4343

{

3894

4344

value=v++;

3895

4345

table= field->getTable();

3896

3897

4346

if (field == table->next_number_field)

3898

4347

table->auto_increment_field_not_null= true;

3899

3900

4348

if (value->save_in_field(field, 0) < 0)

3901

{

3902

if (table)

3903

table->auto_increment_field_not_null= false;

3904

3905

return true;

3906

}

4349

goto err;

3907

4350

}

3908

4351

3909

4352

return(session->is_error());

4353

4354

err:

4355

if (table)

4356

table->auto_increment_field_not_null= false;

4357

4358

return true;

3910

4359

}

3911

4360

3912

4361

3913

4362

bool drizzle_rm_tmp_tables()

3914

4363

{

4364

Session *session;

3915

4365

3916

4366

assert(drizzle_tmpdir.size());

3917

Session::shared_ptr session= Session::make_shared(plugin::Listen::getNullClient(), catalog::local());

3918

4367

3919

if (not session)

4368

if (!(session= new Session(plugin::Listen::getNullClient())))

3920

4369

return true;

3921

session->thread_stack= (char*) session.get();

4370

session->thread_stack= (char*) &session;

3922

4371

session->storeGlobals();

3923

4372

3924

4373

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

3925

4374

4375

session->lockForDelete();

4376

delete session;

4377

3926

4378

return false;

3927

4379

}

3928

4380

3932

4384

unireg support functions

3933

4385

*****************************************************************************/

3934

4386

3935

4387

4388

Invalidate any cache entries that are for some DB

4389

4390

SYNOPSIS

4391

remove_db_from_cache()

4392

db Database name. This will be in lower case if

4393

lower_case_table_name is set

4394

4395

NOTE:

4396

We can't use hash_delete when looping hash_elements. We mark them first

4397

and afterwards delete those marked unused.

4398

4399

4400

void remove_db_from_cache(const SchemaIdentifier &schema_identifier)

4401

{

4402

safe_mutex_assert_owner(LOCK_open.native_handle());

4403

4404

for (TableOpenCache::const_iterator iter= get_open_cache().begin();

4405

iter != get_open_cache().end();

4406

iter++)

4407

{

4408

Table *table= (*iter).second;

4409

4410

if (not schema_identifier.getPath().compare(table->getMutableShare()->getSchemaName()))

4411

{

4412

table->getMutableShare()->resetVersion(); /* Free when thread is ready */

4413

if (not table->in_use)

4414

unused_tables.relink(table);

4415

}

4416

}

4417

4418

unused_tables.cullByVersion();

4419

}

4420

4421

4422

4423

Mark all entries with the table as deleted to force an reopen of the table

4424

4425

The table will be closed (not stored in cache) by the current thread when

4426

close_thread_tables() is called.

4427

4428

PREREQUISITES

4429

Lock on LOCK_open()

4430

4431

RETURN

4432

0 This thread now have exclusive access to this table and no other thread

4433

can access the table until close_thread_tables() is called.

4434

1 Table is in use by another thread

4435

4436

4437

bool remove_table_from_cache(Session *session, TableIdentifier &identifier, uint32_t flags)

4438

{

4439

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

4440

bool result= false;

4441

bool signalled= false;

4442

4443

for (;;)

4444

{

4445

result= signalled= false;

4446

4447

TableOpenCacheRange ppp;

4448

ppp= get_open_cache().equal_range(key);

4449

4450

for (TableOpenCache::const_iterator iter= ppp.first;

4451

iter != ppp.second; ++iter)

4452

{

4453

Table *table= (*iter).second;

4454

Session *in_use;

4455

4456

table->getMutableShare()->resetVersion(); /* Free when thread is ready */

4457

if (!(in_use=table->in_use))

4458

{

4459

unused_tables.relink(table);

4460

}

4461

else if (in_use != session)

4462

{

4463

4464

Mark that table is going to be deleted from cache. This will

4465

force threads that are in mysql_lock_tables() (but not yet

4466

in thr_multi_lock()) to abort it's locks, close all tables and retry

4467

4468

in_use->some_tables_deleted= true;

4469

if (table->is_name_opened())

4470

{

4471

result= true;

4472

}

4473

4474

Now we must abort all tables locks used by this thread

4475

as the thread may be waiting to get a lock for another table.

4476

Note that we need to hold LOCK_open while going through the

4477

list. So that the other thread cannot change it. The other

4478

thread must also hold LOCK_open whenever changing the

4479

open_tables list. Aborting the MERGE lock after a child was

4480

closed and before the parent is closed would be fatal.

4481

4482

for (Table *session_table= in_use->open_tables;

4483

session_table ;

4484

session_table= session_table->getNext())

4485

{

4486

/* Do not handle locks of MERGE children. */

4487

if (session_table->db_stat) // If table is open

4488

signalled|= mysql_lock_abort_for_thread(session, session_table);

4489

}

4490

}

4491

else

4492

result= result || (flags & RTFC_OWNED_BY_Session_FLAG);

4493

}

4494

4495

unused_tables.cullByVersion();

4496

4497

/* Remove table from table definition cache if it's not in use */

4498

TableShare::release(identifier);

4499

4500

if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))

4501

{

4502

4503

Signal any thread waiting for tables to be freed to

4504

reopen their tables

4505

4506

broadcast_refresh();

4507

if (!(flags & RTFC_CHECK_KILLED_FLAG) || !session->killed)

4508

{

4509

dropping_tables++;

4510

if (likely(signalled))

4511

{

4512

boost::mutex::scoped_lock scoped(LOCK_open, boost::adopt_lock_t());

4513

COND_refresh.wait(scoped);

4514

scoped.release();

4515

}

4516

else

4517

{

4518

4519

It can happen that another thread has opened the

4520

table but has not yet locked any table at all. Since

4521

it can be locked waiting for a table that our thread

4522

has done LOCK Table x WRITE on previously, we need to

4523

ensure that the thread actually hears our signal

4524

before we go to sleep. Thus we wait for a short time

4525

and then we retry another loop in the

4526

remove_table_from_cache routine.

4527

4528

boost::xtime xt;

4529

xtime_get(&xt, boost::TIME_UTC);

4530

xt.sec += 10;

4531

boost::mutex::scoped_lock scoped(LOCK_open, boost::adopt_lock_t());

4532

COND_refresh.timed_wait(scoped, xt);

4533

scoped.release();

4534

}

4535

dropping_tables--;

4536

continue;

4537

}

4538

}

4539

break;

4540

}

4541

4542

return result;

4543

}

3936

4544

3937

4545

3938

4546

/**

Older »