Skip navigation links

 Systems for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Downloads
• Documentation
• Articles
• Forums
• Bugs
• Forge
• Blogs

 

---

Learn about new MySQL releases, technical articles, events and more.

Subscribe Now »

mysql/src/5.1-dbg/sql/sql_delete.cc File Reference

#include "mysql_priv.h"
#include "sql_select.h"
#include "sp_head.h"
#include "sql_trigger.h"

Include dependency graph for sql_delete.cc:

Go to the source code of this file.

Defines
#define	MEM_STRIP_BUF_SIZE   current_thd->variables.sortbuff_size
Functions
bool	mysql_delete (THD *thd, TABLE_LIST *table_list, COND *conds, SQL_LIST *order, ha_rows limit, ulonglong options, bool reset_auto_increment)
bool	mysql_prepare_delete (THD *thd, TABLE_LIST *table_list, Item **conds)
int	refpos_order_cmp (void *arg, const void *a, const void *b)
bool	mysql_multi_delete_prepare (THD *thd)
bool	mysql_truncate (THD *thd, TABLE_LIST *table_list, bool dont_send_ok)

---

Define Documentation

#define MEM_STRIP_BUF_SIZE   current_thd->variables.sortbuff_size

Definition at line 415 of file sql_delete.cc.

---

Function Documentation

bool mysql_delete	(	THD *	thd,
		TABLE_LIST *	table_list,
		COND *	conds,
		SQL_LIST *	order,
		ha_rows	limit,
		ulonglong	options,
		bool	reset_auto_increment
	)

Definition at line 31 of file sql_delete.cc.

References st_table_list::alias, st_table::alias, bzero, SQL_SELECT::check_quick(), cleanup(), Bitmap< 64 >::clear_all(), Item::COND_FALSE, Item::const_item(), DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, handler::delete_all_rows(), handler::end_bulk_delete(), end_read_record(), ER, ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE, ER_VIEW_DELETE_MERGE_VIEW, error, handler::extra(), FALSE, st_table::file, filesort(), st_filesort_info::found_records, free_underlaid_joins(), get_index_for_order(), ha_autocommit_or_rollback(), handler::ha_delete_row(), HA_ERR_WRONG_COMMAND, HA_EXTRA_NORMAL, HA_EXTRA_QUICK, HA_POS_ERROR, HA_STATUS_NO_LOCK, HA_STATUS_VARIABLE, Table_triggers_list::has_delete_triggers(), handler::has_transactions(), handler::info(), info, init_ftfuncs(), init_read_record(), init_read_record_idx(), st_filesort_info::io_cache, Bitmap< 64 >::is_clear_all(), MYSQL_LOG::is_open(), make_select(), make_unireg_sortorder(), st_table::map, st_table::mark_columns_needed_for_delete(), MAX_KEY, my_error(), MY_FAE, my_malloc(), my_message(), MY_ZEROFILL, MYF, mysql_bin_log, mysql_prepare_delete(), mysql_unlock_tables(), open_and_lock_tables(), OPTION_QUICK, OPTION_SAFE_UPDATES, OPTION_STATUS_NO_TRANS_UPDATE, order, handler::print_error(), Table_triggers_list::process_triggers(), SQL_SELECT::quick, st_table::quick_keys, st_table::record, ha_statistics::records, remove_eq_conds(), QUICK_SELECT_I::reset(), handler::reset_auto_increment(), send_ok(), SERVER_QUERY_NO_INDEX_USED, setup_order(), SQL_SELECT::skip_record(), st_table::sort, SPECIAL_NO_NEW_FUNC, SPECIAL_SAFE_MODE, specialflag, handler::start_bulk_delete(), handler::stats, LEX_STRING::str, st_table_list::table, test, TRG_ACTION_AFTER, TRG_ACTION_BEFORE, TRG_EVENT_DELETE, st_table::triggers, TRUE, handler::unlock_row(), st_table::used_keys, Item::val_int(), st_table_list::view_db, and st_table_list::view_name.

Referenced by mysql_execute_command(), and mysql_truncate().

