Merge pull request #5878

f9b3f6e Removed Berkeley DB and db switching logic (JesusRami)

CMakeLists.txt

@@ -357,54 +357,9 @@ endif()
 # memory was the default in Cryptonote before Monero implemented LMDB, it still works but is unnecessary.
 # set(DATABASE memory)
 set(DATABASE lmdb)
-
+message(STATUS "Using LMDB as default DB type")
-if (DEFINED ENV{DATABASE})
+set(BLOCKCHAIN_DB DB_LMDB)
-  set(DATABASE $ENV{DATABASE})
+add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"")
-  message(STATUS "DATABASE set: ${DATABASE}")
-else()
-  message(STATUS "Could not find DATABASE in env (not required unless you want to change database type from default: ${DATABASE})")
-endif()
-
-set(BERKELEY_DB_OVERRIDE 0)
-if (DEFINED ENV{BERKELEY_DB})
-  set(BERKELEY_DB_OVERRIDE 1)
-  set(BERKELEY_DB $ENV{BERKELEY_DB})
-elseif()
-  set(BERKELEY_DB 0)
-endif()
-
-if (DATABASE STREQUAL "lmdb")
-  message(STATUS "Using LMDB as default DB type")
-  set(BLOCKCHAIN_DB DB_LMDB)
-  add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"")
-elseif (DATABASE STREQUAL "berkeleydb")
-  find_package(BerkeleyDB)
-  if(NOT BERKELEY_DB)
-      die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
-  else()
-    message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}")
-    if(BERKELEY_DB_LIBRARIES)
-      message(STATUS "Found BerkeleyDB shared library")
-      set(BDB_STATIC false CACHE BOOL "BDB Static flag")
-      set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path")
-      set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name")
-      set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs")
-      set(BERKELEY_DB 1)
-    else()
-      die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
-    endif()
-  endif()
-
-  message(STATUS "Using Berkeley DB as default DB type")
-  add_definitions("-DDEFAULT_DB_TYPE=\"berkeley\"")
-else()
-  die("Invalid database type: ${DATABASE}")
-endif()
-
-if(BERKELEY_DB)
-  add_definitions("-DBERKELEY_DB")
-endif()
-
 add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
 
 # Can't install hook in static build on OSX, because OSX linker does not support --wrap
@@ -506,11 +461,6 @@ link_directories(${EASYLOGGING_LIBRARY_DIRS})
 # Final setup for liblmdb
 include_directories(${LMDB_INCLUDE})
 
-# Final setup for Berkeley DB
-if (BERKELEY_DB)
-  include_directories(${BDB_INCLUDE})
-endif()
-
 # Final setup for libunwind
 include_directories(${LIBUNWIND_INCLUDE})
 link_directories(${LIBUNWIND_LIBRARY_DIRS})

cmake/FindBerkeleyDB.cmake

@@ -1,25 +0,0 @@
-# - Try to find Berkeley DB
-# Once done this will define
-#
-#  BERKELEY_DB_FOUND - system has Berkeley DB
-#  BERKELEY_DB_INCLUDE_DIR - the Berkeley DB include directory
-#  BERKELEY_DB_LIBRARIES - Link these to use Berkeley DB
-#  BERKELEY_DB_DEFINITIONS - Compiler switches required for using Berkeley DB
-
-# Copyright (c) 2006, Alexander Dymo, <adymo@kdevelop.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-find_path(BERKELEY_DB_INCLUDE_DIR db_cxx.h
-  /usr/include/db4
-  /usr/local/include/db4
-)
-
-find_library(BERKELEY_DB_LIBRARIES NAMES db_cxx )
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Berkeley "Could not find Berkeley DB >= 4.1" BERKELEY_DB_INCLUDE_DIR BERKELEY_DB_LIBRARIES)
-# show the BERKELEY_DB_INCLUDE_DIR and BERKELEY_DB_LIBRARIES variables only in the advanced view
-mark_as_advanced(BERKELEY_DB_INCLUDE_DIR BERKELEY_DB_LIBRARIES )
-

src/blockchain_db/CMakeLists.txt

@@ -31,14 +31,6 @@ set(blockchain_db_sources
   lmdb/db_lmdb.cpp
   )
 
