~drizzle-trunk/drizzle/development : revision 51.1.1

45

Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)

46

{

47

Object_creation_ctx *backup_ctx;

48

DBUG_ENTER("Object_creation_ctx::set_n_backup");

49

48

50

49

backup_ctx= create_backup_ctx(thd);

51

50

change_env(thd);

52

51

53

DBUG_RETURN(backup_ctx);

52

return(backup_ctx);

54

53

}

55

54

56

55

void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)

183

182

char *key_buff, *path_buff;

184

183

char path[FN_REFLEN];

185

184

uint path_length;

186

DBUG_ENTER("alloc_table_share");

187

DBUG_PRINT("enter", ("table: '%s'.'%s'",

188

table_list->db, table_list->table_name));

189

185

190

186

path_length= build_table_filename(path, sizeof(path) - 1,

191

187

table_list->db,

232

228

pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);

233

229

pthread_cond_init(&share->cond, NULL);

234

230

}

235

DBUG_RETURN(share);

231

return(share);

236

232

}

237

233

238

234

263

259

uint key_length, const char *table_name,

264

260

const char *path)

265

261

{

266

DBUG_ENTER("init_tmp_table_share");

267

DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));

268

262

269

263

bzero((char*) share, sizeof(*share));

270

264

init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);

294

288

*/

295

289

share->table_map_id= (ulong) thd->query_id;

296

290

297

DBUG_VOID_RETURN;

291

return;

298

292

}

299

293

300

294

312

306

void free_table_share(TABLE_SHARE *share)

313

307

{

314

308

MEM_ROOT mem_root;

315

DBUG_ENTER("free_table_share");

316

DBUG_PRINT("enter", ("table: %s.%s", share->db.str, share->table_name.str));

317

309

DBUG_ASSERT(share->ref_count == 0);

318

310

319

311

/*

341

333

/* We must copy mem_root from share because share is allocated through it */

342

334

memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));

343

335

free_root(&mem_root, MYF(0)); // Free's share

344

DBUG_VOID_RETURN;

336

return;

345

337

}

346

338

347

339

426

418

uchar head[64], *disk_buff;

427

419

char path[FN_REFLEN];

428

420

MEM_ROOT **root_ptr, *old_root;

429

DBUG_ENTER("open_table_def");

430

DBUG_PRINT("enter", ("table: '%s'.'%s' path: '%s'", share->db.str,

431

share->table_name.str, share->normalized_path.str));

432

421

433

422

error= 1;

434

423

error_given= 0;

533

522

open_table_error(share, error, (share->open_errno= my_errno), 0);

534

523

}

535

524

536

DBUG_RETURN(error);

525

return(error);

537

526

}

538

527

539

528

567

556

my_bitmap_map *bitmaps;

568

557

uchar *buff= 0;

569

558

uchar *field_extra_info= 0;

570

DBUG_ENTER("open_binary_frm");

571

559

572

560

new_field_pack_flag= head[27];

573

561

new_frm_ver= (head[2] - FRM_VER);

746

734

{

747

735

/* Read extra data segment */

748

736

uchar *next_chunk, *buff_end;

749

DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));

750

737

if (!(next_chunk= buff= (uchar*) my_malloc(n_length, MYF(MY_WME))))

751

738

goto err;

752

739

if (pread(file, buff, n_length, record_offset + share->reclength) == 0)

789

776

*/

790

777

plugin_unlock(NULL, share->db_plugin);

791

778

share->db_plugin= my_plugin_lock(NULL, &tmp_plugin);

792

DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",

793

str_db_type_length, next_chunk + 2,

794

ha_legacy_type(share->db_type())));

795

779

}

796

780

else if (!tmp_plugin)

797

781

