sequel 2.11.0 → 2.12.0

data/lib/sequel_core/dataset/callback.rb

@@ -1,13 +0,0 @@
-module Sequel
-  class Dataset
-    private
-    # This is run inside .all, after all
-    # of the records have been loaded
-    # via .each, but before any block passed
-    # to all is called.  It is called with
-    # a single argument, an array of all
-    # returned records.
-    def post_load(all_records)
-    end
-  end
-end

data/lib/sequel_core/dataset/schema.rb

@@ -1,15 +0,0 @@
-module Sequel
-  class Dataset
-    # Creates a view in the database with the given named based
-    # on the current dataset.
-    def create_view(name)
-      @db.create_view(name, self)
-    end
-
-    # Creates or replaces a view in the database with the given
-    # named based on the current dataset.
-    def create_or_replace_view(name)
-      @db.create_or_replace_view(name, self)
-    end
-  end
-end

data/lib/sequel_core/deprecated.rb

@@ -1,26 +0,0 @@
-module Sequel
-  # This module makes it easy to add deprecation functionality to other classes.
-  module Deprecation # :nodoc:
-    # This sets the output stream for the deprecation messages.  Set it to an IO
-    # (or any object that responds to puts) and it will call puts on that
-    # object with the deprecation message.  Set to nil to ignore deprecation messages.
-    def self.deprecation_message_stream=(file)
-      @dms = file
-    end
-
-    # Set this to true to print tracebacks with every deprecation message,
-    # so you can see exactly where in your code the deprecated methods are
-    # being called.
-    def self.print_tracebacks=(pt)
-      @pt = pt
-    end
-
-    # Puts the messages unaltered to the deprecation message stream
-    def self.deprecate(message)
-      if @dms
-        @dms.puts(message)
-        caller.each{|c| @dms.puts(c)} if @pt 
-      end
-    end
-  end
-end

data/lib/sequel_core/exceptions.rb

@@ -1,44 +0,0 @@
-module Sequel
-  # Represents an error raised in Sequel code.
-  class Error < ::StandardError
-    
-    # Raised when Sequel is unable to load a specified adapter.
-    class AdapterNotFound < Error ; end
-
-    # Raised on an invalid operation.
-    class InvalidOperation < Error; end
-                                       
-    # Error raised when an invalid statement is executed.
-    class InvalidStatement < Error; end
-
-    # Represents an Invalid transform.
-    class InvalidTransform < Error ; end
-    
-    # Represents an invalid value stored in the database.
-    class InvalidValue < Error ; end
-                                       
-    # Represents an attempt to performing filter operations when no filter has been specified yet.
-    class NoExistingFilter < Error ; end
-                                       
-    # There was an error while waiting on a connection from the connection pool
-    class PoolTimeoutError < Error ; end
-                                       
-    # Rollback is a special error used to rollback a transactions.
-    # A transaction block will catch this error and won't pass further up the stack.
-    class Rollback < Error ; end
-  end  
-
-  # Generic error raised by the database adapters, indicating a
-  # problem originating from the database server.
-  class DatabaseError < Error; end
-  
-  # Error raised when the Sequel is unable to connect to the database with the
-  # connection parameters it was given.
-  class DatabaseConnectionError < DatabaseError; end
-
-  # Error that should be raised by adapters when they determine that the connection
-  # to the database has been lost.  Instructs the connection pool code to 
-  # remove that connection from the pool so that other connections can be acquired
-  # automatically.
-  class DatabaseDisconnectError < DatabaseError; end
-end

data/lib/sequel_core/schema.rb

@@ -1,2 +0,0 @@
-require 'sequel_core/schema/generator'
-require 'sequel_core/schema/sql'

data/lib/sequel_core/schema/sql.rb

