pgsql 1.5.1 → 1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5224c8b4aff8e7d39e4ea3b4bf14ab733d88653caab96507376db480777aaa86
-  data.tar.gz: 717901a45ef2f837911f1aba2cd4ba716354b5a299be9f10bc0684ffd8cda75e
+  metadata.gz: 2519cf85dd607a31191b7992cc99a93c31fb0b1103a38462f28cd77081599f0c
+  data.tar.gz: 026e108f08ffa63454f29504120c04f8fe8b3b1ffb664bd4626e7ca9f98f078a
 SHA512:
-  metadata.gz: aedc9283cc1bf0179cfedc2f145403aff24fe4267286b4c31566df795d359109799df65010f978271546fa657508d8f3821133a295cf9f8345ce6e23414bbce7
-  data.tar.gz: 2aaf604cdaf9c72ada34eb0cb790235000b4b798d993536980855ffbfb62683aa499cfbaf7701bad8a5626ebd2749de05aa14159ead7ded3d2bb26eb54bfaa7f
+  metadata.gz: 608f44789a6b5c009558c75b1d37f71fd2b86d283c2b78bf361d76bf3d7bb37065b6426a26f7ecb7d97829b3b31e4e7cf4a0f53453e11fc7327a914d2d65ca8c
+  data.tar.gz: 5e4e1fe2084fb5ba67646128d145de12840ad66c3fd54e0b22e65ea150c0d16444fc157ff19f61864fe048dd1eca4b3d7731ca8411376708ac81a2c7114b9774

data/lib/Rakefile

@@ -4,7 +4,7 @@
 
 require "autorake"
 
-c = compiler "-O2", "-fPIC"
+c = compiler "-O2", "-fPIC", "-Wall"
 l = linker "-shared"
 
 rule ".o" => ".c" do |t|
@@ -17,7 +17,7 @@ DLs = {
 }
 
 DLs.each { |k,v|
-  task k => v do |t|
+  file k => v do |t|
     l.cc t.name, t.prerequisites
   end
 }

data/lib/conn.c

@@ -26,12 +26,12 @@ extern VALUE pgconn_mkstring( struct pgconn_data *ptr, const char *str);
 extern VALUE pgconn_mkstringn( struct pgconn_data *ptr, const char *str, int len);
 static VALUE pgconn_alloc( VALUE cls);
 static VALUE pgconn_s_connect( int argc, VALUE *argv, VALUE cls);
-static VALUE pgconn_s_parse( VALUE cls, VALUE str);
 static VALUE pgconn_init( int argc, VALUE *argv, VALUE self);
 static int   set_connect_params( st_data_t key, st_data_t val, st_data_t args);
-static void  connstr_to_hash( VALUE params, VALUE str);
-static void  connstr_passwd( VALUE self, VALUE params);
-static VALUE connstr_getparam( VALUE yielded, VALUE params);
+static VALUE connstr_sym_dbname( void);
+static VALUE connstr_sym_password( void);
+static void  connstr_passwd( VALUE self, VALUE orig_params, VALUE *params);
+static VALUE connstr_getparam( RB_BLOCK_CALL_FUNC_ARGLIST( yielded, params));
 
 static VALUE pgconn_close( VALUE self);
 static VALUE pgconn_reset( VALUE self);
@@ -71,6 +71,10 @@ VALUE rb_cPgConn;
 static VALUE rb_ePgConnFailed;
 static VALUE rb_ePgConnInvalid;
 
+static VALUE sym_dbname   = Qundef;
+static VALUE sym_password = Qundef;
+
+static ID id_to_s;
 
 
 void
@@ -221,24 +225,6 @@ pgconn_s_connect( int argc, VALUE *argv, VALUE cls)
         rb_ensure( rb_yield, pgconn, pgconn_close, pgconn) : pgconn;
 }
 
-/*
- * call-seq:
- *   Pg::Conn.parse( str)    -> hash
- *
- * Parse a connection string and return a hash with keys <code>:dbname</code>,
- * <code>:user</code>, <code>:host</code>, etc.
- *
- */
-VALUE
-pgconn_s_parse( VALUE cls, VALUE str)
-{
-    VALUE params;
-
-    params = rb_hash_new();
-    connstr_to_hash( params, str);
-    return params;
-}
-
 
 /*
  * Document-method: Pg::Conn.new
@@ -252,23 +238,39 @@ pgconn_s_parse( VALUE cls, VALUE str)
  *
  *   c = Pg::Conn.new :dbname => "movies", :host => "jupiter", ...
  *
- * The most common parameters may be given in a URL-like
- * connection string:
+ * If the +str+ argument is given but no further parameters,
+ * the PQconnectdb() (not PQconnectdbParams()) function will be called.
+ * If further arguments are present, the +str+ argument will be made into
+ * the "dbname" parameter, but without overwriting an existing one.
+ *
+ * The "dbname" parameter may be a +conninfo+ string as described in the
+ * PostgreSQL documentation:
  *
- *   "user:password@host:port/dbname"
+ *   c = Pg::Conn.new "postgresql://user:password@host:port/dbname"
+ *   c = Pg::Conn.new "postgres://user:password@host:port/dbname"
+ *   c = Pg::Conn.new "dbname=... host=... user=..."
  *
- * Any of these parts may be omitted.  If there is no slash, the part after the
- * @ sign will be read as database name.
+ * The password may be specified as an extra parameter:
+ *
+ *   c = Pg::Conn.new "postgresql://user@host/dbname", password: "verysecret"
  *
  * If the password is the empty string, and there is either an instance method
  * or a class method <code>password?</code>, that method will be asked. This
  * method may ask <code>yield :user</code> or <code>yield :dbname</code> and so
  * on to get the connection parameters.
  *
+ *   class Pg::Conn
+ *     def password?
+ *       "tercesyrev".reverse
+ *     end
+ *   end
+ *   c = Pg::Conn.new "postgresql://user@host/dbname", password: ""
+ *
  * See the PostgreSQL documentation for a full list:
  * [http://www.postgresql.org/docs/current/interactive/libpq-connect.html#LIBPQ-PQCONNECTDBPARAMS]
  *
  * On failure, a +Pg::Error+ exception will be raised.
+ *
  */
 VALUE
 pgconn_init( int argc, VALUE *argv, VALUE self)
