← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_delete.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-09-13 00:53:34 UTC
  • mto: (1126.9.2 captain-20090915-01)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: osullivan.padraig@gmail.com-20090913005334-6wio2sbjugskfbm3
Added calls to the connection start/end dtrace probes.

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/error.h>
 
24
#include <drizzled/probes.h>
 
25
#include <drizzled/sql_parse.h>
 
26
#include <drizzled/sql_base.h>
 
27
#include <drizzled/lock.h>
36
28
 
37
29
/**
38
30
  Implement DELETE SQL word.
43
35
*/
44
36
 
45
37
bool mysql_delete(Session *session, TableList *table_list, COND *conds,
46
 
                  SQL_LIST *order, ha_rows limit, uint64_t,
 
38
                  SQL_LIST *order, ha_rows limit, uint64_t options,
47
39
                  bool reset_auto_increment)
48
40
{
49
 
  int           error;
 
41
  bool          will_batch;
 
42
  int           error, loc_error;
50
43
  Table         *table;
51
 
  optimizer::SqlSelect *select= NULL;
 
44
  SQL_SELECT    *select=0;
52
45
  READ_RECORD   info;
53
46
  bool          using_limit=limit != HA_POS_ERROR;
54
 
  bool          transactional_table, const_cond;
 
47
  bool          transactional_table, safe_update, const_cond;
55
48
  bool          const_cond_result;
56
49
  ha_rows       deleted= 0;
57
50
  uint32_t usable_index= MAX_KEY;
58
51
  Select_Lex   *select_lex= &session->lex->select_lex;
59
52
  Session::killed_state killed_status= Session::NOT_KILLED;
60
53
 
 
54
 
61
55
  if (session->openTablesLock(table_list))
62
 
  {
63
 
    DRIZZLE_DELETE_DONE(1, 0);
64
56
    return true;
65
 
  }
66
57
 
67
58
  table= table_list->table;
68
59
  assert(table);
95
86
  }
96
87
 
97
88
  const_cond= (!conds || conds->const_item());
 
89
  safe_update=test(session->options & OPTION_SAFE_UPDATES);
 
90
  if (safe_update && const_cond)
 
91
  {
 
92
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
 
93
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
 
94
    goto err;
 
95
  }
98
96
 
99
97
  select_lex->no_error= session->lex->ignore;
100
98
 
126
124
  */
127
125
  if (!using_limit && const_cond_result)
128
126
  {
129
 
    /* Update the table->cursor->stats.records number */
130
 
    table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
131
 
    ha_rows const maybe_deleted= table->cursor->stats.records;
132
 
    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()))
133
131
    {
134
132
      error= -1;                                // ok
135
133
      deleted= maybe_deleted;
137
135
    }
138
136
    if (error != HA_ERR_WRONG_COMMAND)
139
137
    {
140
 
      table->print_error(error,MYF(0));
 
138
      table->file->print_error(error,MYF(0));
141
139
      error=0;
142
140
      goto cleanup;
143
141
    }
151
149
      limit= 0;
152
150
  }
153
151
 
154
 
  /* Update the table->cursor->stats.records number */
155
 
  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);
156
154
 
157
155
  table->covering_keys.reset();
158
156
  table->quick_keys.reset();            // Can't use 'only index'
159
 
  select= optimizer::make_select(table, 0, 0, conds, 0, &error);
 
157
  select=make_select(table, 0, 0, conds, 0, &error);
160
158
  if (error)
161
159
    goto err;
162
 
  if ((select && select->check_quick(session, false, limit)) || !limit)
 
160
  if ((select && select->check_quick(session, safe_update, limit)) || !limit)
163
161
  {
164
162
    delete select;
165
163
    free_underlaid_joins(session, select_lex);
166
164
    session->row_count_func= 0;
167
 
    DRIZZLE_DELETE_DONE(0, 0);
168
 
    /**
169
 
     * Resetting the Diagnostic area to prevent
170
 
     * lp bug# 439719
171
 
     */
172
 
    session->main_da.reset_diagnostics_area();
 
165
    DRIZZLE_DELETE_END();
173
166
    session->my_ok((ha_rows) session->row_count_func);
174
167
    /*
175
168
      We don't need to call reset_auto_increment in this case, because
176
169
      mysql_truncate always gives a NULL conds argument, hence we never
177
170
      get here.
178
171
    */
179
 
    return 0; // Nothing to delete
 
172
    return(0);                          // Nothing to delete
180
173
  }
