← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_delete.cc

  • Committer: Monty Taylor
  • Date: 2008-10-23 00:05:28 UTC
  • Revision ID: monty@inaugust.com-20081023000528-grdvrd8c4058nutm
Moved my_handler to myisam, which is where it actually belongs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_delete.cc
18
18
 
19
19
  Multi-table deletes were introduced by Monty and Sinisa
20
20
*/
21
 
#include "config.h"
22
 
#include "drizzled/sql_select.h"
23
 
#include "drizzled/error.h"
24
 
#include "drizzled/probes.h"
25
 
#include "drizzled/sql_parse.h"
26
 
#include "drizzled/sql_base.h"
27
 
#include "drizzled/lock.h"
28
 
#include "drizzled/probes.h"
29
 
#include "drizzled/optimizer/range.h"
30
 
#include "drizzled/records.h"
31
 
#include "drizzled/internal/iocache.h"
32
 
#include "drizzled/transaction_services.h"
33
 
 
34
 
namespace drizzled
35
 
{
 
21
#include <drizzled/server_includes.h>
 
22
#include <drizzled/sql_select.h>
 
23
#include <drizzled/drizzled_error_messages.h>
36
24
 
37
25
/**
38
26
  Implement DELETE SQL word.
43
31
*/
44
32
 
45
33
bool mysql_delete(Session *session, TableList *table_list, COND *conds,
46
 
                  SQL_LIST *order, ha_rows limit, uint64_t,
 
34
                  SQL_LIST *order, ha_rows limit, uint64_t options,
47
35
                  bool reset_auto_increment)
48
36
{
49
 
  int           error;
 
37
  bool          will_batch;
 
38
  int           error, loc_error;
50
39
  Table         *table;
51
 
  optimizer::SqlSelect *select= NULL;
52
 
  ReadRecord    info;
 
40
  SQL_SELECT    *select=0;
 
41
  READ_RECORD   info;
53
42
  bool          using_limit=limit != HA_POS_ERROR;
54
 
  bool          transactional_table, const_cond;
 
43
  bool          transactional_table, safe_update, const_cond;
55
44
  bool          const_cond_result;
56
45
  ha_rows       deleted= 0;
57
46
  uint32_t usable_index= MAX_KEY;
58
 
  Select_Lex   *select_lex= &session->lex->select_lex;
 
47
  SELECT_LEX   *select_lex= &session->lex->select_lex;
59
48
  Session::killed_state killed_status= Session::NOT_KILLED;
 
49
  
60
50
 
61
 
  if (session->openTablesLock(table_list))
 
51
  if (open_and_lock_tables(session, table_list))
 
52
    return(true);
 
53
  /* TODO look at this error */
 
54
  if (!(table= table_list->table))
62
55
  {
63
 
    DRIZZLE_DELETE_DONE(1, 0);
64
 
    return true;
 
56
    my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0), "", "");
 
57
    return(true);
65
58
  }
66
 
 
67
 
  table= table_list->table;
68
 
  assert(table);
69
 
 
70
59
  session->set_proc_info("init");
71
60
  table->map=1;
72
61
 
80
69
    List<Item>   fields;
81
70
    List<Item>   all_fields;
82
71
 
 
72
    memset(&tables, 0, sizeof(tables));
83
73
    tables.table = table;
84
74
    tables.alias = table_list->alias;
85
75
 
94
84
  }
95
85
 
96
86
  const_cond= (!conds || conds->const_item());
 
87
  safe_update=test(session->options & OPTION_SAFE_UPDATES);
 
88
  if (safe_update && const_cond)
 
89
  {
 
90
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
 
91
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
 
92
    goto err;
 
93
  }
97
94
 
98
95
  select_lex->no_error= session->lex->ignore;
99
96
 
123
120
      - We should not be binlogging this statement row-based, and
124
121
      - there should be no delete triggers associated with the table.
125
122
  */
126
 
  if (!using_limit && const_cond_result)
 
123
  if (!using_limit && const_cond_result &&
 
124
      (session->lex->sql_command == SQLCOM_TRUNCATE ||
 
125
       (!session->current_stmt_binlog_row_based)))
127
126
  {
128
 
    /* Update the table->cursor->stats.records number */
129
 
    table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
130
 
    ha_rows const maybe_deleted= table->cursor->stats.records;
131
 
    if (!(error=table->cursor->ha_delete_all_rows()))
 
127
    /* Update the table->file->stats.records number */
 
128
    table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
129
    ha_rows const maybe_deleted= table->file->stats.records;
 
130
    if (!(error=table->file->ha_delete_all_rows()))
132
131
    {
133
132
      error= -1;                                // ok
134
133
      deleted= maybe_deleted;
136
135
    }
137
136
    if (error != HA_ERR_WRONG_COMMAND)
138
137
    {
139
 
      table->print_error(error,MYF(0));
 
138
      table->file->print_error(error,MYF(0));
140
139
      error=0;
141
140
      goto cleanup;
142
141
    }
150
149
      limit= 0;
151
150
  }
