wvanbergen-scoped_search 1.2.0 → 2.0.0

data/README.rdoc

@@ -1,9 +1,8 @@
-= scoped_search
+= Scoped search
 
 The <b>scoped_search</b> Rails plugin makes it easy to search your ActiveRecord models. Searching is 
-performed using a query string, which should be passed to the named_scope *search_for* that uses SQL 
-<tt>LIKE %keyword%</tt> conditions for searching (ILIKE for Postgres). You can specify what fields 
-should be used for searching.
+performed using a query string, which should be passed to the named_scope <tt>search_for</tt>. Based on
+a definition in what fields to look, it will build query conditions and return those as a named scope.
 
 == Installing
 
@@ -12,58 +11,75 @@ The recommended method to enable scoped_search in your project is adding the sco
   Rails::Initializer.run do |config|
     ...
     config.gem 'wvanbergen-scoped_search', :lib => 'scoped_search', 
-                   source => 'http://gems.github.com/'
+                   :source => 'http://gems.github.com/'
   end
 
 Run <tt>sudo rake gems:install</tt> to install the gem.
 
-Another alternative is to install scoped_search as a Rails plugin:
+Alternatively, install scoped_search as a Rails plugin:
 
   script/plugin install git://github.com/wvanbergen/scoped_search.git
 
 == Usage
 
-First, you have to specify in what columns should be searched:
+Scoped search requires you to define the fields you want to search in:
 
   class User < ActiveRecord::Base
-    searchable_on :first_name, :last_name
+    scoped_search :on => [:first_name, :last_name]
   end
 
+For more information about options and using fields from relations, see the project
+wiki on search definitions: http://wiki.github.com/wvanbergen/scoped_search/search-definition
 
 Now, the <b>search_for</b> scope is available for queries. You should pass a query string to the scope. 
 This can be empty or nil, in which case all no search conditions are set (and all records will be returned).
 
-  User.search_for(params[:q]).each { |project| ... }
+  User.search_for('my search string').each { |user| ... }
 
+The result is returned as <tt>named_scope</tt>. Because of this, you can actually chain the call with
+other scopes, or with will_paginate. An example:
 
-You can also search on associate models.  This works with <b>belongs_to</b>, <b>has_one</b>, <b>has_many</b>, 
-<b>has_many :through</b>, and <b>HABTM</b>.  For example if a User <b>has_many</b> Notes (title, content, created_at, updated_at)
-
-  class User < ActiveRecord::Base
-    has_many: notes
-    searchable_on :first_name, :last_name, :notes_title, :notes_content
+  class Project < ActiveRecord::Base
+    searchable_on :name, :description
+    named_scope :public, :conditions => {:public => true }
   end
 
-The search query language is simple. It supports these constructs:
-* <b>words:</b> <tt>some search keywords</tt>
-* <b>phrases:</b> <tt>"a single search phrase"</tt>
-* <b>negation:</b> <tt>"look for this" -"but do not look for this phrase and this" -word</tt>
-* <b>OR words/phrases:</b> word/phrase OR word/phrase.  Example: <tt>"Hello World" OR "Hello Moon"</tt>
-* <b>dates:</b> mm/dd/yyyy, dd/mm/yyyy, yyyy/mm/dd, yyyy-mm-dd
-* <b>date ranges:</b> > date, >= date, < date, <= date, date TO date.  Examples: <tt>> 30/05/1983</tt>, <tt>< 2009-01-30</tt>
+  # using chained named_scopes and will_paginate in your controller
+  Project.public.search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
 
-This functionality is build on <tt>named_scope</tt>. The searchable_on statement creates 
-a named_scope *search_for*. Because of this, you can actually chain the call with
-other scopes. For example, this can be very useful if you only want to search in 
-projects that are accessible by a given user.
+More information about usage can be found in the project wiki: http://wiki.github.com/wvanbergen/scoped_search/usage
 
