← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/haildb/haildb_engine.cc

  • Committer: Lee Bieber
  • Date: 2011-01-18 20:05:06 UTC
  • mfrom: (2094.1.6 build)
  • Revision ID: kalebral@gmail.com-20110118200506-r1v72y174j5x7j0i
Merge Brian - fix processlist test, was failing under lcov
Merge Marisa - fix bug 684803: Need to update Drizzledump documentation with migration conversions / caveats
Merge Marisa - fix bug #686641: Need to document removal of multi-table update/delete from Drizzle
Merge Monty - fix bug 567387: quotes now appearing around module name and author in data_dicionary view
Merge Monty - fix bug 658752: Incorrect datadir value being stored
Merge Andrew - fix bug 680872: max-connect-errors appears to be unused 
Merge Stewart - Haildb updates, ANALYZE table as well as improved index statistics

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/haildb/haildb_engine.cc
116
116
using namespace google;
117
117
using namespace drizzled;
118
118
 
119
 
int read_row_from_haildb(unsigned char* buf, ib_crsr_t cursor, ib_tpl_t tuple, Table* table, bool has_hidden_primary_key, uint64_t *hidden_pkey, drizzled::memory::Root **blobroot= NULL);
 
119
int read_row_from_haildb(Session *session, unsigned char* buf, ib_crsr_t cursor, ib_tpl_t tuple, Table* table, bool has_hidden_primary_key, uint64_t *hidden_pkey, drizzled::memory::Root **blobroot= NULL);
120
120
static void fill_ib_search_tpl_from_drizzle_key(ib_tpl_t search_tuple,
121
121
                                                const drizzled::KeyInfo *key_info,
122
122
                                                const unsigned char *key_ptr,
239
239
/* This is a superset of the map from innobase plugin.
240
240
   Unlike innobase plugin we don't act on errors here, we just
241
241
   map error codes. */
242
 
static int ib_err_t_to_drizzle_error(ib_err_t err)
 
242
static int ib_err_t_to_drizzle_error(Session* session, ib_err_t err)
243
243
{
244
244
  switch (err)
245
245
  {
269
269
    return HA_ERR_NO_ACTIVE_RECORD;
270
270
 
271
271
  case DB_DEADLOCK:
 
272
    /* HailDB will roll back a transaction itself due to DB_DEADLOCK.
 
273
       This means we have to tell Drizzle about it */
 
274
    mark_transaction_to_rollback(session, true);
272
275
    return HA_ERR_LOCK_DEADLOCK;
273
276
 
274
277
  case DB_LOCK_WAIT_TIMEOUT:
387
390
  err= ib_savepoint_rollback(*transaction, savepoint.getName().c_str(),
388
391
                             savepoint.getName().length());
389
392
 
390
 
  return ib_err_t_to_drizzle_error(err);
 
393
  return ib_err_t_to_drizzle_error(session, err);
391
394
}
392
395
 
393
396
int HailDBEngine::doReleaseSavepoint(Session* session,
399
402
  err= ib_savepoint_release(*transaction, savepoint.getName().c_str(),
400
403
                            savepoint.getName().length());
401
404
  if (err != DB_SUCCESS)
402
 
    return ib_err_t_to_drizzle_error(err);
 
405
    return ib_err_t_to_drizzle_error(session, err);
403
406
 
404
407
  return 0;
405
408
}
414
417
    err= ib_trx_commit(*transaction);
415
418
 
416
419
    if (err != DB_SUCCESS)
417
 
      return ib_err_t_to_drizzle_error(err);
 
420
      return ib_err_t_to_drizzle_error(session, err);
418
421
 
419
422
    *transaction= NULL;
420
423
  }
429
432
 
430
433
  if (all || !session_test_options(session, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
431
434
  {
432
 
    err= ib_trx_rollback(*transaction);
 
435
    if (ib_trx_state(*transaction) == IB_TRX_NOT_STARTED)
 
436
      err= ib_trx_release(*transaction);
 
437
    else
 
438
      err= ib_trx_rollback(*transaction);
433
439
 
434
440
    if (err != DB_SUCCESS)
435
 
      return ib_err_t_to_drizzle_error(err);
 
441
      return ib_err_t_to_drizzle_error(session, err);
436
442
 
437
443
    *transaction= NULL;
438
444
  }
439
445
  else
440
446
  {
 
447
    if (ib_trx_state(*transaction) == IB_TRX_NOT_STARTED)
 
448
      return 0;
 
449
 
441
450
    err= ib_savepoint_rollback(*transaction, statement_savepoint_name.c_str(),
442
451
                               statement_savepoint_name.length());
443
452
    if (err != DB_SUCCESS)
444
 
      return ib_err_t_to_drizzle_error(err);
 
453
      return ib_err_t_to_drizzle_error(session, err);
445
454
  }
446
455
 
447
456
  return 0;
825
834
  ib_id_t idx_id;
826
835
 
827
836
  if (err != DB_SUCCESS)
828
 
    return ib_err_t_to_drizzle_error(err);
 
837
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
829
838
 
830
839
  err= ib_cursor_open_table_using_id(table_id, NULL, &cursor);
831
840
  cursor_is_sec_index= false;
832
841
 
833
842
  if (err != DB_SUCCESS)
834
 
    return ib_err_t_to_drizzle_error(err);
 
843
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
835
844
 
836
845
  err= ib_index_get_id(haildb_table_name, "HIDDEN_PRIMARY", &idx_id);
837
846
 
862
871
{
863
872
  ib_err_t err= ib_cursor_close(cursor);
864
873
  if (err != DB_SUCCESS)
865
 
    return ib_err_t_to_drizzle_error(err);
 
874
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
866
875
 
867
876
  free_share();
868
877
 
1070
1079
                        ER_CANT_CREATE_TABLE,
1071
1080
                        _("Cannot create table %s. HailDB Error %d (%s)\n"),
1072
1081
                        haildb_table_name.c_str(), haildb_err, ib_strerror(haildb_err));
1073
 
    return ib_err_t_to_drizzle_error(haildb_err);
 
1082
    return ib_err_t_to_drizzle_error(&session, haildb_err);
1074
1083
  }
1075
1084
 
1076
1085
  for (int colnr= 0; colnr < table_message.field_size() ; colnr++)
1091
1100
                            " HailDB Error %d (%s)\n"),
1092
1101
                          field.name().c_str(), haildb_table_name.c_str(),
1093
1102
                          haildb_err, ib_strerror(haildb_err));
