~drizzle-trunk/drizzle/development : revision 98

247

Name_resolution_context_state ctx_state;

248

thr_lock_type lock_type;

249

Item *unused_conds= 0;

250

DBUG_ENTER("mysql_insert");

250

251

252

/*

253

Upgrade lock type if the requested lock is incompatible with

267

{

268

my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),

269

table_list->table_name);

270

DBUG_RETURN(TRUE);

270

return(TRUE);

271

}

272

273

{

274

if (open_and_lock_tables(thd, table_list))

275

DBUG_RETURN(TRUE);

275

return(TRUE);

276

}

277

lock_type= table_list->lock_type;

278

297

resolution context below is not necessary at all since the list of local

298

tables for INSERT always consists of one table.

299

*/

300

DBUG_ASSERT(!table_list->next_local);

301

DBUG_ASSERT(!context->table_list->next_local);

302

DBUG_ASSERT(!context->first_name_resolution_table->next_name_resolution_table);

300

assert(!table_list->next_local);

301

assert(!context->table_list->next_local);

302

assert(!context->first_name_resolution_table->next_name_resolution_table);

303

304

/* Save the state of the current name resolution context. */

305

ctx_state.save_state(context, table_list);

486

routines did not result in any error due to the KILLED. In

487

such case the flag is ignored for constructing binlog event.

488

*/

489

DBUG_ASSERT(thd->killed != THD::KILL_BAD_DATA || error > 0);

489

assert(thd->killed != THD::KILL_BAD_DATA || error > 0);

490

if (thd->binlog_query(THD::ROW_QUERY_TYPE,

491

thd->query, thd->query_length,

492

transactional_table, FALSE,

499

if (thd->transaction.stmt.modified_non_trans_table)

500

thd->transaction.all.modified_non_trans_table= TRUE;

501

}

502

DBUG_ASSERT(transactional_table || !changed ||

502

assert(transactional_table || !changed ||

503

thd->transaction.stmt.modified_non_trans_table);

504

505

}

552

}

553

thd->abort_on_warning= 0;

554

MYSQL_INSERT_END();

555

DBUG_RETURN(FALSE);

555

return(FALSE);

556

557

abort:

558

if (table != NULL)

561

free_underlaid_joins(thd, &thd->lex->select_lex);

562

thd->abort_on_warning= 0;

563

MYSQL_INSERT_END();

564

DBUG_RETURN(TRUE);

564

return(TRUE);

565

}

566

567

585

List<Item> &fields,

586

bool select_insert)

587

{

588

DBUG_ENTER("mysql_prepare_insert_check_table");

588

589

590

/*

591

first table in list is the one we'll INSERT into, requires INSERT_ACL.

599

table_list,

600

&thd->lex->select_lex.leaf_tables,

601

select_insert))

602

DBUG_RETURN(TRUE);

602

return(TRUE);

603

604

DBUG_RETURN(FALSE);

604

return(FALSE);

605

}

606

607

649

bool insert_into_view= (0 != 0);

650

bool res= 0;

651

table_map map= 0;

652

DBUG_ENTER("mysql_prepare_insert");

653

DBUG_PRINT("enter", ("table_list 0x%lx, table 0x%lx, view %d",

654

(ulong)table_list, (ulong)table,

655

(int)insert_into_view));

652

656

653

/* INSERT should have a SELECT or VALUES clause */

657

DBUG_ASSERT (!select_insert || !values);

654

assert (!select_insert || !values);

658

655

659

656

/*

660

657

For subqueries in VALUES() we should not see the table in which we are

680

677

{

681

678

/* it should be allocated before Item::fix_fields() */

682

679

if (table_list->set_insert_values(thd->mem_root))

683

DBUG_RETURN(TRUE);

680

return(TRUE);

684

681

}

685

682

686

683

if (mysql_prepare_insert_check_table(thd, table_list, fields, select_insert))

687

DBUG_RETURN(TRUE);

684

return(TRUE);

688

685

689

686

690

687

/* Prepare the fields in the statement. */

691

688

if (values)

692

689

{

693

690

/* if we have INSERT ... VALUES () we cannot have a GROUP BY clause */

694

DBUG_ASSERT (!select_lex->group_list.elements);

691

assert (!select_lex->group_list.elements);

695

692

696

693

/* Save the state of the current name resolution context. */

697

694

ctx_state.save_state(context, table_list);

733

730

}

