relationizer 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f70691fd83bd02baeab60d894732c1bb51fa2cc9b5f324efa631e873b82acbcf
-  data.tar.gz: ae5f6b5a66a89bb6ee8bd7204a17253ea406827bc60987767b8f3afa76211758
+  metadata.gz: a48df925940ca5fe199ef9ba19ed66836a55ec029356c80dd93e9f4a2f150558
+  data.tar.gz: 4add1225e3324e97e22e2670628820adf5c1588cd764e303c6ed4a765130d72c
 SHA512:
-  metadata.gz: fbc366ffee800c89f2d16a691d75b8ee2103d5807b5da4eab487bb35b39ca9874c7dbd3e401fc5d525d7da9042d5568e03a3e90056cade18fc6dbad4e3ddbd43
-  data.tar.gz: def44734c1abe5dad8a9387c237723aeb6d7a8c15a60eac7d99c6a4f5d3e1dd9735db8cd381155ed13b5624483dc8d3f86033535219568a4cfbd34e52252d39f
+  metadata.gz: f4a6b8ddaa7d11192b39f940a9ae8da1b9eb75d2b71671c616032cd16db730ce8769d1ceaa8092dac62d16e1d003333d2dfb6c2580cfaa692cd263abe1877906
+  data.tar.gz: fef4f070c8d10430a531fd67d700279511f33505f8df3c0149d0afff9463857229a872e4ab756370e831c42cdcfd8d64e697bfbbdee18f634252d671353de8e5

data/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      id-token: write  # Required for Trusted Publisher
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Build gem
+        run: gem build relationizer.gemspec
+
+      - name: Push to RubyGems (Trusted Publisher)
+        uses: rubygems/release-gem@v1
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: relationizer-*.gem
+          generate_release_notes: true

data/.github/workflows/ruby.yml

@@ -1,20 +1,22 @@
 name: Ruby
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
 
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.2', '3.3', '3.4', '4.0']
+
     steps:
-    - uses: actions/checkout@v1
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
+    - uses: actions/checkout@v4
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6.x
-    - name: Build and test with Rake
-      run: |
-        gem install bundler
-        bundle install --jobs 4 --retry 3
-        bundle exec rake
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake

data/CLAUDE.md

@@ -0,0 +1,48 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What is Relationizer
+
+Ruby gem that converts `Array<Array>` into SQL relation literals. Two backends:
+- **`Relationizer::BigQuery`** → `SELECT * FROM UNNEST(ARRAY<STRUCT<...>>[...])`
+- **`Relationizer::Postgresql`** → `SELECT "col"::TYPE FROM (VALUES(...)) AS t("col")`
+
+Both are modules intended to be `include`d. The public API is `create_relation_literal(schema, tuples)`.
+
+## Commands
+
+```bash
+bundle install            # Install dependencies
+bundle exec rake          # Run all tests (default task)
+bundle exec rake test     # Run all tests (explicit)
+bin/console               # IRB with gem loaded
+```
+
+## Architecture
+
+```
+lib/relationizer.rb            # Namespace module, requires submodules
+lib/relationizer/version.rb    # VERSION constant
+lib/relationizer/big_query.rb  # BigQuery SQL generation (module)
+lib/relationizer/postgresql.rb # PostgreSQL SQL generation (module)
+```
+
+Each backend module:
+- Infers SQL types from Ruby objects (Integer→INT64/INT8, String→STRING/TEXT, etc.)
+- Supports manual type specification via schema hash values
+- Has custom error classes (`ReasonlessTypeError`, `TypeNotFoundError`)
+- Handles edge cases: NULL, single-column relations (BigQuery adds dummy column), empty tuples, Infinity
+
+## Testing
+
+- Framework: **test-unit** (~> 3.0.0)
+- Test files: `test/*_test.rb`
+- Helper: `test/to_one_line.rb` — refinement that normalizes multi-line SQL for assertion comparison
+- Tests use `data` method for parameterized test cases
+
+## Notes
+
+- Zero runtime dependencies (pure Ruby)
+- Column names are quoted (`"col"` for PG, `` `col` `` for BQ)
+- String escaping differs per backend (doubled single quotes for PG, backslash escaping for BQ)

data/README.md

@@ -1,41 +1,143 @@
 # Relationizer
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/relationizer`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+A Ruby gem that converts `Array<Array>` into SQL relation literals. Supports BigQuery and PostgreSQL.
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'relationizer'
 ```
 
-And then execute:
+```
+$ bundle install
+```
+
+## Usage
 
-    $ bundle
+`include` the backend module you need and call `create_relation_literal(schema, tuples)`.
 
