rasti-db 2.0.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b41f6198798c9bee6da1f94742378639bb3b900f3bda6471f791b42a71a24c7
-  data.tar.gz: f470e1f1ef5673546e54e6c144e16ebba577b0f848b8fd59c8822489808a7cbf
+  metadata.gz: 335b135a71edd9bbb047407d8a288094a19f58b6c2e481837bf4406c06605350
+  data.tar.gz: 89c5da3b13e1a1f9a82faaa2eb414bc063d72c8588b35c4871deb44d189c3d5b
 SHA512:
-  metadata.gz: f5e836d580a42656efe1d78ee2e193449edd1adf45dbccd0a4b4c9c4d6f263a0d92e844a142abb908a683a8dcad4865d5926aec10b5a0260c0240425dcd063dd
-  data.tar.gz: 71148abafe56a6fe60613f2ebfa38138df2aaa656bdbe7116a834d41f3920fb49b97bfffac3235a520a6ffbb293184310d2d7fcefa552178d1cb767b94ce8e4d
+  metadata.gz: b27407dcb968c5dc6056a50160cc06b6e89f7008623f0ea2234294195080ebc153da762a79a32618740c79915ff7a5424368f58ed5ee64ff951cd1c4e6f9dc32
+  data.tar.gz: 77203709a9d842b819aaca51b789a8ac4c27fcd269f617f680530da18ce96607f610c13c4b78b72a91b75a1be4487efcb66e7daaeb7025a89888397799f2b128

data/README.md

@@ -93,7 +93,7 @@ User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
 Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
 Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
 Category = Rasti::DB::Model[:id, :name, :posts]
-Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user]
+Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :full_name, :birth_date, :user_id, :user]
 Language = Rasti::DB::Model[:id, :name, :people]
 ```
 
@@ -111,10 +111,10 @@ class Posts < Rasti::DB::Collection
   many_to_many :categories
   one_to_many :comments
 
-  query :created_by do |user_id| 
+  query :created_by do |user_id|
     where user_id: user_id
   end
-  
+
   query :entitled, -> (title) { where title: title }
 
   query :commented_by do |user_id|
@@ -144,6 +144,10 @@ class People < Rasti::DB::Collection
 
   many_to_one :user
   many_to_many :languages
+
+  computed_attribute :full_name do
+    Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+  end
 end
 
 class Languages < Rasti::DB::Collection
@@ -210,6 +214,10 @@ posts.all_attributes # => [Post, ...]
 posts.graph('user.person').select_graph_attributes(user: [:id], 'user.person': [:last_name, :user_id]) # => [Post, ...]
 posts.graph('user.person').exclude_graph_attributes(user: [:name], 'user.person': [:first_name, :last_name]) # => [Post, ...]
 posts.graph('user.person').all_graph_attributes('user.person') # => [Post, ...]
+
+posts.each { |post| do_something post } # Iterate posts loading all at first
+posts.each(batch_size: 1000) { |post| do_something post } # Iterate posts loading in batches
+posts.each_batch(size: 1000) { |posts| do_something posts } # Iterate batches of posts
 ```
 ### Natural Query Language
 

data/lib/rasti/db.rb

@@ -6,20 +6,25 @@ require 'treetop'
 require 'hierarchical_graph'
 require 'class_config'
 require 'hash_ext'
+require 'inflecto'
 require 'multi_require'
 
 module Rasti
   module DB
-    
+
     extend MultiRequire
     extend ClassConfig
 
     require_relative 'db/query'
     require_relative_pattern  'db/relations/*'
     require_relative_pattern  'db/type_converters/postgres_types/*'
+    require_relative_pattern  'db/type_converters/sqlite_types/*'
+    require_relative 'db/nql/nodes/constants/base'
+    require_relative_pattern  'db/nql/filter_condition_strategies/types/*'
     require_relative_pattern  'db/**/*'
 
     attr_config :type_converters, []
