sequel 2.9.0 → 2.10.0

data/lib/sequel_core/adapters/openbase.rb

@@ -51,7 +51,7 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |result|
           begin
-            @columns = result.column_infos.map {|c| c.name.to_sym}
+            @columns = result.column_infos.map{|c| output_identifier(c.name)}
             result.each do |r|
               row = {}
               r.each_with_index {|v, i| row[@columns[i]] = v}

data/lib/sequel_core/adapters/oracle.rb

@@ -90,10 +90,10 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
           begin
-            @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
+            @columns = cursor.get_col_names.map{|c| output_identifier(c)}
             while r = cursor.fetch
               row = {}
-              r.each_with_index {|v, i| row[columns[i]] = v unless columns[i] == :raw_rnum_}
+              r.each_with_index {|v, i| row[@columns[i]] = v unless @columns[i] == :raw_rnum_}
               yield row
             end
           ensure

data/lib/sequel_core/adapters/postgres.rb

@@ -15,7 +15,7 @@ rescue LoadError => e
           # If there is no escape_string instead method, but there is an
           # escape class method, use that instead.
           def escape_string(str)
-            self.class.escape(str)
+            Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
           end
         else
           # Raise an error if no valid string escaping method can be found.
@@ -103,19 +103,12 @@ module Sequel
     }
     
     @use_iso_date_format = true
-    @client_min_messages = :warning
 
     # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
     # the date in a known format that Sequel can parse faster.  This can be turned off
     # if you require a date style other than ISO.
     metaattr_accessor :use_iso_date_format
     
-    # By default, Sequel sets the minimum level of log messages sent to the client
-    # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
-    # of mostly useless messages when running migrations, such as a couple of lines
-    # for every serial primary key field.
-    metaattr_accessor :client_min_messages
-    
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
@@ -132,11 +125,6 @@ module Sequel
           @db.log_info(sql)
           execute(sql)
         end
-        if cmm = Postgres.client_min_messages
-          sql = "SET client_min_messages = '#{cmm.to_s.upcase}'"
-          @db.log_info(sql)
-          execute(sql)
-        end
       end
 
       # Execute the given SQL with this connection.  If a block is given,
@@ -324,7 +312,7 @@ module Sequel
         cols = []
         execute(sql) do |res|
           res.nfields.times do |fieldnum|
-            cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], res.fname(fieldnum).to_sym]
+            cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
           end
           @columns = cols.map{|c| c.at(2)}
           res.ntuples.times do |recnum|
@@ -337,6 +325,20 @@ module Sequel
           end
         end
       end
+
+      # Literalize strings and blobs using code from the native adapter.
+      def literal(v)
+        case v
+        when LiteralString
+          v
+        when SQL::Blob
+          db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+        when String
+          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        else
+          super
+        end
+      end
       
       if SEQUEL_POSTGRES_USES_PG
         

data/lib/sequel_core/adapters/shared/mysql.rb

@@ -6,6 +6,9 @@ module Sequel
     end
   end
   module MySQL
+    # Set the default options used for CREATE TABLE
+    metaattr_accessor :default_charset, :default_collate, :default_engine
+
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
@@ -13,7 +16,8 @@ module Sequel
       NOT_NULL = Sequel::Schema::SQL::NOT_NULL
       NULL = Sequel::Schema::SQL::NULL
       PRIMARY_KEY = Sequel::Schema::SQL::PRIMARY_KEY
-      TYPES = Sequel::Schema::SQL::TYPES
+      TYPES = Sequel::Schema::SQL::TYPES.merge(DateTime=>'datetime', \
+        TrueClass=>'tinyint', FalseClass=>'tinyint')
       UNIQUE = Sequel::Schema::SQL::UNIQUE
       UNSIGNED = Sequel::Schema::SQL::UNSIGNED
       
