snowflake_odbc_adapter 7.2.0

data/lib/active_record/connection_adapters/snowflake_odbc/database_statements.rb

@@ -0,0 +1,117 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SnowflakeOdbc
+      module DatabaseStatements # :nodoc:
+        # Have to because of create table
+        def prepared_statements
+          true
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        # Returns the number of rows affected.
+        def execute(sql, name = nil, binds = [])
+          log(sql, name, binds) do |notification_payload|
+            rc = @raw_connection.do(sql, *binds.map { |bind| prepare_bind(bind).to_s })
+            notification_payload[:row_count] = rc
+            rc
+          end
+        end
+
+        # Executes delete +sql+ statement in the context of this connection using
+        # +binds+ as the bind substitutes. +name+ is logged along with
+        # the executed +sql+ statement.
+        def exec_delete(sql, name, binds)
+          execute(sql, name, binds)
+        end
+
+        # Begins the transaction (and turns off auto-committing).
+        def begin_db_transaction
+          @raw_connection.autocommit = false
+        end
+
+        # Commits the transaction (and turns on auto-committing).
+        def commit_db_transaction
+          @raw_connection.commit
+          @raw_connection.autocommit = true
+        end
+
+        # Rolls back the transaction (and turns on auto-committing). Must be
+        # done if the transaction block raises an exception or returns false.
+        def exec_rollback_db_transaction
+          @raw_connection.rollback
+          @raw_connection.autocommit = true
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
+          log(sql, name, binds) do |notification_payload|
+            if prepare || binds.any?
+              # TODO: refacto
+              stmt = @raw_connection.prepare(sql)
+              binds.each_with_index do |bind, i|
+                if bind.respond_to?("value_for_database") && bind.value.is_a?(Integer) || bind.is_a?(Integer)
+                  stmt.param_type(i, ODBC::SQL_INTEGER)
+                end
+              end
+              stmt.execute(*binds.map { |bind| prepare_bind(bind).to_s })
+            else
+              stmt = @raw_connection.run(sql)
+            end
+            columns = stmt.columns
+            values  = stmt.to_a
+            stmt.drop
+            notification_payload[:row_count] = values.count
+            values = values&.map { |row| row&.map { |value| _type_cast_value(value) } }
+            column_names = columns.keys.map { |key| format_case(key) }
+            ActiveRecord::Result.new(column_names, values)
+          end
+        end
+
+        def bind_params(binds, sql)
+          prepared_binds = *prepared_binds(binds)
+          prepared_binds.each.with_index(1) do |val, ind|
+            sql = sql.gsub("$#{ind}", "'#{val}'")
+          end
+          sql
+        end
+
+        def prepared_binds(binds)
+          binds.map(&:value_for_database)
+        end
+
+        private
+
+        def prepare_bind(bind)
+          if bind.respond_to?("value_for_database")
+            type_cast(bind.value_for_database)
+          elsif bind.is_a?(Integer)
+            bind.to_i
+          else
+            bind.to_s
+          end
+        end
+
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          @raw_connection.do(sql)
+        end
+
+        # type cast value to handle ODBC::TimeStamp
+        def _type_cast_value(value)
+          if value.is_a?(ODBC::TimeStamp)
+            Time.parse(value.to_s)
+          else
+            value
+          end
+        end
+
+        # Assume received identifier is in DBMS's data dictionary case.
+        def format_case(identifier)
+          if ::SnowflakeOdbcAdapter::Metadata.instance.upcase_identifiers?
+            identifier =~ /[a-z]/ ? identifier : identifier.downcase
+          else
+            identifier
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/snowflake_odbc/quoting.rb

