pgsql 1.6 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5906425e386ca8404df02a1d14dec2ec92e730cabd03c8192f624112d537c3d2
-  data.tar.gz: 5bc40a7923bc2076aef6cdd8a2af71b679f01bee63fed44bbc475bf8e3a12dbb
+  metadata.gz: d735e83feb39d55f95efc1a196d433800c523fd0e73538b2c6415edd098f405c
+  data.tar.gz: e8e6e0b0526a73de32bf227effe13337ef125ea9f69d05099401aae4455c4288
 SHA512:
-  metadata.gz: a32d74928d3a5c2d04dd30d4453e11a346ce7f4bb24db40665d375776b6caa89dabed59fa87774ab52fdb1d09a9d37e3e8eca13118e04a35572c33c8e827856c
-  data.tar.gz: c405985704ae2c8a1bb52d957965a9b6ad4811bec41fe9785b3c56dba79c463fe1569ab27426a5853bfb1c5dfea4b10ae85505f7944bf5f6cdb6a0595174b895
+  metadata.gz: bbccf68542f27fc341ed1b517109655d5dd96b9d8cb21ac94e9d874f54d40eec9b3f50652967bb592cf04da68804c1351e01598ab8e4f3487ecc50b706dee65a
+  data.tar.gz: 388001a630086ddb47acb19672291ebe1cbd95f0349038e97189ff676e246047c4ce055bc726d065a9aea399cfdf1ff8d1e62d293178ebc6b8c131b10e4b951a

data/lib/Rakefile

@@ -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,11 +26,11 @@ 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_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);
@@ -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,10 +378,13 @@ 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));
+        }
     }
 }
 
@@ -866,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");
@@ -906,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,6 +8,8 @@
 #include "conn_quote.h"
 #include "result.h"
 
+#include <math.h>
+
 
 static void pg_raise_connexec( struct pgconn_data *c);
 
@@ -18,21 +20,24 @@ static void free_strings( char **strs, int len);
 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 yield_or_return_result( VALUE res);
+static VALUE pgconn_send( int argc, VALUE *argv, VALUE obj);
+static VALUE pgconn_fetch( int argc, VALUE *argv, VALUE conn);
+static void wait_for_pgsocket( PGconn *c, VALUE to);
 static VALUE clear_resultqueue( VALUE self);
+static VALUE pgconn_fetch_rows( int argc, VALUE *argv, VALUE conn);
+static VALUE fetch_result_each( RB_BLOCK_CALL_FUNC_ARGLIST( res, arg));
 
 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, VALUE err);
+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, VALUE err);
 static VALUE release_subtransaction( VALUE ary);
@@ -53,10 +58,12 @@ static VALUE backup_end( VALUE conn);
 
 
 static VALUE rb_ePgConnExec;
+static VALUE rb_ePgConnTimeout;
 static VALUE rb_ePgConnTrans;
 static VALUE rb_ePgConnCopy;
 
 static ID id_to_a;
+static ID id_fetch;
 
 
 void
@@ -72,8 +79,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 {
@@ -97,8 +103,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 {
@@ -112,6 +117,7 @@ pg_statement_send( VALUE conn, VALUE cmd, VALUE par)
     }
     if (res <= 0)
         pg_raise_connexec( c);
+    PQsetSingleRowMode( c->conn);
 }
 
 char **
@@ -123,7 +129,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);
@@ -187,6 +193,13 @@ pgconn_exec( int argc, VALUE *argv, VALUE self)
     return yield_or_return_result( res);
 }
 
+VALUE
+yield_or_return_result( VALUE result)
+{
+    return rb_block_given_p() ?
+        rb_ensure( rb_yield, result, pgresult_clear, result) : result;
+}
+
 
 /*
  * call-seq:
@@ -195,18 +208,28 @@ 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 be separated by an empty result.
+ *
+ *   Pg::Conn.connect do |conn|
+ *     conn.send "SELECT 33; SELECT 'foo';" do
+ *       conn.fetch { |res|
+ *         puts res.first.inspect
+ *       }
  *     end
  *   end
  */