-if (BERKELEY_DB)
-  set(blockchain_db_sources
-  ${blockchain_db_sources}
-  berkeleydb/db_bdb.cpp
-  )
-endif()
-
-
 set(blockchain_db_headers)
 
 set(blockchain_db_private_headers
@@ -46,13 +38,6 @@ set(blockchain_db_private_headers
   lmdb/db_lmdb.h
   )
 
-if (BERKELEY_DB)
-  set(blockchain_db_private_headers
-  ${blockchain_db_private_headers}
-  berkeleydb/db_bdb.h
-  )
-endif()
-
 monero_private_headers(blockchain_db
   ${crypto_private_headers})
 monero_add_library(blockchain_db
@@ -65,7 +50,6 @@ target_link_libraries(blockchain_db
     cncrypto
     ringct
     ${LMDB_LIBRARY}
-    ${BDB_LIBRARY}
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_THREAD_LIBRARY}
   PRIVATE

src/blockchain_db/berkeleydb/db_bdb.h

@@ -1,452 +0,0 @@
-// Copyright (c) 2014-2019, The Monero Project
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <db_cxx.h>
-
-#include "blockchain_db/blockchain_db.h"
-#include "cryptonote_basic/blobdatatype.h" // for type blobdata
-
-#include <unordered_map>
-#include <condition_variable>
-
-// ND: Enables multi-threaded bulk reads for when getting indices.
-//     TODO: Disabled for now, as it doesn't seem to provide noticeable improvements (??. Reason: TBD.
-// #define BDB_BULK_CAN_THREAD
-namespace cryptonote
-{
-
-struct bdb_txn_safe
-{
-  bdb_txn_safe() : m_txn(NULL) { }
-  ~bdb_txn_safe()
-  {
-    LOG_PRINT_L3("bdb_txn_safe: destructor");
-
-    if (m_txn != NULL)
-      abort();
-  }
-
-  void commit(std::string message = "")
-  {
-    if (message.size() == 0)
-    {
-      message = "Failed to commit a transaction to the db";
-    }
-
-    if (m_txn->commit(0))
-    {
-      m_txn = NULL;
-      LOG_PRINT_L0(message);
-      throw DB_ERROR(message.c_str());
-    }
-    m_txn = NULL;
-  }
-
-  void abort()
-  {
-    LOG_PRINT_L3("bdb_txn_safe: abort()");
-    if(m_txn != NULL)
-    {
-      m_txn->abort();
-      m_txn = NULL;
-    }
-    else
-    {
-      LOG_PRINT_L0("WARNING: bdb_txn_safe: abort() called, but m_txn is NULL");
-    }
-  }
-
-  operator DbTxn*()
-  {
-    return m_txn;
-  }
-
-  operator DbTxn**()
-  {
-    return &m_txn;
-  }
-private:
-  DbTxn* m_txn;
-};
-
-// ND: Class to handle buffer management when doing bulk queries
-// (DB_MULTIPLE). Allocates buffers then handles thread queuing
-// so a fixed set of buffers can be used (instead of allocating
-// every time a bulk query is needed).
-template <typename T>
-class bdb_safe_buffer
-{
-  // limit the number of buffers to 8
-  const size_t MaxAllowedBuffers = 8;
-public:
-    bdb_safe_buffer(size_t num_buffers, size_t count)
-    {
-      if(num_buffers > MaxAllowedBuffers)
-        num_buffers = MaxAllowedBuffers;
-
-      set_count(num_buffers);
-      for (size_t i = 0; i < num_buffers; i++)
-        m_buffers.push_back((T) malloc(sizeof(T) * count));
-      m_buffer_count = count;
-    }
-
-    ~bdb_safe_buffer()
-    {
-        for (size_t i = 0; i < m_buffers.size(); i++)
-        {
-            if (m_buffers[i])
-            {
-                free(m_buffers[i]);
-                m_buffers[i] = nullptr;
-            }
-        }
-
-        m_buffers.resize(0);
-    }
-
-    T acquire_buffer()
-    {
-        boost::unique_lock<boost::mutex> lock(m_lock);
-        m_cv.wait(lock, [&]{ return m_count > 0; });
-
-        --m_count;
-        size_t index = -1;
-        for (size_t i = 0; i < m_open_slot.size(); i++)
-        {
-            if (m_open_slot[i])
-            {
-                m_open_slot[i] = false;
-                index = i;
-                break;
-            }
-        }
-
-        assert(index >= 0);
-
-        T buffer = m_buffers[index];
-        m_buffer_map.emplace(buffer, index);
-        return buffer;
-    }
-
-    void release_buffer(T buffer)
-    {
-        boost::unique_lock<boost::mutex> lock(m_lock);
-
-        assert(buffer != nullptr);
-        auto it = m_buffer_map.find(buffer);
-        if (it != m_buffer_map.end())
-        {
-            auto index = it->second;
-
-            assert(index < m_open_slot.size());
-            assert(m_open_slot[index] == false);
-            assert(m_count < m_open_slot.size());
-
-            ++m_count;
-            m_open_slot[index] = true;
-            m_buffer_map.erase(it);
-            m_cv.notify_one();
-        }
-    }
-
-    size_t get_buffer_size() const
-    {
-        return m_buffer_count * sizeof(T);
-    }
-
-    size_t get_buffer_count() const
-    {
-        return m_buffer_count;
-    }
-
-    typedef T type;
-
-private:
-    void set_count(size_t count)
-    {
-        assert(count > 0);
-        m_open_slot.resize(count, true);
-        m_count = count;
-    }
-
-    std::vector<T> m_buffers;
-    std::unordered_map<T, size_t> m_buffer_map;
-
-    boost::condition_variable m_cv;
-    std::vector<bool> m_open_slot;
-    size_t m_count;
-    boost::mutex m_lock;
-
-    size_t m_buffer_count;
-};
-
-template <typename T>
-class bdb_safe_buffer_autolock
-{
-public:
-    bdb_safe_buffer_autolock(T &safe_buffer, typename T::type &buffer) :
-        m_safe_buffer(safe_buffer), m_buffer(nullptr)
-    {
-        m_buffer = m_safe_buffer.acquire_buffer();
-        buffer = m_buffer;
-    }
-
-    ~bdb_safe_buffer_autolock()
-    {
-        if (m_buffer != nullptr)
-        {
-            m_safe_buffer.release_buffer(m_buffer);
-            m_buffer = nullptr;
-        }
-    }
-private:
-    T &m_safe_buffer;
-    typename T::type m_buffer;
-};
-
-class BlockchainBDB : public BlockchainDB
-{
-public:
-  BlockchainBDB(bool batch_transactions=false);
-  ~BlockchainBDB();
-
-  virtual void open(const std::string& filename, const int db_flags);
-
-  virtual void close();
-
-  virtual void sync();
-
-  virtual void reset();
-
-  virtual std::vector<std::string> get_filenames() const;
-
-  virtual bool remove_data_file(const std::string& folder);
-
-  virtual std::string get_db_name() const;
-
-  virtual bool lock();
-
-  virtual void unlock();
-
-  virtual bool block_exists(const crypto::hash& h, uint64_t *height = NULL) const;
-
-  virtual block get_block(const crypto::hash& h) const;
-
-  virtual uint64_t get_block_height(const crypto::hash& h) const;
-
-  virtual block_header get_block_header(const crypto::hash& h) const;
-
-  virtual block get_block_from_height(const uint64_t& height) const;
-
-  virtual uint64_t get_block_timestamp(const uint64_t& height) const;
-
-  virtual uint64_t get_top_block_timestamp() const;
-
-  virtual size_t get_block_weight(const uint64_t& height) const;
-
-  virtual difficulty_type get_block_cumulative_difficulty(const uint64_t& height) const;
-
-  virtual difficulty_type get_block_difficulty(const uint64_t& height) const;
-
-  virtual uint64_t get_block_already_generated_coins(const uint64_t& height) const;
-
-  virtual crypto::hash get_block_hash_from_height(const uint64_t& height) const;
-
-  virtual std::vector<block> get_blocks_range(const uint64_t& h1, const uint64_t& h2) const;
-
-  virtual std::vector<crypto::hash> get_hashes_range(const uint64_t& h1, const uint64_t& h2) const;
-
-  virtual crypto::hash top_block_hash() const;
-
-  virtual block get_top_block() const;
-
-  virtual uint64_t height() const;
-
-  virtual bool tx_exists(const crypto::hash& h) const;
-
-  virtual uint64_t get_tx_unlock_time(const crypto::hash& h) const;
-
-  virtual transaction get_tx(const crypto::hash& h) const;
-
-  virtual uint64_t get_tx_count() const;
-
-  virtual std::vector<transaction> get_tx_list(const std::vector<crypto::hash>& hlist) const;
-
-  virtual uint64_t get_tx_block_height(const crypto::hash& h) const;
-
-  virtual uint64_t get_num_outputs(const uint64_t& amount) const;
-
-  virtual uint64_t get_indexing_base() const { return 1; }
-
-  virtual output_data_t get_output_key(const uint64_t& amount, const uint64_t& index);
-  virtual void get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs);
-
-  virtual tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const;
-  virtual void get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
-          std::vector<tx_out_index> &tx_out_indices) const;
-
-  virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index);
-  virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices);
-
-  virtual std::vector<uint64_t> get_tx_amount_output_indices(const crypto::hash& h) const;
-
-  virtual bool has_key_image(const crypto::key_image& img) const;
-
-  virtual uint64_t add_block( const block& blk
-                            , size_t block_weight
-                            , const difficulty_type& cumulative_difficulty
-                            , const uint64_t& coins_generated
-                            , const std::vector<transaction>& txs
-                            );
-
-  virtual void set_batch_transactions(bool batch_transactions);
-  virtual bool batch_start(uint64_t batch_num_blocks=0);
-  virtual void batch_commit();
-  virtual void batch_stop();
-  virtual void batch_abort();
-
-  virtual void block_txn_start(bool readonly);
-  virtual void block_txn_stop();
-  virtual void block_txn_abort();
-
-  virtual void pop_block(block& blk, std::vector<transaction>& txs);
-
-#if defined(BDB_BULK_CAN_THREAD)
-  virtual bool can_thread_bulk_indices() const { return true; }
-#else
-  virtual bool can_thread_bulk_indices() const { return false; }
-#endif
-
-  /**
-   * @brief return a histogram of outputs on the blockchain
-   *
-   * @param amounts optional set of amounts to lookup
-   *
-   * @return a set of amount/instances
-   */
-  std::map<uint64_t, uint64_t> get_output_histogram(const std::vector<uint64_t> &amounts) const;
-
-private:
-  virtual void add_block( const block& blk
-                , size_t block_weight
-                , const difficulty_type& cumulative_difficulty
-                , const uint64_t& coins_generated
-                , const crypto::hash& block_hash
-                );
-
-  virtual void remove_block();
-
-  virtual void add_transaction_data(const crypto::hash& blk_hash, const transaction& tx, const crypto::hash& tx_hash, const crypto::hash& tx_prunable_hash);
-
-  virtual void remove_transaction_data(const crypto::hash& tx_hash, const transaction& tx);
-
-  virtual void add_output(const crypto::hash& tx_hash, const tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time, const rct::key *commitment);
-
-  virtual void remove_output(const tx_out& tx_output);
-
-  void remove_tx_outputs(const crypto::hash& tx_hash, const transaction& tx);
-
-  void remove_output(const uint64_t& out_index, const uint64_t amount);
-  void remove_amount_output_index(const uint64_t amount, const uint64_t global_output_index);
-
-  virtual void add_spent_key(const crypto::key_image& k_image);
-
-  virtual void remove_spent_key(const crypto::key_image& k_image);
-
-  void get_output_global_indices(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<uint64_t> &global_indices);
-
-  virtual bool for_all_key_images(std::function<bool(const crypto::key_image&)>) const;
-  virtual bool for_all_blocks(std::function<bool(uint64_t, const crypto::hash&, const cryptonote::block&)>) const;
-  virtual bool for_all_transactions(std::function<bool(const crypto::hash&, const cryptonote::transaction&)>, bool pruned) const;
-  virtual bool for_all_outputs(std::function<bool(uint64_t amount, const crypto::hash &tx_hash, size_t tx_idx)> f) const;
-
-  // Hard fork related storage
-  virtual void set_hard_fork_version(uint64_t height, uint8_t version);
-  virtual uint8_t get_hard_fork_version(uint64_t height) const;
-  virtual void check_hard_fork_info();
-  virtual void drop_hard_fork_info();
-
-  /**
-   * @brief get the global index of the index-th output of the given amount
-   *
-   * @param amount the output amount
-   * @param index the index into the set of outputs of that amount
-   *
-   * @return the global index of the desired output
-   */
-  uint64_t get_output_global_index(const uint64_t& amount, const uint64_t& index);
-  output_data_t get_output_key(const uint64_t& global_index) const;
-  void checkpoint_worker() const;
-  void check_open() const;
-
-  virtual bool is_read_only() const;
-
-  //
-  // fix up anything that may be wrong due to past bugs
-  virtual void fixup();
-
-  bool m_run_checkpoint;
-  std::unique_ptr<boost::thread> m_checkpoint_thread;
-  typedef bdb_safe_buffer<void *> bdb_safe_buffer_t;
-  bdb_safe_buffer_t m_buffer;
-
-  DbEnv* m_env;
-
-  Db* m_blocks;
-  Db* m_block_heights;
-  Db* m_block_hashes;
-  Db* m_block_timestamps;
-  Db* m_block_sizes;
-  Db* m_block_diffs;
-  Db* m_block_coins;
-
-  Db* m_txs;
-  Db* m_tx_unlocks;
-  Db* m_tx_heights;
-  Db* m_tx_outputs;
-
-  Db* m_output_txs;
-  Db* m_output_indices;
-  Db* m_output_amounts;
-  Db* m_output_keys;
-
-  Db* m_spent_keys;
-
-  Db* m_hf_starting_heights;
-  Db* m_hf_versions;
-
-  Db* m_properties;
-
-  uint64_t m_height;
-  uint64_t m_num_outputs;
-  std::string m_folder;
-  bdb_txn_safe *m_write_txn;
-
-  bool m_batch_transactions; // support for batch transactions
-};
-
-}  // namespace cryptonote