{
  bool          will_batch;
  int           error, loc_error;
  TABLE         *table;
  SQL_SELECT    *select=0;
  READ_RECORD   info;
  bool          using_limit=limit != HA_POS_ERROR;
  bool          transactional_table, safe_update, const_cond;
  ha_rows       deleted= 0;
  uint usable_index= MAX_KEY;
  SELECT_LEX   *select_lex= &thd->lex->select_lex;
  DBUG_ENTER("mysql_delete");

  if (open_and_lock_tables(thd, table_list))
    DBUG_RETURN(TRUE);
  if (!(table= table_list->table))
  {
    my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0),
             table_list->view_db.str, table_list->view_name.str);
    DBUG_RETURN(TRUE);
  }
  thd->proc_info="init";
  table->map=1;

  if (mysql_prepare_delete(thd, table_list, &conds))
    DBUG_RETURN(TRUE);

  const_cond= (!conds || conds->const_item());
  safe_update=test(thd->options & OPTION_SAFE_UPDATES);
  if (safe_update && const_cond)
  {
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
    DBUG_RETURN(TRUE);
  }

  select_lex->no_error= thd->lex->ignore;

  /*
    Test if the user wants to delete all rows and deletion doesn't have
    any side-effects (because of triggers), so we can use optimized
    handler::delete_all_rows() method.

    If row-based replication is used, we also delete the table row by
    row.
  */
  if (!using_limit && const_cond && (!conds || conds->val_int()) &&
      !(specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) &&
      !(table->triggers && table->triggers->has_delete_triggers()) &&
      !thd->current_stmt_binlog_row_based)
  {
    /* Update the table->file->stats.records number */
    table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
    ha_rows const maybe_deleted= table->file->stats.records;
    DBUG_PRINT("debug", ("Trying to use delete_all_rows()"));
    if (!(error=table->file->delete_all_rows()))
    {
      error= -1;                                // ok
      deleted= maybe_deleted;
      goto cleanup;
    }
    if (error != HA_ERR_WRONG_COMMAND)
    {
      table->file->print_error(error,MYF(0));
      error=0;
      goto cleanup;
    }
    /* Handler didn't support fast delete; Delete rows one by one */
  }
  if (conds)
  {
    Item::cond_result result;
    conds= remove_eq_conds(thd, conds, &result);
    if (result == Item::COND_FALSE)             // Impossible where
      limit= 0;
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (prune_partitions(thd, table, conds))
  {
    free_underlaid_joins(thd, select_lex);
    thd->row_count_func= 0;
    send_ok(thd);                               // No matching records
    DBUG_RETURN(0);
  }
#endif
  /* Update the table->file->stats.records number */
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

  table->used_keys.clear_all();
  table->quick_keys.clear_all();                // Can't use 'only index'
  select=make_select(table, 0, 0, conds, 0, &error);
  if (error)
    DBUG_RETURN(TRUE);
  if ((select && select->check_quick(thd, safe_update, limit)) || !limit)
  {
    delete select;
    free_underlaid_joins(thd, select_lex);
    thd->row_count_func= 0;
    send_ok(thd,0L);
    /*
      We don't need to call reset_auto_increment in this case, because
      mysql_truncate always gives a NULL conds argument, hence we never
      get here.
    */
    DBUG_RETURN(0);                             // Nothing to delete
  }

  /* If running in safe sql mode, don't allow updates without keys */
  if (table->quick_keys.is_clear_all())
  {
    thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
    if (safe_update && !using_limit)
    {
      delete select;
      free_underlaid_joins(thd, select_lex);
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
                 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
      DBUG_RETURN(TRUE);
    }
  }
  if (options & OPTION_QUICK)
    (void) table->file->extra(HA_EXTRA_QUICK);

  if (order && order->elements)
  {
    uint         length;
    SORT_FIELD  *sortorder;
    TABLE_LIST   tables;
    List<Item>   fields;
    List<Item>   all_fields;
    ha_rows examined_rows;

    bzero((char*) &tables,sizeof(tables));
    tables.table = table;
    tables.alias = table_list->alias;

      if (select_lex->setup_ref_array(thd, order->elements) ||
          setup_order(thd, select_lex->ref_pointer_array, &tables,
                    fields, all_fields, (ORDER*) order->first))
    {
      delete select;
      free_underlaid_joins(thd, &thd->lex->select_lex);
      DBUG_RETURN(TRUE);
    }
    
    if (!select && limit != HA_POS_ERROR)
      usable_index= get_index_for_order(table, (ORDER*)(order->first), limit);

    if (usable_index == MAX_KEY)
    {
      table->sort.io_cache= (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
                                                   MYF(MY_FAE | MY_ZEROFILL));
    
      if (!(sortorder= make_unireg_sortorder((ORDER*) order->first,
                                             &length)) ||
          (table->sort.found_records = filesort(thd, table, sortorder, length,
                                                select, HA_POS_ERROR, 1,
                                                &examined_rows))
          == HA_POS_ERROR)
      {
        delete select;
        free_underlaid_joins(thd, &thd->lex->select_lex);
        DBUG_RETURN(TRUE);
      }
      /*
        Filesort has already found and selected the rows we want to delete,
        so we don't need the where clause
      */
      delete select;
      free_underlaid_joins(thd, select_lex);
      select= 0;
    }
  }

  /* If quick select is used, initialize it before retrieving rows. */
  if (select && select->quick && select->quick->reset())
  {
    delete select;
    free_underlaid_joins(thd, select_lex);
    DBUG_RETURN(TRUE);
  }
  if (usable_index==MAX_KEY)
    init_read_record(&info,thd,table,select,1,1);
  else
    init_read_record_idx(&info, thd, table, 1, usable_index);

  init_ftfuncs(thd, select_lex, 1);
  thd->proc_info="updating";
  will_batch= !table->file->start_bulk_delete();


  table->mark_columns_needed_for_delete();

  while (!(error=info.read_record(&info)) && !thd->killed &&
         !thd->net.report_error)
  {
    // thd->net.report_error is tested to disallow delete row on error
    if (!(select && select->skip_record())&& !thd->net.report_error )
    {

      if (table->triggers &&
          table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
                                            TRG_ACTION_BEFORE, FALSE))
      {
        error= 1;
        break;
      }

      if (!(error= table->file->ha_delete_row(table->record[0])))
      {
        deleted++;
        if (table->triggers &&
            table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
                                              TRG_ACTION_AFTER, FALSE))
        {
          error= 1;
          break;
        }
        if (!--limit && using_limit)
        {
          error= -1;
          break;
        }
      }
      else
      {
        table->file->print_error(error,MYF(0));
        /*
          In < 4.0.14 we set the error number to 0 here, but that
          was not sensible, because then MySQL would not roll back the
          failed DELETE, and also wrote it to the binlog. For MyISAM
          tables a DELETE probably never should fail (?), but for
          InnoDB it can fail in a FOREIGN KEY error or an
          out-of-tablespace error.
        */
        error= 1;
        break;
      }
    }
    else
      table->file->unlock_row();  // Row failed selection, release lock on it
  }
  if (thd->killed && !error)
    error= 1;                                   // Aborted
  if (will_batch && (loc_error= table->file->end_bulk_delete()))
  {
    if (error != 1)
      table->file->print_error(loc_error,MYF(0));
    error=1;
  }
  thd->proc_info= "end";
  end_read_record(&info);
  if (options & OPTION_QUICK)
    (void) table->file->extra(HA_EXTRA_NORMAL);

  if (reset_auto_increment && (error < 0))
  {
    /*
      We're really doing a truncate and need to reset the table's
      auto-increment counter.
    */
    int error2= table->file->reset_auto_increment(0);

    if (error2 && (error2 != HA_ERR_WRONG_COMMAND))
    {
      table->file->print_error(error2, MYF(0));
      error= 1;
    }
  }

