~drizzle-trunk/drizzle/development

 

/* drop and alter of tables */

 

#include <plugin/myisam/myisam.h>

#include <drizzled/show.h>

#include <drizzled/error.h>

#include <drizzled/sql_lex.h>

#include <drizzled/session.h>

#include <drizzled/sql_base.h>

#include <drizzled/lock.h>

#include <drizzled/unireg.h>

#include <drizzled/item/int.h>

#include <drizzled/item/empty_string.h>

#include <drizzled/transaction_services.h>

#include <drizzled/table_proto.h>

#include <drizzled/plugin/client.h>

#include <drizzled/identifier.h>

 

#include <algorithm>

#include <sstream>

namespace drizzled

{

 

bool is_primary_key(KeyInfo *key_info)

{

  static const char * primary_key_name="PRIMARY";

void write_bin_log(Session *session, const std::string &query)

{

  TransactionServices &transaction_services= TransactionServices::singleton();

}

 

/*

                   bool drop_temporary)

{

  TableList *table;

  int error= 0;

  bool foreign_key_error= false;

 

      }

      identifier::Table identifier(table->getSchemaName(), table->getTableName(), table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);

 

      if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))

      {

        // Table was not found on disk and table can't be created from engine

        if (if_exists)

          push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,

                              ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),

                              table->getTableName());

        else

        {

          error= 1;

        /* Generate transaction event ONLY when we successfully drop */ 

        if (plugin::StorageEngine::dropTable(*session, identifier, local_error))

        {

        }

        else

        {

 

      if (error)

      {

      }

    }

 

 

  } while (0);

 

  {

    if (not foreign_key_error)

    {

      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),

    }

    else

    {

  int           timestamps= 0, timestamps_with_niladic= 0;

  int           dup_no;

  int           select_field_pos,auto_increment=0;

  uint32_t total_uneven_bit_length= 0;

 

  plugin::StorageEngine *engine= plugin::StorageEngine::findByName(create_proto.engine().name());

        interval= sql_field->interval= typelib(session->mem_root,

                                               sql_field->interval_list);

 

        String conv, *tmp;

        char comma_buf[4];

        int comma_length= cs->cset->wc_mb(cs, ',', (unsigned char*) comma_buf,

          interval->type_lengths[i]= lengthsp;

          ((unsigned char *)interval->type_names[i])[lengthsp]= '\0';

        }

      }

 

      /* DRIZZLE_TYPE_ENUM */

          else /* not NULL */

          {

            def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));

            {

              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);

              return(true);

      (*db_options)|= HA_OPTION_PACK_RECORD;

    }

 

  }

 

  /* record_offset will be increased with 'length-of-null-bits' later */

  record_offset= 0;

  null_fields+= total_uneven_bit_length;

 

  while ((sql_field=it++))

  {

    assert(sql_field->charset != 0);

 

  /* Create keys */

 

  uint32_t key_parts=0, fk_key_count=0;

  bool primary_key=0,unique_key=0;

  Key *key, *key2;

    }

    if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))

      return(true);

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

    {

      while ((key2 = key_iterator2++) != key)

  if (!*key_info_buffer || ! key_part_info)

    return(true);                               // Out of memory

 

  key_number=0;

  for (; (key=key_iterator++) ; key_number++)

  {

 

    message::Table::Field *protofield= NULL;

 

    for (uint32_t column_nr=0 ; (column=cols++) ; column_nr++)

    {

      uint32_t length;

      Key_part_spec *dup_column;

      int proto_field_nr= 0;

 

      field=0;

      while ((sql_field=it++) && ++proto_field_nr &&

             my_strcasecmp(system_charset_info,

          return(true);

        }

      }

 

      if (create_proto.field_size() > 0)

        protofield= create_proto.mutable_field(proto_field_nr - 1);

                     (qsort_cmp) sort_keys);

 

  /* Check fields. */

  while ((sql_field=it++))

  {

    Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);

 

    if (session->variables.sql_mode & MODE_NO_ZERO_DATE &&

        !sql_field->def &&

        (sql_field->flags & NOT_NULL_FLAG) &&

        (type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))

    {

        return error;

      }

 

 

      return error;

    }

      */

      if (definition::Cache::singleton().find(identifier.getKey()))

      {

 

        return error;

      }

  if (table_proto.type() == message::Table::STANDARD && not internal_tmp_table)

  {

    TransactionServices &transaction_services= TransactionServices::singleton();

  }

 

  return false;

 

  /* Build a Table object to pass down to the engine, and the do the actual create. */

  if (not prepare_create_table(session, create_info, table_proto, alter_info,

  {

    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* CREATE TABLE (some confussion on naming, double check) */

    error= locked_create_event(session,

    }

    else

    {

      result= true;

    }

  }

                                                            HA_CHECK_OPT *))

{

  TableList *table;

  List<Item> field_list;

  Item *item;

  int result_code= 0;

  TransactionServices &transaction_services= TransactionServices::singleton();

  const CHARSET_INFO * const cs= system_charset_info;

 

  if (! session->endActiveTransaction())

    return 1;

  field_list.push_back(item = new Item_empty_string("Table",

                                                    NAME_CHAR_LEN * 2,

                                                    cs));

 

  for (table= tables; table; table= table->next_local)

  {

    bool fatal_error=0;

 

    table->lock_type= lock_type;

    /* open only one table from local list of command */

    {

        so it have to be prepared.

        @todo Investigate if we can put extra tables into argument instead of using lex->query_tables

      */

      session->no_warnings_for_error= 0;

 

      session->openTablesLock(table);

    {

      char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];

      uint32_t length;

      session->getClient()->store(operator_name);

      session->getClient()->store(STRING_WITH_LEN("error"));

      length= snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),

      session->getClient()->store(buff, length);

      session->endTransaction(COMMIT);

      session->close_thread_tables();

      table->table=0;                           // For query cache

      if (session->getClient()->flush())

        goto err;

 

send_result:

 

    session->clear_error();  // these errors shouldn't get client

    {