litestack 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c34bfdfaaa6a2472e132e05b1f80494a76d2311026c764b312a463f4f5cb2ee0
-  data.tar.gz: c27e887802afe1ee2f5c7e2c67aeb390fde3ef62adb6cec610e9e3f7af697753
+  metadata.gz: 01c10017cec21bcabea357aecb8746779060718bb2e6b6e36f250c37d80656f1
+  data.tar.gz: 863b319c7a658f2a19410c614035068f8a2dec72b189698a5a081f595ecf5853
 SHA512:
-  metadata.gz: abd6ae7cd31c4988b911f147bcdd00f947fdda537993f854250b3d5c8b91bbb2d702faf0f73e07e6b54f4603253d90dd89ef80c41baab61cb313ccb9420d8e54
-  data.tar.gz: 58e3f6d9b443afc614d4254ace16c7ff3bd5bdfa1dbbfcfabf9e2eb8f69f57b7b1b15153ac59a7de91e303a305987b9aa92701f204140eea4e5ba4108a05725b
+  metadata.gz: 7bb0fd84ee582eddfe32e48b0373a7545cad8581217ba56d7ac6c984b60b137b86d5196e1bc37486b88d21c28bc5ff62da573a1ba6ce6b49d66ba744ddbcabc6
+  data.tar.gz: 38da99eae6a37222a8689577900504ea1b131f0ec56f67531dff00f5ae4f4c62a29baca21ba2a102435cc334773f8ef4709a361dff6f28de988471eac0937e08

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.1.6] - 2022-03-03
+
+- Revamped the locking model, more robust, minimal performance hit
+- Introduced a new resource pooling class
+- Litecache and Litejob now use the resource pool
+- Much less memory usage for Litecache and Litejob
+
 ## [0.1.0] - 2022-02-26
 
 - Initial release

data/README.md

