Merge pull request #1124 from jruby/test_private

More work needed on type registration but this advances state of posgresql.

Author: enebo

lib/arjdbc/postgresql/adapter.rb

@@ -320,6 +320,38 @@ def extensions
       exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
     end
 
+    # Returns a list of defined enum types, and their values.
+    def enum_types
+      query = <<~SQL
+          SELECT
+            type.typname AS name,
+            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          FROM pg_enum AS enum
+          JOIN pg_type AS type
+            ON (type.oid = enum.enumtypid)
+          GROUP BY type.typname;
+      SQL
+      exec_query(query, "SCHEMA").cast_values
+    end
+
+    # Given a name and an array of values, creates an enum type.
+    def create_enum(name, values)
+      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      query = <<~SQL
+          DO $$
+          BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_type t
+                WHERE t.typname = '#{name}'
+              ) THEN
+                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
+              END IF;
+          END
+          $$;
+      SQL
+      exec_query(query)
+    end
+
     # Returns the configured supported identifier length supported by PostgreSQL
     def max_identifier_length
       @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
@@ -672,6 +704,37 @@ module ActiveRecord::ConnectionAdapters
   class PostgreSQLAdapter < AbstractAdapter
     class_attribute :create_unlogged_tables, default: false
 
+    ##
+    # :singleton-method:
+    # PostgreSQL allows the creation of "unlogged" tables, which do not record
+    # data in the PostgreSQL Write-Ahead Log. This can make the tables faster,
+    # but significantly increases the risk of data loss if the database
+    # crashes. As a result, this should not be used in production
+    # environments. If you would like all created tables to be unlogged in
+    # the test environment you can add the following line to your test.rb
+    # file:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+    class_attribute :create_unlogged_tables, default: false
+
+    ##
+    # :singleton-method:
+    # PostgreSQL supports multiple types for DateTimes. By default, if you use +datetime+
+    # in migrations, Rails will translate this to a PostgreSQL "timestamp without time zone".
+    # Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to
+    # store DateTimes as "timestamp with time zone":
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+    #
+    # Or if you are adding a custom type:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type
+    #
+    # If you're using +:ruby+ as your +config.active_record.schema_format+ and you change this
+    # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
+    class_attribute :datetime_type, default: :timestamp
+
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity

lib/arjdbc/postgresql/oid_types.rb

@@ -116,54 +116,57 @@ def reload_type_map
 
       private
 
-      def initialize_type_map(m = type_map)
-        register_class_with_limit m, 'int2', Type::Integer
-        register_class_with_limit m, 'int4', Type::Integer
-        register_class_with_limit m, 'int8', Type::Integer
-        m.register_type 'oid', OID::Oid.new
-        m.register_type 'float4', Type::Float.new
-        m.alias_type 'float8', 'float4'
-        m.register_type 'text', Type::Text.new
-        register_class_with_limit m, 'varchar', Type::String
-        m.alias_type 'char', 'varchar'
-        m.alias_type 'name', 'varchar'
-        m.alias_type 'bpchar', 'varchar'
-        m.register_type 'bool', Type::Boolean.new
-        register_class_with_limit m, 'bit', OID::Bit
-        register_class_with_limit m, 'varbit', OID::BitVarying
-        m.alias_type 'timestamptz', 'timestamp'
-        m.register_type 'date', OID::Date.new
-
-        m.register_type 'money', OID::Money.new
-        m.register_type 'bytea', OID::Bytea.new
-        m.register_type 'point', OID::Point.new
-        m.register_type 'hstore', OID::Hstore.new
-        m.register_type 'json', Type::Json.new
-        m.register_type 'jsonb', OID::Jsonb.new
-        m.register_type 'cidr', OID::Cidr.new
-        m.register_type 'inet', OID::Inet.new
-        m.register_type 'uuid', OID::Uuid.new
-        m.register_type 'xml', OID::Xml.new
-        m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::Macaddr.new
-        m.register_type 'citext', OID::SpecializedString.new(:citext)
-        m.register_type 'ltree', OID::SpecializedString.new(:ltree)
-        m.register_type 'line', OID::SpecializedString.new(:line)
-        m.register_type 'lseg', OID::SpecializedString.new(:lseg)
-        m.register_type 'box', OID::SpecializedString.new(:box)
-        m.register_type 'path', OID::SpecializedString.new(:path)
-        m.register_type 'polygon', OID::SpecializedString.new(:polygon)
-        m.register_type 'circle', OID::SpecializedString.new(:circle)
-
-        m.register_type 'interval' do |*args, sql_type|
-          precision = extract_precision(sql_type)
-          OID::Interval.new(precision: precision)
-        end
+      def register_class_with_limit(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_limit, ...)
+      end
 