-Or install it yourself as:
+- `schema` — A Hash of column names to types. Set the value to `nil` to auto-infer the type from the tuples.
+- `tuples` — Row data as `Array<Array>`.
 
-    $ gem install relationizer
+### BigQuery
 
-## Usage
+```ruby
+require 'relationizer/big_query'
 
-TODO: Write usage instructions here
+class MyQuery
+  include Relationizer::BigQuery
+end
 
-## Development
+q = MyQuery.new
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+q.create_relation_literal(
+  { id: nil, name: nil },
+  [[1, 'hoge'], [2, 'fuga']]
+)
+#=> "SELECT * FROM UNNEST(ARRAY<STRUCT<`id` INT64, `name` STRING>>[(1, 'hoge'), (2, 'fuga')])"
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+#### Auto type inference
 
-## Contributing
+| Ruby type             | BigQuery type |
+|-----------------------|---------------|
+| `Integer`             | INT64         |
+| `Float` / `BigDecimal` | FLOAT64     |
+| `String`              | STRING        |
+| `TrueClass` / `FalseClass` | BOOL    |
+| `Time` / `DateTime`   | TIMESTAMP    |
+| `Date`                | DATE          |
+| `Array`               | ARRAY<T>     |
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/relationizer.
+#### Manual type specification
 
+Pass a Symbol as the schema value to override auto-inference. Useful when a column contains mixed types or when tuples are empty.
 
-## License
+```ruby
+# Force ratio column to FLOAT64 (mixed Integer and Float)
+q.create_relation_literal(
+  { id: nil, ratio: :FLOAT64 },
+  [[1, 1], [2, 3.14]]
+)
+#=> "SELECT * FROM UNNEST(ARRAY<STRUCT<`id` INT64, `ratio` FLOAT64>>[(1, 1), (2, 3.14)])"
+
+# Empty tuples (manual type specification is required)
+q.create_relation_literal(
+  { id: :INT64, name: :STRING },
+  []
+)
+#=> "SELECT * FROM UNNEST(ARRAY<STRUCT<`id` INT64, `name` STRING>>[])"
+```
+
+#### Array columns
+
+```ruby
+q.create_relation_literal(
+  { id: nil, name: nil, combination: nil },
+  [[1, 'hoge', [1, 2, 3]], [2, 'fuga', [4, 5, 6]]]
+)
+#=> "SELECT * FROM UNNEST(ARRAY<STRUCT<`id` INT64, `name` STRING, `combination` ARRAY<INT64>>>[(1, 'hoge', [1, 2, 3]), (2, 'fuga', [4, 5, 6])])"
+```
+
+#### Single column
+
+BigQuery does not support single-column STRUCTs in UNNEST, so a dummy column is added internally. Only the original column is returned in the SELECT.
+
+```ruby
+q.create_relation_literal(
+  { id: nil },
+  [[1], [2], [3]]
+)
+#=> "SELECT id FROM UNNEST(ARRAY<STRUCT<`id` INT64, `___dummy` STRING>>[(1, NULL), (2, NULL), (3, NULL)])"
+```
+
+### PostgreSQL
+
+```ruby
+require 'relationizer/postgresql'
+
+class MyQuery
+  include Relationizer::Postgresql
+end
+
+q = MyQuery.new
+
+q.create_relation_literal(
+  { id: nil, name: nil },
+  [[1, 'hoge'], [2, 'fuga']]
+)
+#=> %Q{SELECT "id"::INT8, "name"::TEXT FROM (VALUES('1', 'hoge'), ('2', 'fuga')) AS t("id", "name")}
+```
+
+#### Auto type inference
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+| Ruby type             | PostgreSQL type |
+|-----------------------|-----------------|
+| `Integer`             | INT8            |
+| `Float`               | FLOAT8          |
+| `BigDecimal`          | DECIMAL         |
+| `String`              | TEXT            |
+| `TrueClass` / `FalseClass` | BOOLEAN   |
+| `Time` / `DateTime`   | TIMESTAMPTZ    |
+| `Date`                | DATE            |
+
+#### NULL
+
+`nil` values are converted to SQL `NULL`.
+
+```ruby
+q.create_relation_literal(
+  { id: nil },
+  [[1], [nil]]
+)
+#=> %Q{SELECT "id"::INT8 FROM (VALUES('1'), (NULL)) AS t("id")}
+```
+
+## Errors
+
+- `ReasonlessTypeError` — Raised when types are mixed within a single column (e.g. Integer and String in the same column)
+- `TypeNotFoundError` (BigQuery only) — Raised when tuples are empty and types are not manually specified
+
+## License
 
+[MIT License](http://opensource.org/licenses/MIT)

data/lib/relationizer/mysql.rb

@@ -0,0 +1,104 @@
+require 'json'
+require 'bigdecimal'
+require 'date'
+
+module Relationizer
+  module MySQL
+    class ReasonlessTypeError < StandardError; end
+    class TypeNotFoundError < StandardError; end
+
+    DEFAULT_TYPES = -> (obj) {
+      case obj
+      when Integer    then :BIGINT
+      when BigDecimal then :'DECIMAL(65,30)'
+      when Float      then :DOUBLE
+      when String     then :TEXT
+      when TrueClass  then :BOOLEAN
+      when FalseClass then :BOOLEAN
+      when Time       then :DATETIME
+      when DateTime   then :DATETIME
+      when Date       then :DATE
+      else
+        nil
+      end
+    }
+
+    def create_relation_literal(schema, tuples)
+      types = fixed_types(schema.values, tuples)
+      names = schema.keys
+
+      json_string = to_json_document(names, types, tuples)
+      escaped = escape_for_sql(json_string)
+      columns_clause = to_columns_clause(names, types)
+
+      %[(SELECT * FROM JSON_TABLE('#{escaped}', "$[*]" COLUMNS(#{columns_clause})) AS t)]
+    end
+
+    private
+
+    def fixed_types(schema_values, tuples)
+      if tuples.empty?
+        raise TypeNotFoundError unless schema_values.all?
+        return schema_values
+      end
+
+      tuples.transpose.zip(schema_values).map { |values, type|
+        next type if type
+
+        values.
+          map(&DEFAULT_TYPES).compact.uniq.
+          tap(&method(:empty_candidate_check)).
+          tap(&method(:many_candidate_check)).
+          first
+      }
+    end
+
+    def many_candidate_check(types)
+      raise ReasonlessTypeError.new("Many candidate: #{types.join(', ')}") unless types.one?
+    end
+
+    def empty_candidate_check(types)
+      raise ReasonlessTypeError.new("Candidate nothing") if types.empty?
+    end
+
+    def to_json_value(obj, type)
+      return nil if obj.nil?
+
+      case type
+      when :'DECIMAL(65,30)'
+        obj.is_a?(BigDecimal) ? obj.to_s("F") : obj.to_s
+      when :DATE
+        obj.strftime('%Y-%m-%d')
+      when :DATETIME
+        obj.strftime('%Y-%m-%d %H:%M:%S')
+      else
+        obj
+      end
+    end
+
+    def to_json_document(names, types, tuples)
+      rows = tuples.map { |tuple|
+        hash = {}
+        names.zip(tuple, types).each do |name, value, type|
+          hash[name] = to_json_value(value, type)
+        end
+        hash
+      }
+      JSON.generate(rows)
+    end
+
+    def escape_for_sql(json_string)
+      json_string.gsub('\\', '\\\\\\\\').gsub("'", "''")
+    end
+
+    def identifier_quote(name)
+      "`#{name}`"
+    end
+
+    def to_columns_clause(names, types)
+      names.zip(types).map { |name, type|
+        %[#{identifier_quote(name)} #{type} PATH "$.#{name}"]
+      }.join(', ')
+    end
+  end
+end

data/lib/relationizer/version.rb

@@ -1,3 +1,3 @@
 module Relationizer
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/relationizer.rb

@@ -1,6 +1,7 @@
 require_relative "relationizer/version"
 require_relative "relationizer/postgresql"
 require_relative "relationizer/big_query"
+require_relative "relationizer/mysql"
 
 module Relationizer
 end

data/relationizer.gemspec

@@ -18,7 +18,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "bigdecimal"
+
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", ">= 12.3.3"
-  spec.add_development_dependency "test-unit", "~> 3.0.0"
+  spec.add_development_dependency "test-unit", "~> 3.0"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: relationizer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - yancya
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-17 00:00:00.000000000 Z
+date: 2026-02-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  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'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -44,23 +58,25 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
-description: 
+        version: '3.0'
+description:
 email:
 - yancya@upec.jp
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/release.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
+- CLAUDE.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -69,6 +85,7 @@ files:
 - bin/setup
 - lib/relationizer.rb
 - lib/relationizer/big_query.rb
+- lib/relationizer/mysql.rb
 - lib/relationizer/postgresql.rb
 - lib/relationizer/version.rb
 - relationizer.gemspec
@@ -76,7 +93,7 @@ homepage: https://github.com/yancya/relationizer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +108,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Array<Array> to Relation ppoi String
 test_files: []