sequel_core 2.2.0 → 3.8.0

data/lib/sequel_core/pretty_table.rb

@@ -1,71 +0,0 @@
-module Sequel
-  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_core/schema.rb

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

data/lib/sequel_core/schema/generator.rb

@@ -1,239 +0,0 @@
-module Sequel
-  # The Schema module holds the schema generators and the SQL code relating
-  # to SQL DDL (Data Definition Language).
-  module Schema
-    # Schema::Generator is used to create tables.  It takes a Database
-    # object and a block of column/index/constraint specifications, and
-    # creates a table in the database based on the specifications.
-    #
-    # Schema::Generator has some methods but also includes method_missing,
-    # allowing users to specify column type as a method instead of using
-    # the column method, which makes for a nicer DSL.
-    #
-    # See Database#create_table.
-    class Generator
-      # Set the database in which to create the table, and evaluate the block
-      # in the context of this object.
-      def initialize(db, &block)
-        @db = db
-        @columns = []
-        @indexes = []
-        @primary_key = nil
-        instance_eval(&block) if block
-      end
-      
-      # Add a unnamed constraint to the DDL, specified by the given block
-      # or args.
-      def check(*args, &block)
-        constraint(nil, *args, &block)
-      end
-
-      # Add a column with the given name, type, and opts to the DDL. 
-      #
-      # You can also create columns via method missing, so the following are
-      # equivalent:
-      #
-      #   column :number, :integer
-      #   integer :number
-      #
-      # The following options are supported:
-      #
-      # * :default - The default value for the column.
-      # * :index - Create an index on this column.
-      # * :key - For foreign key columns, the column in the associated table
-      #   that this column references.  Unnecessary if this column
-      #   references the primary key of the associated table.
-      # * :null - Mark the column as allowing NULL values (if true),
-      #   or not allowing NULL values (if false).  If unspecified, will default
-      #   to whatever the database default is.
-      # * :on_delete - Specify the behavior of this column when being deleted.
-      #   See Schema::SQL#on_delete_clause for options.
-      # * :size - The size of the column, generally used with string
-      #   columns to specify the maximum number of characters the column will hold.
-      # * :unique - Mark the column is unique, generally has the same effect as
-      #   creating a unique index on the column.
-      # * :unsigned - Make the column type unsigned, only useful for integer
-      #   columns.
-      def column(name, type, opts = {})
-        @columns << {:name => name, :type => type}.merge(opts)
-        index(name) if opts[:index]
-      end
-      
-      # Adds a named constraint (or unnamed if name is nil) to the DDL,
-      # with the given block or args.
-      def constraint(name, *args, &block)
-        @columns << {:name => name, :type => :check, :check => block || args}
-      end
-      
-      # Return the DDL created by the generator as a array of two elements,
-      # the first being the columns and the second being the indexes.
-      def create_info
-        @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
-        [@columns, @indexes]
-      end
-
-      # Add a foreign key in the table that references another table to the DDL. See column
-      # for available options.
-      def foreign_key(name, table=nil, opts = {})
-        opts = case table
-        when Hash
-          table.merge(opts)
-        when Symbol
-          opts.merge(:table=>table)
-        when NilClass
-          opts
-        else
-          raise(Error, "The seconds argument to foreign_key should be a Hash, Symbol, or nil")
-        end
-        column(name, :integer, opts)
-      end
-      
-      # Add a full text index on the given columns to the DDL.
-      def full_text_index(columns, opts = {})
-        index(columns, opts.merge(:type => :full_text))
-      end
-      
-      # True if the DDL includes the creation of a column with the given name.
-      def has_column?(name)
-        @columns.any?{|c| c[:name] == name}
-      end
-      
-      # Add an index on the given column(s) with the given options to the DDL.
-      # The available options are:
-      #
-      # * :type - The type of index to use (only supported by some databases)
-      # * :unique - Make the index unique, so duplicate values are not allowed.
-      # * :where - Create a partial index (only supported by some databases)
-      def index(columns, opts = {})
-        @indexes << {:columns => Array(columns)}.merge(opts)
-      end
-      
-      # Add a column with the given type, name, and opts to the DDL.  See column for available
-      # options.
-      def method_missing(type, name = nil, opts = {})
-        name ? column(name, type, opts) : super
-      end
-      
-      # Add a column with the given name and primary key options to the DDL. You
-      # can optionally provide a type argument and/or an options hash argument
-      # to change the primary key options. See column for available options.
-      def primary_key(name, *args)
-        @primary_key = @db.serial_primary_key_options.merge({:name => name})
-        
-        if opts = args.pop
-          opts = {:type => opts} unless opts.is_a?(Hash)
-          if type = args.pop
-            opts.merge!(:type => type)
-          end
-          @primary_key.merge!(opts)
-        end
-        @primary_key
-      end
-      
-      # The name of the primary key for this table, if it has a primary key.
-      def primary_key_name
-        @primary_key[:name] if @primary_key
-      end
-      
-      # Add a spatial index on the given columns to the DDL.
-      def spatial_index(columns, opts = {})
-        index(columns, opts.merge(:type => :spatial))
-      end
-
-      # Add a unique index on the given columns to the DDL.
-      def unique(columns, opts = {})
-        index(columns, opts.merge(:unique => true))
-      end
-    end
-  
-    # The Schema::AlterTableGenerator creates DDL operations on existing tables,
-    # such as adding/removing/modifying columns/indexes/constraints.
-    class AlterTableGenerator
-      # An array of DDL operations to perform
-      attr_reader :operations
-      
-      # Set the Database object to which to apply the DDL, and evaluate the
-      # block in the context of this object.
-      def initialize(db, &block)
-        @db = db
-        @operations = []
-        instance_eval(&block) if block
-      end
-      
-      # Add a column with the given name, type, and opts to the DDL for the table.
-      # See Generator#column for the available options.
-      def add_column(name, type, opts = {})
-        @operations << {:op => :add_column, :name => name, :type => type}.merge(opts)
-      end
-      
-      # Add a constraint with the given name and args to the DDL for the table.
-      # See Generator#constraint.
-      def add_constraint(name, *args, &block)
-        @operations << {:op => :add_constraint, :name => name, :type => :check, \
-          :check => block || args}
-      end
-
-      # Add a foreign key with the given name and referencing the given table
-      # to the DDL for the table.  See Generator#column for the available options.
-      def add_foreign_key(name, table, opts = {})
-        add_column(name, :integer, {:table=>table}.merge(opts))
-      end
-      
-      # Add a full text index on the given columns to the DDL for the table.
-      # See Generator#index for available options.
-      def add_full_text_index(columns, opts = {})
-        add_index(columns, {:type=>:full_text}.merge(opts))
-      end
-      
-      # Add an index on the given columns to the DDL for the table.  See
-      # Generator#index for available options.
-      def add_index(columns, opts = {})
-        @operations << {:op => :add_index, :columns => Array(columns)}.merge(opts)
-      end
-      
-      # Add a primary key to the DDL for the table.  See Generator#column
-      # for the available options.
-      def add_primary_key(name, opts = {})
-        opts = @db.serial_primary_key_options.merge(opts)
-        add_column(name, opts.delete(:type), opts)
-      end
-      
-      # Add a spatial index on the given columns to the DDL for the table.
-      # See Generator#index for available options.
-      def add_spatial_index(columns, opts = {})
-        add_index(columns, {:type=>:spatial}.merge(opts))
-      end
-      
-      # Remove a column from the DDL for the table.
-      def drop_column(name)
-        @operations << {:op => :drop_column, :name => name}
-      end
-      
-      # Remove a constraint from the DDL for the table.
-      def drop_constraint(name)
-        @operations << {:op => :drop_constraint, :name => name}
-      end
-      
-      # Remove an index from the DDL for the table.
-      def drop_index(columns)
-        @operations << {:op => :drop_index, :columns => Array(columns)}
-      end
-
-      # Modify a column's name in the DDL for the table.
-      def rename_column(name, new_name, opts = {})
-        @operations << {:op => :rename_column, :name => name, :new_name => new_name}.merge(opts)
-      end
-      
-      # Modify a column's default value in the DDL for the table.
-      def set_column_default(name, default)
-        @operations << {:op => :set_column_default, :name => name, :default => default}
-      end
-
-      # Modify a column's type in the DDL for the table.
-      def set_column_type(name, type)
-        @operations << {:op => :set_column_type, :name => name, :type => type}
-      end
-    end
-  end
-end
-

