pg 1.3.0.rc2-x64-mingw-ucrt

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
+

data/sample/disk_usage_report.rb

@@ -0,0 +1,177 @@
+# -*- ruby -*-
+# vim: set noet nosta sw=4 ts=4 :
+#
+# Quickly dump size information for a given database.
+# Top twenty objects, and size per schema.
+#
+# Mahlon E. Smith <mahlon@martini.nu>
+#
+# Based on work by Jeff Davis <ruby@j-davis.com>.
+#
+
+
+require 'ostruct'
+require 'optparse'
+require 'etc'
+require 'pg'
+
+SCRIPT_VERSION = %q$Id$
+
+
+### Gather data and output it to $stdout.
+###
+def report( opts )
+	db = PG.connect(
+		:dbname   => opts.database,
+		:host     => opts.host,
+		:port     => opts.port,
+		:user     => opts.user,
+		:password => opts.pass,
+		:sslmode  => 'prefer'
+	)
+
+	# -----------------------------------------
+
+	db_info = db.exec %Q{
+		SELECT
+			count(oid) AS num_relations,
+			pg_size_pretty(pg_database_size('#{opts.database}')) AS dbsize
+		FROM
+			pg_class
+	}
+
+	puts '=' * 70
+	puts "Disk usage information for %s: (%d relations, %s total)" % [
+		opts.database,
+		db_info[0]['num_relations'],
+		db_info[0]['dbsize']
+	]
+	puts '=' * 70
+
+	# -----------------------------------------
+
+	top_twenty = db.exec %q{
+		SELECT
+			relname AS name,
+			relkind AS kind,
+			pg_size_pretty(pg_relation_size(pg_class.oid)) AS size
+		FROM
+			pg_class
+		ORDER BY
+			pg_relation_size(pg_class.oid) DESC
+		LIMIT 20
+	}
+
+	puts 'Top twenty objects by size:'
+	puts '-' * 70
+	top_twenty.each do |row|
+		type = case row['kind']
+			   when 'i'; 'index'
+			   when 't'; 'toast'
+			   when 'r'; 'table'
+			   when 'S'; 'sequence'
+			   else;     '???'
+			   end
+
+		puts "%40s %10s (%s)" % [ row['name'], row['size'], type ]
+	end
+	puts '-' * 70
+
+	# -----------------------------------------
+
+	schema_sizes = db.exec %q{
+		SELECT
+			table_schema,
+			pg_size_pretty( CAST( SUM(pg_total_relation_size(table_schema || '.' || table_name)) AS bigint)) AS size
+		FROM
+			information_schema.tables
+		GROUP BY
+			table_schema
+		ORDER BY
+			CAST( SUM(pg_total_relation_size(table_schema || '.' || table_name)) AS bigint ) DESC
+	}
+
+
+	puts 'Size per schema:'
+	puts '-' * 70
+	schema_sizes.each do |row|
+		puts "%20s %10s" % [ row['table_schema'], row['size'] ]
+	end
+	puts '-' * 70
+	puts
+
+	db.finish
+end
+
+
+### Parse command line arguments.  Return a struct of global options.
+###
+def parse_args( args )
+	options          = OpenStruct.new
+	options.database = Etc.getpwuid( Process.uid ).name
+	options.host     = '127.0.0.1'
+	options.port     = 5432
+	options.user     = Etc.getpwuid( Process.uid ).name
+	options.sslmode  = 'prefer'
+	options.interval = 5
+
+	opts = OptionParser.new do |opts|
+		opts.banner = "Usage: #{$0} [options]"
+
+		opts.separator ''
+		opts.separator 'Connection options:'
+
+		opts.on( '-d', '--database DBNAME',
+				"specify the database to connect to (default: \"#{options.database}\")" ) do |db|
+			options.database = db
+		end
+
+		opts.on( '-h', '--host HOSTNAME', 'database server host' ) do |host|
+			options.host = host
+		end
+
+		opts.on( '-p', '--port PORT', Integer,
+				"database server port (default: \"#{options.port}\")" ) do |port|
+			options.port = port
+		end
+
+		opts.on( '-U', '--user NAME',
+				"database user name (default: \"#{options.user}\")" ) do |user|
+			options.user = user
+		end
+
+		opts.on( '-W', 'force password prompt' ) do |pw|
+			print 'Password: '
+			begin
+				system 'stty -echo'
+				options.pass = gets.chomp
+			ensure
+				system 'stty echo'
+				puts
+			end
+		end
+
+		opts.separator ''
+		opts.separator 'Other options:'
+
+		opts.on_tail( '--help', 'show this help, then exit' ) do
+			$stderr.puts opts
+			exit
+		end
+
+		opts.on_tail( '--version', 'output version information, then exit' ) do
+			puts SCRIPT_VERSION
+			exit
+		end
+	end
+
+	opts.parse!( args )
+	return options
+end
+
+
+if __FILE__ == $0
+	opts = parse_args( ARGV )
+	report( opts )
+end
+

data/sample/issue-119.rb

