← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

Fixed bashism.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.cc
75
75
}
76
76
 
77
77
/*
78
 
  Translate a cursor name to a table name (WL #1324).
 
78
  Translate a file name to a table name (WL #1324).
79
79
 
80
80
  SYNOPSIS
81
81
    filename_to_tablename()
82
 
      from                      The cursor name
 
82
      from                      The file name
83
83
      to                OUT     The table name
84
84
      to_length                 The size of the table name buffer.
85
85
 
125
125
 
126
126
 
127
127
/*
128
 
  Translate a table name to a cursor name (WL #1324).
 
128
  Translate a table name to a file name (WL #1324).
129
129
 
130
130
  SYNOPSIS
131
131
    tablename_to_filename()
132
132
      from                      The table name
133
 
      to                OUT     The cursor name
134
 
      to_length                 The size of the cursor name buffer.
 
133
      to                OUT     The file name
 
134
      to_length                 The size of the file name buffer.
135
135
 
136
136
  RETURN
137
137
    true if errors happen. false on success.
180
180
 
181
181
 
182
182
/*
183
 
  Creates path to a cursor: drizzle_data_dir/db/table.ext
 
183
  Creates path to a file: drizzle_data_dir/db/table.ext
184
184
 
185
185
  SYNOPSIS
186
186
   build_table_filename()
196
196
  NOTES
197
197
 
198
198
    Uses database and table name, and extension to create
199
 
    a cursor name in drizzle_data_dir. Database and table
 
199
    a file name in drizzle_data_dir. Database and table
200
200
    names are converted from system_charset_info into "fscs".
201
201
    Unless flags indicate a temporary table name.
202
202
    'db' is always converted.
269
269
 
270
270
 
271
271
/*
272
 
  Creates path to a cursor: drizzle_tmpdir/#sql1234_12_1.ext
 
272
  Creates path to a file: drizzle_tmpdir/#sql1234_12_1.ext
273
273
 
274
274
  SYNOPSIS
275
275
   build_tmptable_filename()
280
280
  NOTES
281
281
 
282
282
    Uses current_pid, thread_id, and tmp_table counter to create
283
 
    a cursor name in drizzle_tmpdir.
 
283
    a file name in drizzle_tmpdir.
284
284
 
285
285
  RETURN
286
286
    path length on success, 0 on failure
322
322
 
323
323
  DESCRIPTION
324
324
    Write the binlog if open, routine used in multiple places in this
325
 
    cursor
 
325
    file
326
326
*/
327
327
 
328
328
void write_bin_log(Session *session,
458
458
 
459
459
  /*
460
460
    If we have the table in the definition cache, we don't have to check the
461
 
    .frm cursor to find if the table is a normal table (not view) and what
 
461
    .frm file to find if the table is a normal table (not view) and what
462
462
    engine to use.
463
463
  */
464
464
 
518
518
        error= -1;
519
519
        goto err_with_placeholders;
520
520
      }
521
 
      /* remove .frm cursor and engine files */
 
521
      /* remove .frm file and engine files */
522
522
      path_length= build_table_filename(path, sizeof(path), db, table->table_name, table->internal_tmp_table);
523
523
    }
524
524
 
802
802
  case DRIZZLE_TYPE_NULL:
803
803
    sql_field->pack_flag=f_settype((uint32_t) sql_field->sql_type);
804
804
    break;
805
 
  case DRIZZLE_TYPE_DECIMAL:
 
805
  case DRIZZLE_TYPE_NEWDECIMAL:
806
806
    sql_field->pack_flag= 0;
807
807
    break;
808
808
  case DRIZZLE_TYPE_TIMESTAMP:
836
836
                               AlterInfo *alter_info,
837
837
                               bool tmp_table,
838
838
                               uint32_t *db_options,
839
 
                               Cursor *cursor,
 
839
                               Cursor *file,
840
840
                               KEY **key_info_buffer,
841
841
                               uint32_t *key_count,
842
842
                               int select_field_count)
856
856
 
857
857
  select_field_pos= alter_info->create_list.elements - select_field_count;
858
858
  null_fields=blob_columns=0;
