← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_update.cc

Merged Padraig.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_update.cc
26
26
#include <drizzled/field/timestamp.h>
27
27
 
28
28
#include <bitset>
 
29
#include <list>
29
30
 
30
31
using namespace std;
31
32
 
984
985
                           List<Item> *field_list, List<Item> *value_list,
985
986
                           enum enum_duplicates handle_duplicates_arg,
986
987
                           bool ignore_arg)
987
 
  :all_tables(table_list), leaves(leaves_list), update_tables(0),
 
988
  :all_tables(table_list), leaves(leaves_list),
988
989
   tmp_tables(0), updated(0), found(0), fields(field_list),
989
990
   values(value_list), table_count(0), copy_field(0),
990
991
   handle_duplicates(handle_duplicates_arg), do_update(1), trans_safe(1),
1000
1001
                          Select_Lex_Unit *)
1001
1002
{
1002
1003
  TableList *table_ref;
1003
 
  SQL_LIST update;
1004
1004
  table_map tables_to_update;
1005
1005
  Item_field *item;
1006
1006
  List_iterator_fast<Item> field_it(*fields);
1033
1033
    update_table->shared is position for table
1034
1034
    Don't use key read on tables that are updated
1035
1035
  */
1036
 
 
1037
 
  update.empty();
1038
1036
  for (table_ref= leaves; table_ref; table_ref= table_ref->next_leaf)
1039
1037
  {
1040
1038
    /* TODO: add support of view of join support */
1046
1044
                                                sizeof(*tl));
1047
1045
      if (!tl)
1048
1046
        return(1);
1049
 
      update.link_in_list((unsigned char*) tl, (unsigned char**) &tl->next_local);
 
1047
      update_tables.push_back(tl);
1050
1048
      tl->shared= table_count++;
1051
1049
      table->no_keyread=1;
1052
1050
      table->covering_keys.reset();
1055
1053
  }
1056
1054
 
1057
1055
 
1058
 
  table_count=  update.elements;
1059
 
  update_tables= (TableList*) update.first;
 
1056
  table_count=  update_tables.size();
1060
1057
 
1061
1058
  tmp_tables = (Table**) session->calloc(sizeof(Table *) * table_count);
1062
1059
  tmp_table_param = (Tmp_Table_Param*) session->calloc(sizeof(Tmp_Table_Param) *
1172
1169
bool
1173
1170
multi_update::initialize_tables(JOIN *join)
1174
1171
{
1175
 
  TableList *table_ref;
1176
 
 
1177
1172
  if ((session->options & OPTION_SAFE_UPDATES) && error_if_full_join(join))
1178
1173
    return(1);
1179
1174
  main_table=join->join_tab->table;
1183
1178
  assert(fields->elements);
1184
1179
 
1185
1180
  /* Create a temporary table for keys to all tables, except main table */
1186
 
  for (table_ref= update_tables; table_ref; table_ref= table_ref->next_local)
 
1181
  for (list<TableList*>::iterator it= update_tables.begin(); 
 
1182
       it != update_tables.end(); 
 
1183
       ++it)
1187
1184
  {
1188
 
    Table *table=table_ref->table;
1189
 
    uint32_t cnt= table_ref->shared;
 
1185
    Table *table= (*it)->table;
 
1186
    uint32_t cnt= (*it)->shared;
1190
1187
    List<Item> temp_fields;
1191
1188
    order_st     group;
1192
1189
    Tmp_Table_Param *tmp_param;
1196
1193
      table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1197
1194
    if (table == main_table)                    // First table in join
1198
1195
    {
1199
 
      if (safe_update_on_fly(session, join->join_tab, table_ref, all_tables))
 
1196
      if (safe_update_on_fly(session, join->join_tab, (*it), all_tables))
1200
1197
      {
1201
1198
        table_to_update= main_table;            // Update table on the fly
1202
1199
        continue;
1263
1260
multi_update::~multi_update()
1264
1261
{
1265
1262
  TableList *table;
1266
 
  for (table= update_tables ; table; table= table->next_local)
 
1263
  for (list<TableList*>::iterator it= update_tables.begin(); 
 
1264
       it != update_tables.end(); 
 
1265
       ++it)
1267
1266
  {
 
1267
    table= *it;
1268
1268
    table->table->no_keyread= table->table->no_cache= 0;
1269
1269
    if (ignore)
1270
1270
      table->table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1291
1291
 
1292
1292
bool multi_update::send_data(List<Item> &)
1293
1293
{
1294
 
  TableList *cur_table;
1295
 
 
1296
 
  for (cur_table= update_tables; cur_table; cur_table= cur_table->next_local)
 
1294
  for (list<TableList*>::iterator it= update_tables.begin(); 
 
1295
       it != update_tables.end(); 
 
1296
       ++it)
1297
1297
  {
1298
 
    Table *table= cur_table->table;
1299
 
    uint32_t offset= cur_table->shared;
 
1298
    Table *table= (*it)->table;
 
1299
    uint32_t offset= (*it)->shared;
1300
1300
    /*
1301
1301
      Check if we are using outer join and we didn't find the row
1302
1302
      or if we have already updated this row in the previous call to this
1480
1480
  do_update= 0;                                 // Don't retry this function
1481
1481
  if (!found)
1482
1482
    return(0);
1483
 
  for (cur_table= update_tables; cur_table; cur_table= cur_table->next_local)
 
1483
  for (list<TableList*>::iterator it= update_tables.begin(); 
 
1484
       it != update_tables.end(); 
 
1485
       ++it)
1484
1486
  {
 
1487
    cur_table= *it;
1485
1488
    bool can_compare_record;
1486
1489
    uint32_t offset= cur_table->shared;
1487
1490
 
1593
1596
    check_opt_it.rewind();
1594
1597
    while (Table *tbl= check_opt_it++)
1595
1598
        tbl->file->ha_rnd_end();
1596
 
 
1597
1599
  }
1598
1600
  return(0);
1599
1601