rasti-db 2.0.0 → 2.3.1

data/lib/rasti/db/type_converters/sqlite.rb

@@ -0,0 +1,62 @@
+module Rasti
+  module DB
+    module TypeConverters
+      class SQLite
+
+        CONVERTERS = [SQLiteTypes::Array]
+
+        @to_db_mapping = {}
+
+        class << self
+
+          def to_db(db, collection_name, attribute_name, value)
+            to_db_mapping = to_db_mapping_for db, collection_name
+
+            if to_db_mapping.key? attribute_name
+              to_db_mapping[attribute_name][:converter].to_db value
+            else
+              value
+            end
+          end
+
+          def from_db(object)
+            converter = find_converter_from_db object
+            if !converter.nil?
+              converter.from_db object
+            else
+              object
+            end
+          end
+
+          private
+
+          def to_db_mapping_for(db, collection_name)
+            key = [db.opts[:database], collection_name]
+
+            @to_db_mapping[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+
+              columns.each_with_object({}) do |(name, schema), hash|
+                CONVERTERS.each do |converter|
+                  unless hash.key? name
+                    match = converter.column_type_regex.match schema[:db_type]
+
+                    hash[name] = { converter: converter } if match
+                  end
+                end
+              end
+            end
+          end
+
+          def find_converter_from_db(object)
+            CONVERTERS.find do |converter|
+              converter.respond_for? object
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/sqlite_types/array.rb

@@ -0,0 +1,34 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module SQLiteTypes
+        class Array
+
+          class << self
+
+            def column_type_regex
+              /^([a-z]+)\[\]$/
+            end
+
+            def to_db(values)
+              JSON.dump(values)
+            end
+
+            def respond_for?(object)
+              parsed = JSON.parse object
+              object == to_db(parsed)
+            rescue
+              false
+            end
+
+            def from_db(object)
+              JSON.parse object
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '2.0.0'
+    VERSION = '2.3.1'
   end
 end

data/rasti-db.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'multi_require', '~> 1.0'
   spec.add_runtime_dependency 'hierarchical_graph', '~> 1.0'
   spec.add_runtime_dependency 'hash_ext', '~> 0.5'
+  spec.add_runtime_dependency 'inflecto', '~> 0.0'
 
   spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'

data/spec/collection_spec.rb

@@ -2,6 +2,14 @@ require 'minitest_helper'
 
 describe 'Collection' do
 
+  before do
+    Rasti::DB.type_converters = [Rasti::DB::TypeConverters::TimeInZone]
+  end
+
+  after do
+    Rasti::DB.type_converters = [Rasti::DB::TypeConverters::TimeInZone, Rasti::DB::TypeConverters::SQLite]
+  end
+
   describe 'Specification' do
 
     it 'Implicit' do
@@ -537,20 +545,20 @@ describe 'Collection' do
         case sql
 
         when 'SELECT users.* FROM schema_1.users', 
-             'SELECT users.* FROM schema_1.users WHERE (id IN (2, 1))'
+             'SELECT users.* FROM schema_1.users WHERE (users.id IN (2, 1))'
           [
             {id: 1},
             {id: 2}
           ]
 
         when 'SELECT posts.* FROM schema_1.posts',
-             'SELECT posts.* FROM schema_1.posts WHERE (user_id IN (1, 2))'
+             'SELECT posts.* FROM schema_1.posts WHERE (posts.user_id IN (1, 2))'
           [
             {id: 3, user_id: 1, language_id: 1},
             {id: 4, user_id: 2, language_id: 2}
           ]
 
-        when 'SELECT comments.* FROM schema_1.comments WHERE (post_id IN (3, 4))'
+        when 'SELECT comments.* FROM schema_1.comments WHERE (comments.post_id IN (3, 4))'
           [
             {id: 5, user_id: 2, post_id: 3},
             {id: 6, user_id: 1, post_id: 3},
@@ -558,7 +566,7 @@ describe 'Collection' do
             {id: 8, user_id: 2, post_id: 4}
           ]
 
-        when 'SELECT languages.* FROM schema_2.languages WHERE (id IN (1, 2))'
+        when 'SELECT languages.* FROM schema_2.languages WHERE (languages.id IN (1, 2))'
           [
             {id: 1},
             {id: 2}
@@ -663,7 +671,7 @@ describe 'Collection' do
       stub_users.where(id: [1,2]).limit(1).order(:name).all
 
       stub_db.sqls.must_equal [
-        'SELECT users.* FROM schema_1.users WHERE (id IN (1, 2)) ORDER BY name LIMIT 1'
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (1, 2)) ORDER BY users.name LIMIT 1'
       ]
     end
 
@@ -673,13 +681,13 @@ describe 'Collection' do
       stub_db.sqls.must_equal [
         'SELECT posts.* FROM schema_1.posts',
         'SELECT categories.*, categories_posts.post_id AS source_foreign_key FROM schema_1.categories INNER JOIN schema_1.categories_posts ON (schema_1.categories_posts.category_id = schema_1.categories.id) WHERE (categories_posts.post_id IN (3, 4))', 
-        'SELECT comments.* FROM schema_1.comments WHERE (post_id IN (3, 4))',
-        'SELECT users.* FROM schema_1.users WHERE (id IN (2, 1))',
-        'SELECT posts.* FROM schema_1.posts WHERE (user_id IN (1, 2))',
+        'SELECT comments.* FROM schema_1.comments WHERE (comments.post_id IN (3, 4))',
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (2, 1))',
+        'SELECT posts.* FROM schema_1.posts WHERE (posts.user_id IN (1, 2))',
         'SELECT categories.*, categories_posts.post_id AS source_foreign_key FROM schema_1.categories INNER JOIN schema_1.categories_posts ON (schema_1.categories_posts.category_id = schema_1.categories.id) WHERE (categories_posts.post_id IN (3, 4))',
-        'SELECT languages.* FROM schema_2.languages WHERE (id IN (1, 2))',
+        'SELECT languages.* FROM schema_2.languages WHERE (languages.id IN (1, 2))',
         'SELECT people.*, languages_people.language_id AS source_foreign_key FROM schema_1.people INNER JOIN schema_1.languages_people ON (schema_1.languages_people.document_number = schema_1.people.document_number) WHERE (languages_people.language_id IN (1, 2))',
-        'SELECT users.* FROM schema_1.users WHERE (id IN (1, 2))'
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (1, 2))'
       ]
     end
 
