Class Sequel::Postgres::PGRowOp
In: lib/sequel/extensions/pg_row_ops.rb
Parent: SQL::PlaceholderLiteralString

This class represents a composite type expression reference.

Methods

*   []   splat   wrap  

Classes and Modules

Module Sequel::Postgres::PGRowOp::ExpressionMethods

Constants

ROW = ['(', '.*)'].freeze.each(&:freeze)
ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
QUALIFY = ['(', ').'].freeze.each(&:freeze)
WRAP = [""].freeze.each(&:freeze)

Public Class methods

wrap(expr)

Wrap the expression in a PGRowOp, without changing the SQL it would use.

[Source]

     # File lib/sequel/extensions/pg_row_ops.rb, line 98
 98:       def self.wrap(expr)
 99:         PGRowOp.new(WRAP, [expr])
100:       end

Public Instance methods

*(ce=(arg=false;

Use the (identifier).* syntax to reference the members of the composite type as separate columns. Generally used when you want to expand the columns of a composite type to be separate columns in the result set. 

  Sequel.pg_row_op(:a).*     # (a).*
  Sequel.pg_row_op(:a)[:b].* # ((a).b).*

[Source]

     # File lib/sequel/extensions/pg_row_ops.rb, line 123
123:       def *(ce=(arg=false;nil))
124:         if arg == false
125:           Sequel::SQL::ColumnAll.new([self])
126:         else
127:           super(ce)
128:         end
129:       end
[](member)

Access a member of the composite type if given a symbol or an SQL::Identifier. For all other access, assuming the pg_array_ops extension is loaded and that it represents an array access. In either case, return a PgRowOp so that access can be cascaded.

[Source]

     # File lib/sequel/extensions/pg_row_ops.rb, line 107
107:       def [](member)
108:         case member
109:         when Symbol, SQL::Identifier
110:           PGRowOp.new(QUALIFY, [self, member])
111:         else
112:           PGRowOp.wrap(Sequel.pg_array_op(self)[member])
113:         end
114:       end
splat(cast_to=nil)

Use the (identifier.*) syntax to indicate that this expression represents the composite type of one of the tables being referenced, if it has the same name as one of the columns. If the cast_to argument is given, also cast the expression to that type (which should be a symbol representing the composite type). This is used if you want to return whole table row as a composite type. 

  Sequel.pg_row_op(:a).splat[:b] # (a.*).b
  Sequel.pg_row_op(:a).splat(:a) # (a.*)::a

[Source]

     # File lib/sequel/extensions/pg_row_ops.rb, line 142
142:       def splat(cast_to=nil)
143:         if args.length > 1
144:           raise Error, 'cannot splat a PGRowOp with multiple arguments'
145:         end
146: 
147:         if cast_to
148:           PGRowOp.new(ROW_CAST, args + [cast_to])
149:         else
150:           PGRowOp.new(ROW, args)
151:         end
152:       end

[Validate]