Initial bulk erase implementation

4 files changed, 353 insertions, 141 deletions

diff --git a/odb/mssql/simple-object-statements.txx b/odb/mssql/simple-object-statements.txx
index 9edd380..fa1b6e7 100644
--- a/odb/mssql/simple-object-statements.txx
+++ b/odb/mssql/simple-object-statements.txx
@@ -55,7 +55,7 @@ namespace odb
                              id_column_count,
                              object_traits::batch,
                              sizeof (id_image_type),
-                             0),
+                             status_),
           od_ (update_image_bind_ + update_column_count)
     {
       image_[0].version = 0; // @@ TODO [0]
diff --git a/odb/mssql/statement.cxx b/odb/mssql/statement.cxx
index f3456fb..12fc21c 100644
--- a/odb/mssql/statement.cxx
+++ b/odb/mssql/statement.cxx
@@ -276,42 +276,10 @@ namespace odb
     }
 
     void statement::
-    bind_param (bind* b, size_t n, size_t skip, SQLUSMALLINT* status)
+    bind_param (bind* b, size_t n)
     {
       SQLRETURN r;
 
-      // Setup row-wise batch operation. We set the actual number of
-      // rows in the batch in execute().
-      //
-      param_skip_ = skip;
-
-      if (param_skip_ != 0)
-      {
-        r = SQLSetStmtAttr (stmt_,
-                            SQL_ATTR_PARAM_BIND_TYPE,
-                            (SQLPOINTER) param_skip_,
-                            0);
-
-        if (!SQL_SUCCEEDED (r))
-          translate_error (r, conn_, stmt_);
-
-        r = SQLSetStmtAttr (stmt_,
-                            SQL_ATTR_PARAMS_PROCESSED_PTR,
-                            (SQLPOINTER) &processed_,
-                            0);
-
-        if (!SQL_SUCCEEDED (r))
-          translate_error (r, conn_, stmt_);
-
-        r = SQLSetStmtAttr (stmt_,
-                            SQL_ATTR_PARAM_STATUS_PTR,
-                            (SQLPOINTER) status,
-                            0);
-
-        if (!SQL_SUCCEEDED (r))
-          translate_error (r, conn_, stmt_);
-      }
-
       SQLUSMALLINT i (0);
       for (bind* end (b + n); b != end; ++b)
       {
@@ -551,8 +519,6 @@ namespace odb
           t->execute (conn_, *this);
       }
 
-      processed_ = 0;
-
       SQLRETURN r (SQLExecute (stmt_));
 
       if (r == SQL_NEED_DATA)
@@ -753,6 +719,115 @@ namespace odb
     }
 
     //
+    // bulk_statement
+    //
+    bulk_statement::
+    ~bulk_statement () {}
+
+    void bulk_statement::
+    init (size_t skip)
+    {
+      // Setup row-wise batch operation. We set the actual number of
+      // rows in the batch in execute().
+      //
+      SQLRETURN r;
+
+      r = SQLSetStmtAttr (stmt_,
+                          SQL_ATTR_PARAM_BIND_TYPE,
+                          (SQLPOINTER) skip,
+                          0);
+
+      if (!SQL_SUCCEEDED (r))
+        translate_error (r, conn_, stmt_);
+
+      r = SQLSetStmtAttr (stmt_,
+                          SQL_ATTR_PARAMS_PROCESSED_PTR,
+                          (SQLPOINTER) &processed_,
+                          0);
+
+      if (!SQL_SUCCEEDED (r))
+        translate_error (r, conn_, stmt_);
+
+      r = SQLSetStmtAttr (stmt_,
+                          SQL_ATTR_PARAM_STATUS_PTR,
+                          (SQLPOINTER) status_,
+                          0);
+
+      if (!SQL_SUCCEEDED (r))
+        translate_error (r, conn_, stmt_);
+    }
+
+    SQLRETURN bulk_statement::
+    execute (size_t n, multiple_exceptions* mex)
+    {
+      mex_ = mex;
+
+      if (status_ != 0)
+      {
+        SQLRETURN r (SQLSetStmtAttr (stmt_,
+                                     SQL_ATTR_PARAMSET_SIZE,
+                                     (SQLPOINTER) n,
+                                     0));
+
+        if (!SQL_SUCCEEDED (r))
+          translate_error (r, conn_, stmt_);
+
+        // Some SQL* functions would only update the status in case of
+        // an error.
+        //
+        memset (status_, 0, sizeof (status_[0]) * n);
+      }
+
+      processed_ = 0;
+      SQLRETURN r (statement::execute ());
+
+      // If the statement failed as a whole, assume only the first row
+      // was attempted (and failed). Otherwise, the documentation says
+      // that the native client driver keeps processing remaining rows
+      // even in case of an error.
+      //
+      i_ = 0;
+      n_ = (SQL_SUCCEEDED (r) ? n : 1);
+
+      if (mex_ != 0)
+      {
+        mex_->current (i_);
+        mex_->attempted (processed_);
+      }
+
+      if (!SQL_SUCCEEDED (r))
+      {
+        if (mex_ != 0)
+          mex_->fatal (true); // An incomplete batch is always fatal.
+
+        return r;
+      }
+
+      cerr << "processed: " << processed_ << endl;
+
+      for (unsigned i (0); i != processed_; ++i)
+      {
+        cerr << "[" << i << "] " << status_[i] << " ";
+
+        if (status_[i] == SQL_PARAM_ERROR)
+          cerr << "error ";
+        else if (status_[i] == SQL_PARAM_SUCCESS ||
+                 status_[i] == SQL_PARAM_SUCCESS_WITH_INFO)
+          cerr << "ok";
+        else if (status_[i] == SQL_PARAM_UNUSED)
+          cerr << "unused";
+        else if (status_[i] == SQL_PARAM_DIAG_UNAVAILABLE)
+          cerr << "unavailable";
+        else
+          cerr << "?";
+
+        cerr << endl;
+      }
+
+      return r;
+    }
+
+    //
     // select_statement
     //
     select_statement::
