Pushing all the Gemini changes above the table handler.

BUILD/FINISH.sh:
  Add Gemini to configure
Docs/manual.texi:
  Added Gemini content to the manual.
acinclude.m4:
  Add Gemini to configure
configure.in:
  Add Gemini to configure
include/my_base.h:
  transaction isolation level READ UNCOMMITTED does not allow updates
include/mysqld_error.h:
  Added new messages for Lock related failures
sql/field.cc:
  Gemini BLOB support -
sql/field.h:
  Gemini BLOB Support
sql/ha_gemini.cc:
  Gemini Table handler
sql/ha_gemini.h:
  Gemini Table handler
sql/handler.cc:
  Added new messages for Lock related failures
  Provide the ability to turn off recovery for operations like 
  REPAIR TABLE ans ALTER TABLE
sql/handler.h:
  Add a bit to have full text indexes as an option
  and define the prototype to optionally turn on and off logging
sql/lock.cc:
  Added new messages for Lock related failures
sql/share/czech/errmsg.txt:
  Added new messages for Lock related failures
sql/share/danish/errmsg.txt:
  Added new messages for Lock related failures
sql/share/dutch/errmsg.txt:
  Added new messages for Lock related failures
sql/share/english/errmsg.txt:
  Added new messages for Lock related failures
sql/share/estonian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/french/errmsg.txt:
  Added new messages for Lock related failures
sql/share/german/errmsg.txt:
  Added new messages for Lock related failures
sql/share/greek/errmsg.txt:
  Added new messages for Lock related failures
sql/share/hungarian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/italian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/japanese/errmsg.txt:
  Added new messages for Lock related failures
sql/share/korean/errmsg.txt:
  Added new messages for Lock related failures
sql/share/norwegian-ny/errmsg.txt:
  Added new messages for Lock related failures
sql/share/norwegian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/polish/errmsg.txt:
  Added new messages for Lock related failures
sql/share/portuguese/errmsg.txt:
  Added new messages for Lock related failures
sql/share/romanian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/russian/errmsg.txt:
  Added new messages for Lock related failures
sql/share/slovak/errmsg.txt:
  Added new messages for Lock related failures
sql/share/spanish/errmsg.txt:
  Added new messages for Lock related failures
sql/share/swedish/errmsg.txt:
  Added new messages for Lock related failures
sql/sql_base.cc:
  Avoidlock table overflow issues when doing an alter table on Windows.
  This is Gemini specific.
sql/sql_table.cc:
  Add a bit to have full text indexes as an option
  and define the prototype to optionally turn on and off logging
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

BUILD/FINISH.sh

@@ -15,6 +15,10 @@ $make -k clean || true
 aclocal && autoheader && aclocal && automake && autoconf
 (cd bdb/dist && sh s_all)
 (cd innobase && aclocal && autoheader && aclocal && automake && autoconf)
+if [ -d gemini ]
+then
+   (cd gemini && aclocal && autoheader && aclocal && automake && autoconf)
+fi
 
 CFLAGS=\"$cflags\" CXX=gcc CXXFLAGS=\"$cxxflags\" $configure"
 

BitKeeper/etc/logging_ok

-mwagner@evoq.mwagner.org
+mikef@nslinux.bedford.progress.com

acinclude.m4

@@ -999,10 +999,10 @@ dnl echo "DBG_GEM1: gemini='$gemini'"
   gemini_includes=
   gemini_libs=
   case "$gemini" in
-    no | default | *)
+    no) 
       AC_MSG_RESULT([Not using Gemini DB])
       ;;
-    yes )
+    yes | default | *)
       have_gemini_db="yes"
       gemini_includes="-I../gemini/incl -I../gemini"
       gemini_libs="\

configure.in

@@ -2018,6 +2018,17 @@ EOF
     echo "END OF INNODB CONFIGURATION"
   fi
 
