← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
1024
1024
    uint32_t primary_key= (uint32_t) (find_type((char*) "PRIMARY",
1025
1025
                                                &share->keynames, 3) - 1); /* @TODO Huh? */
1026
1026
 
1027
 
    int64_t ha_option= handler_file->ha_table_flags();
1028
 
 
1029
1027
    keyinfo= share->key_info;
1030
1028
    key_part= keyinfo->key_part;
1031
1029
 
1112
1110
            If this field is part of the primary key and all keys contains
1113
1111
            the primary key, then we can use any key to find this column
1114
1112
          */
1115
 
          if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
 
1113
          if (share->storage_engine->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX))
1116
1114
          {
1117
1115
            field->part_of_key= share->keys_in_use;
1118
1116
            if (field->part_of_sortkey.test(key))
1134
1132
        an unique index on the underlying MyISAM table. (Bug #10400)
1135
1133
      */
1136
1134
      if ((keyinfo->flags & HA_NOSAME) ||
1137
 
          (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
 
1135
          (handler_file->getEngine()->check_flag(HTON_BIT_ANY_INDEX_MAY_BE_UNIQUE)))
1138
1136
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
1139
1137
    }
1140
1138
    if (primary_key < MAX_KEY &&
1495
1493
                          HA_OPEN_ABORT_IF_LOCKED :
1496
1494
                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
1497
1495
    {
1498
 
      /* Set a flag if the table is crashed and it can be auto. repaired */
1499
 
      share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
1500
 
                       outparam->cursor->auto_repair() &&
1501
 
                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
1502
 
 
1503
1496
      switch (ha_err)
1504
1497
      {
1505
1498
        case HA_ERR_NO_SUCH_TABLE:
1971
1964
void Table::prepare_for_position()
1972
1965
{
1973
1966
 
1974
 
  if ((cursor->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
 
1967
  if ((cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&
1975
1968
      s->primary_key < MAX_KEY)
1976
1969
  {
1977
1970
    mark_columns_used_by_index_no_reset(s->primary_key);
2102
2095
    mark_columns_used_by_index_no_reset(s->primary_key);
2103
2096
 
2104
2097
  /* If we the engine wants all predicates we mark all keys */
2105
 
  if (cursor->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
 
2098
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
2106
2099
  {
2107
2100
    Field **reg_field;
2108
2101
    for (reg_field= field ; *reg_field ; reg_field++)
2126
2119
    if neeed, either the primary key column or all columns to be read.
2127
2120
    (see mark_columns_needed_for_delete() for details)
2128
2121
 
2129
 
    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
 
2122
    If the engine has HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
2130
2123
    mark all USED key columns as 'to-be-read'. This allows the engine to
2131
2124
    loop over the given record to find all changed keys and doesn't have to
2132
2125
    retrieve the row again.
2149
2142
  else
2150
2143
    mark_columns_used_by_index_no_reset(s->primary_key);
2151
2144
 
2152
 
  if (cursor->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
 
2145
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
2153
2146
  {
2154
2147
    /* Mark all used key columns for read */
2155
2148
    Field **reg_field;
2265
2258
 
2266
2259
 
2267
2260
/**
2268
 
  Create field for information schema table.
2269
 
 
2270
 
  @param session                Thread Cursor
2271
 
  @param table          Temporary table
2272
 
  @param item           Item to create a field for
2273
 
 
2274
 
  @retval
2275
 
    0                   on error
2276
 
  @retval
2277
 
    new_created field
2278
 
*/
2279
 
 
2280
 
static Field *create_tmp_field_for_schema(Item *item, Table *table)
2281
 
{
2282
 
  if (item->field_type() == DRIZZLE_TYPE_VARCHAR)
2283
 
  {
2284
 
    Field *field;
2285
 
    if (item->max_length > MAX_FIELD_VARCHARLENGTH)
2286
 
      field= new Field_blob(item->max_length, item->maybe_null,
2287
 
                            item->name, item->collation.collation);
2288
 
    else
2289
 
      field= new Field_varstring(item->max_length, item->maybe_null,
2290
 
                                 item->name,
2291
 
                                 table->s, item->collation.collation);
2292
 
    if (field)
2293
 
      field->init(table);
2294
 
    return field;
2295
 
  }
2296
 
  return item->tmp_table_field_from_field_type(table, 0);
2297
 
}
2298
 
 
2299
 
 
2300
 
/**
2301
2261
  Create a temp table according to a field list.
2302
2262
 
2303
2263
  Given field pointers are changed to point at tmp_table for
2362
2322
  status_var_increment(session->status_var.created_tmp_tables);
2363
2323
 
2364
2324
  /* if we run out of slots or we are not using tempool */
2365
 
  sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
2366
 
          session->thread_id, session->tmp_table++);
 
2325
  snprintf(path, FN_REFLEN, "%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
 
2326
           session->thread_id, session->tmp_table++);
2367
2327
 
2368
2328
  /*
2369
2329
    No need to change table name to lower case as we are only creating
2561
2521
        We here distinguish between UNION and multi-table-updates by the fact
2562
2522
        that in the later case group is set to the row pointer.
2563
2523
      */
2564
 
      Field *new_field= (param->schema_table) ?
2565
 
        create_tmp_field_for_schema(item, table) :
 
2524
      Field *new_field= 
2566
2525
        create_tmp_field(session, table, item, type, &copy_func,
2567
2526
                         tmp_from_field, &default_field[fieldnr],
2568
2527
                         group != 0,
2635
2594
    share->storage_engine= myisam_engine;
2636
2595
    table->cursor= share->db_type()->getCursor(*share, &table->mem_root);
2637
2596
    if (group &&
2638
 
        (param->group_parts > table->cursor->max_key_parts() ||
2639
 
         param->group_length > table->cursor->max_key_length()))
 
2597
        (param->group_parts > table->cursor->getEngine()->max_key_parts() ||
 
2598
         param->group_length > table->cursor->getEngine()->max_key_length()))
2640
2599
      using_unique_constraint=1;
2641
2600
  }
2642
2601
  else
3183
3142
      goto err;
3184
3143
 
3185
3144
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
3186
 
    if (keyinfo->key_length >= cursor->max_key_length() ||
3187
 
        keyinfo->key_parts > cursor->max_key_parts() ||
 
3145
    if (keyinfo->key_length >= cursor->getEngine()->max_key_length() ||
 
3146
        keyinfo->key_parts > cursor->getEngine()->max_key_parts() ||
3188
3147
        share->uniques)
3189
3148
    {
3190
3149
      /* Can't create a key; Make a unique constraint instead of a key */