data/lib/sequel_core/schema/sql.rb

@@ -1,326 +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[:double] = 'double precision'
-      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_table = quote_identifier(table)
-        quoted_name = quote_identifier(op[:name]) if op[:name]
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{quoted_table} ADD COLUMN #{column_definition_sql(op)}"
-        when :drop_column
-          "ALTER TABLE #{quoted_table} DROP COLUMN #{quoted_name}"
-        when :rename_column
-          "ALTER TABLE #{quoted_table} RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
-        when :set_column_type
-          "ALTER TABLE #{quoted_table} ALTER COLUMN #{quoted_name} TYPE #{op[:type]}"
-        when :set_column_default
-          "ALTER TABLE #{quoted_table} ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
-        when :add_index
-          index_definition_sql(table, op)
-        when :drop_index
-          "DROP INDEX #{default_index_name(table, op[:columns])}"
-        when :add_constraint
-          "ALTER TABLE #{quoted_table} ADD #{constraint_definition_sql(op)}"
-        when :drop_constraint
-          "ALTER TABLE #{quoted_table} DROP CONSTRAINT #{quoted_name}"
-        else
-          raise Error, "Unsupported ALTER TABLE operation"
-        end
-      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(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 << " REFERENCES #{quote_identifier(column[:table])}"
-          sql << "(#{quote_identifier(column[:key])})" if column[:key]
-          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        end
-        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 specifying a constraint on a table.
-      def constraint_definition_sql(constraint)
-        sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
-        sql << "CHECK #{filter_expr(constraint[:check])}"
-        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)
-        sql = ["CREATE TABLE #{quote_identifier(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)
-        "#{table_name}_#{columns.join(UNDERSCORE)}_index"
-      end
-    
-      # SQL DDL statement to drop the table with the given name.
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_identifier(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 #{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_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_identifier(name)} RENAME TO #{quote_identifier(new_name)}"
-      end
-
-      # Parse the schema from the database using the SQL standard INFORMATION_SCHEMA.
-      # 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.
-      def schema(table_name = nil, opts={})
-        if opts[:reload] && @schemas
-          if table_name
-            @schemas.delete(table_name)
-          else
-            @schemas = nil
-          end
-        end
-
-        if table_name
-          return @schemas[table_name] if @schemas && @schemas[table_name]
-        else
-          return @schemas if @schemas
-        end
-
-        if table_name
-          @schemas ||= {}
-          @schemas[table_name] ||= schema_parse_table(table_name, opts)
-        else
-          @schemas = schema_parse_tables(opts)
-        end
-      end
-      
-      # The dataset to use for proxying certain schema methods.
-      def schema_utility_dataset
-        @schema_utility_dataset ||= dataset
-      end
-      
-      # SQL fragment specifying the type of a given column.
-      def type_literal(t)
-        t.is_a?(Symbol) ? t.to_s : literal(t)
-      end
-
-      private
-
-      # 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 'tinyint'
-          Sequel.convert_tinyint_to_bool ? :boolean : :integer
-        when /\A(int(eger)?|bigint|smallint)\z/
-          :integer
-        when /\A(character( varying)?|varchar|text)\z/
-          :string
-        when /\Adate\z/
-          :date
-        when /\A(datetime|timestamp( with(out)? time zone)?)\z/
-          :datetime
-        when /\Atime( with(out)? time zone)?\z/
-          :time
-        when "boolean"
-          :boolean
-        when /\A(real|float|double( precision)?)\z/
-          :float
-        when /\A(numeric|decimal|money)\z/
-          :decimal
-        when "bytea"
-          :blob
-        end
-      end
-
-      # The final dataset used by the schema parser, after all
-      # options have been applied.
-      def schema_ds(table_name, opts)
-        schema_ds_dataset.from(*schema_ds_from(table_name, opts)) \
-          .select(*schema_ds_select(table_name, opts)) \
-          .join(*schema_ds_join(table_name, opts)) \
-          .filter(*schema_ds_filter(table_name, opts))
-      end
-
-      # The blank dataset used by the schema parser.
-      def schema_ds_dataset
-        schema_utility_dataset
-      end
-
-      # Argument array for the schema dataset's filter method.
-      def schema_ds_filter(table_name, opts)
-        if table_name
-          [{:c__table_name=>table_name.to_s}]
-        else
-          [{:t__table_type=>'BASE TABLE'}]
-        end
-      end
-
-      # Argument array for the schema dataset's from method.
-      def schema_ds_from(table_name, opts)
-        [:information_schema__tables___t]
-      end
-
-      # Argument array for the schema dataset's join method.
-      def schema_ds_join(table_name, opts)
-        [:information_schema__columns, {:table_catalog=>:table_catalog,
-          :table_schema => :table_schema, :table_name => :table_name} , :c]
-      end
-
-      # Argument array for the schema dataset's select method.
-      def schema_ds_select(table_name, opts)
-        cols = [:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, \
-          :numeric_precision, :column_default___default, :is_nullable___allow_null]
-        cols << :c__table_name unless table_name
-        cols
-      end
-
-      # Parse the schema for a given table.
-      def schema_parse_table(table_name, opts)
-        schema_parse_rows(schema_ds(table_name, opts))
-      end
-
-      # Parse the schema all tables in the database.
-      def schema_parse_tables(opts)
-        schemas = {}
-        schema_ds(nil, opts).each do |row|
-          (schemas[row.delete(:table_name).to_sym] ||= []) << row
-        end
-        schemas.each do |table, rows|
-          schemas[table] = schema_parse_rows(rows)
-        end
-        schemas
-      end
-
-      # Parse the output of the information schema columns into
-      # the hash used by Sequel.
-      def schema_parse_rows(rows)
-        schema = []
-        rows.each do |row| 
-          row[:allow_null] = row[:allow_null] == 'YES' ? true : false
-          row[:default] = nil if row[:default].blank?
-          row[:type] = schema_column_type(row[:db_type])
-          schema << [row.delete(:column).to_sym, row]
-        end
-        schema
-      end
-    end
-  end
-end