@@ -0,0 +1,94 @@
+# -*- ruby -*-
+
+require 'pg'
+
+# This is another example of how to use COPY FROM, this time as a
+# minimal test case used to try to figure out what was going on in
+# an issue submitted from a user:
+#
+#  https://bitbucket.org/ged/ruby-pg/issue/119
+#
+
+conn		   = PG.connect( dbname: 'test' )
+table_name	   = 'issue_119'
+field_list	   = %w[name body_weight brain_weight]
+method		   = 0
+options		   = { truncate: true }
+sql_parameters = ''
+
+conn.set_error_verbosity( PG::PQERRORS_VERBOSE )
+conn.exec( "DROP TABLE IF EXISTS #{table_name}" )
+conn.exec( "CREATE TABLE #{table_name} ( id SERIAL, name TEXT, body_weight REAL, brain_weight REAL )" )
+
+text = <<-END_DATA
+Mountain beaver	1.35	465
+Cow	465	423
+Grey wolf	36.33	119.5
+Goat	27.66	115
+Guinea pig	1.04	5.5
+Dipliodocus	11700	50
+Asian elephant	2547	4603
+Donkey	187.1	419
+Horse	521	655
+Potar monkey	10	115
+Cat	3.3	25.6
+Giraffe	529	680
+Gorilla	207	406
+Human	62	1320
+African elephant	6654	5712
+Triceratops	9400	70
+Rhesus monkey	6.8	179
+Kangaroo	35	56
+Golden hamster	0.12	1
+Mouse	0.023	0.4
+Rabbit	2.5	12.1
+Sheep	55.5	175
+Jaguar	100	157
+Chimpanzee	52.16	440
+Brachiosaurus	87000	154.5
+Mole	0.122	3
+Pig	192	18
+END_DATA
+
+#ActiveRecord::Base.connection_pool.with_connection do |conn|
+	conn.transaction do
+		rc = conn #.raw_connection
+		rc.exec "TRUNCATE TABLE #{table_name};" if options[:truncate]
+		sql = "COPY #{table_name} (#{field_list.join(',')}) FROM STDIN #{sql_parameters} "
+		p sql
+		rc.exec(sql)
+		errmsg = nil # scope this outside of the rescue below so it's visible later
+		begin
+			if method == 1
+				rc.put_copy_data text + "\\.\n"
+			else
+				text.each_line { |line| rc.put_copy_data(line) }
+			end
+		rescue Errno => err
+			errmsg = "%s while reading copy data: %s" % [err.class.name, err.message]
+			puts "an error occurred"
+		end
+
+		if errmsg
+			rc.put_copy_end(errmsg)
+			puts "ERROR #{errmsg}"
+		else
+			rc.put_copy_end
+		end
+
+		while res = rc.get_result
+			st = res.res_status( res.result_status )
+			puts "Result of COPY is: %s" % [ st ]
+			if res.result_status != PG::PGRES_COPY_IN
+				puts res.error_message
+			end
+		end
+		puts "end"
+	end #transaction
+#end #connection
+
+conn.exec( "SELECT name, brain_weight FROM #{table_name}" ) do |res|
+	p res.values
+end
+
+

data/sample/losample.rb

@@ -0,0 +1,69 @@
+# -*- ruby -*-
+
+require 'pg'
+
+SAMPLE_WRITE_DATA = 'some sample data'
+SAMPLE_EXPORT_NAME = 'lowrite.txt'
+
+conn = PG.connect( :dbname => 'test', :host => 'localhost', :port => 5432 )
+puts "dbname: " + conn.db + "\thost: " + conn.host + "\tuser: " + conn.user
+
+# Start a transaction, as all large object functions require one.
+puts "Beginning transaction"
+conn.exec( 'BEGIN' )
+
+# Test importing from a file
+puts "Import test:"
+puts "  importing %s" % [ __FILE__ ]
+oid = conn.lo_import( __FILE__ )
+puts "  imported as large object %d" % [ oid ]
+
+# Read back 50 bytes of the imported data
+puts "Read test:"
+fd = conn.lo_open( oid, PG::INV_READ|PG::INV_WRITE )
+conn.lo_lseek( fd, 0, PG::SEEK_SET )
+buf = conn.lo_read( fd, 50 )
+puts "  read: %p" % [ buf ]
+puts "  read was ok!" if buf =~ /require 'pg'/
+
+# Append some test data onto the end of the object
+puts "Write test:"
+conn.lo_lseek( fd, 0, PG::SEEK_END )
+buf = SAMPLE_WRITE_DATA.dup
+totalbytes = 0
+until buf.empty?
+	bytes = conn.lo_write( fd, buf )
+	buf.slice!( 0, bytes )
+	totalbytes += bytes
+end
+puts "  appended %d bytes" % [ totalbytes ]
+
+# Now export it
+puts "Export test:"
+File.unlink( SAMPLE_EXPORT_NAME ) if File.exist?( SAMPLE_EXPORT_NAME )
+conn.lo_export( oid, SAMPLE_EXPORT_NAME )
+puts "  success!" if File.exist?( SAMPLE_EXPORT_NAME )
+puts "  exported as %s (%d bytes)" % [ SAMPLE_EXPORT_NAME, File.size(SAMPLE_EXPORT_NAME) ]
+
+conn.exec( 'COMMIT' )
+puts "End of transaction."
+
+
+puts 'Testing read and delete from a new transaction:'
+puts '  starting a new transaction'
+conn.exec( 'BEGIN' )
+
+fd = conn.lo_open( oid, PG::INV_READ )
+puts '  reopened okay.'
+conn.lo_lseek( fd, 50, PG::SEEK_END )
+buf = conn.lo_read( fd, 50 )
+puts '  read okay.' if buf == SAMPLE_WRITE_DATA
+
+puts 'Closing and unlinking:'
+conn.lo_close( fd )
+puts '  closed.'
+conn.lo_unlink( oid )
+puts '  unlinked.'
+conn.exec( 'COMMIT' )
+puts 'Done.'
+

data/sample/minimal-testcase.rb

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'pg'
+
+conn = PG.connect( :dbname => 'test' )
+$stderr.puts '---',
+	RUBY_DESCRIPTION,
+	PG.version_string( true ),
+	"Server version: #{conn.server_version}",
+	"Client version: #{PG.library_version}",
+	'---'
+
+result = conn.exec( "SELECT * from pg_stat_activity" )
+
+$stderr.puts %Q{Expected this to return: ["select * from pg_stat_activity"]}
+p result.field_values( 'current_query' )
+