1094
 
      return ib_err_t_to_drizzle_error(haildb_err);
 
1103
      return ib_err_t_to_drizzle_error(&session, haildb_err);
1095
1104
    }
1096
1105
    if (field_err != 0)
1097
1106
      return field_err;
1239
1248
                        _("Cannot create table %s. HailDB Error %d (%s)\n"),
1240
1249
                        haildb_table_name.c_str(),
1241
1250
                        haildb_err, ib_strerror(haildb_err));
1242
 
    return ib_err_t_to_drizzle_error(haildb_err);
 
1251
    return ib_err_t_to_drizzle_error(&session, haildb_err);
1243
1252
  }
1244
1253
 
1245
1254
  return 0;
1506
1515
  assert(rollback_err == DB_SUCCESS);
1507
1516
  rollback_err= ib_trx_rollback(haildb_schema_transaction);
1508
1517
  assert(rollback_err == DB_SUCCESS);
1509
 
  return ib_err_t_to_drizzle_error(err);
 
1518
  return ib_err_t_to_drizzle_error(&session, err);
1510
1519
}
1511
1520
 
1512
1521
void HailDBEngine::getTableNamesInSchemaFromHailDB(
1901
1910
    err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
1902
1911
 
1903
1912
    if (err != DB_SUCCESS)
1904
 
      return ib_err_t_to_drizzle_error(err);
 
1913
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
1905
1914
 
1906
1915
    cursor_is_sec_index= false;
1907
1916
  }
2010
2019
      ret= HA_ERR_FOUND_DUPP_KEY;
