pg 0.13.2-x86-mingw32 → 0.14.0.pre.353-x86-mingw32

data/ext/pg_result.c

@@ -21,32 +21,38 @@ static PGresult* pgresult_get( VALUE );
  * Result constructor
  */
 VALUE
-pg_new_result(PGresult *result, PGconn *conn)
+pg_new_result(PGresult *result, VALUE rb_pgconn)
 {
+	PGconn *conn = pg_get_pgconn( rb_pgconn );
 	VALUE val = Data_Wrap_Struct(rb_cPGresult, NULL, pgresult_gc_free, result);
 #ifdef M17N_SUPPORTED
 	rb_encoding *enc = pg_conn_enc_get( conn );
 	ENCODING_SET( val, rb_enc_to_index(enc) );
 #endif
 
+	rb_iv_set( val, "@connection", rb_pgconn );
+
 	return val;
 }
 
 /*
- * Raises appropriate exception if PGresult is
- * in a bad state.
+ * call-seq:
+ *    res.result -> nil
+ *
+ * Raises appropriate exception if PG::Result is in a bad state.
  */
-void
-pg_check_result(VALUE rb_pgconn, VALUE rb_pgresult)
+VALUE
+pg_result_check( VALUE self )
 {
 	VALUE error, exception;
+	VALUE rb_pgconn = rb_iv_get( self, "@connection" );
 	PGconn *conn = pg_get_pgconn(rb_pgconn);
 	PGresult *result;
 #ifdef M17N_SUPPORTED
 	rb_encoding *enc = pg_conn_enc_get( conn );
 #endif
 
-	Data_Get_Struct(rb_pgresult, PGresult, result);
+	Data_Get_Struct(self, PGresult, result);
 
 	if(result == NULL)
 	{
@@ -59,9 +65,12 @@ pg_check_result(VALUE rb_pgconn, VALUE rb_pgresult)
 		case PGRES_TUPLES_OK:
 		case PGRES_COPY_OUT:
 		case PGRES_COPY_IN:
+#ifdef HAVE_CONST_PGRES_COPY_BOTH
+		case PGRES_COPY_BOTH:
+#endif
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
-			return;
+			return Qnil;
 		case PGRES_BAD_RESPONSE:
 		case PGRES_FATAL_ERROR:
 		case PGRES_NONFATAL_ERROR:
@@ -77,10 +86,11 @@ pg_check_result(VALUE rb_pgconn, VALUE rb_pgresult)
 #endif
 	exception = rb_exc_new3( rb_ePGerror, error );
 	rb_iv_set( exception, "@connection", rb_pgconn );
-	rb_iv_set( exception, "@result", rb_pgresult );
+	rb_iv_set( exception, "@result", self );
 	rb_exc_raise( exception );
 
-	return;
+	/* Not reached */
+	return Qnil;
 }
 
 
@@ -94,7 +104,7 @@ pg_check_result(VALUE rb_pgconn, VALUE rb_pgresult)
  * call-seq:
  *    res.clear() -> nil
  *
- * Clears the PGresult object as the result of the query.
+ * Clears the PG::Result object as the result of the query.
  */
 VALUE
 pg_result_clear(VALUE self)
@@ -135,7 +145,7 @@ pgresult_get(VALUE self)
 
 /********************************************************************
  * 
- * Document-class: PGresult
+ * Document-class: PG::Result
  *
  * The class to represent the query result tuples (rows). 
  * An instance of this class is created as the result of every query.
@@ -153,7 +163,7 @@ pgresult_get(VALUE self)
  */
 
 /**************************************************************************
- * PGresult INSTANCE METHODS
+ * PG::Result INSTANCE METHODS
  **************************************************************************/
 
 /*
@@ -229,20 +239,20 @@ pgresult_error_message(VALUE self)
  * 
  *   begin
  *       conn.exec( "SELECT * FROM nonexistant_table" )
- *   rescue PGError => err
+ *   rescue PG::Error => err
  *       p [
- *           result.error_field( PGresult::PG_DIAG_SEVERITY ),
- *           result.error_field( PGresult::PG_DIAG_SQLSTATE ),
- *           result.error_field( PGresult::PG_DIAG_MESSAGE_PRIMARY ),
- *           result.error_field( PGresult::PG_DIAG_MESSAGE_DETAIL ),
- *           result.error_field( PGresult::PG_DIAG_MESSAGE_HINT ),
- *           result.error_field( PGresult::PG_DIAG_STATEMENT_POSITION ),
- *           result.error_field( PGresult::PG_DIAG_INTERNAL_POSITION ),
- *           result.error_field( PGresult::PG_DIAG_INTERNAL_QUERY ),
- *           result.error_field( PGresult::PG_DIAG_CONTEXT ),
- *           result.error_field( PGresult::PG_DIAG_SOURCE_FILE ),
- *           result.error_field( PGresult::PG_DIAG_SOURCE_LINE ),
- *           result.error_field( PGresult::PG_DIAG_SOURCE_FUNCTION ),
+ *           result.error_field( PG::Result::PG_DIAG_SEVERITY ),
+ *           result.error_field( PG::Result::PG_DIAG_SQLSTATE ),
+ *           result.error_field( PG::Result::PG_DIAG_MESSAGE_PRIMARY ),
+ *           result.error_field( PG::Result::PG_DIAG_MESSAGE_DETAIL ),
+ *           result.error_field( PG::Result::PG_DIAG_MESSAGE_HINT ),
+ *           result.error_field( PG::Result::PG_DIAG_STATEMENT_POSITION ),
+ *           result.error_field( PG::Result::PG_DIAG_INTERNAL_POSITION ),
+ *           result.error_field( PG::Result::PG_DIAG_INTERNAL_QUERY ),
+ *           result.error_field( PG::Result::PG_DIAG_CONTEXT ),
+ *           result.error_field( PG::Result::PG_DIAG_SOURCE_FILE ),
+ *           result.error_field( PG::Result::PG_DIAG_SOURCE_LINE ),
+ *           result.error_field( PG::Result::PG_DIAG_SOURCE_FUNCTION ),
  *       ]
  *   end
  * 
@@ -492,7 +502,7 @@ pgresult_fsize(VALUE self, VALUE index)
 static VALUE
 pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 {
-	VALUE ret;
+	VALUE val;
 	PGresult *result;
 	int i = NUM2INT(tup_num);
 	int j = NUM2INT(field_num);
@@ -506,10 +516,19 @@ pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 	}
 	if(PQgetisnull(result, i, j))
 		return Qnil;
-	ret = rb_tainted_str_new(PQgetvalue(result, i, j), 
+	val = rb_tainted_str_new(PQgetvalue(result, i, j),
 				PQgetlength(result, i, j));
-	ASSOCIATE_INDEX(ret, self);
-	return ret;
+
+#ifdef M17N_SUPPORTED
+	/* associate client encoding for text format only */
+	if ( 0 == PQfformat(result, j) ) {
+		ASSOCIATE_INDEX( val, self );
+	} else {
+		rb_enc_associate( val, rb_ascii8bit_encoding() );
+	}
+#endif
+
+	return val;
 }
 
 /*
@@ -612,7 +631,7 @@ pgresult_cmd_status(VALUE self)
  *
  * Returns the number of tuples (rows) affected by the SQL command.
  *
- * If the SQL command that generated the PGresult was not one of:
+ * If the SQL command that generated the PG::Result was not one of:
  * * +INSERT+
  * * +UPDATE+
  * * +DELETE+
@@ -706,19 +725,15 @@ pgresult_values(VALUE self)
 	int field;
 	int num_rows = PQntuples(result);
 	int num_fields = PQnfields(result);
-	VALUE ary = rb_ary_new2(num_rows);
+	VALUE rows[ num_rows ];
 
 	for ( row = 0; row < num_rows; row++ ) {
-		/* create new row */
-		VALUE new_row = rb_ary_new2(num_fields);
+		VALUE new_row[ num_fields ];
 
