viking-sequel 3.10.0

data/lib/sequel/extensions/named_timezones.rb

@@ -0,0 +1,61 @@
+# Allows the use of named timezones via TZInfo (requires tzinfo).
+# Forces the use of DateTime as Sequel's datetime_class, since
+# ruby's Time class doesn't support timezones other than local
+# and UTC.
+#
+# This allows you to either pass strings or TZInfo::Timezone
+# instance to Sequel.database_timezone=, application_timezone=, and
+# typecast_timezone=.  If a string is passed, it is converted to a
+# TZInfo::Timezone using TZInfo::Timezone.get.
+#
+# Let's say you have the database server in New York and the
+# application server in Los Angeles.  For historical reasons, data
+# is stored in local New York time, but the application server only
+# services clients in Los Angeles, so you want to use New York
+# time in the database and Los Angeles time in the application.  This
+# is easily done via:
+#
+#   Sequel.database_timezone = 'America/New_York'
+#   Sequel.application_timezone = 'America/Los_Angeles'
+#
+# Then, before data is stored in the database, it is converted to New
+# York time.  When data is retrieved from the database, it is
+# converted to Los Angeles time.
+
+require 'tzinfo'
+
+module Sequel
+  self.datetime_class = DateTime
+  
+  module NamedTimezones
+    private 
+    
+    # Assume the given DateTime has a correct time but a wrong timezone.  It is
+    # currently in UTC timezone, but it should be converted to the input_timzone.
+    # Keep the time the same but convert the timezone to the input_timezone.
+    # Expects the input_timezone to be a TZInfo::Timezone instance.
+    def convert_input_datetime_other(v, input_timezone)
+      local_offset = input_timezone.period_for_local(v).utc_total_offset_rational
+      (v - local_offset).new_offset(local_offset)
+    end
+
+    # Convert the given DateTime to use the given output_timezone.
+    # Expects the output_timezone to be a TZInfo::Timezone instance.
+    def convert_output_datetime_other(v, output_timezone)
+      # TZInfo converts times, but expects the given DateTime to have an offset
+      # of 0 and always leaves the timezone offset as 0
+      v = output_timezone.utc_to_local(v.new_offset(0))
+      local_offset = output_timezone.period_for_local(v).utc_total_offset_rational
+      # Convert timezone offset from UTC to the offset for the output_timezone
+      (v - local_offset).new_offset(local_offset)
+    end
+    
+    # Convert the timezone setter argument.  Returns argument given by default,
+    # exists for easier overriding in extensions.
+    def convert_timezone_setter_arg(tz)
+      tz.is_a?(String) ? TZInfo::Timezone.get(tz) : super
+    end
+  end
+  
+  extend NamedTimezones
+end

data/lib/sequel/extensions/pagination.rb