@@ -1,325 +0,0 @@
-module Sequel
-  module Schema
-    module SQL
-      AUTOINCREMENT = 'AUTOINCREMENT'.freeze
-      CASCADE = 'CASCADE'.freeze
-      COMMA_SEPARATOR = ', '.freeze
-      NO_ACTION = 'NO ACTION'.freeze
-      NOT_NULL = ' NOT NULL'.freeze
-      NULL = ' NULL'.freeze
-      PRIMARY_KEY = ' PRIMARY KEY'.freeze
-      RESTRICT = 'RESTRICT'.freeze
-      SET_DEFAULT = 'SET DEFAULT'.freeze
-      SET_NULL = 'SET NULL'.freeze
-      TYPES = Hash.new {|h, k| k}
-      TYPES.merge!(:double=>'double precision', String=>'varchar(255)',
-        Integer=>'integer', Fixnum=>'integer', Bignum=>'bigint',
-        Float=>'double precision', BigDecimal=>'numeric', Numeric=>'numeric',
-        Date=>'date', DateTime=>'timestamp', Time=>'timestamp', File=>'blob',
-        TrueClass=>'boolean', FalseClass=>'boolean')
-      UNDERSCORE = '_'.freeze
-      UNIQUE = ' UNIQUE'.freeze
-      UNSIGNED = ' UNSIGNED'.freeze
-
-      # The SQL to execute to modify the DDL for the given table name.  op
-      # should be one of the operations returned by the AlterTableGenerator.
-      def alter_table_sql(table, op)
-        quoted_name = quote_identifier(op[:name]) if op[:name]
-        alter_table_op = case op[:op]
-        when :add_column
-          "ADD COLUMN #{column_definition_sql(op)}"
-        when :drop_column
-          "DROP COLUMN #{quoted_name}"
-        when :rename_column
-          "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
-        when :set_column_type
-          "ALTER COLUMN #{quoted_name} TYPE #{type_literal(op)}"
-        when :set_column_default
-          "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
-        when :set_column_null
-          "ALTER COLUMN #{quoted_name} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
-        when :add_index
-          return index_definition_sql(table, op)
-        when :drop_index
-          return drop_index_sql(table, op)
-        when :add_constraint
-          "ADD #{constraint_definition_sql(op)}"
-        when :drop_constraint
-          "DROP CONSTRAINT #{quoted_name}"
-        else
-          raise Error, "Unsupported ALTER TABLE operation"
-        end
-        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op}"
-      end
-
-      # Array of SQL DDL modification statements for the given table,
-      # corresponding to the DDL changes specified by the operations.
-      def alter_table_sql_list(table, operations)
-        operations.map{|op| alter_table_sql(table, op)}
-      end
-      
-      # The SQL string specify the autoincrement property, generally used by
-      # primary keys.
-      def auto_increment_sql
-        AUTOINCREMENT
-      end
-      
-      # SQL DDL fragment containing the column creation SQL for the given column.
-      def column_definition_sql(column)
-        return constraint_definition_sql(column) if column[:type] == :check
-        sql = "#{quote_identifier(column[:name])} #{type_literal(column)}"
-        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]
-        sql << column_references_sql(column) if column[:table]
-        sql
-      end
-      
-      # SQL DDL fragment containing the column creation
-      # SQL for all given columns, used instead a CREATE TABLE block.
-      def column_list_sql(columns)
-        columns.map{|c| column_definition_sql(c)}.join(COMMA_SEPARATOR)
-      end
-
-      # SQL DDL fragment for column foreign key references
-      def column_references_sql(column)
-        sql = " REFERENCES #{quote_schema_table(column[:table])}"
-        sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
-        sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        sql << " ON UPDATE #{on_delete_clause(column[:on_update])}" if column[:on_update]
-        sql
-      end
-    
-      # SQL DDL fragment specifying a constraint on a table.
-      def constraint_definition_sql(constraint)
-        sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
-        case constraint[:constraint_type]
-        when :primary_key
-          sql << "PRIMARY KEY #{literal(constraint[:columns])}"
-        when :foreign_key
-          sql << "FOREIGN KEY #{literal(constraint[:columns])}"
-          sql << column_references_sql(constraint)
-        when :unique
-          sql << "UNIQUE #{literal(constraint[:columns])}"
-        else
-          check = constraint[:check]
-          sql << "CHECK #{filter_expr((check.is_a?(Array) && check.length == 1) ? check.first : check)}"
-        end
-        sql
-      end
-
-      # Array of SQL DDL statements, the first for creating a table with the given
-      # name and column specifications, and the others for specifying indexes on
-      # the table.
-      def create_table_sql_list(name, columns, indexes = nil, options = {})
-        sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})"]
-        sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
-        sql
-      end
-      
-      # Default index name for the table and columns, may be too long
-      # for certain databases.
-      def default_index_name(table_name, columns)
-        schema, table = schema_and_table(table_name)
-        "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.map{|c| c.is_one_of?(String, Symbol) ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
-      end
-    
-      # The SQL to drop an index for the table.
-      def drop_index_sql(table, op)
-        "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}"
-      end
-
-      # SQL DDL statement to drop the table with the given name.
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)}"
-      end
-      
-      # Proxy the filter_expr call to the dataset, used for creating constraints.
-      def filter_expr(*args, &block)
-        schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
-      end
-
-      # SQL DDL statement for creating an index for the table with the given name
-      # and index specifications.
-      def index_definition_sql(table_name, index)
-        index_name = index[:name] || default_index_name(table_name, index[:columns])
-        if index[:type]
-          raise Error, "Index types are not supported for this database"
-        elsif index[:where]
-          raise Error, "Partial indexes are not supported for this database"
-        else
-          "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_identifier(table_name)} #{literal(index[:columns])}"
-        end
-      end
-    
-      # Array of SQL DDL statements, one for each index specification,
-      # for the given table.
-      def index_list_sql_list(table_name, indexes)
-        indexes.map{|i| index_definition_sql(table_name, i)}
-      end
-  
-      # Proxy the literal call to the dataset, used for default values.
-      def literal(v)
-        schema_utility_dataset.literal(v)
-      end
-      
-      # SQL DDL ON DELETE fragment to use, based on the given action.
-      # The following actions are recognized:
-      # 
-      # * :cascade - Delete rows referencing this row.
-      # * :no_action (default) - Raise an error if other rows reference this
-      #   row, allow deferring of the integrity check.
-      # * :restrict - Raise an error if other rows reference this row,
-      #   but do not allow deferring the integrity check.
-      # * :set_default - Set columns referencing this row to their default value.
-      # * :set_null - Set columns referencing this row to NULL.
-      def on_delete_clause(action)
-        case action
-        when :restrict
-          RESTRICT
-        when :cascade
-          CASCADE
-        when :set_null
-          SET_NULL
-        when :set_default
-          SET_DEFAULT
-        else
-          NO_ACTION
-        end
-      end
-      
-      # Proxy the quote_schema_table method to the dataset
-      def quote_schema_table(table)
-        schema_utility_dataset.quote_schema_table(table)
-      end
-      
-      # Proxy the quote_identifier method to the dataset, used for quoting tables and columns.
-      def quote_identifier(v)
-        schema_utility_dataset.quote_identifier(v)
-      end
-      
-      # SQL DDL statement for renaming a table.
-      def rename_table_sql(name, new_name)
-        "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
-      end
-
-      # Parse the schema from the database.
-      # If the table_name is not given, returns the schema for all tables as a hash.
-      # If the table_name is given, returns the schema for a single table as an
-      # array with all members being arrays of length 2.  Available options are:
-      #
-      # * :reload - Get fresh information from the database, instead of using
-      #   cached information.  If table_name is blank, :reload should be used
-      #   unless you are sure that schema has not been called before with a
-      #   table_name, otherwise you may only getting the schemas for tables
-      #   that have been requested explicitly.
-      # * :schema - An explicit schema to use.  It may also be implicitly provided
-      #   via the table name.
-      def schema(table = nil, opts={})
-        raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
-
-        if table
-          sch, table_name = schema_and_table(table)
-          quoted_name = quote_schema_table(table)
-        end
-        opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
-        if opts[:reload] && @schemas
-          if table_name
-            @schemas.delete(quoted_name)
-          else
-            @schemas = nil
-          end
-        end
-
-        if @schemas
-          if table_name
-            return @schemas[quoted_name] if @schemas[quoted_name]
-          else
-            return @schemas
-          end
-        end
-        
-        raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true)
-
-        @schemas ||= Hash.new do |h,k|
-          quote_name = quote_schema_table(k)
-          h[quote_name] if h.include?(quote_name)
-        end
-
-        if table_name
-          cols = schema_parse_table(table_name, opts)
-          raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.blank?
-          @schemas[quoted_name] = cols
-        else
-          tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)}
-          @schemas
-        end
-      end
-      
-      # The dataset to use for proxying certain schema methods.
-      def schema_utility_dataset
-        @schema_utility_dataset ||= dataset
-      end
-      
-      private
-
-      # Remove the cached schema for the given schema name
-      def remove_cached_schema(table)
-        @schemas.delete(quote_schema_table(table)) if @schemas
-      end
-      
-      # Remove the cached schema_utility_dataset, because the identifier
-      # quoting has changed.
-      def reset_schema_utility_dataset
-        @schema_utility_dataset = nil
-      end
-
-      # Match the database's column type to a ruby type via a
-      # regular expression.  The following ruby types are supported:
-      # integer, string, date, datetime, boolean, and float.
-      def schema_column_type(db_type)
-        case db_type
-        when /\Atinyint/io
-          Sequel.convert_tinyint_to_bool ? :boolean : :integer
-        when /\Ainterval\z/io
-          :interval
-        when /\A(character( varying)?|varchar|text)/io
-          :string
-        when /\A(int(eger)?|bigint|smallint)/io
-          :integer
-        when /\Adate\z/io
-          :date
-        when /\A(datetime|timestamp( with(out)? time zone)?)\z/io
-          :datetime
-        when /\Atime( with(out)? time zone)?\z/io
-          :time
-        when /\Aboolean\z/io
-          :boolean
-        when /\A(real|float|double( precision)?)\z/io
-          :float
-        when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/io
-          :decimal
-        when /\Abytea\z/io
-          :blob
-        end
-      end
-
-      # SQL fragment specifying the type of a given column.
-      def type_literal(column)
-        type = type_literal_base(column)
-        column[:size] ||= 255 if type.to_s == 'varchar'
-        elements = column[:size] || column[:elements]
-        "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
-      end
-
-      # SQL fragment specifying the base type of a given column,
-      # without the size or elements.
-      def type_literal_base(column)
-        TYPES[column[:type]]
-      end
-    end
-  end
-end