+  if test "X$have_gemini_db" = "Xyes"; then 
+    sql_server_dirs="gemini $sql_server_dirs"
+    echo "CONFIGURING FOR GEMINI DB"
+    (cd gemini && sh ./configure) \
+    || AC_MSG_ERROR([could not configure Gemini DB])
+
+    echo "END OF GEMINI DB CONFIGURATION"
+
+    AC_DEFINE(HAVE_GEMINI_DB)
+  fi
+
   if test "$with_posix_threads" = "no" -o "$with_mit_threads" = "yes"
   then
     # MIT user level threads

include/my_base.h

@@ -213,6 +213,7 @@ enum ha_base_keytype {
 #define HA_ERR_CRASHED_ON_USAGE  145	/* Table must be repaired */
 #define HA_ERR_LOCK_WAIT_TIMEOUT 146    
 #define HA_ERR_LOCK_TABLE_FULL   147
+#define HA_ERR_READ_ONLY_TRANSACTION 148 /* Updates not allowed */
 
 	/* Other constants */
 

include/mysqld_error.h

@@ -205,4 +205,7 @@
 #define ER_SLAVE_THREAD 1202
 #define ER_TOO_MANY_USER_CONNECTIONS 1203
 #define ER_SET_CONSTANTS_ONLY 1204
-#define ER_ERROR_MESSAGES 205
+#define ER_LOCK_WAIT_TIMEOUT 1205
+#define ER_LOCK_TABLE_FULL 1206
+#define ER_READ_ONLY_TRANSACTION 1207
+#define ER_ERROR_MESSAGES 208

sql/field.cc

@@ -4087,6 +4087,59 @@ const char *Field_blob::unpack(char *to, const char *from)
 }
 
 
+#ifdef HAVE_GEMINI_DB
+/* Blobs in Gemini tables are stored separately from the rows which contain
+** them (except for tiny blobs, which are stored in the row).  For all other
+** blob types (blob, mediumblob, longblob), the row contains the length of 
+** the blob data and a blob id.  These methods (pack_id, get_id, and 
+** unpack_id) handle packing and unpacking blob fields in Gemini rows.
+*/
+char *Field_blob::pack_id(char *to, const char *from, ulonglong id, uint max_length)
+{
+  char *save=ptr;
+  ptr=(char*) from;
+  ulong length=get_length();                    // Length of from string
+  if (length > max_length)
+  {
+    ptr=to;
+    length=max_length;
+    store_length(length);                       // Store max length
+    ptr=(char*) from;
+  }
+  else
+    memcpy(to,from,packlength);                 // Copy length
+  if (length)
+  {
+    int8store(to+packlength, id);
+  }
+  ptr=save;                                     // Restore org row pointer
+  return to+packlength+sizeof(id);
+}
+
+
+ulonglong Field_blob::get_id(const char *from)
+{
+  ulonglong id = 0;
+  ulong length=get_length(from);
+  if (length)
+    longlongget(id, from+packlength);
+  return id;
+}
+
+
+const char *Field_blob::unpack_id(char *to, const char *from, const char *bdata)
+{
+  memcpy(to,from,packlength);
+  ulong length=get_length(from);
+  from+=packlength;
+  if (length)
+    memcpy_fixed(to+packlength, &bdata, sizeof(bdata));
+  else
+    bzero(to+packlength,sizeof(bdata));
+  return from+sizeof(ulonglong);
+}
+#endif  /* HAVE_GEMINI_DB */
+
 /* Keys for blobs are like keys on varchars */
 
 int Field_blob::pack_cmp(const char *a, const char *b, uint key_length)

sql/field.h

@@ -869,6 +869,13 @@ class Field_blob :public Field_str {
   }
   char *pack(char *to, const char *from, uint max_length= ~(uint) 0);
   const char *unpack(char *to, const char *from);
+#ifdef HAVE_GEMINI_DB
+  char *pack_id(char *to, const char *from, ulonglong id, 
+                uint max_length= ~(uint) 0);
+  ulonglong get_id(const char *from);
+  const char *unpack_id(char *to, const char *from, const char *bdata);
+  enum_field_types blobtype() { return (packlength == 1 ? FIELD_TYPE_TINY_BLOB : FIELD_TYPE_BLOB);}
+#endif
   char *pack_key(char *to, const char *from, uint max_length);
   char *pack_key_from_key_image(char* to, const char *from, uint max_length);
   int pack_cmp(const char *a, const char *b, uint key_length);

