rasti-db 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9da5c8d1c2a7912585a7b1f43e9f3ded9dc859e362ce071c692659e4f98b4ba
-  data.tar.gz: fa12eafca7db2b3b540871e8701218d3bb176a7cbd3b1c36d57b8fef4884064f
+  metadata.gz: 9e15c6a4b9b21397abc6135f83b6b863a8e8147e9bfea492cf25fd1d54db00cb
+  data.tar.gz: 0cebbbf49d1262804bfa559e6c696763761242b46a877c50c5f7dce528c9f16c
 SHA512:
-  metadata.gz: cd5dbacac1bf5afe377e2c3078691e8b77afed7c1fe0fa55a25e1c446f698c91630bb07045791d1aacaad45fef2967c27b2a316368083a4e27d0fd45f36c6955
-  data.tar.gz: 83a7a7048def925647078c13cfe241ca3f082cb0ab41a377d9d58fef69de1ffc06fcd781f62e51b7677bf3ffb1d60889a8d88941bc3e44c3127f656e1af720d9
+  metadata.gz: 468ca823921d6eaece74f8b0479e25fc767ed4c7e08a63fe24fd633a467ab3469cf199994b8a53e4207505e5090679011a1a5623d52f6322b910d59594a80ce0
+  data.tar.gz: 938c0fea726c3e70c1fe791d3034eae9f11077c2614321eb252556bf7ad5a8a3f8a470bb9dd3b833ad1e84cec57557a703f4f6591ae2e6dc064b163702264bef

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rasti-db.gemspec
-gemspec
+gemspec

data/lib/rasti/db.rb

@@ -1,4 +1,5 @@
 require 'sequel'
+require 'rasti-model'
 require 'consty'
 require 'time'
 require 'timing'
@@ -6,20 +7,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/**/*'
+    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 +39,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 - computed_attributes.keys
+          @collection_attributes ||= model.attribute_names - relations.keys - computed_attributes.keys
         end
 
         def primary_key
@@ -89,7 +89,7 @@ module Rasti
           raise "Query #{name} already exists" if queries.key? name
 
           queries[name] = lambda || block
-          
+
           define_method name do |*args|
             default_query.instance_exec(*args, &self.class.queries.fetch(name))
           end
@@ -210,21 +210,21 @@ module Rasti
       def qualified_collection_name
         data_source.qualify self.class.collection_name
       end
-      
+
       def qualify(collection_name, data_source_name: nil)
         data_source_name ||= self.class.data_source_name
         environment.qualify data_source_name, collection_name
       end
 
       def default_query
-        Query.new collection_class: self.class, 
-                  dataset: dataset.select_all(self.class.collection_name), 
+        Query.new collection_class: self.class,
+                  dataset: dataset.select_all(self.class.collection_name),
                   environment: environment
       end
 
       def build_query(filter=nil, &block)
         raise ArgumentError, 'must specify filter hash or block' if filter.nil? && block.nil?
-        
+
         if filter
           default_query.where(filter)
         else
@@ -233,7 +233,7 @@ module Rasti
       end
 
       def transform_attributes_to_db(attributes)
-        attributes.each_with_object({}) do |(attribute_name, value), result| 
+        attributes.each_with_object({}) do |(attribute_name, value), result|
           transformed_value = Rasti::DB.to_db data_source.db, qualified_collection_name, attribute_name, value
           result[attribute_name] = transformed_value
         end
@@ -247,7 +247,7 @@ module Rasti
 
         [collection_attributes, relations_ids]
       end
-      
+
       def save_relations(primary_key, relations_primary_keys)
         relations_primary_keys.each do |relation_name, relation_primary_keys|
           relation = self.class.relations[relation_name]
@@ -281,9 +281,9 @@ module Rasti
         relation_data_source = environment.data_source relation.relation_data_source_name
         relation_collection_name = relation_data_source.qualify relation.relation_collection_name
 
-        values = relation_primary_keys.map do |relation_pk| 
+        values = relation_primary_keys.map do |relation_pk|
           {
-            relation.source_foreign_key => primary_key, 
+            relation.source_foreign_key => primary_key,
             relation.target_foreign_key => relation_pk
           }
         end

data/lib/rasti/db/data_source.rb

@@ -12,7 +12,7 @@ module Rasti
       def qualify(collection_name)
         schema ? Sequel[schema][collection_name] : Sequel[collection_name]
       end
-      
+
     end
   end
 end

data/lib/rasti/db/model.rb

@@ -1,112 +1,11 @@
 module Rasti
   module DB
-    class Model
+    class Model < Rasti::Model
 
-      class UninitializedAttributeError < StandardError
-
-        attr_reader :attribute
-
-        def initialize(attribute)
-          @attribute = attribute
-          super "Uninitialized attribute #{attribute}"
-        end
-
-      end
-
-
-      class << self
-
-        def [](*attribute_names)
-          Class.new(self) do
-            attribute(*attribute_names)
-
-            def self.inherited(subclass)
-              subclass.instance_variable_set :@attributes, attributes.dup
-            end
-          end
-        end
-
-        def attributes
-          @attributes ||= []
-        end
-
-        def model_name
-          name || self.superclass.name
-        end
-
-        def to_s
-          "#{model_name}[#{attributes.join(', ')}]"
-        end
-        alias_method :inspect, :to_s
-
-        private
-
-        def attribute(*names)
-          names.each do |name|
-            raise ArgumentError, "Attribute #{name} already exists" if attributes.include?(name)
-            
-            attributes << name
-
-            define_method name do
-              fetch_attribute name
-            end
-          end
-        end
-
-      end
-
-
-      def initialize(attributes)
-        invalid_attributes = attributes.keys - self.class.attributes
-        raise "#{self.class.model_name} invalid attributes: #{invalid_attributes.join(', ')}" unless invalid_attributes.empty?
-        @attributes = attributes
-      end
-
-      def merge(new_attributes)
-        self.class.new attributes.merge(new_attributes)
-      end
-
-      def eql?(other)
-        instance_of?(other.class) && to_h.eql?(other.to_h)
-      end
-
-      def ==(other)
-        other.kind_of?(self.class) && to_h == other.to_h
-      end
-
-      def hash
-        attributes.map(&:hash).hash
-      end
-
-      def to_s
-        "#<#{self.class.model_name}[#{attributes.map { |n,v| "#{n}: #{v.inspect}" }.join(', ')}]>"
-      end
-      alias_method :inspect, :to_s
-
-      def to_h
-        self.class.attributes.each_with_object({}) do |name, hash|
-          if attributes.key? name
-            value = fetch_attribute name
-            case value
-            when Model
-              hash[name] = value.to_h
-            when Array
-              hash[name] = value.map do |e|
-                e.is_a?(Model) ? e.to_h : e
-              end
-            else
-              hash[name] = value
-            end
-          end
-        end
-      end
-      
       private
 
-      attr_reader :attributes
-
-      def fetch_attribute(name)
-        attributes.key?(name) ? Rasti::DB.from_db(attributes[name]) : raise(UninitializedAttributeError, name)
+      def cast_attribute(type, value)
+        super type, Rasti::DB.from_db(value)
       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