← 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-13 20:50:56 UTC
  • mfrom: (1993.2.3 build)
  • Revision ID: kalebral@gmail.com-20101213205056-rkzi5ve3hc0mpnws
Merge Andrew - fix bug 686773: TableFunction::Generator::push() needs assert
Merge Stewart - ON DUPLICATE KEY UPDATE support for HailDB
Merge Monty - fix bug 688819: drizzle fails to build from source in natty 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/haildb/haildb_engine.cc
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;
1778
1779
  return("BTREE");
1779
1780
}
1780
1781
 
1781
 
static ib_err_t write_row_to_haildb_tuple(Field **fields, ib_tpl_t tuple)
 
1782
static ib_err_t write_row_to_haildb_tuple(const unsigned char* buf,
 
1783
                                          Field **fields, ib_tpl_t tuple)
1782
1784
{
1783
1785
  int colnr= 0;
1784
1786
  ib_err_t err= DB_ERROR;
 
1787
  ptrdiff_t row_offset= buf - (*fields)->getTable()->getInsertRecord();
1785
1788
 
1786
1789
  for (Field **field= fields; *field; field++, colnr++)
1787
1790
  {
 
1791
    (**field).move_field_offset(row_offset);
 
1792
 
1788
1793
    if (! (**field).isWriteSet() && (**field).is_null())
 
1794
    {
 
1795
      (**field).move_field_offset(-row_offset);
1789
1796
      continue;
 
1797
    }
1790
1798
 
1791
1799
    if ((**field).is_null())
1792
1800
    {
1793
1801
      err= ib_col_set_value(tuple, colnr, NULL, IB_SQL_NULL);
1794
1802
      assert(err == DB_SUCCESS);
 
1803
      (**field).move_field_offset(-row_offset);
1795
1804
      continue;
1796
1805
    }
1797
1806
 
1829
1838
    }
1830
1839
 
1831
1840
    assert (err == DB_SUCCESS);
 
1841
 
 
1842
    (**field).move_field_offset(-row_offset);
1832
1843
  }
1833
1844
 
1834
1845
  return err;
1936
1947
 
1937
1948
  }
1938
1949
 
1939
 
  write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
1950
  write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
1940
1951
 
1941
1952
  if (share->has_hidden_primary_key)
1942
1953
  {
1969
1980
      err= ib_cursor_first(cursor);
1970
1981
      assert(err == DB_SUCCESS || err == DB_END_OF_INDEX);
1971
1982
 
1972
 
      write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
1983
      write_row_to_haildb_tuple(record, getTable()->getFields(), tuple);
1973
1984
 
1974
1985
      err= ib_cursor_insert_row(cursor, tuple);
1975
1986
      assert(err==DB_SUCCESS); // probably be nice and process errors
1982
1993
 
1983
1994
  tuple= ib_tuple_clear(tuple);
1984
1995
  ib_tuple_delete(tuple);
 
1996
  tuple= NULL;
1985
1997
  err= ib_cursor_reset(cursor);
1986
1998
 
1987
1999
  return ret;
1988
2000
}
1989
2001
 
1990
 
int HailDBCursor::doUpdateRecord(const unsigned char *,
1991
 
                                         unsigned char *)
 
2002
int HailDBCursor::doUpdateRecord(const unsigned char *old_data,
 
2003
                                 unsigned char *new_data)
