litedb.rb in litedb-0.2.1

- old
+ new
@@ -1,100 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "litedb/version"
+require_relative "litedb/connection"
 
 require "sqlite3"
 require "litescheduler"
 
-class Litedb < SQLite3::Database
+module Litedb
   class Error < StandardError; end
-
-  DEFAULT_FILE = ":memory:"
-  DEFAULT_OPTIONS = {
-    synchronous: :NORMAL,
-    mmap_size: 32 * 1024, # 32 kilobytes
-    journal_size_limit: 64 * 1024 * 1024 # 64 megabytes
-  }.freeze
-
-  attr_reader :config
-
-  def initialize(file = nil, options = {}, zvfs = nil)
-    @scheduler = Litescheduler.instance
-    file ||= DEFAULT_FILE
-    options = options.transform_keys { |key|
-      begin
-        key.to_sym
-      rescue
-        key
-      end
-    }
-    @config = DEFAULT_OPTIONS.merge(options)
-
-    super(file, @config, zvfs)
-
-    set_pragmas
-    run_migrations
-    prepare_statements
-  end
-
-  def run_statement(statement, *args)
-    statements[statement].execute!(*args)
-  end
-
-  private
-
-  def set_pragmas
-    # set a custom busy handler to override the `busy_timeout`
-    # this ensures we either switch to another execution context or try again to connect
-    # https://www.sqlite.org/pragma.html#pragma_busy_timeout
-    busy_handler { @scheduler.switch || sleep(rand * 0.001) }
-    # Journal mode WAL allows for greater concurrency (many readers + one writer)
-    # https://www.sqlite.org/pragma.html#pragma_journal_mode
-    self.journal_mode = :WAL
-    # level of database durability
-    # 2 = "FULL" (sync on every write)
-    # 1 = "NORMAL" (sync every 1000 written pages)
-    # 0 = "OFF" (don't sync)
-    # https://www.sqlite.org/pragma.html#pragma_synchronous
-    self.synchronous = @config[:synchronous]
-    # set the global memory map so all processes can share data
-    # https://www.sqlite.org/pragma.html#pragma_mmap_size
-    # https://www.sqlite.org/mmap.html
-    self.mmap_size = @config[:mmap_size]
-    # impose a limit on the WAL file to prevent unlimited growth (with a negative impact on read performance as well)
-    # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
-    self.journal_size_limit = @config[:journal_size_limit]
-  end
-
-  def run_migrations
-    return if @config[:migrations].nil?
-
-    migrations = if @config[:migrations].is_a?(Hash)
-      @config[:migrations].values
-    elsif @config[:migrations].is_a?(Array)
-      @config[:migrations]
-    else
-      raise Error.new("`migrations` option must be either a Hash or an Array")
-    end
-
-    transaction(:immediate) do
-      migrations.each do |sql|
-        execute(clean_sql(sql))
-      end
-    end
-  end
-
-  def prepare_statements
-    instance_variable_set(:@statements, {})
-    self.class.attr_reader(:statements) unless respond_to?(:statements)
-
-    return if @config[:statements].nil?
-
-    @config[:statements].each do |key, sql|
-      statements[key.to_sym] = prepare(clean_sql(sql))
-    end
-  end
-
-  def clean_sql(sql)
-    sql.gsub(/[[:space:]]+/, " ").strip
-  end
 end