command_search 0.11.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ab70b519f399ddeeba1a8862085f8017d327b60a2cbfddaa4682363e56d2f38
-  data.tar.gz: 204fc638f22b3ffddef67f3065c551885c9b116b4fcadffb118f52d4d7ccffb2
+  metadata.gz: c0a659ab861cfea9badba5aa2c4bdf6e8797c5ac820c468bf87f98519040f1c3
+  data.tar.gz: 5d8f4ff47c1b2d7dc917d0e791d27a071943c9d0783968ba831894f67bee9032
 SHA512:
-  metadata.gz: 15beca3aa277baf873b57ff539b46c7dc966e357801ed69ed3818b17d89e021a6ead6bc233e119fd227bfc62615e2e0078e954cd92b9a32b216e3414cf6313e4
-  data.tar.gz: 34da12042bd8b24d8b83bdceb08454a8ec72517cd3cfca155072cc286d0b54c683bfa16fc65f8f579759ea1a8279576c989fbd7599fdd818e0a0d45b2a7cd646
+  metadata.gz: 86e941a3b2e15fd637b657c2bf102887b5ea888a783105492edfe5390fc0a908f546f538197b7c3af46cb78e9b838f3a90119c5ac9bbe2abfca795d92dfead86
+  data.tar.gz: 334d7bccc459f47d47f445217ae9dc702f5dbc432b3c20367a48678ea2ac2d698cb55257987097b54e483cc0cbd64beadc5a11f9ff8338a9cca5fd8ab9553316

data/lib/command_search.rb

@@ -7,6 +7,9 @@ load(__dir__ + '/command_search/optimizer.rb')
 load(__dir__ + '/command_search/backends/memory.rb')
 load(__dir__ + '/command_search/backends/mongoer.rb')
 load(__dir__ + '/command_search/backends/postgres.rb')
+load(__dir__ + '/command_search/backends/sqlite.rb')
+load(__dir__ + '/command_search/backends/mysql.rb')
+load(__dir__ + '/command_search/backends/mysql_v5.rb')
 
 class Boolean; end
 
@@ -21,16 +24,28 @@ module CommandSearch
     Parser.parse!(ast)
     Optimizer.optimize!(ast)
     if type == :postgres
-      Normalizer.normalize!(ast, fields, false)
+      Normalizer.normalize!(ast, fields)
       return Postgres.build_query(ast)
     end
-    Normalizer.normalize!(ast, fields)
+    if type == :sqlite
+      Normalizer.normalize!(ast, fields)
+      return Sqlite.build_query(ast)
+    end
+    if type == :mysql
+      Normalizer.normalize!(ast, fields)
+      return Mysql.build_query(ast)
+    end
+    if type == :mysqlV5
+      Normalizer.normalize!(ast, fields)
+      return MysqlV5.build_query(ast)
+    end
+    Normalizer.normalize!(ast, fields, true)
     return Mongoer.build_query(ast) if type == :mongo
     ast
   end
 
   def search(source, query, options)
-    if source.respond_to?(:mongo_client) && source.queryable
+    if source.respond_to?(:mongo_client)
       ast = CommandSearch.build(:mongo, query, options)
       return source.where(ast)
     end
@@ -38,6 +53,14 @@ module CommandSearch
       ast = CommandSearch.build(:postgres, query, options)
       return source.where(ast)
     end
+    if source.respond_to?(:sqlite3_connection)
+      ast = CommandSearch.build(:sqlite, query, options)
+      return source.where(ast)
+    end
+    if source.respond_to?(:mysql2_connection)
+      ast = CommandSearch.build(:mysql, query, options)
+      return source.where(ast)
+    end
     ast = CommandSearch.build(:other, query, options)
     source.select { |x| CommandSearch::Memory.check(x, ast) }
   end

data/lib/command_search/backends/memory.rb

@@ -20,6 +20,7 @@ module CommandSearch
         # item_val.to_s.match?(search)
       elsif type == Time
         item_time = item_val.to_time
+        return false if search.nil?
         search.first <= item_time && item_time < search.last
       else
         item_val == search

data/lib/command_search/backends/mysql.rb