-		/* add to return array */
-		rb_ary_store( ary, row, new_row );
-
-		/* populate it */
+		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
 			if ( PQgetisnull(result, row, field) ) {
-				rb_ary_store( new_row, field, Qnil );
+				new_row[ field ] = Qnil;
 			}
 			else {
 				VALUE val = rb_tainted_str_new( PQgetvalue(result, row, field), 
@@ -732,16 +747,18 @@ pgresult_values(VALUE self)
 					rb_enc_associate( val, rb_ascii8bit_encoding() );
 				}
 #endif
-
-				rb_ary_store( new_row, field, val );
+				new_row[ field ] = val;
 			}
 		}
+
+		rows[ row ] = rb_ary_new4( num_fields, new_row );
 	}
-	return ary;
+
+	return rb_ary_new4( num_rows, rows );
 }
 
 
-/* 
+/*
  * Make a Ruby array out of the encoded values from the specified
  * column in the given result.
  */
@@ -749,16 +766,17 @@ static VALUE
 make_column_result_array( VALUE self, int col )
 {
 	PGresult *result = pgresult_get( self );
-	int row = PQntuples( result );
-	VALUE ary = rb_ary_new2( row );
+	int rows = PQntuples( result );
+	int i;
 	VALUE val = Qnil;
+	VALUE results[ rows ];
 
 	if ( col >= PQnfields(result) )
 		rb_raise( rb_eIndexError, "no column %d in result", col );
 
-	while ( row-- ) {
-		val = rb_tainted_str_new( PQgetvalue(result, row, col),
-		                          PQgetlength(result, row, col) );
+	for ( i=0; i < rows; i++ ) {
+		val = rb_tainted_str_new( PQgetvalue(result, i, col),
+		                          PQgetlength(result, i, col) );
 
 #ifdef M17N_SUPPORTED
 		/* associate client encoding for text format only */
@@ -769,10 +787,10 @@ make_column_result_array( VALUE self, int col )
 		}
 #endif
 
-		rb_ary_store( ary, row, val );
+		results[ i ] = val;
 	}
 
-	return ary;
+	return rb_ary_new4( rows, results );
 }
 
 
