libsql_activerecord 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bbe7dc7b7658ff6bc015aa2d5c83b12058f8ab13b838c183015248c24d2f78db
+  data.tar.gz: 1af1eda2128fbbac8924504897e7713731cd60848e9f2c2aadd308f808973684
+SHA512:
+  metadata.gz: 5ef0b717227f8a4e5d08bda341d7883c9fbe56a2de10e6707c7adfebaa2eaa701c18d0c6e8251c91fa6ba64f9c1a0a4a433b53e8dfca00caeeacd62123f490be
+  data.tar.gz: 2725820ec50d2bf270a7986a9a9c9818cd6b92116c1d33082cb210c711f120ee518088cdef75f1152a6a866f0cfaa52dced8599ba9d9b93a0928bdd9f8541917

data/lib/active_record/connection_adapters/libsql_adapter.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/sqlite3/database_statements'
+require 'active_record/connection_adapters/sqlite3/schema_statements'
+require 'active_record/connection_adapters/sqlite3/quoting'
+
+require 'libsql'
+
+module ActiveRecord
+  class Base # :nodoc:
+    class << self
+      def libsql_connection(config)
+        config = config.symbolize_keys
+        connection = ::Libsql::Database.new config
+        ConnectionAdapters::LibsqlAdapter.new(connection, logger, config)
+      end
+    end
+  end
+
+  module ConnectionAdapters # :nodoc:
+    if ActiveRecord.version >= Gem::Version.new('7.2')
+      register 'libsql', 'ActiveRecord::ConnectionAdapters::LibsqlAdapter',
+               'active_record/connection_adapters/libsql_adapter'
+    end
+
+    class LibsqlAdapter < AbstractAdapter # :nodoc:
+      ADAPTER_NAME = 'libSQL'
+
+      NATIVE_DATABASE_TYPES = {
+        primary_key: 'integer PRIMARY KEY AUTOINCREMENT NOT NULL',
+        string: { name: 'varchar' },
+        text: { name: 'text' },
+        integer: { name: 'integer' },
+        float: { name: 'float' },
+        decimal: { name: 'decimal' },
+        datetime: { name: 'datetime' },
+        time: { name: 'time' },
+        date: { name: 'date' },
+        binary: { name: 'blob' },
+        boolean: { name: 'boolean' },
+        json: { name: 'json' }
+      }.freeze
+
+      READ_QUERY = AbstractAdapter.build_read_query_regexp(:pragma)
+      private_constant :READ_QUERY
+
+      def write_query?(sql) # :nodoc:
+        !READ_QUERY.match?(sql)
+      end
+
+      def native_database_types # :nodoc:
+        NATIVE_DATABASE_TYPES
+      end
+
+      class << self
+        def new_client(config)
+          db = Libsql::Database.new(config || {})
+          db.connect
+        end
+      end
+
+      def initialize(...)
+        super
+        @connection_parameters = @config.reject { |k| k == :adapter }
+        @connection_parameters[:url] = @connection_parameters[:host]
+      end
+
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
+      end
+
+      def reconnect
+        @raw_connection&.close
+        connect
+      end
+
+      def perform_query(
+        raw_connection, sql, binds, type_casted_binds, prepare:,
+        notification_payload:, batch: false
+      )
+        _ = prepare
+        _ = notification_payload
+        _ = binds
+
+        if batch
+          raw_connection.execute_batch(sql)
+        else
+          stmt = raw_connection.prepare(sql)
+          begin
+            result =
+              if stmt.column_count.zero?
+                @last_affected_rows = stmt.execute type_casted_binds
+                ActiveRecord::Result.empty
+              else
+                rows = stmt.query(type_casted_binds)
+                @last_affected_rows = nil
+                ActiveRecord::Result.new(rows.columns, rows.to_a.map(&:values))
+              end
+          ensure
+            stmt.close
+          end
+        end
+        verified!
+
+        result
+      end
+
+      def affected_rows(_result)
+        @last_affected_rows
+      end
+
+      def cast_result(result)
+        result
+      end
+
+      def quote_column_name(name)
+        %("#{name.to_s.gsub('"', '""')}").freeze
+      end
+
+      def quote_table_name(name)
+        %("#{name.to_s.gsub('"', '""').gsub('.', '"."')}").freeze
+      end
+
+      def column_definitions(table_name)
+        internal_exec_query("PRAGMA table_xinfo(#{quote_table_name(table_name)})", 'SCHEMA')
+      end
+
+      def data_source_sql(name = nil, type: nil)
+        scope = quoted_scope(name, type:)
+        scope[:type] ||= "'table','view'"
+
+        sql = +"SELECT name FROM pragma_table_list WHERE schema <> 'temp'"
+        sql << " AND name NOT IN ('sqlite_sequence', 'sqlite_schema')"
+        sql << " AND name = #{scope[:name]}" if scope[:name]
+        sql << " AND type IN (#{scope[:type]})"
+        sql
+      end
+
+      def quoted_scope(name = nil, type: nil)
+        type = {
+          'BASE_TABLE': "'table'",
+          'VIEW': "'view'",
+          'VIRTUAL TABLE': "'virtual'"
+        }[type]
+
+        scope = {}
+        scope[:name] = quote(name) if name
+        scope[:type] = type if type
+        scope
+      end
+
+      def extract_value_from_default(default)
+        case default
+        when /^null$/i then nil
+        when /^'([^|]*)'$/m then::Regexp.last_match(1).gsub("''", "'")
+        when /^"([^|]*)"$/m then ::Regexp.last_match(1).gsub('""', '"')
+        when /\A-?\d+(\.\d*)?\z/ then ::Regexp.last_match(0)
+        when /x'(.*)'/ then [::Regexp.last_match(1)].pack('H*')
+        end
+      end
+
+      def extract_default_function(default_value, default)
+        default if default_function?(default_value, default)
+      end
+
+      def default_function?(default_value, default)
+        !default_value && /\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP|\|\|/.match?(default)
+      end
+
+      def extract_generated_type(field)
+        case field['hidden']
+        when 2 then :virtual
+        when 3 then :stored
+        end
+      end
+
+      def column_the_rowid?(field, column_definitions)
+        return false unless /integer/i.match?(field['type']) && field['pk'] == 1
+
+        column_definitions.one? { |c| c['pk'].positive? }
+      end
+
+      def new_column_from_field(_table_name, field, definitions)
+        default = field['dflt_value']
+
+        type_metadata = fetch_type_metadata(field['type'])
+        default_value = extract_value_from_default(default)
+        generated_type = extract_generated_type(field)
+
+        default_function =
+          if generated_type.present?
+            default
+          else
+            extract_default_function(default_value, default)
+          end
+
+        rowid = column_the_rowid?(field, definitions)
+
+        Column.new(
+          field['name'],
+          default_value,
+          type_metadata,
+          field['notnull'].to_i.zero?,
+          default_function,
+          collation: field['collation'],
+          auto_increment: field['auto_increment'],
+          rowid:,
+          generated_type:
+        )
+      end
+
+      def primary_keys(table_name) # :nodoc:
+        column_definitions(table_name)
+          .select { |f| f['pk'].positive? }
+          .sort_by { |f| f['pk'] }
+          .map { |f| f['name'] }
+      end
+
+      def indexes(table_name)
+        internal_exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", 'SCHEMA').filter_map do |row|
+          # Indexes SQLite creates implicitly for internal use start with "sqlite_".
+          # See https://www.sqlite.org/fileformat2.html#intschema
+          next if row['name'].start_with?('sqlite_')
+
+          index_sql = query_value(<<~SQL, 'SCHEMA')
+            SELECT sql
+            FROM sqlite_master
+            WHERE name = #{quote(row['name'])} AND type = 'index'
+            UNION ALL
+            SELECT sql
+            FROM sqlite_temp_master
+            WHERE name = #{quote(row['name'])} AND type = 'index'
+          SQL
+
+          %r{\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+))?(?:\s*/\*.*\*/)?\z}i =~ index_sql
+
+          columns = internal_exec_query("PRAGMA index_info(#{quote(row['name'])})", 'SCHEMA').map do |col|
+            col['name']
+          end
+
+          where = where.sub(%r{\s*/\*.*\*/\z}, '') if where
+          orders = {}
+
+          if columns.any?(&:nil?) # index created with an expression
+            columns = expressions
+          elsif index_sql
+            # Add info on sort order for columns (only desc order is explicitly specified,
+            # asc is the default)
+            index_sql.scan(/"(\w+)" DESC/).flatten.each do |order_column|
+              orders[order_column] = :desc
+            end # index_sql can be null in case of primary key indexes
+          end
+
+          IndexDefinition.new(
+            table_name,
+            row['name'],
+            row['unique'] != 0,
+            columns,
+            where:,
+            orders:
+          )
+        end
+      end
+    end
+  end
+end

data/lib/libsql-activerecord.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/libsql_adapter'

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: libsql_activerecord
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Levy A.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: turso_libsql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description:
+email:
+- levyddsa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/connection_adapters/libsql_adapter.rb
+- lib/libsql-activerecord.rb
+homepage: https://rubygems.org/gems/libsql_activerecord
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: libSQL ActiveRecord Adapter
+test_files: []