@@ -687,7 +695,7 @@ describe 'Collection' do
       stub_posts.join('user.person').where(document_number: 'document_1').all
 
       stub_db.sqls.must_equal [
-        "SELECT DISTINCT posts.* FROM schema_1.posts INNER JOIN schema_1.users AS user ON (user.id = posts.user_id) INNER JOIN schema_1.people AS user__person ON (user__person.user_id = user.id) WHERE (document_number = 'document_1')"
+        "SELECT DISTINCT posts.* FROM schema_1.posts INNER JOIN schema_1.users AS user ON (user.id = posts.user_id) INNER JOIN schema_1.people AS user__person ON (user__person.user_id = user.id) WHERE (posts.document_number = 'document_1')"
       ]
     end
 

data/spec/computed_attribute_spec.rb

@@ -0,0 +1,32 @@
+require 'minitest_helper'
+
+describe 'ComputedAttribute' do
+
+  it 'Apply Join wiht join attribute must generate correct query' do
+    dataset = db[:users]
+    computed_attribute = Rasti::DB::ComputedAttribute.new(Sequel[:comments_count][:value]) do |dataset|
+      subquery = dataset.db.from(:comments)
+                           .select(Sequel[:user_id], Sequel.function('count', :id).as(:value))
+                           .group(:user_id)
+                           .as(:comments_count)
+
+      dataset.join_table(:inner, subquery, :user_id => :id)
+    end
+    expected_query = "SELECT *, `comments_count`.`value` AS 'value' FROM `users` INNER JOIN (SELECT `user_id`, count(`id`) AS 'value' FROM `comments` GROUP BY `user_id`) AS 'comments_count' ON (`comments_count`.`user_id` = `users`.`id`)"
+    computed_attribute.apply_join(dataset)
+                      .select_append(computed_attribute.identifier)
+                      .sql
+                      .must_equal expected_query
+  end
+
+  it 'Apply join without join attribute must generate correct query' do
+    dataset = db[:people]
+    computed_attribute = Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+    expected_query = "SELECT * FROM `people` WHERE ((`first_name` || ' ' || `last_name`) = 'FULL NAME')"
+    computed_attribute.apply_join(dataset)
+                      .where(computed_attribute.identifier => 'FULL NAME')
+                      .sql
+                      .must_equal expected_query
+  end
+
+end

data/spec/minitest_helper.rb

@@ -10,14 +10,15 @@ require 'sequel/extensions/pg_array'
 require 'sequel/extensions/pg_json'
 
 Rasti::DB.configure do |config|
-  config.type_converters = [Rasti::DB::TypeConverters::TimeInZone]
+  config.type_converters = [Rasti::DB::TypeConverters::TimeInZone, Rasti::DB::TypeConverters::SQLite]
+  config.nql_filter_condition_strategy = Rasti::DB::NQL::FilterConditionStrategies::SQLite.new
 end
 
-User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
-Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories, :language_id, :language]
-Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
+User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person, :comments_count]
+Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories, :language_id, :language, :notice, :author]
+Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post, :tags]
 Category = Rasti::DB::Model[:id, :name, :posts]
-Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user, :languages]
+Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user, :languages, :full_name]
 Language = Rasti::DB::Model[:id, :name, :people]
 
 
@@ -25,6 +26,18 @@ class Users < Rasti::DB::Collection
   one_to_many :posts
   one_to_many :comments
   one_to_one :person
+
+  computed_attribute :comments_count do
+    Rasti::DB::ComputedAttribute.new(Sequel[:comments_count][:value]) do |dataset|
+      subquery = dataset.db.from(:comments)
+                           .select(Sequel[:user_id], Sequel.function('count', :id).as(:value))
+                           .group(:user_id)
+                           .as(:comments_count)
+
+      dataset.join_table(:inner, subquery, :user_id => :id)
+    end
+  end
+
 end
 
 class Posts < Rasti::DB::Collection
@@ -47,6 +60,15 @@ class Posts < Rasti::DB::Collection
              .distinct
     end
   end
+
+  computed_attribute :notice do
+    Rasti::DB::ComputedAttribute.new Sequel.join([:title, ': ', :body])
+  end
+
+  computed_attribute :author do
+    Rasti::DB::ComputedAttribute.new Sequel[:user]
+  end
+
 end
 
 class Comments < Rasti::DB::Collection
@@ -73,6 +95,10 @@ class People < Rasti::DB::Collection
 
   many_to_one :user
   many_to_many :languages
+
+  computed_attribute :full_name do |db|
+    Rasti::DB::ComputedAttribute.new Sequel.join([:first_name, ' ', :last_name])
+  end
 end
 
 class Languages < Rasti::DB::Collection
@@ -123,6 +149,7 @@ class Minitest::Spec
       db.create_table :comments do
         primary_key :id
         String :text, null: false
+        String :tags, default: Sequel.lit("'[]'")
         foreign_key :user_id, :users, null: false, index: true
         foreign_key :post_id, :posts, null: false, index: true
       end

data/spec/model_spec.rb

@@ -42,7 +42,7 @@ describe 'Model' do
   describe 'To String' do
     
     it 'Class' do
-      User.to_s.must_equal 'User[id, name, posts, comments, person]'
+      User.to_s.must_equal 'User[id, name, posts, comments, person, comments_count]'
     end
 
     it 'Instance' do

data/spec/nql/computed_attributes_spec.rb

@@ -0,0 +1,29 @@
+require 'minitest_helper'
+
+describe 'NQL::ComputedAttributes' do
+
+  let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
+
+  def parse(expression)
+    parser.parse expression
+  end
+
+  it 'must have one computed attributes' do
+    tree = parse 'notice = any notice'
+
+    tree.computed_attributes(Posts).must_equal [:notice]
+  end
+
+  it 'must have multiple computed attributes' do
+    tree = parse 'notice = any notice & (author: anonym | title = good morning)'
+
+    tree.computed_attributes(Posts).must_equal [:notice, :author]
+  end
+
+  it 'must have not repeated computed attributes when expression have it' do
+    tree = parse 'notice = Hi | notice = Bye'
+
+    tree.computed_attributes(Posts).must_equal [:notice]
+  end
+
+end

data/spec/nql/filter_condition_spec.rb

@@ -4,9 +4,11 @@ describe 'NQL::FilterCondition' do
 
   let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
 
+  let(:collection_class) { Rasti::DB::Collection }
+
   def filter_condition(expression)
     tree = parser.parse expression
-    tree.filter_condition
+    tree.filter_condition(collection_class)
   end
 
   def assert_identifier(identifier, expected_value)
@@ -17,13 +19,30 @@ describe 'NQL::FilterCondition' do
   def assert_comparison(filter, expected_left, expected_comparator, expected_right)
     filter.must_be_instance_of Sequel::SQL::BooleanExpression
     filter.op.must_equal expected_comparator.to_sym
-    
+
     left, right = filter.args
     assert_identifier left, expected_left
 
     right.must_equal expected_right
   end
 
+  describe 'None Filter Condition Strategy Validation' do
+
+    before do
+      Rasti::DB.nql_filter_condition_strategy = nil
+    end
+
+    after do
+      Rasti::DB.nql_filter_condition_strategy = Rasti::DB::NQL::FilterConditionStrategies::SQLite.new
+    end
+
+    it 'must raise error' do
+      error = proc { filter_condition 'column = value' }.must_raise RuntimeError
+      error.message.must_equal 'Undefined Rasti::DB.nql_filter_condition_strategy'
+    end
+
+  end
+
   describe 'Comparison' do
 
     it 'must create filter from expression with <' do
@@ -95,7 +114,7 @@ describe 'NQL::FilterCondition' do
 
   end
 
-  it 'must create filter from expression with field with multiple tables' do
+  it 'must create filter from expression with attribute with multiple tables' do
     filter = filter_condition 'table_one.table_two.column = test'
     identifier, value = filter.first
 
