torque-postgresql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d27d24270072d57ca693a53b5fcd29ac72b509e0
+  data.tar.gz: cc63789993cf2817a2857d6cf5c6b8d31c38dabb
+SHA512:
+  metadata.gz: 8b6bd7dc8af51496eecd1c7c7a33f4d3ce8e885e7918668068b8ecf8e7ac9961c1ee4cfe342ecf46c31ccead863b82fe4c3296e523cffd28a5d4ce4c7499be75
+  data.tar.gz: 41141267915f0e8ad1d5b6052cab7cc45c9e2bb37ff4d02fc4e819a4c8cf199ba33ea924884c8732bfd691c354908e330f8390e8836906806bc7e685ce2d7f84

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Carlos Silva
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Torque::Postgresql'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Prints a schema dump of the test database'
+task :dump do |t|
+  lib  = File.expand_path('../lib', __FILE__)
+  spec = File.expand_path('../spec', __FILE__)
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+  $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
+
+  require 'byebug'
+  require 'spec_helper'
+  ActiveRecord::SchemaDumper.dump
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -0,0 +1,103 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module DatabaseStatements
+
+        EXTENDED_DATABASE_TYPES = %i(enum interval)
+
+        # Check if a given type is valid.
+        def valid_type?(type)
+          super || extended_types.include?(type)
+        end
+
+        # Get the list of extended types
+        def extended_types
+          EXTENDED_DATABASE_TYPES
+        end
+
+        # Returns true if type exists.
+        def type_exists?(name)
+          user_defined_types.key? name.to_s
+        end
+        alias data_type_exists? type_exists?
+
+        # Configure the interval format
+        def configure_connection
+          super
+          execute("SET SESSION IntervalStyle TO 'iso_8601'", 'SCHEMA')
+        end
+
+        # Change some of the types being mapped
+        def initialize_type_map(m)
+          super
+          m.register_type 'interval', OID::Interval.new
+        end
+
+        # Add the composite types to be loaded too.
+        def load_additional_types(type_map, oids = nil)
+          super
+
+          filter = "AND     a.typelem::integer IN (%s)" % oids.join(", ") if oids
+
+          query = <<-SQL
+            SELECT      a.typelem AS oid, t.typname, t.typelem,
+                        t.typdelim, t.typbasetype, t.typtype
+            FROM        pg_type t
+            INNER JOIN  pg_type a ON (a.oid = t.typarray)
+            LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+            WHERE       n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND     t.typtype IN ( 'c','e' )
+            #{filter}
+            AND     NOT EXISTS(
+                      SELECT 1 FROM pg_catalog.pg_type el
+                        WHERE el.oid = t.typelem AND el.typarray = t.oid
+                      )
+            AND     (t.typrelid = 0 OR (
+                      SELECT c.relkind = 'c' FROM pg_catalog.pg_class c
+                        WHERE c.oid = t.typrelid
+                      ))
+          SQL
+
+          execute_and_clear(query, 'SCHEMA', []) do |records|
+            records.each do |row|
+              typtype = row['typtype']
+              type = begin
+                case
+                when typtype == 'e'.freeze then OID::Enum.create(row)
+                end
+              end
+
+              type_map.register_type row['oid'].to_i, type
+            end
+          end
+        end
+
+        # Gets a list of user defined types.
+        # You can even choose the +typcategory+ filter
+        def user_defined_types(category = nil)
+          category_condition = "AND     typtype = '#{category}'" unless category.nil?
+          select_all(<<-SQL).rows.to_h
+            SELECT      t.typname AS name,
+                        CASE t.typtype
+                        WHEN 'e' THEN 'enum'
+                        END AS type
+            FROM        pg_type t
+            LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+            WHERE       n.nspname NOT IN ('pg_catalog', 'information_schema')
+            #{category_condition}
+            AND     NOT EXISTS(
+                      SELECT 1 FROM pg_catalog.pg_type el
+                        WHERE el.oid = t.typelem AND el.typarray = t.oid
+                      )
+            AND     (t.typrelid = 0 OR (
+                      SELECT c.relkind = 'c' FROM pg_catalog.pg_class c
+                        WHERE c.oid = t.typrelid
+                      ))
+            ORDER BY    t.typtype DESC
+          SQL
+        end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/array.rb