{

828

812

//reading long table comment

829

813

if (next_chunk + 2 > buff_end)

830

814

{

831

DBUG_PRINT("error",

832

("long table comment is not defined in .frm"));

833

815

my_free(buff, MYF(0));

834

816

goto err;

835

817

}

856

838

{

857

839

if (share->mysql_version >= MYSQL_VERSION_TABLESPACE_IN_FRM)

858

840

{

859

DBUG_PRINT("error", ("Found no field extra info"));

860

841

goto err;

861

842

}

862

DBUG_PRINT("info", ("Found no field extra info"));

863

843

}

864

844

else

865

845

{

866

DBUG_PRINT("info", ("Found field extra info"));

867

846

const uint format_section_header_size= 8;

868

847

uint format_section_len= uint2korr(next_chunk+0);

869

848

uint flags= uint4korr(next_chunk+2);

885

864

next_chunk+= format_section_len;

886

865

}

887

866

}

888

DBUG_ASSERT (next_chunk <= buff_end);

867

assert (next_chunk <= buff_end);

889

868

if (next_chunk > buff_end)

890

869

{

891

DBUG_PRINT("error", ("Buffer overflow in field extra info"));

892

870

goto err;

893

871

}

894

872

}

922

900

share->comment.length);

923

901

}

924

902

925

DBUG_PRINT("info",("i_count: %d i_parts: %d index: %d n_length: %d int_length: %d com_length: %d", interval_count,interval_parts, share->keys,n_length,int_length, com_length));

926

903

927

904

if (!(field_ptr = (Field **)

928

905

alloc_root(&share->mem_root,

1028

1005

storage_type= (enum ha_storage_media)(tmp & STORAGE_TYPE_MASK);

1029

1006

column_format= (enum column_format_type)

1030

1007

((tmp >> COLUMN_FORMAT_SHIFT) & COLUMN_FORMAT_MASK);

1031

DBUG_PRINT("info", ("Field extra: storage %u format %u",

1032

storage_type, column_format));

1033

1008

}

1034

1009

if (new_frm_ver >= 3)

1035

1010

{

1436

1411

#endif

1437

1412

if (buff)

1438

1413

my_free(buff, MYF(0));

1439

DBUG_RETURN (0);

1414

return (0);

1440

1415

1441

1416

err:

1442

1417

if (buff)

1450

1425

hash_free(&share->name_hash);

1451

1426

1452

1427

open_table_error(share, error, share->open_errno, errarg);

1453

DBUG_RETURN(error);

1428

return(error);

1454

1429

} /* open_binary_frm */

1455

1430

1456

1431

1491

1466

bool error_reported= FALSE;

1492

1467

uchar *record, *bitmaps;

1493

1468

Field **field_ptr;

1494

DBUG_ENTER("open_table_from_share");

1495

DBUG_PRINT("enter",("name: '%s.%s' form: 0x%lx, open mode:%s",

1496

share->db.str,

1497

share->table_name.str,

1498

(long) outparam,

1499

(open_mode == OTM_OPEN)?"open":

1500

((open_mode == OTM_CREATE)?"create":"alter")));

1501

1469

1502

1470

/* Parsing of partitioning information from .frm needs thd->lex set up. */

1503

1471

DBUG_ASSERT(thd->lex->is_lex_started);

1696

1664

Too many files opened, use same error message as if the .frm

1697

1665

file can't open

1698

1666

*/

1699

DBUG_PRINT("error", ("open file: %s failed, too many files opened (errno: %d)",

1700

share->normalized_path.str, ha_err));

1701

1667

error= 1;

1702

1668

my_errno= EMFILE;

1703

1669

break;

1721

1687

HA_HAS_OWN_BINLOGGING);

1722

1688

thd->status_var.opened_tables++;

1723

1689

1724

DBUG_RETURN (0);

1690

return (0);

1725

1691

1726

1692

err:

1727

1693

if (!error_reported && !(prgflag & DONT_GIVE_ERROR))

1731

1697

outparam->db_stat=0;

1732

1698

free_root(&outparam->mem_root, MYF(0)); // Safe to call on bzero'd root

1733

1699

my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));

1734

DBUG_RETURN (error);

1700

return (error);

1735

1701

}

1736

1702

1737

1703

1747

1713

int closefrm(register TABLE *table, bool free_share)

1748

1714

{

1749

1715

int error=0;

1750

DBUG_ENTER("closefrm");

1751

DBUG_PRINT("enter", ("table: 0x%lx", (long) table));

1752

1716

1753

1717

if (table->db_stat)

1754

1718

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

1770

1734

free_table_share(table->s);

1771

1735

}

