litestack 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88034778fbac75441d1a9ed2e066ad6ba1aa4962eb48629de1d9ba7ae85f3468
-  data.tar.gz: d6ac66ffd1e78856bd74aa1d88163b95581494aaa481de88b673d84b5a8b8ff6
+  metadata.gz: 2662941f303da99554039370e6e53e4c13956c52070e93ad6862742881ca8063
+  data.tar.gz: ccd5583a9e0e7f5c559f8dafdde913bba256b7b5a679fe927cd31805c1289022
 SHA512:
-  metadata.gz: 37043f1eab519ea41e81e5b9cb6b20798ea5f6e7ed7ce99d8105454067129e7f49f4b8357b0855948e6df51bf6d466966802085b67943b1f9416ee90f443502a
-  data.tar.gz: 602d0e03d53eeb8e780c31b2f9bb1b3add550035c3cb3fd07f1d14fe94d94aea50a93dea19ab819454465c7824249bb40f7768ec4eebf6662af713218175071d
+  metadata.gz: 1a139b3c42cd3f9a327fc7d8f1487dab2e95f2c88d07e063eecc2e438c91236f301a8e3928c9a3b41030fd8c08f4c118c449e56ea4be35b73b00fe2aa240faf8
+  data.tar.gz: 409221a087df5707bd6da477bb9091daf2ee0fc5f8114d71a7666324676bc62e5d77b6edfd1e3e7d29d601985f7936b2e3545e618b1c888b6c7a748544bbafde

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.1.7] - 2022-03-05
+
+- Code cleanup, removal of references to older name
+- Fix for the litedb rake tasks (thanks: netmute)
+- More fixes for the new concurrency model
+- Introduced a logger for the Litejobqueue (doesn't work with Polyphony, fix should come soon)
+
+## [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

@@ -1,9 +1,9 @@
 ![litestack](https://github.com/oldmoe/litestack/blob/master/assets/litestack_logo_teal_large.png?raw=true)
 
 
-litestack is a revolutionary gem for Ruby and Ruby on Rails that provides an all-in-one solution for web application development. It exploits the power and embeddedness of SQLite to include a full-fledged SQL database, a fast cache, a robust job queue, and a simple yet performant full-text search all in a single package.
+litestack is a revolutionary gem for Ruby and Ruby on Rails that provides an all-in-one solution for web application development. It exploits the power and embeddedness of SQLite to include a full-fledged SQL database, a fast cache and a robust job queue all in a single package.
 
-Compared to conventional approaches that require separate servers and databases, LiteStack offers superior performance, efficiency, ease of use, and cost savings. Its embedded database and cache reduce memory and CPU usage, while its simple interface streamlines the development process. Overall, LiteStack sets a new standard for web application development and is an excellent choice for those who demand speed, efficiency, and simplicity.
+Compared to conventional approaches that require separate servers and databases, Litestack offers superior performance, efficiency, ease of use, and cost savings. Its embedded database and cache reduce memory and CPU usage, while its simple interface streamlines the development process. Overall, LiteStack sets a new standard for web application development and is an excellent choice for those who demand speed, efficiency, and simplicity.
 
 You can read more about why litestack can be a good choice for your next web application **[here](WHYLITESTACK.md)**, you might also be interested in litestack **[benchmarks](BENCHMARKS.md)**.
 
@@ -83,7 +83,7 @@ adapter: litedb
 litedb offers integration with the Sequel database toolkit and can be configured as follows
 
 ```ruby
-DB = Sequel.conncet("litedb://path_to_db_file")    
+DB = Sequel.connect("litedb://path_to_db_file")
 ```
 
 
@@ -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.rb

@@ -2,8 +2,8 @@ require 'sqlite3'
 
 def bench(msg, iterations=1000)
   GC.start
-  GC.compact
-  print "Starting #{iterations} iterations of #{msg} ... "
+  #GC.compact
+  STDERR.puts "Starting #{iterations} iterations of #{msg} ... "
   t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   iterations.times do |i|
     yield i
@@ -12,7 +12,7 @@ def bench(msg, iterations=1000)
   time = ((t2 - t1)*1000).to_i.to_f / 1000 rescue 0
   ips = ((iterations/(t2-t1))*100).to_i.to_f / 100 rescue "infinity?"
   #{m: msg, t: time, ips: iteratinos/time, i: iterations}
-  puts "finished in #{time} seconds (#{ips} ips)"
+ STDERR.puts " .. finished in #{time} seconds (#{ips} ips)"
 end
 
 @db = SQLite3::Database.new(":memory:") # sqlite database for fast random string generation

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_jobs_raw.rb

@@ -1,29 +1,45 @@
-#require 'polyphony'
-require 'async/scheduler'
 require './bench'
 
-Fiber.set_scheduler Async::Scheduler.new
+count = ARGV[0].to_i rescue 1000
+env = ARGV[1] || "t"
+delay = ARGV[2].to_f rescue 0
 
-count = 10000
+# Sidekiq bench
+###############
 require './skjob.rb'
-require './uljob.rb'
-
-puts Litesupport.environment
 
-t = Time.now.to_f
+t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 puts "make sure sidekiq is started with skjob.rb as the job"     
 bench("enqueuing sidekiq jobs", count) do |i|
-  SidekiqJob.perform_async(count, t)
+  SidekiqJob.perform_async(count, t, delay)
 end
 
 puts "Don't forget to check the sidekiq log for processing time conclusion"
 
-t = Time.now.to_f
+# Litejob bench
+###############
+
+if env == "t" # threaded
+  # do nothing 
+elsif env == "a" # async
+  require 'async/scheduler'
+  Fiber.set_scheduler Async::Scheduler.new
+elsif env == "p" # polyphony
+  require 'polyphony'
+end
+
+require './uljob.rb'
+
+STDERR.puts "litejob started in #{Litesupport.environment} environmnet"
+
+t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 bench("enqueuing litejobs", count) do |i|
-  MyJob.perform_async(count, t)
+  MyJob.perform_async(count, t, delay)
 end
 
-Fiber.scheduler.run
+puts "Please wait for the benchmark to finish .."
+
+Fiber.scheduler.run if env == "a"
 
 sleep
 

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/bench/skjob.rb

@@ -3,11 +3,13 @@ require 'sidekiq'
 class SidekiqJob
   include Sidekiq::Job
   @@count = 0
-  def perform(count, time)
-    sleep 0.1  
+  def perform(count, time, sleep_interval = nil)
+    sleep sleep_interval if sleep_interval  
     @@count += 1
     if @@count == count  
-      puts "finished in #{Time.now.to_f - time} seconds (#{count / (Time.now.to_f - time)} jps)"
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      STDERR.puts "Sidekiq finished in #{now - time} seconds (#{count / (now - time)} jps)"
+      @@count = 0
     end
   end
 end

data/bench/uljob.rb

@@ -4,12 +4,13 @@ require '../lib/litestack'
 class MyJob
   include Litejob
   @@count = 0
-#  self.queue = :normal
-  def perform(count, time)
-    #sleep 0.1
+  #self.queue = :default
+  def perform(count, time, sleep_interval = nil)
+    sleep sleep_interval if sleep_interval  
     @@count += 1
     if @@count == count  
-      puts "UL finished in #{Time.now.to_f - time} seconds (#{count / (Time.now.to_f - time)} jps)"
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      STDERR.puts "Litejob finished in #{now - time} seconds (#{count / (now - time)} jps)"
     end
   end
 end

data/lib/active_record/connection_adapters/litedb_adapter.rb

@@ -95,7 +95,7 @@ module ActiveRecord
     end
     
     module DatabaseTasks
-      register_task(/ultralite/,       "ActiveRecord::Tasks::LitedbDatabaseTasks")
+      register_task(/litedb/, "ActiveRecord::Tasks::LitedbDatabaseTasks")
 
     end
 	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

@@ -72,9 +72,7 @@ class Litecache
       :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 = create_store
-    @stmts = {}
-    @sql.each_pair{|k, v| @stmts[k] = @cache.prepare(v)}
+    @cache = Litesupport::Pool.new(1){create_db}
     @stats = {hit: 0, miss: 0}
     @last_visited = {}
     @running = true
@@ -85,12 +83,14 @@ 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?
-    begin
-      @stmts[:setter].execute!(key, value, expires_in)
-    rescue SQLite3::FullException
-      @stmts[:extra_pruner].execute!(0.2)
-      @cache.execute("vacuum")
-      retry
+    @cache.acquire do |cache|
+      begin
+        cache.stmts[:setter].execute!(key, value, expires_in)
+      rescue SQLite3::FullException
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
+        retry
+      end
     end
     return true
   end
@@ -99,15 +99,18 @@ 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?
-    begin
-      transaction(:immediate) do
-        @stmts[:inserter].execute!(key, value, expires_in)
-        changes = @cache.changes
+    changes = 0
+    @cache.acquire do |cache|
+      begin
+        transaction(:immediate) do
+          cache.stmts[:inserter].execute!(key, value, expires_in)
+          changes = @cache.changes
+        end
+      rescue SQLite3::FullException
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
+        retry
       end
-    rescue SQLite3::FullException
-      @stmts[:extra_pruner].execute!(0.2)
-      @cache.execute("vacuum")
-      retry
     end
     return changes > 0
   end
@@ -116,7 +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
-    if record = @stmts[:getter].execute!(key)[0]
+    if record = @cache.acquire{|cache| cache.stmts[:getter].execute!(key)[0] }
       @last_visited[key] = true
       @stats[:hit] +=1
       return record[1]
@@ -127,14 +130,18 @@ class Litecache
   
   # delete a key, value pair from the cache
   def delete(key)
-    @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
-    @stmts[:incrementer].execute!(key.to_s, amount, expires_in)
+    @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)
@@ -144,43 +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)
-    if limit and limit.is_a? Integer
-      @stmts[:limited_pruner].execute!(limit)
-    elsif limit and limit.is_a? Float
-      @stmts[:extra_pruner].execute!(limit)
-    else
-      @stmts[:pruner].execute!      
+    @cache.acquire do |cache|
+      if limit and limit.is_a? Integer
+        cache.stmts[:limited_pruner].execute!(limit)
+      elsif limit and limit.is_a? Float
+        cache.stmts[:extra_pruner].execute!(limit)
+      else
+        cache.stmts[:pruner].execute!      
+      end
     end
   end
   
   # return the number of key, value pairs in the cache
   def count
