rom-sql 2.0.0.beta2 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f6a088c5111442c8a6ac85b97315143395afd3a
-  data.tar.gz: 909c97090b071f2229b84055686ea34c0a31d9e2
+  metadata.gz: 3c40812f8e5e3a90dbb8a24608845b06a69f2e7c
+  data.tar.gz: 0675140e980842b9bfe70aae46826b7e1c4ccb4c
 SHA512:
-  metadata.gz: ebaf850abe38152fad88f59e91a50ecd2ea882b5e9159a252f30b32da5b383dfd8a8079095454daf7c5cffefd8e72da20f7c7c86094f50a4109b0f5fd00bbd09
-  data.tar.gz: 36d28232439734adc2de2f440a28cc57374250efbd001bb4291939ea39c01d7e9cddf1020833bf840baf450ae2f8bee9319b0fd5a8bc93cfcb5eacfb4c26efc7
+  metadata.gz: 872afeaa13eb89ce9bb8606b5dc88f599d01169201464b66f746784baef1dd297fb2cfdf4f1da5f3772e54427d8a19168bd6266444b969b5cf5dbac4f781efec
+  data.tar.gz: b344cad962d4db308295b01c37ec7efdbcfd41d30c7aeeb51cae997188238fa73cc4273c07b12a088c283fbc25035d1afdc63b1bd7734711b70344b2cefef72c

data/CHANGELOG.md

@@ -4,14 +4,80 @@
 
 * Support for schema plugins (flash-gordon)
 * Support for auto migrations (flash-gordon)
+* Add DLS for describing table indexes (flash-gordon)
+
+  ```ruby
+    schema do
+      indexes do
+        index :name, name: :unique_name, unique: true
+        index :props, type: :gin
+        index :name, name: :long_names_only, predicate: 'length(name) > 10'
+        index :user_id, :title, name: :composite_idx
+      end
+    end
+  ```
+
+* Support for composite indexes in the auto-restrictions plugin (flash-gordon)
+* `SQL::Gateway#call` calls a SQL function (flash-gordon)
+
+  ```ruby
+    gateway.(:upper, 'foo') # => "FOO"
+    gateway.(:pg_advisory_xact_lock, 1234) # => nil
+  ```
+
+* `SQL::Gateway#run` executes a SQL string, e.g. a DDL statement (flash-gordon)
+
+  ```ruby
+    gateway.run('set session IntervalStyle to default')
+  ```
+
+* `SQL::Relation#exists` joins a relation with the `EXISTS` operator (flash-gordon)
+
+  ```ruby
+    users.exists(posts) # => users with posts
+  ```
+
+* Support for processing a relation in batches (flash-gordon)
+
+  ```ruby
+    users.each_batch(size: 100) do |rel|
+      rel.
+        command(:update).
+        call(name: users[:first_name].concat(users[:last_name])
+    end
+  ```
+
+* `SQL::Relation#import` inserts data from another relation using the `INSERT ... AS SELECT` syntax which is often far more effective than row-by-row processing and an ordinary multi-insert. Relations defined on another gateway are also supported, and in this case, the implementation falls back to the multi-insert strategy (flash-gordon)
+
+  ```ruby
+    users.import(authors.select { first_name.concat(last_name).as(:name) })
+  ```
+
+* Support for `tinytext`, `text`, `mediumtext`, and `longtext data types in MySQL (panthomakos)
+* The new `pg_explain` plugin for getting query plans on PostgreSQL (flash-gordon)
+
+  ```ruby
+    users.by_pk(1).explain(format: :json, analyze: true)
+  ```
+
+* Support for window function calls
+
+  ```ruby
+    employees.select { [dep_no, salary, int::avg(salary).over(partition: dep_no, order: id).as(:avg_salary)] }
+  ```
+
 
 ### Changed
 
 * [BREAKING] based on rom 4.0 now (flash-gordon + solnic)
 * [BREAKING] `Associates` command plugin requires associations now (solnic)
 * [BREAKING] `Command#transaction` is gone in favor of `Relation#transaction` (solnic)
