rom-sql 3.6.2 → 4.0.0.alpha1

data/lib/rom/sql/commands.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rom/commands'
+require "rom/commands"
 
-require 'rom/sql/commands/create'
-require 'rom/sql/commands/update'
-require 'rom/sql/commands/delete'
+require "rom/sql/commands/create"
+require "rom/sql/commands/update"
+require "rom/sql/commands/delete"

data/lib/rom/sql/dsl.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
-require 'rom/support/inflector'
-require 'rom/constants'
+require "concurrent/map"
+require "rom/support/inflector"
+require "rom/constants"
 
 module ROM
   module SQL

data/lib/rom/sql/errors.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'sequel/deprecated'
-require 'sequel/exceptions'
+require "sequel/deprecated"
+require "sequel/exceptions"
 
-require 'rom/sql/error'
+require "rom/sql/error"
 
 module ROM
   module SQL

data/lib/rom/sql/extensions/active_support_notifications.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'sequel/database/logging'
-require 'active_support/notifications'
+require "sequel/database/logging"
+require "active_support/notifications"
 
 module ROM
   module SQL
     module ActiveSupportInstrumentation
       def log_connection_yield(sql, _conn, args = nil)
         ActiveSupport::Notifications.instrument(
-          'sql.rom',
+          "sql.rom",
           sql: sql,
           name: instrumentation_name,
           binds: args
@@ -24,4 +24,4 @@ module ROM
   end
 end
 
-Sequel::Database.send(:prepend, ROM::SQL::ActiveSupportInstrumentation)
+Sequel::Database.prepend ROM::SQL::ActiveSupportInstrumentation

data/lib/rom/sql/extensions/mysql/type_builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rom/sql/schema/attributes_inferrer'
+require "rom/sql/schema/attributes_inferrer"
 
 module ROM
   module SQL
@@ -9,10 +9,10 @@ module ROM
         defines :db_type_mapping
 
         db_type_mapping(
-          'tinytext' => Types::String,
-          'text' => Types::String,
-          'mediumtext' => Types::String,
-          'longtext' => Types::String
+          "tinytext" => Types::String,
+          "text" => Types::String,
+          "mediumtext" => Types::String,
+          "longtext" => Types::String
         ).freeze
 
         def map_type(ruby_type, db_type, **_)

data/lib/rom/sql/extensions/mysql.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'rom/sql/extensions/mysql/type_builder'
+require "rom/sql/extensions/mysql/type_builder"

data/lib/rom/sql/extensions/postgres/commands.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rom/sql/commands/create'
-require 'rom/sql/commands/update'
+require "rom/sql/commands/create"
+require "rom/sql/commands/update"
 
 module ROM
   module SQL
@@ -83,29 +83,33 @@ module ROM
         #
         # @api public
         class Upsert < SQL::Commands::Create
-          adapter :sql
+          config.component.adapter = :sql
 
-          defines :constraint, :conflict_target, :conflict_where, :update_statement, :update_where
+          setting :constraint
+          setting :conflict_target
+          setting :conflict_where
+          setting :update_statement
+          setting :update_where
 
           # @!attribute [r] constraint
           #  @return [Symbol] the name of the constraint expected to be violated
-          option :constraint, default: -> { self.class.constraint }
+          option :constraint, default: -> { config.constraint }
 
           # @!attribute [r] conflict_target
           #  @return [Object] the column or expression to handle a violation on
-          option :conflict_target, default: -> { self.class.conflict_target }
+          option :conflict_target, default: -> { config.conflict_target }
 
           # @!attribute [r] conflict_where
           #  @return [Object] the index filter, when using a partial index to determine uniqueness
-          option :conflict_where, default: -> { self.class.conflict_where }
+          option :conflict_where, default: -> { config.conflict_where }
 
           # @!attribute [r] update_statement
           #  @return [Object] the update statement which will be executed in case of a violation
-          option :update_statement, default: -> { self.class.update_statement }
+          option :update_statement, default: -> { config.update_statement }
 
           # @!attribute [r] update_where
           #  @return [Object] the WHERE clause to be added to the update
-          option :update_where, default: -> { self.class.update_where }
+          option :update_where, default: -> { config.update_where }
 
           # Tries to insert provided tuples and do an update (or nothing)
           # when the inserted record violates a unique constraint and hence
@@ -137,27 +141,5 @@ module ROM
     end
 
     Commands::Postgres = Postgres::Commands
-
-    Gateway.subscribe('configuration.commands.class.before_build') do |event|
-      klass = event[:command]
-
-      # TODO: remove this conditional in favor of `adapter: :sql` in subscribe
-      #       this is here for backward compatibilty with rom-core 4.x
-      if klass.adapter == :sql
-        dataset = event[:dataset]
-        type = dataset.db.database_type
-
-        if type == :postgres
-          ext =
-            if klass < Commands::Create
-              Postgres::Commands::Create
-            elsif klass < Commands::Update
-              Postgres::Commands::Update
-            end
-
-          klass.include(ext) if ext
-        end
-      end
-    end
   end
 end

data/lib/rom/sql/extensions/postgres/type_builder.rb

@@ -6,40 +6,37 @@ module ROM
       class TypeBuilder < Schema::TypeBuilder
         defines :db_numeric_types, :db_type_mapping, :db_array_type_matcher
 
-        db_numeric_types %w[
-          smallint integer bigint
-          decimal numeric real
-          double\ precision serial bigserial
-        ].to_set.freeze
+        db_numeric_types ["smallint", "integer", "bigint", "decimal", "numeric", "real",
+                          "double precision", "serial", "bigserial"].to_set.freeze
 
         db_type_mapping(
-          'uuid'  => Types::UUID,
-          'money' => Types::Money,
-          'bytea' => Types::Bytea,
-          'json'  => Types::JSON,
-          'jsonb' => Types::JSONB,
-          'xml' => Types::XML,
-          'inet' => Types::IPAddress,
-          'cidr' => Types::IPNetwork,
-          'macaddr' => SQL::Types::String,
-          'point' => Types::Point,
-          'hstore' => Types::HStore,
-          'line' => Types::Line,
-          'circle' => Types::Circle,
-          'box' => Types::Box,
-          'lseg' => Types::LineSegment,
-          'polygon' => Types::Polygon,
-          'path' => Types::Path,
-          'int4range' => Types::Int4Range,
-          'int8range' => Types::Int8Range,
-          'numrange' => Types::NumRange,
-          'tsrange' => Types::TsRange,
-          'tstzrange' => Types::TsTzRange,
-          'daterange' => Types::DateRange,
-          'ltree' => Types::LTree
+          "uuid" => Types::UUID,
+          "money" => Types::Money,
+          "bytea" => Types::Bytea,
+          "json" => Types::JSON,
+          "jsonb" => Types::JSONB,
+          "xml" => Types::XML,
+          "inet" => Types::IPAddress,
+          "cidr" => Types::IPAddress,
+          "macaddr" => SQL::Types::String,
+          "point" => Types::Point,
+          "hstore" => Types::HStore,
+          "line" => Types::Line,
+          "circle" => Types::Circle,
+          "box" => Types::Box,
+          "lseg" => Types::LineSegment,
+          "polygon" => Types::Polygon,
+          "path" => Types::Path,
+          "int4range" => Types::Int4Range,
+          "int8range" => Types::Int8Range,
+          "numrange" => Types::NumRange,
+          "tsrange" => Types::TsRange,
+          "tstzrange" => Types::TsTzRange,
+          "daterange" => Types::DateRange,
+          "ltree" => Types::LTree
         ).freeze
 
-        db_array_type_matcher '[]'.freeze
+        db_array_type_matcher "[]"
 
         def map_pk_type(type, db_type, **options)
           if numeric?(type, db_type)
@@ -66,7 +63,7 @@ module ROM
 
         def map_db_type(db_type)
           self.class.db_type_mapping[db_type] ||
-            (db_type.start_with?('timestamp') ? SQL::Types::Time : nil)
+            (db_type.start_with?("timestamp") ? SQL::Types::Time : nil)
         end
 
         def numeric?(ruby_type, db_type)

data/lib/rom/sql/extensions/postgres/type_serializer.rb

@@ -7,37 +7,36 @@ module ROM
       class TypeSerializer < ROM::SQL::TypeSerializer
         mapping(
           mapping.merge(
-            SQL::Types::String => 'text',
-            Types::UUID => 'uuid',
-            Types::XML => 'xml',
-            Types::Money => 'money',
-            Types::Bytea => 'bytea',
-            Types::JSON => 'json',
-            Types::JSONB => 'jsonb',
-            Types::HStore => 'hstore',
-            Types::IPAddress => 'inet',
-            Types::IPNetwork => 'cidr',
-            Types::Point => 'point',
-            Types::Line => 'line',
-            Types::Circle => 'circle',
-            Types::Box => 'box',
-            Types::LineSegment => 'lseg',
-            Types::Polygon => 'polygon',
-            Types::Path => 'path',
-            Types::Int4Range => 'int4range',
-            Types::Int8Range => 'int8range',
-            Types::NumRange => 'numrange',
-            Types::TsRange => 'tsrange',
-            Types::TsTzRange => 'tstzrange',
-            Types::DateRange => 'daterange',
-            Types::LTree => 'ltree'
+            SQL::Types::String => "text",
+            Types::UUID => "uuid",
+            Types::XML => "xml",
+            Types::Money => "money",
+            Types::Bytea => "bytea",
+            Types::JSON => "json",
+            Types::JSONB => "jsonb",
+            Types::HStore => "hstore",
+            Types::IPAddress => "inet",
+            Types::Point => "point",
+            Types::Line => "line",
+            Types::Circle => "circle",
+            Types::Box => "box",
+            Types::LineSegment => "lseg",
+            Types::Polygon => "polygon",
+            Types::Path => "path",
+            Types::Int4Range => "int4range",
+            Types::Int8Range => "int8range",
+            Types::NumRange => "numrange",
+            Types::TsRange => "tsrange",
+            Types::TsTzRange => "tstzrange",
+            Types::DateRange => "daterange",
+            Types::LTree => "ltree"
           )
         )
 
         def call(type)
           super do
             if type.respond_to?(:primitive) && type.primitive.equal?(Array)
-              "#{ type.meta[:type] }[]"
+              "#{type.meta[:type]}[]"
             end
           end
         end

data/lib/rom/sql/extensions/postgres/types/array.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
+require "sequel/core"
 
 Sequel.extension(:pg_array, :pg_array_ops)
 
-require 'rom/sql/extensions/postgres/types/array_types'
+require "rom/sql/extensions/postgres/types/array_types"
 
 module ROM
   module SQL
@@ -123,7 +123,7 @@ module ROM
           end
 
           def any(_type, expr, value)
-            Attribute[SQL::Types::Bool].meta(sql_expr: { value => expr.pg_array.any })
+            Attribute[SQL::Types::Bool].meta(sql_expr: {value => expr.pg_array.any})
           end
 
           def contained_by(type, expr, other)
@@ -142,7 +142,7 @@ module ROM
             Attribute[type].meta(sql_expr: expr.pg_array.remove(cast(type, value)))
           end
 
-          def join(_type, expr, delimiter = '', null = nil)
+          def join(_type, expr, delimiter = "", null = nil)
             Attribute[SQL::Types::String].meta(sql_expr: expr.pg_array.join(delimiter, null))
           end
 

data/lib/rom/sql/extensions/postgres/types/array_types.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rom/sql/type_extensions'
+require "rom/sql/type_extensions"
 
 module ROM
   module SQL

data/lib/rom/sql/extensions/postgres/types/geometric.rb

@@ -34,55 +34,55 @@ module ROM
         # The list of geometric data types supported by PostgreSQL
         # @see https://www.postgresql.org/docs/current/static/datatype-geometric.html
 
-        Point = Type('point') do
+        Point = Type("point") do
           SQL::Types.define(Values::Point) do
             input do |point|
-              "(#{ point.x },#{ point.y })"
+              "(#{point.x},#{point.y})"
             end
 
             output do |point|
-              x, y = point.to_s[1...-1].split(',', 2)
+              x, y = point.to_s[1...-1].split(",", 2)
               Values::Point.new(Float(x), Float(y))
             end
           end
         end
 
-        Line = Type('line') do
+        Line = Type("line") do
           SQL::Types.define(Values::Line) do
             input do |line|
-              "{#{ line.a },#{ line.b },#{line.c}}"
+              "{#{line.a},#{line.b},#{line.c}}"
             end
 
             output do |line|
-              a, b, c = line.to_s[1..-2].split(',', 3)
+              a, b, c = line.to_s[1..-2].split(",", 3)
               Values::Line.new(Float(a), Float(b), Float(c))
             end
           end
         end
 
-        Circle = Type('circle') do
+        Circle = Type("circle") do
           SQL::Types.define(Values::Circle) do
             input do |circle|
-              "<(#{ circle.center.x },#{ circle.center.y }),#{ circle.radius }>"
+              "<(#{circle.center.x},#{circle.center.y}),#{circle.radius}>"
             end
 
             output do |circle|
-              x, y, r = circle.to_s.tr('()<>', '').split(',', 3)
+              x, y, r = circle.to_s.tr("()<>", "").split(",", 3)
               center = Values::Point.new(Float(x), Float(y))
               Values::Circle.new(center, Float(r))
             end
           end
         end
 
-        Box = Type('box') do
+        Box = Type("box") do
           SQL::Types.define(Values::Box) do
             input do |box|
-              "((#{ box.upper_right.x },#{ box.upper_right.y }),"\
-              "(#{ box.lower_left.x },#{ box.lower_left.y }))"
+              "((#{box.upper_right.x},#{box.upper_right.y}),"\
+                "(#{box.lower_left.x},#{box.lower_left.y}))"
             end
 
             output do |box|
-              x_right, y_right, x_left, y_left = box.to_s.tr('()', '').split(',', 4)
+              x_right, y_right, x_left, y_left = box.to_s.tr("()", "").split(",", 4)
               upper_right = Values::Point.new(Float(x_right), Float(y_right))
               lower_left = Values::Point.new(Float(x_left), Float(y_left))
               Values::Box.new(upper_right, lower_left)
@@ -90,15 +90,15 @@ module ROM
           end
         end
 
-        LineSegment = Type('lseg') do
+        LineSegment = Type("lseg") do
           SQL::Types.define(Values::LineSegment) do
             input do |segment|
-              "[(#{ segment.begin.x },#{ segment.begin.y }),"\
-              "(#{ segment.end.x },#{ segment.end.y })]"
+              "[(#{segment.begin.x},#{segment.begin.y}),"\
+                "(#{segment.end.x},#{segment.end.y})]"
             end
 
             output do |segment|
-              x_begin, y_begin, x_end, y_end = segment.to_s.tr('()[]', '').split(',', 4)
+              x_begin, y_begin, x_end, y_end = segment.to_s.tr("()[]", "").split(",", 4)
               point_begin = Values::Point.new(Float(x_begin), Float(y_begin))
               point_end = Values::Point.new(Float(x_end), Float(y_end))
               Values::LineSegment.new(point_begin, point_end)
@@ -106,35 +106,35 @@ module ROM
           end
         end
 
-        Polygon = Type('polygon') do
+        Polygon = Type("polygon") do
           SQL::Types.define(::Array) do
             input do |points|
-              points_joined = points.map { |p| "(#{ p.x },#{ p.y })" }.join(',')
-              "(#{ points_joined })"
+              points_joined = points.map { |p| "(#{p.x},#{p.y})" }.join(",")
+              "(#{points_joined})"
             end
 
             output do |polygon|
-              coordinates = polygon.to_s.tr('()', '').split(',').each_slice(2)
+              coordinates = polygon.to_s.tr("()", "").split(",").each_slice(2)
               coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }
             end
           end
         end
 
