← 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: 2010-12-10 21:36:15 UTC
  • mfrom: (1992.1.3 build)
  • Revision ID: kalebral@gmail.com-20101210213615-qt9c09pg7epgdomq
Merge Evan - Add some extra details to the libdrizzle documentation
Merge Shrews - Fix compiler warning about "comparison between signed and unsigned integer expressions
Merge Monty - We were leaving link-warning.h out of the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/haildb/haildb_engine.cc
354
354
  isolation_level= tx_isolation_to_ib_trx_level((enum_tx_isolation)session_tx_isolation(session));
355
355
  *transaction= ib_trx_begin(isolation_level);
356
356
 
357
 
  return *transaction == NULL;
 
357
  return 0;
358
358
}
359
359
 
360
360
void HailDBEngine::doStartStatement(Session *session)
490
490
    nr++;
491
491
  }
492
492
  ib_tuple_delete(tuple);
493
 
  tuple= NULL;
494
493
  err= ib_cursor_reset(cursor);
495
494
  assert(err == DB_SUCCESS);
496
495
  return nr;
821
820
int HailDBCursor::open(const char *name, int, uint32_t)
822
821
{
823
822
  const char* haildb_table_name= table_path_to_haildb_name(name);
824
 
  ib_err_t err= ib_table_get_id(haildb_table_name, &table_id);
 
823
  ib_err_t err= ib_cursor_open_table(haildb_table_name, NULL, &cursor);
825
824
  bool has_hidden_primary_key= false;
826
825
  ib_id_t idx_id;
827
826
 
828
827
  if (err != DB_SUCCESS)
829
828
    return ib_err_t_to_drizzle_error(err);
830
829
 
831
 
  err= ib_cursor_open_table_using_id(table_id, NULL, &cursor);
832
 
  cursor_is_sec_index= false;
833
 
 
834
 
  if (err != DB_SUCCESS)
835
 
    return ib_err_t_to_drizzle_error(err);
836
 
 
837
830
  err= ib_index_get_id(haildb_table_name, "HIDDEN_PRIMARY", &idx_id);
838
831
 
839
832
  if (err == DB_SUCCESS)
1785
1778
  return("BTREE");
1786
1779
}
1787
1780
 
1788
 
static ib_err_t write_row_to_haildb_tuple(const unsigned char* buf,
1789
 
                                          Field **fields, ib_tpl_t tuple)
 
1781
static ib_err_t write_row_to_haildb_tuple(Field **fields, ib_tpl_t tuple)
1790
1782
{
1791
1783
  int colnr= 0;
1792
1784
  ib_err_t err= DB_ERROR;
1793
 
  ptrdiff_t row_offset= buf - (*fields)->getTable()->getInsertRecord();
1794
1785
 
1795
1786
  for (Field **field= fields; *field; field++, colnr++)
1796
1787
  {
1797
 
    (**field).move_field_offset(row_offset);
1798
 
 
1799
1788
    if (! (**field).isWriteSet() && (**field).is_null())
1800
 
    {
1801
 
      (**field).move_field_offset(-row_offset);
1802
1789
      continue;
1803
 
    }
1804
1790
 
1805
1791
    if ((**field).is_null())
1806
1792
    {
1807
1793
      err= ib_col_set_value(tuple, colnr, NULL, IB_SQL_NULL);
1808
1794
      assert(err == DB_SUCCESS);
1809
 
      (**field).move_field_offset(-row_offset);
1810
1795
      continue;
1811
1796
    }
1812
1797
 
1818
1803
      */
1819
1804
      String str;
1820
1805
      (**field).setReadSet();
1821
 
      (**field).val_str_internal(&str);
 
1806
      (**field).val_str(&str);
1822
1807
      err= ib_col_set_value(tuple, colnr, str.ptr(), str.length());
1823
1808
    }
1824
1809
    else if ((**field).type() == DRIZZLE_TYPE_ENUM)
1844
1829
    }
1845
1830
 
1846
1831
    assert (err == DB_SUCCESS);
1847
 
 
1848
 
    (**field).move_field_offset(-row_offset);
1849
1832
  }
1850
1833
 
1851
1834
  return err;
1894
1877
 
1895
1878
  tuple= ib_clust_read_tuple_create(cursor);