@@ -50,6 +54,16 @@ module Sequel
         "#{", FOREIGN KEY (#{quote_identifier(column[:name])})" unless column[:type] == :check}#{super(column)}"
       end
       
+      # Use MySQL specific syntax for engine type and character encoding
+      def create_table_sql_list(name, columns, indexes = nil, options = {})
+        options[:engine] = Sequel::MySQL.default_engine unless options.include?(:engine)
+        options[:charset] = Sequel::MySQL.default_charset unless options.include?(:charset)
+        options[:collate] = Sequel::MySQL.default_collate unless options.include?(:collate)
+        sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})#{" ENGINE=#{options[:engine]}" if options[:engine]}#{" DEFAULT CHARSET=#{options[:charset]}" if options[:charset]}#{" DEFAULT COLLATE=#{options[:collate]}" if options[:collate]}"]
+        sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
+        sql
+      end
+
       # Handle MySQL specific index SQL syntax
       def index_definition_sql(table_name, index)
         index_name = quote_identifier(index[:name] || default_index_name(table_name, index[:columns]))
@@ -67,13 +81,19 @@ module Sequel
       
       # Get version of MySQL server, used for determined capabilities.
       def server_version
-        m = /(\d+)\.(\d+)\.(\d+)/.match(get(:version[]))
+        m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
         @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
       end
       
       # Return an array of symbols specifying table names in the current database.
-      def tables(server=nil)
-        self['SHOW TABLES'].server(server).map{|r| r.values.first.to_sym}
+      #
+      # Options:
+      # * :server - Set the server to use
+      def tables(opts={})
+        ds = self['SHOW TABLES'].server(opts[:server])
+        ds.identifier_output_method = nil
+        ds2 = dataset
+        ds.map{|r| ds2.send(:output_identifier, r.values.first)}
       end
       
       # Changes the database in use by issuing a USE statement.  I would be
@@ -87,14 +107,22 @@ module Sequel
       
       private
       
-      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers by default.
-      def upcase_identifiers_default
-        false
+      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
+      def identifier_input_method_default
+        nil
+      end
+      
+      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
+      def identifier_output_method_default
+        nil
       end
 
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        self["DESCRIBE ?", SQL::Identifier.new(table_name)].map do |row|
+        ds = self["DESCRIBE ?", SQL::Identifier.new(table_name)]
+        ds.identifier_output_method = nil
+        ds2 = dataset
+        ds.map do |row|
           row.delete(:Extra)
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
@@ -102,9 +130,14 @@ module Sequel
           row[:default] = nil if row[:default].blank?
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
-          [row.delete(:Field).to_sym, row]
+          [ds2.send(:output_identifier, row.delete(:Field)), row]
         end
       end
+
+      # Override the standard type conversions with MySQL specific ones
+      def type_literal_base(column)
+        TYPES[column[:type]]
+      end
     end
   
     # Dataset methods shared by datasets that use MySQL databases.
@@ -198,6 +231,8 @@ module Sequel
           BOOL_TRUE
         when false
           BOOL_FALSE
+        when DateTime, Time
+          v.strftime("'%Y-%m-%d %H:%M:%S'")
         else
           super
         end

data/lib/sequel_core/adapters/shared/oracle.rb

@@ -1,14 +1,13 @@
 module Sequel
   module Oracle
     module DatabaseMethods
-      def tables
-        from(:tab).select(:tname).filter(:tabtype => 'TABLE').map do |r|
-          r[:tname].downcase.to_sym
-        end
+      def tables(opts={})
+        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE')
+        ds.map{|r| ds.send(:output_identifier, r[:tname])}
       end
 
       def table_exists?(name)
-        from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
+        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
       end
     end
     

data/lib/sequel_core/adapters/shared/postgres.rb

@@ -32,7 +32,14 @@ module Sequel
     # uses NativeExceptions, the native adapter uses PGError.
     CONVERTED_EXCEPTIONS = []
     
+    @client_min_messages = :warning
     @force_standard_strings = true
+    
+    # By default, Sequel sets the minimum level of log messages sent to the client
+    # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
+    # of mostly useless messages when running migrations, such as a couple of lines
+    # for every serial primary key field.
+    metaattr_accessor :client_min_messages
 
     # By default, Sequel forces the use of standard strings, so that
     # '\\' is interpreted as \\ and not \.  While PostgreSQL defaults
