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

661

855

662

856

663

857

void Session::unlink_open_table(Table *find)

664

858

{

665

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

666

Table **prev;

667

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

859

char key[MAX_DBKEY_LENGTH];

860

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

861

Table *list, **prev;

862

safe_mutex_assert_owner(&LOCK_open);

668

863

864

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

669

865

670

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

866

Note that we need to hold LOCK_open while changing the

671

867

open_tables list. Another thread may work on it.

672

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

868

(See: remove_table_from_cache(), mysql_wait_completed_table())

673

869

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

674

870

other thread tries to abort the MERGE lock in between.

675

871

676

872

for (prev= &open_tables; *prev; )

677

873

{

678

Table *list= *prev;

874

list= *prev;

679

875

680

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

876

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

877

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

681

878

{

682

879

/* Remove table from open_tables list. */

683

880

*prev= list->getNext();

684

881

685

882

/* Close table. */

686

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

883

remove_table(list);

687

884

}

688

885

else

689

886

{

693

890

}

694

891

695

892

// Notify any 'refresh' threads

696

locking::broadcast_refresh();

893

broadcast_refresh();

697

894

}

698

895

699

896

716

913

table that was locked with LOCK TABLES.

717

914

718

915

719

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

916

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

720

917

{

721

918

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

722

919

{

724

921

}

725

922

else

726

923

{

727

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

924

pthread_mutex_lock(&LOCK_open); /* Close and drop a table (AUX routine) */

728

925

729

926

unlink_open_table() also tells threads waiting for refresh or close

730

927

that something has happened.

731

928

732

929

unlink_open_table(table);

733

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

930

quick_rm_table(*this, identifier);

931

pthread_mutex_unlock(&LOCK_open);

734

932

}

735

933

}

736

934

746

944

cond Condition to wait for

747

945

748

946

749

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

947

void Session::wait_for_condition(pthread_mutex_t *mutex, pthread_cond_t *cond)

750

948

{

751

949

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

752

950

const char *saved_proc_info;

753

mysys_var->current_mutex= &mutex;

754

mysys_var->current_cond= &cond;

951

mysys_var->current_mutex= mutex;

952

mysys_var->current_cond= cond;

755

953

saved_proc_info= get_proc_info();

756

954

set_proc_info("Waiting for table");

757

{

758

759

We must unlock mutex first to avoid deadlock becasue conditions are

760

sent to this thread by doing locks in the following order:

761

lock(mysys_var->mutex)

762

lock(mysys_var->current_mutex)

763

764

One by effect of this that one can only use wait_for_condition with

765

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

766

mutex is unlocked

767

768

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

769

if (not getKilled())

770

{

771

cond.wait(scopedLock);

772

}

773

}

774

boost_unique_lock_t mysys_scopedLock(mysys_var->mutex);

955

if (!killed)

956

(void) pthread_cond_wait(cond, mutex);

957

958

959

We must unlock mutex first to avoid deadlock becasue conditions are

960

sent to this thread by doing locks in the following order:

961

lock(mysys_var->mutex)

962

lock(mysys_var->current_mutex)

963

964

One by effect of this that one can only use wait_for_condition with

965

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

966

mutex is unlocked

967

968

969

pthread_mutex_unlock(mutex);

970

pthread_mutex_lock(&mysys_var->mutex);

775

971

mysys_var->current_mutex= 0;

776

972

mysys_var->current_cond= 0;

777

973

set_proc_info(saved_proc_info);

974

pthread_mutex_unlock(&mysys_var->mutex);

975

}

976

977

978

979

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

980

981

SYNOPSIS

982

reopen_name_locked_table()

983

session Thread handle

984

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

985

member should point to Table object which was used for

986

name-locking.

987

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

988

linked into Session::open_tables list.

989

false - placeholder used for name-locking is already in

990

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

991

pointer.

992

993

NOTE

994

This function assumes that its caller already acquired LOCK_open mutex.

995

996

RETURN VALUE

997

false - Success

998

true - Error

999

1000

1001

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

1002

{

1003

Table *table= table_list->table;

1004

TableShare *share;

1005

char *table_name= table_list->table_name;

1006

Table orig_table;

1007

1008

safe_mutex_assert_owner(&LOCK_open);

1009

1010

if (killed || !table)

1011

return true;

1012

1013

orig_table= *table;

1014

1015

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

1016

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

1017

{

1018

table->intern_close_table();

1019

1020

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

1021

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

1022

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

1023

object to its original state.

1024

1025

*table= orig_table;

1026

return true;

1027

}

1028

1029

share= table->getMutableShare();

1030

1031

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

1032

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

1033

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

1034

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

1035

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

1036

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

1037

1038

share->resetVersion();

1039

table->in_use = this;

1040

1041

if (link_in)

1042

{

1043

table->setNext(open_tables);

1044

open_tables= table;

1045

}

1046

else

1047

{

1048

1049

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

1050

need to set Table::next correctly.

1051

1052

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

1053

}

1054

1055

table->tablenr= current_tablenr++;

1056

table->used_fields= 0;

1057

table->const_table= 0;

1058

table->null_row= false;

1059

table->maybe_null= false;

1060

table->force_index= false;

1061

table->status= STATUS_NO_RECORD;

1062

1063

return false;

778

1064

}

779

1065

780

1066

791

1077

case of failure.

792

1078

793

1079

794

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

1080

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

795

1081

{

796

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

1082

safe_mutex_assert_owner(&LOCK_open);

797

1083

798

1084

799

1085

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

1086

Note that we must use multi_malloc() here as this is freed by the

1087

table cache

800

1088

801

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

802

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

1089

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

1090

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

803

1091

804

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

1092

if (not add_table(table))

805

1093

{

806

1094

delete table;

807

1095

833

1121

@retval true Error occured (OOM)

834

1122

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

835

1123

836

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

1124

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

837

1125

{

838

1126

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

839

1127

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

841

842

table::CacheMap::iterator iter;

843

844

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

845

846

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

1128

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

1129

1130

TableOpenCache::iterator iter;

1131

1132

iter= get_open_cache().find(key);

1133

1134

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

847

1135

{

1136

pthread_mutex_unlock(&LOCK_open);

848

1137

*table= 0;

849

1138

return false;

850

1139

}

851

1140

852

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

1141

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

853

1142

{

1143

pthread_mutex_unlock(&LOCK_open);

854

1144

return true;

855

1145

}

856

1146

(*table)->open_placeholder= true;

857

1147

(*table)->setNext(open_tables);

858

1148

open_tables= *table;

1149

pthread_mutex_unlock(&LOCK_open);

859

1150

860

1151

return false;

861

1152

}

909

1200

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

910

1201

return NULL;

911

1202

912

if (getKilled())

1203

if (killed)

913

1204

return NULL;

914

1205

915

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

1206

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

916

1207

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

917

table::CacheRange ppp;

1208

TableOpenCacheRange ppp;

918

1209

919

1210

920

1211

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

923

1214

same name. This block implements the behaviour.

924

1215

TODO -> move this block into a separate function.

925

1216

926

bool reset= false;

927

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

1217

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

928

1218

{

929

1219

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

930

1220

{

940

1230

return NULL;

941

1231

}

942

1232

table->query_id= getQueryId();

943

reset= true;

1233

goto reset;

1234

}

1235

}

1236

1237

if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)

1238

{

1239

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

1240

return NULL;

1241

}

1242

1243

1244

If it's the first table from a list of tables used in a query,

1245

remember refresh_version (the version of open_cache state).

1246

If the version changes while we're opening the remaining tables,

1247

we will have to back off, close all the tables opened-so-far,

1248

and try to reopen them.

1249

1250

Note-> refresh_version is currently changed only during FLUSH TABLES.

1251

1252

if (!open_tables)

1253

{

1254

version= refresh_version;

1255

}

1256

else if ((version != refresh_version) &&

1257

! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))

