~drizzle-trunk/drizzle/development : contents of drizzled/statement/create

~drizzle-trunk/drizzle/development : (revision 1802)

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2009 Sun Microsystems
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "config.h"
#include <drizzled/show.h>
#include <drizzled/lock.h>
#include <drizzled/session.h>
#include <drizzled/statement/create_table.h>
#include <drizzled/identifier.h>

#include <iostream>

namespace drizzled
{

bool statement::CreateTable::execute()
{
  TableList *first_table= (TableList *) session->lex->select_lex.table_list.first;
  TableList *all_tables= session->lex->query_tables;
  assert(first_table == all_tables && first_table != 0);
  Select_Lex *select_lex= &session->lex->select_lex;
  Select_Lex_Unit *unit= &session->lex->unit;
  bool need_start_waiting= false;
  bool res= false;
  bool link_to_local= false;
  bool lex_identified_temp_table= 
    create_table_message.type() == message::Table::TEMPORARY;

  if (is_engine_set)
  {
    create_info.db_type= 
      plugin::StorageEngine::findByName(*session, create_table_message.engine().name());

    if (create_info.db_type == NULL)
    {
      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), 
               create_table_message.engine().name().c_str());

      return true;
    }
  }
  else /* We now get the default, place it in create_info, and put the engine name in table proto */
  {
    create_info.db_type= session->getDefaultStorageEngine();
  }

  if (not validateCreateTableOption())
  {
    return true;
  }

  /* 
    Now we set the name in our Table proto so that it will match 
    create_info.db_type.
  */
  {
    create_table_message.mutable_engine()->set_name(create_info.db_type->getName());
  }


  /* If CREATE TABLE of non-temporary table, do implicit commit */
  if (not lex_identified_temp_table)
  {
    if (not session->endActiveTransaction())
    {
      return true;
    }
  }
  /* Skip first table, which is the table we are creating */
  TableList *create_table= session->lex->unlink_first_table(&link_to_local);
  TableList *select_tables= session->lex->query_tables;


  /*
    Now that we have the engine, we can figure out the table identifier. We need the engine in order
    to determine if the table is transactional or not if it is temp.
  */

  create_table_message.set_schema(create_table->db);

  TableIdentifier new_table_identifier(create_table->db,
                                       create_table->table_name,
                                       create_table_message.type());

  if (create_table_precheck(new_table_identifier))
  {
    /* put tables back for PS rexecuting */
    session->lex->link_first_table_back(create_table, link_to_local);
    return true;
  }

  /* Might have been updated in create_table_precheck */
  create_info.alias= create_table->alias;

  /*
     The create-select command will open and read-lock the select table
     and then create, open and write-lock the new table. If a global
     read lock steps in, we get a deadlock. The write lock waits for
     the global read lock, while the global read lock waits for the
     select table to be closed. So we wait until the global readlock is
     gone before starting both steps. Note that
     wait_if_global_read_lock() sets a protection against a new global
     read lock when it succeeds. This needs to be released by
     start_waiting_global_read_lock(). We protect the normal CREATE
     TABLE in the same way. That way we avoid that a new table is
     created during a gobal read lock.
   */
  if (! (need_start_waiting= ! wait_if_global_read_lock(session, 0, 1)))
  {
    /* put tables back for PS rexecuting */
    session->lex->link_first_table_back(create_table, link_to_local);
    return true;
  }

  if (select_lex->item_list.elements)		// With select
  {
    select_result *result;

    select_lex->options|= SELECT_NO_UNLOCK;
    unit->set_limit(select_lex);

    if (not lex_identified_temp_table)
    {
      session->lex->link_first_table_back(create_table, link_to_local);
      create_table->setCreate(true);
    }

    if (not (res= session->openTablesLock(session->lex->query_tables)))
    {
      /*
         Is table which we are changing used somewhere in other parts
         of query
       */
      if (not lex_identified_temp_table)
      {
        TableList *duplicate= NULL;
        create_table= session->lex->unlink_first_table(&link_to_local);
        if ((duplicate= unique_table(create_table, select_tables)))
        {
          my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->alias);
          /*
             Release the protection against the global read lock and wake
             everyone, who might want to set a global read lock.
           */
          start_waiting_global_read_lock(session);
          /* put tables back for PS rexecuting */
          session->lex->link_first_table_back(create_table, link_to_local);
          return true;
        }
      }

      /*
         select_create is currently not re-execution friendly and
         needs to be created for every execution of a PS/SP.
       */
      if ((result= new select_create(create_table,
                                     is_if_not_exists,
                                     &create_info,
                                     create_table_message,
                                     &alter_info,
                                     select_lex->item_list,
                                     session->lex->duplicates,
                                     session->lex->ignore,
                                     select_tables,
                                     new_table_identifier)))
      {
        /*
           CREATE from SELECT give its Select_Lex for SELECT,
           and item_list belong to SELECT
         */
        res= handle_select(session, session->lex, result, 0);
        delete result;
      }
    }
    else if (not lex_identified_temp_table)
    {
      create_table= session->lex->unlink_first_table(&link_to_local);
    }
  }
  else
  {
    /* regular create */
    if (is_create_table_like)
    {
      res= mysql_create_like_table(session, 
                                   new_table_identifier,
                                   create_table, 
                                   select_tables,
                                   create_table_message,
                                   is_if_not_exists,
                                   is_engine_set);
    }
    else
    {

      for (int32_t x= 0; x < alter_info.alter_proto.added_field_size(); x++)
      {
        message::Table::Field *field= create_table_message.add_field();

        *field= alter_info.alter_proto.added_field(x);
      }

      res= mysql_create_table(session, 
                              new_table_identifier,
                              &create_info,
                              create_table_message,
                              &alter_info, 
                              false, 
                              0,
                              is_if_not_exists);
    }

    if (not res)
    {
      session->my_ok();
    }
  }

  /*
     Release the protection against the global read lock and wake
     everyone, who might want to set a global read lock.
   */
  start_waiting_global_read_lock(session);

  return res;
}

