rasti-db 2.0.1 → 2.3.2

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.1'
+    VERSION = '2.3.2'
   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

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