src/blockchain_db/blockchain_db.cpp

@@ -35,17 +35,6 @@
 #include "ringct/rctOps.h"
 
 #include "lmdb/db_lmdb.h"
-#ifdef BERKELEY_DB
-#include "berkeleydb/db_bdb.h"
-#endif
-
-static const char *db_types[] = {
-  "lmdb",
-#ifdef BERKELEY_DB
-  "berkeley",
-#endif
-  NULL
-};
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "blockchain.db"
@@ -55,36 +44,6 @@ using epee::string_tools::pod_to_hex;
 namespace cryptonote
 {
 
-bool blockchain_valid_db_type(const std::string& db_type)
-{
-  int i;
-  for (i=0; db_types[i]; i++)
-  {
-    if (db_types[i] == db_type)
-      return true;
-  }
-  return false;
-}
-
-std::string blockchain_db_types(const std::string& sep)
-{
-  int i;
-  std::string ret = "";
-  for (i=0; db_types[i]; i++)
-  {
-    if (i)
-      ret += sep;
-    ret += db_types[i];
-  }
-  return ret;
-}
-
-std::string arg_db_type_description = "Specify database type, available: " + cryptonote::blockchain_db_types(", ");
-const command_line::arg_descriptor<std::string> arg_db_type = {
-  "db-type"
-, arg_db_type_description.c_str()
-, DEFAULT_DB_TYPE
-};
 const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
   "db-sync-mode"
 , "Specify sync option, using format [safe|fast|fastest]:[sync|async]:[<nblocks_per_sync>[blocks]|<nbytes_per_sync>[bytes]]." 
@@ -96,20 +55,13 @@ const command_line::arg_descriptor<bool> arg_db_salvage  = {
 , false
 };
 
-BlockchainDB *new_db(const std::string& db_type)
+BlockchainDB *new_db()
 {
-  if (db_type == "lmdb")
   return new BlockchainLMDB();
-#if defined(BERKELEY_DB)
-  if (db_type == "berkeley")
-    return new BlockchainBDB();
-#endif
-  return NULL;
 }
 
 void BlockchainDB::init_options(boost::program_options::options_description& desc)
 {
-  command_line::add_arg(desc, arg_db_type);
   command_line::add_arg(desc, arg_db_sync_mode);
   command_line::add_arg(desc, arg_db_salvage);
 }

src/blockchain_db/blockchain_db.h

@@ -102,7 +102,6 @@ namespace cryptonote
 /** a pair of <transaction hash, output index>, typedef for convenience */
 typedef std::pair<crypto::hash, uint64_t> tx_out_index;
 
-extern const command_line::arg_descriptor<std::string> arg_db_type;
 extern const command_line::arg_descriptor<std::string> arg_db_sync_mode;
 extern const command_line::arg_descriptor<bool, false> arg_db_salvage;
 
@@ -1826,7 +1825,7 @@ private:
 class db_rtxn_guard: public db_txn_guard { public: db_rtxn_guard(BlockchainDB *db): db_txn_guard(db, true) {} };
 class db_wtxn_guard: public db_txn_guard { public: db_wtxn_guard(BlockchainDB *db): db_txn_guard(db, false) {} };
 
-BlockchainDB *new_db(const std::string& db_type);
+BlockchainDB *new_db();
 
 }  // namespace cryptonote
 

