~drizzle-trunk/drizzle/development

 

  Multi-table deletes were introduced by Monty and Sinisa

*/

 

/**

  Implement DELETE SQL word.

  end of dispatch_command().

*/

 

                  bool reset_auto_increment)

{

  bool          will_batch;

  int           error, loc_error;

  SQL_SELECT    *select=0;

  READ_RECORD   info;

  bool          using_limit=limit != HA_POS_ERROR;

  bool          transactional_table, safe_update, const_cond;

  bool          const_cond_result;

  ha_rows       deleted= 0;

  SELECT_LEX   *select_lex= &thd->lex->select_lex;

  THD::killed_state killed_status= THD::NOT_KILLED;

  

 

  if (open_and_lock_tables(thd, table_list))

  /* TODO look at this error */

  if (!(table= table_list->table))

  {

    my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0), "", "");

  }

  table->map=1;

 

  if (mysql_prepare_delete(thd, table_list, &conds))

  /* check ORDER BY even if it can be ignored */

  if (order && order->elements)

  {

    List<Item>   fields;

    List<Item>   all_fields;

 

    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,

    {

      delete select;

      free_underlaid_joins(thd, &thd->lex->select_lex);

  if (thd->is_error())

  {

    /* Error evaluating val_int(). */

  }

 

  /*

      - there should be no delete triggers associated with the table.

  */

  if (!using_limit && const_cond_result &&

      (thd->lex->sql_command == SQLCOM_TRUNCATE ||

       (!thd->current_stmt_binlog_row_based)))

  {

    delete select;

    free_underlaid_joins(thd, select_lex);

    thd->row_count_func= 0;

    my_ok(thd, (ha_rows) thd->row_count_func);

    /*

      We don't need to call reset_auto_increment in this case, because

 

  if (order && order->elements)

  {

    SORT_FIELD  *sortorder;

    ha_rows examined_rows;

    

    if ((!select || table->quick_keys.is_clear_all()) && limit != HA_POS_ERROR)

 

    if (usable_index == MAX_KEY)

    {

      table->sort.io_cache= (IO_CACHE *) my_malloc(sizeof(IO_CACHE),

                                                   MYF(MY_FAE | MY_ZEROFILL));

    

                                             &length, NULL)) ||

          (table->sort.found_records = filesort(thd, table, sortorder, length,

                                                select, HA_POS_ERROR, 1,

  else

    init_read_record_idx(&info, thd, table, 1, usable_index);

 

 

  will_batch= !table->file->start_bulk_delete();

 

      table->file->print_error(loc_error,MYF(0));

    error=1;

  }

  end_read_record(&info);

  if (options & OPTION_QUICK)

    (void) table->file->extra(HA_EXTRA_NORMAL);

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

 

  if (!transactional_table && deleted > 0)

  

  /* See similar binlogging code in sql_update.cc, for comments */

  if ((error < 0) || thd->transaction.stmt.modified_non_trans_table)

      */

      int log_result= thd->binlog_query(THD::ROW_QUERY_TYPE,

                                        thd->query, thd->query_length,

 

      if (log_result && transactional_table)

      {

      }

    }

    if (thd->transaction.stmt.modified_non_trans_table)

  }

  assert(transactional_table || !deleted || thd->transaction.stmt.modified_non_trans_table);

  free_underlaid_joins(thd, select_lex);

 

  if (error < 0 || (thd->lex->ignore && !thd->is_fatal_error))

  {

    thd->row_count_func= deleted;

  return(error >= 0 || thd->is_error());

 

err:

}

 

 

    conds               - conditions

 

  RETURN VALUE

*/

{

  SELECT_LEX *select_lex= &thd->lex->select_lex;

  

  List<Item> all_fields;

                                    table_list, 

                                    &select_lex->leaf_tables, false) ||

      setup_conds(thd, table_list, select_lex->leaf_tables, conds))

  {

    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 0)))

    {

      update_non_unique_table_error(table_list, "DELETE", duplicate);

    }

  }

 

    fix_inner_refs(thd, all_fields, select_lex, select_lex->ref_pointer_array))

    return(-1);

 

}

 

 

extern "C" int refpos_order_cmp(void* arg, const void *a,const void *b)

{

  handler *file= (handler*)arg;

}

 

/*

    thd         thread handler

 

  RETURN

*/

 

int mysql_multi_delete_prepare(THD *thd)