-    @stmts[:counter].execute!.to_a[0][0]
+    @cache.acquire{|cache| cache.stmts[:counter].execute!.to_a[0][0] }
   end
   
   # return the actual size of the cache file
   def size
-    @stmts[:sizer].execute!.to_a[0][0]
+    @cache.acquire{|cache| cache.stmts[:sizer].execute!.to_a[0][0] }
   end
   
   # delete all key, value pairs in the cache
   def clear
-    @cache.execute("delete FROM data")
+    @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)
@@ -192,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
 
@@ -201,35 +210,29 @@ class Litecache
   
   def spawn_worker
     Litesupport.spawn do
-      # create a specific cache instance for this worker
-      # to overcome SQLite3 Database is locked error
-      cache = create_store
-      stmts = {}
-      [:toucher, :pruner, :extra_pruner].each do |stmt|
-        stmts[stmt] = cache.prepare(@sql[stmt])
-      end
       while @running
-        Litesupport.synchronize do
+        @cache.acquire do |cache|
           begin
             cache.transaction(:immediate) do
               @last_visited.delete_if do |k| # there is a race condition here, but not a serious one
-                stmts[:toucher].execute!(k) || true
+                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]
       end
-      cache.close
     end
   end
   
-  def create_store
+  def create_db
     db = Litesupport.create_db(@options[:path])
     db.synchronous = 0
     db.cache_size = 2000
