diff --git a/docs/lobs.md b/docs/lobs.md
index a6273262c..d85cb41c6 100644
--- a/docs/lobs.md
+++ b/docs/lobs.md
@@ -4,9 +4,17 @@
 
 The SOCI library provides also an interface for basic operations on large objects (BLOBs - Binary Large OBjects).
 
+Selecting a BLOB from a table:
+
     blob b(sql); // sql is a session object
     sql << "select mp3 from mymusic where id = 123", into(b);
 
+Inserting a BLOB from a table:
+
+    blob b(sql); // sql is a session object
+    b.write_from_start(data.data(), data.size()); // data is e.g. a std::vector< char >
+    sql << "insert into mymusic mp3, id VALUES(:mp3, 124)", use(b);
+
 The following functions are provided in the `blob` interface, mimicking the file-like operations:
 
 * `std::size_t get_len();`
@@ -15,13 +23,23 @@ The following functions are provided in the `blob` interface, mimicking the file
 * `std::size_t append(char const *buf, std::size_t toWrite);`
 * `void trim(std::size_t newLen);`
 
-The `offset` parameter is always counted from the beginning of the BLOB's data.
+The `offset` parameter is always counted from the beginning of the BLOB's data. `read_from_start` and `write_from_start` and `append` return the amount of read or written bytes.
+
+### Notes
+
+* As with empty files (but contrary to e.g. `std::vector`) reading from the **beginning** of an empty blob is a valid operation (effectively a no-op),
+  e.g. it won't throw or error otherwise.
+* It is possible to default-construct `blob` objects. Default-constructed `blob`s are in an invalid state and must not be accessed other than to query
+  their validity (`is_valid()`) or to initialize them (`initialize(session &session)`) in order to bring them into a valid state.
 
-### Portability notes
+#### Portability
 
 * The way to define BLOB table columns and create or destroy BLOB objects in the database varies between different database engines.
   Please see the SQL documentation relevant for the given server to learn how this is actually done. The test programs provided with the SOCI library can be also a simple source of full working examples.
-* The `trim` function is not currently available for the PostgreSQL backend.
+* BLOBs are currently not implemented for all supported backends. Backends missing an implementation are `ODBC` and `DB2`.
+* The plain `read(...)` and `write(...)` functions use offsets in a backend-specific format (some start at zero, some at one). They are retained only for backwards compatibility. Don't use them in new code!
+* Some backends (e.g. PostgreSQL) support BLOBs only while a transaction is active. Using a `soci::blob` object outside of a transaction in these cases is undefined behavior.
+  In order to write portable code, you should always ensure to start a transaction before working with BLOBs and end it only after you are done with the BLOB object.
 
 ## Long strings and XML
 
diff --git a/include/private/soci-exchange-cast.h b/include/private/soci-exchange-cast.h
index 596386dc4..755af0ae4 100644
--- a/include/private/soci-exchange-cast.h
+++ b/include/private/soci-exchange-cast.h
@@ -10,6 +10,7 @@
 
 #include "soci/soci-backend.h"
 #include "soci/type-wrappers.h"
+#include "soci/blob.h"
 
 #include <cstdint>
 #include <ctime>
@@ -107,6 +108,12 @@ struct exchange_type_traits<x_xmltype>
   typedef xml_type value_type;
 };
 
+template <>
+struct exchange_type_traits<x_blob>
+{
+  typedef blob value_type;
+};
+
 // exchange_type_traits not defined for x_statement, x_rowid and x_blob here.
 
 template <exchange_type e>
diff --git a/include/private/soci-trivial-blob-backend.h b/include/private/soci-trivial-blob-backend.h
new file mode 100644
index 000000000..cc298bb88
--- /dev/null
+++ b/include/private/soci-trivial-blob-backend.h
@@ -0,0 +1,82 @@
+#ifndef SOCI_PRIVATE_SOCI_TRIVIAL_BLOB_BACKEND_H_INCLUDED
+#define SOCI_PRIVATE_SOCI_TRIVIAL_BLOB_BACKEND_H_INCLUDED
+
+#include "soci/soci-backend.h"
+
+#include <vector>
+#include <cstring>
+#include <cstdint>
+
+namespace soci
+{
+
+namespace details
+{
+
+/**
+ * This Blob implementation uses an explicit buffer that is read from and written to, instead of
+ * directly communicating with the underlying database.
+ * Thus, it is intended to be used whenever the underlying database does not offer a more efficient
+ * way of dealing with BLOBs.
+ */
+class trivial_blob_backend : public details::blob_backend
+{
+public:
+    std::size_t get_len() override { return buffer_.size(); }
+
+    std::size_t read_from_start(void* buf, std::size_t toRead,
+        std::size_t offset = 0) override
+    {
+        if (offset > buffer_.size() || (offset ==  buffer_.size() && offset > 0))
+        {
+            throw soci_error("Can't read past-the-end of BLOB data.");
+        }
+
+        // make sure that we don't try to read
+        // past the end of the data
+        toRead = std::min<decltype(toRead)>(toRead, buffer_.size() - offset);
+
+        memcpy(buf, buffer_.data() + offset, toRead);
+
+        return toRead;
+    }
+
+    std::size_t write_from_start(const void* buf, std::size_t toWrite,
+        std::size_t offset = 0) override
+    {
+        if (offset > buffer_.size())
+        {
+            throw soci_error("Can't start writing far past-the-end of BLOB data.");
+        }
+
+        buffer_.resize(std::max<std::size_t>(buffer_.size(), offset + toWrite));
+
+        memcpy(buffer_.data() + offset, buf, toWrite);
+
+        return toWrite;
+    }
+
+    std::size_t append(void const* buf, std::size_t toWrite) override
+    {
+        return write_from_start(buf, toWrite, buffer_.size());
+    }
+
+    void trim(std::size_t newLen) override { buffer_.resize(newLen); }
+
+    std::size_t set_data(void const* buf, std::size_t toWrite)
+    {
+        buffer_.clear();
+        return write_from_start(buf, toWrite);
+    }
+
+    const std::uint8_t *get_buffer() const { return buffer_.data(); }
+
+protected:
+    std::vector< std::uint8_t > buffer_;
+};
+
+}
+
+}
+
+#endif // SOCI_PRIVATE_SOCI_TRIVIAL_BLOB_BACKEND_H_INCLUDED
diff --git a/include/soci/blob.h b/include/soci/blob.h
index 868ea8163..2b3d1dccf 100644
--- a/include/soci/blob.h
+++ b/include/soci/blob.h
@@ -27,32 +27,45 @@ class blob_backend;
 class SOCI_DECL blob
 {
 public:
+    // Creates an invalid blob object
+    blob() = default;
     explicit blob(session & s);
     ~blob();
 
     blob(blob &&other) = default;
     blob &operator=(blob &&other) = default;
 
+    // Checks whether this blob is in a valid state
+    bool is_valid() const;
+
+    // (Re)initializes this blob
+    void initialize(session &s);
+
     std::size_t get_len();
 
     // offset is backend-specific
     [[deprecated("Use read_from_start instead")]]
-    std::size_t read(std::size_t offset, char * buf, std::size_t toRead);
-
-    // offset starts from 0
-    std::size_t read_from_start(char * buf, std::size_t toRead,
+    std::size_t read(std::size_t offset, void * buf, std::size_t toRead);
+
+    // Extracts data from this blob into the given buffer.
+    // At most toRead bytes are extracted (and copied into buf).
+    // The amount of actually read bytes is returned.
+    //
+    // Note: Using an offset > 0 on a blob whose size is less than
+    // or equal to offset, will throw an exception.
+    std::size_t read_from_start(void * buf, std::size_t toRead,
         std::size_t offset = 0);
 
     // offset is backend-specific
     [[deprecated("Use write_from_start instead")]]
-    std::size_t write(std::size_t offset, char const * buf,
+    std::size_t write(std::size_t offset, const void * buf,
         std::size_t toWrite);
 
     // offset starts from 0
-    std::size_t write_from_start(const char * buf, std::size_t toWrite,
+    std::size_t write_from_start(const void * buf, std::size_t toWrite,
         std::size_t offset = 0);
 
-    std::size_t append(char const * buf, std::size_t toWrite);
+    std::size_t append(const void * buf, std::size_t toWrite);
 
     void trim(std::size_t newLen);
 
@@ -62,6 +75,8 @@ class SOCI_DECL blob
     SOCI_NOT_COPYABLE(blob)
 
     std::unique_ptr<details::blob_backend> backEnd_;
+
+    void ensure_initialized();
 };
 
 } // namespace soci
diff --git a/include/soci/boost-gregorian-date.h b/include/soci/boost-gregorian-date.h
index 66321c529..97237aa4f 100644
--- a/include/soci/boost-gregorian-date.h
+++ b/include/soci/boost-gregorian-date.h
@@ -34,6 +34,9 @@ struct type_conversion<boost::gregorian::date>
         out = boost::gregorian::date_from_tm(in);
     }
 
+    struct move_from_base_check :
+        std::integral_constant<bool, false> {};
+
     static void to_base(
         boost::gregorian::date const & in, base_type & out, indicator & ind)
     {
diff --git a/include/soci/boost-optional.h b/include/soci/boost-optional.h
index a9322b12c..6b06328a9 100644
--- a/include/soci/boost-optional.h
+++ b/include/soci/boost-optional.h
@@ -22,6 +22,8 @@ struct type_conversion<boost::optional<T> >
 {
     typedef typename type_conversion<T>::base_type base_type;
 
+    struct from_base_check : std::integral_constant<bool, true> {};
+
     static void from_base(base_type const & in, indicator ind,
         boost::optional<T> & out)
     {
@@ -37,6 +39,27 @@ struct type_conversion<boost::optional<T> >
         }
     }
 
+    struct move_from_base_check :
+        std::integral_constant<bool,
+            !std::is_const<base_type>::value
+            && std::is_constructible<boost::optional<T>, typename std::add_rvalue_reference<base_type>::type>::value
+        > {};
+
+
+    static void move_from_base(base_type & in, indicator ind, boost::optional<T> & out)
+    {
+        static_assert(move_from_base_check::value,
+                "move_to_base can only be used if the target type can be constructed from an rvalue base reference");
+        if (ind == i_null)
+        {
+            out.reset();
+        }
+        else
+        {
+            out = std::move(in);
+        }
+    }
+
     static void to_base(boost::optional<T> const & in,
         base_type & out, indicator & ind)
     {
@@ -49,6 +72,19 @@ struct type_conversion<boost::optional<T> >
             ind = i_null;
         }
     }
+
+    static void move_to_base(boost::optional<T> & in, base_type & out, indicator & ind)
+    {
+        if (in.is_initialized())
+        {
+            out = std::move(in.get());
+            ind = i_ok;
+        }
+        else
+        {
+            ind = i_null;
+        }
+    }
 };
 
 } // namespace soci
diff --git a/include/soci/db2/soci-db2.h b/include/soci/db2/soci-db2.h
index bb33128be..45191d406 100644
--- a/include/soci/db2/soci-db2.h
+++ b/include/soci/db2/soci-db2.h
@@ -229,9 +229,9 @@ struct db2_blob_backend : details::blob_backend
     ~db2_blob_backend() override;
 
     std::size_t get_len() override;
