activerecord-oracle_enhanced-adapter 7.2.1-java

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        extend ActiveSupport::Concern
+        # QUOTING ==================================================
+        #
+        # see: abstract/quoting.rb
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+          \A
+          (
+            (?:
+              # "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
+          end
+
+          def column_name_with_order_matcher
+            /
+          \A
+          (
+            (?:
+              # "table_name"."column_name" | function(one or no argument)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+            )
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+          end
+
+          def quote_column_name(name) # :nodoc:
+            name = name.to_s
+            QUOTED_COLUMN_NAMES[name] ||= if /\A[a-z][a-z_0-9$#]*\Z/.match?(name)
+              "\"#{name.upcase}\""
+            else
+              # remove double quotes which cannot be used inside quoted identifier
+              "\"#{name.delete('"')}\""
+            end
+          end
+
+          def quote_table_name(name) # :nodoc:
+            name, _link = name.to_s.split("@")
+            QUOTED_TABLE_NAMES[name] ||= [name.split(".").map { |n| quote_column_name(n) }].join(".")
+          end
+        end
+
+        # This method is used in add_index to identify either column name (which is quoted)
+        # or function based index (in which case function expression is not quoted)
+        def quote_column_name_or_expression(name) # :nodoc:
+          name = name.to_s
+          case name
+          # if only valid lowercase column characters in name
+          when /^[a-z][a-z_0-9$#]*$/
+            "\"#{name.upcase}\""
+          when /^[a-z][a-z_0-9$#-]*$/i
+            "\"#{name}\""
+          # if other characters present then assume that it is expression
+          # which should not be quoted
+          else
+            name
+          end
+        end
+
+        # Names must be from 1 to 30 bytes long with these exceptions:
+        # * Names of databases are limited to 8 bytes.
+        # * Names of database links can be as long as 128 bytes.
+        #
+        # Nonquoted identifiers cannot be Oracle Database reserved words
+        #
+        # Nonquoted identifiers must begin with an alphabetic character from
+        # your database character set
+        #
+        # Nonquoted identifiers can contain only alphanumeric characters from
+        # your database character set and the underscore (_), dollar sign ($),
+        # and pound sign (#).
+        # Oracle strongly discourages you from using $ and # in nonquoted identifiers.
+        NONQUOTED_OBJECT_NAME = /[[:alpha:]][\w$#]{0,29}/
+        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}?\Z/
+
+        # unescaped table name should start with letter and
+        # contain letters, digits, _, $ or #
+        # can be prefixed with schema name
+        # CamelCase table names should be quoted
+        def self.valid_table_name?(name) # :nodoc:
+          object_name = name.to_s
+          !!(object_name =~ VALID_TABLE_NAME && !mixed_case?(object_name))
+        end
+
+        def self.mixed_case?(name)
+          object_name = name.include?(".") ? name.split(".").second : name
+          !!(object_name =~ /[A-Z]/ && object_name =~ /[a-z]/)
+        end
+
+        def quote_string(s) # :nodoc:
+          s.gsub(/'/, "''")
+        end
+
+        def quote(value) # :nodoc:
+          case value
+          when Type::OracleEnhanced::CharacterString::Data then
+            "'#{quote_string(value.to_s)}'"
+          when Type::OracleEnhanced::NationalCharacterString::Data then
+            +"N" << "'#{quote_string(value.to_s)}'"
+          when ActiveModel::Type::Binary::Data then
+            "empty_blob()"
+          when Type::OracleEnhanced::Text::Data then
+            "empty_clob()"
+          when Type::OracleEnhanced::NationalCharacterText::Data then
+            "empty_nclob()"
+          else
+            super
+          end
+        end
+
+        def quoted_true # :nodoc:
+          return "'Y'" if emulate_booleans_from_strings
+          "1"
+        end
+
+        def unquoted_true # :nodoc:
+          return "Y" if emulate_booleans_from_strings
+          "1"
+        end
+
+        def quoted_false # :nodoc:
+          return "'N'" if emulate_booleans_from_strings
+          "0"
+        end
+
+        def unquoted_false # :nodoc:
+          return "N" if emulate_booleans_from_strings
+          "0"
+        end
+
+        def type_cast(value)
+          case value
+          when Type::OracleEnhanced::TimestampTz::Data, Type::OracleEnhanced::TimestampLtz::Data
+            if value.acts_like?(:time)
+              zone_conversion_method = ActiveRecord.default_timezone == :utc ? :getutc : :getlocal
+              value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+            else
+              value
+            end
+          when Type::OracleEnhanced::NationalCharacterString::Data
+            value.to_s
+          when Type::OracleEnhanced::CharacterString::Data
+            value
+          else
+            super
+          end
+        end
+
+        private
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+            /[a-z]/.match?(column_name) ? column_name : column_name.downcase
+          end
+      end
+    end
+  end
+end
+
+# if MRI or YARV or TruffleRuby
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby"
+  require "active_record/connection_adapters/oracle_enhanced/oci_quoting"
+# if JRuby
+elsif RUBY_ENGINE == "jruby"
+  require "active_record/connection_adapters/oracle_enhanced/jdbc_quoting"
+else
+  raise "Unsupported Ruby engine #{RUBY_ENGINE}"
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      class SchemaCreation < SchemaCreation
+        private
+          def visit_ColumnDefinition(o)
+            if [:blob, :clob, :nclob].include?(sql_type = type_to_sql(o.type, **o.options).downcase.to_sym)
+              if (tablespace = default_tablespace_for(sql_type))
+                @lob_tablespaces ||= {}
+                @lob_tablespaces[o.name] = tablespace
+              end
+            end
+            super
+          end
+
+          def visit_TableDefinition(o)
+            create_sql = +"CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+            statements = o.columns.map { |c| accept c }
+            statements << accept(o.primary_keys) if o.primary_keys
+
+            if use_foreign_keys?
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
+            end
+
+            create_sql << "(#{statements.join(', ')})" if statements.present?
+
+            unless o.temporary
+              @lob_tablespaces.each do |lob_column, tablespace|
+                create_sql << " LOB (#{quote_column_name(lob_column)}) STORE AS (TABLESPACE #{tablespace}) \n"
+              end if defined?(@lob_tablespaces)
+              create_sql << " ORGANIZATION #{o.organization}" if o.organization
+              if (tablespace = o.tablespace || default_tablespace_for(:table))
+                create_sql << " TABLESPACE #{tablespace}"
+              end
+            end
+            add_table_options!(create_sql, o)
+            create_sql << " AS #{to_sql(o.as)}" if o.as
+            create_sql
+          end
+
+          def default_tablespace_for(type)
+            OracleEnhancedAdapter.default_tablespaces[type]
+          end
+
+          def add_column_options!(sql, options)
+            type = options[:type] || ((column = options[:column]) && column.type)
+            type = type && type.to_sym
+            # handle case of defaults for CLOB/NCLOB columns, which would otherwise get "quoted" incorrectly
+            if options_include_default?(options)
+              if type == :text
+                sql << " DEFAULT #{@conn.quote(options[:default])}"
+              elsif type == :ntext
+                sql << " DEFAULT #{@conn.quote(options[:default])}"
+              else
+                sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
+              end
+            end
+            # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
+            if options[:null] == false
+              sql << " NOT NULL"
+            elsif options[:null] == true
+              sql << " NULL" unless type == :primary_key
+            end
+            # add AS expression for virtual columns
+            if options[:as].present?
+              sql << " AS (#{options[:as]})"
+            end
+            if options[:primary_key] == true
+              sql << " PRIMARY KEY"
+            end
+          end
+
+          def action_sql(action, dependency)
+            if action == "UPDATE"
+              raise ArgumentError, <<~MSG
+                '#{action}' is not supported by Oracle
+              MSG
+            end
+            case dependency
+            when :nullify then "ON #{action} SET NULL"
+            when :cascade  then "ON #{action} CASCADE"
+            else
+              raise ArgumentError, <<~MSG
+                '#{dependency}' is not supported for #{action}
+                Supported values are: :nullify, :cascade
+              MSG
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          # This is a placeholder for future :auto_increment support
+          super
+        end
+
+        [
+          :raw,
+          :timestamptz,
+          :timestampltz,
+          :ntext
+        ].each do |column_type|
+          module_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{column_type}(*args, **options)
+              args.each { |name| column(name, :#{column_type}, **options) }
+            end
+          CODE
+        end
+      end
+
+      class ReferenceDefinition < ActiveRecord::ConnectionAdapters::ReferenceDefinition # :nodoc:
+        def initialize(
+          name,
+          polymorphic: false,
+          index: true,
+          foreign_key: false,
+          type: :integer,
+          **options)
+          super
+        end
+      end
+
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) # :nodoc:
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_accessor :parameters, :statement_parameters, :tablespace
+
+        def initialize(table, name, unique, columns, orders, type, parameters, statement_parameters, tablespace)
+          @parameters = parameters
+          @statement_parameters = statement_parameters
+          @tablespace = tablespace
+          super(table, name, unique, columns, orders: orders, type: type)
+        end
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include OracleEnhanced::ColumnMethods
+
+        attr_accessor :tablespace, :organization
+        def initialize(
+          conn,
+          name,
+          temporary: false,
+          options: nil,
+          as: nil,
+          tablespace: nil,
+          organization: nil,
+          comment: nil,
+          **
+        )
+          @tablespace = tablespace
+          @organization = organization
+          super(conn, name, temporary: temporary, options: options, as: as, comment: comment)
+        end
+
+        def new_column_definition(name, type, **options) # :nodoc:
+          if type == :virtual
+            raise "No virtual column definition found." unless options[:as]
+            type = options[:type]
+          end
+          super
+        end
+
+        def references(*args, **options)
+          super(*args, type: :integer, **options)
+        end
+        alias :belongs_to :references
+
+        private
+          def valid_column_definition_options
+            super + [ :as, :sequence_name, :sequence_start_value, :type ]
+          end
+      end
+
+      class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include OracleEnhanced::ColumnMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module OracleEnhanced # :nodoc:
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        DEFAULT_PRIMARY_KEY_COLUMN_SPEC = { precision: "38", null: "false" }.freeze
+        private_constant :DEFAULT_PRIMARY_KEY_COLUMN_SPEC
+
+        private
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.except!(:precision) if prepare_column_options(column) == DEFAULT_PRIMARY_KEY_COLUMN_SPEC
+            spec
+          end
+
+          def tables(stream)
+            # do not include materialized views in schema dump - they should be created separately after schema creation
+            sorted_tables = (@connection.tables - @connection.materialized_views).sort
+            sorted_tables.each do |tbl|
+              # add table prefix or suffix for schema_migrations
+              next if ignored? tbl
+              table(tbl, stream)
+            end
+            # following table definitions
+            # add foreign keys if table has them
+            sorted_tables.each do |tbl|
+              next if ignored? tbl
+              foreign_keys(tbl, stream)
+            end
+
+            # add synonyms in local schema
+            synonyms(stream)
+          end
+
+          def synonyms(stream)
+            syns = @connection.synonyms
+            syns.each do |syn|
+              next if ignored? syn.name
+              table_name = syn.table_name
+              table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
+              stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
+              stream.puts
+            end
+            stream.puts unless syns.empty?
+          end
+
+          def _indexes(table, stream)
+            if (indexes = @connection.indexes(table)).any?
+              add_index_statements = indexes.filter_map do |index|
+                case index.type
+                when nil
+                  # do nothing here. see indexes_in_create
+                  statement_parts = []
+                when "CTXSYS.CONTEXT"
+                  if index.statement_parameters
+                    statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
+                    statement_parts << index.statement_parameters
+                  else
+                    statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
+                    statement_parts << index.columns.inspect
+                    statement_parts << ("sync: " + $1.inspect) if index.parameters =~ /SYNC\((.*?)\)/
+                    statement_parts << ("name: " + index.name.inspect)
+                  end
+                else
+                  # unrecognized index type
+                  statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
+                end
+                "  " + statement_parts.join(", ") unless statement_parts.empty?
+              end
+
+              return if add_index_statements.empty?
+
+              stream.puts add_index_statements.sort.join("\n")
+              stream.puts
+            end
+          end
+
+          def indexes_in_create(table, stream)
+            if (indexes = @connection.indexes(table)).any?
+              index_statements = indexes.map do |index|
+                "    t.index #{index_parts(index).join(', ')}" unless index.type == "CTXSYS.CONTEXT"
+              end
+              stream.puts index_statements.compact.sort.join("\n")
+            end
+          end
+
+          def index_parts(index)
+            index_parts = super
+            index_parts << "tablespace: #{index.tablespace.inspect}" if index.tablespace
+            index_parts
+          end
+
+          def table(table, stream)
+            columns = @connection.columns(table)
+            begin
+              self.table_name = table
+
+              tbl = StringIO.new
+
+              # first dump primary key column
+              if @connection.respond_to?(:primary_keys)
+                pk = @connection.primary_keys(table)
+                pk = pk.first unless pk.size > 1
+              else
+                pk = @connection.primary_key(table)
+              end
+
+              tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+
+              # addition to make temporary option work
+              tbl.print ", temporary: true" if @connection.temporary_table?(table)
+
+              case pk
+              when String
+                tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
+                pkcol = columns.detect { |c| c.name == pk }
+                pkcolspec = column_spec_for_primary_key(pkcol)
+                unless pkcolspec.empty?
+                  if pkcolspec != pkcolspec.slice(:id, :default)
+                    pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
+                  end
+                  tbl.print ", #{format_colspec(pkcolspec)}"
+                end
+              when Array
+                tbl.print ", primary_key: #{pk.inspect}"
+              else
+                tbl.print ", id: false"
+              end
+
+              table_options = @connection.table_options(table)
+              if table_options.present?
+                tbl.print ", #{format_options(table_options)}"
+              end
+
+              tbl.puts ", force: :cascade do |t|"
+
+              # then dump all non-primary key columns
+              columns.each do |column|
+                raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+                next if column.name == pk
+                type, colspec = column_spec(column)
+                tbl.print "    t.#{type} #{column.name.inspect}"
+                tbl.print ", #{format_colspec(colspec)}" if colspec.present?
+                tbl.puts
+              end
+
+              indexes_in_create(table, tbl)
+
+              tbl.puts "  end"
+              tbl.puts
+
+              _indexes(table, tbl)
+
+              tbl.rewind
+              stream.print tbl.read
+            rescue => e
+              stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+              stream.puts "#   #{e.message}"
+              stream.puts
+            ensure
+              self.table_name = nil
+            end
+          end
+
+          def prepare_column_options(column)
+            spec = super
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec = { type: schema_type(column).inspect }.merge!(spec) unless column.type == :decimal
+            end
+
+            spec
+          end
+
+          def default_primary_key?(column)
+            schema_type(column) == :integer
+          end
+
+          def extract_expression_for_virtual_column(column)
+            column_name = column.name
+            @connection.select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+              select data_default from all_tab_columns
+              where owner = SYS_CONTEXT('userenv', 'current_schema')
+              and table_name = :table_name
+              and column_name = :column_name
+            SQL
+          end
+
+          def bind_string(name, value)
+            ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
+          end
+      end
+    end
+  end
+end