1772

1736

free_root(&table->mem_root, MYF(0));

1773

DBUG_RETURN(error);

1737

return(error);

1774

1738

}

1775

1739

1776

1740

1794

1758

uint a_length,names,length;

1795

1759

uchar *pos,*buf;

1796

1760

ulong ret_value=0;

1797

DBUG_ENTER("get_form_pos");

1798

1761

1799

1762

names=uint2korr(head+8);

1800

1763

a_length=(names+2)*sizeof(char *); /* Room for two extra */

1814

1777

MYF(MY_NABP)))

1815

1778

{ /* purecov: inspected */

1816

1779

x_free((uchar*) buf); /* purecov: inspected */

1817

DBUG_RETURN(0L); /* purecov: inspected */

1780

return(0L); /* purecov: inspected */

1818

1781

}

1819

1782

pos= buf+a_length+length;

1820

1783

ret_value=uint4korr(pos);

1832

1795

str=(char *) (buf+a_length);

1833

1796

fix_type_pointers((const char ***) &buf,save_names,1,&str);

1834

1797

}

1835

DBUG_RETURN(ret_value);

1798

return(ret_value);

1836

1799

}

1837

1800

1838

1801

1845

1808

1846

1809

int read_string(File file, uchar**to, size_t length)

1847

1810

{

1848

DBUG_ENTER("read_string");

1849

1811

1850

1812

x_free(*to);

1851

1813

if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||

1853

1815

{

1854

1816

x_free(*to); /* purecov: inspected */

1855

1817

*to= 0; /* purecov: inspected */

1856

DBUG_RETURN(1); /* purecov: inspected */

1818

return(1); /* purecov: inspected */

1857

1819

}

1858

1820

*((char*) *to+length)= '\0';

1859

DBUG_RETURN (0);

1821

return (0);

1860

1822

} /* read_string */

1861

1823

1862

1824

1869

1831

ulong endpos,newpos;

1870

1832

uchar buff[IO_SIZE];

1871

1833

uchar *pos;

1872

DBUG_ENTER("make_new_entry");

1873

1834

1874

1835

length=(uint) strlen(newname)+1;

1875

1836

n_length=uint2korr(fileinfo+4);

1888

1849

{

1889

1850

VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));

1890

1851

if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))

1891

DBUG_RETURN(0L);

1852

return(0L);

1892

1853

VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,

1893

1854

MYF(0)));

1894

1855

if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))

1895

DBUG_RETURN(0);

1856

return(0);

1896

1857

endpos-=bufflength; bufflength=IO_SIZE;

1897

1858

}

1898

1859

bzero(buff,IO_SIZE); /* Null new block */

1899

1860

VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));

1900

1861

if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))

1901

DBUG_RETURN(0L);

1862

return(0L);

1902

1863

maxlength+=IO_SIZE; /* Fix old ref */

1903

1864

int2store(fileinfo+6,maxlength);

1904

1865

for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;

1921

1882

(names && my_write(file,(uchar*) (*formnames->type_names+n_length-1),

1922

1883

names*4, MYF(MY_NABP+MY_WME))) ||

1923

1884

my_write(file, fileinfo+10, 4,MYF(MY_NABP+MY_WME)))

1924

DBUG_RETURN(0L); /* purecov: inspected */

1885

return(0L); /* purecov: inspected */

1925

1886

1926

1887

int2store(fileinfo+8,names+1);

1927

1888

int2store(fileinfo+4,n_length+length);

1928

1889

(void)ftruncate(file, newpos);/* Append file with '\0' */

1929

DBUG_RETURN(newpos);

1890

return(newpos);

1930

1891

} /* make_new_entry */

1931

1892

1932

1893

1937

1898

int err_no;

1938

1899

char buff[FN_REFLEN];

1939

1900

myf errortype= ME_ERROR+ME_WAITTANG;

1940

DBUG_ENTER("open_table_error");

1941

1901

1942

1902

switch (error) {

1943

1903

case 7:

2001

1961

my_error(ER_NOT_FORM_FILE, errortype, buff, 0);

2002

1962

break;

2003

1963

}

2004

DBUG_VOID_RETURN;

