activerecord-redshift-adapter 0.9.12 → 8.0.0.beta1

data/lib/monkeypatch_activerecord.rb

@@ -1,195 +0,0 @@
-module ActiveRecord
-  module Querying
-    delegate :unload, :copy, :to => :scoped
-  end
-end
-
-module ActiveRecord::QueryMethods
-  module CopyUnloadParser
-    def self.parse_options(options, options_hash, valid_switches, valid_options, valid_unquoted_options, valid_special_options)
-      # credentials first
-      credentials = nil
-      if options_hash.has_key?(:credentials)
-        credentials = options_hash[:credentials]
-      else
-        creds = {}
-        creds[:aws_access_key_id] = options_hash[:aws_access_key_id] if options_hash.has_key?(:aws_access_key_id)
-        creds[:aws_secret_access_key] = options_hash[:aws_secret_access_key] if options_hash.has_key?(:aws_secret_access_key)
-        creds[:token] = options_hash[:token] if options_hash.has_key?(:token)
-        creds[:master_symmetric_key] = options_hash[:master_symmetric_key] if options_hash.has_key?(:master_symmetric_key)
-        credentials = creds.map{|k,v| "#{k}=#{v}"}.join(';')
-      end
-
-      option_list = []
-      option_list << "WITH CREDENTIALS AS #{connection.quote_value(credentials)}" unless credentials.blank?
-
-      valid_switches.each do |switch_name|
-        if options.include? switch_name
-          option_list << switch_name.to_s.upcase
-        end
-      end
-
-      valid_options.each do |option_name|
-        if options_hash.has_key? option_name
-          option_list << "#{option_name.to_s.upcase} AS #{connection.quote_value(options_hash[option_name])}"
-        end
-      end
-
-      valid_unquoted_options.each do |option_name|
-        if options_hash.has_key? option_name
-          option_list << "#{option_name.to_s.upcase} #{options_hash[option_name]}"
-        end
-      end
-
-      return credentials, option_list
-    end
-  end
-end
-
-module ActiveRecord
-  module QueryMethods
-    # UNLOAD ('select_statement')
-    # TO 's3_path'
-    # [ WITH ] CREDENTIALS [AS] 'aws_access_credentials' 
-    # [ option [ ... ] ]
-    #
-    # where option is
-    #
-    # { DELIMITER [ AS ] 'delimiter_char' 
-    # | FIXEDWIDTH [ AS ] 'fixedwidth_spec' }  
-    # | ENCRYPTED
-    # | GZIP     
-    # | ADDQUOTES 
-    # | NULL [ AS ] 'null_string'
-    # | ESCAPE
-    # | ALLOWOVERWRITE
-    VALID_UNLOAD_SWITCHES = [
-                             :gzip,
-                             :addquotes,
-                             :escape,
-                             :allowoverwrite
-                            ]
-    VALID_UNLOAD_OPTIONS = [
-                            :delimiter,
-                            :fixedwidth,
-                            :null
-                           ]
-    VALID_UNQUOTED_UNLOAD_OPTIONS = [ ]
-    VALID_SPECIAL_UNLOAD_OPTIONS = [
-                                    :credentials,
-                                    :aws_access_key_id,
-                                    :aws_secret_access_key,
-                                    :master_symmetric_key,
-                                    :token
-                                   ]
-
-    def unload(to_s3_filename, *options)
-      if options.last.is_a? Hash
-        options_hash = options.last
-      else
-        options_hash = {}
-      end
-
-      credentials, unload_options =
-        ActiveRecord::QueryMethods::CopyUnloadParser.parse_options(options, options_hash,
-                                                                   VALID_UNLOAD_SWITCHES, VALID_UNLOAD_OPTIONS, VALID_UNQUOTED_UNLOAD_OPTIONS, VALID_SPECIAL_UNLOAD_OPTIONS)
-
-
-      relation = Arel::Nodes::UnloadStatement.new(Arel::Nodes::Unload.new(Arel::Nodes::Relation.new(clone), to_s3_filename), unload_options.join(" "))
-      relation
-    end
-
-    VALID_COPY_SWITCHES = [
-                           :encrypted,
-                           :gzip,
-                           :removequotes,
-                           :explicit_ids,
-                           :escape,
-                           :acceptanydate,
-                           :ignoreblanklines,
-                           :truncatecolumns,
-                           :fillrecord,
-                           :trimblanks,
-                           :noload,
-                           :emptyasnull,
-                           :blanksasnull,
-                           :escape,
-                           :roundec
-                          ]
-    VALID_COPY_OPTIONS = [
-                          :delimiter,
-                          :fixedwidth,
-                          :csv,
-                          :acceptinvchars,
-                          :dateformat,
-                          :timeformat,
-                          :null
-                         ]
-
-    VALID_UNQUOTED_COPY_OPTIONS = [
-                                   :maxerror,
-                                   :ignoreheader,
-                                   :comprows,
-                                   :compupdate,
-                                   :statupdate
-                                  ]
-
-    VALID_SPECIAL_COPY_OPTIONS = [
-                                    :credentials,
-                                    :aws_access_key_id,
-                                    :aws_secret_access_key,
-                                    :master_symmetric_key,
-                                    :token
-                                   ]
-
-    # COPY table_name [ (column1 [,column2, ...]) ]
-    # FROM 's3://objectpath'
-    # [ WITH ] CREDENTIALS [AS] 'aws_access_credentials'
-    # [ option [ ... ] ]
-
-    # where option is 
-
-    # { FIXEDWIDTH 'fixedwidth_spec' 
-    # | [DELIMITER [ AS ] 'delimiter_char']  
-    #   [CSV [QUOTE [ AS ] 'quote_character']}
-
-    # | ENCRYPTED
-    # | GZIP
-    # | REMOVEQUOTES
-    # | EXPLICIT_IDS
-
-    # | ACCEPTINVCHARS [ AS ] ['replacement_char']
-    # | MAXERROR [ AS ] error_count
-    # | DATEFORMAT [ AS ] { 'dateformat_string' | 'auto' }
-    # | TIMEFORMAT [ AS ] { 'timeformat_string' | 'auto' | 'epochsecs' | 'epochmillisecs' }
-    # | IGNOREHEADER [ AS ] number_rows
-    # | ACCEPTANYDATE
-    # | IGNOREBLANKLINES
-    # | TRUNCATECOLUMNS
-    # | FILLRECORD
-    # | TRIMBLANKS
-    # | NOLOAD
-    # | NULL [ AS ] 'null_string'
-    # | EMPTYASNULL
-    # | BLANKSASNULL
-    # | COMPROWS numrows
-    # | COMPUPDATE [ { ON | TRUE } | { OFF | FALSE } ]
-    # | STATUPDATE [ { ON | TRUE } | { OFF | FALSE } ]
-    # | ESCAPE
-    # | ROUNDEC 
-    def copy(to_s3_filename, *options)
-      if options.last.is_a? Hash
-        options_hash = options.last
-      else
-        options_hash = {}
-      end
-
-      credentials, copy_options =
-        ::ActiveRecord::QueryMethods::CopyUnloadParser.parse_options(options, options_hash,
-                                                                     VALID_COPY_SWITCHES, VALID_COPY_OPTIONS, VALID_UNQUOTED_COPY_OPTIONS, VALID_SPECIAL_COPY_OPTIONS)
-
-
-      conncection.execute(Arel::Nodes::CopyStatement.new(Arel::Nodes::Copy.new(table_name, to_s3_filename), copy_options.join(" ")).to_sql)
-    end
-  end
-end