-        Path = Type('path') do
+        Path = Type("path") do
           SQL::Types.define(Values::Path) do
             input do |path|
-              points_joined = path.to_a.map { |p| "(#{ p.x },#{ p.y })" }.join(',')
+              points_joined = path.to_a.map { |p| "(#{p.x},#{p.y})" }.join(",")
 
               if path.open?
-                "[#{ points_joined }]"
+                "[#{points_joined}]"
               else
-                "(#{ points_joined })"
+                "(#{points_joined})"
               end
             end
 
             output do |path|
-              open = path.to_s.start_with?('[') && path.to_s.end_with?(']')
-              coordinates = path.to_s.tr('()[]', '').split(',').each_slice(2)
+              open = path.to_s.start_with?("[") && path.to_s.end_with?("]")
+              coordinates = path.to_s.tr("()[]", "").split(",").each_slice(2)
               points = coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }
 
               if open

data/lib/rom/sql/extensions/postgres/types/json.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
-require 'singleton'
+require "sequel/core"
+require "singleton"
 
 Sequel.extension(:pg_json, :pg_json_ops)
 
@@ -23,11 +23,11 @@ module ROM
           include ::Singleton
 
           def to_s
-            'null'
+            "null"
           end
 
           def inspect
-            'null'
+            "null"
           end
         end
 