@@ -0,0 +1,110 @@
+# NOTE: This module supports does not support MariaDB or eariler Mysql versions than 8.0, due to
+# changes in how word breaks are handled in regexes.
+
+module CommandSearch
+  module Mysql
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def build_quoted_regex(str)
+      str = Regexp.escape(str)
+      str = quote_string(str)
+      if str[/(^\W)|(\W$)/]
+        head_border = '(^|[^:+[[:alnum:]]])'
+        tail_border = '($|[^:+[[:alnum:]]])'
+        return head_border + str + tail_border
+      end
+      '\\\\b' + str + '\\\\b'
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "(NOT ((#{field} IS NULL) OR (#{field} LIKE '0')))"
+        end
+        return "((#{field} IS NULL) OR (#{field} LIKE '0'))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        val = build_quoted_regex(val)
+        return "(REGEXP_LIKE(#{field}, '#{val}', 'c') AND (#{field} IS NOT NULL))"
+      end
+      if type == :number
+        op = '='
+      else # type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/backends/mysql_v5.rb

@@ -0,0 +1,108 @@
+# NOTE: This module supports MariaDB and MySql 5 with its distinct word break regex rules.
+
+module CommandSearch
+  module MysqlV5
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def build_quoted_regex(str)
+      str = Regexp.escape(str)
+      str = quote_string(str)
+      if str[/(^\W)|(\W$)/]
+        head_border = '(^|[[:<:]]|\\\\()'
+        tail_border = '($|[[:>:]]|\\\\))'
+        return head_border + str + tail_border
+      end
+      '[[:<:]]' + str + '[[:>:]]'
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "(NOT ((#{field} IS NULL) OR (#{field} LIKE '0')))"
+        end
+        return "((#{field} IS NULL) OR (#{field} LIKE '0'))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        op = 'RLIKE BINARY'
+        val = "'#{build_quoted_regex(val)}'"
+      elsif type == :number
+        op = '='
+      else # type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/backends/postgres.rb

@@ -4,16 +4,15 @@ module CommandSearch
 
     def quote_string(str)
       # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
-      str.gsub!('\\', '\&\&')
-      str.gsub!("'", "''")
-      Regexp.escape(str)
+      str.gsub('\\', '\&\&').gsub("'", "''")
     end
 
     def build_quoted_regex(input)
       str = quote_string(input)
+      str = Regexp.escape(str)
       if str[/(^\W)|(\W$)/]
-        head_border = '(^|\s|[^:+\w])'
-        tail_border = '($|\s|[^:+\w])'
+        head_border = '(^|[^:+\w])'
+        tail_border = '($|[^:+\w])'
         return head_border + str + tail_border
       end
       '\m' + str + '\y'
@@ -36,14 +35,23 @@ module CommandSearch
       end
       if type == Time
         return '0 = 1' unless val