152
151
 
153
 
  /* Update the table->cursor->stats.records number */
154
 
  table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
152
  /* Update the table->file->stats.records number */
 
153
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
155
154
 
156
 
  table->covering_keys.reset();
157
 
  table->quick_keys.reset();            // Can't use 'only index'
158
 
  select= optimizer::make_select(table, 0, 0, conds, 0, &error);
 
155
  table->covering_keys.clear_all();
 
156
  table->quick_keys.clear_all();                // Can't use 'only index'
 
157
  select=make_select(table, 0, 0, conds, 0, &error);
159
158
  if (error)
160
159
    goto err;
161
 
  if ((select && select->check_quick(session, false, limit)) || !limit)
 
160
  if ((select && select->check_quick(session, safe_update, limit)) || !limit)
162
161
  {
163
162
    delete select;
164
163
    free_underlaid_joins(session, select_lex);
165
164
    session->row_count_func= 0;
166
 
    DRIZZLE_DELETE_DONE(0, 0);
167
 
    /**
168
 
     * Resetting the Diagnostic area to prevent
169
 
     * lp bug# 439719
170
 
     */
171
 
    session->main_da.reset_diagnostics_area();
172
 
    session->my_ok((ha_rows) session->row_count_func);
 
165
    DRIZZLE_DELETE_END();
 
166
    my_ok(session, (ha_rows) session->row_count_func);
173
167
    /*
174
168
      We don't need to call reset_auto_increment in this case, because
175
169
      mysql_truncate always gives a NULL conds argument, hence we never
176
170
      get here.
177
171
    */
178
 
    return 0; // Nothing to delete
 
172
    return(0);                          // Nothing to delete
179
173
  }
180
174
 
181
175
  /* If running in safe sql mode, don't allow updates without keys */
182
 
  if (table->quick_keys.none())
 
176
  if (table->quick_keys.is_clear_all())
183
177
  {
184
178
    session->server_status|=SERVER_QUERY_NO_INDEX_USED;
 
179
    if (safe_update && !using_limit)
 
180
    {
 
181
      delete select;
 
182
      free_underlaid_joins(session, select_lex);
 
183
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
 
184
                 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
 
185
      goto err;
 
186
    }
185
187
  }
 
188
  if (options & OPTION_QUICK)
 
189
    (void) table->file->extra(HA_EXTRA_QUICK);
186
190
 
187
191
  if (order && order->elements)