bool statement::CreateTable::validateCreateTableOption()
{
  bool rc= true;
  size_t num_engine_options= create_table_message.engine().options_size();

  assert(create_info.db_type);

  for (size_t y= 0; y < num_engine_options; ++y)
  {
    bool valid= create_info.db_type->validateCreateTableOption(create_table_message.engine().options(y).name(),
                                                               create_table_message.engine().options(y).state());

    if (not valid)
    {
      my_error(ER_UNKNOWN_ENGINE_OPTION, MYF(0),
               create_table_message.engine().options(y).name().c_str(),
               create_table_message.engine().options(y).state().c_str());

      rc= false;
    }
  }

  return rc;
}

} /* namespace drizzled */


1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	1	/* -- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; --
	2	* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
	3	*
	4	* Copyright (C) 2009 Sun Microsystems
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
1241.9.36 by Monty Taylor ZOMG. I deleted drizzled/server_includes.h.	21	#include "config.h"
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	22	#include <drizzled/show.h>
	23	#include <drizzled/lock.h>
	24	#include <drizzled/session.h>
	25	#include <drizzled/statement/create_table.h>
1660.1.1 by Brian Aker Merge in move identifier work.	26	#include <drizzled/identifier.h>
1245.3.3 by Stewart Smith convert builtin table options to use key,value code in parser	27
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	28	#include <iostream>
	29
1130.3.12 by Monty Taylor using namespace drizzled; to namespace drizzled { in statement/	30	namespace drizzled
	31	{
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	32
	33	bool statement::CreateTable::execute()
	34	{
	35	TableList first_table= (TableList ) session->lex->select_lex.table_list.first;
	36	TableList *all_tables= session->lex->query_tables;
	37	assert(first_table == all_tables && first_table != 0);
	38	Select_Lex *select_lex= &session->lex->select_lex;
	39	Select_Lex_Unit *unit= &session->lex->unit;
	40	bool need_start_waiting= false;
	41	bool res= false;
	42	bool link_to_local= false;
1222.2.2 by Brian Aker Remove last ofl HA_CREATE_INFO being involved with temporary tables (always	43	bool lex_identified_temp_table=
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	44	create_table_message.type() == message::Table::TEMPORARY;
1245.3.7 by Stewart Smith error out on invalid table options	45
1222.1.3 by Brian Aker Remove used flag for engine.	46	if (is_engine_set)
1160.1.5 by Brian Aker Final parser SE removal.	47	{
1160.1.5 by Brian Aker Final parser SE removal.	48	create_info.db_type=
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	49	plugin::StorageEngine::findByName(*session, create_table_message.engine().name());
1160.1.5 by Brian Aker Final parser SE removal.	50
	51	if (create_info.db_type == NULL)
	52	{
	53	my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0),
1720.4.1 by LinuxJedi Fix error to show storage engine not table name	54	create_table_message.engine().name().c_str());
1160.1.5 by Brian Aker Final parser SE removal.	55
	56	return true;
	57	}
	58	}
	59	else /* We now get the default, place it in create_info, and put the engine name in table proto */
	60	{
1183.1.1 by Brian Aker Rework interface pieces on SE (sort of... dumb ones...)	61	create_info.db_type= session->getDefaultStorageEngine();
1160.1.5 by Brian Aker Final parser SE removal.	62	}
1160.1.5 by Brian Aker Final parser SE removal.	63
1502.1.30 by Brian Aker First pass on cleanup of Stewart's patch, plus re-engineer to make it work a	64	if (not validateCreateTableOption())
	65	{
	66	return true;
	67	}