2011
2020
  }
2012
2021
  else if (err != DB_SUCCESS)
2013
 
    ret= ib_err_t_to_drizzle_error(err);
 
2022
    ret= ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2014
2023
 
2015
2024
  tuple= ib_tuple_clear(tuple);
2016
2025
  ib_tuple_delete(tuple);
2041
2050
      err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2042
2051
 
2043
2052
      if (err != DB_SUCCESS)
2044
 
        return ib_err_t_to_drizzle_error(err);
 
2053
        return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2045
2054
      cursor_is_sec_index= false;
2046
2055
    }
2047
2056
    else
2093
2102
 
2094
2103
  advance_cursor= true;
2095
2104
 
2096
 
  return ib_err_t_to_drizzle_error(err);
 
2105
  return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2097
2106
}
2098
2107
 
2099
2108
int HailDBCursor::doDeleteRecord(const unsigned char *)
2105
2114
 
2106
2115
  advance_cursor= true;
2107
2116
 
2108
 
  return ib_err_t_to_drizzle_error(err);
 
2117
  return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2109
2118
}
2110
2119
 
2111
2120
int HailDBCursor::delete_all_rows(void)
2130
2139
    err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2131
2140
 
2132
2141
    if (err != DB_SUCCESS)
2133
 
      return ib_err_t_to_drizzle_error(err);
 
2142
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2134
2143
    cursor_is_sec_index= false;
2135
2144
  }
2136
2145
  else
2172
2181
  ib_schema_unlock(transaction);
2173
2182
  ib_err_t rollback_err= ib_trx_rollback(transaction);
2174
2183
  assert(rollback_err == DB_SUCCESS);
2175
 
  return ib_err_t_to_drizzle_error(err);
 
2184
  return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2176
2185
}
2177
2186
 
2178
2187
int HailDBCursor::doStartTableScan(bool)
2202
2211
  }
2203
2212
 
2204
2213
  if (err != DB_SUCCESS)
2205
 
    return ib_err_t_to_drizzle_error(err);
 
2214
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2206
2215
 
2207
2216
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2208
2217
  assert(err == DB_SUCCESS); // FIXME
2214
2223
  {
2215
2224
    int reset_err= ib_cursor_reset(cursor);
2216
2225
    assert(reset_err == DB_SUCCESS);
2217
 
    return ib_err_t_to_drizzle_error(err);
 
2226
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2218
2227
  }
2219
2228
 
2220
2229
  advance_cursor= false;
2222
2231
  return(0);
2223
2232
}
2224
2233
 
2225
 
int read_row_from_haildb(unsigned char* buf, ib_crsr_t cursor, ib_tpl_t tuple, Table* table, bool has_hidden_primary_key, uint64_t *hidden_pkey, drizzled::memory::Root **blobroot)
 
2234
int read_row_from_haildb(Session *session, unsigned char* buf, ib_crsr_t cursor, ib_tpl_t tuple, Table* table, bool has_hidden_primary_key, uint64_t *hidden_pkey, drizzled::memory::Root **blobroot)
2226
2235
{
2227
2236
  ib_err_t err;
2228
2237
  ptrdiff_t row_offset= buf - table->getInsertRecord();
2232
2241
  if (err == DB_RECORD_NOT_FOUND)
2233
2242
    return HA_ERR_END_OF_FILE;
2234
2243
  if (err != DB_SUCCESS)
2235
 
    return ib_err_t_to_drizzle_error(err);
 
2244
    return ib_err_t_to_drizzle_error(session, err);
2236
2245
 
2237
2246
  int colnr= 0;
2238
2247
 
2298
2307
    (**field).move_field_offset(-row_offset);
2299
2308
 
2300
2309
    if (err != DB_SUCCESS)
2301
 
      return ib_err_t_to_drizzle_error(err);
 
2310
      return ib_err_t_to_drizzle_error(session, err);
2302
2311
  }
2303
2312
 
2304
2313
  if (has_hidden_primary_key)
2306
2315
    err= ib_tuple_read_u64(tuple, colnr, hidden_pkey);