-        register_class_with_precision m, 'time', Type::Time
-        register_class_with_precision m, 'timestamp', OID::DateTime
+      def register_class_with_precision(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_precision, ...)
+      end
 
-        m.register_type 'numeric' do |_, fmod, sql_type|
+      def initialize_type_map(m = type_map)
+        m.register_type "int2", Type::Integer.new(limit: 2)
+        m.register_type "int4", Type::Integer.new(limit: 4)
+        m.register_type "int8", Type::Integer.new(limit: 8)
+        m.register_type "oid", OID::Oid.new
+        m.register_type "float4", Type::Float.new
+        m.alias_type "float8", "float4"
+        m.register_type "text", Type::Text.new
+        register_class_with_limit m, "varchar", Type::String
+        m.alias_type "char", "varchar"
+        m.alias_type "name", "varchar"
+        m.alias_type "bpchar", "varchar"
+        m.register_type "bool", Type::Boolean.new
+        register_class_with_limit m, "bit", OID::Bit
+        register_class_with_limit m, "varbit", OID::BitVarying
+        m.register_type "date", OID::Date.new
+
+        m.register_type "money", OID::Money.new
+        m.register_type "bytea", OID::Bytea.new
+        m.register_type "point", OID::Point.new
+        m.register_type "hstore", OID::Hstore.new
+        m.register_type "json", Type::Json.new
+        m.register_type "jsonb", OID::Jsonb.new
+        m.register_type "cidr", OID::Cidr.new
+        m.register_type "inet", OID::Inet.new
+        m.register_type "uuid", OID::Uuid.new
+        m.register_type "xml", OID::Xml.new
+        m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
+        m.register_type "macaddr", OID::Macaddr.new
+        m.register_type "citext", OID::SpecializedString.new(:citext)
+        m.register_type "ltree", OID::SpecializedString.new(:ltree)
+        m.register_type "line", OID::SpecializedString.new(:line)
+        m.register_type "lseg", OID::SpecializedString.new(:lseg)
+        m.register_type "box", OID::SpecializedString.new(:box)
+        m.register_type "path", OID::SpecializedString.new(:path)
+        m.register_type "polygon", OID::SpecializedString.new(:polygon)
+        m.register_type "circle", OID::SpecializedString.new(:circle)
+
+        register_class_with_precision m, "time", Type::Time
+        register_class_with_precision m, "timestamp", OID::Timestamp
+        register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
+
+        m.register_type "numeric" do |_, fmod, sql_type|
           precision = extract_precision(sql_type)
           scale = extract_scale(sql_type)
 
@@ -183,7 +186,10 @@ def initialize_type_map(m = type_map)
           end
         end
 
-        load_additional_types(m)
+        m.register_type "interval" do |*args, sql_type|
+          precision = extract_precision(sql_type)
+          OID::Interval.new(precision: precision)
+        end
 
         # pgjdbc returns these if the column is auto-incrmenting
         m.alias_type 'serial', 'int4'
@@ -231,6 +237,21 @@ def load_additional_types(type_map, oid = nil) # :nodoc:
         initializer.run(records)
       end
 
+      def extract_scale(sql_type)
+        case sql_type
+        when /\((\d+)\)/ then 0
+        when /\((\d+)(,(\d+))\)/ then $3.to_i
+        end
+      end
+
+      def extract_precision(sql_type)
+        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+      end
+
+      def extract_limit(sql_type)
+        $1.to_i if sql_type =~ /\((.*)\)/
+      end
+
       # Support arrays/ranges for defining attributes that don't exist in the db
       ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
       ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)

test/db/postgresql/simple_test.rb

@@ -209,8 +209,8 @@ def test_extensions
   end
 
   test 'type cast (without column)' do
-    assert_equal 1, connection.type_cast(1, false)
-    assert_equal 'some', connection.type_cast(:some, nil)
+    assert_equal 1, connection.type_cast(1)
+    assert_equal 'some', connection.type_cast(:some)
   end
 
   # def test_jdbc_error

test/db/postgresql/unit_test.rb

@@ -95,8 +95,8 @@ def test_rename_index
 
   private
 
-  def method_missing(method_symbol, *arguments)
-    ActiveRecord::Base.connection.send(method_symbol, *arguments)
+  def method_missing(method_symbol, ...)
+    ActiveRecord::Base.connection.send(method_symbol, ...)
   end
 
 end