1896
1879
 
1897
 
  if (cursor_is_sec_index)
1898
 
  {
1899
 
    err= ib_cursor_close(cursor);
1900
 
    assert(err == DB_SUCCESS);
1901
 
 
1902
 
    err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
1903
 
 
1904
 
    if (err != DB_SUCCESS)
1905
 
      return ib_err_t_to_drizzle_error(err);
1906
 
 
1907
 
    cursor_is_sec_index= false;
1908
 
  }
1909
 
  else
1910
 
  {
1911
 
    ib_cursor_attach_trx(cursor, transaction);
1912
 
  }
 
1880
  ib_cursor_attach_trx(cursor, transaction);
1913
1881
 
1914
1882
  err= ib_cursor_first(cursor);
1915
1883
  if (current_session->lex->sql_command == SQLCOM_CREATE_TABLE
1968
1936
 
1969
1937
  }
1970
1938
 
1971
 
  write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
 
1939
  write_row_to_haildb_tuple(getTable()->getFields(), tuple);
1972
1940
 
1973
1941
  if (share->has_hidden_primary_key)
1974
1942
  {
2001
1969
      err= ib_cursor_first(cursor);
2002
1970
      assert(err == DB_SUCCESS || err == DB_END_OF_INDEX);
2003
1971
 
2004
 
      write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
 
1972
      write_row_to_haildb_tuple(getTable()->getFields(), tuple);
2005
1973
 
2006
1974
      err= ib_cursor_insert_row(cursor, tuple);
2007
1975
      assert(err==DB_SUCCESS); // probably be nice and process errors
2014
1982
 
2015
1983
  tuple= ib_tuple_clear(tuple);
2016
1984
  ib_tuple_delete(tuple);
2017
 
  tuple= NULL;
2018
1985
  err= ib_cursor_reset(cursor);
2019
1986
 
2020
1987
  return ret;
2021
1988
}
2022
1989
 
2023
 
int HailDBCursor::doUpdateRecord(const unsigned char *old_data,
2024
 
                                 unsigned char *new_data)
 
1990
int HailDBCursor::doUpdateRecord(const unsigned char *,
 
1991
                                         unsigned char *)
2025
1992
{
2026
1993
  ib_tpl_t update_tuple;
2027
1994
  ib_err_t err;
2028
 
  bool created_tuple= false;
2029
1995
 
2030
1996
  update_tuple= ib_clust_read_tuple_create(cursor);
2031
1997
 
2032
 
  if (tuple == NULL)
2033
 
  {
2034
 
    ib_trx_t transaction= *get_trx(getTable()->in_use);
2035
 
 
2036
 
    if (cursor_is_sec_index)
2037
 
    {
2038
 
      err= ib_cursor_close(cursor);
2039
 
      assert(err == DB_SUCCESS);
2040
 
 
2041
 
      err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2042
 
 
2043
 
      if (err != DB_SUCCESS)
2044
 
        return ib_err_t_to_drizzle_error(err);
2045
 
      cursor_is_sec_index= false;
2046
 
    }
2047
 
    else
2048
 
    {
2049
 
      ib_cursor_attach_trx(cursor, transaction);
2050
 
    }
2051
 
 
2052
 
    store_key_value_from_haildb(getTable()->key_info + getTable()->getShare()->getPrimaryKey(),
2053
 
                                  ref, ref_length, old_data);
2054
 
 
2055
 
    ib_tpl_t search_tuple= ib_clust_search_tuple_create(cursor);
2056
 
 
2057
 
    fill_ib_search_tpl_from_drizzle_key(search_tuple,
2058
 
                                        getTable()->key_info + 0,
2059
 
                                        ref, ref_length);
2060
 
 
2061
 
    err= ib_cursor_set_lock_mode(cursor, IB_LOCK_X);
2062
 
    assert(err == DB_SUCCESS);
2063
 
 
2064
 
    int res;
2065
 
    err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
2066
 
    assert(err == DB_SUCCESS);
2067
 
 
2068
 
    tuple= ib_clust_read_tuple_create(cursor);
2069
 
 
2070
 
    err= ib_cursor_read_row(cursor, tuple);
2071
 
    assert(err == DB_SUCCESS);// FIXME
2072
 
 
2073
 
    created_tuple= true;
2074
 
  }
2075
 
 
2076
1998
  err= ib_tuple_copy(update_tuple, tuple);
2077
1999
  assert(err == DB_SUCCESS);
2078
2000
 
2079
 
  write_row_to_haildb_tuple(new_data, getTable()->getFields(), update_tuple);
 
2001
  write_row_to_haildb_tuple(getTable()->getFields(), update_tuple);
2080
2002
 
2081
2003
  err= ib_cursor_update_row(cursor, tuple, update_tuple);
2082
2004
 
2083
2005
  ib_tuple_delete(update_tuple);
2084
2006
 
2085
 
  if (created_tuple)
2086
 
  {
2087
 
    ib_err_t ib_err= ib_cursor_reset(cursor); //fixme check error
2088
 
    assert(ib_err == DB_SUCCESS);
2089
 
    tuple= ib_tuple_clear(tuple);
2090
 
    ib_tuple_delete(tuple);
2091
 
    tuple= NULL;
2092
 
  }
2093
 
 
2094
2007
  advance_cursor= true;
2095
2008
 
2096
 
  return ib_err_t_to_drizzle_error(err);
 
2009
  if (err == DB_SUCCESS)
 
2010
    return 0;
 
2011
  else if (err == DB_DUPLICATE_KEY)
 
2012
    return HA_ERR_FOUND_DUPP_KEY;
 
2013
  else
 
2014
    return -1;
2097
2015
}
2098
2016
 
