From 530951ff45fb78c907a5ff86bc585f19fea831aa Mon Sep 17 00:00:00 2001
From: Senad Uka <senaduka@gmail.com>
Date: Wed, 5 Feb 2020 13:40:37 +0100
Subject: [PATCH] Upstream sync

---
 Gemfile                                       |   2 +
 Gemfile.lock                                  |   4 +
 README.md                                     |   8 +
 Rakefile                                      |  13 +
 coverage/.resultset.json                      | 223 +++---
 coverage/index.html                           | 672 +++++++++++-------
 lib/lexer.rb                                  | 107 +++
 lib/parser-parser-part/.gitignore             |   4 -
 lib/parser-parser-part/README.md              |  19 -
 lib/parser-parser-part/Rakefile               |  20 -
 lib/parser-parser-part/grammar.y              |  26 -
 .../spec/query_lexer_spec.rb                  | 259 -------
 .../spec/query_parser_spec.rb                 | 164 -----
 lib/parser-parser-part/specification.rex      |  35 -
 lib/parser.rb                                 | 181 +++++
 lib/pg_searchable_regex.rb                    |   5 +-
 lib/specification.rex                         |   4 +-
 lib/text_to_sql_query.rb                      |  92 +++
 pkg/pg_searchable_regex-1.0.13.gem            | Bin 15360 -> 0 bytes
 pkg/pg_searchable_regex-1.0.21.gem            | Bin 0 -> 20992 bytes
 spec/lib/text_to_sql_query_spec.rb            |  61 ++
 version.rb                                    |   2 +-
 22 files changed, 1016 insertions(+), 885 deletions(-)
 create mode 100644 lib/lexer.rb
 delete mode 100644 lib/parser-parser-part/.gitignore
 delete mode 100644 lib/parser-parser-part/README.md
 delete mode 100644 lib/parser-parser-part/Rakefile
 delete mode 100644 lib/parser-parser-part/grammar.y
 delete mode 100644 lib/parser-parser-part/spec/query_lexer_spec.rb
 delete mode 100644 lib/parser-parser-part/spec/query_parser_spec.rb
 delete mode 100644 lib/parser-parser-part/specification.rex
 create mode 100644 lib/parser.rb
 create mode 100644 lib/text_to_sql_query.rb
 delete mode 100644 pkg/pg_searchable_regex-1.0.13.gem
 create mode 100644 pkg/pg_searchable_regex-1.0.21.gem
 create mode 100644 spec/lib/text_to_sql_query_spec.rb

diff --git a/Gemfile b/Gemfile
index 31e2537..54ad0fd 100644
--- a/Gemfile
+++ b/Gemfile
@@ -23,4 +23,6 @@ group :development do
   gem 'rubocop',          '~> 0.54', require: false
   gem 'rubocop-rspec',    '~> 1.23', require: false
   gem 'simplecov',        '~> 0.16', require: false
+  gem "rexical"
+  gem "racc"
 end
diff --git a/Gemfile.lock b/Gemfile.lock
index 1bf8e16..ca4785b 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -76,11 +76,13 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
     public_suffix (3.1.1)
+    racc (1.4.16)
     rack (1.6.11)
     rainbow (3.0.0)
     rake (12.3.2)
     rdoc (3.12.2)
       json (~> 1.4)
+    rexical (1.0.7)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -132,7 +134,9 @@ DEPENDENCIES
   juwelier (~> 2.1)
   pg (~> 0.15)
   pry (~> 0.12)
+  racc
   rdoc (~> 3.12)
+  rexical
   rspec (~> 3.8)
   rubocop (~> 0.54)
   rubocop-rspec (~> 1.23)
diff --git a/README.md b/README.md
index 14d73fb..9f52a93 100644
--- a/README.md
+++ b/README.md
@@ -119,3 +119,11 @@ To run the test suite create `.env.test.local` file containing the same entries
 ## CONTRIBUTING
 
 Make sure the test coverage remains at 100%, there are no rubocop complaints (`bundle exec rubocop`) and make a Pull Request.
+
+
+## Modifying parser and lexer
+
+* `rake lexer` - generates `lexer.rb` file based on `specification.rex` file
+* `rake parser` - generates `parser.rb` file based on `grammar.y` file
+* `rake generate` - generates both `lexer.rb` and `parser.rb` files
+
diff --git a/Rakefile b/Rakefile
index 65ca83f..f883b7a 100644
--- a/Rakefile
+++ b/Rakefile
@@ -44,3 +44,16 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+desc 'Generate Lexer'
+task :lexer do
+  `rex ./lib/specification.rex -o ./lib/lexer.rb`
+end
+
+desc 'Generate Parser'
+task :parser do
+  `racc ./lib/grammar.y -o ./lib/parser.rb`
+end
+
+desc 'Generate Lexer and Parser'
+task generate: %i[lexer parser]
diff --git a/coverage/.resultset.json b/coverage/.resultset.json
index 5f70270..ef5ab35 100644
--- a/coverage/.resultset.json
+++ b/coverage/.resultset.json
@@ -9,69 +9,69 @@
         1,
         1,
         null,
-        1,
-        1,
+        0,
+        0,
         null,
-        1,
-        12,
-        null,
-        null,
-        null,
-        null,
-        null,
-        1,
-        1,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        12,
-        12,
-        12,
-        12,
-        12,
-        12,
-        12,
-        12,
-        12,
-        12,
-        null,
-        null,
-        1,
-        12,
-        43,
-        null,
-        null,
-        null,
-        1,
-        31,
-        30,
-        null,
-        null,
-        1,
+        0,
         0,
         null,
         null,
-        1,
+        null,
+        null,
+        null,
+        0,
         0,
         null,
         null,
-        1,
-        12,
         null,
         null,
-        1,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
         0,
         null,
         null,
-        1,
+        0,
+        0,
+        0,
+        null,
+        null,
+        null,
+        0,
+        0,
+        0,
+        null,
+        null,
+        0,
+        0,
+        null,
+        null,
+        0,
+        0,
+        null,
+        null,
+        0,
+        0,
+        null,
+        null,
+        0,
+        0,
+        null,
+        null,
+        0,
         0,
         0,
         0,
@@ -180,75 +180,102 @@
         null,
         null
       ],
-      "/home/hamo/projects/toptal/outfrontmedia/pg_searchable/lib/text_to_regex_query.rb": [
+      "/home/hamo/projects/toptal/outfrontmedia/pg_searchable/lib/text_to_sql_query.rb": [
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
         null,
         null,
         null,
         null,
         null,
-        1,
-        1,
-        35,
-        35,
-        35,
-        35,
-        37,
-        37,
-        7,
         null,
         null,
         null,
-        1,
-        5,
-        5,
-        5,
-        5,
-        5,
-        5,
         null,
         null,
-        1,
-        null,
-        1,
-        5,
         null,
         null,
-        1,
-        5,
-        5,
-        5,
         null,
         null,
-        1,
-        5,
-        null,
-        5,
-        7,
-        7,
-        5,
-        5,
-        null,
-        5,
-        3,
-        null,
-        5,
         null,
         null,
-        1,
-        5,
-        13,
-        13,
         null,
-        5,
-        8,
         null,
-        5,
         null,
-        5,
         null,
         null
       ]
     },
-    "timestamp": 1579269179
+    "timestamp": 1580827025
   }
 }
diff --git a/coverage/index.html b/coverage/index.html
index 9a8e9c8..cb2a0c4 100644
--- a/coverage/index.html
+++ b/coverage/index.html
@@ -14,27 +14,27 @@
       <img src="./assets/0.10.2/loading.gif" alt="loading"/>
     </div>
     <div id="wrapper" style="display:none;">
-      <div class="timestamp">Generated <abbr class="timeago" title="2020-01-17T14:52:59+01:00">2020-01-17T14:52:59+01:00</abbr></div>
+      <div class="timestamp">Generated <abbr class="timeago" title="2020-02-04T15:37:05+01:00">2020-02-04T15:37:05+01:00</abbr></div>
       <ul class="group_tabs"></ul>
 
       <div id="content">
         <div class="file_list_container" id="AllFiles">
   <h2>
     <span class="group_name">All Files</span>