@@ -0,0 +1,19 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        module Array
+
+          def initialize(subtype, delimiter = ',')
+            super
+            @pg_encoder = Coder
+            @pg_decoder = Coder
+          end
+
+        end
+
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.prepend Array
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/enum.rb

@@ -0,0 +1,46 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Enum < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum
+
+          attr_reader :name, :klass
+
+          def self.create(row)
+            new(row['typname'])
+          end
+
+          def initialize(name)
+            @name  = name
+            @klass = Attributes::Enum.lookup(name)
+          end
+
+          def hash
+            [self.class, name].hash
+          end
+
+          def serialize(value)
+            return if value.blank?
+            value = cast_value(value)
+            value.to_s unless value.nil?
+          end
+
+          def assert_valid_value(value)
+            cast_value(value)
+          end
+
+          private
+
+            def cast_value(value)
+              return if value.blank?
+              return value if value.is_a?(@klass)
+              @klass.new(value)
+            rescue Attributes::Enum::EnumError
+              nil
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/interval.rb

@@ -0,0 +1,94 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Interval < ActiveModel::Type::Value
+
+          CAST_PARTS = [:years, :months, :days, :hours, :minutes, :seconds]
+
+          def type
+            :interval
+          end
+
+          # Accepts database-style string, numeric as seconds, array of parts
+          # padded to left, or a hash
+          #
+          # Examples:
+          #   [12, 0, 0]
+          #   produces: 12 hours, 0 minutes, and 0 seconds
+          #
+          #   [nil, nil, 3, 0, 0, 0]
+          #   produces: 3 days, 0 hours, 0 minutes, and 0 seconds
+          #
+          #   {minutes: 12, seconds: 0}
+          #   produces: 12 minutes, and 0 seconds
+          def cast(value)
+            return if value.blank?
+            case value
+            when ::String then deserialize(value)
+            when ::ActiveSupport::Duration then value
+            when ::Numeric
+              parts = CAST_PARTS.map do |part|
+                rest, value = value.divmod(1.send(part))
+                rest == 0 ? nil : [part, rest]
+              end
+              parts_to_duration(parts.compact)
+            when ::Array
+              value.compact!
+              parts = CAST_PARTS.drop(6 - value.size).zip(value).to_h
+              parts_to_duration(parts)
+            when ::Hash
+              parts_to_duration(value)
+            else
+              value
+            end
+          end
+
+          # Uses the ActiveSupport::Duration::ISO8601Parser
+          # See ActiveSupport::Duration#parse
+          # The value must be Integer when no precision is given
+          def deserialize(value)
+            return if value.blank?
+            parts = ActiveSupport::Duration::ISO8601Parser.new(value).parse!
+            parts_to_duration(parts)
+          end
+
+          # Uses the ActiveSupport::Duration::ISO8601Serializer
+          # See ActiveSupport::Duration#iso8601
+          def serialize(value)
+            return if value.blank?
+            value = cast(value) unless value.is_a?(ActiveSupport::Duration)
+            value.iso8601(precision: @scale)
+          end
+
+          # Always use the numeric value for schema dumper
+          def type_cast_for_schema(value)
+            cast(value).value.inspect
+          end
+
+          # Check if the user input has the correct format
+          def assert_valid_value(value)
+            # TODO: Implement!
+          end
+
+          # Transform a list of parts into a duration object
+          def parts_to_duration(parts)
+            parts = parts.to_h.with_indifferent_access.slice(*CAST_PARTS)
+            return 0.seconds if parts.blank?
+
+            seconds = 0
+            parts = parts.map do |part, num|
+              num = num.to_i unless num.is_a?(Numeric)
+              if num > 0
+                seconds += num.send(part).value
+                [part, num]
+              end
+            end
+            ActiveSupport::Duration.new(seconds, parts.compact)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid.rb

@@ -0,0 +1,15 @@
+require_relative 'oid/array'
+require_relative 'oid/enum'
+require_relative 'oid/interval'
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+      end
+
+      ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
+    end
+  end
+end