2099
2017
int HailDBCursor::doDeleteRecord(const unsigned char *)
2100
2018
{
2101
2019
  ib_err_t err;
2102
2020
 
2103
 
  assert(ib_cursor_is_positioned(cursor) == IB_TRUE);
2104
2021
  err= ib_cursor_delete_row(cursor);
 
2022
  if (err != DB_SUCCESS)
 
2023
    return -1; // FIXME
2105
2024
 
2106
2025
  advance_cursor= true;
2107
 
 
2108
 
  return ib_err_t_to_drizzle_error(err);
 
2026
  return 0;
2109
2027
}
2110
2028
 
2111
2029
int HailDBCursor::delete_all_rows(void)
2112
2030
{
2113
2031
  /* I *think* ib_truncate is non-transactional....
2114
2032
     so only support TRUNCATE and not DELETE FROM t;
2115
 
     (this is what ha_innodb does)
 
2033
     (this is what ha_haildb does)
2116
2034
  */
2117
2035
  if (session_sql_command(getTable()->in_use) != SQLCOM_TRUNCATE)
2118
2036
    return HA_ERR_WRONG_COMMAND;
2122
2040
 
2123
2041
  ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
2124
2042
 
2125
 
  if (cursor_is_sec_index)
2126
 
  {
2127
 
    err= ib_cursor_close(cursor);
2128
 
    assert(err == DB_SUCCESS);
2129
 
 
2130
 
    err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2131
 
 
2132
 
    if (err != DB_SUCCESS)
2133
 
      return ib_err_t_to_drizzle_error(err);
2134
 
    cursor_is_sec_index= false;
2135
 
  }
2136
 
  else
2137
 
  {
2138
 
    ib_cursor_attach_trx(cursor, transaction);
2139
 
  }
 
2043
  ib_cursor_attach_trx(cursor, transaction);
2140
2044
 
2141
2045
  err= ib_schema_lock_exclusive(transaction);
2142
2046
  if (err != DB_SUCCESS)
2172
2076
  ib_schema_unlock(transaction);
2173
2077
  ib_err_t rollback_err= ib_trx_rollback(transaction);
2174
2078
  assert(rollback_err == DB_SUCCESS);
2175
 
  return ib_err_t_to_drizzle_error(err);
 
2079
  return err;
2176
2080
}
2177
2081
 