1258

{

1259

/* Someone did a refresh while thread was opening tables */

1260

if (refresh)

1261

*refresh= true;

1262

1263

return NULL;

1264

}

1265

1266

1267

Before we test the global cache, we test our local session cache.

1268

1269

if (cached_table)

1270

{

1271

assert(false); /* Not implemented yet */

1272

}

1273

1274

1275

Non pre-locked/LOCK TABLES mode, and the table is not temporary:

1276

this is the normal use case.

1277

Now we should:

1278

- try to find the table in the table cache.

1279

- if one of the discovered Table instances is name-locked

1280

(table->getShare()->version == 0) back off -- we have to wait

1281

until no one holds a name lock on the table.

1282

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

1283

and insert it into the cache.

1284

We perform all of the above under LOCK_open which currently protects

1285

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

1286

on disk.

1287

1288

1289

pthread_mutex_lock(&LOCK_open); /* Lock for FLUSH TABLES for open table */

1290

1291

1292

Actually try to find the table in the open_cache.

1293

The cache may contain several "Table" instances for the same

1294

physical table. The instances that are currently "in use" by

1295

some thread have their "in_use" member != NULL.

1296

There is no good reason for having more than one entry in the

1297

hash for the same physical table, except that we use this as

1298

an implicit "pending locks queue" - see

1299

wait_for_locked_table_names for details.

1300

1301

ppp= get_open_cache().equal_range(key);

1302

1303

table= NULL;

1304

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

1305

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

1306

{

1307

table= (*iter).second;

1308

1309

if (not table->in_use)

944

1310

break;

945

}

946

}

947

948

if (not reset)

949

{

950

if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)

951

{

952

my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->getSchemaName(), table_list->getTableName());

953

return NULL;

954

}

955

956

1311

957

If it's the first table from a list of tables used in a query,

958

remember refresh_version (the version of open_cache state).

959

If the version changes while we're opening the remaining tables,

960

we will have to back off, close all the tables opened-so-far,

961

and try to reopen them.

962

963

Note-> refresh_version is currently changed only during FLUSH TABLES.

1312

Here we flush tables marked for flush.

1313

Normally, table->getShare()->version contains the value of

1314

refresh_version from the moment when this table was

1315

(re-)opened and added to the cache.

1316

If since then we did (or just started) FLUSH TABLES

1317

statement, refresh_version has been increased.

1318

For "name-locked" Table instances, table->getShare()->version is set

1319

to 0 (see lock_table_name for details).

1320

In case there is a pending FLUSH TABLES or a name lock, we

1321

need to back off and re-start opening tables.

1322

If we do not back off now, we may dead lock in case of lock

1323

order mismatch with some other thread:

1324

c1-> name lock t1; -- sort of exclusive lock

1325

c2-> open t2; -- sort of shared lock

1326

c1-> name lock t2; -- blocks