1964

return;

2005

1965

} /* open_table_error */

2006

1966

2007

1967

2307

2267

void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)

2308

2268

{

2309

2269

TABLE_SHARE *share= table->s;

2310

DBUG_ENTER("update_create_info_from_table");

2311

2270

2312

2271

create_info->max_rows= share->max_rows;

2313

2272

create_info->min_rows= share->min_rows;

2320

2279

create_info->table_charset= 0;

2321

2280

create_info->comment= share->comment;

2322

2281

2323

DBUG_VOID_RETURN;

2282

return;

2324

2283

}

2325

2284

2326

2285

int

2536

2495

uint i;

2537

2496

my_bool error= FALSE;

2538

2497

my_bool fields_diff_count;

2539

DBUG_ENTER("table_check_intact");

2540

DBUG_PRINT("info",("table: %s expected_count: %d",

2541

table->alias, table_f_count));

2542

2498

2543

2499

fields_diff_count= (table->s->fields != table_f_count);

2544

2500

if (fields_diff_count)

2545

2501

{

2546

DBUG_PRINT("info", ("Column count has changed, checking the definition"));

2547

2502

2548

2503

/* previous MySQL version */

2549

2504

if (MYSQL_VERSION_ID > table->s->mysql_version)

2551

2506

sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),

2552

2507

table->alias, table_f_count, table->s->fields,

2553

2508

table->s->mysql_version, MYSQL_VERSION_ID);

2554

DBUG_RETURN(TRUE);

2509

return(TRUE);

2555

2510

}

2556

2511

else if (MYSQL_VERSION_ID == table->s->mysql_version)

2557

2512

{

2558

2513

sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,

2559

2514

table_f_count, table->s->fields);

2560

DBUG_RETURN(TRUE);

2515

return(TRUE);

2561

2516

}

2562

2517

/*

2563

2518

Something has definitely changed, but we're running an older

2648

2603

error= TRUE;

2649

2604

}

2650

2605

}

2651

DBUG_RETURN(error);

2606

return(error);

2652

2607

}

2653

2608

2654

2609

2733

2688

static Item *

2734

2689

merge_on_conds(THD *thd, TABLE_LIST *table, bool is_cascaded)

2735

2690

{

2736

DBUG_ENTER("merge_on_conds");

2737

2691

2738

2692

Item *cond= NULL;

2739

DBUG_PRINT("info", ("alias: %s", table->alias));

2740

2693

if (table->on_expr)

2741

2694

cond= table->on_expr->copy_andor_structure(thd);

2742

2695

if (!table->nested_join)

2743

DBUG_RETURN(cond);

2696

return(cond);

2744

2697

List_iterator<TABLE_LIST> li(table->nested_join->join_list);

2745

2698

while (TABLE_LIST *tbl= li++)

2746

2699

{

2747

2700

cond= and_conds(cond, merge_on_conds(thd, tbl, is_cascaded));

2748

2701

}

2749

DBUG_RETURN(cond);

2702

return(cond);

2750

2703

}

2751

2704

2752

2705

3082

3035

Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,

3083

3036

const char *name)

3084

3037

{

3085

DBUG_ENTER("create_view_field");

3086

3038

if (view->schema_table_reformed)

3087

3039

{

3088

3040

Item *field= *field_ref;

3093

3045

field. This case happens only for 'show & where' commands.

3094

3046

*/

3095

3047

DBUG_ASSERT(field && field->fixed);

3096

DBUG_RETURN(field);

3048

return(field);

3097

3049

}

3098

3050

3099

DBUG_RETURN(NULL);

3051

return(NULL);

3100

3052

}

3101

3053

3102

3054

3119

3071

3120

3072

void Field_iterator_table_ref::set_field_iterator()

3121

3073

{

3122

DBUG_ENTER("Field_iterator_table_ref::set_field_iterator");

3123

3074

/*

3124

3075

If the table reference we are iterating over is a natural join, or it is

3125

3076

an operand of a natural join, and TABLE_LIST::join_columns contains all

3143

3094

table_ref->join_columns->elements ==

3144

3095

table_ref->table->s->fields)));

3145

3096

field_it= &natural_join_it;

3146

DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",

3147

table_ref->alias));

3148

3097

}

3149

3098

/* This is a base table or stored view. */

3150

3099

else

3151

3100

{

3152

3101

DBUG_ASSERT(table_ref->table);

3153

3102

field_it= &table_field_it;

3154

DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_table",

3155

table_ref->alias));

