bk commit into 6.0 tree (cbell:1.2607) WL#4342

[cbell]

Below is the list of changes that have just been committed into a local
6.0 repository of cbell.  When cbell does a push these changes
will be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2008-04-09 08:56:04-04:00, cbell@mysql_cab_desk. +4 -0
  WL#4342 : ST: extend server service interface to include tablespace objects
    
  Patch contains modifications to support backup and restore of Falcon
  tables with tablespaces.
    
  Note: Patch may change pending work ongoing by Falcon team.

  mysql-test/t/backup_tablespace.test@stripped, 2008-04-09 08:55:59-04:00,
cbell@mysql_cab_desk. +84 -0
    WL#4342 : ST: extend server service interface to include tablespace objects
        
    New test for tablespace backup and restore (incomplete pending patches
    for stream and kernel changes).
    

  mysql-test/t/backup_tablespace.test@stripped, 2008-04-09 08:55:59-04:00,
cbell@mysql_cab_desk. +0 -0

  sql/si_objects.cc@stripped, 2008-04-09 08:55:57-04:00, cbell@mysql_cab_desk. +523 -3
    WL#4342 : ST: extend server service interface to include tablespace objects
        
    This patch adds a new object class to the service interface. This class
    encapsulates working with tablespaces. Additional helper methods were
    added to allow the backup kernel code access to macro operations.
        
    Note: This is currently limited to Falcon tablespaces.

  sql/si_objects.h@stripped, 2008-04-09 08:55:58-04:00, cbell@mysql_cab_desk. +36 -0
    WL#4342 : ST: extend server service interface to include tablespace objects
        
    This patch adds a new object class to the service interface. This class
    encapsulates working with tablespaces. Additional helper methods were
    added to allow the backup kernel code access to macro operations.
        
    Note: This is currently limited to Falcon tablespaces.

  sql/table.h@stripped, 2008-04-09 08:55:59-04:00, cbell@mysql_cab_desk. +3 -1
    WL#4342 : ST: extend server service interface to include tablespace objects
        
    Added Falcon tablespaces to enum.