sql/ha_gemini.h

@@ -19,17 +19,26 @@
 #pragma interface			/* gcc class implementation */
 #endif
 
+#include "gem_global.h"
 #include "dstd.h"
 #include "dsmpub.h"
 
 /* class for the the gemini handler */
 
 enum enum_key_string_options{KEY_CREATE,KEY_DELETE,KEY_CHECK};
-
-#define  READ_UNCOMMITED  0
-#define  READ_COMMITED    1
-#define  REPEATABLE_READ  2
-#define  SERIALIZEABLE    3
+typedef struct st_gemini_share {
+  ha_rows  *rec_per_key;
+  THR_LOCK lock;
+  pthread_mutex_t mutex;
+  char *table_name;
+  uint table_name_length,use_count;
+} GEM_SHARE;
+
+typedef struct gemBlobDesc
+{
+  dsmBlobId_t  blobId;
+  dsmBuffer_t *pBlob;
+} gemBlobDesc_t;
 
 class ha_gemini: public handler
 {
@@ -38,7 +47,7 @@ class ha_gemini: public handler
   uint int_option_flag;
   int tableNumber;
   dsmIndex_t  *pindexNumbers;  // dsm object numbers for the indexes on this table 
-  unsigned long lastRowid;
+  dsmRecid_t lastRowid;
   uint  last_dup_key;
   bool fixed_length_row, key_read, using_ignore;
   byte *rec_buff;
@@ -46,10 +55,12 @@ class ha_gemini: public handler
   dsmKey_t *pbracketLimit;
   dsmKey_t *pfoundKey;
   dsmMask_t    tableStatus;   // Crashed/repair status
+  gemBlobDesc_t *pBlobDescs;
 
   int index_open(char *tableName);
-  int  pack_row(byte **prow, int *ppackedLength, const byte *record);
-  void unpack_row(char *record, char *prow);
+  int  pack_row(byte **prow, int *ppackedLength, const byte *record, 
+                bool update);
+  int  unpack_row(char *record, char *prow);
   int findRow(THD *thd, dsmMask_t findMode, byte *buf);
   int fetch_row(void *gemini_context, const byte *buf);
   int handleIndexEntries(const byte * record, dsmRecid_t recid,
@@ -70,24 +81,28 @@ class ha_gemini: public handler
   void unpack_key(char *record, dsmKey_t *key, uint index);
 
   int key_cmp(uint keynr, const byte * old_row,
-                         const byte * new_row);
+                         const byte * new_row, bool updateStats);
 
+  int saveKeyStats(THD *thd);
+  void get_index_stats(THD *thd);
 
   short cursorId;  /* cursorId of active index cursor if any   */
   dsmMask_t  lockMode;  /* Shared or exclusive      */
 
   /* FIXFIX Don't know why we need this because I don't know what
      store_lock method does but we core dump without this  */
-  THR_LOCK      alock;
   THR_LOCK_DATA lock;
+  GEM_SHARE     *share;
+
  public:
   ha_gemini(TABLE *table): handler(table), file(0),
     int_option_flag(HA_READ_NEXT | HA_READ_PREV |
 		    HA_REC_NOT_IN_SEQ |
 		    HA_KEYPOS_TO_RNDPOS | HA_READ_ORDER | HA_LASTKEY_ORDER |
 		    HA_LONGLONG_KEYS | HA_NULL_KEY | HA_HAVE_KEY_READ_ONLY |
-                    HA_NO_BLOBS | HA_NO_TEMP_TABLES |
-		    /* HA_BLOB_KEY | */ /*HA_NOT_EXACT_COUNT | */ 
+		    HA_BLOB_KEY | 
+		    HA_NO_TEMP_TABLES | HA_NO_FULLTEXT_KEY |
+		    /*HA_NOT_EXACT_COUNT | */ 
 		    /*HA_KEY_READ_WRONG_STR |*/ HA_DROP_BEFORE_CREATE),
                     pbracketBase(0),pbracketLimit(0),pfoundKey(0),
                     cursorId(0)
@@ -100,7 +115,7 @@ class ha_gemini: public handler
   uint max_record_length() const { return MAXRECSZ; }
   uint max_keys()          const { return MAX_KEY-1; }
   uint max_key_parts()     const { return MAX_REF_PARTS; }
-  uint max_key_length()    const { return MAXKEYSZ; }
+  uint max_key_length()    const { return MAXKEYSZ / 2; }
   bool fast_key_read()	   { return 1;}
   bool has_transactions()  { return 1;}
 
@@ -129,8 +144,12 @@ class ha_gemini: public handler
   void info(uint);
   int extra(enum ha_extra_function operation);
   int reset(void);
+  int analyze(THD* thd, HA_CHECK_OPT* check_opt);
   int check(THD* thd, HA_CHECK_OPT* check_opt);
   int repair(THD* thd,  HA_CHECK_OPT* check_opt);
+  int restore(THD* thd, HA_CHECK_OPT* check_opt);
+  int backup(THD* thd, HA_CHECK_OPT* check_opt);
+  int optimize(THD* thd, HA_CHECK_OPT* check_opt);
   int external_lock(THD *thd, int lock_type);
   virtual longlong get_auto_increment();
   void position(byte *record);
@@ -139,7 +158,7 @@ class ha_gemini: public handler
 			   enum ha_rkey_function start_search_flag,
 			   const byte *end_key,uint end_key_len,
 			   enum ha_rkey_function end_search_flag);
