activerecord-cubrid2-adapter 0.0.1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :extra, to: :sql_type_metadata, allow_nil: true
+
+        def unsigned?
+          false
+        end
+
+        def case_sensitive?
+          collation && !collation.end_with?('_ci')
+        end
+
+        def auto_increment?
+          !respond_to?(:extra) && extra == 'auto_increment'
+        end
+
+        def virtual?
+          # /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(*param1, **param2) # :nodoc:
+          if ExplainRegistry.collect? && prepared_statements
+            unprepared_statement { super }
+          else
+            super
+          end
+        end
+
+        def query(sql, name = nil) # :nodoc:
+          execute(sql, name)
+        end
+
+        def query_values(sql, name = nil) # :nodoc:
+          res = exec_query(sql, name)
+          res&.rows&.map(&:first)
+        end
+
+        def query_value(sql, name = nil) # :nodoc:
+          _single_value_from_rows(query(sql, name))
+        end
+
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc, :with
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          # @connection.query_options[:database_timezone] = ActiveRecord.default_timezone
+
+          super
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name) do |result|
+              _build_stmt_result(result)
+            end
+          else
+            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
+              _build_stmt_result(result)
+            end
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = [])
+          if without_prepared_statement?(binds)
+            @lock.synchronize do
+              execute_and_free(sql, name) { |stmt| stmt.affected_rows }
+            end
+          else
+            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+          end
+        end
+        alias exec_update exec_delete
+
+        private
+
+        def is_conn_utf8?
+          charset == 'utf8' && collation =~ /^utf8/
+        end
+
+        def _build_stmt_result(stmt)
+          columns = stmt.column_info.map { |col| col['name'] }
+          rows = is_conn_utf8? ? _extract_rows_from_stmt__utf8(stmt) : _extract_rows_from_stmt__raw(stmt)
+          build_result(columns: columns, rows: rows)
+        end
+
+        def _extract_rows_from_stmt__raw(stmt, as_hash: false)
+          rows = []
+          if as_hash
+            while row = stmt.fetch_hash
+              rows << row
+            end
+          else
+            while row = stmt.fetch
+              rows << row
+            end
+          end
+          rows
+        end
+
+        def _extract_rows_from_stmt__utf8(stmt, as_hash: false)
+          rows = []
+          if as_hash
+            while row = stmt.fetch_hash
+              rows << row.map do |x|
+                [x[0], _as_utf8(x[1])]
+              end.to_h
+            end
+          else
+            while row = stmt.fetch
+              rows << row.map { |x| _as_utf8(x) }
+            end
+          end
+          rows
+        end
+
+        def _as_utf8(val)
+          if val.is_a?(String)
+            val.force_encoding('UTF-8')
+          else
+            val
+          end
+        end
+
+        def _single_value_from_rows(rows)
+          row = rows.fetch
+          row && row.first
+        end
+
+        def execute_batch(statements, name = nil)
+          combine_multi_statements(statements).each do |statement|
+            execute(statement, name)
+          end
+        end
+
+        def default_insert_value(column)
+          super unless column.auto_increment?
+        end
+
+        def last_inserted_id(_result)
+          stmt = query('SELECT LAST_INSERT_ID() as val_')
+          row = stmt.fetch
+          row[0]&.to_i
+        end
+
+        def supports_set_server_option?
+          @connection.respond_to?(:set_server_option)
+        end
+
+        def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+
+          type_casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, type_casted_binds) do
+            stmt = if cache_stmt
+                     @statements[sql] ||= @connection.prepare(sql)
+                   else
+                     @connection.prepare(sql)
+                   end
+
+            begin
+              result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                stmt.execute(*type_casted_binds)
+              end
+            rescue Cubrid2::Error => e
+              if cache_stmt
+                @statements.delete(sql)
+              else
+                stmt.close
+              end
+              raise e
+            end
+
+            ret = yield stmt, result
+            result.free if result
+            stmt.close unless cache_stmt
+            ret
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an query that resembles Cubrid shell:
+        #
+        #   Field                 Type                  Null                  Key                   Default               Extra
+        # ====================================================================================================================================
+        #   'host_year'           'INTEGER'             'NO'                  'PRI'                 NULL                  ''
+        #   'event_code'          'INTEGER'             'NO'                  'MUL'                 NULL                  ''
+        #   'athlete_code'        'INTEGER'             'NO'                  'MUL'                 NULL                  ''
+        #   'stadium_code'        'INTEGER'             'NO'                  ''                    NULL                  ''
+        #   'nation_code'         'CHAR(3)'             'YES'                 ''                    NULL                  ''
+        #   'medal'               'CHAR(1)'             'YES'                 ''                    NULL                  ''
+        #   'game_date'           'DATE'                'YES'                 ''                    NULL                  ''
+        #
+        # 7 rows selected. (0.010673 sec)
+        #
+        def pp(result, elapsed)
+          widths    = compute_column_widths(result) + 4
+          separator = build_separator(widths)
+
+          pp = []
+
+          pp << build_cells(result.columns, widths)
+          pp << separator
+
+          result.rows.each do |row|
+            pp << build_cells(row, widths)
+          end
+
+          pp << build_footer(result.rows.length, elapsed)
+
+          pp.join("\n") + "\n"
+        end
+
+        private
+
+        def compute_column_widths(result)
+          [].tap do |widths|
+            result.columns.each_with_index do |column, i|
+              cells_in_column = [column] + result.rows.map { |r| r[i].nil? ? 'NULL' : r[i].to_s }
+              widths << cells_in_column.map(&:length).max
+            end
+          end
+        end
+
+        def build_separator(widths)
+          '=' * widths
+        end
+
+        def build_cells(items, widths)
+          cells = []
+          items.each_with_index do |item, i|
+            item = 'NULL' if item.nil?
+            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
+            cells << item.to_s.send(justifier, widths[i])
+          end
+          '  ' + cells.join('  ') + '  '
+        end
+
+        def build_footer(nrows, elapsed)
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          "#{nrows} #{rows_label} selected. (%.2f sec)" % elapsed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      module Quoting # :nodoc:
+        # def quote_string(s)
+        #   super
+        # end
+
+        def quote_column_name(name)
+          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+        end
+
+        def quote_table_name(name)
+          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+        end
+
+        # def quote_table_name(name) # :nodoc:
+        #   schema, name = extract_schema_qualified_name(name.to_s)
+
+        #   self.class.quoted_table_names[name] ||= "`#{quote_string(schema)}`.`#{quote_string(name)}`".freeze
+        # end
+
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(name)
+          quote_table_name(name)
+        end
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        end
+
+        # Quotes column names for use in SQL queries.
+        #def quote_column_name(name) # :nodoc:
+          #self.class.quoted_column_names[name] ||= quote(super).freeze
+          #pp "## quote_column_name: #{name}"
+          #self.class.quoted_column_names[name] ||= quote_string(name).freeze
+        #end
+
+        # def visit_Arel_Attributes_Attribute(o, collector)
+        #   join_name = o.relation.table_alias || o.relation.name
+        #   collector << quote_table_name(join_name) << "." << quote_column_name(o.name)
+        # end
+
+        def unquoted_true
+          1
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if supports_datetime_with_precision?
+            super
+          else
+            super.sub(/\.\d{6}\z/, '')
+          end
+        end
+
+        def quoted_binary(value)
+          # https://www.cubrid.org/manual/ko/11.2/sql/literal.html#id5
+          "X'#{value.hex}'"
+        end
+
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              # "table_name"."column_name" | function(one or no argument)
+              # [table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|[`"\[]\w+[`"\]]\.)?(?:\w+|[`"\[]\w+[`"\]])) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+AS\s+(?:\w+|`\w+`))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              # "table_name"."column_name" | function(one or no argument)
+              # [table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|[`"\[]\w+[`"\]]\.)?(?:\w+|[`"\[]\w+[`"\]])) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+        private
+
+        def _type_cast(value)
+          case value
+          when Date, Time then value
+          else super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      class SchemaCreation < ActiveRecord::ConnectionAdapters::SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, to: :@conn, private: true
+
+        private
+
+        # def visit_DropForeignKey(name)
+        #   "DROP FOREIGN KEY #{name}"
+        # end
+
+        def visit_DropCheckConstraint(name)
+          "DROP CONSTRAINT #{name}"
+        end
+
+        def visit_AddColumnDefinition(o)
+          add_column_position!(super, column_options(o.column))
+        end
+
+        def visit_ChangeColumnDefinition(o)
+          change_column_sql = +"CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+          add_column_position!(change_column_sql, column_options(o.column))
+        end
+
+        def visit_CreateIndexDefinition(o)
+          sql = visit_IndexDefinition(o.index, true)
+          sql
+        end
+
+        def visit_IndexDefinition(o, create = false)
+          index_type = o.type&.to_s&.upcase || o.unique && "UNIQUE"
+
+          sql = create ? ["CREATE"] : []
+          sql << index_type if index_type
+          sql << "INDEX"
+          sql << quote_column_name(o.name)
+          #sql << "USING #{o.using}" if o.using
+          sql << "ON #{quote_table_name(o.table)}" if create
+          sql << "(#{quoted_columns(o)})"
+
+          add_sql_comment!(sql.join(" "), o.comment)
+        end
+
+        def add_table_options!(create_sql, options)
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def add_column_options!(sql, options)
+          # In cubrid, default value of timestamp follows system parameter 'return_null_on_function_errors'
+          # if return_null_on_function_errors == 'no', timestamp null means error.
+          # https://www.cubrid.org/manual/en/10.1/sql/datatype.html#date-time-type
+          if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key] &&
+             !(options[:null] == false || options_include_default?(options))
+            sql << ' NULL'
+          end
+
+          if charset = options[:charset]
+            sql << " CHARSET #{charset}"
+          end
+
+          if collation = options[:collation]
+            sql << " COLLATE #{collation}"
+          end
+
+          if as = options[:as]
+            sql << " AS (#{as})"
+          end
+
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def add_column_position!(sql, options)
+          if options[:first]
+            sql << ' FIRST'
+          elsif options[:after]
+            sql << " AFTER #{quote_column_name(options[:after])}"
+          end
+
+          sql
+        end
+
+        def index_in_create(table_name, column_name, options)
+          index_def, algorithm, if_not_exists = @conn.add_index_options(table_name, column_name, **options)
+          index_name = index_def.name
+          index_columns = index_def.columns.map { |x| quote_column_name(x) }.join(', ')
+          index_type = index_def.unique ? 'UNIQUE' : ''
+          comment = index_def.comment
+          add_sql_comment!(
+            +"#{index_type} INDEX #{quote_column_name(index_name)} (#{index_columns})", comment
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      module ColumnMethods
+        extend ActiveSupport::Concern
+        included do
+          define_column_methods :blob, :clob, :nchar
+
+          alias_method :char, :nchar
+        end
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, **options) # :nodoc:
+          case type
+          when :primary_key
+            type = :integer
+            options[:limit] ||= 8
+            options[:primary_key] = true
+          end
+
+          super
+        end
+
+        private
+
+        def aliased_types(_name, fallback)
+          fallback
+        end
+
+        def integer_like_primary_key_type(type, options)
+          options[:auto_increment] = true
+          type
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_reader :null, :visible
+
+        def initialize(table, name, unique = false, columns = [], **options)
+          options.tap do |o|
+            o[:lengths] ||= {}
+            o[:orders] ||= {}
+            o[:opclasses] ||= {}
+          end
+
+          # get rise to error
+          @visible = options.delete(:visible)
+          @null = options.delete(:null)
+
+          super(table, name, unique, columns, **options)
+        end
+
+        def column_options
+          super.tap { |o|
+            o[:null] = @null
+            o[:visible] = @visible
+          }
+        end
+
+        private
+
+        def concise_options(options)
+          if columns.size == options.size && options.values.uniq.size == 1
+            options.values.first
+          else
+            options
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Cubrid2
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+
+        def prepare_column_options(column)
+          spec = super
+          spec[:auto_increment] = 'true' if column.auto_increment?
+          spec
+        end
+
+        def column_spec_for_primary_key(column)
+          spec = super
+          spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+          spec
+        end
+
+        def default_primary_key?(column)
+          super && column.auto_increment?
+        end
+
+        def explicit_primary_key_default?(column)
+          column.type == :integer && !column.auto_increment?
+        end
+      end
+    end
+  end
+end