Import BSDDB 4.7.25 (as of svn r89086)
This commit is contained in:
Zachary Ware
48
docs_src/env/Makefile
vendored
Normal file
48
docs_src/env/Makefile
vendored
Normal file
@@ -0,0 +1,48 @@
|
||||
# $Id: Makefile,v 10.106 2008/01/12 13:42:40 bostic Exp $
|
||||
|
||||
COMMON= api_core.html \
|
||||
env_class.html \
|
||||
env_close.html \
|
||||
env_dbremove.html \
|
||||
env_dbrename.html \
|
||||
env_err.html \
|
||||
env_event_notify.html \
|
||||
env_failchk.html \
|
||||
env_fileid_reset.html \
|
||||
env_list.html \
|
||||
env_lsn_reset.html \
|
||||
env_open.html \
|
||||
env_remove.html \
|
||||
env_set_app_dispatch.html \
|
||||
env_set_cachesize.html \
|
||||
env_set_data_dir.html \
|
||||
env_set_encrypt.html \
|
||||
env_set_errcall.html \
|
||||
env_set_errpfx.html \
|
||||
env_set_feedback.html \
|
||||
env_set_flags.html \
|
||||
env_set_isalive.html \
|
||||
env_set_msgcall.html \
|
||||
env_set_rpc_server.html \
|
||||
env_set_intermediate_dir_mode.html \
|
||||
env_set_shm_key.html \
|
||||
env_set_thread_count.html \
|
||||
env_set_thread_id.html \
|
||||
env_set_thread_id_string.html \
|
||||
env_set_timeout.html \
|
||||
env_set_tmp_dir.html \
|
||||
env_set_verbose.html \
|
||||
env_strerror.html \
|
||||
env_version.html
|
||||
|
||||
C= env_set_alloc.html \
|
||||
env_set_errfile.html \
|
||||
env_set_msgfile.html \
|
||||
env_stat.html
|
||||
|
||||
CXX= env_set_alloc.html \
|
||||
env_set_errfile.html \
|
||||
env_set_error_stream.html \
|
||||
env_set_msg_stream.html \
|
||||
env_set_msgfile.html \
|
||||
env_stat.html
|
||||
214
docs_src/env/api_core.so
vendored
Normal file
214
docs_src/env/api_core.so
vendored
Normal file
@@ -0,0 +1,214 @@
|
||||
m4_comment([DO NOT EDIT: automatically built by build script.])
|
||||
m4_page_title([m4_db: ifelse(M4API, C_API, C, C++) Handle Methods (version M4MAJOR.M4MINOR.M4PATCH)])
|
||||
m4_table_begin(, _center)
|
||||
m4_table_header(ifelse(M4API, C_API, C, C++) Handle Methods, Description)
|
||||
m4_comment([Db::])m4_table_element(m4_ref(ifelse(M4API, C_API, dbh_create, Db)), Create a database handle)
|
||||
m4_comment([Db::associate])m4_table_element(m4_ref(dbh_associate), Associate a secondary index)
|
||||
m4_comment([Db::close])m4_table_element(m4_ref(dbh_close), Close a database)
|
||||
m4_comment([Db::compact])m4_table_element(m4_ref(dbh_compact), Compact a database)
|
||||
m4_comment([Db::cursor])m4_table_element(m4_ref(dbh_cursor), Create a cursor)
|
||||
m4_comment([Db::del])m4_table_element(m4_ref(dbh_del), Delete items from a database)
|
||||
m4_comment([Db::err])m4_table_element([m4_ref(dbh_err), m4_ref(dbh_errx)], Error message)
|
||||
m4_comment([Db::exists])m4_table_element(m4_ref(dbh_exists), Return if an item appears in a database)
|
||||
m4_comment([Db::fd])m4_table_element(m4_ref(dbh_fd), Return a file descriptor from a database)
|
||||
m4_comment([Db::get])m4_table_element([m4_ref(dbh_get), m4_ref(dbh_pget)], Get items from a database)
|
||||
m4_comment([Db::get_byteswapped])m4_table_element(m4_ref(dbh_get_byteswapped), Return if the underlying database is in host order)
|
||||
m4_comment([Db::get_env])m4_table_element(m4_ref(dbh_getenv), Return m4_ref(Db)'s underlying m4_ref(DbEnv) handle)
|
||||
m4_comment([Db::get_type])m4_table_element(m4_ref(dbh_get_type), Return the database type)
|
||||
m4_comment([Db::join])m4_table_element(m4_ref(dbh_join), Perform a database join on cursors)
|
||||
m4_comment([Db::key_range])m4_table_element(m4_ref(dbh_key_range), Return estimate of key location)
|
||||
m4_comment([Db::mpf])m4_table_element(m4_ref(dbh_get_mpf), Return m4_ref(Db)'s underlying m4_ref(DbMpoolFile) handle)
|
||||
m4_comment([Db::open])m4_table_element(m4_ref(dbh_open), Open a database)
|
||||
m4_comment([Db::put])m4_table_element(m4_ref(dbh_put), Store items into a database)
|
||||
m4_comment([Db::remove])m4_table_element(m4_ref(dbh_remove), Remove a database)
|
||||
m4_comment([Db::rename])m4_table_element(m4_ref(dbh_rename), Rename a database)
|
||||
m4_comment([Db::set_alloc])m4_table_element( m4_ref(dbh_set_alloc), Set local space allocation functions)
|
||||
m4_comment([Db::set_append_recno])m4_table_element(m4_ref(dbh_set_append_recno), Set record append callback)
|
||||
m4_comment([Db::set_bt_compare])m4_table_element(m4_ref(dbh_set_bt_compare), Set a Btree comparison function)
|
||||
m4_comment([Db::set_bt_minkey])m4_table_element(m4_ref(dbh_set_bt_minkey), Set the minimum number of keys per Btree page)
|
||||
m4_comment([Db::set_bt_prefix])m4_table_element(m4_ref(dbh_set_bt_prefix), Set a Btree prefix comparison function)
|
||||
m4_comment([Db::set_cachesize])m4_table_element(m4_ref(dbh_set_cachesize), Set the database cache size)
|
||||
m4_comment([Db::set_dup_compare])m4_table_element(m4_ref(dbh_set_dup_compare), Set a duplicate comparison function)
|
||||
m4_comment([Db::set_encrypt])m4_table_element(m4_ref(dbh_set_encrypt), Set the database cryptographic key)
|
||||
m4_comment([Db::set_errcall])m4_table_element([m4_ref(dbh_set_errcall), m4_ref(dbh_set_msgcall)], Set error and informational message callback)
|
||||
m4_comment([Db::set_errfile])m4_table_element([m4_ref(dbh_set_errfile), m4_ref(dbh_set_msgfile)], Set error and informational message FILE)
|
||||
m4_comment([Db::set_error_stream])ifelse(M4API, C_API,, [m4_table_element([m4_ref(dbh_set_error_stream), m4_ref(dbh_set_message_stream)], Set error and informational message output stream)])
|
||||
m4_comment([Db::set_errpfx])m4_table_element(m4_ref(dbh_set_errpfx), Set error message prefix)
|
||||
m4_comment([Db::set_feedback])m4_table_element(m4_ref(dbh_set_feedback), Set feedback callback)
|
||||
m4_comment([Db::set_flags])m4_table_element(m4_ref(dbh_set_flags), General database configuration)
|
||||
m4_comment([Db::set_h_compare])m4_table_element(m4_ref(dbh_set_h_compare), Set a Hash comparison function)
|
||||
m4_comment([Db::set_h_ffactor])m4_table_element(m4_ref(dbh_set_h_ffactor), Set the Hash table density)
|
||||
m4_comment([Db::set_h_hash])m4_table_element(m4_ref(dbh_set_h_hash), Set a hashing function)
|
||||
m4_comment([Db::set_h_nelem])m4_table_element(m4_ref(dbh_set_h_nelem), Set the Hash table size)
|
||||
m4_comment([Db::set_lorder])m4_table_element(m4_ref(dbh_set_lorder), Set the database byte order)
|
||||
m4_comment([Db::set_pagesize])m4_table_element(m4_ref(dbh_set_pagesize), Set the underlying database page size)
|
||||
m4_comment([Db::set_priority])m4_table_element([m4_ref(dbh_set_priority)], Set cache page priority)
|
||||
m4_comment([Db::set_q_extentsize])m4_table_element(m4_ref(dbh_set_q_extentsize), Set Queue database extent size)
|
||||
m4_comment([Db::set_re_delim])m4_table_element(m4_ref(dbh_set_re_delim), Set the variable-length record delimiter)
|
||||
m4_comment([Db::set_re_len])m4_table_element(m4_ref(dbh_set_re_len), Set the fixed-length record length)
|
||||
m4_comment([Db::set_re_pad])m4_table_element(m4_ref(dbh_set_re_pad), Set the fixed-length record pad byte)
|
||||
m4_comment([Db::set_re_source])m4_table_element(m4_ref(dbh_set_re_source), Set the backing Recno text file)
|
||||
m4_comment([Db::stat])m4_table_element([m4_ref(dbh_stat), m4_ref(dbh_stat_print)], Database statistics)
|
||||
m4_comment([Db::sync])m4_table_element(m4_ref(dbh_sync), Flush a database to stable storage)
|
||||
m4_comment([Db::truncate])m4_table_element(m4_ref(dbh_truncate), Empty a database)
|
||||
m4_comment([Db::upgrade])m4_table_element(m4_ref(dbh_upgrade), Upgrade a database)
|
||||
m4_comment([Db::verify])m4_table_element(m4_ref(dbh_verify), Verify/salvage a database)
|
||||
m4_comment([DbCursor::close])m4_table_element(m4_ref(dbc_close), Close a cursor)
|
||||
m4_comment([DbCursor::count])m4_table_element(m4_ref(dbc_count), Return count of duplicates)
|
||||
m4_comment([DbCursor::del])m4_table_element(m4_ref(dbc_del), Delete by cursor)
|
||||
m4_comment([DbCursor::dup])m4_table_element(m4_ref(dbc_dup), Duplicate a cursor)
|
||||
m4_comment([DbCursor::get])m4_table_element([m4_ref(dbc_get), m4_ref(dbc_pget)], Retrieve by cursor)
|
||||
m4_comment([DbCursor::put])m4_table_element(m4_ref(dbc_put), Store by cursor)
|
||||
m4_comment([DbCursor::set_priority])m4_table_element(m4_ref(dbc_set_priority), Set the cursor's cache priority)
|
||||
m4_comment([DbDeadlockException])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbDeadlockException), Deadlock exception)])
|
||||
m4_comment([DbEnv::])m4_table_element(m4_ref(ifelse(M4API, C_API, dbenv_create, DbEnv)), Create an environment handle)
|
||||
m4_comment([DbEnv::cdsgroup_begin])m4_table_element(m4_ref(cdsgroup_begin), Get a locker ID in m4_cam)
|
||||
m4_comment([DbEnv::close])m4_table_element(m4_ref(dbenv_close), Close an environment)
|
||||
m4_comment([DbEnv::dbremove])m4_table_element(m4_ref(dbenv_dbremove), Remove a database)
|
||||
m4_comment([DbEnv::dbrename])m4_table_element(m4_ref(dbenv_dbrename), Rename a database)
|
||||
m4_comment([DbEnv::err])m4_table_element([m4_ref(dbenv_err), m4_ref(dbenv_errx)], Error message)
|
||||
m4_comment([DbEnv::failchk])m4_table_element(m4_ref(dbenv_failchk), Check for thread failure)
|
||||
m4_comment([DbEnv::fileid_reset])m4_table_element(m4_ref(dbenv_fileid_reset), Reset database file IDs)
|
||||
m4_comment([DbEnv::get_home])m4_table_element(m4_ref(dbenv_get_home), Return environment's home directory)
|
||||
m4_comment([DbEnv::get_open_flags])m4_table_element(m4_ref(dbenv_get_open_flags), Return flags with which the environment was opened)
|
||||
m4_comment([DbEnv::lock_detect])m4_table_element(m4_ref(lock_detect), Perform deadlock detection)
|
||||
m4_comment([DbEnv::lock_get])m4_table_element(m4_ref(lock_get), Acquire a lock)
|
||||
m4_comment([DbEnv::lock_id])m4_table_element(m4_ref(lock_id), Acquire a locker ID)
|
||||
m4_comment([DbEnv::lock_id_free])m4_table_element(m4_ref(lock_id_free), Release a locker ID)
|
||||
m4_comment([DbEnv::lock_put])m4_table_element(m4_ref(lock_put), Release a lock)
|
||||
m4_comment([DbEnv::lock_stat])m4_table_element(m4_ref(lock_stat), Return lock subsystem statistics)
|
||||
m4_comment([DbEnv::lock_vec])m4_table_element(m4_ref(lock_vec), Acquire/release locks)
|
||||
m4_comment([DbEnv::log_archive])m4_table_element(m4_ref(log_archive), List log and database files)
|
||||
m4_comment([DbEnv::log_file])m4_table_element(m4_ref(log_file), Map Log Sequence Numbers to log files)
|
||||
m4_comment([DbEnv::log_flush])m4_table_element(m4_ref(log_flush), Flush log records)
|
||||
m4_comment([DbEnv::log_printf])m4_table_element(m4_ref(log_printf), Append informational message to the log)
|
||||
m4_comment([DbEnv::log_put])m4_table_element(m4_ref(log_put), Write a log record)
|
||||
m4_comment([DbEnv::log_set_config])m4_table_element(m4_ref(dbenv_log_set_config), Configure the logging subsystem)
|
||||
m4_comment([DbEnv::log_stat])m4_table_element(m4_ref(log_stat), Return log subsystem statistics)
|
||||
m4_comment([DbEnv::lsn_reset])m4_table_element(m4_ref(dbenv_lsn_reset), Reset database file LSNs)
|
||||
m4_comment([DbEnv::memp_fcreate])m4_table_element(m4_ref(memp_fcreate), Create a memory pool file handle)
|
||||
m4_comment([DbEnv::memp_register])m4_table_element(m4_ref(memp_register), Register input/output functions for a file in a memory pool)
|
||||
m4_comment([DbEnv::memp_stat])m4_table_element(m4_ref(memp_stat), Return memory pool statistics)
|
||||
m4_comment([DbEnv::memp_sync])m4_table_element(m4_ref(memp_sync), Flush pages from a memory pool)
|
||||
m4_comment([DbEnv::memp_trickle])m4_table_element(m4_ref(memp_trickle), Trickle flush pages from a memory pool)
|
||||
m4_comment([DbEnv::mutex_alloc])m4_table_element(m4_ref(mutex_alloc), Allocate a mutex)
|
||||
m4_comment([DbEnv::mutex_free])m4_table_element(m4_ref(mutex_free), Free a mutex)
|
||||
m4_comment([DbEnv::mutex_lock])m4_table_element(m4_ref(mutex_lock), Lock a mutex)
|
||||
m4_comment([DbEnv::mutex_set_align])m4_table_element(m4_ref(mutex_set_align), Configure mutex alignment)
|
||||
m4_comment([DbEnv::mutex_set_increment])m4_table_element(m4_ref(mutex_set_increment), Configure number of additional mutexes)
|
||||
m4_comment([DbEnv::mutex_set_max])m4_table_element(m4_ref(mutex_set_max), Configure total number of mutexes)
|
||||
m4_comment([DbEnv::mutex_set_tas_spins])m4_table_element(m4_ref(mutex_set_tas_spins), Configure test-and-set mutex spin count)
|
||||
m4_comment([DbEnv::mutex_stat])m4_table_element(m4_ref(mutex_stat), Mutex statistics)
|
||||
m4_comment([DbEnv::mutex_unlock])m4_table_element(m4_ref(mutex_unlock), Unlock a mutex)
|
||||
m4_comment([DbEnv::open])m4_table_element(m4_ref(dbenv_open), Open an environment)
|
||||
m4_comment([DbEnv::remove])m4_table_element(m4_ref(dbenv_remove), Remove an environment)
|
||||
m4_comment([DbEnv::rep_elect])m4_table_element(m4_ref(rep_elect), Hold a replication election)
|
||||
m4_comment([DbEnv::rep_process_message])m4_table_element(m4_ref(rep_message), Process a replication message)
|
||||
m4_comment([DbEnv::rep_set_clockskew])m4_table_element(m4_ref(rep_set_clockskew), Configure master lease clock adjustment)
|
||||
m4_comment([DbEnv::rep_set_config])m4_table_element(m4_ref(rep_set_config), Configure the replication subsystem)
|
||||
m4_comment([DbEnv::rep_set_limit])m4_table_element(m4_ref(rep_set_limit), Limit data sent in response to a single message)
|
||||
m4_comment([DbEnv::rep_set_nsites])m4_table_element(m4_ref(rep_set_nsites), Configure replication group site count)
|
||||
m4_comment([DbEnv::rep_set_priority])m4_table_element(m4_ref(rep_set_priority), Configure replication site priority)
|
||||
m4_comment([DbEnv::rep_set_request])m4_table_element(m4_ref(rep_set_request), Configure replication client retransmission requests)
|
||||
m4_comment([DbEnv::rep_set_timeout])m4_table_element(m4_ref(rep_set_timeout), Configure replication timeouts)
|
||||
m4_comment([DbEnv::rep_set_transport])m4_table_element(m4_ref(rep_set_transport), Configure replication transport callback)
|
||||
m4_comment([DbEnv::rep_start])m4_table_element(m4_ref(rep_start), Configure an environment for replication)
|
||||
m4_comment([DbEnv::rep_stat])m4_table_element(m4_ref(rep_stat), Replication statistics)
|
||||
m4_comment([DbEnv::rep_sync])m4_table_element(m4_ref(rep_sync), Replication synchronization)
|
||||
m4_comment([DbEnv::repmgr_add_remote_site])m4_table_element(m4_ref(repmgr_add_remote_site), Specify the replication manager's remote sites)
|
||||
m4_comment([DbEnv::repmgr_set_ack_policy])m4_table_element(m4_ref(repmgr_set_ack_policy), Specify the replication manager's client acknowledgement policy)
|
||||
m4_comment([DbEnv::repmgr_set_local_site])m4_table_element(m4_ref(repmgr_set_local_site), Specify the replication manager's local site)
|
||||
m4_comment([DbEnv::repmgr_site_list])m4_table_element(m4_ref(repmgr_site_list), List the sites and their status)
|
||||
m4_comment([DbEnv::repmgr_start])m4_table_element(m4_ref(repmgr_start), Start the replication manager)
|
||||
m4_comment([DbEnv::repmgr_stat])m4_table_element(m4_ref(repmgr_stat), Replication manager statistics)
|
||||
m4_comment([DbEnv::set_alloc])m4_table_element(m4_ref(dbenv_set_alloc), Set local space allocation functions)
|
||||
m4_comment([DbEnv::set_app_dispatch])m4_table_element(m4_ref(dbenv_set_app_dispatch), Configure application recovery)
|
||||
m4_comment([DbEnv::set_cache_max])m4_table_element(m4_ref(dbenv_set_cache_max), Set the maximum cache size)
|
||||
m4_comment([DbEnv::set_cachesize])m4_table_element(m4_ref(dbenv_set_cachesize), Set the environment cache size)
|
||||
m4_comment([DbEnv::set_data_dir])m4_table_element(m4_ref(dbenv_set_data_dir), Set the environment data directory)
|
||||
m4_comment([DbEnv::set_encrypt])m4_table_element(m4_ref(dbenv_set_encrypt), Set the environment cryptographic key)
|
||||
m4_comment([DbEnv::set_errcall])m4_table_element([m4_ref(dbenv_set_errcall), m4_ref(dbenv_set_msgcall)], Set error and informational message callbacks)
|
||||
m4_comment([DbEnv::set_errfile])m4_table_element([m4_ref(dbenv_set_errfile), m4_ref(dbenv_set_msgfile)], Set error and informational message FILE)
|
||||
m4_comment([DbEnv::set_error_stream])ifelse(M4API, C_API,, [m4_table_element([m4_ref(dbenv_set_error_stream), m4_ref(dbenv_set_message_stream)], Set error and informational message output stream)])
|
||||
m4_comment([DbEnv::set_errpfx])m4_table_element(m4_ref(dbenv_set_errpfx), Set error message prefix)
|
||||
m4_comment([DbEnv::set_event_notify])m4_table_element(m4_ref(dbenv_set_event_notify), Set event notification callback)
|
||||
m4_comment([DbEnv::set_feedback])m4_table_element(m4_ref(dbenv_set_feedback), Set feedback callback)
|
||||
m4_comment([DbEnv::set_flags])m4_table_element(m4_ref(dbenv_set_flags), Environment configuration)
|
||||
m4_comment([DbEnv::set_intermediate_dir_mode])m4_table_element(m4_ref(dbenv_set_intermediate_dir_mode), Set intermediate directory creation mode)
|
||||
m4_comment([DbEnv::set_isalive])m4_table_element(m4_ref(dbenv_set_isalive), Set thread is-alive callback)
|
||||
m4_comment([DbEnv::set_lg_bsize])m4_table_element(m4_ref(dbenv_set_lg_bsize), Set log buffer size)
|
||||
m4_comment([DbEnv::set_lg_dir])m4_table_element(m4_ref(dbenv_set_lg_dir), Set the environment logging directory)
|
||||
m4_comment([DbEnv::set_lg_filemode])m4_table_element(m4_ref(dbenv_set_lg_filemode), Set log file mode)
|
||||
m4_comment([DbEnv::set_lg_max])m4_table_element(m4_ref(dbenv_set_lg_max), Set log file size)
|
||||
m4_comment([DbEnv::set_lg_regionmax])m4_table_element(m4_ref(dbenv_set_lg_regionmax), Set logging region size)
|
||||
m4_comment([DbEnv::set_lk_conflicts])m4_table_element(m4_ref(dbenv_set_lk_conflicts), Set lock conflicts matrix)
|
||||
m4_comment([DbEnv::set_lk_max_detect])m4_table_element(m4_ref(dbenv_set_lk_detect), Set automatic deadlock detection)
|
||||
m4_comment([DbEnv::set_lk_max_lockers])m4_table_element(m4_ref(dbenv_set_lk_max_lockers), Set maximum number of lockers)
|
||||
m4_comment([DbEnv::set_lk_max_locks])m4_table_element(m4_ref(dbenv_set_lk_max_locks), Set maximum number of locks)
|
||||
m4_comment([DbEnv::set_lk_max_objects])m4_table_element(m4_ref(dbenv_set_lk_max_objects), Set maximum number of lock objects)
|
||||
m4_comment([DbEnv::set_lk_partitions])m4_table_element(m4_ref(dbenv_set_lk_partitions), Set number of lock partitions)
|
||||
m4_comment([DbEnv::set_mp_max_openfd])m4_table_element(m4_ref(memp_set_max_openfd), Set the maximum number of open file descriptors)
|
||||
m4_comment([DbEnv::set_mp_max_write])m4_table_element(m4_ref(memp_set_max_write), Set the maximum number of sequential disk writes)
|
||||
m4_comment([DbEnv::set_mp_mmapsize])m4_table_element(m4_ref(dbenv_set_mp_mmapsize), Set maximum mapped-in database file size)
|
||||
m4_comment([DbEnv::set_rpc_server])m4_table_element(m4_ref(dbenv_set_rpc_server), Establish an RPC server connection)
|
||||
m4_comment([DbEnv::set_shm_key])m4_table_element(m4_ref(dbenv_set_shm_key), Set system memory shared segment ID)
|
||||
m4_comment([DbEnv::set_thread_count])m4_table_element(m4_ref(dbenv_set_thread_count), Set approximate thread count)
|
||||
m4_comment([DbEnv::set_thread_id])m4_table_element(m4_ref(dbenv_set_thread_id), Set thread of control ID function)
|
||||
m4_comment([DbEnv::set_thread_id_string])m4_table_element(m4_ref(dbenv_set_thread_id_string), Set thread of control ID format function)
|
||||
m4_comment([DbEnv::set_timeout])m4_table_element(m4_ref(dbenv_set_timeout), Set lock and transaction timeout)
|
||||
m4_comment([DbEnv::set_tmp_dir])m4_table_element(m4_ref(dbenv_set_tmp_dir), Set the environment temporary file directory)
|
||||
m4_comment([DbEnv::set_tx_max])m4_table_element(m4_ref(dbenv_set_tx_max), Set maximum number of transactions)
|
||||
m4_comment([DbEnv::set_tx_timestamp])m4_table_element(m4_ref(dbenv_set_tx_timestamp), Set recovery timestamp)
|
||||
m4_comment([DbEnv::set_verbose])m4_table_element(m4_ref(dbenv_set_verbose), Set verbose messages)
|
||||
m4_comment([DbEnv::stat_print])m4_table_element(m4_ref(dbenv_stat_print), Environment statistics)
|
||||
m4_comment([DbEnv::txn_begin])m4_table_element(m4_ref(txn_begin), Begin a transaction)
|
||||
m4_comment([DbEnv::txn_checkpoint])m4_table_element(m4_ref(txn_checkpoint), Checkpoint the transaction subsystem)
|
||||
m4_comment([DbEnv::txn_recover])m4_table_element(m4_ref(txn_recover), Distributed transaction recovery)
|
||||
m4_comment([DbEnv::txn_stat])m4_table_element(m4_ref(txn_stat), Return transaction subsystem statistics)
|
||||
m4_comment([DbLockNotGrantedException])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbLockNotGrantedException), Lock-not-granted exception)])
|
||||
m4_comment([DbLock])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbLock), Lock object)])
|
||||
m4_comment([DbLogc::])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbLogc), Log Cursor Object)])
|
||||
m4_comment([DbLogc::])m4_table_element(m4_ref(log_cursor), Create a log cursor handle)
|
||||
m4_comment([DbLogc::close])m4_table_element(m4_ref(logc_close), Close a log cursor)
|
||||
m4_comment([DbLogc::get])m4_table_element(m4_ref(logc_get), Retrieve a log record)
|
||||
m4_comment([DbLsn])m4_table_element(m4_ref(DbLsn), Log Sequence Numbers)
|
||||
m4_comment([DbMemoryException])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbMemoryException), Insufficient memory exception)])
|
||||
m4_comment([DbMpoolFile::])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbMpoolFile), Memory pool file object)])
|
||||
m4_comment([DbMpoolFile::close])m4_table_element(m4_ref(memp_fclose), Close a file in a memory pool)
|
||||
m4_comment([DbMpoolFile::get])m4_table_element(m4_ref(memp_fget), Get page from a file in a memory pool)
|
||||
m4_comment([DbMpoolFile::open])m4_table_element(m4_ref(memp_fopen), Open a file in a memory pool)
|
||||
m4_comment([DbMpoolFile::put])m4_table_element(m4_ref(memp_fput), Return a page to a memory pool)
|
||||
m4_comment([DbMpoolFile::set_clear_len])m4_table_element(m4_ref(memp_set_clear_len), Set file page bytes to be cleared)
|
||||
m4_comment([DbMpoolFile::set_fileid])m4_table_element(m4_ref(memp_set_fileid), Set file unique identifier)
|
||||
m4_comment([DbMpoolFile::set_flags])m4_table_element(m4_ref(memp_set_flags), General memory pool file configuration)
|
||||
m4_comment([DbMpoolFile::set_ftype])m4_table_element(m4_ref(memp_set_ftype), Set file type)
|
||||
m4_comment([DbMpoolFile::set_lsn_offset])m4_table_element(m4_ref(memp_set_lsn_offset), Set file log-sequence-number offset)
|
||||
m4_comment([DbMpoolFile::set_maxsize])m4_table_element(m4_ref(memp_set_maxsize), Set maximum file size)
|
||||
m4_comment([DbMpoolFile::set_pgcookie])m4_table_element(m4_ref(memp_set_pgcookie), Set file cookie for pgin/pgout)
|
||||
m4_comment([DbMpoolFile::set_priority])m4_table_element(m4_ref(memp_set_priority), Set memory pool file priority)
|
||||
m4_comment([DbMpoolFile::sync])m4_table_element(m4_ref(memp_fsync), Flush pages from a file in a memory pool)
|
||||
m4_comment([DbSequence::])m4_table_element(ifelse(M4API, C_API, m4_ref(seq_create), m4_ref(DbSequence)), Create a sequence handle)
|
||||
m4_comment([DbSequence::close])m4_table_element(m4_ref(seq_close), Close a sequence)
|
||||
m4_comment([DbSequence::get])m4_table_element(m4_ref(seq_get), Get the next sequence element(s))
|
||||
m4_comment([DbSequence::get_dbp])m4_table_element(m4_ref(seq_get_dbp), Return a handle for the underlying sequence database)
|
||||
m4_comment([DbSequence::get_key])m4_table_element(m4_ref(seq_get_key), Return the key for a sequence)
|
||||
m4_comment([DbSequence::initial_value])m4_table_element(m4_ref(seq_initial_value), Set the initial value of a sequence)
|
||||
m4_comment([DbSequence::open])m4_table_element(m4_ref(seq_open), Open a sequence)
|
||||
m4_comment([DbSequence::remove])m4_table_element(m4_ref(seq_remove), Remove a sequence)
|
||||
m4_comment([DbSequence::set_cachesize])m4_table_element(m4_ref(seq_set_cachesize), Set the cache size of a sequence)
|
||||
m4_comment([DbSequence::set_flags])m4_table_element(m4_ref(seq_set_flags), Set the flags for a sequence)
|
||||
m4_comment([DbSequence::set_range])m4_table_element(m4_ref(seq_set_range), Set the range for a sequence)
|
||||
m4_comment([DbSequence::stat])m4_table_element(m4_ref(seq_stat), Return sequence statistics)
|
||||
m4_comment([DbTxn::])ifelse(M4API, CXX_API, [m4_table_element(m4_ref(DbTxn), Transaction object)])
|
||||
m4_comment([DbTxn::abort])m4_table_element(m4_ref(txn_abort), Abort a transaction)
|
||||
m4_comment([DbTxn::commit])m4_table_element(m4_ref(txn_commit), Commit a transaction)
|
||||
m4_comment([DbTxn::discard])m4_table_element(m4_ref(txn_discard), Discard a prepared but not resolved transaction handle)
|
||||
m4_comment([DbTxn::id])m4_table_element(m4_ref(txn_id), Return a transaction's ID)
|
||||
m4_comment([DbTxn::prepare])m4_table_element(m4_ref(txn_prepare), Prepare a transaction for commit)
|
||||
m4_comment([DbTxn::set_name])m4_table_element(m4_ref(txn_set_name), Associate a string with a transaction)
|
||||
m4_comment([DbTxn::set_timeout])m4_table_element(m4_ref(txn_set_timeout), Set transaction timeout)
|
||||
m4_comment([db_strerror])m4_table_element(m4_ref(dbenv_strerror), Error strings)
|
||||
m4_comment([db_version])m4_table_element(m4_ref(dbenv_version), Return version information)
|
||||
m4_comment([log_compare])m4_table_element(m4_ref(log_compare), Compare two Log Sequence Numbers)
|
||||
m4_table_end
|
||||
m4_page_footer
|
||||
123
docs_src/env/env_class.so
vendored
Normal file
123
docs_src/env/env_class.so
vendored
Normal file
@@ -0,0 +1,123 @@
|
||||
m4_comment([$Id: env_class.so,v 10.45 2005/11/30 19:09:47 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [DbEnv, dbenv_create, DB_RPCCLIENT, DB_CXX_NO_EXCEPTIONS])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4API, C_API, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_create), [dnl
|
||||
int
|
||||
db_env_create(DB_ENV **dbenvp, u_int32_t flags);
|
||||
])])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
m4_pf_header(m4_ref(DbEnv), [dnl
|
||||
class DbEnv {
|
||||
public:
|
||||
DbEnv(u_int32 flags);
|
||||
~DbEnv();
|
||||
m4_blank
|
||||
DB_ENV *DbEnv::get_DB_ENV();
|
||||
const DB_ENV *DbEnv::get_const_DB_ENV() const;
|
||||
static DbEnv *DbEnv::get_DbEnv(DB_ENV *dbenv);
|
||||
static const DbEnv *DbEnv::get_const_DbEnv(const DB_ENV *dbenv);
|
||||
...
|
||||
};])])
|
||||
|
||||
define(m4_rpcclient, [dnl
|
||||
m4_tag(m4_idef(DB_RPCCLIENT),
|
||||
[Create a client environment to connect to a server.])
|
||||
m4_p([dnl
|
||||
The m4_ref(DB_RPCCLIENT) flag indicates to the system that this environment
|
||||
is remote on a server. The use of this flag causes the environment
|
||||
methods to use functions that call a server instead of local functions.
|
||||
Prior to making any environment or database method calls, the application
|
||||
must call the m4_ref(dbenv_set_rpc_server) function to establish the
|
||||
connection to the server.])])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(DbEnv) object is the handle for a m4_db environment -- a
|
||||
collection including support for some or all of caching, locking,
|
||||
logging and transaction subsystems, as well as databases and log files.
|
||||
Methods of the m4_ref(DbEnv) handle are used to configure the
|
||||
environment as well as to operate on subsystems and databases in the
|
||||
environment.])
|
||||
|
||||
m4_p([dnl
|
||||
m4_ref(DbEnv) handles are free-threaded if the m4_ref(DB_THREAD) flag
|
||||
is specified to the m4_refT(dbenv_open) when the environment is opened.
|
||||
The m4_ref(DbEnv) handle should not be closed while any other handle
|
||||
remains open that is using it as a reference (for example, m4_ref(Db)
|
||||
or m4_ref(DbTxn)). Once either the m4_ref(dbenv_close) or
|
||||
m4_refT(dbenv_remove)s are called, the handle may not be accessed again,
|
||||
regardless of the method's return.])
|
||||
|
||||
ifelse(M4API, C_API, [dnl
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_create) function creates a m4_ref(DbEnv) structure that
|
||||
is the handle for a m4_db environment. This function allocates memory
|
||||
for the structure, returning a pointer to the structure in the memory
|
||||
to which m4_arg(dbenvp) refers. To release the allocated memory and
|
||||
discard the handle, call the m4_ref(dbenv_close) or m4_refT(dbenv_remove)s.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(DbEnv) handle contains a special field, "app_private", which
|
||||
is declared as type "void *". This field is provided for the use of
|
||||
the application program. It is initialized to NULL and is not further
|
||||
used by m4_db in any way.])
|
||||
|
||||
m4_return(dbenv_create, std)
|
||||
|
||||
m4_sf_zmust(0)
|
||||
|
||||
m4_tagbegin
|
||||
m4_rpcclient
|
||||
m4_tagend
|
||||
|
||||
m4_err(dbenv_create)],[dnl
|
||||
m4_p([dnl
|
||||
The constructor creates the m4_ref(DbEnv) object. The constructor
|
||||
allocates memory internally; calling the m4_ref(dbenv_close) or
|
||||
m4_refT(dbenv_remove)s will free that memory.])
|
||||
|
||||
m4_p([dnl
|
||||
The following m4_arg(flags) value may be specified:])
|
||||
|
||||
m4_tagbegin
|
||||
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
m4_tag(m4_idef(DB_CXX_NO_EXCEPTIONS), [dnl
|
||||
The m4_db C++ API supports two different error behaviors. By default,
|
||||
whenever an error occurs, an exception is thrown that encapsulates the
|
||||
error information. This generally allows for cleaner logic for
|
||||
transaction processing because a try block can surround a single
|
||||
transaction. However, if m4_ref(DB_CXX_NO_EXCEPTIONS) is specified,
|
||||
exceptions are not thrown; instead, each individual function returns an
|
||||
error code.])])
|
||||
|
||||
m4_rpcclient
|
||||
|
||||
m4_tagend
|
||||
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
m4_p([dnl
|
||||
Each m4_ref(DbEnv) object has an associated m4_refc(DbEnv) structure,
|
||||
which is used by the underlying implementation of m4_db and its
|
||||
C-language API. The DbEnv::get_DB_ENV method returns a pointer to this
|
||||
struct. Given a const m4_ref(DbEnv) object, DbEnv::get_const_DB_ENV
|
||||
returns a const pointer to the same struct.])
|
||||
|
||||
m4_p([dnl
|
||||
Given a m4_refc(DbEnv) struct, the DbEnv::get_DbEnv method returns the
|
||||
corresponding m4_ref(DbEnv) object, if there is one. If the
|
||||
m4_refc(DbEnv) object was not associated with a m4_ref(DbEnv) (that is,
|
||||
it was not returned from a call to DbEnv::get_DB_ENV), then the result
|
||||
of DbEnv::get_DbEnv is undefined. Given a const m4_refc(DbEnv) struct,
|
||||
DbEnv::get_const_Db_Env returns the associated const m4_ref(DbEnv)
|
||||
object, if there is one.])
|
||||
|
||||
m4_p([dnl
|
||||
These methods may be useful for m4_db applications including both C
|
||||
and C++ language software. It should not be necessary to use these
|
||||
calls in a purely C++ application.])])])
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
72
docs_src/env/env_close.so
vendored
Normal file
72
docs_src/env/env_close.so
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
m4_comment([$Id: env_close.so,v 10.38 2004/08/13 03:38:56 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, dbenv_close)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_close),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__close(DB_ENV *dbenv, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
DbEnv::close(u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_close) closes the m4_db environment, freeing any
|
||||
allocated resources and closing any underlying subsystems.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(DbEnv) handle should not be closed while any other handle
|
||||
that refers to it is not yet closed; for example, database environment
|
||||
handles must not be closed while database handles remain open, or
|
||||
transactions in the environment have not yet been committed or aborted.
|
||||
Specifically, this includes m4_ref(Db), m4_ref(Dbc), m4_ref(DbTxn),
|
||||
m4_ref(DbLogc) and m4_ref(DbMpoolFile) handles.])
|
||||
|
||||
m4_p([dnl
|
||||
Where the environment was initialized with the m4_ref(DB_INIT_LOCK)
|
||||
flag, calling m4_ref(dbenv_close) does not release any locks still held
|
||||
by the closing process, providing functionality for long-lived locks.
|
||||
Processes that want to have all their locks released can do so by
|
||||
issuing the appropriate m4_ref(lock_vec) call.])
|
||||
|
||||
m4_p([dnl
|
||||
Where the environment was initialized with the m4_ref(DB_INIT_MPOOL)
|
||||
flag, calling m4_ref(dbenv_close) implies calls to m4_ref(memp_fclose) for
|
||||
any remaining open files in the memory pool that were returned to this
|
||||
process by calls to m4_ref(memp_fopen). It does not imply a call to
|
||||
m4_ref(memp_fsync) for those files.])
|
||||
|
||||
m4_p([dnl
|
||||
Where the environment was initialized with the m4_ref(DB_INIT_TXN) flag,
|
||||
calling m4_ref(dbenv_close) aborts any unresolved transactions.
|
||||
Applications should not depend on this behavior for transactions
|
||||
involving m4_db databases; all such transactions should be explicitly
|
||||
resolved. The problem with depending on this semantic is that aborting
|
||||
an unresolved transaction involving database operations requires a
|
||||
database handle. Because the database handles should have been closed before
|
||||
calling m4_ref(dbenv_close), it will not be possible to abort the
|
||||
transaction, and recovery will have to be run on the m4_db environment
|
||||
before further operations are done.])
|
||||
|
||||
m4_p([dnl
|
||||
Where log cursors were created using the m4_refT(log_cursor), calling
|
||||
m4_ref(dbenv_close) does not imply closing those cursors.])
|
||||
|
||||
m4_p([dnl
|
||||
In multithreaded applications, only a single thread may call
|
||||
m4_ref(dbenv_close).])
|
||||
|
||||
m4_p([dnl
|
||||
After m4_ref(dbenv_close) has been called, regardless of its return, the
|
||||
m4_db environment handle may not be accessed again.])
|
||||
|
||||
m4_return(dbenv_close, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_unusedflags
|
||||
m4_paramend
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
90
docs_src/env/env_dbremove.so
vendored
Normal file
90
docs_src/env/env_dbremove.so
vendored
Normal file
@@ -0,0 +1,90 @@
|
||||
m4_comment([$Id: env_dbremove.so,v 10.49 2004/12/16 19:13:01 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_dbremove)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbremove, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_dbremove),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__dbremove(DB_ENV *dbenv, DB_TXN *txnid,
|
||||
const char *file, const char *database, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::dbremove(DbTxn *txnid,
|
||||
const char *file, const char *database, u_int32_t flags);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_remove),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__remove(DB *db,
|
||||
const char *file, const char *database, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
Db::remove(const char *file, const char *database, u_int32_t flags);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(M4INTERFACE) removes the database specified by the
|
||||
m4_arg(file) and m4_arg(database) parameters. If no m4_arg(database)
|
||||
is specified, the underlying file represented by m4_arg(file) is
|
||||
removed, incidentally removing all of the databases it contained.])
|
||||
|
||||
m4_p([dnl
|
||||
Applications should never remove databases with open m4_ref(Db) handles,
|
||||
or in the case of removing a file, when any database in the file has an
|
||||
open handle. For example, some architectures do not permit the removal
|
||||
of files with open system handles. On these architectures, attempts to
|
||||
remove databases currently in use by any thread of control in the system
|
||||
may fail.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_remove, [dnl
|
||||
m4_p([dnl
|
||||
The m4_refT(dbh_remove) should not be called if the remove is intended
|
||||
to be transactionally safe; the m4_refT(dbenv_dbremove) should be used
|
||||
instead.])
|
||||
m4_p([dnl
|
||||
The m4_refT(dbh_remove) may not be called after calling the
|
||||
m4_refT(dbh_open) on any m4_ref(Db) handle. If the m4_refT(dbh_open)
|
||||
has already been called on a m4_ref(Db) handle, close the existing
|
||||
handle and create a new one before calling m4_ref(dbh_remove).])
|
||||
|
||||
m4_destructor(Db, dbh_remove)])
|
||||
|
||||
m4_return(M4INTERFACE, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(database, [dnl
|
||||
The m4_arg(database) parameter is the database to be removed.])
|
||||
|
||||
m4_param_utf8(file, [dnl
|
||||
The m4_arg(file) parameter is the physical file which contains the
|
||||
database(s) to be removed.])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbremove, [dnl
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_autocommit_flag(dbenv_dbremove)
|
||||
m4_tagend])
|
||||
m4_param_txn(dbenv_dbremove, auto)
|
||||
],[dnl
|
||||
m4_unusedflags])
|
||||
m4_paramend
|
||||
|
||||
m4_header([Environment Variables])
|
||||
m4_data_location(M4INTERFACE, ifelse(M4INTERFACE, dbenv_dbremove, 0, 1))
|
||||
|
||||
m4_err(M4INTERFACE,
|
||||
ifelse(M4INTERFACE, dbenv_dbremove, deadlock, empty),
|
||||
einval, [ifelse(M4INTERFACE, dbenv_dbremove,
|
||||
[m4_ref(dbenv_dbremove) called before m4_ref(dbenv_open) was called],
|
||||
[m4_ref(dbh_remove) called after m4_ref(dbh_open) was called])],
|
||||
filenotfound)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbremove, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
98
docs_src/env/env_dbrename.so
vendored
Normal file
98
docs_src/env/env_dbrename.so
vendored
Normal file
@@ -0,0 +1,98 @@
|
||||
m4_comment([$Id: env_dbrename.so,v 10.37 2004/12/16 19:13:01 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_dbrename)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbrename, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_dbrename),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__dbrename(DB_ENV *dbenv, DB_TXN *txnid, const char *file,
|
||||
const char *database, const char *newname, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::dbrename(DbTxn *txnid, const char *file,
|
||||
const char *database, const char *newname, u_int32_t flags);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_rename),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__rename(DB *db, const char *file,
|
||||
const char *database, const char *newname, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
Db::rename(const char *file,
|
||||
const char *database, const char *newname, u_int32_t flags);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(M4INTERFACE) renames the database specified by the
|
||||
m4_arg(file) and m4_arg(database) parameters to m4_arg(newname). If no
|
||||
m4_arg(database) is specified, the underlying file represented by
|
||||
m4_arg(file) is renamed, incidentally renaming all of the databases it
|
||||
contained.])
|
||||
|
||||
m4_p([dnl
|
||||
Applications should not rename databases that are currently in use. If
|
||||
an underlying file is being renamed and logging is currently enabled in
|
||||
the database environment, no database in the file may be open when the
|
||||
m4_refT(M4INTERFACE) is called. In particular, some architectures do
|
||||
not permit renaming files with open handles. On these architectures,
|
||||
attempts to rename databases that are currently in use by any thread of
|
||||
control in the system may fail.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_rename, [dnl
|
||||
m4_p([dnl
|
||||
The m4_refT(dbh_rename) should not be called if the rename is intended
|
||||
to be transactionally safe; the m4_refT(dbenv_dbrename) should be used
|
||||
instead.])
|
||||
m4_p([dnl
|
||||
The m4_refT(dbh_rename) may not be called after calling the
|
||||
m4_refT(dbh_open) on any m4_ref(Db) handle. If the m4_refT(dbh_open)
|
||||
has already been called on a m4_ref(Db) handle, close the existing
|
||||
handle and create a new one before calling m4_ref(dbh_rename).])
|
||||
|
||||
m4_destructor(Db, dbh_rename)])
|
||||
|
||||
m4_return(M4INTERFACE, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(database, [dnl
|
||||
The m4_arg(database) parameter is the database to be renamed.])
|
||||
|
||||
m4_param_utf8(file, [dnl
|
||||
The m4_arg(file) parameter is the physical file which contains the
|
||||
database(s) to be renamed.])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbrename, [dnl
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_autocommit_flag(dbenv_dbrename)
|
||||
m4_tagend])
|
||||
],[dnl
|
||||
m4_unusedflags
|
||||
])
|
||||
|
||||
m4_param(newname, [dnl
|
||||
The m4_arg(newname) parameter is the new name of the database or file.])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbrename, [m4_param_txn(dbenv_dbrename, auto)])
|
||||
m4_paramend
|
||||
|
||||
m4_header([Environment Variables])
|
||||
m4_data_location(M4INTERFACE, ifelse(M4INTERFACE, dbenv_dbrename, 0, 1))
|
||||
|
||||
m4_err(M4INTERFACE,
|
||||
ifelse(M4INTERFACE, dbenv_dbrename, deadlock, empty), einval,
|
||||
[ifelse(M4INTERFACE, dbenv_dbrename,
|
||||
[m4_ref(dbenv_dbrename) called before m4_ref(dbenv_open) was called],
|
||||
[m4_ref(dbh_rename) called after m4_ref(dbh_open) was called])],
|
||||
filenotfound)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_dbrename, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
106
docs_src/env/env_err.so
vendored
Normal file
106
docs_src/env/env_err.so
vendored
Normal file
@@ -0,0 +1,106 @@
|
||||
m4_comment([$Id: env_err.so,v 10.34 2006/04/27 20:17:47 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_err)])
|
||||
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_err, [dnl
|
||||
define(M4PAGELOCAL, [dbenv_err, dbenv_errx])
|
||||
m4_pf_header(m4_ref(dbenv_err),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__err(DB_ENV *dbenv, int error, const char *fmt, ...);
|
||||
m4_blank
|
||||
void
|
||||
DB_ENV-__GT__errx(DB_ENV *dbenv, const char *fmt, ...);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
DbEnv::err(int error, const char *fmt, ...);
|
||||
m4_blank
|
||||
DbEnv::errx(const char *fmt, ...);
|
||||
]))],[dnl
|
||||
define(M4PAGELOCAL, [dbh_err, dbh_errx])
|
||||
m4_pf_header(m4_ref(dbh_err),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__err(DB *db, int error, const char *fmt, ...);
|
||||
m4_blank
|
||||
void
|
||||
DB-__GT__errx(DB *db, const char *fmt, ...);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
Db::err(int error, const char *fmt, ...);
|
||||
m4_blank
|
||||
Db::errx(const char *fmt, ...);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_err), m4_ref(dbenv_errx), m4_ref(dbh_err) and
|
||||
m4_refT(dbh_errx)s provide error-messaging functionality for
|
||||
applications written using the m4_db library.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbh_err) and m4_refT(dbenv_err)s constructs an error message
|
||||
consisting of the following elements:])
|
||||
|
||||
m4_indentv([dnl
|
||||
m4_tagbegin
|
||||
m4_tag([An optional prefix string], [dnl
|
||||
If no error callback function has been set using the
|
||||
m4_refT(dbenv_set_errcall), any prefix string specified using the
|
||||
m4_refT(dbenv_set_errpfx), followed by two separating characters: a colon
|
||||
and a m4_htmlquote(space) character.])
|
||||
m4_tag([An optional printf-style message], [dnl
|
||||
The supplied message m4_arg(fmt), if non-NULL, in which the
|
||||
m4_ansic_name printf function specifies how subsequent parameters
|
||||
are converted for output.])
|
||||
m4_tag([A separator], [dnl
|
||||
Two separating characters: a colon and a m4_htmlquote(space) character.])
|
||||
m4_tag([A standard error string], [dnl
|
||||
The standard system or m4_db library error string associated with the
|
||||
m4_arg(error) value, as returned by the m4_refT(dbenv_strerror).])
|
||||
m4_tagend
|
||||
])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbh_errx) and m4_refT(dbenv_errx)s are the same as the
|
||||
m4_ref(dbh_err) and m4_refT(dbenv_err)s, except they do not append the
|
||||
final separator characters and standard error string to the error
|
||||
message.])
|
||||
|
||||
m4_p([dnl
|
||||
This constructed error message is then handled as follows:])
|
||||
|
||||
m4_indentv([dnl
|
||||
m4_p([dnl
|
||||
If an error callback function has been set (see m4_ref(dbh_set_errcall)
|
||||
and m4_ref(dbenv_set_errcall)), that function is called with two
|
||||
parameters: any prefix string specified (see m4_ref(dbh_set_errpfx) and
|
||||
m4_ref(dbenv_set_errpfx)) and the error message.])
|
||||
|
||||
m4_p([dnl
|
||||
If a C library FILE * has been set (see m4_ref(dbh_set_errfile) and
|
||||
m4_ref(dbenv_set_errfile)), the error message is written to that output
|
||||
stream.])
|
||||
|
||||
ifelse(M4API, C_API,, [dnl
|
||||
m4_p([dnl
|
||||
If ifelse(M4API, CXX_API, [a C++ ostream], [an OutputStream]) has been set
|
||||
(see m4_ref(dbenv_set_error_stream) and m4_ref(dbh_set_error_stream)),
|
||||
the error message is written to that stream.])])
|
||||
|
||||
m4_p([dnl
|
||||
If none of these output options has been configured, the error message
|
||||
is written to stderr, the standard error output stream.])])
|
||||
|
||||
m4_parambegin
|
||||
m4_param(error, [dnl
|
||||
The m4_arg(error) parameter is the error value for which the
|
||||
m4_ref(dbenv_err) and m4_refT(dbh_err)s will display a explanatory
|
||||
string.])
|
||||
m4_param(fmt, [dnl
|
||||
The m4_arg(fmt) parameter is an optional printf-style message to display.])
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_err, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
113
docs_src/env/env_event_notify.so
vendored
Normal file
113
docs_src/env/env_event_notify.so
vendored
Normal file
@@ -0,0 +1,113 @@
|
||||
m4_comment([$Id: env_event_notify.so,v 10.13 2007/04/05 20:37:29 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dnl
|
||||
dbenv_set_event_notify, DB_EVENT_PANIC, DB_EVENT_REP_CLIENT,
|
||||
DB_EVENT_REP_ELECTED, DB_EVENT_REP_MASTER, DB_EVENT_REP_NEWMASTER,
|
||||
DB_EVENT_REP_PERM_FAILED, DB_EVENT_REP_STARTUPDONE])
|
||||
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_event_notify),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_event_notify(DB_ENV *dbenv,
|
||||
void (*db_event_fcn)(DB_ENV *dbenv, u_int32_t event, void *event_info));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_event_notify(
|
||||
void (*db_event_fcn)(DB_ENV *dbenv, u_int32_t event, void *event_info));
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_set_event_notify) configures a callback function which
|
||||
is called to notify the process of specific m4_db events.])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_event_notify)
|
||||
|
||||
m4_when_any(dbenv_set_event_notify)
|
||||
|
||||
m4_return(dbenv_set_event_notify, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(db_event_fcn, [dnl
|
||||
The m4_arg(db_event_fcn) parameter is the application's event
|
||||
notification function. The function takes three parameters:
|
||||
m4_tagbegin
|
||||
m4_tag(dbenv, [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment handle.])
|
||||
m4_tag(event, [dnl
|
||||
The m4_arg(event) parameter is one of the following values:])
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_EVENT_PANIC), [dnl
|
||||
Errors can occur in the m4_db library where the only solution is to shut
|
||||
down the application and run recovery (for example, if m4_db is unable
|
||||
to allocate heap memory). In such cases, the m4_db methods will
|
||||
ifelse(M4EXCEPT, return_only, [return m4_ref(DB_RUNRECOVERY).])
|
||||
ifelse(M4EXCEPT, except_return, [dnl
|
||||
either return m4_ref(DB_RUNRECOVERY) or throw a m4_ref(DbRunRecoveryException),
|
||||
depending on the API configuration.])
|
||||
ifelse(M4EXCEPT, except_only, [throw a m4_ref(DbRunRecoveryException).])
|
||||
It is often easier to simply exit the application when such errors occur
|
||||
rather than gracefully return up the stack.
|
||||
m4_p([dnl
|
||||
When m4_arg(event) is set to m4_ref(DB_EVENT_PANIC), the database
|
||||
environment has failed. All threads of control in the database
|
||||
environment should exit the environment, and recovery should be run.])])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_CLIENT), [dnl
|
||||
The local site is now a replication client.])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_ELECTED), [dnl
|
||||
The local replication site has just won an election. An application using
|
||||
the Base replication API should arrange for a call to the m4_refT(rep_start)
|
||||
after receiving this event, to reconfigure the local environment as a
|
||||
replication master.])
|
||||
m4_p([dnl
|
||||
Replication Manager applications may safely ignore this event. The
|
||||
Replication Manager calls m4_ref(rep_start) automatically on behalf of
|
||||
the application when appropriate (resulting in firing of the
|
||||
m4_ref(DB_EVENT_REP_MASTER) event).])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_MASTER), [dnl
|
||||
The local site is now the master site of its replication group. It is
|
||||
the application's responsibility to begin acting as the master environment.])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_NEWMASTER), [dnl
|
||||
The replication group of which this site is a member has just established a
|
||||
new master; the local site is not the new master. The
|
||||
m4_arg(event_info) parameter points to an integer containing the
|
||||
environment ID of the new master.])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_PERM_FAILED), [dnl
|
||||
The replication manager did not receive enough acknowledgements (based on
|
||||
the acknowledgement policy configured with m4_ref(repmgr_set_ack_policy))
|
||||
to ensure a transaction's durability within the replication group. The
|
||||
transaction will be flushed to the master's local disk storage for
|
||||
durability.])
|
||||
m4_p([dnl
|
||||
The m4_ref(DB_EVENT_REP_PERM_FAILED) event is provided only to applications
|
||||
configured for the replication manager.])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_REP_STARTUPDONE), [dnl
|
||||
The client has completed startup synchronization and is now processing
|
||||
live log records received from the master.])
|
||||
|
||||
m4_tag(m4_idef(DB_EVENT_WRITE_FAILED), [dnl
|
||||
A m4_db write to stable storage failed.])
|
||||
|
||||
m4_tagend
|
||||
|
||||
m4_tag(event_info, [dnl
|
||||
The m4_arg(event_info) parameter may reference memory which contains
|
||||
additional information describing an event. By default,
|
||||
m4_arg(event_info) is NULL; specific events may pass non-NULL values,
|
||||
in which case the event will also describe the memory's structure.])
|
||||
m4_tagend])
|
||||
|
||||
m4_paramend
|
||||
|
||||
m4_not_reentrant
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
72
docs_src/env/env_failchk.so
vendored
Normal file
72
docs_src/env/env_failchk.so
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
m4_comment([$Id: env_failchk.so,v 10.7 2007/09/21 20:06:01 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_failchk])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_failchk),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__failchk(DB_ENV *dbenv, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::failchk(u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_failchk) checks for threads of control (either a true
|
||||
thread or a process) that have exited while manipulating m4_db library
|
||||
data structures, while holding a logical database lock, or with an
|
||||
unresolved transaction (that is, a transaction that was never aborted
|
||||
or committed). For more information, see m4_link(M4RELDIR/ref/cam/app,
|
||||
Architecting Data Store and Concurrent Data Store applications), and
|
||||
m4_link(M4RELDIR/ref/transapp/app, Architecting Transactional Data Store
|
||||
applications).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_failchk) is based on the "thread_id" and "is_alive"
|
||||
functions specified to the m4_refT(dbenv_set_thread_id). Applications
|
||||
calling the m4_refT(dbenv_failchk) must have already called the
|
||||
m4_refT(dbenv_set_isalive), on the same m4_ref(DbEnv), and must have
|
||||
configured their database environment using the
|
||||
m4_refT(dbenv_set_thread_count).])
|
||||
|
||||
m4_p([dnl
|
||||
If m4_ref(dbenv_failchk) determines a thread of control exited while
|
||||
holding database read locks, it will release those locks. If
|
||||
m4_ref(dbenv_failchk) determines a thread of control exited with an
|
||||
unresolved transaction, the transaction will be aborted. In either of
|
||||
these cases, m4_ref(dbenv_failchk) will return 0 and the application may
|
||||
continue to use the database environment.])
|
||||
|
||||
m4_p([dnl
|
||||
In either of these cases, the m4_refT(dbenv_failchk) will also report
|
||||
the process and thread IDs associated with any released locks or
|
||||
aborted transactions. The information is printed to a specified output
|
||||
channel (see the m4_refT(dbenv_set_msgfile) for more information), or
|
||||
passed to an application callback function (see the
|
||||
m4_refT(dbenv_set_msgcall) for more information).])
|
||||
|
||||
m4_p([dnl
|
||||
If m4_ref(dbenv_failchk) determines a thread of control has exited such
|
||||
that database environment recovery is required, it will return
|
||||
m4_ref(DB_RUNRECOVERY). In this case, the application should not
|
||||
continue to use the database environment. For a further description as
|
||||
to the actions the application should take when this failure occurs, see
|
||||
m4_link(M4RELDIR/ref/cam/fail, Handling failure in Data Store and
|
||||
Concurrent Data Store applications), and
|
||||
m4_link(M4RELDIR/ref/transapp/fail, Handling failure in Transactional
|
||||
Data Store applications).])
|
||||
|
||||
m4_when(dbenv_failchk, before, dbenv_open)
|
||||
|
||||
m4_return(dbenv_failchk, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_unusedflags
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_failchk, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
49
docs_src/env/env_fileid_reset.so
vendored
Normal file
49
docs_src/env/env_fileid_reset.so
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
m4_comment([$Id: env_fileid_reset.so,v 1.3 2005/12/13 16:48:01 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_fileid_reset])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_fileid_reset),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__fileid_reset(DB_ENV *dbenv, const char *file, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::fileid_reset(const char *file, u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_fileid_reset) allows database files to be copied, and
|
||||
then the copy used in the same database environment as the original.])
|
||||
|
||||
m4_p([dnl
|
||||
All databases contain an ID string used to identify the database in the
|
||||
database environment cache. If a physical database file is copied, and
|
||||
used in the same environment as another file with the same ID strings,
|
||||
corruption can occur. The m4_refT(dbenv_fileid_reset) creates new ID
|
||||
strings for all of the databases in the physical file.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_fileid_reset) modifies the physical file, in-place.
|
||||
Applications should not reset IDs in files that are currently in use.])
|
||||
|
||||
m4_when_any(dbenv_fileid_reset)
|
||||
|
||||
m4_return(dbenv_fileid_reset, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(file, [dnl
|
||||
The name of the physical file in which new file IDs are to be created.])
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_tag(DB_ENCRYPT, [dnl
|
||||
The file contains encrypted databases.])
|
||||
m4_tagend])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_fileid_reset, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
7
docs_src/env/env_list.so
vendored
Normal file
7
docs_src/env/env_list.so
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
m4_comment([$Id: env_list.so,v 10.1 2002/08/30 20:00:50 bostic Exp $])
|
||||
|
||||
m4_page_title([m4_db: Database Environments and Related Methods])
|
||||
|
||||
include(env/m4.methods)
|
||||
|
||||
m4_page_footer
|
||||
57
docs_src/env/env_lsn_reset.so
vendored
Normal file
57
docs_src/env/env_lsn_reset.so
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
m4_comment([$Id: env_lsn_reset.so,v 1.4 2005/12/13 16:48:01 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_lsn_reset])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_lsn_reset),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__lsn_reset(DB_ENV *dbenv, const char *file, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::lsn_reset(const char *file, u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_lsn_reset) allows database files to be moved from one
|
||||
transactional database environment to another.])
|
||||
|
||||
m4_p([dnl
|
||||
Database pages in transactional database environments contain references
|
||||
to the environment's log files (that is, log sequence numbers, or LSNs).
|
||||
Copying or moving a database file from one database environment to
|
||||
another, and then modifying it, can result in data corruption if the
|
||||
LSNs are not first cleared.])
|
||||
|
||||
m4_p([dnl
|
||||
Note that LSNs should be reset before moving or copying the database
|
||||
file into a new database environment, rather than moving or copying the
|
||||
database file and then resetting the LSNs. m4_db has consistency checks
|
||||
that may be triggered if an application calls m4_ref(dbenv_lsn_reset)
|
||||
on a database in a new environment when the database LSNs still reflect
|
||||
the old environment.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_lsn_reset) modifies the physical file, in-place.
|
||||
Applications should not reset LSNs in files that are currently in use.])
|
||||
|
||||
m4_when_any(dbenv_lsn_reset)
|
||||
|
||||
m4_return(dbenv_lsn_reset, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(file, [dnl
|
||||
The name of the physical file in which the LSNs are to be cleared.])
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_tag(DB_ENCRYPT, [dnl
|
||||
The file contains encrypted databases.])
|
||||
m4_tagend])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_lsn_reset, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
274
docs_src/env/env_open.so
vendored
Normal file
274
docs_src/env/env_open.so
vendored
Normal file
@@ -0,0 +1,274 @@
|
||||
m4_comment([$Id: env_open.so,v 10.114 2008/04/29 22:42:03 mbrey Exp $])
|
||||
|
||||
define(M4PAGELOCAL,
|
||||
[dbenv_open, dbenv_get_home, dbenv_get_open_flags, DB_CREATE,
|
||||
DB_INIT_CDB, DB_INIT_LOCK, DB_INIT_LOG, DB_INIT_MPOOL,
|
||||
DB_INIT_REP, DB_INIT_TXN, DB_LOCKDOWN, DB_PRIVATE, DB_RECOVER,
|
||||
DB_RECOVER_FATAL, DB_REGISTER, DB_SYSTEM_MEM, DB_THREAD,
|
||||
DB_VERSION_MISMATCH])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_open),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__open(DB_ENV *dbenv, char *db_home, u_int32_t flags, int mode);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_home(DB_ENV *dbenv, const char **homep);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_open_flags(DB_ENV *dbenv, u_int32_t *flagsp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::open(const char *db_home, u_int32_t flags, int mode);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_home(const char **homep);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_open_flags(u_int32_t *flagsp);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_open) opens a m4_db environment. It provides a
|
||||
structure for creating a consistent environment for processes using one
|
||||
or more of the features of m4_db.])
|
||||
|
||||
m4_return(dbenv_open, std,
|
||||
[If m4_ref(dbenv_open) fails, the m4_refT(dbenv_close) must be called
|
||||
to discard the m4_ref(DbEnv) handle.])
|
||||
|
||||
m4_parambegin
|
||||
m4_param_utf8(db_home, [dnl
|
||||
The m4_arg(db_home) parameter is the database environment's home
|
||||
directory. For more information on m4_arg(db_home), and filename
|
||||
resolution in general, see m4_link(M4RELDIR/ref/env/naming, [m4_db File
|
||||
Naming]). The environment variable m4_envvar(DB_HOME) may be used as
|
||||
the path of the database home, as described in
|
||||
m4_link(M4RELDIR/ref/env/naming, [m4_db File Naming]).])
|
||||
|
||||
m4_param(flags, [dnl
|
||||
The m4_arg(flags) parameter specifies the subsystems that are initialized
|
||||
and how the application's environment affects m4_db file naming, among
|
||||
other things.
|
||||
|
||||
m4_sf_or_may
|
||||
|
||||
m4_p([dnl
|
||||
Because there are a large number of flags that can be specified, they
|
||||
have been grouped together by functionality. The first group of flags
|
||||
indicates which of the m4_db subsystems should be initialized.])
|
||||
|
||||
m4_p([dnl
|
||||
The choice of subsystems initialized for a m4_db database environment
|
||||
is specified by the thread of control initially creating the
|
||||
environment. Any subsequent thread of control joining the environment
|
||||
will automatically be configured to use the same subsystems as were
|
||||
created in the environment (unless the thread of control requests a
|
||||
subsystem not available in the environment, which will fail).
|
||||
Applications joining an environment, able to adapt to whatever
|
||||
subsystems have been configured in the environment, should open the
|
||||
environment without specifying any subsystem flags. Applications
|
||||
joining an environment, requiring specific subsystems from their
|
||||
environments, should open the environment specifying those specific
|
||||
subsystem flags.])
|
||||
|
||||
m4_tagbegin
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_CDB), [dnl
|
||||
Initialize locking for the m4_link(M4RELDIR/ref/cam/intro, m4_cam)
|
||||
product. In this mode, m4_db provides multiple reader/single writer
|
||||
access. The only other subsystem that should be specified with the
|
||||
m4_ref(DB_INIT_CDB) flag is m4_ref(DB_INIT_MPOOL).])
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_LOCK), [dnl
|
||||
Initialize the locking subsystem. This subsystem should be used when
|
||||
multiple processes or threads are going to be reading and writing a
|
||||
m4_db database, so that they do not interfere with each other. If all
|
||||
threads are accessing the database(s) read-only, locking is unnecessary.
|
||||
When the m4_ref(DB_INIT_LOCK) flag is specified, it is usually necessary
|
||||
to run a deadlock detector, as well. See m4_ref(db_deadlock) and
|
||||
m4_ref(lock_detect) for more information.])
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_LOG), [dnl
|
||||
Initialize the logging subsystem. This subsystem should be used when
|
||||
recovery from application or system failure is necessary. If the log
|
||||
region is being created and log files are already present, the log files
|
||||
are reviewed; subsequent log writes are appended to the end of the log,
|
||||
rather than overwriting current log entries.])
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_MPOOL), [dnl
|
||||
Initialize the shared memory buffer pool subsystem. This subsystem
|
||||
should be used whenever an application is using any m4_db access
|
||||
method.])
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_REP), [dnl
|
||||
Initialize the replication subsystem. This subsystem
|
||||
should be used whenever an application plans on using replication.
|
||||
The m4_ref(DB_INIT_REP) flag requires the m4_ref(DB_INIT_TXN) and
|
||||
m4_ref(DB_INIT_LOCK) flags also be configured.])
|
||||
|
||||
m4_tag(m4_idef(DB_INIT_TXN), [dnl
|
||||
Initialize the transaction subsystem. This subsystem should be used
|
||||
when recovery and atomicity of multiple operations are important. The
|
||||
m4_ref(DB_INIT_TXN) flag implies the m4_ref(DB_INIT_LOG) flag.])
|
||||
|
||||
m4_tagend
|
||||
|
||||
m4_p([dnl
|
||||
The second group of flags govern what recovery, if any, is performed when
|
||||
the environment is initialized:])
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_RECOVER), [dnl
|
||||
Run normal recovery on this environment before opening it for normal
|
||||
use. If this flag is set, the m4_ref(DB_CREATE) and m4_ref(DB_INIT_TXN)
|
||||
flags must also be set, because the regions will be removed and
|
||||
re-created, and transactions are required for application recovery.])
|
||||
|
||||
m4_tag(m4_idef(DB_RECOVER_FATAL), [dnl
|
||||
Run catastrophic recovery on this environment before opening it for
|
||||
normal use. If this flag is set, the m4_ref(DB_CREATE) and
|
||||
m4_ref(DB_INIT_TXN) flags must also be set, because the regions will be
|
||||
removed and re-created, and transactions are required for application
|
||||
recovery.])
|
||||
|
||||
|
||||
m4_tagend
|
||||
|
||||
m4_p([dnl
|
||||
A standard part of the recovery process is to remove the existing m4_db
|
||||
environment and create a new one in which to perform recovery. If the
|
||||
thread of control performing recovery does not specify the correct
|
||||
region initialization information (for example, the correct memory pool
|
||||
cache size), the result can be an application running in an environment
|
||||
with incorrect cache and other subsystem sizes. For this reason, the
|
||||
thread of control performing recovery should specify correct
|
||||
configuration information before calling the m4_refT(dbenv_open); or it
|
||||
should remove the environment after recovery is completed, leaving
|
||||
creation of the correctly sized environment to a subsequent call to
|
||||
m4_ref(dbenv_open).])
|
||||
|
||||
m4_p([dnl
|
||||
All m4_db recovery processing must be single-threaded; that is, only a
|
||||
single thread of control may perform recovery or access a m4_db
|
||||
environment while recovery is being performed. Because it is not an
|
||||
error to specify m4_ref(DB_RECOVER) for an environment for which no
|
||||
recovery is required, it is reasonable programming practice for the
|
||||
thread of control responsible for performing recovery and creating the
|
||||
environment to always specify the m4_ref(DB_CREATE) and
|
||||
m4_ref(DB_RECOVER) flags during startup.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_open) function returns successfully if m4_ref(DB_RECOVER)
|
||||
or m4_ref(DB_RECOVER_FATAL) is specified and no log files exist, so it
|
||||
is necessary to ensure that all necessary log files are present before
|
||||
running recovery. For further information, consult m4_ref(db_archive)
|
||||
and m4_ref(db_recover).])
|
||||
|
||||
m4_p([dnl
|
||||
The third group of flags govern file-naming extensions in the environment:])
|
||||
|
||||
m4_tagbegin
|
||||
m4_env_flags
|
||||
m4_tagend
|
||||
|
||||
m4_p([Finally, there are a few additional unrelated flags:])
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_CREATE), [dnl
|
||||
Cause m4_db subsystems to create any underlying files, as necessary.])
|
||||
|
||||
m4_tag(m4_idef(DB_LOCKDOWN), [dnl
|
||||
Lock shared m4_db environment files and memory-mapped databases into
|
||||
memory.])
|
||||
|
||||
m4_tag(m4_idef(DB_PRIVATE), [dnl
|
||||
Allocate region memory from the heap instead of from memory backed by
|
||||
the filesystem or system shared memory.
|
||||
m4_p([dnl
|
||||
This flag implies the environment will only be accessed by a single
|
||||
process (although that process may be multithreaded). This flag has two
|
||||
effects on the m4_db environment. First, all underlying data structures
|
||||
are allocated from per-process memory instead of from shared memory that
|
||||
is accessible to more than a single process. Second, mutexes are only
|
||||
configured to work between threads.])
|
||||
m4_p([dnl
|
||||
This flag should not be specified if more than a single process is
|
||||
accessing the environment because it is likely to cause database
|
||||
corruption and unpredictable behavior. For example, if both a server
|
||||
application and m4_db utilities (for example, m4_ref(db_archive),
|
||||
m4_ref(db_checkpoint) or m4_ref(db_stat)) are expected to access the
|
||||
environment, the m4_ref(DB_PRIVATE) flag should not be specified.])
|
||||
m4_p([dnl
|
||||
See m4_link(M4RELDIR/ref/env/region, [Shared Memory Regions]) for more
|
||||
information.])])
|
||||
|
||||
m4_tag(m4_idef(DB_REGISTER), [dnl
|
||||
Check to see if recovery needs to be performed before opening the
|
||||
database environment. (For this check to be accurate, all processes
|
||||
using the environment must specify m4_ref(DB_REGISTER) when opening the
|
||||
environment.) If recovery needs to be performed for any reason
|
||||
(including the initial use of the m4_ref(DB_REGISTER) flag), and
|
||||
m4_ref(DB_RECOVER) is also specified, recovery will be performed and the
|
||||
open will proceed normally. If recovery needs to be performed and
|
||||
m4_ref(DB_RECOVER) is not specified, m4_ref(DB_RUNRECOVERY) will be
|
||||
returned. If recovery does not need to be performed, the
|
||||
m4_ref(DB_RECOVER) flag will be ignored. See
|
||||
m4_link(M4RELDIR/ref/transapp/app, Architecting Transactional Data Store
|
||||
applications) for more information.])
|
||||
|
||||
m4_tag(m4_idef(DB_SYSTEM_MEM), [dnl
|
||||
Allocate region memory from system shared memory instead of from heap
|
||||
memory or memory backed by the filesystem.
|
||||
m4_p([dnl
|
||||
See m4_link(M4RELDIR/ref/env/region, [Shared Memory Regions]) for more
|
||||
information.])])
|
||||
|
||||
m4_tag(m4_idef(DB_THREAD), [dnl
|
||||
Cause the m4_ref(DbEnv) handle returned by m4_ref(dbenv_open) to be
|
||||
m4_italic(free-threaded); that is, concurrently usable by multiple
|
||||
threads in the address space. The DB_THREAD flag should be specified
|
||||
if the m4_ref(DbEnv) handle will be concurrently used by more than one
|
||||
thread in the process, or if any m4_ref(Db) handles opened in the scope
|
||||
of the m4_ref(DbEnv) handle will be concurrently used by more than one
|
||||
thread in the process.
|
||||
m4_p([dnl
|
||||
This flag is required when using the Replication Manager.])])
|
||||
|
||||
m4_tagend])
|
||||
|
||||
m4_param_filemode([m4_db])
|
||||
m4_paramend
|
||||
|
||||
m4_idefz(DB_VERSION_MISMATCH)
|
||||
m4_err(dbenv_open,
|
||||
DB_RUNRECOVERY,
|
||||
[The DB_REGISTER flag was specified, a failure has occurred, and no
|
||||
recovery flag was specified.],
|
||||
DB_VERSION_MISMATCH,
|
||||
[The version of the m4_db library doesn't match the version that created
|
||||
the database environment.],
|
||||
regionagain, einval,
|
||||
[the m4_ref(DB_THREAD) flag was specified and fast mutexes are not
|
||||
available for this architecture;
|
||||
The DB_HOME or TMPDIR environment variables were set, but empty;
|
||||
An incorrectly formatted m4_bold([NAME VALUE]) entry or line was found],
|
||||
ENOSPC,
|
||||
[HP-UX only:
|
||||
Due to the constraints of the PA-RISC memory architecture, HP-UX does not
|
||||
allow a process to map a file into its address space multiple times.
|
||||
For this reason, each m4_db environment may be opened only once by a
|
||||
process on HP-UX; that is, calls to m4_ref(dbenv_open) will fail if the
|
||||
specified m4_db environment has been opened and not subsequently closed.],
|
||||
filenotfound)
|
||||
|
||||
m4_pf_getter(dbenv_get_home,
|
||||
database environment home directory, homep,, reference)
|
||||
|
||||
m4_pf_getter(dbenv_get_open_flags,
|
||||
open method flags originally used to create the database environment,, flagsp)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
95
docs_src/env/env_remove.so
vendored
Normal file
95
docs_src/env/env_remove.so
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
m4_comment([$Id: env_remove.so,v 10.45 2006/12/08 16:22:45 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, dbenv_remove)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_remove),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__remove(DB_ENV *dbenv, char *db_home, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::remove(const char *db_home, u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_remove) destroys a m4_db environment if it is not
|
||||
currently in use. The environment regions, including any backing files,
|
||||
are removed. Any log or database files and the environment directory are
|
||||
not removed.])
|
||||
|
||||
m4_p([dnl
|
||||
If there are processes that have called m4_ref(dbenv_open) without
|
||||
calling m4_ref(dbenv_close) (that is, there are processes currently
|
||||
using the environment), m4_ref(dbenv_remove) will fail without further
|
||||
action unless the m4_ref(DB_FORCE) flag is set, in which case
|
||||
m4_ref(dbenv_remove) will attempt to remove the environment, regardless
|
||||
of any processes still using it.])
|
||||
|
||||
m4_p([dnl
|
||||
The result of attempting to forcibly destroy the environment when it is
|
||||
in use is unspecified. Processes using an environment often maintain open
|
||||
file descriptors for shared regions within it. On UNIX systems, the
|
||||
environment removal will usually succeed, and processes that have already
|
||||
joined the region will continue to run in that region without change.
|
||||
However, processes attempting to join the environment will either fail
|
||||
or create new regions. On other systems in which the m4_manref(unlink,
|
||||
2) system call will fail if any process has an open file descriptor for
|
||||
the file (for example Windows/NT), the region removal will fail.])
|
||||
|
||||
m4_p([dnl
|
||||
Calling m4_ref(dbenv_remove) should not be necessary for most applications
|
||||
because the m4_db environment is cleaned up as part of normal database
|
||||
recovery procedures. However, applications may want to call
|
||||
m4_ref(dbenv_remove) as part of application shut down to free up system
|
||||
resources. For example, if the m4_ref(DB_SYSTEM_MEM) flag was specified
|
||||
to m4_ref(dbenv_open), it may be useful to call m4_ref(dbenv_remove) in
|
||||
order to release system shared memory segments that have been allocated.
|
||||
Or, on architectures in which mutexes require allocation of underlying
|
||||
system resources, it may be useful to call m4_ref(dbenv_remove) in order
|
||||
to release those resources. Alternatively, if recovery is not required
|
||||
because no database state is maintained across failures, and no system
|
||||
resources need to be released, it is possible to clean up an environment
|
||||
by simply removing all the m4_db files in the database environment's
|
||||
directories.])
|
||||
|
||||
m4_p([dnl
|
||||
In multithreaded applications, only a single thread may call
|
||||
m4_ref(dbenv_remove).])
|
||||
|
||||
m4_p([dnl
|
||||
A m4_ref(DbEnv) handle that has already been used to open an environment
|
||||
should not be used to call the m4_refT(dbenv_remove); a new
|
||||
m4_ref(DbEnv) handle should be created for that purpose.])
|
||||
|
||||
m4_p([dnl
|
||||
After m4_ref(dbenv_remove) has been called, regardless of its return,
|
||||
the m4_db environment handle may not be accessed again.])
|
||||
|
||||
m4_return(dbenv_remove, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param_utf8(db_home, [dnl
|
||||
The m4_arg(db_home) parameter names the database environment to be removed.])
|
||||
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_or_may
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_FORCE), [dnl
|
||||
If the m4_ref(DB_FORCE) flag is set, the environment is removed, regardless
|
||||
of any processes that may still using it, and no locks are acquired
|
||||
during this process. (Generally, the m4_ref(DB_FORCE) flag is
|
||||
specified only when applications were unable to shut down cleanly, and there
|
||||
is a risk that an application may have died holding a m4_db lock.)])
|
||||
|
||||
m4_env_flags
|
||||
m4_tagend])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_remove,
|
||||
EBUSY, [The shared memory region was in use and the force flag was not set.])
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
124
docs_src/env/env_set_alloc.so
vendored
Normal file
124
docs_src/env/env_set_alloc.so
vendored
Normal file
@@ -0,0 +1,124 @@
|
||||
m4_comment([$Id: env_set_alloc.so,v 1.24 2008/01/19 14:12:57 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_alloc)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_alloc, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_alloc),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_alloc(DB_ENV *dbenv,
|
||||
void *(*app_malloc)(size_t),
|
||||
void *(*app_realloc)(void *, size_t),
|
||||
void (*app_free)(void *));
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
extern "C" {
|
||||
typedef void *(*db_malloc_fcn_type)(size_t);
|
||||
typedef void *(*db_realloc_fcn_type)(void *, size_t);
|
||||
typedef void *(*db_free_fcn_type)(void *);
|
||||
};
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::set_alloc(db_malloc_fcn_type app_malloc,
|
||||
db_realloc_fcn_type app_realloc,
|
||||
db_free_fcn_type app_free);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_alloc),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__set_alloc(DB *db,
|
||||
void *(*app_malloc)(size_t),
|
||||
void *(*app_realloc)(void *, size_t),
|
||||
void (*app_free)(void *));
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
extern "C" {
|
||||
typedef void *(*db_malloc_fcn_type)(size_t);
|
||||
typedef void *(*db_realloc_fcn_type)(void *, size_t);
|
||||
typedef void *(*db_free_fcn_type)(void *);
|
||||
};
|
||||
m4_blank
|
||||
int
|
||||
Db::set_alloc(db_malloc_fcn_type app_malloc,
|
||||
db_realloc_fcn_type app_realloc,
|
||||
db_free_fcn_type app_free);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
Set the allocation functions used by the m4_ref(DbEnv) and m4_ref(Db)
|
||||
methods to allocate or free memory owned by the application.])
|
||||
|
||||
m4_p([dnl
|
||||
There are a number of interfaces in m4_db where memory is allocated by
|
||||
the library and then given to the application. For example, the
|
||||
m4_ref(DB_DBT_MALLOC) flag, when specified in the m4_ref(Dbt) object,
|
||||
will cause the m4_ref(Db) methods to allocate and reallocate memory
|
||||
which then becomes the responsibility of the calling application. (See
|
||||
m4_ref(Dbt) for more information.) Other examples are the m4_db
|
||||
interfaces which return statistical information to the application:
|
||||
m4_ref(dbh_stat), m4_ref(lock_stat), m4_ref(log_archive),
|
||||
m4_ref(log_stat), m4_ref(memp_stat), and m4_ref(txn_stat). There is one
|
||||
method in m4_db where memory is allocated by the application and then
|
||||
given to the library: m4_ref(dbh_associate).])
|
||||
|
||||
m4_p([dnl
|
||||
On systems in which there may be multiple library versions of the
|
||||
standard allocation routines (notably Windows NT), transferring memory
|
||||
between the library and the application will fail because the m4_db
|
||||
library allocates memory from a different heap than the application uses
|
||||
to free it. To avoid this problem, the m4_ref(dbenv_set_alloc) and
|
||||
m4_refT(dbh_set_alloc)s can be used to pass m4_db references to the
|
||||
application's allocation routines.])
|
||||
|
||||
m4_p([dnl
|
||||
It is not an error to specify only one or two of the possible allocation
|
||||
function parameters to these interfaces; however, in that case the
|
||||
specified interfaces must be compatible with the standard library
|
||||
interfaces, as they will be used together. The functions specified must
|
||||
match the calling conventions of the m4_ansic_name library routines of
|
||||
the same name.])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_alloc, [dnl
|
||||
m4_scope_dbenv(dbenv_set_alloc)
|
||||
|
||||
m4_when_envopen(dbenv_set_alloc)
|
||||
|
||||
m4_return(dbenv_set_alloc, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(app_malloc, [dnl
|
||||
The m4_arg(app_malloc) parameter is the application-specified malloc
|
||||
function.])
|
||||
m4_param(app_realloc, [dnl
|
||||
The m4_arg(app_realloc) parameter is the application-specified realloc
|
||||
function.])
|
||||
m4_param(app_free, [dnl
|
||||
The m4_arg(app_free) parameter is the application-specified free function.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_alloc,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
],[dnl
|
||||
m4_p([dnl
|
||||
Because databases opened within m4_db environments use the allocation
|
||||
interfaces specified to the environment, it is an error to attempt to
|
||||
set those interfaces in a database created within an environment.])
|
||||
|
||||
m4_when_dbopen(dbh_set_alloc)
|
||||
|
||||
m4_return(dbh_set_alloc, std)
|
||||
|
||||
m4_err(dbh_set_alloc,
|
||||
einval, [dnl
|
||||
called in a database environment, or called after m4_ref(dbh_open) was
|
||||
called])
|
||||
|
||||
m4_seealso(Db)
|
||||
])
|
||||
|
||||
m4_page_footer
|
||||
105
docs_src/env/env_set_app_dispatch.so
vendored
Normal file
105
docs_src/env/env_set_app_dispatch.so
vendored
Normal file
@@ -0,0 +1,105 @@
|
||||
m4_comment([$Id: env_set_app_dispatch.so,v 10.54 2004/08/13 03:38:57 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL,
|
||||
[dbenv_set_app_dispatch, DB_TXN_BACKWARD_ROLL, DB_TXN_FORWARD_ROLL,
|
||||
DB_TXN_ABORT, DB_TXN_APPLY, DB_TXN_PRINT])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_app_dispatch),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_app_dispatch(DB_ENV *dbenv,
|
||||
int (*tx_recover)(DB_ENV *dbenv,
|
||||
DBT *log_rec, DB_LSN *lsn, db_recops op));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_app_dispatch(int (*tx_recover)(DbEnv *dbenv,
|
||||
Dbt *log_rec, DbLsn *lsn, db_recops op));
|
||||
]))
|
||||
|
||||
define(__appDispatch_param, [dnl
|
||||
ifelse([$1], internal, [dnl
|
||||
The m4_arg(tx_recover) parameter is the application's abort and recovery
|
||||
function. The function takes four parameters:
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment handle.])
|
||||
m4_tag(m4_arg(log_rec), [dnl
|
||||
The m4_arg(log_rec) parameter is a log record.])
|
||||
m4_tag(m4_arg(lsn), [dnl
|
||||
The m4_arg(lsn) parameter is a log sequence number.])
|
||||
m4_tag(m4_arg(op), [dnl
|
||||
The m4_arg(op) parameter is one of the following values:])],[dnl
|
||||
m4_parambegin
|
||||
m4_param(dbenv, [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment handle.])
|
||||
m4_param(log_rec, [dnl
|
||||
The m4_arg(log_rec) parameter is a log record.])
|
||||
m4_param(lsn, [dnl
|
||||
The m4_arg(lsn) parameter is a log sequence number.])
|
||||
m4_param(op, [dnl
|
||||
The m4_arg(op) parameter is one of the following values:])])
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_TXN_BACKWARD_ROLL), [dnl
|
||||
The log is being read backward to determine which transactions have been
|
||||
committed and to abort those operations that were not; undo the operation
|
||||
described by the log record.])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_FORWARD_ROLL), [dnl
|
||||
The log is being played forward; redo the operation described by the log
|
||||
record.])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_ABORT), [dnl
|
||||
The log is being read backward during a transaction abort; undo the
|
||||
operation described by the log record.])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_APPLY), [dnl
|
||||
The log is being applied on a replica site; redo the operation
|
||||
described by the log record.])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_PRINT), [dnl
|
||||
The log is being printed for debugging purposes; print the contents of
|
||||
this log record in the desired format.])
|
||||
m4_tagend
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(DB_TXN_FORWARD_ROLL) and m4_ref(DB_TXN_APPLY) operations
|
||||
frequently imply the same actions, redoing changes that appear in the
|
||||
log record, although if a recovery function is to be used on a
|
||||
replication client where reads may be taking place concurrently with the
|
||||
processing of incoming messages, m4_ref(DB_TXN_APPLY) operations should
|
||||
also perform appropriate locking. The macro DB_REDO(op) checks that the
|
||||
operation is one of m4_ref(DB_TXN_FORWARD_ROLL) or m4_ref(DB_TXN_APPLY),
|
||||
and should be used in the recovery code to refer to the conditions under
|
||||
which operations should be redone. Similarly, the macro DB_UNDO(op)
|
||||
checks if the operation is one of m4_ref(DB_TXN_BACKWARD_ROLL) or
|
||||
m4_ref(DB_TXN_ABORT).])
|
||||
ifelse([$1], internal, [m4_tagend], [m4_paramend])])
|
||||
|
||||
define(__appDispatch_return, [dnl
|
||||
The function must return 0 on success and either m4_envvar(errno) or a
|
||||
value outside of the m4_db error name space on failure.])
|
||||
|
||||
m4_p([dnl
|
||||
Declare a function to be called during transaction abort and recovery
|
||||
to process application-specific log records.])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_app_dispatch)
|
||||
|
||||
m4_when_envopen(dbenv_set_app_dispatch, corrupt)
|
||||
|
||||
m4_return(dbenv_set_app_dispatch, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(tx_recover, [dnl
|
||||
__appDispatch_param(internal)
|
||||
m4_p([__appDispatch_return])])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_app_dispatch,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_seealso(DbTxn)
|
||||
m4_page_footer
|
||||
131
docs_src/env/env_set_cachesize.so
vendored
Normal file
131
docs_src/env/env_set_cachesize.so
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
m4_comment([$Id: env_set_cachesize.so,v 10.51 2007/07/06 00:22:52 mjc Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_cachesize)])
|
||||
define(M4GETINTERFACE, ifelse(M4INTERFACE,
|
||||
dbenv_set_cachesize, dbenv_get_cachesize, dbh_get_cachesize))
|
||||
|
||||
define(M4PAGELOCAL, [M4INTERFACE, M4GETINTERFACE, dbenv_get_cachesize_ncache])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_cachesize, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_cachesize),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_cachesize(DB_ENV *dbenv,
|
||||
u_int32_t gbytes, u_int32_t bytes, int ncache);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_cachesize(DB_ENV *dbenv,
|
||||
u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_cachesize(u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_cachesize),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__set_cachesize(DB *db,
|
||||
u_int32_t gbytes, u_int32_t bytes, int ncache);
|
||||
m4_blank
|
||||
int
|
||||
DB-__GT__get_cachesize(DB *db,
|
||||
u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
Db::set_cachesize(u_int32_t gbytes, u_int32_t bytes, int ncache);
|
||||
int
|
||||
Db::get_cachesize(u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
Set the size of the shared memory buffer pool -- that is, the cache.
|
||||
The cache should be the size of the normal working data set of the
|
||||
application, with some small amount of additional memory for unusual
|
||||
situations. (Note: the working set is not the same as the number of
|
||||
pages accessed simultaneously, and is usually much larger.)])
|
||||
|
||||
m4_p([dnl
|
||||
The default cache size is 256KB, and may not be specified as less than
|
||||
20KB. Any cache size less than 500MB is automatically increased by 25%
|
||||
to account for buffer pool overhead; cache sizes larger than 500MB are
|
||||
used as specified. The maximum size of a single cache is 4GB on 32-bit
|
||||
systems and 10TB on 64-bit systems. (All sizes are in powers-of-two,
|
||||
that is, 256KB is 2^18 not 256,000.) For information on tuning the m4_db
|
||||
cache size, see m4_link(M4RELDIR/ref/am_conf/cachesize, [Selecting a
|
||||
cache size]).])
|
||||
|
||||
m4_p([dnl
|
||||
It is possible to specify caches to m4_db large enough they cannot be
|
||||
allocated contiguously on some architectures. For example, some
|
||||
releases of Solaris limit the amount of memory that may be allocated
|
||||
contiguously by a process. If m4_arg(ncache) is 0 or 1, the cache will
|
||||
be allocated contiguously in memory. If it is greater than 1, the cache
|
||||
will be split across m4_arg(ncache) separate regions, where the
|
||||
m4_bold(region size) is equal to the initial cache size divided by
|
||||
m4_arg(ncache).])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_cachesize, [dnl
|
||||
m4_p([dnl
|
||||
The memory pool may be resized by calling m4_ref(dbenv_set_cachesize)
|
||||
after the environment is open. The supplied size will be rounded to
|
||||
the nearest multiple of the region size and may not be larger than the
|
||||
maximum size configured with m4_ref(dbenv_set_cache_max). The
|
||||
m4_arg(ncache) parameter is ignored when resizing the cache.])])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_cachesize, [dnl
|
||||
m4_env_config(dbenv_set_cachesize, [initial cache size], set_cachesize,
|
||||
[the initial cache size specified in three parts: the gigabytes of
|
||||
cache, the additional bytes of cache, and the number of caches, also
|
||||
separated by whitespace characters. For example, "set_cachesize 2
|
||||
524288000 3" would create a 2.5GB logical cache, split between three
|
||||
physical caches])
|
||||
|
||||
m4_scope_env(dbenv_set_cachesize)
|
||||
m4_when_any(dbenv_set_cachesize)
|
||||
m4_return(dbenv_set_cachesize, std)
|
||||
],[dnl
|
||||
m4_p([dnl
|
||||
Because databases opened within m4_db environments use the cache
|
||||
specified to the environment, it is an error to attempt to set a cache
|
||||
in a database created within an environment.])
|
||||
|
||||
m4_when_dbopen(dbh_set_cachesize)
|
||||
|
||||
m4_return(dbh_set_cachesize, std)])
|
||||
|
||||
m4_parambegin
|
||||
m4_param(bytes, [dnl
|
||||
The size of the cache is set to m4_arg(gbytes) gigabytes plus m4_arg(bytes).])
|
||||
m4_param(gbytes, [dnl
|
||||
The size of the cache is set to m4_arg(gbytes) gigabytes plus m4_arg(bytes).])
|
||||
m4_param(ncache, [dnl
|
||||
The m4_arg(ncache) parameter is the number of caches to create.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(M4INTERFACE, einval,
|
||||
[the specified cache size was impossibly small;
|
||||
ifelse(M4INTERFACE, dbh_set_cachesize, [the method was called after
|
||||
m4_ref(dbh_open) was called])])
|
||||
|
||||
m4_pf_description(m4_ref(M4GETINTERFACE))
|
||||
m4_p([dnl
|
||||
The m4_refT(M4GETINTERFACE) returns the current size and composition of the
|
||||
cache.])
|
||||
|
||||
m4_when_any(M4GETINTERFACE)
|
||||
|
||||
m4_return(M4GETINTERFACE, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param_co(bytesp, additional bytes of memory in the cache)
|
||||
m4_param_co(gbytesp, gigabytes of memory in the cache)
|
||||
m4_param_co(ncachep, number of caches)
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_cachesize, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
59
docs_src/env/env_set_data_dir.so
vendored
Normal file
59
docs_src/env/env_set_data_dir.so
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
m4_comment([$Id: env_set_data_dir.so,v 10.28 2004/09/28 15:04:20 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_data_dir, dbenv_get_data_dirs])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_data_dir),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_data_dir(DB_ENV *dbenv, const char *dir);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_data_dirs(DB_ENV *dbenv, const char ***dirpp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_data_dir(const char *dir);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_data_dirs(const char ***dirpp);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Set the path of a directory to be used as the location of the access
|
||||
method database files. Paths specified to the m4_ref(dbh_open) function
|
||||
will be searched relative to this path. Paths set using this method
|
||||
are additive, and specifying more than one will result in each specified
|
||||
directory being searched for database files. If any directories are
|
||||
specified, created database files will always be created in the first
|
||||
path specified.])
|
||||
|
||||
m4_p([dnl
|
||||
If no database directories are specified, database files must be named
|
||||
either by absolute paths or relative to the environment home directory.
|
||||
See m4_link(M4RELDIR/ref/env/naming, [m4_db File Naming]) for more
|
||||
information.])
|
||||
|
||||
m4_env_config(dbenv_set_data_dir,
|
||||
data directories, set_data_dir, the directory name, no)
|
||||
|
||||
m4_scope_dbenv(dbenv_set_data_dir)
|
||||
|
||||
m4_when_envopen(dbenv_set_data_dir, corrupt)
|
||||
|
||||
m4_return(dbenv_set_data_dir, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param_utf8(dir, [dnl
|
||||
The m4_arg(dir) parameter is a directory to be used as a location for
|
||||
database files.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_data_dir,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_pf_getter(dbenv_get_data_dirs,
|
||||
NULL-terminated array of directories,, dirpp, reference)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
84
docs_src/env/env_set_encrypt.so
vendored
Normal file
84
docs_src/env/env_set_encrypt.so
vendored
Normal file
@@ -0,0 +1,84 @@
|
||||
m4_comment([$Id: env_set_encrypt.so,v 10.23 2004/09/28 15:04:20 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_encrypt)])
|
||||
define(M4GETINTERFACE, ifelse(M4INTERFACE,
|
||||
dbenv_set_encrypt, dbenv_get_encrypt_flags, dbh_get_encrypt_flags))
|
||||
|
||||
define(M4PAGELOCAL, [M4INTERFACE, M4GETINTERFACE])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_encrypt, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_encrypt),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_encrypt(DB_ENV *dbenv, const char *passwd, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_encrypt_flags(DB_ENV *dbenv, u_int32_t *flagsp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_encrypt(const char *passwd, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_encrypt_flags(u_int32_t *flagsp);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_encrypt),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__set_encrypt(DB *db, const char *passwd, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
DB-__GT__get_encrypt_flags(DB *db, u_int32_t *flagsp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
Db::set_encrypt(const char *passwd, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
Db::get_encrypt_flags(u_int32_t *flagsp);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
Set the password used by the m4_db library to perform encryption and
|
||||
decryption.])
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_encrypt, [dnl
|
||||
m4_scope_env(dbenv_set_encrypt)
|
||||
m4_when_envopen(dbenv_set_encrypt, error)
|
||||
m4_return(dbenv_set_encrypt, std)
|
||||
],[dnl
|
||||
m4_p([dnl
|
||||
Because databases opened within m4_db environments use the password
|
||||
specified to the environment, it is an error to attempt to set a
|
||||
password in a database created within an environment.])
|
||||
m4_when_dbopen(dbh_set_encrypt)
|
||||
m4_return(dbh_set_encrypt, std)
|
||||
])
|
||||
|
||||
m4_parambegin
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_ENCRYPT_AES), [dnl
|
||||
Use the Rijndael/AES (also known as the Advanced Encryption Standard
|
||||
and Federal Information Processing Standard (FIPS) 197) algorithm for
|
||||
encryption or decryption.])
|
||||
m4_tagend])
|
||||
|
||||
m4_param(passwd, [dnl
|
||||
The m4_arg(passwd) parameter is the password used to perform encryption
|
||||
and decryption.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(M4INTERFACE, einval,
|
||||
[the method was called after
|
||||
m4_ref(ifelse(M4INTERFACE, dbenv_set_encrypt, [dbenv_open], [dbh_open]))
|
||||
was called],
|
||||
EOPNOTSUPP, [Cryptography is not available in this m4_db release.])
|
||||
|
||||
m4_pf_getter(M4GETINTERFACE, encryption flags,, flagsp)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_encrypt, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
121
docs_src/env/env_set_errcall.so
vendored
Normal file
121
docs_src/env/env_set_errcall.so
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
m4_comment([$Id: env_set_errcall.so,v 10.39 2006/05/17 20:47:46 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_errcall)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errcall, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_errcall),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__set_errcall(DB_ENV *dbenv, void (*db_errcall_fcn)
|
||||
(const DB_ENV *dbenv, const char *errpfx, const char *msg));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void DbEnv::set_errcall(void (*db_errcall_fcn)
|
||||
(const Dbenv *dbenv, const char *errpfx, const char *msg));
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_errcall),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__set_errcall(DB *, void (*db_errcall_fcn)
|
||||
(const DB_ENV *dbenv, const char *errpfx, const char *msg));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_errcall(void (*db_errcall_fcn)
|
||||
(const DbEnv *dbenv, const char *errpfx, const char *msg));
|
||||
]))])
|
||||
|
||||
define(__error_param, [dnl
|
||||
ifelse([$1], internal, [dnl
|
||||
The m4_arg(db_errcall_fcn) parameter is the application-specified error
|
||||
reporting function. The function takes three parameters:
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment.])
|
||||
m4_tag(m4_arg(errpfx), [dnl
|
||||
The m4_arg(errpfx) parameter is the prefix string (as previously set by
|
||||
m4_ref(dbh_set_errpfx) or m4_ref(dbenv_set_errpfx)).])
|
||||
m4_tag(m4_arg(msg), [dnl
|
||||
The m4_arg(msg) parameter is the error message string.])
|
||||
m4_tagend
|
||||
],[dnl
|
||||
m4_parambegin
|
||||
m4_param(dbenv, [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment.])
|
||||
m4_param(errpfx, [dnl
|
||||
The m4_arg(prefix) parameter is the prefix string (as previously set by
|
||||
m4_ref(dbh_set_errpfx) or m4_ref(dbenv_set_errpfx)).])
|
||||
m4_param(msg, [dnl
|
||||
The m4_arg(msg) parameter is the error message string.])
|
||||
m4_paramend])])
|
||||
|
||||
ifelse(M4API, C_API, [m4_p([dnl
|
||||
When an error occurs in the m4_db library, a m4_db error or an error
|
||||
return value is returned by the interface. In some cases, however,
|
||||
the m4_envvar(errno) value may be insufficient to completely describe
|
||||
the cause of the error, especially during initial application debugging.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_errcall) and m4_refT(dbh_set_errcall)s are used to
|
||||
enhance the mechanism for reporting error messages to the application.
|
||||
In some cases, when an error occurs, m4_db will call
|
||||
m4_arg(db_errcall_fcn) with additional error information. It is up to
|
||||
the m4_arg(db_errcall_fcn) function to display the error message in an
|
||||
appropriate manner.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(db_errcall_fcn) to NULL unconfigures the callback interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbh_set_errfile) or
|
||||
m4_refT(dbenv_set_errfile)s to display the additional information via
|
||||
a C library FILE *.])])
|
||||
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
When an error occurs in the m4_db library, an exception is thrown or an
|
||||
error return value is returned by the interface. In some cases,
|
||||
however, the m4_envvar(errno) value may be insufficient to completely
|
||||
describe the cause of the error, especially during initial application
|
||||
debugging.
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_errcall) and m4_refT(dbh_set_errcall)s are used to
|
||||
enhance the mechanism for reporting error messages to the application.
|
||||
In some cases, when an error occurs, m4_db will call
|
||||
m4_arg(db_errcall_fcn) with additional error information. It is up to
|
||||
the m4_arg(db_errcall_fcn) function to display the error message in an
|
||||
appropriate manner.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(db_errcall_fcn) to NULL unconfigures the callback interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_error_stream) and
|
||||
m4_refT(dbh_set_error_stream)s to display the additional information via
|
||||
an output stream, or the m4_ref(dbh_set_errfile) or
|
||||
m4_refT(dbenv_set_errfile)s to display the additional information via a C
|
||||
library FILE *. You should not mix these approaches.])])
|
||||
|
||||
m4_p([dnl
|
||||
This error-logging enhancement does not slow performance or significantly
|
||||
increase application size, and may be run during normal operation as well
|
||||
as during application debugging.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errcall, [dnl
|
||||
m4_really_dbenv(dbh_set_errcall, dbenv_set_errcall)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errcall,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(db_errcall_fcn, [dnl
|
||||
__error_param(internal)
|
||||
m4_not_reentrant])
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errcall, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
116
docs_src/env/env_set_errfile.so
vendored
Normal file
116
docs_src/env/env_set_errfile.so
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
m4_comment([$Id: env_set_errfile.so,v 10.37 2006/10/26 15:33:59 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_errfile)])
|
||||
define(M4GETINTERFACE, ifelse(M4INTERFACE,
|
||||
dbenv_set_errfile, dbenv_get_errfile, dbh_get_errfile))
|
||||
|
||||
define(M4PAGELOCAL, [M4INTERFACE, M4GETINTERFACE])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errfile, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_errfile),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__set_errfile(DB_ENV *dbenv, FILE *errfile);
|
||||
m4_blank
|
||||
void
|
||||
DB_ENV-__GT__get_errfile(DB_ENV *dbenv, FILE **errfilep);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void
|
||||
DbEnv::set_errfile(FILE *errfile);
|
||||
m4_blank
|
||||
void
|
||||
DbEnv::get_errfile(FILE **errfilep);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_errfile),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__set_errfile(DB *db, FILE *errfile);
|
||||
m4_blank
|
||||
void
|
||||
DB-__GT__get_errfile(DB *db, FILE **errfilep);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_errfile(FILE *errfile);
|
||||
m4_blank
|
||||
void Db::get_errfile(FILE **errfilep);
|
||||
]))])
|
||||
|
||||
ifelse(M4API, C_API, [dnl
|
||||
When an error occurs in the m4_db library, a m4_db error or an error
|
||||
return value is returned by the interface. In some cases, however, the
|
||||
return value may be insufficient to completely describe the cause of the
|
||||
error especially during initial application debugging.
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_errfile) and m4_refT(dbh_set_errfile)s are used to
|
||||
enhance the mechanism for reporting error messages to the application
|
||||
by setting a C library FILE * to be used for displaying additional m4_db
|
||||
error messages. In some cases, when an error occurs, m4_db will output
|
||||
an additional error message to the specified file reference.])])
|
||||
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
When an error occurs in the m4_db library, an exception is thrown or an
|
||||
error return value is returned by the interface. In some cases,
|
||||
however, the exception or returned value may be insufficient to
|
||||
completely describe the cause of the error, especially during initial
|
||||
application debugging.
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_errcall) and m4_refT(dbh_set_errcall)s are used to
|
||||
enhance the mechanism for reporting error messages to the application
|
||||
by setting a C library FILE * to be used for displaying additional m4_db
|
||||
error messages. In some cases, when an error occurs, m4_db will output
|
||||
an additional error message to the specified file reference.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_refT(dbenv_set_error_stream) to display
|
||||
the additional information via an output stream, or the
|
||||
m4_refT(dbenv_set_errcall) to capture the additional error information in
|
||||
a way that does not use either output streams or C library FILE *'s. You
|
||||
should not mix these approaches.])])
|
||||
|
||||
m4_p([dnl
|
||||
The error message will consist of the prefix string and a colon
|
||||
("m4_bold(:)") (if a prefix string was previously specified using
|
||||
m4_ref(dbh_set_errpfx) or m4_ref(dbenv_set_errpfx)), an error string, and
|
||||
a trailing m4_htmlquote(newline) character.])
|
||||
|
||||
m4_p([dnl
|
||||
The default configuration when applications first create m4_ref(Db) or
|
||||
m4_ref(DbEnv) handles is as if the m4_ref(dbenv_set_errfile) or
|
||||
m4_refT(dbh_set_errfile)s were called with the standard error output
|
||||
(stderr) specified as the FILE * argument. Applications wanting no
|
||||
output at all can turn off this default configuration by calling the
|
||||
m4_ref(dbenv_set_errfile) or m4_refT(dbh_set_errfile)s with NULL as the
|
||||
FILE * argument. Additionally, explicitly configuring the error output
|
||||
channel using any of the m4_ref(dbenv_set_errfile),
|
||||
m4_ref(dbh_set_errfile), m4_ref(dbenv_set_errcall),
|
||||
m4_ref(dbh_set_errcall), m4_ref(dbenv_set_error_stream) or
|
||||
m4_refT(dbh_set_error_stream)s will also turn off this default output
|
||||
for the application.])
|
||||
|
||||
m4_p([dnl
|
||||
This error logging enhancement does not slow performance or significantly
|
||||
increase application size, and may be run during normal operation as well
|
||||
as during application debugging.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errfile, [dnl
|
||||
m4_really_dbenv(dbh_set_errfile, dbenv_set_errfile)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errfile,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(errfile, [dnl
|
||||
The m4_arg(errfile) parameter is a C library FILE * to be used for
|
||||
displaying additional m4_db error information.])
|
||||
m4_paramend
|
||||
|
||||
m4_pf_getter(M4GETINTERFACE, FILE *,, errfilep)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errfile, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
70
docs_src/env/env_set_error_stream.so
vendored
Normal file
70
docs_src/env/env_set_error_stream.so
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
m4_comment([$Id: env_set_error_stream.so,v 10.30 2006/02/10 22:54:59 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_error_stream)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_error_stream, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_error_stream),
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void DbEnv::set_error_stream(class ostream*);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_error_stream),
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_error_stream(class ostream*);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
When an error occurs in the m4_db library, an exception is thrown or an
|
||||
m4_envvar(errno) value is returned by the interface. In some cases,
|
||||
however, the m4_envvar(errno) value may be insufficient to completely
|
||||
describe the cause of the error, especially during initial application
|
||||
debugging.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_error_stream) and m4_refT(dbh_set_error_stream)s
|
||||
are used to enhance the mechanism for reporting error messages to the
|
||||
application by setting the C++ ostream used for displaying additional
|
||||
m4_db error messages. In some cases, when an error occurs, m4_db will
|
||||
output an additional error message to the specified stream.])
|
||||
|
||||
m4_p([dnl
|
||||
The error message will consist of the prefix string and a colon
|
||||
("m4_bold(:)") (if a prefix string was previously specified using
|
||||
m4_ref(dbenv_set_errpfx)), an error string, and a trailing
|
||||
m4_htmlquote(newline) character.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(stream) to NULL unconfigures the interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_errfile) and
|
||||
m4_refT(dbh_set_errfile)s to display the additional information via a C
|
||||
library FILE *, or the m4_ref(dbenv_set_errcall) and
|
||||
m4_refT(dbh_set_errcall)s to capture the additional error information
|
||||
in a way that does not use either output streams or C library FILE *'s.
|
||||
You should not mix these approaches.])
|
||||
|
||||
m4_p([dnl
|
||||
This error-logging enhancement does not slow performance or significantly
|
||||
increase application size, and may be run during normal operation as well
|
||||
as during application debugging.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_error_stream, [dnl
|
||||
m4_really_dbenv(dbh_set_error_stream, dbenv_set_error_stream)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_error_stream,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(stream, [dnl
|
||||
The m4_arg(stream) parameter is the application-specified output stream to
|
||||
be used for additional error information.])
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE,
|
||||
dbenv_set_error_stream, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
67
docs_src/env/env_set_errpfx.so
vendored
Normal file
67
docs_src/env/env_set_errpfx.so
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
m4_comment([$Id: env_set_errpfx.so,v 10.34 2006/02/10 22:54:59 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_errpfx)])
|
||||
define(M4GETINTERFACE, ifelse(M4INTERFACE,
|
||||
dbenv_set_errpfx, dbenv_get_errpfx, dbh_get_errpfx))
|
||||
|
||||
define(M4PAGELOCAL, [M4INTERFACE, M4GETINTERFACE])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errpfx, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_errpfx),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__set_errpfx(DB_ENV *dbenv, const char *errpfx);
|
||||
m4_blank
|
||||
void
|
||||
DB_ENV-__GT__get_errpfx(DB_ENV *dbenv, const char **errpfxp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void
|
||||
DbEnv::set_errpfx(const char *errpfx);
|
||||
m4_blank
|
||||
void
|
||||
DbEnv::get_errpfx(const char **errpfxp);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_errpfx),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__set_errpfx(DB *db, const char *errpfx);
|
||||
m4_blank
|
||||
void DB-__GT__get_errpfx(DB *db, const char **errpfxp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_errpfx(const char *errpfx);
|
||||
m4_blank
|
||||
void Db::get_errpfx(const char **errpfxp);
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
Set the prefix string that appears before error messages issued by m4_db.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbh_set_errpfx) and m4_refT(dbenv_set_errpfx)s do not copy
|
||||
the memory to which the m4_arg(errpfx) parameter refers; rather, they
|
||||
maintain a reference to it. Although this allows applications to modify
|
||||
the error message prefix at any time (without repeatedly calling the
|
||||
interfaces), it means the memory must be maintained until the handle is
|
||||
closed.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errpfx, [dnl
|
||||
m4_really_dbenv(dbh_set_errpfx, dbenv_set_errpfx)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_errpfx,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(errpfx, [dnl
|
||||
The m4_arg(errpfx) parameter is the application-specified error prefix
|
||||
for additional error messages.])
|
||||
m4_paramend
|
||||
|
||||
m4_pf_getter(M4GETINTERFACE, error prefix,, errpfxp, reference)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_errpfx, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
87
docs_src/env/env_set_feedback.so
vendored
Normal file
87
docs_src/env/env_set_feedback.so
vendored
Normal file
@@ -0,0 +1,87 @@
|
||||
m4_comment([$Id: env_set_feedback.so,v 10.43 2006/05/17 20:47:46 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_feedback)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_feedback, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_feedback),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_feedback(DB_ENV *dbenv,
|
||||
void (*db_feedback_fcn)(DB_ENV *dbenv, int opcode, int percent));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_feedback(
|
||||
void (*db_feedback_fcn)(DbEnv *dbenv, int opcode, int percent));
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_feedback),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB-__GT__set_feedback(DB *,
|
||||
void (*db_feedback_fcn)(DB *dbp, int opcode, int percent));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
Db::set_feedback(
|
||||
void (*db_feedback_fcn)(DB *dbp, int opcode, int percent));
|
||||
]))])
|
||||
|
||||
m4_p([dnl
|
||||
Some operations performed by the m4_db library can take non-trivial
|
||||
amounts of time. The m4_refT(M4INTERFACE) can be used by applications
|
||||
to monitor progress within these operations. When an operation is
|
||||
likely to take a long time, m4_db will call the specified callback
|
||||
function with progress information.])
|
||||
m4_p([dnl
|
||||
It is up to the callback function to display this information in an
|
||||
appropriate manner.])
|
||||
|
||||
ifelse(M4INTERFACE,
|
||||
dbenv_set_feedback, m4_scope_dbenv(M4INTERFACE), m4_scope_dbh(M4INTERFACE))
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_return(M4INTERFACE, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(db_feedback_fcn, [dnl
|
||||
The m4_arg(db_feedback_fcn) parameter is the application-specified
|
||||
feedback function called to report m4_db operation progress. The
|
||||
callback function must take three parameters:
|
||||
|
||||
m4_tagbegin
|
||||
ifelse(M4INTERFACE, dbenv_set_feedback, [dnl
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is a reference to the enclosing database
|
||||
environment.])],[dnl
|
||||
m4_tag(m4_arg(db), [dnl
|
||||
The m4_arg(db) parameter is a reference to the enclosing database.])])
|
||||
|
||||
m4_tag(m4_arg(opcode), [dnl
|
||||
The m4_arg(opcode) parameter is an operation code. The m4_arg(opcode)
|
||||
parameter may take on any of the following values:
|
||||
|
||||
m4_tagbegin
|
||||
ifelse(M4INTERFACE, dbenv_set_feedback, [dnl
|
||||
m4_tag(m4_idef(DB_RECOVER), [The environment is being recovered.])
|
||||
],[dnl
|
||||
m4_tag(m4_idef(DB_UPGRADE),
|
||||
[The underlying database is being upgraded.])
|
||||
m4_tag(m4_idef(DB_VERIFY),
|
||||
[The underlying database is being verified.])])
|
||||
m4_tagend])
|
||||
|
||||
m4_tag(m4_arg(percent), [dnl
|
||||
The m4_arg(percent) parameter is the percent of the operation that has
|
||||
been completed, specified as an integer value between 0 and 100.])
|
||||
m4_tagend])
|
||||
|
||||
m4_not_reentrant
|
||||
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_feedback, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
228
docs_src/env/env_set_flags.so
vendored
Normal file
228
docs_src/env/env_set_flags.so
vendored
Normal file
@@ -0,0 +1,228 @@
|
||||
m4_comment([$Id])
|
||||
|
||||
define(M4PAGELOCAL,
|
||||
[dbenv_set_flags, dbenv_get_flags, DB_CDB_ALLDB, DB_DIRECT_DB,
|
||||
DB_DSYNC_DB, DB_MULTIVERSION, DB_NOLOCKING,
|
||||
DB_NOMMAP, DB_NOPANIC, DB_OVERWRITE, DB_PANIC_ENVIRONMENT,
|
||||
DB_REGION_INIT, DB_TIME_NOTGRANTED, DB_TXN_NOSYNC, DB_TXN_NOWAIT,
|
||||
DB_TXN_SNAPSHOT, DB_TXN_WRITE_NOSYNC, DB_YIELDCPU])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_flags),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_flags(DB_ENV *dbenv, u_int32_t flags, int onoff);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_flags(DB_ENV *dbenv, u_int32_t *flagsp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_flags(u_int32_t flags, int onoff);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_flags(u_int32_t *flagsp)
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Configure a database environment.])
|
||||
|
||||
m4_env_config(dbenv_set_flags, flag values, set_flags, [dnl
|
||||
the method flag parameter as a string; for example, "set_flags
|
||||
DB_TXN_NOSYNC"])
|
||||
|
||||
m4_return(dbenv_set_flags, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_or_must
|
||||
|
||||
m4_tagbegin
|
||||
|
||||
m4_tag(m4_idef(DB_AUTO_COMMIT), [dnl
|
||||
If set, m4_ref(Db) handle operations for which no explicit transaction
|
||||
handle was specified, and which modify databases in the database
|
||||
environment, will be automatically enclosed within a transaction.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_AUTO_COMMIT, config)
|
||||
m4_env_flags_any(DB_AUTO_COMMIT)])
|
||||
|
||||
m4_idefz([configure @locking for m4_cam])
|
||||
m4_tag(m4_idef(DB_CDB_ALLDB), [dnl
|
||||
If set, m4_cam applications will perform locking on an environment-wide
|
||||
basis rather than on a per-database basis.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_CDB_ALLDB, config)
|
||||
m4_env_flags_open(DB_CDB_ALLDB, before)])
|
||||
|
||||
m4_idefz([turn off system @buffering for database files])
|
||||
m4_tag(m4_idef(DB_DIRECT_DB), [dnl
|
||||
Turn off system buffering of m4_db database files to avoid double caching.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_DIRECT_DB, config)
|
||||
m4_env_flags_any(DB_DIRECT_DB)])
|
||||
|
||||
m4_idefz([turn off system @buffering for database files])
|
||||
m4_tag(m4_idef(DB_DSYNC_DB), [dnl
|
||||
Configure m4_db to flush database writes to the backing disk before
|
||||
returning from the write system call, rather than flushing database
|
||||
writes explicitly in a separate system call, as necessary. This is only
|
||||
available on some systems (for example, systems supporting the
|
||||
m4_posix1_name standard O_DSYNC flag, or systems supporting the Windows
|
||||
FILE_FLAG_WRITE_THROUGH flag). This flag may result in inaccurate file
|
||||
modification times and other file-level information for m4_db database
|
||||
files. This flag will almost certainly result in a performance decrease
|
||||
on most systems. This flag is only applicable to certain filesysystem
|
||||
(for example, the Veritas VxFS filesystem), where the filesystem's
|
||||
support for trickling writes back to stable storage behaves badly (or
|
||||
more likely, has been misconfigured).
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_DSYNC_DB, config)
|
||||
m4_env_flags_any(DB_DSYNC_DB)])
|
||||
|
||||
m4_tag(m4_idef(DB_MULTIVERSION), [dnl
|
||||
If set, all databases in the environment will be opened as if
|
||||
m4_ref(DB_MULTIVERSION) is passed to m4_ref(dbh_open). This flag will
|
||||
be ignored for queue databases for which m4_ref(DB_MULTIVERSION) is not
|
||||
supported.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_MULTIVERSION, config)
|
||||
m4_env_flags_any(DB_MULTIVERSION)])
|
||||
|
||||
m4_idefz([ignore @locking])
|
||||
m4_tag(m4_idef(DB_NOLOCKING), [dnl
|
||||
If set, m4_db will grant all requested mutual exclusion mutexes and
|
||||
database locks without regard for their actual availability. This
|
||||
functionality should never be used for purposes other than debugging.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_NOLOCKING)
|
||||
m4_env_flags_any(DB_NOLOCKING)])
|
||||
|
||||
m4_idefz([turn off database file @memory mapping])
|
||||
m4_tag(m4_idef(DB_NOMMAP), [dnl
|
||||
If set, m4_db will copy read-only database files into the local cache
|
||||
instead of potentially mapping them into process memory (see the
|
||||
description of the m4_refT(dbenv_set_mp_mmapsize) for further
|
||||
information).
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_NOMMAP, config)
|
||||
m4_env_flags_any(DB_NOMMAP)])
|
||||
|
||||
m4_idefz([ignore database environment @panic])
|
||||
m4_tag(m4_idef(DB_NOPANIC), [dnl
|
||||
If set, m4_db will ignore any panic state in the database environment.
|
||||
(Database environments in a panic state normally refuse all attempts to
|
||||
call m4_db functions, returning m4_ref(DB_RUNRECOVERY).) This
|
||||
functionality should never be used for purposes other than debugging.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_NOPANIC)
|
||||
m4_env_flags_any(DB_NOPANIC)])
|
||||
|
||||
m4_tag(m4_idef(DB_OVERWRITE), [dnl
|
||||
Overwrite files stored in encrypted formats before deleting them. m4_db
|
||||
overwrites files using alternating 0xff, 0x00 and 0xff byte patterns.
|
||||
For file overwriting to be effective, the underlying file must be stored
|
||||
on a fixed-block filesystem. Systems with journaling or logging filesystems
|
||||
will require operating system support and probably modification of the
|
||||
m4_db sources.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_OVERWRITE)
|
||||
m4_env_flags_any(DB_OVERWRITE)])
|
||||
|
||||
m4_idefz([turn off access to a database @environment])
|
||||
m4_tag(m4_idef(DB_PANIC_ENVIRONMENT), [dnl
|
||||
If set, m4_db will set the panic state for the database environment.
|
||||
(Database environments in a panic state normally refuse all attempts to
|
||||
call m4_db functions, returning m4_ref(DB_RUNRECOVERY).) This flag may
|
||||
not be specified using the environment's m4_ref(DB_CONFIG) file.
|
||||
m4_scope_env_flags(dbenv_set_flags, DB_PANIC_ENVIRONMENT)
|
||||
m4_env_flags_open(DB_PANIC_ENVIRONMENT, after)])
|
||||
|
||||
m4_idefz([fault database @environment in during open])
|
||||
m4_tag(m4_idef(DB_REGION_INIT), [dnl
|
||||
In some applications, the expense of page-faulting the underlying shared
|
||||
memory regions can affect performance. (For example, if the page-fault
|
||||
occurs while holding a lock, other lock requests can convoy, and overall
|
||||
throughput may decrease.) If set, m4_db will page-fault shared regions
|
||||
into memory when initially creating or joining a m4_db environment. In
|
||||
addition, m4_db will write the shared regions when creating an
|
||||
environment, forcing the underlying virtual memory and filesystems to
|
||||
instantiate both the necessary memory and the necessary disk space.
|
||||
This can also avoid out-of-disk space failures later on.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_REGION_INIT, config)
|
||||
m4_env_flags_any(DB_REGION_INIT)])
|
||||
|
||||
m4_tag(m4_idef(DB_TIME_NOTGRANTED), [dnl
|
||||
If set, database calls timing out based on lock or transaction timeout
|
||||
values will
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
return m4_ref(DB_LOCK_NOTGRANTED) instead of m4_ref(DB_LOCK_DEADLOCK).],[dnl
|
||||
throw a m4_ref(DbLockNotGrantedException) exception instead of
|
||||
m4_ref(DbDeadlockException).])
|
||||
This allows applications to distinguish between operations which have
|
||||
deadlocked and operations which have exceeded their time limits.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_TIME_NOTGRANTED, config)
|
||||
m4_env_flags_any(DB_TIME_NOTGRANTED)])
|
||||
|
||||
m4_idefz([turn off synchronous @transaction commit])
|
||||
m4_tag(m4_idef(DB_TXN_NOSYNC), [dnl
|
||||
If set, m4_db will not write or synchronously flush the log on transaction
|
||||
commit.
|
||||
This means that transactions exhibit the ACI (atomicity, consistency,
|
||||
and isolation) properties, but not D (durability); that is, database
|
||||
integrity will be maintained, but if the application or system fails,
|
||||
it is possible some number of the most recently committed transactions
|
||||
may be undone during recovery. The number of transactions at risk is
|
||||
governed by how many log updates can fit into the log buffer, how often
|
||||
the operating system flushes dirty buffers to disk, and how often the
|
||||
log is checkpointed.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_TXN_NOSYNC,
|
||||
config) m4_env_flags_any(DB_TXN_NOSYNC)])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_NOWAIT), [dnl
|
||||
If set and a lock is unavailable for any m4_db operation performed in
|
||||
the context of a transaction, cause the operation to
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
return m4_ref(DB_LOCK_DEADLOCK) (or m4_ref(DB_LOCK_NOTGRANTED) if
|
||||
configured using the m4_ref(DB_TIME_NOTGRANTED) flag).],[dnl
|
||||
either return m4_ref(DB_LOCK_DEADLOCK) or throw a
|
||||
m4_ref(DbDeadlockException) exception (or return
|
||||
m4_ref(DB_LOCK_NOTGRANTED) or throw a m4_ref(DbLockNotGrantedException)
|
||||
exception if configured using the m4_ref(DB_TIME_NOTGRANTED) flag).])
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_TXN_NOWAIT, config)
|
||||
m4_env_flags_any(DB_TXN_NOWAIT)])
|
||||
|
||||
m4_tag(m4_idef(DB_TXN_SNAPSHOT), [dnl
|
||||
If set, all transactions in the environment will be started as if
|
||||
m4_ref(DB_TXN_SNAPSHOT) were passed to m4_ref(txn_begin), and all
|
||||
non-transactional cursors will be opened as if m4_ref(DB_TXN_SNAPSHOT)
|
||||
were passed to m4_ref(dbh_cursor).
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_TXN_SNAPSHOT, config)
|
||||
m4_env_flags_any(DB_TXN_SNAPSHOT)])
|
||||
|
||||
m4_idefz([turn off synchronous @transaction commit])
|
||||
m4_tag(m4_idef(DB_TXN_WRITE_NOSYNC), [dnl
|
||||
If set, m4_db will write, but will not synchronously flush, the log on
|
||||
transaction commit.
|
||||
This means that transactions exhibit the ACI (atomicity, consistency,
|
||||
and isolation) properties, but not D (durability); that is, database
|
||||
integrity will be maintained, but if the system fails, it is possible
|
||||
some number of the most recently committed transactions may be undone
|
||||
during recovery. The number of transactions at risk is governed by how
|
||||
often the system flushes dirty buffers to disk and how often the log is
|
||||
checkpointed.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_TXN_WRITE_NOSYNC, config)
|
||||
m4_env_flags_any(DB_TXN_WRITE_NOSYNC)])
|
||||
|
||||
m4_idefz([configure for @stress testing])
|
||||
m4_tag(m4_idef(DB_YIELDCPU), [dnl
|
||||
If set, m4_db will yield the processor immediately after each page or
|
||||
mutex acquisition. This functionality should never be used for purposes
|
||||
other than stress testing.
|
||||
m4_scope_dbenv_flags(dbenv_set_flags, DB_YIELDCPU, config)
|
||||
m4_env_flags_any(DB_YIELDCPU)])
|
||||
|
||||
m4_tagend])
|
||||
|
||||
m4_param(onoff, [dnl
|
||||
If the m4_arg(onoff) parameter is zero, the specified flags are cleared;
|
||||
otherwise they are set.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_flags, einval)
|
||||
|
||||
m4_pf_getter(dbenv_get_flags, configuration flags,, flagsp)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
82
docs_src/env/env_set_intermediate_dir_mode.so
vendored
Normal file
82
docs_src/env/env_set_intermediate_dir_mode.so
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
m4_comment([$Id: env_set_intermediate_dir_mode.so,v 1.1 2008/01/15 15:35:22 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_intermediate_dir_mode, dbenv_get_intermediate_dir_mode])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_intermediate_dir_mode),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_intermediate_dir_mode(DB_ENV *dbenv, const char *mode);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_intermediate_dir_mode(DB_ENV *dbenv, const char **modep);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_intermediate_dir_mode(u_int32_t mode);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_intermediate_dir_mode(u_int32_t *modep);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
By default, m4_db does not create intermediate directories needed for
|
||||
recovery, that is, if the file m4_path(/a/b/c/mydatabase) is being
|
||||
recovered, and the directory path m4_arg(b/c) does not exist, recovery
|
||||
will fail. This default behavior is because m4_db does not know what
|
||||
permissions are appropriate for intermediate directory creation, and
|
||||
creating the directory might result in a security problem.])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_set_intermediate_dir_mode) causes m4_db to create any
|
||||
intermediate directories needed during recovery, using the specified
|
||||
permissions.])
|
||||
|
||||
m4_p([dnl
|
||||
On UNIX systems or in m4_posix1_name environments, created directories
|
||||
are owned by the process owner; the group ownership of created
|
||||
directories is based on the system and directory defaults, and is not
|
||||
further specified by m4_db.])
|
||||
|
||||
m4_env_config(dbenv_set_intermediate_dir_mode,
|
||||
[intermediate directory permissions],
|
||||
set_intermediate_dir_mode, [the directory permissions])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_intermediate_dir_mode)
|
||||
|
||||
m4_when_envopen(dbenv_set_intermediate_dir_mode)
|
||||
|
||||
m4_return(dbenv_set_intermediate_dir_mode, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(mode, [dnl
|
||||
The m4_arg(mode) parameter specifies the directory permissions.
|
||||
m4_p([dnl
|
||||
Directory permissions are interpreted as a string of nine characters,
|
||||
using the character set m4_arg(r) (read), m4_arg(w) (write), m4_arg(x)
|
||||
(execute or search), and m4_arg(-) (none). The first character is the
|
||||
read permissions for the directory owner (set to either m4_arg(r) or
|
||||
m4_arg(-)). The second character is the write permissions for the
|
||||
directory owner (set to either m4_arg(w) or m4_arg(-)). The third
|
||||
character is the execute permissions for the directory owner (set to
|
||||
either m4_arg(x) or m4_arg(-)).])
|
||||
m4_p([dnl
|
||||
Similarly, the second set of three characters are the read, write and
|
||||
execute/search permissions for the directory group, and the third set
|
||||
of three characters are the read, write and execute/search permissions
|
||||
for all others. For example, the string m4_arg(rwx------) would
|
||||
configure read, write and execute/search access for the owner only. The
|
||||
string m4_arg(rwxrwx---) would configure read, write and execute/search
|
||||
access for both the owner and the group. The string m4_arg(rwxr-----)
|
||||
would configure read, write and execute/search access for the directory
|
||||
owner and read-only access for the directory group.])])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_intermediate_dir_mode,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_pf_getter(dbenv_get_intermediate_dir_mode,
|
||||
intermediate directory permissions,, modep, reference)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
62
docs_src/env/env_set_isalive.so
vendored
Normal file
62
docs_src/env/env_set_isalive.so
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
m4_comment([$Id: env_set_isalive.so,v 10.4 2006/01/27 16:13:48 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_isalive])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_isalive),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_isalive(DB_ENV *dbenv,
|
||||
int (*is_alive)(DB_ENV *dbenv, pid_t pid, db_threadid_t tid, u_int32_t flags));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_isalive(
|
||||
int (*is_alive)(DbEnv *dbenv, pid_t pid, db_threadid_t tid, u_int32_t flags));
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Declare a function that returns if a thread of control (either a true
|
||||
thread or a process) is still running. The m4_refT(dbenv_set_isalive)
|
||||
supports the m4_refT(dbenv_failchk). For more information, see
|
||||
m4_link(M4RELDIR/ref/cam/app, Architecting Data Store and Concurrent
|
||||
Data Store applications), and m4_link(M4RELDIR/ref/transapp/app,
|
||||
Architecting Transactional Data Store applications).])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_isalive)
|
||||
|
||||
m4_when_any(dbenv_set_isalive)
|
||||
|
||||
m4_return(dbenv_set_isalive, std)
|
||||
|
||||
m4_parambegin
|
||||
|
||||
m4_param(is_alive, [dnl
|
||||
The m4_arg(is_alive) parameter is a function which returns non-zero if
|
||||
the thread of control, identified by the m4_arg(pid) and m4_arg(tid)
|
||||
arguments, is still running. The function takes four arguments:])
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment
|
||||
handle, allowing application access to the application-private fields
|
||||
of that object.])
|
||||
m4_tag(m4_arg(pid), [dnl
|
||||
The m4_arg(pid) parameter is a process ID returned by the function
|
||||
specified to the m4_refT(dbenv_set_thread_id).])
|
||||
m4_tag(m4_arg(tid), [dnl
|
||||
The m4_arg(tid) parameter is a thread ID returned by the function
|
||||
specified to the m4_refT(dbenv_set_thread_id).])
|
||||
m4_tag(m4_arg(flags), [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_MUTEX_PROCESS_ONLY), [dnl
|
||||
Return only if the process is alive, the thread ID should be ignored.])
|
||||
m4_tagend])
|
||||
m4_tagend
|
||||
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_isalive, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
56
docs_src/env/env_set_msg_stream.so
vendored
Normal file
56
docs_src/env/env_set_msg_stream.so
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
m4_comment([$Id: env_set_msg_stream.so,v 10.5 2006/02/10 22:54:59 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_message_stream)])
|
||||
|
||||
define(M4PAGELOCAL, M4INTERFACE)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_message_stream, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_message_stream),
|
||||
void DbEnv::set_message_stream(class ostream*);
|
||||
)],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_message_stream),
|
||||
void Db::set_message_stream(class ostream*);
|
||||
)])
|
||||
|
||||
m4_p([dnl
|
||||
There are interfaces in the m4_db library which either directly output
|
||||
informational messages or statistical information, or configure the
|
||||
library to output such messages when performing other operations, for
|
||||
example, m4_ref(dbenv_set_verbose) and m4_ref(dbenv_stat_print).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_message_stream) and
|
||||
m4_refT(dbh_set_message_stream)s are used to display these messages for
|
||||
the application. In this case, the message will include a trailing
|
||||
m4_htmlquote(newline) character.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(stream) to NULL unconfigures the interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_msgfile) and
|
||||
m4_refT(dbh_set_msgfile)s to display the messages via a C library FILE *,
|
||||
or the m4_ref(dbenv_set_msgcall) and m4_refT(dbh_set_msgcall)s to
|
||||
capture the additional error information in a way that does not use
|
||||
either output streams or C library FILE *'s. You should not mix these
|
||||
approaches.])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_message_stream, [dnl
|
||||
m4_really_dbenv(dbh_set_message_stream, dbenv_set_message_stream)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_message_stream,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(stream, [dnl
|
||||
The m4_arg(stream) parameter is the application-specified output stream to
|
||||
be used for additional message information.])
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE,
|
||||
dbenv_set_message_stream, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
|
||||
m4_page_footer
|
||||
95
docs_src/env/env_set_msgcall.so
vendored
Normal file
95
docs_src/env/env_set_msgcall.so
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
m4_comment([$Id: env_set_msgcall.so,v 10.7 2006/05/17 20:47:46 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_msgcall)])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_msgcall, dbh_set_msgcall])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_msgcall, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_msgcall),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__set_msgcall(DB_ENV *dbenv,
|
||||
void (*db_msgcall_fcn)(const DB_ENV *dbenv, const char *msg));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void DbEnv::set_msgcall(
|
||||
void (*db_msgcall_fcn)(const DbEnv *dbenv, const char *msg));
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_msgcall),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__set_msgcall(DB *,
|
||||
void (*db_msgcall_fcn)(const DB_ENV *dbenv, char *msg));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_msgcall(
|
||||
void (*db_msgcall_fcn)(const DbEnv *dbenv, char *msg));
|
||||
]))])
|
||||
|
||||
ifelse(M4API, C_API, [m4_p([dnl
|
||||
There are interfaces in the m4_db library which either directly output
|
||||
informational messages or statistical information, or configure the
|
||||
library to output such messages when performing other operations, for
|
||||
example, m4_ref(dbenv_set_verbose) and m4_ref(dbenv_stat_print).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_msgcall) and m4_refT(dbh_set_msgcall)s are used to
|
||||
pass these messages to the application, and m4_db will call
|
||||
m4_arg(db_msgcall_fcn) with each message. It is up to the
|
||||
m4_arg(db_msgcall_fcn) function to display the message in an appropriate
|
||||
manner.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(db_msgcall_fcn) to NULL unconfigures the callback interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbh_set_msgfile) or
|
||||
m4_refT(dbenv_set_msgfile)s to display the messages via a C library FILE *.])])
|
||||
|
||||
ifelse(M4API, CXX_API, [m4_p([dnl
|
||||
There are interfaces in the m4_db library which either directly output
|
||||
informational messages or statistical information, or configure the
|
||||
library to output such messages when performing other operations, for
|
||||
example, m4_ref(dbenv_set_verbose) and m4_ref(dbenv_stat_print).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_msgcall) and m4_refT(dbh_set_msgcall)s are used to
|
||||
pass these messages to the application, and m4_db will call
|
||||
m4_arg(db_msgcall_fcn) with each message. It is up to the
|
||||
m4_arg(db_msgcall_fcn) function to display the message in an appropriate
|
||||
manner.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(db_msgcall_fcn) to NULL unconfigures the callback interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_message_stream) and
|
||||
m4_refT(dbh_set_message_stream)s to display the messages via an output
|
||||
stream, or the m4_ref(dbh_set_msgfile) or m4_refT(dbenv_set_msgfile)s
|
||||
to display the messages via a C library FILE *.])])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_msgcall, [dnl
|
||||
m4_really_dbenv(dbh_set_msgcall, dbenv_set_msgcall)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_msgcall,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(db_msgcall_fcn, [dnl
|
||||
The m4_arg(db_msgcall_fcn) parameter is the application-specified message
|
||||
reporting function. The function takes two parameters:
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment.])
|
||||
m4_tag(m4_arg(msg), [dnl
|
||||
The m4_arg(msg) parameter is the message string.])
|
||||
m4_tagend])
|
||||
|
||||
m4_not_reentrant
|
||||
m4_paramend
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_msgcall, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
101
docs_src/env/env_set_msgfile.so
vendored
Normal file
101
docs_src/env/env_set_msgfile.so
vendored
Normal file
@@ -0,0 +1,101 @@
|
||||
m4_comment([$Id: env_set_msgfile.so,v 10.7 2006/02/10 22:54:59 bostic Exp $])
|
||||
|
||||
ifdef([M4INTERFACE],, [define(M4INTERFACE, dbenv_set_msgfile)])
|
||||
define(M4GETINTERFACE, ifelse(M4INTERFACE,
|
||||
dbenv_set_msgfile, dbenv_get_msgfile, dbh_get_msgfile))
|
||||
|
||||
define(M4PAGELOCAL, [M4INTERFACE, M4GETINTERFACE])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_msgfile, [dnl
|
||||
m4_pf_header(m4_ref(dbenv_set_msgfile),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB_ENV-__GT__set_msgfile(DB_ENV *dbenv, FILE *msgfile);
|
||||
m4_blank
|
||||
void
|
||||
DB_ENV-__GT__get_msgfile(DB_ENV *dbenv, FILE **msgfilep);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void
|
||||
DbEnv::set_msgfile(FILE *msgfile);
|
||||
m4_blank
|
||||
void
|
||||
DbEnv::get_msgfile(FILE **msgfilep);
|
||||
]))],[dnl
|
||||
m4_pf_header(m4_ref(dbh_set_msgfile),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
void
|
||||
DB-__GT__set_msgfile(DB *db, FILE *msgfile);
|
||||
m4_blank
|
||||
void
|
||||
DB-__GT__get_msgfile(DB *db, FILE **msgfilep);
|
||||
])dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
void Db::set_msgfile(FILE *msgfile);
|
||||
m4_blank
|
||||
void Db::get_msgfile(FILE **msgfilep);
|
||||
]))])
|
||||
|
||||
ifelse(M4API, C_API, [m4_p([dnl
|
||||
There are interfaces in the m4_db library which either directly output
|
||||
informational messages or statistical information, or configure the
|
||||
library to output such messages when performing other operations, for
|
||||
example, m4_ref(dbenv_set_verbose) and m4_ref(dbenv_stat_print).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_msgfile) and m4_refT(dbh_set_msgfile)s are used to
|
||||
display these messages for the application.
|
||||
In this case the message will include a trailing m4_htmlquote(newline)
|
||||
character.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(msgfile) to NULL unconfigures the interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_msgcall) or
|
||||
m4_refT(dbh_set_msgcall)s to capture the additional error information
|
||||
in a way that does not use C library FILE *'s.])])
|
||||
|
||||
ifelse(M4API, CXX_API, [m4_p([dnl
|
||||
There are interfaces in the m4_db library which either directly output
|
||||
informational messages or statistical information, or configure the
|
||||
library to output such messages when performing other operations, for
|
||||
example, m4_ref(dbenv_set_verbose) and m4_ref(dbenv_stat_print).])
|
||||
|
||||
m4_p([dnl
|
||||
The m4_ref(dbenv_set_msgfile) and m4_refT(dbh_set_msgfile)s are used to
|
||||
display these messages for the application. In this case, the message
|
||||
will include a trailing m4_htmlquote(newline) character.])
|
||||
|
||||
m4_p([dnl
|
||||
Setting m4_arg(msgfile) to NULL unconfigures the interface.])
|
||||
|
||||
m4_p([dnl
|
||||
Alternatively, you can use the m4_ref(dbenv_set_message_stream) and
|
||||
m4_refT(dbh_set_message_stream)s to display the messages via an output
|
||||
stream, or the m4_ref(dbenv_set_msgcall) and m4_refT(dbh_set_msgcall)s
|
||||
to capture the additional error information in a way that does not use
|
||||
either output streams or C library FILE *'s. You should not mix these
|
||||
approaches.])])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_msgfile, [dnl
|
||||
m4_really_dbenv(dbh_set_msgfile, dbenv_set_msgfile)])
|
||||
|
||||
ifelse(M4INTERFACE, dbh_set_msgfile,
|
||||
[m4_scope_dbh(M4INTERFACE)], [m4_scope_dbenv(M4INTERFACE)])
|
||||
|
||||
m4_when_any(M4INTERFACE)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(msgfile, [dnl
|
||||
The m4_arg(msgfile) parameter is a C library FILE * to be used for
|
||||
displaying messages.])
|
||||
m4_paramend
|
||||
|
||||
m4_pf_getter(
|
||||
ifelse(M4INTERFACE, dbh_set_msgfile, dbh_get_msgfile, dbenv_get_msgfile),
|
||||
FILE *,, msgfilep)
|
||||
|
||||
ifelse(M4INTERFACE, dbenv_set_msgfile, [m4_seealso(DbEnv)], [m4_seealso(Db)])
|
||||
m4_page_footer
|
||||
68
docs_src/env/env_set_rpc_server.so
vendored
Normal file
68
docs_src/env/env_set_rpc_server.so
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
m4_comment([$Id: env_set_rpc_server.so,v 10.29 2004/08/13 03:38:57 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_rpc_server, DB_NOSERVER, DB_NOSERVER_ID])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_rpc_server),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_rpc_server(DB_ENV *dbenv, CLIENT *client, char *host,
|
||||
long cl_timeout, long sv_timeout, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_rpc_server(CLIENT *client, char *host,
|
||||
long cl_timeout, long sv_timeout, u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Establishes a connection for this m4_arg(dbenv) to a RPC server.])
|
||||
|
||||
m4_p([dnl
|
||||
When the m4_refT(dbenv_set_rpc_server) has been called, subsequent calls
|
||||
to m4_db library interfaces may return or throw exceptions encapsulating
|
||||
m4_idef(DB_NOSERVER), m4_idef(DB_NOSERVER_ID), or m4_idef(DB_NOSERVER_HOME).])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_rpc_server)
|
||||
|
||||
m4_when_envopen(dbenv_set_rpc_server)
|
||||
|
||||
m4_return(dbenv_set_rpc_server, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(cl_timeout, [dnl
|
||||
m4_idefz(DB_NOSERVER)
|
||||
The m4_arg(cl_timeout) parameter specifies the number of seconds the client
|
||||
should wait for results to come back from the server. Once the timeout
|
||||
has expired on any communication with the server, m4_ref(DB_NOSERVER) will
|
||||
be returned. If this value is zero, a default timeout is used.])
|
||||
|
||||
m4_param(client, [dnl
|
||||
If the m4_arg(client) channel has been provided by the application then
|
||||
m4_db will use it as its connection and the m4_arg(host) and
|
||||
m4_arg(cl_timeout) fields are ignored.])
|
||||
|
||||
m4_param(host, [dnl
|
||||
The m4_arg(host) parameter is the host to which the m4_db server will
|
||||
connect and create a channel for communication.])
|
||||
|
||||
m4_unusedflags
|
||||
|
||||
m4_idefz(DB_NOSERVER_ID)
|
||||
m4_param(sv_timeout, [dnl
|
||||
The m4_arg(sv_timeout) parameter specifies the number of seconds the server
|
||||
should allow a client connection to remain idle before assuming that the
|
||||
client is gone. Once that timeout has been reached, the server releases
|
||||
all resources associated with that client connection. Subsequent attempts
|
||||
by that client to communicate with the server result in
|
||||
m4_ref(DB_NOSERVER_ID), indicating that an invalid identifier has been
|
||||
given to the server. This value can be considered a hint to the server.
|
||||
The server may alter this value based on its own policies or allowed
|
||||
values. If this value is zero, a default timeout is used.])
|
||||
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_rpc_server, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
70
docs_src/env/env_set_shm_key.so
vendored
Normal file
70
docs_src/env/env_set_shm_key.so
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
m4_comment([$Id: env_set_shm_key.so,v 10.28 2004/09/28 15:04:20 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_shm_key, dbenv_get_shm_key])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_shm_key),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_shm_key(DB_ENV *dbenv, long shm_key);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_shm_key(DB_ENV *dbenv, long *shm_keyp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_shm_key(long shm_key);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_shm_key(long *shm_keyp);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Specify a base segment ID for m4_db environment shared memory regions
|
||||
created in system memory on VxWorks or systems supporting X/Open-style
|
||||
shared memory interfaces; for example, UNIX systems supporting
|
||||
m4_manref(shmget, 2) and related System V IPC interfaces.])
|
||||
|
||||
m4_p([dnl
|
||||
This base segment ID will be used when m4_db shared memory regions are
|
||||
first created. It will be incremented a small integer value each time
|
||||
a new shared memory region is created; that is, if the base ID is 35,
|
||||
the first shared memory region created will have a segment ID of 35,
|
||||
and the next one will have a segment ID between 36 and 40 or so. A
|
||||
m4_db environment always creates a master shared memory region; an
|
||||
additional shared memory region for each of the subsystems supported by
|
||||
the environment (Locking, Logging, Memory Pool and Transaction); plus
|
||||
an additional shared memory region for each additional memory pool cache
|
||||
that is supported. Already existing regions with the same segment IDs
|
||||
will be removed. See m4_link(M4RELDIR/ref/env/region, [Shared Memory
|
||||
Regions]) for more information.])
|
||||
|
||||
m4_p([dnl
|
||||
The intent behind this method is two-fold: without it, applications
|
||||
have no way to ensure that two m4_db applications don't attempt to use
|
||||
the same segment IDs when creating different m4_db environments. In
|
||||
addition, by using the same segment IDs each time the environment is
|
||||
created, previously created segments will be removed, and the set of
|
||||
segments on the system will not grow without bound.])
|
||||
|
||||
m4_env_config(dbenv_set_shm_key, [base segment ID], set_shm_key, [the ID])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_shm_key)
|
||||
|
||||
m4_when_envopen(dbenv_set_shm_key, corrupt)
|
||||
|
||||
m4_return(dbenv_set_shm_key, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(shm_key, [dnl
|
||||
The m4_arg(shm_key) parameter is the base segment ID for the database
|
||||
environment.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_shm_key,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_pf_getter(dbenv_get_shm_key, base segment ID,, shm_keyp)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
65
docs_src/env/env_set_thread_count.so
vendored
Normal file
65
docs_src/env/env_set_thread_count.so
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
m4_comment([$Id: env_set_thread_count.so,v 10.3 2007/04/02 16:08:13 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_thread_count, dbenv_get_thread_count])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_thread_count),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_thread_count(DB_ENV *dbenv, u_int32_t count);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_thread_count(DB_ENV *dbenv, u_int32_t *countp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_thread_count(u_int32_t count);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_thread_count(u_int32_t *countp);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Declare an approximate number of threads in the database environment.
|
||||
The m4_refT(dbenv_set_thread_count) must be called prior to opening the
|
||||
database environment if the m4_refT(dbenv_failchk) will be used. The
|
||||
m4_refT(dbenv_set_thread_count) does not set the maximum number of
|
||||
threads but is used to determine memory sizing and the thread control
|
||||
block reclamation policy.])
|
||||
|
||||
m4_p([dnl
|
||||
If a process has not configured an m4_arg(is_alive) function from the
|
||||
m4_refT(dbenv_set_isalive), and then attempts to join a database
|
||||
environment configured for failure checking with the
|
||||
m4_ref(dbenv_failchk), m4_ref(dbenv_set_thread_id),
|
||||
m4_ref(dbenv_set_isalive) and m4_refT(dbenv_set_thread_count)s, the
|
||||
program may be unable to allocate a thread control block and fail to
|
||||
join the environment.
|
||||
m4_bold([This is true of the standalone m4_db utility programs.])
|
||||
To avoid problems when using the standalone m4_db utility programs with
|
||||
environments configured for failure checking, incorporate the utility's
|
||||
functionality directly in the application, or call the
|
||||
m4_refT(dbenv_failchk) before running the utility.])
|
||||
|
||||
m4_env_config(dbenv_set_thread_count,
|
||||
[thread count], set_thread_count, [the thread count])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_thread_count)
|
||||
|
||||
m4_when_envopen(dbenv_set_thread_count)
|
||||
|
||||
m4_return(dbenv_set_thread_count, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(count, [dnl
|
||||
The m4_arg(count) parameter is an approximate thread count for the
|
||||
database environment.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_thread_count,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_pf_getter(dbenv_get_thread_count, thread count,, countp)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
108
docs_src/env/env_set_thread_id.so
vendored
Normal file
108
docs_src/env/env_set_thread_id.so
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
m4_comment([$Id: env_set_thread_id.so,v 10.9 2006/08/24 16:32:23 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_thread_id])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_thread_id),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_thread_id(DB_ENV *dbenv,
|
||||
void (*thread_id)(DB_ENV *dbenv, pid_t *pid, db_threadid_t *tid));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_thread_id(
|
||||
void (*thread_id)(DbEnv *dbenv, pid_t *pid, db_threadid_t *tid));
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Declare a function that returns a unique identifier pair for the current
|
||||
thread of control. The m4_refT(dbenv_set_thread_id) supports the
|
||||
m4_refT(dbenv_failchk). For more information, see
|
||||
m4_link(M4RELDIR/ref/cam/app, Architecting Data Store and Concurrent
|
||||
Data Store applications), and m4_link(M4RELDIR/ref/transapp/app,
|
||||
Architecting Transactional Data Store applications).])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_thread_id)
|
||||
|
||||
m4_when_any(dbenv_set_thread_id)
|
||||
|
||||
m4_return(dbenv_set_thread_id, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(thread_id, [dnl
|
||||
The m4_arg(thread_id) parameter is a function which returns a unique
|
||||
identifier pair for a thread of control in a m4_db application. The
|
||||
function takes three arguments:])
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment
|
||||
handle, allowing application access to the application-private fields
|
||||
of that object.])
|
||||
m4_tag(m4_arg(pid), [dnl
|
||||
The m4_arg(pid) points to a memory location of type pid_t. The
|
||||
process ID of the current thread of control may be returned in
|
||||
this memory location.])
|
||||
m4_tag(m4_arg(tid), [dnl
|
||||
The m4_arg(tid) points to a memory location of type db_threadid_t. The
|
||||
thread ID of the current thread of control may be returned in this
|
||||
memory location.])
|
||||
m4_tagend
|
||||
m4_paramend
|
||||
|
||||
m4_p([dnl
|
||||
The standard system library calls to return process and thread IDs are
|
||||
often sufficient for this purpose (for example, getpid() and
|
||||
pthread_self() on POSIX systems or GetCurrentThreadID on Windows
|
||||
systems). However, if the m4_db application dynamically creates
|
||||
processes or threads, some care may be necessary in assigning unique
|
||||
IDs. In most threading systems, process and thread IDs are available
|
||||
for re-use as soon as the process or thread exits. If a new process or
|
||||
thread is created between the time of process or thread exit, and the
|
||||
m4_refT(dbenv_failchk) is run, it may be possible for
|
||||
m4_ref(dbenv_failchk) to not detect that a thread of control exited
|
||||
without properly releasing all m4_db resources.])
|
||||
|
||||
m4_p([dnl
|
||||
It may be possible to handle this problem by inhibiting process or
|
||||
thread creation between thread of control exit and calling
|
||||
m4_ref(dbenv_failchk). Alternatively, the m4_arg(thread_id) function
|
||||
must be constructed to not re-use m4_arg(pid)/m4_arg(tid) pairs. For
|
||||
example, in a single process application, the returned process ID might
|
||||
be used as an incremental counter, with the returned thread ID set to
|
||||
the actual thread ID. Obviously, the m4_arg(is_alive) function
|
||||
specified to the m4_refT(dbenv_set_isalive) must be compatible with any
|
||||
m4_arg(thread_id) function specified to m4_ref(dbenv_set_thread_id).])
|
||||
|
||||
m4_p([dnl
|
||||
The db_threadid_t type is configured to be the same type as a standard
|
||||
thread identifier, in m4_db configurations where this type is known (for
|
||||
example, systems supporting pthread_t or thread_t, or DWORD on Windows).
|
||||
If the m4_db configuration process is unable to determine the type of a
|
||||
standard thread identifier, the db_thread_t type is set to uintmax_t (or
|
||||
the largest available unsigned integral type, on systems lacking the
|
||||
uintmax_t type). Applications running on systems lacking a detectable
|
||||
standard thread type, and which are also using thread APIs where a
|
||||
thread identifier is not an integral value and so will not fit into the
|
||||
configured db_threadid_t type, must either translate between the
|
||||
db_threadid_t type and the thread identifier (mapping the thread
|
||||
identifier to a unique identifier of the appropriate size), or modify
|
||||
the m4_db sources to use an appropriate db_threadid_t type. Note: we
|
||||
do not currently know of any systems where this is necessary. If your
|
||||
application has to solve this problem, please contact our support group
|
||||
and let us know.])
|
||||
|
||||
m4_p([dnl
|
||||
If no m4_arg(thread_id) function is specified by the application, the
|
||||
m4_db library will identify threads of control by using the taskIdSelf()
|
||||
call on VxWorks, the getpid() and GetCurrentThreadID() calls on Windows,
|
||||
the getpid() and pthread_self() calls when the m4_db library has been
|
||||
configured for POSIX pthreads or Solaris LWP threads, the getpid() and
|
||||
thr_self() calls when the m4_db library has been configured for UI
|
||||
threads, and otherwise getpid().])
|
||||
|
||||
m4_err(dbenv_set_thread_id, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
65
docs_src/env/env_set_thread_id_string.so
vendored
Normal file
65
docs_src/env/env_set_thread_id_string.so
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
m4_comment([$Id: env_set_thread_id_string.so,v 10.2 2007/09/26 15:11:30 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_thread_id_string, DB_THREADID_STRLEN])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_thread_id_string),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_thread_id_string(DB_ENV *dbenv,
|
||||
char *(*thread_id_string)(DB_ENV *dbenv,
|
||||
pid_t pid, db_threadid_t tid, char *buf));
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_thread_id(
|
||||
char *(*thread_id_string)(DbEnv *dbenv,
|
||||
pid_t pid, db_threadid_t tid, char *buf));
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
Declare a function that formats a process ID and thread ID identifier
|
||||
pair for display into a caller-supplied buffer. The function must
|
||||
return a reference to the caller-specified buffer. The
|
||||
m4_refT(dbenv_set_thread_id_string) supports the
|
||||
m4_refT(dbenv_set_thread_id).])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_thread_id_string)
|
||||
|
||||
m4_when_any(dbenv_set_thread_id_string)
|
||||
|
||||
m4_return(dbenv_set_thread_id_string, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(thread_id_string, [dnl
|
||||
The m4_arg(thread_id_string) parameter is a function which returns a
|
||||
buffer in which is an identifier pair formatted for display. The
|
||||
function takes four arguments:])
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_arg(dbenv), [dnl
|
||||
The m4_arg(dbenv) parameter is the enclosing database environment
|
||||
handle, allowing application access to the application-private fields
|
||||
of that object.])
|
||||
m4_tag(m4_arg(pid), [dnl
|
||||
The m4_arg(pid) argument is a process ID.])
|
||||
m4_tag(m4_arg(tid), [dnl
|
||||
The m4_arg(tid) argument is a thread ID.])
|
||||
m4_tag(m4_arg(buf), [dnl
|
||||
m4_idefz(DB_THREADID_STRLEN)
|
||||
The m4_arg(buf) argument is character array of at least
|
||||
m4_ref(DB_THREADID_STRLEN) bytes in length, into which the identifier
|
||||
pair should be formatted.])
|
||||
m4_tagend
|
||||
m4_paramend
|
||||
|
||||
m4_p([dnl
|
||||
If no m4_arg(thread_id_string) function is specified, the default
|
||||
routine displays the identifier pair as "pid/tid", that is, the process
|
||||
ID represented as an unsigned integer value, a slash ('/') character,
|
||||
then the thread ID represented as an unsigned integer value.])
|
||||
|
||||
m4_err(dbenv_set_thread_id_string, einval)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
99
docs_src/env/env_set_timeout.so
vendored
Normal file
99
docs_src/env/env_set_timeout.so
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
m4_comment([$Id: env_set_timeout.so,v 10.24 2005/05/20 15:07:45 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL,
|
||||
[dbenv_set_timeout, dbenv_get_timeout, DB_SET_LOCK_TIMEOUT,
|
||||
DB_SET_TXN_TIMEOUT])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_timeout),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_timeout(DB_ENV *dbenv, db_timeout_t timeout, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_timeout(DB_ENV *dbenv, db_timeout_t *timeoutp, u_int32_t flag);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_timeout(db_timeout_t timeout, u_int32_t flags);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_timeout(db_timeout_t *timeoutp, u_int32_t flag);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_set_timeout) sets timeout values for locks or
|
||||
transactions in the database environment.])
|
||||
|
||||
m4_p([dnl
|
||||
All timeouts are checked whenever a thread of control blocks on a lock
|
||||
or when deadlock detection is performed. (In the case of
|
||||
m4_ref(DB_SET_LOCK_TIMEOUT), the lock is one requested explicitly
|
||||
through the Lock subsystem interfaces. In the case of
|
||||
m4_ref(DB_SET_TXN_TIMEOUT), the lock is one requested on behalf of a
|
||||
transaction. In either case, it may be a lock requested by the database
|
||||
access methods underlying the application.) As timeouts are only
|
||||
checked when the lock request first blocks or when deadlock detection
|
||||
is performed, the accuracy of the timeout depends on how often deadlock
|
||||
detection is performed.])
|
||||
|
||||
m4_p([dnl
|
||||
Timeout values specified for the database environment may be overridden
|
||||
on a per-lock or per-transaction basis. See m4_ref(lock_vec) and
|
||||
m4_ref(txn_set_timeout) for more information.])
|
||||
|
||||
m4_scope_env(dbenv_set_timeout)
|
||||
|
||||
m4_when_any(dbenv_set_timeout)
|
||||
|
||||
m4_return(dbenv_set_timeout, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_must
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_SET_LOCK_TIMEOUT), [dnl
|
||||
Set the timeout value for locks in this database environment.
|
||||
m4_env_config(dbenv_set_timeout,
|
||||
[lock timeout value], set_lock_timeout, [the lock timeout value])])
|
||||
|
||||
m4_tag(m4_idef(DB_SET_TXN_TIMEOUT), [dnl
|
||||
Set the timeout value for transactions in this database environment.
|
||||
m4_env_config(dbenv_set_timeout,
|
||||
[transaction timeout value], set_txn_timeout, [the transaction timeout value])])
|
||||
m4_tagend
|
||||
|
||||
m4_param(timeout, [dnl
|
||||
The m4_arg(timeout) parameter is the timeout value. It must be specified
|
||||
as an unsigned 32-bit number of microseconds, limiting the maximum timeout
|
||||
to roughly 71 minutes.])])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_timeout, einval)
|
||||
|
||||
m4_pf_description(m4_ref(dbenv_get_timeout))
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_get_timeout) returns a timeout value, in microseconds.])
|
||||
|
||||
m4_when_any(dbenv_get_timeout)
|
||||
|
||||
m4_return(dbenv_get_timeout, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(flag, [dnl
|
||||
m4_sf_must
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_SET_LOCK_TIMEOUT), [dnl
|
||||
Return the timeout value for locks in this database environment.])
|
||||
|
||||
m4_tag(m4_idef(DB_SET_TXN_TIMEOUT), [dnl
|
||||
Return the timeout value for transactions in this database environment.])
|
||||
m4_tagend])
|
||||
|
||||
m4_param_co(timeoutp, timeout value of the specified m4_arg(flag) parameter)
|
||||
m4_paramend
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
79
docs_src/env/env_set_tmp_dir.so
vendored
Normal file
79
docs_src/env/env_set_tmp_dir.so
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
m4_comment([$Id: env_set_tmp_dir.so,v 10.27 2008/01/15 13:07:24 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dbenv_set_tmp_dir, dbenv_get_tmp_dir])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_tmp_dir),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_tmp_dir(DB_ENV *dbenv, const char *dir);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_tmp_dir(DB_ENV *dbenv, const char **dirp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_tmp_dir(const char *dir);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_tmp_dir(const char **dirp);
|
||||
]))
|
||||
|
||||
m4_idefz(temporary files)
|
||||
|
||||
m4_p([dnl
|
||||
Specify the path of a directory to be used as the location of temporary
|
||||
files. The files created to back in-memory access method databases will
|
||||
be created relative to this path. These temporary files can be quite
|
||||
large, depending on the size of the database.])
|
||||
|
||||
m4_p([dnl
|
||||
If no directories are specified, the following alternatives are checked
|
||||
in the specified order. The first existing directory path is used for
|
||||
all temporary files.])
|
||||
|
||||
m4_nlistbegin
|
||||
m4_nlist([The value of the environment variable m4_envvar(TMPDIR).])
|
||||
m4_nlistns([The value of the environment variable m4_envvar(TEMP).])
|
||||
m4_nlistns([The value of the environment variable m4_envvar(TMP).])
|
||||
m4_nlistns([The value of the environment variable m4_envvar(TempFolder).])
|
||||
m4_nlistns([The value returned by the GetTempPath interface.])
|
||||
m4_nlistns([The directory m4_path(/var/tmp).])
|
||||
m4_nlistns([The directory m4_path(/usr/tmp).])
|
||||
m4_nlistns([The directory m4_path(/temp).])
|
||||
m4_nlistns([The directory m4_path(/tmp).])
|
||||
m4_nlistns([The directory m4_path(C:/temp).])
|
||||
m4_nlistns([The directory m4_path(C:/tmp).])
|
||||
m4_nlistend
|
||||
|
||||
m4_p([dnl
|
||||
Note: environment variables are only checked if one of the
|
||||
m4_ref(DB_USE_ENVIRON) or m4_ref(DB_USE_ENVIRON_ROOT) flags were
|
||||
specified.])
|
||||
|
||||
m4_p([dnl
|
||||
Note: the GetTempPath interface is only checked on Win/32 platforms.])
|
||||
|
||||
m4_env_config(dbenv_set_tmp_dir,
|
||||
[temporary file directory], set_tmp_dir, [the directory name])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_tmp_dir)
|
||||
|
||||
m4_when_any(dbenv_set_tmp_dir)
|
||||
|
||||
m4_return(dbenv_set_tmp_dir, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param_utf8(dir, [dnl
|
||||
The m4_arg(dir) parameter is the directory to be used to store temporary
|
||||
files.])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_tmp_dir,
|
||||
einval, [the method was called after m4_ref(dbenv_open) was called])
|
||||
|
||||
m4_pf_getter(dbenv_get_tmp_dir,
|
||||
database environment temporary file directory,, dirp, reference)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
123
docs_src/env/env_set_verbose.so
vendored
Normal file
123
docs_src/env/env_set_verbose.so
vendored
Normal file
@@ -0,0 +1,123 @@
|
||||
m4_comment([$Id: env_set_verbose.so,v 10.56 2008/01/19 14:12:57 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, [dnl
|
||||
dbenv_set_verbose, dbenv_get_verbose DB_VERB_DEADLOCK,
|
||||
DB_VERB_RECOVERY, DB_VERB_REGISTER, DB_VERB_REPLICATION,
|
||||
DB_VERB_WAITSFOR])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_set_verbose),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__set_verbose(DB_ENV *dbenv, u_int32_t which, int onoff);
|
||||
m4_blank
|
||||
int
|
||||
DB_ENV-__GT__get_verbose(DB_ENV *dbenv, u_int32_t which, int *onoffp);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::set_verbose(u_int32_t which, int onoff);
|
||||
m4_blank
|
||||
int
|
||||
DbEnv::get_verbose(u_int32_t which, int *onoffp);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_set_verbose) turns specific additional informational
|
||||
and debugging messages in the m4_db message output on and off. To see
|
||||
the additional messages, verbose messages must also be configured for
|
||||
the application. For more information on verbose messages, see the
|
||||
m4_refT(dbenv_set_msgfile).])
|
||||
|
||||
m4_env_config(dbenv_set_verbose, messages, set_verbose, [dnl
|
||||
the method m4_arg(which) parameter as a string; for example,
|
||||
"set_verbose DB_VERB_RECOVERY"])
|
||||
|
||||
m4_scope_dbenv(dbenv_set_verbose)
|
||||
|
||||
m4_when_any(dbenv_set_verbose)
|
||||
|
||||
m4_return(dbenv_set_verbose, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(onoff, [dnl
|
||||
If the m4_arg(onoff) parameter is set to non-zero, the additional
|
||||
messages are output.])
|
||||
|
||||
m4_param(which, [dnl
|
||||
The m4_arg(which) parameter must be set to one of the following values:
|
||||
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_VERB_DEADLOCK), [dnl
|
||||
Display additional information when doing deadlock detection.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_FILEOPS), [dnl
|
||||
Display additional information when performing filesystem operations
|
||||
such as open, close or rename. May not be available on all platforms.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_FILEOPS_ALL), [dnl
|
||||
Display additional information when performing all filesystem operations,
|
||||
including read and write. May not be available on all platforms.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_RECOVERY), [dnl
|
||||
Display additional information when performing recovery.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REGISTER), [dnl
|
||||
Display additional information concerning support for the
|
||||
m4_ref(DB_REGISTER) flag to the m4_refT(dbenv_open).])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REPLICATION), [dnl
|
||||
Display all detailed information about replication. This includes the
|
||||
information displayed by all of the other DB_VERB_REP_* and DB_VERB_REPMGR_*
|
||||
values.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REP_ELECT), [dnl
|
||||
Display detailed information about replication elections.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REP_LEASE), [dnl
|
||||
Display detailed information about replication master leases.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REP_MISC), [dnl
|
||||
Display detailed information about general replication processing not
|
||||
covered by the other DB_VERB_REP_* values.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REP_MSGS), [dnl
|
||||
Display detailed information about replication message processing.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REP_SYNC), [dnl
|
||||
Display detailed information about replication client synchronization.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REPMGR_CONNFAIL), [dnl
|
||||
Display detailed information about Replication Manager connection failures.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_REPMGR_MISC), [dnl
|
||||
Display detailed information about general Replication Manager processing.])
|
||||
|
||||
m4_tag(m4_idef(DB_VERB_WAITSFOR), [dnl
|
||||
Display the waits-for table when doing deadlock detection.])
|
||||
m4_tagend])
|
||||
m4_paramend
|
||||
|
||||
m4_err(dbenv_set_verbose, einval)
|
||||
|
||||
m4_pf_description(m4_ref(dbenv_get_verbose))
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_get_verbose) returns whether the specified m4_arg(which)
|
||||
parameter is currently set or not.])
|
||||
|
||||
m4_when_any(dbenv_get_verbose)
|
||||
|
||||
m4_return(dbenv_get_verbose, std)
|
||||
|
||||
m4_parambegin
|
||||
m4_param(which, [dnl
|
||||
The m4_arg(which) parameter is the message value for which configuration
|
||||
is being checked.])
|
||||
m4_param_co(onoffp, [dnl
|
||||
configuration of the specified m4_arg(which) parameter],, [dnl
|
||||
If the returned m4_arg(onoff) value is zero, the parameter is off;
|
||||
otherwise on.])
|
||||
m4_paramend
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
19
docs_src/env/env_stat.so
vendored
Normal file
19
docs_src/env/env_stat.so
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
m4_comment([$Id: env_stat.so,v 10.5 2004/08/13 03:38:57 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, dbenv_stat_print)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_stat_print),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
int
|
||||
DB_ENV-__GT__stat_print(DB_ENV *dbenv, u_int32_t flags);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
int
|
||||
DbEnv::stat_print(u_int32_t flags);
|
||||
]))
|
||||
|
||||
m4_stat_print(dbenv_stat_print,,, no)
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
37
docs_src/env/env_strerror.so
vendored
Normal file
37
docs_src/env/env_strerror.so
vendored
Normal file
@@ -0,0 +1,37 @@
|
||||
m4_comment([$Id: env_strerror.so,v 8.13 2004/08/13 03:38:57 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL, dbenv_strerror)
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_strerror),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
char *
|
||||
db_strerror(int error);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
static char *
|
||||
DbEnv::strerror(int error);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_strerror) returns an error message string corresponding
|
||||
to the error number m4_arg(error) parameter.])
|
||||
|
||||
m4_p([dnl
|
||||
This function is a superset of the m4_ansic_name m4_manref(strerror,
|
||||
3) function. If the error number m4_arg(error) is greater than or
|
||||
equal to 0, then the string returned by the system function
|
||||
m4_manref(strerror, 3) is returned. If the error number is less than
|
||||
0, an error string appropriate to the corresponding m4_db library error
|
||||
is returned. See
|
||||
m4_link(M4RELDIR/ref/program/errorret, [Error returns to applications])
|
||||
for more information.])
|
||||
|
||||
m4_parambegin
|
||||
m4_param(error, [dnl
|
||||
The m4_arg(error) parameter is the error number for which an error message
|
||||
string is wanted.])
|
||||
m4_paramend
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
35
docs_src/env/env_version.so
vendored
Normal file
35
docs_src/env/env_version.so
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
m4_comment([$Id: env_version.so,v 10.26 2004/09/28 15:04:20 bostic Exp $])
|
||||
|
||||
define(M4PAGELOCAL,
|
||||
[dbenv_version, dbenv_get_version_major, dbenv_get_version_minor,
|
||||
dbenv_get_version_patch, dbenv_get_version_string])
|
||||
include(m4/m4.seealso)
|
||||
|
||||
m4_pf_header(m4_ref(dbenv_version),
|
||||
ifelse(M4API, C_API, [dnl
|
||||
char *
|
||||
db_version(int *major, int *minor, int *patch);
|
||||
])
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
static char *
|
||||
DbEnv::version(int *major, int *minor, int *patch);
|
||||
]))
|
||||
|
||||
m4_p([dnl
|
||||
The m4_refT(dbenv_version) returns a pointer to a string, suitable for
|
||||
display, containing m4_db version information.])
|
||||
|
||||
m4_parambegin
|
||||
m4_param(major, [dnl
|
||||
If m4_arg(major) is non-NULL, the major
|
||||
version of the m4_db release is copied to the memory to which it refers.])
|
||||
m4_param(minor, [dnl
|
||||
If m4_arg(minor) is non-NULL, the minor version of the m4_db release
|
||||
is copied to the memory to which it refers.])
|
||||
m4_param(patch, [dnl
|
||||
If m4_arg(patch) is non-NULL, the patch version of the m4_db release
|
||||
is copied to the memory to which it refers.])
|
||||
m4_paramend
|
||||
|
||||
m4_seealso(DbEnv)
|
||||
m4_page_footer
|
||||
47
docs_src/env/m4.methods
vendored
Normal file
47
docs_src/env/m4.methods
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
m4_comment([$Id: m4.methods,v 10.18 2008/01/12 13:42:40 bostic Exp $])
|
||||
|
||||
m4_table_begin(, _center)
|
||||
|
||||
m4_table_header(Database Environment Operations, Description)
|
||||
m4_comment([DbEnv::])m4_table_element(m4_ref(ifelse(M4API, C_API, dbenv_create, DbEnv)), Create an environment handle)
|
||||
m4_comment([Db::get_env])m4_table_element(m4_ref(dbh_getenv), Return m4_ref(Db)'s underlying m4_ref(DbEnv) handle)
|
||||
m4_comment([DbEnv::close])m4_table_element(m4_ref(dbenv_close), Close an environment)
|
||||
m4_comment([DbEnv::dbremove])m4_table_element(m4_ref(dbenv_dbremove), Remove a database)
|
||||
m4_comment([DbEnv::dbrename])m4_table_element(m4_ref(dbenv_dbrename), Rename a database)
|
||||
m4_comment([DbEnv::err])m4_table_element([m4_ref(dbenv_err), m4_ref(dbenv_errx)], Error message)
|
||||
m4_comment([DbEnv::failchk])m4_table_element(m4_ref(dbenv_failchk), Check for thread failure)
|
||||
m4_comment([DbEnv::fileid_reset])m4_table_element(m4_ref(dbenv_fileid_reset), Reset database file IDs)
|
||||
m4_comment([DbEnv::get_home])m4_table_element(m4_ref(dbenv_get_home), Return environment's home directory)
|
||||
m4_comment([DbEnv::get_open_flags])m4_table_element(m4_ref(dbenv_get_open_flags), Return flags with which the environment was opened)
|
||||
m4_comment([DbEnv::lsn_reset])m4_table_element(m4_ref(dbenv_lsn_reset), Reset database file LSNs)
|
||||
m4_comment([DbEnv::open])m4_table_element(m4_ref(dbenv_open), Open an environment)
|
||||
m4_comment([DbEnv::remove])m4_table_element(m4_ref(dbenv_remove), Remove an environment)
|
||||
m4_comment([DbEnv::stat_print])m4_table_element(m4_ref(dbenv_stat_print), Environment statistics)
|
||||
m4_comment([db_strerror])m4_table_element(m4_ref(dbenv_strerror), Error strings)
|
||||
m4_comment([db_version])m4_table_element(m4_ref(dbenv_version), Return version information)
|
||||
|
||||
m4_table_header(Environment Configuration, _empty)
|
||||
m4_comment([DbEnv::set_alloc])m4_table_element(m4_ref(dbenv_set_alloc), Set local space allocation functions)
|
||||
m4_comment([DbEnv::set_app_dispatch])m4_table_element(m4_ref(dbenv_set_app_dispatch), Configure application recovery)
|
||||
m4_comment([DbEnv::set_cachesize])m4_table_element(m4_ref(dbenv_set_cachesize), Set the environment cache size)
|
||||
m4_comment([DbEnv::set_data_dir])m4_table_element(m4_ref(dbenv_set_data_dir), Set the environment data directory)
|
||||
m4_comment([DbEnv::set_encrypt])m4_table_element(m4_ref(dbenv_set_encrypt), Set the environment cryptographic key)
|
||||
m4_comment([DbEnv::set_errcall])m4_table_element([m4_ref(dbenv_set_errcall), m4_ref(dbenv_set_msgcall)], Set error and informational message callbacks)
|
||||
m4_comment([DbEnv::set_errfile])m4_table_element([m4_ref(dbenv_set_errfile), m4_ref(dbenv_set_msgfile)], Set error and informational message FILE)
|
||||
m4_comment([DbEnv::set_error_stream])ifelse(M4API, C_API,, [m4_table_element([m4_ref(dbenv_set_error_stream), m4_ref(dbenv_set_message_stream)], Set error and informational message output stream)])
|
||||
m4_comment([DbEnv::set_errpfx])m4_table_element(m4_ref(dbenv_set_errpfx), Set error message prefix)
|
||||
m4_comment([DbEnv::set_event_notify])m4_table_element(m4_ref(dbenv_set_event_notify), Set event notification callback)
|
||||
m4_comment([DbEnv::set_feedback])m4_table_element(m4_ref(dbenv_set_feedback), Set feedback callback)
|
||||
m4_comment([DbEnv::set_flags])m4_table_element(m4_ref(dbenv_set_flags), Environment configuration)
|
||||
m4_comment([DbEnv::set_isalive])m4_table_element(m4_ref(dbenv_set_isalive), Set thread is-alive callback)
|
||||
m4_comment([DbEnv::set_intermediate_dir_mode])m4_table_element(m4_ref(dbenv_set_intermediate_dir_mode), Set intermediate directory creation mode)
|
||||
m4_comment([DbEnv::set_rpc_server])m4_table_element(m4_ref(dbenv_set_rpc_server), Establish an RPC server connection)
|
||||
m4_comment([DbEnv::set_shm_key])m4_table_element(m4_ref(dbenv_set_shm_key), Set system memory shared segment ID)
|
||||
m4_comment([DbEnv::set_thread_id])m4_table_element(m4_ref(dbenv_set_thread_id), Set thread of control ID function)
|
||||
m4_comment([DbEnv::set_thread_count])m4_table_element(m4_ref(dbenv_set_thread_count), Set approximate thread count)
|
||||
m4_comment([DbEnv::set_thread_id_string])m4_table_element(m4_ref(dbenv_set_thread_id_string), Set thread of control ID format function)
|
||||
m4_comment([DbEnv::set_timeout])m4_table_element(m4_ref(dbenv_set_timeout), Set lock and transaction timeout)
|
||||
m4_comment([DbEnv::set_tmp_dir])m4_table_element(m4_ref(dbenv_set_tmp_dir), Set the environment temporary file directory)
|
||||
m4_comment([DbEnv::set_verbose])m4_table_element(m4_ref(dbenv_set_verbose), Set verbose messages)
|
||||
|
||||
m4_table_end
|
||||
Reference in New Issue
Block a user