@@ -907,16 +982,13 @@ namespace odb
                       bool returning_id,
                       bool returning_version,
                       binding* returning)
-        : statement (conn,
-                     text, statement_insert,
-                     (process ? &param : 0), false),
-          returning_id_ (returning_id), returning_version_ (returning_version),
-          status_ (param.status)
+        : bulk_statement (conn,
+                          text, statement_insert,
+                          (process ? &param : 0), false,
+                          param.batch, param.skip, param.status),
+          returning_id_ (returning_id), returning_version_ (returning_version)
     {
-      //@@ Just pass binding already! And use batch size, not skip to
-      // decide if it is batch.
-      //
-      bind_param (param.bind, param.count, param.skip, status_);
+      bind_param (param.bind, param.count);
 
       if (returning_id_ || returning_version_)
         init_result (*returning);
@@ -931,14 +1003,14 @@ namespace odb
                       bool returning_version,
                       binding* returning,
                       bool copy_text)
-        : statement (conn,
-                     text, statement_insert,
-                     (process ? &param : 0), false,
-                     copy_text),
-          returning_id_ (returning_id), returning_version_ (returning_version),
-          status_ (param.status)
+        : bulk_statement (conn,
+                          text, statement_insert,
+                          (process ? &param : 0), false,
+                          param.batch, param.skip, param.status,
+                          copy_text),
+          returning_id_ (returning_id), returning_version_ (returning_version)
     {
-      bind_param (param.bind, param.count, param.skip, status_);
+      bind_param (param.bind, param.count);
 
       if (returning_id_ || returning_version_)
         init_result (*returning);
@@ -954,7 +1026,7 @@ namespace odb
       // for one of the inserted columns is supplied at execution
       // (long data).
       //
-      batch_ = strstr (text_, "OUTPUT INSERTED.") == 0 &&
+      text_batch_ = strstr (text_, "OUTPUT INSERTED.") == 0 &&
         strstr (text_, "output inserted.") == 0;
 
       SQLRETURN r;
@@ -1001,28 +1073,6 @@ namespace odb
     size_t insert_statement::
     execute (size_t n, multiple_exceptions* mex)
     {
-      mex_ = mex;
-
-      //@@ TODO Should move to statement, also don't call if no batch (will
-      //   need a flag).
-      //
-      {
-        SQLRETURN r (SQLSetStmtAttr (stmt_,
-                                     SQL_ATTR_PARAMSET_SIZE,
-                                     (SQLPOINTER) n,
-                                     0));
-
-        if (!SQL_SUCCEEDED (r))
-          translate_error (r, conn_, stmt_);
-
-        // Some SQL* functions would only update the status in case of
-        // an error.
-        //
-        memset (status_, 0, sizeof (status_[0]) * n);
-      }
-
-      SQLRETURN r (statement::execute ());
-
       // The batch INSERT works in two different ways, depending on
       // whether we have the OUTPUT clause. If there is no OUTPUT,
       // then all the rows are processed inside the SQLExecute()
@@ -1034,50 +1084,16 @@ namespace odb
       // (value in n_). Note that in the OUTPUT case if there is an
       // error, the processed count seems to jump by 2 for some reason.
       //
-      // If the statement failed as a whole, assume only the first row
-      // was attempted (and failed). Otherwise, the documentation says
-      // that the native client driver keeps processing remaining rows
-      // even in case of an error.
-      //
-      i_ = 0;
-      n_ = (SQL_SUCCEEDED (r) ? n : 1);
-
-      if (mex_ != 0)
-      {
-        mex_->current (i_);
-        mex_->attempted (processed_);
-      }
+      SQLRETURN r (bulk_statement::execute (n, mex));
 
+      // Statement failed as a whole, assume only one row was attempted.
+      //
       if (!SQL_SUCCEEDED (r))
       {
-        if (mex_ != 0)
-          mex_->fatal (true); // An incomplete batch is always fatal.
-
         fetch (r);
         return n_;
       }
 
-      cerr << "processed: " << processed_ << endl;
-
-      for (unsigned i (0); i != processed_; ++i)
-      {
-        cerr << "[" << i << "] " << status_[i] << " ";
-
-        if (status_[i] == SQL_PARAM_ERROR)
-          cerr << "error ";
-        else if (status_[i] == SQL_PARAM_SUCCESS ||
-                 status_[i] == SQL_PARAM_SUCCESS_WITH_INFO)
-          cerr << "ok";
-        else if (status_[i] == SQL_PARAM_UNUSED)
-          cerr << "unused";
-        else if (status_[i] == SQL_PARAM_DIAG_UNAVAILABLE)
-          cerr << "unavailable";
-        else
-          cerr << "?";
-
-        cerr << endl;
-      }
-
       if (n == 1) // Note: not n_!
         fetch (SQL_SUCCESS); // Non-batch case.
       else
@@ -1196,7 +1212,7 @@ namespace odb
       //
       if (result_ && (returning_id_ || returning_version_))
       {
-        if (batch_)
+        if (text_batch_)
         {
           r = SQLMoreResults (stmt_);
 
@@ -1237,13 +1253,21 @@ namespace odb
       //
       if (i != i_)
       {
+        // Multiple exceptions cannot be NULL since this is a batch.
+        //
+        mex_->current (++i_);
+
         // Only in case of the OUTPUT clause do we have multiple result sets.
         //
         if (returning_id_ || returning_version_)
         {
           r = SQLMoreResults (stmt_);
 
-          cerr << "more [" << (i_ + 1) << "] " << status_[i_ + 1] << " "
+          // The actually processed count could have changed (see execute()).
+          //
+          mex_->attempted (processed_);
+
+          cerr << "more [" << (i_) << "] " << status_[i_] << " "
                << SQL_SUCCEEDED (r) << endl;
 
           cerr << "more processed: " << processed_ << endl;
@@ -1255,15 +1279,8 @@ namespace odb
               "?????",
               "multiple result sets expected from an array of parameters");
           }
-
-          // The actually processed count could have changed (see execute()).
-          // Multiple exceptions cannot be NULL since this is a batch.
-          //
-          mex_->attempted (processed_);
         }
 
-        mex_->current (++i_);
-
         fetch (status_[i_] == SQL_PARAM_SUCCESS ||
                status_[i_] == SQL_PARAM_SUCCESS_WITH_INFO
                ? SQL_SUCCESS : SQL_ERROR);
@@ -1412,9 +1429,10 @@ 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.skip, param.status)
     {
       bind_param (param.bind, param.count);
     }
@@ -1424,14 +1442,128 @@ namespace odb
                       const char* text,
                       binding& param,
                       bool copy_text)
-        : statement (conn,
-                     text, statement_delete,
-                     0, false,
-                     copy_text)
+        : bulk_statement (conn,
+                          text, statement_delete,
+                          0, false,
+                          param.batch, param.skip, param.status,
+                          copy_text)
     {
       bind_param (param.bind, param.count);
     }
 
+    size_t delete_statement::
+    execute (size_t n, multiple_exceptions* mex)
+    {
+      /*
+        @@ ??
+
+      // The batch INSERT works in two different ways, depending on
+      // whether we have the OUTPUT clause. If there is no OUTPUT,
+      // then all the rows are processed inside the SQLExecute()
+      // call. If, however, there is OUTPUT, then the rows are
+      // processed one at a time as we consume the results with
+      // the SQLMoreResults() call below. Thus we in effect have
+      // two counts: the "processed so far" as set by the API
+      // (SQL_ATTR_PARAMS_PROCESSED_PTR) and the "to be processed"
+      // (value in n_). Note that in the OUTPUT case if there is an
+      // error, the processed count seems to jump by 2 for some reason.
+      //
+      */
+
+      SQLRETURN r (bulk_statement::execute (n, mex));
+
+      // Statement failed as a whole, assume only one row was attempted.
+      //
+      if (!SQL_SUCCEEDED (r))
+      {
+        fetch (r);
+        return n_;
+      }
+
+      if (n == 1) // Note: not n_!
+        fetch (SQL_SUCCESS); // Non-batch case.
+      else
+        fetch (status_[i_] == SQL_PARAM_SUCCESS ||
+               status_[i_] == SQL_PARAM_SUCCESS_WITH_INFO
+               ? SQL_SUCCESS : SQL_ERROR);
+
+      return n_;
+    }
+
+    void delete_statement::
+    fetch (SQLRETURN r)
+    {
+      /*
+        @@
+
+      // SQL_NO_DATA indicates that the statement hasn't affected any rows.
+      //
+      if (r == SQL_NO_DATA)
+        return 0;
+
+      */
+
+      if (SQL_SUCCEEDED (r))
+      {
+        // Get the number of affected rows.
+        //
+        SQLLEN rows;
+        r = SQLRowCount (stmt_, &rows);
+
+        if (!SQL_SUCCEEDED (r))
+          translate_error (r, conn_, stmt_);
+
+        cerr << "fetch: " << rows << endl;
+
+        result_ = static_cast<unsigned long long> (rows);
+      }
+      else
+        translate_error (r, conn_, stmt_, i_, mex_); // Can return.
+    }
+
+    unsigned long long delete_statement::
+    result (size_t i)
+    {
+      assert ((i_ == i || i_ + 1 == i) && i < n_);
+
+      SQLRETURN r;
+
+      // Get to the next result set if necessary.
+      //
+      if (i != i_)
+      {
+        // Multiple exceptions cannot be NULL since this is a batch.
+        //
+        mex_->current (++i_);
+
+        r = SQLMoreResults (stmt_);
+
+        // The actually processed count could have changed (see execute()).
+        //
+        mex_->attempted (processed_);
+
+        cerr << "more [" << (i_) << "] " << status_[i_] << " "
+             << SQL_SUCCEEDED (r) << " " << (r == SQL_NO_DATA) << endl;
+
+        cerr << "more processed: " << processed_ << endl;
+
+        if (r == SQL_NO_DATA)
+        {
+          throw database_exception (
+            0,
+            "?????",
+            "multiple result sets expected from an array of parameters");
+        }
+
+        fetch (status_[i_] == SQL_PARAM_SUCCESS ||
+               status_[i_] == SQL_PARAM_SUCCESS_WITH_INFO
+               ? SQL_SUCCESS : SQL_ERROR);
+      }
+
+      return result_;
+    }
+
+    /*
     unsigned long long delete_statement::
     execute ()
     {
@@ -1455,5 +1587,6 @@ namespace odb
 
       return static_cast<unsigned long long> (rows);
     }
+    */
   }
 }
