← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

merge for-brian branch (removal frm work)
merge getopt fixes, add fixes for SPARC alignment

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
91
91
char *fn_rext(char *name)
92
92
{
93
93
  char *res= strrchr(name, '.');
94
 
  if (res && !strcmp(res, reg_ext))
 
94
  if (res && !strcmp(res, ".dfe"))
95
95
    return res;
96
96
  return name + strlen(name);
97
97
}
364
364
    default_item= new Item_float(default_value.c_str(), default_value.length());
365
365
    break;
366
366
  case DRIZZLE_TYPE_NULL:
367
 
    return new Item_null();
 
367
    assert(false);
368
368
  case DRIZZLE_TYPE_TIMESTAMP:
369
369
  case DRIZZLE_TYPE_DATETIME:
370
370
  case DRIZZLE_TYPE_DATE:
405
405
int parse_table_proto(Session *session, drizzle::Table &table, TABLE_SHARE *share)
406
406
{
407
407
  int error= 0;
 
408
  handler *handler_file= NULL;
408
409
 
409
410
  {
410
411
    LEX_STRING engine_name= { (char*)table.engine().name().c_str(),
1103
1104
 
1104
1105
    if(default_value)
1105
1106
    {
 
1107
      enum_check_fields old_count_cuted_fields= session->count_cuted_fields;
 
1108
      session->count_cuted_fields= CHECK_FIELD_WARN;
1106
1109
      int res= default_value->save_in_field(f, 1);
1107
 
      (void)res; // TODO error handle;
 
1110
      session->count_cuted_fields= old_count_cuted_fields;
 
1111
      if (res != 0 && res != 3)
 
1112
      {
 
1113
        my_error(ER_INVALID_DEFAULT, MYF(0), f->field_name);
 
1114
        error= 1;
 
1115
        goto err;
 
1116
      }
1108
1117
    }
1109
1118
    else if(f->real_type() == DRIZZLE_TYPE_ENUM &&
1110
1119
            (f->flags & NOT_NULL_FLAG))
1177
1186
  free(field_offsets);
1178
1187
  free(field_pack_length);
1179
1188
 
1180
 
  handler *handler_file;
1181
 
 
1182
1189
  if(!(handler_file= get_new_handler(share, session->mem_root,
1183
1190
                                     share->db_type())))
1184
1191
    abort(); // FIXME
1375
1382
  bitmap_init(&share->all_set, bitmaps, share->fields, false);
1376
1383
  bitmap_set_all(&share->all_set);
1377
1384
 
1378
 
  delete handler_file;
 
1385
  if(handler_file)
 
1386
    delete handler_file;
1379
1387
  return (0);
1380
1388
 
1381
1389
err:
1383
1391
  share->open_errno= my_errno;
1384
1392
  share->errarg= 0;
1385
1393
  hash_free(&share->name_hash);
1386
 
  delete handler_file;
 
1394
  if(handler_file)
 
1395
    delete handler_file;
1387
1396
  open_table_error(share, error, share->open_errno, 0);
1388
1397
  return error;
1389
1398
}
1417
1426
{
1418
1427
  int error;
1419
1428
  bool error_given;
1420
 
  string        path("");
 
1429
  string proto_path("");
1421
1430
 
1422
1431
  error= 1;
1423
1432
  error_given= 0;
1424
1433
 
1425
 
  path.reserve(FN_REFLEN);
1426
 
  path.append(share->normalized_path.str);
1427
 
  string proto_path= path;
1428
 
 
1429
 
  path.append(reg_ext);
 
1434
  proto_path.reserve(FN_REFLEN);
 
1435
  proto_path.append(share->normalized_path.str);
1430
1436
 
1431
1437
  proto_path.append(".dfe");
1432
1438
 
1449
1455
    goto err_not_open;
1450
1456
  }
1451
1457
 
1452
 
  parse_table_proto(session, table, share);
 
1458
  error= parse_table_proto(session, table, share);
1453
1459
 
1454
1460
  share->table_category= get_table_category(& share->db, & share->table_name);
1455
1461
 
2252
2258
      my_error(ER_NO_SUCH_TABLE, MYF(0), share->db.str, share->table_name.str);
2253
2259
    else
2254
2260
    {
2255
 
      sprintf(buff,"%s%s",share->normalized_path.str,reg_ext);
 
2261
      sprintf(buff,"%s",share->normalized_path.str);
2256
2262
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
2257
2263
               errortype, buff, db_errno);
2258
2264
    }
2293
2299
    break;
2294
2300
  }
2295
2301
  case 6:
2296
 
    sprintf(buff,"%s%s",share->normalized_path.str,reg_ext);
 
2302
    sprintf(buff,"%s",share->normalized_path.str);
2297
2303
    my_printf_error(ER_NOT_FORM_FILE,
2298
2304
                    _("Table '%-.64s' was created with a different version "
2299
2305
                    "of Drizzle and cannot be read"),
2303
2309
    break;
2304
2310
  default:                              /* Better wrong error than none */
2305
2311
  case 4:
2306
 
    sprintf(buff,"%s%s",share->normalized_path.str,reg_ext);
 
2312
    sprintf(buff,"%s",share->normalized_path.str);
2307
2313
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
2308
2314
    break;
2309
2315
  }
2460
2466
}
2461
2467
 
2462
2468
 
2463
 
        /* Create a .frm file */
2464
 
 
2465
 
File create_frm(Session *session, const char *name, const char *db,
2466
 
                const char *table, uint32_t reclength, unsigned char *fileinfo,
2467
 
                HA_CREATE_INFO *create_info, uint32_t keys, KEY *key_info)
2468
 