-        return "(#{field} >= '#{val[0]}') AND (#{field} < '#{val[1]}') AND (#{field} IS NOT NULL)"
+        return "
+          (
+            (#{field} >= '#{val[0]}') AND
+            (#{field} < '#{val[1]}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
       end
       if type == :quote
         op = '~'
-        val =  "'#{build_quoted_regex(val)}'"
+        val = "'#{build_quoted_regex(val)}'"
       elsif type == :str
-        op = '~*'
-        val = "'#{quote_string(val)}'"
+        op = '~~*'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
       elsif type == :number
         op = '='
       end
@@ -58,7 +66,13 @@ module CommandSearch
       type = search_node[:type]
       op = node[:nest_op]
       if node[:compare_across_fields]
-        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL) AND (#{val} IS NOT NULL)"
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
       elsif type == Time && val
         "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
       elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s

data/lib/command_search/backends/sqlite.rb

@@ -0,0 +1,109 @@
+module CommandSearch
+  module Sqlite
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "NOT ((#{field} = 0) OR (#{field} IS NULL))"
+        end
+        return "((#{field} = 0) OR (#{field} IS NULL))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        val = quote_string(val)
+        val.gsub!('[', '[[]')
+        val.gsub!('*', '[*]')
+        val.gsub!('?', '[?]')
+        border = '[ .,()?"\'\']'
+        return "
+          (
+            (#{field} IS NOT NULL) AND
+            (
+              (#{field} GLOB '#{val}') OR
+              (#{field} GLOB '*#{border}#{val}#{border}*') OR
+              (#{field} GLOB '*#{border}#{val}') OR
+              (#{field} GLOB '#{val}#{border}*')
+            )
+          )
+        "
+      elsif type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%' ESCAPE '\\'"
+      elsif type == :number
+        op = '='
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/normalizer.rb

@@ -31,8 +31,13 @@ module CommandSearch
         if times
           search_node[:value] = [times.first, times.last]
         else
-          search_node[:value] = nil
-          return
+          time_parsed = Time.parse(str) rescue nil
+          if time_parsed
+            search_node[:value] = [time_parsed, time_parsed + 1]
+          else
+            search_node[:value] = nil
+            return
+          end
         end
       end
       return unless node[:type] == :compare
@@ -53,8 +58,8 @@ module CommandSearch
       str = Regexp.escape(raw)
       return node[:value] = /#{str}/i unless type == :quote
       return node[:value] = /\b#{str}\b/ unless raw[/(\A\W)|(\W\Z)/]
-      border_a = '(^|\s|[^:+\w])'
-      border_b = '($|\s|[^:+\w])'
+      border_a = '(^|[^:+\w])'
+      border_b = '($|[^:+\w])'
       node[:value] = Regexp.new(border_a + str + border_b)
     end
 
@@ -114,7 +119,8 @@ module CommandSearch
       end
     end
 
-    def normalize!(ast, fields, cast_all = true)
+    # TODO: default to false
+    def normalize!(ast, fields, cast_all = false)
       ast.map! do |node|
         if node[:type] == :and || node[:type] == :or || node[:type] == :not
           normalize!(node[:value], fields, cast_all)

data/lib/command_search/parser.rb

@@ -2,127 +2,136 @@ module CommandSearch
   module Parser
     module_function
 
-    def group_parens!(input)
+    def group_parens!(ast)
       i = 0
       opening_idxs = []
-      while i < input.length
-        next i += 1 unless input[i][:type] == :paren
-        if input[i][:value] == '('
+      while i < ast.length
+        next i += 1 unless ast[i][:type] == :paren
+        if ast[i][:value] == '('
           opening_idxs.push(i)
-          input.delete_at(i)
+          ast.delete_at(i)
           next
         end
-        input.delete_at(i)
+        ast.delete_at(i)
         opening = opening_idxs.pop()
         next unless opening
-        val = input.slice(opening, i - opening)
+        val = ast.slice(opening, i - opening)
         if val.count > 1
-          input[opening..(i - 1)] = { type: :and, value: val }
+          ast[opening..(i - 1)] = { type: :and, value: val }
           i -= val.length
           next
         elsif val.count == 1
-          input[opening] = val.first
+          ast[opening] = val.first
         end
       end
     end
 
-    def cluster_cmds!(input)
+    def cluster_cmds!(ast)
       i = 1
-      while i < input.length - 1
-        type = input[i][:type]
+      while i < ast.length - 1
+        type = ast[i][:type]
         next i += 1 unless type == :colon || type == :compare
-        input[(i - 1)..(i + 1)] = {
+        ast[(i - 1)..(i + 1)] = {
           type: type,
-          nest_op: input[i][:value],
-          value: [input[i - 1], input[i + 1]]
+          nest_op: ast[i][:value],
+          value: [ast[i - 1], ast[i + 1]]
         }
       end
     end
 
-    def cluster_or!(input)
+    def cluster_or!(ast)
       i = 0
-      while i < input.length
-        type = input[i][:type]
-        cluster_or!(input[i][:value]) if type == :and || type == :not
+      while i < ast.length
+        type = ast[i][:type]
+        cluster_or!(ast[i][:value]) if type == :and || type == :not
         next i += 1 unless type == :pipe
-        if i == 0 || i == input.length - 1
-          input.delete_at(i)
+        if i == 0 || i == ast.length - 1
+          ast.delete_at(i)
           next
         end
-        val = [input[i - 1], input[i + 1]]
+        val = [ast[i - 1], ast[i + 1]]
         cluster_or!(val)
-        input[(i - 1)..(i + 1)] = { type: :or, value: val }
+        ast[i][:type] = :or
+        ast[i][:value] = val
+        ast.delete_at(i + 1)
+        ast.delete_at(i - 1)
       end
     end
 
-    def cluster_not!(input)
-      i = input.length
+    def cluster_not!(ast)
+      i = ast.length
       while i > 0
         i -= 1
-        type = input[i][:type]
-        cluster_not!(input[i][:value]) if type == :and
+        type = ast[i][:type]
+        cluster_not!(ast[i][:value]) if type == :and
         next unless type == :minus
-        if i == input.length - 1
-          input.delete_at(i)
+        if i == ast.length - 1
+          ast.delete_at(i)
           next
         end
-        input[i..(i + 1)] = {
-          type: :not,
-          value: [input[i + 1]]
-        }
+        ast[i][:type] = :not
+        ast[i][:value] = [ast[i + 1]]
+        ast.delete_at(i + 1)
       end
     end
 
-    def unchain!(input, types)
-      i = 0
-      while i < input.length - 2
-        left = input[i][:type]
-        right = input[i + 2][:type]
-        if types.include?(left) && types.include?(right)
-          input.insert(i + 1, input[i + 1].clone())
-        end
+    def unchain!(ast)
+      i = 1
+      while i < ast.length - 3
+        left = ast[i][:type]
+        right = ast[i + 2][:type]
         i += 1
+        next unless left == :colon || left == :compare
+        next unless right == :colon || right == :compare
+        ast.insert(i, ast[i].clone())
       end
     end
 
-    def merge_strs(input, (x, y))
-      if input[y] && input[y][:type] == :str
-        values = input.map { |x| x[:value] }
-        { type: :str, value: values.join() }
-      else
-        input[x][:type] = :str
-        input
-      end
+    def r_merge!(ast, i)
+      ast[i][:type] = :str
+      return unless ast[i + 1] && ast[i + 1][:type] == :str
+      ast[i][:value] = ast[i][:value] + ast[i + 1][:value]
+      ast.delete_at(i + 1)
     end
 
-    def clean_ununusable!(input)
-      i = 1
-      while i < input.length
-        next i += 1 unless input[i][:type] == :minus
-        next i += 1 unless [:compare, :colon].include?(input[i - 1][:type])
-        input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
-      end
-      i = 0
-      while i < input.length
-        next i += 1 if ![:compare, :colon].include?(input[i][:type])
-        next i += 1 if i > 0 &&
-          (i < input.count - 1) &&
-          [:str, :number, :quote].include?(input[i - 1][:type]) &&
-          [:str, :number, :quote].include?(input[i + 1][:type])
+    def l_merge!(ast, i)
+      ast[i][:type] = :str
+      return unless ast[i - 1] && ast[i - 1][:type] == :str
+      ast[i][:value] = ast[i - 1][:value] + ast[i][:value]
+      ast.delete_at(i - 1)
+    end
 
-        input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
-        input[i - 1..i] = merge_strs(input[i - 1..i], [1, 0]) if i > 0
+    def clean!(ast)
+      return unless ast.any?
+      if ast[0][:type] == :colon || ast[0][:type] == :compare
+        r_merge!(ast, 0)
+      end
+      if ast[-1][:type] == :colon || ast[-1][:type] == :compare
+        l_merge!(ast, ast.length - 1)
+      end
+      i = 1
+      while i < ast.length - 1
+        next i += 1 unless ast[i][:type] == :colon || ast[i][:type] == :compare
+        if ast[i + 1][:type] == :minus
+          r_merge!(ast, i + 1)
+        elsif ![:str, :number, :quote].include?(ast[i - 1][:type])
+          r_merge!(ast, i)
+        elsif ![:str, :number, :quote].include?(ast[i + 1][:type])
+          l_merge!(ast, i)
+        else
+          i += 1
+        end
       end
     end
 
-    def parse!(input)
-      clean_ununusable!(input)
-      unchain!(input, [:colon, :compare])
-      cluster_cmds!(input)
-      group_parens!(input)
-      cluster_not!(input)
-      cluster_or!(input)
-      input
+    def parse!(ast)
+      clean!(ast)
+      unchain!(ast)
+      cluster_cmds!(ast)
+      group_parens!(ast)
+      cluster_not!(ast)
+      cluster_or!(ast)
+      ast
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.1
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-14 00:00:00.000000000 Z
+date: 2021-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -34,7 +34,10 @@ files:
 - lib/command_search/aliaser.rb
 - lib/command_search/backends/memory.rb
 - lib/command_search/backends/mongoer.rb
+- lib/command_search/backends/mysql.rb
+- lib/command_search/backends/mysql_v5.rb
 - lib/command_search/backends/postgres.rb
+- lib/command_search/backends/sqlite.rb
 - lib/command_search/lexer.rb
 - lib/command_search/normalizer.rb
 - lib/command_search/optimizer.rb
@@ -58,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Let users query collections with ease.