tiny_tds 2.1.5 → 3.2.0

data/test/sql/db-create.sql

@@ -0,0 +1,18 @@
+:ON ERROR EXIT
+
+PRINT 'RUNNING DB-CREATE.SQL, CREATING TINYTDS TEST DATABASE';
+IF NOT EXISTS(SELECT * FROM sys.databases WHERE name = 'tinytdstest')
+BEGIN
+  CREATE DATABASE [tinytdstest];
+END
+GO
+
+IF EXISTS (SELECT name FROM master.dbo.sysdatabases WHERE name LIKE 'tinytdstest')
+BEGIN
+  PRINT 'TINY TDS TEST DB SUCCESSFULY CREATED';
+END
+ELSE
+BEGIN
+  THROW 51000, 'TINY TDS TEST DB CREATION FAILED', 1;
+END
+GO

data/test/sql/db-login.sql

@@ -0,0 +1,38 @@
+:ON ERROR EXIT
+
+PRINT 'RUNNING DB-LOGIN.SQL';
+
+PRINT 'CREATING TINYTDS TEST LOGIN';
+IF NOT EXISTS (select name from sys.server_principals where name like 'tinytds')
+BEGIN
+  CREATE LOGIN [tinytds] WITH PASSWORD = '', CHECK_POLICY = OFF, DEFAULT_DATABASE = [tinytdstest];
+END
+GO
+
+IF EXISTS (select name from sys.server_principals where name like 'tinytds')
+BEGIN
+  PRINT 'TINY TDS TEST LOGIN SUCCESSFULY CREATED';
+END
+ELSE
+BEGIN
+  THROW 51000, 'TINY TDS TEST LOGIN CREATION FAILED', 1;
+END
+GO
+
+USE [tinytdstest];
+IF NOT EXISTS (select name from sys.database_principals where name LIKE 'tinytds')
+BEGIN
+  CREATE USER [tinytds] FOR LOGIN [tinytds];
+  EXEC sp_addrolemember N'db_owner', N'tinytds';
+END
+GO
+
+IF EXISTS (select name from sys.database_principals where name LIKE 'tinytds')
+BEGIN
+  PRINT 'TINY TDS TEST USER SUCCESSFULY CREATED';
+END
+ELSE
+BEGIN
+  THROW 51000, 'TINY TDS TEST USER CREATION FAILED', 1;
+END
+GO

data/test/test_helper.rb

@@ -1,30 +1,26 @@
-# encoding: UTF-8
-require 'bundler' ; Bundler.require :development, :test
-require 'tiny_tds'
-require 'minitest/autorun'
-require 'toxiproxy'
+require "bundler"
+Bundler.require :development, :test
+require "tiny_tds"
+require "minitest/autorun"
+require "toxiproxy"
 
-TINYTDS_SCHEMAS = ['sqlserver_2000', 'sqlserver_2005', 'sqlserver_2008', 'sqlserver_2014', 'sqlserver_azure', 'sybase_ase'].freeze
+require "minitest/reporters"
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new, Minitest::Reporters::JUnitReporter.new]
 
-module TinyTds
-  class TestCase < MiniTest::Spec
+TINYTDS_SCHEMAS = ["sqlserver_2017", "sqlserver_azure"].freeze
 
+module TinyTds
+  class TestCase < Minitest::Spec
     class << self
-
       def current_schema
-        ENV['TINYTDS_SCHEMA'] || 'sqlserver_2014'
+        ENV["TINYTDS_SCHEMA"] || "sqlserver_2017"
       end
 
       TINYTDS_SCHEMAS.each do |schema|
-        define_method "#{schema}?" do
-          schema == self.current_schema
+        define_method :"#{schema}?" do
+          schema == current_schema
         end
       end
-
-      def sqlserver?
-        current_schema =~ /sqlserver/
-      end
-
     end
 
     after { close_client }
@@ -32,7 +28,7 @@ module TinyTds
     protected
 
     TINYTDS_SCHEMAS.each do |schema|
-      define_method "#{schema}?" do
+      define_method :"#{schema}?" do
         schema == self.class.current_schema
       end
     end
@@ -41,52 +37,44 @@ module TinyTds
       self.class.current_schema
     end
 
-    def sqlserver?
-      self.class.sqlserver?
-    end
-
-    def close_client(client=@client)
+    def close_client(client = @client)
       client.close if defined?(client) && client.is_a?(TinyTds::Client)
     end
 