-    std::size_t read_from_start(char* buf, std::size_t toRead, std::size_t offset = 0) override;
-    std::size_t write_from_start(char const* buf, std::size_t toWrite, std::size_t offset = 0) override;
-    std::size_t append(char const* buf, std::size_t toWrite) override;
+    std::size_t read_from_start(void* buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void* buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t append(const void* buf, std::size_t toWrite) override;
     void trim(std::size_t newLen) override;
 
     db2_session_backend& session_;
diff --git a/include/soci/empty/soci-empty.h b/include/soci/empty/soci-empty.h
index ff2047c41..fec2495be 100644
--- a/include/soci/empty/soci-empty.h
+++ b/include/soci/empty/soci-empty.h
@@ -139,11 +139,11 @@ struct empty_blob_backend : details::blob_backend
 
     std::size_t get_len() override;
 
-    std::size_t read_from_start(char * buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t read_from_start(void * buf, std::size_t toRead, std::size_t offset = 0) override;
 
-    std::size_t write_from_start(const char * buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void * buf, std::size_t toWrite, std::size_t offset = 0) override;
 
-    std::size_t append(char const* buf, std::size_t toWrite) override;
+    std::size_t append(const void* buf, std::size_t toWrite) override;
     void trim(std::size_t newLen) override;
 
     empty_session_backend& session_;
diff --git a/include/soci/firebird/soci-firebird.h b/include/soci/firebird/soci-firebird.h
index fbc039679..361fdb678 100644
--- a/include/soci/firebird/soci-firebird.h
+++ b/include/soci/firebird/soci-firebird.h
@@ -25,6 +25,7 @@
 #include <cstdlib>
 #include <vector>
 #include <string>
+#include <cstdint>
 
 namespace soci
 {
@@ -258,46 +259,36 @@ struct firebird_blob_backend : details::blob_backend
 
     std::size_t get_len() override;
 
-    std::size_t read_from_start(char * buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t read_from_start(void * buf, std::size_t toRead, std::size_t offset = 0) override;
 
-    std::size_t write_from_start(const char * buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void * buf, std::size_t toWrite, std::size_t offset = 0) override;
 
-    std::size_t append(char const *buf, std::size_t toWrite) override;
+    std::size_t append(const void *buf, std::size_t toWrite) override;
     void trim(std::size_t newLen) override;
 
-    firebird_session_backend &session_;
-
-    virtual void save();
-    virtual void assign(ISC_QUAD const & bid)
-    {
-        cleanUp();
-
-        bid_ = bid;
-        from_db_ = true;
-    }
+    // Writes the current data into the database by allocating a new BLOB
+    // object for it.
+    //
+    // Returns The ID of the newly created BLOB object
+    ISC_QUAD save_to_db();
+    void assign(ISC_QUAD const & bid);
 
-    // BLOB id from in database
-    ISC_QUAD bid_;
+private:
+    void open();
+    long getBLOBInfo();
+    void load();
+    void writeBuffer(std::size_t offset, void const * buf,
+        std::size_t toWrite);
+    void closeBlob();
 
+    firebird_session_backend &session_;
+    ISC_QUAD blob_id_;
     // BLOB id was fetched from database (true)
     // or this is new BLOB
     bool from_db_;
-
-    // BLOB handle
-    isc_blob_handle bhp_;
-
-protected:
-
-    virtual void open();
-    virtual long getBLOBInfo();
-    virtual void load();
-    virtual void writeBuffer(std::size_t offset, char const * buf,
-        std::size_t toWrite);
-    virtual void cleanUp();
-
+    isc_blob_handle blob_handle_;
     // buffer for BLOB data
-    std::vector<char> data_;
-
+    std::vector<std::uint8_t> data_;
     bool loaded_;
     long max_seg_size_;
 };
diff --git a/include/soci/is-detected.h b/include/soci/is-detected.h
new file mode 100644
index 000000000..506e49f1a
--- /dev/null
+++ b/include/soci/is-detected.h
@@ -0,0 +1,49 @@
+//
+// Copyright (C) 2023 Robert Adam
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef SOCI_IS_DETECTED_H_INCLUDED
+#define SOCI_IS_DETECTED_H_INCLUDED
+
+#include <type_traits>
+
+namespace soci
+{
+
+namespace details
+{
+
+template<typename...>
+using void_t = void;
+
+using false_type = std::integral_constant<bool, false>;
+using true_type = std::integral_constant<bool, true>;
+
+// Implementation from https://blog.tartanllama.xyz/detection-idiom/
+// Note, this is a stub that we require until standard C++ gets support
+// for the detection idiom that is not experimental (and thus can be
+// assumed to be present).
+
+namespace detector_detail
+{
+
+    template <template <class...> class Trait, class Enabler, class... Args>
+    struct is_detected : false_type {};
+
+    template <template <class...> class Trait, class... Args>
+    struct is_detected<Trait, void_t<Trait<Args...>>, Args...> : true_type {};
+
+}
+
+
+template <template <class...> class Trait, class... Args>
+using is_detected = typename detector_detail::is_detected<Trait, void, Args...>::type;
+
+}
+
+}
+
+#endif // SOCI_IS_DETECTED_H_INCLUDED
diff --git a/include/soci/mysql/soci-mysql.h b/include/soci/mysql/soci-mysql.h
index 7a45bee8e..08736e38c 100644
--- a/include/soci/mysql/soci-mysql.h
+++ b/include/soci/mysql/soci-mysql.h
@@ -18,6 +18,7 @@
 #endif
 
 #include <soci/soci-backend.h>
+#include <private/soci-trivial-blob-backend.h>
 #ifdef _WIN32
 #include <winsock.h> // SOCKET
 #endif // _WIN32
@@ -241,19 +242,18 @@ struct mysql_rowid_backend : details::rowid_backend
     ~mysql_rowid_backend() override;
 };
 
-struct mysql_blob_backend : details::blob_backend
+class mysql_blob_backend : public details::trivial_blob_backend
 {
+public:
     mysql_blob_backend(mysql_session_backend &session);
 
     ~mysql_blob_backend() override;
 
-    std::size_t get_len() override;
-    std::size_t read_from_start(char *buf, std::size_t toRead, std::size_t offset = 0) override;
-    std::size_t write_from_start(char const *buf, std::size_t toWrite, std::size_t offset = 0) override;
-    std::size_t append(char const *buf, std::size_t toWrite) override;
-    void trim(std::size_t newLen) override;
+    std::size_t hex_str_size() const;
+    void write_hex_str(char *buf, std::size_t size) const;
+    std::string as_hex_str() const;
 
-    mysql_session_backend &session_;
+    void load_from_hex_str(const char* str, std::size_t length);
 };
 
 struct mysql_session_backend : details::session_backend
diff --git a/include/soci/odbc/soci-odbc.h b/include/soci/odbc/soci-odbc.h
index dff2f27e5..8a34fa959 100644
--- a/include/soci/odbc/soci-odbc.h
+++ b/include/soci/odbc/soci-odbc.h
@@ -365,9 +365,9 @@ struct odbc_blob_backend : details::blob_backend
     ~odbc_blob_backend() override;
 
     std::size_t get_len() override;
-    std::size_t read_from_start(char *buf, std::size_t toRead, std::size_t offset = 0) override;
-    std::size_t write_from_start(char const *buf, std::size_t toWrite, std::size_t offset = 0) override;
-    std::size_t append(char const *buf, std::size_t toWrite) override;
+    std::size_t read_from_start(void *buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void *buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t append(const void *buf, std::size_t toWrite) override;
     void trim(std::size_t newLen) override;
 
     odbc_session_backend &session_;
diff --git a/include/soci/oracle/soci-oracle.h b/include/soci/oracle/soci-oracle.h
index 6406b591c..800ad400e 100644
--- a/include/soci/oracle/soci-oracle.h
+++ b/include/soci/oracle/soci-oracle.h
@@ -261,6 +261,8 @@ struct oracle_rowid_backend : details::rowid_backend
 
 struct oracle_blob_backend : details::blob_backend
 {
+    typedef OCILobLocator * locator_t;
+
     oracle_blob_backend(oracle_session_backend &session);
 
     ~oracle_blob_backend() override;
@@ -268,30 +270,43 @@ struct oracle_blob_backend : details::blob_backend
     std::size_t get_len() override;
 
     [[deprecated("Use read_from_start instead")]]
-    std::size_t read(std::size_t offset, char *buf, std::size_t toRead) override
+    std::size_t read(std::size_t offset, void *buf, std::size_t toRead) override
     {
         // Offsets are 1-based in Oracle
         return read_from_start(buf, toRead, offset - 1);
     }
 
-    std::size_t read_from_start(char * buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t read_from_start(void * buf, std::size_t toRead, std::size_t offset = 0) override;
 
     [[deprecated("Use write_from_start instead")]]
-    std::size_t write(std::size_t offset, char const *buf, std::size_t toWrite) override
+    std::size_t write(std::size_t offset, const void *buf, std::size_t toWrite) override
     {
         // Offsets are 1-based in Oracle
         return write_from_start(buf, toWrite, offset - 1);
     }
 
-    std::size_t write_from_start(const char * buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void * buf, std::size_t toWrite, std::size_t offset = 0) override;
 
-    std::size_t append(char const *buf, std::size_t toWrite) override;
+    std::size_t append(const void *buf, std::size_t toWrite) override;
 
     void trim(std::size_t newLen) override;
 
+    locator_t get_lob_locator() const;
+
+    void set_lob_locator(locator_t locator, bool initialized = true);
+
+    void reset();
+
+    void ensure_initialized();
+
+private:
     oracle_session_backend &session_;
 
-    OCILobLocator *lobp_;
+    locator_t lobp_;
+
+    // If this is true, then the locator lobp_ points to something useful
+    // (instead of being the equivalent to a pointer with random value)
+    bool initialized_;
 };
 
 struct oracle_session_backend : details::session_backend
@@ -458,7 +473,7 @@ struct oracle_session_backend : details::session_backend
 
 struct oracle_backend_factory : backend_factory
 {
-	  oracle_backend_factory() {}
+      oracle_backend_factory() {}
     oracle_session_backend * make_session(
         connection_parameters const & parameters) const override;
 };
diff --git a/include/soci/postgresql/soci-postgresql.h b/include/soci/postgresql/soci-postgresql.h
index 3e86ac299..f13858d18 100644
--- a/include/soci/postgresql/soci-postgresql.h
+++ b/include/soci/postgresql/soci-postgresql.h
@@ -327,26 +327,57 @@ struct postgresql_rowid_backend : details::rowid_backend
     unsigned long value_;
 };
 
-struct postgresql_blob_backend : details::blob_backend
+class postgresql_blob_backend : public details::blob_backend
 {
+public:
+
+    struct blob_details
+    {
+        // OID of the large object
+        unsigned long oid;
+        // File descriptor of the large object
+        int fd;
+
+        blob_details();
+        blob_details(unsigned long oid, int fd);
+    };
+
     postgresql_blob_backend(postgresql_session_backend & session);
 
     ~postgresql_blob_backend() override;
 
     std::size_t get_len() override;
 
-    std::size_t read_from_start(char * buf, std::size_t toRead, std::size_t offset = 0) override;
+    std::size_t read_from_start(void * buf, std::size_t toRead, std::size_t offset = 0) override;
 
-    std::size_t write_from_start(const char * buf, std::size_t toWrite, std::size_t offset = 0) override;
+    std::size_t write_from_start(const void * buf, std::size_t toWrite, std::size_t offset = 0) override;
 
-    std::size_t append(char const * buf, std::size_t toWrite) override;
+    std::size_t append(const void * buf, std::size_t toWrite) override;
 
     void trim(std::size_t newLen) override;
 
+    const blob_details &get_blob_details() const;
+
+    void set_blob_details(const blob_details &details);
+
+    bool get_destroy_on_close() const;
+
+    void set_destroy_on_close(bool destroy);
+
+    void set_clone_before_modify(bool clone);
+
+    void init();
+
+    void reset();
+
+private:
     postgresql_session_backend & session_;
+    blob_details details_;
+    bool destroy_on_close_;
+    bool clone_before_modify_;
 
-    unsigned long oid_; // oid of the large object
-    int fd_;            // descriptor of the large object
+    std::size_t seek(std::size_t toOffset, int from);
+    void clone();
 };
 
 struct postgresql_session_backend : details::session_backend
diff --git a/include/soci/row.h b/include/soci/row.h
index 3279dae25..e76aea403 100644
--- a/include/soci/row.h
+++ b/include/soci/row.h
@@ -9,6 +9,8 @@
 #define SOCI_ROW_H_INCLUDED
 
 #include "soci/type-holder.h"
+#include "soci/blob.h"
+#include "soci/type-conversion-traits.h"
 #include "soci/soci-backend.h"
 #include "soci/type-conversion.h"
 // std
@@ -74,6 +76,8 @@ class SOCI_DECL row
     T get(std::size_t pos) const
     {
         typedef typename type_conversion<T>::base_type base_type;
+        static_assert(details::can_use_from_base<type_conversion<T>>(),
+                "Can't use row::get() with this type (not convertible/copy-assignable from base_type) - did you mean to use move_as?");
         base_type const& baseVal = holders_.at(pos)->get<base_type>();
 
         T ret;
@@ -81,6 +85,19 @@ class SOCI_DECL row
         return ret;
     }
 
+    template <typename T>
+    T move_as(std::size_t pos) const
+    {
+        typedef typename type_conversion<T>::base_type base_type;
+        static_assert(details::can_use_move_from_base<T, base_type>(),
+                "row::move_as() can only be called with types that can be instantiated from a base type rvalue reference");
+        base_type & baseVal = holders_.at(pos)->get<base_type>();
+
+        T ret;
+        type_conversion<T>::move_from_base(baseVal, *indicators_.at(pos), ret);
+        return ret;
+    }
+
     template <typename T>
     T get(std::size_t pos, T const &nullValue) const
     {
@@ -92,6 +109,17 @@ class SOCI_DECL row
         return get<T>(pos);
     }
 
+    template <typename T>
+    T move_as(std::size_t pos, T const &nullValue) const
+    {
+        if (i_null == *indicators_.at(pos))
+        {
+            return nullValue;
+        }
+
+        return move_as<T>(pos);
+    }
+
     template <typename T>
     T get(std::string const &name) const
     {
@@ -99,6 +127,13 @@ class SOCI_DECL row
         return get<T>(pos);
     }
 
+    template <typename T>
+    T move_as(std::string const &name) const
+    {
+        std::size_t const pos = find_column(name);
+        return move_as<T>(pos);
+    }
+
     template <typename T>
     T get(std::string const &name, T const &nullValue) const
     {
@@ -112,6 +147,19 @@ class SOCI_DECL row
         return get<T>(pos);
     }
 
+    template <typename T>
+    T move_as(std::string const &name, T const &nullValue) const
+    {
+        std::size_t const pos = find_column(name);
+
+        if (i_null == *indicators_[pos])
+        {
+            return nullValue;
+        }
+
+        return move_as<T>(pos);
+    }
+
     template <typename T>
     row const& operator>>(T& value) const
     {
@@ -144,6 +192,9 @@ class SOCI_DECL row
     mutable std::size_t currentPos_;
 };
 
+template <>
+blob SOCI_DECL row::move_as<blob>(std::size_t pos) const;
+
 } // namespace soci
 
 #endif // SOCI_ROW_H_INCLUDED
diff --git a/include/soci/soci-backend.h b/include/soci/soci-backend.h
index ffb9099aa..5e80d9e3f 100644
--- a/include/soci/soci-backend.h
+++ b/include/soci/soci-backend.h
@@ -15,6 +15,9 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <vector>
+#include <algorithm>
+#include <cstring>
 
 namespace soci
 {
@@ -302,16 +305,16 @@ class blob_backend
     virtual std::size_t get_len() = 0;
 
     [[deprecated("Use read_from_start instead")]]
-    virtual std::size_t read(std::size_t offset, char* buf, std::size_t toRead) { return read_from_start(buf, toRead, offset); }
+    virtual std::size_t read(std::size_t offset, void* buf, std::size_t toRead) { return read_from_start(buf, toRead, offset); }
 
-    virtual std::size_t read_from_start(char* buf, std::size_t toRead, std::size_t offset) = 0;
+    virtual std::size_t read_from_start(void* buf, std::size_t toRead, std::size_t offset) = 0;
 
     [[deprecated("Use write_from_start instead")]]
-    virtual std::size_t write(std::size_t offset, char const* buf, std::size_t toWrite) { return write_from_start(buf, toWrite, offset); }
+    virtual std::size_t write(std::size_t offset, const void* buf, std::size_t toWrite) { return write_from_start(buf, toWrite, offset); }
 
-    virtual std::size_t write_from_start(const char* buf, std::size_t toWrite, std::size_t offset) = 0;
+    virtual std::size_t write_from_start(const void* buf, std::size_t toWrite, std::size_t offset) = 0;
 
-    virtual std::size_t append(char const* buf, std::size_t toWrite) = 0;
+    virtual std::size_t append(const void* buf, std::size_t toWrite) = 0;
 
     virtual void trim(std::size_t newLen) = 0;
 
diff --git a/include/soci/sqlite3/soci-sqlite3.h b/include/soci/sqlite3/soci-sqlite3.h
index 326d7151f..531a23309 100644
--- a/include/soci/sqlite3/soci-sqlite3.h
+++ b/include/soci/sqlite3/soci-sqlite3.h
@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <vector>
 #include <soci/soci-backend.h>
+#include <private/soci-trivial-blob-backend.h>
 
 // Disable flood of nonsense warnings generated for SQLite
 #ifdef _MSC_VER
@@ -261,29 +262,13 @@ struct sqlite3_rowid_backend : details::rowid_backend
     unsigned long value_;
 };
 
-struct sqlite3_blob_backend : details::blob_backend
+struct sqlite3_blob_backend : details::trivial_blob_backend
 {
     sqlite3_blob_backend(sqlite3_session_backend &session);
 
     ~sqlite3_blob_backend() override;
 
-    std::size_t get_len() override;
-
-    std::size_t read_from_start(char * buf, std::size_t toRead, std::size_t offset = 0) override;
-
-    std::size_t write_from_start(const char * buf, std::size_t toWrite, std::size_t offset = 0) override;
-
-    std::size_t append(char const *buf, std::size_t toWrite) override;
-    void trim(std::size_t newLen) override;
-
-    sqlite3_session_backend &session_;
-
-    std::size_t set_data(char const *buf, std::size_t toWrite);
-    const char *get_buffer() const { return buf_; }
-
-private:
-    char *buf_;
-    size_t len_;
+    void ensure_buffer_initialized();
 };
 
 struct sqlite3_session_backend : details::session_backend
diff --git a/include/soci/statement.h b/include/soci/statement.h
index a1397d106..b1dbc4269 100644
--- a/include/soci/statement.h
+++ b/include/soci/statement.h
@@ -16,6 +16,7 @@
 #include "soci/use.h"
 #include "soci/soci-backend.h"
 #include "soci/row.h"
+#include "soci/blob.h"
 // std
 #include <cstddef>
 #include <string>
@@ -164,6 +165,10 @@ class SOCI_DECL statement_impl
     SOCI_NOT_COPYABLE(statement_impl)
 };
 
+template<>
+void statement_impl::into_row<blob>();
+
+
 } // namespace details
 
 // Statement is a handle class for statement_impl
diff --git a/include/soci/type-conversion-traits.h b/include/soci/type-conversion-traits.h
index e334071ea..ce6bcf372 100644
--- a/include/soci/type-conversion-traits.h
+++ b/include/soci/type-conversion-traits.h
@@ -9,33 +9,141 @@
 #define SOCI_TYPE_CONVERSION_TRAITS_H_INCLUDED
 
 #include "soci/soci-backend.h"
+#include "soci/is-detected.h"
+
+#include <type_traits>
 
 namespace soci
 {
 
-// default traits class type_conversion, acts as pass through for row::get()
+// default traits class type_conversion, acts as pass through for row::get() or row::move_as()
 // when no actual conversion is needed.
 template <typename T, typename Enable = void>
 struct type_conversion
 {
     typedef T base_type;
 
-    static void from_base(base_type const & in, indicator ind, T & out)
+    struct from_base_check : std::integral_constant<bool, std::is_constructible<T, const base_type>::value> {};
+
+    static void from_base(base_type const& in, indicator ind, T & out)
     {
-        if (ind == i_null)
-        {
-            throw soci_error("Null value not allowed for this type");
-        }
+        static_assert(from_base_check::value,
+                "from_base can only be used if the target type can be constructed from an lvalue base reference");
+        assert_non_null(ind);
         out = in;
     }
 
+    struct move_from_base_check :
+        std::integral_constant<bool,
+            !std::is_const<base_type>::value
+            && std::is_constructible<T, typename std::add_rvalue_reference<base_type>::type>::value
+        > {};
+
+
+    static void move_from_base(base_type & in, indicator ind, T & out)
+    {
+        static_assert(move_from_base_check::value,
+                "move_to_base can only be used if the target type can be constructed from an rvalue base reference");
+        assert_non_null(ind);
+        out = std::move(in);
+    }
+
     static void to_base(T const & in, base_type & out, indicator & ind)
     {
         out = in;
         ind = i_ok;
     }
+
+    static void move_to_base(T & in, base_type & out, indicator & ind)
+    {
+        out = std::move(in);
+        ind = i_ok;
+    }
+
+private:
+    static void assert_non_null(indicator ind)
+    {
+        if (ind == i_null)
+        {
+            throw soci_error("Null value not allowed for this type");
+        }
+    }
 };
 
+namespace details
+{
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1910)
+    // MSVC 2015 and earlier don't support SFINAE on return types
+    #define SOCI_HAS_RET_TYPE_SFINAE
+#endif
+
+template<typename T>
+using from_base_check_t = decltype(T::from_base_check::value);
+template<typename T>
+using move_from_base_check_t = decltype(T::move_from_base_check::value);
+
+template<typename T>
+using supports_from_base_check = is_detected<from_base_check_t, T>;
+template<typename T>
+using supports_move_from_base_check = is_detected<move_from_base_check_t, T>;
+
+#ifdef SOCI_HAS_RET_TYPE_SFINAE
+
+template<typename Trait>
+constexpr auto can_use_from_base()
+    -> typename std::enable_if<supports_from_base_check<Trait>::value, bool>::type
+{
+    return Trait::from_base_check::value;
+}
+
+template<typename Trait>
+constexpr auto can_use_from_base()
+    -> typename std::enable_if<!supports_from_base_check<Trait>::value, bool>::type
+{
+    return true;
+}
+
+template<typename Trait>
+constexpr auto can_use_move_from_base()
+    -> typename std::enable_if<supports_move_from_base_check<Trait>::value, bool>::type
+{
+    return Trait::from_base_check::value;
+}
+
+template<typename Trait>
+constexpr auto can_use_move_from_base()
+    -> typename std::enable_if<!supports_move_from_base_check<Trait>::value, bool>::type
+{
+    // Default to assuming that the special move_from_base function is not implemented
+    // TODO: Find clever template magic to add a metaprogramming check for a suitable
+    // move_from_base implementation
+    return false;
+}
+
+#undef SOCI_HAS_RET_TYPE_SFINAE
+
+#else
+
+// Always return true - if it doesn't work the user will get a cryptic compiler error but at least
+// it will compile properly for cases in which things do indeed work
+
+template<typename Trait>
+constexpr auto can_use_from_base()
+{
+    return true;
+}
+
+template<typename Trait>
+constexpr auto can_use_move_from_base()
+{
+    return true;
+}
+
+#endif
+
+}
+
 } // namespace soci
 
 #endif // SOCI_TYPE_CONVERSION_TRAITS_H_INCLUDED
diff --git a/include/soci/type-holder.h b/include/soci/type-holder.h
index f103edb58..a9e189d23 100644
--- a/include/soci/type-holder.h
+++ b/include/soci/type-holder.h
@@ -56,7 +56,7 @@ class holder
     virtual ~holder() {}
 
     template<typename T>