859
 
  max_key_length= cursor->max_key_length();
 
859
  max_key_length= file->max_key_length();
860
860
 
861
861
  for (field_no=0; (sql_field=it++) ; field_no++)
862
862
  {
1080
1080
 
1081
1081
    if (prepare_create_field(sql_field, &blob_columns,
1082
1082
                             &timestamps, &timestamps_with_niladic,
1083
 
                             cursor->ha_table_flags()))
 
1083
                             file->ha_table_flags()))
1084
1084
      return(true);
1085
1085
    sql_field->offset= record_offset;
1086
1086
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1098
1098
    return(true);
1099
1099
  }
1100
1100
  if (auto_increment &&
1101
 
      (cursor->ha_table_flags() & HA_NO_AUTO_INCREMENT))
 
1101
      (file->ha_table_flags() & HA_NO_AUTO_INCREMENT))
1102
1102
  {
1103
1103
    my_message(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
1104
1104
               ER(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT), MYF(0));
1105
1105
    return(true);
1106
1106
  }
1107
1107
 
1108
 
  if (blob_columns && (cursor->ha_table_flags() & HA_NO_BLOBS))
 
1108
  if (blob_columns && (file->ha_table_flags() & HA_NO_BLOBS))
1109
1109
  {
1110
1110
    my_message(ER_TABLE_CANT_HANDLE_BLOB, ER(ER_TABLE_CANT_HANDLE_BLOB),
1111
1111
               MYF(0));
1146
1146
      continue;
1147
1147
    }
1148
1148
    (*key_count)++;
1149
 
    tmp=cursor->max_key_parts();
 
1149
    tmp=file->max_key_parts();
1150
1150
    if (key->columns.elements > tmp)
1151
1151
    {
1152
1152
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
1195
1195
      return(true);
1196
1196
    }
1197
1197
  }
1198
 
  tmp=cursor->max_keys();
 
1198
  tmp=file->max_keys();
1199
1199
  if (*key_count > tmp)