cleanup:
  /*
    Invalidate the table in the query cache if something changed. This must
    be before binlog writing and ha_autocommit_...
  */
  if (deleted)
  {
    query_cache_invalidate3(thd, table_list, 1);
  }

  delete select;
  transactional_table= table->file->has_transactions();

  /* See similar binlogging code in sql_update.cc, for comments */
  if ((error < 0) || (deleted && !transactional_table))
  {
    if (mysql_bin_log.is_open())
    {
      if (error < 0)
        thd->clear_error();

      /*
        [binlog]: If 'handler::delete_all_rows()' was called and the
        storage engine does not inject the rows itself, we replicate
        statement-based; otherwise, 'ha_delete_row()' was used to
        delete specific rows which we might log row-based.
      */
      int log_result= thd->binlog_query(THD::ROW_QUERY_TYPE,
                                        thd->query, thd->query_length,
                                        transactional_table, FALSE);

      if (log_result && transactional_table)
      {
        error=1;
      }
    }
    if (!transactional_table)
      thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  }
  free_underlaid_joins(thd, select_lex);
  if (transactional_table)
  {
    if (ha_autocommit_or_rollback(thd,error >= 0))
      error=1;
  }

  if (thd->lock)
  {
    mysql_unlock_tables(thd, thd->lock);
    thd->lock=0;
  }
  if (error < 0)
  {
    thd->row_count_func= deleted;
    send_ok(thd,deleted);
    DBUG_PRINT("info",("%d records deleted",deleted));
  }
  DBUG_RETURN(error >= 0 || thd->net.report_error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool mysql_multi_delete_prepare

(

THD *

thd

)

Definition at line 435 of file sql_delete.cc.

References check_key_in_view(), st_table_list::correspondent_table, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, DELETE_ACL, ER_NON_UPDATABLE_TABLE, ER_VIEW_DELETE_MERGE_VIEW, FALSE, st_table_list::merge_underlying_list, my_error(), MYF, st_table_list::next_local, setup_tables_and_check_access(), LEX_STRING::str, st_table_list::table, st_table_list::table_name, TRUE, st_table_list::updatable, st_table_list::view, st_table_list::view_db, and st_table_list::view_name.

{
  LEX *lex= thd->lex;
  TABLE_LIST *aux_tables= (TABLE_LIST *)lex->auxiliary_table_list.first;
  TABLE_LIST *target_tbl;
  DBUG_ENTER("mysql_multi_delete_prepare");

  /*
    setup_tables() need for VIEWs. JOIN::prepare() will not do it second
    time.

    lex->query_tables also point on local list of DELETE SELECT_LEX
  */
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
                                    &thd->lex->select_lex.top_join_list,
                                    lex->query_tables,
                                    &lex->select_lex.leaf_tables, FALSE, 
                                    DELETE_ACL))
    DBUG_RETURN(TRUE);


  /*
    Multi-delete can't be constructed over-union => we always have
    single SELECT on top and have to check underlying SELECTs of it
  */
  lex->select_lex.exclude_from_table_unique_test= TRUE;
  /* Fix tables-to-be-deleted-from list to point at opened tables */
  for (target_tbl= (TABLE_LIST*) aux_tables;
       target_tbl;
       target_tbl= target_tbl->next_local)
  {
    if (!(target_tbl->table= target_tbl->correspondent_table->table))
    {
      DBUG_ASSERT(target_tbl->correspondent_table->view &&
                  target_tbl->correspondent_table->merge_underlying_list &&
                  target_tbl->correspondent_table->merge_underlying_list->
                  next_local);
      my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0),
               target_tbl->correspondent_table->view_db.str,
               target_tbl->correspondent_table->view_name.str);
      DBUG_RETURN(TRUE);
    }

    if (!target_tbl->correspondent_table->updatable ||
        check_key_in_view(thd, target_tbl->correspondent_table))
    {
      my_error(ER_NON_UPDATABLE_TABLE, MYF(0),
               target_tbl->table_name, "DELETE");
      DBUG_RETURN(TRUE);
    }
    /*
      Check that table from which we delete is not used somewhere
      inside subqueries/view.
    */
    {
      TABLE_LIST *duplicate;
      if ((duplicate= unique_table(thd, target_tbl->correspondent_table,
                                   lex->query_tables)))
      {
        update_non_unique_table_error(target_tbl->correspondent_table,
                                      "DELETE", duplicate);
        DBUG_RETURN(TRUE);
      }
    }
  }
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

