← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_update.cc

  • Committer: Eric Herman
  • Date: 2008-12-06 19:42:46 UTC
  • mto: (656.1.6 devel)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: eric@mysql.com-20081206194246-5cdexuu81i366eek
removed trailing whitespace with simple script:

for file in $(find . -name "*.c") $(find . -name "*.cc") $(find . -name "*.h"); do ruby -pe 'gsub(/\s+$/, $/)' < $file > $file.out; mv $file.out $file; done;

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_update.cc
81
81
  uint32_t keynr;
82
82
  MY_BITMAP unique_map; /* Fields in offended unique. */
83
83
  my_bitmap_map unique_map_buf[bitmap_buffer_size(MAX_FIELDS)];
84
 
  
 
84
 
85
85
  /*
86
86
    Only duplicate key errors print the key value.
87
87
    If storage engine does always read all columns, we have the value alraedy.
175
175
  uint64_t     id;
176
176
  List<Item> all_fields;
177
177
  Session::killed_state killed_status= Session::NOT_KILLED;
178
 
  
 
178
 
179
179
  for ( ; ; )
180
180
  {
181
181
    if (open_tables(session, &table_list, &table_count, 0))
292
292
  table->mark_columns_needed_for_update();
293
293
 
294
294
  /* Check if we are modifying a key that we are used to search with */
295
 
  
 
295
 
296
296
  if (select && select->quick)
297
297
  {
298
298
    used_index= select->quick->index;
420
420
      limit= tmp_limit;
421
421
      table->file->try_semi_consistent_read(0);
422
422
      end_read_record(&info);
423
 
     
 
423
 
424
424
      /* Change select to use tempfile */
425
425
      if (select)
426
426
      {
447
447
 
448
448
  if (ignore)
449
449
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
450
 
  
 
450
 
451
451
  if (select && select->quick && select->quick->reset())
452
452
    goto err;
453
453
  table->file->try_semi_consistent_read(1);
506
506
 
507
507
            1) is covered by exec_bulk_update calls.
508
508
            2) and 3) is handled by the bulk_update_row method.
509
 
            
 
509
 
510
510
            bulk_update_row can execute the updates including the one
511
511
            defined in the bulk_update_row or not including the row
512
512
            in the call. This is up to the handler implementation and can
738
738
 
739
739
  session->lex->allow_sum_func= 0;
740
740
 
741
 
  if (setup_tables_and_check_access(session, &select_lex->context, 
 
741
  if (setup_tables_and_check_access(session, &select_lex->context,
742
742
                                    &select_lex->top_join_list,
743
743
                                    table_list,
744
744
                                    &select_lex->leaf_tables,
765
765
 
766
766
 
767
767
/***************************************************************************
768
 
  Update multiple tables from join 
 
768
  Update multiple tables from join
769
769
***************************************************************************/
770
770
 
771
771
/*
778
778
  Item_field *item;
779
779
  table_map map= 0;
780
780
 
781
 
  while ((item= (Item_field *) item_it++)) 
 
781
  while ((item= (Item_field *) item_it++))
782
782
    map|= item->used_tables();
783
783
  return map;
784
784
}
813
813
  const bool using_lock_tables= session->locked_tables != 0;
814
814
  bool original_multiupdate= (session->lex->sql_command == SQLCOM_UPDATE_MULTI);
815
815
  bool need_reopen= false;
816
 
  
 
816
 
817
817
 
818
818
  /* following need for prepared statements, to run next time multi-update */
819
819
  session->lex->sql_command= SQLCOM_UPDATE_MULTI;
933
933
    further check in multi_update::prepare whether to use record cache.
934
934
  */
935
935
  lex->select_lex.exclude_from_table_unique_test= false;
936
 
 
 
936
 
937
937
  if (session->fill_derived_tables() &&
938
938
      mysql_handle_derived(lex, &mysql_derived_filling))
939
939
    return(true);
957
957
{
958
958
  multi_update *result;
959
959
  bool res;
960
 
  
 
960
 
961
961
  if (!(result= new multi_update(table_list,
962
962
                                 session->lex->select_lex.leaf_tables,
963
963
                                 fields, values,
1016
1016
  List_iterator_fast<Item> value_it(*values);
1017
1017
  uint32_t i, max_fields;
1018
1018
  uint32_t leaf_table_count= 0;
1019
 
  
 
1019
 
1020
1020
  session->count_cuted_fields= CHECK_FIELD_WARN;
1021
1021
  session->cuted_fields=0L;
1022
1022
  session->set_proc_info("updating main table");
1182
1182
multi_update::initialize_tables(JOIN *join)
1183
1183
{
1184
1184
  TableList *table_ref;
1185
 
  
 
1185
 
1186
1186
  if ((session->options & OPTION_SAFE_UPDATES) && error_if_full_join(join))
1187
1187
    return(1);
1188
1188
  main_table=join->join_tab->table;
1464
1464
    if (do_update && table_count > 1)
1465
1465
    {
1466
1466
      /* Add warning here */
1467
 
      /* 
 
1467
      /*
1468
1468
         todo/fixme: do_update() is never called with the arg 1.
1469
1469
         should it change the signature to become argless?
1470
1470
      */
1501
1501
  ha_rows org_updated;
1502
1502
  Table *table, *tmp_table;
1503
1503
  List_iterator_fast<Table> check_opt_it(unupdated_check_opt_tables);
1504
 
  
 
1504
 
1505
1505
  do_update= 0;                                 // Don't retry this function
1506
1506
  if (!found)
1507
1507
    return(0);
1531
1531
      Setup copy functions to copy fields from temporary table
1532
1532
    */
1533
1533
    List_iterator_fast<Item> field_it(*fields_for_table[offset]);
1534
 
    Field **field= tmp_table->field + 
 
1534
    Field **field= tmp_table->field +
1535
1535
                   1 + unupdated_check_opt_tables.elements; // Skip row pointers
1536
1536
    Copy_field *copy_field_ptr= copy_field, *copy_field_end;
1537
1537
    for ( ; *field ; field++)
1656
1656
  char buff[STRING_BUFFER_USUAL_SIZE];
1657
1657
  uint64_t id;
1658
1658
  Session::killed_state killed_status= Session::NOT_KILLED;
1659
 
  
 
1659
 
1660
1660
  session->set_proc_info("updating reference tables");
1661
1661
 
1662
 
  /* 
 
1662
  /*
1663
1663
     Does updates for the last n - 1 tables, returns 0 if ok;
1664
1664
     error takes into account killed status gained in do_updates()
1665
1665
  */
1675
1675
    Write the SQL statement to the binlog if we updated
1676
1676
    rows and we succeeded or if we updated some non
1677
1677
    transactional tables.
1678
 
    
 
1678
 
1679
1679
    The query has to binlog because there's a modified non-transactional table
1680
1680
    either from the query's list or via a stored routine: bug#13270,23333
1681
1681
  */
1682
1682
 
1683
 
  assert(trans_safe || !updated || 
 
1683
  assert(trans_safe || !updated ||
1684
1684
              session->transaction.stmt.modified_non_trans_table);
1685
1685
  if (local_error == 0 || session->transaction.stmt.modified_non_trans_table)
1686
1686
  {