Class: Hash

Inherits:
Object show all
Defined in:
lib/sequel/extensions/core_extensions.rb,
lib/sequel/extensions/pg_json.rb,
lib/sequel/extensions/pg_hstore.rb,
lib/sequel/deprecated_core_extensions.rb

Overview

Sequel extends Hash to add methods to implement the SQL DSL.

Instance Method Summary collapse

Instance Method Details

#&(ce) ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the conditions in this hash and the condition specified by the given argument.

{:a=>1} & :b # SQL: a = 1 AND b
{:a=>true} & ~:b # SQL: a IS TRUE AND NOT b



108
109
110
111
 
# File 'lib/sequel/extensions/core_extensions.rb', line 108

def &(ce)
  Sequel::Deprecation.deprecate('Hash#&', 'Please use Sequel.& instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
end

#case(*args) ⇒ Object

Return a Sequel::SQL::CaseExpression with this hash as the conditions and the given default value. Note that the order of the conditions will be arbitrary on ruby 1.8, so all conditions should be orthogonal.

{{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
{:a=>1, :b=>2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
                              #  or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END



138
139
140
141
 
# File 'lib/sequel/extensions/core_extensions.rb', line 138

def case(*args)
  Sequel::Deprecation.deprecate('Hash#case', 'Please use Sequel.case instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::CaseExpression.new(to_a, *args)
end

#hstore ⇒ Object

Create a new HStore using the receiver as the input hash. Note that the HStore created will not use the receiver as the backing store, since it has to modify the hash. To get the new backing store, use:

hash.hstore.to_hash



339
340
341
 
# File 'lib/sequel/extensions/pg_hstore.rb', line 339

def hstore
  Sequel::Postgres::HStore.new(self)
end

#pg_json ⇒ Object

Return a Sequel::Postgres::JSONHash proxy to the receiver. This is mostly useful as a short cut for creating JSONHash objects that didn’t come from the database.



217
218
219
 
# File 'lib/sequel/extensions/pg_json.rb', line 217

def pg_json
  Sequel::Postgres::JSONHash.new(self)
end

#sql_expr ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the conditions. Rarely do you need to call this explicitly, as Sequel generally assumes that hashes specify this type of condition.

{:a=>true}.sql_expr # SQL: a IS TRUE
{:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)



148
149
150
151
 
# File 'lib/sequel/extensions/core_extensions.rb', line 148

def sql_expr
  Sequel::Deprecation.deprecate('Hash#sql_expr', 'Please use Sequel.expr instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
end

#sql_negate ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, matching none of the conditions.

{:a=>true}.sql_negate # SQL: a IS NOT TRUE
{:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)



157
158
159
160
 
# File 'lib/sequel/extensions/core_extensions.rb', line 157

def sql_negate
  Sequel::Deprecation.deprecate('Hash#sql_negate', 'Please use Sequel.negate instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
end

#sql_or ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, matching any of the conditions.

{:a=>true}.sql_or # SQL: a IS TRUE
{:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)



166
167
168
169
 
# File 'lib/sequel/extensions/core_extensions.rb', line 166

def sql_or
  Sequel::Deprecation.deprecate('Hash#sql_or', 'Please use Sequel.or instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
end

#|(ce) ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the conditions in this hash or the condition specified by the given argument.

{:a=>1} | :b # SQL: a = 1 OR b
{:a=>true} | ~:b # SQL: a IS TRUE OR NOT b



118
119
120
121
 
# File 'lib/sequel/extensions/core_extensions.rb', line 118

def |(ce)
  Sequel::Deprecation.deprecate('Hash#|', 'Please use Sequel.| instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
end

#~ ⇒ Object

Return a Sequel::SQL::BooleanExpression created from this hash, not matching all of the conditions.

~{:a=>true} # SQL: a IS NOT TRUE
~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)



127
128
129
130
 
# File 'lib/sequel/extensions/core_extensions.rb', line 127

def ~
  Sequel::Deprecation.deprecate('Hash#~', 'Please use Sequel.~ instead, or Sequel.extension(:core_extensions) to continue using it')
  ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
end