litestack 0.4.2 → 0.4.4

data/lib/litestack/litesearch/schema_adapters/backed_adapter.rb

@@ -25,20 +25,24 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
 
   def create_primary_triggers_sql(active = false)
     when_stmt = "TRUE"
-    cols = active_cols_names
+    cols = active_cols_names.select{|n| !n.nil?}
     if (filter = @schema[:filter_column])
       when_stmt = "NEW.#{filter} = TRUE"
       cols << filter
     end
+    update_filter = ""
+    if cols.length > 0
+      " OF #{cols.join(', ')} " 
+    end
 
     <<-SQL
   CREATE TRIGGER #{name}_insert AFTER INSERT ON #{table} WHEN #{when_stmt} BEGIN
     INSERT OR REPLACE INTO #{name}(rowid, #{active_field_names.join(", ")}) VALUES (NEW.rowid, #{trigger_cols_sql});
   END;
-  CREATE TRIGGER #{name}_update AFTER UPDATE OF #{cols.join(", ")} ON #{table} WHEN #{when_stmt} BEGIN
+  CREATE TRIGGER #{name}_update AFTER UPDATE #{update_filter} ON #{table} WHEN #{when_stmt} BEGIN
     INSERT OR REPLACE INTO #{name}(rowid, #{active_field_names.join(", ")}) VALUES (NEW.rowid, #{trigger_cols_sql});
   END;
-  CREATE TRIGGER #{name}_update_not AFTER UPDATE OF #{cols.join(", ")} ON #{table} WHEN NOT #{when_stmt} BEGIN
+  CREATE TRIGGER #{name}_update_not AFTER UPDATE #{update_filter} ON #{table} WHEN NOT #{when_stmt} BEGIN
     DELETE FROM #{name} WHERE rowid = NEW.rowid;
   END;
   CREATE TRIGGER #{name}_delete AFTER DELETE ON #{table} BEGIN
@@ -51,19 +55,41 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
     "DROP TRIGGER IF EXISTS #{target_table}_#{target_col}_#{col}_#{name}_update;"
   end
 
+  def drop_secondary_trigger_poly_sql(target_table, target_col, col)
+    "DROP TRIGGER IF EXISTS #{target_table}_#{target_col}_#{name}_update;"
+  end
+
   def create_secondary_trigger_sql(target_table, target_col, col)
     <<~SQL
-      CREATE TRIGGER #{target_table}_#{target_col}_#{col}_#{name}_update AFTER UPDATE OF #{target_col} ON #{target_table} BEGIN
+      CREATE TRIGGER IF NOT EXISTS #{target_table}_#{target_col}_#{col}_#{name}_update AFTER UPDATE OF #{target_col} ON #{target_table} BEGIN
         #{rebuild_sql} AND #{table}.#{col} = NEW.id;
       END;
     SQL
   end
 
+  def create_secondary_trigger_poly_sql(target_table, target_col, col, conditions)
+    conditions_sql = conditions.collect{|k, v| "NEW.#{k} = '#{v}'"}.join(" AND ")
+    <<~SQL
+      CREATE TRIGGER IF NOT EXISTS #{target_table}_#{target_col}_#{name}_insert AFTER INSERT ON #{target_table} WHEN #{conditions_sql} BEGIN
+        #{rebuild_sql};
+      END;
+      CREATE TRIGGER IF NOT EXISTS #{target_table}_#{target_col}_#{name}_update AFTER UPDATE ON #{target_table} WHEN #{conditions_sql} BEGIN
+        #{rebuild_sql};
+      END;
+    SQL
+  end
+
+
+
   def drop_secondary_triggers_sql
     sql = ""
     @schema[:fields].each do |name, field|
       if field[:trigger_sql]
-        sql << drop_secondary_trigger_sql(field[:target_table], field[:target_col], field[:col])
+        if field[:col]
+          sql << drop_secondary_trigger_sql(field[:target_table], field[:target_col], field[:col])
+        elsif field[:source]
+          sql << drop_secondary_trigger_poly_sql(field[:target_table], field[:target_col], name)
+        end
       end
     end
     sql.empty? ? nil : sql
@@ -73,18 +99,18 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
     sql = ""
     @schema[:fields].each do |name, field|
       if field[:trigger_sql]
-        sql << create_secondary_trigger_sql(field[:target_table], field[:target_col], field[:col])
+        if field[:col]
+          sql << create_secondary_trigger_sql(field[:target_table], field[:target_col], field[:col])
+        elsif field[:source]
+          sql << create_secondary_trigger_poly_sql(field[:target_table], field[:target_col], name, field[:conditions])
+        end
       end
     end
     sql.empty? ? nil : sql
   end
 
   def rebuild_sql
