Complete initial bulk erase() implementation

3 files changed, 114 insertions, 116 deletions

diff --git a/odb/mssql/simple-object-statements.hxx b/odb/mssql/simple-object-statements.hxx
index efd52f0..7c5c868 100644
--- a/odb/mssql/simple-object-statements.hxx
+++ b/odb/mssql/simple-object-statements.hxx
@@ -405,6 +405,7 @@ namespace odb
               conn_,
               object_traits::erase_statement,
               id_image_binding_,
+              true, // Unique (0 or 1 affected rows).
               false));
 
         return *erase_;
@@ -420,6 +421,7 @@ namespace odb
               conn_,
               object_traits::optimistic_erase_statement,
               od_.id_image_binding_,
+              true, // Unique (0 or 1 affected rows).
               false));
         }
 
diff --git a/odb/mssql/statement.cxx b/odb/mssql/statement.cxx
index 12fc21c..e49627c 100644
--- a/odb/mssql/statement.cxx
+++ b/odb/mssql/statement.cxx
@@ -728,7 +728,7 @@ namespace odb
     init (size_t skip)
     {
       // Setup row-wise batch operation. We set the actual number of
-      // rows in the batch in execute().
+      // parameter sets in the batch in execute().
       //
       SQLRETURN r;
 
@@ -780,14 +780,15 @@ namespace odb
 
       processed_ = 0;
       SQLRETURN r (statement::execute ());
+      bool ok (SQL_SUCCEEDED (r) || r == SQL_NO_DATA);
 
-      // 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.
+      // If the statement failed as a whole, assume no parameter sets
+      // were attempted. Otherwise, the documentation says that the
+      // native client driver keeps processing remaining sets even
+      // in case of an error.
       //
       i_ = 0;
-      n_ = (SQL_SUCCEEDED (r) ? n : 1);
+      n_ = (ok ? n : 0);
 
       if (mex_ != 0)
       {
@@ -795,7 +796,7 @@ namespace odb
         mex_->attempted (processed_);
       }
 
-      if (!SQL_SUCCEEDED (r))
+      if (!ok)
       {
         if (mex_ != 0)
           mex_->fatal (true); // An incomplete batch is always fatal.
@@ -1074,9 +1075,9 @@ namespace odb
     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
+      // whether we have the OUTPUT clause. If there is no OUTPUT, then
+      // all the parameter sets are processed inside the SQLExecute()
+      // call. If, however, there is OUTPUT, then the sets 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
@@ -1086,7 +1087,8 @@ namespace odb
       //
       SQLRETURN r (bulk_statement::execute (n, mex));
 
-      // Statement failed as a whole, assume only one row was attempted.
+      // Statement failed as a whole, assume no parameter sets were
+      // attempted.
       //
       if (!SQL_SUCCEEDED (r))
       {
@@ -1094,7 +1096,7 @@ namespace odb
         return n_;
       }
 
-      if (n == 1) // Note: not n_!
+      if (n == 1) // Note: not n_; n and n_ not be the same, see command above.
         fetch (SQL_SUCCESS); // Non-batch case.
       else
         fetch (status_[i_] == SQL_PARAM_SUCCESS ||
@@ -1253,9 +1255,7 @@ namespace odb
       //
       if (i != i_)
       {
-        // Multiple exceptions cannot be NULL since this is a batch.
-        //
-        mex_->current (++i_);
+        mex_->current (++i_); // mex cannot be NULL since this is a batch.
 
         // Only in case of the OUTPUT clause do we have multiple result sets.
         //
@@ -1428,11 +1428,13 @@ namespace odb
     delete_statement::
     delete_statement (connection_type& conn,
                       const string& text,
-                      binding& param)
+                      binding& param,
+                      bool unique)
         : bulk_statement (conn,
                           text, statement_delete,
                           0, false,
-                          param.batch, param.skip, param.status)
+                          param.batch, param.skip, param.status),
+          unique_ (unique)
     {
       bind_param (param.bind, param.count);
     }
@@ -1441,12 +1443,14 @@ namespace odb
     delete_statement (connection_type& conn,
                       const char* text,
                       binding& param,
+                      bool unique,
                       bool copy_text)
         : bulk_statement (conn,
                           text, statement_delete,
                           0, false,
                           param.batch, param.skip, param.status,
-                          copy_text)
+                          copy_text),
+          unique_ (unique)
     {
       bind_param (param.bind, param.count);
     }
@@ -1454,139 +1458,101 @@ namespace odb
     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.
+      // In batch DELETE without the OUTPUT clause (which is the
+      // only kind we currently support) all the parameter sets
+      // are processed inside SQLExecute() and the total count of
+      // affected rows is available after it returns.
       //
-      */
 
       SQLRETURN r (bulk_statement::execute (n, mex));
 
-      // Statement failed as a whole, assume only one row was attempted.
+      // Statement failed as a whole, assume no parameter sets were
+      // attempted.
       //
-      if (!SQL_SUCCEEDED (r))
+      if (!(SQL_SUCCEEDED (r) || r == SQL_NO_DATA))
       {
         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.
+      // Figure out the affected row count. SQL_NO_DATA indicates that
+      // the statement hasn't affected any rows.
       //
       if (r == SQL_NO_DATA)
-        return 0;
-
-      */
-
-      if (SQL_SUCCEEDED (r))
+        result_ = 0;
+      else
       {
-        // 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;
+      cerr << "total: " << result_ << endl;
 
-      // Get to the next result set if necessary.
-      //
-      if (i != i_)
+      if (n_ > 1) // Batch.
       {
-        // 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;
+        if (result_ != 0) // Some rows did get affected.
+        {
+          size_t p (n_);
 
-        cerr << "more processed: " << processed_ << endl;
+          // Subtract the parameter sets that failed since they haven't
+          // affected any rows.
+          //
+          for (size_t i (0); i != n_; ++i)
+            if (status_[i] != SQL_PARAM_SUCCESS &&
+                status_[i] != SQL_PARAM_SUCCESS_WITH_INFO)
+              p--;
 
-        if (r == SQL_NO_DATA)
-        {
-          throw database_exception (
-            0,
-            "?????",
-            "multiple result sets expected from an array of parameters");
+          if (p > 1) // True batch.
+          {
+            if (unique_) // Each can affect 0 or 1 row.
+            {
+              result_ = (p == static_cast<size_t> (result_)
+                         ? 1
+                         : result_unknown);
+            }
+            else
+              result_ = result_unknown;
+          }
         }
+      }
 
+      if (n == 1) // n and n_ are really the same here.
+        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 result_;
+      return n_;
     }
 
-    /*
-    unsigned long long delete_statement::
-    execute ()
+    void delete_statement::
+    fetch (SQLRETURN r)
     {
-      SQLRETURN r (statement::execute ());
-
-      // SQL_NO_DATA indicates that the statement hasn't affected any rows.
-      //
-      if (r == SQL_NO_DATA)
-        return 0;
-
       if (!SQL_SUCCEEDED (r))
-        translate_error (r, conn_, stmt_);
+        translate_error (r, conn_, stmt_, i_, mex_); // Can return.
+    }
 
-      // Get the number of affected rows.
-      //
-      SQLLEN rows;
-      r = SQLRowCount (stmt_, &rows);
+    unsigned long long delete_statement::
+    result (size_t i)
+    {
+      assert ((i_ == i || i_ + 1 == i) && i < n_);
 
-      if (!SQL_SUCCEEDED (r))
-        translate_error (r, conn_, stmt_);
+      if (i != i_)
+      {
+        mex_->current (++i_); // mex cannot be NULL since this is a batch.
 
-      return static_cast<unsigned long long> (rows);
+        fetch (status_[i_] == SQL_PARAM_SUCCESS ||
+               status_[i_] == SQL_PARAM_SUCCESS_WITH_INFO
+               ? SQL_SUCCESS : SQL_ERROR);
+      }
+
+      return result_;
     }
-    */
   }
 }
diff --git a/odb/mssql/statement.hxx b/odb/mssql/statement.hxx
index 8da71c2..ea53a38 100644
--- a/odb/mssql/statement.hxx
+++ b/odb/mssql/statement.hxx
@@ -152,6 +152,11 @@ namespace odb
                       SQLUSMALLINT* status,
                       bool copy_text);
 
