17
17
/* Some general useful functions */
28
#include <drizzled/error.h>
29
#include <drizzled/gettext.h>
31
#include "drizzled/plugin/transactional_storage_engine.h"
32
#include "drizzled/plugin/authorization.h"
33
#include <drizzled/nested_join.h>
34
#include <drizzled/sql_parse.h>
35
#include <drizzled/item/sum.h>
36
#include <drizzled/table_list.h>
37
#include <drizzled/session.h>
38
#include <drizzled/sql_base.h>
39
#include <drizzled/sql_select.h>
40
#include <drizzled/field/blob.h>
41
#include <drizzled/field/varstring.h>
42
#include <drizzled/field/double.h>
43
#include <drizzled/unireg.h>
44
#include <drizzled/message/table.pb.h>
45
#include "drizzled/sql_table.h"
46
#include "drizzled/charset.h"
47
#include "drizzled/internal/m_string.h"
48
#include "plugin/myisam/myisam.h"
50
#include <drizzled/item/string.h>
51
#include <drizzled/item/int.h>
52
#include <drizzled/item/decimal.h>
53
#include <drizzled/item/float.h>
54
#include <drizzled/item/null.h>
55
#include <drizzled/temporal.h>
57
#include "drizzled/table_share_instance.h"
59
#include "drizzled/table_proto.h"
66
extern pid_t current_pid;
67
extern plugin::StorageEngine *heap_engine;
68
extern plugin::StorageEngine *myisam_engine;
70
/* Functions defined in this cursor */
72
void open_table_error(TableShare *share, int error, int db_errno,
19
#include "mysql_priv.h"
23
/* INFORMATION_SCHEMA name */
24
LEX_STRING INFORMATION_SCHEMA_NAME= {C_STRING_WITH_LEN("information_schema")};
26
/* MYSQL_SCHEMA name */
27
LEX_STRING MYSQL_SCHEMA_NAME= {C_STRING_WITH_LEN("mysql")};
29
/* Functions defined in this file */
31
void open_table_error(TABLE_SHARE *share, int error, int db_errno,
73
32
myf errortype, int errarg);
33
static int open_binary_frm(THD *thd, TABLE_SHARE *share,
34
uchar *head, File file);
35
static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
36
uint types, char **names);
37
static uint find_field(Field **fields, uchar *record, uint start, uint length);
39
inline bool is_system_table_name(const char *name, uint length);
41
/**************************************************************************
42
Object_creation_ctx implementation.
43
**************************************************************************/
45
Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
47
Object_creation_ctx *backup_ctx;
48
DBUG_ENTER("Object_creation_ctx::set_n_backup");
50
backup_ctx= create_backup_ctx(thd);
53
DBUG_RETURN(backup_ctx);
56
void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
61
backup_ctx->change_env(thd);
66
/**************************************************************************
67
Default_object_creation_ctx implementation.
68
**************************************************************************/
70
Default_object_creation_ctx::Default_object_creation_ctx(THD *thd)
71
: m_client_cs(thd->variables.character_set_client),
72
m_connection_cl(thd->variables.collation_connection)
75
Default_object_creation_ctx::Default_object_creation_ctx(
76
CHARSET_INFO *client_cs, CHARSET_INFO *connection_cl)
77
: m_client_cs(client_cs),
78
m_connection_cl(connection_cl)
82
Default_object_creation_ctx::create_backup_ctx(THD *thd) const
84
return new Default_object_creation_ctx(thd);
87
void Default_object_creation_ctx::change_env(THD *thd) const
89
thd->variables.character_set_client= m_client_cs;
90
thd->variables.collation_connection= m_connection_cl;
92
thd->update_charset();
75
95
/*************************************************************************/
77
// @note this should all be the destructor
78
int Table::delete_table(bool free_share)
83
error= cursor->close();
88
for (Field **ptr=field ; *ptr ; ptr++)
97
/* Get column name from column hash */
99
static uchar *get_field_name(Field **buff, size_t *length,
100
my_bool not_used __attribute__((unused)))
102
*length= (uint) strlen((*buff)->field_name);
103
return (uchar*) (*buff)->field_name;
108
Returns pointer to '.frm' extension of the file name.
115
Checks file name part starting with the rightmost '.' character,
116
and returns it if it is equal to '.frm'.
119
It is a good idea to get rid of this function modifying the code
120
to garantee that the functions presently calling fn_rext() always
121
get arguments in the same format: either with '.frm' or without '.frm'.
124
Pointer to the '.frm' extension. If there is no extension,
125
or extension is not '.frm', pointer at the end of file name.
128
char *fn_rext(char *name)
130
char *res= strrchr(name, '.');
131
if (res && !strcmp(res, reg_ext))
133
return name + strlen(name);
136
TABLE_CATEGORY get_table_category(const LEX_STRING *db, const LEX_STRING *name)
138
DBUG_ASSERT(db != NULL);
139
DBUG_ASSERT(name != NULL);
141
if ((db->length == INFORMATION_SCHEMA_NAME.length) &&
142
(my_strcasecmp(system_charset_info,
143
INFORMATION_SCHEMA_NAME.str,
146
return TABLE_CATEGORY_INFORMATION;
149
if ((db->length == MYSQL_SCHEMA_NAME.length) &&
150
(my_strcasecmp(system_charset_info,
151
MYSQL_SCHEMA_NAME.str,
154
if (is_system_table_name(name->str, name->length))
156
return TABLE_CATEGORY_SYSTEM;
160
return TABLE_CATEGORY_USER;
165
Allocate a setup TABLE_SHARE structure
169
TABLE_LIST Take database and table name from there
170
key Table cache key (db \0 table_name \0...)
171
key_length Length of key
174
0 Error (out of memory)
178
TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
183
char *key_buff, *path_buff;
184
char path[FN_REFLEN];
186
DBUG_ENTER("alloc_table_share");
187
DBUG_PRINT("enter", ("table: '%s'.'%s'",
188
table_list->db, table_list->table_name));
190
path_length= build_table_filename(path, sizeof(path) - 1,
192
table_list->table_name, "", 0);
193
init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
194
if (multi_alloc_root(&mem_root,
195
&share, sizeof(*share),
196
&key_buff, key_length,
197
&path_buff, path_length + 1,
200
bzero((char*) share, sizeof(*share));
202
share->set_table_cache_key(key_buff, key, key_length);
204
share->path.str= path_buff;
205
share->path.length= path_length;
206
strmov(share->path.str, path);
207
share->normalized_path.str= share->path.str;
208
share->normalized_path.length= path_length;
210
share->version= refresh_version;
212
share->tablespace= NULL;
215
This constant is used to mark that no table map version has been
216
assigned. No arithmetic is done on the value: it will be
217
overwritten with a value taken from MYSQL_BIN_LOG.
219
share->table_map_version= ~(uint64_t)0;
222
Since alloc_table_share() can be called without any locking (for
223
example, ha_create_table... functions), we do not assign a table
224
map id here. Instead we assign a value that is not used
225
elsewhere, and then assign a table map id inside open_table()
226
under the protection of the LOCK_open mutex.
228
share->table_map_id= ~0UL;
229
share->cached_row_logging_check= -1;
231
memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
232
pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
233
pthread_cond_init(&share->cond, NULL);
240
Initialize share for temporary tables
243
init_tmp_table_share()
246
key Table_cache_key, as generated from create_table_def_key.
247
must start with db name.
248
key_length Length of key
249
table_name Table name
250
path Path to file (possible in lower case) without .frm
253
This is different from alloc_table_share() because temporary tables
254
don't have to be shared between threads or put into the table def
255
cache, so we can do some things notable simpler and faster
257
If table is not put in thd->temporary_tables (happens only when
258
one uses OPEN TEMPORARY) then one can specify 'db' as key and
259
use key_length= 0 as neither table_cache_key or key_length will be used).
262
void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
263
uint key_length, const char *table_name,
266
DBUG_ENTER("init_tmp_table_share");
267
DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));
269
bzero((char*) share, sizeof(*share));
270
init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
271
share->table_category= TABLE_CATEGORY_TEMPORARY;
272
share->tmp_table= INTERNAL_TMP_TABLE;
273
share->db.str= (char*) key;
274
share->db.length= strlen(key);
275
share->table_cache_key.str= (char*) key;
276
share->table_cache_key.length= key_length;
277
share->table_name.str= (char*) table_name;
278
share->table_name.length= strlen(table_name);
279
share->path.str= (char*) path;
280
share->normalized_path.str= (char*) path;
281
share->path.length= share->normalized_path.length= strlen(path);
282
share->frm_version= FRM_VER_TRUE_VARCHAR;
283
share->tablespace= NULL;
285
Temporary tables are not replicated, but we set up these fields
286
anyway to be able to catch errors.
288
share->table_map_version= ~(uint64_t)0;
289
share->cached_row_logging_check= -1;
292
table_map_id is also used for MERGE tables to suppress repeated
293
compatibility checks.
295
share->table_map_id= (ulong) thd->query_id;
302
Free table share and memory used by it
309
share->mutex must be locked when we come here if it's not a temp table
312
void free_table_share(TABLE_SHARE *share)
315
DBUG_ENTER("free_table_share");
316
DBUG_PRINT("enter", ("table: %s.%s", share->db.str, share->table_name.str));
317
DBUG_ASSERT(share->ref_count == 0);
320
If someone is waiting for this to be deleted, inform it about this.
321
Don't do a delete until we know that no one is refering to this anymore.
323
if (share->tmp_table == NO_TMP_TABLE)
325
/* share->mutex is locked in release_table_share() */
326
while (share->waiting_on_cond)
328
pthread_cond_broadcast(&share->cond);
329
pthread_cond_wait(&share->cond, &share->mutex);
331
/* No thread refers to this anymore */
332
pthread_mutex_unlock(&share->mutex);
333
pthread_mutex_destroy(&share->mutex);
334
pthread_cond_destroy(&share->cond);
336
hash_free(&share->name_hash);
338
plugin_unlock(NULL, share->db_plugin);
339
share->db_plugin= NULL;
341
/* We must copy mem_root from share because share is allocated through it */
342
memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
343
free_root(&mem_root, MYF(0)); // Free's share
349
Return TRUE if a table name matches one of the system table names.
352
help_category, help_keyword, help_relation, help_topic,
354
time_zone, time_zone_leap_second, time_zone_name, time_zone_transition,
355
time_zone_transition_type
357
This function trades accuracy for speed, so may return false
358
positives. Presumably mysql.* database is for internal purposes only
359
and should not contain user tables.
362
inline bool is_system_table_name(const char *name, uint length)
364
CHARSET_INFO *ci= system_charset_info;
367
/* mysql.proc table */
370
my_tolower(ci, name[0]) == 'p' &&
371
my_tolower(ci, name[1]) == 'r' &&
372
my_tolower(ci, name[2]) == 'o' &&
373
my_tolower(ci, name[3]) == 'c'
376
/* one of mysql.help* tables */
379
my_tolower(ci, name[0]) == 'h' &&
380
my_tolower(ci, name[1]) == 'e' &&
381
my_tolower(ci, name[2]) == 'l' &&
382
my_tolower(ci, name[3]) == 'p'
385
/* one of mysql.time_zone* tables */
387
my_tolower(ci, name[0]) == 't' &&
388
my_tolower(ci, name[1]) == 'i' &&
389
my_tolower(ci, name[2]) == 'm' &&
390
my_tolower(ci, name[3]) == 'e'
397
Read table definition from a binary / text based .frm file
402
share Fill this with table definition
403
db_flags Bit mask of the following flags: OPEN_VIEW
406
This function is called when the table definition is not cached in
408
The data is returned in 'share', which is alloced by
409
alloc_table_share().. The code assumes that share is initialized.
413
1 Error (see open_table_error)
414
2 Error (see open_table_error)
415
3 Wrong data in .frm file
416
4 Error (see open_table_error)
417
5 Error (see open_table_error: charset unavailable)
418
6 Unknown .frm version
421
int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
423
int error, table_type;
426
uchar head[64], *disk_buff;
427
char path[FN_REFLEN];
428
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));
437
strxmov(path, share->normalized_path.str, reg_ext, NullS);
438
if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)
441
We don't try to open 5.0 unencoded name, if
442
- non-encoded name contains '@' signs,
443
because '@' can be misinterpreted.
444
It is not clear if '@' is escape character in 5.1,
445
or a normal character in 5.0.
447
- non-encoded db or table name contain "#mysql50#" prefix.
448
This kind of tables must have been opened only by the
451
if (strchr(share->table_name.str, '@') ||
452
!strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX,
453
MYSQL50_TABLE_NAME_PREFIX_LENGTH) ||
454
!strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX,
455
MYSQL50_TABLE_NAME_PREFIX_LENGTH))
458
/* Try unencoded 5.0 name */
460
strxnmov(path, sizeof(path)-1,
461
mysql_data_home, "/", share->db.str, "/",
462
share->table_name.str, reg_ext, NullS);
463
length= unpack_filename(path, path) - reg_ext_length;
465
The following is a safety test and should never fail
466
as the old file name should never be longer than the new one.
468
DBUG_ASSERT(length <= share->normalized_path.length);
470
If the old and the new names have the same length,
471
then table name does not have tricky characters,
472
so no need to check the old file name.
474
if (length == share->normalized_path.length ||
475
((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0))
478
/* Unencoded 5.0 table name found */
479
path[length]= '\0'; // Remove .frm extension
480
strmov(share->normalized_path.str, path);
481
share->normalized_path.length= length;
485
if (my_read(file, head, 64, MYF(MY_NABP)))
488
if (head[0] == (uchar) 254 && head[1] == 1)
490
if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
491
(head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
494
if (db_flags & OPEN_VIEW_ONLY)
503
error= 6; // Unkown .frm version
510
/* No handling of text based files yet */
513
root_ptr= (MEM_ROOT **)pthread_getspecific(THR_MALLOC);
515
*root_ptr= &share->mem_root;
516
error= open_binary_frm(thd, share, head, file);
521
share->table_category= get_table_category(& share->db, & share->table_name);
524
thd->status_var.opened_shares++;
527
my_close(file, MYF(MY_WME));
530
if (error && !error_given)
533
open_table_error(share, error, (share->open_errno= my_errno), 0);
541
Read data from a binary .frm file from MySQL 3.23 - 5.0 into TABLE_SHARE
544
static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
547
int error, errarg= 0;
548
uint new_frm_ver, field_pack_length, new_field_pack_flag;
549
uint interval_count, interval_parts, read_length, int_length;
550
uint db_create_options, keys, key_parts, n_length;
551
uint key_info_length, com_length, null_bit_pos;
552
uint extra_rec_buf_length;
556
char *keynames, *names, *comment_pos;
558
uchar *disk_buff, *strpos, *null_flags, *null_pos;
559
ulong pos, record_offset, *rec_per_key, rec_buff_length;
560
handler *handler_file= 0;
562
KEY_PART_INFO *key_part;
563
SQL_CRYPT *crypted=0;
564
Field **field_ptr, *reg_field;
565
const char **interval_array;
566
enum legacy_db_type legacy_db_type;
567
my_bitmap_map *bitmaps;
569
uchar *field_extra_info= 0;
570
DBUG_ENTER("open_binary_frm");
572
new_field_pack_flag= head[27];
573
new_frm_ver= (head[2] - FRM_VER);
574
field_pack_length= new_frm_ver < 2 ? 11 : 17;
578
if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
579
goto err; /* purecov: inspected */
580
VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
581
if (my_read(file,forminfo,288,MYF(MY_NABP)))
584
share->frm_version= head[2];
586
Check if .frm file created by MySQL 5.0. In this case we want to
587
display CHAR fields as CHAR and not as VARCHAR.
588
We do it this way as we want to keep the old frm version to enable
589
MySQL 4.1 to read these files.
591
if (share->frm_version == FRM_VER_TRUE_VARCHAR -1 && head[33] == 5)
592
share->frm_version= FRM_VER_TRUE_VARCHAR;
594
legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
595
DBUG_ASSERT(share->db_plugin == NULL);
597
if the storage engine is dynamic, no point in resolving it by its
598
dynamically allocated legacy_db_type. We will resolve it later by name.
600
if (legacy_db_type > DB_TYPE_UNKNOWN &&
601
legacy_db_type < DB_TYPE_FIRST_DYNAMIC)
602
share->db_plugin= ha_lock_engine(NULL,
603
ha_checktype(thd, legacy_db_type, 0, 0));
604
share->db_create_options= db_create_options= uint2korr(head+30);
605
share->db_options_in_use= share->db_create_options;
606
share->mysql_version= uint4korr(head+51);
607
share->null_field_first= 0;
608
if (!head[32]) // New frm file in 3.23
610
share->avg_row_length= uint4korr(head+34);
611
share->transactional= (ha_choice) (head[39] & 3);
612
share->page_checksum= (ha_choice) ((head[39] >> 2) & 3);
613
share->row_type= (row_type) head[40];
614
share->table_charset= get_charset((uint) head[38],MYF(0));
615
share->null_field_first= 1;
617
if (!share->table_charset)
619
/* unknown charset in head[38] or pre-3.23 frm */
620
if (use_mb(default_charset_info))
622
/* Warn that we may be changing the size of character columns */
623
sql_print_warning("'%s' had no or invalid character set, "
624
"and default character set is multi-byte, "
625
"so character column sizes may have changed",
628
share->table_charset= default_charset_info;
630
share->db_record_offset= 1;
631
if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
632
share->blob_ptr_size= portable_sizeof_char_ptr;
633
/* Set temporarily a good value for db_low_byte_first */
634
share->db_low_byte_first= test(legacy_db_type != DB_TYPE_ISAM);
636
share->max_rows= uint4korr(head+18);
637
share->min_rows= uint4korr(head+22);
639
/* Read keyinformation */
640
key_info_length= (uint) uint2korr(head+28);
641
VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
642
if (read_string(file,(uchar**) &disk_buff,key_info_length))
643
goto err; /* purecov: inspected */
644
if (disk_buff[0] & 0x80)
646
share->keys= keys= (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
647
share->key_parts= key_parts= uint2korr(disk_buff+2);
651
share->keys= keys= disk_buff[0];
652
share->key_parts= key_parts= disk_buff[1];
654
share->keys_for_keyread.init(0);
655
share->keys_in_use.init(keys);
657
n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
658
if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
659
n_length + uint2korr(disk_buff+4))))
660
goto err; /* purecov: inspected */
661
bzero((char*) keyinfo,n_length);
662
share->key_info= keyinfo;
663
key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
666
if (!(rec_per_key= (ulong*) alloc_root(&share->mem_root,
667
sizeof(ulong*)*key_parts)))
670
for (i=0 ; i < keys ; i++, keyinfo++)
672
keyinfo->table= 0; // Updated in open_frm
673
if (new_frm_ver >= 3)
675
keyinfo->flags= (uint) uint2korr(strpos) ^ HA_NOSAME;
676
keyinfo->key_length= (uint) uint2korr(strpos+2);
677
keyinfo->key_parts= (uint) strpos[4];
678
keyinfo->algorithm= (enum ha_key_alg) strpos[5];
679
keyinfo->block_size= uint2korr(strpos+6);
684
keyinfo->flags= ((uint) strpos[0]) ^ HA_NOSAME;
685
keyinfo->key_length= (uint) uint2korr(strpos+1);
686
keyinfo->key_parts= (uint) strpos[3];
687
keyinfo->algorithm= HA_KEY_ALG_UNDEF;
691
keyinfo->key_part= key_part;
692
keyinfo->rec_per_key= rec_per_key;
693
for (j=keyinfo->key_parts ; j-- ; key_part++)
696
key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
697
key_part->offset= (uint) uint2korr(strpos+2)-1;
698
key_part->key_type= (uint) uint2korr(strpos+5);
699
// key_part->field= (Field*) 0; // Will be fixed later
700
if (new_frm_ver >= 1)
702
key_part->key_part_flag= *(strpos+4);
703
key_part->length= (uint) uint2korr(strpos+7);
708
key_part->length= *(strpos+4);
709
key_part->key_part_flag=0;
710
if (key_part->length > 128)
712
key_part->length&=127; /* purecov: inspected */
713
key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
717
key_part->store_length=key_part->length;
720
keynames=(char*) key_part;
721
strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
723
//reading index comments
724
for (keyinfo= share->key_info, i=0; i < keys; i++, keyinfo++)
726
if (keyinfo->flags & HA_USES_COMMENT)
728
keyinfo->comment.length= uint2korr(strpos);
729
keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos+2,
730
keyinfo->comment.length);
731
strpos+= 2 + keyinfo->comment.length;
733
DBUG_ASSERT(test(keyinfo->flags & HA_USES_COMMENT) ==
734
(keyinfo->comment.length > 0));
737
share->reclength = uint2korr((head+16));
739
share->system= 1; /* one-record-database */
741
record_offset= (ulong) (uint2korr(head+6)+
742
((uint2korr(head+14) == 0xffff ?
743
uint4korr(head+47) : uint2korr(head+14))));
745
if ((n_length= uint4korr(head+55)))
747
/* Read extra data segment */
748
uchar *next_chunk, *buff_end;
749
DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
750
if (!(next_chunk= buff= (uchar*) my_malloc(n_length, MYF(MY_WME))))
752
if (pread(file, buff, n_length, record_offset + share->reclength) == 0)
756
share->connect_string.length= uint2korr(buff);
757
if (!(share->connect_string.str= strmake_root(&share->mem_root,
758
(char*) next_chunk + 2,
759
share->connect_string.
764
next_chunk+= share->connect_string.length + 2;
765
buff_end= buff + n_length;
766
if (next_chunk + 2 < buff_end)
768
uint str_db_type_length= uint2korr(next_chunk);
770
name.str= (char*) next_chunk + 2;
771
name.length= str_db_type_length;
773
plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
774
if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, share->db_plugin))
776
if (legacy_db_type > DB_TYPE_UNKNOWN &&
777
legacy_db_type < DB_TYPE_FIRST_DYNAMIC &&
778
legacy_db_type != ha_legacy_type(
779
plugin_data(tmp_plugin, handlerton *)))
781
/* bad file, legacy_db_type did not match the name */
782
my_free(buff, MYF(0));
786
tmp_plugin is locked with a local lock.
787
we unlock the old value of share->db_plugin before
788
replacing it with a globally locked version of tmp_plugin
790
plugin_unlock(NULL, share->db_plugin);
791
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())));
796
else if (!tmp_plugin)
798
/* purecov: begin inspected */
800
my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), name.str);
801
my_free(buff, MYF(0));
805
next_chunk+= str_db_type_length + 2;
807
#if MYSQL_VERSION_ID < 50200
808
if (share->mysql_version >= 50106 && share->mysql_version <= 50109)
811
Partition state array was here in version 5.1.6 to 5.1.9, this code
812
makes it possible to load a 5.1.6 table in later versions. Can most
813
likely be removed at some point in time. Will only be used for
814
upgrades within 5.1 series of versions. Upgrade to 5.2 can only be
815
done from newer 5.1 versions.
821
if (share->mysql_version >= 50110)
823
/* New auto_partitioned indicator introduced in 5.1.11 */
826
if (forminfo[46] == (uchar)255)
828
//reading long table comment
829
if (next_chunk + 2 > buff_end)
832
("long table comment is not defined in .frm"));
833
my_free(buff, MYF(0));
836
share->comment.length = uint2korr(next_chunk);
837
if (! (share->comment.str= strmake_root(&share->mem_root,
838
(char*)next_chunk + 2, share->comment.length)))
840
my_free(buff, MYF(0));
843
next_chunk+= 2 + share->comment.length;
845
DBUG_ASSERT (next_chunk <= buff_end);
846
if (share->mysql_version >= MYSQL_VERSION_TABLESPACE_IN_FRM_CGE)
849
New frm format in mysql_version 5.2.5 (originally in
850
mysql-5.1.22-ndb-6.2.5)
851
New column properties added:
852
COLUMN_FORMAT DYNAMIC|FIXED and STORAGE DISK|MEMORY
853
TABLESPACE name is now stored in frm
855
if (next_chunk >= buff_end)
857
if (share->mysql_version >= MYSQL_VERSION_TABLESPACE_IN_FRM)
859
DBUG_PRINT("error", ("Found no field extra info"));
862
DBUG_PRINT("info", ("Found no field extra info"));
866
DBUG_PRINT("info", ("Found field extra info"));
867
const uint format_section_header_size= 8;
868
uint format_section_len= uint2korr(next_chunk+0);
869
uint flags= uint4korr(next_chunk+2);
871
share->default_storage_media= (enum ha_storage_media) (flags & 0x7);
873
const char *tablespace= (const char*)next_chunk + format_section_header_size;
874
uint tablespace_len= strlen(tablespace);
875
if (tablespace_len != 0)
877
share->tablespace= (char *) alloc_root(&share->mem_root,
879
strxmov(share->tablespace, tablespace, NullS);
882
share->tablespace= NULL;
884
field_extra_info= next_chunk + format_section_header_size + tablespace_len + 1;
885
next_chunk+= format_section_len;
888
DBUG_ASSERT (next_chunk <= buff_end);
889
if (next_chunk > buff_end)
891
DBUG_PRINT("error", ("Buffer overflow in field extra info"));
895
share->key_block_size= uint2korr(head+62);
898
extra_rec_buf_length= uint2korr(head+59);
899
rec_buff_length= ALIGN_SIZE(share->reclength + 1 + extra_rec_buf_length);
900
share->rec_buff_length= rec_buff_length;
901
if (!(record= (uchar *) alloc_root(&share->mem_root,
903
goto err; /* purecov: inspected */
904
share->default_values= record;
905
if (pread(file, record, (size_t) share->reclength, record_offset) == 0)
906
goto err; /* purecov: inspected */
908
VOID(my_seek(file,pos+288,MY_SEEK_SET,MYF(0)));
910
share->fields= uint2korr(forminfo+258);
911
pos= uint2korr(forminfo+260); /* Length of all screens */
912
n_length= uint2korr(forminfo+268);
913
interval_count= uint2korr(forminfo+270);
914
interval_parts= uint2korr(forminfo+272);
915
int_length= uint2korr(forminfo+274);
916
share->null_fields= uint2korr(forminfo+282);
917
com_length= uint2korr(forminfo+284);
918
if (forminfo[46] != (uchar)255)
920
share->comment.length= (int) (forminfo[46]);
921
share->comment.str= strmake_root(&share->mem_root, (char*) forminfo+47,
922
share->comment.length);
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));
927
if (!(field_ptr = (Field **)
928
alloc_root(&share->mem_root,
929
(uint) ((share->fields+1)*sizeof(Field*)+
930
interval_count*sizeof(TYPELIB)+
931
(share->fields+interval_parts+
932
keys+3)*sizeof(char *)+
933
(n_length+int_length+com_length)))))
934
goto err; /* purecov: inspected */
936
share->field= field_ptr;
937
read_length=(uint) (share->fields * field_pack_length +
938
pos+ (uint) (n_length+int_length+com_length));
939
if (read_string(file,(uchar**) &disk_buff,read_length))
940
goto err; /* purecov: inspected */
941
strpos= disk_buff+pos;
943
share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
944
interval_array= (const char **) (share->intervals+interval_count);
945
names= (char*) (interval_array+share->fields+interval_parts+keys+3);
947
share->intervals= 0; // For better debugging
948
memcpy((char*) names, strpos+(share->fields*field_pack_length),
949
(uint) (n_length+int_length));
950
comment_pos= names+(n_length+int_length);
951
memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
953
fix_type_pointers(&interval_array, &share->fieldnames, 1, &names);
954
if (share->fieldnames.count != share->fields)
956
fix_type_pointers(&interval_array, share->intervals, interval_count,
960
/* Set ENUM and SET lengths */
962
for (interval= share->intervals;
963
interval < share->intervals + interval_count;
966
uint count= (uint) (interval->count + 1) * sizeof(uint);
967
if (!(interval->type_lengths= (uint *) alloc_root(&share->mem_root,
970
for (count= 0; count < interval->count; count++)
972
char *val= (char*) interval->type_names[count];
973
interval->type_lengths[count]= strlen(val);
975
interval->type_lengths[count]= 0;
980
fix_type_pointers(&interval_array, &share->keynames, 1, &keynames);
982
/* Allocate handler */
983
if (!(handler_file= get_new_handler(share, thd->mem_root,
987
record= share->default_values-1; /* Fieldstart = 1 */
988
if (share->null_field_first)
990
null_flags= null_pos= (uchar*) record+1;
991
null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
993
null_bytes below is only correct under the condition that
994
there are no bit fields. Correct values is set below after the
995
table struct is initialized
997
share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
999
#ifndef WE_WANT_TO_SUPPORT_VERY_OLD_FRM_FILES
1002
share->null_bytes= (share->null_fields+7)/8;
1003
null_flags= null_pos= (uchar*) (record + 1 +share->reclength -
1009
use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
1011
use_hash= !hash_init(&share->name_hash,
1012
system_charset_info,
1014
(hash_get_key) get_field_name,0,0);
1016
for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)
1018
uint pack_flag, interval_nr, unireg_type, recpos, field_length;
1019
enum_field_types field_type;
1020
enum ha_storage_media storage_type= HA_SM_DEFAULT;
1021
enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
1022
CHARSET_INFO *charset=NULL;
1025
if (field_extra_info)
1027
char tmp= field_extra_info[i];
1028
storage_type= (enum ha_storage_media)(tmp & STORAGE_TYPE_MASK);
1029
column_format= (enum column_format_type)
1030
((tmp >> COLUMN_FORMAT_SHIFT) & COLUMN_FORMAT_MASK);
1031
DBUG_PRINT("info", ("Field extra: storage %u format %u",
1032
storage_type, column_format));
1034
if (new_frm_ver >= 3)
1036
/* new frm file in 4.1 */
1037
field_length= uint2korr(strpos+3);
1038
recpos= uint3korr(strpos+5);
1039
pack_flag= uint2korr(strpos+8);
1040
unireg_type= (uint) strpos[10];
1041
interval_nr= (uint) strpos[12];
1042
uint comment_length=uint2korr(strpos+15);
1043
field_type=(enum_field_types) (uint) strpos[13];
1047
charset= &my_charset_bin;
1048
else if (!(charset=get_charset((uint) strpos[14], MYF(0))))
1050
error= 5; // Unknown or unavailable charset
1051
errarg= (int) strpos[14];
1055
if (!comment_length)
1057
comment.str= (char*) "";
1062
comment.str= (char*) comment_pos;
1063
comment.length= comment_length;
1064
comment_pos+= comment_length;
1069
field_length= (uint) strpos[3];
1070
recpos= uint2korr(strpos+4),
1071
pack_flag= uint2korr(strpos+6);
1072
pack_flag&= ~FIELDFLAG_NO_DEFAULT; // Safety for old files
1073
unireg_type= (uint) strpos[8];
1074
interval_nr= (uint) strpos[10];
1077
field_type= (enum_field_types) f_packtype(pack_flag);
1078
if (f_is_binary(pack_flag))
1081
Try to choose the best 4.1 type:
1082
- for 4.0 "CHAR(N) BINARY" or "VARCHAR(N) BINARY"
1083
try to find a binary collation for character set.
1084
- for other types (e.g. BLOB) just use my_charset_bin.
1086
if (!f_is_blob(pack_flag))
1088
// 3.23 or 4.0 string
1089
if (!(charset= get_charset_by_csname(share->table_charset->csname,
1090
MY_CS_BINSORT, MYF(0))))
1091
charset= &my_charset_bin;
1094
charset= &my_charset_bin;
1097
charset= share->table_charset;
1098
bzero((char*) &comment, sizeof(comment));
1101
if (interval_nr && charset->mbminlen > 1)
1103
/* Unescape UCS2 intervals from HEX notation */
1104
TYPELIB *interval= share->intervals + interval_nr - 1;
1105
unhex_type2(interval);
1108
#ifndef TO_BE_DELETED_ON_PRODUCTION
1109
if (field_type == MYSQL_TYPE_NEWDECIMAL && !share->mysql_version)
1112
Fix pack length of old decimal values from 5.0.3 -> 5.0.4
1113
The difference is that in the old version we stored precision
1114
in the .frm table while we now store the display_length
1116
uint decimals= f_decimals(pack_flag);
1117
field_length= my_decimal_precision_to_length(field_length,
1119
f_is_dec(pack_flag) == 0);
1120
sql_print_error("Found incompatible DECIMAL field '%s' in %s; "
1121
"Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
1122
share->fieldnames.type_names[i], share->table_name.str,
1123
share->table_name.str);
1124
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
1125
ER_CRASHED_ON_USAGE,
1126
"Found incompatible DECIMAL field '%s' in %s; "
1127
"Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
1128
share->fieldnames.type_names[i],
1129
share->table_name.str,
1130
share->table_name.str);
1131
share->crashed= 1; // Marker for CHECK TABLE
1135
*field_ptr= reg_field=
1136
make_field(share, record+recpos,
1137
(uint32) field_length,
1138
null_pos, null_bit_pos,
1142
(Field::utype) MTYP_TYPENR(unireg_type),
1144
share->intervals+interval_nr-1 :
1146
share->fieldnames.type_names[i]);
1147
if (!reg_field) // Not supported field type
1150
goto err; /* purecov: inspected */
1153
reg_field->flags|= ((uint)storage_type << FIELD_STORAGE_FLAGS);
1154
reg_field->flags|= ((uint)column_format << COLUMN_FORMAT_FLAGS);
1155
reg_field->field_index= i;
1156
reg_field->comment=comment;
1157
if (!(reg_field->flags & NOT_NULL_FLAG))
1159
if (!(null_bit_pos= (null_bit_pos + 1) & 7))
1162
if (f_no_default(pack_flag))
1163
reg_field->flags|= NO_DEFAULT_VALUE_FLAG;
1165
if (reg_field->unireg_check == Field::NEXT_NUMBER)
1166
share->found_next_number_field= field_ptr;
1167
if (share->timestamp_field == reg_field)
1168
share->timestamp_field_offset= i;
1171
(void) my_hash_insert(&share->name_hash,
1172
(uchar*) field_ptr); // never fail
1174
*field_ptr=0; // End marker
1176
/* Fix key->name and key_part->field */
1179
uint primary_key=(uint) (find_type((char*) primary_key_name,
1180
&share->keynames, 3) - 1);
1181
longlong ha_option= handler_file->ha_table_flags();
1182
keyinfo= share->key_info;
1183
key_part= keyinfo->key_part;
1185
for (uint key=0 ; key < share->keys ; key++,keyinfo++)
1187
uint usable_parts= 0;
1188
keyinfo->name=(char*) share->keynames.type_names[key];
1190
if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
1193
If the UNIQUE key doesn't have NULL columns and is not a part key
1194
declare this as a primary key.
1197
for (i=0 ; i < keyinfo->key_parts ;i++)
1199
uint fieldnr= key_part[i].fieldnr;
1201
share->field[fieldnr-1]->null_ptr ||
1202
share->field[fieldnr-1]->key_length() !=
1205
primary_key=MAX_KEY; // Can't be used
1211
for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
1214
if (new_field_pack_flag <= 1)
1215
key_part->fieldnr= (uint16) find_field(share->field,
1216
share->default_values,
1217
(uint) key_part->offset,
1218
(uint) key_part->length);
1219
if (!key_part->fieldnr)
1221
error= 4; // Wrong file
1224
field= key_part->field= share->field[key_part->fieldnr-1];
1225
key_part->type= field->key_type();
1226
if (field->null_ptr)
1228
key_part->null_offset=(uint) ((uchar*) field->null_ptr -
1229
share->default_values);
1230
key_part->null_bit= field->null_bit;
1231
key_part->store_length+=HA_KEY_NULL_LENGTH;
1232
keyinfo->flags|=HA_NULL_PART_KEY;
1233
keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
1234
keyinfo->key_length+= HA_KEY_NULL_LENGTH;
1236
if (field->type() == MYSQL_TYPE_BLOB ||
1237
field->real_type() == MYSQL_TYPE_VARCHAR)
1239
if (field->type() == MYSQL_TYPE_BLOB)
1240
key_part->key_part_flag|= HA_BLOB_PART;
1242
key_part->key_part_flag|= HA_VAR_LENGTH_PART;
1243
keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
1244
key_part->store_length+=HA_KEY_BLOB_LENGTH;
1245
keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
1247
if (i == 0 && key != primary_key)
1248
field->flags |= (((keyinfo->flags & HA_NOSAME) &&
1249
(keyinfo->key_parts == 1)) ?
1250
UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
1252
field->key_start.set_bit(key);
1253
if (field->key_length() == key_part->length &&
1254
!(field->flags & BLOB_FLAG))
1256
if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
1258
share->keys_for_keyread.set_bit(key);
1259
field->part_of_key.set_bit(key);
1260
field->part_of_key_not_clustered.set_bit(key);
1262
if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
1263
field->part_of_sortkey.set_bit(key);
1265
if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
1267
usable_parts++; // For FILESORT
1268
field->flags|= PART_KEY_FLAG;
1269
if (key == primary_key)
1271
field->flags|= PRI_KEY_FLAG;
1273
If this field is part of the primary key and all keys contains
1274
the primary key, then we can use any key to find this column
1276
if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
1278
field->part_of_key= share->keys_in_use;
1279
if (field->part_of_sortkey.is_set(key))
1280
field->part_of_sortkey= share->keys_in_use;
1283
if (field->key_length() != key_part->length)
1285
#ifndef TO_BE_DELETED_ON_PRODUCTION
1286
if (field->type() == MYSQL_TYPE_NEWDECIMAL)
1289
Fix a fatal error in decimal key handling that causes crashes
1290
on Innodb. We fix it by reducing the key length so that
1291
InnoDB never gets a too big key when searching.
1292
This allows the end user to do an ALTER TABLE to fix the
1295
keyinfo->key_length-= (key_part->length - field->key_length());
1296
key_part->store_length-= (uint16)(key_part->length -
1297
field->key_length());
1298
key_part->length= (uint16)field->key_length();
1299
sql_print_error("Found wrong key definition in %s; "
1300
"Please do \"ALTER TABLE '%s' FORCE \" to fix it!",
1301
share->table_name.str,
1302
share->table_name.str);
1303
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
1304
ER_CRASHED_ON_USAGE,
1305
"Found wrong key definition in %s; "
1306
"Please do \"ALTER TABLE '%s' FORCE\" to fix "
1308
share->table_name.str,
1309
share->table_name.str);
1310
share->crashed= 1; // Marker for CHECK TABLE
1314
key_part->key_part_flag|= HA_PART_KEY_SEG;
1317
keyinfo->usable_key_parts= usable_parts; // Filesort
1319
set_if_bigger(share->max_key_length,keyinfo->key_length+
1320
keyinfo->key_parts);
1321
share->total_key_length+= keyinfo->key_length;
1323
MERGE tables do not have unique indexes. But every key could be
1324
an unique index on the underlying MyISAM table. (Bug #10400)
1326
if ((keyinfo->flags & HA_NOSAME) ||
1327
(ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
1328
set_if_bigger(share->max_unique_length,keyinfo->key_length);
1330
if (primary_key < MAX_KEY &&
1331
(share->keys_in_use.is_set(primary_key)))
1333
share->primary_key= primary_key;
1335
If we are using an integer as the primary key then allow the user to
1336
refer to it as '_rowid'
1338
if (share->key_info[primary_key].key_parts == 1)
1340
Field *field= share->key_info[primary_key].key_part[0].field;
1341
if (field && field->result_type() == INT_RESULT)
1343
/* note that fieldnr here (and rowid_field_offset) starts from 1 */
1344
share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
1350
share->primary_key = MAX_KEY; // we do not have a primary key
1353
share->primary_key= MAX_KEY;
1354
x_free((uchar*) disk_buff);
1356
if (new_field_pack_flag <= 1)
1358
/* Old file format with default as not null */
1359
uint null_length= (share->null_fields+7)/8;
1360
bfill(share->default_values + (null_flags - (uchar*) record),
1364
if (share->found_next_number_field)
1366
reg_field= *share->found_next_number_field;
1367
if ((int) (share->next_number_index= (uint)
1368
find_ref_key(share->key_info, share->keys,
1369
share->default_values, reg_field,
1370
&share->next_number_key_offset,
1371
&share->next_number_keypart)) < 0)
1373
/* Wrong field definition */
1378
reg_field->flags |= AUTO_INCREMENT_FLAG;
1381
if (share->blob_fields)
1386
/* Store offsets to blob fields to find them fast */
1387
if (!(share->blob_field= save=
1388
(uint*) alloc_root(&share->mem_root,
1389
(uint) (share->blob_fields* sizeof(uint)))))
1391
for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
1393
if ((*ptr)->flags & BLOB_FLAG)
1399
the correct null_bytes can now be set, since bitfields have been taken
1402
share->null_bytes= (null_pos - (uchar*) null_flags +
1403
(null_bit_pos + 7) / 8);
1404
share->last_null_bit_pos= null_bit_pos;
1406
share->db_low_byte_first= handler_file->low_byte_first();
1407
share->column_bitmap_size= bitmap_buffer_size(share->fields);
1409
if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1410
share->column_bitmap_size)))
1412
bitmap_init(&share->all_set, bitmaps, share->fields, FALSE);
1413
bitmap_set_all(&share->all_set);
1415
delete handler_file;
1418
(void) hash_check(&share->name_hash);
1421
my_free(buff, MYF(0));
1426
my_free(buff, MYF(0));
1427
share->error= error;
1428
share->open_errno= my_errno;
1429
share->errarg= errarg;
1430
x_free((uchar*) disk_buff);
1432
delete handler_file;
1433
hash_free(&share->name_hash);
1435
open_table_error(share, error, share->open_errno, errarg);
1437
} /* open_binary_frm */
1441
Open a table based on a TABLE_SHARE
1444
open_table_from_share()
1446
share Table definition
1447
alias Alias for table
1448
db_stat open flags (for example HA_OPEN_KEYFILE|
1449
HA_OPEN_RNDFILE..) can be 0 (example in
1451
prgflag READ_ALL etc..
1452
ha_open_flags HA_OPEN_ABORT_IF_LOCKED etc..
1453
outparam result table
1454
open_mode One of OTM_OPEN|OTM_CREATE|OTM_ALTER
1455
if OTM_CREATE some errors are ignore
1456
if OTM_ALTER HA_OPEN is not called
1460
1 Error (see open_table_error)
1461
2 Error (see open_table_error)
1462
3 Wrong data in .frm file
1463
4 Error (see open_table_error)
1464
5 Error (see open_table_error: charset unavailable)
1465
7 Table definition has changed in engine
1468
int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
1469
uint db_stat, uint prgflag, uint ha_open_flags,
1470
TABLE *outparam, open_table_mode open_mode)
1473
uint records, i, bitmap_size;
1474
bool error_reported= FALSE;
1475
uchar *record, *bitmaps;
1477
DBUG_ENTER("open_table_from_share");
1478
DBUG_PRINT("enter",("name: '%s.%s' form: 0x%lx, open mode:%s",
1480
share->table_name.str,
1482
(open_mode == OTM_OPEN)?"open":
1483
((open_mode == OTM_CREATE)?"create":"alter")));
1485
/* Parsing of partitioning information from .frm needs thd->lex set up. */
1486
DBUG_ASSERT(thd->lex->is_lex_started);
1489
bzero((char*) outparam, sizeof(*outparam));
1490
outparam->in_use= thd;
1492
outparam->db_stat= db_stat;
1493
outparam->write_row_record= NULL;
1495
init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
1497
if (!(outparam->alias= my_strdup(alias, MYF(MY_WME))))
1499
outparam->quick_keys.init();
1500
outparam->covering_keys.init();
1501
outparam->keys_in_use_for_query.init();
1503
/* Allocate handler */
1505
if (!(prgflag & OPEN_FRM_FILE_ONLY))
1507
if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
1513
DBUG_ASSERT(!db_stat);
1517
outparam->reginfo.lock_type= TL_UNLOCK;
1518
outparam->current_lock= F_UNLCK;
1520
if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
1522
if (prgflag & (READ_ALL+EXTRA_RECORD))
1525
if (!(record= (uchar*) alloc_root(&outparam->mem_root,
1526
share->rec_buff_length * records)))
1527
goto err; /* purecov: inspected */
1531
/* We are probably in hard repair, and the buffers should not be used */
1532
outparam->record[0]= outparam->record[1]= share->default_values;
1536
outparam->record[0]= record;
1538
outparam->record[1]= record+ share->rec_buff_length;
1540
outparam->record[1]= outparam->record[0]; // Safety
1545
We need this because when we read var-length rows, we are not updating
1546
bytes after end of varchar
1550
memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
1551
memcpy(outparam->record[1], share->default_values, share->null_bytes);
1553
memcpy(outparam->record[1], share->default_values,
1554
share->rec_buff_length);
1558
if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
1559
(uint) ((share->fields+1)*
1561
goto err; /* purecov: inspected */
1563
outparam->field= field_ptr;
1565
record= (uchar*) outparam->record[0]-1; /* Fieldstart = 1 */
1566
if (share->null_field_first)
1567
outparam->null_flags= (uchar*) record+1;
1569
outparam->null_flags= (uchar*) (record+ 1+ share->reclength -
1572
/* Setup copy of fields from share, but use the right alias and record */
1573
for (i=0 ; i < share->fields; i++, field_ptr++)
1575
if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
1578
(*field_ptr)= 0; // End marker
1580
if (share->found_next_number_field)
1581
outparam->found_next_number_field=
1582
outparam->field[(uint) (share->found_next_number_field - share->field)];
1583
if (share->timestamp_field)
1584
outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];
1587
/* Fix key->name and key_part->field */
1588
if (share->key_parts)
1590
KEY *key_info, *key_info_end;
1591
KEY_PART_INFO *key_part;
1593
n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
1594
if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
1596
outparam->key_info= key_info;
1597
key_part= (my_reinterpret_cast(KEY_PART_INFO*) (key_info+share->keys));
1599
memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
1600
memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
1603
for (key_info_end= key_info + share->keys ;
1604
key_info < key_info_end ;
1607
KEY_PART_INFO *key_part_end;
1609
key_info->table= outparam;
1610
key_info->key_part= key_part;
1612
for (key_part_end= key_part+ key_info->key_parts ;
1613
key_part < key_part_end ;
1616
Field *field= key_part->field= outparam->field[key_part->fieldnr-1];
1618
if (field->key_length() != key_part->length &&
1619
!(field->flags & BLOB_FLAG))
1622
We are using only a prefix of the column as a key:
1623
Create a new field for the key part that matches the index
1625
field= key_part->field=field->new_field(&outparam->mem_root,
1627
field->field_length= key_part->length;
1633
/* Allocate bitmaps */
1635
bitmap_size= share->column_bitmap_size;
1636
if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1638
bitmap_init(&outparam->def_read_set,
1639
(my_bitmap_map*) bitmaps, share->fields, FALSE);
1640
bitmap_init(&outparam->def_write_set,
1641
(my_bitmap_map*) (bitmaps+bitmap_size), share->fields, FALSE);
1642
bitmap_init(&outparam->tmp_set,
1643
(my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, FALSE);
1644
outparam->default_column_bitmaps();
1646
/* The table struct is now initialized; Open the table */
1648
if (db_stat && open_mode != OTM_ALTER)
1651
if ((ha_err= (outparam->file->
1652
ha_open(outparam, share->normalized_path.str,
1653
(db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
1654
(db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
1655
((db_stat & HA_WAIT_IF_LOCKED) ||
1656
(specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
1657
HA_OPEN_WAIT_IF_LOCKED :
1658
(db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
1659
HA_OPEN_ABORT_IF_LOCKED :
1660
HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
1662
/* Set a flag if the table is crashed and it can be auto. repaired */
1663
share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
1664
outparam->file->auto_repair() &&
1665
!(ha_open_flags & HA_OPEN_FOR_REPAIR));
1669
case HA_ERR_NO_SUCH_TABLE:
1671
The table did not exists in storage engine, use same error message
1672
as if the .frm file didn't exist
1679
Too many files opened, use same error message as if the .frm
1682
DBUG_PRINT("error", ("open file: %s failed, too many files opened (errno: %d)",
1683
share->normalized_path.str, ha_err));
1688
outparam->file->print_error(ha_err, MYF(0));
1689
error_reported= TRUE;
1690
if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
1694
goto err; /* purecov: inspected */
1698
#if defined(HAVE_purify) && !defined(DBUG_OFF)
1699
bzero((char*) bitmaps, bitmap_size*3);
1702
outparam->no_replicate= outparam->file &&
1703
test(outparam->file->ha_table_flags() &
1704
HA_HAS_OWN_BINLOGGING);
1705
thd->status_var.opened_tables++;
1710
if (!error_reported && !(prgflag & DONT_GIVE_ERROR))
1711
open_table_error(share, error, my_errno, 0);
1712
delete outparam->file;
1713
outparam->file= 0; // For easier error checking
1714
outparam->db_stat=0;
1715
free_root(&outparam->mem_root, MYF(0)); // Safe to call on bzero'd root
1716
my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));
1717
DBUG_RETURN (error);
1722
Free information allocated by openfrm
1726
table TABLE object to free
1727
free_share Is 1 if we also want to free table_share
1730
int closefrm(register TABLE *table, bool free_share)
1733
DBUG_ENTER("closefrm");
1734
DBUG_PRINT("enter", ("table: 0x%lx", (long) table));
1737
error=table->file->close();
1738
my_free((char*) table->alias, MYF(MY_ALLOW_ZERO_PTR));
1742
for (Field **ptr=table->field ; *ptr ; ptr++)
95
cursor= 0; /* For easier errorchecking */
1747
table->file= 0; /* For easier errorchecking */
99
if (s->getType() == message::Table::STANDARD)
101
TableShare::release(s);
1750
if (table->s->tmp_table == NO_TMP_TABLE)
1751
release_table_share(table->s, RELEASE_NORMAL);
1753
free_table_share(table->s);
110
mem_root.free_root(MYF(0));
116
void Table::resetTable(Session *session,
118
uint32_t db_stat_arg)
131
db_stat= db_stat_arg;
134
record[0]= (unsigned char *) NULL;
135
record[1]= (unsigned char *) NULL;
137
insert_values.clear();
139
next_number_field= NULL;
140
found_next_number_field= NULL;
141
timestamp_field= NULL;
143
pos_in_table_list= NULL;
153
derived_select_number= 0;
154
current_lock= F_UNLCK;
168
open_placeholder= false;
169
locked_by_name= false;
172
auto_increment_field_not_null= false;
173
alias_name_used= false;
176
quick_condition_rows= 0;
178
timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
183
covering_keys.reset();
188
keys_in_use_for_query.reset();
189
keys_in_use_for_group_by.reset();
190
keys_in_use_for_order_by.reset();
192
memset(quick_rows, 0, sizeof(ha_rows) * MAX_KEY);
193
memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
195
memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
196
memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
198
memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
1755
free_root(&table->mem_root, MYF(0));
203
1760
/* Deallocate temporary blob storage */
205
void free_blobs(register Table *table)
1762
void free_blobs(register TABLE *table)
208
for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
1765
for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
212
((Field_blob*) table->getField(*ptr))->free();
217
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings)
219
TYPELIB *result= (TYPELIB*) mem_root->alloc_root(sizeof(TYPELIB));
1768
((Field_blob*) table->field[*ptr])->free();
1772
/* Find where a form starts */
1773
/* if formname is NullS then only formnames is read */
1775
ulong get_form_pos(File file, uchar *head, TYPELIB *save_names)
1777
uint a_length,names,length;
1780
DBUG_ENTER("get_form_pos");
1782
names=uint2korr(head+8);
1783
a_length=(names+2)*sizeof(char *); /* Room for two extra */
1788
save_names->type_names=0; /* Clear if error */
1792
length=uint2korr(head+4);
1793
VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
1794
if (!(buf= (uchar*) my_malloc((size_t) length+a_length+names*4,
1796
my_read(file, buf+a_length, (size_t) (length+names*4),
1798
{ /* purecov: inspected */
1799
x_free((uchar*) buf); /* purecov: inspected */
1800
DBUG_RETURN(0L); /* purecov: inspected */
1802
pos= buf+a_length+length;
1803
ret_value=uint4korr(pos);
1808
my_free((uchar*) buf,MYF(0));
1811
bzero((char*) save_names,sizeof(save_names));
1815
str=(char *) (buf+a_length);
1816
fix_type_pointers((const char ***) &buf,save_names,1,&str);
1818
DBUG_RETURN(ret_value);
1823
Read string from a file with malloc
1826
We add an \0 at end of the read string to make reading of C strings easier
1829
int read_string(File file, uchar**to, size_t length)
1831
DBUG_ENTER("read_string");
1834
if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||
1835
my_read(file, *to, length,MYF(MY_NABP)))
1837
x_free(*to); /* purecov: inspected */
1838
*to= 0; /* purecov: inspected */
1839
DBUG_RETURN(1); /* purecov: inspected */
1841
*((char*) *to+length)= '\0';
1846
/* Add a new form to a form file */
1848
ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
1849
const char *newname)
1851
uint i,bufflength,maxlength,n_length,length,names;
1852
ulong endpos,newpos;
1853
uchar buff[IO_SIZE];
1855
DBUG_ENTER("make_new_entry");
1857
length=(uint) strlen(newname)+1;
1858
n_length=uint2korr(fileinfo+4);
1859
maxlength=uint2korr(fileinfo+6);
1860
names=uint2korr(fileinfo+8);
1861
newpos=uint4korr(fileinfo+10);
1863
if (64+length+n_length+(names+1)*4 > maxlength)
1866
int4store(fileinfo+10,newpos);
1867
endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
1868
bufflength= (uint) (endpos & (IO_SIZE-1)); /* IO_SIZE is a power of 2 */
1870
while (endpos > maxlength)
1872
VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
1873
if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
1875
VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
1877
if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))
1879
endpos-=bufflength; bufflength=IO_SIZE;
1881
bzero(buff,IO_SIZE); /* Null new block */
1882
VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
1883
if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
1885
maxlength+=IO_SIZE; /* Fix old ref */
1886
int2store(fileinfo+6,maxlength);
1887
for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
1890
endpos=uint4korr(pos)+IO_SIZE;
1891
int4store(pos,endpos);
1898
VOID(strxmov((char*) buff,"/",newname,"/",NullS));
1901
VOID(strxmov((char*) buff,newname,"/",NullS)); /* purecov: inspected */
1902
VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
1903
if (my_write(file, buff, (size_t) length+1,MYF(MY_NABP+MY_WME)) ||
1904
(names && my_write(file,(uchar*) (*formnames->type_names+n_length-1),
1905
names*4, MYF(MY_NABP+MY_WME))) ||
1906
my_write(file, fileinfo+10, 4,MYF(MY_NABP+MY_WME)))
1907
DBUG_RETURN(0L); /* purecov: inspected */
1909
int2store(fileinfo+8,names+1);
1910
int2store(fileinfo+4,n_length+length);
1911
(void)ftruncate(file, newpos);/* Append file with '\0' */
1912
DBUG_RETURN(newpos);
1913
} /* make_new_entry */
1916
/* error message when opening a form file */
1918
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
1921
char buff[FN_REFLEN];
1922
myf errortype= ME_ERROR+ME_WAITTANG;
1923
DBUG_ENTER("open_table_error");
1928
if (db_errno == ENOENT)
1929
my_error(ER_NO_SUCH_TABLE, MYF(0), share->db.str, share->table_name.str);
1932
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
1933
my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
1934
errortype, buff, db_errno);
1940
const char *datext= "";
1942
if (share->db_type() != NULL)
1944
if ((file= get_new_handler(share, current_thd->mem_root,
1947
if (!(datext= *file->bas_ext()))
1951
err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
1952
ER_FILE_USED : ER_CANT_OPEN_FILE;
1953
strxmov(buff, share->normalized_path.str, datext, NullS);
1954
my_error(err_no,errortype, buff, db_errno);
1960
const char *csname= get_charset_name((uint) errarg);
1962
if (!csname || csname[0] =='?')
1964
snprintf(tmp, sizeof(tmp), "#%d", errarg);
1967
my_printf_error(ER_UNKNOWN_COLLATION,
1968
"Unknown collation '%s' in table '%-.64s' definition",
1969
MYF(0), csname, share->table_name.str);
1973
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
1974
my_printf_error(ER_NOT_FORM_FILE,
1975
"Table '%-.64s' was created with a different version "
1976
"of MySQL and cannot be read",
1981
default: /* Better wrong error than none */
1983
strxmov(buff, share->normalized_path.str, reg_ext, NullS);
1984
my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
1988
} /* open_table_error */
1992
** fix a str_type to a array type
1993
** typeparts separated with some char. differents types are separated
1998
fix_type_pointers(const char ***array, TYPELIB *point_to_type, uint types,
2001
char *type_name, *ptr;
2007
point_to_type->name=0;
2008
point_to_type->type_names= *array;
2010
if ((chr= *ptr)) /* Test if empty type */
2012
while ((type_name=strchr(ptr+1,chr)) != NullS)
2014
*((*array)++) = ptr+1;
2015
*type_name= '\0'; /* End string */
2018
ptr+=2; /* Skip end mark and last 0 */
2022
point_to_type->count= (uint) (*array - point_to_type->type_names);
2024
*((*array)++)= NullS; /* End of type */
2026
*names=ptr; /* Update end */
2028
} /* fix_type_pointers */
2031
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
2033
TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
222
result->count= strings.elements;
224
uint32_t nbytes= (sizeof(char*) + sizeof(uint32_t)) * (result->count + 1);
226
if (!(result->type_names= (const char**) mem_root->alloc_root(nbytes)))
2036
result->count=strings.elements;
2038
uint nbytes= (sizeof(char*) + sizeof(uint)) * (result->count + 1);
2039
if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
229
2041
result->type_lengths= (uint*) (result->type_names + result->count + 1);
231
2042
List_iterator<String> it(strings);
233
for (uint32_t i= 0; (tmp= it++); i++)
2044
for (uint i=0; (tmp=it++) ; i++)
235
2046
result->type_names[i]= tmp->ptr();
236
2047
result->type_lengths[i]= tmp->length();
239
result->type_names[result->count]= 0; // End marker
2049
result->type_names[result->count]= 0; // End marker
240
2050
result->type_lengths[result->count]= 0;
2056
Search after a field with given start & length
2057
If an exact field isn't found, return longest field with starts
2061
This is needed because in some .frm fields 'fieldnr' was saved wrong
2068
static uint find_field(Field **fields, uchar *record, uint start, uint length)
2074
for (field= fields, i=1 ; *field ; i++,field++)
2076
if ((*field)->offset(record) == start)
2078
if ((*field)->key_length() == length)
2080
if (!pos || fields[pos-1]->pack_length() <
2081
(*field)->pack_length())
245
2089
/* Check that the integer is in the internal */
247
2091
int set_zone(register int nr, int min_zone, int max_zone)
2481
last_char_is_space= *name==' ';
428
2484
NAMES_SEP_CHAR is used in FRM format to separate SET and ENUM values.
429
2485
It is defined as 0xFF, which is a not valid byte in utf8.
430
2486
This assert is to catch use of this byte if we decide to
431
2487
use non-utf8 as system_character_set.
433
assert(*name != NAMES_SEP_CHAR);
2489
DBUG_ASSERT(*name != NAMES_SEP_CHAR);
437
2493
/* Error if empty or too long column name */
438
return last_char_is_space || (uint32_t) name_length > NAME_CHAR_LEN;
2494
return last_char_is_space || (uint) name_length > NAME_CHAR_LEN;
2499
Checks whether a table is intact. Should be done *just* after the table has
2502
@param[in] table The table to check
2503
@param[in] table_f_count Expected number of columns in the table
2504
@param[in] table_def Expected structure of the table (column name
2508
@retval TRUE There was an error. An error message is output
2509
to the error log. We do not push an error
2510
message into the error stack because this
2511
function is currently only called at start up,
2512
and such errors never reach the user.
2516
table_check_intact(TABLE *table, const uint table_f_count,
2517
const TABLE_FIELD_W_TYPE *table_def)
2520
my_bool error= FALSE;
2521
my_bool fields_diff_count;
2522
DBUG_ENTER("table_check_intact");
2523
DBUG_PRINT("info",("table: %s expected_count: %d",
2524
table->alias, table_f_count));
2526
fields_diff_count= (table->s->fields != table_f_count);
2527
if (fields_diff_count)
2529
DBUG_PRINT("info", ("Column count has changed, checking the definition"));
2531
/* previous MySQL version */
2532
if (MYSQL_VERSION_ID > table->s->mysql_version)
2534
sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
2535
table->alias, table_f_count, table->s->fields,
2536
table->s->mysql_version, MYSQL_VERSION_ID);
2539
else if (MYSQL_VERSION_ID == table->s->mysql_version)
2541
sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,
2542
table_f_count, table->s->fields);
2546
Something has definitely changed, but we're running an older
2547
version of MySQL with new system tables.
2548
Let's check column definitions. If a column was added at
2549
the end of the table, then we don't care much since such change
2550
is backward compatible.
2553
char buffer[STRING_BUFFER_USUAL_SIZE];
2554
for (i=0 ; i < table_f_count; i++, table_def++)
2556
String sql_type(buffer, sizeof(buffer), system_charset_info);
2558
if (i < table->s->fields)
2560
Field *field= table->field[i];
2562
if (strncmp(field->field_name, table_def->name.str,
2563
table_def->name.length))
2566
Name changes are not fatal, we use ordinal numbers to access columns.
2567
Still this can be a sign of a tampered table, output an error
2570
sql_print_error("Incorrect definition of table %s.%s: "
2571
"expected column '%s' at position %d, found '%s'.",
2572
table->s->db.str, table->alias, table_def->name.str, i,
2575
field->sql_type(sql_type);
2577
Generally, if column types don't match, then something is
2580
However, we only compare column definitions up to the
2581
length of the original definition, since we consider the
2582
following definitions compatible:
2584
1. DATETIME and DATETIM
2585
2. INT(11) and INT(11
2586
3. SET('one', 'two') and SET('one', 'two', 'more')
2588
For SETs or ENUMs, if the same prefix is there it's OK to
2589
add more elements - they will get higher ordinal numbers and
2590
the new table definition is backward compatible with the
2593
if (strncmp(sql_type.c_ptr_safe(), table_def->type.str,
2594
table_def->type.length - 1))
2596
sql_print_error("Incorrect definition of table %s.%s: "
2597
"expected column '%s' at position %d to have type "
2598
"%s, found type %s.", table->s->db.str, table->alias,
2599
table_def->name.str, i, table_def->type.str,
2600
sql_type.c_ptr_safe());
2603
else if (table_def->cset.str && !field->has_charset())
2605
sql_print_error("Incorrect definition of table %s.%s: "
2606
"expected the type of column '%s' at position %d "
2607
"to have character set '%s' but the type has no "
2608
"character set.", table->s->db.str, table->alias,
2609
table_def->name.str, i, table_def->cset.str);
2612
else if (table_def->cset.str &&
2613
strcmp(field->charset()->csname, table_def->cset.str))
2615
sql_print_error("Incorrect definition of table %s.%s: "
2616
"expected the type of column '%s' at position %d "
2617
"to have character set '%s' but found "
2618
"character set '%s'.", table->s->db.str, table->alias,
2619
table_def->name.str, i, table_def->cset.str,
2620
field->charset()->csname);
2626
sql_print_error("Incorrect definition of table %s.%s: "
2627
"expected column '%s' at position %d to have type %s "
2628
" but the column is not found.",
2629
table->s->db.str, table->alias,
2630
table_def->name.str, i, table_def->type.str);
2639
Create Item_field for each column in the table.
2642
st_table::fill_item_list()
2643
item_list a pointer to an empty list used to store items
2646
Create Item_field object for each column in the table and
2647
initialize it with the corresponding Field. New items are
2648
created in the current THD memory root.
2655
bool st_table::fill_item_list(List<Item> *item_list) const
2658
All Item_field's created using a direct pointer to a field
2659
are fixed in Item_field constructor.
2661
for (Field **ptr= field; *ptr; ptr++)
2663
Item_field *item= new Item_field(*ptr);
2664
if (!item || item_list->push_back(item))
2671
Reset an existing list of Item_field items to point to the
2672
Fields of this table.
2675
st_table::fill_item_list()
2676
item_list a non-empty list with Item_fields
2679
This is a counterpart of fill_item_list used to redirect
2680
Item_fields to the fields of a newly created table.
2681
The caller must ensure that number of items in the item_list
2682
is the same as the number of columns in the table.
2685
void st_table::reset_item_list(List<Item> *item_list) const
2687
List_iterator_fast<Item> it(*item_list);
2688
for (Field **ptr= field; *ptr; ptr++)
2690
Item_field *item_field= (Item_field*) it++;
2691
DBUG_ASSERT(item_field != 0);
2692
item_field->reset_field(*ptr);
2698
Merge ON expressions for a view
2703
table table for the VIEW
2704
is_cascaded TRUE <=> merge ON expressions from underlying views
2707
This function returns the result of ANDing the ON expressions
2708
of the given view and all underlying views. The ON expressions
2709
of the underlying views are added only if is_cascaded is TRUE.
2712
Pointer to the built expression if there is any.
2713
Otherwise and in the case of a failure NULL is returned.
2717
merge_on_conds(THD *thd, TABLE_LIST *table, bool is_cascaded)
2719
DBUG_ENTER("merge_on_conds");
2722
DBUG_PRINT("info", ("alias: %s", table->alias));
2724
cond= table->on_expr->copy_andor_structure(thd);
2725
if (!table->nested_join)
2727
List_iterator<TABLE_LIST> li(table->nested_join->join_list);
2728
while (TABLE_LIST *tbl= li++)
2730
cond= and_conds(cond, merge_on_conds(thd, tbl, is_cascaded));
2737
Find underlying base tables (TABLE_LIST) which represent given
2738
table_to_find (TABLE)
2741
TABLE_LIST::find_underlying_table()
2742
table_to_find table to find
2745
0 table is not found
2746
found table reference
2749
TABLE_LIST *TABLE_LIST::find_underlying_table(TABLE *table_to_find)
2751
/* is this real table and table which we are looking for? */
2752
if (table == table_to_find && merge_underlying_list == 0)
2755
for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
2758
if ((result= tbl->find_underlying_table(table_to_find)))
2765
cleunup items belonged to view fields translation table
2768
TABLE_LIST::cleanup_items()
2771
void TABLE_LIST::cleanup_items()
2773
if (!field_translation)
2776
for (Field_translator *transl= field_translation;
2777
transl < field_translation_end;
2779
transl->item->walk(&Item::cleanup_processor, 0, 0);
2784
Set insert_values buffer
2788
mem_root memory pool for allocating
2792
TRUE - out of memory
2795
bool TABLE_LIST::set_insert_values(MEM_ROOT *mem_root)
2799
if (!table->insert_values &&
2800
!(table->insert_values= (uchar *)alloc_root(mem_root,
2801
table->s->rec_buff_length)))
2810
Test if this is a leaf with respect to name resolution.
2813
TABLE_LIST::is_leaf_for_name_resolution()
2816
A table reference is a leaf with respect to name resolution if
2817
it is either a leaf node in a nested join tree (table, view,
2818
schema table, subquery), or an inner node that represents a
2819
NATURAL/USING join, or a nested join with materialized join
2823
TRUE if a leaf, FALSE otherwise.
2825
bool TABLE_LIST::is_leaf_for_name_resolution()
2827
return (is_natural_join || is_join_columns_complete || !nested_join);
2832
Retrieve the first (left-most) leaf in a nested join tree with
2833
respect to name resolution.
2836
TABLE_LIST::first_leaf_for_name_resolution()
2839
Given that 'this' is a nested table reference, recursively walk
2840
down the left-most children of 'this' until we reach a leaf
2841
table reference with respect to name resolution.
2844
The left-most child of a nested table reference is the last element
2845
in the list of children because the children are inserted in
2849
If 'this' is a nested table reference - the left-most child of
2850
the tree rooted in 'this',
2854
TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
2856
TABLE_LIST *cur_table_ref;
2857
NESTED_JOIN *cur_nested_join;
2859
if (is_leaf_for_name_resolution())
2861
DBUG_ASSERT(nested_join);
2863
for (cur_nested_join= nested_join;
2865
cur_nested_join= cur_table_ref->nested_join)
2867
List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
2868
cur_table_ref= it++;
2870
If the current nested join is a RIGHT JOIN, the operands in
2871
'join_list' are in reverse order, thus the first operand is
2872
already at the front of the list. Otherwise the first operand
2873
is in the end of the list of join operands.
2875
if (!(cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
2878
while ((next= it++))
2879
cur_table_ref= next;
2881
if (cur_table_ref->is_leaf_for_name_resolution())
2884
return cur_table_ref;
2889
Retrieve the last (right-most) leaf in a nested join tree with
2890
respect to name resolution.
2893
TABLE_LIST::last_leaf_for_name_resolution()
2896
Given that 'this' is a nested table reference, recursively walk
2897
down the right-most children of 'this' until we reach a leaf
2898
table reference with respect to name resolution.
2901
The right-most child of a nested table reference is the first
2902
element in the list of children because the children are inserted
2906
- If 'this' is a nested table reference - the right-most child of
2907
the tree rooted in 'this',
2911
TABLE_LIST *TABLE_LIST::last_leaf_for_name_resolution()
2913
TABLE_LIST *cur_table_ref= this;
2914
NESTED_JOIN *cur_nested_join;
2916
if (is_leaf_for_name_resolution())
2918
DBUG_ASSERT(nested_join);
2920
for (cur_nested_join= nested_join;
2922
cur_nested_join= cur_table_ref->nested_join)
2924
cur_table_ref= cur_nested_join->join_list.head();
2926
If the current nested is a RIGHT JOIN, the operands in
2927
'join_list' are in reverse order, thus the last operand is in the
2930
if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
2932
List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
2934
cur_table_ref= it++;
2935
while ((next= it++))
2936
cur_table_ref= next;
2938
if (cur_table_ref->is_leaf_for_name_resolution())
2941
return cur_table_ref;
2945
Natural_join_column::Natural_join_column(Field_translator *field_param,
2948
DBUG_ASSERT(tab->field_translation);
2949
view_field= field_param;
2956
Natural_join_column::Natural_join_column(Field *field_param,
2959
DBUG_ASSERT(tab->table == field_param->table);
2960
table_field= field_param;
2967
const char *Natural_join_column::name()
2971
DBUG_ASSERT(table_field == NULL);
2972
return view_field->name;
2975
return table_field->field_name;
2979
Item *Natural_join_column::create_item(THD *thd)
2983
DBUG_ASSERT(table_field == NULL);
2984
return create_view_field(thd, table_ref, &view_field->item,
2987
return new Item_field(thd, &thd->lex->current_select->context, table_field);
2991
Field *Natural_join_column::field()
2995
DBUG_ASSERT(table_field == NULL);
3002
const char *Natural_join_column::table_name()
3004
DBUG_ASSERT(table_ref);
3005
return table_ref->alias;
3009
const char *Natural_join_column::db_name()
3012
Test that TABLE_LIST::db is the same as st_table_share::db to
3013
ensure consistency. An exception are I_S schema tables, which
3014
are inconsistent in this respect.
3016
DBUG_ASSERT(!strcmp(table_ref->db,
3017
table_ref->table->s->db.str) ||
3018
(table_ref->schema_table &&
3019
table_ref->table->s->db.str[0] == 0));
3020
return table_ref->db;
3024
void Field_iterator_view::set(TABLE_LIST *table)
3026
DBUG_ASSERT(table->field_translation);
3028
ptr= table->field_translation;
3029
array_end= table->field_translation_end;
3033
const char *Field_iterator_table::name()
3035
return (*ptr)->field_name;
3039
Item *Field_iterator_table::create_item(THD *thd)
3041
SELECT_LEX *select= thd->lex->current_select;
3043
Item_field *item= new Item_field(thd, &select->context, *ptr);
3044
if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
3045
!thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS)
3047
select->non_agg_fields.push_back(item);
3048
item->marker= select->cur_pos_in_select_list;
3054
const char *Field_iterator_view::name()
3060
Item *Field_iterator_view::create_item(THD *thd)
3062
return create_view_field(thd, view, &ptr->item, ptr->name);
3065
Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
3068
DBUG_ENTER("create_view_field");
3069
if (view->schema_table_reformed)
3071
Item *field= *field_ref;
3074
Translation table items are always Item_fields and already fixed
3075
('mysql_schema_table' function). So we can return directly the
3076
field. This case happens only for 'show & where' commands.
3078
DBUG_ASSERT(field && field->fixed);
3086
void Field_iterator_natural_join::set(TABLE_LIST *table_ref)
3088
DBUG_ASSERT(table_ref->join_columns);
3089
column_ref_it.init(*(table_ref->join_columns));
3090
cur_column_ref= column_ref_it++;
3094
void Field_iterator_natural_join::next()
3096
cur_column_ref= column_ref_it++;
3097
DBUG_ASSERT(!cur_column_ref || ! cur_column_ref->table_field ||
3098
cur_column_ref->table_ref->table ==
3099
cur_column_ref->table_field->table);
3103
void Field_iterator_table_ref::set_field_iterator()
3105
DBUG_ENTER("Field_iterator_table_ref::set_field_iterator");
3107
If the table reference we are iterating over is a natural join, or it is
3108
an operand of a natural join, and TABLE_LIST::join_columns contains all
3109
the columns of the join operand, then we pick the columns from
3110
TABLE_LIST::join_columns, instead of the orginial container of the
3111
columns of the join operator.
3113
if (table_ref->is_join_columns_complete)
3115
/* Necesary, but insufficient conditions. */
3116
DBUG_ASSERT(table_ref->is_natural_join ||
3117
table_ref->nested_join ||
3118
table_ref->join_columns &&
3119
/* This is a merge view. */
3120
((table_ref->field_translation &&
3121
table_ref->join_columns->elements ==
3122
(ulong)(table_ref->field_translation_end -
3123
table_ref->field_translation)) ||
3124
/* This is stored table or a tmptable view. */
3125
(!table_ref->field_translation &&
3126
table_ref->join_columns->elements ==
3127
table_ref->table->s->fields)));
3128
field_it= &natural_join_it;
3129
DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",
3132
/* This is a base table or stored view. */
3135
DBUG_ASSERT(table_ref->table);
3136
field_it= &table_field_it;
3137
DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_table",
3140
field_it->set(table_ref);
3145
void Field_iterator_table_ref::set(TABLE_LIST *table)
3148
first_leaf= table->first_leaf_for_name_resolution();
3149
last_leaf= table->last_leaf_for_name_resolution();
3150
DBUG_ASSERT(first_leaf && last_leaf);
3151
table_ref= first_leaf;
3152
set_field_iterator();
3156
void Field_iterator_table_ref::next()
3158
/* Move to the next field in the current table reference. */
3161
If all fields of the current table reference are exhausted, move to
3162
the next leaf table reference.
3164
if (field_it->end_of_fields() && table_ref != last_leaf)
3166
table_ref= table_ref->next_name_resolution_table;
3167
DBUG_ASSERT(table_ref);
3168
set_field_iterator();
3173
const char *Field_iterator_table_ref::table_name()
3175
if (table_ref->is_natural_join)
3176
return natural_join_it.column_ref()->table_name();
3178
DBUG_ASSERT(!strcmp(table_ref->table_name,
3179
table_ref->table->s->table_name.str));
3180
return table_ref->table_name;
3184
const char *Field_iterator_table_ref::db_name()
3186
if (table_ref->is_natural_join)
3187
return natural_join_it.column_ref()->db_name();
3190
Test that TABLE_LIST::db is the same as st_table_share::db to
3191
ensure consistency. An exception are I_S schema tables, which
3192
are inconsistent in this respect.
3194
DBUG_ASSERT(!strcmp(table_ref->db, table_ref->table->s->db.str) ||
3195
(table_ref->schema_table &&
3196
table_ref->table->s->db.str[0] == 0));
3198
return table_ref->db;
3203
Create new or return existing column reference to a column of a
3207
Field_iterator_table_ref::get_or_create_column_ref()
3208
parent_table_ref the parent table reference over which the
3209
iterator is iterating
3212
Create a new natural join column for the current field of the
3213
iterator if no such column was created, or return an already
3214
created natural join column. The former happens for base tables or
3215
views, and the latter for natural/using joins. If a new field is
3216
created, then the field is added to 'parent_table_ref' if it is
3217
given, or to the original table referene of the field if
3218
parent_table_ref == NULL.
3221
This method is designed so that when a Field_iterator_table_ref
3222
walks through the fields of a table reference, all its fields
3223
are created and stored as follows:
3224
- If the table reference being iterated is a stored table, view or
3225
natural/using join, store all natural join columns in a list
3226
attached to that table reference.
3227
- If the table reference being iterated is a nested join that is
3228
not natural/using join, then do not materialize its result
3229
fields. This is OK because for such table references
3230
Field_iterator_table_ref iterates over the fields of the nested
3231
table references (recursively). In this way we avoid the storage
3232
of unnecessay copies of result columns of nested joins.
3235
# Pointer to a column of a natural join (or its operand)
3236
NULL No memory to allocate the column
3239
Natural_join_column *
3240
Field_iterator_table_ref::get_or_create_column_ref(TABLE_LIST *parent_table_ref)
3242
Natural_join_column *nj_col;
3243
bool is_created= TRUE;
3245
TABLE_LIST *add_table_ref= parent_table_ref ?
3246
parent_table_ref : table_ref;
3248
if (field_it == &table_field_it)
3250
/* The field belongs to a stored table. */
3251
Field *tmp_field= table_field_it.field();
3252
nj_col= new Natural_join_column(tmp_field, table_ref);
3253
field_count= table_ref->table->s->fields;
3255
else if (field_it == &view_field_it)
3257
/* The field belongs to a merge view or information schema table. */
3258
Field_translator *translated_field= view_field_it.field_translator();
3259
nj_col= new Natural_join_column(translated_field, table_ref);
3260
field_count= table_ref->field_translation_end -
3261
table_ref->field_translation;
3266
The field belongs to a NATURAL join, therefore the column reference was
3267
already created via one of the two constructor calls above. In this case
3268
we just return the already created column reference.
3270
DBUG_ASSERT(table_ref->is_join_columns_complete);
3272
nj_col= natural_join_it.column_ref();
3273
DBUG_ASSERT(nj_col);
3275
DBUG_ASSERT(!nj_col->table_field ||
3276
nj_col->table_ref->table == nj_col->table_field->table);
3279
If the natural join column was just created add it to the list of
3280
natural join columns of either 'parent_table_ref' or to the table
3281
reference that directly contains the original field.
3285
/* Make sure not all columns were materialized. */
3286
DBUG_ASSERT(!add_table_ref->is_join_columns_complete);
3287
if (!add_table_ref->join_columns)
3289
/* Create a list of natural join columns on demand. */
3290
if (!(add_table_ref->join_columns= new List<Natural_join_column>))
3292
add_table_ref->is_join_columns_complete= FALSE;
3294
add_table_ref->join_columns->push_back(nj_col);
3296
If new fields are added to their original table reference, mark if
3297
all fields were added. We do it here as the caller has no easy way
3298
of knowing when to do it.
3299
If the fields are being added to parent_table_ref, then the caller
3300
must take care to mark when all fields are created/added.
3302
if (!parent_table_ref &&
3303
add_table_ref->join_columns->elements == field_count)
3304
add_table_ref->is_join_columns_complete= TRUE;
3312
Return an existing reference to a column of a natural/using join.
3315
Field_iterator_table_ref::get_natural_column_ref()
3318
The method should be called in contexts where it is expected that
3319
all natural join columns are already created, and that the column
3320
being retrieved is a Natural_join_column.
3323
# Pointer to a column of a natural join (or its operand)
3324
NULL No memory to allocate the column
3327
Natural_join_column *
3328
Field_iterator_table_ref::get_natural_column_ref()
3330
Natural_join_column *nj_col;
3332
DBUG_ASSERT(field_it == &natural_join_it);
3334
The field belongs to a NATURAL join, therefore the column reference was
3335
already created via one of the two constructor calls above. In this case
3336
we just return the already created column reference.
3338
nj_col= natural_join_it.column_ref();
3339
DBUG_ASSERT(nj_col &&
3340
(!nj_col->table_field ||
3341
nj_col->table_ref->table == nj_col->table_field->table));
442
3345
/*****************************************************************************
443
3346
Functions to handle column usage bitmaps (read_set, write_set etc...)
625
3530
if neeed, either the primary key column or all columns to be read.
626
3531
(see mark_columns_needed_for_delete() for details)
628
If the engine has HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
3533
If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
629
3534
mark all USED key columns as 'to-be-read'. This allows the engine to
630
3535
loop over the given record to find all changed keys and doesn't have to
631
3536
retrieve the row again.
634
void Table::mark_columns_needed_for_update()
3539
void st_table::mark_columns_needed_for_update()
637
If the Cursor has no cursor capabilites, or we have row-based
638
logging active for the current statement, we have to read either
639
the primary key, the hidden primary key or all columns to be
642
if (not s->hasPrimaryKey())
644
/* fallback to use all columns in the table to identify row */
649
mark_columns_used_by_index_no_reset(s->getPrimaryKey());
651
if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
3541
DBUG_ENTER("mark_columns_needed_for_update");
3542
if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
653
3544
/* Mark all used key columns for read */
654
3545
Field **reg_field;
655
3546
for (reg_field= field ; *reg_field ; reg_field++)
657
3548
/* Merge keys is all keys that had a column refered to in the query */
658
if (is_overlapping(merge_keys, (*reg_field)->part_of_key))
659
setReadSet((*reg_field)->field_index);
3549
if (merge_keys.is_overlapping((*reg_field)->part_of_key))
3550
bitmap_set_bit(read_set, (*reg_field)->field_index);
3552
file->column_bitmaps_signal();
3554
if ((file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) ||
3555
(mysql_bin_log.is_open() && in_use && in_use->current_stmt_binlog_row_based))
3558
If the handler has no cursor capabilites, or we have row-based
3559
logging active for the current statement, we have to read either
3560
the primary key, the hidden primary key or all columns to be
3561
able to do an update
3563
if (s->primary_key == MAX_KEY)
3564
file->use_hidden_primary_key();
3567
mark_columns_used_by_index_no_reset(s->primary_key, read_set);
3568
file->column_bitmaps_signal();
667
Mark columns the Cursor needs for doing an insert
3576
Mark columns the handler needs for doing an insert
669
3578
For now, this is used to mark fields used by the trigger
673
void Table::mark_columns_needed_for_insert()
3582
void st_table::mark_columns_needed_for_insert()
675
3584
if (found_next_number_field)
676
3585
mark_auto_increment_column();
681
size_t Table::max_row_length(const unsigned char *data)
683
size_t length= getRecordLength() + 2 * sizeFields();
684
uint32_t *const beg= getBlobField();
685
uint32_t *const end= beg + sizeBlobFields();
687
for (uint32_t *ptr= beg ; ptr != end ; ++ptr)
689
Field_blob* const blob= (Field_blob*) field[*ptr];
690
length+= blob->get_length((const unsigned char*)
691
(data + blob->offset(getInsertRecord()))) +
3589
Cleanup this table for re-execution.
3592
TABLE_LIST::reinit_before_use()
3595
void TABLE_LIST::reinit_before_use(THD *thd)
3598
Reset old pointers to TABLEs: they are not valid since the tables
3599
were closed in the end of previous prepare or execute call.
3602
/* Reset is_schema_table_processed value(needed for I_S tables */
3603
schema_table_state= NOT_PROCESSED;
3605
TABLE_LIST *embedded; /* The table at the current level of nesting. */
3606
TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
3609
embedded= parent_embedding;
3610
if (embedded->prep_on_expr)
3611
embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
3612
parent_embedding= embedded->embedding;
3614
while (parent_embedding &&
3615
parent_embedding->nested_join->join_list.head() == embedded);
3619
Return subselect that contains the FROM list this table is taken from
3622
TABLE_LIST::containing_subselect()
3625
Subselect item for the subquery that contains the FROM list
3626
this table is taken from if there is any
3631
Item_subselect *TABLE_LIST::containing_subselect()
3633
return (select_lex ? select_lex->master_unit()->item : 0);
3637
Compiles the tagged hints list and fills up the bitmasks.
3640
process_index_hints()
3641
table the TABLE to operate on.
3644
The parser collects the index hints for each table in a "tagged list"
3645
(TABLE_LIST::index_hints). Using the information in this tagged list
3646
this function sets the members st_table::keys_in_use_for_query,
3647
st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
3648
st_table::force_index and st_table::covering_keys.
3650
Current implementation of the runtime does not allow mixing FORCE INDEX
3651
and USE INDEX, so this is checked here. Then the FORCE INDEX list
3652
(if non-empty) is appended to the USE INDEX list and a flag is set.
3654
Multiple hints of the same kind are processed so that each clause
3655
is applied to what is computed in the previous clause.
3657
USE INDEX (i1) USE INDEX (i2)
3660
and means "consider only i1 and i2".
3663
USE INDEX () USE INDEX (i1)
3666
and means "consider only the index i1"
3668
It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
3671
Different kind of hints (USE/FORCE/IGNORE) are processed in the following
3673
1. All indexes in USE (or FORCE) INDEX are added to the mask.
3676
e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
3677
as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
3679
As an optimization if there is a covering index, and we have
3680
IGNORE INDEX FOR GROUP/ORDER, and this index is used for the JOIN part,
3681
then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.
3684
FALSE no errors found
3685
TRUE found and reported an error.
3687
bool TABLE_LIST::process_index_hints(TABLE *tbl)
3689
/* initialize the result variables */
3690
tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by=
3691
tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
3693
/* index hint list processing */
3696
key_map index_join[INDEX_HINT_FORCE + 1];
3697
key_map index_order[INDEX_HINT_FORCE + 1];
3698
key_map index_group[INDEX_HINT_FORCE + 1];
3701
bool have_empty_use_join= FALSE, have_empty_use_order= FALSE,
3702
have_empty_use_group= FALSE;
3703
List_iterator <Index_hint> iter(*index_hints);
3705
/* initialize temporary variables used to collect hints of each kind */
3706
for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)
3708
index_join[type].clear_all();
3709
index_order[type].clear_all();
3710
index_group[type].clear_all();
3713
/* iterate over the hints list */
3714
while ((hint= iter++))
3718
/* process empty USE INDEX () */
3719
if (hint->type == INDEX_HINT_USE && !hint->key_name.str)
3721
if (hint->clause & INDEX_HINT_MASK_JOIN)
3723
index_join[hint->type].clear_all();
3724
have_empty_use_join= TRUE;
3726
if (hint->clause & INDEX_HINT_MASK_ORDER)
3728
index_order[hint->type].clear_all();
3729
have_empty_use_order= TRUE;
3731
if (hint->clause & INDEX_HINT_MASK_GROUP)
3733
index_group[hint->type].clear_all();
3734
have_empty_use_group= TRUE;
3740
Check if an index with the given name exists and get his offset in
3741
the keys bitmask for the table
3743
if (tbl->s->keynames.type_names == 0 ||
3744
(pos= find_type(&tbl->s->keynames, hint->key_name.str,
3745
hint->key_name.length, 1)) <= 0)
3747
my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
3753
/* add to the appropriate clause mask */
3754
if (hint->clause & INDEX_HINT_MASK_JOIN)
3755
index_join[hint->type].set_bit (pos);
3756
if (hint->clause & INDEX_HINT_MASK_ORDER)
3757
index_order[hint->type].set_bit (pos);
3758
if (hint->clause & INDEX_HINT_MASK_GROUP)
3759
index_group[hint->type].set_bit (pos);
3762
/* cannot mix USE INDEX and FORCE INDEX */
3763
if ((!index_join[INDEX_HINT_FORCE].is_clear_all() ||
3764
!index_order[INDEX_HINT_FORCE].is_clear_all() ||
3765
!index_group[INDEX_HINT_FORCE].is_clear_all()) &&
3766
(!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join ||
3767
!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order ||
3768
!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group))
3770
my_error(ER_WRONG_USAGE, MYF(0), index_hint_type_name[INDEX_HINT_USE],
3771
index_hint_type_name[INDEX_HINT_FORCE]);
3775
/* process FORCE INDEX as USE INDEX with a flag */
3776
if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||
3777
!index_order[INDEX_HINT_FORCE].is_clear_all() ||
3778
!index_group[INDEX_HINT_FORCE].is_clear_all())
3780
tbl->force_index= TRUE;
3781
index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
3782
index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
3783
index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
3786
/* apply USE INDEX */
3787
if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
3788
tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
3789
if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
3790
tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
3791
if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
3792
tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
3794
/* apply IGNORE INDEX */
3795
tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
3796
tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
3797
tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
3800
/* make sure covering_keys don't include indexes disabled with a hint */
3801
tbl->covering_keys.intersect(tbl->keys_in_use_for_query);
3806
size_t max_row_length(TABLE *table, const uchar *data)
3808
TABLE_SHARE *table_s= table->s;
3809
size_t length= table_s->reclength + 2 * table_s->fields;
3810
uint *const beg= table_s->blob_field;
3811
uint *const end= beg + table_s->blob_fields;
3813
for (uint *ptr= beg ; ptr != end ; ++ptr)
3815
Field_blob* const blob= (Field_blob*) table->field[*ptr];
3816
length+= blob->get_length((const uchar*)
3817
(data + blob->offset(table->record[0]))) +
692
3818
HA_KEY_BLOB_LENGTH;
697
/****************************************************************************
698
Functions for creating temporary tables.
699
****************************************************************************/
701
Create field for temporary table from given field.
703
@param session Thread Cursor
704
@param org_field field from which new field will be created
705
@param name New field name
706
@param table Temporary table
707
@param item !=NULL if item->result_field should point to new field.
708
This is relevant for how fill_record() is going to work:
709
If item != NULL then fill_record() will update
710
the record in the original table.
711
If item == NULL then fill_record() will update
713
@param convert_blob_length If >0 create a varstring(convert_blob_length)
714
field instead of blob.
722
Field *create_tmp_field_from_field(Session *session, Field *org_field,
723
const char *name, Table *table,
724
Item_field *item, uint32_t convert_blob_length)
729
Make sure that the blob fits into a Field_varstring which has
732
if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&
733
(org_field->flags & BLOB_FLAG))
734
new_field= new Field_varstring(convert_blob_length,
735
org_field->maybe_null(),
736
org_field->field_name, table->getMutableShare(),
737
org_field->charset());
739
new_field= org_field->new_field(session->mem_root, table,
740
table == org_field->getTable());
743
new_field->init(table);
744
new_field->orig_table= org_field->orig_table;
746
item->result_field= new_field;
748
new_field->field_name= name;
749
new_field->flags|= (org_field->flags & NO_DEFAULT_VALUE_FLAG);
750
if (org_field->maybe_null() || (item && item->maybe_null))
751
new_field->flags&= ~NOT_NULL_FLAG; // Because of outer join
752
if (org_field->type() == DRIZZLE_TYPE_VARCHAR)
753
table->getMutableShare()->db_create_options|= HA_OPTION_PACK_RECORD;
754
else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)
755
((Field_double *) new_field)->not_fixed= true;
762
Create a temp table according to a field list.
764
Given field pointers are changed to point at tmp_table for
765
send_fields. The table object is self contained: it's
766
allocated in its own memory root, as well as Field objects
767
created for table columns.
768
This function will replace Item_sum items in 'fields' list with
769
corresponding Item_field items, pointing at the fields in the
770
temporary table, unless this was prohibited by true
771
value of argument save_sum_fields. The Item_field objects
772
are created in Session memory root.
774
@param session thread handle
775
@param param a description used as input to create the table
776
@param fields list of items that will be used to define
777
column types of the table (also see NOTES)
778
@param group TODO document
779
@param distinct should table rows be distinct
780
@param save_sum_fields see NOTES
781
@param select_options
783
@param table_alias possible name of the temporary table that can
784
be used for name resolving; can be "".
787
#define STRING_TOTAL_LENGTH_TO_PACK_ROWS 128
788
#define AVG_STRING_LENGTH_TO_PACK_ROWS 64
789
#define RATIO_TO_PACK_ROWS 2
792
create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
793
order_st *group, bool distinct, bool save_sum_fields,
794
uint64_t select_options, ha_rows rows_limit,
795
const char *table_alias)
797
memory::Root *mem_root_save;
799
uint i,field_count,null_count,null_pack_length;
800
uint32_t copy_func_count= param->func_count;
801
uint32_t hidden_null_count, hidden_null_pack_length, hidden_field_count;
802
uint32_t blob_count,group_null_items, string_count;
804
ulong reclength, string_total_length;
805
bool using_unique_constraint= false;
806
bool use_packed_rows= true;
807
bool not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
808
unsigned char *pos, *group_buff, *bitmaps;
809
unsigned char *null_flags;
810
Field **reg_field, **from_field, **default_field;
813
KeyPartInfo *key_part_info;
815
MI_COLUMNDEF *recinfo;
816
uint32_t total_uneven_bit_length= 0;
817
bool force_copy_fields= param->force_copy_fields;
818
uint64_t max_rows= 0;
820
session->status_var.created_tmp_tables++;
824
if (! param->quick_group)
826
group= 0; // Can't use group key
828
else for (order_st *tmp=group ; tmp ; tmp=tmp->next)
831
marker == 4 means two things:
832
- store NULLs in the key, and
833
- convert BIT fields to 64-bit long, needed because MEMORY tables
834
can't index BIT fields.
836
(*tmp->item)->marker= 4;
837
if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)
838
using_unique_constraint= true;
840
if (param->group_length >= MAX_BLOB_WIDTH)
841
using_unique_constraint= true;
843
distinct= 0; // Can't use distinct
846
field_count=param->field_count+param->func_count+param->sum_func_count;
847
hidden_field_count=param->hidden_field_count;
850
When loose index scan is employed as access method, it already
851
computes all groups and the result of all aggregate functions. We
852
make space for the items of the aggregate function in the list of
853
functions Tmp_Table_Param::items_to_copy, so that the values of
854
these items are stored in the temporary table.
856
if (param->precomputed_group_by)
858
copy_func_count+= param->sum_func_count;
861
TableShareInstance *share= session->getTemporaryShare(message::Table::INTERNAL); // This will not go into the tableshare cache, so no key is used.
863
if (not share->getMemRoot()->multi_alloc_root(0,
864
&default_field, sizeof(Field*) * (field_count),
865
&from_field, sizeof(Field*)*field_count,
866
©_func, sizeof(*copy_func)*(copy_func_count+1),
867
¶m->keyinfo, sizeof(*param->keyinfo),
868
&key_part_info, sizeof(*key_part_info)*(param->group_parts+1),
869
¶m->start_recinfo, sizeof(*param->recinfo)*(field_count*2+4),
870
&group_buff, (group && ! using_unique_constraint ?
871
param->group_length : 0),
872
&bitmaps, bitmap_buffer_size(field_count)*2,
877
/* CopyField belongs to Tmp_Table_Param, allocate it in Session mem_root */
878
if (!(param->copy_field= copy= new (session->mem_root) CopyField[field_count]))
882
param->items_to_copy= copy_func;
883
/* make table according to fields */
885
table= share->getTable();
887
memset(default_field, 0, sizeof(Field*) * (field_count));
888
memset(from_field, 0, sizeof(Field*)*field_count);
890
mem_root_save= session->mem_root;
891
session->mem_root= table->getMemRoot();
893
share->setFields(field_count+1);
894
table->setFields(share->getFields(true));
895
reg_field= share->getFields(true);
896
table->alias= table_alias;
897
table->reginfo.lock_type=TL_WRITE; /* Will be updated */
898
table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
900
table->copy_blobs= 1;
902
table->in_use= session;
903
table->quick_keys.reset();
904
table->covering_keys.reset();
905
table->keys_in_use_for_query.reset();
907
table->setShare(share);
908
share->blob_field.resize(field_count+1);
909
uint32_t *blob_field= &share->blob_field[0];
910
share->blob_ptr_size= portable_sizeof_char_ptr;
911
share->db_low_byte_first=1; // True for HEAP and MyISAM
912
share->table_charset= param->table_charset;
913
share->keys_for_keyread.reset();
914
share->keys_in_use.reset();
916
/* Calculate which type of fields we will store in the temporary table */
918
reclength= string_total_length= 0;
919
blob_count= string_count= null_count= hidden_null_count= group_null_items= 0;
920
param->using_indirect_summary_function= 0;
922
List_iterator_fast<Item> li(fields);
924
Field **tmp_from_field=from_field;
927
Item::Type type=item->type();
930
if (item->with_sum_func && type != Item::SUM_FUNC_ITEM)
932
if (item->used_tables() & OUTER_REF_TABLE_BIT)
933
item->update_used_tables();
934
if (type == Item::SUBSELECT_ITEM ||
935
(item->used_tables() & ~OUTER_REF_TABLE_BIT))
938
Mark that the we have ignored an item that refers to a summary
939
function. We need to know this if someone is going to use
940
DISTINCT on the result.
942
param->using_indirect_summary_function=1;
946
if (item->const_item() && (int) hidden_field_count <= 0)
947
continue; // We don't have to store this
949
if (type == Item::SUM_FUNC_ITEM && !group && !save_sum_fields)
950
{ /* Can't calc group yet */
951
((Item_sum*) item)->result_field= 0;
952
for (i= 0 ; i < ((Item_sum*) item)->arg_count ; i++)
954
Item **argp= ((Item_sum*) item)->args + i;
956
if (!arg->const_item())
959
create_tmp_field(session, table, arg, arg->type(), ©_func,
960
tmp_from_field, &default_field[fieldnr],
961
group != 0,not_all_columns,
963
param->convert_blob_length);
965
goto err; // Should be OOM
967
reclength+=new_field->pack_length();
968
if (new_field->flags & BLOB_FLAG)
970
*blob_field++= fieldnr;
973
*(reg_field++)= new_field;
974
if (new_field->real_type() == DRIZZLE_TYPE_VARCHAR)
977
string_total_length+= new_field->pack_length();
979
session->mem_root= mem_root_save;
980
session->change_item_tree(argp, new Item_field(new_field));
981
session->mem_root= table->getMemRoot();
982
if (!(new_field->flags & NOT_NULL_FLAG))
986
new_field->maybe_null() is still false, it will be
987
changed below. But we have to setup Item_field correctly
989
(*argp)->maybe_null=1;
991
new_field->field_index= fieldnr++;
998
The last parameter to create_tmp_field() is a bit tricky:
1000
We need to set it to 0 in union, to get fill_record() to modify the
1002
We need to set it to 1 on multi-table-update and in select to
1003
write rows to the temporary table.
1004
We here distinguish between UNION and multi-table-updates by the fact
1005
that in the later case group is set to the row pointer.
1008
create_tmp_field(session, table, item, type, ©_func,
1009
tmp_from_field, &default_field[fieldnr],
1011
!force_copy_fields &&
1012
(not_all_columns || group != 0),
1014
param->convert_blob_length);
1018
if (session->is_fatal_error)
1019
goto err; // Got OOM
1020
continue; // Some kindf of const item
1022
if (type == Item::SUM_FUNC_ITEM)
1023
((Item_sum *) item)->result_field= new_field;
1025
reclength+=new_field->pack_length();
1026
if (!(new_field->flags & NOT_NULL_FLAG))
1028
if (new_field->flags & BLOB_FLAG)
1030
*blob_field++= fieldnr;
1033
if (item->marker == 4 && item->maybe_null)
1036
new_field->flags|= GROUP_FLAG;
1038
new_field->field_index= fieldnr++;
1039
*(reg_field++)= new_field;
1041
if (!--hidden_field_count)
1044
This was the last hidden field; Remember how many hidden fields could
1047
hidden_null_count=null_count;
1049
We need to update hidden_field_count as we may have stored group
1050
functions with constant arguments
1052
param->hidden_field_count= fieldnr;
1056
assert(fieldnr == (uint32_t) (reg_field - table->getFields()));
1057
assert(field_count >= (uint32_t) (reg_field - table->getFields()));
1058
field_count= fieldnr;
1060
*blob_field= 0; // End marker
1061
share->fields= field_count;
1063
/* If result table is small; use a heap */
1064
/* future: storage engine selection can be made dynamic? */
1065
if (blob_count || using_unique_constraint ||
1066
(session->lex->select_lex.options & SELECT_BIG_RESULT) ||
1067
(session->lex->current_select->olap == ROLLUP_TYPE) ||
1068
(select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES)
1070
share->storage_engine= myisam_engine;
1071
table->cursor= share->db_type()->getCursor(*share);
1073
(param->group_parts > table->cursor->getEngine()->max_key_parts() ||
1074
param->group_length > table->cursor->getEngine()->max_key_length()))
1076
using_unique_constraint= true;
1081
share->storage_engine= heap_engine;
1082
table->cursor= share->db_type()->getCursor(*share);
1084
if (! table->cursor)
1088
if (! using_unique_constraint)
1089
reclength+= group_null_items; // null flag is stored separately
1091
share->blob_fields= blob_count;
1092
if (blob_count == 0)
1094
/* We need to ensure that first byte is not 0 for the delete link */
1095
if (param->hidden_field_count)
1096
hidden_null_count++;
1100
hidden_null_pack_length=(hidden_null_count+7)/8;
1101
null_pack_length= (hidden_null_pack_length +
1102
(null_count + total_uneven_bit_length + 7) / 8);
1103
reclength+=null_pack_length;
1105
reclength=1; // Dummy select
1106
/* Use packed rows if there is blobs or a lot of space to gain */
1107
if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))
1110
share->setRecordLength(reclength);
1112
uint32_t alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);
1113
share->rec_buff_length= alloc_length;
1114
if (!(table->record[0]= (unsigned char*) table->alloc_root(alloc_length*2)))
1118
table->record[1]= table->getInsertRecord()+alloc_length;
1119
share->resizeDefaultValues(alloc_length);
1121
copy_func[0]= 0; // End marker
1122
param->func_count= copy_func - param->items_to_copy;
1124
table->setup_tmp_table_column_bitmaps(bitmaps);
1126
recinfo=param->start_recinfo;
1127
null_flags=(unsigned char*) table->getInsertRecord();
1128
pos=table->getInsertRecord()+ null_pack_length;
1129
if (null_pack_length)
1131
memset(recinfo, 0, sizeof(*recinfo));
1132
recinfo->type=FIELD_NORMAL;
1133
recinfo->length=null_pack_length;
1135
memset(null_flags, 255, null_pack_length); // Set null fields
1137
table->null_flags= (unsigned char*) table->getInsertRecord();
1138
share->null_fields= null_count+ hidden_null_count;
1139
share->null_bytes= null_pack_length;
1141
null_count= (blob_count == 0) ? 1 : 0;
1142
hidden_field_count=param->hidden_field_count;
1143
for (i= 0,reg_field= table->getFields(); i < field_count; i++,reg_field++,recinfo++)
1145
Field *field= *reg_field;
1147
memset(recinfo, 0, sizeof(*recinfo));
1149
if (!(field->flags & NOT_NULL_FLAG))
1151
if (field->flags & GROUP_FLAG && !using_unique_constraint)
1154
We have to reserve one byte here for NULL bits,
1155
as this is updated by 'end_update()'
1157
*pos++= '\0'; // Null is stored here
1159
recinfo->type=FIELD_NORMAL;
1161
memset(recinfo, 0, sizeof(*recinfo));
1165
recinfo->null_bit= 1 << (null_count & 7);
1166
recinfo->null_pos= null_count/8;
1168
field->move_field(pos,null_flags+null_count/8,
1169
1 << (null_count & 7));
1173
field->move_field(pos,(unsigned char*) 0,0);
1177
Test if there is a default field value. The test for ->ptr is to skip
1178
'offset' fields generated by initalize_tables
1180
if (default_field[i] && default_field[i]->ptr)
1183
default_field[i] is set only in the cases when 'field' can
1184
inherit the default value that is defined for the field referred
1185
by the Item_field object from which 'field' has been created.
1188
Field *orig_field= default_field[i];
1189
/* Get the value from default_values */
1190
diff= (ptrdiff_t) (orig_field->getTable()->getDefaultValues() - orig_field->getTable()->getInsertRecord());
1191
orig_field->move_field_offset(diff); // Points now at default_values
1192
if (orig_field->is_real_null())
1196
field->set_notnull();
1197
memcpy(field->ptr, orig_field->ptr, field->pack_length());
1199
orig_field->move_field_offset(-diff); // Back to getInsertRecord()
1203
{ /* Not a table Item */
1204
copy->set(field,from_field[i],save_sum_fields);
1207
length=field->pack_length();
1210
/* Make entry for create table */
1211
recinfo->length=length;
1212
if (field->flags & BLOB_FLAG)
1213
recinfo->type= (int) FIELD_BLOB;
1215
recinfo->type=FIELD_NORMAL;
1216
if (!--hidden_field_count)
1217
null_count=(null_count+7) & ~7; // move to next byte
1220
param->copy_field_end=copy;
1221
param->recinfo=recinfo;
1222
table->storeRecordAsDefault(); // Make empty default record
1224
if (session->variables.tmp_table_size == ~ (uint64_t) 0) // No limit
1226
max_rows= ~(uint64_t) 0;
1230
max_rows= (uint64_t) (((share->db_type() == heap_engine) ?
1231
min(session->variables.tmp_table_size,
1232
session->variables.max_heap_table_size) :
1233
session->variables.tmp_table_size) /
1234
share->getRecordLength());
1237
set_if_bigger(max_rows, (uint64_t)1); // For dummy start options
1239
Push the LIMIT clause to the temporary table creation, so that we
1240
materialize only up to 'rows_limit' records instead of all result records.
1242
set_if_smaller(max_rows, rows_limit);
1244
share->setMaxRows(max_rows);
1246
param->end_write_records= rows_limit;
1248
keyinfo= param->keyinfo;
1252
table->group=group; /* Table is grouped by key */
1253
param->group_buff=group_buff;
1255
share->uniques= test(using_unique_constraint);
1256
table->key_info=keyinfo;
1257
keyinfo->key_part=key_part_info;
1258
keyinfo->flags=HA_NOSAME;
1259
keyinfo->usable_key_parts=keyinfo->key_parts= param->group_parts;
1260
keyinfo->key_length= 0;
1261
keyinfo->rec_per_key= 0;
1262
keyinfo->algorithm= HA_KEY_ALG_UNDEF;
1263
keyinfo->name= (char*) "group_key";
1264
order_st *cur_group= group;
1265
for (; cur_group ; cur_group= cur_group->next, key_part_info++)
1267
Field *field=(*cur_group->item)->get_tmp_table_field();
1268
bool maybe_null=(*cur_group->item)->maybe_null;
1269
key_part_info->null_bit= 0;
1270
key_part_info->field= field;
1271
key_part_info->offset= field->offset(table->getInsertRecord());
1272
key_part_info->length= (uint16_t) field->key_length();
1273
key_part_info->type= (uint8_t) field->key_type();
1274
key_part_info->key_type=
1275
((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
1276
(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
1277
(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
1279
if (!using_unique_constraint)
1281
cur_group->buff=(char*) group_buff;
1282
if (!(cur_group->field= field->new_key_field(session->mem_root,table,
1291
To be able to group on NULL, we reserved place in group_buff
1292
for the NULL flag just before the column. (see above).
1293
The field data is after this flag.
1294
The NULL flag is updated in 'end_update()' and 'end_write()'
1296
keyinfo->flags|= HA_NULL_ARE_EQUAL; // def. that NULL == NULL
1297
key_part_info->null_bit=field->null_bit;
1298
key_part_info->null_offset= (uint32_t) (field->null_ptr -
1299
(unsigned char*) table->getInsertRecord());
1300
cur_group->buff++; // Pointer to field data
1301
group_buff++; // Skipp null flag
1303
/* In GROUP BY 'a' and 'a ' are equal for VARCHAR fields */
1304
key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL;
1305
group_buff+= cur_group->field->pack_length();
1307
keyinfo->key_length+= key_part_info->length;
1311
if (distinct && field_count != param->hidden_field_count)
1314
Create an unique key or an unique constraint over all columns
1315
that should be in the result. In the temporary table, there are
1316
'param->hidden_field_count' extra columns, whose null bits are stored
1317
in the first 'hidden_null_pack_length' bytes of the row.
1322
Special mode for index creation in MyISAM used to support unique
1323
indexes on blobs with arbitrary length. Such indexes cannot be
1328
null_pack_length-=hidden_null_pack_length;
1329
keyinfo->key_parts= ((field_count-param->hidden_field_count)+
1330
(share->uniques ? test(null_pack_length) : 0));
1333
if (!(key_part_info= (KeyPartInfo*)
1334
table->alloc_root(keyinfo->key_parts * sizeof(KeyPartInfo))))
1336
memset(key_part_info, 0, keyinfo->key_parts * sizeof(KeyPartInfo));
1337
table->key_info=keyinfo;
1338
keyinfo->key_part=key_part_info;
1339
keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
1340
keyinfo->key_length=(uint16_t) reclength;
1341
keyinfo->name= (char*) "distinct_key";
1342
keyinfo->algorithm= HA_KEY_ALG_UNDEF;
1343
keyinfo->rec_per_key= 0;
1346
Create an extra field to hold NULL bits so that unique indexes on
1347
blobs can distinguish NULL from 0. This extra field is not needed
1348
when we do not use UNIQUE indexes for blobs.
1350
if (null_pack_length && share->uniques)
1352
key_part_info->null_bit= 0;
1353
key_part_info->offset=hidden_null_pack_length;
1354
key_part_info->length=null_pack_length;
1355
key_part_info->field= new Field_varstring(table->getInsertRecord(),
1356
(uint32_t) key_part_info->length,
1361
table->getMutableShare(),
1363
if (!key_part_info->field)
1365
key_part_info->field->init(table);
1366
key_part_info->key_type= 1; /* binary comparison */
1367
key_part_info->type= HA_KEYTYPE_BINARY;
1370
/* Create a distinct key over the columns we are going to return */
1371
for (i=param->hidden_field_count, reg_field=table->getFields() + i ;
1373
i++, reg_field++, key_part_info++)
1375
key_part_info->null_bit= 0;
1376
key_part_info->field= *reg_field;
1377
key_part_info->offset= (*reg_field)->offset(table->getInsertRecord());
1378
key_part_info->length= (uint16_t) (*reg_field)->pack_length();
1379
/* @todo The below method of computing the key format length of the
1380
key part is a copy/paste from optimizer/range.cc, and table.cc.
1381
This should be factored out, e.g. as a method of Field.
1382
In addition it is not clear if any of the Field::*_length
1383
methods is supposed to compute the same length. If so, it
1386
key_part_info->store_length= key_part_info->length;
1388
if ((*reg_field)->real_maybe_null())
1389
key_part_info->store_length+= HA_KEY_NULL_LENGTH;
1390
if ((*reg_field)->type() == DRIZZLE_TYPE_BLOB ||
1391
(*reg_field)->real_type() == DRIZZLE_TYPE_VARCHAR)
1392
key_part_info->store_length+= HA_KEY_BLOB_LENGTH;
1394
key_part_info->type= (uint8_t) (*reg_field)->key_type();
1395
key_part_info->key_type =
1396
((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
1397
(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
1398
(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
1403
if (session->is_fatal_error) // If end of memory
1405
share->db_record_offset= 1;
1406
if (share->db_type() == myisam_engine)
1408
if (table->create_myisam_tmp_table(param->keyinfo, param->start_recinfo,
1409
¶m->recinfo, select_options))
1412
assert(table->in_use);
1413
if (table->open_tmp_table())
1416
session->mem_root= mem_root_save;
1421
session->mem_root= mem_root_save;
1427
/****************************************************************************/
1430
Create a reduced Table object with properly set up Field list from a
1431
list of field definitions.
1433
The created table doesn't have a table Cursor associated with
1434
it, has no keys, no group/distinct, no copy_funcs array.
1435
The sole purpose of this Table object is to use the power of Field
1436
class to read/write data to/from table->getInsertRecord(). Then one can store
1437
the record in any container (RB tree, hash, etc).
1438
The table is created in Session mem_root, so are the table's fields.
1439
Consequently, if you don't BLOB fields, you don't need to free it.
1441
@param session connection handle
1442
@param field_list list of column definitions
1445
0 if out of memory, Table object in case of success
1448
Table *Session::create_virtual_tmp_table(List<CreateField> &field_list)
1450
uint32_t field_count= field_list.elements;
1451
uint32_t blob_count= 0;
1453
CreateField *cdef; /* column definition */
1454
uint32_t record_length= 0;
1455
uint32_t null_count= 0; /* number of columns which may be null */
1456
uint32_t null_pack_length; /* NULL representation array length */
1457
unsigned char *bitmaps;
1460
TableShareInstance *share= getTemporaryShare(message::Table::INTERNAL); // This will not go into the tableshare cache, so no key is used.
1462
if (! share->getMemRoot()->multi_alloc_root(0,
1463
&bitmaps, bitmap_buffer_size(field_count)*2,
1469
table= share->getTable();
1470
share->setFields(field_count + 1);
1471
table->setFields(share->getFields(true));
1472
field= share->getFields(true);
1473
share->blob_field.resize(field_count+1);
1474
share->fields= field_count;
1475
share->blob_ptr_size= portable_sizeof_char_ptr;
1476
table->setup_tmp_table_column_bitmaps(bitmaps);
1478
table->in_use= this; /* field->reset() may access table->in_use */
1480
/* Create all fields and calculate the total length of record */
1481
List_iterator_fast<CreateField> it(field_list);
1482
while ((cdef= it++))
1484
*field= share->make_field(NULL,
1486
(cdef->flags & NOT_NULL_FLAG) ? false : true,
1487
(unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),
1488
(cdef->flags & NOT_NULL_FLAG) ? 0 : 1,
1497
(*field)->init(table);
1498
record_length+= (*field)->pack_length();
1499
if (! ((*field)->flags & NOT_NULL_FLAG))
1502
if ((*field)->flags & BLOB_FLAG)
1503
share->blob_field[blob_count++]= (uint32_t) (field - table->getFields());
1507
*field= NULL; /* mark the end of the list */
1508
share->blob_field[blob_count]= 0; /* mark the end of the list */
1509
share->blob_fields= blob_count;
1511
null_pack_length= (null_count + 7)/8;
1512
share->setRecordLength(record_length + null_pack_length);
1513
share->rec_buff_length= ALIGN_SIZE(share->getRecordLength() + 1);
1514
table->record[0]= (unsigned char*)alloc(share->rec_buff_length);
1515
if (not table->getInsertRecord())
1518
if (null_pack_length)
1520
table->null_flags= (unsigned char*) table->getInsertRecord();
1521
share->null_fields= null_count;
1522
share->null_bytes= null_pack_length;
1525
/* Set up field pointers */
1526
unsigned char *null_pos= table->getInsertRecord();
1527
unsigned char *field_pos= null_pos + share->null_bytes;
1528
uint32_t null_bit= 1;
1530
for (field= table->getFields(); *field; ++field)
1532
Field *cur_field= *field;
1533
if ((cur_field->flags & NOT_NULL_FLAG))
1534
cur_field->move_field(field_pos);
1537
cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);
1539
if (null_bit == (1 << 8))
1547
field_pos+= cur_field->pack_length();
1554
for (field= table->getFields(); *field; ++field)
1556
delete *field; /* just invokes field destructor */
1561
bool Table::open_tmp_table()
1565
TableIdentifier identifier(s->getSchemaName(), s->getTableName(), s->getPath());
1566
if ((error=cursor->ha_open(identifier,
1569
HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
1571
print_error(error, MYF(0));
1575
(void) cursor->extra(HA_EXTRA_QUICK); /* Faster */
1581
Create MyISAM temporary table
3824
Check type of .frm if we are not going to parse it
1584
create_myisam_tmp_table()
1585
keyinfo Description of the index (there is always one index)
1586
start_recinfo MyISAM's column descriptions
1587
recinfo INOUT End of MyISAM's column descriptions
1591
Create a MyISAM temporary table according to passed description. The is
1592
assumed to have one unique index or constraint.
1594
The passed array or MI_COLUMNDEF structures must have this form:
1596
1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
1597
when there are many nullable columns)
1599
3. One free MI_COLUMNDEF element (*recinfo points here)
1601
This function may use the free element to create hash column for unique
1609
bool Table::create_myisam_tmp_table(KeyInfo *keyinfo,
1610
MI_COLUMNDEF *start_recinfo,
1611
MI_COLUMNDEF **recinfo,
3835
frm_type_enum mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt)
3838
uchar header[10]; /* This should be optimized */
1616
MI_UNIQUEDEF uniquedef;
1617
TableShare *share= s;
1619
if (share->sizeKeys())
1620
{ // Get keys for ni_create
1621
bool using_unique_constraint= false;
1622
HA_KEYSEG *seg= (HA_KEYSEG*) this->mem_root.alloc_root(sizeof(*seg) * keyinfo->key_parts);
1626
memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
1627
if (keyinfo->key_length >= cursor->getEngine()->max_key_length() ||
1628
keyinfo->key_parts > cursor->getEngine()->max_key_parts() ||
1631
/* Can't create a key; Make a unique constraint instead of a key */
1634
using_unique_constraint= true;
1635
memset(&uniquedef, 0, sizeof(uniquedef));
1636
uniquedef.keysegs=keyinfo->key_parts;
1638
uniquedef.null_are_equal=1;
1640
/* Create extra column for hash value */
1641
memset(*recinfo, 0, sizeof(**recinfo));
1642
(*recinfo)->type= FIELD_CHECK;
1643
(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
1645
share->setRecordLength(share->getRecordLength() + MI_UNIQUE_HASH_LENGTH);
1649
/* Create an unique key */
1650
memset(&keydef, 0, sizeof(keydef));
1651
keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
1652
keydef.keysegs= keyinfo->key_parts;
1655
for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)
1657
Field *key_field=keyinfo->key_part[i].field;
1659
seg->language= key_field->charset()->number;
1660
seg->length= keyinfo->key_part[i].length;
1661
seg->start= keyinfo->key_part[i].offset;
1662
if (key_field->flags & BLOB_FLAG)
1664
seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
1665
HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
1666
seg->bit_start= (uint8_t)(key_field->pack_length()
1667
- share->blob_ptr_size);
1668
seg->flag= HA_BLOB_PART;
1669
seg->length= 0; // Whole blob in unique constraint
1673
seg->type= keyinfo->key_part[i].type;
1675
if (!(key_field->flags & NOT_NULL_FLAG))
1677
seg->null_bit= key_field->null_bit;
1678
seg->null_pos= (uint32_t) (key_field->null_ptr - (unsigned char*) getInsertRecord());
1680
We are using a GROUP BY on something that contains NULL
1681
In this case we have to tell MyISAM that two NULL should
1682
on INSERT be regarded at the same value
1684
if (! using_unique_constraint)
1685
keydef.flag|= HA_NULL_ARE_EQUAL;
1689
MI_CREATE_INFO create_info;
1691
if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
1693
create_info.data_file_length= ~(uint64_t) 0;
1695
if ((error= mi_create(share->getTableName(), share->sizeKeys(), &keydef,
1696
(uint32_t) (*recinfo-start_recinfo),
1698
share->uniques, &uniquedef,
1700
HA_CREATE_TMP_TABLE)))
1702
print_error(error, MYF(0));
1707
in_use->status_var.created_tmp_disk_tables++;
1708
share->db_record_offset= 1;
1713
void Table::free_tmp_table(Session *session)
1715
memory::Root own_root= mem_root;
1716
const char *save_proc_info;
1718
save_proc_info= session->get_proc_info();
1719
session->set_proc_info("removing tmp table");
1721
// Release latches since this can take a long time
1722
plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
1728
cursor->closeMarkForDelete(s->getTableName());
1731
TableIdentifier identifier(s->getSchemaName(), s->getTableName(), s->getTableName());
1732
s->db_type()->doDropTable(*session, identifier);
1738
for (Field **ptr= field ; *ptr ; ptr++)
1744
own_root.free_root(MYF(0)); /* the table is allocated in its own root */
1745
session->set_proc_info(save_proc_info);
1748
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
1750
my_bitmap_map *old= bitmap->getBitmap();
1751
bitmap->setBitmap(s->all_set.getBitmap());
1755
void Table::restore_column_map(my_bitmap_map *old)
1757
read_set->setBitmap(old);
1760
uint32_t Table::find_shortest_key(const key_map *usable_keys)
1762
uint32_t min_length= UINT32_MAX;
1763
uint32_t best= MAX_KEY;
1764
if (usable_keys->any())
1766
for (uint32_t nr= 0; nr < s->sizeKeys() ; nr++)
1768
if (usable_keys->test(nr))
1770
if (key_info[nr].key_length < min_length)
1772
min_length= key_info[nr].key_length;
1781
/*****************************************************************************
1782
Remove duplicates from tmp table
1783
This should be recoded to add a unique index to the table and remove
1785
Table is a locked single thread table
1786
fields is the number of fields to check (from the end)
1787
*****************************************************************************/
1789
bool Table::compare_record(Field **ptr)
1791
for (; *ptr ; ptr++)
1793
if ((*ptr)->cmp_offset(s->rec_buff_length))
1799
/* Return false if row hasn't changed */
1801
bool Table::compare_record()
1803
if (s->blob_fields + s->varchar_fields == 0)
1804
return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) s->getRecordLength());
1806
/* Compare null bits */
1807
if (memcmp(null_flags, null_flags + s->rec_buff_length, s->null_bytes))
1808
return true; /* Diff in NULL value */
1810
/* Compare updated fields */
1811
for (Field **ptr= field ; *ptr ; ptr++)
1813
if (isWriteSet((*ptr)->field_index) &&
1814
(*ptr)->cmp_binary_offset(s->rec_buff_length))
1821
* Store a record from previous record into next
1824
void Table::storeRecord()
1826
memcpy(getUpdateRecord(), getInsertRecord(), (size_t) s->getRecordLength());
1830
* Store a record as an insert
1833
void Table::storeRecordAsInsert()
1835
assert(insert_values.size() >= s->getRecordLength());
1836
memcpy(&insert_values[0], getInsertRecord(), (size_t) s->getRecordLength());
1840
* Store a record with default values
1843
void Table::storeRecordAsDefault()
1845
memcpy(s->getDefaultValues(), getInsertRecord(), (size_t) s->getRecordLength());
1849
* Restore a record from previous record into next
1852
void Table::restoreRecord()
1854
memcpy(getInsertRecord(), getUpdateRecord(), (size_t) s->getRecordLength());
1858
* Restore a record with default values
1861
void Table::restoreRecordAsDefault()
1863
memcpy(getInsertRecord(), s->getDefaultValues(), (size_t) s->getRecordLength());
1870
void Table::emptyRecord()
1872
restoreRecordAsDefault();
1873
memset(null_flags, 255, s->null_bytes);
1888
next_number_field(NULL),
1889
found_next_number_field(NULL),
1890
timestamp_field(NULL),
1891
pos_in_table_list(NULL),
1900
derived_select_number(0),
1901
current_lock(F_UNLCK),
1911
open_placeholder(false),
1912
locked_by_name(false),
1914
auto_increment_field_not_null(false),
1915
alias_name_used(false),
1917
quick_condition_rows(0),
1918
timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
1920
is_placeholder_created(0)
1922
memset(&def_read_set, 0, sizeof(MyBitmap)); /**< Default read set of columns */
1923
memset(&def_write_set, 0, sizeof(MyBitmap)); /**< Default write set of columns */
1924
memset(&tmp_set, 0, sizeof(MyBitmap)); /* Not sure about this... */
1926
record[0]= (unsigned char *) 0;
1927
record[1]= (unsigned char *) 0;
1930
covering_keys.reset();
1934
keys_in_use_for_query.reset();
1935
keys_in_use_for_group_by.reset();
1936
keys_in_use_for_order_by.reset();
1938
memset(quick_rows, 0, sizeof(ha_rows) * MAX_KEY);
1939
memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
1941
memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
1942
memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
1945
/*****************************************************************************
1946
The different ways to read a record
1947
Returns -1 if row was not found, 0 if row was found and 1 on errors
1948
*****************************************************************************/
1950
/** Help function when we get some an error from the table Cursor. */
1952
int Table::report_error(int error)
1954
if (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND)
1956
status= STATUS_GARBAGE;
1957
return -1; // key not found; ok
1960
Locking reads can legally return also these errors, do not
1961
print them to the .err log
1963
if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)
1964
errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),
1965
error, s->getPath());
1966
print_error(error, MYF(0));
1972
void Table::setup_table_map(TableList *table_list, uint32_t table_number)
1977
status= STATUS_NO_RECORD;
1978
maybe_null= table_list->outer_join;
1979
TableList *embedding= table_list->getEmbedding();
1980
while (!maybe_null && embedding)
1982
maybe_null= embedding->outer_join;
1983
embedding= embedding->getEmbedding();
1985
tablenr= table_number;
1986
map= (table_map) 1 << table_number;
1987
force_index= table_list->force_index;
1988
covering_keys= s->keys_for_keyread;
1993
bool Table::fill_item_list(List<Item> *item_list) const
1996
All Item_field's created using a direct pointer to a field
1997
are fixed in Item_field constructor.
1999
for (Field **ptr= field; *ptr; ptr++)
2001
Item_field *item= new Item_field(*ptr);
2002
if (!item || item_list->push_back(item))
2008
} /* namespace drizzled */
3840
DBUG_ENTER("mysql_frm_type");
3842
*dbt= DB_TYPE_UNKNOWN;
3844
if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)
3845
DBUG_RETURN(FRMTYPE_ERROR);
3846
error= my_read(file, (uchar*) header, sizeof(header), MYF(MY_NABP));
3847
my_close(file, MYF(MY_WME));
3850
DBUG_RETURN(FRMTYPE_ERROR);
3853
This is just a check for DB_TYPE. We'll return default unknown type
3854
if the following test is true (arg #3). This should not have effect
3855
on return value from this function (default FRMTYPE_TABLE)
3857
if (header[0] != (uchar) 254 || header[1] != 1 ||
3858
(header[2] != FRM_VER && header[2] != FRM_VER+1 &&
3859
(header[2] < FRM_VER+3 || header[2] > FRM_VER+4)))
3860
DBUG_RETURN(FRMTYPE_TABLE);
3862
*dbt= (enum legacy_db_type) (uint) *(header + 3);
3863
DBUG_RETURN(FRMTYPE_TABLE); // Is probably a .frm table
3867
/*****************************************************************************
3868
** Instansiate templates
3869
*****************************************************************************/
3871
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
3872
template class List<String>;
3873
template class List_iterator<String>;
added
removed
sql/table.cc