-    conditions = ""
-    jcs = join_conditions_sql
-    fs = filter_sql
-    conditions = " ON #{jcs} #{fs}" unless jcs.empty? && fs.empty?
-    "INSERT OR REPLACE INTO #{name}(rowid, #{active_field_names.join(", ")}) SELECT #{table}.id, #{select_cols_sql} FROM #{join_tables_sql} #{conditions}"
+    "INSERT OR REPLACE INTO #{name}(rowid, #{active_field_names.join(", ")}) SELECT #{table}.id, #{select_cols_sql} FROM #{joins_sql} #{filter_sql}"
   end
 
   def enrich_schema
@@ -92,12 +118,23 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
       if field[:target] && !field[:target].start_with?("#{table}.")
         field[:target] = field[:target].downcase
         target_table, target_col = field[:target].split(".")
-        field[:col] = "#{name}_id".to_sym unless field[:col]
+        field[:col] = :"#{name}_id" unless field[:col]
         field[:target_table] = target_table.to_sym
         field[:target_col] = target_col.to_sym
         field[:sql] = "(SELECT #{field[:target_col]} FROM #{field[:target_table]} WHERE id = NEW.#{field[:col]})"
         field[:trigger_sql] = true # create_secondary_trigger_sql(field[:target_table], field[:target_col], field[:col])
         field[:target_table_alias] = "#{field[:target_table]}_#{name}"
+      elsif field[:source]
+        field[:source] = field[:source].downcase
+        target_table, target_col = field[:source].split(".")
+        field[:target_table] = target_table.to_sym
+        field[:target_col] = target_col.to_sym
+        field[:conditions_sql] = field[:conditions].collect{|k, v| "#{k} = '#{v}'"}.join(" AND ") if field[:conditions]
+        field[:sql] = "SELECT #{field[:target_col]} FROM #{field[:target_table]} WHERE #{field[:reference]} = NEW.id"
+        field[:sql] += " AND #{field[:conditions_sql]}" if field[:conditions_sql]       
+        field[:sql] = "(#{field[:sql]})"
+        field[:trigger_sql] = true 
+        field[:target_table_alias] = "#{field[:target_table]}_#{name}"
       else
         field[:col] = name unless field[:col]
         field[:sql] = field[:col]
@@ -109,7 +146,7 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
 
   def filter_sql
     sql = ""
-    sql << " AND #{@schema[:filter_column]} = TRUE " if @schema[:filter_column]
+    sql << " WHERE #{@schema[:filter_column]} = TRUE " if @schema[:filter_column]
     sql
   end
 
@@ -124,20 +161,27 @@ class Litesearch::Schema::BackedAdapter < Litesearch::Schema::ContentlessAdapter
       (!field[:trigger_sql].nil?) ? "#{field[:target_table_alias]}.#{field[:target_col]}" : field[:target]
     end.join(", ")
   end
-
-  def join_tables_sql
-    tables = [@schema[:table]]
+  
+  def joins_sql
+    joins = [@schema[:table]]
     active_fields.each do |name, field|
-      tables << "#{field[:target_table]} AS #{field[:target_table_alias]}" if field[:trigger_sql]
+      if field[:trigger_sql]
+        join_table = ""
+        join_table << "#{field[:target_table]} AS #{field[:target_table_alias]} ON "
+        if field[:col]
+          join_table << "#{field[:target_table_alias]}.id = #{@schema[:table]}.#{field[:col]}" if field[:col]
+        elsif field[:source]
+          join_table << "#{field[:target_table_alias]}.#{field[:reference]} = #{@schema[:table]}.id"
+          if field[:conditions]
+            join_table << " AND "
+            join_table << field[:conditions].collect{|k, v| "#{field[:target_table_alias]}.#{k} = '#{v}'"}.join(" AND ") 
+          end
+        end
+        joins << join_table 
+      end
     end
-    tables.uniq.join(", ")
+    joins.join(" LEFT JOIN ")
   end
 
-  def join_conditions_sql
-    conditions = []
-    active_fields.each do |name, field|
-      conditions << "#{field[:target_table_alias]}.id = #{@schema[:table]}.#{field[:col]}" if field[:trigger_sql]
-    end
-    conditions.join(" AND ")
-  end
+
 end

data/lib/litestack/litesearch/schema_adapters.rb

@@ -1,4 +1,4 @@
-require_relative "./schema_adapters/basic_adapter"
-require_relative "./schema_adapters/standalone_adapter"
-require_relative "./schema_adapters/contentless_adapter"
-require_relative "./schema_adapters/backed_adapter"
+require_relative "schema_adapters/basic_adapter"
+require_relative "schema_adapters/standalone_adapter"
+require_relative "schema_adapters/contentless_adapter"
+require_relative "schema_adapters/backed_adapter"