bool mysql_prepare_delete	(	THD *	thd,
		TABLE_LIST *	table_list,
		Item **	conds
	)

Definition at line 379 of file sql_delete.cc.

References st_table_list::alias, check_key_in_view(), DBUG_ENTER, DBUG_RETURN, DELETE_ACL, ER_NON_UPDATABLE_TABLE, FALSE, my_error(), MYF, st_table_list::next_global, setup_conds(), setup_ftfuncs(), setup_tables_and_check_access(), TRUE, unique_table(), st_table_list::updatable, and update_non_unique_table_error().

Referenced by mysql_delete(), and mysql_test_delete().

{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  DBUG_ENTER("mysql_prepare_delete");

  thd->lex->allow_sum_func= 0;
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
                                    &thd->lex->select_lex.top_join_list,
                                    table_list, 
                                    &select_lex->leaf_tables, FALSE, 
                                    DELETE_ACL) ||
      setup_conds(thd, table_list, select_lex->leaf_tables, conds) ||
      setup_ftfuncs(select_lex))
    DBUG_RETURN(TRUE);
  if (!table_list->updatable || check_key_in_view(thd, table_list))
  {
    my_error(ER_NON_UPDATABLE_TABLE, MYF(0), table_list->alias, "DELETE");
    DBUG_RETURN(TRUE);
  }
  {
    TABLE_LIST *duplicate;
    if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
    {
      update_non_unique_table_error(table_list, "DELETE", duplicate);
      DBUG_RETURN(TRUE);
    }
  }
  select_lex->fix_prepare_information(thd, conds);
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool mysql_truncate	(	THD *	thd,
		TABLE_LIST *	table_list,
		bool	dont_send_ok
	)

