Merge remote-tracking branch 'origin/master' into wl11451-jdbc

Author: rsomla1

common/op_impl.h

@@ -1042,7 +1042,9 @@ struct Op_admin
   They are implemented as Op_trx template parametrized by operation type.
 */
 
-enum class Trx_op { BEGIN, COMMIT, ROLLBACK };
+enum class Trx_op {
+  BEGIN, COMMIT, ROLLBACK, SAVEPOINT_SET, SAVEPOINT_REMOVE
+};
 
 
 template <Trx_op>
@@ -1078,13 +1080,96 @@ cdk::Reply* Op_trx<Trx_op::COMMIT>::send_command()
   return nullptr;
 }
 
+
+struct Op_trx_savepoint
+  : public Op_base<common::Executable_if>
+{
+  using string = cdk::string;
+
+  string m_name;
+
+  Op_trx_savepoint(Shared_session_impl sess, const string &name = string())
+    : Op_base(sess), m_name(name)
+  {}
+};
+
+
 template<>
-inline
-cdk::Reply* Op_trx<Trx_op::ROLLBACK>::send_command()
+struct Op_trx<Trx_op::ROLLBACK>
+  : public Op_trx_savepoint
 {
-  get_cdk_session().rollback();
-  return nullptr;
-}
+  using Op_trx_savepoint::Op_trx_savepoint;
+
+  cdk::Reply* send_command() override
+  {
+    get_cdk_session().rollback(m_name);
+    return nullptr;
+  }
+
+  Executable_if* clone() const override
+  {
+    return new Op_trx(*this);
+  }
+};
+
+
+template<>
+struct Op_trx<Trx_op::SAVEPOINT_SET>
+  : public Op_trx_savepoint
+{
+  Op_trx(Shared_session_impl sess, const string &name)
+    : Op_trx_savepoint(sess, name)
+  {
+    if (!name.empty())
+      return;
+
+    // Generate savepoint name.
+
+    std::wstringstream savepoint;
+    savepoint << L"SP" << sess->next_savepoint();
+    m_name = savepoint.str();
+  }
+
+  cdk::Reply* send_command() override
+  {
+    get_cdk_session().savepoint_set(m_name);
+    return nullptr;
+  }
+
+  const string& get_name() const
+  {
+    return m_name;
+  }
+
+  Executable_if* clone() const override
+  {
+    return new Op_trx(*this);
+  }
+};
+
+
+template<>
+struct Op_trx<Trx_op::SAVEPOINT_REMOVE>
+  : public Op_trx_savepoint
+{
+  Op_trx(Shared_session_impl sess, const string &name)
+    : Op_trx_savepoint(sess, name)
+  {
+    if (name.empty())
+      throw_error("Invalid empty save point name");
+  }
+
+  cdk::Reply* send_command() override
+  {
+    get_cdk_session().savepoint_remove(m_name);
+    return nullptr;
+  }
+
+  Executable_if* clone() const override
+  {
+    return new Op_trx(*this);
+  }
+};
 
 
 // ----------------------------------------------------------------------

common/session.h

@@ -106,6 +106,12 @@ class Session_impl
 
   void prepare_for_cmd();
 
+  unsigned long m_savepoint = 0;
+
+  unsigned long next_savepoint()
+  {
+    return ++m_savepoint;
+  }
 };
 
 

devapi/session.cc

@@ -150,28 +150,35 @@ void internal::Session_detail::close()
 
 void internal::Session_detail::start_transaction()
 {
-  try {
-    get_cdk_session().begin();
-  }
-  CATCH_AND_WRAP
+  common::Op_trx<common::Trx_op::BEGIN> cmd(m_impl);
+  cmd.execute();
 }
 
 
 void internal::Session_detail::commit()
 {
-  try {
-    get_cdk_session().commit();
-  }
-  CATCH_AND_WRAP
+  common::Op_trx<common::Trx_op::COMMIT> cmd(m_impl);
+  cmd.execute();
 }
 
 
-void internal::Session_detail::rollback()
+void internal::Session_detail::rollback(const string &sp)
 {
-  try {
-    get_cdk_session().rollback();
-  }
-  CATCH_AND_WRAP
+  common::Op_trx<common::Trx_op::ROLLBACK> cmd(m_impl, sp);
+  cmd.execute();
+}
+
+string internal::Session_detail::savepoint_set(const string &sp)
+{
+  common::Op_trx<common::Trx_op::SAVEPOINT_SET> cmd(m_impl, sp);
+  cmd.execute();
+  return cmd.get_name();
+}
+
+void internal::Session_detail::savepoint_remove(const string &sp)
+{
+  common::Op_trx<common::Trx_op::SAVEPOINT_REMOVE> cmd(m_impl, sp);
+  cmd.execute();
 }
 
 

devapi/tests/bugs-t.cc

@@ -109,3 +109,28 @@ TEST_F(Bugs, bug26130226_crash_update)
     tabNew.update().set((char *)0, expr("")).execute(), // SegFault
     Error);
 }