data/lib/litestack/litesearch.rb

@@ -4,8 +4,8 @@ module Litesearch
   class Schema; end
 end
 
-require_relative "./litesearch/index"
-require_relative "./litesearch/model"
+require_relative "litesearch/index"
+require_relative "litesearch/model"
 
 module Litesearch
   def litesearch_index_cache

data/lib/litestack/litesupport.rb

@@ -6,15 +6,16 @@ require "oj"
 require "yaml"
 require "pathname"
 require "fileutils"
+require "erb"
 
-require_relative "./litescheduler"
+require_relative "litescheduler"
 
 module Litesupport
   class Error < StandardError; end
 
   # Detect the Rack or Rails environment.
   def self.detect_environment
-    if defined? Rails
+    if defined?(Rails) && Rails.respond_to?(:env)
       Rails.env
     elsif ENV["RACK_ENV"]
       ENV["RACK_ENV"]
@@ -174,7 +175,7 @@ module Litesupport
     end
 
     def configure(options = {})
-      # detect enviornment (production, development, etc.)
+      # detect environment (production, development, etc.)
       defaults = begin
         self.class::DEFAULT_OPTIONS
       rescue
@@ -182,11 +183,11 @@ module Litesupport
       end
       @options = defaults.merge(options)
       config = begin
-        YAML.load_file(@options[:config_path])
+        YAML.load(ERB.new(File.read(@options[:config_path])).result)
       rescue
         {}
       end # an empty hash won't hurt
-      config = config[Litesupport.environment] if config[Litesupport.environment] # if there is a config for the current enviornment defined then use it, otherwise use the top level declaration
+      config = config[Litesupport.environment] if config[Litesupport.environment] # if there is a config for the current environment defined then use it, otherwise use the top level declaration
       config.keys.each do |k| # symbolize keys
         config[k.to_sym] = config[k]
         config.delete k
@@ -196,7 +197,7 @@ module Litesupport
     end
 
     def setup
-      @conn = create_pooled_connection
+      @conn = create_pooled_connection(@options[:connection_count])
       @logger = create_logger
       @running = true
     end
@@ -231,7 +232,8 @@ module Litesupport
     end
 
     def create_pooled_connection(count = 1)
-      Litesupport::Pool.new(1) { create_connection }
+      count = 1 unless count&.is_a?(Integer)
+      Litesupport::Pool.new(count) { create_connection }
     end
 
     # common db object options

data/lib/litestack/railtie.rb

@@ -3,8 +3,10 @@ require "rails/railtie"
 module Litestack
   class Railtie < ::Rails::Railtie
     initializer :disable_production_sqlite_warning do |app|
-      # The whole point of this gem is to use sqlite3 in production.
-      app.config.active_record.sqlite3_production_warning = false
+      if config.active_record.key?(:sqlite3_production_warning)
+        # The whole point of this gem is to use sqlite3 in production.
+        app.config.active_record.sqlite3_production_warning = false
+      end
     end
   end
 end

data/lib/litestack/version.rb

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

data/lib/litestack.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 # load core classes
-require_relative "./litestack/version"
-require_relative "./litestack/litescheduler"
-require_relative "./litestack/litesupport"
-require_relative "./litestack/litemetric"
-require_relative "./litestack/litedb"
-require_relative "./litestack/litecache"
-require_relative "./litestack/litejob"
-require_relative "./litestack/litecable"
+require_relative "litestack/version"
+require_relative "litestack/litescheduler"
+require_relative "litestack/litesupport"
+require_relative "litestack/litemetric"
+require_relative "litestack/litedb"
+require_relative "litestack/litecache"
+require_relative "litestack/litejob"
+require_relative "litestack/litecable"
 
 # conditionally load integration with other libraries
-require_relative "./sequel/adapters/litedb" if defined? Sequel
-require_relative "./active_record/connection_adapters/litedb_adapter" if defined? ActiveRecord
-require_relative "./railties/rails/commands/dbconsole" if defined?(Rails) && defined?(ActiveRecord)
-require_relative "./active_support/cache/litecache" if defined? ActiveSupport
-require_relative "./active_job/queue_adapters/litejob_adapter" if defined? ActiveJob
-require_relative "./action_cable/subscription_adapter/litecable" if defined? ActionCable
-require_relative "./litestack/railtie" if defined? Rails::Railtie
+require_relative "sequel/adapters/litedb" if defined? Sequel
+require_relative "active_record/connection_adapters/litedb_adapter" if defined? ActiveRecord
+require_relative "railties/rails/commands/dbconsole" if defined?(Rails) && defined?(ActiveRecord)
+require_relative "active_support/cache/litecache" if defined? ActiveSupport
+require_relative "active_job/queue_adapters/litejob_adapter" if defined? ActiveJob
+require_relative "action_cable/subscription_adapter/litecable" if defined? ActionCable
+require_relative "litestack/railtie" if defined? Rails::Railtie
 
 module Litestack
   class NotImplementedError < RuntimeError; end