@@ -280,32 +282,43 @@ pgconn_init( int argc, VALUE *argv, VALUE self)
     struct pgconn_data *c;
 
     if (rb_scan_args( argc, argv, "02", &str, &params) < 2)
-        if (TYPE( str) != T_STRING) {
+        if (TYPE( str) == T_HASH) {
             params = str;
             str = Qnil;
         }
-    if      (NIL_P( params))
-        params = rb_hash_new();
-    else if (TYPE( params) != T_HASH)
-        params = rb_convert_type( params, T_HASH, "Hash", "to_hash");
-    else
-        params = rb_obj_dup( params);
-    if (!NIL_P( str))
-        connstr_to_hash( params, str);
-    connstr_passwd( self, params);
 
     Data_Get_Struct( self, struct pgconn_data, c);
 
-    l = RHASH_SIZE( params) + 1;
-    keywords = (const char **) ALLOCA_N( char *, l);
-    values   = (const char **) ALLOCA_N( char *, l);
-    ptrs[ 0] = keywords;
-    ptrs[ 1] = values;
-    ptrs[ 2] = (const char **) c;
-    st_foreach( RHASH_TBL( params), &set_connect_params, (st_data_t) ptrs);
-    *(ptrs[ 0]) = *(ptrs[ 1]) = NULL;
-
-    c->conn = PQconnectdbParams( keywords, values, 1);
+    if (NIL_P( params)) {
+        c->conn = PQconnectdb( RSTRING_PTR( rb_funcall( str, id_to_s, 0)));
+    } else {
+        int expand_dbname;
+        VALUE orig_params = params;
+
+        if (TYPE( params) != T_HASH)
+            params = rb_convert_type( params, T_HASH, "Hash", "to_hash");
+
+        if (!NIL_P( str) && NIL_P( rb_hash_aref( params, connstr_sym_dbname()))) {
+            if (params == orig_params)
+                params = rb_obj_dup( params);
+            rb_hash_aset( params, sym_dbname, str);
+            expand_dbname = 1;
+        } else
+            expand_dbname = 0;
+
+        connstr_passwd( self, orig_params, &params);
+
+        l = RHASH_SIZE( params) + 1;
+        keywords = (const char **) ALLOCA_N( char *, l);
+        values   = (const char **) ALLOCA_N( char *, l);
+        ptrs[ 0] = keywords;
+        ptrs[ 1] = values;
+        ptrs[ 2] = (const char **) c;
+        st_foreach( RHASH_TBL( params), &set_connect_params, (st_data_t) ptrs);
+        *(ptrs[ 0]) = *(ptrs[ 1]) = NULL;
+
+        c->conn = PQconnectdbParams( keywords, values, expand_dbname);
+    }
     if (PQstatus( c->conn) == CONNECTION_BAD)
         rb_exc_raise( pgconnfailederror_new( c, params));
 
@@ -331,50 +344,29 @@ set_connect_params( st_data_t key, st_data_t val, st_data_t args)
     return ST_CONTINUE;
 }
 
-static const char re_connstr[] =
-    "\\A"
-    "(?:(.*?)(?::(.*))?@)?"             /* user:passwd@     */
-    "(?:(.*?)(?::(\\d+))?/)?(?:(.+))?"  /* host:port/dbname */
-    "\\z"
-;
-
-#define KEY_USER     "user"
-#define KEY_PASSWORD "password"
-#define KEY_HOST     "host"
-#define KEY_PORT     "port"
-#define KEY_DBNAME   "dbname"
+VALUE
+connstr_sym_dbname( void)
+{
+    if (sym_dbname == Qundef)
+        sym_dbname = ID2SYM( rb_intern( "dbname"));
+    return sym_dbname;
+}
 