-    (<span class="covered_percent"><span class="red">68.94%</span></span>
+    (<span class="covered_percent"><span class="red">24.18%</span></span>
      covered at
      <span class="covered_strength">
-       <span class="green">
-         5.11
+       <span class="red">
+         0.22
        </span>
     </span> hits/line)
   </h2>
   <a name="AllFiles"></a>
   <div>
     <b>3</b> files in total.
-    <b>132</b> relevant lines. 
-    <span class="green"><b>91</b> lines covered</span> and
-    <span class="red"><b>41</b> lines missed </span>
+    <b>91</b> relevant lines. 
+    <span class="green"><b>22</b> lines covered</span> and
+    <span class="red"><b>69</b> lines missed </span>
   </div>
   <table class="file_list">
     <thead>
@@ -52,22 +52,22 @@
       
       <tr>
         <td class="strong"><a href="#753228502df7d7eba3c0631f5c2586671ab90064" class="src_link" title="lib/pg_searchable_regex.rb">lib/pg_searchable_regex.rb</a></td>
-        <td class="yellow strong">84.21 %</td>
+        <td class="red strong">10.53 %</td>
         <td>76</td>
         <td>38</td>
-        <td>32</td>
-        <td>6</td>
-        <td>7.3</td>
+        <td>4</td>
+        <td>34</td>
+        <td>0.1</td>
       </tr>
       
       <tr>
-        <td class="strong"><a href="#e8ee935d8bdd18586008a6e7f179fcb3e6b45ccd" class="src_link" title="lib/text_to_regex_query.rb">lib/text_to_regex_query.rb</a></td>
+        <td class="strong"><a href="#ce19b53ff8fa35fd6a57aa6b7ede25d3648dd01c" class="src_link" title="lib/text_to_sql_query.rb">lib/text_to_sql_query.rb</a></td>
         <td class="green strong">100.0 %</td>
-        <td>66</td>
-        <td>41</td>
-        <td>41</td>
+        <td>93</td>
         <td>0</td>
-        <td>9.3</td>
+        <td>0</td>
+        <td>0</td>
+        <td>0.0</td>
       </tr>
       
       <tr>
@@ -99,11 +99,11 @@
         <div class="source_table" id="753228502df7d7eba3c0631f5c2586671ab90064">
   <div class="header">
     <h3>lib/pg_searchable_regex.rb</h3>
-    <h4><span class="yellow">84.21 %</span> covered</h4>
+    <h4><span class="red">10.53 %</span> covered</h4>
     <div>
       <b>38</b> relevant lines. 
-      <span class="green"><b>32</b> lines covered</span> and
-      <span class="red"><b>6</b> lines missed.</span>
+      <span class="green"><b>4</b> lines covered</span> and
+      <span class="red"><b>34</b> lines missed.</span>
     </div>
   </div>
   
@@ -143,7 +143,7 @@
         <li class="covered" data-hits="1" data-linenumber="6">
           <span class="hits">1</span>
           
-          <code class="ruby">require_relative &#39;./text_to_regex_query&#39;</code>
+          <code class="ruby">require_relative &#39;./text_to_sql_query&#39;</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="7">
@@ -152,14 +152,14 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="8">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="8">
+          
           
           <code class="ruby">module PgSearchable</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="9">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="9">
+          
           
           <code class="ruby">  extend ActiveSupport::Concern</code>
         </li>
@@ -170,14 +170,14 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="11">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="11">
+          
           
           <code class="ruby">  included do</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="12">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="12">
+          
           
           <code class="ruby">    def update_pg_search_cache</code>
         </li>
@@ -212,14 +212,14 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="18">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="18">
+          
           
           <code class="ruby">  class_methods do</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="19">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="19">
+          
           
           <code class="ruby">    def pg_search(</code>
         </li>
@@ -290,62 +290,62 @@
           <code class="ruby">    )</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="31">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="31">
+          
           
           <code class="ruby">      @ts_search_fields = fields</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="32">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="32">
+          
           
           <code class="ruby">      @ts_search_fields_mappings = fields_mappings</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="33">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="33">
+          
           
           <code class="ruby">      @ts_cache_field = cache</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="34">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="34">
+          
           
           <code class="ruby">      @ts_language = language</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="35">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="35">
+          
           
           <code class="ruby">      @ts_scope_method = scope</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="36">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="36">
+          
           
           <code class="ruby">      @ts_skip_cache_update = skip_callback</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="37">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="37">
+          
           
           <code class="ruby">      @ts_wildcard = wildcard</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="38">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="38">
+          
           
           <code class="ruby">      @ts_joins = joins</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="39">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="39">
+          
           
           <code class="ruby">      @default_field = (default_field.to_sym || fields.first)</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="40">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="40">
+          
           
           <code class="ruby">      ts_add_scope</code>
         </li>
@@ -362,20 +362,20 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="43">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="43">
+          
           
           <code class="ruby">    def ts_add_scope</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="44">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="44">
+          
           
           <code class="ruby">      class_eval do</code>
         </li>
       
-        <li class="covered" data-hits="43" data-linenumber="45">
-          <span class="hits">43</span>
+        <li class="missed" data-hits="0" data-linenumber="45">
+          
           
           <code class="ruby">        scope ts_scope_method, -&gt;(value) { ts_search(value) }</code>
         </li>
@@ -398,22 +398,22 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="49">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="49">
+          
           
           <code class="ruby">    def ts_search(value)</code>
         </li>
       
-        <li class="covered" data-hits="31" data-linenumber="50">
-          <span class="hits">31</span>
+        <li class="missed" data-hits="0" data-linenumber="50">
+          
           
           <code class="ruby">      return if @ts_search_fields.blank? || value.blank?</code>
         </li>
       
-        <li class="covered" data-hits="30" data-linenumber="51">
-          <span class="hits">30</span>
+        <li class="missed" data-hits="0" data-linenumber="51">
           
-          <code class="ruby">             TextToRegexQuery.new(value, @ts_search_fields, @default_field, @ts_search_fields_mappings).where_clause( includes(@ts_joins).references(:all))</code>
+          
+          <code class="ruby">      TextToSqlQuery.new(value, @ts_search_fields, @default_field, @ts_search_fields_mappings).where_clause( includes(@ts_joins).references(:all))</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="52">
@@ -428,8 +428,8 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="54">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="54">
+          
           
           <code class="ruby">    def should_update_cache_field?</code>
         </li>
@@ -452,8 +452,8 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="58">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="58">
+          
           
           <code class="ruby">    def ts_cache_field</code>
         </li>
@@ -476,14 +476,14 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="62">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="62">
+          
           
           <code class="ruby">    def ts_scope_method</code>
         </li>
       
-        <li class="covered" data-hits="12" data-linenumber="63">
-          <span class="hits">12</span>
+        <li class="missed" data-hits="0" data-linenumber="63">
+          
           
           <code class="ruby">      @ts_scope_method</code>
         </li>
@@ -500,8 +500,8 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="66">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="66">
+          
           
           <code class="ruby">    def ts_cache_method</code>
         </li>
@@ -524,8 +524,8 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="70">
-          <span class="hits">1</span>
+        <li class="missed" data-hits="0" data-linenumber="70">
+          
           
           <code class="ruby">    def ts_fields_to_vector(extra_data = [])</code>
         </li>
@@ -571,13 +571,13 @@
 </div>
 
       
-        <div class="source_table" id="e8ee935d8bdd18586008a6e7f179fcb3e6b45ccd">
+        <div class="source_table" id="ce19b53ff8fa35fd6a57aa6b7ede25d3648dd01c">
   <div class="header">
-    <h3>lib/text_to_regex_query.rb</h3>
+    <h3>lib/text_to_sql_query.rb</h3>
     <h4><span class="green">100.0 %</span> covered</h4>
     <div>
-      <b>41</b> relevant lines. 
-      <span class="green"><b>41</b> lines covered</span> and
+      <b>0</b> relevant lines. 
+      <span class="green"><b>0</b> lines covered</span> and
       <span class="red"><b>0</b> lines missed.</span>
     </div>
   </div>
@@ -588,7 +588,7 @@
         <li class="never" data-hits="" data-linenumber="1">
           
           
-          <code class="ruby"># frozen_string_literal: true</code>
+          <code class="ruby">require &#39;./parser&#39;</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="2">
@@ -600,79 +600,79 @@
         <li class="never" data-hits="" data-linenumber="3">
           
           
-          <code class="ruby"># transforms &quot;english like&quot; text queries into a where clause with regex</code>
+          <code class="ruby">class TextToSqlQuery</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="4">
           
           
-          <code class="ruby"># https://www.postgresql.org/docs/9.5/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES</code>
+          <code class="ruby">  def initialize(text, fields, default_field, fields_mappings = {})</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="5">
           
           
-          <code class="ruby"></code>
-        </li>
-      
-        <li class="covered" data-hits="1" data-linenumber="6">
-          <span class="hits">1</span>
-          
-          <code class="ruby">class TextToRegexQuery</code>
-        </li>
-      
-        <li class="covered" data-hits="1" data-linenumber="7">
-          <span class="hits">1</span>
-          
-          <code class="ruby">  def initialize(text, fields, default_field, fields_mappings = {})</code>
-        </li>
-      
-        <li class="covered" data-hits="35" data-linenumber="8">
-          <span class="hits">35</span>
-          
           <code class="ruby">    @text = text.to_s.strip</code>
         </li>
       
-        <li class="covered" data-hits="35" data-linenumber="9">
-          <span class="hits">35</span>
+        <li class="never" data-hits="" data-linenumber="6">
+          
           
           <code class="ruby">    @fields = fields.map(&amp;:to_sym)</code>
         </li>
       
-        <li class="covered" data-hits="35" data-linenumber="10">
-          <span class="hits">35</span>
+        <li class="never" data-hits="" data-linenumber="7">
+          
           
           <code class="ruby">    @default_field = default_field.to_sym</code>
         </li>
       
-        <li class="covered" data-hits="35" data-linenumber="11">
-          <span class="hits">35</span>
+        <li class="never" data-hits="" data-linenumber="8">
+          
           
           <code class="ruby">    @fields_mappings = fields_mappings.merge(@fields.reduce({}) do |mappings, field|</code>
         </li>
       
-        <li class="covered" data-hits="37" data-linenumber="12">
-          <span class="hits">37</span>
+        <li class="never" data-hits="" data-linenumber="9">
           
-          <code class="ruby">      table_name, field_name = field.to_s.split(&quot;.&quot;)</code>
+          
+          <code class="ruby">      _table_name, field_name = field.to_s.split(&#39;.&#39;)</code>
         </li>
       
-        <li class="covered" data-hits="37" data-linenumber="13">
-          <span class="hits">37</span>
+        <li class="never" data-hits="" data-linenumber="10">
+          
           
           <code class="ruby">      mappings[field_name.to_sym] = field</code>
         </li>
       
-        <li class="covered" data-hits="7" data-linenumber="14">
-          <span class="hits">7</span>
+        <li class="never" data-hits="" data-linenumber="11">
           
-          <code class="ruby">      mappings </code>
+          
+          <code class="ruby">      mappings</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="12">
+          
+          
+          <code class="ruby">    end)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="13">
+          
+          
+          <code class="ruby">    fields_mappings.each do |field, value|</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="14">
+          
+          
+          <code class="ruby">      @fields_mappings[field] = value if @fields_mappings[field]</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="15">
           
           
-          <code class="ruby">    end)</code>
+          <code class="ruby">    end</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="16">
@@ -687,297 +687,459 @@
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="18">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="18">
           
-          <code class="ruby">  def where_clause(query)</code>
+          
+          <code class="ruby">  def where_clause</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="19">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="19">
           
-          <code class="ruby">    @cleared_text = @text.dup</code>
+          
+          <code class="ruby">    @parser = Query.new</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="20">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="20">
           
-          <code class="ruby">    @column_chunks = []</code>
+          
+          <code class="ruby">    @parsed_tree = @parser.parse(@text)</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="21">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="21">
           
-          <code class="ruby">    remove_duplicated_spaces</code>
+          
+          <code class="ruby">    generate_sql @parsed_tree</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="22">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="22">
           
-          <code class="ruby">    extract_columns</code>
+          
+          <code class="ruby">  end</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="23">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="23">
           
-          <code class="ruby">    escape_special_characters</code>
+          
+          <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="24">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="24">
           
-          <code class="ruby">    generate_where_clause(query)</code>
+          
+          <code class="ruby">  private</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="25">
           
           
-          <code class="ruby">  end</code>
+          <code class="ruby"></code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="26">
           
           
-          <code class="ruby"></code>
+          <code class="ruby">  def generate_sql(tree)</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="27">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="27">
           
-          <code class="ruby">private</code>
+          
+          <code class="ruby">    first_key = tree.keys.first</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="28">
           
           
-          <code class="ruby"></code>
+          <code class="ruby">    node_value = tree[first_key]</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="29">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="29">
           
-          <code class="ruby">  def remove_duplicated_spaces</code>
+          
+          <code class="ruby">    case first_key</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="30">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="30">
           
-          <code class="ruby">    @cleared_text.gsub!(/\s+/, &#39; &#39;)</code>
+          
+          <code class="ruby">    when :DEFAULT_COLUMN</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="31">
           
           
-          <code class="ruby">  end</code>
+          <code class="ruby">      escaped_node_value = handle_special_chars node_value</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="32">
           
           
-          <code class="ruby"></code>
+          <code class="ruby">      [&quot;#{@default_field.to_s} ILIKE ?&quot;, &quot;%#{escaped_node_value}%&quot;]</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="33">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="33">
           
-          <code class="ruby">  def escape_special_characters</code>
+          
+          <code class="ruby">    when :OPERATOR_OR</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="34">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="34">
           
-          <code class="ruby">    @cleared_text.gsub!(/\_/, &#39;\_&#39;)</code>
+          
+          <code class="ruby">      generate_expression_for_logical_operator(:OR, node_value)</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="35">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="35">
           
-          <code class="ruby">    @cleared_text.tr!(&#39;\\&#39;, &#39;\\&#39;)</code>
+          
+          <code class="ruby">    when :OPERATOR_AND</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="36">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="36">
           
-          <code class="ruby">    @cleared_text.gsub!(/%/, &#39;\%&#39;)</code>
+          
+          <code class="ruby">      generate_expression_for_logical_operator(:AND, node_value)</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="37">
           
           
-          <code class="ruby">  end</code>
+          <code class="ruby">    when :OPERATOR_NOT</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="38">
           
           
+          <code class="ruby">      not_array = generate_sql node_value</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="39">
+          
+          
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="39">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="40">
           
-          <code class="ruby">  def extract_columns</code>
-        </li>
-      
-        <li class="covered" data-hits="5" data-linenumber="40">
-          <span class="hits">5</span>
           
-          <code class="ruby">    column_search_term_pairs = @cleared_text.scan(/([A-Za-z0-9_]+:[\w\_-]+)/)</code>
+          <code class="ruby">      if not_array.length &lt; 2</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="41">
           
           
+          <code class="ruby">        raise &quot;There should be more than 1 element for expression following NOT operator&quot;</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="42">
+          
+          
+          <code class="ruby">      end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="43">
+          
+          
           <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="42">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="44">
           
-          <code class="ruby">    @column_chunks = (column_search_term_pairs.flatten.map do |pair|</code>
+          
+          <code class="ruby">      not_expression = not_array.first</code>
         </li>
       
-        <li class="covered" data-hits="7" data-linenumber="43">
-          <span class="hits">7</span>
+        <li class="never" data-hits="" data-linenumber="45">
           
-          <code class="ruby">      column, term = pair.split(&#39;:&#39;)</code>
+          
+          <code class="ruby">      not_params = not_array[1..]</code>
         </li>
       
-        <li class="covered" data-hits="7" data-linenumber="44">
-          <span class="hits">7</span>
+        <li class="never" data-hits="" data-linenumber="46">
           
-          <code class="ruby">      next unless @fields_mappings.include?(column.to_sym) </code>
-        </li>
-      
-        <li class="covered" data-hits="5" data-linenumber="45">
-          <span class="hits">5</span>
           
-          <code class="ruby">      @cleared_text.gsub!(pair, &#39;&#39;)</code>
-        </li>
-      
-        <li class="covered" data-hits="5" data-linenumber="46">
-          <span class="hits">5</span>
-          
-          <code class="ruby">      { @fields_mappings[column.to_sym] =&gt; term }</code>
+          <code class="ruby"></code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="47">
           
           
-          <code class="ruby">    end).compact</code>
+          <code class="ruby">      [&quot;NOT #{not_expression}&quot;] + not_params</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="48">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="48">
           
-          <code class="ruby">    unless @cleared_text.strip.empty?</code>
+          
+          <code class="ruby"></code>
         </li>
       
-        <li class="covered" data-hits="3" data-linenumber="49">
-          <span class="hits">3</span>
+        <li class="never" data-hits="" data-linenumber="49">
           
-          <code class="ruby">      @column_chunks = [{ @default_field.to_s =&gt; @cleared_text.strip }] + @column_chunks</code>
+          
+          <code class="ruby">    else</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="50">
           
           
-          <code class="ruby">    end</code>
+          <code class="ruby">      # key is column name</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="51">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="51">
           
-          <code class="ruby">    @column_chunks</code>
+          
+          <code class="ruby">      escaped_node_value = handle_special_chars node_value</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="52">
           
           
-          <code class="ruby">  end</code>
+          <code class="ruby">      mapping = @fields_mappings[first_key.to_sym]</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="53">
           
           
-          <code class="ruby"></code>
+          <code class="ruby">      if mapping.nil?</code>
         </li>
       
-        <li class="covered" data-hits="1" data-linenumber="54">
-          <span class="hits">1</span>
+        <li class="never" data-hits="" data-linenumber="54">
           
-          <code class="ruby">  def generate_where_clause(query)</code>
+          
+          <code class="ruby">        raise &quot;Unknown field &#39;#{first_key.to_s}&#39;&quot;</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="55">
-          <span class="hits">5</span>
+        <li class="never" data-hits="" data-linenumber="55">
           
-          <code class="ruby">    where_clause = &#39;&#39;</code>
+          
+          <code class="ruby">      else</code>
         </li>
       
-        <li class="covered" data-hits="13" data-linenumber="56">
-          <span class="hits">13</span>
+        <li class="never" data-hits="" data-linenumber="56">
           
-          <code class="ruby">    columns = @column_chunks.map { |c| c.keys.first } </code>
+          
+          <code class="ruby">        [&quot;#{mapping.to_s} ILIKE ?&quot;, &quot;%#{escaped_node_value}%&quot;]</code>
         </li>
       
-        <li class="covered" data-hits="13" data-linenumber="57">
-          <span class="hits">13</span>
+        <li class="never" data-hits="" data-linenumber="57">
           
-          <code class="ruby">    values = @column_chunks.map { |c| c.values.first }</code>
+          
+          <code class="ruby">      end</code>
         </li>
       
         <li class="never" data-hits="" data-linenumber="58">
           
           
-          <code class="ruby"></code>
-        </li>
-      
-        <li class="covered" data-hits="5" data-linenumber="59">
-          <span class="hits">5</span>
-          
-          <code class="ruby">    columns.each do |column| </code>
-        </li>
-      
-        <li class="covered" data-hits="8" data-linenumber="60">
-          <span class="hits">8</span>
-          
-          <code class="ruby">      where_clause += &quot;#{column} LIKE ? OR &quot;</code>
-        </li>
-      
-        <li class="never" data-hits="" data-linenumber="61">
-          
-          
           <code class="ruby">    end</code>
         </li>
       
-        <li class="covered" data-hits="5" data-linenumber="62">
-          <span class="hits">5</span>
-          
-          <code class="ruby">    where_clause += &quot; 1&lt;&gt;1 &quot;</code>
-        </li>
-      
-        <li class="never" data-hits="" data-linenumber="63">
-          
-          
-          <code class="ruby"></code>
-        </li>
-      
-        <li class="covered" data-hits="5" data-linenumber="64">
-          <span class="hits">5</span>
-          
-          <code class="ruby">    query.where([where_clause] + values) </code>
-        </li>
-      
-        <li class="never" data-hits="" data-linenumber="65">
+        <li class="never" data-hits="" data-linenumber="59">
           
           
           <code class="ruby">  end</code>
         </li>
       
+        <li class="never" data-hits="" data-linenumber="60">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="61">
+          
+          
+          <code class="ruby">  def generate_expression_for_logical_operator(operator, operator_array)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="62">
+          
+          
+          <code class="ruby">    if operator_array.length != 2</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="63">
+          
+          
+          <code class="ruby">      raise &quot;There should be two array elements for #{operator.to_s} operator&quot;</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="64">
+          
+          
+          <code class="ruby">    end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="65">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
         <li class="never" data-hits="" data-linenumber="66">
           
           
+          <code class="ruby">    first_operand = generate_sql operator_array.first</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="67">
+          
+          
+          <code class="ruby">    second_operand = generate_sql operator_array.last</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="68">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="69">
+          
+          
+          <code class="ruby">    if first_operand.length &lt; 2</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="70">
+          
+          
+          <code class="ruby">      raise &#39;There should be more than 1 element in first operand array&#39;</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="71">
+          
+          
+          <code class="ruby">    end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="72">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="73">
+          
+          
+          <code class="ruby">    if second_operand.length &lt; 2</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="74">
+          
+          
+          <code class="ruby">      raise &#39;There should be more than 1 element in second operand array&#39;</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="75">
+          
+          
+          <code class="ruby">    end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="76">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="77">
+          
+          
+          <code class="ruby">    first_operand_expression = first_operand.first</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="78">
+          
+          
+          <code class="ruby">    first_operand_params = first_operand[1..]</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="79">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="80">
+          
+          
+          <code class="ruby">    second_operand_expression = second_operand.first</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="81">
+          
+          
+          <code class="ruby">    second_operand_params = second_operand[1..]</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="82">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="83">
+          
+          
+          <code class="ruby">    [&quot;(#{first_operand_expression} #{operator.to_s} #{second_operand_expression})&quot;] + first_operand_params + second_operand_params</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="84">
+          
+          
+          <code class="ruby">  end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="85">
+          
+          
+          <code class="ruby"></code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="86">
+          
+          
+          <code class="ruby">  def handle_special_chars(text)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="87">
+          
+          
+          <code class="ruby">    result = text.gsub(/\&quot;/, &#39;&#39;)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="88">
+          
+          
+          <code class="ruby">    result.gsub!(/\_/, &#39;\_&#39;)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="89">
+          
+          
+          <code class="ruby">    result.tr!(&#39;\\&#39;, &#39;\\&#39;)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="90">
+          
+          
+          <code class="ruby">    result.gsub!(/%/, &#39;\%&#39;)</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="91">
+          
+          
+          <code class="ruby">    result</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="92">
+          
+          
+          <code class="ruby">  end</code>
+        </li>
+      
+        <li class="never" data-hits="" data-linenumber="93">
+          
+          
           <code class="ruby">end</code>
         </li>
       
diff --git a/lib/lexer.rb b/lib/lexer.rb
new file mode 100644
index 0000000..80cb51f
--- /dev/null
+++ b/lib/lexer.rb
@@ -0,0 +1,107 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.7
+# from lexical definition file "./lib/specification.rex".
+#++
+
+require 'racc/parser'
+class Query < Racc::Parser
+      require 'strscan'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
+
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
+
+
+        def next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/ +/))
+                    ;
+
+                  when (text = @ss.scan(/\(/))
+                     action { return [:L_BRACKET, text] }
+
+                  when (text = @ss.scan(/\)/))
+                     action { return [:R_BRACKET, text] }
+
+                  when (text = @ss.scan(/(?i)or/))
+                     action { return [:OPERATOR_OR, text] }
+
+                  when (text = @ss.scan(/(?i)and/))
+                     action { return [:OPERATOR_AND, text] }
+
+                  when (text = @ss.scan(/(?i)not/))
+                     action { return [:OPERATOR_NOT, text] }
+
+                  when (text = @ss.scan(/"([^"]*)"/))
+                     action { return [:TERM_WITH_QUOTES, text] }
+
+                  when (text = @ss.scan(/[a-zA-Z0-9\-_]+/))
+                     action { return [:TERM_WITHOUT_QUOTES, text] }
+
+                  when (text = @ss.scan(/\:/))
+                     action { return [:COLON, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
+
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end # class
diff --git a/lib/parser-parser-part/.gitignore b/lib/parser-parser-part/.gitignore
deleted file mode 100644
index c8d090a..0000000
--- a/lib/parser-parser-part/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-.idea
-
-lexer.rb
-parser.rb
\ No newline at end of file
diff --git a/lib/parser-parser-part/README.md b/lib/parser-parser-part/README.md
deleted file mode 100644
index 2eae07a..0000000
--- a/lib/parser-parser-part/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# parser
-
-### Prerequisites
-
-* Rexical (rex) 
-* Racc
-
-### Available commands
-
-* `rake lexer` - generates `lexer.rb` file based on `specification.rex` file
-* `rake parser` - generates `parser.rb` file based on `grammar.y` file
-* `rake generate` - generates `lexer.rb` and `parser.rb` files
-
-### Testing
-
-To run only `lexer` tests, execute : `rspec spec/query_lexer_spec.rb`
-To run only `parser` tests, execute : `rspec spec/query_parser_spec.rb`
-
-To run all tests, execute : `rake spec`
\ No newline at end of file
diff --git a/lib/parser-parser-part/Rakefile b/lib/parser-parser-part/Rakefile
deleted file mode 100644
index 92064f7..0000000
--- a/lib/parser-parser-part/Rakefile
+++ /dev/null
@@ -1,20 +0,0 @@
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new do |c|
-  options = ['--color']
-  options += %w[--format documentation]
-  c.rspec_opts = options
-end
-
-desc 'Generate Lexer'
-task :lexer do
-  `rex specification.rex -o lexer.rb`
-end
-
-desc 'Generate Parser'
-task :parser do
-  `racc grammar.y -o parser.rb`
-end
-
-desc 'Generate Lexer and Parser'
-task generate: %i[lexer parser]
\ No newline at end of file
diff --git a/lib/parser-parser-part/grammar.y b/lib/parser-parser-part/grammar.y
deleted file mode 100644
index 5484994..0000000
--- a/lib/parser-parser-part/grammar.y
+++ /dev/null
@@ -1,26 +0,0 @@
-class Query
-    prechigh
-        left OPERATOR_NOT
-        left OPERATOR_AND
-        left OPERATOR_OR
-      preclow
-    rule
-        target: expression
-                | /* none */ { result = 0 }
-
-          expression: TERM_WITHOUT_QUOTES                                       { result = {:DEFAULT_COLUMN => val[0]} }
-          |     TERM_WITH_QUOTES                                                { result = {:DEFAULT_COLUMN => val[0]} }
-          |     TERM_WITHOUT_QUOTES COLON TERM_WITHOUT_QUOTES                   { result = {val[0] => val[2]} }
-          |     TERM_WITHOUT_QUOTES COLON TERM_WITH_QUOTES                      { result = {val[0] => val[2]} }
-          |     expression OPERATOR_OR expression                               { result = {:OPERATOR_OR => [val[0], val[2]]} }
-          |     expression OPERATOR_AND expression                              { result = {:OPERATOR_AND => [val[0], val[2]]} }
-          |     L_BRACKET expression R_BRACKET                                  { result = val[1] }
-end
-
----- header
-  require_relative 'lexer'
-
----- inner
-  def parse(input)
-    scan_str(input)
-  end
\ No newline at end of file
diff --git a/lib/parser-parser-part/spec/query_lexer_spec.rb b/lib/parser-parser-part/spec/query_lexer_spec.rb
deleted file mode 100644
index b97a65a..0000000
--- a/lib/parser-parser-part/spec/query_lexer_spec.rb
+++ /dev/null
@@ -1,259 +0,0 @@
-require './lexer'
-
-class QueryLexerTester
-  describe 'Testing the Lexer' do
-    before do
-      @evaluator = Query.new
-    end
-
-    it 'tests bracket expression' do
-      @result = @evaluator.tokenize('()')
-      expect(@result.length).to eq 2
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :R_BRACKET
-    end
-
-    it 'tests bracket expression with spaces' do
-      @result = @evaluator.tokenize(' (   )    ')
-      expect(@result.length).to eq 2
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :R_BRACKET
-    end
-
-    it 'tests expression with OR operator' do
-      @result = @evaluator.tokenize('() or () OR ()')
-      expect(@result.length).to eq 8
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :R_BRACKET
-      expect(@result[2][0]).to eq :OPERATOR_OR
-      expect(@result[3][0]).to eq :L_BRACKET
-      expect(@result[4][0]).to eq :R_BRACKET
-      expect(@result[5][0]).to eq :OPERATOR_OR
-      expect(@result[6][0]).to eq :L_BRACKET
-      expect(@result[7][0]).to eq :R_BRACKET
-    end
-
-    it 'tests expression with AND operator' do
-      @result = @evaluator.tokenize('() AND () and ()')
-      expect(@result.length).to eq 8
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :R_BRACKET
-      expect(@result[2][0]).to eq :OPERATOR_AND
-      expect(@result[3][0]).to eq :L_BRACKET
-      expect(@result[4][0]).to eq :R_BRACKET
-      expect(@result[5][0]).to eq :OPERATOR_AND
-      expect(@result[6][0]).to eq :L_BRACKET
-      expect(@result[7][0]).to eq :R_BRACKET
-    end
-
-    it 'tests expression with NOT OR and NOT AND operator' do
-      @result = @evaluator.tokenize('() NOT or () not AND ()')
-      expect(@result.length).to eq 10
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :R_BRACKET
-      expect(@result[2][0]).to eq :OPERATOR_NOT
-      expect(@result[3][0]).to eq :OPERATOR_OR
-      expect(@result[4][0]).to eq :L_BRACKET
-      expect(@result[5][0]).to eq :R_BRACKET
-      expect(@result[6][0]).to eq :OPERATOR_NOT
-      expect(@result[7][0]).to eq :OPERATOR_AND
-      expect(@result[8][0]).to eq :L_BRACKET
-      expect(@result[9][0]).to eq :R_BRACKET
-    end
-
-    it 'tests search term under quotes' do
-      @result = @evaluator.tokenize('"123-456"')
-      expect(@result.length).to eq 1
-
-      expect(@result[0][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[0][1]).to eq '"123-456"'
-    end
-
-    it 'tests term without quotes' do
-      @result = @evaluator.tokenize('device_id')
-      expect(@result.length).to eq 1
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'device_id'
-    end
-
-    it 'tests integer term without quotes' do
-      @result = @evaluator.tokenize('123')
-      expect(@result.length).to eq 1
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq '123'
-    end
-
-    it 'tests multiple terms without quotes' do
-      @result = @evaluator.tokenize('device_id tag 123-456 name123')
-
-      expect(@result.length).to eq 4
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'device_id'
-      expect(@result[1][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[1][1]).to eq 'tag'
-      expect(@result[2][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[2][1]).to eq '123-456'
-      expect(@result[3][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[3][1]).to eq 'name123'
-    end
-
-    it 'tests simple query with column name and search term without quotes' do
-      @result = @evaluator.tokenize('name:JF')
-
-      expect(@result.length).to eq 3
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'name'
-      expect(@result[1][0]).to eq :COLON
-      expect(@result[2][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[2][1]).to eq 'JF'
-    end
-
-    it 'tests simple query with two columns with name and search terms without quotes' do
-      @result = @evaluator.tokenize('name:JF tag:mta')
-
-      expect(@result.length).to eq 6
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'name'
-      expect(@result[1][0]).to eq :COLON
-      expect(@result[2][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[2][1]).to eq 'JF'
-      expect(@result[3][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[3][1]).to eq 'tag'
-      expect(@result[4][0]).to eq :COLON
-      expect(@result[5][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[5][1]).to eq 'mta'
-
-    end
-
-    it 'tests simple query with column name and search term with quotes' do
-      @result = @evaluator.tokenize('name:"name with space"')
-
-      expect(@result.length).to eq 3
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'name'
-      expect(@result[1][0]).to eq :COLON
-      expect(@result[2][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[2][1]).to eq '"name with space"'
-    end
-
-    it 'tests search term with quotes containing non alphanumerical characters' do
-      @result = @evaluator.tokenize('"|*|/\()#-!=<>&$"')
-
-      expect(@result.length).to eq 1
-
-      expect(@result[0][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[0][1]).to eq '"|*|/\()#-!=<>&$"'
-    end
-
-    it 'tests simple query in brackets' do
-      @result = @evaluator.tokenize('(name:"name with space")')
-
-      expect(@result.length).to eq 5
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[1][1]).to eq 'name'
-      expect(@result[2][0]).to eq :COLON
-      expect(@result[3][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[3][1]).to eq '"name with space"'
-      expect(@result[4][0]).to eq :R_BRACKET
-    end
-
-    it 'tests multiple query wtih brackets' do
-      @result = @evaluator.tokenize('(name:"name with space") or (tag:mta)')
-
-      expect(@result.length).to eq 11
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[1][1]).to eq 'name'
-      expect(@result[2][0]).to eq :COLON
-      expect(@result[3][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[3][1]).to eq '"name with space"'
-      expect(@result[4][0]).to eq :R_BRACKET
-      expect(@result[5][0]).to eq :OPERATOR_OR
-      expect(@result[6][0]).to eq :L_BRACKET
-      expect(@result[7][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[7][1]).to eq 'tag'
-      expect(@result[8][0]).to eq :COLON
-      expect(@result[9][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[9][1]).to eq 'mta'
-      expect(@result[10][0]).to eq :R_BRACKET
-
-    end
-
-    it 'tests complex query' do
-      @result = @evaluator.tokenize('(device-id:"with space" tag:mta no-quotes-id-123)'\
-      'or "id with quotes-5"  and   ( ("id with q 10" or "id with q 20")'\
-      'and ("id with Q 30" "id with Q 40") and not id-without-Q-50)')
-
-      expect(@result.length).to eq 27
-
-      expect(@result[0][0]).to eq :L_BRACKET
-      expect(@result[1][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[1][1]).to eq 'device-id'
-      expect(@result[2][0]).to eq :COLON
-      expect(@result[3][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[3][1]).to eq '"with space"'
-      expect(@result[4][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[4][1]).to eq 'tag'
-      expect(@result[5][0]).to eq :COLON
-      expect(@result[6][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[6][1]).to eq 'mta'
-      expect(@result[7][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[7][1]).to eq 'no-quotes-id-123'
-      expect(@result[8][0]).to eq :R_BRACKET
-
-      expect(@result[9][0]).to eq :OPERATOR_OR
-      expect(@result[10][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[10][1]).to eq '"id with quotes-5"'
-      expect(@result[11][0]).to eq :OPERATOR_AND
-
-      expect(@result[12][0]).to eq :L_BRACKET
-      expect(@result[13][0]).to eq :L_BRACKET
-      expect(@result[14][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[14][1]).to eq '"id with q 10"'
-      expect(@result[15][0]).to eq :OPERATOR_OR
-      expect(@result[16][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[16][1]).to eq '"id with q 20"'
-      expect(@result[17][0]).to eq :R_BRACKET
-
-      expect(@result[18][0]).to eq :OPERATOR_AND
-      expect(@result[19][0]).to eq :L_BRACKET
-      expect(@result[20][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[20][1]).to eq '"id with Q 30"'
-      expect(@result[21][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[21][1]).to eq '"id with Q 40"'
-      expect(@result[22][0]).to eq :R_BRACKET
-
-      expect(@result[23][0]).to eq :OPERATOR_AND
-      expect(@result[24][0]).to eq :OPERATOR_NOT
-      expect(@result[25][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[25][1]).to eq 'id-without-Q-50'
-      expect(@result[26][0]).to eq :R_BRACKET
-    end
-
-    it 'tests query with -or-, -and- and -not- words inside quoted expression' do
-      @result = @evaluator.tokenize('tag:"tag with or and not inside"')
-
-      expect(@result.length).to eq 3
-
-      expect(@result[0][0]).to eq :TERM_WITHOUT_QUOTES
-      expect(@result[0][1]).to eq 'tag'
-      expect(@result[1][0]).to eq :COLON
-      expect(@result[2][0]).to eq :TERM_WITH_QUOTES
-      expect(@result[2][1]).to eq '"tag with or and not inside"'
-    end
-  end
-end
diff --git a/lib/parser-parser-part/spec/query_parser_spec.rb b/lib/parser-parser-part/spec/query_parser_spec.rb
deleted file mode 100644
index f26c4a3..0000000
--- a/lib/parser-parser-part/spec/query_parser_spec.rb
+++ /dev/null
@@ -1,164 +0,0 @@
-require './parser'
-
-class QueryParserTester
-  describe 'Testing the Parser' do
-    before do
-      @evaluator = Query.new
-    end
-
-    it 'tests query with only one search term without quotes and without column name' do
-      @result = @evaluator.parse('-123')
-
-      expect(@result[:DEFAULT_COLUMN]).to eq '-123'
-    end
-
-    it 'tests query with only one search term with quotes and without column name' do
-      @result = @evaluator.parse('"OR 128"')
-
-      expect(@result[:DEFAULT_COLUMN]).to eq '"OR 128"'
-    end
-
-    it 'tests query with one column and search term without quotes' do
-      @result = @evaluator.parse('tag:mta')
-
-      expect(@result['tag']).to eq 'mta'
-    end
-
-    it 'tests query with one column and search term with quotes' do
-      @result = @evaluator.parse('tag:"tag 120"')
-
-      expect(@result['tag']).to eq '"tag 120"'
-    end
-
-    it 'tests query with two columns connected with OR and search terms without quotes' do
-      @result = @evaluator.parse('tag:mta OR tag:12')
-
-      @expected_array = [
-          { 'tag' => 'mta' },
-          { 'tag' => '12' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_OR]).to eq @expected_array
-    end
-
-    it 'tests query with two columns connected with OR and search terms with quotes' do
-      @result = @evaluator.parse('tag:mta OR tag:"tag 12"')
-
-      @expected_array = [
-          { 'tag' => 'mta' },
-          { 'tag' => '"tag 12"' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_OR]).to eq @expected_array
-    end
-
-    it 'tests query with two columns connected with AND and search terms without quotes' do
-      @result = @evaluator.parse('tag:mta AND tag:12')
-
-      @expected_array = [
-          { 'tag' => 'mta' },
-          { 'tag' => '12' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_AND]).to eq @expected_array
-    end
-
-    it 'tests query with two columns connected with AND and search terms with quotes' do
-      @result = @evaluator.parse('tag:mta and tag:"tag 12"')
-
-      @expected_array = [
-          { 'tag' => 'mta' },
-          { 'tag' => '"tag 12"' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_AND]).to eq @expected_array
-    end
-
-    it 'tests simple query with brackets' do
-      @result = @evaluator.parse('(123)')
-
-      expect(@result.count).to eq 1
-      expect(@result[:DEFAULT_COLUMN]).to eq '123'
-    end
-
-    it 'tests simple query with brackets and with a column name' do
-      @result = @evaluator.parse('(name:JF)')
-
-      expect(@result.count).to eq 1
-      expect(@result['name']).to eq 'JF'
-    end
-
-    it 'tests query with OR operator in brackets' do
-      @result = @evaluator.parse('(name:JF or tag:mta)')
-
-      @expected_array = [
-          { 'name' => 'JF' },
-          { 'tag' => 'mta' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_OR]).to eq @expected_array
-    end
-
-    it 'tests query with two simple brackets expressions' do
-      @result = @evaluator.parse('(name:JF) and (-456)')
-
-      @expected_array = [
-          { 'name' => 'JF' },
-          { :DEFAULT_COLUMN => '-456' }
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_AND]).to eq @expected_array
-    end
-
-    it 'tests query with two brackets expressions' do
-      @result = @evaluator.parse('(name:JF or tag:"tag 0") and (-456)')
-
-      @expected_array_part_1 = [
-          { 'name' => 'JF' },
-          { 'tag' => '"tag 0"' }
-      ]
-
-      @expected_array_total = [
-          {:OPERATOR_OR => @expected_array_part_1},
-          {:DEFAULT_COLUMN => '-456'}
-      ]
-
-      expect(@result.count).to eq 1
-      expect(@result[:OPERATOR_AND]).to eq @expected_array_total
-    end
-
-    it 'tests operator precedence' do
-      @result1 = @evaluator.parse('tag:mta or name:JF and 12_4')
-      @result2 = @evaluator.parse('tag:mta or (name:JF and 12_4)')
-
-      expect(@result1).to eq @result2
-
-      expect(@result1.length).to eq 1
-
-      @expected_array_part_2 = [
-          {'name' => 'JF'},
-          {:DEFAULT_COLUMN => '12_4'}
-      ]
-
-      @expected_array_total = [
-          {'tag' => 'mta'},
-          {:OPERATOR_AND => @expected_array_part_2}
-      ]
-
-      expect(@result1[:OPERATOR_OR]).to eq @expected_array_total
-
-    end
-
-    # Tests to write :
-    # * query with multiple column names and search terms without logical operators
-    # * AND NOT, OR NOT tests
-
-
-  end
-end
diff --git a/lib/parser-parser-part/specification.rex b/lib/parser-parser-part/specification.rex
deleted file mode 100644
index 4ac4649..0000000
--- a/lib/parser-parser-part/specification.rex
+++ /dev/null
@@ -1,35 +0,0 @@
-class Query
-macro
-    L_BRACKET                       \(
-    R_BRACKET                       \)
-    SPACE                           \ +     # Space char
-    OPERATOR_OR                     (?i)or
-    OPERATOR_AND                    (?i)and
-    OPERATOR_NOT                    (?i)not
-    TERM_WITH_QUOTES                "([^"]*)"
-    TERM_WITHOUT_QUOTES             [a-zA-Z0-9-_]+
-    COLON                           \:
-
-
-
-rule
-    {SPACE}                         # No action
-    {L_BRACKET}                     { return [:L_BRACKET, text] }
-    {R_BRACKET}                     { return [:R_BRACKET, text] }
-    {OPERATOR_OR}                   { return [:OPERATOR_OR, text] }
-    {OPERATOR_AND}                  { return [:OPERATOR_AND, text] }
-    {OPERATOR_NOT}                  { return [:OPERATOR_NOT, text] }
-    {TERM_WITH_QUOTES}              { return [:TERM_WITH_QUOTES, text] }
-    {TERM_WITHOUT_QUOTES}           { return [:TERM_WITHOUT_QUOTES, text] }
-    {COLON}                         { return [:COLON, text] }
-
-inner
-  def tokenize(code)
-    scan_setup(code)
-    tokens = []
-    while token = next_token
-      tokens << token
-    end
-    tokens
-  end
-end
\ No newline at end of file
diff --git a/lib/parser.rb b/lib/parser.rb
new file mode 100644
index 0000000..58fc3c7
--- /dev/null
+++ b/lib/parser.rb
@@ -0,0 +1,181 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.16
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+  require_relative 'lexer'
+
+class Query < Racc::Parser
+
+module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 24)
+  def parse(input)
+    scan_str(input)
+  end
+...end grammar.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+     8,     7,     3,     4,    11,     5,    16,     3,     4,     9,
+     5,     3,     4,     6,     5,     3,     4,     8,     5,     8,
+     7,    14,    15 ]
+
+racc_action_check = [
+    10,    10,     8,     8,     6,     8,    10,     0,     0,     3,
+     0,     5,     5,     1,     5,     7,     7,    12,     7,     2,
+     2,     9,     9 ]
+
+racc_action_pointer = [
+     2,    13,    16,     2,   nil,     6,     4,    10,    -3,    16,
+    -3,   nil,    14,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -2,   -10,    -1,    -3,    -4,   -10,   -10,   -10,   -10,   -10,
+   -10,    17,    -7,    -8,    -5,    -6,    -9 ]
+
+racc_goto_table = [
+     2,     1,   nil,   nil,   nil,    10,   nil,    12,    13 ]
+
+racc_goto_check = [
+     2,     1,   nil,   nil,   nil,     2,   nil,     2,     2 ]
+
+racc_goto_pointer = [
+   nil,     1,     0 ]
+
+racc_goto_default = [
+   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 11, :_reduce_none,
+  0, 11, :_reduce_2,
+  1, 12, :_reduce_3,
+  1, 12, :_reduce_4,
+  3, 12, :_reduce_5,
+  3, 12, :_reduce_6,
+  3, 12, :_reduce_7,
+  3, 12, :_reduce_8,
+  3, 12, :_reduce_9 ]
+
+racc_reduce_n = 10
+
+racc_shift_n = 17
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :OPERATOR_NOT => 2,
+  :OPERATOR_AND => 3,
+  :OPERATOR_OR => 4,
+  :TERM_WITHOUT_QUOTES => 5,
+  :TERM_WITH_QUOTES => 6,
+  :COLON => 7,
+  :L_BRACKET => 8,
+  :R_BRACKET => 9 }
+
+racc_nt_base = 10
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "OPERATOR_NOT",
+  "OPERATOR_AND",
+  "OPERATOR_OR",
+  "TERM_WITHOUT_QUOTES",
+  "TERM_WITH_QUOTES",
+  "COLON",
+  "L_BRACKET",
+  "R_BRACKET",
+  "$start",
+  "target",
+  "expression" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 8)
+  def _reduce_2(val, _values, result)
+     result = 0
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 10)
+  def _reduce_3(val, _values, result)
+     result = {:DEFAULT_COLUMN => val[0]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 11)
+  def _reduce_4(val, _values, result)
+     result = {:DEFAULT_COLUMN => val[0]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 12)
+  def _reduce_5(val, _values, result)
+     result = {val[0] => val[2]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 13)
+  def _reduce_6(val, _values, result)
+     result = {val[0] => val[2]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 14)
+  def _reduce_7(val, _values, result)
+     result = {:OPERATOR_OR => [val[0], val[2]]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 15)
+  def _reduce_8(val, _values, result)
+     result = {:OPERATOR_AND => [val[0], val[2]]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 16)
+  def _reduce_9(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class Query
diff --git a/lib/pg_searchable_regex.rb b/lib/pg_searchable_regex.rb
index 1dc287c..4387373 100644
--- a/lib/pg_searchable_regex.rb
+++ b/lib/pg_searchable_regex.rb
@@ -3,7 +3,7 @@
 require 'active_support'
 require 'squeel'
 require_relative './text_to_tsquery'
-require_relative './text_to_regex_query'
+require_relative './text_to_sql_query'
 
 module PgSearchable
   extend ActiveSupport::Concern
@@ -48,7 +48,8 @@ module PgSearchable
 
     def ts_search(value)
       return if @ts_search_fields.blank? || value.blank?
-             TextToRegexQuery.new(value, @ts_search_fields, @default_field, @ts_search_fields_mappings).where_clause( includes(@ts_joins).references(:all))
+      includes(@ts_joins).references(:all).where(
+      TextToSqlQuery.new(value, @ts_search_fields, @default_field, @ts_search_fields_mappings).where_clause)
     end
 
     def should_update_cache_field?
diff --git a/lib/specification.rex b/lib/specification.rex
index 4ac4649..c92a37e 100644
--- a/lib/specification.rex
+++ b/lib/specification.rex
@@ -7,7 +7,7 @@ macro
     OPERATOR_AND                    (?i)and
     OPERATOR_NOT                    (?i)not
     TERM_WITH_QUOTES                "([^"]*)"
-    TERM_WITHOUT_QUOTES             [a-zA-Z0-9-_]+
+    TERM_WITHOUT_QUOTES             [a-zA-Z0-9\-_]+
     COLON                           \:
 
 
@@ -32,4 +32,4 @@ inner
     end
     tokens
   end
-end
\ No newline at end of file
+end
diff --git a/lib/text_to_sql_query.rb b/lib/text_to_sql_query.rb
new file mode 100644
index 0000000..c7cc6f8
--- /dev/null
+++ b/lib/text_to_sql_query.rb
@@ -0,0 +1,92 @@
+require_relative 'parser'
+
+class TextToSqlQuery
+  def initialize(text, fields, default_field, fields_mappings = {})
+    @text = text.to_s.strip
+    @fields = fields.map(&:to_sym)
+    @default_field = default_field.to_sym
+    @fields_mappings = fields_mappings.merge(@fields.reduce({}) do |mappings, field|
+      _table_name, field_name = field.to_s.split('.')
+      mappings[field_name.to_sym] = field
+      mappings
+    end)
+    fields_mappings.each do |field, value|
+      @fields_mappings[field] = value if @fields_mappings[field]
+    end
+  end
+
+  def where_clause
+    @parser = Query.new
+    @parsed_tree = @parser.parse(@text)
+    generate_sql @parsed_tree
+  end
+
+  private
+
+  def generate_sql(tree)
+    first_key = tree.keys.first
+    node_value = tree[first_key]
+    case first_key
+    when :DEFAULT_COLUMN
+      escaped_node_value = handle_special_chars node_value
+      ["#{@default_field.to_s} ILIKE ?", "%#{escaped_node_value}%"]
+    when :OPERATOR_OR
+      generate_expression_for_logical_operator(:OR, node_value)
+    when :OPERATOR_AND
+      generate_expression_for_logical_operator(:AND, node_value)
+    when :OPERATOR_NOT
+      not_array = generate_sql node_value
+
+      if not_array.length < 2
+        raise "There should be more than 1 element for expression following NOT operator"
+      end
+
+      not_expression = not_array.shift
+      
+      ["NOT #{not_expression}"] + not_params
+
+    else
+      # key is column name
+      escaped_node_value = handle_special_chars node_value
+      mapping = @fields_mappings[first_key.to_sym]
+      if mapping.nil?
+        raise "Unknown field '#{first_key.to_s}'"
+      else
+        ["#{mapping.to_s} ILIKE ?", "%#{escaped_node_value}%"]
+      end
+    end
+  end
+
+  def generate_expression_for_logical_operator(operator, operator_array)
+    if operator_array.length != 2
+      raise "There should be two array elements for #{operator.to_s} operator"
+    end
+
+    first_operand = generate_sql operator_array.first
+    second_operand = generate_sql operator_array.last
+
+    if first_operand.length < 2
+      raise 'There should be more than 1 element in first operand array'
+    end
+
+    if second_operand.length < 2
+      raise 'There should be more than 1 element in second operand array'
+    end
+
+    first_operand_expression = first_operand.shift
+    first_operand_params = first_operand
+
+    second_operand_expression = second_operand.shift
+    second_operand_params = second_operand
+
+    ["(#{first_operand_expression} #{operator.to_s} #{second_operand_expression})"] + first_operand_params + second_operand_params
+  end
+
+  def handle_special_chars(text)
+    result = text.gsub(/\"/, '')
+    result.gsub!(/\_/, '\_')
+    result.tr!('\\', '\\')
+    result.gsub!(/%/, '\%')
+    result
+  end
+end
diff --git a/pkg/pg_searchable_regex-1.0.13.gem b/pkg/pg_searchable_regex-1.0.13.gem
deleted file mode 100644
index 118da0be3278538355c5b427a5fb34103aa46a9d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15360
zcmeHuQ<NsbmTuWrm+h)9+tp>;wr#V^wr$(CZFkwW{@XM6;mkS@cV1@Z-n-V>nQKMn
z+L@6%_80kO<c=LSCe8-N2F?a_W}ZO*UBd8JSXfwq{;m8g|6DS%v9kd&GP5x<va+)O
zy%LClk(q^+35by4zssQiSg(tdvw`DZlibWrOsxN-;-8NHGyVT=+dmrjPq+WSdP)!p
z1q8N3t_uRXt)XDI$%f>6QoHxLPeGNCP4~MF9e%E$&%a6l^3p(rNd9o$P$(WoqMb3~
zs`ZAFss$A%fC;URWxa0r;OzD8U|WJmL_yfEL8iW&VOVXC?*m9B<x2rHm1aCWRTOoa
zdd$3g29IG<N|kc#XVsq^>prffG1;`&#tY)4>!bya@I|t6^amQF%BYY?C@XJ^s!4HS
zel}l|=;ud>VB`Ez^){=b;Xe{Y&2emnuW}sfxg;pzs{DRLfgVfhq>-eO3+C|)q~jZQ
zSv<Ip^u&1(KLwniugpi&c6rUMkzLuXM!L8Bt<E>pV;At{z&CO;o=Sb#sreO08G}d%
zW-oKu8(WYwW))WPxIs=*?+jxMd#jN(O>wSFz$wdqs>}D`MyN@1t}W*92ilX5fsVVn
z!TWP@Po6!h%j)$xo-AOr)f*b)|I`PaSo+cjpw^oHQn#lonr>X|4x>NuqUrr)Cz<3(
z-_Q7JYe&?6EtvlmfG5b8dFWY8pNE|bq#lqs#yKMr8~9LZ;poen<#ZruCmOd<Q<5GX
z!u-|z1|b>KSNX$%OQvSAUwieUu`#N%NKL7zeULZFtP>A(J~AAI_w#NMW^i`q(Xl|9
zUT>(W(g04mH-~(&HWYOmEhN(u?CoIrh~+`7?~AFS(81jen?7aHyAGi(bfw=|g=Wu`
zIfVOg7PVW5*cLcOOXEY;b$d~=cJqBT8aa=WJtJs&DRoL|hUF*Wl9hnGoqdpyTC^hm
zHSd+=F2@4<nUp5Z$tuQ{?d}<rvNZJ;TK{qN+2oo^nc?V`GT3zhJD;+@wpN{JWFF{}
z&SC@4R@p<cvX0C9;>U#>`^|x5T(&tzp(rY4M)S`tpJ9CMUCV<;{;OYXJF1oxYoff|
zf`OOdl^>1jSiX_dy8^qCSMM{t5IknBbCJokbh2IWVK(z_5F?IuTn@gg{@eI&o^Er<
zb$Ym)@cR@n6xRHuE3x;=!*?h@F6I6CJ)kQfyeO~EzkjIMW4ILzcH-M!$Jv8vGr<yv
zdSPf+_ZCp_u}CTjPOo4xJa8%`6#j6w`rv*KG}C0D5eLr!ADuXT>6Nf=)((*^zNcP7
z9$YSR!C35YJrVK&I%0h=u|n2xM~dL#5cr<j%ozRi%7VEm@BMHQ1qVA6#E``wQWr9j
zjV_uS3!>+KH?hXbWGZ77m|zsvCKbCF%+bE0So@&0R*=E%&E2xvO<Ge<ZQ9CDzS@*d
zZoGb=jT+c9i)KI#0NE0jo*u&aui%t_=l;J8_<xW8nOIp^nE#ponc3L>#sB{m`2J^g
z{Dc25eJ(sVTN=#$E~t=9h7%OS6TEGnmSxbjY#Ln+z1D3zd#~IlS)iq=s1%QeW2`>9
zW;|jajLl4e;s`~?6AFvYG@oCZ>m9JB;Eo~mfv{WbhDokP^n5yURXdkAwDkZLWWM)+
zUq>rySIyI|UPeZh%Ym*}&Cl-}YE@6mX0PFcV{kyp7epu5QLc!~C*dENpKUW94@Z;7
zQY0Mo+1$DhCguH-KenRw{X+{xzg0XxOiNqcmY53=70xP4bNylog1pp3hX#8U0cx8#
z9$$7gwtQ!RlUI)!gii)+|Ati8&e84F?Lu9@+K-x6Ui?QPTZol89ybpHGE$q{hwu42
z*Y}hD?>~3XBkvm(x=jGr&TUCpU(Rzpm^RcwJm=UL-%b9lZQllJzkqMZKWSRIu2GO*
zfOAt>fZFQnO70`T>5~N;7(n6*G9!=hE_5B^aa$Ay5PT=d{Yc?wvlYG8D+Xk0U3dU`
z*EM|>0JC=_&Ao#~xGZA?Ns>CN+jpY|r9*4=Sa9ynn7O;36G3x#-3VH&8^sG+4<oUK
zrmGF^m^}|RCj)=_ab`n?i?9rsPd6XvKKu5c6`T(S2<PxC6MMSnIXXNp+<7h`d@t8E
z)Ioqo2wX#T(rm}1$Uv61k|R}ZvaB23cwlg8tcfpMw{V1ote<8+=M1ivRW%U-2tM4q
zh9oxj`VhxqVm$5_!3rE!WvexIIwf%t$ozpVJA2ijK>2O{LPW|!T~A_{LSrh_c=-L+
zEH8xb`_FQH#Ec}tN1_%Q?|zGID5xK5ZvfRDK&_3<UmVQdfMwX&az4NOE@$Puo&U6b
z)<*rs>B^Pwd)L~A_b*Ty06nnp+^vhy!}RwWdl@_oa7Op)x!8Wr`U!@Jz9*K<)1MID
zXxP3CWl55^G?i(phuU`x__1Gv6-ydN0PoqAXqDHW&~(9w-ZL{Y7bsf4r;dIo0Ni%(
zehKRjfh;-*we%C~eRt6Lhx!fmxj{GUfT8!f+GMVKPcc5%;o=jcW$HPs5-^7`gM{RT
z@a#db_#SB3T022J^~<n;6{L^0PupN~KkI)=>6*12Ag`ovz*IBiYlvF-^QF0v+QSK^
zT?L7)U?SU3B3k#M`jy-V)}Jg<AsFmE;5>VIPwRwvWPnm&kDT~8U1C}z-Vz(ma3<1a
z7$gzdcRvS7L6BjlD+rg&)!7Je4BZMD3Yu48UyP01tYyp(+(QSKJ#Y#e&><>|Ew}Sl
z#@dJ;w`1M+962r)&J@h9MDZc*x~si2pp0Yrpv5-n7RY&d=H3x9hnz1mZQzI`62F77
zzsWYto-gqQTxqq-u9?}G62LV#W(()ql`N7BK7M{SMMXcI9h~NOpHekj*jVPyVMXi2
z8QVmVBC=6@`0w-nM)I=)*yU-wMScQ~HxA$ZjEoM(0e&fOH{CS()mQ<%*LB3~yTP6;
zxJ~!Q(j4vac221({moccE%P<W!Qo@UAXOdH_wX}Dqs<<D6$5N5EO7&NvO!dkS;4P+
zai;!w23<0R#j&Z*<8JmFyY5T*Cf4N*@duok$ntNZ8*JDRTTLJN9{nb%&0HV8H~`j_
zL{UGky0OxCW6WuZ#`B8!y^%EzJ~zBdf{`CTW*}9;^(#du)vFtC{8>bR=fSd<2+0c|
z@O4?mU%McNs>7LJ)iKl9t6;=2D=VfN_X+(uN&=kd&e?=@cB+kzQn34u^TADb9}DUT
zz>!uAd}u_>*{n!Wtxxs~{%8{YN)Zplafu_7&$CC%2T5oxj-Z?BYl=sEJUELhT#L@C
z#}bC;F(KY*20tNnhN?k&3@IRnZ-H83hw-)b6@DzLfRUg8VLeBME8oXa;b9rfA1r>g
zL*n1tbynYvD*RJ{h8|vY-k2geK8FRTGfFaVQNHubR%@iy5(KtHE%d_+s-MLE0LMrP
zW9$_spByz|O!58)cvwRFRS|l<DgzH5|50rLzhG8|?Z9JsOOD?eVpd<gN}h4Jq`q*C
zFF0^~Z-}=u+5G!g#*m*1^h#LE)4Su-FP?bmUn19qJ3&d+rpn|hcknEb2@ELZJ%%dW
z$T|w&28YCt#=7?)Vcto2iuW7-GFt4k*nGbh&^XB8Z740}#4*km*eSO$lZzpO(*${}
z<4;Rjxfn^It=6%L#e@^7E~+O%L_n}*Rz*m_z{ssb7v#eb>lpA>l3bMvt$E^LD9}wW
zJK2xNLYGx2t>tN~c9We5eH0izt?;9udsQdQpmxq~mX*s<1}Wg`Mq;bdkdAiA_ZnT@
zf8zbR4K8A*a_DjbU~4ri`=M!?H)mioCFy_^{V9<NF$NboTf59eQ=qm2f=xP0D?1?A
z0~qr2WUZKjG42Q#BVb2vuJeVb(w-;dp;ao8q^G%Bpo(LtJy1@A(cew$H^a3_kgb%p
zBU_Q8Wk<VAV^KKL8H?3I6{9a*W|Jov)+bfOqaj)LW;mU&e99Q%zNTRz=VS)p(ueaK
z&I(f5uE}z^PG^2M8;J>-%#26(^@e+&U+|(WEjLez2g)-M;8bds;zC?0{|GK0E-;QW
z4iMjHDW8se-1BTIJj}ZN6m2BI&KhBmoRZ_7FYsnv9_K{$5)#(8953074DX}YN@o<*
zkcx*kVepMdPy%<w%4NrT5hs^U7m9KQ`dH}SyuOS52)&7sG-Q%2-rf<kvukZ_eJBb2
ztuZk)qFBu$n5@c(HE51N<Zx&q&46`RtXNjSP%jZgX3<8-W>5!r)v=|U&ku?Y+zd@(
z0DRN~g${*`uBl05u}{U$+SDMrfhmG*#X^*niK<L}^os>-rRUqk?#0F~_3Qcg)hr7p
zO%sYNw}p1^BzLRRx$8DD2bibsTTg2@Z49t&&VK~(Ny#PH;W`Px+ES+Jg_ZD^*Jru!
zmW+OqD#jdGnCt6%CA=NQEl|c+70kEx?Vq}HpT%`(=5CAjs@9y)7im%?7h%b^E^2+l
zGBUM3cuzS)_)}~B1-!vtHL5-6oqVIH(wSWS3f|2UP4j@@^fkp$bnfT#QQbZ7LKj-u
ziyuLb4?qen=p>Y560bz>7O{Cb<#1noa@}3){_56~sV!(b@$%Ats>J`isrH!JMyMRp
z_bN<FF^*n-hPZuC;Rzl?kk|SmqgML(-jwzSb-=s5rJ&fra=ciGCCNg(4^daB#!Xin
zHxLBD^s50?-}wxy!Ai!fdu?`ee>C;04K%|eD3E2MW$T&k<B8&Rz)t{&itNmBQ{kmL
z<6b+m#y;b>b%Ac9UoB-RNm^)Pj2L(vNwUvi6Kzjhb_dv$)ZfV3Wfhf|;K_rT3aE`&
zZa@*DzZ?~PmCrC6p2w+BCo5hngFI4M!nqIaGXm`^RpPM21v3PeB~itH589~jg>{Fu
z&u~_~Y&VDRw8(9uxpys_yO%{)I2rMn7r~5UANXyVzIyKp+8DvlAm~T<a$Vw`vB=&2
z$zi<&b3M^AG6F&8(UnIl!z{{Yl5d&4<$;5!{5(k4F?hdb=`<pk(nrc60`~<~UD)4s
z7RqynTUg?Jhtf{4jUHJGzP*g_YKes^XbNf(6hGLk|1E{DA)e9SgxYTr_XZiJYpx<r
zrJ8P(D>>W;x>hfqTd|U`@o~uBgfSNuJ17L@j$rSCjbJh<;i7UP+;NKzr3=A2UtC0_
z0`$px4M7z210-5`k#7NXj!Z-3c9Nsql1XqZaoUm^lo=;xiZIZFL3GP?%Ct`qE_)2o
zHsR_L;vFriHU!<?xXGyFlAtxbxc6p^U;Ov_tK*!vg}`XT(Bt<my)n<Fi`(u~RQy-!
zkzbRVTB~N_8-d)LUM>aTfOGQ-?+UkvlOseuPnip!izpqtA-^sVE`1yULaaR0U5tW}
zyT|OVFL4|?W~{vK&kstDA}|E5dT0YqYf(733O_t1+mJeZv`98nPqx=eWH2(<=wYHV
z{s(%@7YJh@ZAe;(ssj+|lQ2daraS87IBAJP_e)||9XQ>zTm31f(c|_5F3eKwViY8|
zwU1SLI|Q#APp?t2Vnq^(lvixun}vZldD=3A=_nJ(a5<A*L+AnbMmOgzpN|&h0iHxC
zEHGh3-S9`bY{j$7%P5R1rZYm+gI{?4Z%1VxN{H&0BzmYN#0-mxV+`T&jI}kdFhTd1
zqyj#)9_IP20}w!HrhBwlpVHTMmTMYxqE&_vy_0jhXI*S(k9zRsh+?o_(C7tX*Bb_*
z-S)DSaeW6!x7w%3a#W~!!ne^#-q5Mp73h;uzaV0ko*^+s_{@4a{hxmytYZmc89q+*
zSN@Xs_n}@Z1<9tqOxV>XvC`kj-+;!9jv-V61FMV;z@q92gq~`m<%{{Xzw|ryUYseJ
z){2V~&n&R55#hpf3eJ8J(^wHrQUZYk=QYQyU@dlP3_Icz4=i%u(})2#r=#xFbc(7y
zj5LHC;k(%zu^?OA0(RU^C4yrjTcBXEKcW%aP^1d12&p0OJrJVEQG_txEn1sbt-*gT
zRGVQ<zw>h-YCFuHbJ6SsZnRFC5PZbl30V3M5yvQ(>oX<ceo3^^20KGX5Qtllq1kW^
z7SRTWIGU~l&A?fh1u|&9>0uPdSltjcf=5gK9`aOQGKn-~v{4<&jK*7PA-flUefIUt
zEbsF{=Fa9eQyh4r=w+Mph|k~g>^RWTE|N?lGB^tLDP`3HF5+H6Ox%KQy6sdwgwkeM
zoAi%g3lAj5xnceJcDQd0<AKJw8?4=ea3wIJD!mosb$Agl20wpB6BoPo*MeT(0re@+
z{MgS&#w@+G7O!+uHCq*eG{)!%sh}F0G`EJ3J@tYJE0*g3hVOeWCe4N}^d$fIz@I|G
zKi3lkFx-!pahkI+>c9&g@UhAh7<!v(B9lx@LjF<=AZRgxV2hieO4T{775WGtqN`9X
zQ6rxSumu+`Q(na_PEvvD6Kv}DO0&&1&5M<yz#N?#bL<1o3;h<Wi3DcCmMl&wU?Hu&
zBZ86ET$0)`JJg$M*jr|ufRU+1(XL(*SfZptj_W7Ht0fBNFgJt+xnA&qJTp+I$T|&9
zQDHorOBM4s&m5d<#r5FW_hLm6-tUoEk9EfaAqNgMGQ?v%EbOpP24Uwv48J0(aQ;HI
zh9o{<gc(5~lxVC0ldD!^@>HN8#f^sB$LjEopEoH4YS;GMO5!c+`kk1P2H9tS89PsW
z+hvLMO9))rkX{pfFUW_iD4YutcXqu%m>|4=VPlfmkG8FRZJ7A{r)I(L?t45mqaR5U
zSrX7LZO=xh@T%~~5JdNcw?TELbvux#%j7KN-iHC|$3F+9CeV${<IX}{WX+*8zyKqV
ze4-o$)Q84`Lwcp_c#wu#q1ju80ECON9`+ZP6@@QZsU+Gtg7h8u3;jXq0LzdP`rCv4
zIue}tMGRwt%peQW!Z&c23(#Edgd*+ofpU9gpCl3mwpnriyd5Vo1jcHs81G97qW+rL
zl5E&PkbA`WOy%25Xu*5dcvzKSdm#kSC0k09GZ5$1E&=$N7f3z)#E6(}4hEeQIY(RK
z>UPys7;;EttT{`#$7EtQWCzKSHA;gPfknY_g>->UkR|~`!gLUsl!eLXQGp_Iqq!`-
zpUJ+$P&{owa*&L?pkg3&=?Ah9VUjD=6ZOAciuV>@=&}T(LO|jDr~!Xt^UPW1nxBN-
z#D=iZ4T3>}f(@s7q4_}!1#wsw6JUs*{v=f(ZAfNFV_pWF*&(+&<`=bK2Wx&5#Is$r
z-AYKeYms^k@^*H8DjTW<mr^|U>S9CHMSf7q>LRa7;2aW=P>ye*<yYghfz$}NxQJwI
z@f$`gnMAQ+;#m2`1H=>>h_CU@*y|7AS1ydh*|df*pcH8F$oB+zL=oQnLkv11`t2G>
z7^xkn^NCUAFavZJlf1q^yX+~I9<q^B6{V$!1;9eV?e0ZSZ<@mm+7ep3%=N24LGXUW
z=uiMrPVdzV5rDojibF-{({%{%Q;xUOfl8#sgVBanmVO?lV;1J#cF~_mg|P62lm&`3
z4MSBx7}7~dbkRqV7ybTh2(unLA@9IN$YxBp-wRa~gC${yBOKNwz3Fm_qI*6VXk9_&
z6W-7qd_>7Y=cJxOMJsoQ_r?;<QjaH$*@HJQX|r#2VZk8+`zm@M=fs0YShJ^0qEkG@
zZrCxtn$fjfKygeeO_4gLH3|tsVjO-}nC8pR{2|*ZpL$;9e>Cv%{CiBUgU-T>NhU1}
zzi&$`br}JDl_m2|ouKCIv3g^dEn*nUr__=tHN1As$Fe>K*O3Srd>RY6?4*fHNy3S4
zs!9eXAktJh1lcC_pabN`OxxmJUXFo4OcM)gvD$?p(rmu~m$e2JcYqfJn_x1M)hXeS
zT<|uF|E=3uOU#<?#?{w`SEnBkU$QnvPOUtLzZi(YWgnDkpF>{bVLo1vEc@&!8Ui{I
zQ}$3;aG8Cd(#8{$NnWNaFG*#JIG^;-wUIDnfk#y2>QDwGS+>c9#2GFkw-nwZ!Uxlj
z)trmWb{b{zpHF?=UiE&>jlFK(ug6dHqr%sn&X#Dy7(?*Dbm0bP7KZwuQP!=R^pviF
zA#EP}ZxS((8b8e;7ZiDEIKnwlt;iFA6Y+)^euwH)#)rza<4kS<Adh{|Ve=5T0bAPB
zy8!j=4bKe#0Oi`RV$^{89I842qr5V(*on??b+w=mND3{s5>M;$V~Kf{%xaFmsjq2b
zWG`cgo>x1u@#+Taz1%MtS^c1|jSbYEWCW^l4FVP2c}~N4ehKS(47ol^02lWNQr*&C
zIzMc`E_U4guw9W@5Q_yQ@gt<7jJ^QzHW9tB+>urikTlJeZN%Iayvz;OfTX(9U*<N>
zD+g(mk^5S<$cgeHiSe5;#K8a0v2)701sf!zut<J<yD#eb6;9JF80vK9VWntVD^07&
z&@yj*a-3Wf@D${ykO&*rI|-jCH~h46`i1%yY`OVtss1b*sMd1Gop~^KX4)xn<F#=x
z5dtc$3vO@^bE70$r{P-=_PqfrAGPwJ#bn|vE2$^#4@gjhul`sPd06^_L}Sp;B+K8>
zZ@x&sIuj>)tcP|CDksXV16R<TN+=zxRGT0%Xjs=tr_bW)D=_1COXF@lR-h|+t;6IF
z6;PqAsU1QU6<xo~`7ufFOT$?r<WLtoGby*fpfZ$)8i})K5YRy3C`WVF>NonISrc}l
zihm67Fb{~s$8EcS8122EEW-ecRJ^}t68}Vr4S(|CF$0!m!zL`K12S&;)|L_(stAKh
zBnKHZ@pK^<!RcTjtMSJtY`@Tgkr+VGA`GOWXKWn@LPsoATPAHUAJGkmk)BwN<feRQ
zB3teQJlRkPRGpF6R)l4ZiDXlnHHGu`CJ!p+$iWb^zwFz8nG~~CDyRzZy{Ks7cK0a)
zG3C+&oSbL?-;>9lm0yQ|UQz&k!qmrka%j^pzB&0*;`z@3%|?RX&MaJ=$m2SCY_#K`
z*INTPKcef1k!<(G_X16$cm%0*>NfXPAnJqZbQvbLpH40lVo9F4!+<%Jxj-XvC5hYO
z`A7=iCHQAU$>8wh{Ou@SlF~RVgEDBp5dm`(UG%D%`7zocT@^KM<9NRl4}k=d9>tE`
zqb@oTI=gFWSPpH2PTDG(xl+JB$mP&!Dk5gQ^R@XuWN4mj=soK7mdhLYh|nvV?B#?8
zh4C~<gT<|Of1GSq(JoXd*K8sxl#z?ucH2oUl(LGeCp1Y*Hqn7_*F&~UKemr<9HO~#
z|H<ORb&#}0v4({>Uk)^b(z~XxHhU{;mYI=iMRm1o-pAF~x|L2gdj(HkmIfY%V<&NS
zqX=g=FXU+tL3wt#;S|x3EZ9<=SfxfjQfnhSC=GW@GK@14$!6`Tjkuz4olLM$5TQ0x
zFz-7YOJ6zHM8SLBe_j}3!8u`IPOXiTcaWs{o+;754`RXp2sIb_7O}v@oRWWdCmr&P
zX??<KP+_idxG6xq3>VT>!62_9UsPpI$m6MU)jzgsmS`Amk4Hn*AxFoXjR3baA)_A}
z@6jT%YYrLalIJ1WIFv;OU=_+dW>U_)B=SH&V|YEQaP?832IfCm$gulZFqeV$7yd%)
zVrs{L&cFXuT|N1Lxn|0w+gYyR>n-McAucUJh}WxDl^sG8n~n`Id4K~JS$pg$=&zKO
zWPnm~Arq61_L){}5J{w^Zq5h*QLWB9RkP%*ZO9TwKIjEO{M0z;t$tee{%oy(fBare
zMFQ}K`pM7_xoD3~csiPD{GFphlaVxG##)yow=NFL5ibLZnON!R>0w)lgl!rGjx4Bq
ztF9Leq(mzXz&QxG34zf4@b=yMxH%})eX&0|84-Lzimk%|ycfHLy$~<wi_Lsb9-wx0
z9L`~RtCaOP0&#xuW65vr!2bRS7~3MZ96yQ>_EAWMRSrgR3pPsGevs`N3%%$w1!Elv
zg9O!0hVQ>vW5i?^NWvJZNG3g&9R_YH8<Zi^m`}wKrUDV=2(hS5iFR~k)E(fG@Df*+
zQ<>G4DydTX3Ge9u!Zed89eD_=%Loqhp3psHIv7J{G~BMYi#@VKcGZ#<AvKY-uo7xY
zXB#H?VsEW^Zygm?jz0e2p@E@EKGM+^8WMj#H$-0N`eW8_Y^uwbF-3TU!@lO0FQ&+h
z90IE#N)R)bzmjb?RFA!10SdIn!IaH%IPV?m%%@kePlyC2M}_8Qw@@h%uv#MIAt<0L
zy{FX2#|giX4(wR?z2<BVpn=6UzpI!&muS7?H$9kDJ=pv{Tg^^<S-ts)UaYl}@er{w
z)T~^DV4&09a=n)?6z`~ir1O{s=Kj;%tPdtoCmCU1tR#_xD%c*u3k5U)y{wo?Uwinf
z*kWa=qB6vW`<obY{n!=cTmoW^>e>V~<R#n^v#Fzr*aJ^{FXf1210(35ajX`__`btF
zvyqyG7(opvay$1|R{U>;g`kIUY8g`eImDEC+vfDDV=<_3ge>xhlx+>SDJHtNXzlts
zuYR}mPsYYn^TPM!$3Jig3KZiJl=2I|<fte#xc!aWL2&1fBgiqU^}0a-mHOHcHcJa?
zrMDM0s=mIN!0xj<T|N(byw4F=1PzWMji@>rADuUw4an^x{s~AwsS<~Dx9jgCPg>Pp
z=qDn0iRno4mQnH8WbH9<q3^vJ3-AHsHW|euzD`4a7g{)0?XQU6J`sTLn7dpwq7W)e
zLz>G)5ns<eH`<Y5;}lAm_qO#}P|?Zmg(i81&PrCXCUzUx6Ud4Do5)Q<%_fkE(>>yE
z4NDa-!1gxh^?}Ix_ss0J5Q`Y#2A~=h>Hol=h)E(DmVeZ=R|Xe<Xd=;9PA^(a`Vksb
zXpH^gJ2yIh9!Zs85n<7MwhsPeC=6U1i})OvIbt^KuS>!2Fa9lHkZ=W!JCMy()Ilw;
z*cl=rw8a(~vZhvwM6fmx7mi6+clSvN3*pv!5BE-FQgwXzs8QhNgQnpliK^zyb$I<-
zkl0Kf5xvnIPglhv!qEZUC2L3IN&nZeF|Ja1`E3tbf!AWgc^XkNn4sfe)U$=dCLH#j
zls?&07*TOGgf$LnRfg`=u&Q2T%SN7)P`A#{&6@ny1JC8d@0>dd#7{Mi0Sfi<oC%QN
z&VGMcu(PG!nF*x0abt3N{OpH3s)hPbIJ7OB)X;X8SUgc~roNUBNzT#7U-08p=We@<
znhY`UX{s99Hmk-VEeRMx!qZ0;clRpQaP>~Ip-zjuUIBSljbL)~Vt=TKjJ&_{+WpqL
ztai4cwY)}IY=|ovwFXNOrz=$W+r0c<T%wnIY`Of0@xpSeyr7RRO_b1N1>u((*S9xq
zYFN}%!5nE8<7ryxnd^h-+-}qqA64(AQbVg3;a=%0DV8@ZWRTu^vO~M;bZD@tVJaA!
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
I|D*^07d@0ZX8-^I

diff --git a/pkg/pg_searchable_regex-1.0.21.gem b/pkg/pg_searchable_regex-1.0.21.gem
new file mode 100644
index 0000000000000000000000000000000000000000..1d3941a04648ee27c64e502e1a7e7ca7117282d9
GIT binary patch
literal 20992
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
OX@S!Mrv<)kfxiJi5Y^29

literal 0
HcmV?d00001

diff --git a/spec/lib/text_to_sql_query_spec.rb b/spec/lib/text_to_sql_query_spec.rb
new file mode 100644
index 0000000..fd76b8f
--- /dev/null
+++ b/spec/lib/text_to_sql_query_spec.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+describe TextToRegexQuery do
+  include_examples 'pg_search', SimpleVectorModel
+  describe '.new' do
+    # tests simple search term without column name and without quotes
+    it { expect(described_class.new('some-default-value', [:"players.name"], :"players.name").where_clause(SimpleVectorModel)).to eq(['players.name ILIKE ?', '%some-default-value%']) }
+
+    # tests simple search term with column name and without quotes
+    it { expect(described_class.new('title:ab', [:"players.title"], :"players.title").where_clause(SimpleVectorModel)).to eq(['players.title ILIKE ?', '%ab%']) }
+
+    # tests simple search term with unknown column name and without quotes
+    it { expect(described_class.new('unknown:ab', [:"players.name"], :"players.name").where_clause(SimpleVectorModel)).to raise_error(RuntimeError, "Unknown field 'unknown'") }
+
+    # tests simple search term without column name and with quotes
+    it { expect(described_class.new('"ab"', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["players.device_id ILIKE ?", "%ab"]) }
+
+    # tests simple search term with column name and with quotes
+    it { expect(described_class.new('tag:"ab"', [:"players.name", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["players.tag ILIKE ?", "%ab%"]) }
+
+    # tests search without operators
+    it { expect(described_class.new('123 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["(players.device_id ILIKE ? OR players.device_id ILIKE ?)", "%123%", "%456%"]) }
+
+    # tests search with OR operator
+    it { expect(described_class.new('123 or 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["(players.device_id ILIKE ? OR players.device_id ILIKE ?)", "%123%", "%456%"]) }
+
+    # tests search with AND operator
+    it { expect(described_class.new('123 and 456', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["(players.device_id ILIKE ? AND players.device_id ILIKE ?)", "%123%", "%456%"]) }
+
+    # tests search with NOT operator on default column
+    it { expect(described_class.new('not 23', [:"players.name", :"players.device_id"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["NOT players.device_id ILIKE ?", "%23%"]) }
+
+    # tests search with NOT operator on non-default column
+    it { expect(described_class.new('not tag:23', [:"players.name", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(["NOT players.tag ILIKE ?", "%23%"]) }
+
+    # tests search with mixed logical operators
+    it { expect(described_class.new('title:ab and not tag:hf-1', [:"players.title", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(['(players.title ILIKE ? AND NOT players.tag ILIKE ?)', '%ab%', '%hf-1%']) }
+
+    # tests search with mixed logical operators without NOT'
+    it { expect(described_class.new('title:a and title:b or title:c', [:"players.title", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(['((players.title ILIKE ? AND players.title ILIKE ?) OR players.title ILIKE ?)', '%a%', '%b%', '%c%']) }
+
+    # tests search with brackets in expression
+    it { expect(described_class.new('title:a and (title:b or title:c)', [:"players.title", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(['(players.title ILIKE ? AND (players.title ILIKE ? OR players.title ILIKE ?))', '%a%', '%b%', '%c%']) }
+
+    # tests search with brackets in expression and with NOT operator
+    it { expect(described_class.new('title:a and not (title:b or title:c)', [:"players.title", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(['(players.title ILIKE ? AND NOT (players.title ILIKE ? OR players.title ILIKE ?))', '%a%', '%b%', '%c%']) }
+
+    # tests search with special characters in search term
+    it { expect(described_class.new('title:"%a_\"', [:"players.title", :"players.tag"],  :"players.device_id").where_clause(SimpleVectorModel)).to eq(['players.title ILIKE ?', '%\%a\_\\%']) }
+
+    # tests search with field mappings
+    it { expect(described_class.new('tags:h1-r', [:'players.title', :'players.name', :'players.device_id'],  :"players.device_id", { tags: "tags.name" }).where_clause(SimpleVectorModel)).to eq(['tags.name ILIKE ?', '%h1-r%']) }
+
+    # tests search with field mappings when fields array has same mapping
+    it { expect(described_class.new('tags:hs1-r', [:'players.title', :'players.tags', :'players.device_id'],  :"players.device_id", { tags: "tags.name" }).where_clause(SimpleVectorModel)).to eq(["players.tag ILIKE ?", "%ab%"]) }
+
+    # tests complex query
+    it { expect(described_class.new('(device_id:"with space" tags:mta no-quotes-id-123) or "id with quotes-5"  and   ( ("id with q 10" or "id with q 20") and ("id with Q 30" "id with Q 40") and not id-without-Q-50)', [:'players.title', :'players.name', :'players.device_id'],  :"players.device_id", { tags: 'tags.name' }).where_clause(SimpleVectorModel)).to eq(['((players.device_id ILIKE ? OR (tags.name ILIKE ? OR players.device_id ILIKE ?)) OR (players.device_id ILIKE ? AND (((players.device_id ILIKE ? OR players.device_id ILIKE ?) AND (players.device_id ILIKE ? OR players.device_id ILIKE ?)) AND NOT players.device_id ILIKE ?)))', '%with space%', '%mta%', '%no-quotes-id-123%', '%id with quotes-5%', '%id with q 10%', '%id with q 20%', '%id with Q 30%', '%id with Q 40%', '%id-without-Q-50%']) }
+
+  end
+end
diff --git a/version.rb b/version.rb
index cbff164..fc5959a 100644
--- a/version.rb
+++ b/version.rb
@@ -3,7 +3,7 @@
 module Version
   MAJOR = 1
   MINOR = 0
-  PATCH = 13
+  PATCH = 21
 
   def self.to_s
     [MAJOR, MINOR, PATCH].compact.join('.')