Parent

Files

Class Index [+]

Quicksearch

ActiveRecord::ConnectionAdapters::PostgreSQLAdapter

The PostgreSQL adapter works both with the native C (ruby.scripting.ca/postgres/) and the pure Ruby (available both as gem and from rubyforge.org/frs/?group_id=234&release_id=1944) drivers.

Options:

Constants

ADAPTER_NAME
NATIVE_DATABASE_TYPES

Public Class Methods

new(connection, logger, connection_parameters, config) click to toggle source

Initializes and connects a PostgreSQL adapter.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 309
309:       def initialize(connection, logger, connection_parameters, config)
310:         super(connection, logger)
311: 
312:         if config.fetch(:prepared_statements) { true }
313:           @visitor = Arel::Visitors::PostgreSQL.new self
314:         else
315:           @visitor = BindSubstitution.new self
316:         end
317: 
318:         connection_parameters.delete :prepared_statements
319: 
320:         @connection_parameters, @config = connection_parameters, config
321: 
322:         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
323:         @local_tz = nil
324:         @table_alias_length = nil
325: 
326:         connect
327:         @statements = StatementPool.new @connection,
328:                                         config.fetch(:statement_limit) { 1000 }
329: 
330:         if postgresql_version < 80200
331:           raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
332:         end
333: 
334:         @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
335:       end

Public Instance Methods

active?() click to toggle source

Is this connection alive and ready for queries?

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 343
343:       def active?
344:         @connection.query 'SELECT 1'
345:         true
346:       rescue PGError
347:         false
348:       end
adapter_name() click to toggle source

Returns ‘PostgreSQL’ as adapter name for identification purposes.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 238
238:       def adapter_name
239:         ADAPTER_NAME
240:       end
add_column(table_name, column_name, type, options = {}) click to toggle source

Adds a new column to the named table. See TableDefinition#column for details of the options you can use.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1020
1020:       def add_column(table_name, column_name, type, options = {})
1021:         clear_cache!
1022:         add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
1023:         add_column_options!(add_column_sql, options)
1024: 
1025:         execute add_column_sql
1026:       end
begin_db_transaction() click to toggle source

Begins a transaction.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 700
700:       def begin_db_transaction
701:         execute "BEGIN"
702:       end
change_column(table_name, column_name, type, options = {}) click to toggle source

Changes the column of a table.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1029
1029:       def change_column(table_name, column_name, type, options = {})
1030:         clear_cache!
1031:         quoted_table_name = quote_table_name(table_name)
1032: 
1033:         execute "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
1034: 
1035:         change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
1036:         change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
1037:       end
change_column_default(table_name, column_name, default) click to toggle source

Changes the default value of a table column.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1040
1040:       def change_column_default(table_name, column_name, default)
1041:         clear_cache!
1042:         execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
1043:       end
change_column_null(table_name, column_name, null, default = nil) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1045
1045:       def change_column_null(table_name, column_name, null, default = nil)
1046:         clear_cache!
1047:         unless null || default.nil?
1048:           execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
1049:         end
1050:         execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
1051:       end
clear_cache!() click to toggle source

Clears the prepared statements cache.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 338
338:       def clear_cache!
339:         @statements.clear
340:       end
client_min_messages() click to toggle source

Returns the current client message level.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 898
898:       def client_min_messages
899:         query('SHOW client_min_messages', 'SCHEMA')[0][0]
900:       end
client_min_messages=(level) click to toggle source

Set the client message level.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 903
903:       def client_min_messages=(level)
904:         execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
905:       end
columns(table_name, name = nil) click to toggle source

Returns the list of all column definitions for a table.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 855
855:       def columns(table_name, name = nil)
856:         # Limit, precision, and scale are all handled by the superclass.
857:         column_definitions(table_name).collect do |column_name, type, default, notnull|
858:           PostgreSQLColumn.new(column_name, default, type, notnull == 'f')
859:         end
860:       end
commit_db_transaction() click to toggle source

