色々試してる

Author: okadakk

lib/active_record/connection_adapters/duckdb/database_statements.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Duckdb
-      module DatabaseStatements
+      module DatabaseStatements # :nodoc:
         def write_query?(sql) # :nodoc:
           false
         end
@@ -13,13 +13,25 @@ def execute(sql, name = nil) # :nodoc:
 
           log(sql, name) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              p sql
               @connection.query(sql)
             end
           end
         end
+
+        def exec_query(sql, name = nil, binds = [], prepare: false, async: false) # :nodoc:
+          result = execute_and_clear(sql, name, binds, prepare: prepare, async: async)
+          
+          # TODO: https://github.com/suketa/ruby-duckdb/issues/168
+          # build_result(columns: result.columns, rows: result.to_a)
+          build_result(columns: ['id'], rows: result.to_a)
+        end
+
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          result = execute_and_clear(sql, name, binds)
+          result.rows_changed
+        end
+        alias :exec_update :exec_delete
       end
     end
   end
 end
-  

lib/active_record/connection_adapters/duckdb/schema_statements.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      module SchemaStatements # :nodoc:
+        private
+          def new_column_from_field(table_name, field)
+            _cid, name, type, notnull, _dflt_value, _pk = field
+
+            Column.new(
+              name,
+              nil, # default value
+              fetch_type_metadata(type),
+              !notnull,
+              nil, # default function
+            )
+          end
+
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+
+            sql = +"SELECT table_name FROM information_schema.tables"
+            sql << " WHERE table_schema = '#{scope[:schema]}'"
+            if scope[:type] || scope[:name]
+              conditions = []
+              conditions << "table_type = '#{scope[:type]}'" if scope[:type]
+              conditions << "table_name = '#{scope[:name]}'" if scope[:name]
+              sql << " WHERE #{conditions.join(" AND ")}"
+            end
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "main"
+            scope[:name] = quote(name) if name
+            scope[:type] = quote(type) if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+            schema, name = nil, schema unless name
+            [schema, name]
+          end
+      end
+    end
+  end
+end
+  

lib/active_record/connection_adapters/duckdb_adapter.rb

@@ -2,12 +2,9 @@
 
 require 'active_record'
 require 'active_record/base'
-# require 'active_support/dependencies/autoload'
-# require 'active_support/callbacks'
-# require 'active_support/core_ext/string'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/duckdb/database_statements'
-# require 'active_support/core_ext/kernel'
+require 'active_record/connection_adapters/duckdb/schema_statements'
 
 begin
   require 'duckdb'
@@ -29,9 +26,10 @@ class DuckdbAdapter < AbstractAdapter
       ADAPTER_NAME = "DuckDB"
 
       include Duckdb::DatabaseStatements
+      include Duckdb::SchemaStatements
 
       NATIVE_DATABASE_TYPES = {
-        primary_key:  "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
+        primary_key:  "BIGINT PRIMARY KEY",
         string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
@@ -44,6 +42,45 @@ class DuckdbAdapter < AbstractAdapter
         boolean:      { name: "boolean" },
         json:         { name: "json" },
       }
+
+      def native_database_types
+        NATIVE_DATABASE_TYPES
+      end
+
+      def primary_keys(table_name) # :nodoc:
+        raise ArgumentError unless table_name.present?
+
+        results = query("PRAGMA table_info(#{table_name})", "SCHEMA")
+        results.each_with_object([]) do |result, keys|
+          _cid, name, _type, _notnull, _dflt_value, pk = result
+          keys << name if pk
+        end
+      end
+
+      private
+        def execute_and_clear(sql, name, binds, prepare: false, async: false)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          type_casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, type_casted_binds, async: async) do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              # TODO: prepare の有無でcacheするっぽい？
+              stmt = DuckDB::PreparedStatement.new(@connection, sql)
+              if without_prepared_statement?(binds)
+                @connection.query(sql)
+              else
+                @connection.query(sql, *type_casted_binds)
+              end
+            end
+          end
+        end
+        
+        def column_definitions(table_name) # :nodoc:
+          execute("PRAGMA table_info('#{quote_table_name(table_name)}')", "SCHEMA") do |result|
+            each_hash(result)
+          end
+        end
     end
   end  
 end

spec/dummy/app/models/post.rb

@@ -1,9 +1,2 @@
 class Post < ActiveRecord::Base
-  before_create :set_id
-
-  private
-
-  def set_id
-    self.id = SecureRandom.uuid
-  end
 end

spec/models/post_spec.rb

@@ -17,31 +17,41 @@
     end
   end
 
-  let(:params) { {title: "duckdb book", views: 10000} }
+  let(:params) { { id: 1, title: "duckdb book", views: 10000 } }
 
   context 'initialization' do
     it 'should initialize a post object with all columns' do
       post = Post.new(params)
-      post.should be_a(Post)
-      post.title.should eq "duckdb book"
-      post.views.should eq 10000
+      expect(post).to be_a(Post)
+      expect(post.title).to eq "duckdb book"
+      expect(post.views).to eq 10000
     end
   end
 
   context 'persistance' do
-
     before do
       @post = Post.create!(params)
     end
 
     after do
+      # 多分deleteは数字を返すことを求めてるけど、duckdbのlibraryは削除したentityを返すようになってる
       @post.destroy
     end
 
     it 'should persist the record to the database' do
-      @post.persisted?.should eq true
-      refresh_posts
-      Post.count.should eq 1
+      expect(Post.find(1)).to be_a(Post)
+      expect(Post.count).to eq 1
+    end
+
+    it 'dd' do
+      post1 = Post.create(params.merge(id: 2))
+      p post1
+      p Post.count
+
+      d = Post.where(id: [1, 2]).destroy_all
+      p d
+      p Post.count
+      p Post.first
     end
   end
 end