data/lib/torque/postgresql/adapter/quoting.rb

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module Quoting
+
+        Name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
+
+        # Quotes type names for use in SQL queries.
+        def quote_type_name(string, schema = nil)
+          name_schema, table = string.to_s.scan(/[^".\s]+|"[^"]*"/)
+          if table.nil?
+            table = name_schema
+            name_schema = nil
+          end
+
+          schema = schema || name_schema || 'public'
+          Name.new(schema, table).quoted
+        end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module ColumnMethods
+
+        def interval(*args, **options)
+          args.each { |name| column(name, :interval, options) }
+        end
+
+        def enum(*args, **options)
+          args.each do |name|
+            type = options.fetch(:subtype, name)
+            column(name, type, options)
+          end
+        end
+
+      end
+
+      module ColumnDefinition
+        attr_accessor :subtype
+      end
+
+      ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
+      ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include ColumnMethods
+      ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition.include ColumnDefinition
+    end
+  end
+end

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -0,0 +1,31 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module ColumnDumper
+
+        # Adds +:subtype+ as a valid migration key
+        def migration_keys
+          super + [:subtype]
+        end
+
+        # Adds +:subtype+ option to the default set
+        def prepare_column_options(column)
+          spec = super
+
+          if subtype = schema_subtype(column)
+            spec[:subtype] = subtype
+          end
+
+          spec
+        end
+
+        private
+
+          def schema_subtype(column)
+            column.sql_type.to_sym.inspect if [:enum].include? column.type
+          end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -0,0 +1,89 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaStatements
+
+        # Drops a type.
+        def drop_type(name, options = {})
+          force = options.fetch(:force, '').upcase
+          check = 'IF EXISTS' if options.fetch(:check, true)
+          execute <<-SQL
+            DROP TYPE #{check}
+            #{quote_type_name(name, options[:schema])} #{force}
+          SQL
+        end
+
+        # Renames a type.
+        def rename_type(type_name, new_name)
+          execute <<-SQL
+            ALTER TYPE #{quote_type_name(type_name)}
+            RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
+          SQL
+        end
+
+        # Creates a new PostgreSQL enumerator type
+        #
+        # Example:
+        #   create_enum 'status', ['foo', 'bar']
+        #   create_enum 'status', ['foo', 'bar'], prefix: true
+        #   create_enum 'status', ['foo', 'bar'], suffix: 'test'
+        #   create_enum 'status', ['foo', 'bar'], force: true
+        def create_enum(name, values, options = {})
+          drop_type(name, options) if options[:force]
+          execute <<-SQL
+            CREATE TYPE #{quote_type_name(name, options[:schema])} AS ENUM
+            (#{quote_enum_values(name, values, options).join(', ')})
+          SQL
+        end
+
+        # Changes the enumerator by adding new values
+        #
+        # Example:
+        #   add_enum_values 'status', ['baz']
+        #   add_enum_values 'status', ['baz'], before: 'bar'
+        #   add_enum_values 'status', ['baz'], after: 'foo'
+        #   add_enum_values 'status', ['baz'], prepend: true
+        def add_enum_values(name, values, options = {})
+          before = options.fetch(:before, false)
+          after  = options.fetch(:after,  false)
+
+          before = enum_values(name).first if options.key? :prepend
+          before = quote(before) unless before == false
+          after  = quote(after)  unless after == false
+
+          quote_enum_values(name, values, options).each do |value|
+            reference = "BEFORE #{before}" unless before == false
+            reference = "AFTER  #{after}"  unless after == false
+            execute <<-SQL
+              ALTER TYPE #{quote_type_name(name, options[:schema])}
+              ADD VALUE #{value} #{reference}
+            SQL
+
+            before = false
+            after  = value
+          end
+        end
+
+        # Returns all values that an enum type can have.
+        def enum_values(name)
+          select_values("SELECT unnest(enum_range(NULL::#{name}))")
+        end
+
+        private
+
+          def quote_enum_values(name, values, options)
+            prefix = options[:prefix]
+            prefix = name if prefix === true
+
+            suffix = options[:suffix]
+            suffix = name if suffix === true
+
+            values.map! do |value|
+              quote([prefix, value, suffix].compact.join('_'))
+            end
+          end
+
+      end
+    end
+  end
+end