1172.1.1 by Brian Aker Add in support for ENGINE= in create table like.	68
1160.1.5 by Brian Aker Final parser SE removal.	69	/*
	70	Now we set the name in our Table proto so that it will match
	71	create_info.db_type.
	72	*/
	73	{
1502.1.31 by Brian Aker Merge engine options for schema/table.	74	create_table_message.mutable_engine()->set_name(create_info.db_type->getName());
1160.1.5 by Brian Aker Final parser SE removal.	75	}
1160.1.5 by Brian Aker Final parser SE removal.	76
1172.1.1 by Brian Aker Add in support for ENGINE= in create table like.	77
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	78	/* If CREATE TABLE of non-temporary table, do implicit commit */
1320.1.8 by Brian Aker Temporary fix for allowing engines to say "don't do this".	79	if (not lex_identified_temp_table)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	80	{
1320.1.8 by Brian Aker Temporary fix for allowing engines to say "don't do this".	81	if (not session->endActiveTransaction())
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	82	{
	83	return true;
	84	}
	85	}
	86	/* Skip first table, which is the table we are creating */
	87	TableList *create_table= session->lex->unlink_first_table(&link_to_local);
	88	TableList *select_tables= session->lex->query_tables;
1128.2.3 by Brian Aker Remove create_info from global	89
1223.4.1 by Brian Aker Table Identifier patch.	90
1235.1.3 by Brian Aker Remove the need for trans/non-trans temp tables for lock conditions.	91	/*
1223.4.1 by Brian Aker Table Identifier patch.	92	Now that we have the engine, we can figure out the table identifier. We need the engine in order
	93	to determine if the table is transactional or not if it is temp.
	94	*/
