~drizzle-trunk/drizzle/development

  assert(select_lex->db);

 

  /* Chicken/Egg... we need to search for the table, to know if the table exists, so we can build a full identifier from it */

  {

    TableIdentifier identifier(first_table->getSchemaName(), first_table->getTableName());

    if (plugin::StorageEngine::getTableDefinition(*session, identifier, original_table_message) != EEXIST)

    {

      return true;

    }

 

    if (not  create_info.db_type)

    {

      create_info.db_type= 

 

      if (not create_info.db_type)

      {

        return true;

      }

    }

  }

 

  if (not validateCreateTableOption())

    return true;

 

  /* ALTER TABLE ends previous transaction */

  if (not session->endActiveTransaction())

    return true;

 

    return true;

 

  bool res;

  {

    TableIdentifier identifier(first_table->getSchemaName(), first_table->getTableName());

    TableIdentifier new_identifier(select_lex->db ? select_lex->db : first_table->getSchemaName(),

                     identifier,

                     new_identifier,

                     &create_info,

                     create_table_message,

                     first_table,

                     &alter_info,

                       identifier,

                       new_identifier,

                       &create_info,

                       create_table_message,

                       first_table,

                       &alter_info,

     Release the protection against the global read lock and wake

     everyone, who might want to set a global read lock.

   */

  return res;

}

 

        if (def->sql_type == DRIZZLE_TYPE_BLOB)

        {

          my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);

        }

        if ((def->def= alter->def))

        {

          def->flags&= ~NO_DEFAULT_VALUE_FLAG;

        }

        else

          def->flags|= NO_DEFAULT_VALUE_FLAG;

        alter_it.remove();

      }

    }

    if (def->change && ! def->field)

    {

      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change, table->getMutableShare()->getTableName());

    }

    /*

    */

    {

      alter_info->error_if_not_empty= true;

    }

    if (! def->after)

      new_create_list.push_back(def);

    else if (def->after == first_keyword)

      new_create_list.push_front(def);

    else

    {

      CreateField *find;

      if (! find)

      {

        my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table->getMutableShare()->getTableName());

      }

      find_it.after(def); /* Put element after this */

      /*

      */

      if (alter_info->build_method == HA_BUILD_ONLINE)

      {

      }

      alter_info->build_method= HA_BUILD_OFFLINE;

    }

             MYF(0),

             alter_info->alter_list.head()->name,

             table->getMutableShare()->getTableName());

  }

  if (! new_create_list.elements)

  {

    my_message(ER_CANT_REMOVE_ALL_FIELDS,

               ER(ER_CANT_REMOVE_ALL_FIELDS),

               MYF(0));

  }

 

  /*

      if (key->type == Key::FOREIGN_KEY)

      {

        if (((Foreign_key *)key)->validate(new_create_list))

 

        Foreign_key *fkey= (Foreign_key*)key;

        add_foreign_key_to_table_message(&table_message,

        my_error(ER_WRONG_NAME_FOR_INDEX,

                 MYF(0),

                 key->name.str);

      }

    }

  }

    my_error(ER_CANT_DROP_FIELD_OR_KEY,

             MYF(0),

             alter_info->drop_list.head()->name);

  }

  if (alter_info->alter_list.elements)

  {

    my_error(ER_CANT_DROP_FIELD_OR_KEY,

             MYF(0),

             alter_info->alter_list.head()->name);

  }

 

  if (not table_message.options().has_comment()

  rc= false;

  alter_info->create_list.swap(new_create_list);

  alter_info->key_list.swap(new_key_list);

 

  size_t num_engine_options= table_message.engine().options_size();

  size_t original_num_engine_options= original_proto.engine().options_size();

 

  drizzled::message::update(table_message);

 

}

 

/* table_list should contain just one table */

 

  /* The ALTER Table is always in its own transaction */

  error= transaction_services.autocommitOrRollback(session, false);

    error=1;

  if (error)

    goto err;

 

err:

  (void) transaction_services.autocommitOrRollback(session, error);

 

      if (session.find_temporary_table(new_table_identifier))

      {

        return false;

      }

    }

 

      if (not name_lock)

      {

        return false;

      }

 

      if (plugin::StorageEngine::doesTableExist(session, new_table_identifier))

      {

        /* Table will be closed by Session::executeCommand() */

 

        session.unlink_open_table(name_lock);

 

        return false;

      }

  ha_rows copied= 0;

  ha_rows deleted= 0;

 

  session->set_proc_info("init");

 

  table->use_all_columns();

  if (original_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED) ||

      new_engine->check_flag(HTON_BIT_ALTER_NOT_SUPPORTED))

  {

 

    return true;

  }

          while the fact that the table is still open gives us protection

          from concurrent DDL statements.

        */

        wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);

        error= table->cursor->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);

        /* COND_refresh will be signaled in close_thread_tables() */

        break;

      case DISABLE:

        wait_while_table_is_used(session, table, HA_EXTRA_FORCE_REOPEN);

        error=table->cursor->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);

        /* COND_refresh will be signaled in close_thread_tables() */

        break;

                            table->getAlias());

      }

 

      /*

        Unlike to the above case close_cached_table() below will remove ALL

        instances of Table from table cache (it will also remove table lock

        held by this thread). So to make actual table renaming and writing

        to binlog atomic we have to put them into the same critical section

        access() and mysql_rename_table() calls.

      */

 

        */

        if (plugin::StorageEngine::doesTableExist(*session, new_table_identifier))

        {

          error= -1;

        }

        else

 

      if (error == 0)

      {

        session->my_ok();

      }

      else if (error > 0)

        error= -1;

      }

 

      table_list->table= NULL;

 

      return error;

 

  if (not new_table)

  {

    return true;

  }

 

    */

    if (alter_info->error_if_not_empty && session->row_count)

    {

    }

 

    if (original_table_identifier.isTmp())

      }

      else

      {

      }

 

      return true;

        delete new_table;

      }

 

 

 

      return true;

    }

    /* Close lock if this is a transactional table */

    if (session->lock)

    {

      session->lock= 0;

    }

 

      delete new_table;

    }

 

 

    /*

      Data is copied. Now we:

    if (mysql_rename_table(*session, original_engine, original_table_identifier, original_table_to_drop))

    {

      error= 1;

    }

    else

    {

        /* Try to get everything back. */

        error= 1;

 

 

 

        mysql_rename_table(*session, original_engine, original_table_to_drop, original_table_identifier);

      }

      else

      {

      }

    }

 

        from list of open tables list and table cache.

      */

      session->unlink_open_table(table);

 

      return true;

    }

 

 

    session->set_proc_info("end");

 

    table_list->table= NULL;

  }

 

 

    if (name_lock)

    {

      session->unlink_open_table(name_lock);

    }

  }

 

  /* 

   * LP Bug #552420 

   *

   * don't get the usual automatic call to StorageEngine::startStatement(), so

   * we manually call it here...

   */

  to->restoreRecordAsDefault();        // Create empty record

  while (!(error=info.read_record(&info)))

  {

    {

      session->send_kill_message();

      error= 1;

        to->next_number_field->reset();

    }

 

    {

      copy_ptr->do_copy(copy_ptr);

    }

    prev_insert_id= to->cursor->next_insert_id;

    error= to->cursor->insertRecord(to->record[0]);

    to->auto_increment_field_not_null= false;

 

    if (error)

    { 

      { 

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

        break;