tiny_tds 2.1.2 → 3.4.0

data/CHANGELOG.md

@@ -1,3 +1,72 @@
+## (unreleased)
+
+## 3.4.0
+
+* Add Ruby 4.0 to the cross compile list
+* No longer ship a precompiled Gem for Ruby 2.7
+  * This is due to an [upstream change](https://github.com/rake-compiler/rake-compiler-dock/releases/tag/v1.11.0). Users on Windows and Linux on Ruby v2.7 are advised to either upgrade or install FreeTDS manually.
+* Use freetds v1.5.10 and OpenSSL v3.6.0 for Windows and Linux builds.
+* Lower `bigdecimal` requirement to `>= 2.0.0` (was 3.0 only) to allow `bigdecimal` 4.0 on Ruby 4.0. Closes #601.
+
+## 3.3.0
+
+* Use freetds v1.5.4 and OpenSSL v3.5.2 for Windows and Linux builds.
+* Use `TypedData` in C-Land.
+
+## 3.2.1
+
+* Ensure the native Gem loads on Windows. Fixes #581.
+* Use OpenSSL v3.4.1 for Windows and Linux builds.
+
+## 3.2.0
+
+* Reduce number of files shipped with precompiled Windows gem
+* Provide precompiled gem for Linux (GNU + MUSL / 64-bit x86 + ARM)
+* Fix wrappers for `tsql` and `defncopy` utility.
+* Use libiconv v1.18 and freetds v1.4.26 for Windows and Linux builds
+
+## 3.1.0
+
+* Add Ruby 3.4 to the cross compile list
+
+## 3.0.0
+
+* Drop support for Ruby < 2.7
+* Drop support for SQL Server < 2017
+* Drop support for FreeTDS < 1.0
+* No longer provide a 32-bit Windows build
+* Raise error if FreeTDS is unable to send command buffer to the server
+* Use freetds v1.4.23, libiconv v1.17 and OpenSSL v3.4.0 for Windows builds
+* Add `bigdecimal` to dependencies
+
+## 2.1.7
+
+* Add Ruby 3.3 to the cross compile list
+
+## 2.1.6
+
+* Add Ruby 3.0, 3.1, and 3.2 to the cross compile list
+* Fix segfault when asking if client was dead after closing it. Fixes #519.
+* Mark `alloc` function as undefined on `TinyTds::Result`. Fixes #515.
+* Fix Gem installation on Windows by adding default freetds msys path. Fixes #522
+* Search for `freetds` in `/opt/homebrew` when installing on Apple Silicon. Fixes #484, #492 and #508.
+
+## 2.1.5
+
+* Fix compilation errors for Amazon Linux 1. Fixes #495.
+* Fix segfault for login timeouts
+
+## 2.1.4
+
+* Improve handling of network related timeouts
+* Fix error reporting when preceded by info message
+
+## 2.1.3
+
+* Removed old/unused appveyor config
+* Remove old Rubies from CI & cross compile list
+* Add Ruby 2.6 and 2.7 to the cross compile list
+
 ## 2.1.2
 
 * Use Kernel.BigDecimal vs BigDecimal.new. Fixes #409.
@@ -207,6 +276,8 @@ Use both dbsetversion() vs. dbsetlversion. Partially reverts #62.
   state of the client and the need to use Result#cancel to stop processing active results. It is also
   safe to call Result#cancel over and over again.
 * Look for the syb headers only.
+* Fix minitest global matchers warnings.
+* Fix test warnings.
 
 
 ## 0.3.2
@@ -252,4 +323,3 @@ Use both dbsetversion() vs. dbsetlversion. Partially reverts #62.
 
 
 ## 0.1.0 Initial release!
-

data/Gemfile

@@ -1,9 +1,2 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 gemspec
-
-group :development do
-end
-
-group :test do
-  gem 'minitest'
-end

data/ISSUE_TEMPLATE.md

@@ -2,7 +2,7 @@
 
 * On Windows? If so, do you need devkit for your ruby install?
 * Using Ubuntu? If so, you may have forgotten to install FreeTDS first.
-* Are you using FreeTDS 0.95.80 or later? Check `$ tsql -C` to find out.
+* Are you using FreeTDS 1.0.0 or later? Check `$ tsql -C` to find out.
 * If not, please update then uninstall the TinyTDS gem and re-install it.
 * Have you made sure to [enable SQL Server authentication](http://bit.ly/1Kw3set)?
 * Doing work with threads and the raw client? Use the ConnectionPool gem?

data/README.md

@@ -1,21 +1,13 @@
 # TinyTDS - Simple and fast FreeTDS bindings for Ruby using DB-Library.
 
-* [![TravisCI](https://travis-ci.org/rails-sqlserver/tiny_tds.svg?branch=master)](https://travis-ci.org/rails-sqlserver/tiny_tds) - TravisCI
-* [![Build Status](https://ci.appveyor.com/api/projects/status/g2bhhbsdkx0mal55/branch/master?svg=true)](https://ci.appveyor.com/project/rails-sqlserver/tiny-tds/branch/master) - Appveyor
 * [![Gem Version](https://img.shields.io/gem/v/tiny_tds.svg)](https://rubygems.org/gems/tiny_tds) - Gem Version
-* [![Dependency Status](https://dependencyci.com/github/rails-sqlserver/tiny_tds/badge)](https://dependencyci.com/github/rails-sqlserver/tiny_tds) - Dependency Status
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
 
-## Supporting TinyTDS/Adapter
-
-Both TinyTDS and the Rails SQL Server Adapter are MIT-licensed open source projects. Its ongoing development is made possible thanks to the support by these awesome [backers](https://github.com/rails-sqlserver/tiny_tds/blob/master/BACKERS.md). If you'd like to join them, check out our [Patreon Campaign](https://www.patreon.com/metaskills).
-
-
 ## About TinyTDS
 
-The TinyTDS gem is meant to serve the extremely common use-case of connecting, querying and iterating over results to Microsoft SQL Server or Sybase databases from Ruby using the FreeTDS's DB-Library API.
+The TinyTDS gem is meant to serve the extremely common use-case of connecting, querying and iterating over results to Microsoft SQL Server from Ruby using the FreeTDS's DB-Library API.
 
-TinyTDS offers automatic casting to Ruby primitives along with proper encoding support. It converts all SQL Server datatypes to native Ruby primitives while supporting :utc or :local time zones for time-like types. To date it is the only Ruby client library that allows client encoding options, defaulting to UTF-8, while connecting to SQL Server. It also  properly encodes all string and binary data. The motivation for TinyTDS is to become the de-facto low level connection mode for the SQL Server Adapter for ActiveRecord.
+TinyTDS offers automatic casting to Ruby primitives along with proper encoding support. It converts all SQL Server datatypes to native Ruby primitives while supporting :utc or :local time zones for time-like types. To date it is the only Ruby client library that allows client encoding options, defaulting to UTF-8, while connecting to SQL Server. It also  properly encodes all string and binary data.
 
 The API is simple and consists of these classes:
 
@@ -26,67 +18,69 @@ The API is simple and consists of these classes:
 
 ## Install
 
-Installing with rubygems should just work. TinyTDS is currently tested on Ruby version 2.0.0 and upward.
-
-```
-$ gem install tiny_tds
-```
+tiny_tds is tested with Ruby v2.7 and upwards.
 
-If you use Windows, we pre-compile TinyTDS with static versions of FreeTDS and supporting libraries.
-If you're using RubyInstaller the binary gem will require that devkit is installed and in your path to operate properly.
+### Windows and Linux (64-bit)
 
-On all other platforms, we will find these dependencies. It is recommended that you install the latest FreeTDS via your method of choice. For example, here is how to install FreeTDS on Ubuntu. You might also need the `build-essential` and possibly the `libc6-dev` packages.
+We precompile tiny_tds with FreeTDS and supporting libraries, which are dynamically linked at runtime. Therefore, you can run:
 
 ```shell
-$ apt-get install wget
-$ apt-get install build-essential
-$ apt-get install libc6-dev
-
-$ wget http://www.freetds.org/files/stable/freetds-1.00.21.tar.gz
-$ tar -xzf freetds-1.00.21.tar.gz
-$ cd freetds-1.00.21
-$ ./configure --prefix=/usr/local --with-tdsver=7.3
-$ make
-$ make install
+gem install tiny_tds
 ```
 
-If none exist, our native extension will use MiniPortile to install any missing dependencies listed above for your specific platform. These dependencies will be built and linked within the installed TinyTDS gem. Please read the MiniPortile and/or Windows sections at the end of this file for advanced configuration options past the following:
+It should find the platform-specific gem.
 
-```
---with-freetds-dir=DIR
-  Use the freetds library placed under DIR.
-```
+You can also avoid getting the platform-specific gem if you want to compile FreeTDS and supporting libraries yourself:
 
+```shell
+gem install tiny_tds --platform ruby
+```
 
-## Getting Started
+### Mac
 
-Optionally, Microsoft has done a great job writing some articles on how to get started with SQL Server and Ruby using TinyTDS. Please checkout one of the following posts that match your platform.
+Install FreeTDS via Homebrew:
 
-* [SQL Server on a Mac](https://www.microsoft.com/en-us/sql-server/developer-get-started/ruby/mac)
-* [SQL Server on RHEL](https://www.microsoft.com/en-us/sql-server/developer-get-started/ruby/rhel)
-* [SQL Server on Ubuntu](https://www.microsoft.com/en-us/sql-server/developer-get-started/ruby/ubuntu)
+```shell
+brew install openssl@3 libiconv
+brew install freetds
+```
 
+Then you can install tiny_tds:
 
-## FreeTDS Compatibility & Configuration
+```shell
+gem install tiny_tds
+```
 
-TinyTDS is developed against FreeTDS 0.95, 0.99, and 1.0 current. Our default and recommended is 1.0. We also test with SQL Server 2008, 2014, and Azure. However, usage of TinyTDS with SQL Server 2000 or 2005 should be just fine. Below are a few QA style notes about installing FreeTDS.
+### Everybody else
 
-**NOTE:** Windows users of our pre-compiled native gems need not worry about installing FreeTDS and its dependencies.
+`tiny_tds` will find FreeTDS and other libraries based on your compiler paths. Below you can see an example on how to install FreeTDS on a Debian system.
 
-* **Do I need to install FreeTDS?** Yes! Somehow, someway, you are going to need FreeTDS for TinyTDS to compile against. You can avoid installing FreeTDS on your system by using our projects usage of rake-compiler and mini_portile to compile and package a native gem just for you. See the "Using MiniPortile" section below.
+```shell
+$ apt-get install wget
+$ apt-get install build-essential
+$ apt-get install libc6-dev
 
-* **OK, I am installing FreeTDS, how do I configure it?** Contrary to what most people think, you do not need to specially configure FreeTDS in any way for client libraries like TinyTDS to use it. About the only requirement is that you compile it with libiconv for proper encoding support. FreeTDS must also be compiled with OpenSSL (or the like) to use it with Azure. See the "Using TinyTDS with Azure" section below for more info.
+$ wget http://www.freetds.org/files/stable/freetds-1.4.23.tar.gz
+$ tar -xzf freetds-1.4.23.tar.gz
+$ cd freetds-1.4.23
+$ ./configure --prefix=/usr/local --with-tdsver=7.4 --disable-odbc
+$ make
+$ make install
+```
 
-* **Do I need to configure `--with-tdsver` equal to anything?** Most likely! Technically you should not have too. This is only a default for clients/configs that do not specify what TDS version they want to use. We are currently having issues with passing down a TDS version with the login bit. Till we get that fixed, if you are not using a freetds.conf or a TDSVER environment variable, then make sure to use 7.1.
+You can also tell `tiny_tds` where to find your FreeTDS installation.
 
-* **But I want to use TDS version 7.2 for SQL Server 2005 and up!** TinyTDS uses TDS version 7.1 (previously named 8.0) and fully supports all the data types supported by FreeTDS, this includes `varchar(max)` and `nvarchar(max)`. Technically compiling and using TDS version 7.2 with FreeTDS is not supported. But this does not mean those data types will not work. I know, it's confusing If you want to learn more, read this thread. http://lists.ibiblio.org/pipermail/freetds/2011q3/027306.html
+```shell
+gem install tiny_tds -- --with-freetds-dir=/opt/freetds
+```
 
-* **I want to configure FreeTDS using `--enable-msdblib` and/or `--enable-sybase-compat` so it works for my database. Cool?** It's a waste of time and totally moot! Client libraries like TinyTDS define their own C structure names where they diverge from Sybase to SQL Server. Technically we use the MSDBLIB structures which does not mean we only work with that database vs Sybase. These configs are just a low level default for C libraries that do not define what they want. So I repeat, you do not NEED to use any of these, nor will they hurt anything since we control what C structure names we use internally!
+## Getting Started
 
+Optionally, Microsoft has done a great job writing [an article](https://learn.microsoft.com/en-us/sql/connect/ruby/ruby-driver-for-sql-server?view=sql-server-ver16) on how to get started with SQL Server and Ruby using TinyTDS, however, the articles are using outdated versions.
 
 ## Data Types
 
-Our goal is to support every SQL Server data type and covert it to a logical Ruby object. When dates or times are returned, they are instantiated to either `:utc` or `:local` time depending on the query options. Only [datetimeoffset] types are excluded. All strings are associated the to the connection's encoding and all binary data types are associated to Ruby's `ASCII-8BIT/BINARY` encoding.
+Our goal is to support every SQL Server data type and convert it to a logical Ruby object. When dates or times are returned, they are instantiated to either `:utc` or `:local` time depending on the query options. Only [datetimeoffset] types are excluded. All strings are associated to the connection's encoding and all binary data types are associated to Ruby's `ASCII-8BIT/BINARY` encoding.
 
 Below is a list of the data types we support when using the 7.3 TDS protocol version. Using a lower protocol version will result in these types being returned as strings.
 
@@ -104,18 +98,18 @@ Connect to a database.
 client = TinyTds::Client.new username: 'sa', password: 'secret', host: 'mydb.host.net'
 ```
 
-Creating a new client takes a hash of options. For valid iconv encoding options, see the output of `iconv -l`. Only a few have been tested and highly recommended to leave blank for the UTF-8 default.
+Creating a new client takes a hash of options. For valid iconv encoding options, see the output of `iconv -l`. Only a few have been tested, and are highly recommended to leave blank for the UTF-8 default.
 
 * :username - The database server user.
 * :password - The user password.
-* :dataserver - Can be the name for your data server as defined in freetds.conf. Raw hostname or hostname:port will work here too. FreeTDS says that named instance like 'localhost\SQLEXPRESS' work too, but I highly suggest that you use the :host and :port options below. [Google how to find your host port if you are using named instances](http://bit.ly/xAf2jm) or [go here](http://msdn.microsoft.com/en-us/library/ms181087.aspx).
+* :dataserver - Can be the name for your data server as defined in freetds.conf. Raw hostname or hostname:port will work here too. FreeTDS says that a named instance like 'localhost\SQLEXPRESS' will work too, but I highly suggest that you use the :host and :port options below. [Google how to find your host port if you are using named instances](http://bit.ly/xAf2jm) or [go here](http://msdn.microsoft.com/en-us/library/ms181087.aspx).
 * :host - Used if :dataserver blank. Can be an host name or IP.
 * :port - Defaults to 1433. Only used if :host is used.
 * :database - The default database to use.
 * :appname - Short string seen in SQL Servers process/activity window.
 * :tds_version - TDS version. Defaults to "7.3".
 * :login_timeout - Seconds to wait for login. Default to 60 seconds.
-* :timeout - Seconds to wait for a response to a SQL command. Default 5 seconds. Prior to 1.0rc5, FreeTDS was unable to set the timeout on a per-client basis, permitting only a global timeout value. This means that if you're using an older version, the timeout values for all clients will be overwritten each time you instantiate a new `TinyTds::Client` object. If you are using 1.0rc5 or later, all clients will have an independent timeout setting as you'd expect.
+* :timeout - Seconds to wait for a response to a SQL command. Default 5 seconds. Timeouts caused by network failure will raise a timeout error 1 second after the configured timeout limit is hit (see [#481](https://github.com/rails-sqlserver/tiny_tds/pull/481) for details).
 * :encoding - Any valid iconv value like CP1251 or ISO-8859-1. Default UTF-8.
 * :azure - Pass true to signal that you are connecting to azure.
 * :contained - Pass true to signal that you are connecting with a contained database user.
@@ -327,9 +321,13 @@ By default row caching is turned on because the SQL Server adapter for ActiveRec
 TinyTDS takes an opinionated stance on how we handle encoding errors. First, we treat errors differently on reads vs. writes. Our opinion is that if you are reading bad data due to your client's encoding option, you would rather just find `?` marks in your strings vs being blocked with exceptions. This is how things wold work via ODBC or SMS. On the other hand, writes will raise an exception. In this case we raise the SYBEICONVO/2402 error message which has a description of `Error converting characters into server's character set. Some character(s) could not be converted.`. Even though the severity of this message is only a `4` and TinyTDS will automatically strip/ignore unknown characters, we feel you should know that you are inserting bad encodings. In this way, a transaction can be rolled back, etc. Remember, any database write that has bad characters due to the client encoding will still be written to the database, but it is up to you rollback said write if needed. Most ORMs like ActiveRecord handle this scenario just fine.
 
 
+## Timeout Error Handling
+
+TinyTDS will raise a `TinyTDS::Error` when a timeout is reached based on the options supplied to the client. Depending on the reason for the timeout, the connection could be dead or alive. When db processing is the cause for the timeout, the connection should still be usable after the error is raised. When network failure is the cause of the timeout, the connection will be dead. If you attempt to execute another command batch on a dead connection you will see a `DBPROCESS is dead or not enabled` error. Therefore, it is recommended to check for a `dead?` connection before trying to execute another command batch.
+
 ## Binstubs
 
-The TinyTDS gem uses binstub wrappers which mirror compiled [FreeTDS Utilities](http://www.freetds.org/userguide/usefreetds.htm) binaries. These native executables are usually installed at the system level when installing FreeTDS. However, when using MiniPortile to install TinyTDS as we do with Windows binaries, these binstubs will find and prefer local gem `exe` directory executables. These are the following binstubs we wrap.
+The TinyTDS gem uses binstub wrappers which mirror compiled [FreeTDS Utilities](https://www.freetds.org/userguide/usefreetds.html) binaries. These native executables are usually installed at the system level when installing FreeTDS. However, when using MiniPortile to install TinyTDS as we do with Windows binaries, these binstubs will find and prefer local gem `exe` directory executables. These are the following binstubs we wrap.
 
 * tsql - Used to test connections and debug compile time settings.
 * defncopy - Used to dump schema structures.
@@ -393,28 +391,7 @@ Please read our [thread_test.rb](https://github.com/rails-sqlserver/tiny_tds/blo
 
 ## Emoji Support 😍
 
-This is possible using FreeTDS version 0.95 or higher. You must use the `use_utf16` login option or add the following config to your `freetds.conf` in either the global section or a specfic dataserver. If you are on Windows, the default location for your conf file will be in `C:\Sites`.
-
-```ini
-[global]
-  use utf-16 = true
-```
-
-The default is true and since FreeTDS v1.0 would do this as well.
-
-
-## Compiling Gems for Windows
-
-For the convenience of Windows users, TinyTDS ships pre-compiled gems for Ruby 2.0, 2.1, 2.2, and 2.3 on Windows. In order to generate these gems, [rake-compiler-dock](https://github.com/rake-compiler/rake-compiler-dock) is used. This project provides a [Docker image](https://registry.hub.docker.com/u/larskanis/rake-compiler-dock/) with rvm, cross-compilers and a number of different target versions of Ruby.
-
-Run the following rake task to compile the gems for Windows. This will check the availability of [Docker](https://www.docker.com/) (and boot2docker on Windows or OS-X) and will give some advice for download and installation. When docker is running, it will download the docker image (once-only) and start the build:
-
-```
-$ rake gem:windows
-```
-
-The compiled gems will exist in `./pkg` directory.
-
+This is possible. Since FreeTDS v1.0, utf-16 is enabled by default and supported by tiny_tds. You can toggle it by using `use_utf16` when establishing the connection.
 
 ## Development & Testing
 
@@ -424,47 +401,54 @@ First, clone the repo using the command line or your Git GUI of choice.
 $ git clone git@github.com:rails-sqlserver/tiny_tds.git
 ```
 
-After that, the quickest way to get setup for development is to use [Docker](https://www.docker.com/). Assuming you have [downloaded docker](https://www.docker.com/products/docker) for your platform and you have , you can run our test setup script.
+After that, the quickest way to get setup for development is to use the provided devcontainers setup.
 
 ```shell
-$ ./test/bin/setup.sh
+npm install -g @devcontainers/cli
+devcontainer up --workspace-folder .
+devcontainer exec --workspace-folder . bash
 ```
 
-This will download our SQL Server for Linux Docker image based from [microsoft/mssql-server-linux/](https://hub.docker.com/r/microsoft/mssql-server-linux/). Our image already has the `[tinytdstest]` DB and `tinytds` users created. Basically, it does the following.
+From within the container, you can run the tests using the following command:
 
 ```shell
-$ docker pull metaskills/mssql-server-linux-tinytds
-$ docker run -p 1433:1433 -d metaskills/mssql-server-linux-tinytds
+bundle install
+bundle exec rake test
 ```
 
-If you are using your own database. Make sure to run these SQL commands as SA to get the test database and user installed.
+You can customize the environment variables to run the tests against a different environment
 
-```sql
-CREATE DATABASE [tinytdstest];
+```shell 
+rake test TINYTDS_UNIT_DATASERVER=mydbserver TINYTDS_SCHEMA=sqlserver_2017
+rake test TINYTDS_UNIT_HOST=mydb.host.net TINYTDS_SCHEMA=sqlserver_azure
 ```
 
-```sql
-CREATE LOGIN [tinytds] WITH PASSWORD = '', CHECK_POLICY = OFF, DEFAULT_DATABASE = [tinytdstest];
-USE [tinytdstest];
-CREATE USER [tinytds] FOR LOGIN [tinytds];
-EXEC sp_addrolemember N'db_owner', N'tinytds';
-```
+### Code formatting
+
+We are using `standardrb` to format the Ruby code and Artistic Style for the C code. Run `bundle exec rake format` to format both types in one operation. Artistic Style needs to be manually installed through your package manager (e.g. `apt install -y astyle`).
+
+### Compiling Gems for Windows and Linux
 
-From here you can build and run tests against an installed version of FreeTDS.
+> [!WARNING]
+> Compiling the Gems on native Windows currently does not work.
+
+For the convenience, TinyTDS ships pre-compiled gems for supported versions of Ruby on Windows and Linux. In order to generate these gems, [rake-compiler-dock](https://github.com/rake-compiler/rake-compiler-dock) is used.
+
+Run the following rake task to compile the gems. You can run these commands from inside the devcontainers setup, or outside if neeed. The command will check the availability of [Docker](https://www.docker.com/) and will give some advice for download and installation. When docker is running, it will download the docker image (once-only) and start the build:
 
 ```shell
-$ bundle install
-$ bundle exec rake
+bundle exec rake gem:native
 ```
 
-Examples us using enviornment variables to customize the test task.
+The compiled gems will exist in `./pkg` directory.
 
+If you only need a specific gem for one platform and architecture, run this command:
+
+```shell
+bundle exec rake gem:native:x64-mingw-ucrt
 ```
-$ rake TINYTDS_UNIT_DATASERVER=mydbserver
-$ rake TINYTDS_UNIT_DATASERVER=mydbserver TINYTDS_SCHEMA=sqlserver_2008
-$ rake TINYTDS_UNIT_HOST=mydb.host.net TINYTDS_SCHEMA=sqlserver_azure
-$ rake TINYTDS_UNIT_HOST=mydb.host.net TINYTDS_UNIT_PORT=5000 TINYTDS_SCHEMA=sybase_ase
-```
+
+All the supported architectures and platforms are listed in the `Rakefile` in the `CrossLibraries` constant.
 
 ## Help & Support
 
@@ -490,4 +474,4 @@ My name is Ken Collins and I currently maintain the SQL Server adapter for Activ
 
 ## License
 
-TinyTDS is Copyright (c) 2010-2015 Ken Collins, <ken@metaskills.net> and Will Bond (Veracross LLC) <wbond@breuer.com>. It is distributed under the MIT license. Windows binaries contain pre-compiled versions of FreeTDS <http://www.freetds.org/> which is licensed under the GNU LGPL license at <http://www.gnu.org/licenses/lgpl-2.0.html>
+TinyTDS is Copyright (c) 2010-2015 Ken Collins, <ken@metaskills.net> and Will Bond (Veracross LLC) <wbond@breuer.com>. It is distributed under the MIT license. Windows and Linux binaries contain pre-compiled versions of FreeTDS <http://www.freetds.org/> and `libconv` which is licensed under the GNU LGPL license at <http://www.gnu.org/licenses/lgpl-2.0.html>. They also contain OpenSSL, which is licensed under the OpenSSL license at <https://openssl-library.org/source/license/index.html>.

data/Rakefile

@@ -1,18 +1,24 @@
-# encoding: UTF-8
-require 'rbconfig'
-require 'rake'
-require 'rake/clean'
-require 'rake/extensiontask'
-require_relative './ext/tiny_tds/extconsts'
-
-SPEC = Gem::Specification.load(File.expand_path('../tiny_tds.gemspec', __FILE__))
-GEM_PLATFORM_HOSTS = {
-  'x86-mingw32' => 'i686-w64-mingw32',
-  'x64-mingw32' => 'x86_64-w64-mingw32'
-}
+require "rbconfig"
+require "rake"
+require "rake/clean"
+require "rake/extensiontask"
+
+SPEC = Gem::Specification.load(File.expand_path("../tiny_tds.gemspec", __FILE__))
+
+CrossLibrary = Struct.new :platform, :openssl_config
+CrossLibraries = [
+  ["x64-mingw-ucrt", "mingw64"],
+  ["x64-mingw32", "mingw64"],
+  ["x86_64-linux-gnu", "linux-x86_64"],
+  ["x86_64-linux-musl", "linux-x86_64"],
+  ["aarch64-linux-gnu", "linux-aarch64"],
+  ["aarch64-linux-musl", "linux-aarch64"]
+].map do |platform, openssl_config|
+  CrossLibrary.new platform, openssl_config
+end
 
 # Add our project specific files to clean for a rebuild
-CLEAN.include FileList["{ext,lib}/**/*.{so,#{RbConfig::CONFIG['DLEXT']},o}"],
+CLEAN.include FileList["{ext,lib}/**/*.{so,#{RbConfig::CONFIG["DLEXT"]},o}"],
   FileList["exe/*"]
 
 # Clobber all our temp files and ports files including .install files
@@ -20,34 +26,47 @@ CLEAN.include FileList["{ext,lib}/**/*.{so,#{RbConfig::CONFIG['DLEXT']},o}"],
 CLOBBER.include FileList["tmp/**/*"],
   FileList["ports/**/*"].exclude(%r{^ports/archives})
 
-Dir['tasks/*.rake'].sort.each { |f| load f }
+Dir["tasks/*.rake"].sort.each { |f| load f }
 
-Rake::ExtensionTask.new('tiny_tds', SPEC) do |ext|
-  ext.lib_dir = 'lib/tiny_tds'
+Rake::ExtensionTask.new("tiny_tds", SPEC) do |ext|
+  ext.lib_dir = "lib/tiny_tds"
   ext.cross_compile = true
-  ext.cross_platform = GEM_PLATFORM_HOSTS.keys
+  ext.cross_platform = CrossLibraries.map(&:platform)
 
   # Add dependent DLLs to the cross gems
   ext.cross_compiling do |spec|
     # The fat binary gem doesn't depend on the freetds package, since it bundles the library.
-    spec.metadata.delete('msys2_mingw_dependencies')
-
-    platform_host_map = GEM_PLATFORM_HOSTS
-    gemplat = spec.platform.to_s
-    host = platform_host_map[gemplat]
+    spec.metadata.delete("msys2_mingw_dependencies")
 
-    # We don't need the sources in a fat binary gem
-    spec.files = spec.files.reject { |f| f =~ %r{^ports\/archives/} }
-
-    # Make sure to include the ports binaries and libraries
-    spec.files += FileList["ports/#{host}/**/**/{bin,lib}/*"].exclude do |f|
-      File.directory? f
+    if /mingw/.match?(spec.platform.to_s)
+      spec.files += [
+        "ports/#{spec.platform}/bin/libsybdb-5.dll",
+        "ports/#{spec.platform}/bin/defncopy.exe",
+        "ports/#{spec.platform}/bin/tsql.exe"
+      ]
+    elsif /linux/.match?(spec.platform.to_s)
+      spec.files += [
+        "ports/#{spec.platform}/lib/libsybdb.so.5",
+        "ports/#{spec.platform}/bin/defncopy",
+        "ports/#{spec.platform}/bin/tsql"
+      ]
     end
+  end
 
-    spec.files += Dir.glob('exe/*')
+  ext.cross_config_options += CrossLibraries.map do |xlib|
+    {
+      xlib.platform => [
+        "--with-cross-build=#{xlib.platform}",
+        "--with-openssl-platform=#{xlib.openssl_config}"
+      ]
+    }
   end
 end
 
 task build: [:clean, :compile]
 task default: [:build, :test]
 
+task :format do
+  system("bundle exec standardrb --fix")
+  system('astyle --options=astyle.conf "./ext/*.c" "./ext/*.h"')
+end

data/VERSION

@@ -1 +1 @@
-2.1.2
+3.4.0

data/astyle.conf

@@ -0,0 +1,8 @@
+--style=1tbs
+--break-blocks
+--indent-preproc-block
+--indent-preproc-cond
+--indent=spaces=2
+--indent-switches
+--recursive
+--suffix=none