1327

c2-> open t1; -- blocks

964

1328

965

if (!open_tables)

966

{

967

version= refresh_version;

968

}

969

else if ((version != refresh_version) &&

970

! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))

971

{

972

/* Someone did a refresh while thread was opening tables */

1329

if (table->needs_reopen_or_name_lock())

1330

{

1331

if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)

1332

{

1333

/* Force close at once after usage */

1334

version= table->getShare()->getVersion();

1335

continue;

1336

}

1337

1338

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

1339

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

1340

{

1341

pthread_mutex_unlock(&LOCK_open);

1342

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

1343

return NULL;

1344

}

1345

1346

1347

Back off, part 1: mark the table as "unused" for the

1348

purpose of name-locking by setting table->db_stat to 0. Do

1349

that only for the tables in this thread that have an old

1350

table->getShare()->version (this is an optimization (?)).

1351

table->db_stat == 0 signals wait_for_locked_table_names

1352

that the tables in question are not used any more. See

1353

table_is_used call for details.

1354

1355

close_old_data_files(false, false);

1356

1357

1358

Back-off part 2: try to avoid "busy waiting" on the table:

1359

if the table is in use by some other thread, we suspend

1360

and wait till the operation is complete: when any

1361

operation that juggles with table->getShare()->version completes,

1362

it broadcasts COND_refresh condition variable.

1363

If 'old' table we met is in use by current thread we return

1364

without waiting since in this situation it's this thread

1365

which is responsible for broadcasting on COND_refresh

1366

(and this was done already in Session::close_old_data_files()).

1367

Good example of such situation is when we have statement

1368

that needs two instances of table and FLUSH TABLES comes

1369

after we open first instance but before we open second

1370

instance.

1371

1372

if (table->in_use != this)

1373

{

1374

/* wait_for_conditionwill unlock LOCK_open for us */

1375

wait_for_condition(&LOCK_open, &COND_refresh);

1376

}

1377

else

1378

{

1379

pthread_mutex_unlock(&LOCK_open);

1380

}

1381

1382

There is a refresh in progress for this table.

1383

Signal the caller that it has to try again.

1384

973

1385

if (refresh)

974

1386

*refresh= true;

975

976

1387

return NULL;

977

1388

}

978

979

980

Before we test the global cache, we test our local session cache.

981

982

if (cached_table)

983

{

984

assert(false); /* Not implemented yet */

985

}

986

987

988

Non pre-locked/LOCK TABLES mode, and the table is not temporary:

989

this is the normal use case.

990

Now we should:

991

- try to find the table in the table cache.

992

- if one of the discovered Table instances is name-locked

993

(table->getShare()->version == 0) back off -- we have to wait

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

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

1004

1005

1006

Actually try to find the table in the open_cache.

1007

The cache may contain several "Table" instances for the same

1008

physical table. The instances that are currently "in use" by

1009

some thread have their "in_use" member != NULL.

1010

There is no good reason for having more than one entry in the

1011

hash for the same physical table, except that we use this as

1012

an implicit "pending locks queue" - see

1013

wait_for_locked_table_names for details.

1014

1015

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

1016

1017

table= NULL;

1018

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

1019

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

1389

}

1390

if (table)

1391

{

1392

unused_tables.unlink(table);

1393

table->in_use= this;

1394

}

1395

else

1396

{

1397

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

1398

int error;

1399

/* Free cache if too big */

1400

unused_tables.cull();

1401

1402

if (table_list->isCreate())

1403

{

1404

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

1405

1406

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

1020

1407

{

1021

table= (*iter).second;

1022

1023

if (not table->in_use)

1024

break;

1025

1408

1026

Here we flush tables marked for flush.

1027

Normally, table->getShare()->version contains the value of

1028

refresh_version from the moment when this table was

1029

(re-)opened and added to the cache.

1030

If since then we did (or just started) FLUSH TABLES

1031

statement, refresh_version has been increased.

1032

For "name-locked" Table instances, table->getShare()->version is set

1033

to 0 (see lock_table_name for details).

1034

In case there is a pending FLUSH TABLES or a name lock, we

1035

need to back off and re-start opening tables.

1036

If we do not back off now, we may dead lock in case of lock

1037

order mismatch with some other thread:

1038

c1-> name lock t1; -- sort of exclusive lock

1039

c2-> open t2; -- sort of shared lock

1040

c1-> name lock t2; -- blocks

1041

c2-> open t1; -- blocks

1409

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

1042

1410

1043

if (table->needs_reopen_or_name_lock())

1411

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

1044

1412

{

1045

if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)

1046

{

1047

/* Force close at once after usage */

1048

version= table->getShare()->getVersion();

1049

continue;

1050

}

1051

1052

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

1053

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

1054

{

1055

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

1056

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

1057

return NULL;

1058

}

1059

1060

1061

Back off, part 1: mark the table as "unused" for the

1062

purpose of name-locking by setting table->db_stat to 0. Do

1063

that only for the tables in this thread that have an old

1064

table->getShare()->version (this is an optimization (?)).

1065

table->db_stat == 0 signals wait_for_locked_table_names

1066

that the tables in question are not used any more. See

1067

table_is_used call for details.

1068

1069

close_old_data_files(false, false);

1070

1071

1072

Back-off part 2: try to avoid "busy waiting" on the table:

1073

if the table is in use by some other thread, we suspend

1074

and wait till the operation is complete: when any

1075

operation that juggles with table->getShare()->version completes,

1076

it broadcasts COND_refresh condition variable.

1077

If 'old' table we met is in use by current thread we return

1078

without waiting since in this situation it's this thread

1079

which is responsible for broadcasting on COND_refresh

1080

(and this was done already in Session::close_old_data_files()).

1081

Good example of such situation is when we have statement

1082

that needs two instances of table and FLUSH TABLES comes

1083

after we open first instance but before we open second

1084

instance.

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);

1090

}

1091

else

1092

{

1093

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

1094

}

1095

1096

There is a refresh in progress for this table.

1097

Signal the caller that it has to try again.

1098

1099

if (refresh)

1100

*refresh= true;

1413

pthread_mutex_unlock(&LOCK_open);

1101

1414

return NULL;

1102

1415

}