2178
2082
int HailDBCursor::doStartTableScan(bool)
2179
2083
{
2180
 
  ib_err_t err= DB_SUCCESS;
 
2084
  ib_err_t err;
2181
2085
  ib_trx_t transaction;
2182
2086
 
2183
2087
  if (in_table_scan)
2188
2092
 
2189
2093
  assert(transaction != NULL);
2190
2094
 
2191
 
  if (cursor_is_sec_index)
2192
 
  {
2193
 
    err= ib_cursor_close(cursor);
2194
 
    assert(err == DB_SUCCESS);
2195
 
 
2196
 
    err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2197
 
    cursor_is_sec_index= false;
2198
 
  }
2199
 
  else
2200
 
  {
2201
 
    ib_cursor_attach_trx(cursor, transaction);
2202
 
  }
2203
 
 
2204
 
  if (err != DB_SUCCESS)
2205
 
    return ib_err_t_to_drizzle_error(err);
 
2095
  ib_cursor_attach_trx(cursor, transaction);
2206
2096
 
2207
2097
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2208
2098
  assert(err == DB_SUCCESS); // FIXME
2230
2120
 
2231
2121
  err= ib_cursor_read_row(cursor, tuple);
2232
2122
 
2233
 
  if (err == DB_RECORD_NOT_FOUND)
 
2123
  if (err != DB_SUCCESS) // FIXME
2234
2124
    return HA_ERR_END_OF_FILE;
2235
 
  if (err != DB_SUCCESS)
2236
 
    return ib_err_t_to_drizzle_error(err);
2237
2125
 
2238
2126
  int colnr= 0;
2239
2127
 
2244
2132
  for (Field **field= table->getFields() ; *field ; field++, colnr++)
2245
2133
  {
2246
2134
    if (! (**field).isReadSet())
2247
 
      (**field).setReadSet(); /* Fucking broken API screws us royally. */
 
2135
      continue;
2248
2136
 
2249
2137
    (**field).move_field_offset(row_offset);
2250
2138
 
2254
2142
    if (length == IB_SQL_NULL)
2255
2143
    {
2256
2144
      (**field).set_null();
2257
 
      (**field).move_field_offset(-row_offset);
2258
2145
      continue;
2259
2146
    }
2260
2147
    else
2298
2185
 
2299
2186
    (**field).move_field_offset(-row_offset);
2300
2187
 
2301
 
    if (err != DB_SUCCESS)
2302
 
      return ib_err_t_to_drizzle_error(err);
2303
2188
  }
2304
2189
 
2305
2190
  if (has_hidden_primary_key)
2307
2192
    err= ib_tuple_read_u64(tuple, colnr, hidden_pkey);
2308
2193
  }
2309
2194
 
2310
 
  return ib_err_t_to_drizzle_error(err);
 
2195
  return 0;
2311
2196
}
2312
2197
 
2313
2198
int HailDBCursor::rnd_next(unsigned char *buf)
2319
2204
    return previous_error;
2320
2205
 
2321
2206
  if (advance_cursor)
2322
 
  {
2323
2207
    err= ib_cursor_next(cursor);
2324
 
    if (err != DB_SUCCESS)
2325
 
      return ib_err_t_to_drizzle_error(err);
2326
 
  }
2327
2208
 
2328
2209
  tuple= ib_tuple_clear(tuple);
2329
2210
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
2339
2220
  ib_err_t err;
2340
2221
 
2341
2222
  ib_tuple_delete(tuple);
2342
 
  tuple= NULL;
2343
2223
  err= ib_cursor_reset(cursor);
2344
2224
  assert(err == DB_SUCCESS);
2345
2225
  in_table_scan= false;
2346
2226
  previous_error= 0;
2347
 
  return ib_err_t_to_drizzle_error(err);
 
2227
  return 0;
2348
2228
}
2349
2229
 
2350
2230
int HailDBCursor::rnd_pos(unsigned char *buf, unsigned char *pos)
2358
2238
  {
2359
2239
    err= ib_col_set_value(search_tuple, 0,
2360
2240
                          ((uint64_t*)(pos)), sizeof(uint64_t));
2361
 
    if (err != DB_SUCCESS)
2362
 
      return ib_err_t_to_drizzle_error(err);
2363
2241
  }
2364
2242
  else
2365
2243
  {
2375
2253
  }
2376
2254
 
2377
2255
  err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
2378
 
  if (err != DB_SUCCESS)
2379
 
    return ib_err_t_to_drizzle_error(err);
 
2256
  assert(err == DB_SUCCESS);
2380
2257
 
2381
2258
  assert(res==0);
2382
2259
  if (res != 0)
2425
2302
      }
2426
2303
 
2427
2304
      String str;
