rasti-db 2.2.0 → 2.3.0

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.2.0'
+    VERSION = '2.3.0'
   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/minitest_helper.rb

@@ -10,12 +10,13 @@ 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, :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]
+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, :full_name]
 Language = Rasti::DB::Model[:id, :name, :people]
@@ -148,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/nql/filter_condition_spec.rb

@@ -19,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
@@ -134,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

@@ -213,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

data/spec/query_spec.rb

@@ -462,6 +462,95 @@ describe 'Query' do
 
     end
 
+    describe 'Filter Array' do
+
+      def filter_condition_must_raise(comparison_symbol, comparison_name)
+        error = proc { comments_query.nql("tags #{comparison_symbol} [fake, notice]") }.must_raise Rasti::DB::NQL::FilterConditionStrategies::UnsupportedTypeComparison
+        error.argument_type.must_equal Rasti::DB::NQL::FilterConditionStrategies::Types::SQLiteArray
+        error.comparison_name.must_equal comparison_name
+        error.message.must_equal "Unsupported comparison #{comparison_name} for Rasti::DB::NQL::FilterConditionStrategies::Types::SQLiteArray"
+      end
+
+      it 'Must raise exception from not supported methods' do
+        comparisons = {
+          greater_than: '>',
+          greater_than_or_equal: '>=',
+          less_than: '<',
+          less_than_or_equal: '<='
+        }
+
+        comparisons.each do |name, symbol|
+          filter_condition_must_raise symbol, name
+        end
+      end
+
+      it 'Included any of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 2', tags: '["notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 3', tags: '["fake_notice"]'
+        expected_comments = [
+          Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1),
+          Comment.new(id: 5, text: 'fake notice 2', tags: ['notice'], user_id: 5, post_id: 1)
+        ]
+
+        comments_query.nql('tags: [ fake, notice ]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Included exactly all these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice 2', tags: '["notice"]'
+        comments_query.nql('tags = [fake, notice]')
+                    .all
+                    .must_equal [Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1)]
+      end
+
+      it 'Not included anyone of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Good notice!', tags: '["good"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake"]'
+        expected_comments = [
+          Comment.new(id: 1, text: 'Comment 1', tags: [], user_id: 5, post_id: 1),
+          Comment.new(id: 2, text: 'Comment 2', tags: [], user_id: 7, post_id: 1),
+          Comment.new(id: 3, text: 'Comment 3', tags: [], user_id: 2, post_id: 2),
+          Comment.new(id: 5, text: 'Good notice!', tags: ['good'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags !: [fake, notice]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Not include any of these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'Good notice!', tags: '["good"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake"]'
+        expected_comments = [
+          Comment.new(id: 1, text: 'Comment 1', tags: '[]', user_id: 5, post_id: 1),
+          Comment.new(id: 2, text: 'Comment 2', tags: '[]', user_id: 7, post_id: 1),
+          Comment.new(id: 3, text: 'Comment 3', tags: '[]', user_id: 2, post_id: 2),
+          Comment.new(id: 5, text: 'Good notice!', tags: ['good'], user_id: 5, post_id: 1),
+          Comment.new(id: 6, text: 'fake notice', tags: ['fake'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags != [fake, notice]')
+                    .all
+                    .must_equal expected_comments
+      end
+
+      it 'Include any like these elements' do
+        db[:comments].insert post_id: 1, user_id: 5, text: 'fake notice', tags: '["fake","notice"]'
+        db[:comments].insert post_id: 1, user_id: 5, text: 'this is a fake notice!', tags: '["fake_notice"]'
+        expected_comments = [
+          Comment.new(id: 4, text: 'fake notice', tags: ['fake','notice'], user_id: 5, post_id: 1),
+          Comment.new(id: 5, text: 'this is a fake notice!', tags: ['fake_notice'], user_id: 5, post_id: 1)
+        ]
+        comments_query.nql('tags ~ [fake]')
+                      .all
+                      .must_equal expected_comments
+      end
+
+    end
+
   end
 
 end

data/spec/type_converters/sqlite_spec.rb

@@ -0,0 +1,66 @@
+require 'minitest_helper'
+
+describe Rasti::DB::TypeConverters::SQLite do
+
+  let(:type_converter) { Rasti::DB::TypeConverters::SQLite }
+
+  let(:sqlite) do
+    Object.new.tap do |sqlite|
+
+      def sqlite.opts
+        {
+          database: 'database'
+        }
+      end
+
+      def sqlite.schema(table_name, opts={})
+        [
+          [:text_array, {db_type: 'text[]'}],
+        ]
+      end
+
+    end
+  end
+
+  describe 'Default' do
+
+    it 'must not change value in to_db if column not found in mapping' do
+      string = type_converter.to_db sqlite, :table_name, :column, "hola"
+      string.class.must_equal String
+      string.must_equal "hola"
+    end
+
+    it 'must not change value in from_db if class not found in mapping' do
+      string = type_converter.from_db "hola"
+      string.class.must_equal String
+      string.must_equal "hola"
+    end
+
+  end
+
+   describe 'Array' do
+
+    describe 'To DB' do
+
+      it 'must transform Array to SQLiteArray' do
+        sqlite_array = type_converter.to_db sqlite, :table_name, :text_array, ['a', 'b', 'c']
+        sqlite_array.class.must_equal String
+        sqlite_array.must_equal '["a","b","c"]'
+      end
+
+    end
+
+    describe 'From DB' do
+
+      it 'must transform SQLiteArray to Array' do
+        sqlite_array = '["a","b","c"]'
+        array = type_converter.from_db sqlite_array
+        array.class.must_equal Array
+        array.must_equal ['a', 'b', 'c']
+      end
+
+    end
+
+  end
+
+end