Commits a transaction.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 705
705:       def commit_db_transaction
706:         execute "COMMIT"
707:       end
create_database(name, options = {}) click to toggle source

Create a new PostgreSQL database. Options include :owner, :template, :encoding, :tablespace, and :connection_limit (note that MySQL uses :charset while PostgreSQL uses :encoding).

Example:

  create_database config[:database], config
  create_database 'foo_development', :encoding => 'unicode'
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 746
746:       def create_database(name, options = {})
747:         options = options.reverse_merge(:encoding => "utf8")
748: 
749:         option_string = options.symbolize_keys.sum do |key, value|
750:           case key
751:           when :owner
752:             " OWNER = \"#{value}\""
753:           when :template
754:             " TEMPLATE = \"#{value}\""
755:           when :encoding
756:             " ENCODING = '#{value}'"
757:           when :tablespace
758:             " TABLESPACE = \"#{value}\""
759:           when :connection_limit
760:             " CONNECTION LIMIT = #{value}"
761:           else
762:             ""
763:           end
764:         end
765: 
766:         execute "CREATE DATABASE #{quote_table_name(name)}#{option_string}"
767:       end
create_savepoint() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 718
718:       def create_savepoint
719:         execute("SAVEPOINT #{current_savepoint_name}")
720:       end
current_database() click to toggle source

Returns the current database name.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 863
863:       def current_database
864:         query('select current_database()', 'SCHEMA')[0][0]
865:       end
current_schema() click to toggle source

Returns the current schema name.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 868
868:       def current_schema
869:         query('SELECT current_schema', 'SCHEMA')[0][0]
870:       end
disconnect!() click to toggle source

Disconnects from the database if already connected. Otherwise, this method does nothing.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 365
365:       def disconnect!
366:         clear_cache!
367:         @connection.close rescue nil
368:       end
encoding() click to toggle source

Returns the current database encoding format.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 873
873:       def encoding
874:         query(          SELECT pg_encoding_to_char(pg_database.encoding) FROM pg_database          WHERE pg_database.datname LIKE '#{current_database}', 'SCHEMA')[0][0]
875:       end
escape_bytea(value) click to toggle source

Escapes binary strings for bytea input to the database.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 418
418:       def escape_bytea(value)
419:         @connection.escape_bytea(value) if value
420:       end
exec_delete(sql, name = 'SQL', binds = []) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 671
671:       def exec_delete(sql, name = 'SQL', binds = [])
672:         log(sql, name, binds) do
673:           result = binds.empty? ? exec_no_cache(sql, binds) :
674:                                   exec_cache(sql, binds)
675:           affected = result.cmd_tuples
676:           result.clear
677:           affected
678:         end
679:       end
Also aliased as: exec_update
exec_query(sql, name = 'SQL', binds = []) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 660
660:       def exec_query(sql, name = 'SQL', binds = [])
661:         log(sql, name, binds) do
662:           result = binds.empty? ? exec_no_cache(sql, binds) :
663:                                   exec_cache(sql, binds)
664: 
665:           ret = ActiveRecord::Result.new(result.fields, result_as_array(result))
666:           result.clear
667:           return ret
668:         end
669:       end
exec_update(sql, name = 'SQL', binds = []) click to toggle source
Alias for: exec_delete
execute(sql, name = nil) click to toggle source

Executes an SQL statement, returning a PGresult object on success or raising a PGError exception otherwise.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 650
650:       def execute(sql, name = nil)
651:         log(sql, name) do
652:           @connection.async_exec(sql)
653:         end
654:       end
explain(arel, binds = []) click to toggle source

DATABASE STATEMENTS ======================================

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 534
534:       def explain(arel, binds = [])
535:         sql = "EXPLAIN #{to_sql(arel, binds)}"
536:         ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
537:       end
index_name_length() click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1067
1067:       def index_name_length
1068:         63
1069:       end
indexes(table_name, name = nil) click to toggle source