1103

}

1104

if (table)

1105

{

1106

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

1107

table->in_use= this;

1108

}

1109

else

1110

{

1111

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

1112

int error;

1113

/* Free cache if too big */

1114

table::getUnused().cull();

1115

1116

if (table_list->isCreate())

1117

{

1118

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

1119

1120

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

1121

{

1122

1123

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

1124

1125

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

1126

{

1127

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

1128

return NULL;

1129

}

1130

1131

Link placeholder to the open tables list so it will be automatically

1132

removed once tables are closed. Also mark it so it won't be ignored

1133

by other trying to take name-lock.

1134

1135

table->open_placeholder= true;

1136

table->setNext(open_tables);

1137

open_tables= table;

1138

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

1139

1140

return table ;

1141

}

1142

/* Table exists. Let us try to open it. */

1143

}

1144

1145

/* make a new table */

1146

{

1147

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

1148

table= new_table;

1149

if (new_table == NULL)

1150

{

1151

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

1152

return NULL;

1153

}

1154

1155

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

1156

if (error != 0)

1157

{

1158

delete new_table;

1159

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

1160

return NULL;

1161

}

1162

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

1163

}

1164

}

1165

1166

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

1167

}

1168

if (refresh)

1169

{

1170

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

1171

open_tables= table;

1172

}

1173

table->reginfo.lock_type= TL_READ; /* Assume read */

1174

1175

}

1416

1417

Link placeholder to the open tables list so it will be automatically

1418

removed once tables are closed. Also mark it so it won't be ignored

1419

by other trying to take name-lock.

1420

1421

table->open_placeholder= true;

1422

table->setNext(open_tables);

1423

open_tables= table;

1424

pthread_mutex_unlock(&LOCK_open);

1425

1426

return table ;

1427

}

1428

/* Table exists. Let us try to open it. */

1429

}

1430

1431

/* make a new table */

1432

table= new Table;

1433

if (table == NULL)

1434

{

1435

pthread_mutex_unlock(&LOCK_open);

1436

return NULL;

1437

}

1438

1439

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

1440

if (error != 0)

1441

{

1442

delete table;

1443

pthread_mutex_unlock(&LOCK_open);

1444

return NULL;

1445

}

1446

(void)add_table(table);

1447

}

1448

1449

pthread_mutex_unlock(&LOCK_open);

1450

if (refresh)

1451

{

1452

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

1453

open_tables= table;

1454

}

1455

table->reginfo.lock_type= TL_READ; /* Assume read */

1456

1457

reset:

1176

1458

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

1177

1459

1460

if (lex->need_correct_ident())

1461

table->alias_name_used= my_strcasecmp(table_alias_charset,

1462

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

1178

1463

/* Fix alias if table name changes */

1179

1464

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

1180

1465

{

1181

table->setAlias(alias);

1466

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

1467

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

1468

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

1182

1469

}

1183

1470

1184

1471

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

1189

1476

table->maybe_null= false;

1190

1477

table->force_index= false;

1191

1478

table->status=STATUS_NO_RECORD;

1192

table->insert_values.clear();

1479

table->insert_values= 0;

1193

1480

/* Catch wrong handling of the auto_increment_field_not_null. */

1194

1481

assert(!table->auto_increment_field_not_null);

1195

1482

table->auto_increment_field_not_null= false;

1205

1492

}

1206

1493

1207

1494

1495

#if 0

1496

1497

Reopen an table because the definition has changed.

1498

1499

SYNOPSIS

1500

reopen_table()

1501

table Table object

1502

1503

NOTES

1504

The data cursor for the table is already closed and the share is released

1505

The table has a 'dummy' share that mainly contains database and table name.

1506

1507

RETURN

1508

0 ok

1509

1 error. The old table object is not changed.

1510

1511

1512

bool reopen_table(Table *table)

1513