diff --git a/odb/mssql/statement.hxx b/odb/mssql/statement.hxx
index 69d144b..8da71c2 100644
--- a/odb/mssql/statement.hxx
+++ b/odb/mssql/statement.hxx
@@ -97,8 +97,7 @@ namespace odb
 
     protected:
       void
-      bind_param (bind*, std::size_t count,
-                  std::size_t skip = 0, SQLUSMALLINT* status = 0);
+      bind_param (bind*, std::size_t count);
 
       // Return the actual number of columns bound.
       //
@@ -126,10 +125,46 @@ namespace odb
       std::string text_copy_;
       const char* text_;
       auto_handle<SQL_HANDLE_STMT> stmt_;
+    };
+
+    class LIBODB_MSSQL_EXPORT bulk_statement: public statement
+    {
+    public:
+      virtual
+      ~bulk_statement () = 0;
+
+      bulk_statement (connection_type&,
+                      const std::string& text,
+                      statement_kind,
+                      const binding* process,
+                      bool optimize,
+                      std::size_t batch,
+                      std::size_t skip,
+                      SQLUSMALLINT* status);
+
+      bulk_statement (connection_type&,
+                      const char* text,
+                      statement_kind,
+                      const binding* process,
+                      bool optimize,
+                      std::size_t batch,
+                      std::size_t skip,
+                      SQLUSMALLINT* status,
+                      bool copy_text);
 
-      std::size_t param_skip_; // If 0, no batch is used.
-      SQLULEN processed_; // Number of batch rows processed.
-                          // @@ TODO could be local var in execute()? Nop.
+      SQLRETURN
+      execute (std::size_t n, multiple_exceptions*);
+
+    private:
+      void
+      init (std::size_t skip);
+
+    protected:
+      SQLULEN processed_;    // Number of batch rows processed so far.
+      SQLUSMALLINT* status_; // Row status array.
+      std::size_t n_;        // Actual batch size.
+      std::size_t i_;        // Position in result.
+      multiple_exceptions* mex_;
     };
 
     class LIBODB_MSSQL_EXPORT select_statement: public statement