Definition at line 859 of file sql_delete.cc.

References build_table_filename(), bzero, LOGGER::close_log_table(), close_temporary_table(), st_table_list::db, st_table_share::db, st_table_share::db_type, DB_TYPE_UNKNOWN, DBUG_ENTER, DBUG_RETURN, ER_NO_SUCH_TABLE, error, FALSE, st_table::file, find_temporary_table(), FN_REFLEN, free_table_share(), ha_check_storage_engine_flag(), ha_create_table(), ha_enable_transaction(), HA_POS_ERROR, ha_resolve_by_legacy_type(), HA_STATUS_AUTO, HA_STATUS_NO_LOCK, HTON_CAN_RECREATE, handler::info(), MYSQL_LOG::is_open(), LL, LOGGER::lock(), lock_and_wait_for_table_name(), LOCK_open, st_table_list::lock_type, logger, my_error(), my_free, my_strcasecmp, MYF, mysql_bin_log, mysql_delete(), mysql_frm_type(), mysql_init_select(), st_table_share::normalized_path, open_temporary_table(), opt_log, opt_slow_log, OPTION_BEGIN, OPTION_NOT_AUTOCOMMIT, st_table_share::path, path, pthread_mutex_lock, pthread_mutex_unlock, QUERY_LOG_GENERAL, QUERY_LOG_SLOW, reg_ext, reg_ext_length, LOGGER::reopen_log_table(), rm_temporary_table(), st_table::s, send_ok(), LEX_STRING::str, system_charset_info, st_table_list::table_name, st_table_share::table_name, TL_WRITE, TRUE, LOGGER::unlock(), unlock_table_name(), and VOID.

Referenced by mysql_execute_command(), prepare_for_repair(), and prepare_for_restore().