734

731

735

732

if (res)

736

DBUG_RETURN(res);

733

return(res);

737

734

738

735

if (!table)

739

736

table= table_list->table;

745

742

if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))

746

743

{

747

744

update_non_unique_table_error(table_list, "INSERT", duplicate);

748

DBUG_RETURN(TRUE);

745

return(TRUE);

749

746

}

750

747

select_lex->fix_prepare_information(thd, &fake_conds, &fake_conds);

751

748

select_lex->first_execution= 0;

752

749

}

753

750

if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)

754

751

table->prepare_for_position();

755

DBUG_RETURN(FALSE);

752

return(FALSE);

756

753

}

757

754

758

755

801

798

MY_BITMAP *save_read_set, *save_write_set;

802

799

ulonglong prev_insert_id= table->file->next_insert_id;

803

800

ulonglong insert_id_for_cur_row= 0;

804

DBUG_ENTER("write_record");

801

805

802

806

803

info->records++;

807

804

save_read_set= table->read_set;

891

888

that matches, is updated. If update causes a conflict again,

892

889

an error is returned

893

890

*/

894

DBUG_ASSERT(table->insert_values != NULL);

891

assert(table->insert_values != NULL);

895

892

store_record(table,insert_values);

896

893

restore_record(table,record[1]);

897

DBUG_ASSERT(info->update_fields->elements ==

894

assert(info->update_fields->elements ==

898

895

info->update_values->elements);

899

896

if (fill_record(thd, *info->update_fields,

900

897

*info->update_values,

1018

1015

my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH);

1019

1016

if (!table->file->has_transactions())

1020

1017

thd->transaction.stmt.modified_non_trans_table= TRUE;

1021

DBUG_RETURN(0);

1018

return(0);

1022

1019

1023

1020

err:

1024

1021

info->last_errno= error;

1032

1029

if (key)

1033

1030

my_safe_afree(key, table->s->max_unique_length, MAX_KEY_LENGTH);

1034

1031

table->column_bitmaps_set(save_read_set, save_write_set);

1035

DBUG_RETURN(1);

1032

return(1);

1036

1033

}

1037

1034

1038

1035

1092

1089

LEX *lex= thd->lex;

1093

1090

SELECT_LEX *select_lex= &lex->select_lex;

1094

1091

TABLE_LIST *first_select_leaf_table;

1095

DBUG_ENTER("mysql_insert_select_prepare");

1092

1096

1093

1097

1094

/*

1098

1095

Statement-based replication of INSERT ... SELECT ... LIMIT is not safe

1117

1114

lex->update_list, lex->value_list,

1118

1115

lex->duplicates,

1119

1116

&select_lex->where, TRUE, FALSE, FALSE))

1120

DBUG_RETURN(TRUE);

1117

return(TRUE);

1121

1118

1122

1119

/*

1123

1120

exclude first table from leaf tables list, because it belong to

1124

1121

INSERT

1125

1122

*/

1126

DBUG_ASSERT(select_lex->leaf_tables != 0);

1123

assert(select_lex->leaf_tables != 0);

1127

1124

lex->leaf_tables_insert= select_lex->leaf_tables;

1128

1125

/* skip all leaf tables belonged to view where we are insert */

1129

1126

for (first_select_leaf_table= select_lex->leaf_tables->next_leaf;

1134

1131

first_select_leaf_table= first_select_leaf_table->next_leaf)

1135

1132

{}

1136

1133

select_lex->leaf_tables= first_select_leaf_table;

1137

DBUG_RETURN(FALSE);

1134

return(FALSE);

1138

1135

}

1139

1136

1140

1137

1163

1160

int res;

1164

1161

table_map map= 0;

1165

1162

SELECT_LEX *lex_current_select_save= lex->current_select;

1166

DBUG_ENTER("select_insert::prepare");

1163

1167

1164

1168

1165

unit= u;

1169

1166

1207

1204

we can refer to other tables in the ON DUPLICATE KEY part.

1208

1205

We use next_name_resolution_table descructively, so check it first (views?)

1209

1206

*/

1210

DBUG_ASSERT (!table_list->next_name_resolution_table);

1207

