module Sequel::Postgres::DatasetMethods

  1. lib/sequel/adapters/shared/postgres.rb

Constants

EXPLAIN_BOOLEAN_OPTIONS = {}  
EXPLAIN_NONBOOLEAN_OPTIONS = { :serialize => {:none=>"SERIALIZE NONE", :text=>"SERIALIZE TEXT", :binary=>"SERIALIZE BINARY"}.freeze, :format => {:text=>"FORMAT TEXT", :xml=>"FORMAT XML", :json=>"FORMAT JSON", :yaml=>"FORMAT YAML"}.freeze }.freeze  
LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze).freeze  
NULL = LiteralString.new('NULL').freeze  

Public Instance methods

analyze()

Return the results of an EXPLAIN ANALYZE query as a string

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2113 def analyze
2114   explain(:analyze=>true)
2115 end
complex_expression_sql_append(sql, op, args)

Handle converting the ruby xor operator (^) into the PostgreSQL xor operator (#), and use the ILIKE and NOT ILIKE operators.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2120 def complex_expression_sql_append(sql, op, args)
2121   case op
2122   when :^
2123     j = ' # '
2124     c = false
2125     args.each do |a|
2126       sql << j if c
2127       literal_append(sql, a)
2128       c ||= true
2129     end
2130   when :ILIKE, :'NOT ILIKE'
2131     sql << '('
2132     literal_append(sql, args[0])
2133     sql << ' ' << op.to_s << ' '
2134     literal_append(sql, args[1])
2135     sql << ')'
2136   else
2137     super
2138   end
2139 end
disable_insert_returning()

Disables automatic use of INSERT … RETURNING. You can still use returning manually to force the use of RETURNING when inserting.

This is designed for cases where INSERT RETURNING cannot be used, such as when you are using partitioning with trigger functions or conditional rules, or when you are using a PostgreSQL version less than 8.2, or a PostgreSQL derivative that does not support returning.

Note that when this method is used, insert will not return the primary key of the inserted row, you will have to get the primary key of the inserted row before inserting via nextval, or after inserting via currval or lastval (making sure to use the same database connection for currval or lastval).

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2155 def disable_insert_returning
2156   clone(:disable_insert_returning=>true)
2157 end
empty?()

Always return false when using VALUES

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2160 def empty?
2161   return false if @opts[:values]
2162   super
2163 end
explain(opts=OPTS)

Return the results of an EXPLAIN query. Boolean options:

:analyze

Use the ANALYZE option.

:buffers

Use the BUFFERS option.

:costs

Use the COSTS option.

:generic_plan

Use the GENERIC_PLAN option.

:memory

Use the MEMORY option.

:settings

Use the SETTINGS option.

:summary

Use the SUMMARY option.

:timing

Use the TIMING option.

:verbose

Use the VERBOSE option.

:wal

Use the WAL option.

Non boolean options:

:format

Use the FORMAT option to change the format of the returned value. Values can be :text, :xml, :json, or :yaml.

:serialize

Use the SERIALIZE option to get timing on serialization. Values can be :none, :text, or :binary.

See the PostgreSQL EXPLAIN documentation for an explanation of what each option does.

In most cases, the return value is a single string. However, using the format: :json option can result in the return value being an array containing a hash.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2193 def explain(opts=OPTS)
2194   rows = clone(:append_sql=>explain_sql_string_origin(opts)).map(:'QUERY PLAN')
2195 
2196   if rows.length == 1
2197     rows[0]
2198   elsif rows.all?{|row| String === row}
2199     rows.join("\r\n") 
2200   # simplecov:disable
2201   else
2202     # This branch is unreachable in tests, but it seems better to just return
2203     # all rows than throw in error if this case actually happens.
2204     rows
2205   # simplecov:enable
2206   end
2207 end
for_key_share()

Return a cloned dataset which will use FOR KEY SHARE to lock returned rows. Supported on PostgreSQL 9.3+.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2211 def for_key_share
2212   cached_lock_style_dataset(:_for_key_share_ds, :key_share)
2213 end
for_no_key_update()

Return a cloned dataset which will use FOR NO KEY UPDATE to lock returned rows. This is generally a better choice than using for_update on PostgreSQL, unless you will be deleting the row or modifying a key column. Supported on PostgreSQL 9.3+.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2218 def for_no_key_update
2219   cached_lock_style_dataset(:_for_no_key_update_ds, :no_key_update)
2220 end
for_share()

Return a cloned dataset which will use FOR SHARE to lock returned rows.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2223 def for_share
2224   cached_lock_style_dataset(:_for_share_ds, :share)
2225 end
full_text_search(cols, terms, opts = OPTS)

Run a full text search on PostgreSQL. By default, searching for the inclusion of any of the terms in any of the cols.

Options:

:headline

Append a expression to the selected columns aliased to headline that contains an extract of the matched text.

:language

The language to use for the search (default: ‘simple’)

:plain

Whether a plain search should be used (default: false). In this case, terms should be a single string, and it will do a search where cols contains all of the words in terms. This ignores search operators in terms.

:phrase

Similar to :plain, but also adding an ILIKE filter to ensure that returned rows also include the exact phrase used.

:rank

Set to true to order by the rank, so that closer matches are returned first.

:to_tsquery

Can be set to :plain, :phrase, or :websearch to specify the function to use to convert the terms to a ts_query.

:tsquery

Specifies the terms argument is already a valid SQL expression returning a tsquery, and can be used directly in the query.

:tsvector

Specifies the cols argument is already a valid SQL expression returning a tsvector, and can be used directly in the query.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2246 def full_text_search(cols, terms, opts = OPTS)
2247   lang = Sequel.cast(opts[:language] || 'simple', :regconfig)
2248 
2249   unless opts[:tsvector]
2250     phrase_cols = full_text_string_join(cols)
2251     cols = Sequel.function(:to_tsvector, lang, phrase_cols)
2252   end
2253 
2254   unless opts[:tsquery]
2255     phrase_terms = terms.is_a?(Array) || terms.is_a?(Set) ? Sequel.array_or_set_join(terms, ' | ') : terms
2256 
2257     query_func = case to_tsquery = opts[:to_tsquery]
2258     when :phrase, :plain
2259       :"#{to_tsquery}to_tsquery"
2260     when :websearch
2261       :"websearch_to_tsquery"
2262     else
2263       (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
2264     end
2265 
2266     terms = Sequel.function(query_func, lang, phrase_terms)
2267   end
2268 
2269   ds = where(Sequel.lit(["", " @@ ", ""], cols, terms))
2270 
2271   if opts[:phrase]
2272     raise Error, "can't use :phrase with either :tsvector or :tsquery arguments to full_text_search together" if opts[:tsvector] || opts[:tsquery]
2273     ds = ds.grep(phrase_cols, "%#{escape_like(phrase_terms)}%", :case_insensitive=>true)
2274   end
2275 
2276   if opts[:rank]
2277     ds = ds.reverse{ts_rank_cd(cols, terms)}
2278   end
2279 
2280   if opts[:headline]
2281     ds = ds.select_append{ts_headline(lang, phrase_cols, terms).as(:headline)}
2282   end
2283 
2284   ds
2285 end
insert(*values)

Insert given values into the database.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2288 def insert(*values)
2289   if @opts[:returning]
2290     # Already know which columns to return, let the standard code handle it
2291     super
2292   elsif @opts[:sql] || @opts[:disable_insert_returning]
2293     # Raw SQL used or RETURNING disabled, just use the default behavior
2294     # and return nil since sequence is not known.
2295     super
2296     nil
2297   else
2298     # Force the use of RETURNING with the primary key value,
2299     # unless it has been disabled.
2300     returning(insert_pk).insert(*values){|r| return r.values.first}
2301   end
2302 end
insert_conflict(opts=OPTS)

Handle uniqueness violations when inserting, by updating the conflicting row, using ON CONFLICT. With no options, uses ON CONFLICT DO NOTHING. Options:

:conflict_where

The index filter, when using a partial index to determine uniqueness.

:constraint

An explicit constraint name, has precedence over :target.

:target

The column name or expression to handle uniqueness violations on.

:select

Use ON CONFLICT DO SELECT. This will use the dataset’s lock style. You must use returning on this dataset when using this option.

:select_where

A WHERE condition to use for the select.

:update

A hash of columns and values to set. Uses ON CONFLICT DO UPDATE.

:update_where

A WHERE condition to use for the update.

Examples:

DB[:table].insert_conflict.insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT DO NOTHING

DB[:table].insert_conflict(constraint: :table_a_uidx).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT ON CONSTRAINT table_a_uidx DO NOTHING

DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT (a) DO NOTHING

DB[:table].insert_conflict(target: :a, conflict_where: {c: true}).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING

DB[:table].insert_conflict(target: :a, update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT (a) DO UPDATE SET b = excluded.b

DB[:table].insert_conflict(constraint: :table_a_uidx,
  update: {b: Sequel[:excluded][:b]}, update_where: {Sequel[:table][:status_id] => 1}).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT ON CONSTRAINT table_a_uidx
# DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)

DB[:table].returning(:a).insert_conflict(target: :a, select: true).insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT (a) DO SELECT RETURNING a

DB[:table].returning(:a).for_update.
  insert_conflict(target: :a, select: true, select_where: {Sequel[:excluded][:b] => 3}).
  insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT (a) DO SELECT FOR UPDATE WHERE (excluded.b = 3) RETURNING a
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2352 def insert_conflict(opts=OPTS)
2353   if opts[:select] && opts[:update]
2354     raise Error, "Cannot provide both :select and :update options to insert_conflict"
2355   end
2356 
2357   clone(:insert_conflict => opts)
2358 end
insert_ignore()

Ignore uniqueness/exclusion violations when inserting, using ON CONFLICT DO NOTHING. Exists mostly for compatibility to MySQL’s insert_ignore. Example:

DB[:table].insert_ignore.insert(a: 1, b: 2)
# INSERT INTO TABLE (a, b) VALUES (1, 2)
# ON CONFLICT DO NOTHING
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2366 def insert_ignore
2367   insert_conflict
2368 end
insert_select(*values)

Insert a record, returning the record inserted, using RETURNING. Always returns nil without running an INSERT statement if disable_insert_returning is used. If the query runs but returns no values, returns false.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2373 def insert_select(*values)
2374   return unless supports_insert_select?
2375   # Handle case where query does not return a row
2376   server?(:default).with_sql_first(insert_select_sql(*values)) || false
2377 end
insert_select_sql(*values)

The SQL to use for an insert_select, adds a RETURNING clause to the insert unless the RETURNING clause is already present.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2381 def insert_select_sql(*values)
2382   ds = opts[:returning] ? self : returning
2383   ds.insert_sql(*values)
2384 end
join_table(type, table, expr=nil, options=OPTS, &block)

Support SQL::AliasedExpression as expr to setup a USING join with a table alias for the USING columns.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2388 def join_table(type, table, expr=nil, options=OPTS, &block)
2389   if expr.is_a?(SQL::AliasedExpression) && expr.expression.is_a?(Array) && !expr.expression.empty? && expr.expression.all?
2390     options = options.merge(:join_using=>true)
2391   end
2392   super
2393 end
lock(mode, opts=OPTS)

Locks all tables in the dataset’s FROM clause (but not in JOINs) with the specified mode (e.g. ‘EXCLUSIVE’). If a block is given, starts a new transaction, locks the table, and yields. If a block is not given, just locks the tables. Note that PostgreSQL will probably raise an error if you lock the table outside of an existing transaction. Returns nil.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2400 def lock(mode, opts=OPTS)
2401   if defined?(yield) # perform locking inside a transaction and yield to block
2402     @db.transaction(opts){lock(mode, opts); yield}
2403   else
2404     sql = 'LOCK TABLE '.dup
2405     source_list_append(sql, @opts[:from])
2406     mode = mode.to_s.upcase.strip
2407     unless LOCK_MODES.include?(mode)
2408       raise Error, "Unsupported lock mode: #{mode}"
2409     end
2410     sql << " IN #{mode} MODE"
2411     @db.execute(sql, opts)
2412   end
2413   nil
2414 end
merge(&block)

Support MERGE RETURNING on PostgreSQL 17+.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2417 def merge(&block)
2418   sql = merge_sql
2419   if uses_returning?(:merge)
2420     returning_fetch_rows(sql, &block)
2421   else
2422     execute_ddl(sql)
2423   end
2424 end
merge_delete_when_not_matched_by_source(&block)

Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DELETE clause added to the MERGE statement. If a block is passed, treat it as a virtual row and use it as additional conditions for the match.

merge_delete_not_matched_by_source
# WHEN NOT MATCHED BY SOURCE THEN DELETE

merge_delete_not_matched_by_source{a > 30}
# WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DELETE
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2435 def merge_delete_when_not_matched_by_source(&block)
2436   _merge_when(:type=>:delete_not_matched_by_source, &block)
2437 end
merge_do_nothing_when_matched(&block)

Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the MERGE statement. If a block is passed, treat it as a virtual row and use it as additional conditions for the match.

merge_do_nothing_when_matched
# WHEN MATCHED THEN DO NOTHING

merge_do_nothing_when_matched{a > 30}
# WHEN MATCHED AND (a > 30) THEN DO NOTHING
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2448 def merge_do_nothing_when_matched(&block)
2449   _merge_when(:type=>:matched, &block)
2450 end
merge_do_nothing_when_not_matched(&block)

Return a dataset with a WHEN NOT MATCHED THEN DO NOTHING clause added to the MERGE statement. If a block is passed, treat it as a virtual row and use it as additional conditions for the match.

merge_do_nothing_when_not_matched
# WHEN NOT MATCHED THEN DO NOTHING

merge_do_nothing_when_not_matched{a > 30}
# WHEN NOT MATCHED AND (a > 30) THEN DO NOTHING
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2461 def merge_do_nothing_when_not_matched(&block)
2462   _merge_when(:type=>:not_matched, &block)
2463 end
merge_do_nothing_when_not_matched_by_source(&block)

Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DO NOTHING clause added to the MERGE BY SOURCE statement. If a block is passed, treat it as a virtual row and use it as additional conditions for the match.

merge_do_nothing_when_not_matched_by_source
# WHEN NOT MATCHED BY SOURCE THEN DO NOTHING

merge_do_nothing_when_not_matched_by_source{a > 30}
# WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DO NOTHING
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2474 def merge_do_nothing_when_not_matched_by_source(&block)
2475   _merge_when(:type=>:not_matched_by_source, &block)
2476 end
merge_insert(*values, &block)

Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2479 def merge_insert(*values, &block)
2480   h = {:type=>:insert, :values=>values}
2481   if @opts[:override]
2482     h[:override] = insert_override_sql(String.new)
2483   end
2484   _merge_when(h, &block)
2485 end
merge_update_when_not_matched_by_source(values, &block)

Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN UPDATE clause added to the MERGE statement. If a block is passed, treat it as a virtual row and use it as additional conditions for the match.

merge_update_not_matched_by_source(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
# WHEN NOT MATCHED BY SOURCE THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)

merge_update_not_matched_by_source(i1: :i2){a > 30}
# WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN UPDATE SET i1 = i2
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2496 def merge_update_when_not_matched_by_source(values, &block)
2497   _merge_when(:type=>:update_not_matched_by_source, :values=>values, &block)
2498 end
overriding_system_value()

Use OVERRIDING USER VALUE for INSERT statements, so that identity columns always use the user supplied value, and an error is not raised for identity columns that are GENERATED ALWAYS.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2503 def overriding_system_value
2504   clone(:override=>:system)
2505 end
overriding_user_value()

Use OVERRIDING USER VALUE for INSERT statements, so that identity columns always use the sequence value instead of the user supplied value.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2509 def overriding_user_value
2510   clone(:override=>:user)
2511 end
supports_cte?(type=:select)
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2513 def supports_cte?(type=:select)
2514   if type == :select
2515     server_version >= 80400
2516   else
2517     server_version >= 90100
2518   end
2519 end
supports_cte_in_subqueries?()

PostgreSQL supports using the WITH clause in subqueries if it supports using WITH at all (i.e. on PostgreSQL 8.4+).

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2523 def supports_cte_in_subqueries?
2524   supports_cte?
2525 end
supports_distinct_on?()

DISTINCT ON is a PostgreSQL extension

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2528 def supports_distinct_on?
2529   true
2530 end
supports_group_cube?()

PostgreSQL 9.5+ supports GROUP CUBE

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2533 def supports_group_cube?
2534   server_version >= 90500
2535 end
supports_group_rollup?()

PostgreSQL 9.5+ supports GROUP ROLLUP

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2538 def supports_group_rollup?
2539   server_version >= 90500
2540 end
supports_grouping_sets?()

PostgreSQL 9.5+ supports GROUPING SETS

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2543 def supports_grouping_sets?
2544   server_version >= 90500
2545 end
supports_insert_conflict?()

PostgreSQL 9.5+ supports the ON CONFLICT clause to INSERT.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2553 def supports_insert_conflict?
2554   server_version >= 90500
2555 end
supports_insert_select?()

True unless insert returning has been disabled for this dataset.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2548 def supports_insert_select?
2549   !@opts[:disable_insert_returning]
2550 end
supports_lateral_subqueries?()

PostgreSQL 9.3+ supports lateral subqueries

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2558 def supports_lateral_subqueries?
2559   server_version >= 90300
2560 end
supports_merge?()

PostgreSQL 15+ supports MERGE.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2568 def supports_merge?
2569   server_version >= 150000
2570 end
supports_modifying_joins?()

PostgreSQL supports modifying joined datasets

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2563 def supports_modifying_joins?
2564   true
2565 end
supports_nowait?()

PostgreSQL supports NOWAIT.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2573 def supports_nowait?
2574   true
2575 end
supports_regexp?()

PostgreSQL supports pattern matching via regular expressions

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2588 def supports_regexp?
2589   true
2590 end
supports_returning?(type)

MERGE RETURNING is supported on PostgreSQL 17+. Other RETURNING is supported on all supported PostgreSQL versions.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2579 def supports_returning?(type)
2580   if type == :merge
2581     server_version >= 170000
2582   else
2583     true
2584   end
2585 end
supports_skip_locked?()

PostgreSQL 9.5+ supports SKIP LOCKED.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2593 def supports_skip_locked?
2594   server_version >= 90500
2595 end
supports_timestamp_timezones?()

PostgreSQL supports timezones in literal timestamps

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2600 def supports_timestamp_timezones?
2601   # SEQUEL6: Remove
2602   true
2603 end
supports_window_clause?()

PostgreSQL 8.4+ supports WINDOW clause.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2607 def supports_window_clause?
2608   server_version >= 80400
2609 end
supports_window_function_frame_option?(option)

Base support added in 8.4, offset supported added in 9.0, GROUPS and EXCLUDE support added in 11.0.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2618 def supports_window_function_frame_option?(option)
2619   case option
2620   when :rows, :range
2621     true
2622   when :offset
2623     server_version >= 90000
2624   when :groups, :exclude
2625     server_version >= 110000
2626   else
2627     false
2628   end
2629 end
supports_window_functions?()

PostgreSQL 8.4+ supports window functions

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2612 def supports_window_functions?
2613   server_version >= 80400
2614 end
truncate(opts = OPTS)

Truncates the dataset. Returns nil.

Options:

:cascade

whether to use the CASCADE option, useful when truncating tables with foreign keys.

:only

truncate using ONLY, so child tables are unaffected

:restart

use RESTART IDENTITY to restart any related sequences

:only and :restart only work correctly on PostgreSQL 8.4+.

Usage:

DB[:table].truncate
# TRUNCATE TABLE "table"

DB[:table].truncate(cascade: true, only: true, restart: true)
# TRUNCATE TABLE ONLY "table" RESTART IDENTITY CASCADE
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2647 def truncate(opts = OPTS)
2648   if opts.empty?
2649     super()
2650   else
2651     clone(:truncate_opts=>opts).truncate
2652   end
2653 end
with_ties()

Use WITH TIES when limiting the result set to also include additional rules that have the same results for the order column as the final row. Requires PostgreSQL 13.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2658 def with_ties
2659   clone(:limit_with_ties=>true)
2660 end

Protected Instance methods

_import(columns, values, opts=OPTS)

If returned primary keys are requested, use RETURNING unless already set on the dataset. If RETURNING is already set, use existing returning values. If RETURNING is only set to return a single columns, return an array of just that column. Otherwise, return an array of hashes.

[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2668 def _import(columns, values, opts=OPTS)
2669   if @opts[:returning]
2670     # no transaction: our multi_insert_sql_strategy should guarantee
2671     # that there's only ever a single statement.
2672     sql = multi_insert_sql(columns, values)[0]
2673     returning_fetch_rows(sql).map{|v| v.length == 1 ? v.values.first : v}
2674   elsif opts[:return] == :primary_key
2675     returning(insert_pk)._import(columns, values, opts)
2676   else
2677     super
2678   end
2679 end
to_prepared_statement(type, *a)
[show source] 
     # File lib/sequel/adapters/shared/postgres.rb
2681 def to_prepared_statement(type, *a)
2682   if type == :insert && !@opts.has_key?(:returning)
2683     returning(insert_pk).send(:to_prepared_statement, :insert_pk, *a)
2684   else
2685     super
2686   end
2687 end