sequel 2.2.0 → 2.3.0

data/lib/sequel_core/adapters/postgres.rb

@@ -0,0 +1,199 @@
+require 'sequel_core/adapters/shared/postgres'
+
+begin 
+  require 'pg' 
+rescue LoadError => e 
+  begin 
+    require 'postgres' 
+    class PGconn
+      unless method_defined?(:escape_string)
+        if self.respond_to?(:escape)
+          def escape_string(str)
+            self.class.escape(str)
+          end
+        else
+          def escape_string(obj)
+            raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+          end
+        end
+      end
+      unless method_defined?(:escape_bytea)
+        if self.respond_to?(:escape_bytea)
+          def escape_bytea(obj)
+            self.class.escape_bytea(obj)
+          end
+        else
+          begin
+            require 'postgres-pr/typeconv/conv'
+            require 'postgres-pr/typeconv/bytea'
+            extend Postgres::Conversion
+            def escape_bytea(obj)
+              self.class.encode_bytea(obj)
+            end
+            metaalias :unescape_bytea, :decode_bytea
+          rescue
+            def escape_bytea(obj)
+              raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+            def self.unescape_bytea(obj)
+              raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+          end
+        end
+      end
+      alias_method :finish, :close unless method_defined?(:finish) 
+    end
+    class PGresult 
+      alias_method :nfields, :num_fields unless method_defined?(:nfields) 
+      alias_method :ntuples, :num_tuples unless method_defined?(:ntuples) 
+      alias_method :ftype, :type unless method_defined?(:ftype) 
+      alias_method :fname, :fieldname unless method_defined?(:fname) 
+      alias_method :cmd_tuples, :cmdtuples unless method_defined?(:cmd_tuples) 
+    end 
+  rescue LoadError 
+    raise e 
+  end 
+end
+
+module Sequel
+  module Postgres
+    CONVERTED_EXCEPTIONS << PGError
+    PG_TYPES = {
+      16 => lambda{ |s| Postgres.string_to_bool(s) }, # boolean
+      17 => lambda{ |s| Adapter.unescape_bytea(s).to_blob }, # bytea
+      20 => lambda{ |s| s.to_i }, # int8
+      21 => lambda{ |s| s.to_i }, # int2
+      22 => lambda{ |s| s.to_i }, # int2vector
+      23 => lambda{ |s| s.to_i }, # int4
+      26 => lambda{ |s| s.to_i }, # oid
+      700 => lambda{ |s| s.to_f }, # float4
+      701 => lambda{ |s| s.to_f }, # float8
+      790 => lambda{ |s| s.to_d }, # money
+      1082 => lambda{ |s| s.to_date }, # date
+      1083 => lambda{ |s| s.to_time }, # time without time zone
+      1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
+      1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
+      1186 => lambda{ |s| s.to_i }, # interval
+      1266 => lambda{ |s| s.to_time }, # time with time zone
+      1700 => lambda{ |s| s.to_d }, # numeric
+    }
+    
+    def self.string_to_bool(s)
+      if(s.blank?)
+        nil
+      elsif(s.downcase == 't' || s.downcase == 'true')
+        true
+      else
+        false
+      end
+    end
+  
+    class Adapter < ::PGconn
+      include Sequel::Postgres::AdapterMethods
+      self.translate_results = false if respond_to?(:translate_results=)
+      
+      def connected?
+        status == Adapter::CONNECTION_OK
+      end
+      
+      def execute(sql, &block)
+        q = nil
+        begin
+          q = exec(sql)
+        rescue PGError => e
+          unless connected?
+            reset
+            q = exec(sql)
+          else
+            raise e
+          end
+        end
+        begin
+          block ? block[q] : q.cmd_tuples
+        ensure
+          q.clear
+        end
+      end
+      
+      def result_set_values(r, *vals)
+        return if r.nil? || (r.ntuples == 0)
+        case vals.length
+        when 1
+          r.getvalue(0, vals.first)
+        else
+          vals.collect{|col| r.getvalue(0, col)}
+        end
+      end
+    end
+
+    class Database < Sequel::Database
+      include Sequel::Postgres::DatabaseMethods
+      
+      set_adapter_scheme :postgres
+    
+      def connect
+        conn = Adapter.connect(
+          @opts[:host] || 'localhost',
+          @opts[:port] || 5432,
+          '', '',
+          @opts[:database],
+          @opts[:user],
+          @opts[:password]
+        )
+        if encoding = @opts[:encoding] || @opts[:charset]
+          conn.set_client_encoding(encoding)
+        end
+        conn
+      end
+      
+      def dataset(opts = nil)
+        Postgres::Dataset.new(self, opts)
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.finish}
+      end
+    
+      def execute(sql, &block)
+        begin
+          log_info(sql)
+          @pool.hold {|conn| conn.execute(sql, &block)}
+        rescue => e
+          log_info(e.message)
+          raise convert_pgerror(e)
+        end
+      end
+      
+      private
+
+      # PostgreSQL doesn't need the pool to convert exceptions, either.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+    end
+  
+    class Dataset < Sequel::Dataset
+      include Sequel::Postgres::DatasetMethods
+
+      def fetch_rows(sql, &block)
+        @columns = []
+        @db.execute(sql) do |res|
+          (0...res.ntuples).each do |recnum|
+            converted_rec = {}
+            (0...res.nfields).each do |fieldnum|
+              fieldsym = res.fname(fieldnum).to_sym
+              @columns << fieldsym
+              converted_rec[fieldsym] = if value = res.getvalue(recnum,fieldnum)
+                (PG_TYPES[res.ftype(fieldnum)] || lambda{|s| s.to_s}).call(value)
+              else
+                value
+              end
+            end
+            yield converted_rec
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,275 @@
+module Sequel
+  module MySQL
+    module DatabaseMethods
+      AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
+      NOT_NULL = Sequel::Schema::SQL::NOT_NULL
+      NULL = Sequel::Schema::SQL::NULL
+      PRIMARY_KEY = Sequel::Schema::SQL::PRIMARY_KEY
+      SQL_BEGIN = Sequel::Database::SQL_BEGIN
+      SQL_COMMIT = Sequel::Database::SQL_COMMIT
+      SQL_ROLLBACK = Sequel::Database::SQL_ROLLBACK
+      TYPES = Sequel::Schema::SQL::TYPES
+      UNIQUE = Sequel::Schema::SQL::UNIQUE
+      UNSIGNED = Sequel::Schema::SQL::UNSIGNED
+      
+      def alter_table_sql(table, op)
+        type = type_literal(op[:type])
+        type << '(255)' if type == 'varchar'
+        case op[:op]
+        when :rename_column
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{type}"
+        when :set_column_type
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{type}"
+        when :drop_index
+          "DROP INDEX #{default_index_name(table, op[:columns])} ON #{table}"
+        else
+          super(table, op)
+        end
+      end
+      
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+      
+      def column_definition_sql(column)
+        if column[:type] == :check
+          return constraint_definition_sql(column)
+        end
+        sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
+        column[:size] ||= 255 if column[:type] == :varchar
+        elements = column[:size] || column[:elements]
+        sql << literal(Array(elements)) if elements
+        sql << UNSIGNED if column[:unsigned]
+        sql << UNIQUE if column[:unique]
+        sql << NOT_NULL if column[:null] == false
+        sql << NULL if column[:null] == true
+        sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+        sql << PRIMARY_KEY if column[:primary_key]
+        sql << " #{auto_increment_sql}" if column[:auto_increment]
+        if column[:table]
+          sql << ", FOREIGN KEY (#{literal(column[:name].to_sym)}) REFERENCES #{column[:table]}"
+          sql << literal(Array(column[:key])) if column[:key]
+          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
+        end
+        sql
+      end
+
+      def index_definition_sql(table_name, index)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        unique = "UNIQUE " if index[:unique]
+        case index[:type]
+        when :full_text
+          "CREATE FULLTEXT INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
+        when :spatial
+          "CREATE SPATIAL INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
+        when nil
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
+        else
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])} USING #{index[:type]}"
+        end
+      end
+      
+      def serial_primary_key_options
+        {:primary_key => true, :type => :integer, :auto_increment => true}
+      end
+      
+      def server_version
+        m = /(\d+)\.(\d+)\.(\d+)/.match(get(:version[]))
+        @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+      end
+      
+      # Changes the database in use by issuing a USE statement.
+      def use(db_name)
+        disconnect
+        @opts[:database] = db_name if self << "USE #{db_name}"
+        @schemas = nil
+        self
+      end
+      
+      private
+      
+      def schema_ds_dataset
+        ds = schema_utility_dataset.clone
+        ds.quote_identifiers = true
+        ds
+      end
+      
+      def schema_ds_filter(table_name, opts)
+        filt = super
+        # Restrict it to the given or current database, unless specifically requesting :database = nil
+        filt = SQL::BooleanExpression.new(:AND, filt, {:c__table_schema=>opts[:database] || database_name}) if opts[:database] || !opts.include?(:database)
+        filt
+      end
+
+      def schema_ds_join(table_name, opts)
+        [:information_schema__columns, {:table_schema => :table_schema, :table_name => :table_name}, :c]
+      end
+    end
+  
+    module DatasetMethods
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      COMMA_SEPARATOR = ', '.freeze
+      
+      def complex_expression_sql(op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*', :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
+          "(#{literal(args.at(0))} #{'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)}#{[:~, :'!~', :'~*', :'!~*'].include?(op) ? 'REGEXP' : 'LIKE'} #{'BINARY ' if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)}#{literal(args.at(1))})"
+        when :'||'
+          if args.length > 1
+            "CONCAT(#{args.collect{|a| literal(a)}.join(', ')})"
+          else
+            literal(args.at(0))
+          end
+        else
+          super(op, args)
+        end
+      end
+      
+      # MySQL supports ORDER and LIMIT clauses in DELETE statements.
+      def delete_sql(opts = nil)
+        sql = super
+        opts = opts ? @opts.merge(opts) : @opts
+
+        if order = opts[:order]
+          sql << " ORDER BY #{expression_list(order)}"
+        end
+        if limit = opts[:limit]
+          sql << " LIMIT #{limit}"
+        end
+
+        sql
+      end
+
+      def full_text_search(cols, terms, opts = {})
+        mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
+        s = if Array === terms
+          if mode.blank?
+            "MATCH #{literal(Array(cols))} AGAINST #{literal(terms)}"
+          else
+            "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)[1...-1]}#{mode})"
+          end
+        else
+          "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)}#{mode})"
+        end
+        filter(s)
+      end
+
+      # MySQL allows HAVING clause on ungrouped datasets.
+      def having(*cond, &block)
+        @opts[:having] = {}
+        x = filter(*cond, &block)
+      end
+
+      def insert_default_values_sql
+        "INSERT INTO #{source_list(@opts[:from])} () VALUES ()"
+      end
+
+      # Returns a join clause based on the specified join type
+      # and condition.  MySQL's NATURAL join is 'semantically
+      # equivalent to a JOIN with a USING clause that names all
+      # columns that exist in both tables.  The constraint
+      # expression may be nil, so join expression can accept two
+      # arguments.
+      #
+      # === Note
+      # Full outer joins (:full_outer) are not implemented in
+      # MySQL (as of v6.0), nor is there currently a work around
+      # implementation in Sequel.  Straight joins with 'ON
+      # <condition>' are not yet implemented.
+      #
+      # === Example
+      #   @ds = MYSQL_DB[:nodes]
+      #   @ds.join_table(:natural_left_outer, :nodes)
+      #   # join SQL is 'NATURAL LEFT OUTER JOIN nodes'
+      def join_table(type, table, expr=nil, table_alias=nil)
+        type = :inner if (type == :cross) && !expr.nil?
+        raise(Sequel::Error::InvalidJoinType, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
+        super(type, table, expr, table_alias)
+      end
+      
+      def join_type_sql(join_type)
+        case join_type
+        when :straight then 'STRAIGHT_JOIN'
+        when :natural_inner then 'NATURAL LEFT JOIN'
+        else super
+        end
+      end
+
+      def literal(v)
+        case v
+        when true
+          BOOL_TRUE
+        when false
+          BOOL_FALSE
+        else
+          super
+        end
+      end
+      
+      def multi_insert_sql(columns, values)
+        columns = column_list(columns)
+        values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
+        ["INSERT INTO #{source_list(@opts[:from])} (#{columns}) VALUES #{values}"]
+      end
+      
+      def quoted_identifier(c)
+        "`#{c}`"
+      end
+      
+      def replace_sql(*values)
+        from = source_list(@opts[:from])
+        if values.empty?
+          "REPLACE INTO #{from} DEFAULT VALUES"
+        else
+          values = values[0] if values.size == 1
+          
+          # if hash or array with keys we need to transform the values
+          if @transform && (values.is_a?(Hash) || (values.is_a?(Array) && values.keys))
+            values = transform_save(values)
+          end
+
+          case values
+          when Array
+            if values.empty?
+              "REPLACE INTO #{from} DEFAULT VALUES"
+            else
+              "REPLACE INTO #{from} VALUES #{literal(values)}"
+            end
+          when Hash
+            if values.empty?
+              "REPLACE INTO #{from} DEFAULT VALUES"
+            else
+              fl, vl = [], []
+              values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
+              "REPLACE INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+            end
+          when Dataset
+            "REPLACE INTO #{from} #{literal(values)}"
+          else
+            if values.respond_to?(:values)
+              replace_sql(values.values)
+            else  
+              "REPLACE INTO #{from} VALUES (#{literal(values)})"
+            end
+          end
+        end
+      end
+      
+      # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
+      def update_sql(values, opts = nil)
+        sql = super
+        opts = opts ? @opts.merge(opts) : @opts
+
+        if order = opts[:order]
+          sql << " ORDER BY #{expression_list(order)}"
+        end
+        if limit = opts[:limit]
+          sql << " LIMIT #{limit}"
+        end
+
+        sql
+      end
+    end
+  end
+end