188
192
  {
189
193
    uint32_t         length= 0;
190
 
    SortField  *sortorder;
 
194
    SORT_FIELD  *sortorder;
191
195
    ha_rows examined_rows;
192
 
 
193
 
    if ((!select || table->quick_keys.none()) && limit != HA_POS_ERROR)
194
 
      usable_index= optimizer::get_index_for_order(table, (order_st*)(order->first), limit);
 
196
    
 
197
    if ((!select || table->quick_keys.is_clear_all()) && limit != HA_POS_ERROR)
 
198
      usable_index= get_index_for_order(table, (order_st*)(order->first), limit);
195
199
 
196
200
    if (usable_index == MAX_KEY)
197
201
    {
198
 
      table->sort.io_cache= new internal::IO_CACHE;
199
 
 
200
 
 
 
202
      table->sort.io_cache= (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
 
203
                                                   MYF(MY_FAE | MY_ZEROFILL));
 
204
    
201
205
      if (!(sortorder= make_unireg_sortorder((order_st*) order->first,
202
206
                                             &length, NULL)) ||
203
207
          (table->sort.found_records = filesort(session, table, sortorder, length,
226
230
    free_underlaid_joins(session, select_lex);
227
231
    goto err;
228
232
  }
229
 
 
230
233
  if (usable_index==MAX_KEY)
231
 
  {
232
 
    info.init_read_record(session,table,select,1,1);
233
 
  }
 
234
    init_read_record(&info,session,table,select,1,1);
234
235
  else
235
 
  {
236
 
    info.init_read_record_idx(session, table, 1, usable_index);
237
 
  }
 
236
    init_read_record_idx(&info, session, table, 1, usable_index);
238
237
 
239
238
  session->set_proc_info("updating");
240
239
 
 
240
  will_batch= !table->file->start_bulk_delete();
 
241
 
 
242
 
241
243
  table->mark_columns_needed_for_delete();
242
244
 
243
245
  while (!(error=info.read_record(&info)) && !session->killed &&
246
248
    // session->is_error() is tested to disallow delete row on error
247
249
    if (!(select && select->skip_record())&& ! session->is_error() )
248
250
    {
249
 
      if (!(error= table->cursor->deleteRecord(table->getInsertRecord())))
 
251
      if (!(error= table->file->ha_delete_row(table->record[0])))
250
252
      {
251
253
        deleted++;
252
254
        if (!--limit && using_limit)
257
259
      }
258
260
      else
259
261
      {
260
 
        table->print_error(error,MYF(0));
 
262
        table->file->print_error(error,MYF(0));
261
263
        /*
262
264
          In < 4.0.14 we set the error number to 0 here, but that
263
265
          was not sensible, because then MySQL would not roll back the
271
273
      }
272
274
    }
273
275
    else
274
 
      table->cursor->unlock_row();  // Row failed selection, release lock on it
 
276
      table->file->unlock_row();  // Row failed selection, release lock on it
275
277
  }
276
278
  killed_status= session->killed;
277
279
  if (killed_status != Session::NOT_KILLED || session->is_error())
278
280
    error= 1;                                   // Aborted
279
 
 
 
281
  if (will_batch && (loc_error= table->file->end_bulk_delete()))
 
282
  {
 
283
    if (error != 1)
 
284
      table->file->print_error(loc_error,MYF(0));
 
285
    error=1;
 
286
  }
280
287
  session->set_proc_info("end");
281
 
  info.end_read_record();
282
 
 
283
 
cleanup:
 
288
  end_read_record(&info);
 
289
  if (options & OPTION_QUICK)
 
290
    (void) table->file->extra(HA_EXTRA_NORMAL);
284
291
 
285
292
  if (reset_auto_increment && (error < 0))
286
293
  {
288
295
      We're really doing a truncate and need to reset the table's
289
296
      auto-increment counter.
290
297
    */
291
 
    int error2= table->cursor->ha_reset_auto_increment(0);
 
298
    int error2= table->file->ha_reset_auto_increment(0);
292
299
 
293
300
    if (error2 && (error2 != HA_ERR_WRONG_COMMAND))
294
301
    {
295
 
      table->print_error(error2, MYF(0));
 
302
      table->file->print_error(error2, MYF(0));
296
303
      error= 1;
297
304
    }
298
305
  }
299
306
 
 
307
cleanup:
 
308
 
300
309
  delete select;
301
 
  transactional_table= table->cursor->has_transactions();
 
310
  transactional_table= table->file->has_transactions();
302
311
 
303
312
  if (!transactional_table && deleted > 0)
304
 
    session->transaction.stmt.markModifiedNonTransData();
305
 
 
 
313
    session->transaction.stmt.modified_non_trans_table= true;
 
314
  
306
315
  /* See similar binlogging code in sql_update.cc, for comments */
307
 
  if ((error < 0) || session->transaction.stmt.hasModifiedNonTransData())
 
316
  if ((error < 0) || session->transaction.stmt.modified_non_trans_table)
308
317
  {
309
 
    if (session->transaction.stmt.hasModifiedNonTransData())
310
 
      session->transaction.all.markModifiedNonTransData();
 
318
    if (mysql_bin_log.is_open())
 
319
    {
 
320
      if (error < 0)
 
321
        session->clear_error();
 
322
      /*
 
323
        [binlog]: If 'handler::delete_all_rows()' was called and the
 
324
        storage engine does not inject the rows itself, we replicate
 
325
        statement-based; otherwise, 'ha_delete_row()' was used to
 
326
        delete specific rows which we might log row-based.
 
327
      */
 
328
      int log_result= session->binlog_query(Session::ROW_QUERY_TYPE,
 
329
                                        session->query, session->query_length,
 
330
                                        transactional_table, false, killed_status);
 
331
 
 
332
      if (log_result && transactional_table)
 
333
      {
 
334
        error=1;
 
335
      }
 
336
    }
 
337
    if (session->transaction.stmt.modified_non_trans_table)
 
338
      session->transaction.all.modified_non_trans_table= true;
311
339
  }
312
 
  assert(transactional_table || !deleted || session->transaction.stmt.hasModifiedNonTransData());
 
340
  assert(transactional_table || !deleted || session->transaction.stmt.modified_non_trans_table);
313
341
  free_underlaid_joins(session, select_lex);
314
342
 
315
 
  DRIZZLE_DELETE_DONE((error >= 0 || session->is_error()), deleted);
 
343
  DRIZZLE_DELETE_END();
316
344
  if (error < 0 || (session->lex->ignore && !session->is_fatal_error))
317
345
  {
318
346
    session->row_count_func= deleted;
319
 
    /**
320
 
     * Resetting the Diagnostic area to prevent
321
 
     * lp bug# 439719
322
 
     */
323
 
    session->main_da.reset_diagnostics_area();    
324
 
    session->my_ok((ha_rows) session->row_count_func);
 
347
    my_ok(session, (ha_rows) session->row_count_func);
325
348
  }
326
 
  session->status_var.deleted_row_count+= deleted;
327
 
  return (error >= 0 || session->is_error());
 
349
  return(error >= 0 || session->is_error());
328
350
 
329
351
err:
330
 
  DRIZZLE_DELETE_DONE(1, 0);
331
 
  return true;
 
352
  DRIZZLE_DELETE_END();
 
353
  return(true);
332
354
}
333
355
 
334
356
 
347
369
*/
348
370
int mysql_prepare_delete(Session *session, TableList *table_list, Item **conds)
349
371
{
350
 
  Select_Lex *select_lex= &session->lex->select_lex;
351
 
 
 
372
  SELECT_LEX *select_lex= &session->lex->select_lex;
 
373
  
352
374
  List<Item> all_fields;
353
375
 
 
376
  /*
 
377
    Statement-based replication of DELETE ... LIMIT is not safe as order of
 
378
    rows is not defined, so in mixed mode we go to row-based.
 
379
 
 
380
    Note that we may consider a statement as safe if ORDER BY primary_key
 
381
    is present. However it may confuse users to see very similiar statements
 
382
    replicated differently.
 
383
  */
 
384
  if (session->lex->current_select->select_limit)
 
385
  {
 
386
    session->lex->set_stmt_unsafe();
 
387
    session->set_current_stmt_binlog_row_based_if_mixed();
 
388
  }
354
389
  session->lex->allow_sum_func= 0;
355
390
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
356
391
                                    &session->lex->select_lex.top_join_list,
357
 
                                    table_list,
 
392
                                    table_list, 
358
393
                                    &select_lex->leaf_tables, false) ||
359
 
      session->setup_conds(table_list, conds))
 
394
      setup_conds(session, table_list, select_lex->leaf_tables, conds))
360
395
    return(true);
361
396
  {
362
397
    TableList *duplicate;
363
 
    if ((duplicate= unique_table(table_list, table_list->next_global)))
 
398
    if ((duplicate= unique_table(session, table_list, table_list->next_global, 0)))
364
399
    {
365
 
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
 
400
      update_non_unique_table_error(table_list, "DELETE", duplicate);
366
401
      return(true);
367
402
    }
368
403
  }
376
411
 
377
412
 
378
413
/***************************************************************************
 
414
  Delete multiple tables from join 
 
415
***************************************************************************/
 
416
 
 
417
#define MEM_STRIP_BUF_SIZE current_session->variables.sortbuff_size
 
418
 
 
419
extern "C" int refpos_order_cmp(void* arg, const void *a,const void *b)
 
420
{
 
421
  handler *file= (handler*)arg;
 
422
  return file->cmp_ref((const unsigned char*)a, (const unsigned char*)b);
 
423
}
 
424
 
 
425
/*
 
426
  make delete specific preparation and checks after opening tables
 
427
 
 
428
  SYNOPSIS
 
429
    mysql_multi_delete_prepare()
 
430
    session         thread handler
 
431
 
 
432
  RETURN
 
433
    false OK
 
434
    true  Error
 
435
*/
 
436
 
 
437
int mysql_multi_delete_prepare(Session *session)
 
438
{
 
439
  LEX *lex= session->lex;
 
440
  TableList *aux_tables= (TableList *)lex->auxiliary_table_list.first;
 
441
  TableList *target_tbl;
 
442
  
 
443
 
 
444
  /*
 
445
    setup_tables() need for VIEWs. JOIN::prepare() will not do it second
 
446
    time.
 
447
 
 
448
    lex->query_tables also point on local list of DELETE SELECT_LEX
 
449
  */
 
450
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
 
451
                                    &session->lex->select_lex.top_join_list,
 
452
                                    lex->query_tables,
 
453
                                    &lex->select_lex.leaf_tables, false))
 
454
    return(true);
 
455
 
 
456
 
 
457
  /*
 
458
    Multi-delete can't be constructed over-union => we always have
 
459
    single SELECT on top and have to check underlying SELECTs of it
 
460
  */
 
461
  lex->select_lex.exclude_from_table_unique_test= true;
 
462
  /* Fix tables-to-be-deleted-from list to point at opened tables */
 
463
  for (target_tbl= (TableList*) aux_tables;
 
464
       target_tbl;
 
465
       target_tbl= target_tbl->next_local)
 
466
  {
 
467
    if (!(target_tbl->table= target_tbl->correspondent_table->table))
 
468
    {
 
469
      assert(target_tbl->correspondent_table->merge_underlying_list &&
 
470
                  target_tbl->correspondent_table->merge_underlying_list->
 
471
                  next_local);
 
472
      my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0), "", "");
 
473
      return(true);
 
474
    }
 
475
 
 
476
    /*
 
477
      Check that table from which we delete is not used somewhere
 
478
      inside subqueries/view.
 
479
    */
 
480
    {
 
481
      TableList *duplicate;
 
482
      if ((duplicate= unique_table(session, target_tbl->correspondent_table,
 
483
                                   lex->query_tables, 0)))
 
484
      {
 
485
        update_non_unique_table_error(target_tbl->correspondent_table,
 
486
                                      "DELETE", duplicate);
 
487
        return(true);
 
488
      }
 
489
    }
 
490
  }
 
