activerecord-adbc-adapter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c7d09e5234b5077f35cb5ea1b42067bb214e6cd41070e31160aaeab53fca4368
+  data.tar.gz: 21eb666112941a0998a6b5482d58a93b5e23dc83d07b5c40703ffba971b37cf3
+SHA512:
+  metadata.gz: b3cbdef06e5151fc373008042154a1f7134bbb346dde5322e8124796449e33a7c02b28c05723fa3c39771cf2019cab295d3c2def17a70b0cb1539bde5e702c39
+  data.tar.gz: f749b486c3da75fffd5f60060b9bcc5558eb03fab97c7fbdd9b94178fec31af2c398e0f03102c83ba9d7c5d8ca782363099ae88b8d2592bd049f4367ca18907d

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2023 Sutou Kouhei <kou@clear-code.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,223 @@
+# Active Record ADBC adapter
+
+## Description
+
+Active Record ADBC adapter provides an
+[ADBC](https://arrow.apache.org/adbc/) adapter for Active Record.
+
+This adapter is optimized for extracting and loading large data
+from/to DBs. The optimization is powered by Apache Arrow.
+
+## Install
+
+### `Gemfile`
+
+Add
+[rubygems-requirements-system](https://rubygems.org/gems/rubygems-requirements-system)
+plugin and activerecord-adbc-adapter gem to your `Gemfile`:
+
+```ruby
+plugin "rubygems-requirements-system"
+
+gem "activerecord-adbc-adapter"
+```
+
+This adapter requires ADBC libraries implemented in C++. The
+rubygems-requirements-system plugin installs it into your system
+automatically.
+
+### GitHub Actions
+
+On GitHub Actions, you should not use the [`bundler-cache:
+true`](https://github.com/ruby/setup-ruby?tab=readme-ov-file#caching-bundle-install-automatically)
+option. Because it only caches activerecord-adbc-adapter gem. It
+doesn't cache ADBC libraries installed into your system. You need to
+run `bundle install` after `actions/setup-ruby` something like the
+following:
+
+```yaml
+- uses: ruby/setup-ruby@v1
+  with:
+    ruby-version: ruby
+    # bundler-cache: true # No "bundler-cache: true"
+- run: bundle install
+```
+
+### ADBC driver
+
+You also need to install ADBC drivers for systems you want to
+connect. For example, you need the ADBC driver for PostgreSQL when you
+want to connect to PostgreSQL.
+
+See https://arrow.apache.org/adbc/current/driver/installation.html for
+the latest information.
+
+Here is information for some drivers:
+
+PostgreSQL:
+
+```bash
+# Debian/Ubuntu
+sudo apt install libadbc-driver-postgresql-dev
+```
+
+```bash
+# Red Hat Enterprise Linux variants
+sudo dnf install adbc-driver-postgresql-devel
+```
+
+SQLite:
+
+```bash
+# Debian/Ubuntu
+sudo apt install libadbc-driver-sqlite-dev
+```
+
+```bash
+# Red Hat Enterprise Linux variants
+sudo dnf install adbc-driver-sqlite-devel
+```
+
+DuckDB: You don't need to install additional packages for ADBC
+support. `libduckdb.so` includes ADBC support.
+
+## Usage
+
+This adapter is optimized for extracting and loading large data
+from/to DBs. You should use the built-in adapters for normal CRUD use
+cases. You should use this adapter only for large data.
+
+You can use the Active Record's [multiple databases
+support](https://guides.rubyonrails.org/active_record_multiple_databases.html)
+feature.
+
+### `config/database.yml`
+
+Here is a sample `config/database.yml`. The `primary` configuration is
+for the built-in PostgreSQL adapter. The `adbc` configuration is for
+this adapter.
+
+```yaml
+default: &default
+  primary:
+    adapter: postgresql
+    encoding: unicode
+    pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+    url: <%= ENV.fetch("DATABASE_URL") { "postgresql:///my_app_#{Rails.env}" } %>
+  adbc:
+    adapter: adbc
+    driver: adbc_driver_postgresql
+    # "uri" not "url"!!!
+    uri: <%= ENV.fetch("DATABASE_URL") { "postgresql:///my_app_#{Rails.env}" } %>
+    # You need this to avoid migration.
+    database_tasks: false
+development:
+  <<: *default
+test:
+  <<: *default
+production:
+  <<: *default
+```
+
+> [!NOTE]
+>
+> Configuration parameters are different for each ADBC driver. For
+> example, [the PostgreSQL
+> driver](https://arrow.apache.org/adbc/current/driver/postgresql.html)
+> and [the SQLite
+> driver(https://arrow.apache.org/adbc/current/driver/sqlite.html) use
+> `uri` for connection information but [the DuckDB
+> driver](https://duckdb.org/docs/stable/clients/adbc.html) uses
+> `entrypoint` and `path`:
+>
+> ```yaml
+> adbc:
+>   adapter: adbc
+>   driver: duckdb
+>   entrypoint: duckdb_adbc_init # You should not change this.
+>   path: <%= ENV.fetch("DATABASE_PATH") { Rails.root.join("db", "#{Rails.env}.duckdb") } %>
+>   # You need this to avoid migration.
+>   database_tasks: false
+> ```
+>
+> See the driver's documentation for available parameters.
+
+### Model
+
+You need to create an abstract class for the ADBC connection:
+
+```ruby
+# app/models/adbc_application_record.rb
+class AdbcApplicationRecord < ActiveRecord::Base
+  include ActiveRecordADBCAdapter::Ingest
+
+  self.abstract_class = true
+  connects_to database: { writing: :adbc, reading: :adbc }
+end
+```
+
+You can create a model for the ADBC connection:
+
+```ruby
+# app/models/adbc_event.rb
+class AdbcEvent < AdbcApplicationRecord
+  self.table_name = :events
+end
+```
+
+You can use `Event` (that is derived from `ApplicationRecord` not
+`AdbcApplicationRecord`) model for normal use case and `AdbcEvent` for
+large data use case. For the large data use case, you should use
+Apache Arrow data as-is as much as possible for performance. You can
+get Apache Arrow data by `#to_arrow`:
+
+```ruby
+AdbcEvent.all.to_arrow
+```
+
+You can use `.ingest` to load Apache Arrow data:
+
+```ruby
+AdbcEvent.ingest(arrow_data)
+```
+
+You can copy large data efficiently by these method. Here is an sample
+code to copy events in the latest 30 days to DuckDB from PostgreSQL:
+
+```ruby
+DuckDBAdbcEvent.ingest(PgAdbcEvent.where(created_at: ..(1.month.ago)).to_arrow)
+```
+
+## Performance
+
+Here is a benchmark result with 100 integer columns and 10000 rows
+load/dump with PostgreSQL. This adapter is faster than Active Record's
+built-in PostgreSQL adapter and raw SQL (`INSERT INTO ...` and
+`SELECT * FROM ...`).
+
+Load:
+
+```text
+                   user     system      total        real
+SQL            0.003738   0.003141   0.006879 (  0.350767)
+Active Record  2.423670   0.047003   2.470673 (  2.844029)
+ADBC           0.010229   0.010960   0.021189 (  0.075787)
+```
+
+Dump:
+
+```text
+                   user     system      total        real
+SQL            0.110934   0.006219   0.117153 (  0.123201)
+Active Record  0.271154   0.008948   0.280102 (  0.283621)
+ADBC           0.026966   0.006945   0.033911 (  0.067801)
+```
+
+![Load and dump](benchmark/load-dump.svg)
+
+
+See [`benchmark/`](benchmark/) for details.
+
+## License
+
+The MIT license. See `LICENSE.txt` for details.

data/lib/activerecord-adbc-adapter.rb

@@ -0,0 +1,10 @@
+require "active_record"
+
+require_relative "activerecord_adbc_adapter/ingest"
+require_relative "activerecord_adbc_adapter/version"
+
+module ActiveRecord::ConnectionAdapters
+  register("adbc",
+           "ActiveRecordADBCAdapter::Adapter",
+           "activerecord_adbc_adapter/adapter")
+end

data/lib/activerecord_adbc_adapter/adapter.rb

@@ -0,0 +1,209 @@
+require "adbc"
+
+require_relative "column"
+require_relative "database_statements"
+require_relative "quoting"
+require_relative "relation_arrowable"
+require_relative "result"
+require_relative "schema_creation"
+require_relative "schema_definitions"
+require_relative "schema_statements"
+
+module ActiveRecordADBCAdapter
+  # = Active Record ADBC Adapter
+  #
+  # ...
+  #
+  # Options:
+  #
+  # * ...
+  class Adapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+    ADAPTER_NAME = "ADBC"
+
+    class Connection
+      def initialize(**params)
+        params.delete(:database_tasks)
+        @database = ADBC::Database.open(**params)
+        @connection = @database.connect
+      end
+
+      def close
+        if @connection
+          @connection.release
+          @connection = nil
+        end
+        @database.release
+        @database = nil
+      end
+
+      def reconnect
+        if @connection
+          @connection.release
+          @connection = @database.connect
+        end
+      end
+
+      def open_statement(&block)
+        @connection.open_statement(&block)
+      end
+
+      if ADBC::Connection.method_defined?(:get_objects_raw)
+        # red-adbc provides convenient wrapper
+        def get_objects(...)
+          @connection.get_objects(...)
+        end
+      else
+        def get_objects(depth: :all,
+                        catalog: nil,
+                        db_schema: nil,
+                        table_name: nil,
+                        table_types: nil,
+                        column_name: nil)
+          reader = @connection.get_objects(depth,
+                                           catalog,
+                                           db_schema,
+                                           table_name,
+                                           table_types,
+                                           column_name)
+          begin
+            reader.read_all
+          ensure
+            reader.unref
+          end
+        end
+      end
+    end
+
+    class << self
+      def new_client(params)
+        Connection.new(**params)
+      end
+    end
+
+    include DatabaseStatements
+    include Quoting
+    include SchemaStatements
+
+    FEATURES = [
+      :supports_insert_on_duplicate_skip,
+    ]
+
+    def initialize(...)
+      super
+
+      @connection_parameters = @config.compact
+      @connection_parameters.delete(:adapter)
+
+      @raw_connection = nil
+
+      @features = {}
+    end
+
+    FEATURES.each do |feature|
+      define_method("#{feature}?") do
+        @features[feature]
+      end
+    end
+
+    def connect
+      @raw_connection = self.class.new_client(@connection_parameters)
+      detect_features
+      @raw_connection
+    end
+
+    def reconnect
+      @lock.synchronize do
+        @raw_connection&.reconnect
+      end
+
+      connect unless @raw_connection
+    end
+
+    def active?
+      @lock.synchronize do
+        return false unless @raw_connection
+      end
+      true
+    end
+
+    def disconnect!
+      @lock.synchronize do
+        super
+        @raw_connection&.close rescue nil
+        @raw_connection = nil
+      end
+    end
+
+    # Borrowed from
+    # ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#build_insert_sql.
+    #
+    # Copyright (c) David Heinemeier Hansson
+    #
+    # The MIT license.
+    def build_insert_sql(insert)
+      sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+      if insert.skip_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+      elsif insert.update_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        if insert.raw_update_sql?
+          sql << insert.raw_update_sql
+        else
+          sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
+          sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+        end
+      end
+
+      sql << " RETURNING #{insert.returning}" if insert.returning
+      sql
+    end
+
+    def ingest(table_name, attributes, name: nil)
+      log(table_name, name) do |notification_payload|
+        with_raw_connection do |raw_connection|
+          raw_connection.open_statement do |statement|
+            statement.ingest(table_name, attributes, mode: :append)
+          end
+        end
+      end
+    end
+
+    def backend
+      # We can't use @connection_parameters here because #arel_visitor
+      # is called before Adapter#initialize. (#arel_visitor is called
+      # in AbstractAdapter#initialize.)
+      @config[:driver].gsub(/\Aadbc_driver_/, "")
+    end
+
+    def arel_visitor
+      case backend
+      when "postgresql"
+        Arel::Visitors::PostgreSQL.new(self)
+      else
+        super
+      end
+    end
+
+    private
+    def detect_features
+      detect_features_method = "detect_features_#{backend}"
+      if respond_to?(detect_features_method, true)
+        __send__(detect_features_method)
+      end
+    end
+
+    def detect_features_duckdb
+      @features[:supports_insert_on_duplicate_skip] = true
+    end
+
+    def detect_features_postgresql
+      @features[:supports_insert_on_duplicate_skip] = true
+    end
+
+    def detect_features_sqlite
+      @features[:supports_insert_on_duplicate_skip] = true
+    end
+  end
+  ActiveSupport.run_load_hooks(:active_record_adbcadapter, Adapter)
+end

data/lib/activerecord_adbc_adapter/column.rb

@@ -0,0 +1,4 @@
+module ActiveRecordADBCAdapter
+  class Column < ActiveRecord::ConnectionAdapters::Column # :nodoc:
+  end
+end

data/lib/activerecord_adbc_adapter/database_statements.rb

@@ -0,0 +1,68 @@
+module ActiveRecordADBCAdapter
+  module DatabaseStatements
+    def perform_query(raw_connection,
+                      sql,
+                      binds,
+                      type_casted_binds,
+                      prepare:,
+                      notification_payload:,
+                      batch:)
+      raw_connection.open_statement do |statement|
+        statement.sql_query = sql
+        if binds.empty?
+          statement.execute[0]
+        else
+          statement.prepare
+          raw_records = {}
+          binds.zip(type_casted_binds) do |bind, type_casted_bind|
+            case type_casted_bind
+            when String
+              if type_casted_bind.encoding == Encoding::ASCII_8BIT
+                array = Arrow::BinaryArray.new([type_casted_bind])
+              else
+                array = Arrow::StringArray.new([type_casted_bind])
+              end
+            when DateTime
+              array = Arrow::TimestampArray.new(:micro,
+                                                [type_casted_bind.dup.localtime])
+            when Date
+              array = Arrow::Date32Array.new([type_casted_bind])
+            when ActiveRecord::Type::Time::Value
+              local_time = type_casted_bind.dup.localtime
+              time_value = (local_time.seconds_since_midnight * 1_000_000).to_i
+              array = Arrow::Time64Array.new(:micro, [time_value])
+            else
+              array = [type_casted_bind]
+            end
+            raw_records[bind.name] = array
+          end
+          record_batch = Arrow::RecordBatch.new(raw_records)
+          statement.bind(record_batch) do
+            statement.execute[0]
+          end
+        end
+      end
+    end
+
+    def cast_result(arrow_table)
+      Result.new(backend, arrow_table)
+    end
+
+    # Borrowed from
+    # ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements.
+    #
+    # Copyright (c) David Heinemeier Hansson
+    #
+    # The MIT license.
+    READ_QUERY =
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+        :close, :declare, :fetch, :move, :set, :show
+      ) #:nodoc:
+    private_constant :READ_QUERY
+    def write_query?(sql) # :nodoc:
+      !READ_QUERY.match?(sql)
+    rescue ArgumentError # Invalid encoding
+      !READ_QUERY.match?(sql.b)
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/ingest.rb

@@ -0,0 +1,13 @@
+module ActiveRecordADBCAdapter
+  module Ingest
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def ingest(attributes)
+        self.with_connection do |connection|
+          connection.ingest(table_name, attributes, name: "#{self} Ingest")
+        end
+      end
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/quoting.rb

@@ -0,0 +1,19 @@
+module ActiveRecordADBCAdapter
+  module Quoting
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def quote_column_name(column_name)
+        "\"#{column_name.gsub("\"", "\"\"")}\""
+      end
+    end
+
+    def quoted_date(value)
+      value
+    end
+
+    def quoted_time(value)
+      value
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/relation_arrowable.rb

@@ -0,0 +1,18 @@
+module ActiveRecordADBCAdapter
+  module RelationArrowable
+    def to_arrow
+      result = exec_main_query
+      result.attach_model(model)
+      result.to_arrow
+    end
+
+    def each_record_batch(&block)
+      result = exec_main_query
+      result.attach_model(model)
+      result.each_record_batch(&block)
+    end
+  end
+
+  ActiveRecord::Relation.include(RelationArrowable)
+  ActiveRecord::Querying.delegate(:to_arrow, :each_record_batch, to: :all)
+end

data/lib/activerecord_adbc_adapter/result.rb

@@ -0,0 +1,151 @@
+module ActiveRecordADBCAdapter
+  class Result
+    include Enumerable
+
+    def initialize(backend, table)
+      @backend = backend
+      @table = table
+      @schema = @table.schema
+    end
+
+    # This must be called before calling other methods.
+    def attach_model(model)
+      return unless @backend == "sqlite"
+
+      model_columns_hash = model.columns_hash
+      casted = false
+      new_chunked_arrays = []
+      new_fields = []
+      @table.columns.zip(@schema.fields) do |column, field|
+        chunked_array = nil
+        model_column = model_columns_hash[field.name]
+        if model_column
+          casted_type = nil
+          case model_column.sql_type_metadata.type
+          when :boolean
+            case field.data_type
+            when Arrow::IntegerDataType
+              casted_type = Arrow::BooleanDataType.new
+            end
+          when :date
+            case field.data_type
+            when Arrow::StringDataType
+              casted_type = Arrow::Date32DataType.new
+            end
+          when :datetime
+            case field.data_type
+            when Arrow::StringDataType
+              casted_type = Arrow::TimestampDataType.new(:nano)
+            end
+          end
+          if casted_type
+            chunked_array = column.cast(casted_type)
+            field = Arrow::Field.new(field.name, casted_type)
+            casted = true
+          end
+        end
+        new_chunked_arrays << (chunked_array || column.data)
+        new_fields << field
+      end
+      return unless casted
+
+      @schema = Arrow::Schema.new(new_fields)
+      @table = Arrow::Table.new(@schema, new_chunked_arrays)
+    end
+
+    def columns
+      @columns ||= fields.collect(&:name)
+    end
+
+    def column_types
+      @column_types ||= fields.inject({}) do |types, field|
+        types[field.name] = resolve_type(field.data_type)
+        types
+      end
+    end
+
+    def includes_column?(name)
+      columns.include?(name)
+    end
+
+    def rows
+      @rows ||= to_arrow.raw_records
+    end
+
+    def length
+      to_arrow.length
+    end
+
+    def empty?
+      length.zero?
+    end
+
+    def each(&block)
+      return to_enum(__method__) unless block_given?
+
+      rows.each do |record|
+        yield(Hash[@columns.zip(record)])
+      end
+    end
+
+    def indexed_rows
+      @indexed_rows ||= to_a
+    end
+
+    def cast_values(type_overrides = {})
+      # TODO: type_overrides support
+      if fields.size == 1
+        rows.map(&:first)
+      else
+        rows
+      end
+    end
+
+    def to_arrow
+      @table
+    end
+
+    def each_record_batch
+      return to_enum(__method__) unless block_given?
+
+      reader = Arrow::TableBatchReader.new(@table)
+      loop do
+        record_batch = reader.read_next
+        break if record_batch.nil?
+        yield(record_batch)
+      end
+    end
+
+    private
+    def fields
+      @fields ||= @schema.fields
+    end
+
+    def resolve_type(data_type)
+      case data_type
+      when Arrow::BooleanDataType
+        ActiveRecord::Type::Boolean.new
+      when Arrow::Int32DataType
+        ActiveRecord::Type::Integer.new(limit: 4)
+      when Arrow::Int64DataType
+        ActiveRecord::Type::Integer.new(limit: 8)
+      when Arrow::FloatDataType
+        ActiveRecord::Type::Float.new(limit: 24)
+      when Arrow::DoubleDataType
+        ActiveRecord::Type::Float.new
+      when Arrow::BinaryDataType
+        ActiveRecord::Type::Binary.new
+      when Arrow::StringDataType
+        ActiveRecord::Type::String.new
+      when Arrow::Date32DataType
+        ActiveRecord::Type::Date.new
+      when Arrow::TimestampDataType
+        ActiveRecord::Type::DateTime.new
+      when Arrow::Time64DataType
+        ActiveRecord::Type::Time.new
+      else
+        raise "Unknown: #{data_type.inspect}"
+      end
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/schema_creation.rb

@@ -0,0 +1,44 @@
+module ActiveRecordADBCAdapter
+  class SchemaCreation < ActiveRecord::ConnectionAdapters::SchemaCreation
+    private def quote_string(s)
+      @conn.quote_string(s)
+    end
+
+    private def sequence_name(column)
+      "sequence_#{column.table.name}_#{column.name}"
+    end
+
+    private def quoted_sequence_name(column)
+      quote_table_name(sequence_name(column))
+    end
+
+    def visit_ColumnDefinition(o)
+      sql = super
+      if o.type == :primary_key and @conn.backend == "duckdb"
+        sql << " DEFAULT NEXTVAL('#{quote_string(sequence_name(o))}')"
+      end
+      sql
+    end
+
+    def visit_TableDefinition(o)
+      o.columns.each do |column|
+        column.singleton_class.define_method(:table) do
+          o
+        end
+      end
+      sql = super
+      if @conn.backend == "duckdb"
+        o.columns.each do |column|
+          if column.type == :primary_key
+            s = +"CREATE SEQUENCE"
+            s << " IF NOT EXISTS" if o.if_not_exists
+            s << " #{quoted_sequence_name(column)}"
+            s << "; #{sql}"
+            sql = s
+          end
+        end
+      end
+      sql
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/schema_definitions.rb

@@ -0,0 +1,8 @@
+module ActiveRecordADBCAdapter
+  class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+    private
+    def aliased_types(name, fallback)
+      fallback
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/schema_statements.rb

@@ -0,0 +1,178 @@
+module ActiveRecordADBCAdapter
+  module SchemaStatements
+    NATIVE_DATABASE_TYPES = {
+      "duckdb" => {
+        primary_key: "bigint PRIMARY KEY",
+      },
+      "postgresql" => {
+        primary_key: "bigserial PRIMARY KEY",
+        string: {name: "character varying"},
+        binary: {name: "bytea"},
+        datetime: {name: "timestamp without time zone"},
+      },
+      "sqlite" => {
+        primary_key: "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
+        # INTEGER storage class can store 8 bytes value:
+        # https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        integer: {name: "integer", limit: 8},
+        bigint: {name: "bigint", limit: 8},
+      },
+    }
+
+    def native_database_types
+      NATIVE_DATABASE_TYPES[backend] || super
+    end
+
+    def adbc_catalog
+      case backend
+      when "duckdb"
+        path = @connection_parameters[:path]
+        if path
+          File.basename(path, ".*")
+        else
+          "memory"
+        end
+      else
+        nil
+      end
+    end
+
+    def adbc_db_schema
+      case backend
+      when "duckdb"
+        "main"
+      else
+        nil
+      end
+    end
+
+    def adbc_table_type
+      case backend
+      when "duckdb"
+        "BASE TABLE"
+      else
+        "table"
+      end
+    end
+
+    def adbc_view_type
+      case backend
+      when "duckdb"
+        "VIEW"
+      else
+        "view"
+      end
+    end
+
+    def tables
+      type = adbc_table_type
+      with_raw_connection do |conn|
+        objects = conn.get_objects(depth: :tables,
+                                   catalog: adbc_catalog,
+                                   db_schema: adbc_db_schema,
+                                   table_types: [type])
+        tables = []
+        objects.raw_records.each do |_catalog_name, db_schemas|
+          db_schemas.each do |db_schema|
+            db_schema_tables = db_schema["db_schema_tables"]
+            next if db_schema_tables.nil?
+            db_schema_tables.each do |t|
+              # Some drivers may ignore table_types
+              next unless t["table_type"] == type
+              tables << t["table_name"]
+            end
+          end
+        end
+        tables
+      end
+    end
+
+    def views
+      type = adbc_view_type
+      with_raw_connection do |conn|
+        objects = conn.get_objects(depth: :tables,
+                                   catalog: adbc_catalog,
+                                   db_schema: adbc_db_schema,
+                                   table_types: [type])
+        views = []
+        objects.raw_records.each do |_catalog_name, db_schemas|
+          db_schemas.each do |db_schema|
+            db_schema_tables = db_schema["db_schema_tables"]
+            next if db_schema_tables.nil?
+            db_schema_tables.each do |t|
+              # Some drivers may ignore table_types
+              next unless t["table_type"] == type
+              views << t["table_name"]
+            end
+          end
+        end
+        views
+      end
+    end
+
+    def column_definitions(table_name)
+      with_raw_connection do |conn|
+        objects = conn.get_objects(catalog: adbc_catalog,
+                                   db_schema: adbc_db_schema,
+                                   table_name: table_name)
+        objects.raw_records.each do |_catalog_name, db_schemas|
+          db_schemas.each do |db_schema|
+            db_schema_tables = db_schema["db_schema_tables"]
+            next if db_schema_tables.nil?
+            db_schema_tables.each do |table|
+              return table["table_columns"]
+            end
+          end
+        end
+        [] # raise?
+      end
+    end
+
+    def primary_keys(table_name)
+      with_raw_connection do |conn|
+        objects = conn.get_objects(catalog: adbc_catalog,
+                                   db_schema: adbc_db_schema,
+                                   table_name: table_name)
+        objects.raw_records.each do |_catalog_name, db_schemas|
+          db_schemas.each do |db_schema|
+            db_schema_tables = db_schema["db_schema_tables"]
+            next if db_schema_tables.nil?
+            db_schema_tables.each do |table|
+              constraint = table["table_constraints"].find do |constraint|
+                constraint["constraint_type"] == "PRIMARY KEY"
+              end
+              return [] if constraint.nil?
+              return constraint["constraint_column_names"] || []
+            end
+          end
+        end
+        []
+      end
+    end
+
+    private
+    def create_table_definition(name, **options)
+      TableDefinition.new(self, name, **options)
+    end
+
+    def schema_creation
+      SchemaCreation.new(self)
+    end
+
+    def new_column_from_field(table_name, field, definitions)
+      xdbc_type_name = field["xdbc_type_name"]
+      if xdbc_type_name
+        type_metadata = fetch_type_metadata(xdbc_type_name)
+      else
+        type_metadata = nil
+      end
+      Column.new(field["column_name"],
+                 field["xdbc_column_def"],
+                 type_metadata,
+                 field["xdbc_nullable"] == 1,
+                 nil,
+                 collation: nil,
+                 comment: nil)
+    end
+  end
+end

data/lib/activerecord_adbc_adapter/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordADBCAdapter
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-adbc-adapter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sutou Kouhei
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: red-adbc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides an ADBC adapter for Active Record. This adapter is
+  optimized for extracting and loading large data from/to DBs. The optimization is
+  powered by Apache Arrow.
+email:
+- kou@clear-code.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/activerecord-adbc-adapter.rb
+- lib/activerecord_adbc_adapter/adapter.rb
+- lib/activerecord_adbc_adapter/column.rb
+- lib/activerecord_adbc_adapter/database_statements.rb
+- lib/activerecord_adbc_adapter/ingest.rb
+- lib/activerecord_adbc_adapter/quoting.rb
+- lib/activerecord_adbc_adapter/relation_arrowable.rb
+- lib/activerecord_adbc_adapter/result.rb
+- lib/activerecord_adbc_adapter/schema_creation.rb
+- lib/activerecord_adbc_adapter/schema_definitions.rb
+- lib/activerecord_adbc_adapter/schema_statements.rb
+- lib/activerecord_adbc_adapter/version.rb
+homepage: https://github.com/red-data-tools/activerecord-adbc-adapter
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Active Record's ADBC adapter
+test_files: []