← 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-14 19:12:01 UTC
  • mfrom: (1994.2.2 build)
  • Revision ID: kalebral@gmail.com-20101214191201-h090vcfefa97eiv9
Merge Stewart - fix bug 655805 - HailDB Cursor not resetting this->cursor to clustered index after secondary index operations
Merge Andrew - fix bug 690083: Wrong results with regular expressions

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)
821
821
int HailDBCursor::open(const char *name, int, uint32_t)
822
822
{
823
823
  const char* haildb_table_name= table_path_to_haildb_name(name);
824
 
  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);
825
825
  bool has_hidden_primary_key= false;
826
826
  ib_id_t idx_id;
827
827
 
828
828
  if (err != DB_SUCCESS)
829
829
    return ib_err_t_to_drizzle_error(err);
830
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
 
831
837
  err= ib_index_get_id(haildb_table_name, "HIDDEN_PRIMARY", &idx_id);
832
838
 
833
839
  if (err == DB_SUCCESS)
1888
1894
 
1889
1895
  tuple= ib_clust_read_tuple_create(cursor);
1890
1896
 
1891
 
  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
  }
1892
1913
 
1893
1914
  err= ib_cursor_first(cursor);
1894
1915
  if (current_session->lex->sql_command == SQLCOM_CREATE_TABLE
2011
2032
  if (tuple == NULL)
2012
2033
  {
2013
2034
    ib_trx_t transaction= *get_trx(getTable()->in_use);
2014
 
    ib_cursor_attach_trx(cursor, transaction);
 
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
    }
2015
2051
 
2016
2052
    store_key_value_from_haildb(getTable()->key_info + getTable()->getShare()->getPrimaryKey(),
2017
2053
                                  ref, ref_length, old_data);
2057
2093
 
2058
2094
  advance_cursor= true;
2059
2095
 
2060
 
  if (err == DB_SUCCESS)
2061
 
    return 0;
2062
 
  else if (err == DB_DUPLICATE_KEY)
2063
 
    return HA_ERR_FOUND_DUPP_KEY;
2064
 
  else
2065
 
    return -1;
 
2096
  return ib_err_t_to_drizzle_error(err);
2066
2097
}
2067
2098
 
2068
2099
int HailDBCursor::doDeleteRecord(const unsigned char *)
2069
2100
{
2070
2101
  ib_err_t err;
2071
2102
 
 
2103
  assert(ib_cursor_is_positioned(cursor) == IB_TRUE);
2072
2104
  err= ib_cursor_delete_row(cursor);
2073
 
  if (err != DB_SUCCESS)
2074
 
    return -1; // FIXME
2075
2105
 
2076
2106
  advance_cursor= true;
2077
 
  return 0;
 
2107
 
 
2108
  return ib_err_t_to_drizzle_error(err);
2078
2109
}
2079
2110
 
2080
2111
int HailDBCursor::delete_all_rows(void)
2081
2112
{
2082
2113
  /* I *think* ib_truncate is non-transactional....
2083
2114
     so only support TRUNCATE and not DELETE FROM t;
2084
 
     (this is what ha_haildb does)
 
2115
     (this is what ha_innodb does)
2085
2116
  */
2086
2117
  if (session_sql_command(getTable()->in_use) != SQLCOM_TRUNCATE)
2087
2118
    return HA_ERR_WRONG_COMMAND;
2091
2122
 
2092
2123
  ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
2093
2124
 
2094
 
  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
  }
2095
2140
 
2096
2141
  err= ib_schema_lock_exclusive(transaction);
2097
2142
  if (err != DB_SUCCESS)
2127
2172
  ib_schema_unlock(transaction);
2128
2173
  ib_err_t rollback_err= ib_trx_rollback(transaction);
2129
2174
  assert(rollback_err == DB_SUCCESS);
2130
 
  return err;
 
2175
  return ib_err_t_to_drizzle_error(err);
2131
2176
}
2132
2177
 
2133
2178
int HailDBCursor::doStartTableScan(bool)
2134
2179
{
2135
 
  ib_err_t err;
 
2180
  ib_err_t err= DB_SUCCESS;
2136
2181
  ib_trx_t transaction;
2137
2182
 
2138
2183
  if (in_table_scan)
2143
2188
 
2144
2189
  assert(transaction != NULL);
2145
2190
 
2146
 
  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);
2147
2206
 
2148
2207
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2149
2208
  assert(err == DB_SUCCESS); // FIXME
2171
2230
 
2172
2231
  err= ib_cursor_read_row(cursor, tuple);
2173
2232
 
2174
 
  if (err != DB_SUCCESS) // FIXME
 
2233
  if (err == DB_RECORD_NOT_FOUND)
2175
2234
    return HA_ERR_END_OF_FILE;
 
2235
  if (err != DB_SUCCESS)
 
2236
    return ib_err_t_to_drizzle_error(err);
2176
2237
 