491
  return(false);
 
492
}
 
493
 
 
494
 
 
495
multi_delete::multi_delete(TableList *dt, uint32_t num_of_tables_arg)
 
496
  : delete_tables(dt), deleted(0), found(0),
 
497
    num_of_tables(num_of_tables_arg), error(0),
 
498
    do_delete(0), transactional_tables(0), normal_tables(0), error_handled(0)
 
499
{
 
500
  tempfiles= (Unique **) sql_calloc(sizeof(Unique *) * num_of_tables);
 
501
}
 
502
 
 
503
 
 
504
int
 
505
multi_delete::prepare(List<Item> &values __attribute__((unused)),
 
506
                      SELECT_LEX_UNIT *u)
 
507
{
 
508
  
 
509
  unit= u;
 
510
  do_delete= 1;
 
511
  session->set_proc_info("deleting from main table");
 
512
  return(0);
 
513
}
 
514
 
 
515
 
 
516
bool
 
517
multi_delete::initialize_tables(JOIN *join)
 
518
{
 
519
  TableList *walk;
 
520
  Unique **tempfiles_ptr;
 
521
  
 
522
 
 
523
  if ((session->options & OPTION_SAFE_UPDATES) && error_if_full_join(join))
 
524
    return(1);
 
525
 
 
526
  table_map tables_to_delete_from=0;
 
527
  for (walk= delete_tables; walk; walk= walk->next_local)
 
528
    tables_to_delete_from|= walk->table->map;
 
529
 
 
530
  walk= delete_tables;
 
531
  delete_while_scanning= 1;
 
532
  for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;
 
533
       tab < end;
 
534
       tab++)
 