{

1514

Table tmp;

1515

bool error= 1;

1516

Field **field;

1517

uint32_t key,part;

1518

TableList table_list;

1519

Session *session= table->in_use;

1520

1521

assert(table->getShare()->ref_count == 0);

1522

assert(!table->sort.io_cache);

1523

1524

#ifdef EXTRA_DEBUG

1525

if (table->db_stat)

1526

errmsg_printf(ERRMSG_LVL_ERROR, _("Table %s had a open data Cursor in reopen_table"),

1527

table->alias);

1528

#endif

1529

table_list.db= const_cast<char *>(table->getShare()->getSchemaName());

1530

table_list.table_name= table->getShare()->getTableName();

1531

table_list.table= table;

1532

1533

if (wait_for_locked_table_names(session, &table_list))

1534

return true; // Thread was killed

1535

1536

if (open_unireg_entry(session, &tmp, &table_list,

1537

table->alias,

1538

table->getShare()->getCacheKey(),

1539

table->getShare()->getCacheKeySize()))

1540

goto end;

1541

1542

/* This list copies variables set by open_table */

1543

tmp.tablenr= table->tablenr;

1544

tmp.used_fields= table->used_fields;

1545

tmp.const_table= table->const_table;

1546

tmp.null_row= table->null_row;

1547

tmp.maybe_null= table->maybe_null;

1548

tmp.status= table->status;

1549

1550

/* Get state */

1551

tmp.in_use= session;

1552

tmp.reginfo.lock_type=table->reginfo.lock_type;

1553

1554

/* Replace table in open list */

1555

tmp.next= table->next;

1556

tmp.prev= table->prev;

1557

1558

if (table->cursor)

1559

table->delete_table(true); // close cursor, free everything

1560

1561

*table= tmp;

1562

table->default_column_bitmaps();

1563

table->cursor->change_table_ptr(table, table->s);

1564

1565

assert(table->alias != 0);

1566

for (field=table->field ; *field ; field++)

1567

{

1568

(*field)->table= (*field)->orig_table= table;

1569

(*field)->table_name= &table->alias;

1570

}

1571

for (key=0 ; key < table->getShare()->keys ; key++)

1572

{

1573

for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)

1574

table->key_info[key].key_part[part].field->table= table;

1575

}

1576

1577

broadcast_refresh();

1578

error= false;

1579

1580

end:

1581

return(error);

1582

}

1583

#endif

1584

1585

1208

1586

/**

1209

1587

Close all instances of a table open by this thread and replace

1210

1588

them with exclusive name-locks.

1222

1600

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

1223

1601

1224

1602

1225

void Session::close_data_files_and_morph_locks(const TableIdentifier &identifier)

1603

void Session::close_data_files_and_morph_locks(TableIdentifier &identifier)

1226

1604

{

1227

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

1605

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

1228

1606

1229

1607

if (lock)

1230

1608

{

1232

1610

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

1233

1611

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

1234

1612

1235

unlockTables(lock);

1613

mysql_unlock_tables(this, lock);

1236

1614

lock= 0;

1237

1615

}

1238

1616

1267

1645

combination when one needs tables to be reopened (for

1268

1646

example see openTablesLock()).

1269

1647

1270

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

1648

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

1271

1649

1272

1650

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

1273

1651

1284

1662

if (open_tables == NULL)

1285

1663

return false;

1286

1664

1287

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

1665

safe_mutex_assert_owner(&LOCK_open);

1288

1666

if (get_locks)

1289

1667

{

1290

1668

1311

1689

next= table->getNext();

1312

1690

1313

1691

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

1314

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

1692

remove_table(table);

1315

1693

error= 1;

1316

1694

}

1317

1695

*prev=0;

1318

1696

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

1319

1697

{

1320

DrizzleLock *local_lock;

1698

DRIZZLE_LOCK *local_lock;

1321

1699

1322

1700

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

1701

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

1324

1702

already locked.

1325

1703

1326

1704

some_tables_deleted= false;

1327

1705

1328

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

1329

flags, &not_used)))

1706

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

1707

flags, &not_used)))

1330

1708

{

1331

1709

/* unused */

1332

1710

}

1345

1723

if (get_locks && tables)

1346

1724

delete [] tables;

1347

1725

1348

locking::broadcast_refresh();

1726

broadcast_refresh();

1349

1727

1350

1728

return(error);

1351

1729

}

1392

1770

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

1393

1771

instances of this table.

1394

1772

1395

abortLock(ulcktbl);

1396

removeLock(ulcktbl);

1773

mysql_lock_abort(this, ulcktbl);

1774

mysql_lock_remove(this, ulcktbl);

1397

1775

ulcktbl->lock_count= 0;

1398

1776

}

1399

1777

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

1433

1811

}

1434

1812

}

1435

1813

if (found)

1436

locking::broadcast_refresh();

1814

broadcast_refresh();

1815

}

1816

1817

1818

1819

Wait until all threads has closed the tables in the list

1820

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

1821

if the table is closed

1822

1823

1824

bool table_is_used(Table *table, bool wait_for_name_lock)

1825

{

1826

1827

{

1828

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

1829

1830

TableOpenCacheRange ppp;

1831

ppp= get_open_cache().equal_range(key);

1832

1833

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

1834

iter != ppp.second; ++iter)

1835

{

1836

Table *search= (*iter).second;

1837

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

1838

continue; // Name locked by this thread

1839

1840

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

1841

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

1842

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

1843

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

1844

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

1845

1846

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

1847

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

1848

return 1;

1849

}

1850

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

1851

return 0;

1437

1852

}

1438

1853

1439

1854

1444

1859

bool result;

1445

1860

1446

1861

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

1447

{

1448

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

1449

while (not session->getKilled())

1450

{

1451

session->some_tables_deleted= false;

1452

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

1453

if (not table::Cache::singleton().areTablesUsed(session->open_tables, 1))

1454

{

1455

break;

1456

}

1457

COND_refresh.wait(lock);

1458

}

1459

if (session->getKilled())

1460

result= true; // aborted

1461

else

1462

{

1463

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

1464

session->set_proc_info("Reopen tables");

1465

session->version= refresh_version;

1466

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

1467

}

1468

}