assert (!table_list->next_name_resolution_table);

1211

1208

if (lex->select_lex.group_list.elements == 0 &&

1212

1209

!lex->select_lex.with_sum_func)

1213

1210

/*

1244

1241

1245

1242

lex->current_select= lex_current_select_save;

1246

1243

if (res)

1247

DBUG_RETURN(1);

1244

return(1);

1248

1245

/*

1249

1246

if it is INSERT into join view then check_insert_fields already found

1250

1247

real table for insert

1282

1279

(info.handle_duplicates == DUP_UPDATE) &&

1283

1280

(table->next_number_field != NULL) &&

1284

1281

rpl_master_has_bug(&active_mi->rli, 24432))

1285

DBUG_RETURN(1);

1282

return(1);

1286

1283

#endif

1287

1284

1288

1285

thd->cuted_fields=0;

1296

1293

table->mark_columns_needed_for_insert();

1297

1294

1298

1295

1299

DBUG_RETURN(res);

1296

return(res);

1300

1297

}

1301

1298

1302

1299

1318

1315

1319

1316

int select_insert::prepare2(void)

1320

1317

{

1321

DBUG_ENTER("select_insert::prepare2");

1318

1322

1319

if (thd->lex->current_select->options & OPTION_BUFFER_RESULT)

1323

1320

table->file->ha_start_bulk_insert((ha_rows) 0);

1324

DBUG_RETURN(0);

1321

return(0);

1325

1322

}

1326

1323

1327

1324

1328

1325

void select_insert::cleanup()

1329

1326

{

1330

1327

/* select_insert/select_create are never re-used in prepared statement */

1331

DBUG_ASSERT(0);

1328

assert(0);

1332

1329

}

1333

1330

1334

1331

select_insert::~select_insert()

1335

1332

{

1336

DBUG_ENTER("~select_insert");

1333

1337

1334

if (table)

1338

1335

{

1339

1336

table->next_number_field=0;

1342

1339

}

1343

1340

thd->count_cuted_fields= CHECK_FIELD_IGNORE;

1344

1341

thd->abort_on_warning= 0;

1345

DBUG_VOID_RETURN;

1342

return;

1346

1343

}

1347

1344

1348

1345

1349

1346

bool select_insert::send_data(List<Item> &values)

1350

1347

{

1351

DBUG_ENTER("select_insert::send_data");

1348

1352

1349

bool error=0;

1353

1350

1354

1351

if (unit->offset_limit_cnt)

1355

1352

{ // using limit offset,count

1356

1353

unit->offset_limit_cnt--;

1357

DBUG_RETURN(0);

1354

return(0);

1358

1355

}

1359

1356

1360

1357

thd->count_cuted_fields= CHECK_FIELD_WARN; // Calculate cuted fields

1361

1358

store_values(values);

1362

1359

thd->count_cuted_fields= CHECK_FIELD_IGNORE;

1363

1360

if (thd->is_error())

1364

DBUG_RETURN(1);

1361

return(1);

1365

1362

1366

1363

error= write_record(thd, table, &info);

1367

1364

1395

1392

table->next_number_field->reset();

1396

1393

}

1397

1394

}

1398

DBUG_RETURN(error);

1395

return(error);

1399

1396

}

1400

1397

1401

1398

1409

1406

1410

1407

void select_insert::send_error(uint errcode,const char *err)

1411

1408

{

1412

DBUG_ENTER("select_insert::send_error");

1409

1413

1410

1414

1411

my_message(errcode, err, MYF(0));

1415

1412

1416

DBUG_VOID_RETURN;

1413

return;

1417

1414

}

1418

1415

1419

1416

1424

1421

ulonglong id;

1425

1422

bool changed;

1426

1423

THD::killed_state killed_status= thd->killed;

1427

DBUG_ENTER("select_insert::send_eof");

1428

DBUG_PRINT("enter", ("trans_table=%d, table_type='%s'",

1429

trans_table, table->file->table_type()));

1430

1424

1431

1425

error= table->file->ha_end_bulk_insert();

1432

1426

table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);

1433

1427

table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);

1441

1435

if (thd->transaction.stmt.modified_non_trans_table)

1442

1436

thd->transaction.all.modified_non_trans_table= TRUE;

1443

1437

}

1444