535
  {
 
536
    if (tab->table->map & tables_to_delete_from)
 
537
    {
 
538
      /* We are going to delete from this table */
 
539
      Table *tbl=walk->table=tab->table;
 
540
      walk= walk->next_local;
 
541
      /* Don't use KEYREAD optimization on this table */
 
542
      tbl->no_keyread=1;
 
543
      /* Don't use record cache */
 
544
      tbl->no_cache= 1;
 
545
      tbl->covering_keys.clear_all();
 
546
      if (tbl->file->has_transactions())
 
547
        transactional_tables= 1;
 
548
      else
 
549
        normal_tables= 1;
 
550
      tbl->prepare_for_position();
 
551
      tbl->mark_columns_needed_for_delete();
 
552
    }
 
553
    else if ((tab->type != JT_SYSTEM && tab->type != JT_CONST) &&
 
554
             walk == delete_tables)
 
555
    {
 
556
      /*
 
557
        We are not deleting from the table we are scanning. In this
 
558
        case send_data() shouldn't delete any rows a we may touch
 
559
        the rows in the deleted table many times
 
560
      */
 
561
      delete_while_scanning= 0;
 
562
    }
 
563
  }
 
564
  walk= delete_tables;
 
565
  tempfiles_ptr= tempfiles;
 
566
  if (delete_while_scanning)
 
567
  {
 
568
    table_being_deleted= delete_tables;
 
569
    walk= walk->next_local;
 
570
  }
 
571
  for (;walk ;walk= walk->next_local)
 
572
  {
 
573
    Table *table=walk->table;
 
574
    *tempfiles_ptr++= new Unique (refpos_order_cmp,
 
575
                                  (void *) table->file,
 
576
                                  table->file->ref_length,
 
577
                                  MEM_STRIP_BUF_SIZE);
 
578
  }
 
579
  return(session->is_fatal_error != 0);
 
580
}
 
581
 
 
582
 
 
583
multi_delete::~multi_delete()
 
584
{
 
585
  for (table_being_deleted= delete_tables;
 
586
       table_being_deleted;
 
587
       table_being_deleted= table_being_deleted->next_local)
 
588
  {
 
589
    Table *table= table_being_deleted->table;
 
590
    table->no_keyread=0;
 
591
  }
 
592
 
 
593
  for (uint32_t counter= 0; counter < num_of_tables; counter++)
 
594
  {
 
595
    if (tempfiles[counter])
 
596
      delete tempfiles[counter];
 
597
  }
 
598
}
 