+    attr_config :nql_filter_condition_strategy, nil
 
     def self.to_db(db, collection_name, attribute_name, value)
       type_converters.inject(value) do |result, type_converter|
@@ -33,5 +38,10 @@ module Rasti
       end
     end
 
+    def self.nql_filter_condition_for(comparison_name, identifier, argument)
+      raise 'Undefined Rasti::DB.nql_filter_condition_strategy' unless nql_filter_condition_strategy
+      nql_filter_condition_strategy.filter_condition_for comparison_name, identifier, argument
+    end
+
   end
 end

data/lib/rasti/db/collection.rb

@@ -14,7 +14,7 @@ module Rasti
         end
 
         def collection_attributes
-          @collection_attributes ||= model.attributes - relations.keys
+          @collection_attributes ||= model.attributes - relations.keys - computed_attributes.keys
         end
 
         def primary_key
@@ -47,6 +47,10 @@ module Rasti
           @queries ||= Hash::Indifferent.new
         end
 
+        def computed_attributes
+          @computed_attributes ||= Hash::Indifferent.new
+        end
+
         private
 
         def set_collection_name(collection_name)
@@ -91,6 +95,11 @@ module Rasti
           end
         end
 
+        def computed_attribute(name, &block)
+          raise "Computed Attribute #{name} already exists" if computed_attributes.key? name
+          computed_attributes[name] = block.call
+        end
+
       end
 
       def initialize(environment)

data/lib/rasti/db/computed_attribute.rb

@@ -0,0 +1,22 @@
+module Rasti
+  module DB
+    class ComputedAttribute
+
+      attr_reader :identifier
+
+      def initialize(identifier, &join)
+        @identifier = identifier
+        @join = join
+      end
+
+      def apply_join(dataset)
+        join ? join.call(dataset) : dataset
+      end
+
+      private
+
+      attr_reader :join
+
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/base.rb

@@ -0,0 +1,17 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        class Base
+
+          def filter_condition_for(comparison_name, identifier, argument)
+            type = type_for argument
+            raise UnsupportedTypeComparison.new(type, comparison_name) unless type.respond_to?(comparison_name)
+            type.public_send comparison_name, identifier, argument.value
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/postgres.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        class Postgres < Base
+
+          PG_TYPES = {
+            array: Types::PGArray
+          }
+
+          private
+
+          def type_for(argument)
+            PG_TYPES.fetch(argument.type, Types::Generic)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/sqlite.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        class SQLite < Base
+
+          SQLITE_TYPES = {
+            array: Types::SQLiteArray
+          }
+
+          private
+
+          def type_for(argument)
+            SQLITE_TYPES.fetch(argument.type, Types::Generic)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/types/generic.rb

@@ -0,0 +1,49 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        module Types
+          class Generic
+
+            def self.equal(identifier, value)
+              {identifier => value}
+            end
+
+            def self.not_equal(identifier, value)
+              Sequel.negate equal(identifier, value)
+            end
+
+            def self.greater_than(identifier, value)
+              identifier > value
+            end
+
+            def self.greater_than_or_equal(identifier, value)
+              identifier >= value
+            end
+
+            def self.less_than(identifier, value)
+              identifier < value
+            end
+
+            def self.less_than_or_equal(identifier, value)
+              identifier <= value
+            end
+
+            def self.like(identifier, value)
+              Sequel.ilike identifier, value
+            end
+
+            def self.include(identifier, value)
+              Sequel.ilike identifier, "%#{value}%"
+            end
+
+            def self.not_include(identifier, value)
+              ~include(identifier, value)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/types/pg_array.rb

@@ -0,0 +1,32 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        module Types
+          class PGArray
+
+            def self.equal(identifier, values)
+              Sequel.&(
+                Sequel.pg_array(identifier).contains(Sequel.pg_array(values)),
+                Sequel.pg_array(identifier).contained_by(Sequel.pg_array(values))
+              )
+            end
+
+            def self.not_equal(identifier, values)
+              ~equal(identifier, values)
+            end
+
+            def self.include(identifier, values)
+              Sequel.pg_array(identifier).overlaps Sequel.pg_array(values)
+            end
+
+            def self.not_include(identifier, values)
+              ~include(identifier, values)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/types/sqlite_array.rb