@@ -840,19 +858,18 @@ pgresult_each(VALUE self)
 static VALUE
 pgresult_fields(VALUE self)
 {
-	PGresult *result;
-	VALUE ary;
-	int n, i;
+	PGresult *result = pgresult_get( self );
+	int n = PQnfields( result );
+	VALUE fields[ n ];
+	int i;
 
-	result = pgresult_get(self);
-	n = PQnfields(result);
-	ary = rb_ary_new2(n);
-	for (i=0;i<n;i++) {
+	for ( i = 0; i < n; i++ ) {
 		VALUE val = rb_tainted_str_new2(PQfname(result, i));
 		ASSOCIATE_INDEX(val, self);
-		rb_ary_push(ary, val);
+		fields[ i ] = val;
 	}
-	return ary;
+
+	return rb_ary_new4( n, fields );
 }
 
 
@@ -871,6 +888,8 @@ init_pg_result()
 	rb_define_method(rb_cPGresult, "error_field", pgresult_error_field, 1);
 	rb_define_alias( rb_cPGresult, "result_error_field", "error_field" );
 	rb_define_method(rb_cPGresult, "clear", pg_result_clear, 0);
+	rb_define_method(rb_cPGresult, "check", pg_result_check, 0);
+	rb_define_alias (rb_cPGresult, "check_result", "check");
 	rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0);
 	rb_define_alias(rb_cPGresult, "num_tuples", "ntuples");
 	rb_define_method(rb_cPGresult, "nfields", pgresult_nfields, 0);

data/lib/pg.rb

@@ -19,7 +19,7 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.13.2'
+	VERSION = '0.14.0.pre.353'
 
 	# VCS revision
 	REVISION = %q$Revision$

data/lib/pg/connection.rb

@@ -51,6 +51,13 @@ class PG::Connection
 		return connopts.join(' ')
 	end
 
+
+	# Backward-compatibility aliases for stuff that's moved into PG.
+	class << self
+		define_method( :isthreadsafe, &PG.method(:isthreadsafe) )
+	end
+
+
 end # class PG::Connection
 
 # Backward-compatible alias

data/sample/async_api.rb

@@ -65,6 +65,8 @@ until poll_status == PG::PGRES_POLLING_OK ||
 		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

data/sample/check_conn.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env 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/disk_usage_report.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env 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>.
+#
+
+
+begin
+	require 'ostruct'
+	require 'optparse'
+	require 'etc'
+	require 'pg'
+
+rescue LoadError # 1.8 support
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+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
+