-void
-connstr_to_hash( VALUE params, VALUE str)
-{
-    VALUE re, match, k, m;
-
-    re = rb_reg_new( re_connstr, sizeof re_connstr - 1, 0);
-    if (RTEST( rb_reg_match( re, str))) {
-        match = rb_backref_get();
-#define ADD_TO_RES( key, n) \
-            k = ID2SYM( rb_intern( key)); m = rb_reg_nth_match( n, match); \
-            if (NIL_P( rb_hash_aref( params, k)) && !NIL_P(m)) \
-                rb_hash_aset( params, k, m)
-        ADD_TO_RES( KEY_USER,     1);
-        ADD_TO_RES( KEY_PASSWORD, 2);
-        ADD_TO_RES( KEY_HOST,     3);
-        ADD_TO_RES( KEY_PORT,     4);
-        ADD_TO_RES( KEY_DBNAME,   5);
-#undef ADD_TO_RES
-    } else
-        rb_raise( rb_eArgError, "Invalid connection: %s", RSTRING_PTR( str));
+VALUE
+connstr_sym_password( void)
+{
+    if (sym_password == Qundef)
+        sym_password = ID2SYM( rb_intern( "password"));
+    return sym_password;
 }
 
+
 void
-connstr_passwd( VALUE self, VALUE params)
+connstr_passwd( VALUE self, VALUE orig_params, VALUE *params)
 {
-    static VALUE sym_password = Qundef;
     VALUE pw;
 
-    if (sym_password == Qundef)
-        sym_password = ID2SYM( rb_intern( KEY_PASSWORD));
-    pw = rb_hash_aref( params, sym_password);
+    pw = rb_hash_aref( *params, connstr_sym_password());
     if (TYPE( pw) == T_STRING && RSTRING_LEN( pw) == 0) {
         static ID id_password_q = 0;
         VALUE pwobj;
@@ -386,14 +378,18 @@ connstr_passwd( VALUE self, VALUE params)
             pwobj = self;
         if (rb_respond_to( CLASS_OF( self), id_password_q))
             pwobj = CLASS_OF( self);
-        if (pwobj != Qundef)
-            rb_hash_aset( params, sym_password,
+        if (pwobj != Qundef) {
+            if (*params == orig_params)
+                *params = rb_obj_dup( *params);
+            rb_hash_aset( *params, sym_password,
                 rb_block_call( pwobj, id_password_q, 0, NULL,
-                                                &connstr_getparam, params));
+                                                &connstr_getparam, *params));
+        }
     }
 }
 
-VALUE connstr_getparam( VALUE yielded, VALUE params)
+VALUE
+connstr_getparam( RB_BLOCK_CALL_FUNC_ARGLIST( yielded, params))
 {
     return rb_hash_aref( params, yielded);
 }
@@ -865,7 +861,6 @@ Init_pgsql_conn( void)
     rb_define_alloc_func( rb_cPgConn, pgconn_alloc);
     rb_define_singleton_method( rb_cPgConn, "connect", pgconn_s_connect, -1);
     rb_define_alias( rb_singleton_class( rb_cPgConn), "open", "connect");
-    rb_define_singleton_method( rb_cPgConn, "parse", pgconn_s_parse, 1);
     rb_define_method( rb_cPgConn, "initialize", &pgconn_init, -1);
     rb_define_method( rb_cPgConn, "close", &pgconn_close, 0);
     rb_define_alias( rb_cPgConn, "finish", "close");
@@ -905,6 +900,8 @@ Init_pgsql_conn( void)
 
     rb_define_method( rb_cPgConn, "on_notice", &pgconn_on_notice, 0);
 
+    id_to_s = rb_intern( "to_s");
+
     Init_pgsql_conn_quote();
     Init_pgsql_conn_exec();
 }

data/lib/conn_exec.c

@@ -8,12 +8,7 @@
 #include "conn_quote.h"
 #include "result.h"
 
-
-#ifdef HAVE_FUNC_RB_ERRINFO
-    #define RB_ERRINFO (rb_errinfo())
-#else
-    #define RB_ERRINFO ruby_errinfo
-#endif
+#include <math.h>
 
 
 static void pg_raise_connexec( struct pgconn_data *c);
@@ -26,22 +21,23 @@ static void pg_parse_parameters( int argc, VALUE *argv, VALUE *cmd, VALUE *par);
 
 static VALUE pgconn_exec( int argc, VALUE *argv, VALUE obj);
 static VALUE pgconn_send( int argc, VALUE *argv, VALUE obj);
-static VALUE pgconn_fetch( VALUE obj);
+static VALUE pgconn_fetch( int argc, VALUE *argv, VALUE conn);
+static void wait_for_pgsocket( PGconn *c, VALUE to);
 static VALUE yield_or_return_result( VALUE res);
 static VALUE clear_resultqueue( VALUE self);
 
 static VALUE pgconn_query(         int argc, VALUE *argv, VALUE self);
-static VALUE pgconn_select_one(    int argc, VALUE *argv, VALUE self);
+static VALUE pgconn_select_row(    int argc, VALUE *argv, VALUE self);
 static VALUE pgconn_select_value(  int argc, VALUE *argv, VALUE self);
 static VALUE pgconn_select_values( int argc, VALUE *argv, VALUE self);
 static VALUE pgconn_get_notify( VALUE self);
 
 static VALUE pgconn_transaction( int argc, VALUE *argv, VALUE self);
-static VALUE rollback_transaction( VALUE self);
+static VALUE rollback_transaction( VALUE conn, VALUE err);
 static VALUE commit_transaction( VALUE self);
-static VALUE yield_transaction( VALUE self);
+static VALUE yield_transaction( VALUE conn);
 static VALUE pgconn_subtransaction( int argc, VALUE *argv, VALUE self);
-static VALUE rollback_subtransaction( VALUE ary);
+static VALUE rollback_subtransaction( VALUE ary, VALUE err);
 static VALUE release_subtransaction( VALUE ary);
 static VALUE yield_subtransaction( VALUE ary);
 static VALUE pgconn_transaction_status( VALUE self);
@@ -60,6 +56,7 @@ static VALUE backup_end( VALUE conn);
 
 
 static VALUE rb_ePgConnExec;
+static VALUE rb_ePgConnTimeout;
 static VALUE rb_ePgConnTrans;
 static VALUE rb_ePgConnCopy;
 
@@ -79,8 +76,7 @@ pg_statement_exec( VALUE conn, VALUE cmd, VALUE par)
     struct pgconn_data *c;
     PGresult *result;
 
