~drizzle-trunk/drizzle/development

#include <drizzled/server_includes.h>

#include <drizzled/sql_select.h>

#include <drizzled/drizzled_error_messages.h>

static void prepare_record_for_error_message(int error, Table *table)

  uint32_t keynr;

    order_num           number of elemen in order_st BY clause

    order               order_st BY clause list

                 TableList *table_list,

                 List<Item> &values,

                 uint32_t order_num, order_st *order,

                 ha_rows limit,

                 enum enum_duplicates handle_duplicates __attribute__((unused)),

                 bool ignore)

  uint32_t          table_count= 0;

  Table         *table;

  uint64_t     id;

  DRIZZLE_UPDATE_START();

  thd->set_proc_info("init");

    DRIZZLE_UPDATE_END();

    DRIZZLE_UPDATE_END();

        Doing an order_st BY;  Let filesort find and sort the rows we are going

      uint32_t         length= 0;

      thd->set_proc_info("Searching rows for update");

  thd->set_proc_info("Updating");

  thd->abort_on_warning= test(!ignore);

      if (!can_compare_record || table->compare_record())

  thd->set_proc_info("end");

  table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);

  DRIZZLE_UPDATE_END();

  DRIZZLE_UPDATE_END();

    order_num           - number of order_st BY list entries

    order               - order_st BY clause list

bool mysql_prepare_update(THD *thd, TableList *table_list,

                         Item **conds, uint32_t order_num, order_st *order)

    Note that we may consider a statement as safe if order_st BY primary_key

    TableList *duplicate;

 

  TableList *table_list= lex->query_tables;

  TableList *tl, *leaves;

  uint32_t  table_count= lex->table_count;

    Table *table= tl->table;

      /* Update Table::lock_type accordingly. */

    for (TableList *tbl= table_list; tbl; tbl= tbl->next_global)

      TableList *duplicate;

                        TableList *table_list,

                        uint64_t options,

  thd->abort_on_warning= true;

                      conds, 0, (order_st *) NULL, (order_st *)NULL, (Item *) NULL,

                      (order_st *)NULL,

multi_update::multi_update(TableList *table_list,

                           TableList *leaves_list,

int multi_update::prepare(List<Item> &not_used_values __attribute__((unused)),

                          SELECT_LEX_UNIT *lex_unit __attribute__((unused)))

  TableList *table_ref;

  uint32_t i, max_fields;

  uint32_t leaf_table_count= 0;

  thd->set_proc_info("updating main table");

    Table *table=table_ref->table;

      TableList *tl= (TableList*) thd->memdup((char*) table_ref,

      update.link_in_list((unsigned char*) tl, (unsigned char**) &tl->next_local);

  update_tables= (TableList*) update.first;

  tmp_tables = (Table**) thd->calloc(sizeof(Table *) * table_count);

    uint32_t offset= item->field->table->pos_in_table_list->shared;

    the Table::write_set bitmap.

                               TableList *table_ref, TableList *all_tables)

  Table *table= join_tab->table;

  TableList *table_ref;

    Table *table=table_ref->table;

    uint32_t cnt= table_ref->shared;

    order_st     group;

    List_iterator_fast<Table> tbl_it(unupdated_check_opt_tables);

    Table *tbl= table;

#ifdef OLD

      Field_varstring *field= new Field_varstring(tbl->file->ref_length, 0,

                                                  tbl->alias, tbl->s, &my_charset_bin);

#endif

    memset(&group, 0, sizeof(group));

                                           (order_st*) &group, 0, 0,

  TableList *table;

    for (uint32_t cnt = 0; cnt < table_count; cnt++)

        tmp_tables[cnt]->free_tmp_table(thd);

  assert(trans_safe || !updated ||

bool multi_update::send_data(List<Item> &not_used_values __attribute__((unused)))

  TableList *cur_table;

    Table *table= cur_table->table;

    uint32_t offset= cur_table->shared;

      if (!can_compare_record || table->compare_record())

      Table *tmp_table= tmp_tables[offset];