181
174
 
182
175
  /* If running in safe sql mode, don't allow updates without keys */
183
176
  if (table->quick_keys.none())
184
177
  {
185
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
    }
186
187
  }
 
188
  if (options & OPTION_QUICK)
 
189
    (void) table->file->extra(HA_EXTRA_QUICK);
187
190
 
188
191
  if (order && order->elements)
189
192
  {
192
195
    ha_rows examined_rows;
193
196
 
194
197
    if ((!select || table->quick_keys.none()) && limit != HA_POS_ERROR)
195
 
      usable_index= optimizer::get_index_for_order(table, (order_st*)(order->first), limit);
 
198
      usable_index= get_index_for_order(table, (order_st*)(order->first), limit);
196
199
 
197
200
    if (usable_index == MAX_KEY)
198
201
    {
199
 
      table->sort.io_cache= new internal::IO_CACHE;
200
 
      memset(table->sort.io_cache, 0, sizeof(internal::IO_CACHE));
 
202
      table->sort.io_cache= new IO_CACHE;
 
203
      memset(table->sort.io_cache, 0, sizeof(IO_CACHE));
201
204
 
202
205
 
203
206
      if (!(sortorder= make_unireg_sortorder((order_st*) order->first,
228
231
    free_underlaid_joins(session, select_lex);
229
232
    goto err;
230
233
  }
231
 
 
232
234
  if (usable_index==MAX_KEY)
233
235
    init_read_record(&info,session,table,select,1,1);
234
236
  else
236
238
 
237
239
  session->set_proc_info("updating");
238
240
 
 
241
  will_batch= !table->file->start_bulk_delete();
 
242
 
 
243
 
239
244
  table->mark_columns_needed_for_delete();
240
245
 
241
246
  while (!(error=info.read_record(&info)) && !session->killed &&
244
249
    // session->is_error() is tested to disallow delete row on error
245
250
    if (!(select && select->skip_record())&& ! session->is_error() )
246
251
    {
247
 
      if (!(error= table->cursor->ha_delete_row(table->record[0])))
 
252
      if (!(error= table->file->ha_delete_row(table->record[0])))
248
253
      {
249
254
        deleted++;
250
255
        if (!--limit && using_limit)
255
260
      }
256
261
      else
257
262
      {
258
 
        table->print_error(error,MYF(0));
 
263
        table->file->print_error(error,MYF(0));
259
264
        /*
260
265
          In < 4.0.14 we set the error number to 0 here, but that
261
266
          was not sensible, because then MySQL would not roll back the
269
274
      }
270
275
    }
271
276
    else
272
 
      table->cursor->unlock_row();  // Row failed selection, release lock on it
 
277
      table->file->unlock_row();  // Row failed selection, release lock on it
273
278
  }
274
279
  killed_status= session->killed;
275
280
  if (killed_status != Session::NOT_KILLED || session->is_error())
276
281
    error= 1;                                   // Aborted
277
 
 
 
282
  if (will_batch && (loc_error= table->file->end_bulk_delete()))
 
283
  {
 
284
    if (error != 1)
 
285
      table->file->print_error(loc_error,MYF(0));
 
286
    error=1;
 
287
  }
278
288
  session->set_proc_info("end");
279
289
  end_read_record(&info);
280
 
 
281
 
cleanup:
 
290
  if (options & OPTION_QUICK)
 
291
    (void) table->file->extra(HA_EXTRA_NORMAL);
282
292
 
283
293
  if (reset_auto_increment && (error < 0))
284
294
  {
286
296
      We're really doing a truncate and need to reset the table's
287
297
      auto-increment counter.
288
298
    */
289
 
    int error2= table->cursor->ha_reset_auto_increment(0);
 
299
    int error2= table->file->ha_reset_auto_increment(0);
290
300
 
291
301
    if (error2 && (error2 != HA_ERR_WRONG_COMMAND))
292
302
    {
293
 
      table->print_error(error2, MYF(0));
 
303
      table->file->print_error(error2, MYF(0));
294
304
      error= 1;
295
305
    }
296
306
  }
297
307
 
 
308
cleanup:
 
309
 
298
310
  delete select;
299
 
  transactional_table= table->cursor->has_transactions();
 
311
  transactional_table= table->file->has_transactions();
300
312
 
301
313
  if (!transactional_table && deleted > 0)
302
 
    session->transaction.stmt.markModifiedNonTransData();
 
314
    session->transaction.stmt.modified_non_trans_table= true;
303
315
 
304
316
  /* See similar binlogging code in sql_update.cc, for comments */
305
 
  if ((error < 0) || session->transaction.stmt.hasModifiedNonTransData())
 
317
  if ((error < 0) || session->transaction.stmt.modified_non_trans_table)
306
318
  {
307
 
    if (session->transaction.stmt.hasModifiedNonTransData())
308
 
      session->transaction.all.markModifiedNonTransData();
 
319
    if (session->transaction.stmt.modified_non_trans_table)
 
320
      session->transaction.all.modified_non_trans_table= true;
309
321
  }
310
 
  assert(transactional_table || !deleted || session->transaction.stmt.hasModifiedNonTransData());
 
322
  assert(transactional_table || !deleted || session->transaction.stmt.modified_non_trans_table);
311
323
  free_underlaid_joins(session, select_lex);
312
324
 
313
 
  DRIZZLE_DELETE_DONE((error >= 0 || session->is_error()), deleted);
 
325
  DRIZZLE_DELETE_END();
314
326
  if (error < 0 || (session->lex->ignore && !session->is_fatal_error))
315
327
  {
316
328
    session->row_count_func= deleted;
317
 
    /**
318
 
     * Resetting the Diagnostic area to prevent
319
 
     * lp bug# 439719
320
 
     */
321
 
    session->main_da.reset_diagnostics_area();    
322
329
    session->my_ok((ha_rows) session->row_count_func);
323
330
  }
324
 
  return (error >= 0 || session->is_error());
 
331
  return(error >= 0 || session->is_error());
325
332
 
326
333
err:
327
 
  DRIZZLE_DELETE_DONE(1, 0);
328
 
  return true;
 
334
  DRIZZLE_DELETE_END();
 
335
  return(true);
329
336
}
330
337
 
331
338
 
357
364
    return(true);
358
365
  {
359
366
    TableList *duplicate;
360
 
    if ((duplicate= unique_table(table_list, table_list->next_global)))
 
367
    if ((duplicate= unique_table(session, table_list, table_list->next_global, 0)))
361
368
    {
362
369
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
363
370
      return(true);
379
386
/*
380
387
  Optimize delete of all rows by doing a full generate of the table
381
388
  This will work even if the .ISM and .ISD tables are destroyed
 
389
 
 
390
  dont_send_ok should be set if:
 
391
  - We should always wants to generate the table (even if the table type
 
392
    normally can't safely do this.
 
393
  - We don't want an ok to be sent to the end user.
 
394
  - We don't want to log the truncate command
 
395
  - If we want to have a name lock on the table on exit without errors.
382
396
*/
383
397
 
384
 
bool mysql_truncate(Session& session, TableList *table_list)
 
398
bool mysql_truncate(Session *session, TableList *table_list, bool dont_send_ok)
385
399
{
 
400
  HA_CREATE_INFO create_info;
 
401
  char path[FN_REFLEN];
 
402
  Table *table;
386
403
  bool error;
387
 
  TransactionServices &transaction_services= TransactionServices::singleton();
388
 
 
389
 
  uint64_t save_options= session.options;
 
404
  uint32_t path_length;
 
405
 
 
406
 
 
407
  memset(&create_info, 0, sizeof(create_info));
 
408
  /* If it is a temporary table, close and regenerate it */
 
409
  if (!dont_send_ok && (table= session->find_temporary_table(table_list)))
 
410
  {
 
411
    StorageEngine *table_type= table->s->db_type();
 
412
    TableShare *share= table->s;
 
413
 
 
414
    if (!table_type->check_flag(HTON_BIT_CAN_RECREATE))
 
415
      goto trunc_by_del;
 
416
 
 
417
    table->file->info(HA_STATUS_AUTO | HA_STATUS_NO_LOCK);
 
418
 
 
419
    session->close_temporary_table(table, false, false);    // Don't free share
 
420
    ha_create_table(session, share->normalized_path.str,
 
421
                    share->db.str, share->table_name.str, &create_info, 1,
 
422
                    NULL);
 
423
    // We don't need to call invalidate() because this table is not in cache
 
424
    if ((error= (int) !(session->open_temporary_table(share->path.str,
 
425
                                                      share->db.str,
 
426
                                                      share->table_name.str, 1,
 
427
                                                      OTM_OPEN))))
 
428
      (void) session->rm_temporary_table(table_type, path);
 
429
    share->free_table_share();
 
430
    free((char*) table);
 
431
    /*
 
432
      If we return here we will not have logged the truncation to the bin log
 
433
      and we will not my_ok() to the client.
 
434
    */
 
435
    goto end;
 
436
  }
 
437
 
 
438
  path_length= build_table_filename(path, sizeof(path), table_list->db,
 
439
                                    table_list->table_name, 0);
 
440
 
 
441
  if (!dont_send_ok)
 
442
    goto trunc_by_del;
 
443
 
 
444
  pthread_mutex_lock(&LOCK_open); /* Recreate table for truncate */
 
445
  error= ha_create_table(session, path, table_list->db, table_list->table_name,
 
446
                         &create_info, 1, NULL);
 
447
  pthread_mutex_unlock(&LOCK_open);
 
448
 
 
449
end:
 
450
  if (!dont_send_ok)
 
451
  {
 
452
    if (!error)
 
453
    {
 
454
      /*
 
455
        TRUNCATE must always be statement-based binlogged (not row-based) so
 
456
        we don't test current_stmt_binlog_row_based.
 
457
      */
 
458
      write_bin_log(session, true, session->query, session->query_length);
 
459
      session->my_ok();         // This should return record count
 
460
    }
 
461
    pthread_mutex_lock(&LOCK_open); /* For truncate delete from hash when finished */
 
462
    unlock_table_name(table_list);
 
463
    pthread_mutex_unlock(&LOCK_open);
 
464
  }
 
465
  else if (error)
 
466
  {
 
467
    pthread_mutex_lock(&LOCK_open); /* For truncate delete from hash when finished */
 
468
    unlock_table_name(table_list);
 
469
    pthread_mutex_unlock(&LOCK_open);
 
470
  }
 
471
  return(error);
 
472
 
 
473
trunc_by_del:
 
474
  /* Probably InnoDB table */
 
475
  uint64_t save_options= session->options;
390
476
  table_list->lock_type= TL_WRITE;
391
 
  session.options&= ~(OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT);
392
 
  mysql_init_select(session.lex);
393
 
  error= mysql_delete(&session, table_list, (COND*) 0, (SQL_LIST*) 0,
 
477
  session->options&= ~(OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT);
 
478
  ha_enable_transaction(session, false);
 
479
  mysql_init_select(session->lex);
 
480
  error= mysql_delete(session, table_list, (COND*) 0, (SQL_LIST*) 0,
394
481
                      HA_POS_ERROR, 0L, true);
 
482
  ha_enable_transaction(session, true);
395
483
  /*
396
484
    Safety, in case the engine ignored ha_enable_transaction(false)
397
485
    above. Also clears session->transaction.*.
398
486
  */
399
 
  error= transaction_services.ha_autocommit_or_rollback(&session, error);
400
 
  session.options= save_options;
401
 
 
402
 
  return error;
 
487
  error= ha_autocommit_or_rollback(session, error);
 
488
  ha_commit(session);
 
489
  session->options= save_options;
 
490
  return(error);
403
491
}
404
 
 
405
 
} /* namespace drizzled */