1862

pthread_mutex_lock(&LOCK_open); /* Lock for all tables to be refreshed */

1863

while (!session->killed)

1864

{

1865

session->some_tables_deleted= false;

1866

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

1867

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

1868

break;

1869

(void) pthread_cond_wait(&COND_refresh,&LOCK_open);

1870

}

1871

if (session->killed)

1872

result= true; // aborted

1873

else

1874

{

1875

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

1876

session->set_proc_info("Reopen tables");

1877

session->version= refresh_version;

1878

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

1879

}

1880

pthread_mutex_unlock(&LOCK_open);

1469

1881

session->set_proc_info(0);

1470

1882

1471

1883

return result;

1502

1914

prev= &session->open_tables;

1503

1915

1504

1916

1505

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

1917

Note that we need to hold LOCK_open while changing the

1506

1918

open_tables list. Another thread may work on it.

1507

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

1919

(See: remove_table_from_cache(), mysql_wait_completed_table())

1508

1920

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

1509

1921

other thread tries to abort the MERGE lock in between.

1510

1922

1513

1925

next=table->getNext();

1514

1926

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

1515

1927

{

1516

session->removeLock(table);

1928

mysql_lock_remove(session, table);

1517

1929

1518

1930

if (!found)

1519

1931

{

1528

1940

else

1529

1941

{

1530

1942

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

1531

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

1943

remove_table(table);

1532

1944

}

1533

1945

}

1534

1946

else

1539

1951

}

1540

1952

*prev=0;

1541

1953

if (found)

1542

locking::broadcast_refresh();

1954

broadcast_refresh();

1543

1955

1544

1956

return(found);

1545

1957

}

1559

1971

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

1560

1972

{

1561

1973

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

1562

session->abortLock(table);

1974

mysql_lock_abort(session, table);

1563

1975

break;

1564

1976

}

1565

1977

}

1566

1978

}

1567

1979

1980

1981

Load a table definition from cursor and open unireg table

1982

1983

SYNOPSIS

1984

open_unireg_entry()

1985

session Thread handle

1986

entry Store open table definition here

1987

table_list TableList with db, table_name

1988

alias Alias name

1989

cache_key Key for share_cache

1990

cache_key_length length of cache_key

1991

1992

NOTES

1993

Extra argument for open is taken from session->open_options

1994

One must have a lock on LOCK_open when calling this function

1995

1996

RETURN

1997

0 ok

1998

# Error

1999

2000

2001

static int open_unireg_entry(Session *session,

2002

Table *entry,

2003

const char *alias,

2004

TableIdentifier &identifier)

2005

{

2006

int error;

2007

TableShare *share;

2008

uint32_t discover_retry_count= 0;

2009

2010

safe_mutex_assert_owner(&LOCK_open);

2011

retry:

2012

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

2013

identifier,

2014

&error)))

2015

return 1;

2016

2017

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

2018

identifier,

2019

alias,

2020

(uint32_t) (HA_OPEN_KEYFILE |

2021

HA_OPEN_RNDFILE |

2022

HA_GET_INDEX |

2023

HA_TRY_READ_ONLY),

2024

session->open_options, *entry)))

2025

{

2026

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

2027

{

2028

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

2029

if (discover_retry_count++) // Retry once

2030

goto err;

2031

2032

2033

TODO->

2034

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

2035

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

2036

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

2037

2038

Proper fix would be to if the second retry failed:

2039

- Mark that table def changed

2040

- Return from open table

2041

- Close all tables used by this thread

2042

- Start waiting that the share is released

2043

- Retry by opening all tables again

2044

2045

2046

2047

TO BE FIXED

2048

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

2049

using the share.

2050

2051

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

2052

goto err;

2053

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

2054

TableShare::release(share);

2055

2056

if (!session->killed)

2057

{

2058

drizzle_reset_errors(session, 1); // Clear warnings

2059

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

2060

goto retry;

2061

}

2062

return 1;

2063

}

2064

2065

goto err;

2066

}

2067

2068

return 0;

2069

2070

err:

2071

TableShare::release(share);

2072

2073

return 1;

2074

}

2075

1568

2076

1569

2077

1570

2078

Open all tables in list

1632

2140

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

1633

2141

* table/schema information via error messages

1634

2142

1635

TableIdentifier the_table(tables->getSchemaName(), tables->getTableName());

1636

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

2143

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

2144

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

2145

the_table))

1637

2146

{

1638

2147

result= -1; // Fatal error

1639

2148

break;

1741

2250

1742

2251

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

1743

2252

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

1744

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

2253

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

1745

2254

table= 0;

1746

2255

}

1747

2256

1804

2313

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

1805

2314

}

1806

2315

1807

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

2316

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

2317

lock_flag, need_reopen)))

1808

2318

{

1809

2319

return -1;

1810

2320

}

1833

2343

# Table object

1834

2344

1835

2345

1836

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

1837

bool link_in_list)

2346

Table *Session::open_temporary_table(TableIdentifier &identifier,

2347

bool link_in_list)

1838

2348