2177
2238
  int colnr= 0;
2178
2239
 
2183
2244
  for (Field **field= table->getFields() ; *field ; field++, colnr++)
2184
2245
  {
2185
2246
    if (! (**field).isReadSet())
2186
 
      continue;
 
2247
      (**field).setReadSet(); /* Fucking broken API screws us royally. */
2187
2248
 
2188
2249
    (**field).move_field_offset(row_offset);
2189
2250
 
2237
2298
 
2238
2299
    (**field).move_field_offset(-row_offset);
2239
2300
 
 
2301
    if (err != DB_SUCCESS)
 
2302
      return ib_err_t_to_drizzle_error(err);
2240
2303
  }
2241
2304
 
2242
2305
  if (has_hidden_primary_key)
2244
2307
    err= ib_tuple_read_u64(tuple, colnr, hidden_pkey);
2245
2308
  }
2246
2309
 
2247
 
  return 0;
 
2310
  return ib_err_t_to_drizzle_error(err);
2248
2311
}
2249
2312
 
2250
2313
int HailDBCursor::rnd_next(unsigned char *buf)
2256
2319
    return previous_error;
2257
2320
 
2258
2321
  if (advance_cursor)
 
2322
  {
2259
2323
    err= ib_cursor_next(cursor);
 
2324
    if (err != DB_SUCCESS)
 
2325
      return ib_err_t_to_drizzle_error(err);
 
2326
  }
2260
2327
 
2261
2328
  tuple= ib_tuple_clear(tuple);
2262
2329
  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
2277
2344
  assert(err == DB_SUCCESS);
2278
2345
  in_table_scan= false;
2279
2346
  previous_error= 0;
2280
 
  return 0;
 
2347
  return ib_err_t_to_drizzle_error(err);
2281
2348
}
2282
2349
 
2283
2350
int HailDBCursor::rnd_pos(unsigned char *buf, unsigned char *pos)
2291
2358
  {
2292
2359
    err= ib_col_set_value(search_tuple, 0,
2293
2360
                          ((uint64_t*)(pos)), sizeof(uint64_t));
 
2361
    if (err != DB_SUCCESS)
 
2362
      return ib_err_t_to_drizzle_error(err);
2294
2363
  }
2295
2364
  else
2296
2365
  {
2306
2375
  }
2307
2376
 
2308
2377
  err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
2309
 
  assert(err == DB_SUCCESS);
 
2378
  if (err != DB_SUCCESS)
 
2379
    return ib_err_t_to_drizzle_error(err);
2310
2380
 
2311
2381
  assert(res==0);
2312
2382
  if (res != 0)
2461
2531
 
2462
2532
int HailDBCursor::doStartIndexScan(uint32_t keynr, bool)
2463
2533
{
 
2534
  ib_err_t err;
2464
2535
  ib_trx_t transaction= *get_trx(getTable()->in_use);
2465
2536
 
2466
2537
  active_index= keynr;
2467
2538
 
2468
 
  ib_cursor_attach_trx(cursor, transaction);
2469
 
 
2470
2539
  if (active_index == 0 && ! share->has_hidden_primary_key)
2471
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;
2472
2558
    tuple= ib_clust_read_tuple_create(cursor);
2473
2559
  }
2474
2560
  else
2475
2561
  {
2476
 
    ib_err_t err;
2477
2562
    ib_id_t index_id;
2478
2563
    err= ib_index_get_id(table_path_to_haildb_name(getShare()->getPath()),
2479
2564
                         getShare()->getKeyInfo(keynr).name,
2480
2565
                         &index_id);
2481
2566
    if (err != DB_SUCCESS)
2482
 
      return -1;
 
2567
      return ib_err_t_to_drizzle_error(err);
2483
2568
 
2484
2569
    err= ib_cursor_close(cursor);
2485
2570
    assert(err == DB_SUCCESS);
 
2571
 
2486
2572
    err= ib_cursor_open_index_using_id(index_id, transaction, &cursor);
2487
2573
 
2488
2574
    if (err != DB_SUCCESS)
2489
 
      return -1;
 
2575
      return ib_err_t_to_drizzle_error(err);
 
2576
 
 
2577
    cursor_is_sec_index= true;
2490
2578
 
2491
2579
    tuple= ib_clust_read_tuple_create(cursor);
2492
2580
    ib_cursor_set_cluster_access(cursor);
2493
2581
  }
2494
2582
 
2495
 
  ib_err_t err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
 
2583
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
2496
2584
  assert(err == DB_SUCCESS);
2497
2585
 
2498
2586
  advance_cursor= false;
2758
2846
      if (err == DB_END_OF_INDEX)
2759
2847
        return HA_ERR_END_OF_FILE;
2760
2848
      else
2761
 
        return -1; // FIXME
 
2849
        return ib_err_t_to_drizzle_error(err);
2762
2850
    }
2763
2851
  }
2764
2852