+* [BREAKING] `PG::JSONArray`, `PG::JSONBArray`, `PG::JSONHash`, and `PG::JSONBHash` types were dropped, use `PG::JSON` and `PG::JSONB` instead (flash-gordon)
 * `ManyToOne` no longer uses a join (solnic)
 * `AutoCombine` and `AutoWrap` plugins were removed as this functionality is provided by core API (solnic)
+* Foreign keys are indexed by default (flash-gordon)
+* Schemas are qualified by default (solnic)
+* `PG::JSON`, `PG::JSONB`, and `PG::Array` now all have read types so that they return plain Hash/Array values instead of Sequel's wrappers (flash-gordon)
 
 ### Fixed
 

data/lib/rom/plugins/relation/sql/postgres/explain.rb

@@ -0,0 +1,54 @@
+module ROM
+  module Plugins
+    module Relation
+      module SQL
+        module Postgres
+          # @api public
+          module Explain
+            # Show the execution plan
+            # One of four different output formats are supported: plain text, XML, JSON, YAML
+            # JSON format will be parsed and unwrapped automatically, plan in other formats
+            # will be returned as a plain string.
+            # Other options will be transparently added to the statement.
+            #
+            # @example
+            #   users.by_pk(1).explain(analyze: true, timing: false) # => Plan output
+            #
+            # @option :format [Symbol] Plan output format
+            #
+            # @return [Hash,String]
+            #
+            # @see https://www.postgresql.org/docs/current/static/sql-explain.html PostgreSQL docs
+            #
+            # @api public
+            def explain(format: :text, **options)
+              bool_options = options.map { |opt, value| "#{ opt.to_s.upcase } #{ !!value }" }
+              format_option = "FORMAT #{ format.to_s.upcase }"
+
+              query =
+                "EXPLAIN (" <<
+                [format_option, *bool_options].join(', ') <<
+                ") " <<
+                dataset.sql
+
+              rows = dataset.with_sql(query).map(:'QUERY PLAN')
+
+              case format
+              when :json
+                rows[0][0]['Plan']
+              else
+                rows.join("\n")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :sql do
+    register :pg_explain, ROM::Plugins::Relation::SQL::Postgres::Explain, type: :relation
+  end
+end

data/lib/rom/sql.rb

@@ -1,5 +1,5 @@
 require 'dry/equalizer'
-require 'sequel'
+
 require 'rom/core'
 
 require 'rom/sql/version'

data/lib/rom/sql/attribute.rb

@@ -1,7 +1,7 @@
 require 'sequel/core'
 require 'dry/core/cache'
 
-require 'rom/schema/attribute'
+require 'rom/attribute'
 
 require 'rom/sql/type_extensions'
 require 'rom/sql/projection_dsl'
@@ -11,10 +11,10 @@ module ROM
     # Extended schema attributes tailored for SQL databases
     #
     # @api public
-    class Attribute < ROM::Schema::Attribute
+    class Attribute < ROM::Attribute
       OPERATORS = %i[>= <= > <].freeze
       NONSTANDARD_EQUALITY_VALUES = [true, false, nil].freeze
-      INDEXED = Set.new([true]).freeze
+      META_KEYS = %i(index foreign_key target sql_expr qualified).freeze
 
       # Error raised when an attribute cannot be qualified
       QualifyError = Class.new(StandardError)
@@ -61,10 +61,10 @@ module ROM
       #
       # @api public
       def qualified(table_alias = nil)
-        return self if qualified?
+        return self if qualified? && table_alias.nil?
 
         case sql_expr
-        when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier
+        when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
           type = meta(qualified: table_alias || true)
           type.meta(sql_expr: type.to_sql_name)
         else
@@ -287,32 +287,31 @@ module ROM
 
       # @api public
       def indexed?
-        !indexes.empty?
+        meta[:index].equal?(true)
       end
 