@@ -242,7 +277,7 @@ namespace odb
       select_statement* s_;
     };
 
-    class LIBODB_MSSQL_EXPORT insert_statement: public statement
+    class LIBODB_MSSQL_EXPORT insert_statement: public bulk_statement
     {
     public:
       virtual
@@ -290,12 +325,8 @@ namespace odb
     private:
       bool returning_id_;
       bool returning_version_;
-      bool batch_;
+      bool text_batch_;
 
-      multiple_exceptions* mex_;
-      std::size_t n_; // Batch size.
-      std::size_t i_; // Position in result.
-      SQLUSMALLINT* status_; // @@ TODO: move to statement?
       bool result_;
     };
 
@@ -339,7 +370,7 @@ namespace odb
       SQLLEN version_size_ind_;
     };
 
-    class LIBODB_MSSQL_EXPORT delete_statement: public statement
+    class LIBODB_MSSQL_EXPORT delete_statement: public bulk_statement
     {
     public:
       virtual
@@ -354,12 +385,27 @@ namespace odb
                         binding& param,
                         bool copy_text = true);
 
+      // Return the number of parameter rows (out of n) that were attempted.
+      //
+      std::size_t
+      execute (std::size_t n = 1, multiple_exceptions* = 0);
+
+      // Return the number of rows affected (deleted) by the parameter
+      // row. Errors are reported by throwing exceptions.
+      //
       unsigned long long
