pg 0.21.0 → 1.5.3

data/pg.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require_relative 'lib/pg/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg"
+  spec.version       = PG::VERSION
+  spec.authors       = ["Michael Granger", "Lars Kanis"]
+  spec.email         = ["ged@FaerieMUD.org", "lars@greiz-reinsdorf.de"]
+
+  spec.summary       = "Pg is the Ruby interface to the PostgreSQL RDBMS"
+  spec.description   = "Pg is the Ruby interface to the PostgreSQL RDBMS. It works with PostgreSQL 9.3 and later."
+  spec.homepage      = "https://github.com/ged/ruby-pg"
+  spec.license       = "BSD-2-Clause"
+  spec.required_ruby_version = ">= 2.5"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ged/ruby-pg"
+  spec.metadata["changelog_uri"] = "https://github.com/ged/ruby-pg/blob/master/History.md"
+  spec.metadata["documentation_uri"] = "http://deveiate.org/code/pg"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.extensions    = ["ext/extconf.rb"]
+  spec.require_paths = ["lib"]
+  spec.cert_chain    = ["certs/ged.pem"]
+  spec.rdoc_options  = ["--main", "README.md",
+                        "--title", "PG: The Ruby PostgreSQL Driver"]
+  spec.extra_rdoc_files = `git ls-files -z *.rdoc *.md lib/*.rb lib/*/*.rb lib/*/*/*.rb ext/*.c ext/*.h`.split("\x0")
+end

data/rakelib/task_extension.rb

@@ -0,0 +1,46 @@
+# This source code is borrowed from:
+# https://github.com/oneclick/rubyinstaller2/blob/b3dcbf69f131e44c78ea3a1c5e0041c223f266ce/lib/ruby_installer/build/utils.rb#L104-L144
+
+module TaskExtension
+  # Extend rake's file task to be defined only once and to check the expected file is indeed generated
+  #
+  # The same as #task, but for #file.
+  # In addition this file task raises an error, if the file that is expected to be generated is not present after the block was executed.
+  def file(name, *args, &block)
+    task_once(name, block) do
+      super(name, *args) do |ta|
+        block&.call(ta).tap do
+          raise "file #{ta.name} is missing after task executed" unless File.exist?(ta.name)
+        end
+      end
+    end
+  end
+
+  # Extend rake's task definition to be defined only once, even if called several times
+  #
+  # This allows to define common tasks next to specific tasks.
+  # It is expected that any variation of the task's block is reflected in the task name or namespace.
+  # If the task name is identical, the task block is executed only once, even if the file task definition is executed twice.
+  def task(name, *args, &block)
+    task_once(name, block) do
+      super
+    end
+  end
+
+  private def task_once(name, block)
+    name = name.keys.first if name.is_a?(Hash)
+    if block &&
+        Rake::Task.task_defined?(name) &&
+        Rake::Task[name].instance_variable_get('@task_block_location') == block.source_location
+      # task is already defined for this target and the same block
+      # So skip double definition of the same action
+      Rake::Task[name]
+    elsif block
+      yield.tap do
+        Rake::Task[name].instance_variable_set('@task_block_location', block.source_location)
+      end
+    else
+      yield
+    end
+  end
+end

data/sample/array_insert.rb

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+require 'pg'
+
+c = PG.connect( dbname: 'test' )
+
+# this one works:
+c.exec( "DROP TABLE IF EXISTS foo" )
+c.exec( "CREATE TABLE foo (strings character varying[]);" )
+
+# But using a prepared statement works:
+c.set_error_verbosity( PG::PQERRORS_VERBOSE )
+c.prepare( 'stmt', "INSERT INTO foo VALUES ($1);" )
+
+# This won't work
+#c.exec_prepared( 'stmt', ["ARRAY['this','that']"] )
+
+# but this will:
+c.exec_prepared( 'stmt', ["{'this','that'}"] )
+

data/sample/async_api.rb