{

2349

TableShare *share;

2350

1839

2351

assert(identifier.isTmp());

1840

1841

1842

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

1843

identifier,

1844

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

1845

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

2352

share= new TableShare(identifier.getType(),

2353

identifier,

2354

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

2355

2356

2357

Table *new_tmp_table= new Table;

1846

2358

if (not new_tmp_table)

1847

2359

return NULL;

1848

2360

1849

2361

1850

2362

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

1851

2363

1852

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

1853

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

1854

(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |

1855

HA_GET_INDEX),

1856

ha_open_options,

1857

*new_tmp_table))

2364

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

2365

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

2366

(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |

2367

HA_GET_INDEX),

2368

ha_open_options,

2369

*new_tmp_table))

1858

2370

{

1859

2371

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

1860

delete new_tmp_table->getMutableShare();

1861

delete new_tmp_table;

2372

delete share;

2373

free((char*) new_tmp_table);

1862

2374

1863

2375

return 0;

1864

2376

}

1899

2411

{

1900

2412

if (session->mark_used_columns != MARK_COLUMNS_NONE)

1901

2413

{

1902

boost::dynamic_bitset<> *current_bitmap= NULL;

2414

MyBitmap *current_bitmap, *other_bitmap;

1903

2415

1904

2416

1905

2417

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

1912

2424

if (session->mark_used_columns == MARK_COLUMNS_READ)

1913

2425

{

1914

2426

current_bitmap= table->read_set;

2427

other_bitmap= table->write_set;

1915

2428

}

1916

2429

else

1917

2430

{

1918

2431

current_bitmap= table->write_set;

2432

other_bitmap= table->read_set;

1919

2433

}

1920

2434

1921

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

1922

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

2435

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

1923

2436

{

1924

2437

if (session->mark_used_columns == MARK_COLUMNS_WRITE)

1925

2438

session->dup_field= field;

2153

2666

2154

2667

table_name && table_name[0] &&

2155

2668

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

2156

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

2157

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

2669

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

2670

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

2158

2671

return 0;

2159

2672

2160

2673

*actual_table= NULL;

2229

2742

{

2230

2743

Table *table= field_to_set->getTable();

2231

2744

if (session->mark_used_columns == MARK_COLUMNS_READ)

2232

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

2745

table->setReadSet(field_to_set->field_index);

2233

2746

else

2234

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

2747

table->setWriteSet(field_to_set->field_index);

2235

2748

}

2236

2749

}

2237

2750

}

2787

3300

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

2788

3301

bool is_using_column_1;

2789

3302

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

2790

return(result);

3303

goto err;

2791

3304

field_name_1= nj_col_1->name();

2792

3305

is_using_column_1= using_fields &&

2793

3306

test_if_string_in_list(field_name_1, using_fields);

2805

3318

Natural_join_column *cur_nj_col_2;

2806

3319

const char *cur_field_name_2;

2807

3320

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

2808

return(result);

3321

goto err;

2809

3322

cur_field_name_2= cur_nj_col_2->name();

2810

3323

2811

3324

2825

3338

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

2826

3339

{

2827

3340

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

2828

return(result);

3341

goto err;

2829

3342

}

2830

3343

nj_col_2= cur_nj_col_2;

2831

3344

found= true;

2858

3371

Item_func_eq *eq_cond;

2859

3372

2860

3373

if (!item_1 || !item_2)

2861

return(result); // out of memory

3374

goto err; // out of memory

2862

3375

2863

3376

2864

3377

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

2883

3396

2884

3397

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

2885

3398

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

2886

return(result);

3399

goto err;

2887

3400

2888

3401

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

2889

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

3402

goto err; /* Out of memory. */

2890

3403

2891

3404

2892

3405

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

2903

3416

{

2904

3417

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

2905

3418

/* Mark field_1 used for table cache. */

2906

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

3419

table_1->setReadSet(field_1->field_index);

2907

3420

table_1->covering_keys&= field_1->part_of_key;

2908

3421

table_1->merge_keys|= field_1->part_of_key;

2909

3422

}

2911

3424

{

2912

3425

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

2913

3426

/* Mark field_2 used for table cache. */

2914

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

3427

table_2->setReadSet(field_2->field_index);

2915

3428

table_2->covering_keys&= field_2->part_of_key;

2916

3429

table_2->merge_keys|= field_2->part_of_key;

2917

3430

}

2932

3445

2933

3446

result= false;

2934

3447

3448

err:

2935

3449

return(result);

2936

3450

}

2937

3451

2989

3503

2990

3504

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

2991

3505

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

2992

{

2993

return(result);

2994

}

3506

goto err;

2995

3507

2996

3508

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

2997

3509

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

3030

3542

{

3031

3543

my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,

3032

3544

session->where);

3033

return(result);

3545

goto err;

3034

3546

}

3035

3547

if (!my_strcasecmp(system_charset_info,

3036

3548

common_field->name(), using_field_name_ptr))

3058

3570

3059

3571

result= false;

3060

3572

3573

err:

3061

3574

return(result);

3062

3575

}

3063

3576

3143

3656

if (cur_table_ref->getNestedJoin() &&

3144

3657

store_top_level_join_columns(session, cur_table_ref,

3145

3658

real_left_neighbor, real_right_neighbor))

3146

return(result);

3659

goto err;

3147

3660

same_level_right_neighbor= cur_table_ref;

3148

3661

}

3149

3662

}

3175

3688

std::swap(table_ref_1, table_ref_2);

3176

3689

if (mark_common_columns(session, table_ref_1, table_ref_2,

3177

3690

using_fields, &found_using_fields))

3178

return(result);

3691

goto err;

3179

3692

