tiny_tds_vagas 1.0.5

data/ext/tiny_tds/result.h

@@ -0,0 +1,32 @@
+
+#ifndef TINYTDS_RESULT_H
+#define TINYTDS_RESULT_H
+
+void init_tinytds_result();
+VALUE rb_tinytds_new_result_obj(tinytds_client_wrapper *cwrap);
+
+typedef struct {
+  tinytds_client_wrapper *cwrap;
+  DBPROCESS *client;
+  VALUE local_offset;
+  VALUE fields;
+  VALUE fields_processed;
+  VALUE results;
+  rb_encoding *encoding;
+  VALUE dbresults_retcodes;
+  unsigned int number_of_results;
+  unsigned int number_of_fields;
+  unsigned long number_of_rows;
+} tinytds_result_wrapper;
+
+
+// Lib Macros
+
+#define GET_RESULT_WRAPPER(self) \
+  tinytds_result_wrapper *rwrap; \
+  Data_Get_Struct(self, tinytds_result_wrapper, rwrap)
+
+
+
+
+#endif

data/ext/tiny_tds/tiny_tds_ext.c

@@ -0,0 +1,12 @@
+
+#include <tiny_tds_ext.h>
+
+VALUE mTinyTds, cTinyTdsError;
+
+void Init_tiny_tds() {
+  mTinyTds      = rb_define_module("TinyTds");
+  cTinyTdsError = rb_const_get(mTinyTds, rb_intern("Error"));
+  init_tinytds_client();
+  init_tinytds_result();
+}
+

data/ext/tiny_tds/tiny_tds_ext.h

@@ -0,0 +1,17 @@
+#ifndef TINYTDS_EXT
+#define TINYTDS_EXT
+
+#undef SYBDBLIB
+#define MSDBLIB 1
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/version.h>
+#include <ruby/thread.h>
+#include <sybfront.h>
+#include <sybdb.h>
+
+#include <client.h>
+#include <result.h>
+
+#endif

data/lib/tiny_tds.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'date'
+require 'bigdecimal'
+require 'rational'
+
+require 'tiny_tds/version'
+require 'tiny_tds/error'
+require 'tiny_tds/client'
+require 'tiny_tds/result'
+
+# Support multiple ruby versions, fat binaries under Windows.
+if RUBY_PLATFORM =~ /mingw|mswin/ && RUBY_VERSION =~ /(\d+.\d+)/
+  ver = $1
+  # Set the PATH environment variable, so that the DLLs can be found.
+  old_path = ENV['PATH']
+  begin
+    # Do the same host consolidation as in extconf.rb
+    ports_dir = RbConfig::CONFIG["host"].gsub('i686-pc-mingw32', 'i686-w64-mingw32')
+    ENV['PATH'] = "#{File.expand_path("../../ports/#{ports_dir}/bin", __FILE__)};#{old_path}"
+    require "tiny_tds/#{ver}/tiny_tds"
+  rescue LoadError
+    require 'tiny_tds/tiny_tds'
+  ensure
+    ENV['PATH'] = old_path
+  end
+else
+  # Load dependent shared libraries into the process, so that they are already present,
+  # when tiny_tds.so is loaded. This ensures, that shared libraries are loaded even when
+  # the path is different between build and run time (e.g. Heroku).
+  ports_libs = File.expand_path("../../ports/#{RbConfig::CONFIG["host"]}/lib/*.so", __FILE__)
+  Dir[ports_libs].each do |lib|
+    require "fiddle"
+    Fiddle.dlopen(lib)
+  end
+
+  require 'tiny_tds/tiny_tds'
+end

data/lib/tiny_tds/bin.rb

