« back to all changes in this revision
Viewing changes to drizzled/table.cc
- browse files at revision 903
- compare with another revision
- compare with revision 2473
- download diff
- download tarball
- view history from revision 903
- Committer: Brian Aker
- Date: 2009-02-27 18:24:12 UTC
- mfrom: (896.4.8 nofrm896)
- Revision ID: brian@tangent.org-20090227182412-2llu8uxo4j2o0cje
Merge Stewart
- files modified:
- drizzled/serialize/table_reader.cc
added
removed
drizzled/table.cc
53
53
54
54
void open_table_error(TABLE_SHARE *share, int error, int db_errno,
55
55
myf errortype, int errarg);
56
static int open_binary_frm(Session *session, TABLE_SHARE *share,
57
unsigned char *head, File file);
58
56
static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
59
57
uint32_t types, char **names);
60
58
411
409
412
410
int parse_table_proto(Session *session, drizzle::Table &table, TABLE_SHARE *share)
413
411
{
412
int error= 0;
413
414
414
{
415
415
LEX_STRING engine_name= { (char*)table.engine().name().c_str(),
416
416
strlen(table.engine().name().c_str()) };
417
417
share->db_plugin= ha_resolve_by_name(session, &engine_name);
418
418
}
419
419
420
// share->db_create_options FAIL
421
// share->db_options_in_use FAIL
422
420
share->mysql_version= DRIZZLE_VERSION_ID; // TODO: remove
423
421
424
422
drizzle::Table::TableOptions table_options;
426
424
if(table.has_options())
427
425
table_options= table.options();
428
426
427
uint32_t db_create_options= HA_OPTION_LONG_BLOB_PTR;
428
429
if(table_options.has_pack_keys())
430
{
431
if(table_options.pack_keys())
432
db_create_options|= HA_OPTION_PACK_KEYS;
433
else
434
db_create_options|= HA_OPTION_NO_PACK_KEYS;
435
}
436
437
if(table_options.pack_record())
438
db_create_options|= HA_OPTION_PACK_RECORD;
439
440
if(table_options.has_checksum())
441
{
442
if(table_options.checksum())
443
db_create_options|= HA_OPTION_CHECKSUM;
444
else
445
db_create_options|= HA_OPTION_NO_CHECKSUM;
446
}
447
448
if(table_options.has_delay_key_write())
449
{
450
if(table_options.delay_key_write())
451
db_create_options|= HA_OPTION_DELAY_KEY_WRITE;
452
else
453
db_create_options|= HA_OPTION_NO_DELAY_KEY_WRITE;
454
}
455
456
/* db_create_options was stored as 2 bytes in FRM
457
Any HA_OPTION_ that doesn't fit into 2 bytes was silently truncated away.
458
*/
459
share->db_create_options= (db_create_options & 0x0000FFFF);
460
share->db_options_in_use= share->db_create_options;
461
462
429
463
share->avg_row_length= table_options.has_avg_row_length() ?
430
464
table_options.avg_row_length() : 0;
431
465
774
808
stored_columns_reclength+= field_pack_length[fieldnr];
775
809
}
776
810
}
811
share->null_fields= null_fields;
777
812
778
813
ulong null_bits= null_fields;
779
814
if(!table_options.pack_record())
1300
1335
else
1301
1336
share->primary_key= MAX_KEY;
1302
1337
1303
delete handler_file;
1304
1305
return 0;
1338
if (share->found_next_number_field)
1339
{
1340
Field *reg_field= *share->found_next_number_field;
1341
if ((int) (share->next_number_index= (uint32_t)
1342
find_ref_key(share->key_info, share->keys,
1343
share->default_values, reg_field,
1344
&share->next_number_key_offset,
1345
&share->next_number_keypart)) < 0)
1346
{
1347
/* Wrong field definition */
1348
error= 4;
1349
goto err;
1350
}
1351
else
1352
reg_field->flags |= AUTO_INCREMENT_FLAG;
1353
}
1354
1355
if (share->blob_fields)
1356
{
1357
Field **ptr;
1358
uint32_t k, *save;
1359
1360
/* Store offsets to blob fields to find them fast */
1361
if (!(share->blob_field= save=
1362
(uint*) alloc_root(&share->mem_root,
1363
(uint32_t) (share->blob_fields* sizeof(uint32_t)))))
1364
goto err;
1365
for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
1366
{
1367
if ((*ptr)->flags & BLOB_FLAG)
1368
(*save++)= k;
1369
}
1370
}
1371
1372
share->db_low_byte_first= handler_file->low_byte_first();
1373
share->column_bitmap_size= bitmap_buffer_size(share->fields);
1374
1375
my_bitmap_map *bitmaps;
1376
1377
if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1378
share->column_bitmap_size)))
1379
goto err;
1380
bitmap_init(&share->all_set, bitmaps, share->fields, false);
1381
bitmap_set_all(&share->all_set);
1382
1383
delete handler_file;
1384
return (0);
1385
1386
err:
1387
share->error= error;
1388
share->open_errno= my_errno;
1389
share->errarg= 0;
1390
hash_free(&share->name_hash);
1391
delete handler_file;
1392
open_table_error(share, error, share->open_errno, 0);
1393
return error;
1306
1394
}
1307
1395
1308
1396
/*
1332
1420
1333
1421
int open_table_def(Session *session, TABLE_SHARE *share, uint32_t)
1334
1422
{
1335
int error, table_type;
1423
int error;
1336
1424
bool error_given;
1337
File file;
1338
unsigned char head[64], *disk_buff;
1339
1425
string path("");
1340
1426
1341
MEM_ROOT **root_ptr, *old_root;
1342
1343
1427
error= 1;
1344
1428
error_given= 0;
1345
disk_buff= NULL;
1346
1429
1347
1430
path.reserve(FN_REFLEN);
1348
1431
path.append(share->normalized_path.str);
1373
1456
1374
1457
parse_table_proto(session, table, share);
1375
1458
1376
/* end of proto code... now to get some scraps from FRM */
1377
1378
if ((file= open(path.c_str(), O_RDONLY)) < 0)
1379
{
1380
/*
1381
We don't try to open 5.0 unencoded name, if
1382
- non-encoded name contains '@' signs,
1383
because '@' can be misinterpreted.
1384
It is not clear if '@' is escape character in 5.1,
1385
or a normal character in 5.0.
1386
1387
- non-encoded db or table name contain "#mysql50#" prefix.
1388
This kind of tables must have been opened only by the
1389
open() above.
1390
*/
1391
if (strchr(share->table_name.str, '@') ||
1392
!strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX,
1393
MYSQL50_TABLE_NAME_PREFIX_LENGTH) ||
1394
!strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX,
1395
MYSQL50_TABLE_NAME_PREFIX_LENGTH))
1396
goto err_not_open;
1397
1398
/* Try unencoded 5.0 name */
1399
size_t length;
1400
char unpacked_path[FN_REFLEN];
1401
path.clear();
1402
path.append(drizzle_data_home);
1403
path.append("/");
1404
path.append(share->db.str);
1405
path.append("/");
1406
path.append(share->table_name.str);
1407
path.append(reg_ext);
1408
length= unpack_filename(unpacked_path, path.c_str()) - reg_ext_length;
1409
/*
1410
The following is a safety test and should never fail
1411
as the old file name should never be longer than the new one.
1412
*/
1413
assert(length <= share->normalized_path.length);
1414
/*
1415
If the old and the new names have the same length,
1416
then table name does not have tricky characters,
1417
so no need to check the old file name.
1418
*/
1419
if (length == share->normalized_path.length ||
1420
((file= open(unpacked_path, O_RDONLY)) < 0))
1421
goto err_not_open;
1422
1423
/* Unencoded 5.0 table name found */
1424
unpacked_path[length]= '\0'; // Remove .frm extension
1425
strcpy(share->normalized_path.str, unpacked_path);
1426
share->normalized_path.length= length;
1427
}
1428
1429
error= 4;
1430
if (my_read(file, head, 64, MYF(MY_NABP)))
1431
goto err;
1432
1433
if (head[0] == (unsigned char) 254 && head[1] == 1)
1434
{
1435
if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
1436
(head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
1437
{
1438
table_type= 1;
1439
}
1440
else
1441
{
1442
error= 6; // Unkown .frm version
1443
goto err;
1444
}
1445
}
1446
else
1447
goto err;
1448
1449
/* No handling of text based files yet */
1450
if (table_type == 1)
1451
{
1452
root_ptr= current_mem_root_ptr();
1453
old_root= *root_ptr;
1454
*root_ptr= &share->mem_root;
1455
error= open_binary_frm(session, share, head, file);
1456
*root_ptr= old_root;
1457
error_given= 1;
1458
}
1459
else
1460
assert(1);
1461
1462
1459
share->table_category= get_table_category(& share->db, & share->table_name);
1463
1460
1464
1461
if (!error)
1465
1462
session->status_var.opened_shares++;
1466
1463
1467
err:
1468
my_close(file, MYF(MY_WME));
1469
1470
1464
err_not_open:
1471
1465
if (error && !error_given)
1472
1466
{
1477
1471
return(error);
1478
1472
}
1479
1473
1480
1481
/*
1482
Read data from a binary .frm file from MySQL 3.23 - 5.0 into TABLE_SHARE
1483
*/
1484
1485
static int open_binary_frm(Session *session, TABLE_SHARE *share, unsigned char *head,
1486
File file)
1487
{
1488
int error, errarg= 0;
1489
uint32_t new_frm_ver, field_pack_length, new_field_pack_flag;
1490
uint32_t interval_count, interval_parts, read_length, int_length;
1491
uint32_t db_create_options, keys, key_parts, n_length;
1492
uint32_t key_info_length, com_length;
1493
uint32_t vcol_screen_length;
1494
uint32_t i,j;
1495
unsigned char forminfo[288];
1496
char *names, *comment_pos, *vcol_screen_pos;
1497
unsigned char *record;
1498
unsigned char *disk_buff, *strpos;
1499
ulong pos, record_offset, rec_buff_length;
1500
handler *handler_file= 0;
1501
KEY *keyinfo;
1502
KEY_PART_INFO *key_part;
1503
Field **field_ptr, *reg_field;
1504
const char **interval_array;
1505
my_bitmap_map *bitmaps;
1506
unsigned char *buff= 0;
1507
unsigned char *field_extra_info= 0;
1508
1509
new_field_pack_flag= head[27];
1510
new_frm_ver= (head[2] - FRM_VER);
1511
assert(new_frm_ver >= 2); /* If this fails, we're on old FRM */
1512
field_pack_length= 17;
1513
disk_buff= 0;
1514
1515
error= 3;
1516
if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
1517
goto err; /* purecov: inspected */
1518
lseek(file,pos,SEEK_SET);
1519
if (my_read(file,forminfo,288,MYF(MY_NABP)))
1520
goto err;
1521
1522
share->db_create_options= db_create_options= uint2korr(head+30);
1523
share->db_options_in_use= share->db_create_options;
1524
1525
error=4;
1526
1527
/* Read keyinformation */
1528
key_info_length= (uint32_t) uint2korr(head+28);
1529
lseek(file,(ulong) uint2korr(head+6),SEEK_SET);
1530
if (read_string(file,(unsigned char**) &disk_buff,key_info_length))
1531
goto err; /* purecov: inspected */
1532
if (disk_buff[0] & 0x80)
1533
{
1534
/*share->keys=*/ keys= (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
1535
/*share->key_parts=*/ key_parts= uint2korr(disk_buff+2);
1536
}
1537
else
1538
{
1539
/*share->keys= */keys= disk_buff[0];
1540
/*share->key_parts=*/ key_parts= disk_buff[1];
1541
}
1542
1543
/* the magic uint2korr(disk_buff+4) is the key names size */
1544
1545
keyinfo= share->key_info;
1546
key_part= reinterpret_cast<KEY_PART_INFO*> (keyinfo+keys);
1547
strpos=disk_buff+6;
1548
1549
for (i=0 ; i < keys ; i++, keyinfo++)
1550
{
1551
if (new_frm_ver >= 3)
1552
{
1553
strpos+=8;
1554
}
1555
1556
for (j=keyinfo->key_parts ; j-- ; key_part++)
1557
{
1558
if (new_frm_ver >= 1)
1559
{
1560
strpos+=9;
1561
}
1562
else
1563
{
1564
abort(); // Old FRM version, we abort as we should never see it.
1565
}
1566
}
1567
}
1568
1569
// keynames=(char*) key_part;
1570
// strpos+= (strcpy(keynames, (char*)strpos)+strlen((char*)strpos)-keynames)+1;
1571
1572
//reading index comments
1573
for (keyinfo= share->key_info, i=0; i < keys; i++, keyinfo++)
1574
{
1575
if (keyinfo->flags & HA_USES_COMMENT)
1576
{
1577
// keyinfo->comment.length= uint2korr(strpos);
1578
// keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos+2,
1579
// keyinfo->comment.length);
1580
strpos+= 2 + uint2korr(strpos);//keyinfo->comment.length;
1581
}
1582
// assert(test(keyinfo->flags & HA_USES_COMMENT) ==
1583
// (keyinfo->comment.length > 0));
1584
}
1585
1586
assert(share->reclength == uint2korr((head+16)));
1587
1588
record_offset= (ulong) (uint2korr(head+6)+
1589
((uint2korr(head+14) == 0xffff ?
1590
uint4korr(head+47) : uint2korr(head+14))));
1591
1592
if ((n_length= uint4korr(head+55)))
1593
{
1594
/* Read extra data segment */
1595
unsigned char *next_chunk, *buff_end;
1596
if (!(next_chunk= buff= (unsigned char*) malloc(n_length)))
1597
goto err;
1598
if (pread(file, buff, n_length, record_offset + share->reclength) == 0)
1599
{
1600
goto err;
1601
}
1602
1603
uint32_t connect_str_length= uint2korr(buff);
1604
next_chunk+= connect_str_length + 2;
1605
1606
buff_end= buff + n_length;
1607
if (next_chunk + 2 < buff_end)
1608
{
1609
uint32_t str_db_type_length= uint2korr(next_chunk);
1610
next_chunk+= str_db_type_length + 2;
1611
}
1612
if (share->mysql_version >= 50110)
1613
{
1614
/* New auto_partitioned indicator introduced in 5.1.11 */
1615
next_chunk++;
1616
}
1617
if (forminfo[46] == (unsigned char)255)
1618
{
1619
//reading long table comment
1620
if (next_chunk + 2 > buff_end)
1621
{
1622
free(buff);
1623
goto err;
1624
}
1625
uint32_t comment_str_length= uint2korr(next_chunk);
1626
next_chunk+= 2 + comment_str_length;
1627
}
1628
assert(next_chunk <= buff_end);
1629
if (share->mysql_version >= DRIZZLE_VERSION_TABLESPACE_IN_FRM_CGE)
1630
{
1631
/*
1632
New frm format in mysql_version 5.2.5 (originally in
1633
mysql-5.1.22-ndb-6.2.5)
1634
New column properties added:
1635
COLUMN_FORMAT DYNAMIC|FIXED and STORAGE DISK|MEMORY
1636
TABLESPACE name is now stored in frm
1637
*/
1638
if (next_chunk >= buff_end)
1639
{
1640
if (share->mysql_version >= DRIZZLE_VERSION_TABLESPACE_IN_FRM)
1641
{
1642
goto err;
1643
}
1644
}
1645
else
1646
{
1647
const uint32_t format_section_header_size= 8;
1648
uint32_t format_section_len= uint2korr(next_chunk+0);
1649
uint32_t flags= uint4korr(next_chunk+2);
1650
1651
(void)flags;
1652
1653
const char *tablespace= (const char*)next_chunk + format_section_header_size;
1654
uint32_t tablespace_len= strlen(tablespace);
1655
1656
field_extra_info= next_chunk + format_section_header_size + tablespace_len + 1;
1657
next_chunk+= format_section_len;
1658
}
1659
}
1660
assert (next_chunk <= buff_end);
1661
if (next_chunk > buff_end)
1662
{
1663
goto err;
1664
}
1665
}
1666
1667
error=4;
1668
/* head+59 was extra_rec_buf_length */
1669
rec_buff_length= ALIGN_SIZE(share->reclength + 1);
1670
1671
if (!(record= (unsigned char *) alloc_root(&share->mem_root,
1672
rec_buff_length)))
1673
goto err; /* purecov: inspected */
1674
1675
if (pread(file, record, (size_t) share->reclength, record_offset) == 0)
1676
goto err; /* purecov: inspected */
1677
1678
assert(memcmp(share->default_values, record, share->reclength)==0);
1679
1680
lseek(file,pos+288,SEEK_SET);
1681
1682
// share->fields= uint2korr(forminfo+258);
1683
pos= uint2korr(forminfo+260); /* Length of all screens */
1684
n_length= uint2korr(forminfo+268);
1685
interval_count= uint2korr(forminfo+270);
1686
interval_parts= uint2korr(forminfo+272);
1687
int_length= uint2korr(forminfo+274);
1688
share->null_fields= uint2korr(forminfo+282);
1689
com_length= uint2korr(forminfo+284);
1690
vcol_screen_length= uint2korr(forminfo+286);
1691
// share->vfields= 0;
1692
// share->stored_fields= share->fields;
1693
1694
1695
/* WTF is with the share->fields+1 here... */
1696
if (!(field_ptr = (Field **)
1697
alloc_root(&share->mem_root,
1698
(uint32_t) ((share->fields+1)*sizeof(Field*)+
1699
interval_count*sizeof(TYPELIB)+
1700
(share->fields+interval_parts+
1701
keys+3)*sizeof(char *)+
1702
(n_length+int_length+
1703
vcol_screen_length)))))
1704
goto err; /* purecov: inspected */
1705
1706
// share->field= field_ptr;
1707
read_length=(uint32_t) (share->fields * field_pack_length +
1708
pos+ (uint32_t) (n_length+int_length+com_length+
1709
vcol_screen_length));
1710
if (read_string(file,(unsigned char**) &disk_buff,read_length))
1711
goto err; /* purecov: inspected */
1712
strpos= disk_buff+pos;
1713
1714
// share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
1715
interval_array= (const char **) ((field_ptr+share->fields+1)+interval_count);
1716
names= (char*) (interval_array+share->fields+interval_parts+keys+3);
1717
1718
memcpy(names, strpos+(share->fields*field_pack_length),
1719
(uint32_t) (n_length+int_length));
1720
comment_pos= (char *)(disk_buff+read_length-com_length-vcol_screen_length);
1721
vcol_screen_pos= names+(n_length+int_length);
1722
memcpy(vcol_screen_pos, disk_buff+read_length-vcol_screen_length,
1723
vcol_screen_length);
1724
1725
// fix_type_pointers(&interval_array, &share->fieldnames, 1, &names);
1726
assert(share->fieldnames.count == share->fields);
1727
1728
/* if (keynames)
1729
fix_type_pointers(&interval_array, &share->keynames, 1, &keynames);*/
1730
1731
/* Allocate handler */
1732
if (!(handler_file= get_new_handler(share, session->mem_root,
1733
share->db_type())))
1734
goto err;
1735
1736
record= share->default_values-1; /* Fieldstart = 1 */
1737
1738
/* Sanity checks: */
1739
assert(share->fields>=share->stored_fields);
1740
assert(share->reclength>=share->stored_rec_length);
1741
1742
1743
if (disk_buff)
1744
free(disk_buff);
1745
disk_buff= NULL;
1746
1747
if (share->found_next_number_field)
1748
{
1749
reg_field= *share->found_next_number_field;
1750
if ((int) (share->next_number_index= (uint32_t)
1751
find_ref_key(share->key_info, share->keys,
1752
share->default_values, reg_field,
1753
&share->next_number_key_offset,
1754
&share->next_number_keypart)) < 0)
1755
{
1756
/* Wrong field definition */
1757
error= 4;
1758
goto err;
1759
}
1760
else
1761
reg_field->flags |= AUTO_INCREMENT_FLAG;
1762
}
1763
1764
if (share->blob_fields)
1765
{
1766
Field **ptr;
1767
uint32_t k, *save;
1768
1769
/* Store offsets to blob fields to find them fast */
1770
if (!(share->blob_field= save=
1771
(uint*) alloc_root(&share->mem_root,
1772
(uint32_t) (share->blob_fields* sizeof(uint32_t)))))
1773
goto err;
1774
for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
1775
{
1776
if ((*ptr)->flags & BLOB_FLAG)
1777
(*save++)= k;
1778
}
1779
}
1780
1781
/*
1782
the correct null_bytes can now be set, since bitfields have been taken
1783
into account
1784
*/
1785
1786
share->db_low_byte_first= handler_file->low_byte_first();
1787
share->column_bitmap_size= bitmap_buffer_size(share->fields);
1788
1789
if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1790
share->column_bitmap_size)))
1791
goto err;
1792
bitmap_init(&share->all_set, bitmaps, share->fields, false);
1793
bitmap_set_all(&share->all_set);
1794
1795
delete handler_file;
1796
if (buff)
1797
free(buff);
1798
return (0);
1799
1800
err:
1801
if (buff)
1802
free(buff);
1803
share->error= error;
1804
share->open_errno= my_errno;
1805
share->errarg= errarg;
1806
if (disk_buff)
1807
free(disk_buff);
1808
delete handler_file;
1809
hash_free(&share->name_hash);
1810
1811
open_table_error(share, error, share->open_errno, errarg);
1812
return(error);
1813
} /* open_binary_frm */
1814
1815
1816
1474
/*
1817
1475
Clear flag GET_FIXED_FIELDS_FLAG in all fields of the table.
1818
1476
This routine is used for error handling purposes.
Loggerhead is a web-based interface for Breezy
Version: 2.0.1