2307
2316
  }
2308
2317
 
2309
 
  return ib_err_t_to_drizzle_error(err);
 
2318
  return ib_err_t_to_drizzle_error(session, err);
2310
2319
}
2311
2320
 
2312
2321
int HailDBCursor::rnd_next(unsigned char *buf)
2318
2327
  {
2319
2328
    err= ib_cursor_next(cursor);
2320
2329
    if (err != DB_SUCCESS)
2321
 
      return ib_err_t_to_drizzle_error(err);
 
2330
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2322
2331
  }
2323
2332
 
2324
2333
  tuple= ib_tuple_clear(tuple);
2325
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2334
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2335
                            getTable(),
2326
2336
                            share->has_hidden_primary_key,
2327
2337
                            &hidden_autoinc_pkey_position);
2328
2338
 
2339
2349
  err= ib_cursor_reset(cursor);
2340
2350
  assert(err == DB_SUCCESS);
2341
2351
  in_table_scan= false;
2342
 
  return ib_err_t_to_drizzle_error(err);
 
2352
  return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2343
2353
}
2344
2354
 
2345
2355
int HailDBCursor::rnd_pos(unsigned char *buf, unsigned char *pos)
2354
2364
    err= ib_col_set_value(search_tuple, 0,
2355
2365
                          ((uint64_t*)(pos)), sizeof(uint64_t));
2356
2366
    if (err != DB_SUCCESS)
2357
 
      return ib_err_t_to_drizzle_error(err);
 
2367
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2358
2368
  }
2359
2369
  else
2360
2370
  {
2371
2381
 
2372
2382
  err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
2373
2383
  if (err != DB_SUCCESS)
2374
 
    return ib_err_t_to_drizzle_error(err);
 
2384
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2375
2385
 
2376
2386
  assert(res==0);
2377
2387
  if (res != 0)
2382
2392
  tuple= ib_tuple_clear(tuple);
2383
2393
 
2384
2394
  if (ret == 0)
2385
 
    ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2395
    ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2396
                              getTable(),
2386
2397
                              share->has_hidden_primary_key,
2387
2398
                              &hidden_autoinc_pkey_position);
2388
2399
 
2521
2532
 
2522
2533
  }
2523
2534
 
 
2535
  if (flag & HA_STATUS_CONST)
 
2536
  {
 
2537
    for (unsigned int i = 0; i < getTable()->getShare()->sizeKeys(); i++)
 
2538
    {
 
2539
      const char* index_name= getTable()->key_info[i].name;
 
2540
      uint64_t ncols;
 
2541
      int64_t *n_diff;
 
2542
      ha_rows rec_per_key;
 
2543
 
 
2544
      err= ib_get_index_stat_n_diff_key_vals(cursor, index_name,
 
2545
                                             &ncols, &n_diff);
 
2546
 
 
2547
      if (err != DB_SUCCESS)
 
2548
        return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
 
2549
 
 
2550
      for (unsigned int j=0; j < getTable()->key_info[i].key_parts; j++)
 
2551
      {
 
2552
        if (n_diff[j+1] == 0)
 
2553
          rec_per_key= stats.records;
 
2554
        else
 
2555
          rec_per_key= stats.records / n_diff[j+1];
 
2556
 
 
2557
        /* We import this heuristic from ha_innodb, which says
 
2558
           that MySQL favours table scans too much over index searches,
 
2559
           so we pretend our index selectivity is 2 times better. */
 
2560
 
 
2561
        rec_per_key= rec_per_key / 2;
 
2562
 
 
2563
        if (rec_per_key == 0)
 
2564
          rec_per_key= 1;
 
2565
 
 
2566
        getTable()->key_info[i].rec_per_key[j]=
 
2567
          rec_per_key >= ~(ulong) 0 ? ~(ulong) 0 :
 
2568
          (ulong) rec_per_key;
 
2569
      }
 
2570
 
 
2571
      free(n_diff);
 
2572
    }
 
2573
  }
 
2574
 
2524
2575
  return(0);
2525
2576
}
2526
2577
 