3156

3103

}

3157

3104

field_it->set(table_ref);

3158

DBUG_VOID_RETURN;

3105

return;

3159

3106

}

3160

3107

3161

3108

3388

3335

3389

3336

void st_table::prepare_for_position()

3390

3337

{

3391

DBUG_ENTER("st_table::prepare_for_position");

3392

3338

3393

3339

if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&

3394

3340

s->primary_key < MAX_KEY)

3397

3343

/* signal change */

3398

3344

file->column_bitmaps_signal();

3399

3345

}

3400

DBUG_VOID_RETURN;

3346

return;

3401

3347

}

3402

3348

3403

3349

3414

3360

void st_table::mark_columns_used_by_index(uint index)

3415

3361

{

3416

3362

MY_BITMAP *bitmap= &tmp_set;

3417

DBUG_ENTER("st_table::mark_columns_used_by_index");

3418

3363

3419

3364

(void) file->extra(HA_EXTRA_KEYREAD);

3420

3365

bitmap_clear_all(bitmap);

3421

3366

mark_columns_used_by_index_no_reset(index, bitmap);

3422

3367

column_bitmaps_set(bitmap, bitmap);

3423

DBUG_VOID_RETURN;

3368

return;

3424

3369

}

3425

3370

3426

3371

3437

3382

3438

3383

void st_table::restore_column_maps_after_mark_index()

3439

3384

{

3440

DBUG_ENTER("st_table::restore_column_maps_after_mark_index");

3441

3385

3442

3386

key_read= 0;

3443

3387

(void) file->extra(HA_EXTRA_NO_KEYREAD);

3444

3388

default_column_bitmaps();

3445

3389

file->column_bitmaps_signal();

3446

DBUG_VOID_RETURN;

3390

return;

3447

3391

}

3448

3392

3449

3393

3555

3499

3556

3500

void st_table::mark_columns_needed_for_update()

3557

3501

{

3558

DBUG_ENTER("mark_columns_needed_for_update");

3559

3502

if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)

3560

3503

{

3561

3504

/* Mark all used key columns for read */

3585

3528

file->column_bitmaps_signal();

3586

3529

}

3587

3530

}

3588

DBUG_VOID_RETURN;

3531

return;

3589

3532

}

3590

3533

3591

3534

3854

3797

File file;

3855

3798

uchar header[10]; /* This should be optimized */

3856

3799

int error;

3857

DBUG_ENTER("mysql_frm_type");

3858

3800

3859

3801

*dbt= DB_TYPE_UNKNOWN;

3860

3802

3861

3803

if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)

3862

DBUG_RETURN(FRMTYPE_ERROR);

3804

return(FRMTYPE_ERROR);

3863

3805

error= my_read(file, (uchar*) header, sizeof(header), MYF(MY_NABP));

3864

3806

my_close(file, MYF(MY_WME));

3865

3807

3866

3808

if (error)

3867

DBUG_RETURN(FRMTYPE_ERROR);

3809

return(FRMTYPE_ERROR);

3868

3810

3869

3811

/*

3870

3812

This is just a check for DB_TYPE. We'll return default unknown type

3874

3816

if (header[0] != (uchar) 254 || header[1] != 1 ||

3875

3817

(header[2] != FRM_VER && header[2] != FRM_VER+1 &&

3876

3818

(header[2] < FRM_VER+3 || header[2] > FRM_VER+4)))

3877

DBUG_RETURN(FRMTYPE_TABLE);

3819

return(FRMTYPE_TABLE);

3878

3820

3879

3821

*dbt= (enum legacy_db_type) (uint) *(header + 3);

3880

DBUG_RETURN(FRMTYPE_TABLE); // Is probably a .frm table

3822

return(FRMTYPE_TABLE); // Is probably a .frm table

3881

3823

}

3882

3824

3883

3825