-    T get()
+    T &get()
     {
         type_holder<T>* p = checked_ptr_cast<type_holder<T> >(this);
         if (p)
@@ -83,7 +83,10 @@ class type_holder : public holder
     ~type_holder() override { delete t_; }
 
     template<typename TypeValue>
-    TypeValue value() const { return *t_; }
+    const TypeValue &value() const { return *t_; }
+
+    template<typename TypeValue>
+    TypeValue &value() { return *t_; }
 
 private:
     T * t_;
diff --git a/src/backends/db2/blob.cpp b/src/backends/db2/blob.cpp
index 2631d98f3..006b6ce47 100644
--- a/src/backends/db2/blob.cpp
+++ b/src/backends/db2/blob.cpp
@@ -32,18 +32,18 @@ std::size_t db2_blob_backend::get_len()
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t db2_blob_backend::read_from_start(char * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
+std::size_t db2_blob_backend::read_from_start(void * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t db2_blob_backend::write_from_start(char const * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
+std::size_t db2_blob_backend::write_from_start(const void * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
 std::size_t db2_blob_backend::append(
-    char const * /* buf */, std::size_t /* toWrite */)
+    const void * /* buf */, std::size_t /* toWrite */)
 {
     throw soci_error("BLOBs are not supported.");
 }
diff --git a/src/backends/empty/blob.cpp b/src/backends/empty/blob.cpp
index a09e92d05..db26321f9 100644
--- a/src/backends/empty/blob.cpp
+++ b/src/backends/empty/blob.cpp
@@ -32,18 +32,18 @@ std::size_t empty_blob_backend::get_len()
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t empty_blob_backend::read_from_start(char * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
+std::size_t empty_blob_backend::read_from_start(void * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t empty_blob_backend::write_from_start(char const * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
+std::size_t empty_blob_backend::write_from_start(const void * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
 std::size_t empty_blob_backend::append(
-    char const * /* buf */, std::size_t /* toWrite */)
+    const void * /* buf */, std::size_t /* toWrite */)
 {
     throw soci_error("BLOBs are not supported.");
 }
diff --git a/src/backends/firebird/blob.cpp b/src/backends/firebird/blob.cpp
index 5c3bb8078..c646428b6 100644
--- a/src/backends/firebird/blob.cpp
+++ b/src/backends/firebird/blob.cpp
@@ -9,22 +9,25 @@
 #include "soci/firebird/soci-firebird.h"
 #include "firebird/error-firebird.h"
 
+#include <limits>
+#include <cstring>
+
 using namespace soci;
 using namespace soci::details::firebird;
 
 firebird_blob_backend::firebird_blob_backend(firebird_session_backend &session)
-	  : session_(session), bid_(), from_db_(false), bhp_(0), data_(),
-		loaded_(false), max_seg_size_(0)
+      : session_(session), blob_id_(), from_db_(false), blob_handle_(0), data_(),
+        loaded_(false), max_seg_size_(0)
 {}
 
 firebird_blob_backend::~firebird_blob_backend()
 {
-    cleanUp();
+    closeBlob();
 }
 
 std::size_t firebird_blob_backend::get_len()
 {
-    if (from_db_ && bhp_ == 0)
+    if (from_db_ && blob_handle_ == 0)
     {
         open();
     }
@@ -32,9 +35,9 @@ std::size_t firebird_blob_backend::get_len()
     return data_.size();
 }
 
-std::size_t firebird_blob_backend::read_from_start(char * buf, std::size_t toRead, std::size_t offset)
+std::size_t firebird_blob_backend::read_from_start(void * buf, std::size_t toRead, std::size_t offset)
 {
-    if (from_db_ && (loaded_ == false))
+    if (from_db_ && !loaded_)
     {
         // this is blob fetched from database, but not loaded yet
         load();
@@ -42,28 +45,28 @@ std::size_t firebird_blob_backend::read_from_start(char * buf, std::size_t toRea
 
     std::size_t size = data_.size();
 
-    if (offset > size)
+    if (offset >= size)
     {
+        if (offset == 0)
+        {
+            // Read (from beginning) on empty (default-initialized) BLOB is defined as no-op
+            return 0;
+        }
+
         throw soci_error("Can't read past-the-end of BLOB data");
     }
 
-    char * itr = buf;
-    std::size_t limit = size - offset < toRead ? size - offset : toRead;
-    std::size_t index = 0;
+    // Ensure we don't read more than we have
+    toRead = std::min(toRead, size - offset);
 
-    while (index < limit)
-    {
-        *itr = data_[offset+index];
-        ++index;
-        ++itr;
-    }
+    std::memcpy(buf, &data_[offset], toRead);
 
-    return limit;
+    return toRead;
 }
 
-std::size_t firebird_blob_backend::write_from_start(char const * buf, std::size_t toWrite, std::size_t offset)
+std::size_t firebird_blob_backend::write_from_start(const void * buf, std::size_t toWrite, std::size_t offset)
 {
-    if (from_db_ && (loaded_ == false))
+    if (from_db_ && !loaded_)
     {
         // this is blob fetched from database, but not loaded yet
         load();
@@ -88,9 +91,9 @@ std::size_t firebird_blob_backend::write_from_start(char const * buf, std::size_
 }
 
 std::size_t firebird_blob_backend::append(
-    char const * buf, std::size_t toWrite)
+    const void * buf, std::size_t toWrite)
 {
-    if (from_db_ && (loaded_ == false))
+    if (from_db_ && !loaded_)
     {
         // this is blob fetched from database, but not loaded yet
         load();
@@ -106,7 +109,7 @@ std::size_t firebird_blob_backend::append(
 
 void firebird_blob_backend::trim(std::size_t newLen)
 {
-    if (from_db_ && (loaded_ == false))
+    if (from_db_ && !loaded_)
     {
         // this is blob fetched from database, but not loaded yet
         load();
@@ -116,20 +119,14 @@ void firebird_blob_backend::trim(std::size_t newLen)
 }
 
 void firebird_blob_backend::writeBuffer(std::size_t offset,
-                                      char const * buf, std::size_t toWrite)
+                                      const void * buf, std::size_t toWrite)
 {
-    char const * itr = buf;
-    char const * end_itr = buf + toWrite;
-
-    while (itr!=end_itr)
-    {
-        data_[offset++] = *itr++;
-    }
+    std::memcpy(data_.data() + offset, buf, toWrite);
 }
 
 void firebird_blob_backend::open()
 {
-    if (bhp_ != 0)
+    if (blob_handle_ != 0)
     {
         // BLOB already opened
         return;
@@ -138,9 +135,9 @@ void firebird_blob_backend::open()
     ISC_STATUS stat[20];
 
     if (isc_open_blob2(stat, &session_.dbhp_, session_.current_transaction(),
-                       &bhp_, &bid_, 0, NULL))
+                       &blob_handle_, &blob_id_, 0, NULL))
     {
-        bhp_ = 0L;
+        blob_handle_ = 0L;
         throw_iscerror(stat);
     }
 
@@ -150,29 +147,28 @@ void firebird_blob_backend::open()
     data_.resize(blob_size);
 }
 
-void firebird_blob_backend::cleanUp()
+void firebird_blob_backend::closeBlob()
 {
     from_db_ = false;
     loaded_ = false;
     max_seg_size_ = 0;
-    data_.resize(0);
 
-    if (bhp_ != 0)
+    if (blob_handle_ != 0)
     {
         // close blob
         ISC_STATUS stat[20];
-        if (isc_close_blob(stat, &bhp_))
+        if (isc_close_blob(stat, &blob_handle_))
         {
             throw_iscerror(stat);
         }
-        bhp_ = 0;
+        blob_handle_ = 0;
     }
 }
 
 // loads blob data into internal buffer
 void firebird_blob_backend::load()
 {
-    if (bhp_ == 0)
+    if (blob_handle_ == 0)
     {
         open();
     }
@@ -185,7 +181,7 @@ void firebird_blob_backend::load()
 
     ISC_STATUS stat[20];
     unsigned short bytes;
-    std::vector<char>::size_type total_bytes = 0;
+    std::size_t total_bytes = 0;
     bool keep_reading = false;
 
     do
@@ -193,8 +189,8 @@ void firebird_blob_backend::load()
         bytes = 0;
         // next segment of data
         // data_ is large-enough because we know total size of blob
-        isc_get_segment(stat, &bhp_, &bytes, static_cast<short>(max_seg_size_),
-                        &data_[total_bytes]);
+        isc_get_segment(stat, &blob_handle_, &bytes, static_cast<short>(max_seg_size_),
+                        reinterpret_cast<char *>(&data_[total_bytes]));
 
         total_bytes += bytes;
 
@@ -225,25 +221,22 @@ void firebird_blob_backend::load()
     loaded_ = true;
 }
 
-// this method saves BLOB content to database
-// (a new BLOB will be created at this point)
-// BLOB will be closed after save.
-void firebird_blob_backend::save()
+ISC_QUAD firebird_blob_backend::save_to_db()
 {
     // close old blob if necessary
     ISC_STATUS stat[20];
-    if (bhp_ != 0)
+    if (blob_handle_ != 0)
     {
-        if (isc_close_blob(stat, &bhp_))
+        if (isc_close_blob(stat, &blob_handle_))
         {
             throw_iscerror(stat);
         }
-        bhp_ = 0;
+        blob_handle_ = 0;
     }
 
-    // create new blob
-    if (isc_create_blob(stat, &session_.dbhp_, session_.current_transaction(),
-                        &bhp_, &bid_))
+    // create new blob object
+    if (isc_create_blob2(stat, &session_.dbhp_, session_.current_transaction(),
+                        &blob_handle_, &blob_id_, 0, NULL))
     {
         throw_iscerror(stat);
     }
@@ -259,11 +252,11 @@ void firebird_blob_backend::save()
         // in any case.
         do
         {
-            unsigned short segmentSize = 0xFFFF; //last unsigned short number
+            unsigned short segmentSize = std::numeric_limits<unsigned short>::max();
             if (size - offset < segmentSize) //if content size is less than max segment size or last data segment is about to be written
                 segmentSize = static_cast<unsigned short>(size - offset);
             //write segment
-            if (isc_put_segment(stat, &bhp_, segmentSize, &data_[0]+offset))
+            if (isc_put_segment(stat, &blob_handle_, segmentSize, reinterpret_cast<char*>(&data_[offset])))
             {
                 throw_iscerror(stat);
             }
@@ -271,11 +264,27 @@ void firebird_blob_backend::save()
         }
         while (offset < size);
     }
-    cleanUp();
+
+    // We close the newly created blob object immediately. If we don't do it, the BLOB ID is regarded
+    // as invalid (in some cases?).
+    // In any case, BLOBs in Firebird can't be updated anyway - one always has to create a new BLOB object
+    // (with a new ID) and then use that to modify the existing one (replace the ID in the corresponding table).
+    // Therefore, keeping the Blob open for subsequent modification is not needed.
+    closeBlob();
+
+    return blob_id_;
+}
+
+void firebird_blob_backend::assign(const ISC_QUAD &id)
+{
+    closeBlob();
+    data_.clear();
+
+    blob_id_ = id;
     from_db_ = true;
 }
 
-// retrives number of segments and total length of BLOB
+// retrieves number of segments and total length of BLOB
 // returns total length of BLOB
 long firebird_blob_backend::getBLOBInfo()
 {
@@ -286,7 +295,7 @@ long firebird_blob_backend::getBLOBInfo()
 
     ISC_STATUS stat[20];
 
-    if (isc_blob_info(stat, &bhp_, sizeof(blob_items), blob_items,
+    if (isc_blob_info(stat, &blob_handle_, sizeof(blob_items), blob_items,
                       sizeof(res_buffer), res_buffer))
     {
         throw_iscerror(stat);
diff --git a/src/backends/firebird/standard-into-type.cpp b/src/backends/firebird/standard-into-type.cpp
index 796220eee..4e5e6bb0d 100644
--- a/src/backends/firebird/standard-into-type.cpp
+++ b/src/backends/firebird/standard-into-type.cpp
@@ -129,7 +129,7 @@ void firebird_standard_into_type_backend::exchangeData()
                 firebird_blob_backend *blob =
                     dynamic_cast<firebird_blob_backend*>(tmp->get_backend());
 
-                if (0 == blob)
+                if (!blob)
                 {
                     throw soci_error("Can't get Firebid BLOB BackEnd");
                 }
diff --git a/src/backends/firebird/standard-use-type.cpp b/src/backends/firebird/standard-use-type.cpp
index 254c42d7e..c2bc6803c 100644
--- a/src/backends/firebird/standard-use-type.cpp
+++ b/src/backends/firebird/standard-use-type.cpp
@@ -153,13 +153,13 @@ void firebird_standard_use_type_backend::exchangeData()
                 firebird_blob_backend* blob =
                     dynamic_cast<firebird_blob_backend*>(tmp->get_backend());
 
-                if (NULL == blob)
+                if (!blob)
                 {
                     throw soci_error("Can't get Firebid BLOB BackEnd");
                 }
 
-                blob->save();
-                memcpy(buf_, &blob->bid_, var->sqllen);
+                ISC_QUAD blob_id = blob->save_to_db();
+                memcpy(buf_, &blob_id, sizeof(blob_id));
             }
             break;
 
@@ -182,9 +182,11 @@ void firebird_standard_use_type_backend::copy_to_blob(const std::string& in)
         blob_->trim(0);
     else
         blob_ = new firebird_blob_backend(statement_.session_);
+
     blob_->append(in.c_str(), in.length());
-    blob_->save();
-    memcpy(buf_, &blob_->bid_, sizeof(blob_->bid_));
+
+    ISC_QUAD blob_id = blob_->save_to_db();
+    memcpy(buf_, &blob_id, sizeof(blob_id));
 }
 
 void firebird_standard_use_type_backend::post_use(
diff --git a/src/backends/firebird/statement.cpp b/src/backends/firebird/statement.cpp
index aa58ca46c..648c24dcf 100644
--- a/src/backends/firebird/statement.cpp
+++ b/src/backends/firebird/statement.cpp
@@ -731,8 +731,10 @@ void firebird_statement_backend::describe_column(int colNum,
             dbtype = db_int64;
         }
         break;
-        /* case SQL_BLOB:
-        case SQL_ARRAY:*/
+    case SQL_BLOB:
+        dbtype = db_blob;
+        break;
+        /* case SQL_ARRAY:*/
     default:
         std::ostringstream msg;
         msg << "Type of column ["<< colNum << "] \"" << columnName
diff --git a/src/backends/firebird/vector-use-type.cpp b/src/backends/firebird/vector-use-type.cpp
index 0635a54dc..47d561a7a 100644
--- a/src/backends/firebird/vector-use-type.cpp
+++ b/src/backends/firebird/vector-use-type.cpp
@@ -195,8 +195,8 @@ void firebird_vector_use_type_backend::copy_to_blob(const std::string &in)
 
     blob_ = new firebird_blob_backend(statement_.session_);
     blob_->append(in.c_str(), in.length());
-    blob_->save();
-    memcpy(buf_, &blob_->bid_, sizeof(blob_->bid_));
+    ISC_QUAD blob_id = blob_->save_to_db();
+    memcpy(buf_, &blob_id, sizeof(blob_id));
 }
 
 std::size_t firebird_vector_use_type_backend::size()
diff --git a/src/backends/mysql/blob.cpp b/src/backends/mysql/blob.cpp
index 93d44081a..a6d673aa0 100644
--- a/src/backends/mysql/blob.cpp
+++ b/src/backends/mysql/blob.cpp
@@ -10,6 +10,8 @@
 #include "soci/mysql/soci-mysql.h"
 #include <ciso646>
 
+#include <cctype>
+
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4355 4702)
@@ -18,40 +20,107 @@
 using namespace soci;
 using namespace soci::details;
 
-mysql_blob_backend::mysql_blob_backend(mysql_session_backend &session)
-    : session_(session)
+mysql_blob_backend::mysql_blob_backend(mysql_session_backend &)
+    : details::trivial_blob_backend()
 {
-    throw soci_error("BLOBs are not supported.");
 }
 
 mysql_blob_backend::~mysql_blob_backend()
 {
 }
 
-std::size_t mysql_blob_backend::get_len()
+static unsigned char decode_hex_digit(char c)
 {
-    throw soci_error("BLOBs are not supported.");
+    unsigned char i = static_cast<unsigned char>(tolower(c));
+
+    if (!( (i >= '0' && i <= '9') && (i >= 'a' && i <= 'f') ))
+    {
+        throw soci_error("MySQL BLOB: Encountered invalid characters in hex representation");
+    }
+
+    if (i <= '9')
+    {
+        return i - '0';
+    }
+    else
+    {
+        return i - 'a';
+    }
+}
+
+static char encode_hex_digit(unsigned char d) {
+    static const char hexMap[] = "0123456789abcdef";
+
+    return hexMap[d];
 }
 
-std::size_t mysql_blob_backend::read_from_start(char * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
+std::size_t mysql_blob_backend::hex_str_size() const
 {
-    throw soci_error("BLOBs are not supported.");
+    // Every byte is represented by 2 hex digits
+    // +2 as for non-empty buffers, the resulting hex sequence is prefixed by "0x"
+    return buffer_.size() * 2 + (buffer_.empty() ? 0 : 2);
 }
 
-std::size_t mysql_blob_backend::write_from_start(char const * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
+void mysql_blob_backend::write_hex_str(char *buf, std::size_t size) const
 {
-    throw soci_error("BLOBs are not supported.");
+    if (size < hex_str_size())
+    {
+        throw soci_error("MySQL BLOB: Provided buffer is too small to hold hex string");
+    }
+
+    if (buffer_.empty())
+    {
+        return;
+    }
+    else
+    {
+        buf[0] = '0';
+        buf[1] = 'x';
+    }
+
+    // Inspired by https://codereview.stackexchange.com/a/78539
+    for (std::size_t i = 0; i < buffer_.size(); ++i)
+    {
+        // First 4 bits
+        buf[2 + 2 * i ]    = encode_hex_digit(static_cast<unsigned char>(buffer_[i]) >> 4);
+        // Following 4 bits
+        buf[2 + 2 * i + 1] = encode_hex_digit(static_cast<unsigned char>(buffer_[i]) & 0x0F);
+    }
 }
 
-std::size_t mysql_blob_backend::append(
-    char const * /* buf */, std::size_t /* toWrite */)
+std::string mysql_blob_backend::as_hex_str() const
 {
-    throw soci_error("BLOBs are not supported.");
+
+    std::string hexStr;
+    hexStr.resize(hex_str_size());
+
+    write_hex_str(&hexStr[0], hexStr.size());
+
+    return hexStr;
 }
 
-void mysql_blob_backend::trim(std::size_t /* newLen */)
+void mysql_blob_backend::load_from_hex_str(const char *str, std::size_t length)
 {
-    throw soci_error("BLOBs are not supported.");
+    std::size_t nBytes = length / 2;
+
+    if (nBytes * 2 != length)
+    {
+        // We expect an even amount of hex digits
+        throw soci_error("Cannot load BLOB from invalid hex-representation (uneven amount of digits)");
+    }
+
+    if (nBytes > 0)
+    {
+        // The first "byte" as detected by above calculation is only the prefix "0x"
+        nBytes -= 1;
+    }
+
+    buffer_.resize(nBytes);
+
+    for (std::size_t i = 0; i < nBytes; ++i)
+    {
+        buffer_[i] = (decode_hex_digit(str[2 + 2 * i]) << 4) + decode_hex_digit(str[2 + 2 * i + 1]);
+    }
 }
 
 #ifdef _MSC_VER
diff --git a/src/backends/mysql/standard-into-type.cpp b/src/backends/mysql/standard-into-type.cpp
index edb68684f..a07888c1c 100644
--- a/src/backends/mysql/standard-into-type.cpp
+++ b/src/backends/mysql/standard-into-type.cpp
@@ -13,6 +13,7 @@
 #include "common.h"
 #include "soci-exchange-cast.h"
 #include "soci-mktime.h"
+#include "soci/blob.h"
 // std
 #include <ciso646>
 #include <cstdint>
@@ -140,6 +141,17 @@ void mysql_standard_into_type_backend::post_fetch(
             // attempt to parse the string and convert to std::tm
             parse_std_tm(buf, exchange_type_cast<x_stdtm>(data_));
             break;
+        case x_blob:
+            {
+                unsigned long * lengths = mysql_fetch_lengths(statement_.result_);
+                std::size_t size = lengths[pos];
+                blob &b = exchange_type_cast<x_blob>(data_);
+
+                mysql_blob_backend *bbe = static_cast<mysql_blob_backend *>(b.get_backend());
+
+                bbe->set_data(buf, size);
+            }
+            break;
         default:
             throw soci_error("Into element used with non-supported type.");
         }
diff --git a/src/backends/mysql/standard-use-type.cpp b/src/backends/mysql/standard-use-type.cpp
index 17fe5d381..c0b4c17eb 100644
--- a/src/backends/mysql/standard-use-type.cpp
+++ b/src/backends/mysql/standard-use-type.cpp
@@ -12,6 +12,7 @@
 #include "soci/soci-platform.h"
 #include "soci-dtocstr.h"
 #include "soci-exchange-cast.h"
+#include "soci/blob.h"
 // std
 #include <ciso646>
 #include <cstdint>
@@ -159,6 +160,34 @@ void mysql_standard_use_type_backend::pre_use(indicator const *ind)
                     t.tm_hour, t.tm_min, t.tm_sec);
             }
             break;
+        case x_blob:
+            {
+                blob * b = static_cast<blob *>(data_);
+                mysql_blob_backend * bbe =
+                    static_cast<mysql_blob_backend *>(b->get_backend());
+
+                std::size_t hex_size = bbe->hex_str_size();
+                if (hex_size == 0)
+                {
+                    // We can't represent an empty BLOB as hex (thus hex_str_size returns 0). Instead, we'll
+                    // use '' to initialize and empty BLOB.
+                    buf_ = new char[3];
+                    buf_[0] = '\'';
+                    buf_[1] = '\'';
+                    buf_[2] = '\0';
+                }
+                else
+                {
+                    // Note: since the entire MySQL works by assembling the query in text form,
+                    // we can't make use of proper blob objects (that'd require a more sophisticated
+                    // way of using the MySQL API).
+                    buf_ = new char[hex_size + 1];
+                    bbe->write_hex_str(buf_, hex_size);
+                    // Add NULL terminator
+                    buf_[hex_size] = '\0';
+                }
+            }
+            break;
         default:
             throw soci_error("Use element used with non-supported type.");
         }
diff --git a/src/backends/mysql/statement.cpp b/src/backends/mysql/statement.cpp
index f38db1f29..ec0cf4fb8 100644
--- a/src/backends/mysql/statement.cpp
+++ b/src/backends/mysql/statement.cpp
@@ -463,12 +463,20 @@ void mysql_statement_backend::describe_column(int colNum,
     case 245:                   //MYSQL_TYPE_JSON:
     case FIELD_TYPE_VAR_STRING: //MYSQL_TYPE_VAR_STRING:
     case FIELD_TYPE_STRING:     //MYSQL_TYPE_STRING:
-    case FIELD_TYPE_BLOB:       // TEXT OR BLOB
+        dbtype = db_string;
+        break;
+    case FIELD_TYPE_BLOB:       // BLOB
     case FIELD_TYPE_TINY_BLOB:
     case FIELD_TYPE_MEDIUM_BLOB:
     case FIELD_TYPE_LONG_BLOB:
-        dbtype = db_string;
+    {
+        // Quoted from the docs:
+        // To distinguish between binary and nonbinary data for string data types, check whether the
+        // charsetnr value is 63. If so, the character set is binary, which indicates binary rather
+        // than nonbinary data.
+        dbtype = field->charsetnr == 63 ? db_blob : db_string;
         break;
+    }
     default:
         //std::cerr << "field->type: " << field->type << std::endl;
         throw soci_error("Unknown data type.");
diff --git a/src/backends/odbc/blob.cpp b/src/backends/odbc/blob.cpp
index 434e95a8b..b623533f0 100644
--- a/src/backends/odbc/blob.cpp
+++ b/src/backends/odbc/blob.cpp
@@ -32,18 +32,18 @@ std::size_t odbc_blob_backend::get_len()
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t odbc_blob_backend::read_from_start(char * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
+std::size_t odbc_blob_backend::read_from_start(void * /* buf */, std::size_t /* toRead */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
-std::size_t odbc_blob_backend::write_from_start(char const * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
+std::size_t odbc_blob_backend::write_from_start(const void * /* buf */, std::size_t /* toWrite */, std::size_t /* offset */)
 {
     throw soci_error("BLOBs are not supported.");
 }
 
 std::size_t odbc_blob_backend::append(
-    char const * /* buf */, std::size_t /* toWrite */)
+    const void * /* buf */, std::size_t /* toWrite */)
 {
     throw soci_error("BLOBs are not supported.");
 }
diff --git a/src/backends/oracle/blob.cpp b/src/backends/oracle/blob.cpp
index ee689722f..dd43b996d 100644
--- a/src/backends/oracle/blob.cpp
+++ b/src/backends/oracle/blob.cpp
@@ -23,7 +23,7 @@ using namespace soci::details;
 using namespace soci::details::oracle;
 
 oracle_blob_backend::oracle_blob_backend(oracle_session_backend &session)
-    : session_(session)
+    : session_(session), lobp_(NULL), initialized_(false)
 {
     sword res = OCIDescriptorAlloc(session.envhp_,
         reinterpret_cast<dvoid**>(&lobp_), OCI_DTYPE_LOB, 0, 0);
@@ -35,14 +35,28 @@ oracle_blob_backend::oracle_blob_backend(oracle_session_backend &session)
 
 oracle_blob_backend::~oracle_blob_backend()
 {
+    try
+    {
+        reset();
+    }
+    catch (const oracle_soci_error &)
+    {
+        // Ignore, as we shouldn't throw exceptions from the destructor
+    }
+
     OCIDescriptorFree(lobp_, OCI_DTYPE_LOB);
 }
 
 std::size_t oracle_blob_backend::get_len()
 {
-    ub4 len;
+    if (!initialized_)
+    {
+        return 0;
+    }
+
+    oraub8 len;
 
-    sword res = OCILobGetLength(session_.svchp_, session_.errhp_,
+    sword res = OCILobGetLength2(session_.svchp_, session_.errhp_,
         lobp_, &len);
 
     if (res != OCI_SUCCESS)
@@ -53,13 +67,23 @@ std::size_t oracle_blob_backend::get_len()
     return static_cast<std::size_t>(len);
 }
 
-std::size_t oracle_blob_backend::read_from_start(char *buf, std::size_t toRead, std::size_t offset)
+std::size_t oracle_blob_backend::read_from_start(void *buf, std::size_t toRead, std::size_t offset)
 {
-    ub4 amt = static_cast<ub4>(toRead);
+    if (offset >= get_len())
+    {
+        if (!initialized_ && offset == 0)
+        {
+            // Read-attempts (from the beginning) on uninitialized BLOBs is defined to be a no-op
+            return 0;
+        }
+
+        throw soci_error("Can't read past-the-end of BLOB data.");
+    }
+
+    auto amt = static_cast<oraub8>(toRead);
 
-    sword res = OCILobRead(session_.svchp_, session_.errhp_, lobp_, &amt,
-        static_cast<ub4>(offset + 1), reinterpret_cast<dvoid*>(buf),
-        amt, 0, 0, 0, 0);
+    sword res = OCILobRead2(session_.svchp_, session_.errhp_, lobp_, &amt, nullptr,
+        static_cast<oraub8>(offset + 1), buf, amt, OCI_ONE_PIECE, nullptr, nullptr, 0, SQLCS_IMPLICIT);
     if (res != OCI_SUCCESS)
     {
         throw_oracle_soci_error(res, session_.errhp_);
@@ -68,14 +92,21 @@ std::size_t oracle_blob_backend::read_from_start(char *buf, std::size_t toRead,
     return static_cast<std::size_t>(amt);
 }
 
-std::size_t oracle_blob_backend::write_from_start(char const *buf, std::size_t toWrite, std::size_t offset)
+std::size_t oracle_blob_backend::write_from_start(const void *buf, std::size_t toWrite, std::size_t offset)
 {
-    ub4 amt = static_cast<ub4>(toWrite);
+    if (offset > get_len())
+    {
+        // If offset == length, the operation is to be understood as appending (and is therefore allowed)
+        throw soci_error("Can't start writing far past-the-end of BLOB data.");
+    }
+
+    ensure_initialized();
+
+    auto amt = static_cast<oraub8>(toWrite);
 
-    sword res = OCILobWrite(session_.svchp_, session_.errhp_, lobp_, &amt,
-        static_cast<ub4>(offset + 1),
-        reinterpret_cast<dvoid*>(const_cast<char*>(buf)),
-        amt, OCI_ONE_PIECE, 0, 0, 0, 0);
+    sword res = OCILobWrite2(session_.svchp_, session_.errhp_, lobp_, &amt, nullptr,
+        static_cast<oraub8>(offset + 1),
+        const_cast<void*>(buf), amt, OCI_ONE_PIECE, 0, 0, 0, 0);
     if (res != OCI_SUCCESS)
     {
         throw_oracle_soci_error(res, session_.errhp_);
@@ -84,13 +115,14 @@ std::size_t oracle_blob_backend::write_from_start(char const *buf, std::size_t t
     return static_cast<std::size_t>(amt);
 }
 
-std::size_t oracle_blob_backend::append(char const *buf, std::size_t toWrite)
+std::size_t oracle_blob_backend::append(const void *buf, std::size_t toWrite)
 {
-    ub4 amt = static_cast<ub4>(toWrite);
+    ensure_initialized();
 
-    sword res = OCILobWriteAppend(session_.svchp_, session_.errhp_, lobp_,
-        &amt, reinterpret_cast<dvoid*>(const_cast<char*>(buf)),
-        amt, OCI_ONE_PIECE, 0, 0, 0, 0);
+    auto amt = static_cast<oraub8>(toWrite);
+
+    sword res = OCILobWriteAppend2(session_.svchp_, session_.errhp_, lobp_,
+        &amt, nullptr, const_cast<void*>(buf), amt, OCI_ONE_PIECE, 0, 0, 0, 0);
     if (res != OCI_SUCCESS)
     {
         throw_oracle_soci_error(res, session_.errhp_);
@@ -101,10 +133,109 @@ std::size_t oracle_blob_backend::append(char const *buf, std::size_t toWrite)
 
 void oracle_blob_backend::trim(std::size_t newLen)
 {
-    sword res = OCILobTrim(session_.svchp_, session_.errhp_, lobp_,
-        static_cast<ub4>(newLen));
+    sword res = OCILobTrim2(session_.svchp_, session_.errhp_, lobp_,
+        static_cast<oraub8>(newLen));
     if (res != OCI_SUCCESS)
     {
         throw_oracle_soci_error(res, session_.errhp_);
     }
 }
+
+oracle_blob_backend::locator_t oracle_blob_backend::get_lob_locator() const
+{
+    return lobp_;
+}
+
+void oracle_blob_backend::set_lob_locator(oracle_blob_backend::locator_t locator, bool initialized)
+{
+    // If we select a BLOB value into a BLOB object, then the post_fetch code in
+    // the standard_into_type_backend will set this object's locator to the one it is
+    // already holding.
+    // In this case, the locator now already points to the desired BLOB object and thus we
+    // must not reset it.
+    if (lobp_ != locator)
+    {
+        reset();
+
+        lobp_ = locator;
+    }
+
+    initialized_ = initialized;
+
+    if (initialized)
+    {
+        boolean already_open = FALSE;
+        sword res = OCILobIsOpen(session_.svchp_, session_.errhp_, lobp_, &already_open);
+
+        if (res != OCI_SUCCESS)
+        {
+            throw_oracle_soci_error(res, session_.errhp_);
+        }
+
+        if (!already_open)
+        {
+            res = OCILobOpen(session_.svchp_, session_.errhp_, lobp_, OCI_LOB_READWRITE);
+
+            if (res != OCI_SUCCESS)
+            {
+                throw_oracle_soci_error(res, session_.errhp_);
+            }
+        }
+    }
+}
+
+void oracle_blob_backend::reset()
+{
+    if (!initialized_)
+    {
+        return;
+    }
+
+    boolean is_temporary = FALSE;
+    sword res = OCILobIsTemporary(session_.envhp_, session_.errhp_, lobp_, &is_temporary);
+
+    if (res != OCI_SUCCESS)
+    {
+        throw_oracle_soci_error(res, session_.errhp_);
+    }
+
+    if (is_temporary)
+    {
+        res = OCILobFreeTemporary(session_.svchp_, session_.errhp_, lobp_);
+    }
+    else
+    {
+        res = OCILobClose(session_.svchp_, session_.errhp_, lobp_);
+    }
+
+    if (res != OCI_SUCCESS)
+    {
+        throw_oracle_soci_error(res, session_.errhp_);
+    }
+
+    initialized_ = false;
+}
+
+void oracle_blob_backend::ensure_initialized()
+{
+    if (!initialized_)
+    {
+        // If asked to initialize explicitly, we can only create a temporary LOB
+        sword res = OCILobCreateTemporary(session_.svchp_, session_.errhp_, lobp_,
+                OCI_DEFAULT, SQLCS_IMPLICIT, OCI_TEMP_BLOB, FALSE, OCI_DURATION_SESSION);
+
+        if (res != OCI_SUCCESS)
+        {
+            throw_oracle_soci_error(res, session_.errhp_);
+        }
+
+        res = OCILobOpen(session_.svchp_, session_.errhp_, lobp_, OCI_LOB_READWRITE);
+
+        if (res != OCI_SUCCESS)
+        {
+            throw_oracle_soci_error(res, session_.errhp_);
+        }
+
+        initialized_ = true;
+    }
+}
diff --git a/src/backends/oracle/standard-into-type.cpp b/src/backends/oracle/standard-into-type.cpp
index 01292313b..87ba49111 100644
--- a/src/backends/oracle/standard-into-type.cpp
+++ b/src/backends/oracle/standard-into-type.cpp
@@ -131,7 +131,7 @@ void oracle_standard_into_type_backend::define_by_pos(
 
             oracle_statement_backend *stbe
                 = static_cast<oracle_statement_backend *>(st->get_backend());
-            size = 0;
+            size = sizeof(stbe->stmtp_);
             data = &stbe->stmtp_;
         }
         break;
@@ -144,7 +144,7 @@ void oracle_standard_into_type_backend::define_by_pos(
             oracle_rowid_backend *rbe
                 = static_cast<oracle_rowid_backend *>(rid->get_backend());
 
-            size = 0;
+            size = sizeof(rbe->rowidp_);
             data = &rbe->rowidp_;
         }
         break;
@@ -157,8 +157,14 @@ void oracle_standard_into_type_backend::define_by_pos(
             oracle_blob_backend *bbe
                 = static_cast<oracle_blob_backend *>(b->get_backend());
 
-            size = 0;
-            data = &bbe->lobp_;
+            // Reset the blob to ensure that a potentially open temporary BLOB gets
+            // freed before the locator is changed to point to a different BLOB by the
+            // to-be-executed statement (which would leave us with a dangling temporary BLOB)
+            bbe->reset();
+            ociData_ = bbe->get_lob_locator();
+
+            size = sizeof(ociData_);
+            data = &ociData_;
         }
         break;
 
@@ -322,6 +328,15 @@ void oracle_standard_into_type_backend::post_fetch(
                     lobp, exchange_type_cast<x_longstring>(data_).value);
             }
         }
+        else if (type_ == x_blob)
+        {
+            blob *b = static_cast<blob *>(data_);
+
+            oracle_blob_backend *bbe
+                = static_cast<oracle_blob_backend *>(b->get_backend());
+
+            bbe->set_lob_locator(reinterpret_cast<oracle_blob_backend::locator_t>(ociData_));
+        }
     }
 
     // then - deal with indicators
@@ -367,6 +382,11 @@ void oracle_standard_into_type_backend::clean_up()
         ociData_ = NULL;
     }
 
+    if (type_ == x_blob)
+    {
+        ociData_ = NULL;
+    }
+
     if (defnp_ != NULL)
     {
         OCIHandleFree(defnp_, OCI_HTYPE_DEFINE);
diff --git a/src/backends/oracle/standard-use-type.cpp b/src/backends/oracle/standard-use-type.cpp
index 0aac00e10..78ac109e1 100644
--- a/src/backends/oracle/standard-use-type.cpp
+++ b/src/backends/oracle/standard-use-type.cpp
@@ -149,7 +149,7 @@ void oracle_standard_use_type_backend::prepare_for_bind(
 
             oracle_statement_backend *stbe
                 = static_cast<oracle_statement_backend *>(st->get_backend());
-            size = 0;
+            size = sizeof(stbe->stmtp_);
             data = &stbe->stmtp_;
         }
         break;
@@ -162,7 +162,7 @@ void oracle_standard_use_type_backend::prepare_for_bind(
             oracle_rowid_backend *rbe
                 = static_cast<oracle_rowid_backend *>(rid->get_backend());
 
-            size = 0;
+            size = sizeof(rbe->rowidp_);
             data = &rbe->rowidp_;
         }
         break;
@@ -175,8 +175,13 @@ void oracle_standard_use_type_backend::prepare_for_bind(
             oracle_blob_backend *bbe
                 = static_cast<oracle_blob_backend *>(b->get_backend());
 
-            size = 0;
-            data = &bbe->lobp_;
+            // We have to make sure that our blob backend is actually properly initialized
+            bbe->ensure_initialized();
+
+            ociData_ = bbe->get_lob_locator();
+
+            size = sizeof(ociData_);
+            data = &ociData_;
         }
         break;
 
@@ -675,8 +680,8 @@ void oracle_standard_use_type_backend::post_use(bool gotData, indicator *ind)
                 s->define_and_bind();
             }
             break;
-        case x_rowid:
         case x_blob:
+        case x_rowid:
         case x_xmltype:
         case x_longstring:
             // nothing to do here
@@ -711,6 +716,11 @@ void oracle_standard_use_type_backend::clean_up()
         free_temp_lob(statement_.session_, static_cast<OCILobLocator *>(ociData_));
         ociData_ = NULL;
     }
+    
+    if (type_ == x_blob)
+    {
+        ociData_ = NULL;
+    }
 
     if (bindp_ != NULL)
     {
diff --git a/src/backends/oracle/statement.cpp b/src/backends/oracle/statement.cpp
index 0db66132a..0622db91c 100644
--- a/src/backends/oracle/statement.cpp
+++ b/src/backends/oracle/statement.cpp
@@ -315,6 +315,9 @@ void oracle_statement_backend::describe_column(int colNum,
     case SQLT_DAT:
         xdbtype = db_date;
         break;
+    case SQLT_BLOB:
+        xdbtype = db_blob;
+        break;
     default:
         // Unknown oracle types will just be represented by a string
         xdbtype = db_string;
diff --git a/src/backends/postgresql/blob.cpp b/src/backends/postgresql/blob.cpp
index 0e46e32f6..155e4afc3 100644
--- a/src/backends/postgresql/blob.cpp
+++ b/src/backends/postgresql/blob.cpp
@@ -13,6 +13,7 @@
 #include <cstring>
 #include <ctime>
 #include <sstream>
+#include <limits>
 
 #ifdef _MSC_VER
 #pragma warning(disable:4355)
@@ -22,9 +23,14 @@ using namespace soci;
 using namespace soci::details;
 
 
+postgresql_blob_backend::blob_details::blob_details() : oid(InvalidOid), fd(-1) {}
+
+postgresql_blob_backend::blob_details::blob_details(unsigned long oid, int fd) : oid(oid), fd(fd) {}
+
+
 postgresql_blob_backend::postgresql_blob_backend(
     postgresql_session_backend & session)
-    : session_(session), fd_(-1)
+    : session_(session), details_(), destroy_on_close_(false), clone_before_modify_(false)
 {
     // nothing to do here, the descriptor is open in the postFetch
     // method of the Into element
@@ -32,80 +38,263 @@ postgresql_blob_backend::postgresql_blob_backend(
 
 postgresql_blob_backend::~postgresql_blob_backend()
 {
-    if (fd_ != -1)
-    {
-        lo_close(session_.conn_, fd_);
-    }
+    reset();
 }
 
 std::size_t postgresql_blob_backend::get_len()
 {
-    int const pos = lo_lseek(session_.conn_, fd_, 0, SEEK_END);
-    if (pos == -1)
+    return details_.fd == -1 ? 0 : seek(0, SEEK_END);
+}
+
+std::size_t postgresql_blob_backend::read_from_start(void * buf, std::size_t toRead, std::size_t offset)
+{
+    std::size_t size = get_len();
+    if (offset >= size && !(size == 0 && offset == 0))
+    {
+        throw soci_error("Can't read past-the-end of BLOB data.");
+    }
+    if (size == 0)
     {
-        throw soci_error("Cannot retrieve the size of BLOB.");
+        // Reading from an empty blob, is defined as a no-op
+        return 0;
     }
 
-    return static_cast<std::size_t>(pos);
+    // According to postgres docs, lo_read rejects anything that wants to read more than INT_MAX bytes
+    const std::size_t batchSize = std::numeric_limits<std::int32_t>::max();
+    const std::size_t nBatches = toRead / batchSize + 1;
+
+    std::size_t readBytes = 0;
+    for (std::size_t i = 0; i < nBatches; ++i) {
+        seek(offset, SEEK_SET);
+
+        const int readn = lo_read(session_.conn_, details_.fd, reinterpret_cast<char *>(buf), std::min(toRead, batchSize));
+        if (readn < 0)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            throw soci_error(std::string("Cannot read from BLOB: ") + errorMsg);
+        }
+
+        toRead -= batchSize;
+        offset += batchSize;
+        readBytes += static_cast<std::size_t>(readn);
+    }
+
+    return readBytes;
 }
 
-std::size_t postgresql_blob_backend::read_from_start(char * buf, std::size_t toRead, std::size_t offset)
+std::size_t postgresql_blob_backend::write_from_start(const void * buf, std::size_t toWrite, std::size_t offset)
 {
-    int const pos = lo_lseek(session_.conn_, fd_,
-        static_cast<int>(offset), SEEK_SET);
-    if (pos == -1)
+    if (offset > get_len())
     {
-        throw soci_error("Cannot seek in BLOB.");
+        // If offset == length, the operation is to be understood as appending (and is therefore allowed)
+        throw soci_error("Can't start writing far past-the-end of BLOB data.");
     }
 
-    int const readn = lo_read(session_.conn_, fd_, buf, toRead);
-    if (readn < 0)
+    if (clone_before_modify_)
     {
-        throw soci_error("Cannot read from BLOB.");
+        clone();
+    }
+
+    init();
+
+    // According to the docs, lo_write doesn't work for chunk sizes > INT_MAX
+    const std::size_t batchSize = std::numeric_limits<std::int32_t>::max();
+    const std::size_t nBatches = toWrite / batchSize + 1;
+
+    std::size_t writtenBytes = 0;
+    for (std::size_t i = 0; i < nBatches; ++i) {
+        seek(offset, SEEK_SET);
+
+        const int written = lo_write(session_.conn_, details_.fd,
+            reinterpret_cast<const char *>(buf), std::min(toWrite, batchSize));
+        if (written < 0)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            throw soci_error(std::string("Cannot write to BLOB: ") + errorMsg);
+        }
+
+        toWrite -= batchSize;
+        offset += batchSize;
+        writtenBytes += static_cast<std::size_t>(written);
     }
 
-    return static_cast<std::size_t>(readn);
+    return writtenBytes;
+}
+
+std::size_t postgresql_blob_backend::append(
+    const void * buf, std::size_t toWrite)
+{
+    return write_from_start(buf, toWrite, get_len());
 }
 
-std::size_t postgresql_blob_backend::write_from_start(char const * buf, std::size_t toWrite, std::size_t offset)
+void postgresql_blob_backend::trim(std::size_t newLen)
 {
-    int const pos = lo_lseek(session_.conn_, fd_,
-        static_cast<int>(offset), SEEK_SET);
-    if (pos == -1)
+    if (clone_before_modify_)
     {
-        throw soci_error("Cannot seek in BLOB.");
+        if (newLen == 0)
+        {
+            // In case we're clearing the BLOB anyway, there is no point in copying the old data over first
+            reset();
+        }
+        else
+        {
+            clone();
+        }
     }
 
-    int const writen = lo_write(session_.conn_, fd_,
-        const_cast<char *>(buf), toWrite);
-    if (writen < 0)
+    init();
+
+    int ret_code = lo_truncate64(session_.conn_, details_.fd, newLen);
+
+    if (ret_code < 0)
     {
-        throw soci_error("Cannot write to BLOB.");
+        const char *errorMsg = PQerrorMessage(session_.conn_);
+        throw soci_error(std::string("Cannot truncate BLOB: ") + errorMsg);
     }
+}
 
-    return static_cast<std::size_t>(writen);
+const postgresql_blob_backend::blob_details &postgresql_blob_backend::get_blob_details() const
+{
+    return details_;
 }
 
-std::size_t postgresql_blob_backend::append(
-    char const * buf, std::size_t toWrite)
+void postgresql_blob_backend::set_blob_details(const postgresql_blob_backend::blob_details &details)
+{
+    reset();
+
+    details_ = details;
+}
+
+bool postgresql_blob_backend::get_destroy_on_close() const
+{
+    return destroy_on_close_;
+}
+
+void postgresql_blob_backend::set_destroy_on_close(bool destroy)
 {
-    int const pos = lo_lseek(session_.conn_, fd_, 0, SEEK_END);
-    if (pos == -1)
+    destroy_on_close_ = destroy;
+}
+
+void postgresql_blob_backend::set_clone_before_modify(bool clone)
+{
+    clone_before_modify_ = clone;
+}
+
+void postgresql_blob_backend::init()
+{
+    if (details_.fd == -1)
     {
-        throw soci_error("Cannot seek in BLOB.");
+        // Create a new large object
+        Oid oid = lo_creat(session_.conn_, INV_READ | INV_WRITE);
+
+        if (oid == InvalidOid)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            throw soci_error(std::string("Cannot create new BLOB: ") + errorMsg);
+        }
+
+        int fd = lo_open(session_.conn_, oid, INV_READ | INV_WRITE);
+
+        if (fd == -1)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            lo_unlink(session_.conn_, oid);
+            throw soci_error(std::string("Cannot open newly created BLOB: ") + errorMsg);
+        }
+
+        details_.oid = oid;
+        details_.fd = fd;
     }
+}
+
+void postgresql_blob_backend::reset()
+{
+    if (details_.fd != -1)
+    {
+        if (destroy_on_close_)
+        {
+            // Remove the large object from the DB completely
+            lo_unlink(session_.conn_, details_.fd);
+        }
+        else
+        {
+            // Merely close our handle to the large object
+            lo_close(session_.conn_, details_.fd);
+        }
+
+        details_ = {};
+    }
+
+    destroy_on_close_ = false;
+    clone_before_modify_ = false;
+}
+
+std::size_t do_seek(std::size_t toOffset, int from,
+        soci::postgresql_session_backend &session, soci::postgresql_blob_backend::blob_details &details)
+{
+    pg_int64 pos = lo_lseek64(session.conn_, details.fd, static_cast<pg_int64>(toOffset), from);
 
-    int const writen = lo_write(session_.conn_, fd_,
-        const_cast<char *>(buf), toWrite);
-    if (writen < 0)
+    if (pos < 0)
     {
-        throw soci_error("Cannot append to BLOB.");
+        const char *errorMsg = PQerrorMessage(session.conn_);
+        throw soci_error(std::string("Failed to seek in BLOB: ") + errorMsg);
     }
 
-    return static_cast<std::size_t>(writen);
+    return static_cast<std::size_t>(pos);
+}
+
+std::size_t postgresql_blob_backend::seek(std::size_t toOffset, int from)
+{
+    return do_seek(toOffset, from, session_, details_);
 }
 
-void postgresql_blob_backend::trim(std::size_t /* newLen */)
+void postgresql_blob_backend::clone()
 {
-    throw soci_error("Trimming BLOBs is not supported.");
+    clone_before_modify_ = false;
+    if (details_.fd == -1)
+    {
+        return;
+    }
+
+    blob_details old_details = details_;
+    details_ = {};
+    reset();
+    init();
+
+    char buf[1024];
+    std::size_t offset = 0;
+    int read_bytes = 0;
+    do
+    {
+        do_seek(offset, SEEK_SET, session_, old_details);
+        read_bytes = lo_read(session_.conn_, old_details.fd, buf, sizeof(buf));
+
+        if (read_bytes < 0)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            throw soci::soci_error(std::string("Can't read from original BLOB during clone: ") + errorMsg);
+        }
+
+        int bytes_written = lo_write(session_.conn_, details_.fd, buf, read_bytes);
+
+        if (bytes_written != read_bytes)
+        {
+            const char *errorMsg = PQerrorMessage(session_.conn_);
+            throw soci::soci_error(std::string("Can't write (all) data from old BLOB to new one during clone: ") + errorMsg);
+        }
+
+        offset += sizeof(buf);
+    } while (read_bytes == sizeof(buf));
+
+    // Dispose old BLOB object
+    if (destroy_on_close_)
+    {
+        // Remove the large object from the DB completely
+        lo_unlink(session_.conn_, old_details.fd);
+    }
+    else
+    {
+        // Merely close our handle to the large object
+        lo_close(session_.conn_, old_details.fd);
+    }
 }
diff --git a/src/backends/postgresql/standard-into-type.cpp b/src/backends/postgresql/standard-into-type.cpp
index 023b1dda1..d0d7d0b90 100644
--- a/src/backends/postgresql/standard-into-type.cpp
+++ b/src/backends/postgresql/standard-into-type.cpp
@@ -143,20 +143,15 @@ void postgresql_standard_into_type_backend::post_fetch(
                     INV_READ | INV_WRITE);
                 if (fd == -1)
                 {
-                    throw soci_error("Cannot open the blob object.");
+                    const char *errorMsg = PQerrorMessage(statement_.session_.conn_);
+                    throw soci_error(std::string("Cannot open the blob object: ") + errorMsg);
                 }
 
                 blob * b = static_cast<blob *>(data_);
                 postgresql_blob_backend * bbe
                      = static_cast<postgresql_blob_backend *>(b->get_backend());
 
-                if (bbe->fd_ != -1)
-                {
-                    lo_close(statement_.session_.conn_, bbe->fd_);
-                }
-
-                bbe->fd_ = fd;
-                bbe->oid_ = oid;
+                bbe->set_blob_details(postgresql_blob_backend::blob_details(oid, fd));
             }
             break;
         case x_xmltype:
diff --git a/src/backends/postgresql/standard-use-type.cpp b/src/backends/postgresql/standard-use-type.cpp
index 9cff41eee..e6e7ae83e 100644
--- a/src/backends/postgresql/standard-use-type.cpp
+++ b/src/backends/postgresql/standard-use-type.cpp
@@ -170,10 +170,29 @@ void postgresql_standard_use_type_backend::pre_use(indicator const * ind)
                 postgresql_blob_backend * bbe =
                     static_cast<postgresql_blob_backend *>(b->get_backend());
 
+                // In case the backend does not reference a proper BLOB yet, this will create a
+                // new, empty one
+                bbe->init();
+
+                unsigned long oid = bbe->get_blob_details().oid;
+
+                if (oid == InvalidOid)
+                {
+                    throw soci_error("Cannot insert invalid BLOB.");
+                }
+
+                // In case the blob backend has created a new BLOB in the DB, we have to tell it
+                // to not destroy it again, because we will now actually insert it into the DB.
+                bbe->set_destroy_on_close(false);
+
+                // We don't want any subsequent changes made to the blob object to leak to the
+                // object that we are currently writing into the DB
+                bbe->set_clone_before_modify(true);
+
                 std::size_t const bufSize
                     = std::numeric_limits<unsigned long>::digits10 + 2;
                 buf_ = new char[bufSize];
-                snprintf(buf_, bufSize, "%lu", bbe->oid_);
+                snprintf(buf_, bufSize, "%lu", oid);
             }
             break;
         case x_xmltype:
diff --git a/src/backends/postgresql/statement.cpp b/src/backends/postgresql/statement.cpp
index 5995b45b7..f65934753 100644
--- a/src/backends/postgresql/statement.cpp
+++ b/src/backends/postgresql/statement.cpp
@@ -750,7 +750,7 @@ void postgresql_statement_backend::describe_column(int colNum,
     switch (typeOid)
     {
     // Note: the following list of OIDs was taken from the pg_type table
-    // we do not claim that this list is exchaustive or even correct.
+    // we do not claim that this list is exhaustive or even correct.
 
                // from pg_type:
 
@@ -796,7 +796,6 @@ void postgresql_statement_backend::describe_column(int colNum,
         break;
 
     case 23:   // int4
-    case 26:   // oid
         dbtype = db_int32;
         break;
 
@@ -804,6 +803,13 @@ void postgresql_statement_backend::describe_column(int colNum,
         dbtype = db_int64;
         break;
 
+    case 26:   // oid
+        // Note that in theory OIDs can refer to all sorts of things, but their use
+        // for anything but BLOBs seems to be deprecated since PostreSQL 8, so we simply
+        // assume any OID refers to a BLOB.
+       dbtype = db_blob;
+       break;
+
     default:
     {
         auto typeCategoryIt = categoryByColumnOID_.find(typeOid);
diff --git a/src/backends/sqlite3/blob.cpp b/src/backends/sqlite3/blob.cpp
index 15dcd371a..28e2bf803 100644
--- a/src/backends/sqlite3/blob.cpp
+++ b/src/backends/sqlite3/blob.cpp
@@ -13,103 +13,19 @@
 
 using namespace soci;
 
-sqlite3_blob_backend::sqlite3_blob_backend(sqlite3_session_backend &session)
-    : session_(session), buf_(0), len_(0)
+sqlite3_blob_backend::sqlite3_blob_backend(sqlite3_session_backend &)
+    : details::trivial_blob_backend()
 {
 }
 
 sqlite3_blob_backend::~sqlite3_blob_backend()
 {
-    if (buf_)
-    {
-        delete [] buf_;
-        buf_ = 0;
-        len_ = 0;
-    }
 }
 
-std::size_t sqlite3_blob_backend::get_len()
+void sqlite3_blob_backend::ensure_buffer_initialized()
 {
-    return len_;
-}
-
-std::size_t sqlite3_blob_backend::read_from_start(char * buf, std::size_t toRead, std::size_t offset)
-{
-    size_t r = toRead;
-
-    // make sure that we don't try to read
-    // past the end of the data
-    if (r > len_ - offset)
-    {
-        r = len_ - offset;
-    }
-
-    memcpy(buf, buf_ + offset, r);
-
-    return r;
-}
-
-
-std::size_t sqlite3_blob_backend::write_from_start(char const * buf, std::size_t toWrite, std::size_t offset)
-{
-    const char* oldBuf = buf_;
-    std::size_t oldLen = len_;
-    len_ = (std::max)(len_, offset + toWrite);
-
-    buf_ = new char[len_];
-
-    if (oldBuf)
-    {
-        // we need to copy both old and new buffers
-        // it is possible that the new does not
-        // completely cover the old
-        memcpy(buf_, oldBuf, oldLen);
-        delete [] oldBuf;
-    }
-    memcpy(buf_ + offset, buf, toWrite);
-
-    return len_;
-}
-
-
-std::size_t sqlite3_blob_backend::append(
-    char const * buf, std::size_t toWrite)
-{
-    const char* oldBuf = buf_;
-
-    buf_ = new char[len_ + toWrite];
-
-    memcpy(buf_, oldBuf, len_);
-
-    memcpy(buf_ + len_, buf, toWrite);
-
-    delete [] oldBuf;
-
-    len_ += toWrite;
-
-    return len_;
-}
-
-
-void sqlite3_blob_backend::trim(std::size_t newLen)
-{
-    const char* oldBuf = buf_;
-    len_ = newLen;
-
-    buf_ = new char[len_];
-
-    memcpy(buf_, oldBuf, len_);
-
-    delete [] oldBuf;
-}
-
-std::size_t sqlite3_blob_backend::set_data(char const *buf, std::size_t toWrite)
-{
-    if (buf_)
-    {
-        delete [] buf_;
-        buf_ = 0;
-        len_ = 0;
-    }
-    return write_from_start(buf, toWrite);
+    // Ensure that the used buffer is at least large enough to hold one element.
+    // Thus, in case the vector has not yet allocated a buffer at all, it is forced
+    // to do so now.
+    buffer_.reserve(1);
 }
diff --git a/src/backends/sqlite3/standard-use-type.cpp b/src/backends/sqlite3/standard-use-type.cpp
index 016f4da6e..7b39f4272 100644
--- a/src/backends/sqlite3/standard-use-type.cpp
+++ b/src/backends/sqlite3/standard-use-type.cpp
@@ -204,7 +204,15 @@ void sqlite3_standard_use_type_backend::pre_use(indicator const * ind)
             blob *b = static_cast<blob *>(data_);
             sqlite3_blob_backend *bbe = static_cast<sqlite3_blob_backend *>(b->get_backend());
 
-            col.buffer_.constData_ = bbe->get_buffer();
+            // In case the internal buffer has not been initialized yet, get_buffer() will return nullptr. In this case,
+            // we want to make sure to insert an empty BLOB into the DB. However, when passing a nullptr to the
+            // sqlite3_bind_blob routine (in statement.cpp), it has the same effect as sqlite3_bind_null and thus
+            // is inserting NULL instead.
+            // Therefore, we want to make sure that the buffer is definitely initialized (though it can still be empty).
+            bbe->ensure_buffer_initialized();
+
+            static_assert(sizeof(decltype(*bbe->get_buffer())) == 1, "Expected byte-like type");
+            col.buffer_.constData_ = reinterpret_cast<const char *>(bbe->get_buffer());
             col.buffer_.size_ = bbe->get_len();
             break;
         }
diff --git a/src/backends/sqlite3/statement.cpp b/src/backends/sqlite3/statement.cpp
index c21909be0..9843b2da2 100644
--- a/src/backends/sqlite3/statement.cpp
+++ b/src/backends/sqlite3/statement.cpp
@@ -327,7 +327,11 @@ sqlite3_statement_backend::bind_and_execute(int number)
                         break;
 
                     case db_blob:
-                        bindRes = sqlite3_bind_blob(stmt_, pos, col.buffer_.constData_, static_cast<int>(col.buffer_.size_), NULL);
+                        // Since we don't own the buffer_ pointer we are passing here, we can't make any lifetime
+                        // guarantees other than it is currently valid. Thus, we ask SQLite to make a copy of the
+                        // underlying buffer to ensure the database can always access a valid buffer.
+                        bindRes = sqlite3_bind_blob(stmt_, pos, col.buffer_.constData_,
+                                static_cast<int>(col.buffer_.size_), SQLITE_TRANSIENT);
                         break;
 
                     case db_xml:
@@ -565,6 +569,8 @@ void sqlite3_statement_backend::describe_column(int colNum,
         dbtype = db_double;
         break;
     case SQLITE_BLOB:
+        dbtype = db_blob;
+        break;
     case SQLITE_TEXT:
         dbtype = db_string;
         break;
diff --git a/src/core/blob.cpp b/src/core/blob.cpp
index f42930ed7..dfd3b9895 100644
--- a/src/core/blob.cpp
+++ b/src/core/blob.cpp
@@ -15,50 +15,75 @@
 using namespace soci;
 
 blob::blob(session & s)
-	: backEnd_{s.make_blob_backend()}
 {
+    initialize(s);
 }
 
 blob::~blob() = default;
 
+bool blob::is_valid() const
+{
+    return static_cast<bool>(backEnd_);
+}
+
+void blob::initialize(session &session)
+{
+    backEnd_.reset(session.make_blob_backend());
+}
+
 std::size_t blob::get_len()
 {
+    ensure_initialized();
     return backEnd_->get_len();
 }
 
-std::size_t blob::read(std::size_t offset, char *buf, std::size_t toRead)
+std::size_t blob::read(std::size_t offset, void *buf, std::size_t toRead)
 {
+    ensure_initialized();
     SOCI_ALLOW_DEPRECATED_BEGIN
     return backEnd_->read(offset, buf, toRead);
     SOCI_ALLOW_DEPRECATED_END
 }
 
-std::size_t blob::read_from_start(char * buf, std::size_t toRead,
+std::size_t blob::read_from_start(void * buf, std::size_t toRead,
     std::size_t offset)
 {
+    ensure_initialized();
     return backEnd_->read_from_start(buf, toRead, offset);
 }
 
 std::size_t blob::write(
-    std::size_t offset, char const * buf, std::size_t toWrite)
+    std::size_t offset, const void * buf, std::size_t toWrite)
 {
+    ensure_initialized();
     SOCI_ALLOW_DEPRECATED_BEGIN
     return backEnd_->write(offset, buf, toWrite);
     SOCI_ALLOW_DEPRECATED_END
 }
 
-std::size_t blob::write_from_start(const char * buf, std::size_t toWrite,
+std::size_t blob::write_from_start(const void * buf, std::size_t toWrite,
     std::size_t offset)
 {
+    ensure_initialized();
     return backEnd_->write_from_start(buf, toWrite, offset);
 }
 
-std::size_t blob::append(char const * buf, std::size_t toWrite)
+std::size_t blob::append(const void * buf, std::size_t toWrite)
 {
+    ensure_initialized();
     return backEnd_->append(buf, toWrite);
 }
 
 void blob::trim(std::size_t newLen)
 {
+    ensure_initialized();
     backEnd_->trim(newLen);
 }
+
+void blob::ensure_initialized()
+{
+    if (!is_valid())
+    {
+        throw soci_error("Attempted to access invalid blob");
+    }
+}
diff --git a/src/core/row.cpp b/src/core/row.cpp
index 2612e6009..da145deb7 100644
--- a/src/core/row.cpp
+++ b/src/core/row.cpp
@@ -109,3 +109,14 @@ std::size_t row::find_column(std::string const &name) const
 
     return it->second;
 }
+
+template <>
+blob row::move_as<blob>(std::size_t pos) const
+{
+    typedef typename type_conversion<blob>::base_type base_type;
+    base_type & baseVal = holders_.at(pos)->get<base_type>();
+
+    blob ret;
+    type_conversion<blob>::move_from_base(baseVal, *indicators_.at(pos), ret);
+    return ret;
+}
diff --git a/src/core/statement.cpp b/src/core/statement.cpp
index 495cca58e..7bf5e777c 100644
--- a/src/core/statement.cpp
+++ b/src/core/statement.cpp
@@ -6,6 +6,8 @@
 //
 
 #define SOCI_SOURCE
+#include "soci/blob.h"
+#include "soci/blob-exchange.h"
 #include "soci/statement.h"
 #include "soci/session.h"
 #include "soci/into-type.h"
@@ -695,6 +697,12 @@ void statement_impl::bind_into<db_date>()
     into_row<std::tm>();
 }
 
+template<>
+void statement_impl::bind_into<db_blob>()
+{
+    into_row<blob>();
+}
+
 void statement_impl::describe()
 {
     row_->clean_up();
@@ -715,10 +723,12 @@ void statement_impl::describe()
         switch (dbtype)
         {
         case db_string:
-        case db_blob:
         case db_xml:
             bind_into<db_string>();
             break;
+        case db_blob:
+            bind_into<db_blob>();
+            break;
         case db_double:
             bind_into<db_double>();
             break;
@@ -868,3 +878,12 @@ statement_impl::rethrow_current_exception_with_context(char const* operation)
         throw;
     }
 }
+
+template<>
+void statement_impl::into_row<blob>()
+{
+    blob * b = new blob(session_);
+    indicator * ind = new indicator(i_ok);
+    row_->add_holder(b, ind);
+    exchange_for_row(into(*b, *ind));
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7e65d2c65..c8397b4ee 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -14,6 +14,10 @@ colormsg(_HIBLUE_ "Configuring SOCI tests:")
 # This works around a problem when building in C++11 mode with clang (see #984).
 add_definitions(-DCATCH_CONFIG_CPP11_NO_SHUFFLE)
 
+if(MSVC)
+  add_compile_options(/bigobj)
+endif()
+
 include_directories(
   ${SOCI_SOURCE_DIR}/include/private
   ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/tests/common-tests.h b/tests/common-tests.h
index f16c52c6b..cb81501a2 100644
--- a/tests/common-tests.h
+++ b/tests/common-tests.h
@@ -417,6 +417,12 @@ class test_context_base
     // Returns null by default to indicate that CLOB is not supported.
     virtual table_creator_base* table_creator_clob(session&) const { return NULL; }
 
+    // Override this to return the table creator for a simple table containing
+    // an integer "id" column and BLOB "b" one.
+    //
+    // Returns null by default to indicate that BLOB is not supported.
+    virtual table_creator_base* table_creator_blob(session&) const { return NULL; }
+
     // Override this to return the table creator for a simple table containing
     // an integer "id" column and XML "x" one.
     //
@@ -6377,6 +6383,382 @@ TEST_CASE_METHOD(common_tests, "Into XML vector with several fetches", "[core][x
     REQUIRE(!st.fetch());
 }
 
+TEST_CASE_METHOD(common_tests, "BLOB", "[core][blob]")
+{
+    soci::session sql(backEndFactory_, connectString_);
+
+    auto_table_creator tableCreator(tc_.table_creator_blob(sql));
+
+    if (!tableCreator.get())
+    {
+        try
+        {
+            soci::blob blob(sql);
+            FAIL("BLOB creation should throw, if backend doesn't support BLOBs");
+        }
+        catch (const soci_error &)
+        {
+            // Throwing is expected if the backend doesn't support BLOBs
+        }
+        WARN("BLOB type not supported by the database, skipping the test.");
+        return;
+    }
+
+    const char dummy_data[] = "abcdefghijklmnopqrstuvwxyz";
+
+    // Cross-DB usage of BLOBs is only possible if the entire lifetime of the blob object
+    // is covered in an active transaction.
+    soci::transaction transaction(sql);
+    SECTION("Read-access on just-constructed blob")
+    {
+        soci::blob blob(sql);
+
+        CHECK(blob.get_len() == 0);
+
+        char buf[5];
+        std::size_t read_bytes = blob.read_from_start(buf, sizeof(buf));
+
+        // There should be no data that could be read
+        CHECK(read_bytes == 0);
+
+        // Reading from any offset other than zero is invalid
+        CHECK_THROWS_AS(blob.read_from_start(buf, sizeof(buf), 1), soci_error);
+    }
+    SECTION("validity & initialization")
+    {
+        soci::blob blob;
+        CHECK_FALSE(blob.is_valid());
+        blob.initialize(sql);
+        CHECK(blob.is_valid());
+
+        soci::blob other;
+        CHECK_FALSE(other.is_valid());
+        other = std::move(blob);
+        CHECK(other.is_valid());
+        CHECK_FALSE(blob.is_valid());
+    }
+    SECTION("BLOB I/O")
+    {
+        soci::blob blob(sql);
+
+        std::size_t written_bytes = blob.write_from_start(dummy_data, 5);
+
+        CHECK(written_bytes == 5);
+        CHECK(blob.get_len() == 5);
+
+        char buf[5];
+        static_assert(sizeof(buf) <= sizeof(dummy_data), "Underlying assumption violated");
+
+        std::size_t read_bytes = blob.read_from_start(buf, sizeof(buf));
+
+        CHECK(read_bytes == sizeof(buf));
+
+        for (std::size_t i = 0; i < sizeof(buf); ++i)
+        {
+            CHECK(buf[i] == dummy_data[i]);
+        }
+
+        written_bytes = blob.append(dummy_data + 5, 3);
+
+        CHECK(written_bytes == 3);
+        CHECK(blob.get_len() == 8);
+
+        read_bytes = blob.read_from_start(buf, sizeof(buf), 3);
+
+        CHECK(read_bytes == 5);
+
+        for (std::size_t i = 0; i < sizeof(buf); ++i)
+        {
+            CHECK(buf[i] == dummy_data[i + 3]);
+        }
+
+        blob.trim(2);
+
+        CHECK(blob.get_len() == 2);
+
+        read_bytes = blob.read_from_start(buf, sizeof(buf));
+
+        CHECK(read_bytes == 2);
+
+        for (std::size_t i = 0; i < read_bytes; ++i)
+        {
+            CHECK(buf[i] == dummy_data[i]);
+        }
+
+        // Reading from an offset >= the current length of the blob is invalid
+        CHECK_THROWS_AS(blob.read_from_start(buf, sizeof(buf), blob.get_len()), soci_error);
+
+        written_bytes = blob.append("z", 1);
+
+        CHECK(written_bytes == 1);
+        CHECK(blob.get_len() == 3);
+
+        read_bytes = blob.read_from_start(buf, 1, 2);
+
+        CHECK(read_bytes == 1);
+        CHECK(buf[0] == 'z');
+
+        // Writing more than one position beyond the blob is invalid
+        // (Writing exactly one position beyond is the same as appending)
+        CHECK_THROWS_AS(blob.write_from_start(dummy_data, 2, blob.get_len() + 1), soci_error);
+    }
+    SECTION("Inserting/Reading default-constructed blob")
+    {
+        {
+            soci::blob input_blob(sql);
+
+            sql << "insert into soci_test (id, b) values(5, :b)", soci::use(input_blob);
+        }
+
+        soci::blob output_blob(sql);
+        soci::indicator ind;
+
+        sql << "select b from soci_test where id = 5", soci::into(output_blob, ind);
+
+        CHECK(ind == soci::i_ok);
+        CHECK(output_blob.get_len() == 0);
+    }
+    SECTION("Ensure reading into blob overwrites previous contents")
+    {
+        soci::blob blob(sql);
+        blob.write_from_start("hello kitty", 10);
+
+        CHECK(blob.get_len() == 10);
+
+        {
+            soci::blob write_blob(sql);
+            write_blob.write_from_start("test", 4);
+            sql << "insert into soci_test (id, b) values (5, :b)", soci::use(write_blob);
+        }
+
+        sql << "select b from soci_test where id = 5", soci::into(blob);
+
+        CHECK(blob.get_len() == 4);
+        char buf[5];
+
+        std::size_t read_bytes = blob.read_from_start(buf, sizeof(buf));
+        CHECK(read_bytes == 4);
+
+        CHECK(buf[0] == 't');
+        CHECK(buf[1] == 'e');
+        CHECK(buf[2] == 's');
+        CHECK(buf[3] == 't');
+    }
+    SECTION("Blob-DB interaction")
+    {
+        soci::blob write_blob(sql);
+
+        static_assert(sizeof(dummy_data) >= 10, "Underlying assumption violated");
+        write_blob.write_from_start(dummy_data, 10);
+
+        const int first_id = 42;
+
+        // Write and retrieve blob from/into database
+        sql << "insert into soci_test (id, b) values(:id, :b)", soci::use(first_id), soci::use(write_blob);
+
+        // Append to write_blob - these changes must not reflect in the BLOB stored in the DB
+        write_blob.append("ay", 2);
+        CHECK(write_blob.get_len() == 12);
+        char buf[15];
+        std::size_t read_bytes = write_blob.read_from_start(buf, sizeof(buf));
+        CHECK(read_bytes == 12);
+        for (std::size_t i = 0; i < 10; ++i)
+        {
+            CHECK(buf[i] == dummy_data[i]);
+        }
+        CHECK(buf[10] == 'a');
+        CHECK(buf[11] == 'y');
+
+
+        soci::blob read_blob(sql);
+        sql << "select b from soci_test where id = :id", soci::use(first_id), soci::into(read_blob);
+        CHECK(sql.got_data());
+
+        CHECK(read_blob.get_len() == 10);
+
+        std::size_t bytes_read = read_blob.read_from_start(buf, sizeof(buf));
+        CHECK(bytes_read == read_blob.get_len());
+        CHECK(bytes_read == 10);
+        for (std::size_t i = 0; i < bytes_read; ++i)
+        {
+            CHECK(buf[i] == dummy_data[i]);
+        }
+
+        // Update original blob and insert new db-entry (must not change previous entry)
+        const int second_id = first_id + 1;
+        write_blob.trim(0);
+        static_assert(sizeof(dummy_data) >= 15 + 5, "Underlying assumption violated");
+        write_blob.write_from_start(dummy_data + 15, 5);
+
+        sql << "insert into soci_test (id, b) values (:id, :b)", soci::use(second_id), soci::use(write_blob);
+
+        // First, check that the original entry has not been changed
+        sql << "select b from soci_test where id = :id", soci::use(first_id), soci::into(read_blob);
+        CHECK(read_blob.get_len() == 10);
+
+        // Then check new entry can be read
+        sql << "select b from soci_test where id = :id", soci::use(second_id), soci::into(read_blob);
+
+        bytes_read = read_blob.read_from_start(buf, sizeof(buf));
+        CHECK(bytes_read == read_blob.get_len());
+        CHECK(bytes_read == 5);
+        for (std::size_t i = 0; i < bytes_read; ++i)
+        {
+            CHECK(buf[i] == dummy_data[i + 15]);
+        }
+    }
+    SECTION("Binary data")
+    {
+        const std::uint8_t binary_data[12] = {0, 1, 2, 3, 4, 5, 6, 7, 22, 255, 250 };
+
+        soci::blob write_blob(sql);
+
+        std::size_t bytes_written = write_blob.write_from_start(binary_data, sizeof(binary_data));
+        CHECK(bytes_written == sizeof(binary_data));
+
+        sql << "insert into soci_test (id, b) values (1, :b)", soci::use(write_blob);
+
+        soci::blob read_blob(sql);
+
+        sql << "select b from soci_test where id = 1", soci::into(read_blob);
+
+        CHECK(read_blob.get_len() == sizeof(binary_data));
+
+        std::uint8_t buf[20];
+        std::size_t bytes_read = read_blob.read_from_start(buf, sizeof(buf));
+
+        CHECK(bytes_read == sizeof(binary_data));
+        for (std::size_t i = 0; i < sizeof(binary_data); ++i)
+        {
+            CHECK(buf[i] == binary_data[i]);
+        }
+    }
+    SECTION("Rowset Blob recognition")
+    {
+        soci::blob blob(sql);
+
+        // Write and retrieve blob from/into database
+        int id = 1;
+        sql << "insert into soci_test (id, b) values(:id, :b)", soci::use(id), soci::use(blob);
+
+        soci::rowset< soci::row > rowSet = sql.prepare << "select id, b from soci_test";
+        bool containedData = false;
+        for (auto it = rowSet.begin(); it != rowSet.end(); ++it)
+        {
+            containedData = true;
+            const soci::row &currentRow = *it;
+
+            CHECK(currentRow.get_properties(1).get_data_type() == soci::dt_blob);
+        }
+        CHECK(containedData);
+    }
+    SECTION("Blob binding")
+    {
+        // Add data
+        soci::blob blob(sql);
+        static_assert(10 <= sizeof(dummy_data), "Underlying assumption violated");
+        blob.write_from_start(dummy_data, 10);
+        const int id = 42;
+        sql << "insert into soci_test (id, b) values(:id, :b)", soci::use(id), soci::use(blob);
+
+        SECTION("into")
+        {
+            soci::blob intoBlob(sql);
+
+            sql << "select b from soci_test where id=:id", soci::use(id), soci::into(intoBlob);
+
+            char buffer[20];
+            std::size_t written = intoBlob.read_from_start(buffer, sizeof(buffer));
+            CHECK(written == 10);
+            for (std::size_t i = 0; i < 10; ++i)
+            {
+                CHECK(buffer[i] == dummy_data[i]);
+            }
+        }
+        SECTION("move_as")
+        {
+            soci::rowset< soci::row > rowSet = (sql.prepare << "select b from soci_test where id=:id", soci::use(id));
+            bool containedData = false;
+            for (auto it = rowSet.begin(); it != rowSet.end(); ++it)
+            {
+                containedData = true;
+                const soci::row &currentRow = *it;
+
+                soci::blob intoBlob = currentRow.move_as<soci::blob>(0);
+
+                CHECK(intoBlob.get_len() == 10);
+                char buffer[20];
+                std::size_t written = intoBlob.read_from_start(buffer, sizeof(buffer));
+                CHECK(written == 10);
+                for (std::size_t i = 0; i < 10; ++i)
+                {
+                    CHECK(buffer[i] == dummy_data[i]);
+                }
+            }
+            CHECK(containedData);
+        }
+        SECTION("reusing bound blob")
+        {
+            int secondID = id + 1;
+            sql << "insert into soci_test(id, b) values(:id, :b)", soci::use(secondID), soci::use(blob);
+
+            // Selecting the blob associated with secondID should yield the same result as selecting the one for id
+            soci::blob intoBlob(sql);
+            sql << "select b from soci_test where id=:id", soci::use(secondID), soci::into(intoBlob);
+            char buffer[20];
+            std::size_t written = intoBlob.read_from_start(buffer, sizeof(buffer));
+            CHECK(written == 10);
+            for (std::size_t i = 0; i < 10; ++i)
+            {
+                CHECK(buffer[i] == dummy_data[i]);
+            }
+        }
+    }
+    SECTION("Statements")
+    {
+        unsigned int id;
+        soci::blob myBlob(sql);
+        soci::statement insert_stmt = (sql.prepare << "insert into soci_test (id, b) values (:id, :b)", soci::use(id), soci::use(myBlob));
+
+        id = 1;
+        myBlob.write_from_start(dummy_data + id, id);
+        insert_stmt.execute(true);
+
+        id = 5;
+        myBlob.write_from_start(dummy_data + id, id);
+        insert_stmt.execute(true);
+
+
+        soci::statement select_stmt = (sql.prepare << "select id, b from soci_test order by id asc", soci::into(id), soci::into(myBlob));
+        char contents[16];
+
+        select_stmt.execute();
+        CHECK(select_stmt.fetch());
+        CHECK(id == 1);
+        std::size_t blob_size = myBlob.get_len();
+        CHECK(blob_size == id);
+        std::size_t read = myBlob.read_from_start(contents, blob_size);
+        CHECK(read == blob_size);
+        for (unsigned int i = 0; i < blob_size; ++i)
+        {
+            CHECK(contents[i] == dummy_data[id + i]);
+        }
+
+        CHECK(select_stmt.fetch());
+        CHECK(id == 5);
+        blob_size = myBlob.get_len();
+        CHECK(blob_size == id);
+        read = myBlob.read_from_start(contents, blob_size);
+        CHECK(read == blob_size);
+        for (unsigned int i = 0; i < blob_size; ++i)
+        {
+            CHECK(contents[i] == dummy_data[id + i]);
+        }
+
+        CHECK(!select_stmt.fetch());
+    }
+}
+
 TEST_CASE_METHOD(common_tests, "Logger", "[core][log]")
 {
     // Logger class used for testing: appends all queries to the provided
diff --git a/tests/firebird/test-firebird.cpp b/tests/firebird/test-firebird.cpp
index 769ae0d8f..cfe688957 100644
--- a/tests/firebird/test-firebird.cpp
+++ b/tests/firebird/test-firebird.cpp
@@ -500,142 +500,6 @@ TEST_CASE("Firebird bulk operations", "[firebird][bulk]")
     sql << "drop table test6";
 }
 
-// blob test
-TEST_CASE("Firebird blobs", "[firebird][blob]")
-{
-    soci::session sql(backEnd, connectString);
-
-    try
-    {
-        sql << "drop table test7";
-    }
-    catch (std::runtime_error &)
-    {} // ignore if error
-
-    sql << "create table test7(id integer, img blob)";
-    sql.commit();
-
-    sql.begin();
-    {
-        // verify empty blob
-        blob b(sql);
-        indicator ind;
-
-        sql << "insert into test7(id, img) values(1,?)", use(b);
-        sql << "select img from test7 where id = 1", into(b, ind);
-
-        CHECK(ind == i_ok);
-        CHECK(b.get_len() == 0);
-
-        sql << "delete from test7";
-    }
-
-    {
-        // create a new blob
-        blob b(sql);
-
-        char str1[] = "Hello";
-        b.write_from_start(str1, strlen(str1));
-
-        char str2[20];
-        std::size_t i = b.read_from_start(str2, 2, 3);
-        str2[i] = '\0';
-        CHECK(str2[0] == 'l');
-        CHECK(str2[1] == 'o');
-        CHECK(str2[2] == '\0');
-
-        char str3[] = ", Firebird!";
-        b.append(str3, strlen(str3));
-
-        sql << "insert into test7(id, img) values(1,?)", use(b);
-    }
-
-    {
-        // read & update blob
-        blob b(sql);
-
-        sql << "select img from test7 where id = 1", into(b);
-
-        std::vector<char> text(b.get_len());
-        b.read_from_start(&text[0], b.get_len());
-        CHECK(strncmp(&text[0], "Hello, Firebird!", b.get_len()) == 0);
-
-        char str1[] = "FIREBIRD";
-        b.write_from_start(str1, strlen(str1), 7);
-
-        // after modification blob must be written to database
-        sql << "update test7 set img=? where id=1", use(b);
-    }
-
-    {
-        // read blob from database, modify and write to another record
-        blob b(sql);
-
-        sql << "select img from test7 where id = 1", into(b);
-
-        std::vector<char> text(b.get_len());
-        b.read_from_start(&text[0], b.get_len());
-
-        char str1[] = "HELLO";
-        b.write_from_start(str1, strlen(str1));
-
-        b.read_from_start(&text[0], b.get_len());
-        CHECK(strncmp(&text[0], "HELLO, FIREBIRD!", b.get_len()) == 0);
-
-        b.trim(5);
-        sql << "insert into test7(id, img) values(2,?)", use(b);
-    }
-
-    {
-        blob b(sql);
-        statement st = (sql.prepare << "select img from test7", into(b));
-
-        st.execute();
-
-        st.fetch();
-        std::vector<char> text(b.get_len());
-        b.read_from_start(&text[0], b.get_len());
-        CHECK(strncmp(&text[0], "Hello, FIREBIRD!", b.get_len()) == 0);
-
-        st.fetch();
-        text.resize(b.get_len());
-        b.read_from_start(&text[0], b.get_len());
-        CHECK(strncmp(&text[0], "HELLO", b.get_len()) == 0);
-    }
-
-    {
-        // delete blob
-        blob b(sql);
-        indicator ind=i_null;
-        sql << "update test7 set img=? where id = 1", use(b, ind);
-
-        sql << "select img from test7 where id = 2", into(b, ind);
-        CHECK(ind==i_ok);
-
-        sql << "select img from test7 where id = 1", into(b, ind);
-        CHECK(ind==i_null);
-    }
-
-    {
-        //create large blob
-        const int blobSize = 65536; //max segment size is 65535(unsigned short)
-        std::vector<char> data(blobSize);
-        blob b(sql);
-        b.write_from_start(data.data(), blobSize);
-        sql << "insert into test7(id, img) values(3,?)", use(b);
-
-        //now read blob back from database and make sure it has correct content and size
-        blob br(sql);
-        sql << "select img from test7 where id = 3", into(br);
-        std::vector<char> data2(br.get_len());
-        if(br.get_len()>0)
-            br.read_from_start(data2.data(), br.get_len());
-        CHECK(data == data2);
-    }
-
-    sql << "drop table test7";
-}
-
 // named parameters
 TEST_CASE("Firebird named parameters", "[firebird][named-params]")
 {
@@ -1297,6 +1161,17 @@ struct TableCreatorCLOB : public tests::table_creator_base
     }
 };
 
+struct TableCreatorBLOB : public tests::table_creator_base
+{
+    TableCreatorBLOB(soci::session & sql)
+            : tests::table_creator_base(sql)
+    {
+        sql << "create table soci_test(id integer, b blob)";
+        sql.commit();
+        sql.begin();
+    }
+};
+
 struct TableCreatorXML : public tests::table_creator_base
 {
     TableCreatorXML(soci::session & sql)
@@ -1341,6 +1216,12 @@ class test_context : public tests::test_context_base
             return new TableCreatorCLOB(s);
         }
 
+
+        tests::table_creator_base* table_creator_blob(soci::session& s) const override
+        {
+            return new TableCreatorBLOB(s);
+        }
+
         tests::table_creator_base* table_creator_xml(soci::session& s) const override
         {
             return new TableCreatorXML(s);
diff --git a/tests/mysql/test-mysql.cpp b/tests/mysql/test-mysql.cpp
index 7e933432e..7d548d217 100644
--- a/tests/mysql/test-mysql.cpp
+++ b/tests/mysql/test-mysql.cpp
@@ -371,124 +371,59 @@ TEST_CASE("MySQL datetime", "[mysql][datetime]")
     CHECK(t.tm_sec == 52);
 }
 
-// TEXT and BLOB types support test.
-TEST_CASE("MySQL text and blob", "[mysql][text][blob]")
+// TEXT type support test.
+TEST_CASE("MySQL text", "[mysql][text]")
 {
     soci::session sql(backEnd, connectString);
     std::string a("asdfg\0hjkl", 10);
-    std::string b("lkjhg\0fd\0\0sa\0", 13);
-    std::string c("\\0aa\\0bb\\0cc\\0", 10);
     // The maximum length for TEXT and BLOB is 65536.
     std::string x(60000, 'X');
-    std::string y(60000, 'Y');
-    // The default max_allowed_packet value for a MySQL server is 1M,
-    // so let's limit ourselves to 800k, even though the maximum length
-    // for LONGBLOB is 4G.
-    std::string z(800000, 'Z');
-
-    sql << "create table soci_test (id int, text_value text, "
-        "blob_value blob, longblob_value longblob)";
-    sql << "insert into soci_test values (1, \'foo\', \'bar\', \'baz\')";
+
+    sql << "create table soci_test (id int, text_value text)";
+    sql << "insert into soci_test values (1, \'foo\')";
     sql << "insert into soci_test "
-        << "values (2, \'qwerty\\0uiop\', \'zxcv\\0bnm\', "
-        << "\'qwerty\\0uiop\\0zxcvbnm\\0\')";
-    sql << "insert into soci_test values (3, :a, :b, :c)",
-           use(a), use(b), use(c);
-    sql << "insert into soci_test values (4, :x, :y, :z)",
-           use(x), use(y), use(z);
+        << "values (2, \'qwerty\\0uiop\')";
+    sql << "insert into soci_test values (3, :a)",
+           use(a);
+    sql << "insert into soci_test values (4, :x)",
+           use(x);
 
     std::vector<std::string> text_vec(100);
-    std::vector<std::string> blob_vec(100);
-    std::vector<std::string> longblob_vec(100);
-    sql << "select text_value, blob_value, longblob_value "
-        << "from soci_test order by id",
-           into(text_vec), into(blob_vec), into(longblob_vec);
+    sql << "select text_value from soci_test order by id", into(text_vec);
     REQUIRE(text_vec.size() == 4);
-    REQUIRE(blob_vec.size() == 4);
-    REQUIRE(longblob_vec.size() == 4);
     CHECK(text_vec[0] == "foo");
-    CHECK(blob_vec[0] == "bar");
-    CHECK(longblob_vec[0] == "baz");
     CHECK(text_vec[1] == std::string("qwerty\0uiop", 11));
-    CHECK(blob_vec[1] == std::string("zxcv\0bnm", 8));
-    CHECK(longblob_vec[1] == std::string("qwerty\0uiop\0zxcvbnm\0", 20));
     CHECK(text_vec[2] == a);
-    CHECK(blob_vec[2] == b);
-    CHECK(longblob_vec[2] == c);
     CHECK(text_vec[3] == x);
-    CHECK(blob_vec[3] == y);
-    CHECK(longblob_vec[3] == z);
 
-    std::string text, blob, longblob;
-    sql << "select text_value, blob_value, longblob_value "
-        << "from soci_test where id = 1",
-           into(text), into(blob), into(longblob);
+    std::string text;
+    sql << "select text_value from soci_test where id = 1", into(text);
     CHECK(text == "foo");
-    CHECK(blob == "bar");
-    CHECK(longblob == "baz");
-    sql << "select text_value, blob_value, longblob_value "
-        << "from soci_test where id = 2",
-           into(text), into(blob), into(longblob);
+    sql << "select text_value from soci_test where id = 2", into(text);
     CHECK(text == std::string("qwerty\0uiop", 11));
-    CHECK(blob == std::string("zxcv\0bnm", 8));
-    CHECK(longblob == std::string("qwerty\0uiop\0zxcvbnm\0", 20));
-    sql << "select text_value, blob_value, longblob_value "
-        << "from soci_test where id = 3",
-           into(text), into(blob), into(longblob);
+    sql << "select text_value from soci_test where id = 3", into(text);
     CHECK(text == a);
-    CHECK(blob == b);
-    CHECK(longblob == c);
-    sql << "select text_value, blob_value, longblob_value "
-        << "from soci_test where id = 4",
-           into(text), into(blob), into(longblob);
+    sql << "select text_value from soci_test where id = 4", into(text);
     CHECK(text == x);
-    CHECK(blob == y);
-    CHECK(longblob == z);
 
     rowset<row> rs =
-        (sql.prepare << "select text_value, blob_value, longblob_value "
-                        "from soci_test order by id");
+        (sql.prepare << "select text_value from soci_test order by id");
     rowset<row>::const_iterator r = rs.begin();
     CHECK(r->get_properties(0).get_data_type() == dt_string);
     CHECK(r->get_properties(0).get_db_type() == db_string);
     CHECK(r->get<std::string>(0) == "foo");
-    CHECK(r->get_properties(1).get_data_type() == dt_string);
-    CHECK(r->get_properties(1).get_db_type() == db_string);
-    CHECK(r->get<std::string>(1) == "bar");
-    CHECK(r->get_properties(2).get_data_type() == dt_string);
-    CHECK(r->get_properties(2).get_db_type() == db_string);
-    CHECK(r->get<std::string>(2) == "baz");
     ++r;
     CHECK(r->get_properties(0).get_data_type() == dt_string);
     CHECK(r->get_properties(0).get_db_type() == db_string);
     CHECK(r->get<std::string>(0) == std::string("qwerty\0uiop", 11));
-    CHECK(r->get_properties(1).get_data_type() == dt_string);
-    CHECK(r->get_properties(1).get_db_type() == db_string);
-    CHECK(r->get<std::string>(1) == std::string("zxcv\0bnm", 8));
-    CHECK(r->get_properties(2).get_data_type() == dt_string);
-    CHECK(r->get_properties(2).get_db_type() == db_string);
-    CHECK(r->get<std::string>(2) ==
-           std::string("qwerty\0uiop\0zxcvbnm\0", 20));
     ++r;
     CHECK(r->get_properties(0).get_data_type() == dt_string);
     CHECK(r->get_properties(0).get_db_type() == db_string);
     CHECK(r->get<std::string>(0) == a);
-    CHECK(r->get_properties(1).get_data_type() == dt_string);
-    CHECK(r->get_properties(1).get_db_type() == db_string);
-    CHECK(r->get<std::string>(1) == b);
-    CHECK(r->get_properties(2).get_data_type() == dt_string);
-    CHECK(r->get_properties(2).get_db_type() == db_string);
-    CHECK(r->get<std::string>(2) == c);
     ++r;
     CHECK(r->get_properties(0).get_data_type() == dt_string);
     CHECK(r->get_properties(0).get_db_type() == db_string);
     CHECK(r->get<std::string>(0) == x);
-    CHECK(r->get_properties(1).get_data_type() == dt_string);
-    CHECK(r->get_properties(1).get_db_type() == db_string);
-    CHECK(r->get<std::string>(1) == y);
-    CHECK(r->get_properties(2).get_data_type() == dt_string);
-    CHECK(r->get_properties(2).get_db_type() == db_string);
-    CHECK(r->get<std::string>(2) == z);
     ++r;
     CHECK(r == rs.end());
 
@@ -760,8 +695,7 @@ struct strings_table_creator : table_creator_base
     {
         sql << "create table soci_test(s1 char(20), s2 varchar(20), "
             "s3 tinytext, s4 mediumtext, s5 text, s6 longtext, "
-            "b1 binary(20), b2 varbinary(20), b3 tinyblob, b4 mediumblob, "
-            "b5 blob, b6 longblob, e1 enum ('foo', 'bar', 'baz'))";
+            "b1 binary(20), b2 varbinary(20), e1 enum ('foo', 'bar', 'baz'))";
     }
 };
 
@@ -772,22 +706,20 @@ TEST_CASE("MySQL strings", "[mysql][string]")
     std::string text = "Ala ma kota.";
     std::string binary("Ala\0ma\0kota.........", 20);
     sql << "insert into soci_test "
-        "(s1, s2, s3, s4, s5, s6, b1, b2, b3, b4, b5, b6, e1) values "
-        "(:s1, :s2, :s3, :s4, :d5, :s6, :b1, :b2, :b3, :b4, :b5, :b6, "
-        "\'foo\')",
+        "(s1, s2, s3, s4, s5, s6, b1, b2, e1) values "
+        "(:s1, :s2, :s3, :s4, :d5, :s6, :b1, :b2, 'foo')",
         use(text), use(text), use(text), use(text), use(text), use(text),
-        use(binary), use(binary), use(binary), use(binary), use(binary),
-        use(binary);
+        use(binary), use(binary);
     row r;
-    sql << "select s1, s2, s3, s4, s5, s6, b1, b2, b3, b4, b5, b6, e1 "
+    sql << "select s1, s2, s3, s4, s5, s6, b1, b2, e1 "
         "from soci_test", into(r);
-    REQUIRE(r.size() == 13);
-    for (int i = 0; i < 13; i++) {
+    REQUIRE(r.size() == 9);
+    for (int i = 0; i < static_cast<int>(r.size()); i++) {
         CHECK(r.get_properties(i).get_data_type() == dt_string);
         CHECK(r.get_properties(i).get_db_type() == db_string);
         if (i < 6) {
             CHECK(r.get<std::string>(i) == text);
-        } else if (i < 12) {
+        } else if (i < 8) {
             CHECK(r.get<std::string>(i) == binary);
         } else {
             CHECK(r.get<std::string>(i) == "foo");
diff --git a/tests/mysql/test-mysql.h b/tests/mysql/test-mysql.h
index 8d120c3f8..dde8c8718 100644
--- a/tests/mysql/test-mysql.h
+++ b/tests/mysql/test-mysql.h
@@ -49,6 +49,16 @@ struct table_creator_for_get_affected_rows : table_creator_base
     }
 };
 
+struct table_creator_for_blob : public tests::table_creator_base
+{
+    table_creator_for_blob(soci::session & sql)
+        : tests::table_creator_base(sql)
+    {
+        sql << "create table soci_test(id integer, b blob)";
+    }
+};
+
+
 //
 // Support for SOCI Common Tests
 //
@@ -85,6 +95,11 @@ class test_context : public test_context_base
         return "\'" + datdt_string + "\'";
     }
 
+    table_creator_base * table_creator_blob(soci::session &s) const override
+    {
+        return new table_creator_for_blob(s);
+    }
+
     bool has_fp_bug() const override
     {
         // MySQL fails in the common test3() with "1.8000000000000000 !=
diff --git a/tests/odbc/test-odbc-mysql.cpp b/tests/odbc/test-odbc-mysql.cpp
index 5b14e7ea4..fa8eb7499 100644
--- a/tests/odbc/test-odbc-mysql.cpp
+++ b/tests/odbc/test-odbc-mysql.cpp
@@ -7,12 +7,13 @@
 
 #include "soci/soci.h"
 #include "soci/odbc/soci-odbc.h"
-#include "mysql/test-mysql.h"
 #include <iostream>
 #include <string>
 #include <ctime>
 #include <cmath>
 
+#include "mysql/test-mysql.h"
+
 std::string connectString;
 backend_factory const &backEnd = *soci::factory_odbc();
 
@@ -31,6 +32,12 @@ class test_context_odbc : public test_context
         // but we use an older version in the AppVeyor builds.
         return true;
     }
+
+    table_creator_base* table_creator_blob(soci::session&) const override
+    {
+      // Blobs are not supported
+      return nullptr;
+    }
 };
 
 int main(int argc, char** argv)
diff --git a/tests/oracle/test-oracle.cpp b/tests/oracle/test-oracle.cpp
index 88c20251b..d3531fd13 100644
--- a/tests/oracle/test-oracle.cpp
+++ b/tests/oracle/test-oracle.cpp
@@ -102,66 +102,7 @@ TEST_CASE("Oracle explicit calls", "[oracle]")
     CHECK(i == 7);
 }
 
-// DDL + blob test
-
-struct blob_table_creator : public table_creator_base
-{
-    blob_table_creator(soci::session & sql)
-    : table_creator_base(sql)
-    {
-        sql <<
-            "create table soci_test ("
-            "    id number(10) not null,"
-            "    img blob"
-            ")";
-    }
-};
-
-TEST_CASE("Oracle blob", "[oracle][blob]")
-{
-    soci::session sql(backEnd, connectString);
-
-    blob_table_creator tableCreator(sql);
-
-    char buf[] = "abcdefghijklmnopqrstuvwxyz";
-    sql << "insert into soci_test (id, img) values (7, empty_blob())";
-
-    {
-        blob b(sql);
-
-        oracle_session_backend *sessionBackEnd
-            = static_cast<oracle_session_backend *>(sql.get_backend());
-
-        oracle_blob_backend *blobBackEnd
-            = static_cast<oracle_blob_backend *>(b.get_backend());
-
-        OCILobDisableBuffering(sessionBackEnd->svchp_,
-            sessionBackEnd->errhp_, blobBackEnd->lobp_);
-
-        sql << "select img from soci_test where id = 7", into(b);
-        CHECK(b.get_len() == 0);
-
-        b.write_from_start(buf, sizeof(buf));
-        CHECK(b.get_len() == sizeof(buf));
-        b.trim(10);
-        CHECK(b.get_len() == 10);
-
-        // append does not work (Oracle bug #886191 ?)
-        //b.append(buf, sizeof(buf));
-        //assert(b.get_len() == sizeof(buf) + 10);
-        sql.commit();
-    }
-
-    {
-        blob b(sql);
-        sql << "select img from soci_test where id = 7", into(b);
-        //assert(b.get_len() == sizeof(buf) + 10);
-        CHECK(b.get_len() == 10);
-        char buf2[100];
-        b.read_from_start(buf2, 10);
-        CHECK(strncmp(buf2, "abcdefghij", 10) == 0);
-    }
-}
+// DDL test
 
 // nested statement test
 // (the same syntax is used for output cursors in PL/SQL)
@@ -1451,6 +1392,14 @@ struct table_creator_for_clob : table_creator_base
     }
 };
 
+struct table_creator_for_blob : public tests::table_creator_base
+{
+    table_creator_for_blob(soci::session &sql) : tests::table_creator_base(sql)
+    {
+        sql << "create table soci_test(id integer, b blob)";
+    }
+};
+
 class test_context :public test_context_base
 {
 public:
@@ -1483,6 +1432,11 @@ class test_context :public test_context_base
         return new table_creator_for_clob(s);
     }
 
+    table_creator_base* table_creator_blob(soci::session& s) const override
+    {
+      return new table_creator_for_blob(s);
+    }
+
     table_creator_base* table_creator_xml(soci::session& s) const override
     {
         return new table_creator_for_xml(s);
diff --git a/tests/postgresql/test-postgresql.cpp b/tests/postgresql/test-postgresql.cpp
index a69459c49..651685866 100644
--- a/tests/postgresql/test-postgresql.cpp
+++ b/tests/postgresql/test-postgresql.cpp
@@ -228,59 +228,6 @@ TEST_CASE("PostgreSQL function call", "[postgresql][function]")
     }
 }
 
-// BLOB test
-struct blob_table_creator : public table_creator_base
-{
-    blob_table_creator(soci::session & sql)
-    : table_creator_base(sql)
-    {
-        sql <<
-             "create table soci_test ("
-             "    id integer,"
-             "    img oid"
-             ")";
-    }
-};
-
-TEST_CASE("PostgreSQL blob", "[postgresql][blob]")
-{
-    soci::session sql(backEnd, connectString);
-
-    blob_table_creator tableCreator(sql);
-
-    char buf[] = "abcdefghijklmnopqrstuvwxyz";
-
-    sql << "insert into soci_test(id, img) values(7, lo_creat(-1))";
-
-    // in PostgreSQL, BLOB operations must be within transaction block
-    transaction tr(sql);
-
-    {
-        blob b(sql);
-
-        sql << "select img from soci_test where id = 7", into(b);
-        CHECK(b.get_len() == 0);
-
-        b.write_from_start(buf, sizeof(buf));
-        CHECK(b.get_len() == sizeof(buf));
-
-        b.append(buf, sizeof(buf));
-        CHECK(b.get_len() == 2 * sizeof(buf));
-    }
-    {
-        blob b(sql);
-        sql << "select img from soci_test where id = 7", into(b);
-        CHECK(b.get_len() == 2 * sizeof(buf));
-        char buf2[100];
-        b.read_from_start(buf2, 10);
-        CHECK(std::strncmp(buf2, "abcdefghij", 10) == 0);
-    }
-
-    unsigned long oid;
-    sql << "select img from soci_test where id = 7", into(oid);
-    sql << "select lo_unlink(" << oid << ")";
-}
-
 struct longlong_table_creator : table_creator_base
 {
     longlong_table_creator(soci::session & sql)
@@ -1381,7 +1328,16 @@ struct table_creator_for_clob : table_creator_base
     }
 };
 
-// Common tests context
+struct table_creator_for_blob : public tests::table_creator_base
+{
+    table_creator_for_blob(soci::session & sql)
+		: tests::table_creator_base(sql)
+    {
+        sql << "create table soci_test(id integer, b oid)";
+    }
+};
+
+
 class test_context : public test_context_base
 {
 public:
@@ -1419,6 +1375,11 @@ class test_context : public test_context_base
         return new table_creator_for_clob(s);
     }
 
+    table_creator_base* table_creator_blob(soci::session& s) const override
+    {
+        return new table_creator_for_blob(s);
+    }
+
     bool has_real_xml_support() const override
     {
         return true;
diff --git a/tests/sqlite3/test-sqlite3.cpp b/tests/sqlite3/test-sqlite3.cpp
index 90b83edcf..0aa91f76d 100644
--- a/tests/sqlite3/test-sqlite3.cpp
+++ b/tests/sqlite3/test-sqlite3.cpp
@@ -256,58 +256,6 @@ TEST_CASE("SQLite get_last_insert_id escapes table name",
     CHECK(val == 0);
 }
 
-// BLOB test
-struct blob_table_creator : public table_creator_base
-{
-    blob_table_creator(soci::session & sql)
-        : table_creator_base(sql)
-    {
-        sql <<
-            "create table soci_test ("
-            "    id integer,"
-            "    img blob"
-            ")";
-    }
-};
-
-TEST_CASE("SQLite blob", "[sqlite][blob]")
-{
-    soci::session sql(backEnd, connectString);
-
-    blob_table_creator tableCreator(sql);
-
-    char buf[] = "abcdefghijklmnopqrstuvwxyz";
-
-    sql << "insert into soci_test(id, img) values(7, '')";
-
-    {
-        blob b(sql);
-
-        sql << "select img from soci_test where id = 7", into(b);
-        CHECK(b.get_len() == 0);
-
-        b.write_from_start(buf, sizeof(buf));
-        CHECK(b.get_len() == sizeof(buf));
-        sql << "update soci_test set img=? where id = 7", use(b);
-
-        b.append(buf, sizeof(buf));
-        CHECK(b.get_len() == 2 * sizeof(buf));
-        sql << "insert into soci_test(id, img) values(8, ?)", use(b);
-    }
-    {
-        blob b(sql);
-        sql << "select img from soci_test where id = 8", into(b);
-        CHECK(b.get_len() == 2 * sizeof(buf));
-        char buf2[100];
-        b.read_from_start(buf2, 10);
-        CHECK(std::strncmp(buf2, "abcdefghij", 10) == 0);
-
-        sql << "select img from soci_test where id = 7", into(b);
-        CHECK(b.get_len() == sizeof(buf));
-
-    }
-}
-
 // This test was put in to fix a problem that occurs when there are both
 // into and use elements in the same query and one of them (into) binds
 // to a vector object.
@@ -830,6 +778,15 @@ struct table_creator_from_str : table_creator_base
     }
 };
 
+struct table_creator_for_blob : public tests::table_creator_base
+{
+    table_creator_for_blob(soci::session & sql)
+		: tests::table_creator_base(sql)
+    {
+        sql << "create table soci_test(id integer, b blob)";
+    }
+};
+
 class test_context : public test_context_base
 {
 public:
@@ -863,6 +820,11 @@ class test_context : public test_context_base
             "create table soci_test (id integer primary key, val integer)");
     }
 
+    table_creator_base* table_creator_blob(soci::session& s) const override
+    {
+      return new table_creator_for_blob(s);
+    }
+
     table_creator_base* table_creator_xml(soci::session& s) const override
     {
         return new table_creator_from_str(s,