@@ -0,0 +1,34 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        module Types
+          class SQLiteArray
+
+            def self.equal(identifier, values)
+              array = values.map { |value| "\"#{value}\"" }.join(',')
+              {identifier => "[#{array}]"}
+            end
+
+            def self.not_equal(identifier, values)
+              Sequel.|(*values.map { |value| ~Sequel.like(identifier, "%\"#{value}\"%") })
+            end
+
+            def self.like(identifier, values)
+              Sequel.|(*values.map { |value| Sequel.like(identifier, "%#{value}%") })
+            end
+
+            def self.include(identifier, values)
+              Sequel.|(*values.map { |value| Sequel.like(identifier, "%\"#{value}\"%") })
+            end
+
+            def self.not_include(identifier, values)
+              Sequel.&(*values.map { |value| ~Sequel.like(identifier, "%\"#{value}\"%") })
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/filter_condition_strategies/unsupported_type_comparison.rb

@@ -0,0 +1,22 @@
+module Rasti
+  module DB
+    module NQL
+      module FilterConditionStrategies
+        class UnsupportedTypeComparison < StandardError
+
+          attr_reader :argument_type, :comparison_name
+
+          def initialize(argument_type, comparison_name)
+            @argument_type = argument_type
+            @comparison_name = comparison_name
+          end
+
+          def message
+            "Unsupported comparison #{comparison_name} for #{argument_type}"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/nodes/array_content.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module DB
+    module NQL
+      module Nodes
+        class ArrayContent < Treetop::Runtime::SyntaxNode
+
+          def values
+            [left.value] + right_value
+          end
+
+          private
+
+          def right_value
+            right.is_a?(self.class) ? right.values : [right.value]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/nodes/attribute.rb

@@ -0,0 +1,37 @@
+module Rasti
+  module DB
+    module NQL
+      module Nodes
+        class Attribute < Treetop::Runtime::SyntaxNode
+
+          def identifier(collection_class)
+            if computed? collection_class
+              collection_class.computed_attributes[column].identifier
+            else
+              tables.empty? ? Sequel[column] : Sequel[tables.join('__').to_sym][column]
+            end
+          end
+
+          def tables
+            _tables.elements.map{ |e| e.table.text_value }
+          end
+
+          def column
+            _column.text_value.to_sym
+          end
+
+          def computed_attributes(collection_class)
+            computed?(collection_class) ? [column] : []
+          end
+
+          private
+
+          def computed?(collection_class)
+            collection_class.computed_attributes.key? column
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/nql/nodes/binary_node.rb

@@ -8,6 +8,10 @@ module Rasti
             values.flat_map(&:dependency_tables)
           end
 
+          def computed_attributes(collection_class)
+            left.computed_attributes(collection_class) | right.computed_attributes(collection_class)
+          end
+
           def values
             @values ||= values_for(left) + values_for(right)
           end

data/lib/rasti/db/nql/nodes/comparisons/base.rb

@@ -6,7 +6,21 @@ module Rasti
           class Base < Treetop::Runtime::SyntaxNode
 
             def dependency_tables
-              field.tables.empty? ? [] : [field.tables.join('.')]
+              attribute.tables.empty? ? [] : [attribute.tables.join('.')]
+            end
+
+            def computed_attributes(collection_class)
+              attribute.computed_attributes(collection_class)
+            end
+
+            def filter_condition(collection_class)
+              DB.nql_filter_condition_for comparison_name, attribute.identifier(collection_class), argument
+            end
+
+            private
+
+            def comparison_name
+              Inflecto.underscore(Inflecto.demodulize(self.class)).to_sym
             end
 
           end