← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/haildb/haildb_engine.cc

  • Committer: Brian Aker
  • Date: 2010-12-20 19:20:57 UTC
  • mto: This revision was merged to the branch mainline in revision 2016.
  • Revision ID: brian@tangent.org-20101220192057-1ch4b9uo008d8rje
Merge in additional fixes for sign, plus alter table, plus TIME on
processlist.

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 0;
 
357
  return *transaction == NULL;
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;
493
494
  err= ib_cursor_reset(cursor);
494
495
  assert(err == DB_SUCCESS);
495
496
  return nr;
820
821
int HailDBCursor::open(const char *name, int, uint32_t)
821
822
{
822
823
  const char* haildb_table_name= table_path_to_haildb_name(name);
823
 
  ib_err_t err= ib_cursor_open_table(haildb_table_name, NULL, &cursor);
 
824
  ib_err_t err= ib_table_get_id(haildb_table_name, &table_id);
824
825
  bool has_hidden_primary_key= false;
825
826
  ib_id_t idx_id;
826
827
 
827
828
  if (err != DB_SUCCESS)
828
829
    return ib_err_t_to_drizzle_error(err);
829
830
 
 
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
 
830
837
  err= ib_index_get_id(haildb_table_name, "HIDDEN_PRIMARY", &idx_id);
831
838
 
832
839
  if (err == DB_SUCCESS)
1778
1785
  return("BTREE");
1779
1786
}
1780
1787
 
1781
 
static ib_err_t write_row_to_haildb_tuple(Field **fields, ib_tpl_t tuple)
 
1788
static ib_err_t write_row_to_haildb_tuple(const unsigned char* buf,
 
1789
                                          Field **fields, ib_tpl_t tuple)
1782
1790
{
1783
1791
  int colnr= 0;
1784
1792
  ib_err_t err= DB_ERROR;
 
1793
  ptrdiff_t row_offset= buf - (*fields)->getTable()->getInsertRecord();
1785
1794
 
1786
1795
  for (Field **field= fields; *field; field++, colnr++)
1787
1796
  {
 
1797
    (**field).move_field_offset(row_offset);
 
1798
 
1788
1799
    if (! (**field).isWriteSet() && (**field).is_null())
 
1800
    {
 
1801
      (**field).move_field_offset(-row_offset);
1789
1802
      continue;
 
1803
    }
1790
1804
 
1791
1805
    if ((**field).is_null())
1792
1806
    {
1793
1807
      err= ib_col_set_value(tuple, colnr, NULL, IB_SQL_NULL);
1794
1808
      assert(err == DB_SUCCESS);
 
1809
      (**field).move_field_offset(-row_offset);
1795
1810
      continue;
1796
1811
    }
1797
1812
 
1803
1818
      */
1804
1819
      String str;
1805
1820
      (**field).setReadSet();
1806
 
      (**field).val_str(&str);
 
1821
      (**field).val_str_internal(&str);
1807
1822
      err= ib_col_set_value(tuple, colnr, str.ptr(), str.length());
1808
1823
    }
1809
1824
    else if ((**field).type() == DRIZZLE_TYPE_ENUM)
1829
1844
    }
1830
1845
 
1831
1846
    assert (err == DB_SUCCESS);
 
1847
 
 
1848
    (**field).move_field_offset(-row_offset);
1832
1849
  }
1833
1850
 
1834
1851
  return err;
1877
1894
 
1878
1895
  tuple= ib_clust_read_tuple_create(cursor);
1879
1896
 
1880
 
  ib_cursor_attach_trx(cursor, transaction);
 
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
  }
1881
1913
 
1882
1914
  err= ib_cursor_first(cursor);
1883
1915
  if (current_session->lex->sql_command == SQLCOM_CREATE_TABLE
1936
1968
 
1937
1969
  }
1938
1970
 
1939
 
  write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
1971
  write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
1940
1972
 
1941
1973
  if (share->has_hidden_primary_key)
1942
1974
  {
1969
2001
      err= ib_cursor_first(cursor);
1970
2002
      assert(err == DB_SUCCESS || err == DB_END_OF_INDEX);
1971
2003
 
1972
 
      write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
2004
      write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
1973
2005
 
1974
2006
      err= ib_cursor_insert_row(cursor, tuple);
1975
2007
      assert(err==DB_SUCCESS); // probably be nice and process errors
1982
2014
 
1983
2015
  tuple= ib_tuple_clear(tuple);
1984
2016
  ib_tuple_delete(tuple);
 
2017
  tuple= NULL;
1985
2018
  err= ib_cursor_reset(cursor);
1986
2019
 
1987
2020
  return ret;
1988
2021
}
1989
2022
 
1990
 
int HailDBCursor::doUpdateRecord(const unsigned char *,
1991
 
                                         unsigned char *)
 
2023
int HailDBCursor::doUpdateRecord(const unsigned char *old_data,
 
2024
                                 unsigned char *new_data)