src/blockchain_db/db_types.h

@@ -1,36 +0,0 @@
-// Copyright (c) 2014-2019, The Monero Project
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
-#pragma once
-
-namespace cryptonote
-{
-  bool blockchain_valid_db_type(const std::string& db_type);
-  std::string blockchain_db_types(const std::string& sep);
-} // namespace cryptonote

src/blockchain_utilities/blockchain_ancestry.cpp

@@ -40,7 +40,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -336,11 +335,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -350,9 +344,6 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<std::string> arg_txid  = {"txid", "Get ancestry for this txid", ""};
   const command_line::arg_descriptor<std::string> arg_output  = {"output", "Get ancestry for this output (amount/offset format)", ""};
   const command_line::arg_descriptor<uint64_t> arg_height  = {"height", "Get ancestry for all txes at this height", 0};
@@ -367,7 +358,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_txid);
   command_line::add_arg(desc_cmd_sett, arg_output);
   command_line::add_arg(desc_cmd_sett, arg_height);
@@ -446,13 +436,6 @@ int main(int argc, char* argv[])
     }
   }
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   // If we wanted to use the memory pool, we would set up a fake_core.
 
   // Use Blockchain instead of lower-level BlockchainDB for two reasons:
@@ -468,13 +451,13 @@ int main(int argc, char* argv[])
   std::unique_ptr<Blockchain> core_storage;
   tx_memory_pool m_mempool(*core_storage);
   core_storage.reset(new Blockchain(m_mempool));
