Move do to client class

Author: andyundso

ext/tiny_tds/client.c

@@ -61,22 +61,6 @@ static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata)
   userdata->nonblocking_errors_size = 0;
 }
 
-static VALUE rb_tinytds_send_sql_to_server(tinytds_client_wrapper *cwrap, VALUE sql) {
-  rb_tinytds_client_reset_userdata(cwrap->userdata);
-
-  if (cwrap->closed || cwrap->userdata->closed) { \
-    rb_raise(cTinyTdsError, "closed connection"); \
-    return Qnil; \
-  }
-
-  dbcmd(cwrap->client, StringValueCStr(sql));
-  if (dbsqlsend(cwrap->client) == FAIL) {
-    rb_raise(cTinyTdsError, "failed dbsqlsend() function");
-  }
-
-  cwrap->userdata->dbsql_sent = 1;
-}
-
 // code part used to invoke FreeTDS functions with releasing the Ruby GVL
 // basically, while FreeTDS is interacting with the SQL server, other Ruby code can be executed
 #define NOGVL_DBCALL(_dbfunction, _client) ( \
@@ -164,14 +148,55 @@ static RETCODE nogvl_dbsqlok(DBPROCESS *client) {
   return retcode;
 }
 
-static RETCODE rb_tinytds_result_ok_helper(DBPROCESS *client) {
+// some additional helpers interacting with the SQL server
+static VALUE rb_tinytds_send_sql_to_server(tinytds_client_wrapper *cwrap, VALUE sql) {
+  rb_tinytds_client_reset_userdata(cwrap->userdata);
+
+  if (cwrap->closed || cwrap->userdata->closed) { \
+    rb_raise(cTinyTdsError, "closed connection"); \
+    return Qnil; \
+  }
+
+  dbcmd(cwrap->client, StringValueCStr(sql));
+  if (dbsqlsend(cwrap->client) == FAIL) {
+    rb_raise(cTinyTdsError, "failed dbsqlsend() function");
+  }
+
+  cwrap->userdata->dbsql_sent = 1;
+}
+
+static RETCODE rb_tiny_tds_client_ok_helper(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   if (userdata->dbsqlok_sent == 0) {
     userdata->dbsqlok_retcode = nogvl_dbsqlok(client);
   }
+
   return userdata->dbsqlok_retcode;
 }
 
+static void rb_tinytds_result_exec_helper(DBPROCESS *client) {
+  RETCODE dbsqlok_rc = rb_tiny_tds_client_ok_helper(client);
+  GET_CLIENT_USERDATA(client);
+  if (dbsqlok_rc == SUCCEED) {
+    /*
+    This is to just process each result set. Commands such as backup and
+    restore are not done when the first result set is returned, so we need to
+    exhaust the result sets before it is complete.
+    */
+    while (nogvl_dbresults(client) == SUCCEED) {
+      /*
+      If we don't loop through each row for calls to TinyTds::Client.do that
+      actually do return result sets, we will trigger error 20019 about trying
+      to execute a new command with pending results. Oh well.
+      */
+      while (dbnextrow(client) != NO_MORE_ROWS);
+    }
+  }
+  dbcancel(client);
+  userdata->dbcancel_sent = 1;
+  userdata->dbsql_sent = 0;
+}
+
 // Lib Backend (Memory Management & Handlers)
 static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
   // reallocate memory for the array as needed
@@ -414,23 +439,7 @@ static VALUE rb_tiny_tds_insert(VALUE self, VALUE sql) {
   VALUE identity = Qnil;
   GET_CLIENT_WRAPPER(self);  
   rb_tinytds_send_sql_to_server(cwrap, sql);
-
-  RETCODE dbsqlok_rc = rb_tinytds_result_ok_helper(cwrap->client);
-  if (dbsqlok_rc == SUCCEED) {
-    /*
-    This is to just process each result set. Commands such as backup and
-    restore are not done when the first result set is returned, so we need to
-    exhaust the result sets before it is complete.
-    */
-    while (nogvl_dbresults(cwrap->client) == SUCCEED) {
-      /*
-      If we don't loop through each row for calls to TinyTds::Result.do that
-      actually do return result sets, we will trigger error 20019 about trying
-      to execute a new command with pending results. Oh well.
-      */
-      while (nogvl_dbnextrow(cwrap->client) != NO_MORE_ROWS);
-    }
-  }
+  rb_tinytds_result_exec_helper(cwrap->client);
 
   dbcancel(cwrap->client);
   cwrap->userdata->dbcancel_sent = 1;
@@ -459,6 +468,14 @@ static VALUE rb_tiny_tds_insert(VALUE self, VALUE sql) {
   return identity;
 }
 
+static VALUE rb_tiny_tds_do(VALUE self, VALUE sql) {
+  GET_CLIENT_WRAPPER(self);  
+  rb_tinytds_send_sql_to_server(cwrap, sql);
+  rb_tinytds_result_exec_helper(cwrap->client);
+
+  return LONG2NUM((long)dbcount(cwrap->client));
+}
+
 static VALUE rb_tinytds_charset(VALUE self) {
   GET_CLIENT_WRAPPER(self);
   return cwrap->charset;
@@ -599,6 +616,7 @@ void init_tinytds_client() {
   rb_define_method(cTinyTdsClient, "sqlsent?", rb_tinytds_sqlsent, 0);
   rb_define_method(cTinyTdsClient, "execute", rb_tinytds_execute, 1);
   rb_define_method(cTinyTdsClient, "insert", rb_tiny_tds_insert, 1);
+  rb_define_method(cTinyTdsClient, "do", rb_tiny_tds_do, 1);
   rb_define_method(cTinyTdsClient, "charset", rb_tinytds_charset, 0);
   rb_define_method(cTinyTdsClient, "encoding", rb_tinytds_encoding, 0);
   rb_define_method(cTinyTdsClient, "escape", rb_tinytds_escape, 1);

ext/tiny_tds/result.c

@@ -173,29 +173,6 @@ static RETCODE rb_tinytds_result_ok_helper(DBPROCESS *client) {
   return userdata->dbsqlok_retcode;
 }
 
-static void rb_tinytds_result_exec_helper(DBPROCESS *client) {
-  RETCODE dbsqlok_rc = rb_tinytds_result_ok_helper(client);
-  GET_CLIENT_USERDATA(client);
-  if (dbsqlok_rc == SUCCEED) {
-    /*
-    This is to just process each result set. Commands such as backup and
-    restore are not done when the first result set is returned, so we need to
-    exhaust the result sets before it is complete.
-    */
-    while (nogvl_dbresults(client) == SUCCEED) {
-      /*
-      If we don't loop through each row for calls to TinyTds::Result.do that
-      actually do return result sets, we will trigger error 20019 about trying
-      to execute a new command with pending results. Oh well.
-      */
-      while (dbnextrow(client) != NO_MORE_ROWS);
-    }
-  }
-  dbcancel(client);
-  userdata->dbcancel_sent = 1;
-  userdata->dbsql_sent = 0;
-}
-
 static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_keys, int as_array) {
   VALUE row;
   /* Storing Values */
@@ -506,16 +483,6 @@ static VALUE rb_tinytds_result_cancel(VALUE self) {
   return Qtrue;
 }
 
-static VALUE rb_tinytds_result_do(VALUE self) {
-  GET_RESULT_WRAPPER(self);
-  if (rwrap->client) {
-    rb_tinytds_result_exec_helper(rwrap->client);
-    return LONG2NUM((long)dbcount(rwrap->client));
-  } else {
-    return Qnil;
-  }
-}
-
 static VALUE rb_tinytds_result_affected_rows(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client) {
@@ -548,7 +515,6 @@ void init_tinytds_result() {
   rb_define_method(cTinyTdsResult, "fields", rb_tinytds_result_fields, 0);
   rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1);
   rb_define_method(cTinyTdsResult, "cancel", rb_tinytds_result_cancel, 0);
-  rb_define_method(cTinyTdsResult, "do", rb_tinytds_result_do, 0);
   rb_define_method(cTinyTdsResult, "affected_rows", rb_tinytds_result_affected_rows, 0);
   rb_define_method(cTinyTdsResult, "return_code", rb_tinytds_result_return_code, 0);
   /* Intern String Helpers */

test/client_test.rb

@@ -98,7 +98,7 @@ class ClientTest < TinyTds::TestCase
 
     it 'raises TinyTds exception with long query past :timeout option' do
       client = new_connection :timeout => 1
-      action = lambda { client.execute("WaitFor Delay '00:00:02'").do }
+      action = lambda { client.do("WaitFor Delay '00:00:02'") }
       assert_raise_tinytds_error(action) do |e|
         assert_equal 20003, e.db_error_number
         assert_equal 6, e.severity
@@ -111,21 +111,21 @@ class ClientTest < TinyTds::TestCase
 
     it 'must not timeout per sql batch when not under transaction' do
       client = new_connection :timeout => 2
-      client.execute("WaitFor Delay '00:00:01'").do
-      client.execute("WaitFor Delay '00:00:01'").do
-      client.execute("WaitFor Delay '00:00:01'").do
+      client.do("WaitFor Delay '00:00:01'")
+      client.do("WaitFor Delay '00:00:01'")
+      client.do("WaitFor Delay '00:00:01'")
       close_client(client)
     end
 
     it 'must not timeout per sql batch when under transaction' do
       client = new_connection :timeout => 2
       begin
-        client.execute("BEGIN TRANSACTION").do
-        client.execute("WaitFor Delay '00:00:01'").do
-        client.execute("WaitFor Delay '00:00:01'").do
-        client.execute("WaitFor Delay '00:00:01'").do
+        client.do("BEGIN TRANSACTION")
+        client.do("WaitFor Delay '00:00:01'")
+        client.do("WaitFor Delay '00:00:01'")
+        client.do("WaitFor Delay '00:00:01'")
       ensure
-        client.execute("COMMIT TRANSACTION").do
+        client.do("COMMIT TRANSACTION")
         close_client(client)
       end
     end
@@ -134,7 +134,7 @@ class ClientTest < TinyTds::TestCase
       begin
         client = new_connection timeout: 2, port: 1234, host: ENV['TOXIPROXY_HOST']
         assert_client_works(client)
-        action = lambda { client.execute("waitfor delay '00:00:05'").do }
+        action = lambda { client.do("waitfor delay '00:00:05'") }
 
         # Use toxiproxy to close the TCP socket after 1 second.
         # We want TinyTds to execute the statement, hit the timeout configured above, and then not be able to use the network to cancel
@@ -157,7 +157,7 @@ class ClientTest < TinyTds::TestCase
       begin
         client = new_connection timeout: 2, port: 1234, host: ENV['TOXIPROXY_HOST']
         assert_client_works(client)
-        action = lambda { client.execute("waitfor delay '00:00:05'").do }
+        action = lambda { client.do("waitfor delay '00:00:05'") }
 
         # Use toxiproxy to close the network connection after 1 second.
         # We want TinyTds to execute the statement, hit the timeout configured above, and then not be able to use the network to cancel
@@ -278,8 +278,8 @@ class ClientTest < TinyTds::TestCase
     it 'has an #insert method that cancels result rows and returns IDENTITY natively' do
       rollback_transaction(@client) do
         text = 'test scope identity rows native'
-        @client.execute("DELETE FROM [datatypes] WHERE [varchar_50] = '#{text}'").do
-        @client.execute("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')").do
+        @client.do("DELETE FROM [datatypes] WHERE [varchar_50] = '#{text}'")
+        @client.do("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')")
         sql_identity = @client.execute(@client.identity_sql).each.first['Ident']
         native_identity = @client.insert("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')")
 
@@ -295,12 +295,12 @@ class ClientTest < TinyTds::TestCase
 
       rollback_transaction(@client) do
         seed = 9223372036854775805
-        @client.execute("DELETE FROM [datatypes]").do
+        @client.do("DELETE FROM [datatypes]")
         id_constraint_name = @client.execute("EXEC sp_helpindex [datatypes]").detect { |row| row['index_keys'] == 'id' }['index_name']
-        @client.execute("ALTER TABLE [datatypes] DROP CONSTRAINT [#{id_constraint_name}]").do
-        @client.execute("ALTER TABLE [datatypes] DROP COLUMN [id]").do
-        @client.execute("ALTER TABLE [datatypes] ADD [id] [bigint] NOT NULL IDENTITY(1,1) PRIMARY KEY").do
-        @client.execute("DBCC CHECKIDENT ('datatypes', RESEED, #{seed})").do
+        @client.do("ALTER TABLE [datatypes] DROP CONSTRAINT [#{id_constraint_name}]")
+        @client.do("ALTER TABLE [datatypes] DROP COLUMN [id]")
+        @client.do("ALTER TABLE [datatypes] ADD [id] [bigint] NOT NULL IDENTITY(1,1) PRIMARY KEY")
+        @client.do("DBCC CHECKIDENT ('datatypes', RESEED, #{seed})")
         identity = @client.insert("INSERT INTO [datatypes] ([varchar_50]) VALUES ('something')")
 
         assert_equal(seed, identity)
@@ -318,4 +318,35 @@ class ClientTest < TinyTds::TestCase
       end
     end
   end
+
+  describe "#do" do
+    before do
+      @client = new_connection
+    end
+
+    it 'has a #do method that cancels result rows and returns affected rows natively' do
+      rollback_transaction(@client) do
+        text = 'test affected rows native'
+        count = @client.execute("SELECT COUNT(*) AS [count] FROM [datatypes]").each.first['count']
+        deleted_rows = @client.do("DELETE FROM [datatypes]")
+        assert_equal count, deleted_rows, 'should have deleted rows equal to count'
+        inserted_rows = @client.do("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')")
+        assert_equal 1, inserted_rows, 'should have inserted row for one above'
+        updated_rows = @client.do("UPDATE [datatypes] SET [varchar_50] = NULL WHERE [varchar_50] = '#{text}'")
+        assert_equal 1, updated_rows, 'should have updated row for one above'
+      end
+    end
+
+    it 'allows native affected rows using #do to work under transaction' do
+      rollback_transaction(@client) do
+        text = 'test affected rows native in transaction'
+        @client.do("BEGIN TRANSACTION")
+        @client.do("DELETE FROM [datatypes]")
+        inserted_rows = @client.do("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')")
+        assert_equal 1, inserted_rows, 'should have inserted row for one above'
+        updated_rows = @client.do("UPDATE [datatypes] SET [varchar_50] = NULL WHERE [varchar_50] = '#{text}'")
+        assert_equal 1, updated_rows, 'should have updated row for one above'
+      end
+    end
+  end
 end