~drizzle-trunk/drizzle/development

static int open_binary_frm(THD *thd, TABLE_SHARE *share,

                           unsigned char *head, File file);

static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,

 

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

 

*/

 

TABLE_SHARE *alloc_table_share(TableList *table_list, char *key,

{

  MEM_ROOT mem_root;

  TABLE_SHARE *share;

  char *key_buff, *path_buff;

  char path[FN_REFLEN];

 

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

                                    table_list->db,

*/

 

void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,

                          const char *path)

{

 

   6    Unknown .frm version

*/

 

{

  int error, table_type;

  bool error_given;

      goto err_not_open;

 

    /* Try unencoded 5.0 name */

    strxnmov(path, sizeof(path)-1,

             mysql_data_home, "/", share->db.str, "/",

             share->table_name.str, reg_ext, NULL);

                           File file)

{

  int error, errarg= 0;

  bool use_hash;

  unsigned char forminfo[288];

  char *keynames, *names, *comment_pos;

    buff_end= buff + n_length;

    if (next_chunk + 2 < buff_end)

    {

      LEX_STRING name;

      name.str= (char*) next_chunk + 2;

      name.length= str_db_type_length;

      }

      else

      {

 

        field_extra_info= next_chunk + format_section_header_size + 1;

        next_chunk+= format_section_len;

         interval < share->intervals + interval_count;

         interval++)

    {

                                                        count)))

        goto err;

      for (count= 0; count < interval->count; count++)

 

  for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)

  {

    enum_field_types field_type;

    enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;

    const CHARSET_INFO *charset= NULL;

      pack_flag=    uint2korr(strpos+8);

      unireg_type=  (uint) strpos[10];

      interval_nr=  (uint) strpos[12];

      field_type=(enum_field_types) (uint) strpos[13];

 

      {

  /* Fix key->name and key_part->field */

  if (key_parts)

  {

                                       &share->keynames, 3) - 1);

    int64_t ha_option= handler_file->ha_table_flags();

    keyinfo= share->key_info;

    key_part= keyinfo->key_part;

 

    {

      keyinfo->name=(char*) share->keynames.type_names[key];

 

      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))

        primary_key=key;

        for (i=0 ; i < keyinfo->key_parts ;i++)

        {

          if (!fieldnr ||

              share->field[fieldnr-1]->null_ptr ||

              share->field[fieldnr-1]->key_length() !=

  if (new_field_pack_flag <= 1)

  {

    /* Old file format with default as not null */

    memset(share->default_values + (null_flags - (unsigned char*) record), 

          null_length, 255);

  }

  if (share->blob_fields)

  {

    Field **ptr;

 

    /* Store offsets to blob fields to find them fast */

    if (!(share->blob_field= save=

*/

 

int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,

                          Table *outparam, open_table_mode open_mode)

{

  int error;

  bool error_reported= false;

  unsigned char *record, *bitmaps;

  Field **field_ptr;

  {

    KEY *key_info, *key_info_end;

    KEY_PART_INFO *key_part;

    n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);

    if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))

      goto err;

 

void free_blobs(register Table *table)

{

  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();

       ptr != end ;

       ptr++)

 

ulong get_form_pos(File file, unsigned char *head, TYPELIB *save_names)

{

  unsigned char *pos,*buf;

  ulong ret_value=0;

 

ulong make_new_entry(File file, unsigned char *fileinfo, TYPELIB *formnames,

                     const char *newname)

{

  ulong endpos,newpos;

  unsigned char buff[IO_SIZE];

  unsigned char *pos;

        */

 

static void

                  char **names)

{

  char *type_name, *ptr;

    return 0;

  result->count=strings.elements;

  result->name="";

  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))

    return 0;

  result->type_lengths= (uint*) (result->type_names + result->count + 1);

  List_iterator<String> it(strings);

  String *tmp;

  {

    result->type_names[i]= tmp->ptr();

    result->type_lengths[i]= tmp->length();

   #  field number +1

*/

 

{

  Field **field;

 

  pos= 0;

  for (field= fields, i=1 ; *field ; i++,field++)

    May fail with some multibyte charsets though.

*/

 

{

  const char *end= pos+length;

  res->append('\'');

  for (; pos != end ; pos++)

  {

#if defined(USE_MB)

    if (use_mb(default_charset_info) &&

        (mblen= my_ismbchar(default_charset_info, pos, end)))

    {

        /* Create a .frm file */

 

File create_frm(THD *thd, const char *name, const char *db,

{

  register File file;

  ulong length;

  unsigned char fill[IO_SIZE];

  int create_flags= O_RDWR | O_TRUNC;

  ulong key_comment_total_bytes= 0;

 

  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)

    create_flags|= O_EXCL | O_NOFOLLOW;

 

  if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)

  {

    memset(fileinfo, 0, 64);

    /* header */

    fileinfo[0]=(unsigned char) 254;

 

void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)

{

 

  bitmap_init(&this->def_read_set, (my_bitmap_map*) bitmaps, field_count, false);

  bitmap_init(&this->tmp_set, (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count, false);

{

  char buff[MAX_FIELD_WIDTH], *to;

  String str(buff,sizeof(buff),&my_charset_bin);

 

  field->val_str(&str);

  if (!(length= str.length()))

{

  char buff[MAX_FIELD_WIDTH], *to;

  String str(buff,sizeof(buff),&my_charset_bin);

 

  field->val_str(&str);

  length= str.length();

    given a buffer with a key value, and a map of keyparts

    that are present in this value, returns the length of the value

*/

                       const unsigned char *buf __attribute__((unused)),

                       key_part_map keypart_map)

{

  KEY *key_info= table->s->key_info+key;

  KEY_PART_INFO *key_part= key_info->key_part;

  KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;

 

  while (key_part < end_key_part && keypart_map)

  {

bool check_db_name(LEX_STRING *org_name)

{

  char *name= org_name->str;

 

  if (!name_length || name_length > NAME_LEN || name[name_length - 1] == ' ')

    return 1;

*/

 

 

{

  if (!length || length > NAME_LEN || name[length - 1] == ' ')

    return 1;

*/

bool check_column_name(const char *name)

{

  bool last_char_is_space= true;

  

  while (*name)

*/

 

bool

                          const TABLE_FIELD_W_TYPE *table_def)

{

  bool error= false;

  bool fields_diff_count;

 

    or Table::restore_column_maps_after_mark_index()

*/

 

{

  MY_BITMAP *bitmap= &tmp_set;

 

  mark columns used by key, but don't reset other fields

*/

 

                                                   MY_BITMAP *bitmap)

{

  KEY_PART_INFO *key_part= key_info[index].key_part;

    /* iterate over the hints list */

    while ((hint= iter++))

    {

 

      /* process empty USE INDEX () */

      if (hint->type == INDEX_HINT_USE && !hint->key_name.str)

size_t Table::max_row_length(const unsigned char *data)

{

  size_t length= getRecordLength() + 2 * sizeFields();

 

  {

    Field_blob* const blob= (Field_blob*) field[*ptr];

    length+= blob->get_length((const unsigned char*)

 

Field *create_tmp_field_from_field(THD *thd, Field *org_field,

                                   const char *name, Table *table,

{

  Field *new_field;

 

static Field *create_tmp_field_from_item(THD *thd __attribute__((unused)),

                                         Item *item, Table *table,

                                         Item ***copy_func, bool modify_item,

{

  bool maybe_null= item->maybe_null;

  Field *new_field;

                        bool group, bool modify_item,

                        bool table_cant_handle_bit_fields __attribute__((unused)),

                        bool make_copy_field,

{

  Field *result;

  Item::Type orig_type= type;

  Table *table;

  TABLE_SHARE *share;

  uint  i,field_count,null_count,null_pack_length;

  ulong reclength, string_total_length;

  bool  using_unique_constraint= 0;

  bool  use_packed_rows= 0;

  unsigned char *pos, *group_buff, *bitmaps;

  unsigned char *null_flags;

  Field **reg_field, **from_field, **default_field;

  Copy_field *copy=0;

  KEY *keyinfo;

  KEY_PART_INFO *key_part_info;

  Item **copy_func;

  MI_COLUMNDEF *recinfo;

  bool force_copy_fields= param->force_copy_fields;

 

  status_var_increment(thd->status_var.created_tmp_tables);

 

  share->reclength= reclength;

  {

    share->rec_buff_length= alloc_length;

    if (!(table->record[0]= (unsigned char*)

                            alloc_root(&table->mem_root, alloc_length*3)))

  for (i=0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)

  {

    Field *field= *reg_field;

    memset(recinfo, 0, sizeof(*recinfo));

 

    if (!(field->flags & NOT_NULL_FLAG))

 

Table *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list)

{

  Field **field;

  Create_field *cdef;                           /* column definition */

  unsigned char *bitmaps;

  Table *table;

  TABLE_SHARE *share;

    /* Set up field pointers */

    unsigned char *null_pos= table->record[0];

    unsigned char *field_pos= null_pos + share->null_bytes;

 

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

    {

      keydef.keysegs=  keyinfo->key_parts;

      keydef.seg= seg;

    }

    {

      Field *field=keyinfo->key_part[i].field;

      seg->flag=     0;

  read_set->bitmap= old;

}

 

{

  uint32_t min_length= UINT32_MAX;

  uint32_t best= MAX_KEY;

  if (!usable_keys->is_clear_all())

  {

    {

      if (usable_keys->is_set(nr))

      {