sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/swift/postgres.rb

@@ -1,45 +0,0 @@
-require 'swift/db/postgres'
-Sequel.require 'adapters/shared/postgres'
-
-module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::Swift::Error
-  
-  module Swift
-    # Adapter, Database, and Dataset support for accessing a PostgreSQL
-    # database via Swift.
-    module Postgres
-      # Methods to add to Database instances that access PostgreSQL via Swift.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::Postgres::DatabaseMethods
-        
-        # Add the primary_keys and primary_key_sequences instance variables,
-        # so we can get the correct return values for inserted rows.
-        def self.extended(db)
-          super
-          db.send(:initialize_postgres_adapter)
-        end
-        
-        private
-        
-        # Remove all other options except for ones specifically handled, as
-        # otherwise swift passes them to dbic++ which passes them to PostgreSQL
-        # which can raise an error.
-        def server_opts(o)
-          o = super
-          so = {}
-          [:db, :user, :password, :host, :port].each{|s| so[s] = o[s] if o.has_key?(s)}
-          so
-        end
-      
-        # Extend the adapter with the Swift PostgreSQL AdapterMethods.
-        def setup_connection(conn)
-          conn = super(conn)
-          conn.native_bind_format = true
-          connection_configuration_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
-          conn
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/swift/sqlite.rb

@@ -1,47 +0,0 @@
-require 'swift/db/sqlite3'
-Sequel.require 'adapters/shared/sqlite'
-
-module Sequel
-  module Swift
-    # Database and Dataset instance methods for SQLite specific
-    # support via Swift.
-    module SQLite
-      # Database instance methods for SQLite databases accessed via Swift.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::SQLite::DatabaseMethods
-
-        DATABASE_ERROR_REGEXPS = {
-          /\AUNIQUE constraint failed: / => UniqueConstraintViolation,
-          /\AFOREIGN KEY constraint failed/ => ForeignKeyConstraintViolation,
-          /\ACHECK constraint failed/ => CheckConstraintViolation,
-          /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed/ => ConstraintViolation,
-          /may not be NULL\z|NOT NULL constraint failed: .+/ => NotNullConstraintViolation,
-          /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
-        }.freeze
-        def database_error_regexps
-          DATABASE_ERROR_REGEXPS
-        end
-
-        # Set the correct pragmas on the connection.
-        def connect(opts)
-          c = super
-          connection_pragmas.each{|s| log_yield(s){c.execute(s)}}
-          c
-        end
-      end
-      
-      # Dataset class for SQLite datasets accessed via Swift.
-      class Dataset < Swift::Dataset
-        include Sequel::SQLite::DatasetMethods
-        
-        private
-        
-        # Use Swift's escape method for quoting.
-        def literal_string_append(sql, s)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/utils/pg_types.rb

@@ -1,68 +0,0 @@
-module Sequel
-  module Postgres
-    NAN             = 0.0/0.0
-    PLUS_INFINITY   = 1.0/0.0
-    MINUS_INFINITY  = -1.0/0.0
-    NAN_STR             = 'NaN'.freeze
-    PLUS_INFINITY_STR   = 'Infinity'.freeze
-    MINUS_INFINITY_STR  = '-Infinity'.freeze
-    TRUE_STR = 't'.freeze
-    DASH_STR = '-'.freeze
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == TRUE_STR end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when NAN_STR
-          NAN
-        when PLUS_INFINITY_STR
-          PLUS_INFINITY
-        when MINUS_INFINITY_STR
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split(DASH_STR).map(&:to_i)) end
-      def bytea(str)
-        str = if str =~ /\A\\x/
-          # PostgreSQL 9.0+ bytea hex format
-          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
-        else
-          # Historical PostgreSQL bytea escape format
-          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
-            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
-          }
-        end
-        ::Sequel::SQL::Blob.new(str)
-      end
-    end.new
-
-    # Type OIDs for string types used by PostgreSQL.  These types don't
-    # have conversion procs associated with them (since the data is
-    # already in the form of a string).
-    STRING_TYPES = [18, 19, 25, 1042, 1043]
-
-    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
-    # Non-builtin types that don't have fixed numbers should use this to register
-    # conversion procs.
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-
-    # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {} unless defined?(PG_TYPES)
-
-    {
-      [16] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [1700] => ::BigDecimal.method(:new),
-      [1083, 1266] => ::Sequel.method(:string_to_time),
-      [1082] => ::Sequel.method(:string_to_date),
-      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
-    }.each do |k,v|
-      k.each{|n| PG_TYPES[n] = v}
-    end
-  end
-end 