599
 
 
600
 
 
601
bool multi_delete::send_data(List<Item> &values __attribute__((unused)))
 
602
{
 
603
  int secure_counter= delete_while_scanning ? -1 : 0;
 
604
  TableList *del_table;
 
605
  
 
606
 
 
607
  for (del_table= delete_tables;
 
608
       del_table;
 
609
       del_table= del_table->next_local, secure_counter++)
 
610
  {
 
611
    Table *table= del_table->table;
 
612
 
 
613
    /* Check if we are using outer join and we didn't find the row */
 
614
    if (table->status & (STATUS_NULL_ROW | STATUS_DELETED))
 
615
      continue;
 
616
 
 
617
    table->file->position(table->record[0]);
 
618
    found++;
 
619
 
 
620
    if (secure_counter < 0)
 
621
    {
 
622
      /* We are scanning the current table */
 
623
      assert(del_table == table_being_deleted);
 
624
      table->status|= STATUS_DELETED;
 
625
      if (!(error=table->file->ha_delete_row(table->record[0])))
 
626
      {
 
627
        deleted++;
 
628
        if (!table->file->has_transactions())
 
629
          session->transaction.stmt.modified_non_trans_table= true;
 
630
      }
 
631
      else
 
632
      {
 
633
        table->file->print_error(error,MYF(0));
 
634
        return(1);
 
635
      }
 
636
    }
 
637
    else
 
638
    {
 
639
      error=tempfiles[secure_counter]->unique_add((char*) table->file->ref);
 
640
      if (error)
 
641
      {
 
642
        error= 1;                               // Fatal error
 
643
        return(1);
 
644
      }
 
645
    }
 
646
  }
 
647
  return(0);
 
648
}
 
649
 
 
650
 
 
651
void multi_delete::send_error(uint32_t errcode,const char *err)
 
652
{
 
653
  
 
654
 
 
655
  /* First send error what ever it is ... */
 
656
  my_message(errcode, err, MYF(0));
 
657
 
 
658
  return;
 
659
}
 
660
 
 
661
 
 
662
void multi_delete::abort()
 
663
{
 
664
  
 
665
 
 
666
  /* the error was handled or nothing deleted and no side effects return */
 
667
  if (error_handled ||
 
668
      (!session->transaction.stmt.modified_non_trans_table && !deleted))
 
669
    return;
 
670
 
 
671
  /*
 
672
    If rows from the first table only has been deleted and it is
 
673
    transactional, just do rollback.
 
674
    The same if all tables are transactional, regardless of where we are.
 
675
    In all other cases do attempt deletes ...
 
676
  */
 
677
  if (do_delete && normal_tables &&
 
678
      (table_being_deleted != delete_tables ||
 
679
       !table_being_deleted->table->file->has_transactions()))
 
680
  {
 
681
    /*
 
682
      We have to execute the recorded do_deletes() and write info into the
 
683
      error log
 
684
    */
 
685
    error= 1;
 
686
    send_eof();
 
687
    assert(error_handled);
 
688
    return;
 
689
  }
 
690
  
 
691
  if (session->transaction.stmt.modified_non_trans_table)
 
692
  {
 
693
    /* 
 
694
       there is only side effects; to binlog with the error
 
695
    */
 
696
    if (mysql_bin_log.is_open())
 
697
    {
 
698
      session->binlog_query(Session::ROW_QUERY_TYPE,
 
699
                        session->query, session->query_length,
 
700
                        transactional_tables, false);
 
701
    }
 
702
    session->transaction.all.modified_non_trans_table= true;
 
703
  }
 
704
  return;
 
705
}
 
706
 
 
707
 
 
708
 
 
709
/*
 
710
  Do delete from other tables.
 
711
  Returns values:
 
712
        0 ok
 
713
        1 error
 
714
*/
 
715
 
 
716
int multi_delete::do_deletes()
 