@@ -46,7 +53,7 @@ module Sequel
       attr_writer :db
       
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
-      SELECT_CUSTOM_SEQUENCE = <<-end_sql
+      SELECT_CUSTOM_SEQUENCE = proc do |schema, table| <<-end_sql
         SELECT '"' || name.nspname || '"."' || CASE  
             WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN  
               substr(split_part(def.adsrc, '''', 2),  
@@ -60,10 +67,11 @@ module Sequel
         JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1])
         WHERE cons.contype = 'p'
           AND def.adsrc ~* 'nextval'
-          AND name.nspname = '%s'
-          AND t.relname = '%s'
+          #{"AND name.nspname = '#{schema}'" if schema}
+          AND t.relname = '#{table}'
       end_sql
-      SELECT_PK = <<-end_sql
+      end
+      SELECT_PK = proc do |schema, table| <<-end_sql
         SELECT pg_attribute.attname
         FROM pg_class, pg_attribute, pg_index, pg_namespace
         WHERE pg_class.oid = pg_attribute.attrelid
@@ -71,10 +79,11 @@ module Sequel
           AND pg_class.oid = pg_index.indrelid
           AND pg_index.indkey[0] = pg_attribute.attnum
           AND pg_index.indisprimary = 't'
-          AND pg_namespace.nspname = '%s'
-          AND pg_class.relname = '%s'
+          #{"AND pg_namespace.nspname = '#{schema}'" if schema}
+          AND pg_class.relname = '#{table}'
       end_sql
-      SELECT_SERIAL_SEQUENCE = <<-end_sql
+      end
+      SELECT_SERIAL_SEQUENCE = proc do |schema, table| <<-end_sql
         SELECT  '"' || name.nspname || '"."' || seq.relname || '"'
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
           pg_namespace name, pg_constraint cons
@@ -86,9 +95,10 @@ module Sequel
           AND attr.attrelid = cons.conrelid
           AND attr.attnum = cons.conkey[1]
           AND cons.contype = 'p'
-          AND name.nspname = '%s'
-          AND seq.relname = '%s'
+          #{"AND name.nspname = '#{schema}'" if schema}
+          AND seq.relname = '#{table}'
       end_sql
+      end
       
       # Depth of the current transaction on this connection, used
       # to implement multi-level transactions with savepoints.
@@ -106,6 +116,11 @@ module Sequel
           # try it unconditionally and rescue any errors.
           execute(sql) rescue nil
         end
+        if cmm = Postgres.client_min_messages
+          sql = "SET client_min_messages = '#{cmm.to_s.upcase}'"
+          @db.log_info(sql)
+          execute(sql)
+        end
       end
 
       # Get the last inserted value for the given sequence.
@@ -120,7 +135,7 @@ module Sequel
       
       # Get the primary key for the given table.
       def primary_key(schema, table)
-        sql = SELECT_PK % [schema, table]
+        sql = SELECT_PK[schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
@@ -129,14 +144,14 @@ module Sequel
       
       # Get the primary key and sequence for the given table.
       def sequence(schema, table)
-        sql = SELECT_SERIAL_SEQUENCE % [schema, table]
+        sql = SELECT_SERIAL_SEQUENCE[schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           seq = single_value(r)
           return seq if seq
         end
         
-        sql = SELECT_CUSTOM_SEQUENCE % [schema, table]
+        sql = SELECT_CUSTOM_SEQUENCE[schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
@@ -155,6 +170,7 @@ module Sequel
       SQL_ROLLBACK = 'ROLLBACK'.freeze
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
+      TYPES = Sequel::Schema::SQL::TYPES.merge(File=>'bytea', String=>'text')
 
       # Creates the function in the database.  See create_function_sql for arguments.
       def create_function(*args)
@@ -237,11 +253,6 @@ module Sequel
         "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
       end
       
-      # The default schema to use if none is specified (default: public)
-      def default_schema
-        @default_schema ||= :public
-      end
-      
       # Drops the function from the database.  See drop_function_sql for arguments.
       def drop_function(*args)
         self << drop_function_sql(*args)
@@ -311,13 +322,13 @@ module Sequel
         filter = " WHERE #{filter_expr(filter)}" if filter
         case index_type
         when :full_text
-          cols = Array(index[:columns]).map{|x| :COALESCE[x, '']}.sql_string_join(' ')
+          cols = Array(index[:columns]).map{|x| SQL::Function.new(:COALESCE, x, '')}.sql_string_join(' ')
           expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(cols)}))"
           index_type = :gin
         when :spatial
           index_type = :gist
         end
-        "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
+        "CREATE #{unique}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
       
       # Dataset containing all current database locks 
@@ -328,8 +339,25 @@ module Sequel
       end
       
       # Return primary key for the given table.
-      def primary_key(table, server=nil)
-        synchronize(server){|conn| primary_key_for_table(conn, table)}
+      def primary_key(table, opts={})
+        quoted_table = quote_schema_table(table)
+        return @primary_keys[quoted_table] if @primary_keys.include?(quoted_table)
+        @primary_keys[quoted_table] = if conn = opts[:conn]
+          conn.primary_key(*schema_and_table(table))
+        else
+          synchronize(opts[:server]){|con| con.primary_key(*schema_and_table(table))}
+        end
+      end
+      
+      # Return the sequence providing the default for the primary key for the given table.
+      def primary_key_sequence(table, opts={})
+        quoted_table = quote_schema_table(table)
+        return @primary_key_sequences[quoted_table] if @primary_key_sequences.include?(quoted_table)
+        @primary_key_sequences[quoted_table] = if conn = opts[:conn]
+          conn.sequence(*schema_and_table(table))
+        else
+          synchronize(opts[:server]){|con| con.sequence(*schema_and_table(table))}
+        end
       end
 
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
@@ -351,7 +379,7 @@ module Sequel
           (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
-          m = /PostgreSQL (\d+)\.(\d+)\.(\d+)/.match(get(:version[]))
+          m = /PostgreSQL (\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
           @server_version = (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
         end
         @server_version
@@ -365,7 +393,7 @@ module Sequel
       def table_exists?(table, opts={})
         schema, table = schema_and_table(table)
         opts[:schema] ||= schema
-        tables(opts){|ds| !ds.first(:relname=>table.to_s).nil?}
+        tables(opts){|ds| !ds.first(:relname=>ds.send(:input_identifier, table)).nil?}
       end
       
       # Array of symbols specifying table names in the current database.
@@ -376,8 +404,12 @@ module Sequel
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
       def tables(opts={})
-        ds = self[:pg_class].join(:pg_namespace, :oid=>:relnamespace, 'r'=>:relkind, :nspname=>(opts[:schema]||default_schema).to_s).select(:relname).exclude(:relname.like(SYSTEM_TABLE_REGEXP)).server(opts[:server])
-        block_given? ? yield(ds) : ds.map{|r| r[:relname].to_sym}
+        ds = self[:pg_class].filter(:relkind=>'r').select(:relname).exclude(:relname.like(SYSTEM_TABLE_REGEXP)).server(opts[:server])
+        ds.join!(:pg_namespace, :oid=>:relnamespace, :nspname=>(opts[:schema]||default_schema).to_s) if opts[:schema] || default_schema
+        ds.identifier_input_method = nil
+        ds.identifier_output_method = nil
+        ds2 = dataset
+        block_given? ? yield(ds) : ds.map{|r| ds2.send(:output_identifier, r[:relname])}
       end
       
       # PostgreSQL supports multi-level transactions using save points.
@@ -424,10 +456,15 @@ module Sequel
       end
 
       private
+
+      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
+      def identifier_input_method_default
+        nil
+      end
       
-      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers by default.
-      def upcase_identifiers_default
-        false
+      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
+      def identifier_output_method_default
+        nil
       end
 
       # The result of the insert for the given table and values.  If values
@@ -439,12 +476,12 @@ module Sequel
       def insert_result(conn, table, values)
         case values
         when Hash
-          return nil unless pk = primary_key_for_table(conn, table)
+          return nil unless pk = primary_key(table, :conn=>conn)
           if pk and pkv = values[pk.to_sym]
             pkv
           else
             begin
-              if seq = primary_key_sequence_for_table(conn, table)
+              if seq = primary_key_sequence(table, :conn=>conn)
                 conn.last_insert_id(seq)
               end
             rescue Exception => e
@@ -464,49 +501,9 @@ module Sequel
         PREPARED_ARG_PLACEHOLDER
       end
       
-      # Returns primary key for the given table.  This information is
-      # cached, and if the primary key for a table is changed, the
-      # @primary_keys instance variable should be reset manually.
-      def primary_key_for_table(conn, table)
-        @primary_keys[quote_schema_table(table)] ||= conn.primary_key(*schema_and_table(table))
-      end
-      
-      # Returns primary key for the given table.  This information is
-      # cached, and if the primary key for a table is changed, the
-      # @primary_keys instance variable should be reset manually.
-      def primary_key_sequence_for_table(conn, table)
-        @primary_key_sequences[quote_schema_table(table)] ||= conn.sequence(*schema_and_table(table))
-      end
-      
-      # Set the default of the row to NULL if it is blank, and set
-      # the ruby type for the column based on the database type.
-      def schema_parse_rows(rows)
-        rows.map do |row|
-          row[:default] = nil if row[:default].blank?
-          row[:type] = schema_column_type(row[:db_type])
-          [row.delete(:name).to_sym, row]
-        end
-      end
-
-      # Parse the schema for a single table.
-      def schema_parse_table(table_name, opts)
-        schema_parse_rows(schema_parser_dataset(table_name, opts))
-      end
-
-      # Parse the schema for multiple tables.
-      def schema_parse_tables(opts)
-        schemas = {}
-        schema_parser_dataset(nil, opts).each do |row|
-          (schemas[quote_schema_table(SQL::QualifiedIdentifier.new(row.delete(:schema), row.delete(:table)))] ||= []) << row
-        end
-        schemas.each do |table, rows|
-          schemas[table] = schema_parse_rows(rows)
-        end
-        schemas
-      end
-
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
-      def schema_parser_dataset(table_name, opts)
+      def schema_parse_table(table_name, opts)
+        ds2 = dataset
         ds = dataset.select(:pg_attribute__attname___name,
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
@@ -518,21 +515,28 @@ module Sequel
           left_outer_join(:pg_attrdef, :adrelid=>:pg_class__oid, :adnum=>:pg_attribute__attnum).
           left_outer_join(:pg_index, :indrelid=>:pg_class__oid, :indisprimary=>true).
           filter(:pg_attribute__attisdropped=>false).
-          filter(:pg_attribute__attnum > 0).
+          filter{|o| o.pg_attribute__attnum > 0}.
+          filter(:pg_class__relname=>ds2.send(:input_identifier, table_name)).
           order(:pg_attribute__attnum)
-        if table_name
-          ds.filter!(:pg_class__relname=>table_name.to_s)
-        else
-          ds.select_more!(:pg_class__relname___table, :pg_namespace__nspname___schema)
-          ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s)
+        ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s) if opts[:schema] || default_schema
+        ds.identifier_input_method = nil
+        ds.identifier_output_method = nil
+        ds.map do |row|
+          row[:default] = nil if row[:default].blank?
+          row[:type] = schema_column_type(row[:db_type])
+          [ds2.send(:output_identifier, row.delete(:name)), row]
         end
-        ds
       end
 
       # Turns an array of argument specifiers into an SQL fragment used for function arguments.  See create_function_sql.
       def sql_function_args(args)
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
       end
+      
+      # Override the standard type conversions with PostgreSQL specific ones
+      def type_literal_base(column)
+        TYPES[column[:type]]
+      end
     end
     
     # Instance methods for datasets that connect to a PostgreSQL database.
@@ -603,7 +607,7 @@ module Sequel
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
         lang = opts[:language] || 'simple'
-        cols =  Array(cols).map{|x| :COALESCE[x, '']}.sql_string_join(' ')
+        cols =  Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}.sql_string_join(' ')
         filter("to_tsvector(#{literal(lang)}, #{literal(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
       end
       
@@ -634,9 +638,9 @@ module Sequel
         when LiteralString
           v
         when SQL::Blob
-          db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+          "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
         when String
-          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+          "'#{v.gsub("'", "''")}'"
         when Time
           "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
         when DateTime