-
+  void update_create_info(HA_CREATE_INFO *create_info);
   int create(const char *name, register TABLE *form,
 	     HA_CREATE_INFO *create_info);
   int delete_table(const char *name);
@@ -167,6 +186,7 @@ extern long gemini_locktablesize;
 extern long gemini_lock_wait_timeout;
 extern long gemini_spin_retries;
 extern long gemini_connection_limit;
+extern char *gemini_basedir;
 extern TYPELIB gemini_recovery_typelib;
 extern ulong gemini_recovery_options;
 
@@ -175,12 +195,13 @@ bool gemini_end(void);
 bool gemini_flush_logs(void);
 int gemini_commit(THD *thd);
 int gemini_rollback(THD *thd);
+int gemini_recovery_logging(THD *thd, bool on);
 void gemini_disconnect(THD *thd);
 int gemini_rollback_to_savepoint(THD *thd);
 int gemini_parse_table_name(const char *fullname, char *dbname, char *tabname);
 int gemini_is_vst(const char *pname);
 int gemini_set_option_long(int optid, long optval);
 
-const int gemini_blocksize = 8192;
-const int gemini_recbits = 7;
+const int gemini_blocksize = BLKSIZE;
+const int gemini_recbits = DEFAULT_RECBITS;
 

sql/handler.cc

@@ -694,6 +694,15 @@ void handler::print_error(int error, myf errflag)
   case HA_ERR_RECORD_FILE_FULL:
     textno=ER_RECORD_FILE_FULL;
     break;
+  case HA_ERR_LOCK_WAIT_TIMEOUT:
+    textno=ER_LOCK_WAIT_TIMEOUT;
+    break;
+  case HA_ERR_LOCK_TABLE_FULL:
+    textno=ER_LOCK_TABLE_FULL;
+    break;
+  case HA_ERR_READ_ONLY_TRANSACTION:
+    textno=ER_READ_ONLY_TRANSACTION;
+    break;
   default:
     {
       my_error(ER_GET_ERRNO,errflag,error);
@@ -757,6 +766,25 @@ int ha_commit_rename(THD *thd)
     return error;
 }
 