1992
2004
{
1993
2005
  ib_tpl_t update_tuple;
1994
2006
  ib_err_t err;
 
2007
  bool created_tuple= false;
1995
2008
 
1996
2009
  update_tuple= ib_clust_read_tuple_create(cursor);
1997
2010
 
 
2011
  if (tuple == NULL)
 
2012
  {
 
2013
    ib_trx_t transaction= *get_trx(getTable()->in_use);
 
2014
    ib_cursor_attach_trx(cursor, transaction);
 
2015
 
 
2016
    store_key_value_from_haildb(getTable()->key_info + getTable()->getShare()->getPrimaryKey(),
 
2017
                                  ref, ref_length, old_data);
 
2018
 
 
2019
    ib_tpl_t search_tuple= ib_clust_search_tuple_create(cursor);
 
2020
 
 
2021
    fill_ib_search_tpl_from_drizzle_key(search_tuple,
 
2022
                                        getTable()->key_info + 0,
 
2023
                                        ref, ref_length);
 
2024
 
 
2025
    err= ib_cursor_set_lock_mode(cursor, IB_LOCK_X);
 
2026
    assert(err == DB_SUCCESS);
 
2027
 
 
2028
    int res;
 
2029
    err= ib_cursor_moveto(cursor, search_tuple, IB_CUR_GE, &res);
 
2030
    assert(err == DB_SUCCESS);
 
2031
 
 
2032
    tuple= ib_clust_read_tuple_create(cursor);
 
2033
 
 
2034
    err= ib_cursor_read_row(cursor, tuple);
 
2035
    assert(err == DB_SUCCESS);// FIXME
 
2036
 
 
2037
    created_tuple= true;
 
2038
  }
 
2039
 
1998
2040
  err= ib_tuple_copy(update_tuple, tuple);
1999
2041
  assert(err == DB_SUCCESS);
2000
2042
 
2001
 
  write_row_to_haildb_tuple(getTable()->getFields(), update_tuple);
 
2043
  write_row_to_haildb_tuple(new_data, getTable()->getFields(), update_tuple);
2002
2044
 
2003
2045
  err= ib_cursor_update_row(cursor, tuple, update_tuple);
2004
2046
 
2005
2047
  ib_tuple_delete(update_tuple);
2006
2048
 
 
2049
  if (created_tuple)
 
2050
  {
 
2051
    ib_err_t ib_err= ib_cursor_reset(cursor); //fixme check error
 
2052
    assert(ib_err == DB_SUCCESS);
 
2053
    tuple= ib_tuple_clear(tuple);
 
2054
    ib_tuple_delete(tuple);
 
2055
    tuple= NULL;
 
2056
  }
 
2057
 
2007
2058
  advance_cursor= true;
2008
2059
 
2009
2060
  if (err == DB_SUCCESS)
2142
2193
    if (length == IB_SQL_NULL)
2143
2194
    {
2144
2195
      (**field).set_null();
 
2196
      (**field).move_field_offset(-row_offset);
2145
2197
      continue;
2146
2198
    }
2147
2199
    else
2220
2272
  ib_err_t err;
2221
2273
 
2222
2274
  ib_tuple_delete(tuple);
 
2275
  tuple= NULL;
2223
2276
  err= ib_cursor_reset(cursor);
2224
2277
  assert(err == DB_SUCCESS);
2225
2278
  in_table_scan= false;
2381
2434
 
2382
2435
  if (flag & HA_STATUS_AUTO)
2383
2436
    stats.auto_increment_value= 1;
 
2437
 
 
2438
  if (flag & HA_STATUS_ERRKEY) {
 
2439
    const char *err_table_name;
 
2440
    const char *err_index_name;
 
2441
 
 
2442
    ib_trx_t transaction= *get_trx(getTable()->in_use);
 
2443
 
 
2444
    err= ib_get_duplicate_key(transaction, &err_table_name, &err_index_name);
 
2445
 
 
2446
    errkey= -1;
 
2447
 
 
2448
    for (unsigned int i = 0; i < getTable()->getShare()->keys; i++)
 
2449
    {
 
2450
      if (strcmp(err_index_name, getTable()->key_info[i].name) == 0)
 
2451
      {
 
2452
        errkey= i;
 
2453
        break;
 
2454
      }
 
2455
    }
 
2456
 
 
2457
  }
 
2458
 
2384
2459
  return(0);
2385
2460
}
2386
2461