Class: Sequel::Postgres::PGRowOp

Inherits:
SQL::PlaceholderLiteralString show all
Defined in:
lib/sequel/extensions/pg_row_ops.rb

Overview

This class represents a composite type expression reference.

Defined Under Namespace

Modules: ExpressionMethods

Constant Summary collapse

OPEN = 
'('.freeze
CLOSE_DOT = 
').'.freeze
CLOSE_STAR = 
'.*)'.freeze
CLOSE_STAR_CAST = 
'.*)::'.freeze
EMPTY = 
"".freeze
ROW = 
[OPEN, CLOSE_STAR].freeze
ROW_CAST = 
[OPEN, CLOSE_STAR_CAST].freeze
QUALIFY = 
[OPEN, CLOSE_DOT].freeze
WRAP = 
[EMPTY].freeze

Instance Attribute Summary

Attributes inherited from SQL::PlaceholderLiteralString

#args, #parens, #str

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from SQL::PlaceholderLiteralString

#initialize

Methods included from HStoreOpMethods

#hstore

Methods included from RangeOpMethods

#pg_range

Methods included from ArrayOpMethods

#pg_array

Methods included from JSONOpMethods

#pg_json, #pg_jsonb

Methods included from InetOpMethods

#pg_inet

Methods included from ExpressionMethods

#pg_row

Methods included from SQL::SubscriptMethods

#sql_subscript

Methods included from SQL::StringMethods

#ilike, #like

Methods included from SQL::PatternMatchMethods

#=~

Methods included from SQL::OrderMethods

#asc, #desc

Methods included from SQL::NumericMethods

#+, #coerce

Methods included from SQL::ComplexExpressionMethods

#extract, #sql_boolean, #sql_number, #sql_string

Methods included from SQL::CastMethods

#cast, #cast_numeric, #cast_string

Methods included from SQL::BooleanMethods

#~

Methods included from SQL::AliasMethods

#as

Methods inherited from SQL::Expression

#==, attr_reader, #eql?, #hash, inherited, #inspect, #lit, #sql_literal

Constructor Details

This class inherits a constructor from Sequel::SQL::PlaceholderLiteralString

Class Method Details

.wrap(expr) ⇒ Object

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



103
104
105
 
# File 'lib/sequel/extensions/pg_row_ops.rb', line 103

def self.wrap(expr)
  PGRowOp.new(WRAP, [expr])
end

Instance Method Details

#*(ce = (arg=false;nil)) ⇒ Object

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).*



128
129
130
131
132
133
134
 
# File 'lib/sequel/extensions/pg_row_ops.rb', line 128

def *(ce=(arg=false;nil))
  if arg == false
    Sequel::SQL::ColumnAll.new([self])
  else
    super(ce)
  end
end

#[](member) ⇒ Object

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.



112
113
114
115
116
117
118
119
 
# File 'lib/sequel/extensions/pg_row_ops.rb', line 112

def [](member)
  case member
  when Symbol, SQL::Identifier
    PGRowOp.new(QUALIFY, [self, member])
  else
    PGRowOp.wrap(Sequel.pg_array_op(self)[member])
  end
end

#splat(cast_to = nil) ⇒ Object

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



147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/sequel/extensions/pg_row_ops.rb', line 147

def splat(cast_to=nil)
  if args.length > 1
    raise Error, 'cannot splat a PGRowOp with multiple arguments'
  end

  if cast_to
    PGRowOp.new(ROW_CAST, args + [cast_to])
  else
    PGRowOp.new(ROW, args)
  end
end