1200
1200
  {
1201
1201
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
1311
1311
 
1312
1312
        if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
1313
1313
        {
1314
 
          if (! (cursor->ha_table_flags() & HA_CAN_INDEX_BLOBS))
 
1314
          if (! (file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
1315
1315
          {
1316
1316
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
1317
1317
            return true;
1333
1333
          else
1334
1334
          {
1335
1335
            key_info->flags|= HA_NULL_PART_KEY;
1336
 
            if (! (cursor->ha_table_flags() & HA_NULL_IN_KEY))
 
1336
            if (! (file->ha_table_flags() & HA_NULL_IN_KEY))
1337
1337
            {
1338
1338
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
1339
1339
              return true;
1342
1342
        }
1343
1343
        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1344
1344
        {
1345
 
          if (column_nr == 0 || (cursor->ha_table_flags() & HA_AUTO_PART_KEY))
 
1345
          if (column_nr == 0 || (file->ha_table_flags() & HA_AUTO_PART_KEY))
1346
1346
            auto_increment--;                   // Field is used
1347
1347
        }
1348
1348
      }
1357
1357
        if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
1358
1358
        {
1359
1359
          if ((length=column->length) > max_key_length ||
1360
 
              length > cursor->max_key_part_length())
 
1360
              length > file->max_key_part_length())
1361
1361
          {
1362
 
            length= min(max_key_length, cursor->max_key_part_length());
 
1362
            length= min(max_key_length, file->max_key_part_length());
1363
1363
            if (key->type == Key::MULTIPLE)
1364
1364
            {
1365
1365
              /* not a critical problem */
1384
1384
          my_message(ER_WRONG_SUB_KEY, ER(ER_WRONG_SUB_KEY), MYF(0));
1385
1385
          return(true);
1386
1386
        }
1387
 
        else if (!(cursor->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS))
 
1387
        else if (!(file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS))
1388
1388
          length=column->length;
1389
1389
      }
1390
1390
      else if (length == 0)
1392
1392
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.str);
1393
1393
          return(true);
1394
1394
      }
1395
 
      if (length > cursor->max_key_part_length())
 
1395
      if (length > file->max_key_part_length())
1396
1396
      {
1397
 
        length= cursor->max_key_part_length();
 
1397
        length= file->max_key_part_length();
1398
1398
        if (key->type == Key::MULTIPLE)
1399
1399
        {
1400
1400
          /* not a critical problem */
1474
1474
    key_info++;
1475
1475
  }
1476
1476
  if (!unique_key && !primary_key &&
1477
 
      (cursor->ha_table_flags() & HA_REQUIRE_PRIMARY_KEY))
 
1477
      (file->ha_table_flags() & HA_REQUIRE_PRIMARY_KEY))
1478
1478
  {
1479
1479
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
1480
1480
    return(true);
1602
1602
  uint32_t          path_length;
1603
1603
  uint          db_options, key_count;
1604
1604
  KEY           *key_info_buffer;
1605
 
  Cursor        *cursor;
 
1605
  Cursor        *file;
1606
1606
  bool          error= true;
1607
 
  TableShare share;
1608
 
 
1609
1607
  /* Check for duplicate fields and check type of table to create */
1610
1608
  if (!alter_info->create_list.elements)
1611
1609
  {
1619
1617
  db_options= create_info->table_options;
1620
1618
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
1621
1619
    db_options|=HA_OPTION_PACK_RECORD;
1622
 
  if (!(cursor= create_info->db_type->getCursor(share, session->mem_root)))
 
1620
  if (!(file= create_info->db_type->getCursor((TableShare*) 0, session->mem_root)))
1623
1621
  {
1624
1622
    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Cursor));
1625
1623
    return true;
1629
1627
 
1630
1628
  if (mysql_prepare_create_table(session, create_info, table_proto, alter_info,
1631
1629
                                 internal_tmp_table,
1632
 
                                 &db_options, cursor,
 
1630
                                 &db_options, file,
1633
1631
                                 &key_info_buffer, &key_count,
1634
1632
                                 select_field_count))
1635
1633
    goto err;
1691
1689
      We don't assert here, but check the result, because the table could be
1692
1690
      in the table definition cache and in the same time the .frm could be
1693
1691
      missing from the disk, in case of manual intervention which deletes
1694
 
      the .frm cursor. The user has to use FLUSH TABLES; to clear the cache.
 
1692
      the .frm file. The user has to use FLUSH TABLES; to clear the cache.
1695
1693
      Then she could create the table. This case is pretty obscure and
1696
1694
      therefore we don't introduce a new error message only for it.
1697
1695
    */
1709
1707
    unless user specified CREATE TABLE IF EXISTS
1710
1708
    The LOCK_open mutex has been locked to make sure no
1711
1709
    one else is attempting to discover the table. Since
1712
 
    it's not on disk as a frm cursor, no one could be using it!
 
1710
    it's not on disk as a frm file, no one could be using it!
1713
1711
  */
1714
1712
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1715
1713
  {
1760
1758
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1761
1759
  {
1762
1760
    /* Open table and put in temporary table list */
1763
 
    if (!(session->open_temporary_table(path, db, table_name, 1)))
 
1761
    if (!(session->open_temporary_table(path, db, table_name, 1, OTM_OPEN)))
1764
1762
    {
1765
1763
      (void) session->rm_temporary_table(create_info->db_type, path);
1766
1764
      goto unlock_and_end;
1783
1781
 
1784
1782
err:
1785
1783
  session->set_proc_info("After create");
1786
 
  delete cursor;
 
1784
  delete file;
1787
1785
  return(error);
1788
1786
}
1789
1787
 
1904
1902
      flags                     flags for build_table_filename().
1905
1903
                                FN_FROM_IS_TMP old_name is temporary.
1906
1904
                                FN_TO_IS_TMP   new_name is temporary.
1907
 
                                NO_FRM_RENAME  Don't rename the FRM cursor
 
1905
                                NO_FRM_RENAME  Don't rename the FRM file
1908
1906
                                but only the table in the storage engine.
1909
1907
 
1910
1908
  RETURN
1973
1971
 
1974
1972
  safe_mutex_assert_owner(&LOCK_open);
1975
1973
 
1976
 
  table->cursor->extra(function);
 
1974
  table->file->extra(function);
1977
1975
  /* Mark all tables that are in use as 'old' */
1978
1976
  mysql_lock_abort(session, table);     /* end threads waiting on lock */
1979
1977
 
2172
2170
        goto err;
2173
2171
    }
2174
2172
 
2175
 
    result_code = (table->table->cursor->*operator_func)(session, check_opt);
 
2173
    result_code = (table->table->file->*operator_func)(session, check_opt);
2176
2174
 
2177
2175
send_result:
2178
2176
 
2267
2265
      if (!result_code) // recreation went ok
2268
2266
      {
2269
2267
        if ((table->table= session->openTableLock(table, lock_type)) &&
2270
 
            ((result_code= table->table->cursor->ha_analyze(session, check_opt)) > 0))
 
2268
            ((result_code= table->table->file->ha_analyze(session, check_opt)) > 0))
2271
2269
          result_code= 0; // analyze went ok
2272
2270
      }
2273
2271
      if (result_code) // either mysql_recreate_table or analyze failed
2323
2321
      else if (open_for_modify)
2324
2322
      {
2325
2323
        if (table->table->s->tmp_table)
2326
 
          table->table->cursor->info(HA_STATUS_CONST);
 
2324
          table->table->file->info(HA_STATUS_CONST);
2327
2325
        else
2328
2326
        {
2329
2327
          pthread_mutex_lock(&LOCK_open);
2392
2390
  /*
2393
2391
    By opening source table we guarantee that it exists and no concurrent
2394
2392
    DDL operation will mess with it. Later we also take an exclusive
2395
 
    name-lock on target table name, which makes copying of .frm cursor,
 
2393
    name-lock on target table name, which makes copying of .frm file,
2396
2394
    call to plugin::StorageEngine::createTable() and binlogging atomic
2397
2395
    against concurrent DML and DDL operations on target table.
2398
2396
    Thus by holding both these "locks" we ensure that our statement is
2511
2509
 
2512
2510
  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
2513
2511
  {
2514
 
    if (err || !session->open_temporary_table(dst_path, db, table_name, true))
 
2512
    if (err || !session->open_temporary_table(dst_path, db, table_name, 1, OTM_OPEN))
2515
2513
    {
2516
2514
      (void) session->rm_temporary_table(create_info->db_type, dst_path);
2517
2515
      goto err;
2696
2694
    }
2697
2695
    else
2698
2696
    {
2699
 
      if (t->cursor->ha_table_flags() & HA_HAS_CHECKSUM &&
 
2697
      if (t->file->ha_table_flags() & HA_HAS_CHECKSUM &&
2700
2698
          !(check_opt->flags & T_EXTEND))
2701
 
        session->client->store((uint64_t)t->cursor->checksum());
2702
 
      else if (!(t->cursor->ha_table_flags() & HA_HAS_CHECKSUM) &&
 
2699
        session->client->store((uint64_t)t->file->checksum());
 
2700
      else if (!(t->file->ha_table_flags() & HA_HAS_CHECKSUM) &&
2703
2701
               (check_opt->flags & T_QUICK))
2704
2702
        session->client->store();
2705
2703
      else
2710
2708
 
2711
2709
        t->use_all_columns();
2712
2710
 
2713
 
        if (t->cursor->ha_rnd_init(1))
 
2711
        if (t->file->ha_rnd_init(1))
2714
2712
          session->client->store();
2715
2713
        else
2716
2714
        {
2717
2715
          for (;;)
2718
2716
          {
2719
2717
            ha_checksum row_crc= 0;
2720
 
            int error= t->cursor->rnd_next(t->record[0]);
 
2718
            int error= t->file->rnd_next(t->record[0]);
2721
2719
            if (unlikely(error))
2722
2720
            {
2723
2721
              if (error == HA_ERR_RECORD_DELETED)
2752
2750
            crc+= row_crc;
2753
2751
          }
2754
2752
          session->client->store((uint64_t)crc);
2755
 
          t->cursor->ha_rnd_end();
 
2753
          t->file->ha_rnd_end();
2756
2754
        }
2757
2755
      }
2758
2756
      session->clear_error();