@@ -44,7 +44,7 @@ module ROM
             SQL::Types::False
           ]
 
-          JSON = Type('json') do
+          JSON = Type("json") do
             casts = ::Hash.new(-> v { ::Sequel.pg_json(v) })
             json_null = ::Sequel.pg_json_wrap(nil)
             casts[JSONNullType] = -> _ { json_null }
@@ -60,7 +60,7 @@ module ROM
               .meta(read: JSONRead)
           end
 
-          JSONB = Type('jsonb') do
+          JSONB = Type("jsonb") do
             casts = ::Hash.new(-> v { ::Sequel.pg_jsonb(v) })
             jsonb_null = ::Sequel.pg_jsonb_wrap(nil)
             casts[JSONNullType] = -> _ { jsonb_null }
@@ -76,11 +76,11 @@ module ROM
               .meta(read: JSONRead)
           end
         else
-          JSON = Type('json') do
+          JSON = Type("json") do
             (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_json)).meta(read: JSONRead)
           end
 
-          JSONB = Type('jsonb') do
+          JSONB = Type("jsonb") do
             (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_jsonb)).meta(read: JSONRead)
           end
         end
@@ -242,7 +242,7 @@ module ROM
 
           def path_args(path)
             case path.size
-            when 0 then raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
+            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
             when 1 then path[0]
             else path
             end