pgsql 1.8 → 1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9774f4721fba4301276843fea1a5287083234d0aadf8947559b08e2619a97e7
-  data.tar.gz: b6df52ab912e62f814770c339cce1de5444f41c249869a6edf3e069dd6be7132
+  metadata.gz: 2519cf85dd607a31191b7992cc99a93c31fb0b1103a38462f28cd77081599f0c
+  data.tar.gz: 026e108f08ffa63454f29504120c04f8fe8b3b1ffb664bd4626e7ca9f98f078a
 SHA512:
-  metadata.gz: 908112734acf984c86746934cea2471a702e0eeb7b93a5bf39b4abbd640eae9cb962788da168396919994429fce7d6cbfe04c3b6834e8bb5bd5a845d2a248ace
-  data.tar.gz: c4ac1fe22fca378f9e321f6fbc33bbd3371d0e7e831321c9ad496ce673d7a7d120a8527c31f07696a66ffa0d7c35ec760540e6954ed8c013db233056d60d3197
+  metadata.gz: 608f44789a6b5c009558c75b1d37f71fd2b86d283c2b78bf361d76bf3d7bb37065b6426a26f7ecb7d97829b3b31e4e7cf4a0f53453e11fc7327a914d2d65ca8c
+  data.tar.gz: 5e4e1fe2084fb5ba67646128d145de12840ad66c3fd54e0b22e65ea150c0d16444fc157ff19f61864fe048dd1eca4b3d7731ca8411376708ac81a2c7114b9774

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);
 
@@ -19,7 +21,8 @@ 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);
 
@@ -30,9 +33,9 @@ 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,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;
 
@@ -72,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 {
@@ -97,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 {
@@ -112,6 +114,7 @@ pg_statement_send( VALUE conn, VALUE cmd, VALUE par)
     }
     if (res <= 0)
         pg_raise_connexec( c);
+    PQsetSingleRowMode( c->conn);
 }
 
 char **
@@ -123,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);
@@ -195,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
  */
@@ -222,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.
@@ -231,20 +244,70 @@ 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 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
@@ -255,14 +318,31 @@ yield_or_return_result( VALUE 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;
 }
 
@@ -387,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);
@@ -423,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;
@@ -431,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, 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;
 }
 
@@ -496,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);
@@ -525,7 +605,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));
@@ -542,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));
@@ -570,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));
 }
 
@@ -585,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
  *
@@ -610,7 +690,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()))
@@ -670,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)
@@ -722,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;
@@ -753,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;
@@ -787,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);
@@ -857,13 +937,14 @@ 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_row", &pgconn_select_row, -1);

data/lib/conn_quote.c

@@ -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.8"
+#define PGSQL_VERSION "1.9"
 
 
 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.8'
+  version: '1.9'
 platform: ruby
 authors:
 - Bertram Scharpf
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-11 00:00:00.000000000 Z
+date: 2021-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autorake