2428
 
      field->val_str_internal(&str);
 
2305
      field->val_str(&str);
2429
2306
 
2430
2307
      *ref++= (char)(str.length() & 0x000000ff);
2431
2308
      *ref++= (char)((str.length()>>8) & 0x000000ff);
2504
2381
 
2505
2382
  if (flag & HA_STATUS_AUTO)
2506
2383
    stats.auto_increment_value= 1;
2507
 
 
2508
 
  if (flag & HA_STATUS_ERRKEY) {
2509
 
    const char *err_table_name;
2510
 
    const char *err_index_name;
2511
 
 
2512
 
    ib_trx_t transaction= *get_trx(getTable()->in_use);
2513
 
 
2514
 
    err= ib_get_duplicate_key(transaction, &err_table_name, &err_index_name);
2515
 
 
2516
 
    errkey= -1;
2517
 
 
2518
 
    for (unsigned int i = 0; i < getTable()->getShare()->keys; i++)
2519
 
    {
2520
 
      if (strcmp(err_index_name, getTable()->key_info[i].name) == 0)
2521
 
      {
2522
 
        errkey= i;
2523
 
        break;
2524
 
      }
2525
 
    }
2526
 
 
2527
 
  }
2528
 
 
2529
2384
  return(0);
2530
2385
}
2531
2386
 
2532
2387
int HailDBCursor::doStartIndexScan(uint32_t keynr, bool)
2533
2388
{
2534
 
  ib_err_t err;
2535
2389
  ib_trx_t transaction= *get_trx(getTable()->in_use);
2536
2390
 
2537
2391
  active_index= keynr;
2538
2392
 
 
2393
  ib_cursor_attach_trx(cursor, transaction);
 
2394
 
2539
2395
  if (active_index == 0 && ! share->has_hidden_primary_key)
2540
2396
  {
2541
 
    if (cursor_is_sec_index)
2542
 
    {
2543
 
      err= ib_cursor_close(cursor);
2544
 
      assert(err == DB_SUCCESS);
2545
 
 
2546
 
      err= ib_cursor_open_table_using_id(table_id, transaction, &cursor);
2547
 
 
2548
 
      if (err != DB_SUCCESS)
2549
 
        return ib_err_t_to_drizzle_error(err);
2550
 
 
2551
 
    }
2552
 
    else
2553
 
    {
2554
 
      ib_cursor_attach_trx(cursor, transaction);
2555
 
    }
2556
 
 
2557
 
    cursor_is_sec_index= false;
2558
2397
    tuple= ib_clust_read_tuple_create(cursor);
2559
2398
  }
2560
2399
  else
2561
2400
  {
 
2401
    ib_err_t err;
2562
2402
    ib_id_t index_id;
2563
2403
    err= ib_index_get_id(table_path_to_haildb_name(getShare()->getPath()),
2564
2404
                         getShare()->getKeyInfo(keynr).name,
2565
2405
                         &index_id);
2566
2406
    if (err != DB_SUCCESS)
2567
 
      return ib_err_t_to_drizzle_error(err);
 
2407
      return -1;
2568
2408
 
2569
2409
    err= ib_cursor_close(cursor);
2570
2410
    assert(err == DB_SUCCESS);
2571
 
 
2572
2411
    err= ib_cursor_open_index_using_id(index_id, transaction, &cursor);
2573
2412
 
2574
2413
    if (err != DB_SUCCESS)
2575
 
      return ib_err_t_to_drizzle_error(err);
2576
 
 
2577
 
    cursor_is_sec_index= true;
 
2414
      return -1;
2578
2415
 
2579
2416
    tuple= ib_clust_read_tuple_create(cursor);
2580
2417
    ib_cursor_set_cluster_access(cursor);
2581
2418
  }
2582
2419
 
2583
 
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
 
2420
  ib_err_t err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2584
2421
  assert(err == DB_SUCCESS);
2585
2422
 
2586
2423
  advance_cursor= false;
2846
2683
      if (err == DB_END_OF_INDEX)
2847
2684
        return HA_ERR_END_OF_FILE;
2848
2685
      else
2849
 
        return ib_err_t_to_drizzle_error(err);
 
2686
        return -1; // FIXME
2850
2687
    }
2851
2688
  }
2852
2689