Returns an array of indexes for the given table.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 816
816:       def indexes(table_name, name = nil)
817:          result = query(           SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid           FROM pg_class t           INNER JOIN pg_index d ON t.oid = d.indrelid           INNER JOIN pg_class i ON d.indexrelid = i.oid           WHERE i.relkind = 'i'             AND d.indisprimary = 'f'             AND t.relname = '#{table_name}'             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )          ORDER BY i.relname, 'SCHEMA')
818: 
819: 
820:         result.map do |row|
821:           index_name = row[0]
822:           unique = row[1] == 't'
823:           indkey = row[2].split(" ")
824:           inddef = row[3]
825:           oid = row[4]
826: 
827:           columns = Hash[query(          SELECT a.attnum, a.attname          FROM pg_attribute a          WHERE a.attrelid = #{oid}          AND a.attnum IN (#{indkey.join(",")}), "SCHEMA")]
828: 
829:           column_names = columns.values_at(*indkey).compact
830: 
831:           # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
832:           desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
833:           orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
834: 
835:           column_names.empty? ? nil : IndexDefinition.new(table_name, index_name, unique, column_names, [], orders)
836:         end.compact
837:       end
insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) click to toggle source

Executes an INSERT query and returns the new record’s ID

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 583
583:       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
584:         unless pk
585:           # Extract the table from the insert sql. Yuck.
586:           table_ref = extract_table_ref_from_insert_sql(sql)
587:           pk = primary_key(table_ref) if table_ref
588:         end
589: 
590:         if pk
591:           select_value("#{sql} RETURNING #{quote_column_name(pk)}")
592:         else
593:           super
594:         end
595:       end
outside_transaction?() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 714
714:       def outside_transaction?
715:         @connection.transaction_status == PGconn::PQTRANS_IDLE
716:       end
primary_key(table) click to toggle source

Returns just a table’s primary key

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 989
989:       def primary_key(table)
990:         row = exec_query(          SELECT DISTINCT(attr.attname)          FROM pg_attribute attr          INNER JOIN pg_depend dep ON attr.attrelid = dep.refobjid AND attr.attnum = dep.refobjsubid          INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]          WHERE cons.contype = 'p'            AND dep.refobjid = '#{quote_table_name(table)}'::regclass, 'SCHEMA').rows.first
991: 
992:         row && row.first
993:       end
quote_table_name(name) click to toggle source

Checks the following cases:

  • table_name

  • “table.name“

  • schema_name.table_name

  • schema_name.“table.name“

  • “schema.name“.table_name

  • “schema.name“.“table.name“

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 483
483:       def quote_table_name(name)
484:         schema, name_part = extract_pg_identifier_from_name(name.to_s)
485: 
486:         unless name_part
487:           quote_column_name(schema)
488:         else
489:           table_name, name_part = extract_pg_identifier_from_name(name_part)
490:           "#{quote_column_name(schema)}.#{quote_column_name(table_name)}"
491:         end
492:       end
reconnect!() click to toggle source

Close then reopen the connection.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 351
351:       def reconnect!
352:         clear_cache!
353:         @connection.reset
354:         @open_transactions = 0
355:         configure_connection
356:       end
release_savepoint() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 726
726:       def release_savepoint
727:         execute("RELEASE SAVEPOINT #{current_savepoint_name}")
728:       end
rename_column(table_name, column_name, new_column_name) click to toggle source

Renames a column in a table.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1054
1054:       def rename_column(table_name, column_name, new_column_name)
1055:         clear_cache!
1056:         execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
1057:       end
rename_index(table_name, old_name, new_name) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1063
1063:       def rename_index(table_name, old_name, new_name)
1064:         execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
1065:       end
rename_table(name, new_name) click to toggle source

Renames a table. Also renames a table’s primary key sequence if the sequence name matches the Active Record default.

Example:

  rename_table('octopuses', 'octopi')
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1008
1008:       def rename_table(name, new_name)
1009:         clear_cache!
1010:         execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
1011:         pk, seq = pk_and_sequence_for(new_name)
1012:         if seq == "#{name}_#{pk}_seq"
1013:           new_seq = "#{new_name}_#{pk}_seq"
1014:           execute "ALTER TABLE #{quote_table_name(seq)} RENAME TO #{quote_table_name(new_seq)}"
1015:         end
1016:       end
reset!() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 358
358:       def reset!
359:         clear_cache!
360:         super
361:       end
rollback_db_transaction() click to toggle source

