kudu_adapter 0.1.0

data/lib/active_record/connection_adapters/kudu/type/integer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_model/type/integer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Kudu
+      module Type
+        # :nodoc:
+        class Integer < ::ActiveModel::Type::Integer
+          def type
+            :integer
+          end
+
+          def limit
+            4
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/kudu/type/small_int.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_model/type/integer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Kudu
+      module Type
+        # :nodoc:
+        class SmallInt < ::ActiveModel::Type::Integer
+          def type
+            :smallint
+          end
+
+          def limit
+            2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/kudu/type/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_model/type/string'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Kudu
+      module Type
+        class String < ::ActiveModel::Type::String
+          def type
+            :string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/kudu/type/time.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_model/type/big_integer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Kudu
+      module Type
+        # :nodoc:
+        class Time < ::ActiveModel::Type::BigInteger
+          def type
+            :time
+          end
+
+          def serialize(value)
+            value.to_i
+          end
+
+          def deserialize(value)
+            ::Time.at value.to_i
+          end
+
+          def user_input_in_time_zone(value)
+            value.in_time_zone
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/kudu/type/tiny_int.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_model/type/integer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Kudu
+      module Type
+        # :nodoc:
+        class TinyInt < ::ActiveModel::Type::Integer
+          def type
+            :tinyint
+          end
+
+          def limit
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/kudu_adapter.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/kudu/quoting'
+require 'active_record/connection_adapters/kudu/database_statements'
+require 'active_record/connection_adapters/kudu/schema_statements'
+require 'active_record/connection_adapters/kudu/type/big_int'
+require 'active_record/connection_adapters/kudu/type/boolean'
+require 'active_record/connection_adapters/kudu/type/char'
+require 'active_record/connection_adapters/kudu/type/date_time'
+require 'active_record/connection_adapters/kudu/type/double'
+require 'active_record/connection_adapters/kudu/type/float'
+require 'active_record/connection_adapters/kudu/type/integer'
+require 'active_record/connection_adapters/kudu/type/small_int'
+require 'active_record/connection_adapters/kudu/type/string'
+require 'active_record/connection_adapters/kudu/type/time'
+require 'active_record/connection_adapters/kudu/type/tiny_int'
+require 'impala'
+require 'kudu_adapter/bind_substitution'
+
+module ActiveRecord
+  # Create new connection with Impala database
+  # @param config [::Hash] Connection configuration options
+  class Base
+    def self.kudu_connection(config)
+      ::ActiveRecord::ConnectionAdapters::KuduAdapter.new(nil, logger, config)
+    end
+  end
+
+  # :nodoc:
+  module Timestamp
+    private
+    def _create_record
+      if record_timestamps
+        current_time = current_time_from_proper_timezone
+        all_timestamp_attributes_in_model.each do |column|
+          # force inserting of current time for timestamp columns if is needed
+          write_attribute(column, current_time)
+        end
+      end
+      super
+    end
+  end
+
+  # :nodoc:
+  module ConnectionAdapters
+    # Main Impala connection adapter class
+    class KuduAdapter < ::ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+      include Kudu::DatabaseStatements
+      include Kudu::SchemaStatements
+      include Kudu::Quoting
+
+      ADAPTER_NAME = 'Kudu'
+
+      # @!attribute [r] connection
+      #  @return [::Impala::Connection] Connection which we are working on
+      attr_reader :connection
+
+      NATIVE_DATABASE_TYPES = {
+        primary_key: { name: 'INT' },
+        tinyint: { name: 'TINYINT' }, # 1 byte
+        smallint: { name: 'SMALLINT' }, # 2 bytes
+        integer: { name: 'INT' }, # 4 bytes
+        bigint: { name: 'BIGINT' }, # 8 bytes
+        float: { name: 'FLOAT' },
+        double: { name: 'DOUBLE' },
+        boolean: { name: 'BOOLEAN' },
+        char: { name: 'CHAR', limit: 255 },
+        string: { name: 'STRING' }, # 32767 characters
+        time: { name: 'BIGINT' },
+        datetime: { name: 'BIGINT' }
+      }.freeze
+
+      def initialize(connection, logger, connection_params)
+        super(connection, logger)
+
+        @connection_params = connection_params
+        connect
+        @visitor = ::KuduAdapter::BindSubstition.new self
+      end
+
+      def connect
+        @connection = ::Impala.connect(
+          @connection_params[:host],
+          @connection_params[:port]
+        )
+
+        db_names = @connection.query('SHOW DATABASES').map {|db| db[:name]}
+
+        @connection.execute('USE ' + @connection_params[:database]) if
+          @connection_params[:database].present? && db_names.include?(@connection_params[:database])
+      end
+
+      def disconnect!
+        @connection.close
+        @connection = nil
+      end
+
+      def reconnect!
+        disconnect!
+        connect
+      end
+
+      def active?
+        @connection.execute('SELECT now()')
+        true
+      rescue
+        false
+      end
+
+      def execute(sql, name = nil)
+        with_auto_reconnect do
+          log(sql, name) { @connection.execute(sql) }
+        end
+      end
+
+      def query(sql, name = nil)
+        with_auto_reconnect do
+          log(sql, name) do
+            @connection.query sql
+          end
+        end
+      end
+
+      def lookup_cast_type_from_column(column)
+        lookup_cast_type column.type.to_s
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def supports_multi_insert?
+        false
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def native_database_types
+        ::ActiveRecord::ConnectionAdapters::KuduAdapter::NATIVE_DATABASE_TYPES
+      end
+
+      def initialize_type_map(mapping)
+        mapping.register_type(/bigint/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::BigInt.new)
+        mapping.register_type(/boolean/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Boolean.new)
+        mapping.register_type(/char/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Char.new)
+        mapping.register_type(/datetime/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::DateTime.new)
+        mapping.register_type(/double/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Double.new)
+        mapping.register_type(/float/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Float.new)
+        mapping.register_type(/integer/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Integer.new)
+        mapping.register_type(/smallint/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::SmallInt.new)
+        mapping.register_type(/string/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::String.new)
+        mapping.register_type(/(date){0}time/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::Time.new)
+        mapping.register_type(/tinyint/i, ::ActiveRecord::ConnectionAdapters::Kudu::Type::TinyInt.new)
+      end
+
+      def with_auto_reconnect
+        yield
+      rescue Thrift::TransportException => e
+        raise unless e.message == 'end of file reached'
+        reconnect!
+        yield
+      end
+
+      def create_database(database_name)
+        # TODO: escape name
+        execute "CREATE DATABASE IF NOT EXISTS `#{database_name}`"
+      end
+    end
+  end
+end