@@ -0,0 +1,86 @@
+require_relative './version'
+require 'shellwords'
+
+module TinyTds
+  class Bin
+
+    ROOT  = File.expand_path '../../..', __FILE__
+    PATHS = ENV['PATH'].split File::PATH_SEPARATOR
+    EXTS  = (ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']) | ['.exe']
+
+    attr_reader :name
+
+    class << self
+
+      def exe(name, *args)
+        bin = new(name)
+        puts bin.info
+        bin.run(*args)
+      end
+
+    end
+
+    def initialize(name)
+      @name = name
+      @binstub = find_bin
+      @exefile = find_exe
+    end
+
+    def run(*args)
+      return nil unless path
+      Kernel.system Shellwords.join(args.unshift(path))
+      $?.to_i
+    end
+
+    def path
+      return @path if defined?(@path)
+      @path = @exefile && File.exists?(@exefile) ? @exefile : which
+    end
+
+    def info
+      "[TinyTds][v#{TinyTds::VERSION}][#{name}]: #{path}"
+    end
+
+
+    private
+
+    def find_bin
+      File.join ROOT, 'bin', name
+    end
+
+    def find_exe
+      EXTS.each do |ext|
+        f = File.join ROOT, 'exe', "#{name}#{ext}"
+        return f if File.exists?(f)
+      end
+      nil
+    end
+
+    def which
+      PATHS.each do |path|
+        EXTS.each do |ext|
+          exe = File.expand_path File.join(path, "#{name}#{ext}"), ROOT
+          next if exe == @binstub
+          next if !File.executable?(exe)
+          next if !binary?(exe)
+          return exe
+        end
+      end
+      return nil
+    end
+
+    # Implementation directly copied from ptools.
+    # https://github.com/djberg96/ptools
+    # https://opensource.org/licenses/Artistic-2.0
+    #
+    def binary?(file)
+      bytes = File.stat(file).blksize
+      return false unless bytes
+      bytes = 4096 if bytes > 4096
+      s = (File.read(file, bytes) || "")
+      s = s.encode('US-ASCII', :undef => :replace).split(//)
+      ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
+    end
+
+  end
+end

data/lib/tiny_tds/client.rb

@@ -0,0 +1,124 @@
+module TinyTds
+  class Client
+
+    @@default_query_options = {
+      :as => :hash,
+      :symbolize_keys => false,
+      :cache_rows => true,
+      :timezone => :local,
+      :empty_sets => true
+    }
+
+    attr_reader :query_options
+
+    class << self
+
+      def default_query_options
+        @@default_query_options
+      end
+
+      # Most, if not all, iconv encoding names can be found by ruby. Just in case, you can
+      # overide this method to return a string name that Encoding.find would work with. Default
+      # is to return the passed encoding.
+      #
+      def transpose_iconv_encoding(encoding)
+        encoding
+      end
+
+    end
+
+
+    def initialize(opts={})
+      raise ArgumentError, 'missing :host option if no :dataserver given' if opts[:dataserver].to_s.empty? && opts[:host].to_s.empty?
+      opts[:username] = parse_username(opts)
+      @query_options = @@default_query_options.dup
+      opts[:password] = opts[:password].to_s if opts[:password] && opts[:password].to_s.strip != ''
+      opts[:appname] ||= 'TinyTds'
+      opts[:tds_version] = tds_versions_setter(opts)
+      opts[:login_timeout] ||= 60
+      opts[:timeout] ||= 5
+      opts[:encoding] = (opts[:encoding].nil? || opts[:encoding].downcase == 'utf8') ? 'UTF-8' : opts[:encoding].upcase
+      opts[:port] ||= 1433
+      opts[:dataserver] = "#{opts[:host]}:#{opts[:port]}" if opts[:dataserver].to_s.empty?
+      connect(opts)
+    end
+
+    def tds_73?
+      tds_version >= 11
+    end
+
+    def tds_version_info
+      info = TDS_VERSIONS_GETTERS[tds_version]
+      "#{info[:name]} - #{info[:description]}" if info
+    end
+
+    def active?
+      !closed? && !dead?
+    end
+
+
+    private
+
+    def self.local_offset
+      ::Time.local(2010).utc_offset.to_r / 86400
+    end
+
+    def parse_username(opts)
+      host = opts[:host]
+      username = opts[:username]
+      return username if username.nil? || !opts[:azure]
+      return username if username.include?("@") && !username.include?("database.windows.net")
+      user, domain = username.split("@")
+      domain ||= host
+      "#{user}@#{domain.split('.').first}"
+    end
+
+    def tds_versions_setter(opts={})
+      v = opts[:tds_version] || ENV['TDSVER'] || '7.3'
+      TDS_VERSIONS_SETTERS[v.to_s]
+    end
+
+    # From sybdb.h comments:
+    # DBVERSION_xxx are used with dbsetversion()
+    #
+    TDS_VERSIONS_SETTERS = {
+      'unknown' => 0,
+      '46'      => 1,
+      '100'     => 2,
+      '42'      => 3,
+      '70'      => 4,
+      '7.0'     => 4,
+      '71'      => 5,
+      '7.1'     => 5,
+      '80'      => 5,
+      '8.0'     => 5,
+      '72'      => 6,
+      '7.2'     => 6,
+      '90'      => 6,
+      '9.0'     => 6,
+      '73'      => 7,
+      '7.3'     => 7
+    }.freeze
+
+    # From sybdb.h comments:
+    # DBTDS_xxx are returned by DBTDS()
+    # The integer values of the constants are poorly chosen.
+    #
+    TDS_VERSIONS_GETTERS = {
+      0  => {:name => 'DBTDS_UNKNOWN',        :description => 'Unknown'},
+      1  => {:name => 'DBTDS_2_0',            :description => 'Pre 4.0 SQL Server'},
+      2  => {:name => 'DBTDS_3_4',            :description => 'Microsoft SQL Server (3.0)'},
+      3  => {:name => 'DBTDS_4_0',            :description => '4.0 SQL Server'},
+      4  => {:name => 'DBTDS_4_2',            :description => '4.2 SQL Server'},
+      5  => {:name => 'DBTDS_4_6',            :description => '2.0 OpenServer and 4.6 SQL Server.'},
+      6  => {:name => 'DBTDS_4_9_5',          :description => '4.9.5 (NCR) SQL Server'},
+      7  => {:name => 'DBTDS_5_0',            :description => '5.0 SQL Server'},
+      8  => {:name => 'DBTDS_7_0',            :description => 'Microsoft SQL Server 7.0'},
+      9  => {:name => 'DBTDS_7_1/DBTDS_8_0',  :description => 'Microsoft SQL Server 2000'},
+      10 => {:name => 'DBTDS_7_2/DBTDS_9_0',  :description => 'Microsoft SQL Server 2005'},
+      11 => {:name => 'DBTDS_7_3',            :description => 'Microsoft SQL Server 2008'},
+      12 => {:name => 'DBTDS_7_4',            :description => 'Microsoft SQL Server 2012/2014'}
+    }.freeze
+
+  end
+end

data/lib/tiny_tds/error.rb

@@ -0,0 +1,15 @@
+module TinyTds
+  class Error < StandardError
+
+    attr_accessor :source, :severity, :db_error_number, :os_error_number
+
+    def initialize(message)
+      super
+      @severity = nil
+      @db_error_number = nil
+      @os_error_number = nil
+    end
+
+
+  end
+end

data/lib/tiny_tds/result.rb

@@ -0,0 +1,8 @@
+module TinyTds
+  class Result
+    
+    include Enumerable
+    
+    
+  end
+end

data/lib/tiny_tds/version.rb

@@ -0,0 +1,3 @@
+module TinyTds
+  VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).chomp
+end

data/ports/patches/freetds/1.00/0001-mingw_missing_inet_pton.diff

@@ -0,0 +1,34 @@
+diff --git a/src/tds/tls.c b/src/tds/tls.c
+index 0d11a33..b8ab2ba 100644
+--- a/src/tds/tls.c
++++ b/src/tds/tls.c
+@@ -72,6 +72,29 @@
+ #define SSL_PTR bio->ptr
+ #endif
+
++/*
++ * Add a workaround for older Mingw versions without inet_pton().
++ * This means RubyInstallers DevKit-4.7.2 in particular.
++ */
++#if defined(__MINGW64_VERSION_MAJOR) && !defined(InetPtonA)
++  #include <windows.h>
++
++  static HMODULE ws2_32 = NULL;
++  typedef INT (WINAPI * __inet_pton)(INT Family, LPCWSTR pStringBuf, PVOID pAddr);
++  static __inet_pton _inet_pton = NULL;
++
++  INT WINAPI inet_pton(INT Family, LPCWSTR pStringBuf, PVOID pAddr)
++  {
++    if (_inet_pton == NULL) {
++      ws2_32 = LoadLibraryEx("Ws2_32.dll", NULL, 0);
++
++      _inet_pton = (__inet_pton)GetProcAddress(ws2_32, "inet_pton");
++    }
++
++    return (_inet_pton)(Family, pStringBuf, pAddr);
++  }
++#endif
++
+ static SSL_RET
+ tds_pull_func_login(SSL_PULL_ARGS)
+ {

data/test/appveyor/dbsetup.ps1

@@ -0,0 +1,27 @@
+
+Write-Output "Setting up..."
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.SqlWmiManagement") | Out-Null
+
+Write-Output "Setting variables..."
+$serverName = $env:COMPUTERNAME
+$instances = @('SQL2008R2SP2', 'SQL2012SP1', 'SQL2014')
+$smo = 'Microsoft.SqlServer.Management.Smo.'
+$wmi = new-object ($smo + 'Wmi.ManagedComputer')
+
+Write-Output "Configure Instances..."
+foreach ($instance in $instances) {
+  Write-Output "Instance $instance ..."
+  Write-Output "Enable TCP/IP and port 1433..."
+  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instance']/ServerProtocol[@Name='Tcp']"
+  $tcp = $wmi.GetSmoObject($uri)
+  $tcp.IsEnabled = $true
+  foreach ($ipAddress in $Tcp.IPAddresses) {
+    $ipAddress.IPAddressProperties["TcpDynamicPorts"].Value = ""
+    $ipAddress.IPAddressProperties["TcpPort"].Value = "1433"
+  }
+  $tcp.Alter()
+}
+
+Set-Service SQLBrowser -StartupType Manual
+Start-Service SQLBrowser

data/test/appveyor/dbsetup.sql

@@ -0,0 +1,9 @@
+CREATE DATABASE [tinytdstest];
+GO
+CREATE LOGIN [tinytds] WITH PASSWORD = '', CHECK_POLICY = OFF, DEFAULT_DATABASE = [tinytdstest];
+GO
+USE [tinytdstest];
+CREATE USER [tinytds] FOR LOGIN [tinytds];
+GO
+EXEC sp_addrolemember N'db_owner', N'tinytds';
+GO

data/test/benchmark/query.rb

@@ -0,0 +1,77 @@
+$:.unshift File.expand_path('../../../lib',__FILE__)
+require 'rubygems'
+require 'bench_press'
+require 'tiny_tds'
+require 'odbc'
+require 'odbc_utf8'
+
+extend BenchPress
+
+author 'Ken Collins'
+summary 'Query everything.'
+
+reps 1_000
+
+@odbc = ODBC.connect ENV['TINYTDS_UNIT_DATASERVER'], 'tinytds', ''
+@odbc.use_time = true
+
+@odbc_utf8 = ODBC_UTF8.connect ENV['TINYTDS_UNIT_DATASERVER'], 'tinytds', ''
+@odbc_utf8.use_time = true
+
+@tinytds = TinyTds::Client.new(
+  :dataserver    => ENV['TINYTDS_UNIT_DATASERVER'],
+  :username      => 'tinytds',
+  :password      => '',
+  :database      => 'tinytdstest',
+  :appname       => 'TinyTds Dev',
+  :login_timeout => 5,
+  :timeout       => 5 )
+
+@query_all = "SELECT * FROM [datatypes]"
+
+
+measure "ODBC (ascii-8bit)" do
+  h = @odbc.run(@query_all)
+  h.fetch_all
+  h.drop
+end
+
+# measure "ODBC (utf8)" do
+#   h = @odbc_utf8.run(@query_all)
+#   h.fetch_all
+#   h.drop
+# end
+
+measure "TinyTDS (row caching)" do
+  @tinytds.execute(@query_all).each
+end
+
+measure "TinyTDS (no caching)" do
+  @tinytds.execute(@query_all).each(:cache_rows => false)
+end
+
+
+
+=begin
+
+Author: Ken Collins  
+Date: January 22, 2011  
+Summary: Query everything.  
+
+System Information
+------------------
+    Operating System:    Mac OS X 10.6.6 (10J567)
+    CPU:                 Intel Core 2 Duo 1.6 GHz
+    Processor Count:     2
+    Memory:              4 GB
+    ruby 1.8.7 (2010-04-19 patchlevel 253) [i686-darwin10.4.3], MBARI 0x6770, Ruby Enterprise Edition 2010.02
+
+"TinyTDS (row caching)" is up to 79% faster over 1,000 repetitions
+------------------------------------------------------------------
+
+    TinyTDS (row caching)    4.90862512588501 secs    Fastest
+    TinyTDS (no caching)     4.91626906394958 secs    0% Slower
+    ODBC (ascii-8bit)        23.959536075592  secs    79% Slower
+
+=end
+