Merge baker@bk-internal.mysql.com:/home/bk/mysql-4.1

into brian-akers-computer.local:/Users/brian/mysql/mysql-4.1-examples


BitKeeper/etc/logging_ok:
  auto-union
include/my_base.h:
  Auto merged
sql/handler.cc:
  Auto merged
sql/handler.h:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged

BitKeeper/etc/logging_ok

@@ -24,6 +24,7 @@ bell@laptop.sanja.is.com.ua
 bell@sanja.is.com.ua
 bk@admin.bk
 bk@mysql.r18.ru
+brian@brian-akers-computer.local
 carsten@tsort.bitbybit.dk
 davida@isil.mysql.com
 dlenev@brandersnatch.localdomain

acconfig.h

@@ -112,6 +112,9 @@
 /* Define if we are using OSF1 DEC threads on 3.2 */
 #undef HAVE_DEC_3_2_THREADS
 
+/* Builds Example DB */
+#undef HAVE_EXAMPLE_DB
+
 /* fp_except from ieeefp.h */
 #undef HAVE_FP_EXCEPT
 

acinclude.m4

@@ -1302,6 +1302,36 @@ dnl ---------------------------------------------------------------------------
 dnl END OF MYSQL_CHECK_INNODB SECTION
 dnl ---------------------------------------------------------------------------
 
+dnl ---------------------------------------------------------------------------
+dnl Macro: MYSQL_CHECK_EXAMPLEDB
+dnl Sets HAVE_EXAMPLE_DB if --with-example-storage-engine is used
+dnl ---------------------------------------------------------------------------
+AC_DEFUN([MYSQL_CHECK_EXAMPLEDB], [
+  AC_ARG_WITH([example-storage-engine],
+              [
+  --with-example-storage-engine
+                          Enable the Example Storge Engine],
+              [exampledb="$withval"],
+              [exampledb=no])
+  AC_MSG_CHECKING([for example storage engine])
+
+  case "$exampledb" in
+    yes )
+      AC_DEFINE(HAVE_EXAMPLE_DB)
+      AC_MSG_RESULT([yes])
+      [exampledb=yes])
+      ;;
+    * )
+      AC_MSG_RESULT([no])
+      [exampledb=no])
+      ;;
+  esac
+
+])
+dnl ---------------------------------------------------------------------------
+dnl END OF MYSQL_CHECK_EXAMPLE SECTION
+dnl ---------------------------------------------------------------------------
+
 dnl By default, many hosts won't let programs access large files;
 dnl one must use special compiler options to get large-file access to work.
 dnl For more details about this brain damage please see:

configure.in

@@ -2618,6 +2618,7 @@ AC_DEFINE_UNQUOTED(MYSQL_DEFAULT_COLLATION_NAME,"$default_collation")
 MYSQL_CHECK_ISAM
 MYSQL_CHECK_BDB
 MYSQL_CHECK_INNODB
+MYSQL_CHECK_EXAMPLEDB
 
 # If we have threads generate some library functions and test programs
 sql_server_dirs=

include/my_base.h

@@ -364,4 +364,7 @@ typedef ulong		ha_rows;
 #define MAX_FILE_SIZE	LONGLONG_MAX
 #endif
 
+/* Currently used for saying which interfaces a Storage Engine implements */
+#define HA_ERR_NOT_IMPLEMENTED -1
+
 #endif /* _my_base_h */

sql/Makefile.am

@@ -37,7 +37,7 @@ LDADD =			@isam_libs@ \
 			../mysys/libmysys.a \
 			../dbug/libdbug.a \
 			../regex/libregex.a \
-			../strings/libmystrings.a
+			../strings/libmystrings.a 
 
 mysqld_LDADD =		@MYSQLD_EXTRA_LDFLAGS@ \
 			@bdb_libs@ @innodb_libs@ @pstack_libs@ \