+      # Returns a new attribute marked as indexed
+      #
       # @api public
-      def indexes
-        if meta[:index] == true
-          INDEXED
-        else
-          meta[:index] || EMPTY_SET
-        end
+      def indexed
+        meta(index: true)
       end
 
       # @api private
       def meta_ast
         meta = super
-        meta[:index] = indexes if indexed?
+        meta[:index] = true if indexed?
         meta
       end
 
+      # Removes metadata from the type
+      #
       # @api private
       def unwrap
-        if optional?
-          self.class.new(right, options).meta(meta)
-        else
-          self
-        end
+        cleaned_meta = meta.reject { |k, _| META_KEYS.include?(k) }
+        type = optional? ? right : self.type
+
+        self.class.new(type.with(meta: cleaned_meta), options)
       end
 
       private

data/lib/rom/sql/errors.rb

@@ -1,3 +1,6 @@
+require 'sequel/deprecated'
+require 'sequel/exceptions'
+
 require 'rom/sql/error'
 
 module ROM

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

@@ -1 +1 @@
-require 'rom/sql/extensions/mysql/attributes_inferrer'
+require 'rom/sql/extensions/mysql/type_builder'

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

@@ -0,0 +1,28 @@
+require 'rom/sql/schema/attributes_inferrer'
+
+module ROM
+  module SQL
+    module MySQL
+      class TypeBuilder < Schema::TypeBuilder
+        defines :db_type_mapping
+
+        db_type_mapping(
+          'tinytext' => Types::String,
+          'text' => Types::String,
+          'mediumtext' => Types::String,
+          'longtext' => Types::String
+        ).freeze
+
+        def map_type(ruby_type, db_type, **_)
+          map_db_type(db_type) || super
+        end
+
+        def map_db_type(db_type)
+          self.class.db_type_mapping[db_type]
+        end
+      end
+    end
+
+    Schema::TypeBuilder.register(:mysql, MySQL::TypeBuilder.new.freeze)
+  end
+end

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

@@ -1,3 +1,5 @@
 require 'rom/sql/extensions/postgres/commands'
 require 'rom/sql/extensions/postgres/types'
-require 'rom/sql/extensions/postgres/attributes_inferrer'
+require 'rom/sql/extensions/postgres/type_builder'
+require 'rom/sql/extensions/postgres/type_serializer'
+require 'rom/plugins/relation/sql/postgres/explain'

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

@@ -3,8 +3,8 @@ require 'rom/sql/commands/update'
 
 module ROM
   module SQL
-    module Commands
-      module Postgres
+    module Postgres
+      module Commands
         module Create
           # Executes insert statement and returns inserted tuples
           #
@@ -45,21 +45,19 @@ module ROM
 
         # Upsert command
         #
-        # Uses a feature of PostgreSQL 9.5 commonly called an "upsert".
-        # The command been called attempts to perform an insert and
-        # can make an update (or silently do nothing) in case of
-        # the insertion was unsuccessful due to a violation of a unique
-        # constraint.
-        # Very important implementation detail is that the whole operation
-        # is atomic, i.e. aware of concurrent transactions, and doesn't raise
-        # exceptions if used properly.
+        # The command beign called attempts to insert a record and
+        # if the inserted row would violate a unique constraint
+        # updates the conflicting row (or silently does nothing).
+        # A very important implementation detail is that the whole operation
+        # is serializable, i.e. aware of concurrent transactions, and doesn't raise
+        # exceptions and doesn't issue missing updates once used properly.
         #
         # See PG's docs in INSERT statement for details
         # https://www.postgresql.org/docs/current/static/sql-insert.html
         #
-        # Normally, the command should configured via class level settings.
-        # By default, that is without any settings provided, the command
-        # uses ON CONFLICT DO NOTHING clause.
+        # Normally, the command should be configured via class level settings.
+        # By default, that is without any setting provided, the command
+        # uses the ON CONFLICT DO NOTHING clause.
         #
         # This implementation uses Sequel's API underneath, the docs are available at
         # http://sequel.jeremyevans.net/rdoc-adapters/classes/Sequel/Postgres/DatasetMethods.html#method-i-insert_conflict