DBUG_ASSERT(trans_table || !changed ||

1438

assert(trans_table || !changed ||

1445

1439

thd->transaction.stmt.modified_non_trans_table);

1446

1440

1447

1441

/*

1463

1457

if (error)

1464

1458

{

1465

1459

table->file->print_error(error,MYF(0));

1466

DBUG_RETURN(1);

1460

return(1);

1467

1461

}

1468

1462

char buff[160];

1469

1463

if (info.ignore)

1482

1476

thd->first_successful_insert_id_in_prev_stmt :

1483

1477

(info.copied ? autoinc_value_of_last_inserted_row : 0));

1484

1478

::my_ok(thd, (ulong) thd->row_count_func, id, buff);

1485

DBUG_RETURN(0);

1479

return(0);

1486

1480

}

1487

1481

1488

1482

void select_insert::abort() {

1489

1483

1490

DBUG_ENTER("select_insert::abort");

1484

1491

1485

/*

1492

1486

If the creation of the table failed (due to a syntax error, for

1493

1487

example), no table will have been opened and therefore 'table'

1524

1518

if (!thd->current_stmt_binlog_row_based && !can_rollback_data())

1525

1519

thd->transaction.all.modified_non_trans_table= TRUE;

1526

1520

}

1527

DBUG_ASSERT(transactional_table || !changed ||

1521

assert(transactional_table || !changed ||

1528

1522

thd->transaction.stmt.modified_non_trans_table);

1529

1523

table->file->ha_release_auto_increment();

1530

1524

}

1531

1525

1532

DBUG_VOID_RETURN;

1526

return;

1533

1527

}

1534

1528

1535

1529

1595

1589

Item *item;

1596

1590

Field *tmp_field;

1597

1591

bool not_used;

1598

DBUG_ENTER("create_table_from_items");

1599

1600

DBUG_EXECUTE_IF("sleep_create_select_before_check_if_exists", my_sleep(6000000););

1601

1592

1602

1593

if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&

1603

1594

create_table->table->db_stat)

1609

1600

push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,

1610

1601

ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),

1611

1602

create_table->table_name);

1612

DBUG_RETURN(create_table->table);

1603

return(create_table->table);

1613

1604

}

1614

1605

1615

1606

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);

1616

DBUG_RETURN(0);

1607

return(0);

1617

1608

}

1618

1609

1619

1610

tmp_table.alias= 0;

1645

1636

!(cr_field=new Create_field(field,(item->type() == Item::FIELD_ITEM ?

1646

1637

((Item_field *)item)->field :

1647

1638

(Field*) 0))))

1648

DBUG_RETURN(0);

1639

return(0);

1649

1640

if (item->maybe_null)

1650

1641

cr_field->flags &= ~NOT_NULL_FLAG;

1651

1642

alter_info->create_list.push_back(cr_field);

1652

1643

}

1653

1644

1654

DBUG_EXECUTE_IF("sleep_create_select_before_create", my_sleep(6000000););

1655

1656

1645

/*

1657

1646

Create and lock table.

1658

1647

1685

1674

cluster. We don't have much options but throw an error.

1686

1675

*/

1687

1676

my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);

1688

DBUG_RETURN(0);

1677

return(0);

1689

1678

}

1690

1679

1691

DBUG_EXECUTE_IF("sleep_create_select_before_open", my_sleep(6000000););

1692

1693

1680

if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))

1694

1681

{

1695

1682

VOID(pthread_mutex_lock(&LOCK_open));

1720

1707

}

1721

1708

reenable_binlog(thd);

1722

1709

if (!table) // open failed

1723

DBUG_RETURN(0);

1710

return(0);

1724

1711

}

1725

1712

1726

DBUG_EXECUTE_IF("sleep_create_select_before_lock", my_sleep(6000000););

1727

1728

1713

table->reginfo.lock_type=TL_WRITE;

1729

1714

hooks->prelock(&table, 1); // Call prelock hooks

1730

1715

if (! ((*lock)= mysql_lock_tables(thd, &table, 1,

1739

1724

1740

1725

if (!create_info->table_existed)

1741

1726

drop_open_table(thd, table, create_table->db, create_table->table_name);

1742

DBUG_RETURN(0);

1727

return(0);

1743

1728

}

1744

DBUG_RETURN(table);

1729

return(table);

1745

1730

}

1746

1731

1747

1732

1749

1734

select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)

