postgres_ext 1.0.0 → 2.0.0

data/lib/postgres_ext/active_record/sanitization.rb

@@ -1,30 +0,0 @@
-require 'active_record/sanitization'
-
-module ActiveRecord
-  module Sanitization
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def sanitize_sql_hash_for_assignment(attrs)
-        attrs.map do |attr, value|
-          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value, attr)}"
-        end.join(', ')
-      end
-
-      def quote_bound_value(value, column = nil, c = connection)
-        if column.present? && column != c
-          record_column = self.columns.select {|col| col.name == column}.first
-          c.quote(value, record_column)
-        elsif value.respond_to?(:map) && !value.acts_like?(:string)
-          if value.respond_to?(:empty?) && value.empty?
-            c.quote(nil)
-          else
-            value.map { |v| c.quote(v) }.join(',')
-          end
-        else
-          c.quote(value)
-        end
-      end
-    end
-  end
-end

data/lib/postgres_ext/active_record/schema_dumper.rb

@@ -1,157 +0,0 @@
-require 'active_record/schema_dumper'
-
-module ActiveRecord
-  class SchemaDumper
-    VALID_COLUMN_SPEC_KEYS = [:name, :limit, :precision, :scale, :default, :null, :array]
-    def self.valid_column_spec_keys
-      VALID_COLUMN_SPEC_KEYS
-    end
-
-    def dump(stream)
-      header(stream)
-      # added
-      extensions(stream) if @connection.respond_to?(:supports_extensions?) && 
-                            @connection.supports_extensions?
-      # /added
-      tables(stream)
-      trailer(stream)
-      stream
-    end
-
-    private
-
-    def extensions(stream)
-      exts = @connection.extensions
-
-      unless exts.empty?
-        stream.puts exts.map { |name| "  add_extension \"#{name}\""}.join("\n") + "\n\n"
-      end
-    end
-
-    def table(table, stream)
-      columns = @connection.columns(table)
-      begin
-        tbl = StringIO.new
-
-        # first dump primary key column
-        if @connection.respond_to?(:pk_and_sequence_for)
-          pk, _ = @connection.pk_and_sequence_for(table)
-        elsif @connection.respond_to?(:primary_key)
-          pk = @connection.primary_key(table)
-        end
-
-        tbl.print "  create_table #{table.inspect}"
-        if columns.detect { |c| c.name == pk }
-          if pk != 'id'
-            tbl.print %Q(, :primary_key => "#{pk}")
-          end
-        else
-          tbl.print ", :id => false"
-        end
-        tbl.print ", :force => true"
-        tbl.puts " do |t|"
-
-        # then dump all non-primary key columns
-        column_specs = columns.map do |column|
-          raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
-          next if column.name == pk
-          spec = column_spec(column)
-          (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
-          spec
-        end.compact
-
-        # find all migration keys used in this table
-        keys = self.class.valid_column_spec_keys & column_specs.map{ |k| k.keys }.flatten
-
-        # figure out the lengths for each column based on above keys
-        lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
-
-        # the string we're going to sprintf our values against, with standardized column widths
-        format_string = lengths.map{ |len| "%-#{len}s" }
-
-        # find the max length for the 'type' column, which is special
-        type_length = column_specs.map{ |column| column[:type].length }.max
-
-        # add column type definition to our format string
-        format_string.unshift "    t.%-#{type_length}s "
-
-        format_string *= ''
-
-        column_specs.each do |colspec|
-          values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
-          values.unshift colspec[:type]
-          tbl.print((format_string % values).gsub(/,\s*$/, ''))
-          tbl.puts
-        end
-
-        tbl.puts "  end"
-        tbl.puts
-
-        indexes(table, tbl)
-
-        tbl.rewind
-        stream.print tbl.read
-      rescue => e
-        stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
-        stream.puts "#   #{e.message}"
-        stream.puts
-      end
-
-      stream
-    end
-
-    #mostly rails 3.2 code
-    def indexes(table, stream)
-      if (indexes = @connection.indexes(table)).any?
-        add_index_statements = indexes.map do |index|
-          statement_parts = [
-            ('add_index ' + index.table.inspect),
-            index.columns.inspect,
-            (':name => ' + index.name.inspect),
-          ]
-          statement_parts << ':unique => true' if index.unique
-
-          index_lengths = (index.lengths || []).compact
-          statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
-
-          index_orders = (index.orders || {})
-          statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
-
-          # changed from rails 2.3
-          statement_parts << (':where => ' + index.where.inspect) if index.where
-          statement_parts << (':using => ' + index.using.inspect) if index.using
-          statement_parts << (':index_opclass => ' + index.index_opclass.inspect) if index.index_opclass.present?
-          # /changed
-
-          '  ' + statement_parts.join(', ')
-        end
-
-        stream.puts add_index_statements.sort.join("\n")
-        stream.puts
-      end
-    end
-
-    #mostly rails 3.2 code (pulled out of table method)
-    def column_spec(column)
-      spec = {}
-      spec[:name]      = column.name.inspect
-
-      # AR has an optimization which handles zero-scale decimals as integers. This
-      # code ensures that the dumper still dumps the column as a decimal.
-      spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
-                           'decimal'
-                         else
-                           column.type.to_s
-                         end
-      spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-      spec[:precision] = column.precision.inspect if column.precision
-      spec[:scale]     = column.scale.inspect if column.scale
-      spec[:null]      = 'false' unless column.null
-      spec[:default]   = default_string(column.default) if column.has_default?
-      # changed from rails 3.2 code
-      spec[:array]     = 'true' if column.respond_to?(:array) && column.array
-      # /changed
-      spec
-    end
-  end
-end

data/spec/columns/array_spec.rb

@@ -1,119 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Array column' do
-  let!(:integer_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'integer[]'}
-  let!(:string_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'character varying(255)[]'}
-  let!(:text_array_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'text[]'}
-  let!(:adapter) { ActiveRecord::Base.connection }
-
-  context 'string array' do
-    describe '#type_cast' do
-      context 'has null value' do
-        it 'converts the PostgreSQL value to an array with a nil value' do
-          string_array_column.type_cast('{1,NULL,"NULL"}').should eq ['1',nil,'NULL']
-        end
-      end
-
-      context 'utf8' do
-        it "handles incoming UTF8 as UTF8" do
-          string_array_column.type_cast('{"Аркалио"}').should eq ['Аркалио']
-        end
-      end
-
-      context 'corner cases, strings with commas and quotations' do
-        it 'converts the PostgreSQL value containing escaped " to an array' do
-          string_array_column.type_cast('{"has \" quote",another value}').should eq ['has " quote', 'another value']
-        end
-
-        it 'converts the PostgreSQL value containing commas to an array' do
-          string_array_column.type_cast('{"has , comma",another value,"more, commas"}').should eq ['has , comma', 'another value', 'more, commas']
-        end
-
-        it 'converts strings containing , to the proper value' do
-          adapter.type_cast(['c,'], string_array_column).should eq '{"c,"}'
-        end
-
-        it "handles strings with double quotes" do
-          adapter.type_cast(['a"b'], string_array_column).should eq '{"a\\"b"}'
-        end
-
-        it 'converts arrays of strings containing nil to the proper value' do
-          adapter.type_cast(['one', nil, 'two'], string_array_column).should eq '{"one",NULL,"two"}'
-        end
-      end
-    end
-  end
-
-  context 'text array' do
-    describe '#type_cast' do
-      context 'has null value' do
-        it 'converts the PostgreSQL value to an array with a nil value' do
-          text_array_column.type_cast('{1,NULL,"NULL"}').should eq ['1',nil,'NULL']
-        end
-      end
-
-      context 'utf8' do
-        it "handles incoming UTF8 as UTF8" do
-          text_array_column.type_cast('{"Аркалио"}').should eq ['Аркалио']
-        end
-      end
-
-      context 'corner cases, strings with commas and quotations' do
-        it 'converts one element, 2 dimensional arrays' do
-          adapter.type_cast([['one','two']], text_array_column).should eq '{{"one","two"}}'
-        end
-        it 'converts the PostgreSQL value containing escaped " to an array' do
-          text_array_column.type_cast('{"has \" quote",another value}').should eq ['has " quote', 'another value']
-        end
-
-        it 'converts the PostgreSQL value containing commas to an array' do
-          text_array_column.type_cast('{"has , comma",another value,"more, commas"}').should eq ['has , comma', 'another value', 'more, commas']
-        end
-
-        it 'converts strings containing , to the proper value' do
-          adapter.type_cast(['c,'], text_array_column).should eq '{"c,"}'
-        end
-
-        it "handles strings with double quotes" do
-          adapter.type_cast(['a"b'], text_array_column).should eq '{"a\\"b"}'
-        end
-
-        it 'converts arrays of strings containing nil to the proper value' do
-          adapter.type_cast(['one', nil, 'two'], text_array_column).should eq '{"one",NULL,"two"}'
-        end
-      end
-    end
-  end
-
-  context 'integer array' do
-    describe '#type_cast' do
-      context 'has null value' do
-        it 'converts a Postgres Array with nulls in it' do
-          integer_array_column.type_cast('{1,NULL,2}').should eq [1,nil,2]
-        end
-      end
-      context 'one dimensional array' do
-        it 'converts a PostgreSQL array value to an array of integers' do
-          integer_array_column.type_cast('{1,2,3,4}').should eq [1,2,3,4]
-        end
-      end
-    end
-
-    describe 'integer array to SQL statment conversion' do
-      context 'contains a nil value' do
-        it 'returns a PostgreSQL array' do
-          value = integer_array_column.type_cast('{1,NULL,2}')
-          adapter.type_cast(value, integer_array_column).should eq '{1,NULL,2}'
-        end
-      end
-      context 'one dimensional array' do
-        it 'returns a PostgreSQL array' do
-          value = integer_array_column.type_cast('{1,2,3,4}')
-          adapter.type_cast(value, integer_array_column).should eq '{1,2,3,4}'
-        end
-      end
-    end
-  end
-end

data/spec/columns/inet_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe 'INET column' do
-  let!(:column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'inet'}
-  let!(:adapter) { ActiveRecord::Base.connection }
-
-  describe '#type_class_code' do
-    it 'returns code for converting strings to IPAddr' do
-      column.type_cast_code('v').should eq 'ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_cidr_address(v)'
-    end
-  end
-
-  describe 'inet type casting' do
-    it 'converts ip strings to NetAddr::CIDR objects' do
-      column.type_cast('127.0.0.1').should be_a_kind_of IPAddr
-    end
-  end
-
-  describe 'inet value conversion for SQL statments' do
-    it 'returns the string value of the IPAddr address' do
-      value = column.type_cast('127.0.0.1')
-      adapter.type_cast(value, column).should eq '127.0.0.1/32'
-    end
-  end
-end

data/spec/columns/ranges/daterange_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe 'daterange column' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  let!(:date_range_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'daterange'}
-
-  describe '#type_class' do
-    it 'converts an end-inclusive PostgreSQL integer range to a Ruby range' do
-      date_range_column.type_cast('[2011-01-01,2012-01-31]').should eq Date.new(2011,01,01)..Date.new(2012,01,31)
-    end
-
-    it 'converts an end-exclusive PostgreSQL integer range to a Ruby range' do
-      date_range_column.type_cast('[2011-01-01,2012-01-31)').should eq Date.new(2011,01,01)...Date.new(2012,01,31)
-    end
-
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      # Cannot have a range from -Infinity to a date
-      # date_range_column.type_cast('(,2011-01-01)').should eq -(1.0/0.0)...4
-      date_range_column.type_cast('[2011-01-01,)').should eq Date.new(2011,01,01)..(1.0/0.0)
-    end
-  end
-
-  describe 'date range to SQL statment conversion' do
-    it 'returns an end-inclusive PostgreSQL range' do
-      value = date_range_column.type_cast('[2011-01-01,2012-01-31]')
-      adapter.type_cast(value, date_range_column).should eq '[2011-01-01,2012-01-31]'
-    end
-    it 'returns an end-exclusive PostgreSQL range' do
-      value = date_range_column.type_cast('[2011-01-01,2012-01-31)')
-      adapter.type_cast(value, date_range_column).should eq '[2011-01-01,2012-01-31)'
-    end
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      value = date_range_column.type_cast('[2011-01-01,)')
-      adapter.type_cast(value, date_range_column).should eq '[2011-01-01,)'
-    end
-  end
-end

data/spec/columns/ranges/int4range_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe 'int4range column' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  let!(:int4_range_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'int4range'}
-
-  describe '#type_class' do
-    it 'converts an end-inclusive PostgreSQL integer range to a Ruby range' do
-      int4_range_column.type_cast('[0,4]').should eq 0..4
-    end
-
-    it 'converts an end-exclusive PostgreSQL integer range to a Ruby range' do
-      int4_range_column.type_cast('[0,4)').should eq 0...4
-    end
-
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      int4_range_column.type_cast('(,4)').should eq -(1.0/0.0)...4
-      int4_range_column.type_cast('[0,)').should eq 0..(1.0/0.0)
-    end
-  end
-
-  describe 'int4 range to SQL statment conversion' do
-    it 'returns an end-inclusive PostgreSQL range' do
-      value = int4_range_column.type_cast('[0,4]')
-      adapter.type_cast(value, int4_range_column).should eq '[0,4]'
-    end
-    it 'returns an end-exclusive PostgreSQL range' do
-      value = int4_range_column.type_cast('[0,4)')
-      adapter.type_cast(value, int4_range_column).should eq '[0,4)'
-    end
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      value = int4_range_column.type_cast('(,4)')
-      adapter.type_cast(value, int4_range_column).should eq '(,4)'
-      value = int4_range_column.type_cast('[0,)')
-      adapter.type_cast(value, int4_range_column).should eq '[0,)'
-    end
-  end
-end

data/spec/columns/ranges/int8range_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe 'int8range column' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  let!(:int8_range_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'int8range'}
-
-  describe '#type_class' do
-    it 'converts an end-inclusive PostgreSQL integer range to a Ruby range' do
-      int8_range_column.type_cast('[0,4]').should eq 0..4
-    end
-
-    it 'converts an end-exclusive PostgreSQL integer range to a Ruby range' do
-      int8_range_column.type_cast('[0,4)').should eq 0...4
-    end
-
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      int8_range_column.type_cast('(,4)').should eq -(1.0/0.0)...4
-      int8_range_column.type_cast('[0,)').should eq 0..(1.0/0.0)
-    end
-  end
-
-  describe 'int8 range to SQL statment conversion' do
-    it 'returns an end-inclusive PostgreSQL range' do
-      value = int8_range_column.type_cast('[0,4]')
-      adapter.type_cast(value, int8_range_column).should eq '[0,4]'
-    end
-    it 'returns an end-exclusive PostgreSQL range' do
-      value = int8_range_column.type_cast('[0,4)')
-      adapter.type_cast(value, int8_range_column).should eq '[0,4)'
-    end
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      value = int8_range_column.type_cast('(,4)')
-      adapter.type_cast(value, int8_range_column).should eq '(,4)'
-      value = int8_range_column.type_cast('[0,)')
-      adapter.type_cast(value, int8_range_column).should eq '[0,)'
-    end
-  end
-end

data/spec/columns/ranges/numrange_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe 'numrange column' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  let!(:numeric_range_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'numrange'}
-  describe '#type_class' do
-    it 'converts an end-inclusive PostgreSQL integer range to a Ruby range' do
-      numeric_range_column.type_cast('[0,4.1]').should eq 0.0..4.1
-    end
-
-    it 'converts an end-exclusive PostgreSQL integer range to a Ruby range' do
-      numeric_range_column.type_cast('[0,4)').should eq 0.0...4.0
-    end
-
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      numeric_range_column.type_cast('(,4)').should eq -(1.0/0.0)...4.0
-      numeric_range_column.type_cast('[0,)').should eq 0.0..(1.0/0.0)
-    end
-  end
-
-  describe 'Numeric range to SQL statment conversion' do
-    it 'returns an end-inclusive PostgreSQL range' do
-      value = numeric_range_column.type_cast('[0,4.0]')
-      adapter.type_cast(value, numeric_range_column).should eq '[0.0,4.0]'
-    end
-    it 'returns an end-exclusive PostgreSQL range' do
-      value = numeric_range_column.type_cast('[0,4.0)')
-      adapter.type_cast(value, numeric_range_column).should eq '[0.0,4.0)'
-    end
-    it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-      value = numeric_range_column.type_cast('(,4.0)')
-      adapter.type_cast(value, numeric_range_column).should eq '(,4.0)'
-      value = numeric_range_column.type_cast('[0,)')
-      adapter.type_cast(value, numeric_range_column).should eq '[0.0,)'
-    end
-  end
-end

data/spec/columns/ranges/tsrange_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe 'tsrange column' do
-  let!(:adapter) { ActiveRecord::Base.connection }
-  let!(:ts_range_column) { ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new 'field', nil, 'tsrange'}
-
-  describe '#type_class' do
-    it 'converts an end-inclusive PostgreSQL integer range to a Ruby range' do
-      ts_range_column.type_cast('[2011-01-01 12:34:00,2012-01-31 08:00:01]').should eq Time.new(2011, 01, 01, 12, 34)..Time.new(2012, 01, 31, 8, 0, 1)
-    end
-
-    it 'converts an end-exclusive PostgreSQL integer range to a Ruby range' do
-      ts_range_column.type_cast('[2011-01-01 12:34:00,2012-01-31 08:00:01)').should eq Time.new(2011, 01, 01, 12, 34)...Time.new(2012, 01, 31, 8, 0, 1)
-    end
-
-    #it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-    ## Cannot have a range from -Infinity to a ts
-    ## ts_range_column.type_cast('(,2011-01-01)').should eq -(1.0/0.0)...4
-    #ts_range_column.type_cast('[2011-01-01 12:34:00,)').should eq Time.new(2011,01,01, 12, 34)..(1.0/0.0)
-    #end
-  end
-
-  describe 'Time range to SQL statment conversion' do
-    it 'returns an end-inclusive PostgreSQL range' do
-      value = ts_range_column.type_cast('[2011-01-01 12:34:00,2012-01-31 08:00:01]')
-      adapter.type_cast(value, ts_range_column).should eq '[2011-01-01 12:34:00,2012-01-31 08:00:01]'
-    end
-    it 'returns an end-exclusive PostgreSQL range' do
-      value = ts_range_column.type_cast('[2011-01-01 12:34:00,2012-01-31 08:00:01)')
-      adapter.type_cast(value, ts_range_column).should eq '[2011-01-01 12:34:00,2012-01-31 08:00:01)'
-    end
-    #it 'converts an infinite PostgreSQL integer range to a Ruby range' do
-    #value = ts_range_column.type_cast('[2011-01-01 12:34:00,)')
-    #adapter.type_cast(value, ts_range_column).should eq '[2011-01-01 12:34:00,)'
-    #end
-  end
-end

data/spec/migrations/active_record_migration_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe 'ActiveRecord Migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :generic_data_types }
-  it 'creates non-postgres_ext columns' do
-    lambda do
-      connection.create_table :generic_data_types do |t|
-        t.integer :col_1
-        t.string :col_2
-        t.datetime :col_3
-      end
-      connection.add_column :generic_data_types, :col_4, :text
-    end.should_not raise_exception
-
-    columns = connection.columns(:generic_data_types)
-    col_1 = columns.detect { |c| c.name == 'col_1'}
-    col_2 = columns.detect { |c| c.name == 'col_2'}
-    col_3 = columns.detect { |c| c.name == 'col_3'}
-    col_4 = columns.detect { |c| c.name == 'col_4'}
-
-
-    col_1.sql_type.should eq 'integer'
-    col_2.sql_type.should eq 'character varying(255)'
-    col_3.sql_type.should eq 'timestamp without time zone'
-    col_4.sql_type.should eq 'text'
-  end
-end
-