data/lib/monkeypatch_arel.rb

@@ -1,96 +0,0 @@
-module Arel
-  module Nodes
-    class Relation < Arel::Nodes::Unary
-    end
-
-    class Unload < Arel::Nodes::Binary
-      alias :statement :left
-      alias :statement= :left=
-      alias :to :right
-      alias :to= :right=
-      def initialize statement = nil, to = nil
-        super
-      end
-
-      def initialize_copy other
-        super
-        @right = @right.clone
-      end
-    end
-
-    class UnloadStatement < Arel::Nodes::Binary
-      alias :relation :left
-      alias :relation= :left=
-      alias :options :right
-      alias :options= :right=
-
-      def initialize relation = nil, options = []
-        super
-      end
-
-      def initialize_copy other
-        super
-        @right = @right.clone
-      end
-    end
-
-    class Copy < Arel::Nodes::Binary
-      alias :statement :left
-      alias :statement= :left=
-      alias :from :right
-      alias :from= :right=
-      def initialize statement = nil, from = nil
-        super
-      end
-
-      def initialize_copy other
-        super
-        @right = @right.clone
-      end
-    end
-
-    class CopyStatement < Arel::Nodes::Binary
-      alias :relation :left
-      alias :relation= :left=
-      alias :options :right
-      alias :options= :right=
-
-      def initialize relation = nil, options = []
-        super
-      end
-
-      def initialize_copy other
-        super
-        @right = @right.clone
-      end
-    end
-
-  end
-end
-
-module Arel
-  module Visitors
-    class ToSql < Arel::Visitors::Visitor
-
-      def visit_Arel_Nodes_UnloadStatement o
-        "#{visit o.relation} #{o.options}"
-      end
-
-      def visit_Arel_Nodes_Unload o
-        "UNLOAD (#{visit o.statement}) TO #{visit o.to}"
-      end
-
-      def visit_Arel_Nodes_CopyStatement o
-        "#{visit o.relation} #{o.options}"
-      end
-
-      def visit_Arel_Nodes_Copy o
-        "COPY #{o.statement} FROM #{visit o.from}"
-      end
-
-      def visit_Arel_Nodes_Relation o
-        visit o.expr.to_sql
-      end
-    end
-  end
-end