-  class Project < ActiveRecord::Base
-    searchable_on :name, :description
-    named_scope :accessible_by, lambda { |user| ... }
-  end
+== Query language
+
+The search query language is simple, but supports several constructs to support more complex queries:
+
+words::         require very word to be present, e.g.: <tt>some search keywords</tt>
+
+phrases::       use quotes for multi-word phrases, e.g. <tt>"police car"</tt>
+
+negation::      look for "everything but", e.g. <tt>police -uniform</tt>, <tt>-"police car"</tt>, 
+                <tt>police NOT car</tt>
+
+logical keywords:: make logical constructs using AND, OR, &&, ||, &, | operators, e.g.
+                   <tt>uniform OR car</tt>, <tt>scoped && search</tt>
+
+parentheses:: to structure logic e.g. <tt>"police AND (uniform OR car)"</tt>
+
+comparison operators:: to search in numerical or temporal fields, e.g.
+                       <tt>> 22</tt>, <tt>< 2009-01-01</tt>
+
+explicit fields::  search only in the given field. e.g. <tt>username = root</tt>,
+                   <tt>created_at > 2009-01-01</tt>
+
+NULL checks::   using the <tt>set?</tt> and <tt>null?</tt> operator with a field name, e.g.
+                <tt>null? graduated_at</tt>, <tt>set? parent_id</tt>
+
+A complex query example to look for Ruby on Rails programmers without cobol experience, over 18 years old,
+with a recently updated record and a non-lame nickname:
+
+  ("Ruby" OR "Rails") -cobol, age >= 18, updated_at > 2009-01-01 && nickname !~ l33t
 
-  # using chained named_scopes and will_paginate
-  Project.accessible_by(current_user).search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
+For more info, see the the project wiki: http://wiki.github.com/wvanbergen/scoped_search/query-language
 
 == Additional resources
 

data/Rakefile

@@ -1,5 +1,3 @@
 Dir['tasks/*.rake'].each { |file| load(file) }
  
-desc 'Default: run unit tests for only sqlite.' 
-task :default => [:test]
-
+task :default => [:spec]

data/lib/scoped_search.rb

@@ -1,108 +1,58 @@
 module ScopedSearch
-  
+      
   module ClassMethods
     
-    def self.extended(base) # :nodoc:
-      require 'scoped_search/reg_tokens'
-      require 'scoped_search/query_language_parser'
-      require 'scoped_search/query_conditions_builder'
+    # Export the scoped_search method fo defining the search options.
+    # This method will create a definition instance for the class if it does not yet exist,
+    # and use the object as block argument and retun value.
+    def scoped_search(*definitions)
+      @scoped_search ||= ScopedSearch::Definition.new(self)
+      definitions.each do |definition|
+        if definition[:on].kind_of?(Array)
+          definition[:on].each { |field| @scoped_search.define(definition.merge(:on => field)) }
+        else
+          @scoped_search.define(definition)
+        end
+      end
+      return @scoped_search
     end
+
+  end
   
-    # Creates a named scope in the class it was called upon.
-    #
-    # fields:: The fields to search on.
+  module BackwardsCompatibility
+    # Defines fields to search on using a syntax compatible with scoped_search 1.2
     def searchable_on(*fields)
-      # Make sure that the table to be searched actually exists
-      if self.table_exists?
-        
-        # Get a collection of fields to be searched on.
-        if fields.first.class.to_s == 'Hash'
-          if fields.first.has_key?(:only)
-            # only search on these fields.
-            fields = fields.first[:only]
-          elsif fields.first.has_key?(:except)
-            # Get all the fields and remove any that are in the -except- list.
-            fields = self.column_names.collect { |column| fields.first[:except].include?(column.to_sym) ? nil : column.to_sym }.compact
-          end
+      
+      options = fields.last.kind_of?(Hash) ? fields.pop : {}
+      # TODO: handle options?
+      
+      fields.each do |field| 
+        if relation = self.reflections.keys.detect { |relation| field.to_s =~ Regexp.new("^#{relation}_(\\w+)$") }
+          scoped_search(:in => relation, :on => $1.to_sym) 
+        else
+          scoped_search(:on => field)
         end