data/lib/sequel_model/association_reflection.rb

@@ -1,267 +0,0 @@
-module Sequel::Model::Associations
-  # Map of association type symbols to association reflection classes.
-  ASSOCIATION_TYPES = {}
-
-  # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
-  # provides methods to reduce internal code duplication.  It should not
-  # be instantiated by the user.
-  class AssociationReflection < Hash
-    # Name symbol for _add_ internal association method
-    def _add_method
-      :"_add_#{self[:name].to_s.singularize}"
-    end
-  
-    # Name symbol for _dataset association method
-    def _dataset_method
-      :"_#{self[:name]}_dataset"
-    end
-  
-    # Name symbol for _remove_all internal association method
-    def _remove_all_method
-      :"_remove_all_#{self[:name]}"
-    end
-  
-    # Name symbol for _remove_ internal association method
-    def _remove_method
-      :"_remove_#{self[:name].to_s.singularize}"
-    end
-  
-    # Name symbol for setter association method
-    def _setter_method
-      :"_#{self[:name]}="
-    end
-  
-    # Name symbol for add_ association method
-    def add_method
-      :"add_#{self[:name].to_s.singularize}"
-    end
-  
-    # Name symbol for association method, the same as the name of the association.
-    def association_method
-      self[:name]
-    end
-  
-    # The class associated to the current model class via this association
-    def associated_class
-      self[:class] ||= self[:class_name].constantize
-    end
-  
-    # Name symbol for dataset association method
-    def dataset_method
-      :"#{self[:name]}_dataset"
-    end
-  
-    # Name symbol for _helper internal association method
-    def dataset_helper_method
-      :"_#{self[:name]}_dataset_helper"
-    end
-  
-    # Whether the dataset needs a primary key to function, true by default.
-    def dataset_need_primary_key?
-      true
-    end
-
-    # Whether to eagerly graph a lazy dataset, true by default.
-    def eager_graph_lazy_dataset?
-      true
-    end
-
-    # Whether the associated object needs a primary key to be added/removed,
-    # false by default.
-    def need_associated_primary_key?
-      false
-    end
-
-    # Returns/sets the reciprocal association variable, if one exists
-    def reciprocal
-      return self[:reciprocal] if include?(:reciprocal)
-      r_type = reciprocal_type
-      key = self[:key]
-      associated_class.all_association_reflections.each do |assoc_reflect|
-        if assoc_reflect[:type] == r_type && assoc_reflect[:key] == key
-          return self[:reciprocal] = assoc_reflect[:name]
-        end
-      end
-      self[:reciprocal] = nil
-    end
-
-    # Whether the reciprocal of this  association returns an array of objects instead of a single object,
-    # true by default.
-    def reciprocal_array?
-      true
-    end
-
-    # Name symbol for remove_all_ association method
-    def remove_all_method
-      :"remove_all_#{self[:name]}"
-    end
-  
-    # Name symbol for remove_ association method
-    def remove_method
-      :"remove_#{self[:name].to_s.singularize}"
-    end
-  
-    # Whether this association returns an array of objects instead of a single object,
-    # true by default.
-    def returns_array?
-      true
-    end
-
-    # The columns to select when loading the association, nil by default.
-    def select
-      self[:select]
-    end
-
-    # By default, associations shouldn't set the reciprocal association to self.
-    def set_reciprocal_to_self?
-      false
-    end
-
-    # Name symbol for setter association method
-    def setter_method
-      :"#{self[:name]}="
-    end
-
-  end
-
-  class ManyToOneAssociationReflection < AssociationReflection
-    ASSOCIATION_TYPES[:many_to_one] = self
-
-    # Whether the dataset needs a primary key to function, false for many_to_one associations.
-    def dataset_need_primary_key?
-      false
-    end
-
-    # Default foreign key name symbol for foreign key in current model's table that points to
-    # the given association's table's primary key.
-    def default_key
-      :"#{self[:name]}_id"
-    end
-  
-    # Whether to eagerly graph a lazy dataset, true for many_to_one associations
-    # only if the key is nil.
-    def eager_graph_lazy_dataset?
-      self[:key].nil?
-    end
-
-    # The key to use for the key hash when eager loading
-    def eager_loader_key
-      self[:key]
-    end
-
-    # The column in the associated table that the key in the current table references.
-    def primary_key
-     self[:primary_key] ||= associated_class.primary_key
-    end
-  
-    # Whether this association returns an array of objects instead of a single object,
-    # false for a many_to_one association.
-    def returns_array?
-      false
-    end
-
-    private
-
-    # The reciprocal type of a many_to_one association is a one_to_many association.
-    def reciprocal_type
-      :one_to_many
-    end
-  end
-
-  class OneToManyAssociationReflection < AssociationReflection
-    ASSOCIATION_TYPES[:one_to_many] = self
-
-    # Default foreign key name symbol for key in associated table that points to
-    # current table's primary key.
-    def default_key
-      :"#{self[:model].name.to_s.demodulize.underscore}_id"
-    end
-
-    # The key to use for the key hash when eager loading
-    def eager_loader_key
-      primary_key
-    end
-
-    # The column in the current table that the key in the associated table references.
-    def primary_key
-     self[:primary_key] ||= self[:model].primary_key
-    end
-  
-    # One to many associations set the reciprocal to self.
-    def set_reciprocal_to_self?
-      true
-    end
-
-    # Whether the reciprocal of this  association returns an array of objects instead of a single object,
-    # false for a one_to_many association.
-    def reciprocal_array?
-      false
-    end
-
-    private
-
-    # The reciprocal type of a one_to_many association is a many_to_one association.
-    def reciprocal_type
-      :many_to_one
-    end
-  end
-
-  class ManyToManyAssociationReflection < AssociationReflection
-    ASSOCIATION_TYPES[:many_to_many] = self
-
-    # Default name symbol for the join table.
-    def default_join_table
-      ([self[:class_name].demodulize, self[:model].name.to_s.demodulize]. \
-        map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
-    end
-  
-    # Default foreign key name symbol for key in join table that points to
-    # current table's primary key (or :left_primary_key column).
-    def default_left_key
-      :"#{self[:model].name.to_s.demodulize.underscore}_id"
-    end
-
-    # Default foreign key name symbol for foreign key in join table that points to
-    # the association's table's primary key (or :right_primary_key column).
-    def default_right_key
-      :"#{self[:name].to_s.singularize}_id"
-    end
-  
-    # The key to use for the key hash when eager loading
-    def eager_loader_key
-      self[:left_primary_key]
-    end
-
-    # Whether the associated object needs a primary key to be added/removed,
-    # true for many_to_many associations.
-    def need_associated_primary_key?
-      true
-    end
-
-    # Returns/sets the reciprocal association variable, if one exists
-    def reciprocal
-      return self[:reciprocal] if include?(:reciprocal)
-      left_key = self[:left_key]
-      right_key = self[:right_key]
-      join_table = self[:join_table]
-      associated_class.all_association_reflections.each do |assoc_reflect|
-        if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key \
-           && assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table
-          return self[:reciprocal] = assoc_reflect[:name]
-        end
-      end
-      self[:reciprocal] = nil
-    end
-
-    # The primary key column to use in the associated table.
-    def right_primary_key
-      self[:right_primary_key] ||= associated_class.primary_key
-    end
-
-    # The columns to select when loading the association, associated_class.table_name.* by default.
-    def select
-     return self[:select] if include?(:select)
-     self[:select] ||= associated_class.table_name.*
-    end
-  end
-end