1992
2025
{
1993
2026
  ib_tpl_t update_tuple;
1994
2027
  ib_err_t err;
 
2028
  bool created_tuple= false;
1995
2029
 
1996
2030
  update_tuple= ib_clust_read_tuple_create(cursor);
1997
2031
 
 
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
 
1998
2076
  err= ib_tuple_copy(update_tuple, tuple);
1999
2077
  assert(err == DB_SUCCESS);
2000
2078
 
2001
 
  write_row_to_haildb_tuple(getTable()->getFields(), update_tuple);
 
2079
  write_row_to_haildb_tuple(new_data, getTable()->getFields(), update_tuple);
2002
2080
 
2003
2081
  err= ib_cursor_update_row(cursor, tuple, update_tuple);
2004
2082
 
2005
2083
  ib_tuple_delete(update_tuple);
2006
2084
 
 
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
 
2007
2094
  advance_cursor= true;
2008
2095
 
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;
 
2096
  return ib_err_t_to_drizzle_error(err);
2015
2097
}
2016
2098
 
2017
2099
int HailDBCursor::doDeleteRecord(const unsigned char *)
2018
2100
{
2019
2101
  ib_err_t err;
2020
2102
 
 
2103
  assert(ib_cursor_is_positioned(cursor) == IB_TRUE);
2021
2104
  err= ib_cursor_delete_row(cursor);
2022
 
  if (err != DB_SUCCESS)
2023
 
    return -1; // FIXME
2024
2105
 
2025
2106
  advance_cursor= true;
2026
 
  return 0;
 
2107
 
 
2108
  return ib_err_t_to_drizzle_error(err);
2027
2109
}
2028
2110
 
2029
2111
int HailDBCursor::delete_all_rows(void)
2030
2112
{
2031
2113
  /* I *think* ib_truncate is non-transactional....
2032
2114
     so only support TRUNCATE and not DELETE FROM t;
2033
 
     (this is what ha_haildb does)
 
2115
     (this is what ha_innodb does)
2034
2116
  */
2035
2117
  if (session_sql_command(getTable()->in_use) != SQLCOM_TRUNCATE)
2036
2118
    return HA_ERR_WRONG_COMMAND;
2040
2122
 
2041
2123
  ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
2042
2124
 
2043
 
  ib_cursor_attach_trx(cursor, transaction);
 
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
  }
2044
2140
 
2045
2141
  err= ib_schema_lock_exclusive(transaction);
2046
2142
  if (err != DB_SUCCESS)
2076
2172
  ib_schema_unlock(transaction);
2077
2173
  ib_err_t rollback_err= ib_trx_rollback(transaction);
2078
2174
  assert(rollback_err == DB_SUCCESS);
2079
 
  return err;
 
2175
  return ib_err_t_to_drizzle_error(err);
2080
2176
}
2081
2177
 
2082
2178
int HailDBCursor::doStartTableScan(bool)
2083
2179
{
2084
 
  ib_err_t err;
 
2180
  ib_err_t err= DB_SUCCESS;
2085
2181
  ib_trx_t transaction;
2086
2182
 
2087
2183
  if (in_table_scan)
2092
2188
 
2093
2189
  assert(transaction != NULL);
2094
2190
 
2095
 
  ib_cursor_attach_trx(cursor, transaction);
 
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);
2096
2206
 
2097
2207
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2098
2208
  assert(err == DB_SUCCESS); // FIXME
2120
2230
 
2121
2231
  err= ib_cursor_read_row(cursor, tuple);
2122
2232
 
2123
 
  if (err != DB_SUCCESS) // FIXME
 
2233
  if (err == DB_RECORD_NOT_FOUND)
2124
2234
    return HA_ERR_END_OF_FILE;
 
2235
  if (err != DB_SUCCESS)
 
2236
    return ib_err_t_to_drizzle_error(err);
2125
2237
 
2126
2238
  int colnr= 0;
2127
2239
 
2132
2244
  for (Field **field= table->getFields() ; *field ; field++, colnr++)
2133
2245
  {
2134
2246
    if (! (**field).isReadSet())
2135
 
      continue;
 
2247
      (**field).setReadSet(); /* Fucking broken API screws us royally. */
2136
2248
 
2137
2249
    (**field).move_field_offset(row_offset);
2138
2250
 
2142
2254
    if (length == IB_SQL_NULL)
2143
2255
    {
2144
2256
      (**field).set_null();
 
2257
      (**field).move_field_offset(-row_offset);
2145
2258
      continue;
2146
2259
    }
2147
2260
    else
2185
2298
 
2186
2299
    (**field).move_field_offset(-row_offset);
2187
2300
 
 
2301
    if (err != DB_SUCCESS)
 
2302
      return ib_err_t_to_drizzle_error(err);
2188
2303
  }
2189
2304
 
2190
2305
  if (has_hidden_primary_key)
