~drizzle-trunk/drizzle/development

 

/* Insert of records */

 

#include <cstdio>

#include <drizzled/sql_select.h>

#include <drizzled/show.h>

#include <drizzled/sql_load.h>

#include <drizzled/field/epoch.h>

#include <drizzled/lock.h>

 

 

namespace drizzled

{

  }

  else

  {                                             // Part field list

    Name_resolution_context *context= &select_lex->context;

    Name_resolution_context_state ctx_state;

    int res;

  uint64_t id;

  CopyInfo info;

  Table *table= 0;

  List_item *values;

  Name_resolution_context *context;

  Name_resolution_context_state ctx_state;

    if (table != NULL)

      table->cursor->ha_release_auto_increment();

    if (!joins_freed)

    DRIZZLE_INSERT_DONE(1, 0);

    return true;

  }

  /* mysql_prepare_insert set table_list->table if it was not set */

  table= table_list->table;

 

  /*

    These three asserts test the hypothesis that the resetting of the name

    resolution context below is not necessary at all since the list of local

      if (table != NULL)

        table->cursor->ha_release_auto_increment();

      if (!joins_freed)

      DRIZZLE_INSERT_DONE(1, 0);

 

      return true;

      if (table != NULL)

        table->cursor->ha_release_auto_increment();

      if (!joins_freed)

      DRIZZLE_INSERT_DONE(1, 0);

      return true;

    }

  }

 

  /* Restore the current context. */

  ctx_state.restore_state(context, table_list);

  }

 

 

 

  table->mark_columns_needed_for_insert();

 

    session->row_count++;

  }

 

  joins_freed= true;

 

  /*

    if (table != NULL)

      table->cursor->ha_release_auto_increment();

    if (!joins_freed)

    DRIZZLE_INSERT_DONE(1, 0);

    return true;

  }

                                    !session->cuted_fields))

  {

    session->row_count_func= info.copied + info.deleted + info.updated;

                   info.copied + info.deleted + info.touched, id);

  }

  else

      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,

              (ulong) (info.deleted + info.updated), (ulong) session->cuted_fields);

    session->row_count_func= info.copied + info.deleted + info.updated;

                   info.copied + info.deleted + info.touched, id, buff);

  }

 

  return false;

}

     than INSERT.

  */

 

                                    table_list,

                                    select_insert))

    return(true);

 

                          bool select_insert,

                          bool check_fields, bool abort_on_warning)

{

  Name_resolution_context *context= &select_lex->context;

  Name_resolution_context_state ctx_state;

  bool insert_into_view= (0 != 0);

    inserting (for INSERT ... SELECT this is done by changing table_list,

    because INSERT ... SELECT share Select_Lex it with SELECT.

  */

  {

    for (Select_Lex_Unit *un= select_lex->first_inner_unit();

         un;

 

    if (!res && check_fields)

    {

      res= check_that_all_fields_are_given_values(session,

                                                  table ? table :

                                                  context->table_list->table,

                                                  context->table_list);

    }

 

    if (!res && duplic == DUP_UPDATE)

    /* Restore the current context. */

    ctx_state.restore_state(context, table_list);

 

      res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);

  }

 

  if (res)

    return(res);

 

    table= table_list->table;

 

  {

    TableList *duplicate;

    if ((duplicate= unique_table(table_list, table_list->next_global, true)))

      return true;

    }

  }

  if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)

    table->prepare_for_position();

 

err:

  info->last_errno= error;

  /* current_select is NULL if this is a delayed insert */

  table->print_error(error,MYF(0));

 

before_err:

      }

    }

  }

}

 

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

 

bool insert_select_prepare(Session *session)

{

  Select_Lex *select_lex= &lex->select_lex;

 

  /*

int

select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)

{

  int res;

  table_map map= 0;

 

 

  unit= u;

    select, LEX::current_select should point to the first select while

    we are fixing fields from insert list.

  */

  res= check_insert_fields(session, table_list, *fields, values,

                           !insert_into_view, &map) ||

       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);

 

  if (!res && fields->elements)

  {

    res= check_that_all_fields_are_given_values(session, table_list->table,

                                                table_list);

  }

 

  if (info.handle_duplicates == DUP_UPDATE && !res)

  {

    Name_resolution_context_state ctx_state;

 

    /* Save the state of the current name resolution context. */

      We use next_name_resolution_table descructively, so check it first (views?)

    */

    assert (!table_list->next_name_resolution_table);

      /*

        We must make a single context out of the two separate name resolution contexts :

        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.

        order to get correct values from those fields when the select

        employs a temporary table.

      */

      Item *item;

 

      while ((item= li++))

      {

        item->transform(&Item::update_value_transformer,

      }

    }

 

    ctx_state.restore_state(context, table_list);

  }

 

  if (res)

    return(1);

  /*

  if (unique_table(table_list, table_list->next_global))

  {

    /* Using same table for INSERT and SELECT */

  }

  {

    /*

      We must not yet prepare the result table if it is the same as one of the

  table->next_number_field=table->found_next_number_field;

 

  session->cuted_fields=0;

  if (info.ignore || info.handle_duplicates != DUP_ERROR)

    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);

  if (info.handle_duplicates == DUP_REPLACE)

    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);

  if (info.handle_duplicates == DUP_UPDATE)

    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);

  table->mark_columns_needed_for_insert();

 

 

 

int select_insert::prepare2(void)

{

    table->cursor->ha_start_bulk_insert((ha_rows) 0);

  return(0);

}

 

    table->cursor->ha_reset();

  }

  session->count_cuted_fields= CHECK_FIELD_IGNORE;

  return;

}

 

bool select_insert::send_data(List<Item> &values)

{

 

 

  if (unit->offset_limit_cnt)

  {                                             // using limit offset,count

    unit->offset_limit_cnt--;

  }

 

  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields

  store_values(values);

  session->count_cuted_fields= CHECK_FIELD_IGNORE;

  if (session->is_error())