Aborts a transaction.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 710
710:       def rollback_db_transaction
711:         execute "ROLLBACK"
712:       end
rollback_to_savepoint() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 722
722:       def rollback_to_savepoint
723:         execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
724:       end
schema_exists?(name) click to toggle source

Returns true if schema exists.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 807
807:       def schema_exists?(name)
808:         exec_query(          SELECT COUNT(*)          FROM pg_namespace          WHERE nspname = '#{name}', 'SCHEMA').rows.first[0].to_i > 0
809:       end
schema_search_path() click to toggle source

Returns the active schema search path.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 893
893:       def schema_search_path
894:         @schema_search_path ||= query('SHOW search_path', 'SCHEMA')[0][0]
895:       end
schema_search_path=(schema_csv) click to toggle source

Sets the schema search path to a string of comma-separated schema names. Names beginning with $ have to be quoted (e.g. $user => ’$user’). See: www.postgresql.org/docs/current/static/ddl-schemas.html

This should be not be called manually but set in database.yml.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 885
885:       def schema_search_path=(schema_csv)
886:         if schema_csv
887:           execute("SET search_path TO #{schema_csv}", 'SCHEMA')
888:           @schema_search_path = schema_csv
889:         end
890:       end
select_rows(sql, name = nil) click to toggle source

Executes a SELECT query and returns an array of rows. Each row is an array of field values.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 578
578:       def select_rows(sql, name = nil)
579:         select_raw(sql, name).last
580:       end
serial_sequence(table, column) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 914
914:       def serial_sequence(table, column)
915:         result = exec_query(          SELECT pg_get_serial_sequence('#{table}', '#{column}'), 'SCHEMA')
916:         result.rows.first.first
917:       end
session_auth=(user) click to toggle source

Set the authorized user for this session

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 510
510:       def session_auth=(user)
511:         clear_cache!
512:         exec_query "SET SESSION AUTHORIZATION #{user}"
513:       end
set_standard_conforming_strings() click to toggle source

Enable standard-conforming strings if available.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 385
385:       def set_standard_conforming_strings
386:         old, self.client_min_messages = client_min_messages, 'panic'
387:         execute('SET standard_conforming_strings = on', 'SCHEMA') rescue nil
388:       ensure
389:         self.client_min_messages = old
390:       end
sql_for_insert(sql, pk, id_value, sequence_name, binds) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 682
682:       def sql_for_insert(sql, pk, id_value, sequence_name, binds)
683:         unless pk
684:           # Extract the table from the insert sql. Yuck.
685:           table_ref = extract_table_ref_from_insert_sql(sql)
686:           pk = primary_key(table_ref) if table_ref
687:         end
688: 
689:         sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
690: 
691:         [sql, binds]
692:       end
substitute_at(column, index) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 656
656:       def substitute_at(column, index)
657:         Arel::Nodes::BindParam.new "$#{index + 1}"
658:       end
supports_ddl_transactions?() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 396
396:       def supports_ddl_transactions?
397:         true
398:       end
supports_explain?() click to toggle source

Returns true.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 406
406:       def supports_explain?
407:         true
408:       end
supports_index_sort_order?() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 248
248:       def supports_index_sort_order?
249:         true
250:       end
supports_insert_with_returning?() click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 392
392:       def supports_insert_with_returning?
393:         true
394:       end
supports_migrations?() click to toggle source

Returns true, since this connection adapter supports migrations.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 375
375:       def supports_migrations?
376:         true
377:       end
supports_savepoints?() click to toggle source

Returns true, since this connection adapter supports savepoints.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 401
401:       def supports_savepoints?
402:         true
403:       end
supports_statement_cache?() click to toggle source

Returns true, since this connection adapter supports prepared statement caching.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 244
244:       def supports_statement_cache?
245:         true
246:       end
table_alias_length() click to toggle source