2192
2307
    err= ib_tuple_read_u64(tuple, colnr, hidden_pkey);
2193
2308
  }
2194
2309
 
2195
 
  return 0;
 
2310
  return ib_err_t_to_drizzle_error(err);
2196
2311
}
2197
2312
 
2198
2313
int HailDBCursor::rnd_next(unsigned char *buf)
2204
2319
    return previous_error;
2205
2320
 
2206
2321
  if (advance_cursor)
 
2322
  {
2207
2323
    err= ib_cursor_next(cursor);
 
2324
    if (err != DB_SUCCESS)
 
2325
      return ib_err_t_to_drizzle_error(err);
 
2326
  }
2208
2327
 
2209
2328
  tuple= ib_tuple_clear(tuple);
2210
2329
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
2220
2339
  ib_err_t err;
2221
2340
 
2222
2341
  ib_tuple_delete(tuple);
 
2342
  tuple= NULL;
2223
2343
  err= ib_cursor_reset(cursor);
2224
2344
  assert(err == DB_SUCCESS);
2225
2345
  in_table_scan= false;
2226
2346
  previous_error= 0;
2227
 
  return 0;
 
2347
  return ib_err_t_to_drizzle_error(err);
2228
2348
}
2229
2349
 
2230
2350
int HailDBCursor::rnd_pos(unsigned char *buf, unsigned char *pos)
2238
2358
  {
2239
2359
    err= ib_col_set_value(search_tuple, 0,
2240
2360
                          ((uint64_t*)(pos)), sizeof(uint64_t));
 
2361
    if (err != DB_SUCCESS)
 
2362
      return ib_err_t_to_drizzle_error(err);
2241
2363
  }
2242
2364
  else
2243
2365
  {
2253
2375
  }
2254
2376
 
2255
2377
  err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
2256
 
  assert(err == DB_SUCCESS);
 
2378
  if (err != DB_SUCCESS)
 
2379
    return ib_err_t_to_drizzle_error(err);
2257
2380
 
2258
2381
  assert(res==0);
2259
2382
  if (res != 0)
2302
2425
      }
2303
2426
 
2304
2427
      String str;
2305
 
      field->val_str(&str);
 
2428
      field->val_str_internal(&str);
2306
2429
 
2307
2430
      *ref++= (char)(str.length() & 0x000000ff);
2308
2431
      *ref++= (char)((str.length()>>8) & 0x000000ff);
2381
2504
 
2382
2505
  if (flag & HA_STATUS_AUTO)
2383
2506
    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
 
2384
2529
  return(0);
2385
2530
}
2386
2531
 
2387
2532
int HailDBCursor::doStartIndexScan(uint32_t keynr, bool)
2388
2533
{
 
2534
  ib_err_t err;
2389
2535
  ib_trx_t transaction= *get_trx(getTable()->in_use);
2390
2536
 
2391
2537
  active_index= keynr;
2392
2538
 
2393
 
  ib_cursor_attach_trx(cursor, transaction);
2394
 
 
2395
2539
  if (active_index == 0 && ! share->has_hidden_primary_key)
2396
2540
  {
 
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;
2397
2558
    tuple= ib_clust_read_tuple_create(cursor);
2398
2559
  }
2399
2560
  else
2400
2561
  {
2401
 
    ib_err_t err;
2402
2562
    ib_id_t index_id;
2403
2563
    err= ib_index_get_id(table_path_to_haildb_name(getShare()->getPath()),
2404
2564
                         getShare()->getKeyInfo(keynr).name,
2405
2565
                         &index_id);
2406
2566
    if (err != DB_SUCCESS)
2407
 
      return -1;
 
2567
      return ib_err_t_to_drizzle_error(err);
2408
2568
 
2409
2569
    err= ib_cursor_close(cursor);
2410
2570
    assert(err == DB_SUCCESS);
 
2571
 
2411
2572
    err= ib_cursor_open_index_using_id(index_id, transaction, &cursor);
2412
2573
 
2413
2574
    if (err != DB_SUCCESS)
2414
 
      return -1;
 
2575
      return ib_err_t_to_drizzle_error(err);
 
2576
 
 
2577
    cursor_is_sec_index= true;
2415
2578
 
2416
2579
    tuple= ib_clust_read_tuple_create(cursor);
2417
2580
    ib_cursor_set_cluster_access(cursor);
2418
2581
  }
2419
2582
 
2420
 
  ib_err_t err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
 
2583
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2421
2584
  assert(err == DB_SUCCESS);
2422
2585
 
2423
2586
  advance_cursor= false;
2683
2846
      if (err == DB_END_OF_INDEX)
2684
2847
        return HA_ERR_END_OF_FILE;
2685
2848
      else
2686
 
        return -1; // FIXME
 
2849
        return ib_err_t_to_drizzle_error(err);
2687
2850
    }
2688
2851
  }
2689
2852