-  BlockchainDB *db = new_db(db_type);
+  BlockchainDB *db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
+  LOG_PRINT_L0("database: LMDB");
 
   const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
   LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");

src/blockchain_utilities/blockchain_blackball.cpp

@@ -39,7 +39,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "wallet/ringdb.h"
 #include "version.h"
 
@@ -1170,11 +1169,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -1188,9 +1182,6 @@ int main(int argc, char* argv[])
       get_default_db_path(),
   };
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<bool> arg_rct_only  = {"rct-only", "Only work on ringCT outputs", false};
   const command_line::arg_descriptor<bool> arg_check_subsets  = {"check-subsets", "Check ring subsets (very expensive)", false};
   const command_line::arg_descriptor<bool> arg_verbose  = {"verbose", "Verbose output)", false};
@@ -1207,7 +1198,6 @@ int main(int argc, char* argv[])
 
   command_line::add_arg(desc_cmd_sett, arg_blackball_db_dir);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_rct_only);
   command_line::add_arg(desc_cmd_sett, arg_check_subsets);
   command_line::add_arg(desc_cmd_sett, arg_verbose);
@@ -1261,12 +1251,6 @@ int main(int argc, char* argv[])
   std::string extra_spent_list = command_line::get_arg(vm, arg_extra_spent_list);
   std::vector<std::pair<uint64_t, uint64_t>> extra_spent_outputs = extra_spent_list.empty() ? std::vector<std::pair<uint64_t, uint64_t>>() : load_outputs(extra_spent_list);
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
 
   std::string db_sync_mode = command_line::get_arg(vm, arg_db_sync_mode);
   if (!parse_db_sync_mode(db_sync_mode))

src/blockchain_utilities/blockchain_depth.cpp

@@ -34,7 +34,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -50,11 +49,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -64,9 +58,6 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<std::string> arg_txid  = {"txid", "Get min depth for this txid", ""};
   const command_line::arg_descriptor<uint64_t> arg_height  = {"height", "Get min depth for all txes at this height", 0};
   const command_line::arg_descriptor<bool> arg_include_coinbase  = {"include-coinbase", "Include coinbase in the average", false};
@@ -75,7 +66,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_txid);
   command_line::add_arg(desc_cmd_sett, arg_height);
   command_line::add_arg(desc_cmd_sett, arg_include_coinbase);