2541
2592
      err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2542
2593
 
2543
2594
      if (err != DB_SUCCESS)
2544
 
        return ib_err_t_to_drizzle_error(err);
 
2595
        return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2545
2596
 
2546
2597
    }
2547
2598
    else
2559
2610
                         getShare()->getKeyInfo(keynr).name,
2560
2611
                         &index_id);
2561
2612
    if (err != DB_SUCCESS)
2562
 
      return ib_err_t_to_drizzle_error(err);
 
2613
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2563
2614
 
2564
2615
    err= ib_cursor_close(cursor);
2565
2616
    assert(err == DB_SUCCESS);
2567
2618
    err= ib_cursor_open_index_using_id(index_id, transaction, &cursor);
2568
2619
 
2569
2620
    if (err != DB_SUCCESS)
2570
 
      return ib_err_t_to_drizzle_error(err);
 
2621
      return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2571
2622
 
2572
2623
    cursor_is_sec_index= true;
2573
2624
 
2720
2771
 
2721
2772
  if (err != DB_SUCCESS)
2722
2773
  {
2723
 
    return ib_err_t_to_drizzle_error(err);
 
2774
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2724
2775
  }
2725
2776
 
2726
2777
  tuple= ib_tuple_clear(tuple);
2727
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2778
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2779
                            getTable(),
2728
2780
                            share->has_hidden_primary_key,
2729
2781
                            &hidden_autoinc_pkey_position,
2730
2782
                            (allocate_blobs)? &blobroot : NULL);
2801
2853
  return 0;
2802
2854
}
2803
2855
 
 
2856
int HailDBCursor::analyze(Session*)
 
2857
{
 
2858
  ib_err_t err;
 
2859
 
 
2860
  err= ib_update_table_statistics(cursor);
 
2861
 
 
2862
  return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
 
2863
}
 
2864
 
2804
2865
int HailDBCursor::index_next(unsigned char *buf)
2805
2866
{
2806
2867
  int ret= HA_ERR_END_OF_FILE;
2813
2874
  }
2814
2875
 
2815
2876
  tuple= ib_tuple_clear(tuple);
2816
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2877
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2878
                            getTable(),
2817
2879
                            share->has_hidden_primary_key,
2818
2880
                            &hidden_autoinc_pkey_position);
2819
2881
 
2841
2903
      if (err == DB_END_OF_INDEX)
2842
2904
        return HA_ERR_END_OF_FILE;
2843
2905
      else
2844
 
        return ib_err_t_to_drizzle_error(err);
 
2906
        return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2845
2907
    }
2846
2908
  }
2847
2909
 
2848
2910
  tuple= ib_tuple_clear(tuple);
2849
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2911
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2912
                            getTable(),
2850
2913
                            share->has_hidden_primary_key,
2851
2914
                            &hidden_autoinc_pkey_position);
2852
2915
 
2863
2926
 
2864
2927
  err= ib_cursor_first(cursor);
2865
2928
  if (err != DB_SUCCESS)
2866
 
    return ib_err_t_to_drizzle_error(err);
 
2929
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2867
2930
 
2868
2931
  tuple= ib_tuple_clear(tuple);
2869
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2932
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2933
                            getTable(),
2870
2934
                            share->has_hidden_primary_key,
2871
2935
                            &hidden_autoinc_pkey_position);
2872
2936
 
2883
2947
 
2884
2948
  err= ib_cursor_last(cursor);
2885
2949
  if (err != DB_SUCCESS)
2886
 
    return ib_err_t_to_drizzle_error(err);
 
2950
    return ib_err_t_to_drizzle_error(getTable()->getSession(), err);
2887
2951
 
2888
2952
  tuple= ib_tuple_clear(tuple);
2889
 
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
 
2953
  ret= read_row_from_haildb(getTable()->getSession(), buf, cursor, tuple,
 
2954
                            getTable(),
2890
2955
                            share->has_hidden_primary_key,
2891
2956
                            &hidden_autoinc_pkey_position);
2892
2957
  advance_cursor= true;