@@ -0,0 +1,102 @@
+# -*- ruby -*-
+
+require 'pg'
+
+# This is a example of how to use the asynchronous API to query the
+# server without blocking other threads. It's intentionally low-level;
+# if you hooked up the PG::Connection#socket to some kind of reactor, you
+# could make this much nicer.
+
+TIMEOUT = 5.0 # seconds to wait for an async operation to complete
+
+# Print 'x' continuously to demonstrate that other threads aren't
+# blocked while waiting for the connection, for the query to be sent,
+# for results, etc. You might want to sleep inside the loop or
+# comment this out entirely for cleaner output.
+progress_thread = Thread.new { loop { print 'x' } }
+
+# Output progress messages
+def output_progress( msg )
+	puts "\n>>> #{msg}\n"
+end
+
+# Start the connection
+output_progress "Starting connection..."
+conn = PG::Connection.connect_start( :dbname => 'test' ) or
+	abort "Unable to create a new connection!"
+abort "Connection failed: %s" % [ conn.error_message ] if
+	conn.status == PG::CONNECTION_BAD
+
+# Track the progress of the connection, waiting for the socket to become readable/writable
+# before polling it
+poll_status = PG::PGRES_POLLING_WRITING
+until poll_status == PG::PGRES_POLLING_OK ||
+	  poll_status == PG::PGRES_POLLING_FAILED
+
+	# If the socket needs to read, wait 'til it becomes readable to poll again
+	case poll_status
+	when PG::PGRES_POLLING_READING
+		output_progress "  waiting for socket to become readable"
+		select( [conn.socket_io], nil, nil, TIMEOUT ) or
+			raise "Asynchronous connection timed out!"
+
+	# ...and the same for when the socket needs to write
+	when PG::PGRES_POLLING_WRITING
+		output_progress "  waiting for socket to become writable"
+		select( nil, [conn.socket_io], nil, TIMEOUT ) or
+			raise "Asynchronous connection timed out!"
+	end
+
+	# Output a status message about the progress
+	case conn.status
+	when PG::CONNECTION_STARTED
+		output_progress "  waiting for connection to be made."
+	when PG::CONNECTION_MADE
+		output_progress "  connection OK; waiting to send."
+	when PG::CONNECTION_AWAITING_RESPONSE
+		output_progress "  waiting for a response from the server."
+	when PG::CONNECTION_AUTH_OK
+		output_progress "  received authentication; waiting for backend start-up to finish."
+	when PG::CONNECTION_SSL_STARTUP
+		output_progress "  negotiating SSL encryption."
+	when PG::CONNECTION_SETENV
+		output_progress "  negotiating environment-driven parameter settings."
+	when PG::CONNECTION_NEEDED
+		output_progress "  internal state: connect() needed."
+	end
+
+	# Check to see if it's finished or failed yet
+	poll_status = conn.connect_poll
+end
+
+abort "Connect failed: %s" % [ conn.error_message ] unless conn.status == PG::CONNECTION_OK
+
+output_progress "Sending query"
+conn.send_query( "SELECT * FROM pg_stat_activity" )
+
+# Fetch results until there aren't any more
+loop do
+	output_progress "  waiting for a response"
+
+	# Buffer any incoming data on the socket until a full result is ready.
+	conn.consume_input
+	while conn.is_busy
+		select( [conn.socket_io], nil, nil, TIMEOUT ) or
+			raise "Timeout waiting for query response."
+		conn.consume_input
+	end
+
+	# Fetch the next result. If there isn't one, the query is finished
+	result = conn.get_result or break
+
+	puts "\n\nQuery result:\n%p\n" % [ result.values ]
+end
+
+output_progress "Done."
+conn.finish
+
+if defined?( progress_thread )
+	progress_thread.kill
+	progress_thread.join
+end
+