-    Data_Get_Struct( conn, struct pgconn_data, c);
-    pg_check_conninvalid( c);
+    c = get_pgconn( conn);
     if (NIL_P( par))
         result = PQexec( c->conn, pgconn_destring( c, cmd, NULL));
     else {
@@ -104,8 +100,7 @@ pg_statement_send( VALUE conn, VALUE cmd, VALUE par)
     struct pgconn_data *c;
     int res;
 
-    Data_Get_Struct( conn, struct pgconn_data, c);
-    pg_check_conninvalid( c);
+    c = get_pgconn( conn);
     if (NIL_P( par))
         res = PQsendQuery( c->conn, pgconn_destring( c, cmd, NULL));
     else {
@@ -119,6 +114,7 @@ pg_statement_send( VALUE conn, VALUE cmd, VALUE par)
     }
     if (res <= 0)
         pg_raise_connexec( c);
+    PQsetSingleRowMode( c->conn);
 }
 
 char **
@@ -130,7 +126,7 @@ params_to_strings( VALUE conn, VALUE params, int *len)
     char **values, **v;
     char *a;
 
-    Data_Get_Struct( conn, struct pgconn_data, c);
+    c = get_pgconn( conn);
     ptr = RARRAY_PTR( params);
     *len = l = RARRAY_LEN( params);
     values = ALLOC_N( char *, l);