@@ -0,0 +1,100 @@
+# The pagination extension adds the Sequel::Dataset#paginate and #each_page methods,
+# which return paginated (limited and offset) datasets with some helpful methods
+# that make creating a paginated display easier.
+
+module Sequel
+  class Dataset
+    # Returns a paginated dataset. The returned dataset is limited to
+    # the page size at the correct offset, and extended with the Pagination
+    # module.  If a record count is not provided, does a count of total
+    # number of records for this dataset.
+    def paginate(page_no, page_size, record_count=nil)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      paginated = limit(page_size, (page_no - 1) * page_size)
+      paginated.extend(Pagination)
+      paginated.set_pagination_info(page_no, page_size, record_count || count)
+    end
+      
+    # Yields a paginated dataset for each page and returns the receiver. Does
+    # a count to find the total number of records for this dataset.
+    def each_page(page_size, &block)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      record_count = count
+      total_pages = (record_count / page_size.to_f).ceil
+      (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
+      self
+    end
+
+    # Holds methods that only relate to paginated datasets. Paginated dataset
+    # have pages starting at 1 (page 1 is offset 0, page 1 is offset page_size).
+    module Pagination
+      # The number of records per page (the final page may have fewer than
+      # this number of records).
+      attr_accessor :page_size
+
+      # The number of pages in the dataset before pagination, of which
+      # this paginated dataset is one.
+      attr_accessor :page_count
+
+      # The current page of the dataset, starting at 1 and not 0.
+      attr_accessor :current_page
+
+      # The total number of records in the dataset before pagination.
+      attr_accessor :pagination_record_count
+
+      # Returns the record range for the current page
+      def current_page_record_range
+        return (0..0) if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        a..b
+      end
+
+      # Returns the number of records in the current page
+      def current_page_record_count
+        return 0 if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        b - a + 1
+      end
+
+      # Returns true if the current page is the first page
+      def first_page?
+        @current_page == 1
+      end
+
+      # Returns true if the current page is the last page
+      def last_page?
+        @current_page == @page_count
+      end
+
+      # Returns the next page number or nil if the current page is the last page
+      def next_page
+        current_page < page_count ? (current_page + 1) : nil
+      end
+      
+      # Returns the page range
+      def page_range
+        1..page_count
+      end
+      
+      # Returns the previous page number or nil if the current page is the first
+      def prev_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      # Sets the pagination info for this paginated dataset, and returns self.
+      def set_pagination_info(page_no, page_size, record_count)
+        @current_page = page_no
+        @page_size = page_size
+        @pagination_record_count = record_count
+        @page_count = (record_count / page_size.to_f).ceil
+        self
+      end
+    end
+  end
+end

data/lib/sequel/extensions/pretty_table.rb

@@ -0,0 +1,82 @@
+# The pretty_table extension adds Sequel::Dataset#print and the
+# Sequel::PrettyTable class for creating nice-looking plain-text
+# tables.
+
+module Sequel
+  class Dataset
+    # Pretty prints the records in the dataset as plain-text table.
+    def print(*cols)
+      Sequel::PrettyTable.print(naked.all, cols.empty? ? columns : cols)
+    end
+  end
+
+  module PrettyTable
+    # Prints nice-looking plain-text tables via puts
+    # 
+    #   +--+-------+
+    #   |id|name   |
+    #   |--+-------|
+    #   |1 |fasdfas|
+    #   |2 |test   |
+    #   +--+-------+
+    def self.print(records, columns = nil) # records is an array of hashes
+      columns ||= records.first.keys.sort_by{|x|x.to_s}
+      sizes = column_sizes(records, columns)
+      sep_line = separator_line(columns, sizes)
+
+      puts sep_line
+      puts header_line(columns, sizes)
+      puts sep_line
+      records.each {|r| puts data_line(columns, sizes, r)}
+      puts sep_line
+    end
+
+    ### Private Module Methods ###
+
+    # Hash of the maximum size of the value for each column 
+    def self.column_sizes(records, columns) # :nodoc:
+      sizes = Hash.new {0}
+      columns.each do |c|
+        s = c.to_s.size
+        sizes[c.to_sym] = s if s > sizes[c.to_sym]
+      end
+      records.each do |r|
+        columns.each do |c|
+          s = r[c].to_s.size
+          sizes[c.to_sym] = s if s > sizes[c.to_sym]
+        end
+      end
+      sizes
+    end
+    
+    # String for each data line
+    def self.data_line(columns, sizes, record) # :nodoc:
+      '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+    end
+    
+    # Format the value so it takes up exactly size characters
+    def self.format_cell(size, v) # :nodoc:
+      case v
+      when Bignum, Fixnum
+        "%#{size}d" % v
+      when Float
+        "%#{size}g" % v
+      else
+        "%-#{size}s" % v.to_s
+      end
+    end
+    
+    # String for header line
+    def self.header_line(columns, sizes) # :nodoc:
+      '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+    end
+
+    # String for separtor line
+    def self.separator_line(columns, sizes) # :nodoc:
+      '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+    end
+
+    private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+  end
+end
+

data/lib/sequel/extensions/query.rb

@@ -0,0 +1,52 @@
+# The query extension adds Sequel::Dataset#query which allows
+# a different way to construct queries instead of the usual
+# method chaining.
+
+module Sequel
+  class Database
+    # Return a dataset modified by the query block
+    def query(&block)
+      dataset.query(&block)
+    end
+  end
+
+  class Dataset
+    # Translates a query block into a dataset. Query blocks can be useful
+    # when expressing complex SELECT statements, e.g.:
+    #
+    #   dataset = DB[:items].query do
+    #     select :x, :y, :z
+    #     filter{|o| (o.x > 1) & (o.y > 2)}
+    #     order :z.desc
+    #   end
+    #
+    # Which is the same as:
+    #
+    #  dataset = DB[:items].select(:x, :y, :z).filter{|o| (o.x > 1) & (o.y > 2)}.order(:z.desc)
+    #
+    # Note that inside a call to query, you cannot call each, insert, update,
+    # or delete (or any method that calls those), or Sequel will raise an
+    # error.
+    def query(&block)
+      copy = clone({})
+      copy.extend(QueryBlockCopy)
+      copy.instance_eval(&block)
+      clone(copy.opts)
+    end
+
+    # Module used by Dataset#query that has the effect of making all
+    # dataset methods into !-style methods that modify the receiver.
+    module QueryBlockCopy
+      %w'each insert update delete'.each do |meth|
+        define_method(meth){|*args| raise Error, "##{meth} cannot be invoked inside a query block."}
+      end
+
+      # Merge the given options into the receiver's options and return the receiver
+      # instead of cloning the receiver.
+      def clone(opts = nil)
+        @opts.merge!(opts)
+        self
+      end
+    end
+  end
+end

data/lib/sequel/extensions/schema_dumper.rb

@@ -0,0 +1,271 @@
+# The schema_dumper extension supports dumping tables and indexes
+# in a Sequel::Migration format, so they can be restored on another
+# database (which can be the same type or a different type than
+# the current database).  The main interface is through
+# Sequel::Database#dump_schema_migration.
+
+module Sequel
+  class Database
+    # Dump indexes for all tables as a migration.  This complements
+    # the :indexes=>false option to dump_schema_migration. Options:
+    # * :same_db - Create a dump for the same database type, so
+    #   don't ignore errors if the index statements fail.
+    def dump_indexes_migration(options={})
+      ts = tables(options)
+      <<END_MIG
+Class.new(Sequel::Migration) do
+  def up
+#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+  
+  def down
+#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :drop_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+end
+END_MIG
+    end
+
+    # Return a string that contains a Sequel::Migration subclass that when
+    # run would recreate the database structure. Options:
+    # * :same_db - Don't attempt to translate database types to ruby types.
+    #   If this isn't set to true, all database types will be translated to
+    #   ruby types, but there is no guarantee that the migration generated
+    #   will yield the same type.  Without this set, types that aren't
+    #   recognized will be translated to a string-like type.
+    # * :indexes - If set to false, don't dump indexes (they can be added
+    #   later via dump_index_migration).
+    def dump_schema_migration(options={})
+      ts = tables(options)
+      <<END_MIG
+Class.new(Sequel::Migration) do
+  def up
+#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}
+  end
+  
+  def down
+    drop_table(#{ts.sort_by{|t| t.to_s}.inspect[1...-1]})
+  end
+end
+END_MIG
+    end
+
+    # Return a string with a create table block that will recreate the given
+    # table's schema.  Takes the same options as dump_schema_migration.
+    def dump_table_schema(table, options={})
+      s = schema(table).dup
+      pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
+      options = options.merge(:single_pk=>true) if pks.length == 1
+      m = method(:column_schema_to_generator_opts)
+      im = method(:index_to_generator_opts)
+      indexes = indexes(table).sort_by{|k,v| k.to_s} if options[:indexes] != false and respond_to?(:indexes)
+      gen = Schema::Generator.new(self) do
+        s.each{|name, info| send(*m.call(name, info, options))}
+        primary_key(pks) if !@primary_key && pks.length > 0
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))} if indexes
+      end
+      commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
+      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && indexes && !indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
+    end
+
+    private
+        
+    # If a database default exists and can't be converted, return the string with the inspect
+    # method modified so that .lit is always appended after it, only if the
+    # :same_db option is used.
+    def column_schema_to_ruby_default_fallback(default, options)
+      if default.is_a?(String) && options[:same_db] && use_column_schema_to_ruby_default_fallback?
+        default = default.to_s
+        def default.inspect
+          "#{super}.lit"
+        end
+        default
+      end
+    end
+
+    # Convert the given name and parsed database schema into an array with a method
+    # name and arguments to it to pass to a Schema::Generator to recreate the column.
+    def column_schema_to_generator_opts(name, schema, options)
+      if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
+        type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+          [:primary_key, name]
+        else
+          [:primary_key, name, type_hash]
+        end
+      else
+        col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        type = col_opts.delete(:type)
+        col_opts.delete(:size) if col_opts[:size].nil?
+        col_opts[:default] = if schema[:ruby_default].nil?
+          column_schema_to_ruby_default_fallback(schema[:default], options)
+        else
+          schema[:ruby_default]
+        end
+        col_opts.delete(:default) if col_opts[:default].nil?
+        col_opts[:null] = false if schema[:allow_null] == false
+        [:column, name, type, col_opts]
+      end
+    end
+
+    # Convert the column schema information to a hash of column options, one of which must
+    # be :type.  The other options added should modify that type (e.g. :size).  If a
+    # database type is not recognized, return it as a String type.
+    def column_schema_to_ruby_type(schema)
+      case t = schema[:db_type].downcase
+      when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?\z/o
+        {:type=>Integer}
+      when /\Atinyint(?:\((\d+)\))?\z/o
+        {:type =>schema[:type] == :boolean ? TrueClass : Integer}
+      when /\Abigint(?:\((?:\d+)\))?\z/o
+        {:type=>Bignum}
+      when /\A(?:real|float|double(?: precision)?)\z/o
+        {:type=>Float}
+      when 'boolean'
+        {:type=>TrueClass}
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
+        {:type=>String, :text=>true}
+      when 'date'
+        {:type=>Date}
+      when /\A(?:small)?datetime\z/o
+        {:type=>DateTime}
+      when /\Atimestamp(?: with(?:out)? time zone)?\z/o
+        {:type=>DateTime}
+      when /\Atime(?: with(?:out)? time zone)?\z/o
+        {:type=>Time, :only_time=>true}
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
+      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1)}
+      when /\A(?:small)?money\z/o
+        {:type=>BigDecimal, :size=>[19,2]}
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+        s = [($1.to_i if $1), ($2.to_i if $2)].compact
+        {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+        {:type=>File, :size=>($1.to_i if $1)}
+      when 'year'
+        {:type=>Integer}
+      else
+        {:type=>String}
+      end
+    end
+
+    # Return a string that containing add_index/drop_index method calls for
+    # creating the index migration.
+    def dump_table_indexes(table, meth, options={})
+      return '' unless respond_to?(:indexes)
+      im = method(:index_to_generator_opts)
+      indexes = indexes(table).sort_by{|k,v| k.to_s} 
+      gen = Schema::Generator.new(self) do
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))}
+      end
+      gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])
+    end
+
+    # Convert the parsed index information into options to the Generators index method. 
+    def index_to_generator_opts(table, name, index_opts)
+      h = {}
+      h[:name] = name unless default_index_name(table, index_opts[:columns]) == name.to_s
+      h[:unique] = true if index_opts[:unique]
+      h
+    end
+    
+    # Don't use the "...".lit fallback on MySQL, since the defaults it uses aren't
+    # valid literal SQL values.
+    def use_column_schema_to_ruby_default_fallback?
+      database_type != :mysql
+    end
+  end
+
+  module Schema
+    class Generator
+      # Dump this generator's columns to a string that could be evaled inside
+      # another instance to represent the same columns
+      def dump_columns
+        strings = []
+        cols = columns.dup
+        if pkn = primary_key_name
+          cols.delete_if{|x| x[:name] == pkn}
+          pk = @primary_key.dup
+          pkname = pk.delete(:name)
+          @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
+          strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
+        end
+        cols.each do |c|
+          c = c.dup
+          name = c.delete(:name)
+          type = c.delete(:type)
+          opts = opts_inspect(c)
+          strings << if type.is_a?(Class)
+            "#{type.name} #{name.inspect}#{opts}"
+          else
+            "column #{name.inspect}, #{type.inspect}#{opts}"
+          end
+        end
+        strings.join("\n")
+      end
+
+      # Dump this generator's constraints to a string that could be evaled inside
+      # another instance to represent the same constraints
+      def dump_constraints
+        constraints.map do |c|
+          c = c.dup
+          type = c.delete(:type)
+          case type
+          when :check
+            raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
+            name = c.delete(:name)
+            if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
+              "check #{c[:check].first.inspect[1...-1]}"
+            else
+              "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
+            end
+          else
+            cols = c.delete(:columns)
+            "#{type} #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end.join("\n")
+      end
+
+      # Dump this generator's indexes to a string that could be evaled inside
+      # another instance to represent the same indexes. Options:
+      # * :add_index - Use add_index instead of index, so the methods
+      #   can be called outside of a generator but inside a migration.
+      #   The value of this option should be the table name to use.
+      # * :drop_index - Same as add_index, but create drop_index statements.
+      # * :ignore_errors - Add the ignore_errors option to the outputted indexes
+      def dump_indexes(options={})
+        indexes.map do |c|
+          c = c.dup
+          cols = c.delete(:columns)
+          if table = options[:add_index] || options[:drop_index]
+            "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{', :ignore_errors=>true' if options[:ignore_errors]}#{opts_inspect(c)}"
+          else
+            "index #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end.join("\n")
+      end
+
+      private
+
+      def opts_inspect(opts)
+        if opts[:default]
+          opts = opts.dup
+          de = case d = opts.delete(:default)
+          when BigDecimal, Sequel::SQL::Blob
+            "#{d.class.name}.new(#{d.to_s.inspect})"
+          when DateTime, Date
+            "#{d.class.name}.parse(#{d.to_s.inspect})"
+          when Time
+            "#{d.class.name}.parse(#{d.strftime('%H:%M:%S').inspect})"
+          else
+            d.inspect
+          end
+          ", :default=>#{de}#{", #{opts.inspect[1...-1]}" if opts.length > 0}"
+        else
+          ", #{opts.inspect[1...-1]}" if opts.length > 0
+        end
+      end
+    end
+  end
+end