ducklake 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e31c96f2bcf9728685f6eb72f3cdfad44174eb28347dbe549391703f2795414
+  data.tar.gz: 63befb2ceaad4c0587b6ef10672e687aa2c51cdc78c95451c85599595d9e83d7
+SHA512:
+  metadata.gz: 1a62d39d7962cbdd8b60a49ba0f7a20d47bbf2a3a18061ae59330cab07b67d91d7dab533487da99cdfbfc3d2b1d7cceaf407bfdd471ffe2bee6d84d2f5567413
+  data.tar.gz: 7032e761c77d93463beb4fb650e17fba8a8e3d54554ca5debc9f14a1625a18806c9167f5719cd7bab7079b068adae151b53a404600ac09b02eb1974cfe90c06e

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2025-08-17)
+
+- First release

data/README.md

@@ -0,0 +1,330 @@
+# DuckLake Ruby
+
+:fire: [DuckLake](https://ducklake.select/) for Ruby
+
+Run your own data lake with a SQL database and file/object storage
+
+```ruby
+DuckLake::Client.new(
+  catalog_url: "postgres://user:pass@host:5432/db",
+  storage_url: "s3://my-bucket/"
+)
+```
+
+[Learn more](https://duckdb.org/2025/05/27/ducklake.html)
+
+Note: DuckLake is [not considered production-ready](https://ducklake.select/faq#is-ducklake-production-ready) at the moment
+
+[![Build Status](https://github.com/ankane/ducklake-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/ducklake-ruby/actions)
+
+## Installation
+
+First, install libduckdb. For Homebrew, use:
+
+```sh
+brew install duckdb
+```
+
+Then add this line to your application’s Gemfile:
+
+```ruby
+gem "ducklake"
+```
+
+## Getting Started
+
+Create a client - this one stores everything locally
+
+```ruby
+ducklake =
+  DuckLake::Client.new(
+    catalog_url: "sqlite:///ducklake.sqlite",
+    storage_url: "data_files/",
+    create_if_not_exists: true
+  )
+```
+
+Create a table
+
+```ruby
+ducklake.sql("CREATE TABLE events (id bigint, name text)")
+```
+
+Load data from a file
+
+```ruby
+ducklake.sql("COPY events FROM 'data.csv'")
+```
+
+Confirm a new Parquet file was added to the data lake
+
+```ruby
+ducklake.list_files("events")
+```
+
+Query the data
+
+```ruby
+ducklake.sql("SELECT COUNT(*) FROM events").to_a
+```
+
+## Catalog Database
+
+Catalog information can be stored in:
+
+- Postgres: `postgres://user@pass@host:5432/dbname`
+- SQLite: `sqlite:///path/to/dbname.sqlite`
+- DuckDB: `duckdb:///path/to/dbname.duckdb`
+
+Note: MySQL and MariaDB are not currently supported due to [duckdb/ducklake#70](https://github.com/duckdb/ducklake/issues/70) and [duckdb/ducklake#210](https://github.com/duckdb/ducklake/issues/210)
+
+There are two ways to set up the schema:
+
+1. Run [this script](https://ducklake.select/docs/stable/specification/tables/overview#full-schema-creation-script)
+2. Configure the client to do it
+
+  ```ruby
+  DuckLake::Client.new(create_if_not_exists: true, ...)
+  ```
+
+## Data Storage
+
+Data can be stored in:
+
+- Local files: `data_files/`
+- Amazon S3: `s3://my-bucket/path/`
+- [Other providers](https://ducklake.select/docs/stable/duckdb/usage/choosing_storage): todo
+
+### Amazon S3
+
+Credentials are detected in the standard AWS SDK locations, or you can pass them manually
+
+```ruby
+DuckLake::Client.new(
+  storage_options: {
+    aws_access_key_id: "...",
+    aws_secret_access_key: "...",
+    region: "us-east-1"
+  },
+  ...
+)
+```
+
+IAM permissions
+
+- Read: `s3::ListBucket`, `s3::GetObject`
+- Write: `s3::ListBucket`, `s3::PutObject`
+- Maintenance: `s3::ListBucket`, `s3::GetObject`, `s3::PutObject`, `s3::DeleteObject`
+
+## Operations
+
+Create an empty table
+
+```ruby
+ducklake.sql("CREATE TABLE events (id bigint, name text)")
+```
+
+Or a table from a file
+
+```ruby
+ducklake.sql("CREATE TABLE events AS FROM 'data.csv'")
+```
+
+Load data from a file
+
+```ruby
+ducklake.sql("COPY events FROM 'data.csv'")
+```
+
+You can also load data directly from other [data sources](https://duckdb.org/docs/stable/data/data_sources)
+
+```ruby
+ducklake.attach("blog", "postgres://localhost:5432/blog")
+ducklake.sql("INSERT INTO events SELECT * FROM blog.ahoy_events")
+```
+
+Or [register existing data files](https://ducklake.select/docs/stable/duckdb/metadata/adding_files)
+
+```ruby
+ducklake.add_data_files("events", "data.parquet")
+```
+
+Note: This transfers ownership to DuckLake, so the file can be deleted after running `cleanup_old_files`
+
+Update data
+
+```ruby
+ducklake.sql("UPDATE events SET name = ? WHERE id = 1", ["Test", 1])
+```
+
+Delete data
+
+```ruby
+ducklake.sql("DELETE * FROM events WHERE id = ?", [1])
+```
+
+Update the schema
+
+```ruby
+ducklake.sql("ALTER TABLE events ADD COLUMN active BOOLEAN")
+```
+
+## Snapshots
+
+Get snapshots
+
+```ruby
+ducklake.snapshots
+```
+
+Query the data at a specific snapshot version or time
+
+```ruby
+ducklake.sql("SELECT * FROM events AT (VERSION => ?)", [3])
+#
+ducklake.sql("SELECT * FROM events AT (TIMESTAMP => ?)", [Date.today - 7])
+```
+
+You can also specify a snapshot when creating the client
+
+```ruby
+DuckLake::Client.new(snapshot_version: 3, ...)
+# or
+DuckLake::Client.new(snapshot_time: Date.today - 7, ...)
+```
+
+## Maintenance
+
+Merge files
+
+```ruby
+ducklake.merge_adjacent_files
+```
+
+Expire snapshots
+
+```ruby
+ducklake.expire_snapshots(older_than: Date.today - 7)
+```
+
+Clean up old files
+
+```ruby
+ducklake.cleanup_old_files(older_than: Date.today - 7)
+```
+
+## Configuration
+
+Get [options](https://ducklake.select/docs/stable/duckdb/usage/configuration)
+
+```ruby
+ducklake.options
+```
+
+Set an option globally
+
+```ruby
+ducklake.set_option("parquet_compression", "zstd")
+```
+
+Or for a specific table
+
+```ruby
+ducklake.set_option("parquet_compression", "zstd", table_name: "events")
+```
+
+## Security
+
+See [best practices](https://duckdb.org/docs/stable/operations_manual/securing_duckdb/overview.html) for DuckDB security.
+
+Grant minimal permissions for the catalog database and data storage.
+
+### External Access
+
+[Restrict external access](https://duckdb.org/docs/stable/operations_manual/securing_duckdb/overview.html#restricting-file-access) to the DuckDB engine
+
+```ruby
+ducklake.disable_external_access
+```
+
+Allow specific directories and paths
+
+```ruby
+ducklake.disable_external_access(
+  allowed_directories: ["/path/to/directory"],
+  allowed_paths: ["/path/to/file.txt"]
+)
+```
+
+The storage URL is automatically included in `allowed_directories`
+
+## Reference
+
+Get table info
+
+```ruby
+ducklake.table_info
+```
+
+Get column info
+
+```ruby
+ducklake.column_info("events")
+```
+
+Drop a table
+
+```ruby
+ducklake.drop_table("events")
+# or
+ducklake.drop_table("events", if_exists: true)
+```
+
+List files
+
+```ruby
+ducklake.list_files("events")
+```
+
+List files at a specific snapshot version or time
+
+```ruby
+ducklake.list_files("events", snapshot_version: 3)
+# or
+ducklake.list_files("events", snapshot_time: Date.today - 7)
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/ducklake-ruby/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/ducklake-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/ducklake-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/ducklake-ruby.git
+cd ducklake-ruby
+bundle install
+
+# Postgres
+createdb ducklake_ruby_test
+bundle exec rake test:postgres
+
+# MySQL and MariaDB
+mysqladmin create ducklake_ruby_test
+bundle exec rake test:mysql
+
+# SQLite
+bundle exec rake test:sqlite
+
+# DuckDB
+bundle exec rake test:duckdb
+```

data/lib/ducklake/client.rb

@@ -0,0 +1,430 @@
+module DuckLake
+  class Client
+    def initialize(
+      catalog_url:,
+      storage_url:,
+      storage_options: {},
+      snapshot_version: nil,
+      snapshot_time: nil,
+      data_inlining_row_limit: 0,
+      create_if_not_exists: false,
+      _read_only: false # experimental
+    )
+      catalog_uri = URI.parse(catalog_url)
+      storage_uri = URI.parse(storage_url)
+
+      extension = nil
+      case catalog_uri.scheme
+      when "postgres", "postgresql"
+        extension = "postgres"
+        attach = "postgres:#{catalog_uri}"
+      when "mysql", "mariadb"
+        extension = "mysql"
+        attach = "mysql:#{catalog_uri}"
+      when "sqlite"
+        extension = "sqlite"
+        attach = "sqlite:#{catalog_path(catalog_uri)}"
+      when "duckdb"
+        attach = "duckdb:#{catalog_path(catalog_uri)}"
+      else
+        raise ArgumentError, "Unsupported catalog type: #{catalog_uri.scheme}"
+      end
+
+      secret_options = nil
+      storage_options = storage_options.dup
+
+      case storage_uri.scheme
+      when "s3"
+        # https://duckdb.org/docs/stable/core_extensions/httpfs/s3api.html
+        key_id = storage_options.delete(:aws_access_key_id)
+        secret = storage_options.delete(:aws_secret_access_key)
+        region = storage_options.delete(:region)
+
+        secret_options = {
+          type: "s3",
+          provider: "credential_chain"
+        }
+        secret_options[:key_id] = key_id if key_id
+        secret_options[:secret] = secret if secret
+        secret_options[:region] = region if region
+      end
+
+      if storage_options.any?
+        raise ArgumentError, "Unsupported #{storage_uri.scheme || "file"} storage options: #{storage_options.keys.map(&:inspect).join(", ")}"
+      end
+
+      attach_options = {data_path: storage_url}
+      attach_options[:read_only] = true if _read_only
+      attach_options[:snapshot_version] = snapshot_version if !snapshot_version.nil?
+      attach_options[:snapshot_time] = snapshot_time if !snapshot_time.nil?
+      attach_options[:data_inlining_row_limit] = data_inlining_row_limit if data_inlining_row_limit > 0
+      attach_options[:create_if_not_exists] = false unless create_if_not_exists
+
+      @catalog = "ducklake"
+      @storage_url = storage_url
+
+      if _read_only
+        config = DuckDB::Config.new
+        config["access_mode"] = "READ_ONLY"
+
+        # make the entire database read-only, not just DuckLake
+        # read-only mode can only be set when the database is opened
+        # and cannot be used on in-memory database, so create a temporary one
+        @tmpdir = Dir.mktmpdir
+        ObjectSpace.define_finalizer(@tmpdir, self.class.finalize(@tmpdir.dup))
+        dbpath = File.join(@tmpdir, "memory.duckdb")
+        DuckDB::Database.open(dbpath) { }
+
+        @db = DuckDB::Database.open(dbpath, config)
+      else
+        @db = DuckDB::Database.open
+      end
+
+      @conn = @db.connect
+
+      install_extension("ducklake")
+      install_extension(extension) if extension
+      create_secret(secret_options) if secret_options
+      attach_with_options(@catalog, "ducklake:#{attach}", attach_options)
+      execute("USE #{quote_identifier(@catalog)}")
+      detach("memory")
+    end
+
+    # https://duckdb.org/docs/stable/operations_manual/securing_duckdb/overview.html#restricting-file-access
+    def disable_external_access(allowed_directories: [], allowed_paths: [])
+      allowed_directories += [@storage_url]
+      execute("SET allowed_directories = #{quote_array(allowed_directories)}")
+      execute("SET allowed_paths = #{quote_array(allowed_paths)}")
+      execute("SET enable_external_access = false")
+      nil
+    end
+
+    def sql(sql, params = [])
+      execute(sql, params)
+    end
+
+    def attach(alias_, url)
+      type = nil
+      extension = nil
+
+      uri = URI.parse(url)
+      case uri.scheme
+      when "postgres", "postgresql"
+        type = "postgres"
+        extension = "postgres"
+      else
+        raise ArgumentError, "Unsupported data source type: #{uri.scheme}"
+      end
+
+      install_extension(extension) if extension
+
+      options = {
+        type: type,
+        read_only: true
+      }
+      attach_with_options(alias_, url, options)
+    end
+
+    def detach(alias_)
+      execute("DETACH #{quote_identifier(alias_)}")
+      nil
+    end
+
+    def table_info
+      symbolize_keys execute("SELECT * FROM ducklake_table_info(?)", [@catalog])
+    end
+
+    def column_info(table)
+      sql = <<~SQL
+        SELECT column_name AS name, LOWER(data_type) AS type
+        FROM information_schema.columns
+        WHERE table_catalog = ? AND table_schema = ? AND table_name = ?
+        ORDER BY ordinal_position
+      SQL
+      result = execute(sql, [@catalog, "main", table])
+      if result.empty?
+        raise CatalogError, "Table does not exist!"
+      end
+      symbolize_keys result
+    end
+
+    # TODO more DDL methods?
+    def drop_table(table, if_exists: nil)
+      execute("DROP TABLE#{" IF EXISTS" if if_exists} #{quote_identifier(table)}")
+      nil
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/usage/snapshots
+    def snapshots
+      symbolize_keys execute("SELECT * FROM ducklake_snapshots(?)", [@catalog])
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/usage/configuration
+    def options
+      symbolize_keys execute("SELECT * FROM ducklake_options(?)", [@catalog])
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/usage/configuration
+    def set_option(name, value, table_name: nil)
+      args = ["?", "?", "?"]
+      params = [@catalog, name, value]
+
+      if !table_name.nil?
+        args << "table_name => ?"
+        params << table_name
+      end
+
+      execute("CALL ducklake_set_option(#{args.join(", ")})", params)
+      nil
+    end
+
+    def format_version
+      execute("SELECT value FROM ducklake_options(?) WHERE option_name = ?", [@catalog, "version"]).first["value"]
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/maintenance/merge_adjacent_files
+    def merge_adjacent_files
+      execute("CALL merge_adjacent_files()")
+      nil
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/maintenance/expire_snapshots
+    def expire_snapshots(versions: nil, older_than: nil, dry_run: false)
+      args = ["?"]
+      params = [@catalog]
+
+      if !versions.nil?
+        # inline since duckdb gem does not support array params
+        args << "versions => #{quote_array(versions)}"
+      end
+
+      if !older_than.nil?
+        args << "older_than => ?"
+        params << older_than
+      end
+
+      if dry_run
+        args << "dry_run => ?"
+        params << dry_run
+      end
+
+      symbolize_keys execute("CALL ducklake_expire_snapshots(#{args.join(", ")})", params)
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/maintenance/cleanup_old_files
+    def cleanup_old_files(cleanup_all: false, older_than: nil, dry_run: false)
+      args = ["?"]
+      params = [@catalog]
+
+      if cleanup_all
+        args << "cleanup_all => ?"
+        params << cleanup_all
+      end
+
+      if !older_than.nil?
+        args << "older_than => ?"
+        params << older_than
+      end
+
+      if dry_run
+        args << "dry_run => ?"
+        params << dry_run
+      end
+
+      symbolize_keys execute("CALL ducklake_cleanup_old_files(#{args.join(", ")})", params)
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/advanced_features/data_inlining
+    def flush_inlined_data(table_name: nil)
+      args = ["?"]
+      params = [@catalog]
+
+      if !table_name.nil?
+        args << "table_name => ?"
+        params << table_name
+      end
+
+      symbolize_keys execute("CALL ducklake_flush_inlined_data(#{args.join(", ")})", params)
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/metadata/list_files
+    def list_files(table, snapshot_version: nil, snapshot_time: nil)
+      args = ["?", "?"]
+      params = [@catalog, table]
+
+      if !snapshot_version.nil?
+        args << "snapshot_version => ?"
+        params << snapshot_version
+      end
+
+      if !snapshot_time.nil?
+        snapshot_time = snapshot_time.utc if snapshot_time.is_a?(Time)
+        args << "snapshot_time => ?"
+        params << snapshot_time
+      end
+
+      symbolize_keys execute("SELECT * FROM ducklake_list_files(#{args.join(", ")})", params)
+    end
+
+    # https://ducklake.select/docs/stable/duckdb/metadata/adding_files
+    def add_data_files(table, data, allow_missing: nil, ignore_extra_columns: nil)
+      params = [@catalog, table, data]
+      args = ["?", "?", "?"]
+
+      if !allow_missing.nil?
+        args << "allow_missing => ?"
+        params << allow_missing
+      end
+
+      if !ignore_extra_columns.nil?
+        args << "ignore_extra_columns => ?"
+        params << ignore_extra_columns
+      end
+
+      execute("CALL ducklake_add_data_files(#{args.join(", ")})", params)
+      nil
+    end
+
+    # libduckdb does not provide function
+    # https://duckdb.org/docs/stable/sql/dialect/keywords_and_identifiers.html
+    def quote_identifier(value)
+      "\"#{encoded(value).gsub('"', '""')}\""
+    end
+
+    # libduckdb does not provide function
+    # TODO support more types
+    def quote(value)
+      if value.nil?
+        "NULL"
+      elsif value == true
+        "true"
+      elsif value == false
+        "false"
+      elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
+        value.to_s("F")
+      elsif value.is_a?(Numeric)
+        value.to_s
+      else
+        if value.is_a?(Time)
+          value = value.utc.iso8601(9)
+        elsif value.is_a?(DateTime)
+          value = value.iso8601(9)
+        elsif value.is_a?(Date)
+          value = value.strftime("%Y-%m-%d")
+        end
+        "'#{encoded(value).gsub("'", "''")}'"
+      end
+    end
+
+    def disconnect
+      @conn.disconnect
+      @db.close
+      nil
+    end
+
+    # hide internal state
+    def inspect
+      to_s
+    end
+
+    def self.finalize(dir)
+      proc { FileUtils.remove_entry(dir) }
+    end
+
+    private
+
+    def execute(sql, params = [])
+      # use prepare instead of query to prevent multiple statements at once
+      result =
+        @conn.prepare(sql) do |stmt|
+          params.each_with_index do |v, i|
+            stmt.bind(i + 1, v)
+          end
+          stmt.execute
+        end
+
+      # TODO add column types
+      Result.new(result.columns.map(&:name), result.to_a)
+    rescue DuckDB::Error => e
+      raise map_error(e), cause: nil
+    end
+
+    def error_mapping
+      @error_mapping ||= {
+        "Catalog Error: " => CatalogError,
+        "Conversion Error: " => ConversionError,
+        "Invalid Input Error: " => InvalidInputError,
+        "IO Error: " => IOError,
+        "Permission Error: " => PermissionError
+      }
+    end
+
+    # not ideal to base on prefix, but do not see a better way at the moment
+    def map_error(e)
+      error_mapping.each do |prefix, cls|
+        if e.message&.start_with?(prefix)
+          return cls.new(e.message.delete_prefix(prefix))
+        end
+      end
+      Error.new(e.message)
+    end
+
+    def install_extension(extension)
+      execute("INSTALL #{quote_identifier(extension)}")
+    end
+
+    def create_secret(options)
+      execute("CREATE SECRET (#{options_args(options)})")
+    end
+
+    def attach_with_options(alias_, url, options)
+      execute("ATTACH #{quote(url)} AS #{quote_identifier(alias_)} (#{options_args(options)})")
+    end
+
+    def options_args(options)
+      options.map { |k, v| "#{option_name(k)} #{quote(v)}" }.join(", ")
+    end
+
+    def option_name(k)
+      name = k.to_s.upcase
+      # should never contain user input, but just to be safe
+      unless name.match?(/\A[A-Z_]+\z/)
+        raise "Invalid option name"
+      end
+      name
+    end
+
+    def symbolize_keys(result)
+      result.map { |v| v.transform_keys(&:to_sym) }
+    end
+
+    def catalog_path(uri)
+      # custom message for sqlite://db.sqlite
+      # TODO improve message
+      if !uri.host.empty?
+        raise ArgumentError, "Unexpected host in catalog_url"
+      end
+
+      if uri.path.length < 2 || uri.user || uri.password || uri.port || uri.query || uri.fragment
+        raise ArgumentError, "Invalid catalog_url"
+      end
+
+      uri.path[1..]
+    end
+
+    def quote_array(value)
+      "[#{value.map { |v| quote(v) }.join(", ")}]"
+    end
+
+    def encoded(value)
+      value = value.to_s if value.is_a?(Symbol)
+      if !value.respond_to?(:to_str)
+        raise TypeError, "no implicit conversion of #{value.class.name} into String"
+      end
+      if ![Encoding::UTF_8, Encoding::US_ASCII].include?(value.encoding) || !value.valid_encoding?
+        raise ArgumentError, "Unsupported encoding"
+      end
+      value
+    end
+  end
+end

data/lib/ducklake/result.rb

@@ -0,0 +1,22 @@
+module DuckLake
+  class Result
+    include Enumerable
+
+    attr_reader :columns, :rows
+
+    def initialize(columns, rows)
+      @columns = columns
+      @rows = rows
+    end
+
+    def each
+      @rows.each do |row|
+        yield @columns.zip(row).to_h
+      end
+    end
+
+    def empty?
+      rows.empty?
+    end
+  end
+end

data/lib/ducklake/version.rb

@@ -0,0 +1,3 @@
+module DuckLake
+  VERSION = "0.1.0"
+end

data/lib/ducklake.rb

@@ -0,0 +1,19 @@
+# dependencies
+require "duckdb"
+
+# stdlib
+require "uri"
+
+# modules
+require_relative "ducklake/client"
+require_relative "ducklake/result"
+require_relative "ducklake/version"
+
+module DuckLake
+  class Error < StandardError; end
+  class CatalogError < Error; end
+  class ConversionError < Error; end
+  class InvalidInputError < Error; end
+  class IOError < Error; end
+  class PermissionError < Error; end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: ducklake
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duckdb
+  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'
+email: andrew@ankane.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/ducklake.rb
+- lib/ducklake/client.rb
+- lib/ducklake/result.rb
+- lib/ducklake/version.rb
+homepage: https://github.com/ankane/ducklake-ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: DuckLake for Ruby
+test_files: []