3180

3693

3181

3694

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

3187

3700

if (store_natural_using_join_columns(session, table_ref, table_ref_1,

3188

3701

table_ref_2, using_fields,

3189

3702

found_using_fields))

3190

return(result);

3703

goto err;

3191

3704

3192

3705

3193

3706

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

3220

3733

}

3221

3734

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

3222

3735

3736

err:

3223

3737

return(result);

3224

3738

}

3225

3739

3621

4135

assert(tables->is_leaf_for_name_resolution());

3622

4136

3623

4137

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

3624

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

4138

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

3625

4139

continue;

3626

4140

3627

4141

3657

4171

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

3658

4172

{

3659

4173

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

3660

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

4174

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

3661

4175

if (table)

3662

4176

{

3663

4177

table->covering_keys&= field->part_of_key;

3864

4378

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

3865

4379

{

3866

4380

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

3867

if (table)

3868

table->auto_increment_field_not_null= false;

3869

3870

return true;

4381

goto err;

3871

4382

}

3872

4383

}

3873

4384

3874

4385

return session->is_error();

4386

4387

err:

4388

if (table)

4389

table->auto_increment_field_not_null= false;

4390

4391

return true;

3875

4392

}

3876

4393

3877

4394

3921

4438

if (field == table->next_number_field)

3922

4439

table->auto_increment_field_not_null= true;

3923

4440

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

3924

{

3925

if (table)

3926

table->auto_increment_field_not_null= false;

3927

3928

return true;

3929

}

4441

goto err;

3930

4442

}

3931

4443

3932

4444

return(session->is_error());

4445

4446

err:

4447

if (table)

4448

table->auto_increment_field_not_null= false;

4449

4450

return true;

3933

4451

}

3934

4452

3935

4453

3957

4475

unireg support functions

3958

4476

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

3959

4477

3960

4478

4479

Invalidate any cache entries that are for some DB

4480

4481

SYNOPSIS

4482

remove_db_from_cache()

4483

db Database name. This will be in lower case if

4484

lower_case_table_name is set

4485

4486

NOTE:

4487

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

4488

and afterwards delete those marked unused.

4489

4490

4491

void remove_db_from_cache(const SchemaIdentifier &schema_identifier)

4492

{

4493

safe_mutex_assert_owner(&LOCK_open);

4494

4495

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

4496

iter != get_open_cache().end();

4497

iter++)

4498

{

4499

Table *table= (*iter).second;

4500

4501

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

4502

{

4503

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

4504

if (not table->in_use)

4505

unused_tables.relink(table);

4506

}

4507

}

4508

4509

unused_tables.cullByVersion();

4510

}

4511

4512

4513

4514

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

4515

4516

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

4517

close_thread_tables() is called.

4518

4519

PREREQUISITES

4520

Lock on LOCK_open()

4521

4522

RETURN

4523

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

4524

can access the table until close_thread_tables() is called.

4525

1 Table is in use by another thread

4526

4527

4528

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

4529

{

4530

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

4531

bool result= false;

4532

bool signalled= false;

4533

4534

for (;;)

4535

{

4536

result= signalled= false;

4537

4538

TableOpenCacheRange ppp;

4539

ppp= get_open_cache().equal_range(key);

4540

4541

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

4542

iter != ppp.second; ++iter)

4543

{

4544

Table *table= (*iter).second;

4545

Session *in_use;

4546

4547

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

4548

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

4549

{

4550

unused_tables.relink(table);

4551

}

4552

else if (in_use != session)

4553

{

4554

4555

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

4556

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

4557

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

4558

4559

in_use->some_tables_deleted= true;

4560

if (table->is_name_opened())

4561

{

4562

result= true;

4563

}

4564

4565

Now we must abort all tables locks used by this thread

4566

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

4567

Note that we need to hold LOCK_open while going through the

4568

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

4569

thread must also hold LOCK_open whenever changing the

4570

open_tables list. Aborting the MERGE lock after a child was

4571

closed and before the parent is closed would be fatal.

4572

4573

for (Table *session_table= in_use->open_tables;

4574

session_table ;

4575

session_table= session_table->getNext())

4576

{

4577

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

4578

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

4579

signalled|= mysql_lock_abort_for_thread(session, session_table);

4580

}

4581

}

4582

else

4583

result= result || (flags & RTFC_OWNED_BY_Session_FLAG);

4584

}

4585

4586

unused_tables.cullByVersion();

4587

4588

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

4589

TableShare::release(identifier);

4590

4591

if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))

4592

{

4593

4594

Signal any thread waiting for tables to be freed to

4595

reopen their tables

4596

4597

broadcast_refresh();

4598

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

4599

{

4600

dropping_tables++;

4601

if (likely(signalled))

4602

(void) pthread_cond_wait(&COND_refresh, &LOCK_open);

4603

else

4604

{

4605

struct timespec abstime;

4606

4607

It can happen that another thread has opened the

4608

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

4609

it can be locked waiting for a table that our thread

4610

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

4611

ensure that the thread actually hears our signal

4612

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

4613

and then we retry another loop in the

4614

remove_table_from_cache routine.

4615

4616

set_timespec(abstime, 10);

4617

pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);

4618

}

4619

dropping_tables--;

4620

continue;

4621

}

4622

}

4623

break;

4624

}

4625

4626

return result;

4627

}

3961

4628

3962

4629

3963

4630

/**

Older »