data/sample/async_copyto.rb

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+
+require 'pg'
+require 'stringio'
+
+# Using COPY asynchronously
+
+$stderr.puts "Opening database connection ..."
+conn = PG.connect( :dbname => 'test' )
+conn.setnonblocking( true )
+
+socket = conn.socket_io
+
+$stderr.puts "Running COPY command ..."
+buf = ''
+conn.transaction do
+	conn.send_query( "COPY logs TO STDOUT WITH csv" )
+	buf = nil
+
+	# #get_copy_data returns a row if there's a whole one to return, false
+	# if there isn't one but the COPY is still running, or nil when it's
+	# finished.
+	begin
+		$stderr.puts "COPY loop"
+		conn.consume_input
+		while conn.is_busy
+			$stderr.puts "  ready loop"
+			select( [socket], nil, nil, 5.0 ) or
+				raise "Timeout (5s) waiting for query response."
+			conn.consume_input
+		end
+
+		buf = conn.get_copy_data
+		$stdout.puts( buf ) if buf
+	end until buf.nil?
+end
+
+conn.finish
+

data/sample/async_mixed.rb

@@ -0,0 +1,56 @@
+# -*- ruby -*-
+
+require 'pg'
+
+$stdout.sync = true
+
+# This is a example of how to mix and match synchronous and async APIs. In this case,
+# the connection to the server is made syncrhonously, and then queries are
+# asynchronous.
+
+TIMEOUT = 5.0 # seconds to wait for an async operation to complete
+CONN_OPTS = {
+	:host     => 'localhost',
+	:dbname   => 'test',
+}
+
+# Output progress messages
+def output_progress( msg )
+	puts ">>> #{msg}\n"
+end
+
+# Start the (synchronous) connection
+output_progress "Starting connection..."
+conn = PG.connect( CONN_OPTS ) or abort "Unable to create a new connection!"
+
+abort "Connect failed: %s" % [ conn.error_message ] unless conn.status == PG::CONNECTION_OK
+
+# Now grab a reference to the underlying socket to select() on while the query is running
+socket = conn.socket_io
+
+# Send the (asynchronous) query
+output_progress "Sending query"
+conn.send_query( "SELECT * FROM pg_stat_activity" )
+
+# Fetch results until there aren't any more
+loop do
+	output_progress "  waiting for a response"
+
+	# Buffer any incoming data on the socket until a full result is ready.
+	conn.consume_input
+	while conn.is_busy
+		output_progress "  waiting for data to be available on %p..." % [ socket ]
+		select( [socket], nil, nil, TIMEOUT ) or
+			raise "Timeout waiting for query response."
+		conn.consume_input
+	end
+
+	# Fetch the next result. If there isn't one, the query is finished
+	result = conn.get_result or break
+
+	output_progress "Query result:\n%p\n" % [ result.values ]
+end
+
+output_progress "Done."
+conn.finish
+

data/sample/check_conn.rb

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require 'pg'
+
+# This is a minimal example of a function that can test an existing PG::Connection and
+# reset it if necessary.
+
+def check_connection( conn )
+	begin
+		conn.exec( "SELECT 1" )
+	rescue PG::Error => err
+		$stderr.puts "%p while testing connection: %s" % [ err.class, err.message ]
+		conn.reset
+	end
+end
+
+conn = PG.connect( dbname: 'test' )
+check_connection( conn )
+

data/sample/copydata.rb

