aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--odb/oracle/binding.hxx22
-rw-r--r--odb/oracle/container-statements.hxx2
-rw-r--r--odb/oracle/error.cxx21
-rw-r--r--odb/oracle/error.hxx12
-rw-r--r--odb/oracle/exceptions.cxx24
-rw-r--r--odb/oracle/exceptions.hxx12
-rw-r--r--odb/oracle/no-id-object-statements.hxx2
-rw-r--r--odb/oracle/oracle-types.hxx3
-rw-r--r--odb/oracle/polymorphic-object-statements.hxx8
-rw-r--r--odb/oracle/section-statements.hxx3
-rw-r--r--odb/oracle/section-statements.txx2
-rw-r--r--odb/oracle/simple-object-statements.hxx69
-rw-r--r--odb/oracle/simple-object-statements.txx25
-rw-r--r--odb/oracle/statement.cxx697
-rw-r--r--odb/oracle/statement.hxx238
-rw-r--r--odb/oracle/statement.ixx63
16 files changed, 933 insertions, 270 deletions
diff --git a/odb/oracle/binding.hxx b/odb/oracle/binding.hxx
index 94e7128..e2d3fa5 100644
--- a/odb/oracle/binding.hxx
+++ b/odb/oracle/binding.hxx
@@ -11,6 +11,7 @@
#include <odb/oracle/version.hxx>
#include <odb/oracle/oracle-types.hxx>
+#include <odb/oracle/auto-handle.hxx>
#include <odb/oracle/details/export.hxx>
@@ -24,10 +25,23 @@ namespace odb
typedef oracle::bind bind_type;
typedef oracle::change_callback change_callback_type;
- binding (): bind (0), count (0), version (0), change_callback (0) {}
+ binding ()
+ : bind (0), count (0), version (0),
+ batch (0), skip (0), status (0),
+ change_callback (0) {}
binding (bind_type* b, std::size_t n)
- : bind (b), count (n), version (0), change_callback (0)
+ : bind (b), count (n), version (0),
+ batch (1), skip (0), status (0),
+ change_callback (0)
+ {
+ }
+
+ binding (bind_type* b, std::size_t n,
+ std::size_t bt, std::size_t s, sb4* st)
+ : bind (b), count (n), version (0),
+ batch (bt), skip (s), status (st),
+ change_callback (0)
{
}
@@ -35,6 +49,10 @@ namespace odb
std::size_t count;
std::size_t version;
+ std::size_t batch;
+ std::size_t skip;
+ sb4* status; // Batch status array.
+
change_callback_type* change_callback;
private:
diff --git a/odb/oracle/container-statements.hxx b/odb/oracle/container-statements.hxx
index ef1733d..a0a1742 100644
--- a/odb/oracle/container-statements.hxx
+++ b/odb/oracle/container-statements.hxx
@@ -122,7 +122,7 @@ namespace odb
insert_text_,
versioned_, // Process if versioned.
insert_image_binding_,
- false));
+ 0));
return *insert_;
}
diff --git a/odb/oracle/error.cxx b/odb/oracle/error.cxx
index afab2c7..68bdc44 100644
--- a/odb/oracle/error.cxx
+++ b/odb/oracle/error.cxx
@@ -19,7 +19,8 @@ namespace odb
namespace oracle
{
static void
- translate_error (void* h, ub4 htype, sword r, connection* conn)
+ translate_error (void* h, ub4 htype, sword r, connection* conn,
+ size_t pos, multiple_exceptions* mex)
{
assert (r != OCI_SUCCESS && r != OCI_SUCCESS_WITH_INFO);
@@ -186,25 +187,33 @@ namespace odb
dbe.append (e, b);
}
- throw dbe;
+ if (mex == 0)
+ throw dbe;
+ else
+ // It could be that some of these errors are fatal. I guess we
+ // will just have to learn from experience which ones are. The
+ // client code can always treat specific error codes as fatal.
+ //
+ mex->insert (pos, dbe);
}
void
- translate_error (OCIError* h, sword r)
+ translate_error (OCIError* h, sword r, connection* c,
+ size_t pos, multiple_exceptions* mex)
{
- translate_error (h, OCI_HTYPE_ERROR, r, 0);
+ translate_error (h, OCI_HTYPE_ERROR, r, c, pos, mex);
}
void
translate_error (connection& c, sword r)
{
- translate_error (c.error_handle (), OCI_HTYPE_ERROR, r, &c);
+ translate_error (c.error_handle (), OCI_HTYPE_ERROR, r, &c, 0, 0);
}
void
translate_error (OCIEnv* h)
{
- translate_error (h, OCI_HTYPE_ENV, OCI_ERROR, 0);
+ translate_error (h, OCI_HTYPE_ENV, OCI_ERROR, 0, 0, 0);
}
}
}
diff --git a/odb/oracle/error.hxx b/odb/oracle/error.hxx
index fdb0537..accfc3f 100644
--- a/odb/oracle/error.hxx
+++ b/odb/oracle/error.hxx
@@ -7,20 +7,24 @@
#include <odb/pre.hxx>
+#include <cstddef> // std::size_t
+
#include <odb/oracle/oracle-fwd.hxx>
-#include <odb/oracle/forward.hxx>
+#include <odb/oracle/forward.hxx> // connection, multiple_exceptions
#include <odb/oracle/version.hxx>
+
#include <odb/oracle/details/export.hxx>
namespace odb
{
namespace oracle
{
- // Translate OCI error given an error handle and throw an appropriate
- // exception.
+ // Translate OCI error given an error handle and throw (or return,
+ // in case multiple_exceptions is not NULL) an appropriate exception.
//
LIBODB_ORACLE_EXPORT void
- translate_error (OCIError*, sword result);
+ translate_error (OCIError*, sword result, connection* = 0,
+ std::size_t pos = 0, multiple_exceptions* = 0);
LIBODB_ORACLE_EXPORT void
translate_error (connection&, sword result);
diff --git a/odb/oracle/exceptions.cxx b/odb/oracle/exceptions.cxx
index b6375e7..4676843 100644
--- a/odb/oracle/exceptions.cxx
+++ b/odb/oracle/exceptions.cxx
@@ -57,6 +57,12 @@ namespace odb
return what_.c_str ();
}
+ database_exception* database_exception::
+ clone () const
+ {
+ return new database_exception (*this);
+ }
+
//
// lob_comparison
//
@@ -67,6 +73,12 @@ namespace odb
return "comparison of LOB values in queries not supported";
}
+ lob_comparison* lob_comparison::
+ clone () const
+ {
+ return new lob_comparison (*this);
+ }
+
//
// cli_exception
//
@@ -88,6 +100,12 @@ namespace odb
return what_.c_str ();
}
+ cli_exception* cli_exception::
+ clone () const
+ {
+ return new cli_exception (*this);
+ }
+
//
// invalid_oci_handle
//
@@ -97,5 +115,11 @@ namespace odb
{
return "invalid oci handle passed or unable to allocate handle";
}
+
+ invalid_oci_handle* invalid_oci_handle::
+ clone () const
+ {
+ return new invalid_oci_handle (*this);
+ }
}
}
diff --git a/odb/oracle/exceptions.hxx b/odb/oracle/exceptions.hxx
index d8ca14a..87327b9 100644
--- a/odb/oracle/exceptions.hxx
+++ b/odb/oracle/exceptions.hxx
@@ -76,6 +76,9 @@ namespace odb
virtual const char*
what () const throw ();
+ virtual database_exception*
+ clone () const;
+
void
append (sb4 error, const std::string& message);
@@ -88,6 +91,9 @@ namespace odb
{
virtual const char*
what () const throw ();
+
+ virtual lob_comparison*
+ clone () const;
};
struct LIBODB_ORACLE_EXPORT cli_exception: odb::exception
@@ -98,6 +104,9 @@ namespace odb
virtual const char*
what () const throw ();
+ virtual cli_exception*
+ clone () const;
+
private:
std::string what_;
};
@@ -106,6 +115,9 @@ namespace odb
{
virtual const char*
what () const throw ();
+
+ virtual invalid_oci_handle*
+ clone () const;
};
namespace core
diff --git a/odb/oracle/no-id-object-statements.hxx b/odb/oracle/no-id-object-statements.hxx
index 0be8dac..fe4d8d0 100644
--- a/odb/oracle/no-id-object-statements.hxx
+++ b/odb/oracle/no-id-object-statements.hxx
@@ -88,7 +88,7 @@ namespace odb
object_traits::persist_statement,
object_traits::versioned, // Process if versioned.
insert_image_binding_,
- false));
+ 0));
return *persist_;
}
diff --git a/odb/oracle/oracle-types.hxx b/odb/oracle/oracle-types.hxx
index ec53425..ffc974a 100644
--- a/odb/oracle/oracle-types.hxx
+++ b/odb/oracle/oracle-types.hxx
@@ -115,7 +115,8 @@ namespace odb
// bindings, this is interpreted as the OCIDefine
// handle associated with the LOB result parameter.
ub4 capacity; // The maximum number of bytes that can be stored in
- // the buffer.
+ // the buffer. For LOBs, it used to store array skip
+ // size.
sb2* indicator; // Pointer to an OCI indicator variable.
lob_callback* callback;
diff --git a/odb/oracle/polymorphic-object-statements.hxx b/odb/oracle/polymorphic-object-statements.hxx
index 81ea3c3..58ecdaa 100644
--- a/odb/oracle/polymorphic-object-statements.hxx
+++ b/odb/oracle/polymorphic-object-statements.hxx
@@ -306,7 +306,7 @@ namespace odb
object_traits::persist_statement,
object_traits::versioned, // Process if versioned.
insert_image_binding_,
- false));
+ 0));
return *persist_;
}
@@ -366,6 +366,7 @@ namespace odb
return extra_statement_cache_.get (
conn_,
image_,
+ id_image (),
id_image_binding (),
&id_image_binding ()); // Note, not id+version.
}
@@ -404,8 +405,9 @@ namespace odb
root_statements_type& root_statements_;
base_statements_type& base_statements_;
- extra_statement_cache_ptr<extra_statement_cache_type, image_type>
- extra_statement_cache_;
+ extra_statement_cache_ptr<extra_statement_cache_type,
+ image_type,
+ id_image_type> extra_statement_cache_;
image_type image_;
diff --git a/odb/oracle/section-statements.hxx b/odb/oracle/section-statements.hxx
index 3d32b65..eb61cc1 100644
--- a/odb/oracle/section-statements.hxx
+++ b/odb/oracle/section-statements.hxx
@@ -36,6 +36,7 @@ namespace odb
typedef ST traits;
typedef typename traits::image_type image_type;
+ typedef typename traits::id_image_type id_image_type;
typedef oracle::select_statement select_statement_type;
typedef oracle::update_statement update_statement_type;
@@ -43,7 +44,7 @@ namespace odb
typedef oracle::connection connection_type;
section_statements (connection_type&,
- image_type&,
+ image_type&, id_image_type&,
binding& id, binding& idv);
connection_type&
diff --git a/odb/oracle/section-statements.txx b/odb/oracle/section-statements.txx
index 391550f..583b706 100644
--- a/odb/oracle/section-statements.txx
+++ b/odb/oracle/section-statements.txx
@@ -11,7 +11,7 @@ namespace odb
template <typename T, typename ST>
section_statements<T, ST>::
section_statements (connection_type& conn,
- image_type& im,
+ image_type& im, id_image_type&,
binding& id, binding& idv)
: conn_ (conn),
svm_ (0),
diff --git a/odb/oracle/simple-object-statements.hxx b/odb/oracle/simple-object-statements.hxx
index ff76e91..0ee263a 100644
--- a/odb/oracle/simple-object-statements.hxx
+++ b/odb/oracle/simple-object-statements.hxx
@@ -39,49 +39,56 @@ namespace odb
// deleter function which will be initialized during allocation
// (at that point we know that the cache class is defined).
//
- template <typename T, typename I>
+ template <typename T, typename I, typename ID>
struct extra_statement_cache_ptr
{
typedef I image_type;
+ typedef ID id_image_type;
typedef oracle::connection connection_type;
extra_statement_cache_ptr (): p_ (0) {}
~extra_statement_cache_ptr ()
{
if (p_ != 0)
- (this->*deleter_) (0, 0, 0, 0);
+ (this->*deleter_) (0, 0, 0, 0, 0);
}
T&
- get (connection_type& c, image_type& im, binding& id, binding* idv)
+ get (connection_type& c,
+ image_type& im, id_image_type& idim,
+ binding& id, binding* idv)
{
if (p_ == 0)
- allocate (&c, &im, &id, (idv != 0 ? idv : &id));
+ allocate (&c, &im, &idim, &id, (idv != 0 ? idv : &id));
return *p_;
}
private:
void
- allocate (connection_type*, image_type*, binding*, binding*);
+ allocate (connection_type*,
+ image_type*, id_image_type*,
+ binding*, binding*);
private:
T* p_;
void (extra_statement_cache_ptr::*deleter_) (
- connection_type*, image_type*, binding*, binding*);
+ connection_type*, image_type*, id_image_type*, binding*, binding*);
};
- template <typename T, typename I>
- void extra_statement_cache_ptr<T, I>::
- allocate (connection_type* c, image_type* im, binding* id, binding* idv)
+ template <typename T, typename I, typename ID>
+ void extra_statement_cache_ptr<T, I, ID>::
+ allocate (connection_type* c,
+ image_type* im, id_image_type* idim,
+ binding* id, binding* idv)
{
// To reduce object code size, this function acts as both allocator
// and deleter.
//
if (p_ == 0)
{
- p_ = new T (*c, *im, *id, *idv);
- deleter_ = &extra_statement_cache_ptr<T, I>::allocate;
+ p_ = new T (*c, *im, *idim, *id, *idv);
+ deleter_ = &extra_statement_cache_ptr<T, I, ID>::allocate;
}
else
delete p_;
@@ -276,10 +283,7 @@ namespace odb
// Object image.
//
image_type&
- image ()
- {
- return image_;
- }
+ image (std::size_t i = 0) {return images_[i].obj;}
// Insert binding.
//
@@ -323,7 +327,7 @@ namespace odb
// Object id image and binding.
//
id_image_type&
- id_image () {return id_image_;}
+ id_image (std::size_t i = 0) {return images_[i].id;}
std::size_t
id_image_version () const {return id_image_version_;}
@@ -353,7 +357,7 @@ namespace odb
object_traits::persist_statement,
object_traits::versioned, // Process if versioned.
insert_image_binding_,
- object_traits::auto_id));
+ object_traits::auto_id ? &id_image_binding_ : 0));
return *persist_;
}
@@ -383,7 +387,8 @@ namespace odb
new (details::shared) update_statement_type (
conn_,
object_traits::update_statement,
- object_traits::versioned, // Process if versioned.
+ true, // Unique (0 or 1).
+ object_traits::versioned, // Process if versioned.
update_image_binding_));
return *update_;
@@ -397,6 +402,7 @@ namespace odb
new (details::shared) delete_statement_type (
conn_,
object_traits::erase_statement,
+ true, // Unique (0 or 1 affected rows).
id_image_binding_));
return *erase_;
@@ -423,7 +429,9 @@ namespace odb
extra_statement_cache ()
{
return extra_statement_cache_.get (
- conn_, image_, id_image_binding_, od_.id_image_binding ());
+ conn_,
+ images_[0].obj, images_[0].id,
+ id_image_binding_, od_.id_image_binding ());
}
public:
@@ -470,10 +478,22 @@ namespace odb
template <typename T1>
friend class polymorphic_derived_object_statements;
- extra_statement_cache_ptr<extra_statement_cache_type, image_type>
- extra_statement_cache_;
+ extra_statement_cache_ptr<extra_statement_cache_type,
+ image_type,
+ id_image_type> extra_statement_cache_;
+
+ // The UPDATE statement uses both the object and id image. Keep
+ // them next to each other so that the same skip distance can
+ // be used in batch binding.
+ //
+ struct images
+ {
+ image_type obj;
+ id_image_type id;
+ };
- image_type image_;
+ images images_[object_traits::batch];
+ sb4 status_[object_traits::batch];
// Select binding.
//
@@ -502,10 +522,9 @@ namespace odb
bind update_image_bind_[update_column_count + id_column_count +
managed_optimistic_column_count];
- // Id image binding (only used as a parameter). Uses the suffix in
- // the update bind.
+ // Id image binding (only used as a parameter or in RETURNING for
+ // auto ids). Uses the suffix in the update bind.
//
- id_image_type id_image_;
std::size_t id_image_version_;
binding id_image_binding_;
diff --git a/odb/oracle/simple-object-statements.txx b/odb/oracle/simple-object-statements.txx
index 61bbc5f..0e42d31 100644
--- a/odb/oracle/simple-object-statements.txx
+++ b/odb/oracle/simple-object-statements.txx
@@ -43,24 +43,35 @@ namespace odb
object_statements (connection_type& conn)
: object_statements_base (conn),
select_image_binding_ (select_image_bind_, select_column_count),
- insert_image_binding_ (insert_image_bind_, insert_column_count),
+ insert_image_binding_ (insert_image_bind_,
+ insert_column_count,
+ object_traits::batch,
+ sizeof (images),
+ status_),
update_image_binding_ (update_image_bind_,
update_column_count + id_column_count +
- managed_optimistic_column_count),
+ managed_optimistic_column_count,
+ object_traits::batch,
+ sizeof (images),
+ status_),
id_image_binding_ (update_image_bind_ + update_column_count,
- id_column_count),
+ id_column_count,
+ object_traits::batch,
+ sizeof (images),
+ status_),
od_ (update_image_bind_ + update_column_count)
{
- image_.version = 0;
+ images_[0].obj.version = 0; // @@ TODO [0]
+ images_[0].id.version = 0; // @@ TODO
+
select_image_version_ = 0;
insert_image_version_ = 0;
update_image_version_ = 0;
update_id_image_version_ = 0;
-
- id_image_.version = 0;
id_image_version_ = 0;
- select_image_binding_.change_callback = image_.change_callback ();
+ select_image_binding_.change_callback =
+ images_[0].obj.change_callback ();
std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_));
std::memset (update_image_bind_, 0, sizeof (update_image_bind_));
diff --git a/odb/oracle/statement.cxx b/odb/oracle/statement.cxx
index 4032138..023e41f 100644
--- a/odb/oracle/statement.cxx
+++ b/odb/oracle/statement.cxx
@@ -4,8 +4,9 @@
#include <oci.h>
-#include <cstring> // std::strlen
+#include <cstring> // std::strlen, std::memset
#include <cassert>
+#include <iostream> // @@ tmp
#include <odb/tracer.hxx>
#include <odb/exceptions.hxx> // object_not_persistent
@@ -70,10 +71,18 @@ namespace odb
SQLT_CLOB // bind::nclob
};
+ template <typename T>
+ inline T*
+ offset (T* base, size_t count, size_t size)
+ {
+ return reinterpret_cast<T*> (
+ reinterpret_cast<char*> (base) + count * size);
+ }
+
extern "C" sb4
odb_oracle_param_callback_proxy (void* context,
OCIBind*,
- ub4, // iteration
+ ub4 it, // iteration
ub4, // index
void** buffer,
ub4* size,
@@ -81,15 +90,23 @@ namespace odb
void** indicator)
{
bind& b (*static_cast<bind*> (context));
- lob* l (static_cast<lob*> (b.buffer));
+
+ // Offset the data based on the current iteration and skip size (stored
+ // in capacity).
+ //
+ sb2* ind (offset (b.indicator, it, b.capacity));
// Only call the callback if the parameter is not NULL.
//
- if (*b.indicator != -1)
+ if (*ind != -1)
{
+ lob* l (static_cast<lob*> (offset (b.buffer, it, b.capacity)));
+ lob_callback* cb (
+ static_cast<lob_callback*> (offset (b.callback, it, b.capacity)));
+
chunk_position pos;
- if (!(*b.callback->callback.param) (
- b.callback->context.param,
+ if (!(*cb->callback.param) (
+ cb->context.param,
&l->position,
const_cast<const void**> (buffer),
size,
@@ -125,7 +142,7 @@ namespace odb
else
*piece = OCI_ONE_PIECE;
- *indicator = b.indicator;
+ *indicator = ind;
return OCI_CONTINUE;
}
@@ -321,7 +338,7 @@ namespace odb
}
ub4 statement::
- bind_param (bind* b, size_t n)
+ bind_param (bind* b, size_t n, size_t batch, size_t skip)
{
// Figure out how many unbind elements we will need and allocate them.
//
@@ -589,7 +606,11 @@ namespace odb
// However, in Oracle, LOBs cannot be used in queries so we can
// make an exception here.
//
- l->buffer = &lob_buffer;
+ for (size_t i (0); i != batch;)
+ {
+ l->buffer = &lob_buffer;
+ l = static_cast<lob*> (offset (b->buffer, ++i, skip));
+ }
}
assert (callback);
@@ -603,6 +624,11 @@ namespace odb
//
capacity = 4096;
+ // Store skip in capacity so that the callback can offset the
+ // values based on the iteration number.
+ //
+ b->capacity = static_cast<ub4> (skip);
+
break;
}
default:
@@ -686,6 +712,23 @@ namespace odb
if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
translate_error (err, r);
}
+
+ // Set array information if we have a batch.
+ //
+ if (batch != 1)
+ {
+ ub4 s (static_cast<ub4> (skip));
+
+ r = OCIBindArrayOfStruct (h,
+ err,
+ (value != 0 ? s : 0), // value
+ (b->indicator != 0 ? s : 0), // indicator
+ (size != 0 ? s : 0), // length
+ 0); // return code
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ translate_error (err, r);
+ }
}
return i;
@@ -1175,6 +1218,211 @@ namespace odb
}
//
+ // bulk_statement
+ //
+
+ bulk_statement::
+ ~bulk_statement () {}
+
+ sword bulk_statement::
+ execute (size_t n, multiple_exceptions* mex, sb4 ignore_code)
+ {
+ {
+ odb::tracer* t;
+ if ((t = conn_.transaction_tracer ()) ||
+ (t = conn_.tracer ()) ||
+ (t = conn_.database ().tracer ()))
+ t->execute (conn_, *this);
+ }
+
+ mex_ = mex;
+
+ OCIError* err (conn_.error_handle ());
+
+ // We use OCI_BATCH_ERRORS for n == 1 in order to get the batch
+ // error reporting even for a single parameter set. This makes
+ // it easier to populate mex since otherwise we would have two
+ // cases to worry about: batch and non-batch (statement fails
+ // as a whole).
+ //
+ sword r (OCIStmtExecute (conn_.handle (),
+ stmt_,
+ err,
+ static_cast<ub4> (n),
+ 0,
+ 0,
+ 0,
+ status_ == 0 ? OCI_DEFAULT : OCI_BATCH_ERRORS));
+
+ // If the statement failed as a whole, assume no parameter sets
+ // were attempted in case of a batch. Otherwise, in the batch
+ // errors mode, all the sets are always attempted (let's hope
+ // this is actually true).
+ //
+ i_ = 0;
+ n_ = (r == OCI_ERROR || r == OCI_INVALID_HANDLE
+ ? (status_ == 0 ? 1 : 0)
+ : n);
+
+ if (mex_ != 0)
+ {
+ mex_->current (i_);
+ mex_->attempted (n_);
+ }
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ {
+ if (mex_ != 0)
+ mex_->fatal (true); // An incomplete batch is always fatal.
+
+ return r;
+ }
+
+ // Initialize the batch status array and extract error information
+ // for failed parameter sets.
+ //
+ if (status_ != 0)
+ {
+ sword r; // Our own return code.
+
+ // Clear the status array.
+ //
+ memset (status_, 0, n * sizeof (status_[0]));
+
+ if (err1_ == 0)
+ {
+ OCIError* e (0);
+ r = OCIHandleAlloc (conn_.database ().environment (),
+ reinterpret_cast<void**> (&e),
+ OCI_HTYPE_ERROR,
+ 0,
+ 0);
+
+ if (r != OCI_SUCCESS)
+ throw invalid_oci_handle ();
+
+ err1_.reset (e);
+ }
+
+ ub4 errors;
+ r = OCIAttrGet (stmt_,
+ OCI_HTYPE_STMT,
+ &errors,
+ 0,
+ OCI_ATTR_NUM_DML_ERRORS,
+ err1_);
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ translate_error (err1_, r);
+
+ //cerr << "NUM_DML_ERRORS: " << errors << endl;
+ errors_ = errors;
+
+ if (errors != 0)
+ {
+ auto_handle<OCIError> err2;
+
+ {
+ OCIError* e (0);
+ r = OCIHandleAlloc (conn_.database ().environment (),
+ reinterpret_cast<void**> (&e),
+ OCI_HTYPE_ERROR,
+ 0,
+ 0);
+
+ if (r != OCI_SUCCESS)
+ throw invalid_oci_handle ();
+
+ err2.reset (e);
+ }
+
+ for (ub4 i (0); i != errors; ++i)
+ {
+ {
+ OCIError* tmp (err2);
+ r = OCIParamGet (err, // from
+ OCI_HTYPE_ERROR,
+ err1_, // diagnostics
+ reinterpret_cast<void**> (&tmp), // to
+ i);
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ translate_error (err1_, r);
+ }
+
+ ub4 row;
+ r = OCIAttrGet (err2,
+ OCI_HTYPE_ERROR,
+ &row,
+ 0,
+ OCI_ATTR_DML_ROW_OFFSET,
+ err1_);
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ translate_error (err1_, r);
+
+ OCIErrorGet (err2, 1, 0, &status_[row], 0, 0, OCI_HTYPE_ERROR);
+
+ if (status_[row] != ignore_code)
+ translate_error (err2, OCI_ERROR, &conn_, row, mex_);
+
+ cerr << "[" << row << "] " << status_[row] << endl;
+ }
+ }
+ }
+
+ return r;
+ }
+
+ unsigned long long bulk_statement::
+ affected (bool unique)
+ {
+ unsigned long long rows;
+ {
+ ub4 n (0);
+ OCIError* err (conn_.error_handle ());
+ sword r (OCIAttrGet (stmt_,
+ OCI_HTYPE_STMT,
+ &n,
+ 0,
+ OCI_ATTR_ROW_COUNT,
+ err));
+
+ if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
+ translate_error (err, r);
+
+ rows = static_cast<unsigned long long> (n);
+ }
+
+ //cerr << "total: " << rows << endl;
+
+ if (n_ > 1) // Batch.
+ {
+ if (rows != 0) // Some rows did get affected.
+ {
+ // Subtract the parameter sets that failed since they haven't
+ // affected any rows.
+ //
+ size_t p (n_ - errors_);
+
+ if (p > 1) // True batch.
+ {
+ if (unique) // Each can affect 0 or 1 row.
+ {
+ rows = (p == static_cast<size_t> (rows)
+ ? 1
+ : result_unknown);
+ }
+ else
+ rows = result_unknown;
+ }
+ }
+ }
+
+ return rows;
+ }
+
+ //
// generic_statement
//
@@ -1559,22 +1807,25 @@ namespace odb
extern "C" sb4
odb_oracle_returning_in (void* context,
OCIBind*, // bind
- ub4, // iter
+ ub4 it, // iter
ub4, // index
void** buffer,
ub4* size,
ub1* piece,
void** indicator)
{
- typedef insert_statement::id_bind_type bind;
-
- bind& b (*static_cast<bind*> (context));
+ binding& ret (*static_cast<insert_statement*> (context)->ret_);
+ // Offset the data based on the current iteration and skip size.
+ // The id is always first.
+ //
*buffer = 0;
*size = 0;
*piece = OCI_ONE_PIECE;
- b.indicator = -1;
- *indicator = &b.indicator;
+
+ sb2* ind (offset (ret.bind[0].indicator, it, ret.skip));
+ *ind = -1;
+ *indicator = ind;
return OCI_CONTINUE;
}
@@ -1582,30 +1833,56 @@ namespace odb
extern "C" sb4
odb_oracle_returning_out (void* context,
OCIBind*, // bind
- ub4, // iter
+ ub4 it, // iter
ub4, // index
void** buffer,
ub4** size,
- ub1*, // piece
+ ub1* piece,
void** indicator,
ub2** rcode)
{
- typedef insert_statement::id_bind_type bind;
+ insert_statement& st (*static_cast<insert_statement*> (context));
+ bind& b (st.ret_->bind[0]); // The id is always first.
+ size_t skip (st.ret_->skip);
- bind& b (*static_cast<bind*> (context));
+ // Offset the data based on the current iteration and skip size.
+ //
+ *buffer = offset (b.buffer, it, skip);
-#if (OCI_MAJOR_VERSION == 11 && OCI_MINOR_VERSION >=2) \
- || OCI_MAJOR_VERSION > 11
- *buffer = &b.id.integer;
- **size = sizeof (unsigned long long);
-#else
- *buffer = b.id.number.buffer;
- *size = &b.id.number.size;
- b.id.number.size = 21;
-#endif
+ if (b.type == bind::number)
+ {
+ // So the straightforward way to handle this would have been to
+ // set size to the properly offset pointer to b.size, just like
+ // we do for the buffer and indicator. The problem is that in
+ // OCI size is ub2 everywhere except in the *Dynamic() callbacks.
+ // Here it is expected to be ub4 and, as a result, we cannot use
+ // our ub2 size that we use throughout (I know you are tempted
+ // to just cast ub2* to ub4* and forget about this mess, but,
+ // trust me, this won't end up well).
+ //
+ // So what we will do instead is this: have a temporary ub4 buffer
+ // that we return to OCI so that it can store the size for us. But
+ // the callback can be called multiple times (batch operations) so
+ // on each subsequent call we will have to save the size from the
+ // previous call into our ub2 array. We will also have to handle
+ // the last extracted size after OCIStmtExecute() below. Thanks,
+ // Oracle!
+ //
+ if (st.ret_prev_ != 0)
+ *st.ret_prev_ = static_cast<ub2> (st.ret_size_);
+
+ st.ret_prev_ = offset (b.size, it, skip);
+ *size = &st.ret_size_;
+ }
+
+ // For some reason we have to set the out size to the (presumably)
+ // maximum buffer size.
+ //
+ **size = b.capacity;
- *indicator = &b.indicator;
+ *indicator = offset (b.indicator, it, skip);
*rcode = 0;
+ *piece = OCI_ONE_PIECE;
return OCI_CONTINUE;
}
@@ -1620,12 +1897,14 @@ namespace odb
const string& text,
bool process,
binding& param,
- bool returning)
- : statement (conn,
- text, statement_insert,
- (process ? &param : 0), false)
+ binding* returning)
+ : bulk_statement (conn,
+ text, statement_insert,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ ret_ (returning)
{
- init (param, returning);
+ init (param);
}
insert_statement::
@@ -1633,37 +1912,44 @@ namespace odb
const char* text,
bool process,
binding& param,
- bool returning)
- : statement (conn,
- text, statement_insert,
- (process ? &param : 0), false)
+ binding* returning)
+ : bulk_statement (conn,
+ text, statement_insert,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ ret_ (returning)
{
- init (param, returning);
+ init (param);
}
void insert_statement::
- init (binding& param, bool returning)
+ init (binding& param)
{
- ub4 param_count (bind_param (param.bind, param.count));
-
- if (returning)
+ ub4 param_count (bind_param (param.bind, param.count,
+ param.batch, param.skip));
+ if (ret_ != 0)
{
OCIError* err (conn_.error_handle ());
OCIBind* h (0);
+ bind* b (ret_->bind);
+
+#if OCI_MAJOR_VERSION < 11 || \
+ (OCI_MAJOR_VERSION == 11 && OCI_MINOR_VERSION < 2)
+ // Assert if a 64 bit integer buffer type is provided and the OCI
+ // version is unable to implicitly convert the NUMBER binary data
+ // to the relevant type.
+ //
+ assert ((b->type != bind::integer && b->type != bind::uinteger) ||
+ b->capacity <= 4);
+#endif
sword r (OCIBindByPos (stmt_,
&h,
err,
param_count + 1,
0,
-#if (OCI_MAJOR_VERSION == 11 && OCI_MINOR_VERSION >=2) \
- || OCI_MAJOR_VERSION > 11
- sizeof (unsigned long long),
- SQLT_UIN,
-#else
- 21,
- SQLT_NUM,
-#endif
+ b->capacity,
+ param_sqlt_lookup[b->type],
0,
0,
0,
@@ -1676,9 +1962,9 @@ namespace odb
r = OCIBindDynamic (h,
err,
- &id_bind_,
+ this,
&odb_oracle_returning_in,
- &id_bind_,
+ this,
&odb_oracle_returning_out);
if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
@@ -1686,71 +1972,63 @@ namespace odb
}
}
- bool insert_statement::
- execute ()
+ size_t insert_statement::
+ execute (size_t n, multiple_exceptions* mex)
{
- {
- odb::tracer* t;
- if ((t = conn_.transaction_tracer ()) ||
- (t = conn_.tracer ()) ||
- (t = conn_.database ().tracer ()))
- t->execute (conn_, *this);
- }
-
OCIError* err (conn_.error_handle ());
- sword r (OCIStmtExecute (conn_.handle (),
- stmt_,
- err,
- 1,
- 0,
- 0,
- 0,
- OCI_DEFAULT));
+ if (ret_ != 0)
+ ret_prev_ = 0;
+ // Ignore ORA-00001 error code, see fetch() below for details.
+ //
+ sword r (bulk_statement::execute (n, mex, (ret_ == 0 ? 1 : 0)));
+
+ // Statement failed as a whole, assume no parameter sets were
+ // attempted in case of a batch.
+ //
if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
{
sb4 e;
OCIErrorGet (err, 1, 0, &e, 0, 0, OCI_HTYPE_ERROR);
+ fetch (r, e);
- // The Oracle error code ORA-00001 indicates unique constraint
- // violation, which covers more than just a duplicate primary key.
- // Unfortunately, there is nothing more precise that we can use.
- //
- if (e == 1)
- return false;
- else
- translate_error (conn_, r);
+ if (result_) // If fetch() hasn't translated the error.
+ translate_error (err, r, &conn_, 0, mex_); // Can return.
+
+ return n_;
}
- ub4 row_count (0);
- r = OCIAttrGet (stmt_,
- OCI_HTYPE_STMT,
- &row_count,
- 0,
- OCI_ATTR_ROW_COUNT,
- err);
+ // Store the last returned id size (see odb_oracle_returning_out()
+ // for details).
+ //
+ if (ret_ != 0 && ret_prev_ != 0)
+ *ret_prev_ = static_cast<ub2> (ret_size_);
- if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
- translate_error (err, r);
+ if (status_ == 0) // Non-batch mode.
+ fetch (OCI_SUCCESS, 0);
+ else
+ {
+ fetch (status_[i_] == 0 ? OCI_SUCCESS : OCI_ERROR, status_[i_]);
+ }
- // The value of the OCI_ATTR_ROW_COUNT attribute associated with an
- // INSERT statment represents the number of rows inserted.
- //
- return row_count != 0;
+ return n_;
}
- unsigned long long insert_statement::
- id ()
+ bool insert_statement::
+ result (std::size_t i)
{
-#if (OCI_MAJOR_VERSION == 11 && OCI_MINOR_VERSION >=2) \
- || OCI_MAJOR_VERSION > 11
- return id_bind_.id.integer;
-#else
- return details::number_to_uint64 (
- id_bind_.id.number.buffer,
- static_cast <std::size_t> (id_bind_.id.number.size));
-#endif
+ assert ((i_ == i || i_ + 1 == i) && i < n_);
+
+ // Get to the next parameter set if necessary.
+ //
+ if (i != i_)
+ {
+ mex_->current (++i_); // mex cannot be NULL since this is a batch.
+ fetch (status_[i_] == 0 ? OCI_SUCCESS : OCI_ERROR, status_[i_]);
+ }
+
+ return result_;
}
//
@@ -1767,12 +2045,32 @@ namespace odb
const string& text,
bool process,
binding& param)
- : statement (conn,
- text, statement_update,
- (process ? &param : 0), false)
+ : bulk_statement (conn,
+ text, statement_update,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ unique_ (false)
{
+ assert (param.batch == 1); // Specify unique_hint explicitly.
+
if (!empty ())
- bind_param (param.bind, param.count);
+ bind_param (param.bind, param.count, param.batch, param.skip);
+ }
+
+ update_statement::
+ update_statement (connection_type& conn,
+ const string& text,
+ bool unique,
+ bool process,
+ binding& param)
+ : bulk_statement (conn,
+ text, statement_update,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ unique_ (unique)
+ {
+ if (!empty ())
+ bind_param (param.bind, param.count, param.batch, param.skip);
}
update_statement::
@@ -1780,55 +2078,66 @@ namespace odb
const char* text,
bool process,
binding& param)
- : statement (conn,
- text, statement_update,
- (process ? &param : 0), false)
+ : bulk_statement (conn,
+ text, statement_update,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ unique_ (false)
{
+ assert (param.batch == 1); // Specify unique_hint explicitly.
+
if (!empty ())
- bind_param (param.bind, param.count);
+ bind_param (param.bind, param.count, param.batch, param.skip);
}
- unsigned long long update_statement::
- execute ()
+ update_statement::
+ update_statement (connection_type& conn,
+ const char* text,
+ bool unique,
+ bool process,
+ binding& param)
+ : bulk_statement (conn,
+ text, statement_update,
+ (process ? &param : 0), false,
+ param.batch, param.status),
+ unique_ (unique)
{
- {
- odb::tracer* t;
- if ((t = conn_.transaction_tracer ()) ||
- (t = conn_.tracer ()) ||
- (t = conn_.database ().tracer ()))
- t->execute (conn_, *this);
- }
+ if (!empty ())
+ bind_param (param.bind, param.count, param.batch, param.skip);
+ }
+ size_t update_statement::
+ execute (size_t n, multiple_exceptions* mex)
+ {
OCIError* err (conn_.error_handle ());
+ sword r (bulk_statement::execute (n, mex));
- sword r (OCIStmtExecute (conn_.handle (),
- stmt_,
- err,
- 1,
- 0,
- 0,
- 0,
- OCI_DEFAULT));
-
+ // Statement failed as a whole, assume no parameter sets were
+ // attempted in case of a batch.
+ //
if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
- translate_error (conn_, r);
+ {
+ translate_error (err, r, &conn_, 0, mex_); // Can return.
+ return n_;
+ }
- ub4 row_count (0);
- r = OCIAttrGet (stmt_,
- OCI_HTYPE_STMT,
- &row_count,
- 0,
- OCI_ATTR_ROW_COUNT,
- err);
+ // Figure out the affected (matched, not necessarily updated)
+ // row count.
+ //
+ result_ = affected (unique_);
- if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
- translate_error (err, r);
+ return n_;
+ }
- // The value of the OCI_ATTR_ROW_COUNT attribute associated with an
- // UPDATE statment represents the number of matching rows found. Zero
- // indicates no match.
- //
- return static_cast<unsigned long long> (row_count);
+ unsigned long long update_statement::
+ result (std::size_t i)
+ {
+ assert ((i_ == i || i_ + 1 == i) && i < n_);
+
+ if (i != i_)
+ mex_->current (++i_); // mex cannot be NULL since this is a batch.
+
+ return result_;
}
//
@@ -1844,61 +2153,89 @@ namespace odb
delete_statement (connection_type& conn,
const string& text,
binding& param)
- : statement (conn,
- text, statement_delete,
- 0, false)
+ : bulk_statement (conn,
+ text, statement_delete,
+ 0, false,
+ param.batch, param.status),
+ unique_ (false)
+ {
+ assert (param.batch == 1); // Specify unique_hint explicitly.
+ bind_param (param.bind, param.count, param.batch, param.skip);
+ }
+
+ delete_statement::
+ delete_statement (connection_type& conn,
+ const string& text,
+ bool unique,
+ binding& param)
+ : bulk_statement (conn,
+ text, statement_delete,
+ 0, false,
+ param.batch, param.status),
+ unique_ (unique)
{
- bind_param (param.bind, param.count);
+ bind_param (param.bind, param.count, param.batch, param.skip);
}
delete_statement::
delete_statement (connection_type& conn,
const char* text,
binding& param)
- : statement (conn,
- text, statement_delete,
- 0, false)
+ : bulk_statement (conn,
+ text, statement_delete,
+ 0, false,
+ param.batch, param.status),
+ unique_ (false)
{
- bind_param (param.bind, param.count);
+ assert (param.batch == 1); // Specify unique_hint explicitly.
+ bind_param (param.bind, param.count, param.batch, param.skip);
}
- unsigned long long delete_statement::
- execute ()
+ delete_statement::
+ delete_statement (connection_type& conn,
+ const char* text,
+ bool unique,
+ binding& param)
+ : bulk_statement (conn,
+ text, statement_delete,
+ 0, false,
+ param.batch, param.status),
+ unique_ (unique)
{
- {
- odb::tracer* t;
- if ((t = conn_.transaction_tracer ()) ||
- (t = conn_.tracer ()) ||
- (t = conn_.database ().tracer ()))
- t->execute (conn_, *this);
- }
+ bind_param (param.bind, param.count, param.batch, param.skip);
+ }
+ size_t delete_statement::
+ execute (size_t n, multiple_exceptions* mex)
+ {
+ sword r (bulk_statement::execute (n, mex));
OCIError* err (conn_.error_handle ());
- sword r (OCIStmtExecute (conn_.handle (),
- stmt_,
- err,
- 1,
- 0,
- 0,
- 0,
- OCI_DEFAULT));
-
+ // Statement failed as a whole, assume no parameter sets were
+ // attempted in case of a batch.
+ //
if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
- translate_error (conn_, r);
+ {
+ translate_error (err, r, &conn_, 0, mex_); // Can return.
+ return n_;
+ }
- ub4 row_count (0);
- r = OCIAttrGet (stmt_,
- OCI_HTYPE_STMT,
- &row_count,
- 0,
- OCI_ATTR_ROW_COUNT,
- err);
+ // Figure out the affected row count.
+ //
+ result_ = affected (unique_);
- if (r == OCI_ERROR || r == OCI_INVALID_HANDLE)
- translate_error (err, r);
+ return n_;
+ }
+
+ unsigned long long delete_statement::
+ result (std::size_t i)
+ {
+ assert ((i_ == i || i_ + 1 == i) && i < n_);
+
+ if (i != i_)
+ mex_->current (++i_); // mex cannot be NULL since this is a batch.
- return static_cast<unsigned long long> (row_count);
+ return result_;
}
}
}
diff --git a/odb/oracle/statement.hxx b/odb/oracle/statement.hxx
index cf336c4..6a5d604 100644
--- a/odb/oracle/statement.hxx
+++ b/odb/oracle/statement.hxx
@@ -11,6 +11,7 @@
#include <cstddef> // std::size_t
#include <odb/statement.hxx>
+#include <odb/exceptions.hxx>
#include <odb/oracle/version.hxx>
#include <odb/oracle/forward.hxx>
@@ -96,7 +97,8 @@ namespace odb
// of columns bound.
//
ub4
- bind_param (bind*, std::size_t count);
+ bind_param (bind*, std::size_t count,
+ size_t batch = 1, std::size_t skip = 0);
// Bind results for this statement. This function must only be
// called once. Multiple calls to it will result in memory leaks
@@ -141,6 +143,50 @@ namespace odb
std::size_t usize_;
};
+ class LIBODB_ORACLE_EXPORT bulk_statement: public statement
+ {
+ public:
+ virtual
+ ~bulk_statement () = 0;
+
+ protected:
+ bulk_statement (connection_type&,
+ const std::string& text,
+ statement_kind,
+ const binding* process,
+ bool optimize,
+ std::size_t batch,
+ sb4* status);
+
+ bulk_statement (connection_type&,
+ const char* text,
+ statement_kind,
+ const binding* process,
+ bool optimize,
+ std::size_t batch,
+ sb4* status);
+
+ // Call OCIStmtExecute() and set up the batch tracking variables (see
+ // below). The ignore_code argument specifies optional error code that
+ // should not be treated as an error.
+ //
+ sword
+ execute (std::size_t n, multiple_exceptions*, sb4 ignore_code = 0);
+
+ static const unsigned long long result_unknown = ~0ULL;
+
+ unsigned long long
+ affected (bool unique);
+
+ protected:
+ auto_handle<OCIError> err1_;
+ sb4* status_; // Parameter sets status array.
+ std::size_t n_; // Actual batch size.
+ std::size_t i_; // Position in result.
+ std::size_t errors_; // Number of parameter sets that failed.
+ multiple_exceptions* mex_;
+ };
+
class LIBODB_ORACLE_EXPORT generic_statement: public statement
{
public:
@@ -251,7 +297,7 @@ namespace odb
select_statement& s_;
};
- class LIBODB_ORACLE_EXPORT insert_statement: public statement
+ class LIBODB_ORACLE_EXPORT insert_statement: public bulk_statement
{
public:
virtual
@@ -261,106 +307,222 @@ namespace odb
const std::string& text,
bool process_text,
binding& param,
- bool returning);
+ binding* returning);
insert_statement (connection_type& conn,
const char* text,
bool process_text,
binding& param,
- bool returning);
+ binding* returning);
- // Return true if successful and false if the row is a duplicate. All
- // other errors are reported by throwing exceptions.
+ // Return the number of parameter sets (out of n) that were attempted.
+ //
+ std::size_t
+ execute (std::size_t n, multiple_exceptions& mex)
+ {
+ return execute (n, &mex);
+ }
+
+ // Return true if successful and false if this row is a duplicate.
+ // All other errors are reported via exceptions.
//
bool
- execute ();
+ result (std::size_t i);
- unsigned long long
- id ();
+ bool
+ execute ()
+ {
+ execute (1, 0);
+ return result (0);
+ }
private:
insert_statement (const insert_statement&);
insert_statement& operator= (const insert_statement&);
- // Only OCI versions 11.2 and greater support conversion of the internal
- // Oracle type NUMBER to an external 64-bit integer type. If we detect
- // version 11.2 or greater we provide an unsigned long long image.
- // Otherwise, we revert to using a NUMBER image and manipulate it using
- // the custom conversion algorithms found in details/number.hxx.
- //
- public:
- struct id_bind_type
- {
- union
- {
- struct
- {
- char buffer[21];
- ub4 size;
- } number;
-
- unsigned long long integer;
- } id;
-
- sb2 indicator;
- };
-
private:
void
- init (binding& param, bool returning);
+ init (binding& param);
+
+ std::size_t
+ execute (std::size_t, multiple_exceptions*);
+
+ void
+ fetch (sword r, sb4 code);
+
+ public: // For odb_oracle_returning_*().
+ binding* ret_;
+ ub4 ret_size_; // You don't want to know (see statement.cxx).
+ ub2* ret_prev_;
private:
- id_bind_type id_bind_;
+ bool result_;
};
- class LIBODB_ORACLE_EXPORT update_statement: public statement
+ class LIBODB_ORACLE_EXPORT update_statement: public bulk_statement
{
public:
virtual
~update_statement ();
+ // OCI does not expose individual affected row counts for batch
+ // operations. Instead, it adds them all up and returns a single
+ // count. This is bad news for us.
+ //
+ // In case of updating by primary key (the affected row count is
+ // either 1 or 0), we can recognize the presumably successful case
+ // where the total affected row count is equal to the batch size
+ // (we can also recognize the "all unsuccessful" case where the
+ // total affected row count is 0). The unique_hint argument in the
+ // constructors below indicates whether this is a "0 or 1" UPDATE
+ // statement.
+ //
+ // In all other situations (provided this is a batch), the result()
+ // function below returns the special result_unknown value.
+ //
+ update_statement (connection_type& conn,
+ const std::string& text,
+ bool process_text,
+ binding& param);
+
update_statement (connection_type& conn,
const std::string& text,
+ bool unique_hint,
+ bool process_text,
+ binding& param);
+
+ update_statement (connection_type& conn,
+ const char* text,
bool process_text,
binding& param);
update_statement (connection_type& conn,
const char* text,
+ bool unique_hint,
bool process_text,
binding& param);
+ // Return the number of parameter sets (out of n) that were attempted.
+ //
+ std::size_t
+ execute (std::size_t n, multiple_exceptions& mex)
+ {
+ return execute (n, &mex);
+ }
+
+ // Return the number of rows affected (deleted) by the parameter
+ // set. If this is a batch (n > 1 in execute() call above) and it
+ // is impossible to determine the affected row count for each
+ // parameter set, then this function returns result_unknown. All
+ // other errors are reported by throwing exceptions.
+ //
+ using bulk_statement::result_unknown;
+
unsigned long long
- execute ();
+ result (std::size_t i);
+
+ unsigned long long
+ execute ()
+ {
+ execute (1, 0);
+ return result (0);
+ }
private:
update_statement (const update_statement&);
update_statement& operator= (const update_statement&);
+
+ private:
+ std::size_t
+ execute (std::size_t, multiple_exceptions*);
+
+ private:
+ bool unique_;
+ unsigned long long result_;
};
- class LIBODB_ORACLE_EXPORT delete_statement: public statement
+ class LIBODB_ORACLE_EXPORT delete_statement: public bulk_statement
{
public:
virtual
~delete_statement ();
+ // OCI does not expose individual affected row counts for batch
+ // operations. Instead, it adds them all up and returns a single
+ // count. This is bad news for us.
+ //
+ // In case of deleting by primary key (the affected row count is
+ // either 1 or 0), we can recognize the presumably successful case
+ // where the total affected row count is equal to the batch size
+ // (we can also recognize the "all unsuccessful" case where the
+ // total affected row count is 0). The unique_hint argument in the
+ // constructors below indicates whether this is a "0 or 1" DELETE
+ // statement.
+ //
+ // In all other situations (provided this is a batch), the result()
+ // function below returns the special result_unknown value.
+ //
+ delete_statement (connection_type& conn,
+ const std::string& text,
+ binding& param);
+
delete_statement (connection_type& conn,
const std::string& text,
+ bool unique_hint,
+ binding& param);
+
+ delete_statement (connection_type& conn,
+ const char* text,
binding& param);
delete_statement (connection_type& conn,
const char* text,
+ bool unique_hint,
binding& param);
+ // Return the number of parameter sets (out of n) that were attempted.
+ //
+ std::size_t
+ execute (std::size_t n, multiple_exceptions& mex)
+ {
+ return execute (n, &mex);
+ }
+
+ // Return the number of rows affected (deleted) by the parameter
+ // set. If this is a batch (n > 1 in execute() call above) and it
+ // is impossible to determine the affected row count for each
+ // parameter set, then this function returns result_unknown. All
+ // other errors are reported by throwing exceptions.
+ //
+ using bulk_statement::result_unknown;
+
unsigned long long
- execute ();
+ result (std::size_t i);
+
+ unsigned long long
+ execute ()
+ {
+ execute (1, 0);
+ return result (0);
+ }
private:
delete_statement (const delete_statement&);
delete_statement& operator= (const delete_statement&);
+
+ private:
+ std::size_t
+ execute (std::size_t, multiple_exceptions*);
+
+ private:
+ bool unique_;
+ unsigned long long result_;
};
}
}
+#include <odb/oracle/statement.ixx>
+
#include <odb/post.hxx>
#endif // ODB_ORACLE_STATEMENT_HXX
diff --git a/odb/oracle/statement.ixx b/odb/oracle/statement.ixx
new file mode 100644
index 0000000..f1cdb75
--- /dev/null
+++ b/odb/oracle/statement.ixx
@@ -0,0 +1,63 @@
+// file : odb/oracle/statement.ixx
+// copyright : Copyright (c) 2005-2013 Code Synthesis Tools CC
+// license : ODB NCUEL; see accompanying LICENSE file
+
+using namespace std;
+
+namespace odb
+{
+ namespace oracle
+ {
+ // bulk_statement
+ //
+ inline bulk_statement::
+ bulk_statement (connection_type& c,
+ const std::string& text,
+ statement_kind k,
+ const binding* process,
+ bool optimize,
+ std::size_t batch,
+ sb4* status)
+ : statement (c, text, k, process, optimize),
+ status_ (batch == 1 ? 0 : status)
+ {
+ }
+
+ inline bulk_statement::
+ bulk_statement (connection_type& c,
+ const char* text,
+ statement_kind k,
+ const binding* process,
+ bool optimize,
+ std::size_t batch,
+ sb4* status)
+ : statement (c, text, k, process, optimize),
+ status_ (batch == 1 ? 0 : status)
+ {
+ }
+
+ // insert_statement
+ //
+ inline void insert_statement::
+ fetch (sword r, sb4 code)
+ {
+ result_ = true;
+
+ if (r != 0) // OCI_SUCCESS
+ {
+ // An auto-assigned object id should never cause a duplicate primary
+ // key.
+ //
+ if (ret_ == 0)
+ {
+ // The Oracle error code ORA-00001 indicates unique constraint
+ // violation, which covers more than just a duplicate primary key.
+ // Unfortunately, there is nothing more precise that we can use.
+ //
+ if (code == 1)
+ result_ = false;
+ }
+ }
+ }
+ }
+}
generated by cgit v1.1 at 2024-11-21 18:07:10 +0000