data/lib/sequel/dataset/mutation.rb

@@ -1,109 +0,0 @@
-module Sequel
-  class Dataset
-    # ---------------------
-    # :section: 7 - Mutation methods
-    # These methods modify the receiving dataset and should be used with care.
-    # ---------------------
-    
-    # All methods that should have a ! method added that modifies the receiver.
-    MUTATION_METHODS = QUERY_METHODS - [:naked, :from_self]
-    
-    # Setup mutation (e.g. filter!) methods.  These operate the same as the
-    # non-! methods, but replace the options of the current dataset with the
-    # options of the resulting dataset.
-    #
-    # Do not call this method with untrusted input, as that can result in
-    # arbitrary code execution.
-    def self.def_mutation_method(*meths)
-      options = meths.pop if meths.last.is_a?(Hash)
-      mod = options[:module] if options
-      mod ||= self
-      meths.each do |meth|
-        mod.class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
-      end
-    end
-    
-    # Add the mutation methods via metaprogramming
-    def_mutation_method(*MUTATION_METHODS)
-    
-    # The row_proc for this database, should be any object that responds to +call+ with
-    # a single hash argument and returns the object you want #each to return.
-    attr_reader :row_proc
-    
-    # Load an extension into the receiver.  In addition to requiring the extension file, this
-    # also modifies the dataset to work with the extension (usually extending it with a
-    # module defined in the extension file).  If no related extension file exists or the
-    # extension does not have specific support for Database objects, an Error will be raised.
-    # Returns self.
-    def extension!(*exts)
-      raise_if_frozen!
-      Sequel.extension(*exts)
-      exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
-        else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
-        end
-      end
-      self
-    end
-
-    # Avoid self-referential dataset by cloning.
-    def from_self!(*args, &block)
-      raise_if_frozen!
-      @opts = clone.from_self(*args, &block).opts
-      self
-    end
-
-    # Set the method to call on identifiers going into the database for this dataset
-    def identifier_input_method=(v)
-      raise_if_frozen!
-      skip_symbol_cache!
-      @identifier_input_method = v
-    end
-    
-    # Set the method to call on identifiers coming the database for this dataset
-    def identifier_output_method=(v)
-      raise_if_frozen!
-      @identifier_output_method = v
-    end
-
-    # Remove the row_proc from the current dataset.
-    def naked!
-      raise_if_frozen!
-      self.row_proc = nil
-      self
-    end
-    
-    # Set whether to quote identifiers for this dataset
-    def quote_identifiers=(v)
-      raise_if_frozen!
-      skip_symbol_cache!
-      @quote_identifiers = v
-    end
-
-    # Override the row_proc for this dataset
-    def row_proc=(v)
-      raise_if_frozen!
-      @row_proc = v
-    end
-    
-    private
-    
-    # Modify the receiver with the results of sending the meth, args, and block
-    # to the receiver and merging the options of the resulting dataset into
-    # the receiver's options.
-    def mutation_method(meth, *args, &block)
-      raise_if_frozen!
-      @opts = send(meth, *args, &block).opts
-      self
-    end
-
-    # Raise a RuntimeError if the receiver is frozen
-    def raise_if_frozen!
-      if frozen?
-        raise RuntimeError, "can't modify frozen #{visible_class_name}"
-      end
-    end
-  end
-end

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -1,3 +0,0 @@
-# This only exists for backwards compatibility, as the behavior
-# added by this extension is now the default Sequel behavior. 
-Sequel::Dataset.register_extension(:empty_array_ignore_nulls){}

data/lib/sequel/extensions/filter_having.rb