-        
-        # Get an array of associate modules.
-        assoc_models = self.reflections.collect { |key,value| key }
-        
-        # Subtract out the fields to be searched on that are part of *this* model.
-        # Any thing left will be associate module fields to be searched on.
-        assoc_fields = fields - self.column_names.collect { |column| column.to_sym }
-        
-        # Subtraced out the associated fields from the fields so that you are only left
-        # with fields in *this* model.
-        fields -= assoc_fields
-        
-        # Loop through each of the associate models and group accordingly each
-        # associate model field to search.  Assuming the following relations:
-        # has_many :clients
-        # has_many :notes,
-        # belongs_to :user_type 
-        # assoc_groupings will look like
-        # assoc_groupings = {:clients => [:first_name, :last_name],
-        #                    :notes => [:descr],
-        #                    :user_type => [:identifier]}
-        assoc_groupings = {}
-        assoc_models.each do |assoc_model|
-          assoc_groupings[assoc_model] = []
-        	assoc_fields.each do |assoc_field|
-        	  unless assoc_field.to_s.match(/^#{assoc_model.to_s}_/).nil?
-              assoc_groupings[assoc_model] << assoc_field.to_s.sub(/^#{assoc_model.to_s}_/, '').to_sym 
-            end
-          end
-        end
-    
-        # If a grouping does not contain any fields to be searched on then remove it.
-        assoc_groupings = assoc_groupings.delete_if {|group, field_group| field_group.empty?}
-        
-        # Set the appropriate class attributes. 
-        self.cattr_accessor :scoped_search_fields, :scoped_search_assoc_groupings
-        self.scoped_search_fields = fields
-        self.scoped_search_assoc_groupings = assoc_groupings
-        self.named_scope :search_for, lambda { |keywords| self.build_scoped_search_conditions(keywords) }
       end
-    end
+    end    
+  end
   
-    # Build a hash that is used for the named_scope search_for.
-    # This function will split the search_string into keywords, and search for all the keywords
-    # in the fields that were provided to searchable_on.
-    #
-    # search_string:: The search string to parse.
-    def build_scoped_search_conditions(search_string)    
-      if search_string.nil? || search_string.strip.blank?
-        return {:conditions => nil}
-      else        
-        query_fields = {}
-        self.scoped_search_fields.each do |field| 
-          field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
-          query_fields[field_name] = self.columns_hash[field.to_s].type
-        end
-        
-        assoc_model_indx = 0
-        assoc_fields_indx = 1
-        assoc_models_to_include = []
-        self.scoped_search_assoc_groupings.each do |group|  
-          assoc_models_to_include << group[assoc_model_indx]
-          group[assoc_fields_indx].each do |group_field|
-            field_name = connection.quote_table_name(group[assoc_model_indx].to_s.pluralize) + "." + connection.quote_column_name(group_field)
-            query_fields[field_name] = self.reflections[group[assoc_model_indx]].klass.columns_hash[group_field.to_s].type
-          end
-        end
-        
-        search_conditions = QueryLanguageParser.parse(search_string) 
-        conditions = QueryConditionsBuilder.build_query(search_conditions, query_fields) 
- 
-        retVal = {:conditions => conditions}
-        retVal[:include] = assoc_models_to_include unless assoc_models_to_include.empty?
+  class Exception < StandardError
+  end
 
-        return retVal
-      end
-    end
+  class DefinitionError < ScopedSearch::Exception
   end
+  
+  class QueryNotSupported < ScopedSearch::Exception
+  end
+  
 end
 
-ActiveRecord::Base.send(:extend, ScopedSearch::ClassMethods)
+# Load all lib files
+require 'scoped_search/definition'
+require 'scoped_search/adapters'
+require 'scoped_search/query_language'
+require 'scoped_search/query_builder'
+
+# Import the search_on method in the ActiveReocrd::Base class
+ActiveRecord::Base.send(:extend, ScopedSearch::ClassMethods)
+ActiveRecord::Base.send(:extend, ScopedSearch::BackwardsCompatibility)

data/lib/scoped_search/adapters.rb

@@ -0,0 +1,41 @@
+module ScopedSearch
+  module Adapter
+
+    def self.setup(connection)
+      adapter = connection.class.name.split('::').last
+      const_get(adapter).setup(connection) if const_defined?(adapter)
+    end
+
+    module MysqlAdapter
+
+      def self.setup(connection)
+        ScopedSearch::Definition::Field.send :include, FieldInstanceMethods
+      end
+
+      module FieldInstanceMethods
+        
+        # Monkey patch Field#to_sql method to ensure that comparisons using :eq / :ne
+        # are case sensitive by adding a BINARY operator in front of the field name.
+        def to_sql(operator = nil, &block)
+          
+          # Normal implementation
+          yield(:include, relation) if relation
+          field_name = definition.klass.connection.quote_table_name(klass.table_name) + "." + 
+              definition.klass.connection.quote_column_name(field)
+
+          # Add BINARY operator if the field is textual and = or <> is used.
+          field_name = "BINARY #{field_name}" if textual? && [:ne, :eq].include?(operator)
+          return field_name
+        end
+      end
+      
+    end
+    
+    module PostgreSQLAdapter      
+      def self.setup(connection)
+        ScopedSearch::QueryBuilder::SQL_OPERATORS[:like] = 'ILIKE'
+        ScopedSearch::QueryBuilder::SQL_OPERATORS[:unlike] = 'NOT ILIKE'
+      end
+    end
+  end
+end

data/lib/scoped_search/definition.rb

@@ -0,0 +1,122 @@
+module ScopedSearch
+  
+  class Definition
+    
+    class Field
+      
+      attr_reader :definition, :field, :only_explicit, :relation
+      
+      def klass
+        if relation
+          definition.klass.reflections[relation].klass
+        else
+          definition.klass
+        end
+      end
+      
+      # Find the relevant column definition in the AR class
+      def column
+        klass.columns_hash[field.to_s]
+      end
+      
+      def type
+        column.type
+      end
+      
+      def datetime?
+        [:datetime, :time, :timestamp].include?(type)
+      end
+      
+      def date?
+        type == :date
+      end
+      
+      def temporal?
+        datetime? || date?
+      end
+      
+      def numerical?
+        [:integer, :double, :float, :decimal].include?(type)
+      end
+      
+      def textual?
+        [:string, :text].include?(type)
+      end
+      
+      # Returns the default search operator for this field.
+      def default_operator
+        @default_operator ||= case type
+          when :string, :text then :like
+          else :eq
+        end
+      end
+
+      def initialize(definition, options = {})
+        @definition = definition
+        case options
+        when Symbol, String
+          @field = field.to_sym
+        when Hash
+          @field = options.delete(:on)
+
+          # Set attributes from options hash
+          @relation         = options[:in]
+          @only_explicit    = !!options[:only_explicit]
+          @default_operator = options[:default_operator] if options.has_key?(:default_operator)
+        end
+        
+        # Store this field is the field array
+        definition.fields[@field] ||= self
+        definition.unique_fields   << self
+        
+        # Store definition for alias / aliases as well
+        definition.fields[options[:alias]] ||= self                    if options[:alias]
+        options[:aliases].each { |al| definition.fields[al] ||= self } if options[:aliases]        
+      end
+    end
+    
+    attr_reader :klass, :fields, :unique_fields
+    
+    def initialize(klass)
+      @klass         = klass
+      @fields        = {}
+      @unique_fields = []
+      
+      setup_adapter!        unless klass.connection.nil?
+      register_named_scope! unless klass.respond_to?(:search_for)
+    end
+    
+    NUMBER_REGXP    = /^\-?\d+(\.\d+)?$/
+    
+    def default_fields_for(value, operator = nil)
+      # Use the value to detect
+      column_types  = []
+      column_types += [:string, :text]                      if [nil, :like, :unlike, :ne, :eq].include?(operator)
+      column_types += [:integer, :double, :float, :decimal] if value =~ NUMBER_REGXP
+      column_types += [:datetime, :date, :timestamp]        if ScopedSearch::QueryBuilder.parse_temporal(value)
+
+      default_fields.select { |field| column_types.include?(field.type) }
+    end
+    
+    def default_fields
+      unique_fields.reject { |field| field.only_explicit }
+    end
+    
+    def define(options)
+      Field.new(self, options)
+    end
+        
+    protected
+    
+    # Registers the search_for named scope within the class
+    def register_named_scope! # :nodoc
+      @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(args[1] || self, args[0]) })
+    end
+    
+    def setup_adapter!
+      ScopedSearch::Adapter.setup(@klass.connection)
+    end
+    
+  end
+  
+end