@@ -113,5 +111,24 @@ module ROM
         end
       end
     end
+
+    Commands::Postgres = Postgres::Commands
+
+    Gateway.subscribe('configuration.commands.class.before_build') do |event|
+      klass = event[:command]
+      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

data/lib/rom/sql/extensions/postgres/{attributes_inferrer.rb → type_builder.rb}

@@ -1,11 +1,7 @@
-require 'set'
-require 'rom/sql/schema/attributes_inferrer'
-require 'rom/sql/extensions/postgres/types'
-
 module ROM
   module SQL
-    class Schema
-      class PostgresInferrer < AttributesInferrer[:postgres]
+    module Postgres
+      class TypeBuilder < Schema::TypeBuilder
         defines :db_numeric_types, :db_type_mapping, :db_array_type_matcher
 
         db_numeric_types %w(
@@ -15,29 +11,27 @@ module ROM
         ).to_set.freeze
 
         db_type_mapping(
-          'uuid'  => Types::PG::UUID,
-          'money' => Types::PG::Money,
-          'bytea' => Types::Blob,
-          'json'  => Types::PG::JSON,
-          'jsonb' => Types::PG::JSONB,
-          'inet' => Types::PG::IPAddress,
-          'cidr' => Types::PG::IPAddress,
-          'macaddr' => Types::String,
-          'point' => Types::PG::PointT,
-          'xml' => Types::String,
-          'hstore' => Types::PG::HStore,
-          'line' => Types::PG::LineT,
-          'circle' => Types::PG::CircleT,
-          'box' => Types::PG::BoxT,
-          'lseg' => Types::PG::LineSegmentT,
-          'polygon' => Types::PG::PolygonT,
-          'path' => Types::PG::PathT
+          '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
         ).freeze
 
         db_array_type_matcher '[]'.freeze
 
-        private
-
         def map_pk_type(type, db_type)
           if numeric?(type, db_type)
             type = self.class.numeric_pk_type
@@ -50,9 +44,9 @@ module ROM
 
         def map_type(ruby_type, db_type, enum_values: nil, **_)
           if db_type.end_with?(self.class.db_array_type_matcher)
-            Types::PG::Array(db_type)
+            Types::Array(db_type[0...-2])
           elsif enum_values
-            Types::String.enum(*enum_values)
+            SQL::Types::String.enum(*enum_values)
           else
             map_db_type(db_type) || super
           end
@@ -60,7 +54,7 @@ module ROM
 
         def map_db_type(db_type)
           self.class.db_type_mapping[db_type] ||
-            (db_type.start_with?('timestamp') ? Types::Time : nil)
+            (db_type.start_with?('timestamp') ? SQL::Types::Time : nil)
         end
 
         def numeric?(ruby_type, db_type)
@@ -68,5 +62,7 @@ module ROM
         end
       end
     end
+
+    Schema::TypeBuilder.register(:postgres, Postgres::TypeBuilder.new.freeze)
   end
 end

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

@@ -0,0 +1,39 @@
+module ROM
+  module SQL
+    module Postgres
+      # @api private
+      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::Point => 'point',
+            Types::Line => 'line',
+            Types::Circle => 'circle',
+            Types::Box => 'box',
+            Types::LineSegment => 'lseg',
+            Types::Polygon => 'polygon',
+            Types::Path => 'path'
+          )
+        )
+
+        def call(type)
+          super do
+            if type.respond_to?(:primitive) && type.primitive.equal?(Array)
+              "#{ type.meta[:type] }[]"
+            end
+          end
+        end
+      end
+    end
+
+    TypeSerializer.register(:postgres, Postgres::TypeSerializer.new.freeze)
+  end
+end