@@ -240,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/litejobqueue.rb

@@ -1,5 +1,5 @@
 # frozen_stringe_literal: true
-
+require 'logger'
 require 'oj'
 require 'yaml'
 require_relative './litequeue'
@@ -32,9 +32,10 @@ class Litejobqueue
   DEFAULT_OPTIONS = {
     config_path: "./litejob.yml",
     path: "./queue.db",
-    queues: [["default", 5]],
-    workers: 1,
-    sleep_intervals: [0.001, 0.005, 0.025, 0.125, 0.625, 3.125]
+    queues: [["default", 1]],
+    workers: 5,
+    logger: STDOUT,
+    sleep_intervals: [0.001, 0.005, 0.025, 0.125, 0.625, 1.0, 2.0]
   }
   
   @@queue = nil
@@ -57,7 +58,6 @@ 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.keys.each do |k| # symbolize keys
       config[k.to_sym] = config[k]
@@ -65,6 +65,11 @@ class Litejobqueue
     end
     @options.merge!(config)
     @queue = Litequeue.new(@options) # create a new queue object
+    if @options[:logger].respond_to? :info
+      @logger = @options[:logger] 
+    else
+      @logger = Logger.new(@options[:logger])
+    end
     # group and order queues according to their priority
     pgroups = {}
     @options[:queues].each do |q|