@@ -0,0 +1,71 @@
+# -*- ruby -*-
+
+require 'pg'
+require 'stringio'
+
+$stderr.puts "Opening database connection ..."
+conn = PG.connect( dbname: 'test' )
+
+conn.exec( <<END_SQL )
+DROP TABLE IF EXISTS logs;
+CREATE TABLE logs (
+	client_ip inet,
+	username text,
+	ts timestamp,
+	request text,
+	status smallint,
+	bytes int
+);
+END_SQL
+
+csv_io = StringIO.new( <<"END_DATA" )
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /manual/ HTTP/1.1",404,205
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /favicon.ico HTTP/1.1",404,209
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /favicon.ico HTTP/1.1",404,209
+"127.0.0.1","","30/Aug/2010:08:22:29 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:22:38 -0700","GET /manual/index.html HTTP/1.1",200,725
+"127.0.0.1","","30/Aug/2010:08:27:56 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:27:57 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/index.html HTTP/1.1",200,7709
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/feather.gif HTTP/1.1",200,6471
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/left.gif HTTP/1.1",200,60
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual.css HTTP/1.1",200,18674
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual-print.css HTTP/1.1",200,13200
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/favicon.ico HTTP/1.1",200,1078
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual-loose-100pc.css HTTP/1.1",200,3065
+"127.0.0.1","","30/Aug/2010:08:28:14 -0700","OPTIONS * HTTP/1.0",200,0
+"127.0.0.1","","30/Aug/2010:08:28:15 -0700","OPTIONS * HTTP/1.0",200,0
+"127.0.0.1","","30/Aug/2010:08:28:47 -0700","GET /manual/mod/directives.html HTTP/1.1",200,33561
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/mod/mpm_common.html HTTP/1.1",200,67683
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/images/down.gif HTTP/1.1",200,56
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/images/up.gif HTTP/1.1",200,57
+"127.0.0.1","","30/Aug/2010:09:19:58 -0700","GET /manual/mod/mod_log_config.html HTTP/1.1",200,28307
+"127.0.0.1","","30/Aug/2010:09:20:19 -0700","GET /manual/mod/core.html HTTP/1.1",200,194144
+"127.0.0.1","","30/Aug/2010:16:02:56 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:16:03:00 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:16:06:16 -0700","GET /manual/mod/mod_dir.html HTTP/1.1",200,10583
+"127.0.0.1","","30/Aug/2010:16:06:44 -0700","GET /manual/ HTTP/1.1",200,7709
+END_DATA
+
+### You can test the error case from the database side easily by
+### changing one of the numbers at the end of one of the above rows to
+### something non-numeric like "-".
+
+$stderr.puts "Running COPY command with data ..."
+buf = ''
+conn.transaction do
+	res = conn.copy_data( "COPY logs FROM STDIN WITH csv" ) do
+		$stderr.print "Sending lines... "
+		csv_io.each_line.with_index do |buf, i|
+			$stderr.print "#{i + 1} "
+			conn.put_copy_data( buf )
+		end
+		$stderr.puts "done."
+	end
+	$stderr.puts "Result of COPY is: %s" % [ res.res_status(res.result_status) ]
+	$stderr.puts "  tuples copied: %p" % [ res.cmd_tuples ]
+end
+
+
+conn.finish
+

data/sample/copyfrom.rb