@@ -133,13 +123,6 @@ int main(int argc, char* argv[])
     }
   }
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   // If we wanted to use the memory pool, we would set up a fake_core.
 
   // Use Blockchain instead of lower-level BlockchainDB for two reasons:
@@ -155,13 +138,13 @@ int main(int argc, char* argv[])
   std::unique_ptr<Blockchain> core_storage;
   tx_memory_pool m_mempool(*core_storage);
   core_storage.reset(new Blockchain(m_mempool));
-  BlockchainDB *db = new_db(db_type);
+  BlockchainDB *db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
+  LOG_PRINT_L0("database: LMDB");
 
   const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
   LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");

src/blockchain_utilities/blockchain_export.cpp

@@ -32,7 +32,6 @@
 #include "cryptonote_core/tx_pool.h"
 #include "cryptonote_core/cryptonote_core.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -47,11 +46,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
   uint64_t block_stop = 0;
   bool blocks_dat = false;
@@ -65,9 +59,6 @@ int main(int argc, char* argv[])
   const command_line::arg_descriptor<std::string> arg_output_file = {"output-file", "Specify output file", "", true};
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
   const command_line::arg_descriptor<uint64_t> arg_block_stop = {"block-stop", "Stop at block number", block_stop};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<bool> arg_blocks_dat = {"blocksdat", "Output in blocks.dat format", blocks_dat};
 
 
@@ -76,7 +67,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_block_stop);
   command_line::add_arg(desc_cmd_sett, arg_blocks_dat);
 
@@ -124,13 +114,6 @@ int main(int argc, char* argv[])
 
   m_config_folder = command_line::get_arg(vm, cryptonote::arg_data_dir);
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   if (command_line::has_arg(vm, arg_output_file))
     output_file_path = boost::filesystem::path(command_line::get_arg(vm, arg_output_file));
   else
@@ -153,13 +136,13 @@ int main(int argc, char* argv[])
   tx_memory_pool m_mempool(*core_storage);
   core_storage = new Blockchain(m_mempool);
 
-  BlockchainDB* db = new_db(db_type);
+  BlockchainDB* db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
+  LOG_PRINT_L0("database: LMDB");
 
   boost::filesystem::path folder(m_config_folder);
   folder /= db->get_db_name();

src/blockchain_utilities/blockchain_import.cpp

@@ -42,7 +42,6 @@
 #include "serialization/binary_utils.h" // dump_binary(), parse_binary()
 #include "serialization/json_utils.h" // dump_json()
 #include "include_base_utils.h"
-#include "blockchain_db/db_types.h"
 #include "cryptonote_core/cryptonote_core.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -93,44 +92,6 @@ int get_db_flags_from_mode(const std::string& db_mode)
   return db_flags;
 }
 
-int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int& db_flags)
-{
-  std::vector<std::string> db_args;
-  boost::split(db_args, db_arg_str, boost::is_any_of("#"));
-  db_type = db_args.front();
-  boost::algorithm::trim(db_type);
-
-  if (db_args.size() == 1)
-  {
-    return 0;
-  }
-  else if (db_args.size() > 2)
-  {
-    std::cerr << "unrecognized database argument format: " << db_arg_str << ENDL;
-    return 1;
-  }
-
-  std::string db_arg_str2 = db_args[1];
-  boost::split(db_args, db_arg_str2, boost::is_any_of(","));
-
-  // optionally use a composite mode instead of individual flags
-  const std::unordered_set<std::string> db_modes {"safe", "fast", "fastest"};
-  std::string db_mode;
-  if (db_args.size() == 1)
-  {
-    if (db_modes.count(db_args[0]) > 0)
-    {
-      db_mode = db_args[0];
-    }
-  }
-  if (! db_mode.empty())
-  {
-    db_flags = get_db_flags_from_mode(db_mode);
-  }
-  return 0;
-}
-
-
 int pop_blocks(cryptonote::core& core, int num_blocks)
 {
   bool use_batch = opt_batch;
@@ -594,11 +555,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
   uint64_t num_blocks = 0;
   uint64_t block_stop = 0;
@@ -622,9 +578,6 @@ int main(int argc, char* argv[])
       , "Count blocks in bootstrap file and exit"
       , false
   };
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<bool> arg_noverify =  {"dangerous-unverified-import",
     "Blindly trust the import file and use potentially malicious blocks and transactions during import (only enable if you exported the file yourself)", false};
   const command_line::arg_descriptor<bool> arg_batch  =  {"batch",
@@ -634,7 +587,6 @@ int main(int argc, char* argv[])
 
   command_line::add_arg(desc_cmd_sett, arg_input_file);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_batch_size);
   command_line::add_arg(desc_cmd_sett, arg_block_stop);
 
@@ -709,7 +661,6 @@ int main(int argc, char* argv[])
     return 1;
   }
   m_config_folder = command_line::get_arg(vm, cryptonote::arg_data_dir);
-  db_arg_str = command_line::get_arg(vm, arg_database);
 
   mlog_configure(mlog_get_default_log_path("monero-blockchain-import.log"), true);
   if (!command_line::is_arg_defaulted(vm, arg_log_level))
@@ -735,25 +686,7 @@ int main(int argc, char* argv[])
     return 0;
   }
 