@@ -57,7 +57,8 @@ noinst_HEADERS =	item.h item_func.h item_sum.h item_cmpfunc.h \
 			lex.h lex_symbol.h sql_acl.h sql_crypt.h  \
 			log_event.h sql_repl.h slave.h \
 			stacktrace.h sql_sort.h sql_cache.h set_var.h \
-			spatial.h gstream.h client_settings.h
+			spatial.h gstream.h client_settings.h \
+			examples/ha_example.h
 mysqld_SOURCES =	sql_lex.cc sql_handler.cc \
 			item.cc item_sum.cc item_buff.cc item_func.cc \
 			item_cmpfunc.cc item_strfunc.cc item_timefunc.cc \
@@ -86,7 +87,8 @@ mysqld_SOURCES =	sql_lex.cc sql_handler.cc \
 			slave.cc sql_repl.cc sql_union.cc sql_derived.cc \
 			client.c sql_client.cc mini_client_errors.c pack.c\
 			stacktrace.c repl_failsafe.h repl_failsafe.cc sql_olap.cc\
-			gstream.cc spatial.cc sql_help.cc protocol_cursor.cc
+			gstream.cc spatial.cc sql_help.cc protocol_cursor.cc \
+			examples/ha_example.cc
 gen_lex_hash_SOURCES =	gen_lex_hash.cc
 gen_lex_hash_LDADD =	$(LDADD) $(CXXLDFLAGS)
 

sql/examples/ha_example.cc