@@ -152,9 +152,9 @@ You can add more configuration in litejob.yml (or config/litejob.yml if you are
 
 ```yaml
 queues:
-    - [default 1]
-    - [urgent 5]
-    - [critical 10 "spawn"]
+    - [default, 1]
+    - [urgent, 5]
+    - [critical, 10, "spawn"]
 ```
 
 The queues need to include a name and a priority (a number between 1 and 10) and can also optionally add the token "spawn", which means every job will run it its own concurrency context (thread or fiber)

data/bench/bench_cache_raw.rb

@@ -9,7 +9,7 @@ Fiber.set_scheduler Async::Scheduler.new
 Fiber.scheduler.run
 
 require_relative '../lib/litestack'
-
+#require 'litestack'
 
 cache = Litecache.new({path: '../db/cache.db'}) # default settings
 redis = Redis.new # default settings

data/bench/bench_queue.rb

@@ -5,11 +5,11 @@ count = 1000
 
 q = Litequeue.new({path: '../db/queue.db' })
 
-bench("enqueue", count) do |i|
+bench("Litequeue enqueue", count) do |i|
   q.push i.to_s
 end
 
-bench("dequeue", count) do |i|
+bench("Litequeue dequeue", count) do |i|
   q.pop  
 end
 

data/lib/active_support/cache/litecache.rb

@@ -25,12 +25,14 @@ module ActiveSupport
       def increment(key, amount = 1, options = nil)
         key = key.to_s
         options = merged_options(options)
-        @cache.transaction(:immediate) do
+        # todo: fix me
+        # this is currently a hack to avoid dealing with Rails cache encoding and decoding
+        #@cache.transaction(:immediate) do
           if value = read(key, options)
             value = value.to_i + amount
             write(key, value, options)
           end
-        end
+        #end
       end
 
       def decrement(key, amount = 1, options = nil)

data/lib/litestack/litecache.rb

@@ -58,21 +58,21 @@ class Litecache
   def initialize(options = {})
     @options = DEFAULT_OPTIONS.merge(options)
     @options[:size] = @options[:min_size] if @options[:size] < @options[:min_size]
-    @cache = create_store
-    @stmts = {
-      :pruner => @cache.prepare("DELETE FROM data WHERE expires_in <= $1"),
-      :extra_pruner => @cache.prepare("DELETE FROM data WHERE id IN (SELECT id FROM data ORDER BY last_used ASC LIMIT (SELECT CAST((count(*) * $1) AS int) FROM data))"),
-      :limited_pruner => @cache.prepare("DELETE FROM data WHERE id IN (SELECT id FROM data ORDER BY last_used asc limit $1)"),
-      :toucher => @cache.prepare("UPDATE data SET  last_used = unixepoch('now') WHERE id = $1"),
-      :setter => @cache.prepare("INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = excluded.value, last_used = excluded.last_used, expires_in = excluded.expires_in"),
-      :inserter => @cache.prepare("INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = excluded.value, last_used = excluded.last_used, expires_in = excluded.expires_in WHERE id = $1 and expires_in <= unixepoch('now')"),
-      :finder => @cache.prepare("SELECT id FROM data WHERE id = $1"),
-      :getter => @cache.prepare("SELECT id, value, expires_in FROM data WHERE id = $1"),
-      :deleter => @cache.prepare("delete FROM data WHERE id = $1 returning value"),
-      :incrementer => @cache.prepare("INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = cast(value AS int) + cast(excluded.value as int), last_used = excluded.last_used, expires_in = excluded.expires_in"),
-      :counter => @cache.prepare("SELECT count(*) FROM data"),
-      :sizer => @cache.prepare("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count") 
+    @sql = {
+      :pruner => "DELETE FROM data WHERE expires_in <= $1",
+      :extra_pruner => "DELETE FROM data WHERE id IN (SELECT id FROM data ORDER BY last_used ASC LIMIT (SELECT CAST((count(*) * $1) AS int) FROM data))",
+      :limited_pruner => "DELETE FROM data WHERE id IN (SELECT id FROM data ORDER BY last_used asc limit $1)",
+      :toucher => "UPDATE data SET  last_used = unixepoch('now') WHERE id = $1",
+      :setter => "INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = excluded.value, last_used = excluded.last_used, expires_in = excluded.expires_in",
+      :inserter => "INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = excluded.value, last_used = excluded.last_used, expires_in = excluded.expires_in WHERE id = $1 and expires_in <= unixepoch('now')",
+      :finder => "SELECT id FROM data WHERE id = $1",
+      :getter => "SELECT id, value, expires_in FROM data WHERE id = $1",
+      :deleter => "delete FROM data WHERE id = $1 returning value",
+      :incrementer => "INSERT into data (id, value, expires_in, last_used) VALUES   ($1, $2, unixepoch('now') + $3, unixepoch('now')) on conflict(id) do UPDATE SET value = cast(value AS int) + cast(excluded.value as int), last_used = excluded.last_used, expires_in = excluded.expires_in",
+      :counter => "SELECT count(*) FROM data",
+      :sizer => "SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count" 
     }
+    @cache = Litesupport::Pool.new(1){create_db}
     @stats = {hit: 0, miss: 0}
     @last_visited = {}
     @running = true
@@ -83,12 +83,12 @@ class Litecache
   def set(key, value, expires_in = nil)
     key = key.to_s
     expires_in = @options[:expires_in] if expires_in.nil? or expires_in.zero?
-    Litesupport.synchronize do
+    @cache.acquire do |cache|
       begin
-        @stmts[:setter].execute!(key, value, expires_in)
+        cache.stmts[:setter].execute!(key, value, expires_in)
       rescue SQLite3::FullException
-        @stmts[:extra_pruner].execute!(0.2)
-        @cache.execute("vacuum")
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
         retry
       end
     end
@@ -99,15 +99,16 @@ class Litecache
   def set_unless_exists(key, value, expires_in = nil)
     key = key.to_s
     expires_in = @options[:expires_in] if expires_in.nil? or expires_in.zero?
-    Litesupport.synchronize do
+    changes = 0
+    @cache.acquire do |cache|
       begin
         transaction(:immediate) do
-          @stmts[:inserter].execute!(key, value, expires_in)
+          cache.stmts[:inserter].execute!(key, value, expires_in)
           changes = @cache.changes
         end
       rescue SQLite3::FullException
-        @stmts[:extra_pruner].execute!(0.2)
-        @cache.execute("vacuum")
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
         retry
       end
     end
@@ -118,11 +119,7 @@ class Litecache
   # if the key doesn't exist or it is expired then null will be returned
   def get(key)
     key = key.to_s
-    record = nil
-    Litesupport.synchronize do
-      record = @stmts[:getter].execute!(key)[0]
-    end
-    if record
+    if record = @cache.acquire{|cache| cache.stmts[:getter].execute!(key)[0] }
       @last_visited[key] = true
       @stats[:hit] +=1
       return record[1]
@@ -133,18 +130,18 @@ class Litecache
   
   # delete a key, value pair from the cache
   def delete(key)
-    Litesupport.synchronize do
-      @stmts[:deleter].execute!(key)
-      return @cache.changes > 0
+    changes = 0
+    @cache.aquire do |cache|
+      cache.stmts[:deleter].execute!(key)
+      changes = cache.changes
     end
+    return changes > 0
   end
   
   # increment an integer value by amount, optionally add an expiry value (in seconds)
   def increment(key, amount, expires_in = nil)
     expires_in = @expires_in unless expires_in
-    Litesupport.synchronize do
-      @stmts[:incrementer].execute!(key.to_s, amount, expires_in)
-    end
+    @cache.acquire{|cache| cache.stmts[:incrementer].execute!(key.to_s, amount, expires_in) }
   end
   
   # decrement an integer value by amount, optionally add an expiry value (in seconds)
@@ -154,51 +151,43 @@ class Litecache
   
   # delete all entries in the cache up limit (ordered by LRU), if no limit is provided approximately 20% of the entries will be deleted
   def prune(limit=nil)
-    Litesupport.synchronize do
+    @cache.acquire do |cache|
       if limit and limit.is_a? Integer
-        @stmts[:limited_pruner].execute!(limit)
+        cache.stmts[:limited_pruner].execute!(limit)
       elsif limit and limit.is_a? Float
-        @stmts[:extra_pruner].execute!(limit)
+        cache.stmts[:extra_pruner].execute!(limit)
       else
-        @stmts[:pruner].execute!      
+        cache.stmts[:pruner].execute!      
       end
     end
   end
   
   # return the number of key, value pairs in the cache
   def count
-    Litesupport.synchronize do
-      @stmts[:counter].execute!.to_a[0][0]
-    end
+    @cache.acquire{|cache| cache.stmts[:counter].execute!.to_a[0][0] }
   end
   
   # return the actual size of the cache file
   def size
-    Litesupport.synchronize do
-      @stmts[:sizer].execute!.to_a[0][0]
-    end
+    @cache.acquire{|cache| cache.stmts[:sizer].execute!.to_a[0][0] }
   end
   
   # delete all key, value pairs in the cache
   def clear
-    Litesupport.synchronize do  
-      @cache.execute("delete FROM data")
-    end
+    @cache.acquire{|cache| cache.execute("delete FROM data") }
   end
   
   # close the connection to the cache file
   def close
     @running = false
     #Litesupport.synchronize do
-      #@cache.close
+    @cache.acquire{|cache| cache.close }
     #end
   end
   
   # return the maximum size of the cache
   def max_size
-    Litesupport.synchronize do
-      @cache.get_first_value("SELECT s.page_size * c.max_page_count FROM pragma_page_size() as s, pragma_max_page_count() as c")
-    end
+    @cache.acquire{|cache| cache.get_first_value("SELECT s.page_size * c.max_page_count FROM pragma_page_size() as s, pragma_max_page_count() as c") }
   end
   
   # hits and misses for get operations performed over this particular connection (not cache wide)
@@ -210,8 +199,10 @@ class Litecache
 
   # low level access to SQLite transactions, use with caution
   def transaction(mode)
-    @cache.transaction(mode) do
-      yield
+    @cache.acquire do |cache|
+      cache.transaction(mode) do
+        yield
+      end
     end
   end
 
@@ -220,18 +211,20 @@ class Litecache
   def spawn_worker
     Litesupport.spawn do
       while @running
-        Litesupport.synchronize do
+        @cache.acquire do |cache|
           begin
-            @cache.transaction(:immediate) do
-              @last_visited.delete_if do |k|
-                @stmts[:toucher].execute!(k) || true
+            cache.transaction(:immediate) do
+              @last_visited.delete_if do |k| # there is a race condition here, but not a serious one
+                cache.stmts[:toucher].execute!(k) || true
               end
-              @stmts[:pruner].execute!             
+              cache.stmts[:pruner].execute!             
             end
           rescue SQLite3::BusyException
             retry
           rescue SQLite3::FullException
-            @stmts[:extra_pruner].execute!(0.2)
+            cache.stmts[:extra_pruner].execute!(0.2)
+          rescue Exception
+            # database is closed
           end
         end
         sleep @options[:sleep_interval]
@@ -239,7 +232,7 @@ class Litecache
     end
   end
   
-  def create_store
+  def create_db
     db = Litesupport.create_db(@options[:path])
     db.synchronous = 0
     db.cache_size = 2000
@@ -250,6 +243,7 @@ class Litecache
     db.execute("CREATE table if not exists data(id text primary key, value text, expires_in integer, last_used integer)")
     db.execute("CREATE index if not exists expiry_index on data (expires_in)")
     db.execute("CREATE index if not exists last_used_index on data (last_used)")
+    @sql.each_pair{|k, v| db.stmts[k] = db.prepare(v)}
     db
   end
   

data/lib/litestack/litejob.rb

@@ -43,21 +43,21 @@ module Litejob
   private
   def self.included(klass)
     klass.extend(ClassMethods)
-    klass.get_queue
+    klass.get_jobqueue
   end
   
   module ClassMethods
     def perform_async(*params)
-      get_queue.push(self.name, params, 0, queue)      
+      get_jobqueue.push(self.name, params, 0, queue)      
     end
     
     def perform_at(time, *params)
       delay = time - Time.now.to_i
-      get_queue.push(self.name, params, delay, queue)           
+      get_jobqueue.push(self.name, params, delay, queue)           
     end
     
     def perfrom_in(delay, *params)
-      get_queue.push(self.name, params, delay, queue)           
+      get_jobqueue.push(self.name, params, delay, queue)           
     end
         
     def options
@@ -76,8 +76,8 @@ module Litejob
       @@queue_name = queue_name.to_s
     end
           
-    def get_queue
-      Litejobqueue.queue(options)
+    def get_jobqueue
+      Litejobqueue.jobqueue(options)
     end
   end
     

data/lib/litestack/litejobqueue.rb

@@ -41,7 +41,7 @@ class Litejobqueue
   
   # a method that returns a single instance of the job queue
   # for use by Litejob
-  def self.queue(options = {})
+  def self.jobqueue(options = {})
     @@queue ||= Litesupport.synchronize{self.new(options)}
   end
 
@@ -58,8 +58,8 @@ class Litejobqueue
   def initialize(options = {})
     @options = DEFAULT_OPTIONS.merge(options)
     @worker_sleep_index = 0
-    config = YAML.load_file(@options[:config_path]) rescue {} #an empty hash won't hurt
-    config.each_key do |k| # symbolize keys
+    config = YAML.load_file(@options[:config_path]) rescue {} # an empty hash won't hurt
+    config.keys.each do |k| # symbolize keys
       config[k.to_sym] = config[k]
       config.delete k
     end
@@ -116,14 +116,13 @@ class Litejobqueue
   # create a worker according to environment
   def create_worker
     Litesupport.spawn do
-      Litesupport.switch
       loop do
         processed = 0
         @queues.each do |level| # iterate through the levels
           level[1].each do |q| # iterate through the queues in the level
             index = 0
             max = level[0]
-            while index < max && payload = @queue.pop(q[0])  
+            while index < max && payload = @queue.pop(q[0]) # fearlessly use the same queue object 
               processed += 1
               index += 1
               begin

data/lib/litestack/litequeue.rb

@@ -34,15 +34,18 @@ class Litequeue
   
   def initialize(options = {})
     @options = DEFAULT_OPTIONS.merge(options)
-    @queue = create_db #(@options[:path])
-    prepare
+    @queue = Litesupport::Pool.new(1){create_db} # delegate the db creation to the litepool
   end
    
   # push an item to the queue, optionally specifying the queue name (defaults to default) and after how many seconds it should be ready to pop (defaults to zero)
   # a unique job id is returned from this method, can be used later to delete it before it fires. You can push string, integer, float, true, false or nil values
   #
   def push(value, delay=0, queue='default')
-    result = @push.execute!(queue, delay, value)[0]
+    # @todo - check if queue is busy, back off if it is
+    # also bring back the synchronize block, to prevent
+    # a race condition if a thread hits the busy handler
+    # before the current thread proceeds after a backoff
+    result = @queue.acquire { |q| q.stmts[:push].execute!(queue, delay, value)[0] }
     return result[0] if result
   end
   
@@ -50,11 +53,7 @@ class Litequeue
   
   # pop an item from the queue, optionally with a specific queue name (default queue name is 'default')
   def pop(queue='default')
-    result = nil
-    Litesupport.synchronize do
-      result = @pop.execute!(queue)[0]
-    end
-    result 
+    @queue.acquire {|q| q.stmts[:pop].execute!(queue)[0] }
   end
   
   # delete an item from the queue
@@ -64,22 +63,22 @@ class Litequeue
   #   queue.pop # => nil
   def delete(id, queue='default')
     fire_at, id = id.split("_")
-    result = @deleter.execute!(queue, fire_at.to_i, id)[0]
+    result = @queue.acquire{|q| q.stmts[:delete].execute!(queue, fire_at.to_i, id)[0] } 
   end
   
   # deletes all the entries in all queues, or if a queue name is given, deletes all entries in that specific queue
   def clear(queue=nil)
-    @queue.execute("DELETE FROM _ul_queue_ WHERE iif(?, queue = ?,  1)", queue)
+    @queue.acquire{|q| q.execute("DELETE FROM _ul_queue_ WHERE iif(?, queue = ?,  1)", queue) }
   end
 
   # returns a count of entries in all queues, or if a queue name is given, reutrns the count of entries in that queue
   def count(queue=nil)
-    @queue.get_first_value("SELECT count(*) FROM _ul_queue_ WHERE iif(?, queue = ?, 1)", queue)
+    @queue.acquire{|q| q.get_first_value("SELECT count(*) FROM _ul_queue_ WHERE iif(?, queue = ?, 1)", queue) }
   end
   
   # return the size of the queue file on disk
   def size
-    @queue.get_first_value("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count")
+    @queue.acquire{|q| q.get_first_value("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count") }
   end
 
   private  
@@ -90,14 +89,12 @@ class Litequeue
     db.wal_autocheckpoint = 10000 
     db.mmap_size = @options[:mmap_size]
     db.execute("CREATE TABLE IF NOT EXISTS _ul_queue_(queue TEXT DEFAULT('default') NOT NULL ON CONFLICT REPLACE, fire_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, id TEXT DEFAULT(hex(randomblob(8)) || (strftime('%f') * 100)) NOT NULL ON CONFLICT REPLACE, value TEXT, created_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, PRIMARY KEY(queue, fire_at ASC, id) ) WITHOUT ROWID")
+    db.stmts[:push] = db.prepare("INSERT INTO _ul_queue_(queue, fire_at, value) VALUES ($1, (strftime('%s') + $2), $3) RETURNING fire_at || '-' || id")
+    db.stmts[:pop] = db.prepare("DELETE FROM _ul_queue_ WHERE (queue, fire_at, id) = (SELECT queue, min(fire_at), id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) limit 1) RETURNING fire_at || '-' || id, value")
+    db.stmts[:delete] = db.prepare("DELETE FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at = $2 AND id = $3 RETURNING value")
     db
   end
 
-  def prepare
-     @push = @queue.prepare("INSERT INTO _ul_queue_(queue, fire_at, value) VALUES ($1, (strftime('%s') + $2), $3) RETURNING fire_at || '-' || id")
-     @pop = @queue.prepare("DELETE FROM _ul_queue_ WHERE (queue, fire_at, id) = (SELECT queue, min(fire_at), id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) limit 1) RETURNING fire_at || '-' || id, value")
-     @deleter = @queue.prepare("DELETE FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at = $2 AND id = $3 RETURNING value")
-  end
 
 end  
 

data/lib/litestack/litesupport.rb

@@ -33,15 +33,30 @@ module Litesupport
     # we should never reach here
   end
   
+  def self.detect_context
+    if environment == :fiber || environment == :poylphony
+      Fiber.current.storage
+    else
+      Thread.current
+    end
+  end
+  
+  def self.context
+    @ctx ||= detect_context
+  end
+  
   # switch the execution context to allow others to run
   def self.switch
     if self.environment == :fiber
       Fiber.scheduler.yield
+      true
     elsif self.environment == :polyphony
       Fiber.current.schedule
       Thread.current.switch_fiber
+      true
     else
       # do nothing in case of thread, switching will auto-happen
+      false
     end   
   end
   
@@ -66,9 +81,67 @@ module Litesupport
   # common db object options
   def self.create_db(path)
     db = SQLite3::Database.new(path)
-    db.busy_handler{ sleep 0.001 }
+    db.busy_handler{ switch || sleep(0.001) }
     db.journal_mode = "WAL"
+    db.instance_variable_set(:@stmts, {})
+    class << db
+      attr_reader :stmts
+    end
     db
   end
   
+  class Mutex
+  
+    def initialize
+      @mutex = Thread::Mutex.new
+    end
+    
+    def synchronize(&block)
+      if Litesupport.environment == :threaded || Litesupport.environment == :iodine
+        @mutex.synchronize{ block.call }
+      else
+        block.call
+      end
+    end
+  
+  end
+  
+  class Pool
+  
+    def initialize(count, &block)
+      @count = count
+      @block = block
+      @resources = []
+      @mutex = Litesupport::Mutex.new
+      @count.times do
+        resource = @mutex.synchronize{ block.call }
+        @resources << [resource, :free]
+      end
+    end
+    
+    def acquire
+      acquired = false
+      result = nil
+      while !acquired do
+        @mutex.synchronize do
+          if resource = @resources.find{|r| r[1] == :free}
+            resource[1] = :busy
+            begin
+              result = yield resource[0]
+            rescue Exception => e
+              raise e
+            ensure
+              resource[1] = :free
+              acquired = true
+              return nil              
+            end
+          end
+        end
+        sleep 0.0001 unless acquired
+      end
+      result
+    end
+    
+  end
+  
 end  

data/lib/litestack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Litestack
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end       

data/lib/sequel/adapters/litedb.rb

@@ -1,6 +1,7 @@
 require_relative '../../litestack/litedb'
 require 'sequel'
 require 'sequel/adapters/sqlite'
+#require 'shared/litedb'
 
 module Sequel
   module Litedb
@@ -12,15 +13,19 @@ module Sequel
       
       set_adapter_scheme :litedb
       
-      
       def connect(server)
+      
+        Sequel.extension :fiber_concurrency if [:fiber, :polyphony].include? Litesupport.environment
+      
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::Litedb.new(opts[:database].to_s, sqlite3_opts)
+
+        self.transaction_mode = :immediate
         
-	    if sqlite_version >= 104
+  	    if sqlite_version >= 104
           db.extended_result_codes = true
         end
         
@@ -29,8 +34,8 @@ module Sequel
         class << db
           attr_reader :prepared_statements
         end
-        db.instance_variable_set(:@prepared_statements, {})
         
+        db.instance_variable_set(:@prepared_statements, {})
         db
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: litestack
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Mohamed Hassan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-26 00:00:00.000000000 Z
+date: 2023-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3