Class | Hash
In: | lib/sequel/extensions/pg_hstore.rb lib/sequel/extensions/pg_json.rb lib/sequel/extensions/core_extensions.rb
Parent: | Object

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

### Methods

& case hstore pg_json sql_expr sql_negate sql_or | ~

### Public Instance methods

&(ce)

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

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 108
    108:   def &(ce)
    109:     ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
    110:   end

case(*args)

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

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 138
    138:   def case(*args)
    139:     ::Sequel::SQL::CaseExpression.new(to_a, *args)
    140:   end

hstore()

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

[Source]

         # File lib/sequel/extensions/pg_hstore.rb, line 309
    309:     def hstore
    310:       Sequel::Postgres::HStore.new(self)
    311:     end

pg_json()

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.

[Source]

         # File lib/sequel/extensions/pg_json.rb, line 204
    204:     def pg_json
    205:       Sequel::Postgres::JSONHash.new(self)
    206:     end

sql_expr()

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)

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 148
    148:   def sql_expr
    149:     ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
    150:   end

sql_negate()

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)

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 157
    157:   def sql_negate
    158:     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
    159:   end

sql_or()

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)

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 166
    166:   def sql_or
    167:     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
    168:   end

|(ce)

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

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 118
    118:   def |(ce)
    119:     ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
    120:   end

~()

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)

[Source]

         # File lib/sequel/extensions/core_extensions.rb, line 127
    127:   def ~
    128:     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
    129:   end

[Validate]