{
  HA_CREATE_INFO create_info;
  char path[FN_REFLEN];
  TABLE *table;
  bool error;
  uint closed_log_tables= 0, lock_logger= 0;
  uint path_length;
  DBUG_ENTER("mysql_truncate");

  bzero((char*) &create_info,sizeof(create_info));
  /* If it is a temporary table, close and regenerate it */
  if (!dont_send_ok && (table= find_temporary_table(thd, table_list)))
  {
    handlerton *table_type= table->s->db_type;
    TABLE_SHARE *share= table->s;
    if (!ha_check_storage_engine_flag(table_type, HTON_CAN_RECREATE))
      goto trunc_by_del;

    table->file->info(HA_STATUS_AUTO | HA_STATUS_NO_LOCK);
    
    close_temporary_table(thd, table, 0, 0);    // Don't free share
    ha_create_table(thd, share->normalized_path.str,
                    share->db.str, share->table_name.str, &create_info, 1);
    // We don't need to call invalidate() because this table is not in cache
    if ((error= (int) !(open_temporary_table(thd, share->path.str,
                                             share->db.str,
                                             share->table_name.str, 1))))
      (void) rm_temporary_table(table_type, path);
    free_table_share(share);
    my_free((char*) table,MYF(0));
    /*
      If we return here we will not have logged the truncation to the bin log
      and we will not send_ok() to the client.
    */
    goto end;
  }

  path_length= build_table_filename(path, sizeof(path), table_list->db,
                                    table_list->table_name, reg_ext, 0);

  if (!dont_send_ok)
  {
    enum legacy_db_type table_type;
    mysql_frm_type(thd, path, &table_type);
    if (table_type == DB_TYPE_UNKNOWN)
    {
      my_error(ER_NO_SUCH_TABLE, MYF(0),
               table_list->db, table_list->table_name);
      DBUG_RETURN(TRUE);
    }
    if (!ha_check_storage_engine_flag(ha_resolve_by_legacy_type(thd, table_type),
                                      HTON_CAN_RECREATE))
      goto trunc_by_del;

    if (lock_and_wait_for_table_name(thd, table_list))
      DBUG_RETURN(TRUE);
  }

  /* close log tables in use */
  if (!my_strcasecmp(system_charset_info, table_list->db, "mysql"))
  {
    if (opt_log &&
        !my_strcasecmp(system_charset_info, table_list->table_name,
                       "general_log"))
    {
      lock_logger= 1;
      logger.lock();
      logger.close_log_table(QUERY_LOG_GENERAL, FALSE);
      closed_log_tables= closed_log_tables | QUERY_LOG_GENERAL;
    }
    else
      if (opt_slow_log &&
          !my_strcasecmp(system_charset_info, table_list->table_name,
                         "slow_log"))
      {
        lock_logger= 1;
        logger.lock();
        logger.close_log_table(QUERY_LOG_SLOW, FALSE);
        closed_log_tables= closed_log_tables | QUERY_LOG_SLOW;
      }
  }

  // Remove the .frm extension AIX 5.2 64-bit compiler bug (BUG#16155): this
  // crashes, replacement works.  *(path + path_length - reg_ext_length)=
  // '\0';
  path[path_length - reg_ext_length] = 0;
  VOID(pthread_mutex_lock(&LOCK_open));
  error= ha_create_table(thd, path, table_list->db, table_list->table_name,
                         &create_info, 1);
  VOID(pthread_mutex_unlock(&LOCK_open));
  query_cache_invalidate3(thd, table_list, 0);

end:
  if (!dont_send_ok)
  {
    if (!error)
    {
      if (mysql_bin_log.is_open())
      {
        /*
          TRUNCATE must always be statement-based binlogged (not row-based) so
          we don't test current_stmt_binlog_row_based.
        */
        thd->clear_error();
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
      }
      send_ok(thd);             // This should return record count
    }
    VOID(pthread_mutex_lock(&LOCK_open));
    unlock_table_name(thd, table_list);
    VOID(pthread_mutex_unlock(&LOCK_open));

    if (opt_slow_log && (closed_log_tables & QUERY_LOG_SLOW))
      logger.reopen_log_table(QUERY_LOG_SLOW);

    if (opt_log && (closed_log_tables & QUERY_LOG_GENERAL))
      logger.reopen_log_table(QUERY_LOG_GENERAL);
    if (lock_logger)
      logger.unlock();
  }
  else if (error)
  {
    VOID(pthread_mutex_lock(&LOCK_open));
    unlock_table_name(thd, table_list);
    VOID(pthread_mutex_unlock(&LOCK_open));
  }
  DBUG_RETURN(error);

trunc_by_del:
  /* Probably InnoDB table */
  ulong save_options= thd->options;
  table_list->lock_type= TL_WRITE;
  thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_NOT_AUTOCOMMIT);
  ha_enable_transaction(thd, FALSE);
  mysql_init_select(thd->lex);
  bool save_binlog_row_based= thd->current_stmt_binlog_row_based;
  thd->clear_current_stmt_binlog_row_based();
  error= mysql_delete(thd, table_list, (COND*) 0, (SQL_LIST*) 0,
                      HA_POS_ERROR, LL(0), TRUE);
  ha_enable_transaction(thd, TRUE);
  thd->options= save_options;
  thd->current_stmt_binlog_row_based= save_binlog_row_based;
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int refpos_order_cmp	(	void *	arg,
		const void *	a,
		const void *	b
	)

Definition at line 417 of file sql_delete.cc.

References handler::cmp_ref().

Referenced by QUICK_INDEX_MERGE_SELECT::read_keys_and_merge().

{
  handler *file= (handler*)arg;
  return file->cmp_ref((const byte*)a, (const byte*)b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

© 1995-2008 MySQL AB, 2008 Sun Microsystems, Inc.

• Online Shop
• Site Map
• About MySQL
• Legal
• Privacy Policy
• Contact Us
• Job Opportunities