postshift 0.1.0

data/lib/active_record/connection_adapters/redshift/column.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class RedshiftColumn < PostgreSQLColumn #:nodoc:
+      delegate :encoding, to: :sql_type_metadata
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift/referential_integrity.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ReferentialIntegrity # :nodoc:
+        def disable_referential_integrity # :nodoc:
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift/schema_definitions.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      if ActiveRecord.version < Gem::Version.new('5.1')
+        # All this to add 'encoding' to Structure
+        class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :auto_increment, :primary_key, :collation, :sql_type, :comment, :encoding)
+          # From PostgreSQL to maintain compatability
+          attr_accessor :array
+
+          # From Abstract to maintain compatability
+          def primary_key?
+            primary_key || type.to_sym == :primary_key
+          end
+        end
+
+        class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+          include ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods
+
+          def new_column_definition(name, type, options) # :nodoc:
+            super.tap do |column|
+              column.encoding = options[:encoding]
+            end
+          end
+
+          private
+
+          def create_column_definition(name, type, options=nil)
+            ColumnDefinition.new name, type, options
+          end
+        end
+      else
+        class TableDefinition < ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+          def primary_key(name, type=:primary_key, **options)
+            ints = %i(integer bigint)
+            options[:auto_increment] ||= true if ints.include?(type) && !options.key?(:default)
+            type = :primary_key if ints.include?(type) && options.delete(:auto_increment) == true
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift/schema_dumper.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ColumnDumper
+        def column_spec_for_primary_key(column)
+          super.tap do |spec|
+            spec[:id] = ':primary_key' if column.sql_type == 'primary_key'
+          end
+        end
+
+        # Adds +:encoding+ option to the default set
+        def prepare_column_options(column)
+          super.tap do |spec|
+            spec[:encoding] = "'#{column.sql_type_metadata.encoding}'" if column.sql_type_metadata.encoding.present?
+          end
+        end
+
+        # Adds +:encoding+ as a valid migration key
+        def migration_keys
+          super + [:encoding]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift/schema_statements.rb

@@ -0,0 +1,154 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      class SchemaCreation < PostgreSQL::SchemaCreation
+        private
+
+        def add_column_options!(sql, options)
+          sql = super
+          if (encoding = encoding_option(options)).present?
+            sql << " ENCODE #{encoding}"
+          end
+          sql
+        end
+
+        def encoding_option(options)
+          if ActiveRecord.version < Gem::Version.new('5.1')
+            options[:column].encoding
+          else
+            options[:encoding]
+          end
+        end
+      end
+
+      module SchemaStatements
+        # Create a new Redshift database. Options include <tt>:owner</tt> and <tt>:connection_limit</tt> 
+        # Example:
+        #   create_database config[:database], config
+        #   create_database 'foo_development', encoding: 'unicode'
+        def create_database(name, options = {})
+          options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
+
+          option_string = options.inject("") do |memo, (key, value)|
+            memo += case key
+                    when :owner
+                      " OWNER = \"#{value}\""
+                    when :connection_limit
+                      " CONNECTION LIMIT = #{value}"
+                    else
+                      ''
+                    end
+          end
+
+          execute "CREATE DATABASE #{quote_table_name(name)}#{option_string}"
+        end
+ 
+        def create_table(table_name, comment: nil, **options)
+          options[:options] ||= ''
+          options[:options] += "DISTKEY(#{options.delete(:distkey)}) " if options.key?(:distkey)
+          options[:options] += "SORTKEY(#{options.delete(:sortkey)}) " if options.key?(:sortkey)
+          super
+        end
+
+        def indexes(*)
+          []
+        end
+
+        # Returns the list of all column definitions for a table.
+        def columns(table_name)
+          column_definitions(table_name.to_s).map do |column_name, type, default, notnull, oid, fmod, encoding|
+            default_value = extract_value_from_default(default)
+            type = determine_primary_key_type_conversion(type, default)
+            type_metadata = fetch_type_metadata(column_name, type, oid, fmod, encoding)
+            default_function = extract_default_function(default_value, default)
+            new_column(column_name, default_value, type_metadata, notnull == false, table_name, default_function)
+          end
+        end
+
+        def determine_primary_key_type_conversion(type, default)
+          return 'primary_key' if (type == 'integer' && default.to_s.starts_with?('"identity"'))
+          type
+        end
+
+        def new_column(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil) # :nodoc:
+          RedshiftColumn.new(name, default, sql_type_metadata, null, table_name, default_function)
+        end
+
+        def table_options(table_name) # :nodoc:
+          {}.tap do |options|
+            if (distkey = table_distkey(table_name)).present?
+              options[:distkey] = distkey
+            end
+            if (sortkey = table_sortkey(table_name)).present?
+              options[:sortkey] = sortkey
+            end
+          end
+        end
+
+        def table_distkey(table_name) # :nodoc:
+          select_value("SELECT \"column\" FROM pg_table_def WHERE tablename = #{quote(table_name)} AND distkey = true")
+        end
+
+        def table_sortkey(table_name) # :nodoc:
+          columns = select_values("SELECT \"column\" FROM pg_table_def WHERE tablename = #{quote(table_name)} AND sortkey > 0 ORDER BY sortkey ASC")
+          columns.present? ? columns.join(', ') : nil
+        end
+
+        # Returns just a table's primary key
+        def primary_keys(table)
+          pks = query(<<-end_sql, 'SCHEMA')
+            SELECT DISTINCT attr.attname
+            FROM pg_attribute attr
+            INNER JOIN pg_depend dep ON attr.attrelid = dep.refobjid AND attr.attnum = dep.refobjsubid
+            INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = any(cons.conkey)
+            WHERE cons.contype = 'p'
+              AND dep.refobjid = '#{quote_table_name(table)}'::regclass
+          end_sql
+          pks.present? ? pks[0] : pks
+        end
+
+        # TODO: This entire method block for 't2.oid::regclass::text' to 't2.relname' 
+        def foreign_keys(table_name)
+          fk_info = select_all(<<-SQL.strip_heredoc, 'SCHEMA')
+            SELECT t2.relname AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+            FROM pg_constraint c
+            JOIN pg_class t1 ON c.conrelid = t1.oid
+            JOIN pg_class t2 ON c.confrelid = t2.oid
+            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+            JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            WHERE c.contype = 'f'
+              AND t1.relname = #{quote(table_name)}
+              AND t3.nspname = ANY (current_schemas(false))
+            ORDER BY c.conname
+          SQL
+
+          fk_info.map do |row|
+            options = {
+              column: row['column'],
+              name: row['name'],
+              primary_key: row['primary_key']
+            }
+
+            options[:on_delete] = extract_foreign_key_action(row['on_delete'])
+            options[:on_update] = extract_foreign_key_action(row['on_update'])
+
+            ForeignKeyDefinition.new(table_name, row['to_table'], options)
+          end
+        end
+
+        def fetch_type_metadata(column_name, sql_type, oid, fmod, encoding)
+          cast_type = get_oid_type(oid, fmod, column_name, sql_type)
+          simple_type = SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+          )
+          RedshiftSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod, encoding: encoding)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift/type_metadata.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class RedshiftSQLTypeMetadata < PostgreSQLTypeMetadata
+      attr_reader :encoding
+
+      def initialize(type_metadata, oid: nil, fmod: nil, encoding: nil)
+        super(type_metadata, oid: oid, fmod: fmod)
+        @encoding = encoding unless encoding == 'none'
+      end
+
+      protected
+
+      def attributes_for_hash
+        super << encoding
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_adapter.rb