717
{
 
718
  int local_error= 0, counter= 0, tmp_error;
 
719
  bool will_batch;
 
720
  
 
721
  assert(do_delete);
 
722
 
 
723
  do_delete= 0;                                 // Mark called
 
724
  if (!found)
 
725
    return(0);
 
726
 
 
727
  table_being_deleted= (delete_while_scanning ? delete_tables->next_local :
 
728
                        delete_tables);
 
729
 
 
730
  for (; table_being_deleted;
 
731
       table_being_deleted= table_being_deleted->next_local, counter++)
 
732
  { 
 
733
    ha_rows last_deleted= deleted;
 
734
    Table *table = table_being_deleted->table;
 
735
    if (tempfiles[counter]->get(table))
 
736
    {
 
737
      local_error=1;
 
738
      break;
 
739
    }
 
740
 
 
741
    READ_RECORD info;
 
742
    init_read_record(&info,session,table,NULL,0,1);
 
743
    /*
 
744
      Ignore any rows not found in reference tables as they may already have
 
745
      been deleted by foreign key handling
 
746
    */
 
747
    info.ignore_not_found_rows= 1;
 
748
    will_batch= !table->file->start_bulk_delete();
 
749
    while (!(local_error=info.read_record(&info)) && !session->killed)
 
750
    {
 
751
      if ((local_error=table->file->ha_delete_row(table->record[0])))
 
752
      {
 
753
        table->file->print_error(local_error,MYF(0));
 
754
        break;
 
755
      }
 
756
      deleted++;
 
757
    }
 
758
    if (will_batch && (tmp_error= table->file->end_bulk_delete()))
 
759
    {
 
760
      if (!local_error)
 
761
      {
 
762
        local_error= tmp_error;
 
763
        table->file->print_error(local_error,MYF(0));
 
764
      }
 
765
    }
 
766
    if (last_deleted != deleted && !table->file->has_transactions())
 
767
      session->transaction.stmt.modified_non_trans_table= true;
 
768
    end_read_record(&info);
 
769
    if (session->killed && !local_error)
 
770
      local_error= 1;
 
771
    if (local_error == -1)                              // End of file
 
772
      local_error = 0;
 
773
  }
 
774
  return(local_error);
 
775
}
 
776
 
 
777
 
 
778
/*
 
779
  Send ok to the client
 
780
 
 
781
  return:  0 sucess
 
782
           1 error
 
783
*/
 
784
 
 
785
bool multi_delete::send_eof()
 
786
{
 
787
  Session::killed_state killed_status= Session::NOT_KILLED;
 
788
  session->set_proc_info("deleting from reference tables");
 
789
 
 
790
  /* Does deletes for the last n - 1 tables, returns 0 if ok */
 
791
  int local_error= do_deletes();                // returns 0 if success
 
792
 
 
793
  /* compute a total error to know if something failed */
 
794
  local_error= local_error || error;
 
795
  killed_status= (local_error == 0)? Session::NOT_KILLED : session->killed;
 
796
  /* reset used flags */
 
797
  session->set_proc_info("end");
 
798
 
 
799
  if ((local_error == 0) || session->transaction.stmt.modified_non_trans_table)
 
800
  {
 
801
    if (mysql_bin_log.is_open())
 
802
    {
 
803
      if (local_error == 0)
 
804
        session->clear_error();
 
805
      if (session->binlog_query(Session::ROW_QUERY_TYPE,
 
806
                            session->query, session->query_length,
 
807
                            transactional_tables, false, killed_status) &&
 
808
          !normal_tables)
 
809
      {
 
810
        local_error=1;  // Log write failed: roll back the SQL statement
 
811
      }
 
812
    }
 
813
    if (session->transaction.stmt.modified_non_trans_table)
 
814
      session->transaction.all.modified_non_trans_table= true;
 
815
  }
 
816
  if (local_error != 0)
 
817
    error_handled= true; // to force early leave from ::send_error()
 
818
 
 
819
  if (!local_error)
 
820
  {
 
821
    session->row_count_func= deleted;
 
822
    ::my_ok(session, (ha_rows) session->row_count_func);
 
823
  }
 
824
  return 0;
 
825
}
 
826
 
 
827
 
 
828
/***************************************************************************
379
829
  TRUNCATE Table
380
830
****************************************************************************/
381
831
 
382
832
/*
383
833
  Optimize delete of all rows by doing a full generate of the table
384
834
  This will work even if the .ISM and .ISD tables are destroyed
 
835
 
 
836
  dont_send_ok should be set if:
 
837
  - We should always wants to generate the table (even if the table type
 
838
    normally can't safely do this.
 
839
  - We don't want an ok to be sent to the end user.
 
840
  - We don't want to log the truncate command
 
841
  - If we want to have a name lock on the table on exit without errors.
385
842
*/
386
843
 
387
 
bool mysql_truncate(Session& session, TableList *table_list)
 