+/* Tell the handler to turn on or off logging to the handler's
+   recovery log
+*/
+int ha_recovery_logging(THD *thd, bool on)
+{
+  int error=0;
+
+  DBUG_ENTER("ha_recovery_logging");
+#ifdef USING_TRANSACTIONS
+  if (opt_using_transactions)
+  {
+#ifdef HAVE_GEMINI_DB
+    error = gemini_recovery_logging(thd, on);
+  }
+#endif
+#endif
+  DBUG_RETURN(error);
+}
+
 int handler::index_next_same(byte *buf, const byte *key, uint keylen)
 {
   int error;

sql/handler.h

@@ -74,6 +74,7 @@
 #define HA_NOT_DELETE_WITH_CACHE (HA_NOT_READ_AFTER_KEY*2)
 #define HA_NO_TEMP_TABLES       (HA_NOT_DELETE_WITH_CACHE*2)
 #define HA_NO_PREFIX_CHAR_KEYS	(HA_NO_TEMP_TABLES*2) 
+#define HA_NO_FULLTEXT_KEY      (HA_NO_PREFIX_CHAR_KEYS*2)
 
 	/* Parameters for open() (in register form->filestat) */
 	/* HA_GET_INFO does a implicit HA_ABORT_IF_LOCKED */
@@ -353,3 +354,4 @@ int ha_autocommit_or_rollback(THD *thd, int error);
 void ha_set_spin_retries(uint retries);
 bool ha_flush_logs(void);
 int ha_commit_rename(THD *thd);
+int ha_recovery_logging(THD *thd, bool on);

sql/lock.cc

@@ -35,6 +35,7 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table,uint count,
 				 bool unlock, TABLE **write_locked);
 static int lock_external(TABLE **table,uint count);
 static int unlock_external(THD *thd, TABLE **table,uint count);
+static void print_lock_error(int error);
 
 
 MYSQL_LOCK *mysql_lock_tables(THD *thd,TABLE **tables,uint count)
@@ -154,7 +155,7 @@ static int lock_external(TABLE **tables,uint count)
 	(*tables)->file->external_lock(thd, F_UNLCK);
 	(*tables)->current_lock=F_UNLCK;
       }
-      my_error(ER_CANT_LOCK,MYF(ME_BELL+ME_OLDWIN+ME_WAITTANG),error);
+      print_lock_error(error);
       DBUG_RETURN(error);
     }
     else
@@ -325,7 +326,7 @@ static int unlock_external(THD *thd, TABLE **table,uint count)
     }
   }
   if (error_code)
-    my_error(ER_CANT_LOCK,MYF(ME_BELL+ME_OLDWIN+ME_WAITTANG),error_code);
+    print_lock_error(error_code);
   DBUG_RETURN(error_code);
 }
 
@@ -480,3 +481,24 @@ bool wait_for_locked_table_names(THD *thd, TABLE_LIST *table_list)
   }
   DBUG_RETURN(result);
 }
+
+static void print_lock_error(int error)
+{
+  int textno;
+  DBUG_ENTER("print_lock_error");
+
+  switch (error) {
+  case HA_ERR_LOCK_WAIT_TIMEOUT:
+    textno=ER_LOCK_WAIT_TIMEOUT;
+    break;
+  case HA_ERR_READ_ONLY_TRANSACTION:
+    textno=ER_READ_ONLY_TRANSACTION;
+    break;
+  default:
+    textno=ER_CANT_LOCK;
+    break;
+  }
+  my_error(textno,MYF(ME_BELL+ME_OLDWIN+ME_WAITTANG),error);
+  DBUG_VOID_RETURN;
+}
+

sql/share/czech/errmsg.txt

@@ -215,3 +215,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/danish/errmsg.txt

@@ -209,3 +209,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/dutch/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/english/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/estonian/errmsg.txt

@@ -210,3 +210,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/french/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/german/errmsg.txt

@@ -209,3 +209,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/greek/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/hungarian/errmsg.txt

@@ -208,3 +208,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/italian/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/japanese/errmsg.txt

@@ -208,3 +208,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/korean/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/norwegian-ny/errmsg.txt

@@ -208,3 +208,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/norwegian/errmsg.txt