-    def new_connection(options={})
+    def new_connection(options = {})
       client = TinyTds::Client.new(connection_options(options))
-      if sybase_ase?
-        client.execute("SET ANSINULL ON").do
-        return client
-      elsif sqlserver_azure?
-        client.execute('SET ANSI_NULLS ON').do
-        client.execute('SET CURSOR_CLOSE_ON_COMMIT OFF').do
-        client.execute('SET ANSI_NULL_DFLT_ON ON').do
-        client.execute('SET IMPLICIT_TRANSACTIONS OFF').do
-        client.execute('SET ANSI_PADDING ON').do
-        client.execute('SET QUOTED_IDENTIFIER ON').do
-        client.execute('SET ANSI_WARNINGS ON').do
+      if sqlserver_azure?
+        client.execute("SET ANSI_NULLS ON").do
+        client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+        client.execute("SET ANSI_NULL_DFLT_ON ON").do
+        client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+        client.execute("SET ANSI_PADDING ON").do
+        client.execute("SET QUOTED_IDENTIFIER ON").do
+        client.execute("SET ANSI_WARNINGS ON").do
       else
-        client.execute('SET ANSI_DEFAULTS ON').do
-        client.execute('SET CURSOR_CLOSE_ON_COMMIT OFF').do
-        client.execute('SET IMPLICIT_TRANSACTIONS OFF').do
+        client.execute("SET ANSI_DEFAULTS ON").do
+        client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+        client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
       end
-      client.execute('SET TEXTSIZE 2147483647').do
-      client.execute('SET CONCAT_NULL_YIELDS_NULL ON').do
+      client.execute("SET TEXTSIZE 2147483647").do
+      client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
       client
     end
 