844
bool mysql_truncate(Session *session, TableList *table_list, bool dont_send_ok)
388
845
{
 
846
  HA_CREATE_INFO create_info;
 
847
  char path[FN_REFLEN];
 
848
  Table *table;
389
849
  bool error;
390
 
  TransactionServices &transaction_services= TransactionServices::singleton();
391
 
 
392
 
  uint64_t save_options= session.options;
 
850
  uint32_t path_length;
 
851
  
 
852
 
 
853
  memset(&create_info, 0, sizeof(create_info));
 
854
  /* If it is a temporary table, close and regenerate it */
 
855
  if (!dont_send_ok && (table= find_temporary_table(session, table_list)))
 
856
  {
 
857
    handlerton *table_type= table->s->db_type();
 
858
    TABLE_SHARE *share= table->s;
 
859
    bool frm_only= (share->tmp_table == TMP_TABLE_FRM_FILE_ONLY);
 
860
 
 
861
    if (!ha_check_storage_engine_flag(table_type, HTON_CAN_RECREATE))
 
862
      goto trunc_by_del;
 
863
 
 
864
    table->file->info(HA_STATUS_AUTO | HA_STATUS_NO_LOCK);
 
865
    
 
866
    close_temporary_table(session, table, 0, 0);    // Don't free share
 
867
    ha_create_table(session, share->normalized_path.str,
 
868
                    share->db.str, share->table_name.str, &create_info, 1);
 
869
    // We don't need to call invalidate() because this table is not in cache
 
870
    if ((error= (int) !(open_temporary_table(session, share->path.str,
 
871
                                             share->db.str,
 
872
                                             share->table_name.str, 1,
 
873
                                             OTM_OPEN))))
 
874
      (void) rm_temporary_table(table_type, path, frm_only);
 
875
    free_table_share(share);
 
876
    free((char*) table);
 
877
    /*
 
878
      If we return here we will not have logged the truncation to the bin log
 
879
      and we will not my_ok() to the client.
 
880
    */
 
881
    goto end;
 
882
  }
 
883
 
 
884
  path_length= build_table_filename(path, sizeof(path), table_list->db,
 
885
                                    table_list->table_name, reg_ext, 0);
 
886
 
 
887
  if (!dont_send_ok)
 
888
    goto trunc_by_del;
 
889
 
 
890
  // Remove the .frm extension AIX 5.2 64-bit compiler bug (BUG#16155): this
 
891
  // crashes, replacement works.  *(path + path_length - reg_ext_length)=
 
892
  // '\0';
 
893
  path[path_length - reg_ext_length] = 0;
 
894
  pthread_mutex_lock(&LOCK_open);
 
895
  error= ha_create_table(session, path, table_list->db, table_list->table_name,
 
896
                         &create_info, 1);
 
897
  pthread_mutex_unlock(&LOCK_open);
 
898
 
 
899
end:
 
900
  if (!dont_send_ok)
 
901
  {
 
902
    if (!error)
 
903
    {
 
904
      /*
 
905
        TRUNCATE must always be statement-based binlogged (not row-based) so
 
906
        we don't test current_stmt_binlog_row_based.
 
907
      */
 
908
      write_bin_log(session, true, session->query, session->query_length);
 
909
      my_ok(session);           // This should return record count
 
910
    }
 
911
    pthread_mutex_lock(&LOCK_open);
 
912
    unlock_table_name(session, table_list);
 
913
    pthread_mutex_unlock(&LOCK_open);
 
914
  }
 
915
  else if (error)
 
916
  {
 
917
    pthread_mutex_lock(&LOCK_open);
 
918
    unlock_table_name(session, table_list);
 
919
    pthread_mutex_unlock(&LOCK_open);
 
920
  }
 
921
  return(error);
 
922
 
 
923
trunc_by_del:
 
924
  /* Probably InnoDB table */
 
925
  uint64_t save_options= session->options;
393
926
  table_list->lock_type= TL_WRITE;
394
 
  session.options&= ~(OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT);
395
 
  mysql_init_select(session.lex);
396
 
  error= mysql_delete(&session, table_list, (COND*) 0, (SQL_LIST*) 0,
 
927
  session->options&= ~(OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT);
 
928
  ha_enable_transaction(session, false);
 
929
  mysql_init_select(session->lex);
 
930
  bool save_binlog_row_based= session->current_stmt_binlog_row_based;
 
931
  session->clear_current_stmt_binlog_row_based();
 
932
  error= mysql_delete(session, table_list, (COND*) 0, (SQL_LIST*) 0,
397
933
                      HA_POS_ERROR, 0L, true);
 
934
  ha_enable_transaction(session, true);
398
935
  /*
399
936
    Safety, in case the engine ignored ha_enable_transaction(false)
400
937
    above. Also clears session->transaction.*.
401
938
  */
402
 
  error= transaction_services.autocommitOrRollback(&session, error);
403
 
  session.options= save_options;
404
 
 
405
 
  return error;
 
939
  error= ha_autocommit_or_rollback(session, error);
 
940
  ha_commit(session);
 
941
  session->options= save_options;
 
942
  session->current_stmt_binlog_row_based= save_binlog_row_based;
 
943
  return(error);
406
944
}
407
 
 
408
 
} /* namespace drizzled */