@@ -208,3 +208,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/polish/errmsg.txt

@@ -210,3 +210,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/portuguese/errmsg.txt

@@ -206,3 +206,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/romanian/errmsg.txt

@@ -210,3 +210,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/russian/errmsg.txt

@@ -209,3 +209,6 @@
 "    SLAVE,   ",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/slovak/errmsg.txt

@@ -214,3 +214,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/spanish/errmsg.txt

@@ -207,3 +207,6 @@
 "Could not create slave thread, check system resources",
 "User %-.64s has already more than 'max_user_connections' active connections",
 "You may only use constant expressions with SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/share/swedish/errmsg.txt

@@ -206,3 +206,6 @@
 "Kunde inte starta en tråd för replikering",
 "Användare '%-.64s' har redan 'max_user_connections' aktiva inloggningar",
 "Du kan endast använda konstant-uttryck med SET",
+"Lock wait timeout exceeded",
+"The total number of locks exceeds the lock table size",
+"Update locks cannot be acquired during a READ UNCOMMITTED transaction",

sql/sql_base.cc

@@ -1388,11 +1388,6 @@ TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
   bool refresh;
   DBUG_ENTER("open_ltable");
 
-#ifdef __WIN__
-  /* Win32 can't drop a file that is open */
-  if (lock_type == TL_WRITE_ALLOW_READ)
-    lock_type= TL_WRITE;
-#endif
   thd->proc_info="Opening table";
   while (!(table=open_table(thd,table_list->db ? table_list->db : thd->db,
 			    table_list->real_name,table_list->name,
@@ -1400,6 +1395,19 @@ TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type)
   if (table)
   {
     int error;
+
+#ifdef __WIN__
+    /* Win32 can't drop a file that is open */
+    if (lock_type == TL_WRITE_ALLOW_READ
+#ifdef HAVE_GEMINI_DB
+        && table->db_type != DB_TYPE_GEMINI
+#endif /* HAVE_GEMINI_DB */
+       )
+    {
+      lock_type= TL_WRITE;
+    }
+#endif /* __WIN__ */
+
     table_list->table=table;
     table->grant= table_list->grant;
     if (thd->locked_tables)

sql/sql_table.cc

@@ -423,6 +423,13 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
 			column->field_name);
 	DBUG_RETURN(-1);
       }
+      if (key->type == Key::FULLTEXT &&
+          (file->option_flag() & HA_NO_FULLTEXT_KEY))
+      {
+        my_printf_error(ER_WRONG_KEY_COLUMN, ER(ER_WRONG_KEY_COLUMN), MYF(0),
+                        column->field_name);
+        DBUG_RETURN(-1);
+      }
       if (f_is_blob(sql_field->pack_flag))
       {
 	if (!(file->option_flag() & HA_BLOB_KEY))
@@ -1678,6 +1685,16 @@ copy_data_between_tables(TABLE *from,TABLE *to,
       goto err;
   };
 
+  /* Turn off recovery logging since rollback of an
+     alter table is to delete the new table so there
+     is no need to log the changes to it.              */
+  error = ha_recovery_logging(thd,false);
+  if(error)
+  {
+    error = 1;
+    goto err;
+  }
+
   init_read_record(&info, thd, from, (SQL_SELECT *) 0, 1,1);
   if (handle_duplicates == DUP_IGNORE ||
       handle_duplicates == DUP_REPLACE)
@@ -1723,6 +1740,7 @@ copy_data_between_tables(TABLE *from,TABLE *to,
   if (to->file->activate_all_index(thd))
     error=1;
 
+  tmp_error = ha_recovery_logging(thd,true);
   /*
     Ensure that the new table is saved properly to disk so that we
     can do a rename
@@ -1734,6 +1752,7 @@ copy_data_between_tables(TABLE *from,TABLE *to,
   if (to->file->external_lock(thd,F_UNLCK))
     error=1;
  err:
+  tmp_error = ha_recovery_logging(thd,true);
   free_io_cache(from);
   *copied= found_count;
   *deleted=delete_count;