{
2469
 
  register File file;
2470
 
  ulong length;
2471
 
  unsigned char fill[IO_SIZE];
2472
 
  int create_flags= O_RDWR | O_TRUNC;
2473
 
  ulong key_comment_total_bytes= 0;
2474
 
  uint32_t i;
2475
 
 
2476
 
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
2477
 
    create_flags|= O_EXCL;
2478
 
 
2479
 
  /* Fix this when we have new .frm files;  Current limit is 4G rows (QQ) */
2480
 
  if (create_info->max_rows > UINT32_MAX)
2481
 
    create_info->max_rows= UINT32_MAX;
2482
 
  if (create_info->min_rows > UINT32_MAX)
2483
 
    create_info->min_rows= UINT32_MAX;
2484
 
 
2485
 
  if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)
2486
 
  {
2487
 
    uint32_t key_length, tmp_key_length;
2488
 
    uint32_t tmp;
2489
 
    memset(fileinfo, 0, 64);
2490
 
    /* header */
2491
 
    fileinfo[0]=(unsigned char) 254;
2492
 
    fileinfo[1]= 1;
2493
 
    fileinfo[2]= FRM_VER+3+ test(create_info->varchar);
2494
 
 
2495
 
    fileinfo[3]= (unsigned char) ha_legacy_type(
2496
 
          ha_checktype(session,ha_legacy_type(create_info->db_type),0,0));
2497
 
    fileinfo[4]=1;
2498
 
    int2store(fileinfo+6,IO_SIZE);              /* Next block starts here */
2499
 
    for (i= 0; i < keys; i++)
2500
 
    {
2501
 
      assert(test(key_info[i].flags & HA_USES_COMMENT) ==
2502
 
                 (key_info[i].comment.length > 0));
2503
 
      if (key_info[i].flags & HA_USES_COMMENT)
2504
 
        key_comment_total_bytes += 2 + key_info[i].comment.length;
2505
 
    }
2506
 
    /*
2507
 
      Keep in sync with pack_keys() in unireg.cc
2508
 
      For each key:
2509
 
      8 bytes for the key header
2510
 
      9 bytes for each key-part (MAX_REF_PARTS)
2511
 
      NAME_LEN bytes for the name
2512
 
      1 byte for the NAMES_SEP_CHAR (before the name)
2513
 
      For all keys:
2514
 
      6 bytes for the header
2515
 
      1 byte for the NAMES_SEP_CHAR (after the last name)
2516
 
      9 extra bytes (padding for safety? alignment?)
2517
 
      comments
2518
 
    */
2519
 
    key_length= (keys * (8 + MAX_REF_PARTS * 9 + NAME_LEN + 1) + 16 +
2520
 
                 key_comment_total_bytes);
2521
 
    length= next_io_size((ulong) (IO_SIZE+key_length+reclength+
2522
 
                                  create_info->extra_size));
2523
 
    int4store(fileinfo+10,length);
2524
 
    tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;
2525
 
    int2store(fileinfo+14,tmp_key_length);
2526
 
    int2store(fileinfo+16,reclength);
2527
 
    int4store(fileinfo+18,create_info->max_rows);
2528
 
    int4store(fileinfo+22,create_info->min_rows);
2529
 
    /* fileinfo[26] is set in mysql_create_frm() */
2530
 
    fileinfo[27]=2;                             // Use long pack-fields
2531
 
    /* fileinfo[28 & 29] is set to key_info_length in mysql_create_frm() */
2532
 
    create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers
2533
 
    int2store(fileinfo+30,create_info->table_options);
2534
 
    fileinfo[32]=0;                             // No filename anymore
2535
 
    fileinfo[33]=5;                             // Mark for 5.0 frm file
2536
 
    int4store(fileinfo+34,create_info->avg_row_length);
2537
 
    fileinfo[38]= (create_info->default_table_charset ?
2538
 
                   create_info->default_table_charset->number : 0);
2539
 
    fileinfo[39]= (unsigned char) create_info->page_checksum;
2540
 
    fileinfo[40]= (unsigned char) create_info->row_type;
2541
 
    /* Next few bytes were for RAID support */
2542
 
    fileinfo[41]= 0;
2543
 
    fileinfo[42]= 0;
2544
 
    int4store(fileinfo+43,create_info->block_size);
2545
 
 
2546
 
    fileinfo[44]= 0;
2547
 
    fileinfo[45]= 0;
2548
 
    fileinfo[46]= 0;
2549
 
    int4store(fileinfo+47, key_length);
2550
 
    tmp= DRIZZLE_VERSION_ID;          // Store to avoid warning from int4store
2551
 
    int4store(fileinfo+51, tmp);
2552
 
    int4store(fileinfo+55, create_info->extra_size);
2553
 
    /*
2554
 
      59-60 is reserved for extra_rec_buf_length (always 0),
2555
 
      61 for default_part_db_type
2556
 
    */
2557
 
    int2store(fileinfo+62, create_info->key_block_size);
2558
 
    memset(fill, 0, IO_SIZE);
2559
 
    for (; length > IO_SIZE ; length-= IO_SIZE)
2560
 
    {
2561
 
      if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
2562
 
      {
2563
 
        my_close(file,MYF(0));
2564
 
        my_delete(name,MYF(0));
2565
 
        return(-1);
2566
 
      }
2567
 
    }
2568
 
  }
2569
 
  else
2570
 
  {
2571
 
    if (my_errno == ENOENT)
2572
 
      my_error(ER_BAD_DB_ERROR,MYF(0),db);
2573
 
    else
2574
 
      my_error(ER_CANT_CREATE_TABLE,MYF(0),table,my_errno);
2575
 
  }
2576
 
  return (file);
2577
 
} /* create_frm */
2578
 
 
2579
2469
/*
2580
2470
  Set up column usage bitmaps for a temporary table
2581
2471