@@ -222,51 +245,140 @@ 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.
  *
- * 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 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) {
+            VALUE res;
+
+            res = pgresult_new( result, c, Qnil, Qnil);
+            rb_ensure( rb_yield, res, pgresult_clear, res);
+        }
+    return Qnil;
 }
 
-VALUE
-yield_or_return_result( VALUE result)
-{
-    return rb_block_given_p() ?
-        rb_ensure( rb_yield, result, pgresult_clear, result) : result;
+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
-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;
 }
 
 
+/*
+ * call-seq:
+ *    conn.fetch_rows( timeout = nil) { |row| ... }  -> obj
+ *
+ * Fetches the results of the previous Pg::Conn#send call as an array.
+ *
+ * Multiple select statements will _not_ be separated by an empty array or
+ * something similar. Query twice or call +#fetch+ if you want to separate
+ * them.
+ *
+ *   Pg::Conn.connect do |conn|
+ *     conn.send "SELECT 33; SELECT 'foo';" do
+ *       conn.fetch { |row|
+ *         puts row.inspect
+ *       }
+ *     end
+ *   end
+ */
+VALUE
+pgconn_fetch_rows( int argc, VALUE *argv, VALUE conn)
+{
+    if (!id_fetch)
+        id_fetch = rb_intern( "fetch");
+    return rb_block_call( conn, id_fetch, argc, argv, fetch_result_each, Qnil);
+}
+
+VALUE
+fetch_result_each( RB_BLOCK_CALL_FUNC_ARGLIST( res, arg))
+{
+    return pgresult_each( res);
+}
 
 
 /*
@@ -303,13 +415,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;
@@ -327,7 +439,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)
@@ -348,6 +460,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
@@ -386,14 +499,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);
@@ -422,7 +535,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;
@@ -430,50 +543,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, VALUE err)
+rollback_transaction( VALUE conn, VALUE err)
 {
-    pgresult_clear( pg_statement_exec( self, rb_str_new2( "ROLLBACK;"), Qnil));
+    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;
 }
 
@@ -495,13 +608,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);
@@ -524,7 +637,7 @@ 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));
@@ -541,7 +654,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));
@@ -569,7 +682,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));
 }
 
@@ -584,7 +697,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
  *
@@ -609,7 +722,7 @@ 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()))
@@ -669,7 +782,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)
@@ -721,7 +834,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;
@@ -752,7 +865,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;
@@ -786,7 +899,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);
@@ -856,16 +969,18 @@ 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, "fetch_rows", &pgconn_fetch_rows, -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);
@@ -895,6 +1010,7 @@ Init_pgsql_conn_exec( void)
 
     rb_define_method( rb_cPgConn, "backup", &pgconn_backup, 1);
 
-    id_to_a = 0;
+    id_to_a  = 0;
+    id_fetch = 0;
 }
 

data/lib/conn_quote.c

@@ -355,7 +355,7 @@ pgconn_for_copy( VALUE self, VALUE obj)
             rb_global_variable( &pg_escape_regex);
         }
         if (RTEST( rb_reg_match( pg_escape_regex, ret)))
-            ret = rb_block_call( ret, id_gsub, 1, &pg_escape_regex, gsub_escape_i, Qnil);
+            ret = rb_block_call( ret, id_gsub, 1, &pg_escape_regex, &gsub_escape_i, Qnil);
     }
     return ret;
 }
@@ -472,7 +472,7 @@ gsub_escape_i( RB_BLOCK_CALL_FUNC_ARGLIST( c, 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
@@ -517,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) {

data/lib/module.c

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

data/lib/result.c

@@ -241,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.6'
+  version: 1.9.1
 platform: ruby
 authors:
 - Bertram Scharpf
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autorake