@@ -1,59 +0,0 @@
-# The filter_having extension allows Dataset#filter, #and, #or
-# and #exclude to operate on the HAVING clause if the dataset
-# already has a HAVING clause, which was the historical behavior
-# before Sequel 4.  It is only recommended to use this for
-# backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:filter_having)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:filter_having)
-
-#
-module Sequel
-  module FilterHaving
-    # Operate on HAVING clause if HAVING clause already present.
-    def and(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def exclude(*cond, &block)
-      if @opts[:having]
-        exclude_having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def filter(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def or(*cond, &block)
-      if having = @opts[:having]
-        cond = cond.first if cond.size == 1
-        clone(:having => SQL::BooleanExpression.new(:OR, having, filter_expr(cond, &block)))
-      else
-        super
-      end
-    end
-  end
-
-  Dataset.register_extension(:filter_having, FilterHaving)
-end

data/lib/sequel/extensions/hash_aliases.rb

@@ -1,45 +0,0 @@
-# The hash_aliases extension allows Dataset#select and Dataset#from
-# to treat a hash argument as an alias specification, with keys
-# being the expressions and values being the aliases, 
-# which was the historical behavior before Sequel 4.
-# It is only recommended to use this for backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:hash_aliases)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:hash_aliases)
-
-#
-module Sequel
-  module HashAliases
-    def from(*source)
-      super(*convert_hash_aliases(source))
-    end
-
-    def select(*columns, &block)
-      virtual_row_columns(columns, block)
-      super(*convert_hash_aliases(columns), &nil)
-    end
-
-    private
-
-    def convert_hash_aliases(columns)
-      m = []
-      columns.each do |i|
-        if i.is_a?(Hash)
-          m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)})
-        else
-          m << i
-        end
-      end
-      m
-    end
-  end
-
-  Dataset.register_extension(:hash_aliases, HashAliases)
-end

data/lib/sequel/extensions/meta_def.rb

@@ -1,31 +0,0 @@
-# The meta_def extension is designed for backwards compatibility
-# with older Sequel code that uses the meta_def method on
-# Database, Dataset, and Model classes and/or instances.  It is
-# not recommended for usage in new code.  To load this extension:
-#
-#   Sequel.extension :meta_def
-
-#
-module Sequel
-  # Contains meta_def method for adding methods to objects via blocks.
-  # Only recommended for backwards compatibility with existing code.
-  module Metaprogramming
-    # Define a method with the given name and block body on the receiver.
-    #
-    #   ds = DB[:items]
-    #   ds.meta_def(:x){42}
-    #   ds.x # => 42
-    def meta_def(name, &block)
-      (class << self; self end).send(:define_method, name, &block)
-    end
-  end
-
-  Database.extend Metaprogramming
-  Database.send(:include, Metaprogramming)
-  Dataset.extend Metaprogramming
-  Dataset.send(:include, Metaprogramming)
-  if defined?(Model)
-    Model.extend Metaprogramming
-    Model.send(:include, Metaprogramming)
-  end
-end

data/lib/sequel/extensions/query_literals.rb

@@ -1,80 +0,0 @@
-# The query_literals extension changes Sequel's default behavior of
-# the select, order and group methods so that if the first argument
-# is a regular string, it is treated as a literal string, with the
-# rest of the arguments (if any) treated as placeholder values. This
-# allows you to write code such as:
-#
-#   DB[:table].select('a, b, ?', 2).group('a, b').order('c')
-#
-# The default Sequel behavior would literalize that as:
-#
-#   SELECT 'a, b, ?', 2 FROM table GROUP BY 'a, b' ORDER BY 'c'
-#
-# Using this extension changes the literalization to:
-#
-#   SELECT a, b, 2, FROM table GROUP BY a, b ORDER BY c
-#
-# This extension makes select, group, and order methods operate
-# like filter methods, which support the same interface.
-#
-# There are very few places where Sequel's default behavior is
-# desirable in this area, but for backwards compatibility, the
-# defaults won't be changed until the next major release.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:query_literals)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:query_literals)
-
-#
-module Sequel
-  # The QueryLiterals module can be used to make select, group, and
-  # order methods operate similar to the filter methods if the first
-  # argument is a plain string, treating it like a literal string,
-  # with any remaining arguments treated as placeholder values.
-  #
-  # This adds such support to the following methods: select, select_append,
-  # select_group, select_more, group, group_and_count, order, order_append,
-  # and order_more.
-  #
-  # Note that if you pass a block to these methods, it will use the default
-  # implementation without the special literal handling.
-  module QueryLiterals
-    %w'select select_append select_group select_more group group_and_count group_append order order_append order_more'.each do |m|
-      class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def #{m}(*args)
-          if !block_given? && (l = query_literal(args))
-            super(l)
-          else
-            super
-          end
-        end
-      END
-    end
-
-    private
-
-    # If the first argument is a plain string, return a literal string
-    # if there are no additional args or a placeholder literal string with
-    # the remaining args.  Otherwise, return nil.
-    def query_literal(args)
-      case (s = args[0])
-      when LiteralString, SQL::Blob
-        nil
-      when String
-        if args.length == 1
-          LiteralString.new(s)
-        else
-          SQL::PlaceholderLiteralString.new(s, args[1..-1])
-        end
-      end
-    end
-  end
-
-  Dataset.register_extension(:query_literals, QueryLiterals)
-end