Returns the configured supported identifier length supported by PostgreSQL

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 411
411:       def table_alias_length
412:         @table_alias_length ||= query('SHOW max_identifier_length')[0][0].to_i
413:       end
table_exists?(name) click to toggle source

Returns true if table exists. If the schema is not specified as part of name then it will only find tables within the current schema search path (regardless of permissions to access tables in other schemas)

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 789
789:       def table_exists?(name)
790:         schema, table = Utils.extract_schema_and_table(name.to_s)
791:         return false unless table
792: 
793:         binds = [[nil, table]]
794:         binds << [nil, schema] if schema
795: 
796:         exec_query(            SELECT COUNT(*)            FROM pg_class c            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace            WHERE c.relkind in ('v','r')            AND c.relname = '#{table.gsub(/(^"|"$)/,'')}'            AND n.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}, 'SCHEMA').rows.first[0].to_i > 0
797:       end
tables(name = nil) click to toggle source

Returns the list of all tables in the schema search path or a specified schema.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 778
778:       def tables(name = nil)
779:         query(          SELECT tablename          FROM pg_tables          WHERE schemaname = ANY (current_schemas(false)), 'SCHEMA').map { |row| row[0] }
780:       end
type_cast(value, column) click to toggle source
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 458
458:       def type_cast(value, column)
459:         return super unless column
460: 
461:         case value
462:         when String
463:           return super unless 'bytea' == column.sql_type
464:           { :value => value, :format => 1 }
465:         else
466:           super
467:         end
468:       end
type_to_sql(type, limit = nil, precision = nil, scale = nil) click to toggle source

Maps logical Rails types to PostgreSQL-specific data types.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1072
1072:       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
1073:         case type.to_s
1074:         when 'binary'
1075:           # PostgreSQL doesn't support limits on binary (bytea) columns.
1076:           # The hard limit is 1Gb, because of a 32-bit size field, and TOAST.
1077:           case limit
1078:           when nil, 0..0x3fffffff; super(type)
1079:           else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
1080:           end
1081:         when 'integer'
1082:           return 'integer' unless limit
1083: 
1084:           case limit
1085:             when 1, 2; 'smallint'
1086:             when 3, 4; 'integer'
1087:             when 5..8; 'bigint'
1088:             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
1089:           end
1090:         else
1091:           super
1092:         end
1093:       end
unescape_bytea(value) click to toggle source

Unescapes bytea output from a database to the binary string it represents. NOTE: This is NOT an inverse of escape_bytea! This is only to be used

      on escaped binary output from database drive.
     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 425
425:       def unescape_bytea(value)
426:         @connection.unescape_bytea(value) if value
427:       end
update_sql(sql, name = nil) click to toggle source

Executes an UPDATE query and returns the number of affected tuples.

     # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 695
695:       def update_sql(sql, name = nil)
696:         super.cmd_tuples
697:       end

Protected Instance Methods

postgresql_version() click to toggle source

Returns the version of the connected PostgreSQL server.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1134
1134:         def postgresql_version
1135:           @connection.server_version
1136:         end
translate_exception(exception, message) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1138
1138:         def translate_exception(exception, message)
1139:           case exception.message
1140:           when /duplicate key value violates unique constraint/
1141:             RecordNotUnique.new(message, exception)
1142:           when /violates foreign key constraint/
1143:             InvalidForeignKey.new(message, exception)
1144:           else
1145:             super
1146:           end
1147:         end

Private Instance Methods

configure_connection() click to toggle source

Configures the encoding, verbosity, schema search path, and time zone of the connection. This is called by # and should not be called manually.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1220
1220:         def configure_connection
1221:           if @config[:encoding]
1222:             @connection.set_client_encoding(@config[:encoding])
1223:           end
1224:           self.client_min_messages = @config[:min_messages] if @config[:min_messages]
1225:           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
1226: 
1227:           # Use standard-conforming strings if available so we don't have to do the E'...' dance.
1228:           set_standard_conforming_strings
1229: 
1230:           # If using Active Record's time zone support configure the connection to return
1231:           # TIMESTAMP WITH ZONE types in UTC.
1232:           if ActiveRecord::Base.default_timezone == :utc
1233:             execute("SET time zone 'UTC'", 'SCHEMA')
1234:           elsif @local_tz
1235:             execute("SET time zone '#{@local_tz}'", 'SCHEMA')
1236:           end
1237:         end
connect() click to toggle source