diff -Nrup a/mysql-test/t/backup_tablespace.test b/mysql-test/t/backup_tablespace.test
--- /dev/null	Wed Dec 31 16:00:00 196900
+++ b/mysql-test/t/backup_tablespace.test	2008-04-09 08:55:59 -04:00
@@ -0,0 +1,84 @@
+#
+# This test includes tests for backup and restore of tables that use
+# tablespaces.
+#
+# Note: This test is limited to the falcon storage engine only.
+#
+
+--source include/have_falcon.inc
+--source include/not_embedded.inc
+
+--disable_warnings
+DROP DATABASE IF EXISTS backup_ts;
+--error 0,1
+--remove_file $MYSQLTEST_VARDIR/master-data/backup_ts.bak;
+--enable_warnings
+
+CREATE DATABASE backup_ts;
+
+#
+# Test 1 - Test backup of database with a table that uses a tablespace
+#
+--echo Test 1:
+--echo Create a tablespace.
+CREATE TABLESPACE bup_ts ADD DATAFILE 'bup_ts.dat' COMMENT = 'test tablespace backup'
ENGINE=FALCON;
+
+--echo Create tables and add data.
+CREATE TABLE backup_ts.not_ts (id int, comment char(40)) ENGINE=FALCON;
+CREATE TABLE backup_ts.has_ts (id int, comment char(40))
+                               TABLESPACE bup_ts ENGINE=FALCON;
+
+# Create some data.
+INSERT INTO backup_ts.not_ts VALUES (1, "no tablespace 1");
+INSERT INTO backup_ts.not_ts VALUES (2, "no tablespace 2");
+INSERT INTO backup_ts.not_ts VALUES (3, "no tablespace 3");
+INSERT INTO backup_ts.not_ts VALUES (4, "no tablespace 4");
+INSERT INTO backup_ts.not_ts VALUES (5, "no tablespace 5");
+
+INSERT INTO backup_ts.has_ts VALUES (51, "Table has a tablespace 51");
+INSERT INTO backup_ts.has_ts VALUES (52, "Table has a tablespace 52");
+INSERT INTO backup_ts.has_ts VALUES (53, "Table has a tablespace 53");
+INSERT INTO backup_ts.has_ts VALUES (54, "Table has a tablespace 54");
+INSERT INTO backup_ts.has_ts VALUES (55, "Table has a tablespace 55");
+
+# Backup the database with tablespace.
+--replace_column 1 #
+BACKUP DATABASE backup_ts TO 'backup_ts.bak';
+
+# Drop the database
+--echo Drop the database.
+DROP DATABASE backup_ts;
+
+# Restore the database and ensure there are no errors.
+--echo Now restore the database.
+--replace_column 1 #
+RESTORE FROM 'backup_ts.bak';
+
+--echo Show data
+SELECT * FROM backup_ts.not_ts;
+SELECT * FROM backup_ts.has_ts;
+
+DROP DATABASE backup_ts;
+
+#
+# Test 2 - Test restore of database throws error when tablespace
+#          has been altered.
+#
+--echo Test 2:
+--echo Alter the tablespace.
+DROP TABLESPACE bup_ts;
+CREATE TABLESPACE bup_ts ADD DATABASE 'different.dat' ENGINE= FALCON;
+
+# Restore the database and ensure there is an error.
+--echo Now restore the database.
+--error 1200
+--replace_column 1 #
+RESTORE FROM 'backup_ts.bak';
+
+--echo Cleanup
+DROP TABLESPACE bup_ts ENGINE=FALCON;
+DROP DATABASE backup_ts;
+
+--error 0,1
+--remove_file $MYSQLTEST_VARDIR/master-data/backup_ts.bak
+
diff -Nrup a/sql/si_objects.cc b/sql/si_objects.cc
--- a/sql/si_objects.cc	2008-03-23 09:59:06 -04:00
+++ b/sql/si_objects.cc	2008-04-09 08:55:57 -04:00
@@ -273,6 +273,12 @@ bool drop_object(THD *thd, const char *o
 
   @param[in] thd  Thread context
   @param[in] st   Schema table enum
+  @param[in] db_list List of databases for select condition
+
+  @note: The select condition is designed to form a WHERE clause based on
+  the database/schema column of the information_schema views. Most views have
+  a database/schema column but for those that do not, you must ignore the 
+  selection condition by passing db_list = NULL.
 
   @retval TABLE* The schema table
 */
@@ -308,7 +314,13 @@ TABLE* open_schema_table(THD *thd, ST_SC
 
   old_map= tmp_use_all_columns(t, t->read_set);
 
-  st->fill_table(thd, &arg, obs::create_db_select_condition(thd, t, db_list));
+  /*
+    Create a selection condition only if db_list is defined.
+  */
+  if (db_list)
+    st->fill_table(thd, &arg, obs::create_db_select_condition(thd, t, db_list));
+  else
+    st->fill_table(thd, &arg, NULL);
 
   tmp_restore_column_map(t->read_set, old_map);
 
@@ -698,6 +710,64 @@ private:
   String m_create_stmt;
 };
 
+/**
+   @class TablespaceObj
+
+   This class provides an abstraction to a user object for creation and
+   capture of the creation data.
+*/
+class TablespaceObj : public Obj
+{
+public:
+  TablespaceObj(const String *ts_name);
+  
+public:
+  virtual bool serialize(THD *thd, String *serialization);
+
+  virtual bool materialize(uint serialization_version,
+                           const String *serialization);
+
+  virtual bool execute(THD *thd);
+
+  const String *describe();
+
+  const String *build_serialization();
+
+  /*
+    The get_db_name primitive is not used for tablespaces.
+  */
+  const String *get_db_name() { return 0; }
+
+  const String* get_name()
+  { return &m_ts_name; }
+
+  const String* get_datafile()
+  { return &m_datafile; }
+
+  const String* get_comments()
+  { return &m_comments; }
+
+  void set_datafile(const String *df)
+  { m_datafile.copy(*df); }
+
+  void set_comments(const String *c)
+  { m_comments.copy(*c); }
+
+private:
+  // These attributes are to be used only for serialization.
+  String m_ts_name;
+  String m_datafile;
+  String m_comments;
+
+  // Drop is not supported by this object.
+  bool drop(THD *thd)
+  { return 0; }
+
+private:
+  // These attributes are to be used only for materialization.
+  String m_create_stmt;
+};
+
 ///////////////////////////////////////////////////////////////////////////
 
 //
@@ -906,6 +976,7 @@ private:
   String m_db_name;
 };
 
+
 ///////////////////////////////////////////////////////////////////////////
 
 class ViewBaseObjectsIterator : public ObjIterator