data/lib/active_record/tasks/kudu_database_tasks.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_record/tasks/database_tasks'
+
+module ActiveRecord
+  # :nodoc:
+  module Tasks
+    # :nodoc:
+    class KuduDatabaseTasks
+      delegate :connection, :establish_connection, :clear_active_connections!,
+               to: ::ActiveRecord::Base
+
+      # @!attribute [r] configuration
+      #  @return [Hash] Database configuration
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def create
+        establish_connection
+        connection.create_database configuration['database']
+      end
+    end
+
+    DatabaseTasks.register_task(/kudu/, KuduDatabaseTasks)
+  end
+end

data/lib/arel/visitors/kudu.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Arel
+  module Visitors
+    class Kudu < ::Arel::Visitors::ToSql; end
+  end
+end

data/lib/kudu_adapter/bind_substitution.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'arel/visitors/bind_visitor'
+require 'arel/visitors/kudu'
+
+module KuduAdapter
+  # Bind substition class definition
+  class BindSubstition < ::Arel::Visitors::Kudu
+    include ::Arel::Visitors::BindVisitor
+
+    def preparable
+      false
+    end
+  end
+end

data/lib/kudu_adapter/table_definition_extensions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module KuduAdapter
+  # Definitions of additional table capabilities in Kudu
+  module TableDefinitionExtensions
+    # @!attribute [r] partitions
+    #  @return [Array] List of table partition definitions
+    attr_reader :partitions
+
+    # Define single partition
+    # @param name [String] Parition name
+    # @param type [String] Partition type
+    # @param options [Hash] Parition options
+    def partition(name, type, options = {})
+      column(name, type, options)
+      @partitions ||= []
+      @partitions << @columns.pop
+    end
+
+    def row_format
+      'ROW FORMAT DELIMITED FIELDS TERMINATED BY "\t"'
+    end
+
+    def external
+      true
+    end
+  end
+end