@@ -0,0 +1,42 @@
+require "snowflake_odbc_adapter/metadata"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SnowflakeOdbc
+      module Quoting # :nodoc:
+        extend ActiveSupport::Concern # :nodoc:
+        module ClassMethods # :nodoc:
+          # Returns a quoted form of the column name.
+          def quote_column_name(name)
+            name = name.to_s
+            quote_char = identifier_quote_char.to_s.strip
+            return name if quote_char.empty?
+
+            quote_char = quote_char[0]
+            # Avoid quoting any already quoted name
+            return name if name[0] == quote_char && name[-1] == quote_char
+
+            # If upcase identifiers, only quote mixed case names.
+            return name if upcase_identifiers? && name !~ /([A-Z]+[a-z])|([a-z]+[A-Z])/
+
+            "#{quote_char.chr}#{name}#{quote_char.chr}"
+          end
+
+          def quote_table_name(name)
+            name
+          end
+
+          private
+
+          def identifier_quote_char
+            ::SnowflakeOdbcAdapter::Metadata.instance.identifier_quote_char
+          end
+
+          def upcase_identifiers?
+            ::SnowflakeOdbcAdapter::Metadata.instance.upcase_identifiers?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/snowflake_odbc/schema_statements.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SnowflakeOdbc
+      module SchemaStatements # :nodoc:
+        # ODBC constants missing from Christian Werner's Ruby ODBC driver
+        SQL_NO_NULLS = 0
+        SQL_NULLABLE = 1
+        SQL_NULLABLE_UNKNOWN = 2
+
+        def data_sources
+          tables | views
+        end
+
+        # Returns a Hash of mappings from the abstract data types to the native
+        # database types. See TableDefinition#column for details on the recognized
+        # abstract data types.
+        def native_database_types
+          @native_database_types ||= ::SnowflakeOdbcAdapter::ColumnMetadata.new(self).native_database_types
+        end
+
+        # Returns an array of table names, for database tables visible on the
+        # current connection.
+        def tables(_name = nil)
+          stmt   = @raw_connection.tables
+          result = stmt.fetch_all || []
+          stmt&.drop
+          result = ::SnowflakeOdbcAdapter::Snowflake.table_filter(result, @raw_connection)
+          result.each_with_object([]) do |row, table_names|
+            table_names << format_case(row[2])
+          end
+        end
+
+        # Returns an array of view names, for database views visible on the
+        # current connection.
+        def views(_name = nil)
+          stmt   = @raw_connection.tables
+          result = stmt.fetch_all || []
+          stmt&.drop
+          result = ::SnowflakeOdbcAdapter::Snowflake.view_filter(result, @raw_connection)
+          result.each_with_object([]) do |row, table_names|
+            table_names << format_case(row[2])
+          end
+        end
+
+        # Checks to see if the table +table_name+ exists on the database.
+        #
+        #   table_exists?(:developers)
+        #
+        def table_exists?(table_name)
+          stmt = @raw_connection.tables(native_case(table_name.to_s))
+          result = stmt.fetch_all || []
+          stmt.drop
+          result.size.positive?
+        end
+
+        def column_definitions(table_name)
+          stmt = @raw_connection.columns(native_case(table_name.to_s))
+          result = stmt.fetch_all || []
+          stmt.drop
+          # Column can return some technical columns
+          ::SnowflakeOdbcAdapter::Snowflake.column_filters(result)
+        end
+
+        def new_column_from_field(table_name, field, _definitions)
+          col_name = field[3]
+          SnowflakeOdbc::Column.new(
+            format_case(col_name), # SQLColumns: COLUMN_NAME,
+            field[12], # SQLColumns: COLUMN_DEF,
+            sql_type_metadata(field),
+            nullability(field[17], field[10])
+          )
+        end
+
+        def primary_key(table_name)
+          stmt   = @raw_connection.primary_keys(native_case(table_name.to_s))
+          result = stmt.fetch_all || []
+          stmt&.drop
+          result[0] && format_case(result[0][3])
+        end
+
+        def rename_table(table_name, new_name, **options)
+          validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+          clear_cache!
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
+          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
+        end
+
+        # Renames a column in a table.
+        def rename_column(table_name, column_name, new_column_name) # :nodoc:
+          clear_cache!
+          execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name,
+                                                                                   new_column_name)}")
+        end
+
+        private
+
+        def sql_type_metadata(col)
+          col_scale       = col[8]  # SQLColumns: DECIMAL_DIGITS
+          col_sql_type    = col[4]  # SQLColumns: DATA_TYPE
+          col_limit       = col[6]  # SQLColumns: COLUMN_SIZE
+          args = { sql_type: col_sql_type, type: col_sql_type, limit: col_limit }
+          col_native_type = col[5]  # SQLColumns: TYPE_NAME
+          args[:sql_type] = ::SnowflakeOdbcAdapter::Snowflake.type_mapper(col)
+          args[:sql_type] = "boolean" if col_native_type == "BOOLEAN"
+          args[:sql_type] = "json" if %w[VARIANT JSON STRUCT].include?(col_native_type)
+          args[:sql_type] = "date" if col_native_type == "DATE"
+          if [ ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC ].include?(col_sql_type)
+            args[:scale]     = col_scale || 0
+            args[:precision] = col_limit
+          end
+          ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(**args)
+        end
+
+        def native_case(identifier)
+          if ::SnowflakeOdbcAdapter::Metadata.instance.upcase_identifiers?
+            identifier =~ /[A-Z]/ ? identifier : identifier.upcase
+          else
+            identifier
+          end
+        end
+
+        # Assume column is nullable if nullable == SQL_NULLABLE_UNKNOWN
+        def nullability(is_nullable, nullable)
+          not_nullable = !is_nullable || !nullable.to_s.match("NO").nil?
+          !(not_nullable || nullable == SQL_NO_NULLS)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/snowflake_odbc_adapter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/snowflake_odbc/quoting"
+require "active_record/connection_adapters/snowflake_odbc/database_statements"
+require "active_record/connection_adapters/snowflake_odbc/schema_statements"
+require "active_record/connection_adapters/snowflake_odbc/column"
+require "snowflake_odbc_adapter/metadata"
+require "snowflake_odbc_adapter/column_metadata"
+require "odbc"
+require "odbc_utf8"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SnowflakeOdbcAdapter < AbstractAdapter
+      ADAPTER_NAME = "ODBC"
+
+      include SnowflakeOdbc::Quoting
+      include SnowflakeOdbc::DatabaseStatements
+      include SnowflakeOdbc::SchemaStatements
+
+      class << self
+        def new_client(config)
+          config = config.symbolize_keys
+          _, config = if config.key?(:dsn)
+            dsn_connection(config)
+          elsif config.key?(:conn_str)
+            str_connection(config)
+          else
+            raise ArgumentError, "No data source name (:dsn) or connection string (:conn_str) specified."
+          end
+        rescue ::ODBC::Error => error
+          # TODO: be more specific on error to raise
+          raise ActiveRecord::ConnectionNotEstablished, error.message
+        end
+
+        def dbconsole(config, options = {})
+          raise NotImplementedError
+        end
+
+        private
+        def dsn_connection(config)
+          raise NotImplementedError
+        end
+
+        def str_connection(config)
+          attrs = config[:conn_str].split(";").map { |option| option.split("=", 2) }.to_h
+          odbc_module = attrs["ENCODING"] == "utf8" ? ODBC_UTF8 : ODBC
+          driver = odbc_module::Driver.new
+          driver.name = "odbc"
+          driver.attrs = attrs
+          connection = odbc_module::Database.new.drvconnect(driver)
+          # encoding_bug indicates that the driver is using non ASCII and has the issue referenced here https://github.com/larskanis/ruby-odbc/issues/2
+          [ connection, config.merge(driver: driver, encoding: attrs["ENCODING"], encoding_bug: attrs["ENCODING"] == "utf8") ]
+        end
+
+
+        def initialize_type_map(m)
+          super(m)
+          # Integer are negated by active record
+          m.register_type (-1 * ODBC::SQL_TIMESTAMP),    Type::DateTime.new
+          m.register_type "boolean",                     Type::Boolean.new
+          m.register_type "json",                        Type::Json.new
+          m.register_type (-1 * ODBC::SQL_CHAR),         Type::String.new
+          m.register_type (-1 * ODBC::SQL_LONGVARCHAR),  Type::Text.new
+          m.register_type (-1 * ODBC::SQL_TINYINT),      Type::Integer.new(limit: 4)
+          m.register_type (-1 * ODBC::SQL_SMALLINT),     Type::Integer.new(limit: 8)
+          m.register_type (-1 * ODBC::SQL_INTEGER),      Type::Integer.new(limit: 16)
+          m.register_type (-1 * ODBC::SQL_BIGINT),       Type::BigInteger.new(limit: 32)
+          m.register_type (-1 * ODBC::SQL_REAL),         Type::Float.new(limit: 24)
+          m.register_type (-1 * ODBC::SQL_FLOAT),        Type::Float.new
+          m.register_type (-1 * ODBC::SQL_DOUBLE),       Type::Float.new(limit: 53)
+          m.register_type (-1 * ODBC::SQL_DECIMAL),      Type::Float.new
+          m.register_type (-1 * ODBC::SQL_NUMERIC),      Type::Integer.new
+          m.register_type (-1 * ODBC::SQL_BINARY),       Type::Binary.new
+          m.register_type (-1 * ODBC::SQL_DATE),         Type::Date.new
+          m.register_type (-1 * ODBC::SQL_DATETIME),     Type::DateTime.new
+          m.register_type (-1 * ODBC::SQL_TIME),         Type::Time.new
+          m.register_type (-1 * ODBC::SQL_TIMESTAMP),    Type::DateTime.new
+          m.register_type (-1 * ODBC::SQL_GUID),         Type::String.new
+
+          alias_type m, (-1 * ODBC::SQL_BIT),            "boolean"
+          alias_type m, (-1 * ODBC::SQL_VARCHAR),        (-1 * ODBC::SQL_CHAR)
+          alias_type m, (-1 * ODBC::SQL_WCHAR),          (-1 * ODBC::SQL_CHAR)
+          alias_type m, (-1 * ODBC::SQL_WVARCHAR),       (-1 * ODBC::SQL_CHAR)
+          alias_type m, (-1 * ODBC::SQL_WLONGVARCHAR),   (-1 * ODBC::SQL_LONGVARCHAR)
+          alias_type m, (-1 * ODBC::SQL_VARBINARY),      (-1 * ODBC::SQL_BINARY)
+          alias_type m, (-1 * ODBC::SQL_LONGVARBINARY),  (-1 * ODBC::SQL_BINARY)
+          alias_type m, (-1 * ODBC::SQL_TYPE_DATE),      (-1 * ODBC::SQL_DATE)
+          alias_type m, (-1 * ODBC::SQL_TYPE_TIME),      (-1 * ODBC::SQL_TIME)
+          alias_type m, (-1 * ODBC::SQL_TYPE_TIMESTAMP), (-1 * ODBC::SQL_TIMESTAMP)
+        end
+
+        # Can't use the built-in ActiveRecord map#alias_type because it doesn't
+        # work with non-string keys, and in our case the keys are (almost) all
+        # numeric
+        def alias_type(map, new_type, old_type)
+          map.register_type(new_type) do |_, *args|
+            map.lookup(old_type, *args)
+          end
+        end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def initialize(...)
+        super
+        @raw_connection, @config = self.class.new_client(@config)
+        @raw_connection.use_time = true
+        ::SnowflakeOdbcAdapter::Metadata.instance.connection(@config, @raw_connection)
+      end
+
+      def supports_insert_returning?
+        false
+      end
+
+      def active?
+        @raw_connection.connected?
+      end
+
+      def reconnect
+        @raw_connection, @config = self.class.new_client(@config)
+      end
+
+      def disconnect!
+        @raw_connection.disconnect if @raw_connection.connected?
+      end
+    end
+    register "odbc", "ActiveRecord::ConnectionAdapters::SnowflakeOdbcAdapter", "active_record/connection_adapters/snowflake_odbc_adapter"
+  end
+end