-    def connection_options(options={})
-      username = (sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_USER'] : ENV['TINYTDS_UNIT_USER']) || 'tinytds'
-      password = (sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_PASS'] : ENV['TINYTDS_UNIT_PASS']) || ''
-      { :dataserver    => sqlserver_azure? ? nil : ENV['TINYTDS_UNIT_DATASERVER'],
-        :host          => ENV['TINYTDS_UNIT_HOST'] || 'localhost',
-        :port          => ENV['TINYTDS_UNIT_PORT'] || '1433',
-        :tds_version   => ENV['TINYTDS_UNIT_VERSION'],
-        :username      => username,
-        :password      => password,
-        :database      => ENV['TINYTDS_UNIT_DATABASE'] || 'tinytdstest',
-        :appname       => 'TinyTds Dev',
-        :login_timeout => 5,
-        :timeout       => connection_timeout,
-        :azure         => sqlserver_azure?
-      }.merge(options)
+    def connection_options(options = {})
+      username = (sqlserver_azure? ? ENV["TINYTDS_UNIT_AZURE_USER"] : ENV["TINYTDS_UNIT_USER"]) || "tinytds"
+      password = (sqlserver_azure? ? ENV["TINYTDS_UNIT_AZURE_PASS"] : ENV["TINYTDS_UNIT_PASS"]) || ""
+      {dataserver: sqlserver_azure? ? nil : ENV["TINYTDS_UNIT_DATASERVER"],
+       host: ENV["TINYTDS_UNIT_HOST"] || "localhost",
+       port: ENV["TINYTDS_UNIT_PORT"] || "1433",
+       tds_version: ENV["TINYTDS_UNIT_VERSION"],
+       username: username,
+       password: password,
+       database: ENV["TINYTDS_UNIT_DATABASE"] || "tinytdstest",
+       appname: "TinyTds Dev",
+       login_timeout: 5,
+       timeout: connection_timeout,
+       azure: sqlserver_azure?}.merge(options)
     end
 
     def connection_timeout
@@ -94,7 +82,7 @@ module TinyTds
     end
 
     def assert_client_works(client)
-      _(client.execute("SELECT 'client_works' as [client_works]").each).must_equal [{'client_works' => 'client_works'}]
+      _(client.execute("SELECT 'client_works' as [client_works]").each).must_equal [{"client_works" => "client_works"}]
     end
 
     def assert_new_connections_work
@@ -111,28 +99,26 @@ module TinyTds
       rescue TinyTds::Error => e
         error_raised = true
       end
-      assert error_raised, 'expected a TinyTds::Error but none happened'
+      assert error_raised, "expected a TinyTds::Error but none happened"
       yield e
     ensure
       close_client(result)
     end
 
     def inspect_tinytds_exception
-      begin
-        yield
-      rescue TinyTds::Error => e
-        props = { :source => e.source, :message => e.message, :severity => e.severity,
-                  :db_error_number => e.db_error_number, :os_error_number => e.os_error_number }
-        raise "TinyTds::Error - #{props.inspect}"
-      end
+      yield
+    rescue TinyTds::Error => e
+      props = {source: e.source, message: e.message, severity: e.severity,
+               db_error_number: e.db_error_number, os_error_number: e.os_error_number}
+      raise "TinyTds::Error - #{props.inspect}"
     end
 
     def assert_binary_encoding(value)
-      assert_equal Encoding.find('BINARY'), value.encoding
+      assert_equal Encoding.find("BINARY"), value.encoding
     end
 
     def assert_utf8_encoding(value)
-      assert_equal Encoding.find('UTF-8'), value.encoding
+      assert_equal Encoding.find("UTF-8"), value.encoding
     end
 
     def rubyRbx?
@@ -140,17 +126,17 @@ module TinyTds
     end
 
     def ruby_windows?
-      RbConfig::CONFIG['host_os'] =~ /ming/
+      RbConfig::CONFIG["host_os"] =~ /ming/
     end
 
     def ruby_darwin?
-      RbConfig::CONFIG['host_os'] =~ /darwin/
+      RbConfig::CONFIG["host_os"] =~ /darwin/
     end
 
     def load_current_schema
       loader = new_connection
-      schema_file = File.expand_path File.join(File.dirname(__FILE__), 'schema', "#{current_schema}.sql")
-      schema_sql = File.open(schema_file,"rb:UTF-8") { |f|f.read }
+      schema_file = File.expand_path File.join(File.dirname(__FILE__), "schema", "#{current_schema}.sql")
+      schema_sql = File.open(schema_file, "rb:UTF-8") { |f| f.read }
       loader.execute(drop_sql).do
       loader.execute(schema_sql).do
       loader.execute(sp_sql).do
@@ -161,28 +147,6 @@ module TinyTds
     end
 
     def drop_sql
-      sybase_ase? ? drop_sql_sybase : drop_sql_microsoft
-    end
-
-    def drop_sql_sybase
-      %|IF EXISTS(
-          SELECT 1 FROM sysobjects WHERE type = 'U' AND name = 'datatypes'
-        ) DROP TABLE datatypes
-        IF EXISTS(
-          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestReturnCodes'
-        ) DROP PROCEDURE tinytds_TestReturnCodes
-        IF EXISTS(
-          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestPrintWithError'
-        ) DROP PROCEDURE tinytds_TestPrintWithError
-        IF EXISTS(
-          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestPrintWithError'
-        ) DROP PROCEDURE tinytds_TestPrintWithError
-        IF EXISTS(
-          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestSeveralPrints'
-        ) DROP PROCEDURE tinytds_TestSeveralPrints|
-    end
-
-    def drop_sql_microsoft
       %|IF EXISTS (
           SELECT TABLE_NAME
           FROM INFORMATION_SCHEMA.TABLES
@@ -219,14 +183,14 @@ module TinyTds
     end
 
     def sp_several_prints_sql
-      %|CREATE PROCEDURE tinytds_TestSeveralPrints
+      %(CREATE PROCEDURE tinytds_TestSeveralPrints
         AS
         PRINT 'hello 1'
         PRINT 'hello 2'
-        PRINT 'hello 3'|
+        PRINT 'hello 3')
     end
 
-    def find_value(id, column, query_options={})
+    def find_value(id, column, query_options = {})
       query_options[:timezone] ||= :utc
       sql = "SELECT [#{column}] FROM [datatypes] WHERE [id] = #{id}"
       @client.execute(sql).each(query_options).first[column.to_s]
@@ -248,22 +212,31 @@ module TinyTds
     end
 
     def init_toxiproxy
-      return if ENV['APPVEYOR_BUILD_FOLDER'] # only for CI using docker
-
       # In order for toxiproxy to work for local docker instances of mssql, the containers must be on the same network
       # and the host used below must match the mssql container name so toxiproxy knows where to proxy to.
       # localhost from the perspective of toxiproxy's container is its own container an *not* the mssql container it needs to proxy to.
       # docker-compose.yml handles this automatically for us. In instances where someone is using their own local mssql container they'll
       # need to set up the networks manually and set TINYTDS_UNIT_HOST to their mssql container name
       # For anything other than localhost just use the environment config
-      env_host = ENV['TINYTDS_UNIT_HOST_TEST'] || ENV['TINYTDS_UNIT_HOST'] || 'localhost'
-      host = ['localhost', '127.0.0.1', '0.0.0.0'].include?(env_host) ? 'sqlserver' : env_host
-      port = ENV['TINYTDS_UNIT_PORT'] || 1433
+      toxi_host = ENV["TOXIPROXY_HOST"] || "localhost"
+      toxi_api_port = 8474
+      toxi_test_port = 1234
+      Toxiproxy.host = "http://#{toxi_host}:#{toxi_api_port}"
+
+      toxi_upstream_host = ENV["TINYTDS_UNIT_HOST_TEST"] || ENV["TINYTDS_UNIT_HOST"] || "localhost"
+      toxi_upstream_port = ENV["TINYTDS_UNIT_PORT"] || 1433
+
+      puts "\n-------------------------"
+      puts "Toxiproxy api listener: #{toxi_host}:#{toxi_api_port}"
+      puts "Toxiproxy unit test listener: #{toxi_host}:#{toxi_test_port}"
+      puts "Toxiproxy upstream sqlserver: #{toxi_upstream_host}:#{toxi_upstream_port}"
+      puts "-------------------------"
+
       Toxiproxy.populate([
         {
           name: "sqlserver_test",
-          listen: "0.0.0.0:1234",
-          upstream: "#{host}:#{port}"
+          listen: "#{toxi_host}:#{toxi_test_port}",
+          upstream: "#{toxi_upstream_host}:#{toxi_upstream_port}"
         }
       ])
     end

data/test/thread_test.rb

@@ -1,25 +1,23 @@
-require 'test_helper'
-require 'logger'
-require 'benchmark'
+require "test_helper"
+require "logger"
+require "benchmark"
 
 class ThreadTest < TinyTds::TestCase
-
-  describe 'Threaded SELECT queries' do
-
+  describe "Threaded SELECT queries" do
     before do
       @logger = Logger.new $stdout
       @logger.level = Logger::WARN
       @poolsize = 4
       @numthreads = 10
       @query = "waitfor delay '00:00:01'"
-      @pool = ConnectionPool.new(:size => @poolsize, :timeout => 5) { new_connection }
+      @pool = ConnectionPool.new(size: @poolsize, timeout: 5) { new_connection }
     end
 
     after do
       @pool.shutdown { |c| c.close }
     end
 
-    it 'should finish faster in parallel' do
+    it "should finish faster in parallel" do
       skip if sqlserver_azure?
       x = Benchmark.realtime do
         threads = []
@@ -35,24 +33,22 @@ class ThreadTest < TinyTds::TestCase
         threads.each { |t| t.join }
       end
       assert x < @numthreads, "#{x} is not faster than #{@numthreads} seconds"
-      mintime = (1.0*@numthreads/@poolsize).ceil
+      mintime = (1.0 * @numthreads / @poolsize).ceil
       @logger.info "#{@numthreads} queries on #{@poolsize} threads: #{x} sec. Minimum time: #{mintime} sec."
       assert x > mintime, "#{x} is not slower than #{mintime} seconds"
     end
 
-    it 'should not crash on error in parallel' do
+    it "should not crash on error in parallel" do
       skip if sqlserver_azure?
       threads = []
       @numthreads.times do |i|
         threads << Thread.new do
           @pool.with do |client|
-            begin
-              result = client.execute "select dbname()"
-              result.each { |r| puts r }
-            rescue Exception => _e
-              # We are throwing an error on purpose here since 0.6.1 would
-              # segfault on errors thrown in threads
-            end
+            result = client.execute "select dbname()"
+            result.each { |r| puts r }
+          rescue => _e
+            # We are throwing an error on purpose here since 0.6.1 would
+            # segfault on errors thrown in threads
           end
         end
       end
@@ -60,27 +56,25 @@ class ThreadTest < TinyTds::TestCase
       assert true
     end
 
-    it 'should cancel when hitting timeout in thread' do
+    it "should cancel when hitting timeout in thread" do
       exception = false
 
       thread = Thread.new do
         @pool.with do |client|
-          begin
-            delay = ('0' + (connection_timeout + 2).to_s)[-2,2] # Two seconds longer than default.
-            result = client.execute "waitfor delay '00:00:#{delay}'; select db_name()"
-            result.each { |r| puts r }
-          rescue TinyTds::Error => e
-            if e.message == 'Adaptive Server connection timed out'
-              exception = true
-            end
+          delay = ("0" + (connection_timeout + 2).to_s)[-2, 2] # Two seconds longer than default.
+          result = client.execute "waitfor delay '00:00:#{delay}'; select db_name()"
+          result.each { |r| puts r }
+        rescue TinyTds::Error => e
+          if e.message == "Adaptive Server connection timed out"
+            exception = true
           end
         end
       end
 
       timer_thread = Thread.new do
         # Sleep until after the timeout should have been reached
-        sleep(connection_timeout+2)
-        if not exception
+        sleep(connection_timeout + 2)
+        if !exception
           thread.kill
           raise "Timeout passed without query timing out"
         end
@@ -91,8 +85,5 @@ class ThreadTest < TinyTds::TestCase
 
       assert exception
     end
-
   end
-
 end
-

data/tiny_tds.gemspec

@@ -1,30 +1,31 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.push File.expand_path('../lib', __FILE__)
-require 'tiny_tds/version'
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "tiny_tds/version"
 
 Gem::Specification.new do |s|
-  s.name          = 'tiny_tds'
-  s.version       = TinyTds::VERSION
-  s.platform      = Gem::Platform::RUBY
-  s.authors       = ['Ken Collins', 'Erik Bryn', 'Will Bond']
-  s.email         = ['ken@metaskills.net', 'will@wbond.net']
-  s.homepage      = 'http://github.com/rails-sqlserver/tiny_tds'
-  s.summary       = 'TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library.'
-  s.description   = 'TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library. Developed for the ActiveRecord SQL Server adapter.'
-  s.files         = `git ls-files`.split("\n") + Dir.glob('exe/*')
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = ['lib']
-  s.rdoc_options  = ['--charset=UTF-8']
-  s.extensions    = ['ext/tiny_tds/extconf.rb']
-  s.license       = 'MIT'
-  s.required_ruby_version = '>= 2.0.0'
-  s.metadata['msys2_mingw_dependencies'] = 'freetds'
-  s.add_development_dependency 'mini_portile2', '~> 2.0'
-  s.add_development_dependency 'rake', '~> 13.0'
-  s.add_development_dependency 'rake-compiler', '~> 1.0'
-  s.add_development_dependency 'rake-compiler-dock', '~> 1.0'
-  s.add_development_dependency 'minitest', '~> 5.6'
-  s.add_development_dependency 'connection_pool', '~> 2.2'
-  s.add_development_dependency 'toxiproxy', '~> 2.0.0'
+  s.name = "tiny_tds"
+  s.version = TinyTds::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Ken Collins", "Erik Bryn", "Will Bond"]
+  s.email = ["ken@metaskills.net", "will@wbond.net"]
+  s.homepage = "http://github.com/rails-sqlserver/tiny_tds"
+  s.summary = "TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library."
+  s.description = "TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library. Developed for the ActiveRecord SQL Server adapter."
+  s.files = `git ls-files`.split("\n") + Dir.glob("exe/*")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extensions = ["ext/tiny_tds/extconf.rb"]
+  s.license = "MIT"
+  s.required_ruby_version = ">= 2.7.0"
+  s.metadata["msys2_mingw_dependencies"] = "freetds"
+  s.add_dependency "bigdecimal", "~> 3"
+  s.add_development_dependency "mini_portile2", "~> 2.8.0"
+  s.add_development_dependency "rake", "~> 13.0.0"
+  s.add_development_dependency "rake-compiler", "~> 1.2"
+  s.add_development_dependency "rake-compiler-dock", "~> 1.9.1"
+  s.add_development_dependency "minitest", "~> 5.25"
+  s.add_development_dependency "minitest-reporters", "~> 1.6.1"
+  s.add_development_dependency "connection_pool", "~> 2.2.0"
+  s.add_development_dependency "toxiproxy", "~> 2.0.0"
+  s.add_development_dependency "standard", "~> 1.31.0"
 end