data/spec/active_record/base_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Base do
-  let(:connection) { ActiveRecord::Base.redshift_connection(TEST_CONNECTION_HASH) }
-
-  describe '.redshift_connection' do
-    it "opens a connection" do
-      expect(connection).to be_active
-    end
-  end
-
-  describe 'set UTC timezone for datetime' do
-    class TimezoneTest < ActiveRecord::Base
-      default_timezone = :jst
-      establish_connection(TEST_CONNECTION_HASH.merge('adapter' => 'redshift', 'read_timezone' => 'UTC'))
-    end
-
-    before do
-      connection.query <<-SQL
-        CREATE TABLE public.timezone_tests ( "id" INTEGER NULL, "created_at" TIMESTAMP NULL );
-        INSERT INTO public.timezone_tests VALUES (1, '2013-07-01 12:00:00');
-      SQL
-    end
-
-    after do
-      connection.query <<-SQL
-        DROP TABLE public.timezone_tests;
-      SQL
-    end
-
-    it 'returns timestamp as UTC' do
-      data = TimezoneTest.all.first
-      expect(data.created_at.zone).to eq 'UTC'
-      expect(data.created_at).to eq Time.parse '2013-07-01 12:00:00 UTC'
-    end
-  end
-end

data/spec/active_record/connection_adapters/redshift_adapter_spec.rb

