es-query-builder 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01a7f2c3df52977455ef8cc73bb06caffae1b5d8
-  data.tar.gz: f9b6ddc51b5b9f64fceb830d8a9a12b5e557d362
+  metadata.gz: 8b7061462ef887c110a7362d082ecab6170d8800
+  data.tar.gz: 273dc7a2f14404b05e8bf8b573fb1f4af62650be
 SHA512:
-  metadata.gz: 76e05d352511a51d07b53363273dc10da73ed421d09b8c92acf3bf7274a151f1756fd5ea68037a84efebc39f872c41590304be8df8aae1444bbed0a06aadf1b0
-  data.tar.gz: 4d19002288f950ad91db2bc5a819cd9fff51f74349a4aafa0bd9536af50cea9540c10defc4ed478e1ffb440a48517c143dad5403360b877766ba6e184af8b0c7
+  metadata.gz: 19b39d4e940467281be485a915fa4333f808d903c0dac03d69206570a603f0b592b02e0950357b6cefb90f4229a62bc63ab884adae1394961e615aad981350a5
+  data.tar.gz: 36d828651c879de1cdfb76b59bbdc4de8772372c72845acd7fcfb8929a44ecbb3d1c6f4b824553d038cc75f26c432f96bda09bb2e589f2d3594a65eaf115f994

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.0.2 - January 3, 2015
+
+- [[#1](https://github.com/increments/es-query-builder/pull/1)] Support nested query and has_child query by [@f-kubotar](https://github.com/f-kubotar).
+
+## 0.0.1 - November 15, 2014
+
+- The initial release.

data/lib/es-query-builder.rb

@@ -47,11 +47,14 @@ class EsQueryBuilder
   #
   # Returns nothing.
   def initialize(query_fields: [], filter_fields: [],
-                 all_query_fields: '_all', hierarchy_fields: [])
+                 all_query_fields: '_all', hierarchy_fields: [],
+                 nested_fields: {}, child_fields: {})
     @query_fields = query_fields
     @filter_fields = filter_fields
     @all_query_fields = all_query_fields
     @hierarchy_fields = hierarchy_fields
+    @nested_fields = nested_fields
+    @child_fields = child_fields
   end
 
   # Public: Convert the given query string into a query object.
@@ -88,6 +91,10 @@ class EsQueryBuilder
   #
   # Returns a Parser.
   def parser
-    @parser ||= Parser.new(@all_query_fields, @hierarchy_fields)
+    @parser ||= Parser.new(
+      all_query_fields: @all_query_fields,
+      hierarchy_fields:  @hierarchy_fields,
+      nested_fields: @nested_fields,
+      child_fields: @child_fields)
   end
 end

data/lib/es-query-builder/parser.rb

@@ -18,9 +18,12 @@ class EsQueryBuilder
     #                    character as a hierarchy (default: []).
     #
     # Returns nothing.
-    def initialize(all_query_fields = '_all', hierarchy_fields = [])
+    def initialize(all_query_fields: '_all', hierarchy_fields: [],
+                   nested_fields: {}, child_fields: {})
       @all_query_fields = all_query_fields
       @hierarchy_fields = hierarchy_fields
+      @nested_fields = nested_fields
+      @child_fields = child_fields
     end
 
     # Public: Parse the given tokens and build a query hash.
@@ -155,25 +158,70 @@ class EsQueryBuilder
     def create_bool_queries(query_tokens)
       must, must_not = [], []
       query_tokens.each do |token|
-        # When the field is not given or invalid one, search by all fields.
-        field = token.field || @all_query_fields
         queries = token.minus? ? must_not : must
-        if field.is_a?(String)
-          queries << {
-            match: {
-              field => token.term
-            }
+
+        queries <<
+          # When the field is not given or invalid one, search by all fields.
+          if token.field.nil?
+            should = []
+            should << create_match_query(@all_query_fields, token.term)
+            @nested_fields.each do |nested_path, nested_field|
+              should << create_nested_match_query(nested_path, nested_field, token.term)
+            end
+            @child_fields.each do |child_type, child_field|
+              should << create_has_child_match_query(child_type, child_field, token.term)
+            end
+            connect_queries(should)
+
+          # When the specify nested field
+          elsif nested_field = @nested_fields[token.field_namespace]
+            create_nested_match_query(token.field_namespace, nested_field, token.term)
+
+          # When the specify child field
+          elsif child_field = @child_fields[token.field_namespace]
+            create_has_child_match_query(token.field_namespace, child_field, token.term)
+
+          # When the specify standard field
+          else
+            create_match_query(token.field, token.term)
+          end
+      end
+      [must, must_not]
+    end
+
+    def create_match_query(field, term)
+      if field.is_a?(String)
+        {
+          match: {
+            field => term
           }
-        else
-          queries << {
-            multi_match: {
-              fields: field,
-              query: token.term
-            }
+        }
+      else
+        {
+          multi_match: {
+            fields: field,
+            query: term
           }
-        end
+        }
       end
-      [must, must_not]
+    end
+
+    def create_nested_match_query(path, field, term)
+      {
+        nested: {
+          path: path.to_s,
+          query: create_match_query(field, term)
+        }
+      }
+    end
+
+    def create_has_child_match_query(child_type, field, term)
+      {
+        has_child: {
+          type: child_type.to_s,
+          query: create_match_query(field, term)
+        }
+      }
     end
 
     # Internal: Create boolean filter based on the filter matches.

data/lib/es-query-builder/token.rb

@@ -1,6 +1,6 @@
 class EsQueryBuilder
   class Token
-    attr_reader :full, :field, :term
+    attr_reader :full, :field, :term, :field_namespace
 
     TYPE_KINDS = %i(query filter or).freeze
 
@@ -10,6 +10,7 @@ class EsQueryBuilder
       @field = field
       @term = term
       @type = type
+      @field_namespace = field.to_s[/^(.+?)\./, 1]
     end
 
     def minus?

data/lib/es-query-builder/tokenizer.rb

@@ -14,7 +14,7 @@ class EsQueryBuilder
 
     OR_CONDITION = /^OR$/i
 
-    # Public: COnstruct the tokenizer object.
+    # Public: Construct the tokenizer object.
     #
     # filter_fields    - An Array of Strings for specifing allowed filtering
     #                    types (default: []).
@@ -35,8 +35,8 @@ class EsQueryBuilder
     #
     #   tokenize('hello OR tag:world')
     #   # => [<Token: @full="hello",     @type=:query,  ...>,
-    #         <Token: @full="OR",        @type=:or,     ...>,
-    #         <Token: @full="tag:world", @type=:filter, ...>]
+    #   #     <Token: @full="OR",        @type=:or,     ...>,
+    #   #     <Token: @full="tag:world", @type=:filter, ...>]
     #
     # Returns an Array of Tokens.
     def tokenize(query_string)

data/lib/es-query-builder/version.rb

@@ -1,3 +1,3 @@
 class EsQueryBuilder
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/es_query_builder_spec.rb

@@ -90,6 +90,426 @@ describe EsQueryBuilder do
           end
         end
       end
+
+      context 'and it is constructed with nested_fields' do
+        let(:param) do
+          { nested_fields: { hoge: ['hoge.title'] } }
+        end
+
+        let(:all_query_fields) do
+          { nested: { hoge: ['hoge.title'] } }
+        end
+
+        it "returns a nested query for the specified nested path and fields" do
+          should eq(
+            {
+              bool: {
+                should: [
+                  {
+                    match: {
+                      '_all' => term
+                    }
+                  },
+                  {
+                    nested: {
+                      path: 'hoge',
+                      query: {
+                        multi_match: {
+                          fields: ['hoge.title'],
+                          query: term
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          match: {
+                            '_all' => term
+                          }
+                        },
+                        {
+                          nested: {
+                            path: 'hoge',
+                            query: {
+                              multi_match: {
+                                fields: ['hoge.title'],
+                                query: term
+                              }
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
+
+      context 'and it is constructed with child_fields' do
+        let(:param) do
+          { child_fields: { child_type => child_field } }
+        end
+
+        let(:child_type) do
+          'hoge'
+        end
+
+        let(:child_field) do
+          ['title']
+        end
+
+        it "returns a has_child query for the specified child field" do
+          should eq(
+            {
+              bool: {
+                should: [
+                  {
+                    match: {
+                      '_all' => term
+                    }
+                  },
+                  {
+                    has_child: {
+                      type: child_type,
+                      query: {
+                        multi_match: {
+                          fields: child_field,
+                          query: term
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          match: {
+                            '_all' => term
+                          }
+                        },
+                        {
+                          has_child: {
+                            type: child_type,
+                            query: {
+                              multi_match: {
+                                fields: child_field,
+                                query: term
+                              }
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
+
+      context 'and it is constructed with both all_query_fields and nested fields' do
+        let(:param) do
+          {
+            all_query_fields: ['hoge'],
+            nested_fields: { hoge: ['hoge.title'] }
+          }
+        end
+
+        it "returns a nested query for the specified nested path and fields" do
+          should eq(
+            {
+              bool: {
+                should: [
+                  {
+                    multi_match: {
+                      fields: ['hoge'],
+                      query: term
+                    }
+                  },
+                  {
+                    nested: {
+                      path: 'hoge',
+                      query: {
+                        multi_match: {
+                          fields: ['hoge.title'],
+                          query: term
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          multi_match: {
+                            fields: ['hoge'],
+                            query: term
+                          }
+                        },
+                        {
+                          nested: {
+                            path: 'hoge',
+                            query: {
+                              multi_match: {
+                                fields: ['hoge.title'],
+                                query: term
+                              }
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
+
+      context 'and it is constructed with both all_query_fields and child_fields' do
+        let(:param) do
+          {
+            all_query_fields: ['hoge'],
+            child_fields: { hoge: ['hoge.title'] }
+          }
+        end
+
+        it "returns a nested query for the specified nested path and fields" do
+          should eq(
+            {
+              bool: {
+                should: [
+                  {
+                    multi_match: {
+                      fields: ['hoge'],
+                      query: term
+                    }
+                  },
+                  {
+                    has_child: {
+                      type: 'hoge',
+                      query: {
+                        multi_match: {
+                          fields: ['hoge.title'],
+                          query: term
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          multi_match: {
+                            fields: ['hoge'],
+                            query: term
+                          }
+                        },
+                        {
+                          has_child: {
+                            type: 'hoge',
+                            query: {
+                              multi_match: {
+                                fields: ['hoge.title'],
+                                query: term
+                              }
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
+
+      context 'and it is constructed with all_query_fields, nested_fields, child_fields' do
+        let(:param) do
+          {
+            all_query_fields: all_query_fields,
+            nested_fields: { nested_path => nested_fields },
+            child_fields: { child_type => child_fields },
+          }
+        end
+
+        let(:all_query_fields) do
+          ['parent_field1']
+        end
+
+        let(:nested_path) do
+          'hoge'
+        end
+
+        let(:nested_fields) do
+          ['hoge.field1']
+        end
+
+        let(:child_type) do
+          'fuga'
+        end
+
+        let(:child_fields) do
+          ['child_field1']
+        end
+
+        it "returns a bool query for the match in nested or child" do
+          should eq(
+            {
+              bool: {
+                should: [
+                  {
+                    multi_match: {
+                      fields: all_query_fields,
+                      query: term
+                    }
+                  },
+                  {
+                    nested: {
+                      path: nested_path,
+                      query: {
+                        multi_match: {
+                          fields: nested_fields,
+                          query: term
+                        }
+                      }
+                    }
+                  },
+                  {
+                    has_child: {
+                      type: child_type,
+                      query: {
+                        multi_match: {
+                          fields: child_fields,
+                          query: term
+                        }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          multi_match: {
+                            fields: all_query_fields,
+                            query: term
+                          }
+                        },
+                        {
+                          nested: {
+                            path: nested_path,
+                            query: {
+                              multi_match: {
+                                fields: nested_fields,
+                                query: term
+                              }
+                            }
+                          }
+                        },
+                        {
+                          has_child: {
+                            type: child_type,
+                            query: {
+                              multi_match: {
+                                fields: child_fields,
+                                query: term
+                              }
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
     end
 
     context 'when term queries are given' do
@@ -206,6 +626,140 @@ describe EsQueryBuilder do
           )
         end
       end
+
+      context 'and it is constructed with nested_fields' do
+        let(:param) do
+          { nested_fields: { nested_path => nested_fields } }
+        end
+
+        let(:nested_path) do
+          'hoge'
+        end
+
+        let(:nested_fields) do
+          ['hoge.title']
+        end
+
+        it 'returns a bool query with must match queries' do
+          should eq(
+            bool: {
+              must: [
+                {
+                  bool: {
+                    should: [
+                      {
+                        match: {
+                          '_all' => term_1
+                        }
+                      },
+                      {
+                        nested: {
+                          path: nested_path,
+                          query: {
+                            multi_match: {
+                              fields: nested_fields,
+                              query: term_1,
+                            }
+                          }
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  bool: {
+                    should: [
+                      {
+                        match: {
+                          '_all' => term_2
+                        }
+                      },
+                      {
+                        nested: {
+                          path: nested_path,
+                          query: {
+                            multi_match: {
+                              fields: nested_fields,
+                              query: term_2,
+                            }
+                          }
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context 'and it is constructed with child_fields' do
+        let(:param) do
+          { child_fields: { child_type => child_fields } }
+        end
+
+        let(:child_type) do
+          'hoge'
+        end
+
+        let(:child_fields) do
+          ['hoge.title']
+        end
+
+        it 'returns a bool query with must match queries' do
+          should eq(
+            bool: {
+              must: [
+                {
+                  bool: {
+                    should: [
+                      {
+                        match: {
+                          '_all' => term_1
+                        }
+                      },
+                      {
+                        has_child: {
+                          type: child_type,
+                          query: {
+                            multi_match: {
+                              fields: child_fields,
+                              query: term_1,
+                            }
+                          }
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  bool: {
+                    should: [
+                      {
+                        match: {
+                          '_all' => term_2
+                        }
+                      },
+                      {
+                        has_child: {
+                          type: child_type,
+                          query: {
+                            multi_match: {
+                              fields: child_fields,
+                              query: term_2,
+                            }
+                          }
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
     end
 
     context 'when a field query is given' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: es-query-builder
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Yuku Takahashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-15 00:00:00.000000000 Z
+date: 2015-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md