1337.2.2 by Stewart Smith Add Schema to table message. modify alter table to correctly set a schema when running ALTER TABLE. Also update show_table_message test results to reflect the new field.	95
1353 by Brian Aker Merge Stewart, but I dropped the plugin for now.	96	create_table_message.set_schema(create_table->db);
1337.2.2 by Stewart Smith Add Schema to table message. modify alter table to correctly set a schema when running ALTER TABLE. Also update show_table_message test results to reflect the new field.	97
1223.4.1 by Brian Aker Table Identifier patch.	98	TableIdentifier new_table_identifier(create_table->db,
1223.4.3 by Brian Aker More identifier work.	99	create_table->table_name,
1395.1.7 by Brian Aker Removed the internal table type in favor of the protobuf one.	100	create_table_message.type());
1223.4.1 by Brian Aker Table Identifier patch.	101
1223.4.1 by Brian Aker Table Identifier patch.	102	if (create_table_precheck(new_table_identifier))
1100.3.67 by Padraig O'Sullivan Various small style cleanups.	103	{
	104	/* put tables back for PS rexecuting */
	105	session->lex->link_first_table_back(create_table, link_to_local);
	106	return true;
	107	}
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	108
	109	/* Might have been updated in create_table_precheck */
	110	create_info.alias= create_table->alias;
	111
	112	/*
	113	The create-select command will open and read-lock the select table
	114	and then create, open and write-lock the new table. If a global
	115	read lock steps in, we get a deadlock. The write lock waits for
	116	the global read lock, while the global read lock waits for the
	117	select table to be closed. So we wait until the global readlock is
	118	gone before starting both steps. Note that
	119	wait_if_global_read_lock() sets a protection against a new global
	120	read lock when it succeeds. This needs to be released by
	121	start_waiting_global_read_lock(). We protect the normal CREATE
	122	TABLE in the same way. That way we avoid that a new table is
	123	created during a gobal read lock.
	124	*/
	125	if (! (need_start_waiting= ! wait_if_global_read_lock(session, 0, 1)))
	126	{
1100.3.67 by Padraig O'Sullivan Various small style cleanups.	127	/* put tables back for PS rexecuting */
	128	session->lex->link_first_table_back(create_table, link_to_local);
	129	return true;
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	130	}
1172.1.1 by Brian Aker Add in support for ENGINE= in create table like.	131
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	132	if (select_lex->item_list.elements) // With select
	133	{
	134	select_result *result;
	135
	136	select_lex->options\|= SELECT_NO_UNLOCK;
	137	unit->set_limit(select_lex);
	138
1340.1.1 by Brian Aker Length usage of identifier down the tree.	139	if (not lex_identified_temp_table)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	140	{
	141	session->lex->link_first_table_back(create_table, link_to_local);
1637.2.6 by Vijay Samuel Merge encapsulate TableList-1.	142	create_table->setCreate(true);
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	143	}
	144
1340.1.1 by Brian Aker Length usage of identifier down the tree.	145	if (not (res= session->openTablesLock(session->lex->query_tables)))
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	146	{
	147	/*
	148	Is table which we are changing used somewhere in other parts
	149	of query
	150	*/
1340.1.1 by Brian Aker Length usage of identifier down the tree.	151	if (not lex_identified_temp_table)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	152	{
	153	TableList *duplicate= NULL;
	154	create_table= session->lex->unlink_first_table(&link_to_local);
1220.1.13 by Brian Aker Remove mysql_lock_have_duplicate() (we don't have merge, and our partition	155	if ((duplicate= unique_table(create_table, select_tables)))
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	156	{
	157	my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->alias);
1100.3.67 by Padraig O'Sullivan Various small style cleanups.	158	/*
	159	Release the protection against the global read lock and wake
	160	everyone, who might want to set a global read lock.
	161	*/
	162	start_waiting_global_read_lock(session);
	163	/* put tables back for PS rexecuting */
	164	session->lex->link_first_table_back(create_table, link_to_local);
	165	return true;
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	166	}
	167	}
	168
	169	/*
	170	select_create is currently not re-execution friendly and
	171	needs to be created for every execution of a PS/SP.
	172	*/
	173	if ((result= new select_create(create_table,
1222.2.3 by Brian Aker Remove a few more options, from options in HA_CREATE_INFO.	174	is_if_not_exists,
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	175	&create_info,
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	176	create_table_message,
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	177	&alter_info,
	178	select_lex->item_list,
	179	session->lex->duplicates,
	180	session->lex->ignore,
1340.1.1 by Brian Aker Length usage of identifier down the tree.	181	select_tables,
	182	new_table_identifier)))
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	183	{
	184	/*
	185	CREATE from SELECT give its Select_Lex for SELECT,
	186	and item_list belong to SELECT
	187	*/
	188	res= handle_select(session, session->lex, result, 0);
	189	delete result;
	190	}
	191	}
1340.1.1 by Brian Aker Length usage of identifier down the tree.	192	else if (not lex_identified_temp_table)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	193	{
	194	create_table= session->lex->unlink_first_table(&link_to_local);
	195	}
	196	}
	197	else
	198	{
	199	/* regular create */
1222.2.3 by Brian Aker Remove a few more options, from options in HA_CREATE_INFO.	200	if (is_create_table_like)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	201	{
	202	res= mysql_create_like_table(session,
1340.1.1 by Brian Aker Length usage of identifier down the tree.	203	new_table_identifier,
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	204	create_table,
	205	select_tables,
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	206	create_table_message,
1222.1.3 by Brian Aker Remove used flag for engine.	207	is_if_not_exists,
1222.1.3 by Brian Aker Remove used flag for engine.	208	is_engine_set);
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	209	}
	210	else
	211	{
1215.1.1 by stewart at flamingspork [patch 01/17] horrible hack to have one lonely codepath produce Fields in the table proto	212
1220.1.11 by Brian Aker Committing Stewart's work	213	for (int32_t x= 0; x < alter_info.alter_proto.added_field_size(); x++)
1215.1.1 by stewart at flamingspork [patch 01/17] horrible hack to have one lonely codepath produce Fields in the table proto	214	{
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	215	message::Table::Field *field= create_table_message.add_field();
1215.1.1 by stewart at flamingspork [patch 01/17] horrible hack to have one lonely codepath produce Fields in the table proto	216
1220.1.11 by Brian Aker Committing Stewart's work	217	*field= alter_info.alter_proto.added_field(x);
1215.1.1 by stewart at flamingspork [patch 01/17] horrible hack to have one lonely codepath produce Fields in the table proto	218	}
	219
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	220	res= mysql_create_table(session,
1223.4.1 by Brian Aker Table Identifier patch.	221	new_table_identifier,
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	222	&create_info,
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	223	create_table_message,
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	224	&alter_info,
1223.4.3 by Brian Aker More identifier work.	225	false,
1222.2.3 by Brian Aker Remove a few more options, from options in HA_CREATE_INFO.	226	0,
	227	is_if_not_exists);
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	228	}
1340.1.4 by Brian Aker A first pass through adding a timestamp to our proto.	229
1320.1.8 by Brian Aker Temporary fix for allowing engines to say "don't do this".	230	if (not res)
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	231	{
	232	session->my_ok();
	233	}
	234	}
	235
	236	/*
	237	Release the protection against the global read lock and wake
	238	everyone, who might want to set a global read lock.
	239	*/
	240	start_waiting_global_read_lock(session);