@@ -0,0 +1,81 @@
+# -*- ruby -*-
+
+require 'pg'
+require 'stringio'
+
+$stderr.puts "Opening database connection ..."
+conn = PG.connect( :dbname => 'test' )
+
+conn.exec( <<END_SQL )
+DROP TABLE IF EXISTS logs;
+CREATE TABLE logs (
+	client_ip inet,
+	username text,
+	ts timestamp,
+	request text,
+	status smallint,
+	bytes int
+);
+END_SQL
+
+copy_data = StringIO.new( <<"END_DATA" )
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /manual/ HTTP/1.1",404,205
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /favicon.ico HTTP/1.1",404,209
+"127.0.0.1","","30/Aug/2010:08:21:24 -0700","GET /favicon.ico HTTP/1.1",404,209
+"127.0.0.1","","30/Aug/2010:08:22:29 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:22:38 -0700","GET /manual/index.html HTTP/1.1",200,725
+"127.0.0.1","","30/Aug/2010:08:27:56 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:27:57 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/index.html HTTP/1.1",200,7709
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/feather.gif HTTP/1.1",200,6471
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/left.gif HTTP/1.1",200,60
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual.css HTTP/1.1",200,18674
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual-print.css HTTP/1.1",200,13200
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/images/favicon.ico HTTP/1.1",200,1078
+"127.0.0.1","","30/Aug/2010:08:28:06 -0700","GET /manual/style/css/manual-loose-100pc.css HTTP/1.1",200,3065
+"127.0.0.1","","30/Aug/2010:08:28:14 -0700","OPTIONS * HTTP/1.0",200,0
+"127.0.0.1","","30/Aug/2010:08:28:15 -0700","OPTIONS * HTTP/1.0",200,0
+"127.0.0.1","","30/Aug/2010:08:28:47 -0700","GET /manual/mod/directives.html HTTP/1.1",200,33561
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/mod/mpm_common.html HTTP/1.1",200,67683
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/images/down.gif HTTP/1.1",200,56
+"127.0.0.1","","30/Aug/2010:08:28:53 -0700","GET /manual/images/up.gif HTTP/1.1",200,57
+"127.0.0.1","","30/Aug/2010:09:19:58 -0700","GET /manual/mod/mod_log_config.html HTTP/1.1",200,28307
+"127.0.0.1","","30/Aug/2010:09:20:19 -0700","GET /manual/mod/core.html HTTP/1.1",200,194144
+"127.0.0.1","","30/Aug/2010:16:02:56 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:16:03:00 -0700","GET /manual/ HTTP/1.1",200,11094
+"127.0.0.1","","30/Aug/2010:16:06:16 -0700","GET /manual/mod/mod_dir.html HTTP/1.1",200,10583
+"127.0.0.1","","30/Aug/2010:16:06:44 -0700","GET /manual/ HTTP/1.1",200,7709
+END_DATA
+
+### You can test the error case from the database side easily by
+### changing one of the numbers at the end of one of the above rows to
+### something non-numeric like "-".
+
+$stderr.puts "Running COPY command with data ..."
+buf = ''
+conn.transaction do
+	conn.exec( "COPY logs FROM STDIN WITH csv" )
+	begin
+		while copy_data.read( 256, buf )
+			### Uncomment this to test error-handling for exceptions from the reader side:
+			# raise Errno::ECONNRESET, "socket closed while reading"
+			$stderr.puts "	sending %d bytes of data..." % [ buf.length ]
+			until conn.put_copy_data( buf )
+				$stderr.puts "	waiting for connection to be writable..."
+				sleep 0.1
+			end
+		end
+	rescue Errno => err
+		errmsg = "%s while reading copy data: %s" % [ err.class.name, err.message ]
+		conn.put_copy_end( errmsg )
+	else
+		conn.put_copy_end
+		while res = conn.get_result
+			$stderr.puts "Result of COPY is: %s" % [ res.res_status(res.result_status) ]
+		end
+	end
+end
+
+
+conn.finish
+

data/sample/copyto.rb

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+
+require 'pg'
+require 'stringio'
+
+# An example of how to stream data to your local host from the database as CSV.
+
+$stderr.puts "Opening database connection ..."
+conn = PG.connect( :dbname => 'test' )
+
+$stderr.puts "Running COPY command ..."
+buf = ''
+conn.transaction do
+	conn.exec( "COPY logs TO STDOUT WITH csv" )
+	$stdout.puts( buf ) while buf = conn.get_copy_data
+end
+
+conn.finish
+

data/sample/cursor.rb

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+require 'pg'
+
+# An example of how to use SQL cursors. This is mostly a straight port of
+# the cursor portion of testlibpq.c from src/test/examples.
+
+$stderr.puts "Opening database connection ..."
+conn = PG.connect( :dbname => 'test' )
+
+#
+conn.transaction do
+    conn.exec( "DECLARE myportal CURSOR FOR select * from pg_database" )
+    res = conn.exec( "FETCH ALL IN myportal" )
+
+    puts res.fields.collect {|fname| "%-15s" % [fname] }.join( '' )
+    res.values.collect do |row|
+        puts row.collect {|col| "%-15s" % [col] }.join( '' )
+    end
+end
+