+/* Copyright (C) 2003 MySQL AB
+
+  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#ifdef __GNUC__
+#pragma implementation        // gcc: Class implementation
+#endif
+
+#include <mysql_priv.h>
+
+#ifdef HAVE_EXAMPLE_DB
+#include "ha_example.h"
+
+/* Variables for example share methods */
+pthread_mutex_t example_mutex;
+static HASH example_open_tables;
+static int example_init= 0;
+
+static byte* example_get_key(EXAMPLE_SHARE *share,uint *length,
+                             my_bool not_used __attribute__((unused)))
+{
+  *length=share->table_name_length;
+  return (byte*) share->table_name;
+}
+
+
+/*
+  Example of simple lock controls.
+*/
+static EXAMPLE_SHARE *get_share(const char *table_name, TABLE *table)
+{
+  EXAMPLE_SHARE *share;
+  uint length;
+  char *tmp_name;
+
+  if (!example_init)
+  {
+    /* Hijack a mutex for init'ing the storage engine */
+    pthread_mutex_lock(&LOCK_mysql_create_db);
+    if (!example_init)
+    {
+      example_init++;
+      VOID(pthread_mutex_init(&example_mutex,MY_MUTEX_INIT_FAST));
+      (void) hash_init(&example_open_tables,system_charset_info,32,0,0,
+                       (hash_get_key) example_get_key,0,0);
+    }
+    pthread_mutex_unlock(&LOCK_mysql_create_db);
+  }
+  pthread_mutex_lock(&example_mutex);
+  length=(uint) strlen(table_name);
+
+  if (!(share=(EXAMPLE_SHARE*) hash_search(&example_open_tables,
+                                           (byte*) table_name,
+                                           length)))
+  {
+    if (!(share=(EXAMPLE_SHARE *)
+          my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+                          &share, sizeof(*share),
+                          &tmp_name, length+1,
+                          NullS))) 
+    {
+      pthread_mutex_unlock(&example_mutex);
+      return NULL;
+    }
+
+    share->use_count=0;
+    share->table_name_length=length;
+    share->table_name=tmp_name;
+    strmov(share->table_name,table_name);
+    if (my_hash_insert(&example_open_tables, (byte*) share))
+      goto error;
+    thr_lock_init(&share->lock);
+    pthread_mutex_init(&share->mutex,MY_MUTEX_INIT_FAST);
+  }
+  share->use_count++;
+  pthread_mutex_unlock(&example_mutex);
+
+  return share;
+
+error2:
+  thr_lock_delete(&share->lock);
+  pthread_mutex_destroy(&share->mutex);
+error:
+  pthread_mutex_unlock(&example_mutex);
+  my_free((gptr) share, MYF(0));
+
+  return NULL;
+}
+
+
+/* 
+  Free lock controls.
+*/
+static int free_share(EXAMPLE_SHARE *share)
+{
+  pthread_mutex_lock(&example_mutex);
+  if (!--share->use_count)
+  {
+    hash_delete(&example_open_tables, (byte*) share);
+    thr_lock_delete(&share->lock);
+    pthread_mutex_destroy(&share->mutex);
+    my_free((gptr) share, MYF(0));
+  }
+  pthread_mutex_unlock(&example_mutex);
+
+  return 0;
+}
+
+
+const char **ha_example::bas_ext() const
+{ static const char *ext[]= { NullS }; return ext; }
+
+
+int ha_example::open(const char *name, int mode, uint test_if_locked)
+{
+  DBUG_ENTER("ha_example::open");
+
+  if (!(share = get_share(name, table)))
+    DBUG_RETURN(1);
+  thr_lock_data_init(&share->lock,&lock,NULL);
+
+  DBUG_RETURN(0);
+}
+
+int ha_example::close(void)
+{
+  DBUG_ENTER("ha_example::close");
+  DBUG_RETURN(free_share(share));
+}
+
+int ha_example::write_row(byte * buf)
+{
+  DBUG_ENTER("ha_example::write_row");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::update_row(const byte * old_data, byte * new_data)
+{
+
+  DBUG_ENTER("ha_example::update_row");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::delete_row(const byte * buf)
+{
+  DBUG_ENTER("ha_example::delete_row");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::index_read(byte * buf, const byte * key,
+                           uint key_len __attribute__((unused)),
+                           enum ha_rkey_function find_flag
+                           __attribute__((unused)))
+{
+  DBUG_ENTER("ha_example::index_read");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::index_read_idx(byte * buf, uint index, const byte * key,
+                               uint key_len __attribute__((unused)),
+                               enum ha_rkey_function find_flag
+                               __attribute__((unused)))
+{
+  DBUG_ENTER("ha_example::index_read_idx");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+
+int ha_example::index_next(byte * buf)
+{
+  DBUG_ENTER("ha_example::index_next");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::index_prev(byte * buf)
+{
+  DBUG_ENTER("ha_example::index_prev");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::index_first(byte * buf)
+{
+  DBUG_ENTER("ha_example::index_first");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::index_last(byte * buf)
+{
+  DBUG_ENTER("ha_example::index_last");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::rnd_init(bool scan)
+{
+  DBUG_ENTER("ha_example::rnd_init");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::rnd_next(byte *buf)
+{
+  DBUG_ENTER("ha_example::rnd_next");
+  DBUG_RETURN(HA_ERR_END_OF_FILE);
+}
+
+void ha_example::position(const byte *record)
+{
+  DBUG_ENTER("ha_example::position");
+  DBUG_VOID_RETURN;
+}
+
+int ha_example::rnd_pos(byte * buf, byte *pos)
+{
+  DBUG_ENTER("ha_example::rnd_pos");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+void ha_example::info(uint flag)
+{
+  DBUG_ENTER("ha_example::info");
+  DBUG_VOID_RETURN;
+}
+
+int ha_example::extra(enum ha_extra_function operation)
+{
+  DBUG_ENTER("ha_example::extra");
+  DBUG_RETURN(0);
+}
+
+int ha_example::reset(void)
+{
+  DBUG_ENTER("ha_example::reset");
+  DBUG_RETURN(0);
+}
+
+
+int ha_example::delete_all_rows()
+{
+  DBUG_ENTER("ha_example::delete_all_rows");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+int ha_example::external_lock(THD *thd, int lock_type)
+{
+  DBUG_ENTER("ha_example::external_lock");
+  DBUG_RETURN(0);
+}
+
+THR_LOCK_DATA **ha_example::store_lock(THD *thd,
+                                       THR_LOCK_DATA **to,
+                                       enum thr_lock_type lock_type)
+{
+  if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
+    lock.type=lock_type;
+  *to++= &lock;
+  return to;
+}
+
+int ha_example::delete_table(const char *name)
+{
+  DBUG_ENTER("ha_example::delete_table");
+  /* This is not implemented but we want someone to be able that it works. */
+  DBUG_RETURN(0);
+}
+
+int ha_example::rename_table(const char * from, const char * to)
+{
+  DBUG_ENTER("ha_example::rename_table ");
+  DBUG_RETURN(HA_ERR_NOT_IMPLEMENTED);
+}
+
+ha_rows ha_example::records_in_range(int inx,
+                                     const byte *start_key,uint start_key_len,
+                                     enum ha_rkey_function start_search_flag,
+                                     const byte *end_key,uint end_key_len,
+                                     enum ha_rkey_function end_search_flag)
+{
+  DBUG_ENTER("ha_example::records_in_range ");
+  DBUG_RETURN(records); // HA_ERR_NOT_IMPLEMENTED 
+}
+
+
+int ha_example::create(const char *name, TABLE *table_arg, HA_CREATE_INFO *create_info)
+{
+  DBUG_ENTER("ha_example::create");
+  /* This is not implemented but we want someone to be able that it works. */
+  DBUG_RETURN(0);
+}
+#endif /* HAVE_EXAMPLE_DB */

sql/examples/ha_example.h

+/* Copyright (C) 2003 MySQL AB
+
+  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+typedef struct st_example_share {
+  char *table_name;
+  uint table_name_length,use_count;
+  pthread_mutex_t mutex;
+  THR_LOCK lock;
+} EXAMPLE_SHARE;
+
+class ha_example: public handler
+{
+  THR_LOCK_DATA lock;      /* MySQL lock */
+  EXAMPLE_SHARE *share;    /* Shared lock info */
+
+public:
+  ha_example(TABLE *table): handler(table)
+  {
+  }
+  ~ha_example() 
+  {
+  }
+  const char *table_type() const { return "EXAMPLE"; }
+  const char *index_type(uint inx) { return "NONE"; }
+  const char **bas_ext() const;
+  ulong table_flags() const
+  {
+    return 0;
+  }
+  ulong index_flags(uint inx) const
+  {
+    return 0;
+  }
+  uint max_record_length() const { return HA_MAX_REC_LENGTH; }
+  uint max_keys()          const { return 0; }
+  uint max_key_parts()     const { return 0; }
+  uint max_key_length()    const { return 0; }
+  /*
+    Called in test_quick_select to determine if indexes should be used.
+  */
+  virtual double scan_time() { return (double) (records+deleted) / 20.0+10; }
+  /* The next method will never be called */
+  virtual double read_time(ha_rows rows) { return (double) rows /  20.0+1; }
+  virtual bool fast_key_read() { return 1;}
+
+  int open(const char *name, int mode, uint test_if_locked);
+  int close(void);
+  int write_row(byte * buf);
+  int update_row(const byte * old_data, byte * new_data);
+  int delete_row(const byte * buf);
+  int index_read(byte * buf, const byte * key,
+                 uint key_len, enum ha_rkey_function find_flag);
+  int index_read_idx(byte * buf, uint idx, const byte * key,
+                     uint key_len, enum ha_rkey_function find_flag);
+  int index_next(byte * buf);
+  int index_prev(byte * buf);
+  int index_first(byte * buf);
+  int index_last(byte * buf);
+  int rnd_init(bool scan=1);
+  int rnd_next(byte *buf);
+  int rnd_pos(byte * buf, byte *pos);
+  void position(const byte *record);
+  void info(uint);
+  int extra(enum ha_extra_function operation);
+  int reset(void);
+  int external_lock(THD *thd, int lock_type);
+  int delete_all_rows(void);
+  ha_rows records_in_range(int inx, const byte *start_key,uint start_key_len,
+                           enum ha_rkey_function start_search_flag,
+                           const byte *end_key,uint end_key_len,
+                           enum ha_rkey_function end_search_flag);
+  int delete_table(const char *from);
+  int rename_table(const char * from, const char * to);
+  int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
+
+  THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
+                             enum thr_lock_type lock_type);
+};

sql/handler.cc

@@ -32,6 +32,9 @@
 #ifdef HAVE_BERKELEY_DB
 #include "ha_berkeley.h"
 #endif
+#ifdef HAVE_EXAMPLE_DB
+#include "examples/ha_example.h"
+#endif
 #ifdef HAVE_INNOBASE_DB
 #include "ha_innodb.h"
 #else
@@ -76,6 +79,8 @@ struct show_table_type_st sys_table_types[]=
    "Supports transactions and page-level locking", DB_TYPE_BERKELEY_DB},
   {"BERKELEYDB",&have_berkeley_db,
    "Alias for BDB", DB_TYPE_BERKELEY_DB},
+  {"EXAMPLE",&have_example_db,
+   "Example storage engine", DB_TYPE_EXAMPLE_DB},
   {NullS, NULL, NullS, DB_TYPE_UNKNOWN}
 };
 
@@ -171,6 +176,10 @@ handler *get_new_handler(TABLE *table, enum db_type db_type)
 #ifdef HAVE_INNOBASE_DB
   case DB_TYPE_INNODB:
     return new ha_innobase(table);
+#endif
+#ifdef HAVE_EXAMPLE_DB
+  case DB_TYPE_EXAMPLE_DB:
+    return new ha_example(table);
 #endif
   case DB_TYPE_HEAP:
     return new ha_heap(table);

sql/handler.h

@@ -146,7 +146,7 @@ enum db_type { DB_TYPE_UNKNOWN=0,DB_TYPE_DIAB_ISAM=1,
 	       DB_TYPE_RMS_ISAM, DB_TYPE_HEAP, DB_TYPE_ISAM,
 	       DB_TYPE_MRG_ISAM, DB_TYPE_MYISAM, DB_TYPE_MRG_MYISAM,
 	       DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB, DB_TYPE_GEMINI,
-	       DB_TYPE_DEFAULT };
+	       DB_TYPE_EXAMPLE_DB, DB_TYPE_DEFAULT };
 
 struct show_table_type_st {
   const char *type;

sql/mysql_priv.h

@@ -908,7 +908,7 @@ extern struct my_option my_long_options[];
 
 /* optional things, have_* variables */
 
-extern SHOW_COMP_OPTION have_isam, have_innodb, have_berkeley_db;
+extern SHOW_COMP_OPTION have_isam, have_innodb, have_berkeley_db, have_example_db;
 extern SHOW_COMP_OPTION have_raid, have_openssl, have_symlink;
 extern SHOW_COMP_OPTION have_query_cache, have_berkeley_db, have_innodb;
 extern SHOW_COMP_OPTION have_crypt;

sql/mysqld.cc

@@ -370,7 +370,7 @@ KEY_CACHE *sql_key_cache;
 CHARSET_INFO *system_charset_info, *files_charset_info ;
 CHARSET_INFO *national_charset_info, *table_alias_charset;
 
-SHOW_COMP_OPTION have_berkeley_db, have_innodb, have_isam;
+SHOW_COMP_OPTION have_berkeley_db, have_innodb, have_isam, have_example_db;
 SHOW_COMP_OPTION have_raid, have_openssl, have_symlink, have_query_cache;
 SHOW_COMP_OPTION have_crypt, have_compress;
 
@@ -5121,6 +5121,11 @@ static void mysql_init_variables(void)
 #else
   have_isam=SHOW_OPTION_NO;
 #endif
+#ifdef HAVE_EXAMPLE_DB
+  have_example_db= SHOW_OPTION_YES;
+#else
+  have_example_db= SHOW_OPTION_NO;
+#endif
 #ifdef USE_RAID
   have_raid=SHOW_OPTION_YES;
 #else