@@ -962,8 +1033,31 @@ bool InformationSchemaIterator::prepare_
   enum_schema_tables is_table_idx,
   List<LEX_STRING> db_list)
 {
-  *is_table= open_schema_table(thd, get_schema_table(is_table_idx), &db_list);
-
+  ST_SCHEMA_TABLE *st;
+  /*
+    The falcon schema table does not conform to the older SHOW 
+    style fill methods nor does it use a wildcard condition.
+  */
+  switch (is_table_idx) {
+    case SCH_FALCON_TABLESPACES:
+    {
+      st= find_schema_table(thd, "FALCON_TABLESPACES");
+      *is_table= open_schema_table(thd, st, NULL);
+      break;
+    }
+    case SCH_FALCON_TABLESPACE_FILES:
+    {
+      st= find_schema_table(thd, "FALCON_TABLESPACE_FILES");
+      *is_table= open_schema_table(thd, st, NULL);
+      break;
+    }
+    default:
+    {
+      st= get_schema_table(is_table_idx);
+      *is_table= open_schema_table(thd, st, &db_list);
+      break;
+    }
+  }
   if (!*is_table)
     return TRUE;
 
@@ -2324,6 +2418,137 @@ bool EventObj::drop(THD *thd)
 
 ///////////////////////////////////////////////////////////////////////////
 
+//
+// Implementation: TablespaceObj class.
+//
+
+/////////////////////////////////////////////////////////////////////////////
+
+TablespaceObj::TablespaceObj(const String *ts_name)
+{
+  // copy strings to newly allocated memory
+  m_ts_name.copy(*ts_name);
+  m_datafile.length(0);
+  m_comments.length(0);
+}
+
+/**
+  Serialize the object.
+
+  This method produces the data necessary for materializing the object
+  on restore (creates object).
+
+  @param[in]  thd            Thread context.
+  @param[out] serialization  The data needed to recreate this object.
+
+  @returns Error status.
+    @retval FALSE on success
+    @retval TRUE on error
+*/
+bool TablespaceObj::serialize(THD *thd, String *serialization)
+{
+  DBUG_ENTER("TablespaceObj::serialize()");
+  build_serialization();
+  serialization->copy(m_create_stmt);
+  DBUG_RETURN(FALSE);
+}
+
+/**
+  Materialize the serialization string.
+
+  This method saves serialization string into a member variable.
+
+  @param[in]  serialization_version   version number of this interface
+  @param[in]  serialization           the string from serialize()
+
+  @todo take serialization_version into account
+
+  @returns Error status.
+    @retval FALSE on success
+    @retval TRUE on error
+*/
+bool TablespaceObj::materialize(uint serialization_version,
+                                const String *serialization)
+{
+  DBUG_ENTER("TablespaceObj::materialize()");
+  m_create_stmt.copy(*serialization);
+  DBUG_RETURN(FALSE);
+}
+
+/**
+  Get a description of the tablespace object.
+
+  This method returns the description of the object which is currently
+  the serialization string.
+
+  @returns Serialization string.
+*/
+const String *TablespaceObj::describe()
+{
+  DBUG_ENTER("TablespaceObj::describe()");
+  DBUG_RETURN(build_serialization());
+}
+
+/**
+  Build the serialization string.
+
+  This constructs the serialization string for identification
+  use in describing tablespace to the user and for creating the
+  tablespace.
+
+  @todo take serialization_version into account
+
+  @returns Serialization string.
+*/
+const String *TablespaceObj::build_serialization()
+{
+  DBUG_ENTER("TablespaceObj::build_serialization()");
+
+  if (m_create_stmt.length())
+    DBUG_RETURN(&m_create_stmt);
+
+  /*
+    Construct the CREATE TABLESPACE command from the variables.
+  */
+  m_create_stmt.length(0);
+  m_create_stmt.append("CREATE TABLESPACE ");
+  if (m_ts_name.length() > 0)
+  {
+    THD *thd= current_thd;
+    append_identifier(thd, &m_create_stmt, 
+      m_ts_name.c_ptr(), m_ts_name.length());  
+  }
+  m_create_stmt.append(" ADD DATAFILE '");
+  m_create_stmt.append(m_datafile);
+  if (m_comments.length())
+  {
+    m_create_stmt.append("' COMMENT = '");
+    m_create_stmt.append(m_comments);
+  }
+  m_create_stmt.append("' ENGINE=FALCON");
+  DBUG_RETURN(&m_create_stmt);
+}
+
+/**
+  Create the object.
+
+  This method uses serialization string in a query and executes it.
+
+  @param[in]  thd  Thread context.
+
+  @returns Error status.
+    @retval FALSE on success
+    @retval TRUE on error
+*/
+bool TablespaceObj::execute(THD *thd)
+{
+  DBUG_ENTER("TablespaceObj::execute()");
+  build_serialization(); // Build the CREATE command.
+  DBUG_RETURN(silent_exec(thd, &m_create_stmt));
+}
+
+///////////////////////////////////////////////////////////////////////////
+
 Obj *get_database(const String *db_name)
 {
   return new DatabaseObj(db_name);
@@ -2443,6 +2668,16 @@ Obj *materialize_event(const String *db_
   return obj;
 }
 
+Obj *materialize_tablespace(const String *ts_name,
+                            uint serialization_version,
+                            const String *serialialization)
+{
+  Obj *obj= new TablespaceObj(ts_name);
+  obj->materialize(serialization_version, serialialization);
+
+  return obj;
+}
+
 ///////////////////////////////////////////////////////////////////////////
 
 bool is_internal_db_name(const String *db_name)
@@ -2464,6 +2699,291 @@ bool is_internal_db_name(const String *d
 bool check_db_existence(const String *db_name)
 {
   return check_db_dir_existence(((String *) db_name)->c_ptr_safe());
+}
+
+/**
+  Locate the row in the information_schema view for this tablespace.
+
+  This method returns a row from a tablespace information_schema view
+  that matches the tablespace name passed. 
+
+  @param[in]     thd           Thread context
+  @param[in]     is_table_idx  The information schema to search
+  @param[in]     ts_name       The name of the tablespace to find
+  @param[out]    datafile      The datafile for the tablespace
+  @param[out]    comments      The comments for the tablespace
+  
+  @retval FALSE if tablespace exists and no errors
+  @retval TRUE if tablespace does not exist or errors
+*/
+static bool find_tablespace_schema_row(THD *thd,
+                                       enum_schema_tables is_table_idx,
+                                       const String *ts_name,
+                                       String *datafile,
+                                       String *comments)
+{
+  TABLE *is_table;
+  handler *ha;
+  my_bitmap_map *orig_col;
+  LEX_STRING lex_ts_name;
+  String found_ts_name;
+  bool retval= FALSE;
+  String data;
+  List<LEX_STRING> ts_list;
+  DBUG_ENTER("obs::find_tablespace_schema_row()");
+
+  /*
+    First, open the IS table.
+  */
+  lex_ts_name.str= (char *)ts_name->ptr();
+  lex_ts_name.length= ts_name->length();
+  ts_list.push_back(&lex_ts_name);
+
+  if (InformationSchemaIterator::prepare_is_table(
+      thd, &is_table, &ha, &orig_col, is_table_idx, ts_list))
+    DBUG_RETURN(TRUE);
+
+  /*
+    Now read from the IS table.
+  */
+  if (ha->rnd_next(is_table->record[0]))
+  {
+    retval= TRUE;
+    goto end;
+  }
+
+  /*    
+    Attempt to locate the row in the tablespaces table.
+    If found, proceed to the retrieving the data.
+  */
+  int ret= 0;
+  is_table->field[0]->val_str(&found_ts_name);
+  while (!ret && found_ts_name.length() &&
+    (strncasecmp(found_ts_name.ptr(), ts_name->ptr(), 
+     ts_name->length()) != 0))
+  {
+    ret= ha->rnd_next(is_table->record[0]);
+    found_ts_name.length(0); // reset the length of the string
+    if (!ret)
+      is_table->field[0]->val_str(&found_ts_name);
+  }
+  if (ret || (found_ts_name.length() == 0))
+  {
+    retval= TRUE;
+    goto end;
+  }
+
+  /*
+    TS name is in col 0 in FALCON_TABLESPACES
+    TS comment is in col 2 in FALCON_TABLESPACES
+    TS datafile is in col 3 in FALCON_TABLESPACE_FILES
+  */
+  switch (is_table_idx) {
+    case SCH_FALCON_TABLESPACES:
+    {
+      is_table->field[2]->val_str(&data);
+      comments->copy(data);
+      break;
+    }
+    case SCH_FALCON_TABLESPACE_FILES:
+    {
+      is_table->field[3]->val_str(&data);
+      datafile->copy(data);
+      break;
+    }
+    default:
+    {
+      retval= TRUE;  //error
+      goto end;
+    }
+  }
+  DBUG_PRINT("find_tablespace_schema_row", (" Found tablespace %s", 
+    found_ts_name.ptr()));
+
+  /*
+    Cleanup
+  */
+end:
+  ha->ha_rnd_end();
+
+  dbug_tmp_restore_column_map(is_table->read_set, orig_col);
+  free_tmp_table(thd, is_table);
+  DBUG_RETURN(retval);
+}
+
+/**
+  Build a valid tablespace from the information_schema views.
+
+  This method builds a @c TablespaceObj object if the tablespace
+  exists on the server.
+
+  @param[in]     thd           Thread context.
+  @param[out]    TablespaceObj A pointer to a new tablespace object
+  @param[in]     ts_name       The name of the tablespace to find
+  
+  @note Caller is responsible for destroying the tablespace object.
+
+  @retval FALSE if tablespace exists and no errors
+  @retval TRUE if tablespace does not exist or errors
+*/
+static bool get_tablespace_from_schema(THD *thd,
+                                       TablespaceObj **ts, 
+                                       const String *ts_name)
+{
+  String datafile;
+  String comments;
+  DBUG_ENTER("obs::get_tablespace_from_schema()");
+
+  /*
+    Locate the row in FALCON_TABLESPACES and get the comments.
+  */
+  if (find_tablespace_schema_row(thd, SCH_FALCON_TABLESPACES, 
+      ts_name, &datafile, &comments))
+    DBUG_RETURN(TRUE);
+
+  /*
+    Locate the row in FALCON_TABLESPACE_FILES and get the datafile.
+  */
+  if (find_tablespace_schema_row(thd, SCH_FALCON_TABLESPACE_FILES, 
+      ts_name, &datafile, &comments))
+    DBUG_RETURN(TRUE);
+
+  /*
+    The datafile parameter is required.
+  */
+  if (datafile.length() == 0)
+    DBUG_RETURN(TRUE);
+
+  DBUG_PRINT("get_tablespace_from_schema", (" Found tablespace %s %s", 
+    ts_name->ptr(), datafile.ptr()));
+
+  TablespaceObj *ts_local= new TablespaceObj(ts_name);
+  *ts= ts_local;
+  ts_local->set_datafile(&datafile);
+  ts_local->set_comments(&comments);
+
+  DBUG_RETURN(FALSE);
+}
+
+/**
+  Retrieve the tablespace for a table if it exists
+  
+  This method returns a @c TablespaceObj object if the table has a tablespace.
+
+  @param[in]  thd       Thread context.
+  @param[in]  db_name   The database name for the table.
+  @param[in]  tbl_name  The table name.
+  
+  @note Caller is responsible for destroying the object.
+
+  @retval Tablespace object if table uses a tablespace 
+  @retval NULL if table does not use a tablespace
+*/
+Obj *get_tablespace_for_table(THD *thd, 
+                              const String *db_name, 
+                              const String *tbl_name)
+{
+  TablespaceObj *ts= NULL;
+  char path[FN_REFLEN];
+  String ts_name;
+  DBUG_ENTER("obs::get_tablespace_for_table()");
+  DBUG_PRINT("obs::get_tablespace_for_table", ("name: %s.%s", 
+             db_name, tbl_name));
+
+  const char *db= db_name->ptr();
+  const char *name= tbl_name->ptr();
+
+  build_table_filename(path, sizeof(path), db, name, "", 0);
+  ts_name.length(0);
+  TABLE *table= open_temporary_table(thd, path, db, name,
+                    FALSE /* don't link to thd->temporary_tables */,
+                    OTM_OPEN);
+  if (table)
+  {
+    if (table->s->db_type()->db_type == DB_TYPE_FALCON)
+      ts_name.append(table->file->get_tablespace_name());
+    else
+      goto end;
+    ts_name.set_charset(system_charset_info);
+    intern_close_table(table);
+    my_free(table, MYF(0));
+  }
+  else
+    goto end;
+
+  /*
+    Now open the information_schema table and get the tablespace information.
+  */
+  get_tablespace_from_schema(thd, &ts, &ts_name);
+
+end:
+  DBUG_RETURN(ts);
+}
+
+/**
+  Determine if tablespace exists.
+
+  This method determines if a materialized tablespace exists on the
+  system. This compares the name and all saved attributes of the 
+  tablespace. A FALSE return would mean either the tablespace does
+  not exist or the tablespace attributes are different.
+
+  @param[in]  Obj  The TablspaceObj pointer to compare.
+  
+  @retval TRUE if it exists
+  @retval FALSE if it does not exist
+*/
+bool tablespace_exists(THD *thd,
+                       Obj *ts)
+{
+  TablespaceObj *other_ts= NULL;
+  bool retval= FALSE;
+  DBUG_ENTER("obs::tablespace_exists()");
+  get_tablespace_from_schema(thd, &other_ts, ts->get_name());
+  if (!other_ts)
+    DBUG_RETURN(retval);
+  retval= (my_strcasecmp(system_charset_info, 
+           other_ts->build_serialization()->ptr(), 
+           ((TablespaceObj *)ts)->build_serialization()->ptr()) == 0);
+  delete other_ts;
+  DBUG_RETURN(retval);
+}
+
+/**
+  Is there a tablespace with the given name?
+  
+  This method determines if the tablespace referenced by name exists on the
+  system. Returns a TablespaceObj if it exists or NULL if it doesn't.
+
+  @param[in]  ts_name  The Tablspace name to compare.
+  
+  @note Caller is responsible for destroying the tablespace object.
+
+  @returns the tablespace if found or NULL if not found
+*/
+Obj *is_tablespace(THD *thd,
+                   const String *ts_name)
+{
+  TablespaceObj *other_ts= NULL;
+  DBUG_ENTER("obs::is_tablespace()");
+  get_tablespace_from_schema(thd, &other_ts, ts_name);
+  DBUG_RETURN(other_ts);
+}
+
+/**
+  Decribe a tablespace.
+
+  This method returns a description of the tablespace useful for communicating
+  with the user.
+
+  @param[in]  ts  The Tablspace to describe.
+  
+  @returns tablespace description
+*/
+const String *describe_tablespace(Obj *ts)
+{
+  DBUG_ENTER("obs::describe_tablespace()");
+  DBUG_RETURN(((TablespaceObj *)ts)->describe());
 }
 
 ///////////////////////////////////////////////////////////////////////////
diff -Nrup a/sql/si_objects.h b/sql/si_objects.h
--- a/sql/si_objects.h	2008-01-31 10:15:25 -05:00
+++ b/sql/si_objects.h	2008-04-09 08:55:58 -04:00
@@ -133,6 +133,9 @@ private:
                                 uint,
                                 const String *);
 
+  friend Obj *materialize_tablespace(const String *,
+                                     uint,
+                                     const String *);
 };
 
 ///////////////////////////////////////////////////////////////////////////
@@ -445,6 +448,10 @@ Obj *materialize_event(const String *db_
                        uint serialization_version,
                        const String *serialialization);
 
+Obj *materialize_tablespace(const String *ts_name,
+                            uint serialization_version,
+                            const String *serialialization);
+
 ///////////////////////////////////////////////////////////////////////////
 
 bool is_internal_db_name(const String *db_name);
@@ -459,6 +466,35 @@ bool is_internal_db_name(const String *d
     @retval TRUE on error (the database either not exists, or not accessible).
 */
 bool check_db_existence(const String *db_name);
+
+/*
+  This method returns a @c TablespaceObj object if the table has a tablespace.
+*/
+Obj *get_tablespace_for_table(THD *thd, 
+                              const String *db_name, 
+                              const String *tbl_name);
+
+/*
+  This method determines if a materialized tablespace exists on the
+  system. This compares the name and all saved attributes of the 
+  tablespace. A FALSE return would mean either the tablespace does
+  not exist or the tablespace attributes are different.
+*/
+bool tablespace_exists(THD *thd,
+                       Obj *ts);
+
+/*
+  This method determines if the tablespace referenced by name exists on the
+  system. Returns a TablespaceObj if it exists or NULL if it doesn't.
+*/
+Obj *is_tablespace(THD *thd,
+                   const String *ts_name);
+
+/*
+  This method returns a description of the tablespace useful for communicating
+  with the user.
+*/
+const String *describe_tablespace(Obj *ts);
 
 ///////////////////////////////////////////////////////////////////////////
 
diff -Nrup a/sql/table.h b/sql/table.h
--- a/sql/table.h	2008-04-01 09:44:55 -04:00
+++ b/sql/table.h	2008-04-09 08:55:59 -04:00
@@ -749,7 +749,9 @@ enum enum_schema_tables
   SCH_TRIGGERS,
   SCH_USER_PRIVILEGES,
   SCH_VARIABLES,
-  SCH_VIEWS
+  SCH_VIEWS,
+  SCH_FALCON_TABLESPACES,
+  SCH_FALCON_TABLESPACE_FILES
 };