@@ -72,7 +77,7 @@ class Litejobqueue
       pgroups[q[1]] << [q[0], q[2] == "spawn"]
     end
     @queues = pgroups.keys.sort.reverse.collect{|p| [p, pgroups[p]]}
-    @workers = @options[:workers].times.collect{create_worker} 
+    @workers = @options[:workers].times.collect{ create_worker } 
   end
   
   # push a job to the queue
@@ -85,7 +90,10 @@ class Litejobqueue
   #   jobqueue.push(EasyJob, params) # the job will be performed asynchronously
   def push(jobclass, params, delay=0, queue=nil)
     payload = Oj.dump([jobclass, params])
-    @queue.push(payload, delay, queue)
+    #res = 
+    res = @queue.push(payload, delay, queue)
+    @logger.info("[litejob]:[ENQ] id: #{res} class: #{jobclass}")
+    res
   end
   
   # delete a job from the job queue
@@ -99,7 +107,9 @@ class Litejobqueue
   #   jobqueue.delete(id)    
   def delete(id)
     job = @queue.delete(id)
+    @logger.info("[litejob]:[DEL] job: #{job}")
     Oj.load(job) if job
+    job
   end
   
   private
@@ -111,30 +121,36 @@ class Litejobqueue
     else
       yield
     end
-  end
-  
+  end  
+    
   # create a worker according to environment
   def create_worker
     Litesupport.spawn do
-      # we create a queue object specific to this worker here
-      # this way we can survive potential SQLite3 Database is locked errors
-      queue = Litequeue.new(@options)
+      if @options[:logger].respond_to? :info
+        logger = @options[:logger] 
+      else
+        logger = Logger.new(@options[:logger])
+      end
+      worker_sleep_index = 0
+      i = 0
       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], 1) # fearlessly use the same queue object 
               processed += 1
               index += 1
               begin
                 id, job = payload[0], payload[1]
                 job = Oj.load(job)
+                logger.info "[litejob]:[DEQ] id: #{id} class: #{job[0]}" 
                 klass = eval(job[0])
                 schedule(q[1]) do # run the job in a new context
                   begin
                     klass.new.perform(*job[1])
+                    logger.info "[litejob]:[END] id: #{id} class: #{job[0]}" 
                   rescue Exception => e
                     puts e
                     puts e.message
@@ -146,18 +162,18 @@ class Litejobqueue
                 puts e.message
                 puts e.backtrace
               end
-              Litesupport.switch #give other context a chance to run here
+              Litesupport.switch #give other contexts a chance to run here
             end
           end
         end
         if processed == 0 
-          sleep @options[:sleep_intervals][@worker_sleep_index]      
-          @worker_sleep_index += 1 if @worker_sleep_index < @options[:sleep_intervals].length - 1          
+          sleep @options[:sleep_intervals][worker_sleep_index]      
+          worker_sleep_index += 1 if worker_sleep_index < @options[:sleep_intervals].length - 1          
         else
-          @worker_sleep_index = 0 # reset the index
+          worker_sleep_index = 0 # reset the index
         end
       end
     end
-  end     
+  end  
   
 end

data/lib/litestack/litequeue.rb

@@ -34,23 +34,28 @@ 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
   
   alias_method :"<<", :push
   
   # pop an item from the queue, optionally with a specific queue name (default queue name is 'default')
-  def pop(queue='default')
-    @pop.execute!(queue)[0]
+  def pop(queue='default', limit = 1)
+   res = @queue.acquire {|q| res = q.stmts[:pop].execute!(queue, limit)[0] }
+   #return res[0] if res.length == 1
+   #res
   end
   
   # delete an item from the queue
@@ -60,22 +65,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  
@@ -86,14 +91,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) IN (SELECT queue, fire_at, id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) ORDER BY fire_at ASC LIMIT ifnull($2, 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