Connects to a PostgreSQL server and sets up the adapter depending on the connected server’s characteristics.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1207
1207:         def connect
1208:           @connection = PGconn.connect(*@connection_parameters)
1209: 
1210:           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
1211:           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
1212:           # should know about this but can't detect it there, so deal with it here.
1213:           PostgreSQLColumn.money_precision = (postgresql_version >= 80300) ? 19 : 10
1214: 
1215:           configure_connection
1216:         end
exec_cache(sql, binds) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1156
1156:         def exec_cache(sql, binds)
1157:           begin
1158:             stmt_key = prepare_statement sql
1159: 
1160:             # Clear the queue
1161:             @connection.get_last_result
1162:             @connection.send_query_prepared(stmt_key, binds.map { |col, val|
1163:               type_cast(val, col)
1164:             })
1165:             @connection.block
1166:             @connection.get_last_result
1167:           rescue PGError => e
1168:             # Get the PG code for the failure.  Annoyingly, the code for
1169:             # prepared statements whose return value may have changed is
1170:             # FEATURE_NOT_SUPPORTED.  Check here for more details:
1171:             # http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
1172:             code = e.result.result_error_field(PGresult::PG_DIAG_SQLSTATE)
1173:             if FEATURE_NOT_SUPPORTED == code
1174:               @statements.delete sql_key(sql)
1175:               retry
1176:             else
1177:               raise e
1178:             end
1179:           end
1180:         end
exec_no_cache(sql, binds) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1152
1152:         def exec_no_cache(sql, binds)
1153:           @connection.async_exec(sql)
1154:         end
extract_pg_identifier_from_name(name) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1289
1289:         def extract_pg_identifier_from_name(name)
1290:           match_data = name.start_with?('"') ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
1291: 
1292:           if match_data
1293:             rest = name[match_data[0].length, name.length]
1294:             rest = rest[1, rest.length] if rest.start_with? "."
1295:             [match_data[1], (rest.length > 0 ? rest : nil)]
1296:           end
1297:         end
extract_table_ref_from_insert_sql(sql) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1299
1299:         def extract_table_ref_from_insert_sql(sql)
1300:           sql[/into\s+([^\(]*).*values\s*\(/]
1301:           $1.strip if $1
1302:         end
prepare_statement(sql) click to toggle source

Prepare the statement if it hasn’t been prepared, return the statement key.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1190
1190:         def prepare_statement(sql)
1191:           sql_key = sql_key(sql)
1192:           unless @statements.key? sql_key
1193:             nextkey = @statements.next_key
1194:             @connection.prepare nextkey, sql
1195:             @statements[sql_key] = nextkey
1196:           end
1197:           @statements[sql_key]
1198:         end
select(sql, name = nil, binds = []) click to toggle source

Executes a SELECT query and returns the results, performing any data type conversions that are required to be performed here instead of in PostgreSQLColumn.

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1247
1247:         def select(sql, name = nil, binds = [])
1248:           exec_query(sql, name, binds).to_a
1249:         end
select_raw(sql, name = nil) click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1251
1251:         def select_raw(sql, name = nil)
1252:           res = execute(sql, name)
1253:           results = result_as_array(res)
1254:           fields = res.fields
1255:           res.clear
1256:           return fields, results
1257:         end
sql_key(sql) click to toggle source

Returns the statement identifier for the client side cache of statements

      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1184
1184:         def sql_key(sql)
1185:           "#{schema_search_path}-#{sql}"
1186:         end
table_definition() click to toggle source
      # File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1304
1304:         def table_definition
1305:           TableDefinition.new(self)
1306:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.