{

  LEX *lex= thd->lex;

  

 

  /*

                                    &thd->lex->select_lex.top_join_list,

                                    lex->query_tables,

                                    &lex->select_lex.leaf_tables, false))

 

 

  /*

    Multi-delete can't be constructed over-union => we always have

    single SELECT on top and have to check underlying SELECTs of it

  */

  /* Fix tables-to-be-deleted-from list to point at opened tables */

       target_tbl;

       target_tbl= target_tbl->next_local)

  {

                  target_tbl->correspondent_table->merge_underlying_list->

                  next_local);

      my_error(ER_VIEW_DELETE_MERGE_VIEW, MYF(0), "", "");

    }

 

    /*

      inside subqueries/view.

    */

    {

      if ((duplicate= unique_table(thd, target_tbl->correspondent_table,

                                   lex->query_tables, 0)))

      {

        update_non_unique_table_error(target_tbl->correspondent_table,

                                      "DELETE", duplicate);

      }

    }

  }

}

 

 

  : delete_tables(dt), deleted(0), found(0),

    num_of_tables(num_of_tables_arg), error(0),

    do_delete(0), transactional_tables(0), normal_tables(0), error_handled(0)

 

 

int

{

  

  unit= u;

  do_delete= 1;

  return(0);

}

 

bool

multi_delete::initialize_tables(JOIN *join)

{

  Unique **tempfiles_ptr;

  

 

    if (tab->table->map & tables_to_delete_from)

    {

      /* We are going to delete from this table */

      walk= walk->next_local;

      /* Don't use KEYREAD optimization on this table */

      tbl->no_keyread=1;

  }

  for (;walk ;walk= walk->next_local)

  {

    *tempfiles_ptr++= new Unique (refpos_order_cmp,

                                  (void *) table->file,

                                  table->file->ref_length,

       table_being_deleted;

       table_being_deleted= table_being_deleted->next_local)

  {

    table->no_keyread=0;

  }

 

  {

    if (tempfiles[counter])

      delete tempfiles[counter];

}

 

 

{

  int secure_counter= delete_while_scanning ? -1 : 0;

  

 

  for (del_table= delete_tables;

       del_table;

       del_table= del_table->next_local, secure_counter++)

  {

 

    /* Check if we are using outer join and we didn't find the row */

    if (table->status & (STATUS_NULL_ROW | STATUS_DELETED))

      {

        deleted++;

        if (!table->file->has_transactions())

      }

      else

      {

}

 

 

{

  

 

    {

      thd->binlog_query(THD::ROW_QUERY_TYPE,

                        thd->query, thd->query_length,

    }

    thd->transaction.all.modified_non_trans_table= true;

  }

       table_being_deleted= table_being_deleted->next_local, counter++)

  { 

    ha_rows last_deleted= deleted;

    if (tempfiles[counter]->get(table))

    {

      local_error=1;

      }

    }

    if (last_deleted != deleted && !table->file->has_transactions())

    end_read_record(&info);

    if (thd->killed && !local_error)

      local_error= 1;

bool multi_delete::send_eof()

{

  THD::killed_state killed_status= THD::NOT_KILLED;

 

  /* Does deletes for the last n - 1 tables, returns 0 if ok */

  int local_error= do_deletes();                // returns 0 if success

  local_error= local_error || error;

  killed_status= (local_error == 0)? THD::NOT_KILLED : thd->killed;

  /* reset used flags */

 

  if ((local_error == 0) || thd->transaction.stmt.modified_non_trans_table)

  {

        thd->clear_error();

      if (thd->binlog_query(THD::ROW_QUERY_TYPE,

                            thd->query, thd->query_length,

          !normal_tables)

      {

        local_error=1;  // Log write failed: roll back the SQL statement

      }

    }

    if (thd->transaction.stmt.modified_non_trans_table)

  }

  if (local_error != 0)

 

  if (!local_error)

  {

 

 

/***************************************************************************

****************************************************************************/

 

/*

  - If we want to have a name lock on the table on exit without errors.

*/

 

{

  HA_CREATE_INFO create_info;

  char path[FN_REFLEN];

  bool error;

  

 

  /* If it is a temporary table, close and regenerate it */

  if (!dont_send_ok && (table= find_temporary_table(thd, table_list)))

  {

                                             OTM_OPEN))))

      (void) rm_temporary_table(table_type, path, frm_only);

    free_table_share(share);

    /*

      If we return here we will not have logged the truncation to the bin log

      and we will not my_ok() to the client.

                                    table_list->table_name, reg_ext, 0);

 

  if (!dont_send_ok)

 

  // 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;

  error= ha_create_table(thd, path, table_list->db, table_list->table_name,

                         &create_info, 1);

 

end:

  if (!dont_send_ok)

        TRUNCATE must always be statement-based binlogged (not row-based) so

        we don't test current_stmt_binlog_row_based.

      */

      my_ok(thd);               // This should return record count

    }

    unlock_table_name(thd, table_list);

  }

  else if (error)

  {

    unlock_table_name(thd, table_list);

  }

  return(error);

 

trunc_by_del:

  /* Probably InnoDB table */