data/lib/kudu_adapter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module KuduAdapter
+  VERSION = '0.1.0'
+end

data/lib/kudu_adapter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Requiring with this pattern to mirror ActiveRecord
+require 'active_record/connection_adapters/kudu_adapter'
+require 'active_record/tasks/kudu_database_tasks'

data/spec/spec_config.yaml.template

@@ -0,0 +1,8 @@
+# Copy this file to spec/config.yaml and set appropriate values.
+# You can also use environment variables, see spec_helper.rb
+database:
+  name: 'test'
+  host: '127.0.0.1'
+  port: 28050
+  user: 'kudu'
+  password: 'impala'

data/spec/spec_helper.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'bundler'
+require 'yaml'
+
+Bundler.setup :default, :development
+
+$LOAD_PATH.unshift(File.expand('../../lib', __FILE__))
+
+# Load config, if present
+config_path = File.expand('../spec_config.yaml', __FILE__)
+config = if File.exist?(config_path)
+           puts "==> Loading config from #{config_path}"
+           YAML.load_file config_path
+         else
+           puts '==> Loading config from env or use default'
+           {
+             'database' => {}
+           }
+         end
+
+require 'rspec'
+
+require 'active_record'
+
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/class/attribute_accessors'
+
+require 'active_support/log_subscriber'
+require 'active_record/log_subscriber'
+
+require 'logger'
+
+require 'active_record/connection_adapters/kudu_adapter'
+
+puts "==> Effective ActiveRecord version #{ActiveRecord::VERSION::STRING}"
+
+# :nodoc:
+module LoggerSpecHelper
+  def set_logger
+    @logger = MockLogger.new
+    @old_logger = ActiveRecord::Base.logger
+
+    @notifier = ActiveSupport::Notifications::Fanout.new
+
+    ActiveSupport::LogSubscriber.colorize_logging = false
+
+    ActiveRecord::Base.logger = @logger
+
+    @old_notifier = ActiveSupport::Notifications.notifier
+    ActiveSupport::Notifications.notifier = @notifier
+
+    ActiveRecord::LogSubscriber.attach_to :active_record
+    ActiveSupport::Notifications.subscribe 'sql.active_record',
+                                           ActiveRecord::ExplainSubscriber.new
+  end
+
+  # :nodoc:
+  class MockLogger
+    attr_reader :flush_count
+
+    def initialize
+      @flush_count = 0
+      @logged = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def method_missing(level, message)
+      if respond_to_missing?(level)
+        @logged[level] << message
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, *)
+      %i[debug info warn error].include?(method) || super
+    end
+
+    def logged(level)
+      @logged[level].compact.map { |l| l.to_s.strip }
+    end
+
+    def output(level)
+      logged(level).join "\n"
+    end
+
+    def flush
+      @flush_count += 1
+    end
+
+    def clear(level)
+      @logged[level] = []
+    end
+  end
+end
+
+DATABASE_NAME = config['database']['name'] ||
+                ENV['DATABASE_NAME'] ||
+                'test'
+DATABASE_HOST = config['database']['host'] ||
+                ENV['DATABASE_HOST'] ||
+                '127.0.0.1'
+DATABASE_PORT = config['database']['port'] ||
+                ENV['DATABASE_PORT'] ||
+                28_050
+DATABASE_USER = config['database']['user'] ||
+                ENV['DATABASE_USER'] ||
+                'kudu'
+DATABASE_PASSWORD = config['database']['password'] ||
+                    ENV['DATABASE_PASSWORD'] ||
+                    'impala'
+
+CONNECTION_PARAMS = {
+  adapter: 'kudu',
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD
+}.freeze