@@ -1,97 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::ConnectionAdapters::RedshiftAdapter do
-  before(:all) do
-    @connection =  ActiveRecord::Base.redshift_connection(TEST_CONNECTION_HASH)
-
-    @connection.query <<-sql
-    CREATE TABLE public.test ( "id" INTEGER NULL, "name" VARCHAR(80) NULL );
-    CREATE TABLE public.test2 ( "id" INTEGER, "name" VARCHAR );
-    INSERT INTO public.test VALUES (1, 'first');
-    INSERT INTO public.test VALUES (2, 'second');
-    CREATE TABLE test.test ( "id" INTEGER NOT NULL, "is" BOOL NOT NULL );
-    CREATE TABLE test.test2 ( "id" INTEGER, "is" BOOL );
-    sql
-  end
-
-  after(:all) do
-    @connection.query <<-sql
-    DROP TABLE public.test, public.test2, test.test, test.test2;
-    sql
-  end
-
-  describe "#initialize" do
-    it "opens a connection" do
-      @connection.active?.should be_true
-    end
-  end
-
-  describe "#tables" do
-    it "returns all tables in public schema" do
-      @connection.schema_search_path = "public"
-      @connection.tables.should == ["public.test", "public.test2"]
-    end
-
-    it "returns all tables in all schemas" do
-      @connection.schema_search_path = "public, test"
-      @connection.tables.should == ["public.test", "public.test2", "test.test", "test.test2"]
-    end
-  end
-
-  describe "#columns" do
-    it "returns all columns in table in public schema" do
-      id = ActiveRecord::ConnectionAdapters::RedshiftColumn.new("id", "", "integer", true)
-      name =  ActiveRecord::ConnectionAdapters::RedshiftColumn.new("name", "", "character varying(80)", true)
-      @connection.columns("test").should == [id, name]
-    end
-
-    it "returns all columns in table" do
-      id = ActiveRecord::ConnectionAdapters::RedshiftColumn.new("id", "", "integer", false)
-      is =  ActiveRecord::ConnectionAdapters::RedshiftColumn.new("is", "", "boolean", false)
-      @connection.columns("test.test").should == [id, is]
-    end
-  end
-
-  describe "#table_exists?" do
-    it "checks if table in schema exists" do
-      @connection.table_exists?("public.test").should be_true
-    end
-
-    it "checks if unknown table in schema doesn't exist" do
-      @connection.table_exists?("public.null").should be_false
-    end
-
-    it "checks if table in implied schema exists" do
-      @connection.table_exists?("test2").should be_true
-    end
-  end
-
-  describe "#current_database" do
-    it "returns current database" do
-      @connection.current_database.should == TEST_CONNECTION_HASH[:database]
-    end
-  end
-
-  describe "#schema_search_path" do
-    it "returns current database" do
-      @connection.schema_search_path = '"$user", public'
-      @connection.schema_search_path.should == '"$user", public'
-    end
-  end
-
-  describe "#update_sql" do
-    it "returns the number of updated rows" do
-      @connection.update_sql("UPDATE public.test SET name = 'test'").should == 2
-    end
-  end
-
-  describe "#quote_string" do
-    it "quotes the string without surrouding quotes" do
-      @connection.quote_string("quote'd").should == "quote''d"
-    end
-
-    it "returns identical string when no quoting is required" do
-      @connection.quote_string("quote").should == "quote"
-    end
-  end
-end

data/spec/dummy/config/database.example.yml

@@ -1,12 +0,0 @@
-# CREATE USER test_user WITH PASSWORD 'test_password';
-# CREATE SCHEMA test AUTHORIZATION test_user;
-host: CLUSTERNAME.IDENTIFIER.REGION.redshift.amazonaws.com
-port: 5432
-username: test_user
-password: test_password
-database: dev
-#As RedShift does not support RETURNING keyword yet
-use_insert_returning: false
-# ssl: true
-# search_path:
-# role:

data/spec/spec_helper.rb

@@ -1,33 +0,0 @@
-require "active_record"
-require "yaml"
-require "active_record/connection_adapters/redshift_adapter"
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end
-
-TEST_CONNECTION_FILENAME = File.expand_path("../dummy/config/database.yml", __FILE__)
-
-if File.exist?(TEST_CONNECTION_FILENAME)
-  TEST_CONNECTION_HASH = YAML.load(File.read(TEST_CONNECTION_FILENAME)).with_indifferent_access
-else
-  puts
-  puts "Create #{TEST_CONNECTION_FILENAME} with connection info "
-  puts "for your Redshift test database in order to run the test suite."
-  puts
-  exit(1)
-end