@@ -132,7 +151,7 @@ describe 'NQL::FilterCondition' do
 
     filter.must_be_instance_of Sequel::SQL::BooleanExpression
     filter.op.must_equal :AND
-    
+
     major_expression, and_expression = filter.args
     assert_comparison major_expression, 'column_one', '>', 1
 

data/spec/nql/filter_condition_strategies_spec.rb

@@ -0,0 +1,112 @@
+require 'minitest_helper'
+
+describe 'NQL::FilterConditionStrategies' do
+
+  let(:comments_query) { Rasti::DB::Query.new collection_class: Comments, dataset: db[:comments], environment: environment }
+
+  def sqls_where(query)
+    "#<Rasti::DB::Query: \"SELECT `comments`.* FROM `comments` WHERE (#{query})\">"
+  end
+
+  def sqls_where_not(query)
+    "#<Rasti::DB::Query: \"SELECT `comments`.* FROM `comments` WHERE NOT (#{query})\">"
+  end
+
+  def nql_s(nql_query)
+    comments_query.nql(nql_query).to_s
+  end
+
+  describe 'Generic' do
+
+    it 'Equal' do
+      nql_s('text = hola').must_equal sqls_where("`comments`.`text` = 'hola'")
+    end
+
+    it 'Not Equal' do
+      nql_s('text != hola').must_equal sqls_where("`comments`.`text` != 'hola'")
+    end
+
+    it 'Greather Than' do
+      nql_s('id > 1').must_equal sqls_where("`comments`.`id` > 1")
+    end
+
+    it 'Greather Than or Equal' do
+      nql_s('id >= 1').must_equal sqls_where("`comments`.`id` >= 1")
+    end
+
+    it 'Less Than' do
+      nql_s('id < 1').must_equal sqls_where("`comments`.`id` < 1")
+    end
+    
+    it 'Less Than or Equal' do
+      nql_s('id <= 1').must_equal sqls_where("`comments`.`id` <= 1")
+    end
+
+    it 'Like' do
+      nql_s('text ~ hola').must_equal sqls_where("UPPER(`comments`.`text`) LIKE UPPER('hola') ESCAPE '\\'")
+    end
+
+    it 'Include' do
+      nql_s('text: hola').must_equal sqls_where("UPPER(`comments`.`text`) LIKE UPPER('%hola%') ESCAPE '\\'")
+    end
+
+    it 'Not Include' do
+      nql_s('text!: hola').must_equal sqls_where_not("UPPER(`comments`.`text`) LIKE UPPER('%hola%') ESCAPE '\\'")
+    end
+
+  end
+
+  describe 'SQLite Array' do
+
+    it 'Equal' do
+      nql_s('tags = [notice]').must_equal sqls_where("`comments`.`tags` = '[\"notice\"]'")
+    end
+
+    it 'Not Equal' do
+      nql_s('tags != [notice]').must_equal sqls_where_not("`comments`.`tags` LIKE '%\"notice\"%' ESCAPE '\\'")
+    end
+
+    it 'Like' do
+      nql_s('tags ~ [notice]').must_equal sqls_where("`comments`.`tags` LIKE '%notice%' ESCAPE '\\'")
+    end
+
+    it 'Include' do
+      nql_s('tags: [notice]').must_equal sqls_where("`comments`.`tags` LIKE '%\"notice\"%' ESCAPE '\\'")
+    end
+
+    it 'Not Include' do
+      nql_s('tags!: [notice]').must_equal sqls_where_not("`comments`.`tags` LIKE '%\"notice\"%' ESCAPE '\\'")
+    end
+
+  end
+
+  describe 'Postgres Array' do
+
+    before do
+      Rasti::DB.nql_filter_condition_strategy = Rasti::DB::NQL::FilterConditionStrategies::Postgres.new
+      Sequel.extension :pg_array_ops
+    end
+
+    after do
+      Rasti::DB.nql_filter_condition_strategy = Rasti::DB::NQL::FilterConditionStrategies::SQLite.new
+    end
+
+    it 'Equal' do
+      nql_s('tags = [notice]').must_equal sqls_where("(`comments`.`tags` @> ARRAY['notice']) AND (`comments`.`tags` <@ ARRAY['notice'])")
+    end
+
+    it 'Not Equal' do
+      nql_s('tags != [notice]').must_equal sqls_where("NOT (`comments`.`tags` @> ARRAY['notice']) OR NOT (`comments`.`tags` <@ ARRAY['notice'])")
+    end
+
+    it 'Include' do
+      nql_s('tags: [notice]').must_equal sqls_where("`comments`.`tags` && ARRAY['notice']")
+    end
+
+    it 'Not Include' do
+      nql_s('tags!: [notice]').must_equal sqls_where_not("`comments`.`tags` && ARRAY['notice']")
+    end
+
+  end
+
+end