1100.3.67 by Padraig O'Sullivan Various small style cleanups.	241
1100.3.65 by Padraig O'Sullivan Extracted the CREATE TABLE command into its own class and implementation	242	return res;
	243	}
1130.3.12 by Monty Taylor using namespace drizzled; to namespace drizzled { in statement/	244
1502.1.30 by Brian Aker First pass on cleanup of Stewart's patch, plus re-engineer to make it work a	245	bool statement::CreateTable::validateCreateTableOption()
	246	{
	247	bool rc= true;
	248	size_t num_engine_options= create_table_message.engine().options_size();
	249
	250	assert(create_info.db_type);
	251
	252	for (size_t y= 0; y < num_engine_options; ++y)
	253	{
	254	bool valid= create_info.db_type->validateCreateTableOption(create_table_message.engine().options(y).name(),
	255	create_table_message.engine().options(y).state());
	256
	257	if (not valid)
	258	{
	259	my_error(ER_UNKNOWN_ENGINE_OPTION, MYF(0),
	260	create_table_message.engine().options(y).name().c_str(),
	261	create_table_message.engine().options(y).state().c_str());
	262
	263	rc= false;
	264	}
	265	}
	266
	267	return rc;
	268	}
	269
1130.3.12 by Monty Taylor using namespace drizzled; to namespace drizzled { in statement/	270	} /* namespace drizzled */
	271