Skip to content

M
mariadb
Commit 04d2b020 authored by unknown's avatar unknown
Browse files
Options

This is the second patch for bdb removeal. This takes care of all options and... 

This is the second patch for bdb removeal. This takes care of all options and variables that rely on bdb. 


BitKeeper/deleted/.del-ha_berkeley.cc:
  Delete: sql/ha_berkeley.cc
BitKeeper/deleted/.del-ha_berkeley.h:
  Delete: sql/ha_berkeley.h
mysql-test/install_test_db.sh:
  Removed skip option
mysql-test/mysql-test-run.pl:
  Remove bdb option
mysql-test/mysql-test-run.sh:
  Remove bdb option
sql/Makefile.am:
  Remove bdb option
sql/handler.cc:
  Remove references to bdb
sql/lex.h:
  Removed lex for bdb
sql/mysql_priv.h:
  Removed bdb privs
sql/mysqld.cc:
  Removed all options for bdb
sql/set_var.cc:
  Removed variables for bdb
sql/sql_yacc.yy:
  Removed yacc for bdb
parent 21bb4f94
Hide whitespace changes
Inline Side-by-side
Showing with 8 additions and 3154 deletions
mysql-test/install_test_db.sh
View file @ 04d2b020
...@@ -80,7 +80,7 @@ basedir=. ...@@ -80,7 +80,7 @@ basedir=.
EXTRA_ARG="--language=../sql/share/english/ --character-sets-dir=../sql/share/charsets/" EXTRA_ARG="--language=../sql/share/english/ --character-sets-dir=../sql/share/charsets/"
fi fi
mysqld_boot=" $execdir/mysqld --no-defaults --bootstrap --skip-grant-tables --basedir=$basedir --datadir=$ldata --skip-innodb --skip-ndbcluster --skip-bdb --tmpdir=. $EXTRA_ARG" mysqld_boot=" $execdir/mysqld --no-defaults --bootstrap --skip-grant-tables --basedir=$basedir --datadir=$ldata --skip-innodb --skip-ndbcluster --tmpdir=. $EXTRA_ARG"
echo "running $mysqld_boot" echo "running $mysqld_boot"
if $scriptdir/mysql_create_system_tables test $mdata $hostname | $mysqld_boot if $scriptdir/mysql_create_system_tables test $mdata $hostname | $mysqld_boot
......
mysql-test/mysql-test-run.pl
View file @ 04d2b020
...@@ -2108,7 +2108,6 @@ sub install_db ($$) { ...@@ -2108,7 +2108,6 @@ sub install_db ($$) {
mtr_add_arg($args, "--datadir=%s", $data_dir); mtr_add_arg($args, "--datadir=%s", $data_dir);
mtr_add_arg($args, "--skip-innodb"); mtr_add_arg($args, "--skip-innodb");
mtr_add_arg($args, "--skip-ndbcluster"); mtr_add_arg($args, "--skip-ndbcluster");
mtr_add_arg($args, "--skip-bdb");
mtr_add_arg($args, "--tmpdir=."); mtr_add_arg($args, "--tmpdir=.");
if ( ! $opt_netware ) if ( ! $opt_netware )
...@@ -2201,7 +2200,6 @@ basedir = $path_my_basedir ...@@ -2201,7 +2200,6 @@ basedir = $path_my_basedir
server_id = $server_id server_id = $server_id
skip-stack-trace skip-stack-trace
skip-innodb skip-innodb
skip-bdb
skip-ndbcluster skip-ndbcluster
EOF EOF
; ;
...@@ -2615,7 +2613,6 @@ sub mysqld_arguments ($$$$$) { ...@@ -2615,7 +2613,6 @@ sub mysqld_arguments ($$$$$) {
if ( $opt_valgrind_mysqld ) if ( $opt_valgrind_mysqld )
{ {
mtr_add_arg($args, "%s--skip-safemalloc", $prefix); mtr_add_arg($args, "%s--skip-safemalloc", $prefix);
mtr_add_arg($args, "%s--skip-bdb", $prefix);
} }
my $pidfile; my $pidfile;
......
mysql-test/mysql-test-run.sh
View file @ 04d2b020
...@@ -536,8 +536,8 @@ while test $# -gt 0; do ...@@ -536,8 +536,8 @@ while test $# -gt 0; do
--valgrind | --valgrind-all) --valgrind | --valgrind-all)
find_valgrind; find_valgrind;
VALGRIND=$FIND_VALGRIND VALGRIND=$FIND_VALGRIND
EXTRA_MASTER_MYSQLD_OPT="$EXTRA_MASTER_MYSQLD_OPT --skip-safemalloc --skip-bdb" EXTRA_MASTER_MYSQLD_OPT="$EXTRA_MASTER_MYSQLD_OPT --skip-safemalloc"
EXTRA_SLAVE_MYSQLD_OPT="$EXTRA_SLAVE_MYSQLD_OPT --skip-safemalloc --skip-bdb" EXTRA_SLAVE_MYSQLD_OPT="$EXTRA_SLAVE_MYSQLD_OPT --skip-safemalloc"
SLEEP_TIME_AFTER_RESTART=10 SLEEP_TIME_AFTER_RESTART=10
SLEEP_TIME_FOR_DELETE=60 SLEEP_TIME_FOR_DELETE=60
USE_RUNNING_SERVER=0 USE_RUNNING_SERVER=0
......
sql/Makefile.am
View file @ 04d2b020
...@@ -50,7 +50,7 @@ noinst_HEADERS = item.h item_func.h item_sum.h item_cmpfunc.h \ ...@@ -50,7 +50,7 @@ noinst_HEADERS = item.h item_func.h item_sum.h item_cmpfunc.h \
sql_manager.h sql_map.h sql_string.h unireg.h \ sql_manager.h sql_map.h sql_string.h unireg.h \
sql_error.h field.h handler.h mysqld_suffix.h \ sql_error.h field.h handler.h mysqld_suffix.h \
ha_heap.h ha_myisam.h ha_myisammrg.h ha_partition.h \ ha_heap.h ha_myisam.h ha_myisammrg.h ha_partition.h \
ha_innodb.h ha_berkeley.h ha_federated.h \ ha_innodb.h ha_federated.h \
ha_ndbcluster.h ha_ndbcluster_binlog.h \ ha_ndbcluster.h ha_ndbcluster_binlog.h \
ha_ndbcluster_tables.h \ ha_ndbcluster_tables.h \
opt_range.h protocol.h rpl_tblmap.h \ opt_range.h protocol.h rpl_tblmap.h \
...@@ -88,7 +88,7 @@ mysqld_SOURCES = sql_lex.cc sql_handler.cc sql_partition.cc \ ...@@ -88,7 +88,7 @@ mysqld_SOURCES = sql_lex.cc sql_handler.cc sql_partition.cc \
discover.cc time.cc opt_range.cc opt_sum.cc \ discover.cc time.cc opt_range.cc opt_sum.cc \
records.cc filesort.cc handler.cc \ records.cc filesort.cc handler.cc \
ha_heap.cc ha_myisam.cc ha_myisammrg.cc \ ha_heap.cc ha_myisam.cc ha_myisammrg.cc \
ha_partition.cc ha_innodb.cc ha_berkeley.cc \ ha_partition.cc ha_innodb.cc \
ha_federated.cc \ ha_federated.cc \
ha_ndbcluster.cc ha_ndbcluster_binlog.cc \ ha_ndbcluster.cc ha_ndbcluster_binlog.cc \
sql_db.cc sql_table.cc sql_rename.cc sql_crypt.cc \ sql_db.cc sql_table.cc sql_rename.cc sql_crypt.cc \
...@@ -161,9 +161,6 @@ lex_hash.h: gen_lex_hash$(EXEEXT) ...@@ -161,9 +161,6 @@ lex_hash.h: gen_lex_hash$(EXEEXT)
./gen_lex_hash$(EXEEXT) > $@ ./gen_lex_hash$(EXEEXT) > $@
# the following three should eventually be moved out of this directory # the following three should eventually be moved out of this directory
ha_berkeley.o: ha_berkeley.cc ha_berkeley.h
$(CXXCOMPILE) $(LM_CFLAGS) -c $<
ha_ndbcluster.o:ha_ndbcluster.cc ha_ndbcluster.h ha_ndbcluster.o:ha_ndbcluster.cc ha_ndbcluster.h
$(CXXCOMPILE) @ndbcluster_includes@ $(LM_CFLAGS) -c $< $(CXXCOMPILE) @ndbcluster_includes@ $(LM_CFLAGS) -c $<
......
sql/ha_berkeley.cc deleted 100644 → 0
View file @ 21bb4f94
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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 */
/*
TODO:
- Not compressed keys should use cmp_fix_length_key
- Don't automaticly pack all string keys (To do this we need to modify
CREATE TABLE so that one can use the pack_keys argument per key).
- An argument to pack_key that we don't want compression.
- DB_DBT_USERMEM should be used for fixed length tables
We will need an updated Berkeley DB version for this.
- Killing threads that has got a 'deadlock'
- SHOW TABLE STATUS should give more information about the table.
- Get a more accurate count of the number of rows
(estimate_rows_upper_bound()).
We could store the found number of rows when the table is scanned and
then increment the counter for each attempted write.
- We will need to extend the manager thread to makes checkpoints at
given intervals.
- When not using UPDATE IGNORE, don't make a sub transaction but abort
the main transaction on errors.
- Handling of drop table during autocommit=0 ?
(Should we just give an error in this case if there is a pending
transaction ?)
- When using ALTER TABLE IGNORE, we should not start an transaction, but do
everything wthout transactions.
- When we do rollback, we need to subtract the number of changed rows
from the updated tables.
Testing of:
- Mark tables that participate in a transaction so that they are not
closed during the transaction. We need to test what happens if
MySQL closes a table that is updated by a not commited transaction.
*/
#ifdef USE_PRAGMA_IMPLEMENTATION
#pragma implementation // gcc: Class implementation
#endif
#include "mysql_priv.h"
#include <m_ctype.h>
#include <myisampack.h>
#include <hash.h>
#ifdef WITH_BERKELEY_STORAGE_ENGINE
#include "ha_berkeley.h"
#include "sql_manager.h"
#include <stdarg.h>
#include <mysql/plugin.h>
#define HA_BERKELEY_ROWS_IN_TABLE 10000 /* to get optimization right */
#define HA_BERKELEY_RANGE_COUNT 100
#define HA_BERKELEY_MAX_ROWS 10000000 /* Max rows in table */
/* extra rows for estimate_rows_upper_bound() */
#define HA_BERKELEY_EXTRA_ROWS 100
/* Bits for share->status */
#define STATUS_PRIMARY_KEY_INIT 1
#define STATUS_ROW_COUNT_INIT 2
#define STATUS_BDB_ANALYZE 4
const u_int32_t bdb_DB_TXN_NOSYNC= DB_TXN_NOSYNC;
const u_int32_t bdb_DB_RECOVER= DB_RECOVER;
const u_int32_t bdb_DB_PRIVATE= DB_PRIVATE;
const u_int32_t bdb_DB_DIRECT_DB= DB_DIRECT_DB;
const u_int32_t bdb_DB_DIRECT_LOG= DB_DIRECT_LOG;
const char *ha_berkeley_ext=".db";
bool berkeley_shared_data=0;
u_int32_t berkeley_init_flags= DB_PRIVATE | DB_RECOVER,
berkeley_env_flags= DB_LOG_AUTOREMOVE,
berkeley_lock_type= DB_LOCK_DEFAULT;
ulong berkeley_log_buffer_size=0 , berkeley_log_file_size=0;
ulonglong berkeley_cache_size= 0;
char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
long berkeley_lock_scan_time=0;
ulong berkeley_region_size=0, berkeley_cache_parts=1;
ulong berkeley_trans_retry=1;
ulong berkeley_max_lock;
pthread_mutex_t bdb_mutex;
static DB_ENV *db_env;
static HASH bdb_open_tables;
static const char berkeley_hton_name[]= "BerkeleyDB";
static const int berkeley_hton_name_length=sizeof(berkeley_hton_name)-1;
const char *berkeley_lock_names[] =
{ "DEFAULT", "OLDEST", "RANDOM", "YOUNGEST", "EXPIRE", "MAXLOCKS",
"MAXWRITE", "MINLOCKS", "MINWRITE", 0 };
u_int32_t berkeley_lock_types[]=
{ DB_LOCK_DEFAULT, DB_LOCK_OLDEST, DB_LOCK_RANDOM, DB_LOCK_YOUNGEST,
DB_LOCK_EXPIRE, DB_LOCK_MAXLOCKS, DB_LOCK_MAXWRITE, DB_LOCK_MINLOCKS,
DB_LOCK_MINWRITE };
TYPELIB berkeley_lock_typelib= {array_elements(berkeley_lock_names)-1,"",
berkeley_lock_names, NULL};
static void berkeley_print_error(const DB_ENV *db_env, const char *db_errpfx,
const char *buffer);
static byte* bdb_get_key(BDB_SHARE *share,uint *length,
my_bool not_used __attribute__((unused)));
static BDB_SHARE *get_share(const char *table_name, TABLE *table);
static int free_share(BDB_SHARE *share, TABLE *table, uint hidden_primary_key,
bool mutex_is_locked);
static int write_status(DB *status_block, char *buff, uint length);
static void update_status(BDB_SHARE *share, TABLE *table);
static int berkeley_close_connection(THD *thd);
static int berkeley_commit(THD *thd, bool all);
static int berkeley_rollback(THD *thd, bool all);
static int berkeley_rollback_to_savepoint(THD* thd, void *savepoint);
static int berkeley_savepoint(THD* thd, void *savepoint);
static int berkeley_release_savepoint(THD* thd, void *savepoint);
static handler *berkeley_create_handler(TABLE_SHARE *table,
MEM_ROOT *mem_root);
handlerton berkeley_hton;
static handler *berkeley_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
{
return new (mem_root) ha_berkeley(table);
}
typedef struct st_berkeley_trx_data {
DB_TXN *all;
DB_TXN *stmt;
DB_TXN *sp_level;
uint bdb_lock_count;
} berkeley_trx_data;
/* General functions */
int berkeley_init(void)
{
DBUG_ENTER("berkeley_init");
berkeley_hton.state=SHOW_OPTION_YES;
berkeley_hton.db_type=DB_TYPE_BERKELEY_DB;
berkeley_hton.savepoint_offset=sizeof(DB_TXN *);
berkeley_hton.close_connection=berkeley_close_connection;
berkeley_hton.savepoint_set=berkeley_savepoint;
berkeley_hton.savepoint_rollback=berkeley_rollback_to_savepoint;
berkeley_hton.savepoint_release=berkeley_release_savepoint;
berkeley_hton.commit=berkeley_commit;
berkeley_hton.rollback=berkeley_rollback;
berkeley_hton.create=berkeley_create_handler;
berkeley_hton.panic=berkeley_end;
berkeley_hton.flush_logs=berkeley_flush_logs;
berkeley_hton.show_status=berkeley_show_status;
berkeley_hton.flags=HTON_CLOSE_CURSORS_AT_COMMIT | HTON_FLUSH_AFTER_RENAME;
if (have_berkeley_db != SHOW_OPTION_YES)
return 0; // nothing else to do
if (!berkeley_tmpdir)
berkeley_tmpdir=mysql_tmpdir;
if (!berkeley_home)
berkeley_home=mysql_real_data_home;
DBUG_PRINT("bdb",("berkeley_home: %s",mysql_real_data_home));
/*
If we don't set set_lg_bsize() we will get into trouble when
trying to use many open BDB tables.
If log buffer is not set, assume that the we will need 512 byte per
open table. This is a number that we have reached by testing.
*/
if (!berkeley_log_buffer_size)
{
berkeley_log_buffer_size= max(table_cache_size*512,32*1024);
}
/*
Berkeley DB require that
berkeley_log_file_size >= berkeley_log_buffer_size*4
*/
berkeley_log_file_size= berkeley_log_buffer_size*4;
berkeley_log_file_size= MY_ALIGN(berkeley_log_file_size,1024*1024L);
berkeley_log_file_size= max(berkeley_log_file_size, 10*1024*1024L);
if (db_env_create(&db_env,0))
goto error;
db_env->set_errcall(db_env,berkeley_print_error);
db_env->set_errpfx(db_env,"bdb");
db_env->set_tmp_dir(db_env, berkeley_tmpdir);
db_env->set_data_dir(db_env, mysql_data_home);
db_env->set_flags(db_env, berkeley_env_flags, 1);
if (berkeley_logdir)
db_env->set_lg_dir(db_env, berkeley_logdir); /* purecov: tested */
if (opt_endinfo)
db_env->set_verbose(db_env,
DB_VERB_DEADLOCK | DB_VERB_RECOVERY,
1);
if (berkeley_cache_size > (uint) ~0)
db_env->set_cachesize(db_env, berkeley_cache_size / (1024*1024L*1024L),
berkeley_cache_size % (1024L*1024L*1024L),
berkeley_cache_parts);
else
db_env->set_cachesize(db_env, 0, berkeley_cache_size, berkeley_cache_parts);
db_env->set_lg_max(db_env, berkeley_log_file_size);
db_env->set_lg_bsize(db_env, berkeley_log_buffer_size);
db_env->set_lk_detect(db_env, berkeley_lock_type);
db_env->set_lg_regionmax(db_env, berkeley_region_size);
if (berkeley_max_lock)
db_env->set_lk_max(db_env, berkeley_max_lock);
if (db_env->open(db_env,
berkeley_home,
berkeley_init_flags | DB_INIT_LOCK |
DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
DB_CREATE | DB_THREAD, 0666))
{
db_env->close(db_env,0);
db_env=0;
goto error;
}
(void) hash_init(&bdb_open_tables,system_charset_info,32,0,0,
(hash_get_key) bdb_get_key,0,0);
pthread_mutex_init(&bdb_mutex,MY_MUTEX_INIT_FAST);
DBUG_RETURN(FALSE);
error:
have_berkeley_db= SHOW_OPTION_DISABLED; // If we couldn't use handler
DBUG_RETURN(TRUE);
}
int berkeley_end(ha_panic_function type)
{
int error= 0;
DBUG_ENTER("berkeley_end");
if (db_env)
{
berkeley_cleanup_log_files();
error= db_env->close(db_env,0); // Error is logged
db_env= 0;
hash_free(&bdb_open_tables);
pthread_mutex_destroy(&bdb_mutex);
}
DBUG_RETURN(error);
}
static int berkeley_close_connection(THD *thd)
{
my_free((gptr)thd->ha_data[berkeley_hton.slot], MYF(0));
return 0;
}
bool berkeley_flush_logs()
{
int error;
bool result=0;
DBUG_ENTER("berkeley_flush_logs");
if ((error=db_env->log_flush(db_env,0)))
{
my_error(ER_ERROR_DURING_FLUSH_LOGS,MYF(0),error); /* purecov: inspected */
result=1; /* purecov: inspected */
}
if ((error=db_env->txn_checkpoint(db_env,0,0,0)))
{
my_error(ER_ERROR_DURING_CHECKPOINT,MYF(0),error); /* purecov: inspected */
result=1; /* purecov: inspected */
}
DBUG_RETURN(result);
}
static int berkeley_commit(THD *thd, bool all)
{
DBUG_ENTER("berkeley_commit");
DBUG_PRINT("trans",("ending transaction %s", all ? "all" : "stmt"));
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
DB_TXN **txn= all ? &trx->all : &trx->stmt;
int error= (*txn)->commit(*txn,0);
*txn=0;
#ifndef DBUG_OFF
if (error)
DBUG_PRINT("error",("error: %d",error));
#endif
DBUG_RETURN(error);
}
static int berkeley_rollback(THD *thd, bool all)
{
DBUG_ENTER("berkeley_rollback");
DBUG_PRINT("trans",("aborting transaction %s", all ? "all" : "stmt"));
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
DB_TXN **txn= all ? &trx->all : &trx->stmt;
int error= (*txn)->abort(*txn);
*txn=0;
DBUG_RETURN(error);
}
static int berkeley_savepoint(THD* thd, void *savepoint)
{
int error;
DB_TXN **save_txn= (DB_TXN**) savepoint;
DBUG_ENTER("berkeley_savepoint");
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
if (!(error= db_env->txn_begin(db_env, trx->sp_level, save_txn, 0)))
{
trx->sp_level= *save_txn;
}
DBUG_RETURN(error);
}
static int berkeley_rollback_to_savepoint(THD* thd, void *savepoint)
{
int error;
DB_TXN *parent, **save_txn= (DB_TXN**) savepoint;
DBUG_ENTER("berkeley_rollback_to_savepoint");
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
parent= (*save_txn)->parent;
if (!(error= (*save_txn)->abort(*save_txn)))
{
trx->sp_level= parent;
error= berkeley_savepoint(thd, savepoint);
}
DBUG_RETURN(error);
}
static int berkeley_release_savepoint(THD* thd, void *savepoint)
{
int error;
DB_TXN *parent, **save_txn= (DB_TXN**) savepoint;
DBUG_ENTER("berkeley_release_savepoint");
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
parent= (*save_txn)->parent;
if (!(error= (*save_txn)->commit(*save_txn,0)))
{
trx->sp_level= parent;
*save_txn= 0;
}
DBUG_RETURN(error);
}
static bool berkeley_show_logs(THD *thd, stat_print_fn *stat_print)
{
char **all_logs, **free_logs, **a, **f;
int error=1;
MEM_ROOT **root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**,THR_MALLOC);
MEM_ROOT show_logs_root, *old_mem_root= *root_ptr;
DBUG_ENTER("berkeley_show_logs");
init_sql_alloc(&show_logs_root, BDB_LOG_ALLOC_BLOCK_SIZE,
BDB_LOG_ALLOC_BLOCK_SIZE);
*root_ptr= &show_logs_root;
all_logs= free_logs= 0;
if ((error= db_env->log_archive(db_env, &all_logs,
DB_ARCH_ABS | DB_ARCH_LOG)) ||
(error= db_env->log_archive(db_env, &free_logs, DB_ARCH_ABS)))
{
DBUG_PRINT("error", ("log_archive failed (error %d)", error));
db_env->err(db_env, error, "log_archive: DB_ARCH_ABS");
if (error== DB_NOTFOUND)
error=0; // No log files
goto err;
}
/* Error is 0 here */
if (all_logs)
{
for (a = all_logs, f = free_logs; *a; ++a)
{
if (f && *f && strcmp(*a, *f) == 0)
{
f++;
if ((error= stat_print(thd, berkeley_hton_name,
berkeley_hton_name_length, *a, strlen(*a),
STRING_WITH_LEN(SHOW_LOG_STATUS_FREE))))
break;
}
else
{
if ((error= stat_print(thd, berkeley_hton_name,
berkeley_hton_name_length, *a, strlen(*a),
STRING_WITH_LEN(SHOW_LOG_STATUS_INUSE))))
break;
}
}
}
err:
if (all_logs)
free(all_logs);
if (free_logs)
free(free_logs);
free_root(&show_logs_root,MYF(0));
*root_ptr= old_mem_root;
DBUG_RETURN(error);
}
bool berkeley_show_status(THD *thd, stat_print_fn *stat_print,
enum ha_stat_type stat_type)
{
switch (stat_type) {
case HA_ENGINE_LOGS:
return berkeley_show_logs(thd, stat_print);
default:
return FALSE;
}
}
static void berkeley_print_error(const DB_ENV *db_env, const char *db_errpfx,
const char *buffer)
{
sql_print_error("%s: %s",db_errpfx,buffer); /* purecov: tested */
}
void berkeley_cleanup_log_files(void)
{
DBUG_ENTER("berkeley_cleanup_log_files");
char **names;
int error;
// by HF. Sometimes it crashes. TODO - find out why
#ifndef EMBEDDED_LIBRARY
/* XXX: Probably this should be done somewhere else, and
* should be tunable by the user. */
if ((error = db_env->txn_checkpoint(db_env, 0, 0, 0)))
my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error); /* purecov: inspected */
#endif
if ((error = db_env->log_archive(db_env, &names, DB_ARCH_ABS)) != 0)
{
DBUG_PRINT("error", ("log_archive failed (error %d)", error)); /* purecov: inspected */
db_env->err(db_env, error, "log_archive: DB_ARCH_ABS"); /* purecov: inspected */
DBUG_VOID_RETURN; /* purecov: inspected */
}
if (names)
{ /* purecov: tested */
char **np; /* purecov: tested */
for (np = names; *np; ++np) /* purecov: tested */
my_delete(*np, MYF(MY_WME)); /* purecov: tested */
free(names); /* purecov: tested */
}
DBUG_VOID_RETURN;
}
/*****************************************************************************
** Berkeley DB tables
*****************************************************************************/
ha_berkeley::ha_berkeley(TABLE_SHARE *table_arg)
:handler(&berkeley_hton, table_arg), alloc_ptr(0), rec_buff(0), file(0),
int_table_flags(HA_REC_NOT_IN_SEQ | HA_FAST_KEY_READ |
HA_NULL_IN_KEY | HA_CAN_INDEX_BLOBS |
HA_PRIMARY_KEY_IN_READ_INDEX | HA_FILE_BASED |
HA_CAN_GEOMETRY |
HA_AUTO_PART_KEY | HA_TABLE_SCAN_ON_INDEX),
changed_rows(0), last_dup_key((uint) -1), version(0), using_ignore(0)
{}
static const char *ha_berkeley_exts[] = {
ha_berkeley_ext,
NullS
};
const char **ha_berkeley::bas_ext() const
{
return ha_berkeley_exts;
}
ulong ha_berkeley::index_flags(uint idx, uint part, bool all_parts) const
{
ulong flags= (HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER | HA_KEYREAD_ONLY
| HA_READ_RANGE);
for (uint i= all_parts ? 0 : part ; i <= part ; i++)
{
KEY_PART_INFO *key_part= table_share->key_info[idx].key_part+i;
if (key_part->field->type() == FIELD_TYPE_BLOB)
{
/* We can't use BLOBS to shortcut sorts */
flags&= ~(HA_READ_ORDER | HA_KEYREAD_ONLY | HA_READ_RANGE);
break;
}
switch (key_part->field->key_type()) {
case HA_KEYTYPE_TEXT:
case HA_KEYTYPE_VARTEXT1:
case HA_KEYTYPE_VARTEXT2:
/*
As BDB stores only one copy of equal strings, we can't use key read
on these. Binary collations do support key read though.
*/
if (!(key_part->field->charset()->state & MY_CS_BINSORT))
flags&= ~HA_KEYREAD_ONLY;
break;
default: // Keep compiler happy
break;
}
}
return flags;
}
static int
berkeley_cmp_hidden_key(DB* file, const DBT *new_key, const DBT *saved_key)
{
ulonglong a=uint5korr((char*) new_key->data);
ulonglong b=uint5korr((char*) saved_key->data);
return a < b ? -1 : (a > b ? 1 : 0);
}
static int
berkeley_cmp_packed_key(DB *file, const DBT *new_key, const DBT *saved_key)
{
KEY *key= (new_key->app_private ? (KEY*) new_key->app_private :
(KEY*) (file->app_private));
char *new_key_ptr= (char*) new_key->data;
char *saved_key_ptr=(char*) saved_key->data;
KEY_PART_INFO *key_part= key->key_part, *end=key_part+key->key_parts;
uint key_length=new_key->size;
DBUG_DUMP("key_in_index", saved_key_ptr, saved_key->size);
for (; key_part != end && (int) key_length > 0; key_part++)
{
int cmp;
uint length;
if (key_part->null_bit)
{
if (*new_key_ptr != *saved_key_ptr++)
return ((int) *new_key_ptr - (int) saved_key_ptr[-1]);
key_length--;
if (!*new_key_ptr++)
continue;
}
if ((cmp= key_part->field->pack_cmp(new_key_ptr,saved_key_ptr,
key_part->length,
key->table->insert_or_update)))
return cmp;
length= key_part->field->packed_col_length(new_key_ptr,
key_part->length);
new_key_ptr+=length;
key_length-=length;
saved_key_ptr+=key_part->field->packed_col_length(saved_key_ptr,
key_part->length);
}
return key->handler.bdb_return_if_eq;
}
/* The following is not yet used; Should be used for fixed length keys */
#ifdef NOT_YET
static int
berkeley_cmp_fix_length_key(DB *file, const DBT *new_key, const DBT *saved_key)
{
KEY *key= (new_key->app_private ? (KEY*) new_key->app_private :
(KEY*) (file->app_private));
char *new_key_ptr= (char*) new_key->data;
char *saved_key_ptr=(char*) saved_key->data;
KEY_PART_INFO *key_part= key->key_part, *end=key_part+key->key_parts;
uint key_length=new_key->size;
for (; key_part != end && (int) key_length > 0 ; key_part++)
{
int cmp;
if ((cmp=key_part->field->pack_cmp(new_key_ptr,saved_key_ptr,0,0)))
return cmp;
new_key_ptr+=key_part->length;
key_length-= key_part->length;
saved_key_ptr+=key_part->length;
}
return key->handler.bdb_return_if_eq;
}
#endif
/* Compare key against row */
static bool
berkeley_key_cmp(TABLE *table, KEY *key_info, const char *key, uint key_length)
{
KEY_PART_INFO *key_part= key_info->key_part,
*end=key_part+key_info->key_parts;
for (; key_part != end && (int) key_length > 0; key_part++)
{
int cmp;
uint length;
if (key_part->null_bit)
{
key_length--;
/*
With the current usage, the following case will always be FALSE,
because NULL keys are sorted before any other key
*/
if (*key != (table->record[0][key_part->null_offset] &
key_part->null_bit) ? 0 : 1)
return 1;
if (!*key++) // Null value
continue;
}
/*
Last argument has to be 0 as we are also using this to function to see
if a key like 'a ' matched a row with 'a'
*/
if ((cmp= key_part->field->pack_cmp(key, key_part->length, 0)))
return cmp;
length= key_part->field->packed_col_length(key,key_part->length);
key+= length;
key_length-= length;
}
return 0; // Identical keys
}
int ha_berkeley::open(const char *name, int mode, uint test_if_locked)
{
char name_buff[FN_REFLEN];
uint open_mode=(mode == O_RDONLY ? DB_RDONLY : 0) | DB_THREAD;
uint max_key_length;
int error;
DBUG_ENTER("ha_berkeley::open");
/* Open primary key */
hidden_primary_key=0;
if ((primary_key= table_share->primary_key) >= MAX_KEY)
{ // No primary key
primary_key= table_share->keys;
key_used_on_scan=MAX_KEY;
ref_length=hidden_primary_key=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
}
else
key_used_on_scan=primary_key;
/* Need some extra memory in case of packed keys */
max_key_length= table_share->max_key_length + MAX_REF_PARTS*3;
if (!(alloc_ptr=
my_multi_malloc(MYF(MY_WME),
&key_buff, max_key_length,
&key_buff2, max_key_length,
&primary_key_buff,
(hidden_primary_key ? 0 :
table_share->key_info[table_share->primary_key].key_length),
NullS)))
DBUG_RETURN(1); /* purecov: inspected */
if (!(rec_buff= (byte*) my_malloc((alloced_rec_buff_length=
table_share->rec_buff_length),
MYF(MY_WME))))
{
my_free(alloc_ptr,MYF(0)); /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
/* Init shared structure */
if (!(share= get_share(name,table)))
{
my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */
my_free(alloc_ptr,MYF(0)); /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
thr_lock_data_init(&share->lock,&lock,(void*) 0);
key_file = share->key_file;
key_type = share->key_type;
bzero((char*) &current_row,sizeof(current_row));
/* Fill in shared structure, if needed */
pthread_mutex_lock(&share->mutex);
file= share->file;
if (!share->use_count++)
{
if ((error=db_create(&file, db_env, 0)))
{
free_share(share,table, hidden_primary_key,1); /* purecov: inspected */
my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */
my_free(alloc_ptr,MYF(0)); /* purecov: inspected */
my_errno=error; /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
share->file= file;
file->set_bt_compare(file,
(hidden_primary_key ? berkeley_cmp_hidden_key :
berkeley_cmp_packed_key));
if (!hidden_primary_key)
file->app_private= (void*) (table->key_info + table_share->primary_key);
if ((error= db_env->txn_begin(db_env, NULL, (DB_TXN**) &transaction, 0)) ||
(error= (file->open(file, transaction,
fn_format(name_buff, name, "", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
"main", DB_BTREE, open_mode, 0))) ||
(error= transaction->commit(transaction, 0)))
{
free_share(share, table, hidden_primary_key,1); /* purecov: inspected */
my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */
my_free(alloc_ptr,MYF(0)); /* purecov: inspected */
my_errno=error; /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
/* Open other keys; These are part of the share structure */
key_file[primary_key]=file;
key_type[primary_key]= hidden_primary_key ? 0 : DB_NOOVERWRITE;
DB **ptr=key_file;
for (uint i=0, used_keys=0; i < table_share->keys ; i++, ptr++)
{
char part[7];
if (i != primary_key)
{
if ((error=db_create(ptr, db_env, 0)))
{
close(); /* purecov: inspected */
my_errno=error; /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
sprintf(part,"key%02d",++used_keys);
key_type[i]=table->key_info[i].flags & HA_NOSAME ? DB_NOOVERWRITE : 0;
(*ptr)->set_bt_compare(*ptr, berkeley_cmp_packed_key);
(*ptr)->app_private= (void*) (table->key_info+i);
if (!(table->key_info[i].flags & HA_NOSAME))
{
DBUG_PRINT("bdb",("Setting DB_DUP for key %u", i));
(*ptr)->set_flags(*ptr, DB_DUP);
}
if ((error= db_env->txn_begin(db_env, NULL, (DB_TXN**) &transaction,
0)) ||
(error=((*ptr)->open(*ptr, transaction, name_buff, part, DB_BTREE,
open_mode, 0))) ||
(error= transaction->commit(transaction, 0)))
{
close(); /* purecov: inspected */
my_errno=error; /* purecov: inspected */
DBUG_RETURN(1); /* purecov: inspected */
}
}
}
/* Calculate pack_length of primary key */
share->fixed_length_primary_key= 1;
if (!hidden_primary_key)
{
ref_length=0;
KEY_PART_INFO *key_part= table->key_info[primary_key].key_part;
KEY_PART_INFO *end=key_part+table->key_info[primary_key].key_parts;
for (; key_part != end ; key_part++)
ref_length+= key_part->field->max_packed_col_length(key_part->length);
share->fixed_length_primary_key=
(ref_length == table->key_info[primary_key].key_length);
share->status|= STATUS_PRIMARY_KEY_INIT;
}
share->ref_length= ref_length;
}
ref_length= share->ref_length; // If second open
pthread_mutex_unlock(&share->mutex);
transaction=0;
cursor=0;
key_read=0;
stats.block_size=8192; // Berkeley DB block size
share->fixed_length_row= !(table_share->db_create_options &
HA_OPTION_PACK_RECORD);
get_status();
info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
DBUG_RETURN(0);
}
int ha_berkeley::close(void)
{
DBUG_ENTER("ha_berkeley::close");
my_free((char*) rec_buff,MYF(MY_ALLOW_ZERO_PTR));
my_free(alloc_ptr,MYF(MY_ALLOW_ZERO_PTR));
ha_berkeley::reset(); // current_row buffer
DBUG_RETURN(free_share(share,table, hidden_primary_key,0));
}
/* Reallocate buffer if needed */
bool ha_berkeley::fix_rec_buff_for_blob(ulong length)
{
if (! rec_buff || length > alloced_rec_buff_length)
{
byte *newptr;
if (!(newptr=(byte*) my_realloc((gptr) rec_buff, length,
MYF(MY_ALLOW_ZERO_PTR))))
return 1; /* purecov: inspected */
rec_buff=newptr;
alloced_rec_buff_length=length;
}
return 0;
}
/* Calculate max length needed for row */
ulong ha_berkeley::max_row_length(const byte *buf)
{
ulong length= table_share->reclength + table_share->fields*2;
uint *ptr, *end;
for (ptr= table_share->blob_field, end=ptr + table_share->blob_fields ;
ptr != end ;
ptr++)
{
Field_blob *blob= ((Field_blob*) table->field[*ptr]);
length+= blob->get_length((char*) buf + blob->offset())+2;
}
return length;
}
/*
Pack a row for storage. If the row is of fixed length, just store the
row 'as is'.
If not, we will generate a packed row suitable for storage.
This will only fail if we don't have enough memory to pack the row, which;
may only happen in rows with blobs, as the default row length is
pre-allocated.
*/
int ha_berkeley::pack_row(DBT *row, const byte *record, bool new_row)
{
byte *ptr;
bzero((char*) row,sizeof(*row));
if (share->fixed_length_row)
{
row->data=(void*) record;
row->size= table_share->reclength+hidden_primary_key;
if (hidden_primary_key)
{
if (new_row)
get_auto_primary_key(current_ident);
memcpy_fixed((char*) record+table_share->reclength,
(char*) current_ident,
BDB_HIDDEN_PRIMARY_KEY_LENGTH);
}
return 0;
}
if (table_share->blob_fields)
{
if (fix_rec_buff_for_blob(max_row_length(record)))
return HA_ERR_OUT_OF_MEM; /* purecov: inspected */
}
/* Copy null bits */
memcpy(rec_buff, record, table_share->null_bytes);
ptr= rec_buff + table_share->null_bytes;
for (Field **field=table->field ; *field ; field++)
ptr=(byte*) (*field)->pack((char*) ptr,
(char*) record + (*field)->offset());
if (hidden_primary_key)
{
if (new_row)
get_auto_primary_key(current_ident);
memcpy_fixed((char*) ptr, (char*) current_ident,
BDB_HIDDEN_PRIMARY_KEY_LENGTH);
ptr+=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
}
row->data=rec_buff;
row->size= (size_t) (ptr - rec_buff);
return 0;
}
void ha_berkeley::unpack_row(char *record, DBT *row)
{
if (share->fixed_length_row)
memcpy(record,(char*) row->data,table_share->reclength+hidden_primary_key);
else
{
/* Copy null bits */
my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
const char *ptr= (const char*) row->data;
memcpy(record, ptr, table_share->null_bytes);
ptr+= table_share->null_bytes;
for (Field **field=table->field ; *field ; field++)
ptr= (*field)->unpack(record + (*field)->offset(), ptr);
dbug_tmp_restore_column_map(table->write_set, old_map);
}
}
/* Store the key and the primary key into the row */
void ha_berkeley::unpack_key(char *record, DBT *key, uint index)
{
KEY *key_info= table->key_info+index;
KEY_PART_INFO *key_part= key_info->key_part,
*end= key_part+key_info->key_parts;
char *pos= (char*) key->data;
for (; key_part != end; key_part++)
{
if (key_part->null_bit)
{
if (!*pos++) // Null value
{
/*
We don't need to reset the record data as we will not access it
if the null data is set
*/
record[key_part->null_offset]|=key_part->null_bit;
continue;
}
record[key_part->null_offset]&= ~key_part->null_bit;
}
pos= (char*) key_part->field->unpack_key(record + key_part->field->offset(),
pos, key_part->length);
}
}
/*
Create a packed key from a row. This key will be written as such
to the index tree.
This will never fail as the key buffer is pre-allocated.
*/
DBT *ha_berkeley::create_key(DBT *key, uint keynr, char *buff,
const byte *record, int key_length)
{
bzero((char*) key,sizeof(*key));
if (hidden_primary_key && keynr == primary_key)
{
/* We don't need to set app_private here */
key->data=current_ident;
key->size=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
return key;
}
KEY *key_info=table->key_info+keynr;
KEY_PART_INFO *key_part=key_info->key_part;
KEY_PART_INFO *end=key_part+key_info->key_parts;
my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
DBUG_ENTER("create_key");
key->data=buff;
key->app_private= key_info;
for (; key_part != end && key_length > 0; key_part++)
{
if (key_part->null_bit)
{
/* Store 0 if the key part is a NULL part */
if (record[key_part->null_offset] & key_part->null_bit)
{
*buff++ =0;
key->flags|=DB_DBT_DUPOK;
continue;
}
*buff++ = 1; // Store NOT NULL marker
}
buff=key_part->field->pack_key(buff,(char*) (record + key_part->offset),
key_part->length);
key_length-=key_part->length;
}
key->size= (buff - (char*) key->data);
DBUG_DUMP("key",(char*) key->data, key->size);
dbug_tmp_restore_column_map(table->write_set, old_map);
DBUG_RETURN(key);
}
/*
Create a packed key from from a MySQL unpacked key (like the one that is
sent from the index_read()
This key is to be used to read a row
*/
DBT *ha_berkeley::pack_key(DBT *key, uint keynr, char *buff,
const byte *key_ptr, uint key_length)
{
KEY *key_info=table->key_info+keynr;
KEY_PART_INFO *key_part=key_info->key_part;
KEY_PART_INFO *end=key_part+key_info->key_parts;
my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
DBUG_ENTER("bdb:pack_key");
bzero((char*) key,sizeof(*key));
key->data=buff;
key->app_private= (void*) key_info;
for (; key_part != end && (int) key_length > 0 ; key_part++)
{
uint offset=0;
if (key_part->null_bit)
{
if (!(*buff++ = (*key_ptr == 0))) // Store 0 if NULL
{
key_length-= key_part->store_length;
key_ptr+= key_part->store_length;
key->flags|=DB_DBT_DUPOK;
continue;
}
offset=1; // Data is at key_ptr+1
}
buff=key_part->field->pack_key_from_key_image(buff,(char*) key_ptr+offset,
key_part->length);
key_ptr+=key_part->store_length;
key_length-=key_part->store_length;
}
key->size= (buff - (char*) key->data);
DBUG_DUMP("key",(char*) key->data, key->size);
dbug_tmp_restore_column_map(table->write_set, old_map);
DBUG_RETURN(key);
}
int ha_berkeley::write_row(byte * record)
{
DBT row,prim_key,key;
int error;
DBUG_ENTER("write_row");
statistic_increment(table->in_use->status_var.ha_write_count, &LOCK_status);
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
table->timestamp_field->set_time();
if (table->next_number_field && record == table->record[0])
update_auto_increment();
if ((error=pack_row(&row, record,1)))
DBUG_RETURN(error); /* purecov: inspected */
table->insert_or_update= 1; // For handling of VARCHAR
if (table_share->keys + test(hidden_primary_key) == 1)
{
error=file->put(file, transaction, create_key(&prim_key, primary_key,
key_buff, record),
&row, key_type[primary_key]);
last_dup_key=primary_key;
}
else
{
DB_TXN *sub_trans = transaction;
/* Don't use sub transactions in temporary tables */
for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
{
key_map changed_keys(0);
if (!(error=file->put(file, sub_trans, create_key(&prim_key, primary_key,
key_buff, record),
&row, key_type[primary_key])))
{
changed_keys.set_bit(primary_key);
for (uint keynr=0 ; keynr < table_share->keys ; keynr++)
{
if (keynr == primary_key)
continue;
if ((error=key_file[keynr]->put(key_file[keynr], sub_trans,
create_key(&key, keynr, key_buff2,
record),
&prim_key, key_type[keynr])))
{
last_dup_key=keynr;
break;
}
changed_keys.set_bit(keynr);
}
}
else
last_dup_key=primary_key;
if (error)
{
/* Remove inserted row */
DBUG_PRINT("error",("Got error %d",error));
if (using_ignore)
{
int new_error = 0;
if (!changed_keys.is_clear_all())
{
new_error = 0;
for (uint keynr=0;
keynr < table_share->keys+test(hidden_primary_key);
keynr++)
{
if (changed_keys.is_set(keynr))
{
if ((new_error = remove_key(sub_trans, keynr, record,
&prim_key)))
break; /* purecov: inspected */
}
}
}
if (new_error)
{
error=new_error; // This shouldn't happen /* purecov: inspected */
break; /* purecov: inspected */
}
}
}
if (error != DB_LOCK_DEADLOCK)
break;
}
}
table->insert_or_update= 0;
if (error == DB_KEYEXIST)
error=HA_ERR_FOUND_DUPP_KEY;
else if (!error)
changed_rows++;
DBUG_RETURN(error);
}
/* Compare if a key in a row has changed */
int ha_berkeley::key_cmp(uint keynr, const byte * old_row,
const byte * new_row)
{
KEY_PART_INFO *key_part=table->key_info[keynr].key_part;
KEY_PART_INFO *end=key_part+table->key_info[keynr].key_parts;
for (; key_part != end ; key_part++)
{
if (key_part->null_bit)
{
if ((old_row[key_part->null_offset] & key_part->null_bit) !=
(new_row[key_part->null_offset] & key_part->null_bit))
return 1;
}
if (key_part->key_part_flag & (HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
if (key_part->field->cmp_binary((char*) (old_row + key_part->offset),
(char*) (new_row + key_part->offset),
(ulong) key_part->length))
return 1;
}
else
{
if (memcmp(old_row+key_part->offset, new_row+key_part->offset,
key_part->length))
return 1;
}
}
return 0;
}
/*
Update a row from one value to another.
Clobbers key_buff2
*/
int ha_berkeley::update_primary_key(DB_TXN *trans, bool primary_key_changed,
const byte * old_row, DBT *old_key,
const byte * new_row, DBT *new_key,
bool local_using_ignore)
{
DBT row;
int error;
DBUG_ENTER("update_primary_key");
if (primary_key_changed)
{
// Primary key changed or we are updating a key that can have duplicates.
// Delete the old row and add a new one
if (!(error=remove_key(trans, primary_key, old_row, old_key)))
{
if (!(error=pack_row(&row, new_row, 0)))
{
if ((error=file->put(file, trans, new_key, &row,
key_type[primary_key])))
{
// Probably a duplicated key; restore old key and row if needed
last_dup_key=primary_key;
if (local_using_ignore)
{
int new_error;
if ((new_error=pack_row(&row, old_row, 0)) ||
(new_error=file->put(file, trans, old_key, &row,
key_type[primary_key])))
error=new_error; // fatal error /* purecov: inspected */
}
}
}
}
}
else
{
// Primary key didn't change; just update the row data
if (!(error=pack_row(&row, new_row, 0)))
error=file->put(file, trans, new_key, &row, 0);
}
DBUG_RETURN(error);
}
/*
Restore changed keys, when a non-fatal error aborts the insert/update
of one row.
Clobbers keybuff2
*/
int ha_berkeley::restore_keys(DB_TXN *trans, key_map *changed_keys,
uint primary_key,
const byte *old_row, DBT *old_key,
const byte *new_row, DBT *new_key)
{
int error;
DBT tmp_key;
uint keynr;
DBUG_ENTER("restore_keys");
/* Restore the old primary key, and the old row, but don't ignore
duplicate key failure */
if ((error=update_primary_key(trans, TRUE, new_row, new_key,
old_row, old_key, FALSE)))
goto err; /* purecov: inspected */
/* Remove the new key, and put back the old key
changed_keys is a map of all non-primary keys that need to be
rolled back. The last key set in changed_keys is the one that
triggered the duplicate key error (it wasn't inserted), so for
that one just put back the old value. */
if (!changed_keys->is_clear_all())
{
for (keynr=0 ; keynr < table_share->keys+test(hidden_primary_key) ; keynr++)
{
if (changed_keys->is_set(keynr))
{
if (changed_keys->is_prefix(1) &&
(error = remove_key(trans, keynr, new_row, new_key)))
break; /* purecov: inspected */
if ((error = key_file[keynr]->put(key_file[keynr], trans,
create_key(&tmp_key, keynr, key_buff2,
old_row),
old_key, key_type[keynr])))
break; /* purecov: inspected */
}
}
}
err:
DBUG_ASSERT(error != DB_KEYEXIST);
DBUG_RETURN(error);
}
int ha_berkeley::update_row(const byte * old_row, byte * new_row)
{
DBT prim_key, key, old_prim_key;
int error;
DB_TXN *sub_trans;
bool primary_key_changed;
DBUG_ENTER("update_row");
LINT_INIT(error);
statistic_increment(table->in_use->status_var.ha_update_count,&LOCK_status);
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
table->timestamp_field->set_time();
table->insert_or_update= 1; // For handling of VARCHAR
if (hidden_primary_key)
{
primary_key_changed=0;
bzero((char*) &prim_key,sizeof(prim_key));
prim_key.data= (void*) current_ident;
prim_key.size=BDB_HIDDEN_PRIMARY_KEY_LENGTH;
old_prim_key=prim_key;
}
else
{
create_key(&prim_key, primary_key, key_buff, new_row);
if ((primary_key_changed=key_cmp(primary_key, old_row, new_row)))
create_key(&old_prim_key, primary_key, primary_key_buff, old_row);
else
old_prim_key=prim_key;
}
sub_trans = transaction;
for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
{
key_map changed_keys(0);
/* Start by updating the primary key */
if (!(error=update_primary_key(sub_trans, primary_key_changed,
old_row, &old_prim_key,
new_row, &prim_key,
using_ignore)))
{
// Update all other keys
for (uint keynr=0 ; keynr < table_share->keys ; keynr++)
{
if (keynr == primary_key)
continue;
if (key_cmp(keynr, old_row, new_row) || primary_key_changed)
{
if ((error=remove_key(sub_trans, keynr, old_row, &old_prim_key)))
{
table->insert_or_update= 0;
DBUG_RETURN(error); // Fatal error /* purecov: inspected */
}
changed_keys.set_bit(keynr);
if ((error=key_file[keynr]->put(key_file[keynr], sub_trans,
create_key(&key, keynr, key_buff2,
new_row),
&prim_key, key_type[keynr])))
{
last_dup_key=keynr;
break;
}
}
}
}
if (error)
{
/* Remove inserted row */
DBUG_PRINT("error",("Got error %d",error));
if (using_ignore)
{
int new_error = 0;
if (!changed_keys.is_clear_all())
new_error=restore_keys(transaction, &changed_keys, primary_key,
old_row, &old_prim_key, new_row, &prim_key);
if (new_error)
{
/* This shouldn't happen */
error=new_error; /* purecov: inspected */
break; /* purecov: inspected */
}
}
}
if (error != DB_LOCK_DEADLOCK)
break;
}
table->insert_or_update= 0;
if (error == DB_KEYEXIST)
error=HA_ERR_FOUND_DUPP_KEY;
DBUG_RETURN(error);
}
/*
Delete one key
This uses key_buff2, when keynr != primary key, so it's important that
a function that calls this doesn't use this buffer for anything else.
*/
int ha_berkeley::remove_key(DB_TXN *trans, uint keynr, const byte *record,
DBT *prim_key)
{
int error;
DBT key;
DBUG_ENTER("remove_key");
DBUG_PRINT("enter",("index: %d",keynr));
if (keynr == active_index && cursor)
error=cursor->c_del(cursor,0);
else if (keynr == primary_key ||
((table->key_info[keynr].flags & (HA_NOSAME | HA_NULL_PART_KEY)) ==
HA_NOSAME))
{ // Unique key
DBUG_ASSERT(keynr == primary_key || prim_key->data != key_buff2);
error=key_file[keynr]->del(key_file[keynr], trans,
keynr == primary_key ?
prim_key :
create_key(&key, keynr, key_buff2, record),
0);
}
else
{
/*
To delete the not duplicated key, we need to open an cursor on the
row to find the key to be delete and delete it.
We will never come here with keynr = primary_key
*/
DBUG_ASSERT(keynr != primary_key && prim_key->data != key_buff2);
DBC *tmp_cursor;
if (!(error=key_file[keynr]->cursor(key_file[keynr], trans,
&tmp_cursor, 0)))
{
if (!(error=tmp_cursor->c_get(tmp_cursor,
create_key(&key, keynr, key_buff2, record),
prim_key, DB_GET_BOTH | DB_RMW)))
{ // This shouldn't happen
error=tmp_cursor->c_del(tmp_cursor,0);
}
int result=tmp_cursor->c_close(tmp_cursor);
if (!error)
error=result;
}
}
DBUG_RETURN(error);
}
/* Delete all keys for new_record */
int ha_berkeley::remove_keys(DB_TXN *trans, const byte *record,
DBT *new_record, DBT *prim_key, key_map *keys)
{
int result = 0;
for (uint keynr=0;
keynr < table_share->keys+test(hidden_primary_key);
keynr++)
{
if (keys->is_set(keynr))
{
int new_error=remove_key(trans, keynr, record, prim_key);
if (new_error)
{
result=new_error; // Return last error /* purecov: inspected */
break; // Let rollback correct things /* purecov: inspected */
}
}
}
return result;
}
int ha_berkeley::delete_row(const byte * record)
{
int error;
DBT row, prim_key;
key_map keys= table_share->keys_in_use;
DBUG_ENTER("delete_row");
statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
if ((error=pack_row(&row, record, 0)))
DBUG_RETURN((error)); /* purecov: inspected */
create_key(&prim_key, primary_key, key_buff, record);
if (hidden_primary_key)
keys.set_bit(primary_key);
/* Subtransactions may be used in order to retry the delete in
case we get a DB_LOCK_DEADLOCK error. */
DB_TXN *sub_trans = transaction;
for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
{
error=remove_keys(sub_trans, record, &row, &prim_key, &keys);
if (error)
{ /* purecov: inspected */
DBUG_PRINT("error",("Got error %d",error));
break; // No retry - return error
}
if (error != DB_LOCK_DEADLOCK)
break;
}
#ifdef CANT_COUNT_DELETED_ROWS
if (!error)
changed_rows--;
#endif
DBUG_RETURN(error);
}
int ha_berkeley::index_init(uint keynr, bool sorted)
{
int error;
DBUG_ENTER("ha_berkeley::index_init");
DBUG_PRINT("enter",("table: '%s' key: %d", table_share->table_name.str,
keynr));
/*
Under some very rare conditions (like full joins) we may already have
an active cursor at this point
*/
if (cursor)
{
DBUG_PRINT("note",("Closing active cursor"));
cursor->c_close(cursor);
}
active_index=keynr;
if ((error=key_file[keynr]->cursor(key_file[keynr], transaction, &cursor,
table->reginfo.lock_type >
TL_WRITE_ALLOW_READ ?
0 : 0)))
cursor=0; // Safety /* purecov: inspected */
bzero((char*) &last_key,sizeof(last_key));
DBUG_RETURN(error);
}
int ha_berkeley::index_end()
{
int error=0;
DBUG_ENTER("ha_berkely::index_end");
if (cursor)
{
DBUG_PRINT("enter",("table: '%s'", table_share->table_name.str));
error=cursor->c_close(cursor);
cursor=0;
}
active_index=MAX_KEY;
DBUG_RETURN(error);
}
/* What to do after we have read a row based on an index */
int ha_berkeley::read_row(int error, char *buf, uint keynr, DBT *row,
DBT *found_key, bool read_next)
{
DBUG_ENTER("ha_berkeley::read_row");
if (error)
{
if (error == DB_NOTFOUND || error == DB_KEYEMPTY)
error=read_next ? HA_ERR_END_OF_FILE : HA_ERR_KEY_NOT_FOUND;
table->status=STATUS_NOT_FOUND;
DBUG_RETURN(error);
}
if (hidden_primary_key)
memcpy_fixed(current_ident,
(char*) row->data+row->size-BDB_HIDDEN_PRIMARY_KEY_LENGTH,
BDB_HIDDEN_PRIMARY_KEY_LENGTH);
table->status=0;
if (keynr != primary_key)
{
/* We only found the primary key. Now we have to use this to find
the row data */
if (key_read && found_key)
{
unpack_key(buf,found_key,keynr);
if (!hidden_primary_key)
unpack_key(buf,row,primary_key);
DBUG_RETURN(0);
}
DBT key;
bzero((char*) &key,sizeof(key));
key.data=key_buff;
key.size=row->size;
key.app_private= (void*) (table->key_info+primary_key);
memcpy(key_buff,row->data,row->size);
/* Read the data into current_row */
current_row.flags=DB_DBT_REALLOC;
if ((error=file->get(file, transaction, &key, &current_row, 0)))
{
table->status=STATUS_NOT_FOUND; /* purecov: inspected */
DBUG_RETURN(error == DB_NOTFOUND ? HA_ERR_CRASHED : error); /* purecov: inspected */
}
row= &current_row;
}
unpack_row(buf,row);
DBUG_RETURN(0);
}
/* This is only used to read whole keys */
int ha_berkeley::index_read_idx(byte * buf, uint keynr, const byte * key,
uint key_len, enum ha_rkey_function find_flag)
{
table->in_use->status_var.ha_read_key_count++;
DBUG_ENTER("index_read_idx");
current_row.flags=DB_DBT_REALLOC;
active_index=MAX_KEY;
DBUG_RETURN(read_row(key_file[keynr]->get(key_file[keynr], transaction,
pack_key(&last_key, keynr, key_buff, key,
key_len),
&current_row,0),
(char*) buf, keynr, &current_row, &last_key, 0));
}
int ha_berkeley::index_read(byte * buf, const byte * key,
uint key_len, enum ha_rkey_function find_flag)
{
DBT row;
int error;
KEY *key_info= &table->key_info[active_index];
int do_prev= 0;
DBUG_ENTER("ha_berkeley::index_read");
table->in_use->status_var.ha_read_key_count++;
bzero((char*) &row,sizeof(row));
if (find_flag == HA_READ_BEFORE_KEY)
{
find_flag= HA_READ_KEY_OR_NEXT;
do_prev= 1;
}
else if (find_flag == HA_READ_PREFIX_LAST_OR_PREV)
{
find_flag= HA_READ_AFTER_KEY;
do_prev= 1;
}
if (key_len == key_info->key_length &&
!(table->key_info[active_index].flags & HA_END_SPACE_KEY))
{
if (find_flag == HA_READ_AFTER_KEY)
key_info->handler.bdb_return_if_eq= 1;
error=read_row(cursor->c_get(cursor, pack_key(&last_key,
active_index,
key_buff,
key, key_len),
&row,
(find_flag == HA_READ_KEY_EXACT ?
DB_SET : DB_SET_RANGE)),
(char*) buf, active_index, &row, (DBT*) 0, 0);
key_info->handler.bdb_return_if_eq= 0;
}
else
{
/* read of partial key */
pack_key(&last_key, active_index, key_buff, key, key_len);
/* Store for compare */
memcpy(key_buff2, key_buff, (key_len=last_key.size));
/*
If HA_READ_AFTER_KEY is set, return next key, else return first
matching key.
*/
key_info->handler.bdb_return_if_eq= (find_flag == HA_READ_AFTER_KEY ?
1 : -1);
error=read_row(cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE),
(char*) buf, active_index, &row, (DBT*) 0, 0);
key_info->handler.bdb_return_if_eq= 0;
if (!error && find_flag == HA_READ_KEY_EXACT)
{
/* Ensure that we found a key that is equal to the current one */
if (!error && berkeley_key_cmp(table, key_info, key_buff2, key_len))
error=HA_ERR_KEY_NOT_FOUND;
}
}
if (do_prev)
{
bzero((char*) &row, sizeof(row));
error= read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV),
(char*) buf, active_index, &row, &last_key, 1);
}
DBUG_RETURN(error);
}
/*
Read last key is solved by reading the next key and then reading
the previous key
*/
int ha_berkeley::index_read_last(byte * buf, const byte * key, uint key_len)
{
DBT row;
int error;
KEY *key_info= &table->key_info[active_index];
DBUG_ENTER("ha_berkeley::index_read");
statistic_increment(table->in_use->status_var.ha_read_key_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
/* read of partial key */
pack_key(&last_key, active_index, key_buff, key, key_len);
/* Store for compare */
memcpy(key_buff2, key_buff, (key_len=last_key.size));
key_info->handler.bdb_return_if_eq= 1;
error=read_row(cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE),
(char*) buf, active_index, &row, (DBT*) 0, 0);
key_info->handler.bdb_return_if_eq= 0;
bzero((char*) &row,sizeof(row));
if (read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV),
(char*) buf, active_index, &row, &last_key, 1) ||
berkeley_key_cmp(table, key_info, key_buff2, key_len))
error=HA_ERR_KEY_NOT_FOUND;
DBUG_RETURN(error);
}
int ha_berkeley::index_next(byte * buf)
{
DBT row;
DBUG_ENTER("index_next");
statistic_increment(table->in_use->status_var.ha_read_next_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
(char*) buf, active_index, &row, &last_key, 1));
}
int ha_berkeley::index_next_same(byte * buf, const byte *key, uint keylen)
{
DBT row;
int error;
DBUG_ENTER("index_next_same");
statistic_increment(table->in_use->status_var.ha_read_next_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
if (keylen == table->key_info[active_index].key_length &&
!(table->key_info[active_index].flags & HA_END_SPACE_KEY))
error=read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT_DUP),
(char*) buf, active_index, &row, &last_key, 1);
else
{
error=read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
(char*) buf, active_index, &row, &last_key, 1);
if (!error && ::key_cmp_if_same(table, key, active_index, keylen))
error=HA_ERR_END_OF_FILE;
}
DBUG_RETURN(error);
}
int ha_berkeley::index_prev(byte * buf)
{
DBT row;
DBUG_ENTER("index_prev");
statistic_increment(table->in_use->status_var.ha_read_prev_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_PREV),
(char*) buf, active_index, &row, &last_key, 1));
}
int ha_berkeley::index_first(byte * buf)
{
DBT row;
DBUG_ENTER("index_first");
statistic_increment(table->in_use->status_var.ha_read_first_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_FIRST),
(char*) buf, active_index, &row, &last_key, 1));
}
int ha_berkeley::index_last(byte * buf)
{
DBT row;
DBUG_ENTER("index_last");
statistic_increment(table->in_use->status_var.ha_read_last_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_LAST),
(char*) buf, active_index, &row, &last_key, 0));
}
int ha_berkeley::rnd_init(bool scan)
{
DBUG_ENTER("rnd_init");
current_row.flags=DB_DBT_REALLOC;
DBUG_RETURN(index_init(primary_key, 0));
}
int ha_berkeley::rnd_end()
{
return index_end();
}
int ha_berkeley::rnd_next(byte *buf)
{
DBT row;
DBUG_ENTER("rnd_next");
statistic_increment(table->in_use->status_var.ha_read_rnd_next_count,
&LOCK_status);
bzero((char*) &row,sizeof(row));
DBUG_RETURN(read_row(cursor->c_get(cursor, &last_key, &row, DB_NEXT),
(char*) buf, primary_key, &row, &last_key, 1));
}
DBT *ha_berkeley::get_pos(DBT *to, byte *pos)
{
/* We don't need to set app_private here */
bzero((char*) to,sizeof(*to));
to->data=pos;
if (share->fixed_length_primary_key)
to->size=ref_length;
else
{
KEY_PART_INFO *key_part=table->key_info[primary_key].key_part;
KEY_PART_INFO *end=key_part+table->key_info[primary_key].key_parts;
for (; key_part != end ; key_part++)
pos+=key_part->field->packed_col_length((char*) pos,key_part->length);
to->size= (uint) (pos- (byte*) to->data);
}
DBUG_DUMP("key", (char*) to->data, to->size);
return to;
}
int ha_berkeley::rnd_pos(byte * buf, byte *pos)
{
DBT db_pos;
DBUG_ENTER("ha_berkeley::rnd_pos");
statistic_increment(table->in_use->status_var.ha_read_rnd_count,
&LOCK_status);
active_index= MAX_KEY;
DBUG_RETURN(read_row(file->get(file, transaction,
get_pos(&db_pos, pos),
&current_row, 0),
(char*) buf, primary_key, &current_row, (DBT*) 0, 0));
}
/*
Set a reference to the current record in (ref,ref_length).
SYNOPSIS
ha_berkeley::position()
record The current record buffer
DESCRIPTION
The BDB handler stores the primary key in (ref,ref_length).
There is either an explicit primary key, or an implicit (hidden)
primary key.
During open(), 'ref_length' is calculated as the maximum primary
key length. When an actual key is shorter than that, the rest of
the buffer must be cleared out. The row cannot be identified, if
garbage follows behind the end of the key. There is no length
field for the current key, so that the whole ref_length is used
for comparison.
RETURN
nothing
*/
void ha_berkeley::position(const byte *record)
{
DBT key;
DBUG_ENTER("ha_berkeley::position");
if (hidden_primary_key)
{
DBUG_ASSERT(ref_length == BDB_HIDDEN_PRIMARY_KEY_LENGTH);
memcpy_fixed(ref, (char*) current_ident, BDB_HIDDEN_PRIMARY_KEY_LENGTH);
}
else
{
create_key(&key, primary_key, (char*) ref, record);
if (key.size < ref_length)
bzero(ref + key.size, ref_length - key.size);
}
DBUG_VOID_RETURN;
}
void ha_berkeley::info(uint flag)
{
DBUG_ENTER("ha_berkeley::info");
if (flag & HA_STATUS_VARIABLE)
{
// Just to get optimizations right
stats.records = share->rows + changed_rows;
stats.deleted = 0;
}
if ((flag & HA_STATUS_CONST) || version != share->version)
{
version=share->version;
for (uint i=0 ; i < table_share->keys ; i++)
{
table->key_info[i].rec_per_key[table->key_info[i].key_parts-1]=
share->rec_per_key[i];
}
}
/* Don't return key if we got an error for the internal primary key */
if (flag & HA_STATUS_ERRKEY && last_dup_key < table_share->keys)
errkey= last_dup_key;
DBUG_VOID_RETURN;
}
int ha_berkeley::extra(enum ha_extra_function operation)
{
switch (operation) {
case HA_EXTRA_RESET_STATE:
reset();
break;
case HA_EXTRA_KEYREAD:
key_read=1; // Query satisfied with key
break;
case HA_EXTRA_NO_KEYREAD:
key_read=0;
break;
case HA_EXTRA_IGNORE_DUP_KEY:
using_ignore=1;
break;
case HA_EXTRA_NO_IGNORE_DUP_KEY:
using_ignore=0;
break;
default:
break;
}
return 0;
}
int ha_berkeley::reset(void)
{
key_read= 0;
using_ignore= 0;
if (current_row.flags & (DB_DBT_MALLOC | DB_DBT_REALLOC))
{
current_row.flags= 0;
if (current_row.data)
{
free(current_row.data);
current_row.data= 0;
}
}
return 0;
}
/*
As MySQL will execute an external lock for every new table it uses
we can use this to start the transactions.
If we are in auto_commit mode we just need to start a transaction
for the statement to be able to rollback the statement.
If not, we have to start a master transaction if there doesn't exist
one from before.
*/
int ha_berkeley::external_lock(THD *thd, int lock_type)
{
int error=0;
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
DBUG_ENTER("ha_berkeley::external_lock");
if (!trx)
{
thd->ha_data[berkeley_hton.slot]= trx= (berkeley_trx_data *)
my_malloc(sizeof(*trx), MYF(MY_ZEROFILL));
if (!trx)
DBUG_RETURN(1);
}
if (trx->all == 0)
trx->sp_level= 0;
if (lock_type != F_UNLCK)
{
if (!trx->bdb_lock_count++)
{
DBUG_ASSERT(trx->stmt == 0);
transaction=0; // Safety
/* First table lock, start transaction */
if ((thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
OPTION_TABLE_LOCK)) && !trx->all)
{
/* We have to start a master transaction */
DBUG_PRINT("trans",("starting transaction all: options: 0x%lx",
(ulong) thd->options));
if ((error= db_env->txn_begin(db_env, NULL, &trx->all, 0)))
{
trx->bdb_lock_count--; // We didn't get the lock
DBUG_RETURN(error);
}
trx->sp_level= trx->all;
trans_register_ha(thd, TRUE, &berkeley_hton);
if (thd->in_lock_tables)
DBUG_RETURN(0); // Don't create stmt trans
}
DBUG_PRINT("trans",("starting transaction stmt"));
if ((error= db_env->txn_begin(db_env, trx->sp_level, &trx->stmt, 0)))
{
/* We leave the possible master transaction open */
trx->bdb_lock_count--; // We didn't get the lock
DBUG_RETURN(error);
}
trans_register_ha(thd, FALSE, &berkeley_hton);
}
transaction= trx->stmt;
}
else
{
lock.type=TL_UNLOCK; // Unlocked
thread_safe_add(share->rows, changed_rows, &share->mutex);
changed_rows=0;
if (!--trx->bdb_lock_count)
{
if (trx->stmt)
{
/*
F_UNLCK is done without a transaction commit / rollback.
This happens if the thread didn't update any rows
We must in this case commit the work to keep the row locks
*/
DBUG_PRINT("trans",("commiting non-updating transaction"));
error= trx->stmt->commit(trx->stmt,0);
trx->stmt= transaction= 0;
}
}
}
DBUG_RETURN(error);
}
/*
When using LOCK TABLE's external_lock is only called when the actual
TABLE LOCK is done.
Under LOCK TABLES, each used tables will force a call to start_stmt.
*/
int ha_berkeley::start_stmt(THD *thd, thr_lock_type lock_type)
{
int error=0;
DBUG_ENTER("ha_berkeley::start_stmt");
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
DBUG_ASSERT(trx);
/*
note that trx->stmt may have been already initialized as start_stmt()
is called for *each table* not for each storage engine,
and there could be many bdb tables referenced in the query
*/
if (!trx->stmt)
{
DBUG_PRINT("trans",("starting transaction stmt"));
error= db_env->txn_begin(db_env, trx->sp_level, &trx->stmt, 0);
trans_register_ha(thd, FALSE, &berkeley_hton);
}
transaction= trx->stmt;
DBUG_RETURN(error);
}
/*
The idea with handler::store_lock() is the following:
The statement decided which locks we should need for the table
for updates/deletes/inserts we get WRITE locks, for SELECT... we get
read locks.
Before adding the lock into the table lock handler (see thr_lock.c)
mysqld calls store lock with the requested locks. Store lock can now
modify a write lock to a read lock (or some other lock), ignore the
lock (if we don't want to use MySQL table locks at all) or add locks
for many tables (like we do when we are using a MERGE handler).
Berkeley DB changes all WRITE locks to TL_WRITE_ALLOW_WRITE (which
signals that we are doing WRITES, but we are still allowing other
reader's and writer's.
When releasing locks, store_lock() are also called. In this case one
usually doesn't have to do anything.
In some exceptional cases MySQL may send a request for a TL_IGNORE;
This means that we are requesting the same lock as last time and this
should also be ignored. (This may happen when someone does a flush
table when we have opened a part of the tables, in which case mysqld
closes and reopens the tables and tries to get the same locks at last
time). In the future we will probably try to remove this.
*/
THR_LOCK_DATA **ha_berkeley::store_lock(THD *thd, THR_LOCK_DATA **to,
enum thr_lock_type lock_type)
{
if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
{
/* If we are not doing a LOCK TABLE, then allow multiple writers */
if ((lock_type >= TL_WRITE_CONCURRENT_INSERT &&
lock_type <= TL_WRITE) &&
!thd->in_lock_tables)
lock_type = TL_WRITE_ALLOW_WRITE;
lock.type= lock_type;
}
*to++= &lock;
return to;
}
static int create_sub_table(const char *table_name, const char *sub_name,
DBTYPE type, int flags)
{
int error;
DB *file;
DBUG_ENTER("create_sub_table");
DBUG_PRINT("enter",("sub_name: %s flags: %d",sub_name, flags));
if (!(error=db_create(&file, db_env, 0)))
{
file->set_flags(file, flags);
error=(file->open(file, NULL, table_name, sub_name, type,
DB_THREAD | DB_CREATE, my_umask));
if (error)
{
DBUG_PRINT("error",("Got error: %d when opening table '%s'",error, /* purecov: inspected */
table_name)); /* purecov: inspected */
(void) file->remove(file,table_name,NULL,0); /* purecov: inspected */
}
else
(void) file->close(file,0);
}
else
{
DBUG_PRINT("error",("Got error: %d when creting table",error)); /* purecov: inspected */
}
if (error)
my_errno=error; /* purecov: inspected */
DBUG_RETURN(error);
}
int ha_berkeley::create(const char *name, register TABLE *form,
HA_CREATE_INFO *create_info)
{
char name_buff[FN_REFLEN];
char part[7];
uint index=1;
int error;
DBUG_ENTER("ha_berkeley::create");
fn_format(name_buff,name,"", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT);
/* Create the main table that will hold the real rows */
if ((error= create_sub_table(name_buff,"main",DB_BTREE,0)))
DBUG_RETURN(error); /* purecov: inspected */
primary_key= form->s->primary_key;
/* Create the keys */
for (uint i=0; i < form->s->keys; i++)
{
if (i != primary_key)
{
sprintf(part,"key%02d",index++);
if ((error= create_sub_table(name_buff, part, DB_BTREE,
(form->key_info[i].flags & HA_NOSAME) ? 0 :
DB_DUP)))
DBUG_RETURN(error); /* purecov: inspected */
}
}
/* Create the status block to save information from last status command */
/* Is DB_BTREE the best option here ? (QUEUE can't be used in sub tables) */
DB *status_block;
if (!(error=(db_create(&status_block, db_env, 0))))
{
if (!(error=(status_block->open(status_block, NULL, name_buff,
"status", DB_BTREE, DB_CREATE, 0))))
{
char rec_buff[4+MAX_KEY*4];
uint length= 4+ form->s->keys*4;
bzero(rec_buff, length);
error= write_status(status_block, rec_buff, length);
status_block->close(status_block,0);
}
}
DBUG_RETURN(error);
}
int ha_berkeley::delete_table(const char *name)
{
int error;
char name_buff[FN_REFLEN];
DBUG_ENTER("delete_table");
if ((error=db_create(&file, db_env, 0)))
my_errno=error; /* purecov: inspected */
else
error=file->remove(file,fn_format(name_buff,name,"",ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
NULL,0);
file=0; // Safety
DBUG_RETURN(error);
}
int ha_berkeley::rename_table(const char * from, const char * to)
{
int error;
char from_buff[FN_REFLEN];
char to_buff[FN_REFLEN];
if ((error= db_create(&file, db_env, 0)))
my_errno= error;
else
{
/* On should not do a file->close() after rename returns */
error= file->rename(file,
fn_format(from_buff, from, "",
ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
NULL, fn_format(to_buff, to, "", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT), 0);
}
return error;
}
/*
How many seeks it will take to read through the table
This is to be comparable to the number returned by records_in_range so
that we can decide if we should scan the table or use keys.
*/
double ha_berkeley::scan_time()
{
return rows2double(stats.records/3);
}
ha_rows ha_berkeley::records_in_range(uint keynr, key_range *start_key,
key_range *end_key)
{
DBT key;
DB_KEY_RANGE start_range, end_range;
DB *kfile=key_file[keynr];
double start_pos,end_pos,rows;
bool error;
KEY *key_info= &table->key_info[keynr];
DBUG_ENTER("ha_berkeley::records_in_range");
/* Ensure we get maximum range, even for varchar keys with different space */
key_info->handler.bdb_return_if_eq= -1;
error= ((start_key && kfile->key_range(kfile,transaction,
pack_key(&key, keynr, key_buff,
start_key->key,
start_key->length),
&start_range,0)));
if (error)
{
key_info->handler.bdb_return_if_eq= 0;
// Better than returning an error
DBUG_RETURN(HA_BERKELEY_RANGE_COUNT); /* purecov: inspected */
}
key_info->handler.bdb_return_if_eq= 1;
error= (end_key && kfile->key_range(kfile,transaction,
pack_key(&key, keynr, key_buff,
end_key->key,
end_key->length),
&end_range,0));
key_info->handler.bdb_return_if_eq= 0;
if (error)
{
// Better than returning an error
DBUG_RETURN(HA_BERKELEY_RANGE_COUNT); /* purecov: inspected */
}
if (!start_key)
start_pos= 0.0;
else if (start_key->flag == HA_READ_KEY_EXACT)
start_pos=start_range.less;
else
start_pos=start_range.less+start_range.equal;
if (!end_key)
end_pos= 1.0;
else if (end_key->flag == HA_READ_BEFORE_KEY)
end_pos=end_range.less;
else
end_pos=end_range.less+end_range.equal;
rows=(end_pos-start_pos)*stats.records;
DBUG_PRINT("exit",("rows: %g",rows));
DBUG_RETURN((ha_rows)(rows <= 1.0 ? 1 : rows));
}
void ha_berkeley::get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values)
{
/* Ideally in case of real error (not "empty table") nr should be ~ULL(0) */
ulonglong nr=1; // Default if error or new key
int error;
(void) ha_berkeley::extra(HA_EXTRA_KEYREAD);
/* Set 'active_index' */
ha_berkeley::index_init(table_share->next_number_index, 0);
if (!table_share->next_number_key_offset)
{ // Autoincrement at key-start
error=ha_berkeley::index_last(table->record[1]);
/* has taken read lock on page of max key so reserves to infinite */
*nb_reserved_values= ULONGLONG_MAX;
}
else
{
/*
MySQL needs to call us for next row: assume we are inserting ("a",null)
here, we return 3, and next this statement will want to insert ("b",null):
there is no reason why ("b",3+1) would be the good row to insert: maybe it
already exists, maybe 3+1 is too large...
*/
*nb_reserved_values= 1;
DBT row,old_key;
bzero((char*) &row,sizeof(row));
KEY *key_info= &table->key_info[active_index];
/* Reading next available number for a sub key */
ha_berkeley::create_key(&last_key, active_index,
key_buff, table->record[0],
table_share->next_number_key_offset);
/* Store for compare */
memcpy(old_key.data=key_buff2, key_buff, (old_key.size=last_key.size));
old_key.app_private=(void*) key_info;
error=1;
{
/* Modify the compare so that we will find the next key */
key_info->handler.bdb_return_if_eq= 1;
/* We lock the next key as the new key will probl. be on the same page */
error=cursor->c_get(cursor, &last_key, &row, DB_SET_RANGE | DB_RMW);
key_info->handler.bdb_return_if_eq= 0;
if (!error || error == DB_NOTFOUND)
{
/*
Now search go one step back and then we should have found the
biggest key with the given prefix
*/
error=1;
if (!cursor->c_get(cursor, &last_key, &row, DB_PREV | DB_RMW) &&
!berkeley_cmp_packed_key(key_file[active_index], &old_key,
&last_key))
{
error=0; // Found value
unpack_key((char*) table->record[1], &last_key, active_index);
}
}
}
}
if (!error)
nr= (ulonglong)
table->next_number_field->val_int_offset(table_share->rec_buff_length)+1;
ha_berkeley::index_end();
(void) ha_berkeley::extra(HA_EXTRA_NO_KEYREAD);
*first_value= nr;
}
void ha_berkeley::print_error(int error, myf errflag)
{
if (error == DB_LOCK_DEADLOCK)
error=HA_ERR_LOCK_DEADLOCK;
handler::print_error(error,errflag);
}
/****************************************************************************
Analyzing, checking, and optimizing tables
****************************************************************************/
#ifdef NOT_YET
static void print_msg(THD *thd, const char *table_name, const char *op_name,
const char *msg_type, const char *fmt, ...)
{
Protocol *protocol= thd->protocol;
char msgbuf[256];
msgbuf[0] = 0;
va_list args;
va_start(args,fmt);
my_vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
msgbuf[sizeof(msgbuf) - 1] = 0; // healthy paranoia
DBUG_PRINT(msg_type,("message: %s",msgbuf));
protocol->set_nfields(4);
protocol->prepare_for_resend();
protocol->store(table_name);
protocol->store(op_name);
protocol->store(msg_type);
protocol->store(msgbuf);
if (protocol->write())
thd->killed=THD::KILL_CONNECTION;
}
#endif
int ha_berkeley::analyze(THD* thd, HA_CHECK_OPT* check_opt)
{
uint i;
DB_BTREE_STAT *stat=0;
DB_TXN_STAT *txn_stat_ptr= 0;
berkeley_trx_data *trx=(berkeley_trx_data *)thd->ha_data[berkeley_hton.slot];
DBUG_ASSERT(trx);
for (i=0 ; i < table_share->keys ; i++)
{
if (stat)
{
free(stat);
stat=0;
}
if ((key_file[i]->stat)(key_file[i], trx->all, (void*) &stat, 0))
goto err; /* purecov: inspected */
share->rec_per_key[i]= (stat->bt_ndata /
(stat->bt_nkeys ? stat->bt_nkeys : 1));
}
/* A hidden primary key is not in key_file[] */
if (hidden_primary_key)
{
if (stat)
{
free(stat);
stat=0;
}
if ((file->stat)(file, trx->all, (void*) &stat, 0))
goto err; /* purecov: inspected */
}
pthread_mutex_lock(&share->mutex);
share->rows=stat->bt_ndata;
share->status|=STATUS_BDB_ANALYZE; // Save status on close
share->version++; // Update stat in table
pthread_mutex_unlock(&share->mutex);
update_status(share,table); // Write status to file
if (stat)
free(stat);
return ((share->status & STATUS_BDB_ANALYZE) ? HA_ADMIN_FAILED :
HA_ADMIN_OK);
err:
if (stat) /* purecov: inspected */
free(stat); /* purecov: inspected */
return HA_ADMIN_FAILED; /* purecov: inspected */
}
int ha_berkeley::optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
return ha_berkeley::analyze(thd,check_opt);
}
int ha_berkeley::check(THD* thd, HA_CHECK_OPT* check_opt)
{
DBUG_ENTER("ha_berkeley::check");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
#ifdef NOT_YET
char name_buff[FN_REFLEN];
int error;
DB *tmp_file;
/*
To get this to work we need to ensure that no running transaction is
using the table. We also need to create a new environment without
locking for this.
*/
/* We must open the file again to be able to check it! */
if ((error=db_create(&tmp_file, db_env, 0)))
{
print_msg(thd, table->real_name, "check", "error",
"Got error %d creating environment",error);
DBUG_RETURN(HA_ADMIN_FAILED);
}
/* Compare the overall structure */
tmp_file->set_bt_compare(tmp_file,
(hidden_primary_key ? berkeley_cmp_hidden_key :
berkeley_cmp_packed_key));
tmp_file->app_private= (void*) (table->key_info+table->primary_key);
fn_format(name_buff,share->table_name.str,"", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT);
if ((error=tmp_file->verify(tmp_file, name_buff, NullS, (FILE*) 0,
hidden_primary_key ? 0 : DB_NOORDERCHK)))
{
print_msg(thd, table->real_name, "check", "error",
"Got error %d checking file structure",error);
tmp_file->close(tmp_file,0);
DBUG_RETURN(HA_ADMIN_CORRUPT);
}
/* Check each index */
tmp_file->set_bt_compare(tmp_file, berkeley_cmp_packed_key);
for (uint index=0,i=0 ; i < table->keys ; i++)
{
char part[7];
if (i == primary_key)
strmov(part,"main");
else
sprintf(part,"key%02d",++index);
tmp_file->app_private= (void*) (table->key_info+i);
if ((error=tmp_file->verify(tmp_file, name_buff, part, (FILE*) 0,
DB_ORDERCHKONLY)))
{
print_msg(thd, table->real_name, "check", "error",
"Key %d was not in order (Error: %d)",
index+ test(i >= primary_key),
error);
tmp_file->close(tmp_file,0);
DBUG_RETURN(HA_ADMIN_CORRUPT);
}
}
tmp_file->close(tmp_file,0);
DBUG_RETURN(HA_ADMIN_OK);
#endif
}
/****************************************************************************
Handling the shared BDB_SHARE structure that is needed to provide table
locking.
****************************************************************************/
static byte* bdb_get_key(BDB_SHARE *share,uint *length,
my_bool not_used __attribute__((unused)))
{
*length=share->table_name_length;
return (byte*) share->table_name;
}
static BDB_SHARE *get_share(const char *table_name, TABLE *table)
{
BDB_SHARE *share;
pthread_mutex_lock(&bdb_mutex);
uint length=(uint) strlen(table_name);
if (!(share=(BDB_SHARE*) hash_search(&bdb_open_tables, (byte*) table_name,
length)))
{
ulong *rec_per_key;
char *tmp_name;
DB **key_file;
u_int32_t *key_type;
uint keys= table->s->keys;
if ((share=(BDB_SHARE *)
my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
&share, sizeof(*share),
&rec_per_key, keys * sizeof(ha_rows),
&tmp_name, length+1,
&key_file, (keys+1) * sizeof(*key_file),
&key_type, (keys+1) * sizeof(u_int32_t),
NullS)))
{
share->rec_per_key = rec_per_key;
share->table_name = tmp_name;
share->table_name_length=length;
strmov(share->table_name, table_name);
share->key_file = key_file;
share->key_type = key_type;
if (my_hash_insert(&bdb_open_tables, (byte*) share))
{
pthread_mutex_unlock(&bdb_mutex); /* purecov: inspected */
my_free((gptr) share,0); /* purecov: inspected */
return 0; /* purecov: inspected */
}
thr_lock_init(&share->lock);
pthread_mutex_init(&share->mutex,MY_MUTEX_INIT_FAST);
}
}
pthread_mutex_unlock(&bdb_mutex);
return share;
}
static int free_share(BDB_SHARE *share, TABLE *table, uint hidden_primary_key,
bool mutex_is_locked)
{
int error, result = 0;
uint keys= table->s->keys + test(hidden_primary_key);
pthread_mutex_lock(&bdb_mutex);
if (mutex_is_locked)
pthread_mutex_unlock(&share->mutex); /* purecov: inspected */
if (!--share->use_count)
{
DB **key_file = share->key_file;
update_status(share,table);
/* this does share->file->close() implicitly */
for (uint i=0; i < keys; i++)
{
if (key_file[i] && (error=key_file[i]->close(key_file[i],0)))
result=error; /* purecov: inspected */
}
if (share->status_block &&
(error = share->status_block->close(share->status_block,0)))
result = error; /* purecov: inspected */
hash_delete(&bdb_open_tables, (byte*) share);
thr_lock_delete(&share->lock);
pthread_mutex_destroy(&share->mutex);
my_free((gptr) share, MYF(0));
}
pthread_mutex_unlock(&bdb_mutex);
return result;
}
/*
Get status information that is stored in the 'status' sub database
and the max used value for the hidden primary key.
*/
void ha_berkeley::get_status()
{
if (!test_all_bits(share->status,(STATUS_PRIMARY_KEY_INIT |
STATUS_ROW_COUNT_INIT)))
{
pthread_mutex_lock(&share->mutex);
if (!(share->status & STATUS_PRIMARY_KEY_INIT))
{
(void) extra(HA_EXTRA_KEYREAD);
index_init(primary_key, 0);
if (!index_last(table->record[1]))
share->auto_ident=uint5korr(current_ident);
index_end();
(void) extra(HA_EXTRA_NO_KEYREAD);
}
if (! share->status_block)
{
char name_buff[FN_REFLEN];
uint open_mode= (((table->db_stat & HA_READ_ONLY) ? DB_RDONLY : 0)
| DB_THREAD);
fn_format(name_buff, share->table_name, "", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT);
if (!db_create(&share->status_block, db_env, 0))
{
if (share->status_block->open(share->status_block, NULL, name_buff,
"status", DB_BTREE, open_mode, 0))
{
share->status_block->close(share->status_block, 0); /* purecov: inspected */
share->status_block=0; /* purecov: inspected */
}
}
}
if (!(share->status & STATUS_ROW_COUNT_INIT) && share->status_block)
{
share->org_rows= share->rows=
table_share->max_rows ? table_share->max_rows : HA_BERKELEY_MAX_ROWS;
if (!share->status_block->cursor(share->status_block, 0, &cursor, 0))
{
DBT row;
char rec_buff[64];
bzero((char*) &row,sizeof(row));
bzero((char*) &last_key,sizeof(last_key));
row.data=rec_buff;
row.ulen=sizeof(rec_buff);
row.flags=DB_DBT_USERMEM;
if (!cursor->c_get(cursor, &last_key, &row, DB_FIRST))
{
uint i;
uchar *pos=(uchar*) row.data;
share->org_rows=share->rows=uint4korr(pos); pos+=4;
for (i=0 ; i < table_share->keys ; i++)
{
share->rec_per_key[i]=uint4korr(pos);
pos+=4;
}
}
cursor->c_close(cursor);
}
cursor=0; // Safety
}
share->status|= STATUS_PRIMARY_KEY_INIT | STATUS_ROW_COUNT_INIT;
pthread_mutex_unlock(&share->mutex);
}
}
static int write_status(DB *status_block, char *buff, uint length)
{
DBT row,key;
int error;
const char *key_buff="status";
bzero((char*) &row,sizeof(row));
bzero((char*) &key,sizeof(key));
row.data=buff;
key.data=(void*) key_buff;
key.size=sizeof(key_buff);
row.size=length;
error=status_block->put(status_block, 0, &key, &row, 0);
return error;
}
static void update_status(BDB_SHARE *share, TABLE *table)
{
DBUG_ENTER("update_status");
if (share->rows != share->org_rows ||
(share->status & STATUS_BDB_ANALYZE))
{
pthread_mutex_lock(&share->mutex);
if (!share->status_block)
{
/*
Create sub database 'status' if it doesn't exist from before
(This '*should*' always exist for table created with MySQL)
*/
char name_buff[FN_REFLEN]; /* purecov: inspected */
if (db_create(&share->status_block, db_env, 0)) /* purecov: inspected */
goto end; /* purecov: inspected */
share->status_block->set_flags(share->status_block,0); /* purecov: inspected */
if (share->status_block->open(share->status_block, NULL,
fn_format(name_buff,share->table_name,
"", ha_berkeley_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
"status", DB_BTREE,
DB_THREAD | DB_CREATE, my_umask)) /* purecov: inspected */
goto end; /* purecov: inspected */
}
{
char rec_buff[4+MAX_KEY*4], *pos=rec_buff;
int4store(pos,share->rows); pos+=4;
for (uint i=0 ; i < table->s->keys ; i++)
{
int4store(pos,share->rec_per_key[i]); pos+=4;
}
DBUG_PRINT("info",("updating status for %s", share->table_name));
(void) write_status(share->status_block, rec_buff,
(uint) (pos-rec_buff));
share->status&= ~STATUS_BDB_ANALYZE;
share->org_rows=share->rows;
}
end:
pthread_mutex_unlock(&share->mutex);
}
DBUG_VOID_RETURN;
}
/*
Return an estimated of the number of rows in the table.
Used when sorting to allocate buffers and by the optimizer.
*/
ha_rows ha_berkeley::estimate_rows_upper_bound()
{
return share->rows + HA_BERKELEY_EXTRA_ROWS;
}
int ha_berkeley::cmp_ref(const byte *ref1, const byte *ref2)
{
if (hidden_primary_key)
return memcmp(ref1, ref2, BDB_HIDDEN_PRIMARY_KEY_LENGTH);
int result;
Field *field;
KEY *key_info=table->key_info+table_share->primary_key;
KEY_PART_INFO *key_part=key_info->key_part;
KEY_PART_INFO *end=key_part+key_info->key_parts;
for (; key_part != end; key_part++)
{
field= key_part->field;
result= field->pack_cmp((const char*)ref1, (const char*)ref2,
key_part->length, 0);
if (result)
return result;
ref1+= field->packed_col_length((const char*)ref1, key_part->length);
ref2+= field->packed_col_length((const char*)ref2, key_part->length);
}
return 0;
}
bool ha_berkeley::check_if_incompatible_data(HA_CREATE_INFO *info,
uint table_changes)
{
if (table_changes < IS_EQUAL_YES)
return COMPATIBLE_DATA_NO;
return COMPATIBLE_DATA_YES;
}
struct st_mysql_storage_engine berkeley_storage_engine=
{ MYSQL_HANDLERTON_INTERFACE_VERSION, &berkeley_hton };
mysql_declare_plugin(berkeley)
{
MYSQL_STORAGE_ENGINE_PLUGIN,
&berkeley_storage_engine,
berkeley_hton_name,
"Sleepycat Software",
"Supports transactions and page-level locking",
berkeley_init, /* Plugin Init */
NULL, /* Plugin Deinit */
0x0100, /* 1.0 */
0
}
mysql_declare_plugin_end;
#endif
sql/ha_berkeley.h deleted 100644 → 0
View file @ 21bb4f94
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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 USE_PRAGMA_INTERFACE
#pragma interface /* gcc class implementation */
#endif
/* class for the the myisam handler */
#include <db.h>
#define BDB_HIDDEN_PRIMARY_KEY_LENGTH 5
typedef struct st_berkeley_share {
ulonglong auto_ident;
ha_rows rows, org_rows;
ulong *rec_per_key;
THR_LOCK lock;
pthread_mutex_t mutex;
char *table_name;
DB *status_block, *file, **key_file;
u_int32_t *key_type;
uint table_name_length,use_count;
uint status,version;
uint ref_length;
bool fixed_length_primary_key, fixed_length_row;
} BDB_SHARE;
class ha_berkeley: public handler
{
THR_LOCK_DATA lock;
DBT last_key,current_row;
gptr alloc_ptr;
byte *rec_buff;
char *key_buff, *key_buff2, *primary_key_buff;
DB *file, **key_file;
DB_TXN *transaction;
u_int32_t *key_type;
DBC *cursor;
BDB_SHARE *share;
ulong int_table_flags;
ulong alloced_rec_buff_length;
ulong changed_rows;
uint primary_key,last_dup_key, hidden_primary_key, version;
bool key_read, using_ignore;
bool fix_rec_buff_for_blob(ulong length);
byte current_ident[BDB_HIDDEN_PRIMARY_KEY_LENGTH];
ulong max_row_length(const byte *buf);
int pack_row(DBT *row,const byte *record, bool new_row);
void unpack_row(char *record, DBT *row);
void unpack_key(char *record, DBT *key, uint index);
DBT *create_key(DBT *key, uint keynr, char *buff, const byte *record,
int key_length = MAX_KEY_LENGTH);
DBT *pack_key(DBT *key, uint keynr, char *buff, const byte *key_ptr,
uint key_length);
int remove_key(DB_TXN *trans, uint keynr, const byte *record, DBT *prim_key);
int remove_keys(DB_TXN *trans,const byte *record, DBT *new_record,
DBT *prim_key, key_map *keys);
int restore_keys(DB_TXN *trans, key_map *changed_keys, uint primary_key,
const byte *old_row, DBT *old_key,
const byte *new_row, DBT *new_key);
int key_cmp(uint keynr, const byte * old_row, const byte * new_row);
int update_primary_key(DB_TXN *trans, bool primary_key_changed,
const byte * old_row, DBT *old_key,
const byte * new_row, DBT *prim_key,
bool local_using_ignore);
int read_row(int error, char *buf, uint keynr, DBT *row, DBT *key, bool);
DBT *get_pos(DBT *to, byte *pos);
public:
ha_berkeley(TABLE_SHARE *table_arg);
~ha_berkeley() {}
const char *table_type() const { return "BerkeleyDB"; }
ulong index_flags(uint idx, uint part, bool all_parts) const;
const char *index_type(uint key_number) { return "BTREE"; }
const char **bas_ext() const;
ulonglong table_flags(void) const { return int_table_flags; }
uint max_supported_keys() const { return MAX_KEY-1; }
uint extra_rec_buf_length() const { return BDB_HIDDEN_PRIMARY_KEY_LENGTH; }
ha_rows estimate_rows_upper_bound();
uint max_supported_key_length() const { return UINT_MAX32; }
uint max_supported_key_part_length() const { return UINT_MAX32; }
const key_map *keys_to_use_for_scanning() { return &key_map_full; }
int open(const char *name, int mode, uint test_if_locked);
int close(void);
double scan_time();
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, bool sorted);
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_read_last(byte * buf, const byte * key, uint key_len);
int index_next(byte * buf);
int index_next_same(byte * buf, const byte *key, uint keylen);
int index_prev(byte * buf);
int index_first(byte * buf);
int index_last(byte * buf);
int rnd_init(bool scan);
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 reset(void);
int external_lock(THD *thd, int lock_type);
int start_stmt(THD *thd, thr_lock_type lock_type);
void position(byte *record);
int analyze(THD* thd,HA_CHECK_OPT* check_opt);
int optimize(THD* thd, HA_CHECK_OPT* check_opt);
int check(THD* thd, HA_CHECK_OPT* check_opt);
ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key);
int create(const char *name, register TABLE *form,
HA_CREATE_INFO *create_info);
int delete_table(const char *name);
int rename_table(const char* from, const char* to);
THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
enum thr_lock_type lock_type);
void get_status();
inline void get_auto_primary_key(byte *to)
{
pthread_mutex_lock(&share->mutex);
share->auto_ident++;
int5store(to,share->auto_ident);
pthread_mutex_unlock(&share->mutex);
}
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values);
void print_error(int error, myf errflag);
uint8 table_cache_type() { return HA_CACHE_TBL_TRANSACT; }
bool primary_key_is_clustered() { return true; }
int cmp_ref(const byte *ref1, const byte *ref2);
bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes);
};
extern const u_int32_t bdb_DB_TXN_NOSYNC;
extern const u_int32_t bdb_DB_RECOVER;
extern const u_int32_t bdb_DB_PRIVATE;
extern const u_int32_t bdb_DB_DIRECT_DB;
extern const u_int32_t bdb_DB_DIRECT_LOG;
extern bool berkeley_shared_data;
extern u_int32_t berkeley_init_flags,berkeley_env_flags, berkeley_lock_type,
berkeley_lock_types[];
extern ulong berkeley_max_lock, berkeley_log_buffer_size;
extern ulonglong berkeley_cache_size;
extern ulong berkeley_region_size, berkeley_cache_parts;
extern char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
extern long berkeley_lock_scan_time;
extern TYPELIB berkeley_lock_typelib;
int berkeley_init(void);
int berkeley_end(ha_panic_function type);
bool berkeley_flush_logs(void);
bool berkeley_show_status(THD *thd, stat_print_fn *print, enum ha_stat_type);
sql/handler.cc
View file @ 04d2b020
...@@ -74,7 +74,6 @@ static const LEX_STRING sys_table_aliases[]= ...@@ -74,7 +74,6 @@ static const LEX_STRING sys_table_aliases[]=
{ {
{(char*)STRING_WITH_LEN("INNOBASE")}, {(char*)STRING_WITH_LEN("INNODB")}, {(char*)STRING_WITH_LEN("INNOBASE")}, {(char*)STRING_WITH_LEN("INNODB")},
{(char*)STRING_WITH_LEN("NDB")}, {(char*)STRING_WITH_LEN("NDBCLUSTER")}, {(char*)STRING_WITH_LEN("NDB")}, {(char*)STRING_WITH_LEN("NDBCLUSTER")},
{(char*)STRING_WITH_LEN("BDB")}, {(char*)STRING_WITH_LEN("BERKELEYDB")},
{(char*)STRING_WITH_LEN("HEAP")}, {(char*)STRING_WITH_LEN("MEMORY")}, {(char*)STRING_WITH_LEN("HEAP")}, {(char*)STRING_WITH_LEN("MEMORY")},
{(char*)STRING_WITH_LEN("MERGE")}, {(char*)STRING_WITH_LEN("MRG_MYISAM")}, {(char*)STRING_WITH_LEN("MERGE")}, {(char*)STRING_WITH_LEN("MRG_MYISAM")},
{NullS, 0} {NullS, 0}
...@@ -1480,7 +1479,7 @@ int handler::ha_open(TABLE *table_arg, const char *name, int mode, ...@@ -1480,7 +1479,7 @@ int handler::ha_open(TABLE *table_arg, const char *name, int mode,
/* /*
Read first row (only) from a table Read first row (only) from a table
This is never called for InnoDB or BDB tables, as these table types This is never called for InnoDB tables, as these table types
has the HA_STATS_RECORDS_IS_EXACT set. has the HA_STATS_RECORDS_IS_EXACT set.
*/ */
......
sql/lex.h
View file @ 04d2b020
...@@ -82,10 +82,8 @@ static SYMBOL symbols[] = { ...@@ -82,10 +82,8 @@ static SYMBOL symbols[] = {
{ "AVG", SYM(AVG_SYM)}, { "AVG", SYM(AVG_SYM)},
{ "AVG_ROW_LENGTH", SYM(AVG_ROW_LENGTH)}, { "AVG_ROW_LENGTH", SYM(AVG_ROW_LENGTH)},
{ "BACKUP", SYM(BACKUP_SYM)}, { "BACKUP", SYM(BACKUP_SYM)},
{ "BDB", SYM(BERKELEY_DB_SYM)},
{ "BEFORE", SYM(BEFORE_SYM)}, { "BEFORE", SYM(BEFORE_SYM)},
{ "BEGIN", SYM(BEGIN_SYM)}, { "BEGIN", SYM(BEGIN_SYM)},
{ "BERKELEYDB", SYM(BERKELEY_DB_SYM)},
{ "BETWEEN", SYM(BETWEEN_SYM)}, { "BETWEEN", SYM(BETWEEN_SYM)},
{ "BIGINT", SYM(BIGINT)}, { "BIGINT", SYM(BIGINT)},
{ "BINARY", SYM(BINARY)}, { "BINARY", SYM(BINARY)},
......
sql/mysql_priv.h
View file @ 04d2b020
...@@ -1620,12 +1620,6 @@ extern handlerton innobase_hton; ...@@ -1620,12 +1620,6 @@ extern handlerton innobase_hton;
#else #else
extern SHOW_COMP_OPTION have_innodb; extern SHOW_COMP_OPTION have_innodb;
#endif #endif
#ifdef WITH_BERKELEY_STORAGE_ENGINE
extern handlerton berkeley_hton;
#define have_berkeley_db berkeley_hton.state
#else
extern SHOW_COMP_OPTION have_berkeley_db;
#endif
#ifdef WITH_EXAMPLE_STORAGE_ENGINE #ifdef WITH_EXAMPLE_STORAGE_ENGINE
extern handlerton example_hton; extern handlerton example_hton;
#define have_example_db example_hton.state #define have_example_db example_hton.state
......
sql/mysqld.cc
View file @ 04d2b020
...@@ -310,7 +310,7 @@ static bool lower_case_table_names_used= 0; ...@@ -310,7 +310,7 @@ static bool lower_case_table_names_used= 0;
static bool volatile select_thread_in_use, signal_thread_in_use; static bool volatile select_thread_in_use, signal_thread_in_use;
static bool volatile ready_to_exit; static bool volatile ready_to_exit;
static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0; static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;
static my_bool opt_bdb, opt_isam, opt_ndbcluster, opt_merge; static my_bool opt_isam, opt_ndbcluster, opt_merge;
static my_bool opt_short_log_format= 0; static my_bool opt_short_log_format= 0;
static uint kill_cached_threads, wake_thread; static uint kill_cached_threads, wake_thread;
static ulong killed_threads, thread_created; static ulong killed_threads, thread_created;
...@@ -332,10 +332,6 @@ static I_List<THD> thread_cache; ...@@ -332,10 +332,6 @@ static I_List<THD> thread_cache;
static pthread_cond_t COND_thread_cache, COND_flush_thread_cache; static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;
#ifdef WITH_BERKELEY_STORAGE_ENGINE
static my_bool opt_sync_bdb_logs;
#endif
/* Global variables */ /* Global variables */
bool opt_update_log, opt_bin_log; bool opt_update_log, opt_bin_log;
...@@ -405,22 +401,6 @@ extern ulong srv_commit_concurrency; ...@@ -405,22 +401,6 @@ extern ulong srv_commit_concurrency;
extern ulong srv_flush_log_at_trx_commit; extern ulong srv_flush_log_at_trx_commit;
} }
#endif #endif
#ifdef WITH_BERKELEY_STORAGE_ENGINE
#ifndef HAVE_U_INT32_T
typedef unsigned int u_int32_t;
#endif
extern const u_int32_t bdb_DB_TXN_NOSYNC, bdb_DB_RECOVER, bdb_DB_PRIVATE,
bdb_DB_DIRECT_DB, bdb_DB_DIRECT_LOG;
extern bool berkeley_shared_data;
extern u_int32_t berkeley_init_flags,berkeley_env_flags, berkeley_lock_type,
berkeley_lock_types[];
extern ulong berkeley_max_lock, berkeley_log_buffer_size;
extern ulonglong berkeley_cache_size;
extern ulong berkeley_region_size, berkeley_cache_parts;
extern char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
extern long berkeley_lock_scan_time;
extern TYPELIB berkeley_lock_typelib;
#endif
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
const char *opt_ndbcluster_connectstring= 0; const char *opt_ndbcluster_connectstring= 0;
...@@ -3337,11 +3317,7 @@ server."); ...@@ -3337,11 +3317,7 @@ server.");
static void create_maintenance_thread() static void create_maintenance_thread()
{ {
if ( if (flush_time && flush_time != ~(ulong) 0L)
#ifdef WITH_BERKELEY_STORAGE_ENGINE
(have_berkeley_db == SHOW_OPTION_YES) ||
#endif
(flush_time && flush_time != ~(ulong) 0L))
{ {
pthread_t hThread; pthread_t hThread;
if (pthread_create(&hThread,&connection_attrib,handle_manager,0)) if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
...@@ -4883,38 +4859,6 @@ struct my_option my_long_options[] = ...@@ -4883,38 +4859,6 @@ struct my_option my_long_options[] =
"Path to installation directory. All paths are usually resolved relative to this.", "Path to installation directory. All paths are usually resolved relative to this.",
(gptr*) &mysql_home_ptr, (gptr*) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG, (gptr*) &mysql_home_ptr, (gptr*) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0}, 0, 0, 0, 0, 0, 0},
{"bdb", OPT_BDB, "Enable Berkeley DB (if this version of MySQL supports it). \
Disable with --skip-bdb (will save memory).",
(gptr*) &opt_bdb, (gptr*) &opt_bdb, 0, GET_BOOL, NO_ARG, OPT_BDB_DEFAULT, 0, 0,
0, 0, 0},
#ifdef WITH_BERKELEY_STORAGE_ENGINE
{"bdb-data-direct", OPT_BDB_DATA_DIRECT,
"Turn off system buffering of BDB database files to avoid double caching.",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-home", OPT_BDB_HOME, "Berkeley home directory.", (gptr*) &berkeley_home,
(gptr*) &berkeley_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-lock-detect", OPT_BDB_LOCK,
"Berkeley lock detect (DEFAULT, OLDEST, RANDOM or YOUNGEST, # sec).",
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-log-direct", OPT_BDB_LOG_DIRECT,
"Turn off system buffering of BDB log files to avoid double caching.",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-logdir", OPT_BDB_LOG, "Berkeley DB log file directory.",
(gptr*) &berkeley_logdir, (gptr*) &berkeley_logdir, 0, GET_STR,
REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-no-recover", OPT_BDB_NO_RECOVER,
"Don't try to recover Berkeley DB tables on start.", 0, 0, 0, GET_NO_ARG,
NO_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-no-sync", OPT_BDB_NOSYNC,
"This option is deprecated, use --skip-sync-bdb-logs instead",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
{"bdb-shared-data", OPT_BDB_SHARED,
"Start Berkeley DB in multi-process mode.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
0, 0, 0, 0, 0},
{"bdb-tmpdir", OPT_BDB_TMP, "Berkeley DB tempfile name.",
(gptr*) &berkeley_tmpdir, (gptr*) &berkeley_tmpdir, 0, GET_STR,
REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
{"big-tables", OPT_BIG_TABLES, {"big-tables", OPT_BIG_TABLES,
"Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).", "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
...@@ -5729,31 +5673,6 @@ log and this option does nothing anymore.", ...@@ -5729,31 +5673,6 @@ log and this option does nothing anymore.",
"The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.", "The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.",
(gptr*) &back_log, (gptr*) &back_log, 0, GET_ULONG, (gptr*) &back_log, (gptr*) &back_log, 0, GET_ULONG,
REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 }, REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
#ifdef WITH_BERKELEY_STORAGE_ENGINE
{ "bdb_cache_parts", OPT_BDB_CACHE_PARTS,
"Number of parts to use for BDB cache.",
(gptr*) &berkeley_cache_parts, (gptr*) &berkeley_cache_parts, 0, GET_ULONG,
REQUIRED_ARG, 1, 1, 1024, 0, 1, 0},
{ "bdb_cache_size", OPT_BDB_CACHE_SIZE,
"The buffer that is allocated to cache index and rows for BDB tables.",
(gptr*) &berkeley_cache_size, (gptr*) &berkeley_cache_size, 0, GET_ULL,
REQUIRED_ARG, KEY_CACHE_SIZE, 20*1024, (ulonglong) ~0, 0, IO_SIZE, 0},
{"bdb_lock_max", OPT_BDB_MAX_LOCK, "Synonym for bdb_max_lock.",
(gptr*) &berkeley_max_lock, (gptr*) &berkeley_max_lock, 0, GET_ULONG,
REQUIRED_ARG, 10000, 0, (long) ~0, 0, 1, 0},
{"bdb_log_buffer_size", OPT_BDB_LOG_BUFFER_SIZE,
"The buffer that is allocated to cache index and rows for BDB tables.",
(gptr*) &berkeley_log_buffer_size, (gptr*) &berkeley_log_buffer_size, 0,
GET_ULONG, REQUIRED_ARG, 0, 256*1024L, ~0L, 0, 1024, 0},
{"bdb_max_lock", OPT_BDB_MAX_LOCK,
"The maximum number of locks you can have active on a BDB table.",
(gptr*) &berkeley_max_lock, (gptr*) &berkeley_max_lock, 0, GET_ULONG,
REQUIRED_ARG, 10000, 0, (long) ~0, 0, 1, 0},
{"bdb_region_size", OPT_BDB_REGION_SIZE,
"The size of the underlying logging area of the Berkeley DB environment.",
(gptr*) &berkeley_region_size, (gptr*) &berkeley_region_size, 0, GET_ULONG,
OPT_ARG, 60*1024L, 60*1024L, (long) ~0, 0, 1, 0},
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
{"binlog_cache_size", OPT_BINLOG_CACHE_SIZE, {"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
"The size of the cache to hold the SQL statements for the binary log during a transaction. If you often use big, multi-statement transactions you can increase this to get more performance.", "The size of the cache to hold the SQL statements for the binary log during a transaction. If you often use big, multi-statement transactions you can increase this to get more performance.",
(gptr*) &binlog_cache_size, (gptr*) &binlog_cache_size, 0, GET_ULONG, (gptr*) &binlog_cache_size, (gptr*) &binlog_cache_size, 0, GET_ULONG,
...@@ -6245,12 +6164,6 @@ The minimum value for this variable is 4096.", ...@@ -6245,12 +6164,6 @@ The minimum value for this variable is 4096.",
(gptr*) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG, (gptr*) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD, MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD,
1, 0}, 1, 0},
#ifdef WITH_BERKELEY_STORAGE_ENGINE
{"sync-bdb-logs", OPT_BDB_SYNC,
"Synchronously flush Berkeley DB logs. Enabled by default",
(gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
NO_ARG, 1, 0, 0, 0, 0, 0},
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
{"sync-binlog", OPT_SYNC_BINLOG, {"sync-binlog", OPT_SYNC_BINLOG,
"Synchronously flush binary log to disk after every #th event. " "Synchronously flush binary log to disk after every #th event. "
"Use 0 (default) to disable synchronous flushing.", "Use 0 (default) to disable synchronous flushing.",
...@@ -7565,59 +7478,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)), ...@@ -7565,59 +7478,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
have_merge_db= SHOW_OPTION_YES; have_merge_db= SHOW_OPTION_YES;
else else
have_merge_db= SHOW_OPTION_DISABLED; have_merge_db= SHOW_OPTION_DISABLED;
#ifdef WITH_BERKELEY_STORAGE_ENGINE
case OPT_BDB_NOSYNC:
/* Deprecated option */
opt_sync_bdb_logs= 0;
/* Fall through */
case OPT_BDB_SYNC:
if (!opt_sync_bdb_logs)
berkeley_env_flags|= bdb_DB_TXN_NOSYNC;
else
berkeley_env_flags&= ~bdb_DB_TXN_NOSYNC;
break;
case OPT_BDB_LOG_DIRECT:
berkeley_env_flags|= bdb_DB_DIRECT_DB;
break;
case OPT_BDB_DATA_DIRECT:
berkeley_env_flags|= bdb_DB_DIRECT_LOG;
break;
case OPT_BDB_NO_RECOVER:
berkeley_init_flags&= ~(bdb_DB_RECOVER);
break;
case OPT_BDB_LOCK:
{
int type;
if ((type=find_type(argument, &berkeley_lock_typelib, 2)) > 0)
berkeley_lock_type=berkeley_lock_types[type-1];
else
{
int err;
char *end;
uint length= strlen(argument);
long value= my_strntol(&my_charset_latin1, argument, length, 10, &end, &err);
if (end == argument+length)
berkeley_lock_scan_time= value;
else
{
fprintf(stderr,"Unknown lock type: %s\n",argument);
exit(1);
}
}
break;
}
case OPT_BDB_SHARED:
berkeley_init_flags&= ~(bdb_DB_PRIVATE);
berkeley_shared_data= 1;
break;
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
case OPT_BDB: case OPT_BDB:
#ifdef WITH_BERKELEY_STORAGE_ENGINE
if (opt_bdb)
have_berkeley_db= SHOW_OPTION_YES;
else
have_berkeley_db= SHOW_OPTION_DISABLED;
#endif
break; break;
case OPT_NDBCLUSTER: case OPT_NDBCLUSTER:
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
...@@ -7850,10 +7711,6 @@ static void get_options(int argc,char **argv) ...@@ -7850,10 +7711,6 @@ static void get_options(int argc,char **argv)
#ifndef WITH_ISAM_STORAGE_ENGINE #ifndef WITH_ISAM_STORAGE_ENGINE
if (opt_isam) if (opt_isam)
sql_print_warning("this binary does not contain ISAM storage engine"); sql_print_warning("this binary does not contain ISAM storage engine");
#endif
#ifndef WITH_BERKELEY_STORAGE_ENGINE
if (opt_bdb)
sql_print_warning("this binary does not contain BDB storage engine");
#endif #endif
if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes) && if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes) &&
!opt_slow_log) !opt_slow_log)
...@@ -8197,7 +8054,6 @@ void refresh_status(THD *thd) ...@@ -8197,7 +8054,6 @@ void refresh_status(THD *thd)
/***************************************************************************** /*****************************************************************************
Instantiate have_xyx for missing storage engines Instantiate have_xyx for missing storage engines
*****************************************************************************/ *****************************************************************************/
#undef have_berkeley_db
#undef have_innodb #undef have_innodb
#undef have_ndbcluster #undef have_ndbcluster
#undef have_example_db #undef have_example_db
...@@ -8207,7 +8063,6 @@ void refresh_status(THD *thd) ...@@ -8207,7 +8063,6 @@ void refresh_status(THD *thd)
#undef have_partition_db #undef have_partition_db
#undef have_blackhole_db #undef have_blackhole_db
SHOW_COMP_OPTION have_berkeley_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_innodb= SHOW_OPTION_NO; SHOW_COMP_OPTION have_innodb= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_ndbcluster= SHOW_OPTION_NO; SHOW_COMP_OPTION have_ndbcluster= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_example_db= SHOW_OPTION_NO; SHOW_COMP_OPTION have_example_db= SHOW_OPTION_NO;
...@@ -8217,14 +8072,6 @@ SHOW_COMP_OPTION have_federated_db= SHOW_OPTION_NO; ...@@ -8217,14 +8072,6 @@ SHOW_COMP_OPTION have_federated_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_partition_db= SHOW_OPTION_NO; SHOW_COMP_OPTION have_partition_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_blackhole_db= SHOW_OPTION_NO; SHOW_COMP_OPTION have_blackhole_db= SHOW_OPTION_NO;
#ifndef WITH_BERKELEY_STORAGE_ENGINE
bool berkeley_shared_data;
ulong berkeley_max_lock, berkeley_log_buffer_size;
ulonglong berkeley_cache_size;
ulong berkeley_region_size, berkeley_cache_parts;
char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
#endif
#ifndef WITH_INNOBASE_STORAGE_ENGINE #ifndef WITH_INNOBASE_STORAGE_ENGINE
uint innobase_flush_log_at_trx_commit; uint innobase_flush_log_at_trx_commit;
ulong innobase_fast_shutdown; ulong innobase_fast_shutdown;
......
sql/set_var.cc
View file @ 04d2b020
...@@ -59,13 +59,6 @@ ...@@ -59,13 +59,6 @@
#include "event_scheduler.h" #include "event_scheduler.h"
/* WITH_BERKELEY_STORAGE_ENGINE */
extern bool berkeley_shared_data;
extern ulong berkeley_max_lock, berkeley_log_buffer_size;
extern ulonglong berkeley_cache_size;
extern ulong berkeley_region_size, berkeley_cache_parts;
extern char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
/* WITH_INNOBASE_STORAGE_ENGINE */ /* WITH_INNOBASE_STORAGE_ENGINE */
extern uint innobase_flush_log_at_trx_commit; extern uint innobase_flush_log_at_trx_commit;
extern ulong innobase_fast_shutdown; extern ulong innobase_fast_shutdown;
...@@ -668,7 +661,6 @@ sys_var_thd_time_zone sys_time_zone("time_zone"); ...@@ -668,7 +661,6 @@ sys_var_thd_time_zone sys_time_zone("time_zone");
/* Read only variables */ /* Read only variables */
sys_var_have_variable sys_have_archive_db("have_archive", &have_archive_db); sys_var_have_variable sys_have_archive_db("have_archive", &have_archive_db);
sys_var_have_variable sys_have_berkeley_db("have_bdb", &have_berkeley_db);
sys_var_have_variable sys_have_blackhole_db("have_blackhole_engine", sys_var_have_variable sys_have_blackhole_db("have_blackhole_engine",
&have_blackhole_db); &have_blackhole_db);
sys_var_have_variable sys_have_compress("have_compress", &have_compress); sys_var_have_variable sys_have_compress("have_compress", &have_compress);
...@@ -759,15 +751,6 @@ SHOW_VAR init_vars[]= { ...@@ -759,15 +751,6 @@ SHOW_VAR init_vars[]= {
{sys_automatic_sp_privileges.name,(char*) &sys_automatic_sp_privileges, SHOW_SYS}, {sys_automatic_sp_privileges.name,(char*) &sys_automatic_sp_privileges, SHOW_SYS},
{"back_log", (char*) &back_log, SHOW_LONG}, {"back_log", (char*) &back_log, SHOW_LONG},
{sys_basedir.name, (char*) &sys_basedir, SHOW_SYS}, {sys_basedir.name, (char*) &sys_basedir, SHOW_SYS},
{"bdb_cache_parts", (char*) &berkeley_cache_parts, SHOW_LONG},
{"bdb_cache_size", (char*) &berkeley_cache_size, SHOW_LONGLONG},
{"bdb_home", (char*) &berkeley_home, SHOW_CHAR_PTR},
{"bdb_log_buffer_size", (char*) &berkeley_log_buffer_size, SHOW_LONG},
{"bdb_logdir", (char*) &berkeley_logdir, SHOW_CHAR_PTR},
{"bdb_max_lock", (char*) &berkeley_max_lock, SHOW_LONG},
{"bdb_region_size", (char*) &berkeley_region_size, SHOW_LONG},
{"bdb_shared_data", (char*) &berkeley_shared_data, SHOW_BOOL},
{"bdb_tmpdir", (char*) &berkeley_tmpdir, SHOW_CHAR_PTR},
{sys_binlog_cache_size.name,(char*) &sys_binlog_cache_size, SHOW_SYS}, {sys_binlog_cache_size.name,(char*) &sys_binlog_cache_size, SHOW_SYS},
{sys_binlog_format.name, (char*) &sys_binlog_format, SHOW_SYS}, {sys_binlog_format.name, (char*) &sys_binlog_format, SHOW_SYS},
{sys_bulk_insert_buff_size.name,(char*) &sys_bulk_insert_buff_size,SHOW_SYS}, {sys_bulk_insert_buff_size.name,(char*) &sys_bulk_insert_buff_size,SHOW_SYS},
...@@ -812,7 +795,6 @@ SHOW_VAR init_vars[]= { ...@@ -812,7 +795,6 @@ SHOW_VAR init_vars[]= {
{sys_var_general_log_path.name, (char*) &sys_var_general_log_path, SHOW_SYS}, {sys_var_general_log_path.name, (char*) &sys_var_general_log_path, SHOW_SYS},
{sys_group_concat_max_len.name, (char*) &sys_group_concat_max_len, SHOW_SYS}, {sys_group_concat_max_len.name, (char*) &sys_group_concat_max_len, SHOW_SYS},
{sys_have_archive_db.name, (char*) &have_archive_db, SHOW_HAVE}, {sys_have_archive_db.name, (char*) &have_archive_db, SHOW_HAVE},
{sys_have_berkeley_db.name, (char*) &have_berkeley_db, SHOW_HAVE},
{sys_have_blackhole_db.name,(char*) &have_blackhole_db, SHOW_HAVE}, {sys_have_blackhole_db.name,(char*) &have_blackhole_db, SHOW_HAVE},
{sys_have_compress.name, (char*) &have_compress, SHOW_HAVE}, {sys_have_compress.name, (char*) &have_compress, SHOW_HAVE},
{sys_have_crypt.name, (char*) &have_crypt, SHOW_HAVE}, {sys_have_crypt.name, (char*) &have_crypt, SHOW_HAVE},
......
sql/sql_yacc.yy
View file @ 04d2b020
...@@ -146,7 +146,6 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); ...@@ -146,7 +146,6 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%token BEFORE_SYM %token BEFORE_SYM
%token BEGIN_SYM %token BEGIN_SYM
%token BENCHMARK_SYM %token BENCHMARK_SYM
%token BERKELEY_DB_SYM
%token BIGINT %token BIGINT
%token BINARY %token BINARY
%token BINLOG_SYM %token BINLOG_SYM
...@@ -8328,30 +8327,6 @@ show_param: ...@@ -8328,30 +8327,6 @@ show_param:
if (prepare_schema_table(YYTHD, lex, 0, SCH_COLLATIONS)) if (prepare_schema_table(YYTHD, lex, 0, SCH_COLLATIONS))
YYABORT; YYABORT;
} }
| BERKELEY_DB_SYM LOGS_SYM
{
LEX *lex= Lex;
lex->sql_command= SQLCOM_SHOW_ENGINE_LOGS;
if (!(lex->create_info.db_type=
ha_resolve_by_legacy_type(YYTHD, DB_TYPE_BERKELEY_DB)))
{
my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), "BerkeleyDB");
YYABORT;
}
WARN_DEPRECATED(yythd, "5.2", "SHOW BDB LOGS", "'SHOW ENGINE BDB LOGS'");
}
| LOGS_SYM
{
LEX *lex= Lex;
lex->sql_command= SQLCOM_SHOW_ENGINE_LOGS;
if (!(lex->create_info.db_type=
ha_resolve_by_legacy_type(YYTHD, DB_TYPE_BERKELEY_DB)))
{
my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), "BerkeleyDB");
YYABORT;
}
WARN_DEPRECATED(yythd, "5.2", "SHOW LOGS", "'SHOW ENGINE BDB LOGS'");
}
| GRANTS | GRANTS
{ {
LEX *lex=Lex; LEX *lex=Lex;
...@@ -9382,7 +9357,6 @@ keyword_sp: ...@@ -9382,7 +9357,6 @@ keyword_sp:
| AUTOEXTEND_SIZE_SYM {} | AUTOEXTEND_SIZE_SYM {}
| AVG_ROW_LENGTH {} | AVG_ROW_LENGTH {}
| AVG_SYM {} | AVG_SYM {}
| BERKELEY_DB_SYM {}
| BINLOG_SYM {} | BINLOG_SYM {}
| BIT_SYM {} | BIT_SYM {}
| BOOL_SYM {} | BOOL_SYM {}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7