data/lib/scoped_search/query_builder.rb

@@ -0,0 +1,213 @@
+module ScopedSearch
+
+  class QueryBuilder
+    
+    attr_reader :ast, :definition
+    
+    # Creates a find parameter hash given a class, and query string.
+    def self.build_query(definition, query) 
+      # Return all record when an empty search string is given
+      if !query.kind_of?(String) || query.strip.blank?
+        return { :conditions => nil }
+      elsif query.kind_of?(ScopedSearch::QueryLanguage::AST::Node)
+        return self.new(definition, query).build_find_params
+      else
+        return self.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query)).build_find_params
+      end
+    end
+
+    # Initializes the instance by setting the relevant parameters
+    def initialize(definition, ast)
+      @definition, @ast = definition, ast
+    end
+    
+    # Actually builds the find parameters
+    def build_find_params
+      parameters = []
+      includes   = []
+      
+      # Build SQL WHERE clause using the AST
+      sql = @ast.to_sql(definition) do |notification, value|
+        
+        # Handle the notifications encountered during the SQL generation:
+        # Store the parameters, includes, etc so that they can be added to
+        # the find-hash later on.
+        case notification
+        when :parameter then parameters << value
+        when :include   then includes   << value
+        else raise ScopedSearch::QueryNotSupported, "Cannot handle #{notification.inspect}: #{value.inspect}"
+        end
+      end
+      
+      # Build hash for ActiveRecord::Base#find for the named scope
+      find_attributes = {}
+      find_attributes[:conditions] = [sql] + parameters unless sql.nil?
+      find_attributes[:include]    = includes.uniq      unless includes.empty?
+      # p find_attributes # Uncomment for debugging
+      return find_attributes
+    end
+    
+    SQL_OPERATORS = { :eq =>'=', :ne => '<>',
+      :like => 'LIKE', :unlike => 'NOT LIKE',
+      :gt => '>', :lt =>'<', :lte => '<=', :gte => '>=' }
+    
+    # Return the SQL operator to use
+    def self.sql_operator(operator, field)
+      SQL_OPERATORS[operator]
+    end
+
+    # Perform a comparison between a field and a Date(Time) value.
+    # Makes sure the date is valid and adjust the comparison in
+    # some cases to return more logical results
+    def self.datetime_test(field, operator, value, &block)
+      
+      # Parse the value as a date/time and ignore invalid timestamps
+      timestamp = parse_temporal(value)
+      return nil unless timestamp 
+      timestamp = Date.parse(timestamp.strftime('%Y-%m-%d')) if field.date?      
+      
+      # Check for the case that a date-only value is given as search keyword,
+      # but the field is of datetime type. Change the comparison to return
+      # more logical results.
+      if timestamp.day_fraction == 0 && field.datetime?
+        
+        if [:eq, :ne].include?(operator)
+          # Instead of looking for an exact (non-)match, look for dates that
+          # fall inside/outside the range of timestamps of that day.
+          yield(:parameter, timestamp)
+          yield(:parameter, timestamp + 1)
+          negate    = (operator == :ne) ? 'NOT' : ''
+          field_sql = field.to_sql(operator, &block)
+          return "#{negate}(#{field_sql} >= ? AND #{field_sql} < ?)"
+          
+        elsif operator == :gt
+          # Make sure timestamps on the given date are not included in the results
+          # by moving the date to the next day.
+          timestamp += 1
+          operator = :gte
+          
+        elsif operator == :lte
+          # Make sure the timestamps of the given date are included by moving the 
+          # date to the next date.
+          timestamp += 1
+          operator = :lt
+        end
+      end
+    
+      # Yield the timestamp and return the SQL test
+      yield(:parameter, timestamp)
+      "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
+    end
+    
+    # Generates a simple SQL test expression, for a field and value using an operator.
+    def self.sql_test(field, operator, value, &block)
+      if [:like, :unlike].include?(operator) && value !~ /^\%/ && value !~ /\%$/
+        yield(:parameter, "%#{value}%")
+        return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
+      elsif field.temporal?
+        return datetime_test(field, operator, value, &block)
+      else
+        yield(:parameter, value)
+        return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
+      end
+    end
+    
+    # Try to parse a string as a datetime.
+    def self.parse_temporal(value)
+      DateTime.parse(value, true) rescue nil
+    end
+
+    module Field
+      
+      # Return an SQL representation for this field
+      def to_sql(operator = nil, &block)
+        yield(:include, relation) if relation
+        definition.klass.connection.quote_table_name(klass.table_name) + "." + 
+            definition.klass.connection.quote_column_name(field)
+      end
+    end
+
+    module AST
+      
+      # Defines the to_sql method for AST LeadNodes
+      module LeafNode
+        def to_sql(definition, &block)
+          # Search keywords found without context, just search on all the default fields
+          fragments = definition.default_fields_for(value).map do |field|
+            ScopedSearch::QueryBuilder.sql_test(field, field.default_operator, value, &block)
+          end
+          "(#{fragments.join(' OR ')})"
+        end
+      end
+      
+      # Defines the to_sql method for AST operator nodes
+      module OperatorNode
+            
+        # Returns a NOT(...)  SQL fragment that negates the current AST node's children  
+        def to_not_sql(definition, &block)
+          "(NOT(#{rhs.to_sql(definition, &block)}) OR #{rhs.to_sql(definition, &block)} IS NULL)"
+        end
+        
+        # Returns a IS (NOT) NULL SQL fragment
+        def to_null_sql(definition, &block)
+          field = definition.fields[rhs.value.to_sym]  
+          raise ScopedSearch::QueryNotSupported, "Field '#{rhs.value}' not recognized for searching!" unless field
+          
+          case operator
+            when :null    then "#{field.to_sql(&block)} IS NULL"
+            when :notnull then "#{field.to_sql(&block)} IS NOT NULL"
+          end
+        end
+        
+        # No explicit field name given, run the operator on all default fields
+        def to_default_fields_sql(definition, &block)
+          raise ScopedSearch::QueryNotSupported, "Value not a leaf node" unless rhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode)          
+          
+          # Search keywords found without context, just search on all the default fields
+          fragments = definition.default_fields_for(rhs.value, operator).map { |field|
+            ScopedSearch::QueryBuilder.sql_test(field, operator, rhs.value, &block) }.compact
+          fragments.empty? ? nil : "(#{fragments.join(' OR ')})"
+        end
+        
+        # Explicit field name given, run the operator on the specified field only
+        def to_single_field_sql(definition, &block)
+          raise ScopedSearch::QueryNotSupported, "Field name not a leaf node" unless lhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode)
+          raise ScopedSearch::QueryNotSupported, "Value not a leaf node"      unless rhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode)
+          
+          # Search only on the given field.
+          field = definition.fields[lhs.value.to_sym]
+          raise ScopedSearch::QueryNotSupported, "Field '#{lhs.value}' not recognized for searching!" unless field
+          ScopedSearch::QueryBuilder.sql_test(field, operator, rhs.value, &block)
+        end
+        
+        # Convert this AST node to an SQL fragment.
+        def to_sql(definition, &block)
+          if operator == :not && children.length == 1
+            to_not_sql(definition, &block)
+          elsif [:null, :notnull].include?(operator)
+            to_null_sql(definition, &block)
+          elsif children.length == 1
+            to_default_fields_sql(definition, &block)            
+          elsif children.length == 2
+            to_single_field_sql(definition, &block)
+          else
+            raise ScopedSearch::QueryNotSupported, "Don't know how to handle this operator node: #{operator.inspect} with #{children.inspect}!"
+          end
+        end 
+      end
+      
+      # Defines the to_sql method for AST AND/OR operators
+      module LogicalOperatorNode
+        def to_sql(definition, &block)
+          fragments = children.map { |c| c.to_sql(definition, &block) }.compact
+          fragments.empty? ? nil : "(#{fragments.join(" #{operator.to_s.upcase} ")})"
+        end 
+      end      
+    end
+  end
+
+  Definition::Field.send(:include, QueryBuilder::Field)
+  QueryLanguage::AST::LeafNode.send(:include, QueryBuilder::AST::LeafNode)
+  QueryLanguage::AST::OperatorNode.send(:include, QueryBuilder::AST::OperatorNode)
+  QueryLanguage::AST::LogicalOperatorNode.send(:include, QueryBuilder::AST::LogicalOperatorNode)  
+end