rasti-db 1.5.0 → 2.3.0

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,24 +10,39 @@ 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]
-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]
+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]
 
 
 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
   many_to_one :user
+  many_to_one :language
   many_to_many :categories
   one_to_many :comments
 
@@ -39,12 +54,21 @@ class Posts < Rasti::DB::Collection
 
   query :commented_by do |user_id|
     chainable do
-      dataset.join(with_schema(:comments), post_id: :id)
-             .where(with_schema(:comments, :user_id) => user_id)
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
              .select_all(:posts)
              .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
@@ -53,7 +77,7 @@ class Comments < Rasti::DB::Collection
 
   def posts_commented_by(user_id)
     dataset.where(Sequel[:comments][:user_id] => user_id)
-           .join(with_schema(:posts), id: :post_id)
+           .join(qualify(:posts, data_source_name: :default), id: :post_id)
            .select_all(:posts)
            .map { |row| Post.new row }
   end
@@ -70,24 +94,43 @@ class People < Rasti::DB::Collection
   set_model Person
 
   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
+  set_data_source_name :custom
+
+  many_to_many :people, collection: People, relation_data_source_name: :default
+  one_to_many :posts
 end
 
 
 class Minitest::Spec
 
-  let(:users) { Users.new db }
+  let(:users) { Users.new environment }
 
-  let(:posts) { Posts.new db }
+  let(:posts) { Posts.new environment }
   
-  let(:comments) { Comments.new db }
+  let(:comments) { Comments.new environment }
 
-  let(:categories) { Categories.new db }
+  let(:categories) { Categories.new environment }
 
-  let(:people) { People.new db }
+  let(:people) { People.new environment }
 
-  let :db do
-    driver = (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite}
+  let(:languages) { Languages.new environment }
+
+  let(:driver) { (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite} }
+
+  let :environment do 
+    Rasti::DB::Environment.new default: Rasti::DB::DataSource.new(db),
+                               custom: Rasti::DB::DataSource.new(custom_db)
+  end
 
+  let :db do
     Sequel.connect(driver).tap do |db|
 
       db.create_table :users do
@@ -99,12 +142,14 @@ class Minitest::Spec
         primary_key :id
         String :title, null: false, unique: true
         String :body, null: false
+        Integer :language_id, null: false, index: true
         foreign_key :user_id, :users, null: false, index: true
       end
 
       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
@@ -128,6 +173,23 @@ class Minitest::Spec
         foreign_key :user_id, :users, null: false, unique: true
       end
 
+      db.create_table :languages_people do
+        Integer :language_id, null: false, index: true
+        foreign_key :document_number, :people, type: String, null: false, index: true
+        primary_key [:language_id, :document_number]
+      end
+
+    end
+  end
+
+  let :custom_db do
+    Sequel.connect(driver).tap do |db|
+
+      db.create_table :languages do
+        primary_key :id
+        String :name, null: false, unique: true
+      end
+
     end
   end
 

data/spec/model_spec.rb

@@ -10,7 +10,7 @@ describe 'Model' do
     end
 
     it 'Invalid definition' do
-      error = proc { model = Rasti::DB::Model[:id, :name, :name] }.must_raise ArgumentError
+      error = proc { Rasti::DB::Model[:id, :name, :name] }.must_raise ArgumentError
       error.message.must_equal 'Attribute name already exists'
     end
 
@@ -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
@@ -82,6 +82,8 @@ describe 'Model' do
   it 'Merge' do
     user = User.new(id: 1, name: 'User 1')
     changed_user = user.merge(name: 'User 2')
+    
+    user.must_equal User.new(id: 1, name: 'User 1')
     changed_user.must_equal User.new(id: 1, name: 'User 2')
   end
 

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

data/spec/nql/syntax_parser_spec.rb

@@ -31,7 +31,7 @@ describe 'NQL::SyntaxParser' do
           proposition = tree.proposition
           proposition.must_be_instance_of node_class
           proposition.comparator.text_value.must_equal comparator
-          proposition.field.text_value.must_equal 'column'
+          proposition.attribute.text_value.must_equal 'column'
           proposition.argument.text_value.must_equal 'value'
         end
       end
@@ -44,7 +44,7 @@ describe 'NQL::SyntaxParser' do
       proposition = tree.proposition
       proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Comparisons::Equal
       proposition.comparator.text_value.must_equal '='
-      proposition.field.text_value.must_equal 'column'
+      proposition.attribute.text_value.must_equal 'column'
       proposition.argument.text_value.must_equal 'value'
     end
 
@@ -128,12 +128,19 @@ describe 'NQL::SyntaxParser' do
     
     end
 
-    it 'must parse expression with field with tables' do
+    it 'must parse expression with attribute with tables' do
       tree = parse 'relation_table_one.relation_table_two.column = 1'
 
-      left_hand_operand = tree.proposition.field
+      left_hand_operand = tree.proposition.attribute
       left_hand_operand.tables.must_equal ['relation_table_one', 'relation_table_two']
-      left_hand_operand.column.must_equal 'column'
+      left_hand_operand.column.must_equal :column
+    end
+
+    it 'must parse expression with computed attribute' do
+      tree = parse 'comments_count = 1'
+      computed = tree.proposition.attribute
+      computed.tables.must_equal []
+      computed.computed_attributes(Users).must_equal [:comments_count]
     end
 
   end
@@ -206,4 +213,28 @@ describe 'NQL::SyntaxParser' do
 
   end
 
+  describe 'Array' do
+
+    it 'must parse array with one element' do
+      tree = parse 'column = [ a ]'
+      tree.proposition.argument.value.must_equal ['a']
+    end
+
+    it 'must parse array with many elements' do 
+      tree = parse 'column = [ a, b, c ]'
+      tree.proposition.argument.value.must_equal ['a', 'b', 'c']
+    end
+
+    it 'must parse array respecting content types' do
+      tree = parse 'column = [ true, 12:00, 1.1, 1, "literal string", string ]'
+      tree.proposition.argument.value.must_equal [true, Timing::TimeInZone.parse('12:00').to_s, 1.1, 1, "literal string", 'string']
+    end
+
+    it 'must parse array with literal string allowing reserved characters in conflict with array' do
+      tree = parse 'column = [ ",", "[", "]", "[,", "],", "[,]", "simple literal" ]'
+      tree.proposition.argument.value.must_equal [ ',', '[', ']', '[,', '],', '[,]', 'simple literal' ]
+    end
+
+  end
+
 end