@@ -0,0 +1,220 @@
+require 'active_support'
+require 'active_support/core_ext/module/deprecation'
+
+require 'active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+require 'active_record/connection_adapters/redshift/column'
+require 'active_record/connection_adapters/redshift/referential_integrity'
+require 'active_record/connection_adapters/redshift/schema_definitions'
+require 'active_record/connection_adapters/redshift/schema_dumper'
+require 'active_record/connection_adapters/redshift/schema_statements'
+require 'active_record/connection_adapters/redshift/type_metadata'
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc
+    RS_VALID_CONN_PARAMS = [:host, :hostaddr, :port, :dbname, :user, :password, :connect_timeout,
+                            :client_encoding, :options, :application_name, :fallback_application_name,
+                            :keepalives, :keepalives_idle, :keepalives_interval, :keepalives_count,
+                            :tty, :sslmode, :requiressl, :sslcompression, :sslcert, :sslkey,
+                            :sslrootcert, :sslcrl, :requirepeer, :krbsrvname, :gsslib, :service]
+
+    # Establishes a connection to the database that's used by all Active Record objects
+    def redshift_connection(config)
+      conn_params = config.symbolize_keys
+
+      conn_params.delete_if { |_, v| v.nil? }
+
+      # Map ActiveRecords param names to PGs.
+      conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
+      conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
+
+      # Forward only valid config params to PGconn.connect.
+      conn_params.keep_if { |k, _| RS_VALID_CONN_PARAMS.include?(k) }
+
+      # The postgres drivers don't allow the creation of an unconnected PGconn object,
+      # so just pass a nil connection object for the time being.
+      ConnectionAdapters::RedshiftAdapter.new(nil, logger, conn_params, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class RedshiftAdapter < PostgreSQLAdapter
+      ADAPTER_NAME = 'Redshift'.freeze
+
+      NATIVE_DATABASE_TYPES = {
+        primary_key: 'integer identity primary key',
+        string:      { name: 'varchar' },
+        text:        { name: 'varchar' },
+        integer:     { name: 'integer' },
+        float:       { name: 'float' },
+        decimal:     { name: 'decimal' },
+        datetime:    { name: 'timestamp' },
+        time:        { name: 'timestamptz' },
+        date:        { name: 'date' },
+        bigint:      { name: 'bigint' },
+        boolean:     { name: 'boolean' },
+      }.freeze
+
+      include Redshift::ColumnDumper
+      include Redshift::ReferentialIntegrity
+      include Redshift::SchemaStatements
+
+      def schema_creation # :nodoc:
+        Redshift::SchemaCreation.new self
+      end
+
+      def supports_index_sort_order?
+        false
+      end
+
+      def supports_partial_index?
+        false
+      end
+
+      def supports_expression_index?
+        false
+      end
+
+      def supports_transaction_isolation?
+        false
+      end
+
+      def supports_json?
+        false
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def native_database_types #:nodoc:
+        NATIVE_DATABASE_TYPES
+      end
+
+      def supports_extensions?
+        false
+      end
+
+      def use_insert_returning?
+        false
+      end
+
+      def supports_advisory_locks?
+        false
+      end
+
+      def supports_ranges?
+        false
+      end
+
+      def supports_materialized_views?
+        false
+      end
+
+      def postgresql_version
+        # Will pass all inernal version support checks
+        Float::INFINITY
+      end
+
+    private
+
+      # TODO: Copied from PostgreSQL with minor registration changes.  If broken out, could override segments, etc
+      def initialize_type_map(m) # :nodoc:
+        register_class_with_limit m, 'int2', Type::Integer
+        register_class_with_limit m, 'int4', Type::Integer
+        register_class_with_limit m, 'int8', Type::Integer
+        m.alias_type 'oid', 'int2'
+        m.register_type 'float4', Type::Float.new
+        m.alias_type 'float8', 'float4'
+        m.register_type 'text', Type::Text.new
+        register_class_with_limit m, 'varchar', Type::String
+        m.alias_type 'char', 'varchar'
+        m.alias_type 'name', 'varchar'
+        m.alias_type 'bpchar', 'varchar'
+        m.register_type 'bool', Type::Boolean.new
+        m.alias_type 'timestamptz', 'timestamp'
+        m.register_type 'date', Type::Date.new
+
+        m.register_type 'timestamp' do |_, _, sql_type|
+          precision = extract_precision(sql_type)
+          OID::DateTime.new(precision: precision)
+        end
+
+        m.register_type 'numeric' do |_, fmod, sql_type|
+          precision = extract_precision(sql_type)
+          scale = extract_scale(sql_type)
+
+          # The type for the numeric depends on the width of the field,
+          # so we'll do something special here.
+          #
+          # When dealing with decimal columns:
+          #
+          # places after decimal  = fmod - 4 & 0xffff
+          # places before decimal = (fmod - 4) >> 16 & 0xffff
+          if fmod && (fmod - 4 & 0xffff).zero?
+            # FIXME: Remove this class, and the second argument to
+            # lookups on PG
+            Type::DecimalWithoutScale.new(precision: precision)
+          else
+            OID::Decimal.new(precision: precision, scale: scale)
+          end
+        end
+      end
+
+      def configure_connection
+        if @config[:encoding]
+          @connection.set_client_encoding(@config[:encoding])
+        end
+        self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
+
+        # SET statements from :variables config hash
+        # http://www.postgresql.org/docs/8.3/static/sql-set.html
+        variables = @config[:variables] || {}
+        variables.map do |k, v|
+          if v == ':default' || v == :default
+            # Sets the value to the global or compile default
+            execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
+          elsif !v.nil?
+            execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
+          end
+        end
+      end
+
+      # Returns the list of a table's column names, data types, and default values.
+      #
+      # The underlying query is roughly:
+      #  SELECT column.name, column.type, default.value
+      #    FROM column LEFT JOIN default
+      #      ON column.table_id = default.table_id
+      #     AND column.num = default.column_num
+      #   WHERE column.table_id = get_table_id('table_name')
+      #     AND column.num > 0
+      #     AND NOT column.is_dropped
+      #   ORDER BY column.num
+      #
+      # If the table name is not prefixed with a schema, the database will
+      # take the first match from the schema search path.
+      #
+      # Query implementation notes:
+      #  - format_type includes the column size constraint, e.g. varchar(50)
+      #  - ::regclass is a function that gives the id for a table name
+      def column_definitions(table_name) # :nodoc:
+        query(<<-end_sql, 'SCHEMA')
+            SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                   pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+                   format_encoding(a.attencodingtype::integer)
+              FROM pg_attribute a LEFT JOIN pg_attrdef d
+                ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+             WHERE a.attrelid = '#{quote_table_name(table_name)}'::regclass
+               AND a.attnum > 0 AND NOT a.attisdropped
+             ORDER BY a.attnum
+        end_sql
+      end
+
+      def create_table_definition(*args) # :nodoc:
+        Redshift::TableDefinition.new(*args)
+      end
+    end
+  end
+end