+
+TEST_F(Bugs, bug_26962725_double_bind)
+{
+  get_sess().dropSchema("bug_26962725_double_bind");
+  Schema db = get_sess().createSchema("bug_26962725_double_bind");
+  /// Collection.find() function with fixed values
+
+  db.dropCollection("my_collection");
+  Collection myColl = db.createCollection("my_collection");
+
+  myColl.add(R"({"name":"mike", "age":39})")
+        .add(R"({"name":"johannes", "age":28})")
+        .execute();
+
+  EXPECT_EQ(2, myColl.find().execute().count());
+
+  // Create Collection.remove() operation, but do not run it yet
+  auto myRemove = myColl.remove("name = :param1 AND age = :param2");
+
+  // Binding parameters to the prepared function and .execute()
+  myRemove.bind("param1", "mike").bind("param2", 39).execute();
+  myRemove.bind("param1", "johannes").bind("param2", 28).execute();
+
+  EXPECT_EQ(0, myColl.find().execute().count());
+}

devapi/tests/session-t.cc

@@ -262,6 +262,37 @@ TEST_F(Sess, trx)
     EXPECT_FALSE(doc.hasField("bar"));
   }
 
+  //With Savepoints!
+
+  get_sess().startTransaction();
+
+  std::vector<string> savepoints;
+
+  coll.add("{\"bar\": 5}").execute();
+  savepoints.emplace_back(get_sess().setSavepoint()); //savepoints[0]
+  coll.add("{\"bar\": 6}").execute();
+  savepoints.emplace_back(get_sess().setSavepoint()); //savepoints[1]
+  coll.add("{\"bar\": 7}").execute();
+  savepoints.emplace_back(get_sess().setSavepoint()); //savepoints[2]
+  coll.add("{\"bar\": 8}").execute();
+  savepoints.emplace_back(get_sess().setSavepoint("MySave")); //savepoints[3]
+
+  get_sess().releaseSavepoint("MySave");
+  EXPECT_THROW(get_sess().releaseSavepoint(savepoints.back()), Error);
+  savepoints.pop_back();
+  // rollback to bar:6
+  get_sess().rollbackTo(savepoints[1]);
+  //savepoint of bar:7 was removed because of the rollback to bar:6
+  EXPECT_THROW(get_sess().rollbackTo(savepoints[2]), Error);
+  EXPECT_THROW(get_sess().rollbackTo(""), Error);
+  get_sess().rollbackTo(savepoints.front());
+  get_sess().commit();
+
+  cout << "Collection has " << coll.count()
+    << " documents." << endl;
+
+  EXPECT_EQ(3U, coll.count());
+
   cout << "Done!" << endl;
 }
 

include/mysqlx/devapi/detail/session.h

@@ -317,7 +317,9 @@ struct PUBLIC_API Session_detail
 
   void start_transaction();
   void commit();
-  void rollback();
+  void rollback(const string &sp = string());
+  string savepoint_set(const string &sp = string());
+  void savepoint_remove(const string&);
 
 
   common::Session_impl& get_impl()

include/mysqlx/xapi.h

@@ -731,7 +731,7 @@ mysqlx_transaction_commit(mysqlx_session_t *sess);
 
 
 /**
-  Rollback a transaction for the session.
+  Roll back a transaction for the session.
 
   @param sess session handle
 
@@ -748,6 +748,61 @@ PUBLIC_API int
 mysqlx_transaction_rollback(mysqlx_session_t *sess);
 
 
+/**
+  Create savepoint inside transaction.
+
+  @param sess session handle.
+
+  @param name savepoint name (NULL for automatically generated one)
+
+  @return savepoint name
+
+  @note Savepoints are created inside transaction! Later, you can roll back
+  the transaction to a created savepoint using mysqlx_rollback_to().
+  If the current transaction has a savepoint with the same name, the old
+  savepoint is deleted and a new one is set.
+
+  @ingroup xapi_sess
+*/
+
+PUBLIC_API const char*
+mysqlx_savepoint_set( mysqlx_session_t *sess, const char *name);
+
+
+/**
+  Release savepoint created by mysqlx_savepoint_set().
+
+  @param sess session handle
+
+  @param name savepoint name to be released
+
+  @return `RESULT_OK` - savepoint exists and is released;
+          `RESULT_ERR` - on error
+
+  @ingroup xapi_sess
+*/
+
+PUBLIC_API int
+mysqlx_savepoint_release(mysqlx_session_t *sess, const char *name);
+
+
+/**
+  Roll back to savepoint created by mysqlx_savepoint_set().
+
+  @param sess session handle.
+
+  @param name savepoint name.
+
+  @return `RESULT_OK` - savepoint exists and is released;
+          `RESULT_ERR` - on error.
+
+  @ingroup xapi_sess
+*/
+
+PUBLIC_API int
+mysqlx_rollback_to(  mysqlx_session_t *sess, const char *name);
+
+
 /**
   Allocate a new session configuration data object.