Added NDB storage engine

include/my_base.h:
  Added three new errorcodes to be returned by the handler
sql/Makefile.am:
  Add new files discover.cc, ha_ndbcluster.cc and ha_ndbcluster.h
  Add include path of NDB files
sql/handler.cc:
  Added variable for keeping track of number of "discovers"
  Added NDB to list of storage engines
  Added calls to NDB for commit, rollback etc.
  Added function ha_discover for discovering a table from handler
sql/handler.h:
  Added NDB to list of storage engines
  Added vbariable in transaction for keeping a ndb transaction handle
sql/lex.h:
  Changed AND to AND_SYM and OR to OR_SYM to avoid nameclash
sql/mysql_priv.h:
  Added prototypes for new functions readfrm, writefrm and create_table_from_handler
sql/mysqld.cc:
  Added NDB support
  Disable NDB with --skip-ndbcluster
sql/set_var.cc:
  Add posibilty to show if NDB handler is supported
sql/ha_ndbcluster.cc:
  Add ifdef for whole file for not compiling anything if NDB sholdn't be included
  Updated timestamp handling to use new vars timestamp_default_now and timestamp_on_update_now
sql/sql_base.cc:
  If frm file is not found on disk, ask handler if it knows about the table. Then retry the open.
  This new functionality is called "discover" and can be used by any handler.
sql/sql_class.h:
  Added variable for keeping a NDB connection handle
sql/sql_table.cc:
  Before trying to create a table, ask handler if a table with that name already exists.
  If user said CREATE TABLE IF NOT EXISTS, disocver the table from handler
sql/sql_yacc.yy:
  Add NDBCLUSTER_SYM
  Change AND to AND_SYM
  Change OR to OR_SYM
sql/table.cc:
  Fixe for probelm when NullS is returned from bas_ext of a handler.

1 files changed, 218 insertions, 0 deletions

diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h
new file mode 100755
index 00000000000..ed66d07d79b
--- /dev/null
+++ b/sql/ha_ndbcluster.h
@@ -0,0 +1,218 @@
+/* Copyright (C) 2000-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 */
+
+/*
+  This file defines the NDB Cluster handler: the interface between MySQL and
+  NDB Cluster
+*/
+
+/* The class defining a handle to an NDB Cluster table */
+
+#ifdef __GNUC__
+#pragma interface                       /* gcc class implementation */
+#endif
+
+#include <ndbapi_limits.h>
+#include <ndb_types.h>
+
+class Ndb;             // Forward declaration
+class NdbOperation;    // Forward declaration
+class NdbConnection;   // Forward declaration
+class NdbRecAttr;      // Forward declaration
+class NdbResultSet;    // Forward declaration
+
+typedef enum ndb_index_type {
+  UNDEFINED_INDEX = 0,
+  PRIMARY_KEY_INDEX = 1,
+  UNIQUE_INDEX = 2,
+  ORDERED_INDEX = 3
+} NDB_INDEX_TYPE;
+
+
+typedef struct st_ndbcluster_share {
+  THR_LOCK lock;
+  pthread_mutex_t mutex;
+  char *table_name;
+  uint table_name_length,use_count;
+} NDB_SHARE;
+
+class ha_ndbcluster: public handler
+{
+ public:
+  ha_ndbcluster(TABLE *table);
+  ~ha_ndbcluster();
+
+  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_init(uint index);
+  int index_end();
+  int index_read(byte *buf, const byte *key, uint key_len, 
+		 enum ha_rkey_function find_flag);
+  int index_read_idx(byte *buf, uint index, 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_end();
+  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 extra_opt(enum ha_extra_function operation, ulong cache_size);
+  int reset();
+  int external_lock(THD *thd, int lock_type);
+  int start_stmt(THD *thd);
+  const char * table_type() const { return("ndbcluster");}
+  const char ** bas_ext() const;
+  ulong table_flags(void) const { return m_table_flags; }
+  ulong index_flags(uint idx) const;
+  uint max_record_length() const { return NDB_MAX_TUPLE_SIZE; };
+  uint max_keys()          const { return MAX_KEY;  }
+  uint max_key_parts()     const { return NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY; };
+  uint max_key_length()    const { return NDB_MAX_KEY_SIZE;};
+
+  int rename_table(const char *from, const char *to);
+  int delete_table(const char *name);
+  int create(const char *name, TABLE *form, HA_CREATE_INFO *info);
+  THR_LOCK_DATA **store_lock(THD *thd,
+			     THR_LOCK_DATA **to,
+			     enum thr_lock_type lock_type);
+
+  bool low_byte_first() const
+    { 
+#ifdef WORDS_BIGENDIAN
+      return false;
+#else
+      return true;
+#endif
+    }
+  bool has_transactions()  { return true;}
+
+  const char* index_type(uint key_number) {
+    switch (get_index_type(key_number)) {
+    case ORDERED_INDEX:
+      return "BTREE";
+    case UNIQUE_INDEX:
+    case PRIMARY_KEY_INDEX:
+    default:
+      return "HASH";
+    }
+  }
+
+  double scan_time();
+  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);
+
+
+  static Ndb* seize_ndb();
+  static void release_ndb(Ndb* ndb);
+
+    
+ private:
+  int alter_table_name(const char *from, const char *to);
+  int drop_table();
+  int create_index(const char *name, KEY *key_info);
+  int initialize_autoincrement(const void* table);
+  int get_metadata(const char* path);
+  void release_metadata();
+  const char* get_index_name(uint idx_no) const;
+  NDB_INDEX_TYPE get_index_type(uint idx_no) const;
+  NDB_INDEX_TYPE get_index_type_from_table(uint index_no) const;
+  
+  int pk_read(const byte *key, uint key_len, 
+	      byte *buf);
+  int unique_index_read(const byte *key, uint key_len, 
+			byte *buf);
+  int ordered_index_scan(const byte *key, uint key_len, 
+			 byte *buf,
+			 enum ha_rkey_function find_flag);
+  int full_table_scan(byte * buf);
+  int next_result(byte *buf); 
+#if 0
+  int filtered_scan(const byte *key, uint key_len, 
+		    byte *buf,
+		    enum ha_rkey_function find_flag);
+#endif
+
+  void unpack_record(byte *buf);
+
+  void set_dbname(const char *pathname);
+  void set_tabname(const char *pathname);
+  void set_tabname(const char *pathname, char *tabname);
+
+  bool set_hidden_key(NdbOperation*,
+		      uint fieldnr, const byte* field_ptr);
+  int set_ndb_key(NdbOperation*, Field *field,
+		  uint fieldnr, const byte* field_ptr);
+  int set_ndb_value(NdbOperation*, Field *field, uint fieldnr);
+  int get_ndb_value(NdbOperation*, uint fieldnr, byte *field_ptr);
+  int set_primary_key(NdbOperation *op, const byte *key);
+  int set_primary_key(NdbOperation *op);
+  int key_cmp(uint keynr, const byte * old_row, const byte * new_row);
+  void print_results();
+
+  longlong get_auto_increment();
+
+  int ndb_err(NdbConnection*);
+
+ private:
+  int check_ndb_connection();
+
+  NdbConnection *m_active_trans;
+  NdbResultSet *m_active_cursor;
+  Ndb *m_ndb;
+  void *m_table;		
+  char m_dbname[FN_HEADLEN];
+  //char m_schemaname[FN_HEADLEN];
+  char m_tabname[FN_HEADLEN];
+  ulong m_table_flags;
+  THR_LOCK_DATA m_lock;
+  NDB_SHARE *m_share;
+  NDB_INDEX_TYPE  m_indextype[MAX_KEY];
+  NdbRecAttr *m_value[NDB_MAX_ATTRIBUTES_IN_TABLE];
+  bool m_use_write;
+};
+
+bool ndbcluster_init(void);
+bool ndbcluster_end(void);
+
+int ndbcluster_commit(THD *thd, void* ndb_transaction);
+int ndbcluster_rollback(THD *thd, void* ndb_transaction);
+
+void ndbcluster_close_connection(THD *thd);
+
+int ndbcluster_discover(const char* dbname, const char* name,
+			const void** frmblob, uint* frmlen);
+int ndbcluster_drop_database(const char* path);
+
+
+
+
+
+
+
+