activerecord-cubrid2-adapter 0.0.1

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

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          indexes = []
+          current_index = nil
+          execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", 'SCHEMA') do |result|
+            each_hash(result) do |row|
+              if current_index != row[:Key_name]
+                next if row[:Key_name] == 'PRIMARY' # skip the primary key
+
+                current_index = row[:Key_name]
+
+                cubrid_index_type = row[:Index_type].downcase.to_sym
+
+                # currently only support btree
+                # https://www.cubrid.org/manual/en/11.2/sql/query/show.html?highlight=show%20index#show-index
+                index_using = cubrid_index_type
+                index_type = nil
+
+                indexes << [
+                  row[:Table],
+                  row[:Key_name],
+                  row[:Non_unique].to_i == 0,
+                  [],
+                  { lengths: {},
+                    orders: {},
+                    type: index_type,
+                    using: index_using,
+                    comment: row[:Comment].presence,
+                    null: row[:Null] == 'YES',
+                    visible: row[:Visible] == 'YES' }
+                ]
+              end
+
+              if row[:Func]
+                expression = row[:Func]
+                expression = +"(#{expression})" unless expression.start_with?('(')
+                indexes.last[-2] << expression
+                indexes.last[-1][:expressions] ||= {}
+                indexes.last[-1][:expressions][expression] = expression
+                indexes.last[-1][:orders][expression] = :desc if row[:Collation] == 'D'
+              else
+                indexes.last[-2] << row[:Column_name]
+                indexes.last[-1][:lengths][row[:Column_name]] = row[:Sub_part].to_i if row[:Sub_part]
+                indexes.last[-1][:orders][row[:Column_name]] = :desc if row[:Collation] == 'D'
+              end
+            end
+          end
+
+          indexes.map do |index|
+            options = index.pop
+
+            if expressions = options.delete(:expressions)
+              orders = options.delete(:orders)
+              lengths = options.delete(:lengths)
+
+              columns = index[-1].map do |name|
+                [name.to_sym, expressions[name] || +quote_column_name(name)]
+              end.to_h
+
+              index[-1] = add_options_for_index_columns(
+                columns, order: orders, length: lengths
+              ).values.join(', ')
+            end
+
+            IndexDefinition.new(*index, **options)
+          end
+        end
+
+        def remove_column(table_name, column_name, type = nil, **options)
+          remove_foreign_key(table_name, column: column_name) if foreign_key_exists?(table_name, column: column_name)
+          super
+        end
+
+        def create_table(table_name, options: default_row_format, **)
+          super
+        end
+
+        def internal_string_options_for_primary_key
+          super.tap do |options|
+            if !row_format_dynamic_by_default? && charset =~ /^utf8/
+              options[:collation] = collation.sub(/\A[^_]+/, 'utf8')
+            end
+          end
+        end
+
+        def update_table_definition(table_name, base)
+          Cubrid2::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          Cubrid2::SchemaDumper.create(self, options)
+        end
+
+        # Maps logical Rails types to Cubrid-specific data types.
+        def type_to_sql(type, limit: nil,
+                        precision: nil, scale: nil,
+                        size: limit_to_size(limit, type),
+                        unsigned: nil, **)
+
+          case type.to_s
+          when 'integer'
+            integer_to_sql(limit)
+          when 'serial'
+            integer_to_sql(8) #bigint
+          when 'float', 'real', 'double', 'double precision'
+            float_to_sql(limit)
+          when 'text', 'string', 'varchar', 'char varing'
+            type_with_size_to_sql('string', size)
+          when 'char', 'character'
+            type_with_size_to_sql('char', size)
+          when 'blob', 'binary'
+            type_with_size_to_sql('blob', size)
+          when 'clob'
+            type_with_size_to_sql('clob', size)
+          when 'nchar', 'nchar varing'
+            raise 'Not supported from cubrid 9.0'
+          else
+            super
+          end
+        end
+
+        def table_alias_length
+          # https://www.cubrid.org/manual/en/9.1.0/sql/identifier.html#id2
+          222
+        end
+
+        private
+
+        def row_format_dynamic_by_default?
+          false
+        end
+
+        def default_row_format
+          return if row_format_dynamic_by_default?
+
+          nil
+        end
+
+        def schema_creation
+          Cubrid2::SchemaCreation.new(self)
+        end
+
+        def create_table_definition(*args, **options)
+          Cubrid2::TableDefinition.new(self, *args, **options)
+        end
+
+        def new_column_from_field(_table_name, field)
+          type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
+          default = field[:Default]
+          default_function = nil
+
+          if type_metadata.type == :datetime # && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+            default_function = default
+            default = nil
+          end
+
+          Cubrid2::Column.new(
+            field[:Field],
+            default,
+            type_metadata,
+            field[:Null] == 'YES',
+            default_function,
+            collation: field[:Collation],
+            comment: field[:Comment].presence,
+            extra: field[:Extra]
+          )
+        end
+
+        def fetch_type_metadata(sql_type, extra = '')
+          Cubrid2::TypeMetadata.new(super(sql_type), extra: extra)
+        end
+
+        def extract_foreign_key_action(specifier)
+          case specifier
+          when 'CASCADE' then :cascade
+          when 'SET NULL' then :nullify
+          when 'RESTRICT' then :restrict
+          end
+        end
+
+        def add_index_length(quoted_columns, **options)
+          lengths = options_for_index_columns(options[:length])
+          quoted_columns.each do |name, column|
+            column << "(#{lengths[name]})" if lengths[name].present?
+          end
+        end
+
+        def add_options_for_index_columns(quoted_columns, **options)
+          quoted_columns = add_index_length(quoted_columns, **options)
+          super
+        end
+
+        def data_source_sql(name = nil, type: nil)
+          scope = quoted_scope(name, type: type)
+          sql = +'SHOW TABLES '
+          sql << " LIKE #{scope[:name]}" if scope[:name]
+          sql
+        end
+
+        def quoted_scope(name = nil, type: nil)
+          schema, name = extract_schema_qualified_name(name)
+          scope = {}
+          scope[:schema] = schema ? quote(schema) : 'database()'
+          scope[:name] = quote(name) if name
+          scope[:type] = quote(type) if type
+          scope
+        end
+
+        def extract_schema_qualified_name(string)
+          return [] if string.nil?
+
+          q1 = '[`\"\[]'
+          q2 = '[`\"\]]'
+          schema, name = string.scan(/[^`"\[\].]+|#{q1}[^"]*#{q2}/)
+          if name.nil?
+            name = schema
+            schema = nil
+          end
+          [schema, name]
+        end
+
+        def type_with_size_to_sql(type, _size)
+          case type
+          when 'string'
+            'varchar'
+          when 'char'
+            'char'
+          when 'blob'
+            'blob'
+          when 'clob'
+            'clob'
+          end
+        end
+
+        def limit_to_size(limit, type)
+          case type.to_s
+          when 'text', 'blob', 'binary'
+            case limit
+            when 0..0xff then               'tiny'
+            when nil, 0x100..0xffff then    nil
+            when 0x10000..0xffffff then     'medium'
+            when 0x1000000..0xffffffff then 'long'
+            else raise ArgumentError, "No #{type} type has byte size #{limit}"
+            end
+          end
+        end
+
+        def integer_to_sql(limit)
+          case limit
+          when 1 then 'smallint'
+          when 2 then 'smallint'
+          when 3 then 'int'
+          when nil, 4 then 'int'
+          when 5..8 then 'bigint'
+          when 9..16 then 'decimal'
+          else raise ArgumentError, "No integer type has byte size #{limit}. Use a decimal with scale 0 instead."
+          end
+        end
+
+        def float_to_sql(limit)
+          case limit
+          when nil, 1..4 then 'float'
+          when 5..8 then 'double'
+          else raise ArgumentError, "No float type has byte size #{limit}. Use a decimal with scale 0 instead."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        undef to_yaml if method_defined?(:to_yaml)
+
+        attr_reader :extra
+
+        def initialize(type_metadata, extra: '')
+          super(type_metadata)
+          @extra = extra
+        end
+
+        def ==(other)
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            extra == other.extra
+        end
+        alias eql? ==
+
+        def hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            extra.hash
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/cubrid2/version.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      VERSION = File.read(File.expand_path("../../../../VERSION", __dir__)).chomp
+    end
+  end
+end

data/lib/active_record/connection_adapters/cubrid2_adapter.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_cubrid2_adapter'
+require 'active_record/connection_adapters/cubrid2/database_statements'
+require 'cubrid2'
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    ER_DATABASE_CONNECTION_ERROR = -1000
+
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def cubrid2_connection(config)
+      config = config.symbolize_keys
+      config[:flags] ||= 0
+
+      client = Cubrid2::Client.new(config)
+      ConnectionAdapters::Cubrid2Adapter.new(client, logger, nil, config)
+    rescue Cubrid2::Error => e
+      if e.error_number == ER_DATABASE_CONNECTION_ERROR
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class Cubrid2Adapter < AbstractCubrid2Adapter
+      ADAPTER_NAME = 'Cubrid2'
+
+      include Cubrid2::DatabaseStatements
+
+      def initialize(connection, logger, connection_options, config)
+        superclass_config = config.reverse_merge(prepared_statements: false)
+        super(connection, logger, connection_options, superclass_config)
+        configure_connection
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def self.database_exists?(config)
+        !!ActiveRecord::Base.cubrid_connection(config)
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
+      def supports_json?
+        database_version >= '10.2'
+      end
+
+      def supports_comments?
+        # https://www.cubrid.org/manual/en/10.0/release_note/r10_0.html#overview
+        database_version >= '10.0'
+      end
+
+      def supports_comments_in_create?
+        supports_comments?
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def supports_lazy_transactions?
+        false
+      end
+
+      # HELPER METHODS ===========================================
+      def each_hash(result) # :nodoc:
+        stmt = result.is_a?(Array) ? result.first : result
+        if block_given?
+          if result && stmt
+            while row = stmt.fetch_hash
+              yield row.symbolize_keys
+            end
+          end
+        else
+          to_enum(:each_hash, stmt)
+        end
+      end
+
+      def error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
+      end
+
+      #--
+      # QUOTING ==================================================
+      #++
+
+      def quote_string(string)
+        # escaping with backslash is only allowed when 'no_backslash_escapes' == 'yes' in cubrid config, default is yes.
+        # See: https://www.cubrid.org/manual/ko/11.2/sql/literal.html#id5
+        # "'#{string.gsub("'", "''")}'"
+        string
+      end
+
+      #--
+      # CONNECTION MANAGEMENT ====================================
+      #++
+
+      def active?
+        @connection.ping
+      end
+
+      def reconnect!
+        super
+        disconnect!
+        connect
+      end
+      alias reset! reconnect!
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        super
+        @connection.close
+      end
+
+      def discard! # :nodoc:
+        super
+        #@connection.automatic_close = false
+        @connection = nil
+      end
+
+      def server_version
+        @connection.server_version
+      end
+
+      def ping
+        @connection.ping
+      end
+
+      def cubrid_connection
+        @connection
+      end
+
+      # 오류??
+      def auto_commit
+        @connection.auto_commit
+      end
+
+      def auto_commit=(flag)
+        @connection.auto_commit = flag
+      end
+
+      private
+
+      def connect
+        @connection = Cubrid2::Client.new(@config)
+        configure_connection
+      end
+
+      def configure_connection
+        @connection.query_options[:as] = :array
+        super
+      end
+
+      def full_version
+        schema_cache.database_version.full_version_string
+      end
+
+      def get_full_version
+        @connection.server_version
+      end
+    end
+  end
+end

data/lib/activerecord-cubrid2-adapter.rb

@@ -0,0 +1,4 @@
+# load local cubrid gem wrapper (ruby code)
+require 'cubrid2'
+
+require 'active_record/connection_adapters/cubrid2_adapter'

data/lib/arel/visitors/cubrid.rb

@@ -0,0 +1,67 @@
+module Arel # :nodoc: all
+  module Visitors
+    class Cubrid < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_Bin(o, collector)
+        collector << 'BINARY '
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_SelectCore(o, collector)
+        o.froms ||= Arel.sql('DB_ROOT')
+        super
+      end
+
+      def visit_Arel_Nodes_Concat(o, collector)
+        collector << ' CONCAT('
+        visit o.left, collector
+        collector << ', '
+        visit o.right, collector
+        collector << ') '
+        collector
+      end
+
+      def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+        collector = visit o.left, collector
+        collector << ' <=> '
+        visit o.right, collector
+      end
+
+      def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+        collector << 'NOT '
+        visit_Arel_Nodes_IsNotDistinctFrom o, collector
+      end
+
+      def visit_Arel_Nodes_Regexp(o, collector)
+        infix_value o, collector, ' REGEXP '
+      end
+
+      def visit_Arel_Nodes_NotRegexp(o, collector)
+        infix_value o, collector, ' NOT REGEXP '
+      end
+
+      # no-op
+      def visit_Arel_Nodes_NullsFirst(o, collector)
+        visit o.expr, collector
+      end
+
+      # In the simple case, Cubrid allows us to place JOINs directly into the UPDATE
+      # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+      # these, we must use a subquery.
+      def prepare_update_statement(o)
+        if o.offset # || has_group_by_and_having?(o) ||
+          has_join_sources?(o) && has_limit_or_offset_or_orders?(o)
+          super
+        else
+          o
+        end
+      end
+      alias prepare_delete_statement prepare_update_statement
+    end
+  end
+end

data/lib/cubrid2/client.rb

@@ -0,0 +1,93 @@
+module Cubrid2
+  class Client
+    delegate :new, :prepare, to: :@conn
+
+    attr_reader :query_options, :read_timeout, :conn
+
+    def self.default_query_options
+      @default_query_options ||= {
+        auto_commit: true
+      }
+    end
+
+    def initialize(opts = {})
+      raise Cubrid2::Error, 'Options parameter must be a Hash' unless opts.is_a? Hash
+
+      opts = Cubrid2::Util.key_hash_as_symbols(opts)
+      @read_timeout = nil
+      @query_options = self.class.default_query_options.dup
+      @query_options.merge! opts
+
+      %i[auto_commit].each do |key|
+        next unless opts.key?(key)
+
+        case key
+        when :auto_commit
+          send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
+        else
+          send(:"#{key}=", opts[key])
+        end
+      end
+
+      flags = 0
+
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname]
+      port     = opts[:port]
+      database = opts[:database] || opts[:dbname] || opts[:db]
+
+      # Correct the data types before passing these values down to the C level
+      user = user.to_s unless user.nil?
+      pass = pass.to_s unless pass.nil?
+      host = host.to_s unless host.nil?
+      port = port.to_i unless port.nil?
+      database = database.to_s unless database.nil?
+
+      @conn = Cubrid.connect database, host, port, user, pass
+    end
+
+    def query(sql, options = {})
+      Thread.handle_interrupt(::Cubrid2::Util::TIMEOUT_ERROR_CLASS => :never) do
+        _query(sql, @query_options.merge(options))
+      end
+    end
+
+    def _query(sql, _options)
+      @conn.query(sql)
+    end
+
+    def query_info
+      info = query_info_string
+      return {} unless info
+
+      info_hash = {}
+      info.split.each_slice(2) { |s| info_hash[s[0].downcase.delete(':').to_sym] = s[1].to_i }
+      info_hash
+    end
+
+    def info
+      self.class.info
+    end
+
+    def ping
+      @conn.server_version.present?
+    end
+
+    def server_version
+      @conn.server_version
+    end
+
+    def close
+      @conn.close
+    end
+
+    def auto_commit
+      @conn.auto_commit
+    end
+
+    def auto_commit=(flag)
+      @conn.auto_commit = flag
+    end
+  end
+end

data/lib/cubrid2/console.rb

@@ -0,0 +1,5 @@
+# Loaded by script/console. Land helpers here.
+
+Pry.config.prompt = lambda do |context, *|
+  "[cubrid2] #{context}> "
+end