1750

1735

{

1751

1736

MYSQL_LOCK *extra_lock= NULL;

1752

DBUG_ENTER("select_create::prepare");

1737

1753

1738

1754

1739

TABLEOP_HOOKS *hook_ptr= NULL;

1755

1740

/*

1819

1804

if (!(table= create_table_from_items(thd, create_info, create_table,

1820

1805

alter_info, &values,

1821

1806

&extra_lock, hook_ptr)))

1822

DBUG_RETURN(-1); // abort() deletes table

1807

return(-1); // abort() deletes table

1823

1808

1824

1809

if (extra_lock)

1825

1810

{

1826

DBUG_ASSERT(m_plock == NULL);

1811

assert(m_plock == NULL);

1827

1812

1828

1813

if (create_info->options & HA_LEX_CREATE_TMP_TABLE)

1829

1814

m_plock= &m_lock;

1836

1821

if (table->s->fields < values.elements)

1837

1822

{

1838

1823

my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1);

1839

DBUG_RETURN(-1);

1824

return(-1);

1840

1825

}

1841

1826

1842

1827

/* First field to copy */

1861

1846

table->file->ha_start_bulk_insert((ha_rows) 0);

1862

1847

thd->abort_on_warning= !info.ignore;

1863

1848

if (check_that_all_fields_are_given_values(thd, table, table_list))

1864

DBUG_RETURN(1);

1849

return(1);

1865

1850

table->mark_columns_needed_for_insert();

1866

1851

table->file->extra(HA_EXTRA_WRITE_CACHE);

1867

DBUG_RETURN(0);

1852

return(0);

1868

1853

}

1869

1854

1870

1855

void

1887

1872

schema that will do a close_thread_tables(), destroying the

1888

1873

statement transaction cache.

1889

1874

*/

1890

DBUG_ASSERT(thd->current_stmt_binlog_row_based);

1891

DBUG_ASSERT(tables && *tables && count > 0);

1875

assert(thd->current_stmt_binlog_row_based);

1876

assert(tables && *tables && count > 0);

1892

1877

1893

1878

char buf[2048];

1894

1879

String query(buf, sizeof(buf), system_charset_info);

1900

1885

query.length(0); // Have to zero it since constructor doesn't

1901

1886

1902

1887

result= store_create_info(thd, &tmp_table_list, &query, create_info);

1903

DBUG_ASSERT(result == 0); /* store_create_info() always return 0 */

1888

assert(result == 0); /* store_create_info() always return 0 */

1904

1889

1905

1890

thd->binlog_query(THD::STMT_QUERY_TYPE,

1906

1891

query.ptr(), query.length(),

1916

1901

1917

1902

void select_create::send_error(uint errcode,const char *err)

1918

1903

{

1919

DBUG_ENTER("select_create::send_error");

1920

1921

DBUG_PRINT("info",

1922

("Current statement %s row-based",

1923

thd->current_stmt_binlog_row_based ? "is" : "is NOT"));

1924

DBUG_PRINT("info",

1925

("Current table (at 0x%lu) %s a temporary (or non-existant) table",

1926

(ulong) table,

1927

table && !table->s->tmp_table ? "is NOT" : "is"));

1928

DBUG_PRINT("info",

1929

("Table %s prior to executing this statement",

1930

get_create_info()->table_existed ? "existed" : "did not exist"));

1904

1931

1905

1932

1906

/*

1933

1907

This will execute any rollbacks that are necessary before writing

1944

1918

select_insert::send_error(errcode, err);

1945

1919

reenable_binlog(thd);

1946

1920

1947

DBUG_VOID_RETURN;

1921

return;

1948

1922

}

1949

1923

1950

1924

1981

1955

1982

1956

void select_create::abort()

1983

1957

{

1984

DBUG_ENTER("select_create::abort");

1958

1985

1959

1986

1960

/*

1987

1961

In select_insert::abort() we roll back the statement, including

2019

1993

drop_open_table(thd, table, create_table->db, create_table->table_name);

2020

1994

table=0; // Safety

2021

1995

}

2022

DBUG_VOID_RETURN;

1996

return;

2023

1997

}

2024

1998

2025

1999