@@ -166,8 +162,6 @@ free_strings( char **strs, int len)
 void
 pg_parse_parameters( int argc, VALUE *argv, VALUE *cmd, VALUE *par)
 {
-    int len;
-
     rb_scan_args( argc, argv, "1*", cmd, par);
     StringValue( *cmd);
     if (RARRAY_LEN( *par) <= 0)
@@ -204,18 +198,29 @@ pgconn_exec( int argc, VALUE *argv, VALUE self)
  * Sends an asynchronous SQL query request specified by +sql+ to the
  * PostgreSQL server.
  *
+ * This sets the query into single row mode. You have to call +Pg::Conn#fetch+
+ * what will yield one-row results. You may cancel the delivery by breaking
+ * the loop.
+ *
  * Use Pg::Conn#fetch to fetch the results after you waited for data.
  *
  *   Pg::Conn.connect do |conn|
  *     conn.send "SELECT pg_sleep(3), * FROM t;" do
- *       ins = [ conn.socket]
- *       loop do
- *         r = IO.select ins, nil, nil, 0.5
- *         break if r
- *         puts Time.now
- *       end
- *       res = conn.fetch
- *       res.each { |w| puts w.inspect }
+ *       conn.fetch { |res|
+ *         puts res.first.inspect
+ *         break if (rand 3) < 1
+ *       }
+ *     end
+ *   end
+ *
+ * Multiple select statements will not be separated by an empty result
+ * or something similar. Query twice if you want to separate them.
+ *
+ *   Pg::Conn.connect do |conn|
+ *     conn.send "SELECT 33; SELECT 'foo';" do
+ *       conn.fetch { |res|
+ *         puts res.first.inspect
+ *       }
  *     end
  *   end
  */
@@ -231,8 +236,7 @@ pgconn_send( int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.fetch()                   -> result or nil
- *    conn.fetch() { |result| ... }  -> obj
+ *    conn.fetch( timeout = nil) { |result| ... }  -> obj
  *
  * Fetches the results of the previous Pg::Conn#send call.
  * See there for an example.
@@ -240,42 +244,105 @@ pgconn_send( int argc, VALUE *argv, VALUE self)
  * The result will be +nil+ if there are no more results.
  */
 VALUE
-pgconn_fetch( VALUE self)
+pgconn_fetch( int argc, VALUE *argv, VALUE conn)
 {
     struct pgconn_data *c;
     PGresult *result;
-    VALUE res;
+    VALUE to;
+
+    rb_scan_args( argc, argv, "01", &to);
 
-    Data_Get_Struct( self, struct pgconn_data, c);
-    pg_check_conninvalid( c);
+    c = get_pgconn( conn);
+    wait_for_pgsocket( c->conn, to);
     if (PQconsumeInput( c->conn) == 0)
         pg_raise_connexec( c);
-    if (PQisBusy( c->conn) > 0)
-        return Qnil;
-    result = PQgetResult( c->conn);
-    return result == NULL ? Qnil :
-        yield_or_return_result( pgresult_new( result, c, Qnil, Qnil));
+    if (PQisBusy( c->conn) == 0)
+        while ((result = PQgetResult( c->conn)) != NULL) {
+            if (PQntuples( result) == 0)
+                PQclear( result);
+            else
+                rb_yield( pgresult_new( result, c, Qnil, Qnil));
+        }
+    return Qnil;
+}
+
+void
+wait_for_pgsocket( PGconn *c, VALUE to)
+{
+    int fd;
+    fd_set readset;
+    struct timeval tv, *ptv;
+
+    fd = PQsocket( c);
+
+    FD_ZERO(&readset);
+    FD_SET(fd, &readset);
+
+    ptv = NULL;
+    if (!NIL_P( to)) {
+        int type = TYPE( to);
+        if (type == T_FIXNUM) {
+            tv.tv_sec = FIX2LONG( to);
+            tv.tv_usec = 0;
+        } else {
+            double x;
+            switch (type) {
+            case T_FLOAT:
+                x = RFLOAT_VALUE( to);
+                break;
+            case T_BIGNUM:
+                x = rb_big2dbl( to);
+                break;
+            case T_RATIONAL:
+                x = rb_num2dbl( to);
+                break;
+            default:
+                x = RFLOAT_VALUE( rb_funcall( to, rb_intern( "to_f"), 0));
+                break;
+            }
+            tv.tv_sec  = floor( x);
+            tv.tv_usec = round( (x-tv.tv_sec)*1000000);
+        }
+        ptv = &tv;
+    }
+
+    if (select( fd+1, &readset, NULL, NULL, ptv) < 0 || !FD_ISSET( fd, &readset))
+        rb_raise( rb_ePgConnTimeout, "Wait for data timed out.");
 }
 
 VALUE
 yield_or_return_result( VALUE result)
 {
-    struct pgresult_data *r;
-
-    Data_Get_Struct( result, struct pgresult_data, r);
     return rb_block_given_p() ?
         rb_ensure( rb_yield, result, pgresult_clear, result) : result;
 }
 
 VALUE
-clear_resultqueue( VALUE self)
+clear_resultqueue( VALUE conn)
 {
     struct pgconn_data *c;
     PGresult *result;
+    int cancelled;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
-    while ((result = PQgetResult( c->conn)) != NULL)
+    c = get_pgconn( conn);
+    cancelled = 0;
+    while ((result = PQgetResult( c->conn)) != NULL) {
         PQclear( result);
+        if (!cancelled) {
+            char errbuf[ 256];
+            PGcancel *cancel;
+            int ret;
+
+            cancel = PQgetCancel( c->conn);
+            if (cancel == NULL)
+                rb_raise( rb_ePgConnTrans, "Could not get cancel object.");
+            ret = PQcancel( cancel, errbuf, sizeof errbuf);
+            PQfreeCancel( cancel);
+            if (ret == 0)
+                rb_raise( rb_ePgConnTrans, "Cancel of sent query failed: %s", errbuf);
+            cancelled = 1;
+        }
+    }
     return Qnil;
 }
 
@@ -316,13 +383,13 @@ pgconn_query( int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *   conn.select_one( query, *bind_values)
+ *   conn.select_row( query, *bind_values)
  *
  * Return the first row of the query results.
  * Equivalent to <code>conn.query( query, *bind_values).first</code>.
  */
 VALUE
-pgconn_select_one( int argc, VALUE *argv, VALUE self)
+pgconn_select_row( int argc, VALUE *argv, VALUE self)
 {
     VALUE cmd, par;
     VALUE res;
@@ -340,7 +407,7 @@ pgconn_select_one( int argc, VALUE *argv, VALUE self)
  *   conn.select_value( query, *bind_values)
  *
  * Return the first value of the first row of the query results.
- * Equivalent to conn.query( query, *bind_values).first.first
+ * Equivalent to conn.query( query, *bind_values).first&.first
  */
 VALUE
 pgconn_select_value( int argc, VALUE *argv, VALUE self)
@@ -361,6 +428,7 @@ pgconn_select_value( int argc, VALUE *argv, VALUE self)
  * call-seq:
  *   conn.select_values( query, *bind_values)
  *
+ * Return the all values over all rows as one array.
  * Equivalent to conn.query( query, *bind_values).flatten
  */
 VALUE
@@ -399,14 +467,14 @@ pgconn_select_values( int argc, VALUE *argv, VALUE self)
  * Returns a notifier.  If there is no unprocessed notifier, it returns +nil+.
  */
 VALUE
-pgconn_get_notify( VALUE self)
+pgconn_get_notify( VALUE conn)
 {
     struct pgconn_data *c;
     PGnotify *notify;
     VALUE rel, pid, ext;
     VALUE ret;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( conn);
     if (PQconsumeInput( c->conn) == 0)
         pg_raise_connexec( c);
     notify = PQnotifies( c->conn);
@@ -435,7 +503,7 @@ pgconn_get_notify( VALUE self)
  *
  */
 VALUE
-pgconn_transaction( int argc, VALUE *argv, VALUE self)
+pgconn_transaction( int argc, VALUE *argv, VALUE conn)
 {
     struct pgconn_data *c;
     VALUE ser, ro;
@@ -443,50 +511,50 @@ pgconn_transaction( int argc, VALUE *argv, VALUE self)
     int p;
 
     rb_scan_args( argc, argv, "02", &ser, &ro);
-    cmd = rb_str_buf_new2( "begin");
+    cmd = rb_str_buf_new2( "BEGIN");
     p = 0;
     if (!NIL_P( ser)) {
-        rb_str_buf_cat2( cmd, " isolation level ");
-        rb_str_buf_cat2( cmd, RTEST(ser) ? "serializable" : "read committed");
+        rb_str_buf_cat2( cmd, " ISOLATION LEVEL ");
+        rb_str_buf_cat2( cmd, RTEST(ser) ? "SERIALIZABLE" : "READ COMMITTED");
         p++;
     }
     if (!NIL_P( ro)) {
         if (p) rb_str_buf_cat2( cmd, ",");
-        rb_str_buf_cat2( cmd, " read ");
-        rb_str_buf_cat2( cmd, (RTEST(ro)  ? "only" : "write"));
+        rb_str_buf_cat2( cmd, " READ ");
+        rb_str_buf_cat2( cmd, (RTEST(ro)  ? "ONLY" : "WRITE"));
     }
     rb_str_buf_cat2( cmd, ";");
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( conn);
     if (PQtransactionStatus( c->conn) > PQTRANS_IDLE)
         rb_raise( rb_ePgConnTrans,
             "Nested transaction block. Use Conn#subtransaction.");
-    pgresult_clear( pg_statement_exec( self, cmd, Qnil));
-    return rb_ensure( yield_transaction, self, commit_transaction, self);
+    pgresult_clear( pg_statement_exec( conn, cmd, Qnil));
+    return rb_ensure( yield_transaction, conn, commit_transaction, conn);
 }
 
 VALUE
-yield_transaction( VALUE self)
+yield_transaction( VALUE conn)
 {
-    return rb_rescue( rb_yield, self, rollback_transaction, self);
+    return rb_rescue( rb_yield, conn, rollback_transaction, conn);
 }
 
 VALUE
-rollback_transaction( VALUE self)
+rollback_transaction( VALUE conn, VALUE err)
 {
-    pgresult_clear( pg_statement_exec( self, rb_str_new2( "ROLLBACK;"), Qnil));
-    rb_exc_raise( RB_ERRINFO);
+    pgresult_clear( pg_statement_exec( conn, rb_str_new2( "ROLLBACK;"), Qnil));
+    rb_exc_raise( err);
     return Qnil;
 }
 
 VALUE
-commit_transaction( VALUE self)
+commit_transaction( VALUE conn)
 {
     struct pgconn_data *c;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( conn);
     if (PQtransactionStatus( c->conn) > PQTRANS_IDLE)
-        pgresult_clear( pg_statement_exec( self, rb_str_new2( "COMMIT;"), Qnil));
+        pgresult_clear( pg_statement_exec( conn, rb_str_new2( "COMMIT;"), Qnil));
     return Qnil;
 }
 
@@ -508,13 +576,13 @@ pgconn_subtransaction( int argc, VALUE *argv, VALUE self)
     char *p;
     int n;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     a = rb_scan_args( argc, argv, "1*", &sp, &par);
     StringValue( sp);
     if (a > 1)
         sp = rb_str_format(RARRAY_LEN(par), RARRAY_PTR(par), sp);
 
-    cmd = rb_str_buf_new2( "savepoint ");
+    cmd = rb_str_buf_new2( "SAVEPOINT ");
     q = pgconn_destring( c, sp, &n);
     p = PQescapeIdentifier( c->conn, q, n);
     rb_str_buf_cat2( cmd, p);
@@ -533,16 +601,16 @@ yield_subtransaction( VALUE ary)
 }
 
 VALUE
-rollback_subtransaction( VALUE ary)
+rollback_subtransaction( VALUE ary, VALUE err)
 {
     VALUE cmd;
 
-    cmd = rb_str_buf_new2( "rollback to savepoint ");
+    cmd = rb_str_buf_new2( "ROLLBACK TO SAVEPOINT ");
     rb_str_buf_append( cmd, rb_ary_entry( ary, 1));
     rb_str_buf_cat2( cmd, ";");
     pgresult_clear( pg_statement_exec( rb_ary_entry( ary, 0), cmd, Qnil));
     rb_ary_store( ary, 1, Qnil);
-    rb_exc_raise( RB_ERRINFO);
+    rb_exc_raise( err);
     return Qnil;
 }
 
@@ -554,7 +622,7 @@ release_subtransaction( VALUE ary)
 
     n = rb_ary_entry( ary, 1);
     if (!NIL_P( n)) {
-        cmd = rb_str_buf_new2( "release savepoint ");
+        cmd = rb_str_buf_new2( "RELEASE SAVEPOINT ");
         rb_str_buf_append( cmd, n);
         rb_str_buf_cat2( cmd, ";");
         pgresult_clear( pg_statement_exec( rb_ary_entry( ary, 0), cmd, Qnil));
@@ -582,7 +650,7 @@ pgconn_transaction_status( VALUE self)
 {
     struct pgconn_data *c;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     return INT2FIX( PQtransactionStatus( c->conn));
 }
 
@@ -597,7 +665,7 @@ pgconn_transaction_status( VALUE self)
  *
  *   conn.copy_stdin "COPY t FROM STDIN;" do
  *      ary = ...
- *      l = stringize_line ary
+ *      l = conn.stringize_line ary
  *      conn.put l
  *   end
  *
@@ -622,10 +690,10 @@ put_end( VALUE self)
     int r;
     PGresult *res;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     /*
      * I would like to hand over something like
-     *     RSTRING_PTR( rb_obj_as_string( RB_ERRINFO))
+     *     RSTRING_PTR( rb_obj_as_string( rb_errinfo()))
      * here but when execution is inside a rescue block
      * the error info will be non-null even though the
      * exception just has been caught.
@@ -682,7 +750,7 @@ pgconn_putline( VALUE self, VALUE arg)
         str = t;
     }
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     p = pgconn_destring( c, str, &l);
     r = PQputCopyData( c->conn, p, l);
     if (r < 0)
@@ -734,7 +802,7 @@ get_end( VALUE self)
     struct pgconn_data *c;
     PGresult *res;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     if ((res = PQgetResult( c->conn)) != NULL)
         pgresult_new( res, c, Qnil, Qnil);
     return Qnil;
@@ -765,7 +833,7 @@ pgconn_getline( int argc, VALUE *argv, VALUE self)
 
     async = rb_scan_args( argc, argv, "01", &as) > 0 && !NIL_P( as) ? 1 : 0;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     r = PQgetCopyData( c->conn, &b, async);
     if (r > 0) {
         VALUE ret;
@@ -799,7 +867,7 @@ pgconn_each_line( VALUE self)
     int r;
     VALUE s;
 
-    Data_Get_Struct( self, struct pgconn_data, c);
+    c = get_pgconn( self);
     for (; (r = PQgetCopyData( c->conn, &b, 0)) > 0;) {
         s = pgconn_mkstringn( c, b, r);
         PQfreemem( b);
@@ -869,16 +937,17 @@ Init_pgsql_conn_exec( void)
     rb_cPgConn = rb_define_class_under( rb_mPg, "Conn", rb_cObject);
 #endif
 
-    rb_ePgConnExec  = rb_define_class_under( rb_cPgConn, "ExecError",        rb_ePgError);
-    rb_ePgConnTrans = rb_define_class_under( rb_cPgConn, "TransactionError", rb_ePgError);
-    rb_ePgConnCopy  = rb_define_class_under( rb_cPgConn, "CopyError",        rb_ePgError);
+    rb_ePgConnExec    = rb_define_class_under( rb_cPgConn, "ExecError",        rb_ePgError);
+    rb_ePgConnTimeout = rb_define_class_under( rb_cPgConn, "Timeout",          rb_ePgError);
+    rb_ePgConnTrans   = rb_define_class_under( rb_cPgConn, "TransactionError", rb_ePgError);
+    rb_ePgConnCopy    = rb_define_class_under( rb_cPgConn, "CopyError",        rb_ePgError);
 
     rb_define_method( rb_cPgConn, "exec", &pgconn_exec, -1);
     rb_define_method( rb_cPgConn, "send", &pgconn_send, -1);
-    rb_define_method( rb_cPgConn, "fetch", &pgconn_fetch, 0);
+    rb_define_method( rb_cPgConn, "fetch", &pgconn_fetch, -1);
 
     rb_define_method( rb_cPgConn, "query", &pgconn_query, -1);
-    rb_define_method( rb_cPgConn, "select_one", &pgconn_select_one, -1);
+    rb_define_method( rb_cPgConn, "select_row", &pgconn_select_row, -1);
     rb_define_method( rb_cPgConn, "select_value", &pgconn_select_value, -1);
     rb_define_method( rb_cPgConn, "select_values", &pgconn_select_values, -1);
     rb_define_method( rb_cPgConn, "get_notify", &pgconn_get_notify, 0);
@@ -908,6 +977,6 @@ Init_pgsql_conn_exec( void)
 
     rb_define_method( rb_cPgConn, "backup", &pgconn_backup, 1);
 
-    ID id_to_a = 0;
+    id_to_a = 0;
 }
 

data/lib/conn_quote.c

@@ -23,7 +23,8 @@ extern VALUE pgconn_for_copy( VALUE self, VALUE str);
 static int   needs_dquote_string( VALUE str);
 static VALUE dquote_string( VALUE str);
 static VALUE stringize_array( VALUE self, VALUE result, VALUE ary);
-static VALUE gsub_escape_i( VALUE c, VALUE arg);
+static VALUE gsub_escape_i( RB_BLOCK_CALL_FUNC_ARGLIST( c, arg));
+
 
 static VALUE pgconn_quote( VALUE self, VALUE obj);
 static VALUE pgconn_quote_all( int argc, VALUE *argv, VALUE self);
@@ -199,11 +200,11 @@ pgconn_unescape_bytea( VALUE self, VALUE obj)
     size_t l;
     VALUE ret;
 
-    if (NIL_P( obj))
-        return Qnil;
 #ifdef RUBY_ENCODING
     rb_scan_args( argc, argv, "11", &obj, &enc);
 #endif
+    if (NIL_P( obj))
+        return Qnil;
     StringValue( obj);
 
     s = PQunescapeBytea( (unsigned char *) RSTRING_PTR( obj), &l);
@@ -319,7 +320,7 @@ pgconn_stringize_line( VALUE self, VALUE ary)
     VALUE a;
     VALUE *p;
     int l;
-    VALUE ret, s;
+    VALUE ret;
 
     a = rb_check_convert_type( ary, T_ARRAY, "Array", "to_ary");
     if (NIL_P(a))
@@ -411,13 +412,13 @@ dquote_string( VALUE str)
 VALUE
 stringize_array( VALUE self, VALUE result, VALUE ary)
 {
-    long i, j;
+    long i;
     VALUE *o;
     VALUE cf, co;
     VALUE r;
 
     cf = Qundef;
-    for (o = RARRAY_PTR( ary), j = RARRAY_LEN( ary); j; ++o, --j) {
+    for (o = RARRAY_PTR( ary), i = RARRAY_LEN( ary); i; ++o, --i) {
         co = CLASS_OF( *o);
         if (cf == Qundef)
             cf = co;
@@ -438,7 +439,7 @@ stringize_array( VALUE self, VALUE result, VALUE ary)
 
 
 VALUE
-gsub_escape_i( VALUE c, VALUE arg)
+gsub_escape_i( RB_BLOCK_CALL_FUNC_ARGLIST( c, arg))
 {
     const char *r;
 
@@ -471,7 +472,7 @@ gsub_escape_i( VALUE c, VALUE arg)
  * This method is to prevent you from saying something like <code>"insert into
  * ... (E'#{conn.stringize obj}', ...);"</code>.  It is more efficient to say
  *
- *   conn.exec "insert into ... (#{conn.quote obj}, ...);"
+ *   conn.exec "INSERT INTO ... (#{conn.quote obj}, ...);"
  *
  * Your self-defined classes will be checked whether they have a method named
  * +to_postgres+.  If that doesn't exist the object will be converted by
@@ -516,25 +517,25 @@ VALUE pgconn_quote( VALUE self, VALUE obj)
                 co = CLASS_OF( obj);
                 if        (co == rb_cTime) {
                     res = rb_funcall( obj, id_iso8601, 0);
-                    type = "timestamptz";
+                    type = "TIMESTAMPTZ";
                 } else if (co == rb_cDate) {
                     res = rb_obj_as_string( obj);
-                    type = "date";
+                    type = "DATE";
                 } else if (co == rb_cDateTime) {
                     res = rb_obj_as_string( obj);
-                    type = "timestamptz";
+                    type = "TIMESTAMPTZ";
                 } else if (co == pg_monetary_class() &&
                                     rb_respond_to( obj, id_raw)) {
                     res = rb_funcall( obj, id_raw, 0);
                     StringValue( res);
-                    type = "money";
+                    type = "MONEY";
                 } else if (rb_respond_to( obj, id_to_postgres)) {
                     res = rb_funcall( obj, id_to_postgres, 0);
                     StringValue( res);
                     type = NULL;
                 } else {
                     res = rb_obj_as_string( obj);
-                    type = "unknown";
+                    type = "UNKNOWN";
                 }
                 res = quote_string( self, res);
                 if (type != NULL) {
@@ -584,12 +585,12 @@ quote_string( VALUE conn, VALUE str)
 VALUE
 quote_array( VALUE self, VALUE result, VALUE ary)
 {
-    long i, j;
+    long i;
     VALUE *o;
     VALUE cf, co;
 
     cf = Qundef;
-    for (o = RARRAY_PTR( ary), j = RARRAY_LEN( ary); j; ++o, --j) {
+    for (o = RARRAY_PTR( ary), i = RARRAY_LEN( ary); i; ++o, --i) {
         co = CLASS_OF( *o);
         if (cf == Qundef)
             cf = co;

data/lib/mkrf_conf

@@ -10,27 +10,19 @@ Autorake.configure {
 
   extending_ruby
 
-  if RUBY_VERSION < "1.9" then
-    have_header "ruby.h"
-    have_header "rubyio.h"
-    have_header "st.h"
-  else
-    have_header "ruby/ruby.h"
-    have_header "ruby/io.h"
-  end
+  need_header "ruby/ruby.h"
+  need_header "ruby/io.h"
+
 
   incdir :postgres,        `pg_config --pkgincludedir`
   incdir :postgres_server, `pg_config --includedir-server`
 
-  have_library "crypto"
-  have_library "ssl"
-  have_library "pq"
+  need_library "pq"
 
-  have_header "postgres.h"
-  have_header "libpq-fe.h"
-  have_header "catalog/pg_type.h"
+  need_header "postgres.h"
+  need_header "libpq-fe.h"
+  need_header "catalog/pg_type.h"
 
-  have_func "rb_errinfo"
   have_func "rb_io_stdio_file"
   have_func "rb_locale_encoding"
 

data/lib/module.c

@@ -8,7 +8,7 @@
 #include "result.h"
 
 
-#define PGSQL_VERSION "1.5.1"
+#define PGSQL_VERSION "1.9"
 
 
 VALUE rb_mPg;

data/lib/module.h

@@ -18,15 +18,9 @@
 #endif
 #include "undef.h"
 
-#ifdef HAVE_HEADER_POSTGRES_H
-    #include <postgres.h>
-#endif
-#ifdef HAVE_HEADER_LIBPQ_FE_H
-    #include <libpq-fe.h>
-#endif
-#ifdef HAVE_HEADER_CATALOG_PG_TYPE_H
-    #include <catalog/pg_type.h>
-#endif
+#include <postgres.h>
+#include <libpq-fe.h>
+#include <catalog/pg_type.h>
 #include "undef.h"
 
 

data/lib/result.c

@@ -11,9 +11,6 @@
 static void pgresult_init( struct pgresult_data *r, PGresult *result, struct pgconn_data *conn);
 static VALUE pgreserror_new( VALUE result, VALUE cmd, VALUE par);
 
-static VALUE pgreserror_command( VALUE self);
-static VALUE pgreserror_params(  VALUE self);
-
 static struct pgresult_data *pgreserror_result( VALUE self);
 static VALUE pgreserror_status(  VALUE self);
 static VALUE pgreserror_sqlst(   VALUE self);
@@ -25,7 +22,6 @@ static VALUE pgreserror_diag(    VALUE self, VALUE field);
 
 static VALUE pgresult_s_translate_results_set( VALUE cls, VALUE fact);
 
-static void pgresult_mark( struct pgresult_data *ptr);
 static void pgresult_free( struct pgresult_data *ptr);
 extern VALUE pgresult_new( PGresult *result, struct pgconn_data *conn, VALUE cmd, VALUE par);
 
@@ -214,13 +210,6 @@ pgresult_s_translate_results_set( VALUE cls, VALUE fact)
 
 
 
-void
-pgresult_mark( struct pgresult_data *ptr)
-{
-    rb_gc_mark( ptr->fields);
-    rb_gc_mark( ptr->indices);
-}
-
 void
 pgresult_free( struct pgresult_data *ptr)
 {
@@ -252,6 +241,8 @@ pgresult_new( PGresult *result, struct pgconn_data *conn, VALUE cmd, VALUE par)
         case PGRES_TUPLES_OK:
         case PGRES_COPY_OUT:
         case PGRES_COPY_IN:
+        case PGRES_COPY_BOTH:
+        case PGRES_SINGLE_TUPLE:
             break;
         case PGRES_BAD_RESPONSE:
         case PGRES_NONFATAL_ERROR:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgsql
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: '1.9'
 platform: ruby
 authors:
 - Bertram Scharpf
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-13 00:00:00.000000000 Z
+date: 2021-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autorake
@@ -55,7 +55,7 @@ homepage: http://www.bertram-scharpf.de/software/pgsql
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README
@@ -73,8 +73,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - PostgreSQL
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: PostgreSQL-API for Ruby
 test_files: []