data/lib/snowflake_odbc_adapter/column_metadata.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "odbc"
+require "snowflake_odbc_adapter/snowflake"
+
+module SnowflakeOdbcAdapter
+  class ColumnMetadata # :nodoc:
+    GENERICS = {
+      primary_key: [ ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT ],
+      string: [ ODBC::SQL_VARCHAR ],
+      text: [ ODBC::SQL_LONGVARCHAR, ODBC::SQL_VARCHAR ],
+      integer: [ ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT ],
+      decimal: [ ODBC::SQL_NUMERIC, ODBC::SQL_DECIMAL ],
+      float: [ ODBC::SQL_DOUBLE, ODBC::SQL_REAL ],
+      datetime: [ ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP ],
+      timestamp: [ ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP ],
+      time: [ ODBC::SQL_TYPE_TIME, ODBC::SQL_TIME, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP ],
+      date: [ ODBC::SQL_TYPE_DATE, ODBC::SQL_DATE, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP ],
+      binary: [ ODBC::SQL_LONGVARBINARY, ODBC::SQL_VARBINARY ],
+      boolean: [ ODBC::SQL_BIT, ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT, ODBC::SQL_INTEGER ],
+      json: [ 2004 ]
+    }.freeze
+
+    attr_reader :adapter
+
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def native_database_types
+      grouped = reported_types.group_by { |row| row[1] }
+
+      GENERICS.each_with_object({}) do |(abstract, candidates), mapped|
+        candidates.detect do |candidate|
+          next unless grouped[candidate]
+
+          mapped[abstract] = native_type_mapping(abstract, grouped[candidate])
+        end
+      end
+    end
+
+    private
+
+    # Creates a Hash describing a mapping from an abstract type to a
+    # DBMS native type for use by #native_database_types
+    def native_type_mapping(abstract, rows)
+      # The appropriate SQL for :primary_key is hard to derive as
+      # ODBC doesn't provide any info on a DBMS's native syntax for
+      # autoincrement columns. So we use a lookup instead.
+      return Snowflake::PRIMARY_KEY if abstract == :primary_key
+
+      selected_row = rows[0]
+
+      # If more than one native type corresponds to the SQL type we're
+      # handling, the type in the first descriptor should be the
+      # best match, because the ODBC specification states that
+      # SQLGetTypeInfo returns the results ordered by SQL type and then by
+      # how closely the native type maps to that SQL type.
+      # But, for :text and :binary, select the native type with the
+      # largest capacity. (Compare SQLGetTypeInfo:COLUMN_SIZE values)
+      selected_row = rows.max_by { |row| row[2] } if %i[text binary].include?(abstract)
+      result = { name: selected_row[0] } # SQLGetTypeInfo: TYPE_NAME
+
+      create_params = selected_row[5]
+      # Depending on the column type, the CREATE_PARAMS keywords can
+      # include length, precision or scale.
+      if create_params && !create_params.strip.empty? && ! %i[decimal json].include?(abstract)
+        result[:limit] = selected_row[2] # SQLGetTypeInfo: COL_SIZE
+      end
+      result
+    end
+
+    def reported_types
+      @reported_types ||=
+        begin
+          stmt = adapter.raw_connection.types
+          stmt.fetch_all
+        ensure
+          stmt&.drop
+        end
+    end
+  end
+end

