colincasey-sequel 2.10.0 → 2.10.1

data/lib/sequel_core/version.rb

@@ -0,0 +1,11 @@
+module Sequel
+  MAJOR = 2
+  MINOR = 10
+  TINY  = 0
+  
+  VERSION = [MAJOR, MINOR, TINY].join('.')
+  
+  def self.version
+    VERSION
+  end
+end

data/lib/sequel_core.rb

@@ -0,0 +1,172 @@
+%w'bigdecimal bigdecimal/util date enumerator thread time uri yaml'.each do |f|
+  require f
+end
+%w"core_ext sql core_sql connection_pool exceptions pretty_table
+  dataset migration schema database object_graph version".each do |f|
+  require "sequel_core/#{f}"
+end
+
+# Top level module for Sequel
+#
+# There are some class methods that are added via metaprogramming, one for
+# each supported adapter.  For example:
+#
+#   DB = Sequel.sqlite # Memory database
+#   DB = Sequel.sqlite('blog.db')
+#   DB = Sequel.postgres('database_name', :user=>'user', 
+#          :password=>'password', :host=>'host', :port=>5432, 
+#          :max_connections=>10)
+#
+# If a block is given to these methods, it is passed the opened Database
+# object, which is closed (disconnected) when the block exits.  For example:
+#
+#   Sequel.sqlite('blog.db'){|db| puts db.users.count}  
+#
+# Sequel converts the column type tinyint to a boolean by default,
+# you can override the conversion to use tinyint as an integer:
+#
+#   Sequel.convert_tinyint_to_bool = false
+#
+# Sequel converts two digit years in Dates and DateTimes by default,
+# so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
+# as December 13, 1999.. You can override this # to treat those dates as
+# January 2nd, 0003 and December 13, 0099, respectively, by setting: 
+#
+#   Sequel.convert_two_digit_years = false
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.datetime_class = DateTime
+module Sequel
+  @convert_tinyint_to_bool = true
+  @convert_two_digit_years = true
+  @datetime_class = Time
+  
+  metaattr_accessor :convert_tinyint_to_bool
+  metaattr_accessor :convert_two_digit_years
+  metaattr_accessor :datetime_class
+
+  # Creates a new database object based on the supplied connection string
+  # and optional arguments.  The specified scheme determines the database
+  # class used, and the rest of the string specifies the connection options.
+  # For example:
+  #
+  #   DB = Sequel.connect('sqlite:/') # Memory database
+  #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
+  #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
+  #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
+  #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
+  #
+  # If a block is given, it is passed the opened Database object, which is
+  # closed when the block exits.  For example:
+  #
+  #   Sequel.connect('sqlite://blog.db'){|db| puts db.users.count}  
+  #
+  # This is also aliased as Sequel.open.
+  def self.connect(*args, &block)
+    Database.connect(*args, &block)
+  end
+  metaalias :open, :connect
+  
+  # Set the method to call on identifiers going into the database.  This affects
+  # the literalization of identifiers by calling this method on them before they are input.
+  # Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:
+  #
+  #   Sequel.identifier_input_method = nil
+  # 
+  # to downcase instead:
+  #
+  #   Sequel.identifier_input_method = :downcase
+  #
+  # Other string methods work as well.
+  def self.identifier_input_method=(value)
+    Database.identifier_input_method = value
+  end
+  
+  # Set the method to call on identifiers coming out of the database.  This affects
+  # the literalization of identifiers by calling this method on them when they are
+  # retrieved from the database.  Sequel downcases identifiers retrieved for most
+  # databases, so to turn that off:
+  #
+  #   Sequel.identifier_output_method = nil
+  # 
+  # to upcase instead:
+  #
+  #   Sequel.identifier_output_method = :upcase
+  #
+  # Other string methods work as well.
+  def self.identifier_output_method=(value)
+    Database.identifier_output_method = value
+  end
+  
+  # Set whether to quote identifiers for all databases by default. By default,
+  # Sequel quotes identifiers in all SQL strings, so to turn that off:
+  #
+  #   Sequel.quote_identifiers = false
+  def self.quote_identifiers=(value)
+    Database.quote_identifiers = value
+  end
+  
+  # Set whether to set the single threaded mode for all databases by default. By default,
+  # Sequel uses a threadsafe connection pool, which isn't as fast as the
+  # single threaded connection pool.  If your program will only have one thread,
+  # and speed is a priority, you may want to set this to true:
+  #
+  #   Sequel.single_threaded = true
+  def self.single_threaded=(value)
+    Database.single_threaded = value
+  end
+
+  # Set whether to upcase identifiers for all databases by default. By default,
+  # Sequel upcases identifiers unless the database folds unquoted identifiers to
+  # lower case (MySQL, PostgreSQL, and SQLite).
+  #
+  #   Sequel.upcase_identifiers = false
+  #
+  # This will set the indentifier_input_method to :upcase if value is true
+  # or nil if value is false.
+  def self.upcase_identifiers=(value)
+    Database.upcase_identifiers = value
+  end
+  
+  # Always returns false, since ParseTree support has been removed.
+  def self.use_parse_tree
+    false
+  end
+
+  # Raises an error if attempting to turn ParseTree support on (since it no longer exists).
+  # Otherwise, is a no-op.
+  def self.use_parse_tree=(val)
+    raise(Error, 'ParseTree support has been removed from Sequel') if val
+  end
+  
+  ### Private Class Methods ###
+
+  # Helper method that the database adapter class methods that are added to Sequel via
+  # metaprogramming use to parse arguments.
+  def self.adapter_method(adapter, *args, &block) # :nodoc:
+    raise(::Sequel::Error, "Wrong number of arguments, 0-2 arguments valid") if args.length > 2
+    opts = {:adapter=>adapter.to_sym}
+    opts[:database] = args.shift if args.length >= 1 && !(args[0].is_a?(Hash))
+    if Hash === (arg = args[0])
+      opts.merge!(arg)
+    elsif !arg.nil?
+      raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+    end
+    connect(opts, &block)
+  end
+
+  # Method that adds a database adapter class method to Sequel that calls
+  # Sequel.adapter_method.
+  def self.def_adapter_method(*adapters) # :nodoc:
+    adapters.each do |adapter|
+      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end")
+    end
+  end
+
+  private_class_method :adapter_method, :def_adapter_method
+  
+  # Add the database adapter class methods to Sequel via metaprogramming
+  def_adapter_method(*Database::ADAPTERS)
+end

data/lib/sequel_model/association_reflection.rb

@@ -0,0 +1,267 @@
+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