+      // Call SQLExecute() and set up the batch tracking variables (see
+      // below). Note that this function does not treat SQL_NO_DATA as
+      // an error since for DELETE and UPDATE statements this is a
+      // shortcut notation for zero rows affected.
+      //
       SQLRETURN
       execute (std::size_t n, multiple_exceptions*);
 
@@ -300,7 +305,7 @@ namespace odb
                         binding* returning,
                         bool copy_text = true);
 
-      // Return the number of rows (out of n) that were attempted.
+      // Return the number of parameter sets (out of n) that were attempted.
       //
       std::size_t
       execute (std::size_t n = 1, multiple_exceptions* = 0);
@@ -376,23 +381,47 @@ namespace odb
       virtual
       ~delete_statement ();
 
+      // SQL Server native client ODBC driver does not expose individual
+      // affected row counts for batch operations, even though it says it
+      // does (SQLGetInfo(SQL_PARAM_ARRAY_ROW_COUNTS) returns SQL_PARC_BATCH).
+      // 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);
+                        binding& param,
+                        bool unique_hint = false);
 
       delete_statement (connection_type& conn,
                         const char* text,
                         binding& param,
+                        bool unique_hint = false,
                         bool copy_text = true);
 
-      // Return the number of parameter rows (out of n) that were attempted.
+      // Return the number of parameter sets (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.
+      // 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.
       //
+      static const unsigned long long result_unknown = ~0ULL;
+
       unsigned long long
       result (std::size_t i = 0);
 
@@ -405,6 +434,7 @@ namespace odb
       fetch (SQLRETURN);
 
     private:
+      bool unique_;
       unsigned long long result_;
     };
   }