data/lib/snowflake_odbc_adapter/metadata.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module SnowflakeOdbcAdapter
+  class Metadata # :nodoc:
+    include Singleton
+
+    FIELDS = %i[
+      SQL_DBMS_NAME
+      SQL_DBMS_VER
+      SQL_IDENTIFIER_CASE
+      SQL_QUOTED_IDENTIFIER_CASE
+      SQL_IDENTIFIER_QUOTE_CHAR
+      SQL_MAX_IDENTIFIER_LEN
+      SQL_MAX_TABLE_NAME_LEN
+      SQL_USER_NAME
+      SQL_DATABASE_NAME
+    ].freeze
+
+    attr_reader :identifier_quote_char
+
+    def initialize
+      @mutex = Mutex.new
+    end
+
+    FIELDS.each do |field|
+      define_method(field.to_s.downcase.gsub("sql_", "")) do
+        metadata[field]
+      end
+    end
+
+    def upcase_identifiers?
+      (identifier_case == ODBC::SQL_IC_UPPER)
+    end
+
+    def connection(config, connection)
+      unless @connection
+        with_mutex do
+          @connection = connection
+        end
+      end
+      @connection
+    end
+
+    private
+
+    def metadata
+      raise "Need to connect" unless @connection
+
+      unless @metadata
+        with_mutex do
+          @metadata = Hash[FIELDS.map do |field|
+            info = @connection.get_info(ODBC.const_get(field))
+            [ field, info ]
+          end]
+        end
+      end
+      @metadata
+    end
+
+    def with_mutex(&block)
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/lib/snowflake_odbc_adapter/snowflake.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SnowflakeOdbcAdapter
+  # Snowflake specific overrides
+  module Snowflake
+    PRIMARY_KEY = "BIGINT UNIQUE PRIMARY KEY AUTOINCREMENT START 1 INCREMENT 1 ORDER "
+    class << self
+      # Remove Snowflake specific columns
+      def column_filters(columns)
+        columns.reject { |col| col[0] =~ /^snowflake$/i }.reject { |col| col[1] =~ /^account_usage$/i }
+      end
+
+      def type_mapper(col)
+        # Transform DECIMAL 38 0 into BIGINT ODBC Specific
+        return "bigint" if col[4] == ODBC::SQL_DECIMAL && col[8] == 0 && col[6] == 38
+        col[4]
+      end
+
+      # Remove outside database tables
+      def table_filter(tables, connection)
+        database = connection.get_info(ODBC::SQL_DATABASE_NAME)
+        tables.select { |table| table[0] == database && table[3] =~ /^TABLE$/i }
+      end
+
+      # Remove outside database views
+      def view_filter(tables, connection)
+        database = connection.get_info(ODBC::SQL_DATABASE_NAME)
+        tables.select do |table|
+          table[0] == database && table[3] =~ /^VIEW$/i && table[1] !~ /^information_schema$/i
+        end
+      end
+    end
+  end
+end