data/lib/railties/rails/commands/dbconsole.rb

@@ -27,7 +27,7 @@ module Rails
 
         args << db_config.database
 
-        find_cmd_and_exec(["mysql", "mysql5"], *args)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec(["mysql", "mysql5"], *args)
 
       when /^postgres|^postgis/
         ENV["PGUSER"] = config[:username] if config[:username]
@@ -38,7 +38,7 @@ module Rails
         ENV["PGSSLCERT"] = config[:sslcert].to_s if config[:sslcert]
         ENV["PGSSLKEY"] = config[:sslkey].to_s if config[:sslkey]
         ENV["PGSSLROOTCERT"] = config[:sslrootcert].to_s if config[:sslrootcert]
-        find_cmd_and_exec("psql", db_config.database)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("psql", db_config.database)
 
       when "sqlite3", "litedb"
         args = []
@@ -47,7 +47,7 @@ module Rails
         args << "-header" if @options[:header]
         args << File.expand_path(db_config.database, Rails.respond_to?(:root) ? Rails.root : nil)
 
-        find_cmd_and_exec("sqlite3", *args)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlite3", *args)
 
       when "oracle", "oracle_enhanced"
         logon = ""
@@ -58,7 +58,7 @@ module Rails
           logon << "@#{db_config.database}" if db_config.database
         end
 
-        find_cmd_and_exec("sqlplus", logon)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlplus", logon)
 
       when "sqlserver"
         args = []
@@ -73,7 +73,7 @@ module Rails
           args += ["-S", host_arg]
         end
 
-        find_cmd_and_exec("sqlcmd", *args)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlcmd", *args)
 
       else
         abort "Unknown command-line client for #{db_config.database}."

data/lib/sequel/adapters/litedb.rb

@@ -19,6 +19,7 @@ module Sequel
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::Litedb.new(opts[:database].to_s, sqlite3_opts)
+        @raw_db = db
 
         self.transaction_mode = :immediate
 
@@ -33,12 +34,19 @@ module Sequel
         end
 
         db.instance_variable_set(:@prepared_statements, {})
-        @raw_db = db
         db
       end
+      
+      def sqlite_version
+        @raw_db.sqlite_version
+      end
+      
     end
 
     class Dataset < Sequel::SQLite::Dataset
+      def supports_insert_select?
+        true
+      end
     end
   end
 end

data/lib/sequel/adapters/shared/litedb.rb

@@ -715,7 +715,7 @@ module Sequel
 
       # Handle uniqueness violations when inserting, by using a specified
       # resolution algorithm. With no options, uses INSERT OR REPLACE. SQLite
-      # supports the following conflict resolution algoriths: ROLLBACK, ABORT,
+      # supports the following conflict resolution algorithms: ROLLBACK, ABORT,
       # FAIL, IGNORE and REPLACE.
       #
       # On SQLite 3.24.0+, you can pass a hash to use an ON CONFLICT clause.
@@ -877,7 +877,7 @@ module Sequel
       end
 
       # Use from_self for aggregate dataset using VALUES.
-      def aggreate_dataset_use_from_self?
+      def aggregate_dataset_use_from_self?
         super || @opts[:values]
       end
 

data/scripts/build_metrics.rb

@@ -17,14 +17,14 @@ Litejobqueue.new({
   log: nil
 })
 
-$time = Time.now.to_i #- 10800
+$time = Time.now.to_i # - 10800
 $start_time = Time.now.to_i
 
 class NormalJob
   include Litejob
   self.queue = "normal"
   def perform(time)
-    $time = time #-= (rand * 100).to_i #10 seconds in the past
+    $time = time # -= (rand * 100).to_i #10 seconds in the past
     sleep 0.001
     warn "performing some normal action"
   end

data/scripts/test_cable.rb

@@ -11,7 +11,7 @@ class Client
   end
 
   def call(*args)
-    warn "[#{Process.pid}]:#{object_id} recieved #{args} from #{@channel}"
+    warn "[#{Process.pid}]:#{object_id} received #{args} from #{@channel}"
   end
 end