Class: ROM::SQL::Relation

Inherits:
Relation
  • Object
show all
Extended by:
Notifications::Listener
Includes:
ROM::SQL, Reading, Writing
Defined in:
lib/rom/sql/relation.rb,
lib/rom/sql/relation/reading.rb,
lib/rom/sql/relation/writing.rb

Overview

Sequel-specific relation extensions

Defined Under Namespace

Modules: Reading, Writing

Constant Summary

Constants included from Reading

Reading::ROW_LOCK_MODES

Constants included from ROM::SQL

CheckConstraintError, ConstraintError, DatabaseError, ERROR_MAP, ForeignKeyConstraintError, MigrationError, MissingConfigurationError, MissingPrimaryKeyError, NoAssociationError, NotNullConstraintError, UniqueConstraintError, UnknownDBTypeError, UnsupportedConversion, VERSION

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Reading

#as_hash, #avg, #count, #distinct, #each_batch, #exclude, #exist?, #exists, #fetch, #first, #group, #group_and_count, #group_append, #having, #invert, #join, #last, #left_join, #limit, #lock, #map, #max, #min, #offset, #order, #pluck, #prefix, #qualified, #qualified_columns, #query, #read, #rename, #reverse, #right_join, #select, #select_append, #select_group, #sum, #unfiltered, #union, #unique?, #unordered, #where, #wrap

Methods included from Writing

#delete, #import, #insert, #multi_insert, #update, #upsert

Methods included from ROM::SQL

migration, with_gateway

Class Method Details

.associations ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



102
103
104
 
# File 'lib/rom/sql/relation.rb', line 102

def self.associations
  schema.associations
end

.define_default_views! ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

rubocop:disable Metrics/MethodLength



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/rom/sql/relation.rb', line 56

def self.define_default_views!
  undef_method :by_pk if method_defined?(:by_pk)

  if schema.primary_key.size > 1
    pks = schema.primary_key
    # @!method by_pk(val1, val2)
    #   Return a relation restricted by its composite primary key
    #
    #   @param [Array] args A list with composite pk values
    #
    #   @return [SQL::Relation]
    #
    #   @api public
    class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
      def by_pk(#{pks.map(&:name).join(", ")})                     # def by_pk(val1, val2)
        s = schema.canonical                                       #   s = schema.canonical
        where(                                                     #   where(
          #{pks.map { "s[:#{_1.name}] => #{_1.name}" }.join(", ")} #     s[:val1] => val1, s[:val2] => val2
        )                                                          #   )
      end                                                          # end
    RUBY
  else
    # @!method by_pk(pk)
    #   Return a relation restricted by its primary key
    #
    #   @param [Object] pk The primary key value
    #
    #   @return [SQL::Relation]
    #
    #   @api public
    class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
      def by_pk(pk)                                    # def by_pk(pk)
        s = schema.canonical                           #   s = schema.canonical
        if primary_key.nil?                            #   if primary_key.nil?
          raise MissingPrimaryKeyError.new(            #     raise MissingPrimaryKeyError.new(
            "Missing primary key for :\#{schema.name}" #       "Missing primary key for :#{schema.name}"
          )                                            #     )
        end                                            #   end
        where(s[s.primary_key_name].qualified => pk)   #   where(s[s.primary_key_name].qualified => pk)
      end                                              # end
    RUBY
  end
end

.primary_key_columns(db, table) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



107
108
109
110
 
# File 'lib/rom/sql/relation.rb', line 107

def self.primary_key_columns(db, table)
  names = db.respond_to?(:primary_key) ? Array(db.primary_key(table)) : [:id]
  names.map { |col| :"#{table}__#{col}" }
end

Instance Method Details

#assoc(name) ⇒ Relation

Return relation that will load associated tuples of this relation

This method is useful for defining custom relation views for relation composition when you want to enhance default association query

Examples:

assoc(:tasks).where(tasks[:title] => "Task One")

Parameters:

  • name (Symbol) —

    The association name

Returns:



127
128
129
 
# File 'lib/rom/sql/relation.rb', line 127

def assoc(name)
  associations[name].()
end

#columns ⇒ Array<Symbol>

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Return raw column names

Returns:

  • (Array<Symbol>) 


197
198
199
 
# File 'lib/rom/sql/relation.rb', line 197

def columns
  @columns ||= dataset.columns
end

#transaction(opts = EMPTY_HASH) {|t| ... } ⇒ Mixed

Open a database transaction

Parameters:

  • opts (Hash) (defaults to: EMPTY_HASH)

Options Hash (opts):

  • :auto_savepoint (Boolean) —

    Automatically use a savepoint for Database#transaction calls inside this transaction block.

  • :isolation (Symbol) —

    The transaction isolation level to use for this transaction, should be :uncommitted, :committed, :repeatable, or :serializable, used if given and the database/adapter supports customizable transaction isolation levels.

  • :num_retries (Integer) —

    The number of times to retry if the :retry_on option is used. The default is 5 times. Can be set to nil to retry indefinitely, but that is not recommended.

  • :before_retry (Proc) —

    Proc to execute before rertrying if the :retry_on option is used. Called with two arguments: the number of retry attempts (counting the current one) and the error the last attempt failed with.

  • :prepare (String) —

    A string to use as the transaction identifier for a prepared transaction (two-phase commit), if the database/adapter supports prepared transactions.

  • :retry_on (Class) —

    An exception class or array of exception classes for which to automatically retry the transaction. Can only be set if not inside an existing transaction. Note that this should not be used unless the entire transaction block is idempotent, as otherwise it can cause non-idempotent behavior to execute multiple times.

  • :rollback (Symbol) —

    Can be set to :reraise to reraise any Sequel::Rollback exceptions raised, or :always to always rollback even if no exceptions occur (useful for testing).

  • :server (Symbol) —

    The server to use for the transaction. Set to :default, :read_only, or whatever symbol you used in the connect string when naming your servers.

  • :savepoint (Boolean) —

    Whether to create a new savepoint for this transaction, only respected if the database/adapter supports savepoints. By default Sequel will reuse an existing transaction, so if you want to use a savepoint you must use this option. If the surrounding transaction uses :auto_savepoint, you can set this to false to not use a savepoint. If the value given for this option is :only, it will only create a savepoint if it is inside a transacation.

  • :deferrable (Boolean) —

    If present, set to DEFERRABLE if true or NOT DEFERRABLE if false.

  • :read_only (Boolean) —

    **PG only** If present, set to READ ONLY if true or READ WRITE if false.

  • :synchronous (Symbol) —

    **PG only** If non-nil, set synchronous_commit appropriately. Valid values true, :on, false, :off, :local, and :remote_write.

Yields:

  • (t) —

    Transaction

Returns:

  • (Mixed) 


188
189
190
 
# File 'lib/rom/sql/relation.rb', line 188

def transaction(opts = EMPTY_HASH, &)
  Transaction.new(dataset.db).run(opts, &)
end