scoped_search 2.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+scoped_search-*.gem
+/tmp
+/doc
+/pkg
+/coverage
+/classes
+/files

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Willem van Bergen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,107 @@
+= 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 <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.
+
+Scoped search is great if you want to offer a simple search box to your users
+and build a query based on the search string they enter. If you want to build a
+more complex search form with multiple fields, searchlogic (see
+http://github.com/binarylogic/searchlogic) may be a good choice for you.
+
+
+== Installing
+
+The recommended method to enable scoped_search in your project is adding the scoped_search gem to your environment. Add the following code to your Rails configuration in <tt>config/environment.rb</tt>:
+
+  Rails::Initializer.run do |config|
+    ...
+    config.gem 'wvanbergen-scoped_search', :lib => 'scoped_search',
+                   :source => 'http://gems.github.com/'
+  end
+
+Run <tt>sudo rake gems:install</tt> to install the gem.
+
+Alternatively, install scoped_search as a Rails plugin:
+
+  script/plugin install git://github.com/wvanbergen/scoped_search.git
+
+== Usage
+
+Scoped search requires you to define the fields you want to search in:
+
+  class User < ActiveRecord::Base
+    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('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:
+
+  class Project < ActiveRecord::Base
+    searchable_on :name, :description
+    named_scope :public, :conditions => {:public => true }
+  end
+
+  # using chained named_scopes and will_paginate in your controller
+  Project.public.search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
+
+More information about usage can be found in the project wiki:
+http://wiki.github.com/wvanbergen/scoped_search/usage
+
+== Query language
+
+The search query language is simple, but supports several constructs to support
+more complex queries:
+
+words::         require every 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
+
+For more info, see the the project wiki: http://wiki.github.com/wvanbergen/scoped_search/query-language
+
+== Additional resources
+
+* Source code: http://github.com/wvanbergen/scoped_search/tree/master
+* Project wiki: http://wiki.github.com/wvanbergen/scoped_search
+* RDoc documentation: http://wvanbergen.github.com/scoped_search
+* wvanbergen's blog posts: http://techblog.floorplanner.com/tag/scoped_search
+
+== License
+
+This plugin is released under the MIT license. Please contact weshays
+(http://github.com/weshays) or wvanbergen (http://github.com/wvanbergen) for any
+questions.

data/Rakefile

@@ -0,0 +1,4 @@
+Dir['tasks/*.rake'].each { |file| load(file) }
+
+GithubGem::RakeTasks.new(:gem)
+task :default => [:spec]

data/init.rb

@@ -0,0 +1 @@
+require 'scoped_search'

data/lib/scoped_search.rb

@@ -0,0 +1,91 @@
+# ScopedSearch is the base module for the scoped_search plugin. This file
+# defines some modules and exception classes, loads the necessary files, and
+# installs itself in ActiveRecord.
+#
+# The ScopedSearch module defines two modules that can be mixed into
+# ActiveRecord::Base as class methods. <tt>ScopedSearch::ClassMethods</tt>
+# will register the scoped_search class function, which can be used to define
+# the search fields. <tt>ScopedSearch::BackwardsCompatibility</tt> will
+# register the <tt>searchable_on</tt> method for backwards compatibility with
+# previous scoped_search versions (1.x).
+module ScopedSearch
+
+  # The current scoped_search version. Do not change thisvalue by hand,
+  # because it will be updated automatically by the gem release script.
+  VERSION = "2.0.1"
+
+  # The ClassMethods module will be included into the ActiveRecord::Base class
+  # to add the <tt>ActiveRecord::Base.scoped_search</tt> method and the
+  # <tt>ActiveRecord::Base.search_for</tt> named scope.
+  module ClassMethods
+
+    # 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
+
+  # The <tt>BackwardsCompatibility</tt> module can be included into
+  # <tt>ActiveRecord::Base</tt> to provide the <tt>searchable_on</tt> search
+  # field definition syntax that is compatible with scoped_seach 1.x
+  #
+  # Currently, it is included into <tt>ActiveRecord::Base</tt> by default, but
+  # this may change in the future. So, please uodate to the newer syntax as
+  # soon as possible.
+  module BackwardsCompatibility
+
+    # Defines fields to search on using a syntax compatible with scoped_search 1.x
+    def searchable_on(*fields)
+
+      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
+      end
+    end
+  end
+
+  # The default scoped_search exception class.
+  class Exception < StandardError
+  end
+
+  # The default exception class that is raised when there is something
+  # wrong with the scoped_search definition call.
+  #
+  # You usually do not want to catch this exception, but fix the faulty
+  # scoped_search method call.
+  class DefinitionError < ScopedSearch::Exception
+  end
+
+  # The default exception class that is raised when there is a problem
+  # with parsing or interpreting a search query.
+  #
+  # You may want to catch this exception and handle this gracefully.
+  class QueryNotSupported < ScopedSearch::Exception
+  end
+
+end
+
+# Load all lib files
+require 'scoped_search/definition'
+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/definition.rb

@@ -0,0 +1,145 @@
+module ScopedSearch
+
+  # The ScopedSearch definition class defines on what fields should be search
+  # in the model in what cases
+  #
+  # A definition can be created by calling the <tt>scoped_search</tt> method on
+  # an ActiveRecord-based class, so you should not create an instance of this
+  # class yourself.
+  class Definition
+
+    # The Field class specifies a field of a model that is available for searching,
+    # in what cases this field should be searched and its default search behavior.
+    #
+    # Instances of this class are created when calling scoped_search in your model
+    # class, so you should not create instances of this class yourself.
+    class Field
+
+      attr_reader :definition, :field, :only_explicit, :relation
+
+      # The ActiveRecord-based class that belongs to this field.
+      def klass
+        if relation
+          definition.klass.reflections[relation].klass
+        else
+          definition.klass
+        end
+      end
+
+      # Returns the ActiveRecord column definition that corresponds to this field.
+      def column
+        klass.columns_hash[field.to_s]
+      end
+
+      # Returns the column type of this field.
+      def type
+        column.type
+      end
+
+      # Returns true if this field is a datetime-like column
+      def datetime?
+        [:datetime, :time, :timestamp].include?(type)
+      end
+
+      # Returns true if this field is a date-like column
+      def date?
+        type == :date
+      end
+
+      # Returns true if this field is a date or datetime-like column.
+      def temporal?
+        datetime? || date?
+      end
+
+      # Returns true if this field is numerical.
+      # Numerical means either integer, floating point or fixed point.
+      def numerical?
+        [:integer, :double, :float, :decimal].include?(type)
+      end
+
+      # Returns true if this is a textual column.
+      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
+
+      # Initializes a Field instance given the definition passed to the
+      # scoped_search call on the ActiveRecord-based model class.
+      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
+
+    # Initializes a ScopedSearch definition instance.
+    # This method will also setup a database adapter and create the :search_for
+    # named scope if it does not yet exist.
+    def initialize(klass)
+      @klass         = klass
+      @fields        = {}
+      @unique_fields = []
+
+      register_named_scope! unless klass.respond_to?(:search_for)
+    end
+
+    NUMERICAL_REGXP = /^\-?\d+(\.\d+)?$/
+
+    # Returns a list of appropriate fields to search in given a search keyword and operator.
+    def default_fields_for(value, operator = nil)
+
+      column_types  = []
+      column_types += [:string, :text]                      if [nil, :like, :unlike, :ne, :eq].include?(operator)
+      column_types += [:integer, :double, :float, :decimal] if value =~ NUMERICAL_REGXP
+      column_types += [:datetime, :date, :timestamp]        if (DateTime.parse(value) rescue nil)
+
+      default_fields.select { |field| column_types.include?(field.type) }
+    end
+
+    # Returns a list of fields that should be searched on by default.
+    #
+    # Every field will show up in this method's result, except for fields for
+    # which the only_explicit parameter is set to true.
+    def default_fields
+      unique_fields.reject { |field| field.only_explicit }
+    end
+
+    # Defines a new search field for this search definition.
+    def define(options)
+      Field.new(self, options)
+    end
+
+    protected
+
+    # Registers the search_for named scope within the class that is used for searching.
+    def register_named_scope! # :nodoc
+      @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(args[1] || self, args[0]) })
+    end
+  end
+end

data/lib/scoped_search/query_builder.rb

@@ -0,0 +1,296 @@
+module ScopedSearch
+
+  # The QueryBuilder class builds an SQL query based on aquery string that is
+  # provided to the search_for named scope. It uses a SearchDefinition instance
+  # to shape the query.
+  class QueryBuilder
+
+    attr_reader :ast, :definition
+
+    # Creates a find parameter hash that can be passed to ActiveRecord::Base#find,
+    # given a search definition and query string. This method is called from the
+    # search_for named scope.
+    #
+    # This method will parse the query string and build an SQL query using the search
+    # query. It will return an ampty hash if the search query is empty, in which case
+    # the scope call will simply return all records.
+    def self.build_query(definition, query)
+      query_builder_class = self.class_for(definition)
+      if query.kind_of?(ScopedSearch::QueryLanguage::AST::Node)
+        return query_builder_class.new(definition, query).build_find_params
+      elsif query.kind_of?(String)
+        return query_builder_class.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query)).build_find_params
+      elsif query.nil?
+        return { }
+      else
+        raise "Unsupported query object: #{query.inspect}!"
+      end
+    end
+    
+    # Loads the QueryBuilder class for the connection of the given definition.
+    # If no specific adapter is found, the default QueryBuilder class is returned.
+    def self.class_for(definition)
+      self.const_get(definition.klass.connection.class.name.split('::').last)
+    rescue
+      self
+    end
+
+    # Initializes the instance by setting the relevant parameters
+    def initialize(definition, ast)
+      @definition, @ast = definition, ast
+    end
+
+    # Actually builds the find parameters hash that should be used in the search_for
+    # named scope.
+    def build_find_params
+      parameters = []
+      includes   = []
+
+      # Build SQL WHERE clause using the AST
+      sql = @ast.to_sql(self, 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?
+      find_attributes # Uncomment for debugging
+      return find_attributes
+    end
+
+    # A hash that maps the operators of the query language with the corresponding SQL operator.
+    SQL_OPERATORS = { :eq =>'=',  :ne => '<>', :like => 'LIKE', :unlike => 'NOT LIKE',
+                      :gt => '>', :lt =>'<',   :lte => '<=',    :gte => '>=' }
+    
+    # Return the SQL operator to use given an operator symbol and field definition.
+    #
+    # By default, it will simply look up the correct SQL operator in the SQL_OPERATORS
+    # hash, but this can be overrided by a database adapter.
+    def sql_operator(operator, field)
+      SQL_OPERATORS[operator]
+    end
+
+    # Perform a comparison between a field and a Date(Time) value.
+    #
+    # This function makes sure the date is valid and adjust the comparison in
+    # some cases to return more logical results.
+    #
+    # This function needs a block that can be used to pass other information about the query
+    # (parameters that should be escaped, includes) to the query builder.
+    #
+    # <tt>field</tt>:: The field to test.
+    # <tt>operator</tt>:: The operator used for comparison.
+    # <tt>value</tt>:: The value to compare the field with.
+    def datetime_test(field, operator, value, &block) # :yields: finder_option_type, value
+
+      # 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)} #{sql_operator(operator, field)} ?"
+    end
+
+    # Generates a simple SQL test expression, for a field and value using an operator.
+    #
+    # This function needs a block that can be used to pass other information about the query
+    # (parameters that should be escaped, includes) to the query builder.
+    #
+    # <tt>field</tt>:: The field to test.
+    # <tt>operator</tt>:: The operator used for comparison.
+    # <tt>value</tt>:: The value to compare the field with.
+    def sql_test(field, operator, value, &block) # :yields: finder_option_type, value
+      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 parse_temporal(value)
+      DateTime.parse(value, true) rescue nil
+    end
+
+    # This module gets included into the Field class to add SQL generation.
+    module Field
+
+      # Return an SQL representation for this field. Also make sure that
+      # the relation which includes the search field is included in the
+      # SQL query.
+      #
+      # This function may yield an :include that should be used in the
+      # ActiveRecord::Base#find call, to make sure that the field is avalable
+      # for the SQL query.
+      def to_sql(builder, operator = nil, &block) # :yields: finder_option_type, value
+        yield(:include, relation) if relation
+        definition.klass.connection.quote_table_name(klass.table_name) + "." +
+            definition.klass.connection.quote_column_name(field)
+      end
+    end
+
+    # This module contains modules for every AST::Node class to add SQL generation.
+    module AST
+
+      # Defines the to_sql method for AST LeadNodes
+      module LeafNode
+        def to_sql(builder, definition, &block)
+          # Search keywords found without context, just search on all the default fields
+          fragments = definition.default_fields_for(value).map do |field|
+            builder.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(builder, definition, &block)
+          "(NOT(#{rhs.to_sql(builder, definition, &block)}) OR #{rhs.to_sql(builder, definition, &block)} IS NULL)"
+        end
+
+        # Returns an IS (NOT) NULL SQL fragment
+        def to_null_sql(builder, 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(builder, &block)} IS NULL"
+            when :notnull then "#{field.to_sql(builder, &block)} IS NOT NULL"
+          end
+        end
+
+        # No explicit field name given, run the operator on all default fields
+        def to_default_fields_sql(builder, 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|
+                          builder.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(builder, 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
+          builder.sql_test(field, operator, rhs.value, &block)
+        end
+
+        # Convert this AST node to an SQL fragment.
+        def to_sql(builder, definition, &block)
+          if operator == :not && children.length == 1
+            to_not_sql(builder, definition, &block)
+          elsif [:null, :notnull].include?(operator)
+            to_null_sql(builder, definition, &block)
+          elsif children.length == 1
+            to_default_fields_sql(builder, definition, &block)
+          elsif children.length == 2
+            to_single_field_sql(builder, 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(builder, definition, &block)
+          fragments = children.map { |c| c.to_sql(builder, definition, &block) }.compact
+          fragments.empty? ? nil : "(#{fragments.join(" #{operator.to_s.upcase} ")})"
+        end
+      end
+    end
+
+    # The MysqlAdapter makes sure that case sensitive comparisons are used
+    # when using the (not) equals operator, regardless of the field's
+    # collation setting.
+    class MysqlAdapter < ScopedSearch::QueryBuilder
+      
+      # Patches the default <tt>sql_operator</tt> method to add
+      # <tt>BINARY</tt> after the equals and not equals operator to force
+      # case-sensitive comparisons.
+      def sql_operator(operator, field)
+        if [:ne, :eq].include?(operator) && field.textual?
+          "#{SQL_OPERATORS[operator]} BINARY"
+        else
+          super(operator, field)
+        end
+      end
+    end
+
+    # The PostgreSQLAdapter make sure that searches are case sensitive when
+    # using the like/unlike operators, by using the PostrgeSQL-specific
+    # <tt>ILIKE operator</tt> instead of <tt>LIKE</tt>.
+    class PostgreSQLAdapter < ScopedSearch::QueryBuilder
+      
+      # Switches out the default LIKE operator for ILIKE in the default
+      # <tt>sql_operator</tt> method.
+      def sql_operator(operator, field)
+        case operator
+        when :like   then 'ILIKE'
+        when :unlike then 'NOT ILIKE'
+        else super(operator, field)
+        end
+      end
+    end
+  end
+
+  # Include the modules into the corresponding classes
+  # to add SQL generation capabilities to them.
+
+  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