Methods
Public Instance
- add_conversion_proc
- add_named_conversion_proc
- check_constraints
- commit_prepared_transaction
- conversion_procs
- convert_serial_to_identity
- create_function
- create_language
- create_schema
- create_table
- create_table?
- create_trigger
- database_type
- defer_constraints
- do
- drop_function
- drop_language
- drop_schema
- drop_trigger
- foreign_key_list
- freeze
- immediate_constraints
- indexes
- locks
- notify
- primary_key
- primary_key_sequence
- refresh_view
- reset_primary_key_sequence
- rollback_prepared_transaction
- serial_primary_key_options
- server_version
- supports_create_table_if_not_exists?
- supports_deferrable_constraints?
- supports_deferrable_foreign_key_constraints?
- supports_drop_table_if_exists?
- supports_partial_indexes?
- supports_prepared_transactions?
- supports_savepoints?
- supports_transaction_isolation_levels?
- supports_transactional_ddl?
- supports_trigger_conditions?
- tables
- type_supported?
- values
- views
- with_advisory_lock
Included modules
Constants
DATABASE_ERROR_REGEXPS | = | [ # Add this check first, since otherwise it's possible for users to control # which exception class is generated. [/invalid input syntax/, DatabaseError], [/duplicate key value violates unique constraint/, UniqueConstraintViolation], [/violates foreign key constraint/, ForeignKeyConstraintViolation], [/violates check constraint/, CheckConstraintViolation], [/violates not-null constraint/, NotNullConstraintViolation], [/conflicting key value violates exclusion constraint/, ExclusionConstraintViolation], [/could not serialize access/, SerializationFailure], [/could not obtain lock on row in relation/, DatabaseLockTimeout], ].freeze | ||
FOREIGN_KEY_LIST_ON_DELETE_MAP | = | {'a'=>:no_action, 'r'=>:restrict, 'c'=>:cascade, 'n'=>:set_null, 'd'=>:set_default}.freeze | ||
MAX_DATE | = | Date.new(5874897, 12, 31) | ||
MAX_TIMESTAMP | = | (Time.utc(294277) - Rational(1, 1000000)).freeze | ||
MIN_DATE | = | Date.new(-4713, 11, 24) | ||
MIN_TIMESTAMP | = | Time.utc(-4713, 11, 24).freeze | ||
ON_COMMIT | = | {:drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS'}.freeze | ||
SELECT_CUSTOM_SEQUENCE_SQL | = | (<<-end_sql SELECT name.nspname AS "schema", CASE WHEN split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2) ~ '.' THEN substr(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2), strpos(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2), '.')+1) ELSE split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2) END AS "sequence" FROM pg_class t JOIN pg_namespace name ON (t.relnamespace = name.oid) JOIN pg_attribute attr ON (t.oid = attrelid) JOIN pg_attrdef def ON (adrelid = attrelid AND adnum = attnum) JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1]) WHERE cons.contype = 'p' AND pg_get_expr(def.adbin, attr.attrelid) ~* 'nextval' end_sql ).strip.gsub(/\s+/, ' ').freeze |
SQL fragment for custom sequences (ones not created by serial primary key), Returning the schema and literal form of the sequence name, by parsing the column defaults table. |
|
SELECT_PK_SQL | = | (<<-end_sql SELECT pg_attribute.attname AS pk FROM pg_class, pg_attribute, pg_index, pg_namespace WHERE pg_class.oid = pg_attribute.attrelid AND pg_class.relnamespace = pg_namespace.oid AND pg_class.oid = pg_index.indrelid AND pg_index.indkey[0] = pg_attribute.attnum AND pg_index.indisprimary = 't' end_sql ).strip.gsub(/\s+/, ' ').freeze |
SQL fragment for determining primary key column for the given table. Only returns the first primary key if the table has a composite primary key. |
|
SELECT_SERIAL_SEQUENCE_SQL | = | (<<-end_sql SELECT name.nspname AS "schema", seq.relname AS "sequence" FROM pg_class seq, pg_attribute attr, pg_depend dep, pg_namespace name, pg_constraint cons, pg_class t WHERE seq.oid = dep.objid AND seq.relnamespace = name.oid AND seq.relkind = 'S' AND attr.attrelid = dep.refobjid AND attr.attnum = dep.refobjsubid AND attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1] AND attr.attrelid = t.oid AND cons.contype = 'p' end_sql ).strip.gsub(/\s+/, ' ').freeze |
SQL fragment for getting sequence associated with table’s primary key, assuming it was a serial primary key column. |
|
TYPTYPE_METHOD_MAP | = | { 'c' => :schema_composite_type, 'e' => :schema_enum_type, 'r' => :schema_range_type, 'm' => :schema_multirange_type, } | ||
VALID_CLIENT_MIN_MESSAGES | = | %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze.each(&:freeze) |
Attributes
conversion_procs | [R] |
A hash of conversion procs, keyed by type integer (oid) and having callable values for the conversion proc for that type. |
Public Instance methods
Set a conversion proc for the given oid. The callable can be passed either as a argument or a block.
# File lib/sequel/adapters/shared/postgres.rb 320 def add_conversion_proc(oid, callable=nil, &block) 321 conversion_procs[oid] = callable || block 322 end
Add a conversion proc for a named type, using the given block. This should be used for types without fixed OIDs, which includes all types that are not included in a default PostgreSQL installation.
# File lib/sequel/adapters/shared/postgres.rb 327 def add_named_conversion_proc(name, &block) 328 unless oid = from(:pg_type).where(:typtype=>['b', 'e'], :typname=>name.to_s).get(:oid) 329 raise Error, "No matching type in pg_type for #{name.inspect}" 330 end 331 add_conversion_proc(oid, block) 332 end
A hash of metadata for CHECK constraints on the table. Keys are CHECK constraint name symbols. Values are hashes with the following keys:
:definition |
An SQL fragment for the definition of the constraint |
:columns |
An array of column symbols for the columns referenced in the constraint, can be an empty array if the database cannot deteremine the column symbols. |
# File lib/sequel/adapters/shared/postgres.rb 343 def check_constraints(table) 344 m = output_identifier_meth 345 346 hash = {} 347 _check_constraints_ds.where_each(:conrelid=>regclass_oid(table)) do |row| 348 constraint = m.call(row[:constraint]) 349 entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[], :validated=>row[:validated], :enforced=>row[:enforced]} 350 entry[:columns] << m.call(row[:column]) if row[:column] 351 end 352 353 hash 354 end
# File lib/sequel/adapters/shared/postgres.rb 334 def commit_prepared_transaction(transaction_id, opts=OPTS) 335 run("COMMIT PREPARED #{literal(transaction_id)}", opts) 336 end
Convert the first primary key column in the table
from being a serial column to being an identity column. If the column is already an identity column, assume it was already converted and make no changes.
Only supported on PostgreSQL 10.2+, since on those versions Sequel
will use identity columns instead of serial columns for auto incrementing primary keys. Only supported when running as a superuser, since regular users cannot modify system tables, and there is no way to keep an existing sequence when changing an existing column to be an identity column.
This method can raise an exception in at least the following cases where it may otherwise succeed (there may be additional cases not listed here):
-
The serial column was added after table creation using PostgreSQL <7.3
-
A regular index also exists on the column (such an index can probably be dropped as the primary key index should suffice)
Options:
:column |
Specify the column to convert instead of using the first primary key column |
:server |
Run the SQL on the given server |
# File lib/sequel/adapters/shared/postgres.rb 374 def convert_serial_to_identity(table, opts=OPTS) 375 raise Error, "convert_serial_to_identity is only supported on PostgreSQL 10.2+" unless server_version >= 100002 376 377 server = opts[:server] 378 server_hash = server ? {:server=>server} : OPTS 379 ds = dataset 380 ds = ds.server(server) if server 381 382 raise Error, "convert_serial_to_identity requires superuser permissions" unless ds.get{current_setting('is_superuser')} == 'on' 383 384 table_oid = regclass_oid(table) 385 im = input_identifier_meth 386 unless column = (opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0])) 387 raise Error, "could not determine column to convert from serial to identity automatically" 388 end 389 column = im.call(column) 390 391 column_num = ds.from(:pg_attribute). 392 where(:attrelid=>table_oid, :attname=>column). 393 get(:attnum) 394 395 pg_class = Sequel.cast('pg_class', :regclass) 396 res = ds.from(:pg_depend). 397 where(:refclassid=>pg_class, :refobjid=>table_oid, :refobjsubid=>column_num, :classid=>pg_class, :objsubid=>0, :deptype=>%w'a i'). 398 select_map([:objid, Sequel.as({:deptype=>'i'}, :v)]) 399 400 case res.length 401 when 0 402 raise Error, "unable to find related sequence when converting serial to identity" 403 when 1 404 seq_oid, already_identity = res.first 405 else 406 raise Error, "more than one linked sequence found when converting serial to identity" 407 end 408 409 return if already_identity 410 411 transaction(server_hash) do 412 run("ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(column)} DROP DEFAULT", server_hash) 413 414 ds.from(:pg_depend). 415 where(:classid=>pg_class, :objid=>seq_oid, :objsubid=>0, :deptype=>'a'). 416 update(:deptype=>'i') 417 418 ds.from(:pg_attribute). 419 where(:attrelid=>table_oid, :attname=>column). 420 update(:attidentity=>'d') 421 end 422 423 remove_cached_schema(table) 424 nil 425 end
Creates the function in the database. Arguments:
name |
name of the function to create | ||||||||||||||||||||||||||||
definition |
string definition of the function, or object file for a dynamically loaded C function. | ||||||||||||||||||||||||||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 448 def create_function(name, definition, opts=OPTS) 449 self << create_function_sql(name, definition, opts) 450 end
Create the procedural language in the database. Arguments:
name |
Name of the procedural language (e.g. plpgsql) | ||||||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 459 def create_language(name, opts=OPTS) 460 self << create_language_sql(name, opts) 461 end
Create a schema in the database. Arguments:
name |
Name of the schema (e.g. admin) | ||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 468 def create_schema(name, opts=OPTS) 469 self << create_schema_sql(name, opts) 470 end
Support partitions of tables using the :partition_of option.
# File lib/sequel/adapters/shared/postgres.rb 473 def create_table(name, options=OPTS, &block) 474 if options[:partition_of] 475 create_partition_of_table_from_generator(name, CreatePartitionOfTableGenerator.new(&block), options) 476 return 477 end 478 479 super 480 end
Support partitions of tables using the :partition_of option.
# File lib/sequel/adapters/shared/postgres.rb 483 def create_table?(name, options=OPTS, &block) 484 if options[:partition_of] 485 create_table(name, options.merge!(:if_not_exists=>true), &block) 486 return 487 end 488 489 super 490 end
Create a trigger in the database. Arguments:
table |
the table on which this trigger operates | ||||||||||||
name |
the name of this trigger | ||||||||||||
function |
the function to call for this trigger, which should return type trigger. | ||||||||||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 504 def create_trigger(table, name, function, opts=OPTS) 505 self << create_trigger_sql(table, name, function, opts) 506 end
# File lib/sequel/adapters/shared/postgres.rb 508 def database_type 509 :postgres 510 end
For constraints that are deferrable, defer constraints until transaction commit. Options:
:constraints |
An identifier of the constraint, or an array of identifiers for constraints, to apply this change to specific constraints. |
:server |
The server/shard on which to run the query. |
Examples:
DB.defer_constraints # SET CONSTRAINTS ALL DEFERRED DB.defer_constraints(constraints: [:c1, Sequel[:sc][:c2]]) # SET CONSTRAINTS "c1", "sc"."s2" DEFERRED
# File lib/sequel/adapters/shared/postgres.rb 527 def defer_constraints(opts=OPTS) 528 _set_constraints(' DEFERRED', opts) 529 end
Use PostgreSQL’s DO syntax to execute an anonymous code block. The code should be the literal code string to use in the underlying procedural language. Options:
:language |
The procedural language the code is written in. The PostgreSQL default is plpgsql. Can be specified as a string or a symbol. |
# File lib/sequel/adapters/shared/postgres.rb 536 def do(code, opts=OPTS) 537 language = opts[:language] 538 run "DO #{"LANGUAGE #{literal(language.to_s)} " if language}#{literal(code)}" 539 end
Drops the function from the database. Arguments:
name |
name of the function to drop | ||||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 547 def drop_function(name, opts=OPTS) 548 self << drop_function_sql(name, opts) 549 end
Drops a procedural language from the database. Arguments:
name |
name of the procedural language to drop | ||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 556 def drop_language(name, opts=OPTS) 557 self << drop_language_sql(name, opts) 558 end
Drops a schema from the database. Arguments:
name |
name of the schema to drop | ||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 565 def drop_schema(name, opts=OPTS) 566 self << drop_schema_sql(name, opts) 567 end
Drops a trigger from the database. Arguments:
table |
table from which to drop the trigger | ||||
name |
name of the trigger to drop | ||||
opts |
options hash:
|
# File lib/sequel/adapters/shared/postgres.rb 575 def drop_trigger(table, name, opts=OPTS) 576 self << drop_trigger_sql(table, name, opts) 577 end
Return full foreign key information using the pg system tables, including :name, :on_delete, :on_update, and :deferrable entries in the hashes.
Supports additional options:
:reverse |
Instead of returning foreign keys in the current table, return foreign keys in other tables that reference the current table. |
:schema |
Set to true to have the :table value in the hashes be a qualified identifier. Set to false to use a separate :schema value with the related schema. Defaults to whether the given table argument is a qualified identifier. |
# File lib/sequel/adapters/shared/postgres.rb 589 def foreign_key_list(table, opts=OPTS) 590 m = output_identifier_meth 591 schema, _ = opts.fetch(:schema, schema_and_table(table)) 592 593 h = {} 594 fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 595 reverse = opts[:reverse] 596 597 (reverse ? _reverse_foreign_key_list_ds : _foreign_key_list_ds).where_each(Sequel[:cl][:oid]=>regclass_oid(table)) do |row| 598 if reverse 599 key = [row[:schema], row[:table], row[:name]] 600 else 601 key = row[:name] 602 end 603 604 if r = h[key] 605 r[:columns] << m.call(row[:column]) 606 r[:key] << m.call(row[:refcolumn]) 607 else 608 entry = h[key] = { 609 :name=>m.call(row[:name]), 610 :columns=>[m.call(row[:column])], 611 :key=>[m.call(row[:refcolumn])], 612 :on_update=>fklod_map[row[:on_update]], 613 :on_delete=>fklod_map[row[:on_delete]], 614 :deferrable=>row[:deferrable], 615 :validated=>row[:validated], 616 :enforced=>row[:enforced], 617 :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table]), 618 } 619 620 unless schema 621 # If not combining schema information into the :table entry 622 # include it as a separate entry. 623 entry[:schema] = m.call(row[:schema]) 624 end 625 end 626 end 627 628 h.values 629 end
# File lib/sequel/adapters/shared/postgres.rb 631 def freeze 632 server_version 633 supports_prepared_transactions? 634 _schema_ds 635 _select_serial_sequence_ds 636 _select_custom_sequence_ds 637 _select_pk_ds 638 _indexes_ds 639 _check_constraints_ds 640 _foreign_key_list_ds 641 _reverse_foreign_key_list_ds 642 @conversion_procs.freeze 643 super 644 end
Immediately apply deferrable constraints.
:constraints |
An identifier of the constraint, or an array of identifiers for constraints, to apply this change to specific constraints. |
:server |
The server/shard on which to run the query. |
Examples:
DB.immediate_constraints # SET CONSTRAINTS ALL IMMEDIATE DB.immediate_constraints(constraints: [:c1, Sequel[:sc][:c2]]) # SET CONSTRAINTS "c1", "sc"."s2" IMMEDIATE
# File lib/sequel/adapters/shared/postgres.rb 660 def immediate_constraints(opts=OPTS) 661 _set_constraints(' IMMEDIATE', opts) 662 end
Use the pg_* system tables to determine indexes on a table
# File lib/sequel/adapters/shared/postgres.rb 665 def indexes(table, opts=OPTS) 666 m = output_identifier_meth 667 cond = {Sequel[:tab][:oid]=>regclass_oid(table, opts)} 668 cond[:indpred] = nil unless opts[:include_partial] 669 670 indexes = {} 671 _indexes_ds.where_each(cond) do |r| 672 i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique], :deferrable=>r[:deferrable]} 673 i[:columns] << m.call(r[:column]) 674 end 675 indexes 676 end
Dataset
containing all current database locks
# File lib/sequel/adapters/shared/postgres.rb 679 def locks 680 dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select{[pg_class[:relname], Sequel::SQL::ColumnAll.new(:pg_locks)]} 681 end
Notifies the given channel. See the PostgreSQL NOTIFY documentation. Options:
:payload |
The payload string to use for the NOTIFY statement. Only supported in PostgreSQL 9.0+. |
:server |
The server to which to send the NOTIFY statement, if the sharding support is being used. |
# File lib/sequel/adapters/shared/postgres.rb 689 def notify(channel, opts=OPTS) 690 sql = String.new 691 sql << "NOTIFY " 692 dataset.send(:identifier_append, sql, channel) 693 if payload = opts[:payload] 694 sql << ", " 695 dataset.literal_append(sql, payload.to_s) 696 end 697 execute_ddl(sql, opts) 698 end
Return primary key for the given table.
# File lib/sequel/adapters/shared/postgres.rb 701 def primary_key(table, opts=OPTS) 702 quoted_table = quote_schema_table(table) 703 Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)} 704 value = _select_pk_ds.where_single_value(Sequel[:pg_class][:oid] => regclass_oid(table, opts)) 705 Sequel.synchronize{@primary_keys[quoted_table] = value} 706 end
Return the sequence providing the default for the primary key for the given table.
# File lib/sequel/adapters/shared/postgres.rb 709 def primary_key_sequence(table, opts=OPTS) 710 quoted_table = quote_schema_table(table) 711 Sequel.synchronize{return @primary_key_sequences[quoted_table] if @primary_key_sequences.has_key?(quoted_table)} 712 cond = {Sequel[:t][:oid] => regclass_oid(table, opts)} 713 value = if pks = _select_serial_sequence_ds.first(cond) 714 literal(SQL::QualifiedIdentifier.new(pks[:schema], pks[:sequence])) 715 elsif pks = _select_custom_sequence_ds.first(cond) 716 literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence]))) 717 end 718 719 Sequel.synchronize{@primary_key_sequences[quoted_table] = value} if value 720 end
Refresh the materialized view with the given name.
DB.refresh_view(:items_view) # REFRESH MATERIALIZED VIEW items_view DB.refresh_view(:items_view, concurrently: true) # REFRESH MATERIALIZED VIEW CONCURRENTLY items_view
# File lib/sequel/adapters/shared/postgres.rb 728 def refresh_view(name, opts=OPTS) 729 run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}" 730 end
Reset the primary key sequence for the given table, basing it on the maximum current value of the table’s primary key.
# File lib/sequel/adapters/shared/postgres.rb 734 def reset_primary_key_sequence(table) 735 return unless seq = primary_key_sequence(table) 736 pk = SQL::Identifier.new(primary_key(table)) 737 db = self 738 s, t = schema_and_table(table) 739 table = Sequel.qualify(s, t) if s 740 741 if server_version >= 100000 742 seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq))) 743 increment_by = :seqincrement 744 min_value = :seqmin 745 # :nocov: 746 else 747 seq_ds = metadata_dataset.from(LiteralString.new(seq)) 748 increment_by = :increment_by 749 min_value = :min_value 750 # :nocov: 751 end 752 753 get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)} 754 end
# File lib/sequel/adapters/shared/postgres.rb 756 def rollback_prepared_transaction(transaction_id, opts=OPTS) 757 run("ROLLBACK PREPARED #{literal(transaction_id)}", opts) 758 end
PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for managing incrementing primary keys.
# File lib/sequel/adapters/shared/postgres.rb 762 def serial_primary_key_options 763 # :nocov: 764 auto_increment_key = server_version >= 100002 ? :identity : :serial 765 # :nocov: 766 {:primary_key => true, auto_increment_key => true, :type=>Integer} 767 end
The version of the PostgreSQL server, used for determining capability.
# File lib/sequel/adapters/shared/postgres.rb 770 def server_version(server=nil) 771 return @server_version if @server_version 772 ds = dataset 773 ds = ds.server(server) if server 774 @server_version = swallow_database_error{ds.with_sql("SELECT CAST(current_setting('server_version_num') AS integer) AS v").single_value} || 0 775 end
PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
# File lib/sequel/adapters/shared/postgres.rb 778 def supports_create_table_if_not_exists? 779 server_version >= 90100 780 end
PostgreSQL 9.0+ supports some types of deferrable constraints beyond foreign key constraints.
# File lib/sequel/adapters/shared/postgres.rb 783 def supports_deferrable_constraints? 784 server_version >= 90000 785 end
PostgreSQL supports deferrable foreign key constraints.
# File lib/sequel/adapters/shared/postgres.rb 788 def supports_deferrable_foreign_key_constraints? 789 true 790 end
PostgreSQL supports DROP TABLE IF EXISTS
# File lib/sequel/adapters/shared/postgres.rb 793 def supports_drop_table_if_exists? 794 true 795 end
PostgreSQL supports partial indexes.
# File lib/sequel/adapters/shared/postgres.rb 798 def supports_partial_indexes? 799 true 800 end
PostgreSQL supports prepared transactions (two-phase commit) if max_prepared_transactions is greater than 0.
# File lib/sequel/adapters/shared/postgres.rb 809 def supports_prepared_transactions? 810 return @supports_prepared_transactions if defined?(@supports_prepared_transactions) 811 @supports_prepared_transactions = self['SHOW max_prepared_transactions'].get.to_i > 0 812 end
PostgreSQL supports savepoints
# File lib/sequel/adapters/shared/postgres.rb 815 def supports_savepoints? 816 true 817 end
PostgreSQL supports transaction isolation levels
# File lib/sequel/adapters/shared/postgres.rb 820 def supports_transaction_isolation_levels? 821 true 822 end
PostgreSQL supports transaction DDL statements.
# File lib/sequel/adapters/shared/postgres.rb 825 def supports_transactional_ddl? 826 true 827 end
PostgreSQL 9.0+ supports trigger conditions.
# File lib/sequel/adapters/shared/postgres.rb 803 def supports_trigger_conditions? 804 server_version >= 90000 805 end
Array of symbols specifying table names in the current database. The dataset used is yielded to the block if one is provided, otherwise, an array of symbols of table names is returned.
Options:
:qualify |
Return the tables as Sequel::SQL::QualifiedIdentifier instances, using the schema the table is located in as the qualifier. |
:schema |
The schema to search |
:server |
The server to use |
# File lib/sequel/adapters/shared/postgres.rb 838 def tables(opts=OPTS, &block) 839 pg_class_relname(['r', 'p'], opts, &block) 840 end
Check whether the given type name string/symbol (e.g. :hstore) is supported by the database.
# File lib/sequel/adapters/shared/postgres.rb 844 def type_supported?(type) 845 Sequel.synchronize{return @supported_types[type] if @supported_types.has_key?(type)} 846 supported = from(:pg_type).where(:typtype=>'b', :typname=>type.to_s).count > 0 847 Sequel.synchronize{return @supported_types[type] = supported} 848 end
Creates a dataset that uses the VALUES clause:
DB.values([[1, 2], [3, 4]]) # VALUES ((1, 2), (3, 4)) DB.values([[1, 2], [3, 4]]).order(:column2).limit(1, 1) # VALUES ((1, 2), (3, 4)) ORDER BY column2 LIMIT 1 OFFSET 1
# File lib/sequel/adapters/shared/postgres.rb 857 def values(v) 858 raise Error, "Cannot provide an empty array for values" if v.empty? 859 @default_dataset.clone(:values=>v) 860 end
Array of symbols specifying view names in the current database.
Options:
:materialized |
Return materialized views |
:qualify |
Return the views as Sequel::SQL::QualifiedIdentifier instances, using the schema the view is located in as the qualifier. |
:schema |
The schema to search |
:server |
The server to use |
# File lib/sequel/adapters/shared/postgres.rb 870 def views(opts=OPTS) 871 relkind = opts[:materialized] ? 'm' : 'v' 872 pg_class_relname(relkind, opts) 873 end
Attempt to acquire an exclusive advisory lock with the given lock_id (which should be a 64-bit integer). If successful, yield to the block, then release the advisory lock when the block exits. If unsuccessful, raise a Sequel::AdvisoryLockError.
DB.with_advisory_lock(1347){DB.get(1)} # SELECT pg_try_advisory_lock(1357) LIMIT 1 # SELECT 1 AS v LIMIT 1 # SELECT pg_advisory_unlock(1357) LIMIT 1
Options:
:wait |
Do not raise an error, instead, wait until the advisory lock can be acquired. |
# File lib/sequel/adapters/shared/postgres.rb 886 def with_advisory_lock(lock_id, opts=OPTS) 887 ds = dataset 888 if server = opts[:server] 889 ds = ds.server(server) 890 end 891 892 synchronize(server) do |c| 893 begin 894 if opts[:wait] 895 ds.get{pg_advisory_lock(lock_id)} 896 locked = true 897 else 898 unless locked = ds.get{pg_try_advisory_lock(lock_id)} 899 raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}" 900 end 901 end 902 903 yield 904 ensure 905 ds.get{pg_advisory_unlock(lock_id)} if locked 906 end 907 end 908 end