data/lib/snowflake_odbc_adapter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SnowflakeOdbcAdapter
+  VERSION = "7.2.0"
+end

data/lib/snowflake_odbc_adapter.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "snowflake_odbc_adapter/version"
+require "active_record/connection_adapters/snowflake_odbc_adapter"

data/sig/snowflake_odbc_adapter.rbs

@@ -0,0 +1,4 @@
+module SnowflakeOdbcAdapter
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/snowflake_odbc_adapter.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/snowflake_odbc_adapter/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "snowflake_odbc_adapter"
+  spec.version = SnowflakeOdbcAdapter::VERSION
+  spec.authors = [ "Guillaume GILLET" ]
+  spec.email = [ "guillaume.gillet@singlespot.com" ]
+
+  spec.summary = "ODBC ActiveRecord adapter design for Snowflake"
+  spec.description = <<~TXT
+    As the generic odbc adapter https://github.com/localytics/odbc_adapter is no longer maintain and
+    do not follow the rails evolution, we need to create our own.
+  TXT
+  spec.homepage = "https://github.com/singlespot/snowflake_odbc_adapter"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/GuillaumeGillet/snowflake_odbc_adapter"
+  spec.metadata["changelog_uri"] = "https://github.com/GuillaumeGillet/snowflake_odbc_adapter/CHANGELOG.md."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = [ "lib" ]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activerecord", ">= 7.2"
+  spec.add_dependency "ruby-odbc"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end