-
+  MINFO("database: LMDB");
-  std::string db_type;
-  int db_flags = 0;
-  int res = 0;
-  res = parse_db_arguments(db_arg_str, db_type, db_flags);
-  if (res)
-  {
-    std::cerr << "Error parsing database argument(s)" << ENDL;
-    return 1;
-  }
-
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
-  MINFO("database: " << db_type);
-  MINFO("database flags: " << db_flags);
   MINFO("verify:  " << std::boolalpha << opt_verify << std::noboolalpha);
   if (opt_batch)
   {

src/blockchain_utilities/blockchain_prune.cpp

@@ -35,7 +35,6 @@
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
 #include "blockchain_db/lmdb/db_lmdb.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -441,11 +440,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -455,9 +449,6 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
     "db-sync-mode"
   , "Specify sync option, using format [safe|fast|fastest]:[nrecords_per_sync]."
@@ -469,7 +460,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_db_sync_mode);
   command_line::add_arg(desc_cmd_sett, arg_copy_pruned_database);
   command_line::add_arg(desc_cmd_only, command_line::arg_help);
@@ -511,18 +501,6 @@ int main(int argc, char* argv[])
   while (boost::ends_with(data_dir, "/") || boost::ends_with(data_dir, "\\"))
     data_dir.pop_back();
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    MERROR("Invalid database type: " << db_type);
-    return 1;
-  }
-  if (db_type != "lmdb")
-  {
-    MERROR("Unsupported database type: " << db_type << ". Only lmdb is supported");
-    return 1;
-  }
-
   std::string db_sync_mode = command_line::get_arg(vm, arg_db_sync_mode);
   uint64_t db_flags = 0;
   if (!parse_db_sync_mode(db_sync_mode, db_flags))
@@ -552,13 +530,12 @@ int main(int argc, char* argv[])
   {
     core_storage[n].reset(new Blockchain(m_mempool));
 
-    BlockchainDB* db = new_db(db_type);
+    BlockchainDB* db = new_db();
     if (db == NULL)
     {
-      MERROR("Attempted to use non-existent database type: " << db_type);
+      MERROR("Failed to initialize a database");
-      throw std::runtime_error("Attempting to use non-existent database type");
+      throw std::runtime_error("Failed to initialize a database");
     }
-    MDEBUG("database: " << db_type);
 
     if (n == 1)
     {

src/blockchain_utilities/blockchain_prune_known_spent_data.cpp

@@ -33,7 +33,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -102,11 +101,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -114,9 +108,6 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<bool> arg_verbose  = {"verbose", "Verbose output", false};
   const command_line::arg_descriptor<bool> arg_dry_run  = {"dry-run", "Do not actually prune", false};
   const command_line::arg_descriptor<std::string> arg_input = {"input", "Path to the known spent outputs file"};
@@ -125,7 +116,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_verbose);
   command_line::add_arg(desc_cmd_sett, arg_dry_run);
   command_line::add_arg(desc_cmd_sett, arg_input);
@@ -167,26 +157,18 @@ int main(int argc, char* argv[])
   bool opt_verbose = command_line::get_arg(vm, arg_verbose);
   bool opt_dry_run = command_line::get_arg(vm, arg_dry_run);
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   const std::string input = command_line::get_arg(vm, arg_input);
 
   LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
   std::unique_ptr<Blockchain> core_storage;
   tx_memory_pool m_mempool(*core_storage);
   core_storage.reset(new Blockchain(m_mempool));
-  BlockchainDB *db = new_db(db_type);
+  BlockchainDB *db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
 
   const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
   LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");

src/blockchain_utilities/blockchain_stats.cpp

@@ -34,7 +34,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -52,11 +51,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
   uint64_t block_start = 0;
   uint64_t block_stop = 0;
@@ -68,9 +62,6 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<uint64_t> arg_block_start  = {"block-start", "start at block number", block_start};
   const command_line::arg_descriptor<uint64_t> arg_block_stop = {"block-stop", "Stop at block number", block_stop};
   const command_line::arg_descriptor<bool> arg_inputs  = {"with-inputs", "with input stats", false};
@@ -82,7 +73,6 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_block_start);
   command_line::add_arg(desc_cmd_sett, arg_block_stop);
   command_line::add_arg(desc_cmd_sett, arg_inputs);
@@ -131,24 +121,16 @@ int main(int argc, char* argv[])
   bool do_ringsize = command_line::get_arg(vm, arg_ringsize);
   bool do_hours = command_line::get_arg(vm, arg_hours);
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
   std::unique_ptr<Blockchain> core_storage;
   tx_memory_pool m_mempool(*core_storage);
   core_storage.reset(new Blockchain(m_mempool));
-  BlockchainDB *db = new_db(db_type);
+  BlockchainDB *db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
 
   const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
   LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");

src/blockchain_utilities/blockchain_usage.cpp

@@ -34,7 +34,6 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -82,11 +81,6 @@ int main(int argc, char* argv[])
 
   epee::string_tools::set_module_name_and_folder(argv[0]);
 
-  std::string default_db_type = "lmdb";
-
-  std::string available_dbs = cryptonote::blockchain_db_types(", ");
-  available_dbs = "available: " + available_dbs;
-
   uint32_t log_level = 0;
 
   tools::on_startup();