-      execute ();
+      result (std::size_t i = 0);
 
     private:
       delete_statement (const delete_statement&);
       delete_statement& operator= (const delete_statement&);
+
+    private:
+      void
+      fetch (SQLRETURN);
+
+    private:
+      unsigned long long result_;
     };
   }
 }
diff --git a/odb/mssql/statement.ixx b/odb/mssql/statement.ixx
index b2c091e..66316f4 100644
--- a/odb/mssql/statement.ixx
+++ b/odb/mssql/statement.ixx
@@ -6,6 +6,39 @@ namespace odb
 {
   namespace mssql
   {
+    inline bulk_statement::
+    bulk_statement (connection_type& c,
+                    const std::string& text,
+                    statement_kind k,
+                    const binding* process,
+                    bool optimize,
+                    std::size_t batch,
+                    std::size_t skip,
+                    SQLUSMALLINT* status)
+        : statement (c, text, k, process, optimize),
+          status_ (batch == 1 ? 0 : status)
+    {
+      if (batch != 1)
+        init (skip);
+    }
+
+    inline bulk_statement::
+    bulk_statement (connection_type& c,
+                    const char* text,
+                    statement_kind k,
+                    const binding* process,
+                    bool optimize,
+                    std::size_t batch,
+                    std::size_t skip,
+                    SQLUSMALLINT* status,
+                    bool copy_text)
+        : statement (c, text, k, process, optimize, copy_text),
+          status_ (batch == 1 ? 0 : status)
+    {
+      if (batch != 1)
+        init (skip);
+    }
+
     inline unsigned long long update_statement::
     version ()
     {