home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / ha_berkeley.cpp < prev    next >
C/C++ Source or Header  |  2000-11-20  |  43KB  |  1,630 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. /*
  19.   TODO:
  20.   - Not compressed keys should use cmp_fix_length_key
  21.   - Don't automaticly pack all string keys (To do this we need to modify
  22.     CREATE TABLE so that one can use the pack_keys argument per key).
  23.   - An argument to pack_key that we don't want compression.
  24.   - DB_DBT_USERMEN should be used for fixed length tables
  25.     We will need an updated Berkeley DB version for this.
  26.   - Killing threads that has got a 'deadlock'
  27.   - SHOW TABLE STATUS should give more information about the table.
  28.   - Get a more accurate count of the number of rows (estimate_number_of_rows()).
  29.     We could store the found number of rows when the table is scanned and
  30.     then increment the counter for each attempted write.
  31.   - We will need a manager thread that calls flush_logs, removes old
  32.     logs and makes checkpoints at given intervals.
  33.   - When not using UPDATE IGNORE, don't make a sub transaction but abort
  34.     the main transaction on errors.
  35.   - Handling of drop table during autocommit=0 ?
  36.     (Should we just give an error in this case if there is a pending
  37.     transaction ?)
  38.   - When using ALTER TABLE IGNORE, we should not start an transaction, but do
  39.     everything wthout transactions.
  40.  
  41.   Testing of:
  42.   - ALTER TABLE
  43.   - LOCK TABLES
  44.   - CHAR keys
  45.   - BLOBS
  46. */
  47.  
  48.  
  49. #ifdef __GNUC__
  50. #pragma implementation                // gcc: Class implementation
  51. #endif
  52.  
  53. #include "mysql_priv.h"
  54. #ifdef HAVE_BERKELEY_DB
  55. #include <m_ctype.h>
  56. #include <myisampack.h>
  57. #include <assert.h>
  58. #include <hash.h>
  59. #include "ha_berkeley.h"
  60.  
  61. #define HA_BERKELEY_ROWS_IN_TABLE 10000 /* to get optimization right */
  62. #define HA_BERKELEY_RANGE_COUNT      100
  63. #define HA_BERKELEY_MAX_ROWS      10000000 /* Max rows in table */
  64.  
  65. const char *ha_berkeley_ext=".db";
  66. bool berkeley_skip=0;
  67. u_int32_t berkeley_init_flags=0,berkeley_lock_type=DB_LOCK_DEFAULT;
  68. ulong berkeley_cache_size;
  69. char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
  70. long berkeley_lock_scan_time=0;
  71. ulong berkeley_trans_retry=5;
  72. ulong berkeley_lock_max;
  73. pthread_mutex_t bdb_mutex;
  74.  
  75. static DB_ENV *db_env;
  76. static HASH bdb_open_tables;
  77.  
  78. const char *berkeley_lock_names[] =
  79. { "DEFAULT", "OLDEST","RANDOM","YOUNGEST" };
  80. u_int32_t berkeley_lock_types[]=
  81. { DB_LOCK_DEFAULT, DB_LOCK_OLDEST, DB_LOCK_RANDOM };
  82. TYPELIB berkeley_lock_typelib= {array_elements(berkeley_lock_names),"",
  83.                 berkeley_lock_names};
  84.  
  85. static void berkeley_print_error(const char *db_errpfx, char *buffer);
  86. static byte* bdb_get_key(BDB_SHARE *share,uint *length,
  87.              my_bool not_used __attribute__((unused)));
  88. static BDB_SHARE *get_share(const char *table_name);
  89. static void free_share(BDB_SHARE *share);
  90.  
  91.  
  92. /* General functions */
  93.  
  94. bool berkeley_init(void)
  95. {
  96.   char buff[1024],*config[10], **conf_pos, *str_pos;
  97.   conf_pos=config; str_pos=buff;
  98.   DBUG_ENTER("berkeley_init");
  99.  
  100.   if (!berkeley_tmpdir)
  101.     berkeley_tmpdir=mysql_tmpdir;
  102.   if (!berkeley_home)
  103.     berkeley_home=mysql_real_data_home;
  104.  
  105.   if (db_env_create(&db_env,0))
  106.     DBUG_RETURN(1);
  107.   db_env->set_errcall(db_env,berkeley_print_error);
  108.   db_env->set_errpfx(db_env,"bdb");
  109.   db_env->set_tmp_dir(db_env, berkeley_tmpdir);
  110.   db_env->set_data_dir(db_env, mysql_data_home);
  111.   if (berkeley_logdir)
  112.     db_env->set_lg_dir(db_env, berkeley_logdir);
  113.  
  114.   if (opt_endinfo)
  115.     db_env->set_verbose(db_env,
  116.             DB_VERB_CHKPOINT | DB_VERB_DEADLOCK | DB_VERB_RECOVERY,
  117.             1);
  118.   
  119.   db_env->set_cachesize(db_env, 0, berkeley_cache_size, 0);
  120.   db_env->set_lk_detect(db_env, berkeley_lock_type);
  121.   if (berkeley_lock_max)
  122.     db_env->set_lk_max(db_env, berkeley_lock_max);
  123.   if (db_env->open(db_env,
  124.            berkeley_home,
  125.            berkeley_init_flags |  DB_INIT_LOCK | 
  126.            DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
  127.            DB_CREATE | DB_THREAD | DB_PRIVATE, 0666))
  128.   {
  129.     db_env->close(db_env,0);
  130.     db_env=0;
  131.   }
  132.   (void) hash_init(&bdb_open_tables,32,0,0,
  133.            (hash_get_key) bdb_get_key,0,0);
  134.   pthread_mutex_init(&bdb_mutex,NULL);
  135.   DBUG_RETURN(db_env == 0);
  136. }
  137.  
  138.  
  139. bool berkeley_end(void)
  140. {
  141.   int error;
  142.   DBUG_ENTER("berkeley_end");
  143.   if (!db_env)
  144.     return 1;
  145.   error=db_env->close(db_env,0);        // Error is logged
  146.   db_env=0;
  147.   hash_free(&bdb_open_tables);
  148.   pthread_mutex_destroy(&bdb_mutex);
  149.   DBUG_RETURN(error != 0);
  150. }
  151.  
  152. bool berkeley_flush_logs()
  153. {
  154.   int error;
  155.   bool result=0;
  156.   DBUG_ENTER("berkeley_flush_logs");
  157.   if ((error=log_flush(db_env,0)))
  158.   {
  159.     my_error(ER_ERROR_DURING_FLUSH_LOGS,MYF(0),error);
  160.     result=1;
  161.   }
  162.   if ((error=txn_checkpoint(db_env,0,0,0)))
  163.   {
  164.     my_error(ER_ERROR_DURING_CHECKPOINT,MYF(0),error);
  165.     result=1;
  166.   }
  167.   DBUG_RETURN(result);
  168. }
  169.  
  170.  
  171. int berkeley_commit(THD *thd)
  172. {
  173.   DBUG_ENTER("berkeley_commit");
  174.   DBUG_PRINT("trans",("ending transaction"));
  175.   int error=txn_commit((DB_TXN*) thd->transaction.bdb_tid,0);
  176. #ifndef DBUG_OFF
  177.   if (error)
  178.     DBUG_PRINT("error",("error: %d",error));
  179. #endif
  180.   thd->transaction.bdb_tid=0;
  181.   DBUG_RETURN(error);
  182. }
  183.  
  184. int berkeley_rollback(THD *thd)
  185. {
  186.   DBUG_ENTER("berkeley_rollback");
  187.   DBUG_PRINT("trans",("aborting transaction"));
  188.   int error=txn_abort((DB_TXN*) thd->transaction.bdb_tid);
  189.   thd->transaction.bdb_tid=0;
  190.   DBUG_RETURN(error);
  191. }
  192.  
  193.  
  194. static void berkeley_print_error(const char *db_errpfx, char *buffer)
  195. {
  196.   sql_print_error("%s:  %s",db_errpfx,buffer);
  197. }
  198.  
  199.  
  200.  
  201. /*****************************************************************************
  202. ** Berkeley DB tables
  203. *****************************************************************************/
  204.  
  205. const char **ha_berkeley::bas_ext() const
  206. { static const char *ext[]= { ha_berkeley_ext, NullS }; return ext; }
  207.  
  208.  
  209. static int
  210. berkeley_cmp_hidden_key(DB* file, const DBT *new_key, const DBT *saved_key)
  211. {
  212.   ulonglong a=uint5korr((char*) new_key->data);
  213.   ulonglong b=uint5korr((char*) saved_key->data);
  214.   return  a < b ? -1 : (a > b ? 1 : 0); 
  215. }
  216.  
  217. static int
  218. berkeley_cmp_packed_key(DB *file, const DBT *new_key, const DBT *saved_key)
  219. {
  220.   KEY *key=          (KEY*) (file->app_private);
  221.   char *new_key_ptr=  (char*) new_key->data;
  222.   char *saved_key_ptr=(char*) saved_key->data;
  223.   KEY_PART_INFO *key_part= key->key_part, *end=key_part+key->key_parts;
  224.   uint key_length=new_key->size;
  225.  
  226.   for ( ; key_part != end && (int) key_length > 0; key_part++)
  227.   {
  228.     int cmp;
  229.     if (key_part->null_bit)
  230.     {
  231.       if (*new_key_ptr != *saved_key_ptr++)
  232.     return ((int) *new_key_ptr - (int) saved_key_ptr[-1]);
  233.       if (!*new_key_ptr++)
  234.       {
  235.     key_length--;
  236.     continue;
  237.       }
  238.     }
  239.     if ((cmp=key_part->field->pack_cmp(new_key_ptr,saved_key_ptr,
  240.                        key_part->length)))
  241.       return cmp;
  242.     uint length=key_part->field->packed_col_length(new_key_ptr);
  243.     new_key_ptr+=length;
  244.     key_length-=length;
  245.     saved_key_ptr+=key_part->field->packed_col_length(saved_key_ptr);
  246.   }
  247.   return key->handler.bdb_return_if_eq;
  248. }
  249.  
  250.  
  251. /* The following is not yet used; Should be used for fixed length keys */
  252.  
  253. static int
  254. berkeley_cmp_fix_length_key(DB *file, const DBT *new_key, const DBT *saved_key)
  255. {
  256.   KEY *key=(KEY*) (file->app_private);
  257.   char *new_key_ptr=  (char*) new_key->data;
  258.   char *saved_key_ptr=(char*) saved_key->data;
  259.   KEY_PART_INFO *key_part= key->key_part, *end=key_part+key->key_parts;
  260.   uint key_length=new_key->size;
  261.  
  262.   for ( ; key_part != end && (int) key_length > 0 ; key_part++)
  263.   {
  264.     int cmp;
  265.     if ((cmp=key_part->field->pack_cmp(new_key_ptr,saved_key_ptr,0)))
  266.       return cmp;
  267.     new_key_ptr+=key_part->length;
  268.     key_length-= key_part->length;
  269.     saved_key_ptr+=key_part->length;
  270.   }
  271.   return key->handler.bdb_return_if_eq;
  272. }
  273.  
  274.  
  275. /* Compare key against row */
  276.  
  277. static bool
  278. berkeley_key_cmp(TABLE *table, KEY *key_info, const char *key, uint key_length)
  279. {
  280.   KEY_PART_INFO *key_part= key_info->key_part,
  281.             *end=key_part+key_info->key_parts;
  282.  
  283.   for ( ; key_part != end && (int) key_length > 0; key_part++)
  284.   {
  285.     int cmp;
  286.     if (key_part->null_bit)
  287.     {
  288.       key_length--;
  289.       if (*key != (table->record[0][key_part->null_offset] &
  290.            key_part->null_bit) ? 0 : 1)
  291.     return 1;
  292.       if (!*key++)                    // Null value
  293.     continue;
  294.     }
  295.     if ((cmp=key_part->field->pack_cmp(key,key_part->length)))
  296.       return cmp;
  297.     uint length=key_part->field->packed_col_length(key);
  298.     key+=length;
  299.     key_length-=length;
  300.   }
  301.   return 0;
  302. }
  303.  
  304.  
  305. int ha_berkeley::open(const char *name, int mode, uint test_if_locked)
  306. {
  307.   char name_buff[FN_REFLEN];
  308.   uint open_mode=(mode == O_RDONLY ? DB_RDONLY : 0) | DB_THREAD;
  309.   int error;
  310.   DBUG_ENTER("ha_berkeley::open");
  311.  
  312.   /* Open primary key */
  313.   hidden_primary_key=0;
  314.   if ((primary_key=table->primary_key) >= MAX_KEY)
  315.   {                        // No primary key
  316.     primary_key=table->keys;
  317.     fixed_length_primary_key=1;
  318.     ref_length=hidden_primary_key=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
  319.   }
  320.   key_used_on_scan=primary_key;
  321.  
  322.   /* Need some extra memory in case of packed keys */
  323.   uint max_key_length= table->max_key_length + MAX_REF_PARTS*2;
  324.   if (!(alloc_ptr=
  325.     my_multi_malloc(MYF(MY_WME),
  326.             &key_file, (table->keys+1)*sizeof(*key_file),
  327.             &key_type, (table->keys+1)*sizeof(u_int32_t),
  328.             &key_buff,  max_key_length,
  329.             &key_buff2, max_key_length,
  330.             &primary_key_buff,
  331.             (hidden_primary_key ? 0 :
  332.              table->key_info[table->primary_key].key_length),
  333.             NullS)))
  334.     DBUG_RETURN(1);
  335.   if (!(rec_buff=my_malloc((alloced_rec_buff_length=table->rec_buff_length),
  336.                MYF(MY_WME))))
  337.   {
  338.     my_free(alloc_ptr,MYF(0));
  339.     DBUG_RETURN(1);
  340.   }
  341.  
  342.   /* Init table lock structure */
  343.   if (!(share=get_share(name)))
  344.   {
  345.     my_free(rec_buff,MYF(0));
  346.     my_free(alloc_ptr,MYF(0));
  347.     DBUG_RETURN(1);
  348.   }
  349.   thr_lock_data_init(&share->lock,&lock,(void*) 0);
  350.  
  351.   if ((error=db_create(&file, db_env, 0)))
  352.   {
  353.     free_share(share);
  354.     my_free(rec_buff,MYF(0));
  355.     my_free(alloc_ptr,MYF(0));
  356.     my_errno=error;
  357.     DBUG_RETURN(1);
  358.   }
  359.  
  360.   file->set_bt_compare(file,
  361.                (hidden_primary_key ? berkeley_cmp_hidden_key :
  362.             berkeley_cmp_packed_key));
  363.   if (!hidden_primary_key)
  364.     file->app_private= (void*) (table->key_info+table->primary_key);
  365.   if ((error=(file->open(file, fn_format(name_buff,name,"", ha_berkeley_ext,
  366.                      2 | 4),
  367.              "main", DB_BTREE, open_mode,0))))
  368.   {
  369.     free_share(share);
  370.     my_free(rec_buff,MYF(0));
  371.     my_free(alloc_ptr,MYF(0));
  372.     my_errno=error;
  373.     DBUG_RETURN(1);
  374.   }
  375.  
  376.   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
  377.   transaction=0;
  378.   cursor=0;
  379.   key_read=0;
  380.   fixed_length_row=!(table->db_create_options & HA_OPTION_PACK_RECORD);
  381.  
  382.   /* Open other keys */
  383.   bzero((char*) key_file,sizeof(*key_file)*table->keys);
  384.   key_file[primary_key]=file;
  385.   key_type[primary_key]=DB_NOOVERWRITE;
  386.   bzero((char*) ¤t_row,sizeof(current_row));
  387.  
  388.   DB **ptr=key_file;
  389.   for (uint i=0, used_keys=0; i < table->keys ; i++, ptr++)
  390.   {
  391.     char part[7];
  392.     if (i != primary_key)
  393.     {
  394.       if ((error=db_create(ptr, db_env, 0)))
  395.       {
  396.     close();
  397.     my_errno=error;
  398.     DBUG_RETURN(1);
  399.       }
  400.       sprintf(part,"key%02d",++used_keys);
  401.       key_type[i]=table->key_info[i].flags & HA_NOSAME ? DB_NOOVERWRITE : 0;
  402.       (*ptr)->set_bt_compare(*ptr, berkeley_cmp_packed_key);
  403.       (*ptr)->app_private= (void*) (table->key_info+i);
  404.       if (!(table->key_info[i].flags & HA_NOSAME))
  405.     (*ptr)->set_flags(*ptr, DB_DUP);
  406.       if ((error=((*ptr)->open(*ptr, name_buff, part, DB_BTREE,
  407.                    open_mode, 0))))
  408.       {
  409.     close();
  410.     my_errno=error;
  411.     DBUG_RETURN(1);
  412.       }
  413.     }
  414.   }
  415.  
  416.   /* Calculate pack_length of primary key */
  417.   if (!hidden_primary_key)
  418.   {
  419.     ref_length=0;
  420.     KEY_PART_INFO *key_part= table->key_info[primary_key].key_part;
  421.     KEY_PART_INFO *end=key_part+table->key_info[primary_key].key_parts;
  422.     for ( ; key_part != end ; key_part++)
  423.       ref_length+= key_part->field->max_packed_col_length(key_part->length);
  424.     fixed_length_primary_key=
  425.       (ref_length == table->key_info[primary_key].key_length);
  426.   }
  427.   else
  428.   {
  429.     if (!share->primary_key_inited)
  430.       update_auto_primary_key();
  431.   }
  432.   DBUG_RETURN(0);
  433. }
  434.  
  435.  
  436. int ha_berkeley::close(void)
  437. {
  438.   int error,result=0;
  439.   uint keys=table->keys + test(hidden_primary_key);
  440.   DBUG_ENTER("ha_berkeley::close");
  441.  
  442.   for (uint i=0; i < keys; i++)
  443.   {
  444.     if (key_file[i] && (error=key_file[i]->close(key_file[i],0)))
  445.       result=error;
  446.   }
  447.   free_share(share);
  448.   my_free(rec_buff,MYF(MY_ALLOW_ZERO_PTR));
  449.   my_free(alloc_ptr,MYF(MY_ALLOW_ZERO_PTR));
  450.   if (result)
  451.     my_errno=result;
  452.   DBUG_RETURN(result);
  453. }
  454.  
  455.  
  456. /* Reallocate buffer if needed */
  457.  
  458. bool ha_berkeley::fix_rec_buff_for_blob(ulong length)
  459. {
  460.   if (! rec_buff || length > alloced_rec_buff_length)
  461.   {
  462.     byte *newptr;
  463.     if (!(newptr=(byte*) my_realloc((gptr) rec_buff, length,
  464.                     MYF(MY_ALLOW_ZERO_PTR))))
  465.       return 1;
  466.     rec_buff=newptr;
  467.     alloced_rec_buff_length=length;
  468.   }
  469.   return 0;
  470. }
  471.  
  472.  
  473. /* Calculate max length needed for row */
  474.  
  475. ulong ha_berkeley::max_row_length(const byte *buf)
  476. {
  477.   ulong length=table->reclength + table->fields*2;
  478.   for (Field_blob **ptr=table->blob_field ; *ptr ; ptr++)
  479.     length+= (*ptr)->get_length(buf+(*ptr)->offset())+2;
  480.   return length;
  481. }
  482.  
  483.  
  484. /*
  485.   Pack a row for storage.  If the row is of fixed length, just store the
  486.   row 'as is'.
  487.   If not, we will generate a packed row suitable for storage.
  488.   This will only fail if we don't have enough memory to pack the row, which;
  489.   may only happen in rows with blobs,  as the default row length is
  490.   pre-allocated.
  491. */
  492.  
  493. int ha_berkeley::pack_row(DBT *row, const byte *record, bool new_row)
  494. {
  495.   bzero((char*) row,sizeof(*row));
  496.   if (fixed_length_row)
  497.   {
  498.     row->data=(void*) record;
  499.     row->size=table->reclength+hidden_primary_key;
  500.     if (hidden_primary_key)
  501.     {
  502.       if (new_row)
  503.     get_auto_primary_key(current_ident);
  504.       memcpy_fixed((char*) record+table->reclength, (char*) current_ident,
  505.            BDB_HIDDEN_PRIMARY_KEY_LENGTH);
  506.     }
  507.     return 0;
  508.   }
  509.   if (table->blob_fields)
  510.   {
  511.     if (fix_rec_buff_for_blob(max_row_length(record)))
  512.       return HA_ERR_OUT_OF_MEM;
  513.   }
  514.  
  515.   /* Copy null bits */
  516.   memcpy(rec_buff, record, table->null_bytes);
  517.   byte *ptr=rec_buff + table->null_bytes;
  518.  
  519.   for (Field **field=table->field ; *field ; field++)
  520.     ptr=(byte*) (*field)->pack((char*) ptr,record + (*field)->offset());
  521.  
  522.   if (hidden_primary_key)
  523.   {
  524.     if (new_row)
  525.       get_auto_primary_key(current_ident);
  526.     memcpy_fixed((char*) ptr, (char*) current_ident,
  527.          BDB_HIDDEN_PRIMARY_KEY_LENGTH);
  528.     ptr+=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
  529.   }
  530.   row->data=rec_buff;
  531.   row->size= (size_t) (ptr - rec_buff);
  532.   return 0;
  533. }
  534.  
  535.  
  536. void ha_berkeley::unpack_row(char *record, DBT *row)
  537. {
  538.   if (fixed_length_row)
  539.     memcpy(record,(char*) row->data,table->reclength+hidden_primary_key);
  540.   else
  541.   {
  542.     /* Copy null bits */
  543.     const char *ptr= (const char*) row->data;
  544.     memcpy(record, ptr, table->null_bytes);
  545.     ptr+=table->null_bytes;
  546.     for (Field **field=table->field ; *field ; field++)
  547.       ptr= (*field)->unpack(record + (*field)->offset(), ptr);
  548.   }
  549. }
  550.  
  551.  
  552. /* Store the key and the primary key into the row */
  553.  
  554. void ha_berkeley::unpack_key(char *record, DBT *key, uint index)
  555. {
  556.   KEY *key_info=table->key_info+index;
  557.   KEY_PART_INFO *key_part= key_info->key_part,
  558.                 *end=key_part+key_info->key_parts;
  559.  
  560.   char *pos=(char*) key->data;
  561.   for ( ; key_part != end; key_part++)
  562.   {
  563.     if (key_part->null_bit)
  564.     {
  565.       if (!*pos++)                // Null value
  566.       {
  567.     /*
  568.       We don't need to reset the record data as we will not access it
  569.       if the null data is set
  570.     */
  571.  
  572.     record[key_part->null_offset]|=key_part->null_bit;
  573.     continue;
  574.       }
  575.       record[key_part->null_offset]&= ~key_part->null_bit;
  576.     }
  577.     pos= (char*) key_part->field->unpack(record + key_part->field->offset(),
  578.                      pos);
  579.   }
  580. }
  581.  
  582.  
  583. /*
  584.   Create a packed key from from a row
  585.   This will never fail as the key buffer is pre allocated.
  586. */
  587.  
  588. DBT *ha_berkeley::pack_key(DBT *key, uint keynr, char *buff,
  589.                const byte *record)
  590. {
  591.   bzero((char*) key,sizeof(*key));
  592.  
  593.   if (hidden_primary_key && keynr == primary_key)
  594.   {
  595.     key->data=current_ident;
  596.     key->size=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
  597.     return key;
  598.   }
  599.  
  600.   KEY *key_info=table->key_info+keynr;
  601.   KEY_PART_INFO *key_part=key_info->key_part;
  602.   KEY_PART_INFO *end=key_part+key_info->key_parts;
  603.   DBUG_ENTER("pack_key");
  604.  
  605.   key->data=buff;
  606.  
  607.   for ( ; key_part != end ; key_part++)
  608.   {
  609.     if (key_part->null_bit)
  610.     {
  611.       /* Store 0 if the key part is a NULL part */
  612.       if (record[key_part->null_offset] & key_part->null_bit)
  613.       {
  614.     *buff++ =0;
  615.     key->flags|=DB_DBT_DUPOK;
  616.     continue;
  617.       }
  618.       *buff++ = 1;                // Store NOT NULL marker
  619.     }
  620.     buff=key_part->field->pack(buff,record + key_part->offset,
  621.                    key_part->length);
  622.   }
  623.   key->size= (buff  - (char*) key->data);
  624.   DBUG_DUMP("key",(char*) key->data, key->size);
  625.   DBUG_RETURN(key);
  626. }
  627.  
  628.  
  629. /*
  630.   Create a packed key from from a MySQL unpacked key
  631. */
  632.  
  633. DBT *ha_berkeley::pack_key(DBT *key, uint keynr, char *buff,
  634.                const byte *key_ptr, uint key_length)
  635. {
  636.   KEY *key_info=table->key_info+keynr;
  637.   KEY_PART_INFO *key_part=key_info->key_part;
  638.   KEY_PART_INFO *end=key_part+key_info->key_parts;
  639.   DBUG_ENTER("pack_key2");
  640.  
  641.   bzero((char*) key,sizeof(*key));
  642.   key->data=buff;
  643.  
  644.   for (; key_part != end && (int) key_length > 0 ; key_part++)
  645.   {
  646.     uint offset=0;
  647.     if (key_part->null_bit)
  648.     {
  649.       offset=1;
  650.       if (!(*buff++ = (*key_ptr == 0)))        // Store 0 if NULL
  651.       {
  652.     key_length-= key_part->store_length;
  653.     key_ptr+=   key_part->store_length;
  654.     key->flags|=DB_DBT_DUPOK;
  655.     continue;
  656.       }
  657.       key_ptr++;
  658.     }    
  659.     buff=key_part->field->keypack(buff,key_ptr+offset,key_part->length);
  660.     key_ptr+=key_part->store_length;
  661.     key_length-=key_part->store_length;
  662.   }
  663.   key->size= (buff  - (char*) key->data);
  664.   DBUG_DUMP("key",(char*) key->data, key->size);
  665.   DBUG_RETURN(key);
  666. }
  667.  
  668.  
  669. int ha_berkeley::write_row(byte * record)
  670. {
  671.   DBT row,prim_key,key;
  672.   int error;
  673.   DBUG_ENTER("write_row");
  674.  
  675.   statistic_increment(ha_write_count,&LOCK_status);
  676.   if (table->time_stamp)
  677.     update_timestamp(record+table->time_stamp-1);
  678.   if (table->next_number_field && record == table->record[0])
  679.     update_auto_increment();
  680.   if ((error=pack_row(&row, record,1)))
  681.     DBUG_RETURN(error);
  682.  
  683.   if (table->keys == 1)
  684.   {
  685.     error=file->put(file, transaction, pack_key(&prim_key, primary_key,
  686.                         key_buff, record),
  687.             &row, key_type[primary_key]);
  688.   }
  689.   else
  690.   {
  691.     for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
  692.     {
  693.       uint keynr;
  694.       DB_TXN *sub_trans;
  695.       if ((error=txn_begin(db_env, transaction, &sub_trans, 0)))
  696.     break;
  697.       DBUG_PRINT("trans",("starting subtransaction"));
  698.       if (!(error=file->put(file, sub_trans, pack_key(&prim_key, primary_key,
  699.                               key_buff, record),
  700.                 &row, key_type[primary_key])))
  701.       {
  702.     for (keynr=0 ; keynr < table->keys ; keynr++)
  703.     {
  704.       if (keynr == primary_key)
  705.         continue;
  706.       if ((error=key_file[keynr]->put(key_file[keynr], sub_trans,
  707.                       pack_key(&key, keynr, key_buff2,
  708.                            record),
  709.                       &prim_key, key_type[keynr])))
  710.       {
  711.         last_dup_key=keynr;
  712.         break;
  713.       }
  714.     }
  715.       }
  716.       if (!error)
  717.       {
  718.     DBUG_PRINT("trans",("committing subtransaction"));
  719.     error=txn_commit(sub_trans, 0);
  720.       }
  721.       else
  722.       {
  723.     /* Remove inserted row */
  724.     int new_error;
  725.     DBUG_PRINT("error",("Got error %d",error));
  726.     DBUG_PRINT("trans",("aborting subtransaction"));
  727.     if ((new_error=txn_abort(sub_trans)))
  728.     {
  729.       error=new_error;            // This shouldn't happen
  730.       break;
  731.     }
  732.       }
  733.       if (error != DB_LOCK_DEADLOCK)
  734.     break;
  735.     }
  736.   }
  737.   if (error == DB_KEYEXIST)
  738.     error=HA_ERR_FOUND_DUPP_KEY;
  739.   DBUG_RETURN(error);
  740. }
  741.  
  742.  
  743. /* Compare if a key in a row has changed */
  744.  
  745. int ha_berkeley::key_cmp(uint keynr, const byte * old_row,
  746.              const byte * new_row)
  747. {
  748.   KEY_PART_INFO *key_part=table->key_info[keynr].key_part;
  749.   KEY_PART_INFO *end=key_part+table->key_info[keynr].key_parts;
  750.  
  751.   for ( ; key_part != end ; key_part++)
  752.   {
  753.     if (key_part->null_bit)
  754.     {
  755.       if ((old_row[key_part->null_offset] & key_part->null_bit) !=
  756.       (new_row[key_part->null_offset] & key_part->null_bit))
  757.     return 1;
  758.     }
  759.     if (key_part->key_part_flag & (HA_BLOB_PART | HA_VAR_LENGTH))
  760.     {
  761.       
  762.       if (key_part->field->cmp_binary(old_row + key_part->offset,
  763.                       new_row + key_part->offset,
  764.                       (ulong) key_part->length))
  765.     return 1;
  766.     }
  767.     else
  768.     {
  769.       if (memcmp(old_row+key_part->offset, new_row+key_part->offset,
  770.          key_part->length))
  771.     return 1;
  772.     }
  773.   }
  774.   return 0;
  775. }
  776.  
  777.  
  778. /*
  779.   Update a row from one value to another.
  780. */
  781.  
  782. int ha_berkeley::update_primary_key(DB_TXN *trans, bool primary_key_changed,
  783.                     const byte * old_row,
  784.                     const byte * new_row, DBT *prim_key)
  785. {
  786.   DBT row, old_key;
  787.   int error;
  788.   DBUG_ENTER("update_primary_key");
  789.  
  790.   if (primary_key_changed)
  791.   {
  792.     // Primary key changed or we are updating a key that can have duplicates.
  793.     // Delete the old row and add a new one
  794.     pack_key(&old_key, primary_key, key_buff2, old_row);
  795.     if ((error=remove_key(trans, primary_key, old_row, (DBT *) 0, &old_key)))
  796.       DBUG_RETURN(error);            // This should always succeed
  797.     if ((error=pack_row(&row, new_row, 0)))
  798.     {
  799.       // Out of memory (this shouldn't happen!) 
  800.       (void) file->put(file, trans, &old_key, &row,
  801.                key_type[primary_key]);
  802.       DBUG_RETURN(error);
  803.     }
  804.     // Write new key
  805.     if ((error=file->put(file, trans, prim_key, &row, key_type[primary_key])))
  806.     {
  807.       // Probably a duplicated key;  Return the error and let the caller
  808.       // abort.
  809.       last_dup_key=primary_key;
  810.       DBUG_RETURN(error);
  811.     }
  812.   }
  813.   else
  814.   {
  815.     // Primary key didn't change;  just update the row data
  816.     if ((error=pack_row(&row, new_row, 0)))
  817.       DBUG_RETURN(error);
  818.       error=file->put(file, trans, prim_key, &row, 0);
  819.     if (error)
  820.       DBUG_RETURN(error);                // Fatal error
  821.   }
  822.   DBUG_RETURN(0);
  823. }
  824.  
  825.  
  826.  
  827. int ha_berkeley::update_row(const byte * old_row, byte * new_row)
  828. {
  829.   DBT prim_key, key, old_prim_key;
  830.   int error;
  831.   DB_TXN *sub_trans;
  832.   bool primary_key_changed;
  833.   DBUG_ENTER("update_row");
  834.  
  835.   statistic_increment(ha_update_count,&LOCK_status);
  836.   if (table->time_stamp)
  837.     update_timestamp(new_row+table->time_stamp-1);
  838.  
  839.   if (hidden_primary_key)
  840.   {
  841.     primary_key_changed=0;
  842.     bzero((char*) &prim_key,sizeof(prim_key));
  843.     prim_key.data= (void*) current_ident;
  844.     prim_key.size=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
  845.     old_prim_key=prim_key;
  846.   }
  847.   else
  848.   {
  849.     pack_key(&prim_key, primary_key, key_buff, new_row);
  850.   
  851.     if ((primary_key_changed=key_cmp(primary_key, old_row, new_row)))
  852.       pack_key(&old_prim_key, primary_key, primary_key_buff, old_row);
  853.     else
  854.       old_prim_key=prim_key;
  855.   }
  856.  
  857.   LINT_INIT(error);
  858.   for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
  859.   {
  860.     if ((error=txn_begin(db_env, transaction, &sub_trans, 0)))
  861.       break;
  862.     DBUG_PRINT("trans",("starting subtransaction"));
  863.     /* Start by updating the primary key */
  864.     if (!(error=update_primary_key(sub_trans, primary_key_changed,
  865.                    old_row, new_row, &prim_key)))
  866.     {
  867.       // Update all other keys
  868.       for (uint keynr=0 ; keynr < table->keys ; keynr++)
  869.       {
  870.     if (keynr == primary_key)
  871.       continue;
  872.     if (key_cmp(keynr, old_row, new_row) || primary_key_changed)
  873.     {
  874.       if ((error=remove_key(sub_trans, keynr, old_row, (DBT*) 0,
  875.                 &old_prim_key)) ||
  876.           (error=key_file[keynr]->put(key_file[keynr], sub_trans,
  877.                       pack_key(&key, keynr, key_buff2,
  878.                            new_row),
  879.                       &prim_key, key_type[keynr])))
  880.       {
  881.         last_dup_key=keynr;
  882.         break;
  883.       }
  884.     }
  885.       }
  886.     }
  887.     if (!error)
  888.     {
  889.       DBUG_PRINT("trans",("committing subtransaction"));
  890.       error=txn_commit(sub_trans, 0);
  891.       }
  892.     else
  893.     {
  894.       /* Remove inserted row */
  895.       int new_error;
  896.       DBUG_PRINT("error",("Got error %d",error));
  897.       DBUG_PRINT("trans",("aborting subtransaction"));
  898.       if ((new_error=txn_abort(sub_trans)))
  899.       {
  900.     error=new_error;            // This shouldn't happen
  901.     break;
  902.       }
  903.     }
  904.     if (error != DB_LOCK_DEADLOCK)
  905.       break;
  906.   }
  907.   if (error == DB_KEYEXIST)
  908.     error=HA_ERR_FOUND_DUPP_KEY;
  909.   DBUG_RETURN(error);
  910. }
  911.  
  912.  
  913. /*
  914.   Delete one key
  915.   This uses key_buff2, when keynr != primary key, so it's important that
  916.   a function that calls this doesn't use this buffer for anything else.
  917.   packed_record may be NULL if the key is unique
  918. */
  919.  
  920. int ha_berkeley::remove_key(DB_TXN *sub_trans, uint keynr, const byte *record,
  921.                 DBT *packed_record,
  922.                 DBT *prim_key)
  923. {
  924.   int error;
  925.   DBT key;
  926.   DBUG_ENTER("remove_key");
  927.   DBUG_PRINT("enter",("index: %d",keynr));
  928.  
  929.   if ((table->key_info[keynr].flags & (HA_NOSAME | HA_NULL_PART_KEY)) ==
  930.       HA_NOSAME)
  931.   {                        // Unique key
  932.     dbug_assert(keynr == primary_key || prim_key->data != key_buff2);
  933.     error=key_file[keynr]->del(key_file[keynr], sub_trans,
  934.                    keynr == primary_key ?
  935.                    prim_key :
  936.                    pack_key(&key, keynr, key_buff2, record),
  937.                    0);
  938.   }
  939.   else
  940.   {
  941.     /*
  942.       To delete the not duplicated key, we need to open an cursor on the
  943.       row to find the key to be delete and delete it.
  944.       We will never come here with keynr = primary_key
  945.     */
  946.     dbug_assert(keynr != primary_key && prim_key->data != key_buff2);
  947.     DBC *cursor;
  948.     if (!(error=file->cursor(key_file[keynr], sub_trans, &cursor, 0)))
  949.     {
  950.       if (!(error=cursor->c_get(cursor,
  951.                    (keynr == primary_key ? 
  952.                 prim_key :
  953.                 pack_key(&key, keynr, key_buff2, record)),
  954.                    (keynr == primary_key ? 
  955.                 packed_record :  prim_key),
  956.                 DB_GET_BOTH)))
  957.       {                    // This shouldn't happen
  958.     error=cursor->c_del(cursor,0);
  959.       }
  960.       int result=cursor->c_close(cursor);
  961.       if (!error)
  962.     error=result;
  963.     }
  964.   }
  965.   DBUG_RETURN(error);
  966. }
  967.  
  968.  
  969. /* Delete all keys for new_record */
  970.  
  971. int ha_berkeley::remove_keys(DB_TXN *trans, const byte *record,
  972.                  DBT *new_record, DBT *prim_key, key_map keys,
  973.                  int result)
  974. {
  975.   for (uint keynr=0 ; keys  ;keynr++, keys>>=1)
  976.   {
  977.     if (keys & 1)
  978.     {
  979.       int new_error=remove_key(trans, keynr, record, new_record, prim_key);
  980.       if (new_error)
  981.       {
  982.     result=new_error;            // Return last error
  983.     if (trans)
  984.       break;                // Let rollback correct things
  985.       }
  986.     }
  987.   }
  988.   return result;
  989. }
  990.  
  991.  
  992. int ha_berkeley::delete_row(const byte * record)
  993. {
  994.   int error;
  995.   DBT row, prim_key;
  996.   key_map keys=table->keys_in_use;
  997.   DBUG_ENTER("delete_row");
  998.   statistic_increment(ha_delete_count,&LOCK_status);
  999.     
  1000.   if ((error=pack_row(&row, record, 0)))
  1001.     DBUG_RETURN((error));
  1002.   pack_key(&prim_key, primary_key, key_buff, record);
  1003.   if (hidden_primary_key)
  1004.     keys|= (key_map) 1 << primary_key;
  1005.  
  1006.   for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
  1007.   {
  1008.     DB_TXN *sub_trans;
  1009.     if ((error=txn_begin(db_env, transaction, &sub_trans, 0)))
  1010.       break;
  1011.     DBUG_PRINT("trans",("starting sub transaction"));
  1012.     if (!error)
  1013.       error=remove_keys(sub_trans, record, &row, &prim_key, keys,0);
  1014.     if (!error)
  1015.     {
  1016.       DBUG_PRINT("trans",("ending sub transaction"));
  1017.       error=txn_commit(sub_trans, 0);
  1018.     }
  1019.     if (error)
  1020.     {
  1021.       /* retry */
  1022.       int new_error;
  1023.       DBUG_PRINT("error",("Got error %d",error));
  1024.       DBUG_PRINT("trans",("aborting subtransaction"));
  1025.       if ((new_error=txn_abort(sub_trans)))
  1026.       {
  1027.     error=new_error;            // This shouldn't happen
  1028.     break;
  1029.       }
  1030.     }
  1031.     if (error != DB_LOCK_DEADLOCK)
  1032.       break;
  1033.   }
  1034.   DBUG_RETURN(0);
  1035. }
  1036.  
  1037.  
  1038. int ha_berkeley::index_init(uint keynr)
  1039. {
  1040.   int error;
  1041.   DBUG_ENTER("index_init");
  1042.   active_index=keynr;
  1043.   dbug_assert(cursor == 0);
  1044.   if ((error=file->cursor(key_file[keynr], transaction, &cursor,
  1045.               table->reginfo.lock_type > TL_WRITE_ALLOW_READ ?
  1046.               0 : 0)))
  1047.     cursor=0;                    // Safety
  1048.   bzero((char*) &last_key,sizeof(last_key));
  1049.   DBUG_RETURN(error);
  1050. }
  1051.  
  1052. int ha_berkeley::index_end()
  1053. {
  1054.   int error=0;
  1055.   DBUG_ENTER("index_end");
  1056.   if (cursor)
  1057.   {
  1058.     error=cursor->c_close(cursor);
  1059.     cursor=0;
  1060.   }
  1061.   DBUG_RETURN(error);
  1062. }
  1063.  
  1064.  
  1065. /* What to do after we have read a row based on an index */
  1066.  
  1067. int ha_berkeley::read_row(int error, char *buf, uint keynr, DBT *row,
  1068.               DBT *found_key, bool read_next)
  1069. {
  1070.   DBUG_ENTER("read_row");
  1071.   if (error)
  1072.   {
  1073.     if (error == DB_NOTFOUND || error == DB_KEYEMPTY)
  1074.       error=read_next ? HA_ERR_END_OF_FILE : HA_ERR_KEY_NOT_FOUND;
  1075.     table->status=STATUS_NOT_FOUND;
  1076.     DBUG_RETURN(error);
  1077.   }
  1078.   if (hidden_primary_key)
  1079.     memcpy_fixed(current_ident,
  1080.          (char*) row->data+row->size-BDB_HIDDEN_PRIMARY_KEY_LENGTH,
  1081.          BDB_HIDDEN_PRIMARY_KEY_LENGTH);
  1082.   table->status=0;
  1083.   if (keynr != primary_key)
  1084.   {
  1085.     /* We only found the primary key.  Now we have to use this to find
  1086.        the row data */
  1087.     if (key_read && found_key)
  1088.     {
  1089.       unpack_key(buf,found_key,keynr);
  1090.       if (!hidden_primary_key)
  1091.     unpack_key(buf,row,primary_key);
  1092.       DBUG_RETURN(0);
  1093.     }
  1094.     DBT key;
  1095.     bzero((char*) &key,sizeof(key));
  1096.     key.data=key_buff2;
  1097.     key.size=row->size;
  1098.     memcpy(key_buff2,row->data,row->size);
  1099.     /* Read the data into current_row */
  1100.     current_row.flags=DB_DBT_REALLOC;
  1101.     if ((error=file->get(file, transaction, &key, ¤t_row, 0)))
  1102.     {
  1103.       table->status=STATUS_NOT_FOUND;
  1104.       DBUG_RETURN(error == DB_NOTFOUND ? HA_ERR_CRASHED : error);
  1105.     }
  1106.     row= ¤t_row;
  1107.   }
  1108.   unpack_row(buf,row);
  1109.   DBUG_RETURN(0);
  1110. }
  1111.  
  1112.  
  1113. /* This is only used to read whole keys */
  1114.  
  1115. int ha_berkeley::index_read_idx(byte * buf, uint keynr, const byte * key,
  1116.                 uint key_len, enum ha_rkey_function find_flag)
  1117. {
  1118.   statistic_increment(ha_read_key_count,&LOCK_status);
  1119.   DBUG_ENTER("index_read_idx");
  1120.   current_row.flags=DB_DBT_REALLOC;
  1121.   DBUG_RETURN(read_row(file->get(key_file[keynr], transaction,
  1122.                  pack_key(&last_key, keynr, key_buff, key,
  1123.                       key_len),
  1124.                  ¤t_row,0),
  1125.                buf, keynr, ¤t_row, &last_key, 0));
  1126. }
  1127.  
  1128.  
  1129. int ha_berkeley::index_read(byte * buf, const byte * key,
  1130.                 uint key_len, enum ha_rkey_function find_flag)
  1131. {
  1132.   DBT row;
  1133.   int error;
  1134.   KEY *key_info= &table->key_info[active_index];
  1135.   DBUG_ENTER("index_read");
  1136.  
  1137.   statistic_increment(ha_read_key_count,&LOCK_status);
  1138.   bzero((char*) &row,sizeof(row));
  1139.   if (key_len == key_info->key_length)
  1140.   {
  1141.     error=read_row(cursor->c_get(cursor, pack_key(&last_key,
  1142.                           active_index,
  1143.                           key_buff,
  1144.                           key, key_len),
  1145.                  &row, DB_SET),
  1146.            buf, active_index, &row, (DBT*) 0, 0);
  1147.   }
  1148.   else
  1149.   {
  1150.     /* read of partial key */
  1151.     pack_key(&last_key, active_index, key_buff, key, key_len);
  1152.     /* Store for compare */
  1153.     memcpy(key_buff2, key_buff, (key_len=last_key.size));
  1154.     key_info->handler.bdb_return_if_eq= -1;
  1155.     error=read_row(cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE),
  1156.            buf, active_index, &row, (DBT*) 0, 0);
  1157.     key_info->handler.bdb_return_if_eq= 0;
  1158.     if (!error && find_flag == HA_READ_KEY_EXACT)
  1159.     {
  1160.       /* Ensure that we found a key that is equal to the current one */
  1161.       if (!error && berkeley_key_cmp(table, key_info, key_buff2, key_len))
  1162.     error=HA_ERR_KEY_NOT_FOUND;
  1163.     }
  1164.   }
  1165.   DBUG_RETURN(error);
  1166. }
  1167.  
  1168.  
  1169. int ha_berkeley::index_next(byte * buf)
  1170. {
  1171.   DBT row;
  1172.   DBUG_ENTER("index_next");
  1173.   statistic_increment(ha_read_next_count,&LOCK_status);
  1174.   bzero((char*) &row,sizeof(row));
  1175.   DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
  1176.                buf, active_index, &row, &last_key, 1));
  1177. }
  1178.  
  1179. int ha_berkeley::index_next_same(byte * buf, const byte *key, uint keylen)
  1180. {
  1181.   DBT row;
  1182.   int error;
  1183.   DBUG_ENTER("index_next_same");
  1184.   statistic_increment(ha_read_next_count,&LOCK_status);
  1185.   bzero((char*) &row,sizeof(row));
  1186.   if (keylen == table->key_info[active_index].key_length)
  1187.     error=read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT_DUP),
  1188.            buf, active_index, &row, &last_key, 1);
  1189.   else
  1190.   {
  1191.     error=read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
  1192.            buf, active_index, &row, &last_key, 1);
  1193.     if (!error && ::key_cmp(table, key, active_index, keylen))
  1194.       error=HA_ERR_END_OF_FILE;
  1195.   }
  1196.   DBUG_RETURN(error);
  1197. }
  1198.  
  1199.  
  1200. int ha_berkeley::index_prev(byte * buf)
  1201. {
  1202.   DBT row;
  1203.   DBUG_ENTER("index_prev");
  1204.   statistic_increment(ha_read_prev_count,&LOCK_status);
  1205.   bzero((char*) &row,sizeof(row));
  1206.   DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV),
  1207.                buf, active_index, &row, &last_key, 1));
  1208. }
  1209.   
  1210.  
  1211. int ha_berkeley::index_first(byte * buf)
  1212. {
  1213.   DBT row;
  1214.   DBUG_ENTER("index_first");
  1215.   statistic_increment(ha_read_first_count,&LOCK_status);
  1216.   bzero((char*) &row,sizeof(row));
  1217.   DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_FIRST),
  1218.                buf, active_index, &row, &last_key, 0));
  1219. }
  1220.  
  1221. int ha_berkeley::index_last(byte * buf)
  1222. {
  1223.   DBT row;
  1224.   DBUG_ENTER("index_last");
  1225.   statistic_increment(ha_read_last_count,&LOCK_status);
  1226.   bzero((char*) &row,sizeof(row));
  1227.   DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_LAST),
  1228.                buf, active_index, &row, &last_key, 0));
  1229. }
  1230.  
  1231. int ha_berkeley::rnd_init(bool scan)
  1232. {
  1233.   current_row.flags=DB_DBT_REALLOC;
  1234.   return index_init(primary_key);
  1235. }
  1236.  
  1237. int ha_berkeley::rnd_end()
  1238. {
  1239.   return index_end();
  1240. }
  1241.  
  1242. int ha_berkeley::rnd_next(byte *buf)
  1243. {
  1244.   DBT row;
  1245.   DBUG_ENTER("rnd_next");
  1246.   statistic_increment(ha_read_rnd_next_count,&LOCK_status);
  1247.   bzero((char*) &row,sizeof(row));
  1248.   DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
  1249.                buf, active_index, &row, &last_key, 1));
  1250. }
  1251.  
  1252.  
  1253. DBT *ha_berkeley::get_pos(DBT *to, byte *pos)
  1254. {
  1255.   bzero((char*) to,sizeof(*to));
  1256.  
  1257.   to->data=pos;
  1258.   if (fixed_length_primary_key)
  1259.     to->size=ref_length;
  1260.   else
  1261.   {
  1262.     KEY_PART_INFO *key_part=table->key_info[primary_key].key_part;
  1263.     KEY_PART_INFO *end=key_part+table->key_info[primary_key].key_parts;
  1264.  
  1265.     for ( ; key_part != end ; key_part++)
  1266.       pos+=key_part->field->packed_col_length(pos);
  1267.     to->size= (uint) (pos- (byte*) to->data);
  1268.   }
  1269.   return to;
  1270. }
  1271.  
  1272.  
  1273. int ha_berkeley::rnd_pos(byte * buf, byte *pos)
  1274. {
  1275.   DBT db_pos;
  1276.   statistic_increment(ha_read_rnd_count,&LOCK_status);
  1277.  
  1278.   return read_row(file->get(file, transaction,
  1279.                 get_pos(&db_pos, pos),
  1280.                 ¤t_row, 0),
  1281.           buf, active_index, ¤t_row, (DBT*) 0, 0);
  1282. }
  1283.  
  1284. void ha_berkeley::position(const byte *record)
  1285. {
  1286.   DBT key;
  1287.   if (hidden_primary_key)
  1288.   {
  1289.     memcpy_fixed(ref, (char*) current_ident, BDB_HIDDEN_PRIMARY_KEY_LENGTH);
  1290.   }
  1291.   else
  1292.     pack_key(&key, primary_key, ref, record);
  1293. }
  1294.  
  1295.  
  1296. void ha_berkeley::info(uint flag)
  1297. {
  1298.   DBUG_ENTER("info");
  1299.   if (flag & HA_STATUS_VARIABLE)
  1300.   {
  1301.     records = estimate_number_of_rows();         // Just to get optimisations right
  1302.     deleted = 0;
  1303.   }
  1304.   else if (flag & HA_STATUS_ERRKEY)
  1305.     errkey=last_dup_key;
  1306.   DBUG_VOID_RETURN;
  1307. }
  1308.  
  1309.  
  1310. int ha_berkeley::extra(enum ha_extra_function operation)
  1311. {
  1312.   switch (operation) {
  1313.   case HA_EXTRA_RESET:
  1314.   case HA_EXTRA_RESET_STATE:
  1315.     key_read=0;
  1316.     break;
  1317.   case HA_EXTRA_KEYREAD:
  1318.     key_read=1;                    // Query satisfied with key
  1319.     break;
  1320.   case HA_EXTRA_NO_KEYREAD:
  1321.     key_read=0;
  1322.     break;
  1323.   default:
  1324.     break;
  1325.   }
  1326.   return 0;
  1327. }
  1328.  
  1329.  
  1330. int ha_berkeley::reset(void)
  1331. {
  1332.   key_read=0;                    // Reset to state after open
  1333.   return 0;
  1334. }
  1335.  
  1336.  
  1337. /*
  1338.   As MySQL will execute an external lock for every new table it uses
  1339.   we can use this to start the transactions.
  1340. */
  1341.  
  1342. int ha_berkeley::external_lock(THD *thd, int lock_type)
  1343. {
  1344.   int error=0;
  1345.   DBUG_ENTER("ha_berkeley::external_lock");
  1346.   if (lock_type != F_UNLCK)
  1347.   {
  1348.     if (!thd->transaction.bdb_lock_count++ && !thd->transaction.bdb_tid)
  1349.     {
  1350.       /* Found first lock, start transaction */
  1351.       DBUG_PRINT("trans",("starting transaction"));
  1352.       if ((error=txn_begin(db_env, 0,
  1353.                (DB_TXN**) &thd->transaction.bdb_tid,
  1354.                0)))
  1355.     thd->transaction.bdb_lock_count--;
  1356.     }
  1357.     transaction= (DB_TXN*) thd->transaction.bdb_tid;
  1358.   }
  1359.   else
  1360.   {
  1361.     lock.type=TL_UNLOCK;            // Unlocked
  1362.     if (current_row.flags & (DB_DBT_MALLOC | DB_DBT_REALLOC))
  1363.     {
  1364.       current_row.flags=0;
  1365.       if (current_row.data)
  1366.       {
  1367.     free(current_row.data);
  1368.     current_row.data=0;
  1369.       }
  1370.     }
  1371.     current_row.data=0;
  1372.     if (!--thd->transaction.bdb_lock_count)
  1373.     {
  1374.       if (thd->transaction.bdb_tid && (thd->options & OPTION_AUTO_COMMIT)
  1375.           && !(thd->options & OPTION_BEGIN))
  1376.       {
  1377.     /* 
  1378.        F_UNLOCK is done without a transaction commit / rollback.
  1379.        This happens if the thread didn't update any rows or if
  1380.        something went wrong during an update.
  1381.        We can in this case silenty abort the transaction.
  1382.     */
  1383.     DBUG_PRINT("trans",("aborting transaction"));
  1384.     error=txn_abort((DB_TXN*) thd->transaction.bdb_tid);
  1385.     thd->transaction.bdb_tid=0;
  1386.       }
  1387.     }
  1388.   }
  1389.   DBUG_RETURN(error);
  1390. }  
  1391.  
  1392.  
  1393. THR_LOCK_DATA **ha_berkeley::store_lock(THD *thd, THR_LOCK_DATA **to,
  1394.                     enum thr_lock_type lock_type)
  1395. {
  1396.   if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
  1397.   {
  1398.     /* If we are not doing a LOCK TABLE, then allow multiple writers */
  1399.     if ((lock_type >= TL_WRITE_CONCURRENT_INSERT &&
  1400.      lock_type <= TL_WRITE) &&
  1401.     !thd->in_lock_tables)
  1402.       lock_type = TL_WRITE_ALLOW_WRITE;
  1403.     lock.type=lock_type;
  1404.   }
  1405.   *to++= &lock;
  1406.   return to;
  1407. }
  1408.  
  1409.  
  1410. static int create_sub_table(const char *table_name, const char *sub_name,
  1411.                 DBTYPE type, int flags)
  1412. {
  1413.   int error;
  1414.   DB *file;
  1415.   DBUG_ENTER("create_sub_table");
  1416.   DBUG_PRINT("enter",("sub_name: %s",sub_name));
  1417.  
  1418.   if (!(error=db_create(&file, db_env, 0)))
  1419.   {
  1420.     file->set_flags(file, flags);
  1421.     error=(file->open(file, table_name, sub_name, type,
  1422.               DB_THREAD | DB_CREATE, my_umask));
  1423.     if (error)
  1424.     {
  1425.       DBUG_PRINT("error",("Got error: %d when opening table '%s'",error,
  1426.               table_name));
  1427.       (void) file->remove(file,table_name,NULL,0);
  1428.     }
  1429.     else
  1430.       (void) file->close(file,0);
  1431.   }
  1432.   else
  1433.   {
  1434.     DBUG_PRINT("error",("Got error: %d when creting table",error));
  1435.   }
  1436.   if (error)
  1437.     my_errno=error;
  1438.   DBUG_RETURN(error);
  1439. }
  1440.  
  1441.  
  1442. int ha_berkeley::create(const char *name, register TABLE *form,
  1443.             HA_CREATE_INFO *create_info)
  1444. {
  1445.   char name_buff[FN_REFLEN];
  1446.   char part[7];
  1447.   uint index=1;
  1448.   DBUG_ENTER("ha_berkeley::create");
  1449.  
  1450.   fn_format(name_buff,name,"", ha_berkeley_ext,2 | 4);
  1451.  
  1452.   /* Create the main table that will hold the real rows */
  1453.   if (create_sub_table(name_buff,"main",DB_BTREE,0))
  1454.     DBUG_RETURN(1);
  1455.  
  1456.   primary_key=table->primary_key;
  1457.   /* Create the keys */
  1458.   for (uint i=0; i < form->keys; i++)
  1459.   {
  1460.     if (i != primary_key)
  1461.     {
  1462.       sprintf(part,"key%02d",index++);
  1463.       if (create_sub_table(name_buff, part, DB_BTREE,
  1464.                (table->key_info[i].flags & HA_NOSAME) ? 0 :
  1465.                DB_DUP))
  1466.     DBUG_RETURN(1);
  1467.     }
  1468.   }
  1469.  
  1470.   /* Create the status block to save information from last status command */
  1471.   /* Is DB_BTREE the best option here ? (QUEUE can't be used in sub tables) */
  1472.   if (create_sub_table(name_buff,"status",DB_BTREE,0))
  1473.     DBUG_RETURN(1);
  1474.   DBUG_RETURN(0);
  1475. }
  1476.  
  1477.  
  1478. int ha_berkeley::delete_table(const char *name)
  1479. {
  1480.   int error;
  1481.   char name_buff[FN_REFLEN];
  1482.   if ((error=db_create(&file, db_env, 0)))
  1483.   {
  1484.     my_errno=error;
  1485.     file=0;
  1486.     return 1;
  1487.   }
  1488.   error=file->remove(file,fn_format(name_buff,name,"",ha_berkeley_ext,2 | 4),
  1489.              NULL,0);
  1490.   file=0;                    // Safety
  1491.   return error;
  1492. }
  1493.  
  1494. /*
  1495.   How many seeks it will take to read through the table
  1496.   This is to be comparable to the number returned by records_in_range so
  1497.   that we can decide if we should scan the table or use keys.
  1498. */
  1499.  
  1500. double ha_berkeley::scan_time()
  1501. {
  1502.   return records/3;
  1503.  }
  1504.  
  1505. ha_rows ha_berkeley::records_in_range(int keynr,
  1506.                       const byte *start_key,uint start_key_len,
  1507.                       enum ha_rkey_function start_search_flag,
  1508.                       const byte *end_key,uint end_key_len,
  1509.                       enum ha_rkey_function end_search_flag)
  1510. {
  1511.   DBT key;
  1512.   DB_KEY_RANGE start_range, end_range;
  1513.   double start_pos,end_pos,rows;
  1514.   DBUG_ENTER("records_in_range");
  1515.   if ((start_key && file->key_range(key_file[keynr],transaction,
  1516.                     pack_key(&key, keynr, key_buff, start_key,
  1517.                          start_key_len),
  1518.                     &start_range,0)) ||
  1519.       (end_key && file->key_range(key_file[keynr],transaction,
  1520.                   pack_key(&key, keynr, key_buff, end_key,
  1521.                        end_key_len),
  1522.                   &end_range,0)))
  1523.     DBUG_RETURN(HA_BERKELEY_RANGE_COUNT); // Better than returning an error
  1524.  
  1525.   if (!start_key)
  1526.     start_pos=0.0;
  1527.   else if (start_search_flag == HA_READ_KEY_EXACT)
  1528.     start_pos=start_range.less;
  1529.   else
  1530.     start_pos=start_range.less+start_range.equal;
  1531.  
  1532.   if (!end_key)
  1533.     end_pos=1.0;
  1534.   else if (end_search_flag == HA_READ_BEFORE_KEY)
  1535.     end_pos=end_range.less;
  1536.   else
  1537.     end_pos=end_range.less+end_range.equal;
  1538.   rows=(end_pos-start_pos)*records;
  1539.   DBUG_PRINT("exit",("rows: %g",rows));
  1540.   DBUG_RETURN(rows <= 1.0 ? (ha_rows) 1 : (ha_rows) rows);
  1541. }
  1542.  
  1543. /****************************************************************************
  1544.  Handling the shared BDB_SHARE structure that is needed to provide table
  1545.  locking.
  1546. ****************************************************************************/
  1547.  
  1548. static byte* bdb_get_key(BDB_SHARE *share,uint *length,
  1549.              my_bool not_used __attribute__((unused)))
  1550. {
  1551.   *length=share->table_name_length;
  1552.   return (byte*) share->table_name;
  1553. }
  1554.  
  1555. static BDB_SHARE *get_share(const char *table_name)
  1556. {
  1557.   BDB_SHARE *share;
  1558.   pthread_mutex_lock(&bdb_mutex);
  1559.   uint length=(uint) strlen(table_name);
  1560.   if (!(share=(BDB_SHARE*) hash_search(&bdb_open_tables, table_name, length)))
  1561.   {
  1562.     if ((share=(BDB_SHARE *) my_malloc(sizeof(*share)+length+1,
  1563.                        MYF(MY_WME | MY_ZEROFILL))))
  1564.     {
  1565.       share->table_name_length=length;
  1566.       share->table_name=(char*) (share+1);
  1567.       strmov(share->table_name,table_name);
  1568.       if (hash_insert(&bdb_open_tables, (char*) share))
  1569.       {
  1570.     pthread_mutex_unlock(&bdb_mutex);
  1571.     my_free((gptr) share,0);
  1572.     return 0;
  1573.       }
  1574.       thr_lock_init(&share->lock);
  1575.       pthread_mutex_init(&share->mutex,NULL);
  1576.     }
  1577.   }
  1578.   share->use_count++;
  1579.   pthread_mutex_unlock(&bdb_mutex);
  1580.   return share;
  1581. }
  1582.  
  1583. static void free_share(BDB_SHARE *share)
  1584. {
  1585.   pthread_mutex_lock(&bdb_mutex);
  1586.   if (!--share->use_count)
  1587.   {
  1588.     hash_delete(&bdb_open_tables, (gptr) share);
  1589.     thr_lock_delete(&share->lock);
  1590.     pthread_mutex_destroy(&share->mutex);
  1591.     my_free((gptr) share, MYF(0));
  1592.   }
  1593.   pthread_mutex_unlock(&bdb_mutex);
  1594. }
  1595.  
  1596.  
  1597. void ha_berkeley::update_auto_primary_key()
  1598. {
  1599.   pthread_mutex_lock(&share->mutex);
  1600.   if (!share->primary_key_inited)
  1601.   {
  1602.     (void) extra(HA_EXTRA_KEYREAD);
  1603.     index_init(primary_key);
  1604.     if (!index_last(table->record[1]))
  1605.       share->auto_ident=uint5korr(current_ident);
  1606.     index_end();
  1607.     (void) extra(HA_EXTRA_NO_KEYREAD);
  1608.   }
  1609.   pthread_mutex_unlock(&share->mutex);
  1610. }
  1611.  
  1612. /*
  1613.   Return an estimated of the number of rows in the table.
  1614.   Used when sorting to allocate buffers and by the optimizer.
  1615. */
  1616.  
  1617. ha_rows ha_berkeley::estimate_number_of_rows()
  1618. {
  1619.   ulonglong max_ident;
  1620.   ulonglong max_rows=table->max_rows ? table->max_rows : HA_BERKELEY_MAX_ROWS;
  1621.   if (!hidden_primary_key)
  1622.     return (ha_rows) max_rows;
  1623.   pthread_mutex_lock(&share->mutex);
  1624.   max_ident=share->auto_ident+EXTRA_RECORDS;
  1625.   pthread_mutex_unlock(&share->mutex);
  1626.   return (ha_rows) min(max_ident,max_rows);
  1627. }
  1628.  
  1629. #endif /* HAVE_BERKELEY_DB */
  1630.