@@ -96,16 +90,12 @@ int main(int argc, char* argv[])
   po::options_description desc_cmd_only("Command line options");
   po::options_description desc_cmd_sett("Command line options and settings options");
   const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
-  const command_line::arg_descriptor<std::string> arg_database = {
-    "database", available_dbs.c_str(), default_db_type
-  };
   const command_line::arg_descriptor<bool> arg_rct_only  = {"rct-only", "Only work on ringCT outputs", false};
   const command_line::arg_descriptor<std::string> arg_input = {"input", ""};
 
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
   command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
   command_line::add_arg(desc_cmd_sett, arg_log_level);
-  command_line::add_arg(desc_cmd_sett, arg_database);
   command_line::add_arg(desc_cmd_sett, arg_rct_only);
   command_line::add_arg(desc_cmd_sett, arg_input);
   command_line::add_arg(desc_cmd_only, command_line::arg_help);
@@ -147,13 +137,6 @@ int main(int argc, char* argv[])
   network_type net_type = opt_testnet ? TESTNET : opt_stagenet ? STAGENET : MAINNET;
   bool opt_rct_only = command_line::get_arg(vm, arg_rct_only);
 
-  std::string db_type = command_line::get_arg(vm, arg_database);
-  if (!cryptonote::blockchain_valid_db_type(db_type))
-  {
-    std::cerr << "Invalid database type: " << db_type << std::endl;
-    return 1;
-  }
-
   // If we wanted to use the memory pool, we would set up a fake_core.
 
   // Use Blockchain instead of lower-level BlockchainDB for two reasons:
@@ -170,13 +153,13 @@ int main(int argc, char* argv[])
   std::unique_ptr<Blockchain> core_storage;
   tx_memory_pool m_mempool(*core_storage);
   core_storage.reset(new Blockchain(m_mempool));
-  BlockchainDB* db = new_db(db_type);
+  BlockchainDB* db = new_db();
   if (db == NULL)
   {
-    LOG_ERROR("Attempted to use non-existent database type: " << db_type);
+    LOG_ERROR("Failed to initialize a database");
-    throw std::runtime_error("Attempting to use non-existent database type");
+    throw std::runtime_error("Failed to initialize a database");
   }
-  LOG_PRINT_L0("database: " << db_type);
+  LOG_PRINT_L0("database: LMDB");
 
   const std::string filename = input;
   LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");

src/cryptonote_core/cryptonote_core.cpp

@@ -455,7 +455,6 @@ namespace cryptonote
     bool r = handle_command_line(vm);
     CHECK_AND_ASSERT_MES(r, false, "Failed to handle command line");
 
-    std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
     std::string db_sync_mode = command_line::get_arg(vm, cryptonote::arg_db_sync_mode);
     bool db_salvage = command_line::get_arg(vm, cryptonote::arg_db_salvage) != 0;
     bool fast_sync = command_line::get_arg(vm, arg_fast_block_sync) != 0;
@@ -489,10 +488,10 @@ namespace cryptonote
     // folder might not be a directory, etc, etc
     catch (...) { }
 
-    std::unique_ptr<BlockchainDB> db(new_db(db_type));
+    std::unique_ptr<BlockchainDB> db(new_db());
     if (db == NULL)
     {
-      LOG_ERROR("Attempted to use non-existent database type");
+      LOG_ERROR("Failed to initialize a database");
       return false;
     }
 

src/daemon/main.cpp

@@ -44,7 +44,6 @@
 #include "rpc/core_rpc_server.h"
 #include "rpc/rpc_args.h"
 #include "daemon/command_line_args.h"
-#include "blockchain_db/db_types.h"
 #include "version.h"
 
 #ifdef STACK_TRACE
@@ -224,16 +223,6 @@ int main(int argc, char const * argv[])
       return 1;
     }
 
-    std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
-
-    // verify that blockchaindb type is valid
-    if(!cryptonote::blockchain_valid_db_type(db_type))
-    {
-      std::cout << "Invalid database type (" << db_type << "), available types are: " <<
-        cryptonote::blockchain_db_types(", ") << std::endl;
-      return 0;
-    }
-
     // data_dir
     //   default: e.g. ~/.bitmonero/ or ~/.bitmonero/testnet
     //   if data-dir argument given:

tests/unit_tests/blockchain_db.cpp

@@ -38,9 +38,6 @@
 #include "string_tools.h"
 #include "blockchain_db/blockchain_db.h"
 #include "blockchain_db/lmdb/db_lmdb.h"
-#ifdef BERKELEY_DB
-#include "blockchain_db/berkeleydb/db_bdb.h"
-#endif
 #include "cryptonote_basic/cryptonote_format_utils.h"
 
 using namespace cryptonote;
@@ -233,11 +230,7 @@ protected:
 
 using testing::Types;
 
-typedef Types<BlockchainLMDB
+typedef Types<BlockchainLMDB> implementations;
-#ifdef BERKELEY_DB
-  , BlockchainBDB
-#endif
-> implementations;
 
 TYPED_TEST_CASE(BlockchainDBTest, implementations);