ruby-pg 0.7.9.2008.01.08 → 0.7.9.2008.01.24

data/ext/compat.c

@@ -12,189 +12,225 @@
   $Date: 2007-12-04 14:25:44 -0800 (Tue, 04 Dec 2007) $
 ************************************************/
 
+#include <ctype.h>
 #include "compat.h"
 
-#ifndef HAVE_PQDESCRIBEPREPARED
+#ifdef PG_BEFORE_080300
+int
+PQconnectionNeedsPassword(PGconn *conn)
+{
+	rb_raise(rb_eStandardError, 
+		"PQconnectionNeedsPassword not supported by this client version.");
+}
+
+int
+PQconnectionUsedPassword(PGconn *conn)
+{
+	rb_raise(rb_eStandardError, 
+		"PQconnectionUsedPassword not supported by this client version.");
+}
+
+int
+lo_truncate(PGconn *conn, int fd, size_t len)
+{
+	rb_raise(rb_eStandardError, "lo_truncate not supported by this client version.");
+}
+#endif /* PG_BEFORE_080300 */
+
+#ifdef PG_BEFORE_080200
+int
+PQisthreadsafe()
+{
+	return Qfalse;
+}
+
+int
+PQnparams(const PGresult *res)
+{
+	rb_raise(rb_eStandardError, "PQnparams not supported by this client version.");
+}
+
+Oid
+PQparamtype(const PGresult *res, int param_number)
+{
+	rb_raise(rb_eStandardError, "PQparamtype not supported by this client version.");
+}
+
 PGresult *
 PQdescribePrepared(PGconn *conn, const char *stmtName)
 {
 	rb_raise(rb_eStandardError, "PQdescribePrepared not supported by this client version.");
 }
-#endif /* HAVE_PQDESCRIBEPREPARED */
 
-#ifndef HAVE_PQDESCRIBEPORTAL
 PGresult *
 PQdescribePortal(PGconn *conn, const char *portalName)
 {
 	rb_raise(rb_eStandardError, "PQdescribePortal not supported by this client version.");
 }
-#endif /* HAVE_PQDESCRIBEPORTAL */
 
-#ifndef HAVE_PQESCAPESTRINGCONN
-size_t
-PQescapeStringConn(PGconn *conn, char *to, const char *from, 
-	size_t length, int *error)
+int
+PQsendDescribePrepared(PGconn *conn, const char *stmtName)
 {
-	return PQescapeString(to,from,length);
+	rb_raise(rb_eStandardError, "PQsendDescribePrepared not supported by this client version.");
 }
 
-unsigned char *
-PQescapeByteaConn(PGconn *conn, const unsigned char *from, 
-	size_t from_length, size_t *to_length)
+int
+PQsendDescribePortal(PGconn *conn, const char *portalName)
 {
-	return PQescapeBytea(from, from_length, to_length);
+	rb_raise(rb_eStandardError, "PQsendDescribePortal not supported by this client version.");
 }
-#endif /* HAVE_PQESCAPESTRINGCONN */
 
-#ifndef HAVE_PQPREPARE
+char *
+PQencryptPassword(const char *passwd, const char *user)
+{
+	rb_raise(rb_eStandardError, "PQencryptPassword not supported by this client version.");
+}
+#endif /* PG_BEFORE_080200 */
+
+#ifdef PG_BEFORE_080100
+Oid
+lo_create(PGconn *conn, Oid lobjId)
+{
+	rb_raise(rb_eStandardError, "lo_create not supported by this client version.");
+}
+#endif /* PG_BEFORE_080100 */
+
+#ifdef PG_BEFORE_080000
 PGresult *
 PQprepare(PGconn *conn, const char *stmtName, const char *query,
 	int nParams, const Oid *paramTypes)
 {
 	rb_raise(rb_eStandardError, "PQprepare not supported by this client version.");
 }
-#endif /* HAVE_PQPREPARE */
 
-#ifndef HAVE_PQCONNECTIONNEEDSPASSWORD
 int
-PQconnectionNeedsPassword(PGconn *conn)
+PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes)
 {
-	rb_raise(rb_eStandardError, 
-		"PQconnectionNeedsPassword not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQsendPrepare not supported by this client version.");
 }
-#endif /* HAVE_PQCONNECTIONUSEDPASSWORD */
 
-#ifndef HAVE_PQCONNECTIONUSEDPASSWORD
 int
-PQconnectionUsedPassword(PGconn *conn)
+PQserverVersion(const PGconn* conn)
 {
-	rb_raise(rb_eStandardError, 
-		"PQconnectionUsedPassword not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQserverVersion not supported by this client version.");
 }
-#endif /* HAVE_PQCONNECTIONUSEDPASSWORD */
+#endif /* PG_BEFORE_080000 */
 
-#ifndef HAVE_PQISTHREADSAFE
-int
-PQisthreadsafe()
+#ifdef PG_BEFORE_070400
+PGresult *
+PQexecParams(PGconn *conn, const char *command, int nParams, 
+	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
+	const int *paramFormats, int resultFormat)
 {
-	return Qfalse;
+	rb_raise(rb_eStandardError, "PQexecParams not supported by this client version.");
+}
+
+PGTransactionStatusType 
+PQtransactionStatus(const PGconn *conn)
+{
+	rb_raise(rb_eStandardError, "PQtransactionStatus not supported by this client version.");
+}
+
+char *
+PQparameterStatus(const PGconn *conn, const char *paramName)
+{
+	rb_raise(rb_eStandardError, "PQparameterStatus not supported by this client version.");
 }
-#endif /* HAVE_PQISTHREADSAFE */
 
-#ifndef HAVE_LO_TRUNCATE
 int
-lo_truncate(PGconn *conn, int fd, size_t len)
+PQprotocolVersion(const PGconn *conn)
 {
-	rb_raise(rb_eStandardError, "lo_truncate not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQprotocolVersion not supported by this client version.");
 }
-#endif /* HAVE_LO_TRUNCATE */
 
-#ifndef HAVE_LO_CREATE
-Oid
-lo_create(PGconn *conn, Oid lobjId)
+PGresult
+*PQexecPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat)
 {
-	rb_raise(rb_eStandardError, "lo_create not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQexecPrepared not supported by this client version.");
 }
-#endif /* HAVE_LO_CREATE */
 
-#ifndef HAVE_PQNPARAMS
 int
-PQnparams(const PGresult *res)
+PQsendQueryParams(PGconn *conn, const char *command, int nParams,
+	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
+	const int *paramFormats, int resultFormat)
 {
-	rb_raise(rb_eStandardError, "PQnparams not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQsendQueryParams not supported by this client version.");
 }
-#endif /* HAVE_PQNPARAMS */
 
-#ifndef HAVE_PQPARAMTYPE
-Oid
-PQparamtype(const PGresult *res, int param_number)
+int
+PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat)
 {
-	rb_raise(rb_eStandardError, "PQparamtype not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQsendQueryPrepared not supported by this client version.");
 }
-#endif /* HAVE_PQPARAMTYPE */
 
-#ifndef HAVE_PQSERVERVERSION
 int
-PQserverVersion(const PGconn* conn)
+PQputCopyData(PGconn *conn, const char *buffer, int nbytes)
 {
-	rb_raise(rb_eStandardError, "PQserverVersion not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQputCopyData not supported by this client version.");
 }
-#endif /* HAVE_PQSERVERVERSION */
 
-#ifndef HAVE_PQSENDDESCRIBEPREPARED
 int
-PQsendDescribePrepared(PGconn *conn, const char *stmtName)
+PQputCopyEnd(PGconn *conn, const char *errormsg)
 {
-	rb_raise(rb_eStandardError, "PQsendDescribePrepared not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQputCopyEnd not supported by this client version.");
 }
-#endif /* HAVE_PQSENDDESCRIBEPREPARED */
 
-#ifndef HAVE_PQSENDDESCRIBEPORTAL
 int
-PQsendDescribePortal(PGconn *conn, const char *portalName)
+PQgetCopyData(PGconn *conn, char **buffer, int async)
 {
-	rb_raise(rb_eStandardError, "PQsendDescribePortal not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQgetCopyData not supported by this client version.");
+}
+
+PGVerbosity
+PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity)
+{
+	rb_raise(rb_eStandardError, "PQsetErrorVerbosity not supported by this client version.");
+}
+
+Oid
+PQftable(const PGresult *res, int column_number)
+{
+	rb_raise(rb_eStandardError, "PQftable not supported by this client version.");
 }
-#endif /* HAVE_PQSENDDESCRIBEPORTAL */
 
-#ifndef HAVE_PQSENDPREPARE
 int
-PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
-	int nParams, const Oid *paramTypes)
+PQftablecol(const PGresult *res, int column_number)
 {
-	rb_raise(rb_eStandardError, "PQsendPrepare not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQftablecol not supported by this client version.");
 }
-#endif /* HAVE_PQSENDPREPARE */
 
-#ifndef HAVE_PQENCRYPTPASSWORD
-char *
-PQencryptPassword(const char *passwd, const char *user)
+int
+PQfformat(const PGresult *res, int column_number)
 {
-	rb_raise(rb_eStandardError, "PQencryptPassword not supported by this client version.");
+	rb_raise(rb_eStandardError, "PQfformat not supported by this client version.");
 }
-#endif /* HAVE_PQENCRYPTPASSWORD */
+#endif /* PG_BEFORE_070400 */
 
-#ifndef HAVE_PQEXECPARAMS
-PGresult *
-PQexecParams(PGconn *conn, const char *command, int nParams, 
-	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
-	const int *paramFormats, int resultFormat)
+#ifdef PG_BEFORE_070300
+size_t
+PQescapeStringConn(PGconn *conn, char *to, const char *from, 
+	size_t length, int *error)
 {
-	rb_raise(rb_eStandardError, "PQexecParams not supported by this client version.");
+	return PQescapeString(to,from,length);
 }
 
-#define BIND_PARAM_PATTERN "\\$(\\d+)"
-#include <ruby.h>
-#include <re.h>
-PGresult *
-PQexecParams_compat(PGconn *conn, VALUE command, VALUE values)
-{
-    VALUE bind_param_re = rb_reg_new(BIND_PARAM_PATTERN, 7, 0);
-    VALUE result = rb_str_buf_new(RSTRING(command)->len);
-    char* ptr = RSTRING(command)->ptr;
-    int scan = 0;
-    while ((scan = rb_reg_search(bind_param_re, command, scan, 0)) > 0) {
-        VALUE match = rb_backref_get();
-        int pos = BindParamNumber(match);
-        if (pos < RARRAY(values)->len) {
-            rb_str_buf_cat(result, ptr, scan - (ptr - RSTRING(command)->ptr));
-            ptr = RSTRING(command)->ptr + scan;
-            rb_str_buf_append(result, RARRAY(values)->ptr[pos]);
-        }
-        scan += RSTRING(rb_reg_nth_match(0, match))->len;
-        ptr += RSTRING(rb_reg_nth_match(0, match))->len;
-    }
-    rb_str_buf_cat(result, ptr, RSTRING(command)->len - (ptr - RSTRING(command)->ptr));
-
-    return PQexec(conn, StringValuePtr(result));
-}
-#endif /* HAVE_PQEXECPARAMS */
+unsigned char *
+PQescapeByteaConn(PGconn *conn, const unsigned char *from, 
+	size_t from_length, size_t *to_length)
+{
+	return PQescapeBytea(from, from_length, to_length);
+}
+#endif /* PG_BEFORE_070300 */
 
 
 /**************************************************************************
 
 IF ANY CODE IS COPIED FROM POSTGRESQL, PLACE IT AFTER THIS COMMENT.
-THE BSD LICENSE REQUIRES THAT YOU MAINTAIN THIS COPYRIGHT NOTICE.
 
 ***************************************************************************
 
@@ -227,7 +263,6 @@ PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 **************************************************************************/
 
 #ifndef HAVE_PQSETCLIENTENCODING
-
 int
 PQsetClientEncoding(PGconn *conn, const char *encoding)
 {

data/ext/compat.h

@@ -4,48 +4,47 @@
 
 #include <stdlib.h>
 
-#include "ruby.h"
-#include "rubyio.h"
 #include "libpq-fe.h"
 #include "libpq/libpq-fs.h"              /* large-object interface */
 
+#include "ruby.h"
 
+/* pg_config.h does not exist in older versions of
+ * PostgreSQL, so I can't effectively use PG_VERSION_NUM
+ * Instead, I create some #defines to help organization.
+ */
 #ifndef HAVE_PQCONNECTIONUSEDPASSWORD
-#define POSTGRES_BEFORE_83
+#define PG_BEFORE_080300
 #endif
 
-#if RUBY_VERSION_CODE < 180
-#define rb_check_string_type(x) rb_check_convert_type(x, T_STRING, "String", "to_str")
-#endif /* RUBY_VERSION_CODE < 180 */
+#ifndef HAVE_PQISTHREADSAFE
+#define PG_BEFORE_080200
+#endif
 
-#ifndef RARRAY_LEN
-#define RARRAY_LEN(x) RARRAY((x))->len
-#endif /* RARRAY_LEN */
+#ifndef HAVE_LOCREATE
+#define PG_BEFORE_080100
+#endif
 
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(x) RSTRING((x))->len
-#endif /* RSTRING_LEN */
+#ifndef HAVE_PQPREPARE
+#define PG_BEFORE_080000
+#endif
 
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(x) RSTRING((x))->ptr
-#endif /* RSTRING_PTR */
+#ifndef HAVE_PQEXECPARAMS
+#define PG_BEFORE_070400
+#endif
 
-#ifndef StringValuePtr
-#define StringValuePtr(x) STR2CSTR(x)
-#endif /* StringValuePtr */
+#ifndef HAVE_PQESCAPESTRINGCONN
+#define PG_BEFORE_070300
+#error PostgreSQL client version too old, requires 7.3 or later.
+#endif
 
-#ifdef POSTGRES_BEFORE_83
-#ifndef HAVE_PG_ENCODING_TO_CHAR
-#define pg_encoding_to_char(x) "SQL_ASCII"
-#else
- /* Some versions ofPostgreSQL prior to 8.3 define
-  * pg_encoding_to_char but do not declare it
-  * in a header file, so this declaration will
-  * eliminate an unecessary warning
-  */
-extern char* pg_encoding_to_char(int);
-#endif /* HAVE_PG_ENCODING_TO_CHAR */
-#endif /* POSTGRES_BEFORE_83 */
+/* This is necessary because NAMEDATALEN is defined in 
+ * pg_config_manual.h in 8.3, and that include file doesn't
+ * exist before 7.4
+ */
+#ifndef PG_BEFORE_070400
+#include "pg_config_manual.h"
+#endif
 
 #ifndef PG_DIAG_INTERNAL_POSITION
 #define PG_DIAG_INTERNAL_POSITION 'p'
@@ -55,94 +54,123 @@ extern char* pg_encoding_to_char(int);
 #define PG_DIAG_INTERNAL_QUERY  'q'
 #endif /* PG_DIAG_INTERNAL_QUERY */
 
-#ifndef HAVE_PQFREEMEM
-#define PQfreemem(ptr) free(ptr)
-#endif /* HAVE_PQFREEMEM */
+#ifdef PG_BEFORE_080300
 
-#ifndef HAVE_PQSETCLIENTENCODING
-int PQsetClientEncoding(PGconn *conn, const char *encoding)
-#endif /* HAVE_PQSETCLIENTENCODING */
-
-#ifndef HAVE_PQESCAPESTRING
-size_t PQescapeString(char *to, const char *from, size_t length);
-unsigned char * PQescapeBytea(const unsigned char *bintext, size_t binlen, size_t *bytealen);
-unsigned char * PQunescapeBytea(const unsigned char *strtext, size_t *retbuflen);
-#endif /* HAVE_PQESCAPESTRING */
-
-#ifndef HAVE_PQESCAPESTRINGCONN
-size_t PQescapeStringConn(PGconn *conn, char *to, const char *from, 
-	size_t length, int *error);
-unsigned char *PQescapeByteaConn(PGconn *conn, const unsigned char *from, 
-	size_t from_length, size_t *to_length);
-#endif /* HAVE_PQESCAPESTRINGCONN */
-
-#ifndef HAVE_PQPREPARE
-PGresult *PQprepare(PGconn *conn, const char *stmtName, const char *query,
-	int nParams, const Oid *paramTypes);
-#endif /* HAVE_PQPREPARE */
-
-#ifndef HAVE_PQDESCRIBEPREPARED
-PGresult * PQdescribePrepared(PGconn *conn, const char *stmtName);
-#endif /* HAVE_PQDESCRIBEPREPARED */
-
-#ifndef HAVE_PQDESCRIBEPORTAL
-PGresult * PQdescribePortal(PGconn *conn, const char *portalName);
-#endif /* HAVE_PQDESCRIBEPORTAL */
+#ifndef HAVE_PG_ENCODING_TO_CHAR
+#define pg_encoding_to_char(x) "SQL_ASCII"
+#else
+ /* Some versions ofPostgreSQL prior to 8.3 define pg_encoding_to_char
+  * but do not declare it in a header file, so this declaration will
+  * eliminate an unecessary warning
+  */
+extern char* pg_encoding_to_char(int);
+#endif /* HAVE_PG_ENCODING_TO_CHAR */
 
-#ifndef HAVE_PQCONNECTIONNEEDSPASSWORD
 int PQconnectionNeedsPassword(PGconn *conn);
-#endif /* HAVE_PQCONNECTIONNEEDSPASSWORD */
-
-#ifndef HAVE_PQCONNECTIONUSEDPASSWORD
 int PQconnectionUsedPassword(PGconn *conn);
-#endif /* HAVE_PQCONNECTIONUSEDPASSWORD */
-
-#ifndef HAVE_PQISTHREADSAFE
-int PQisthreadsafe(void);
-#endif /* HAVE_PQISTHREADSAFE */
-
-#ifndef HAVE_LO_TRUNCATE
 int lo_truncate(PGconn *conn, int fd, size_t len);
-#endif /* HAVE_LO_TRUNCATE */
 
-#ifndef HAVE_LO_CREATE
-Oid lo_create(PGconn *conn, Oid lobjId);
-#endif /* HAVE_LO_CREATE */
+#endif /* PG_BEFORE_080300 */
 
-#ifndef HAVE_PQNPARAMS
+#ifdef PG_BEFORE_080200
+int PQisthreadsafe(void);
 int PQnparams(const PGresult *res);
-#endif /* HAVE_PQNPARAMS */
-
-#ifndef HAVE_PQPARAMTYPE
 Oid PQparamtype(const PGresult *res, int param_number);
-#endif /* HAVE_PQPARAMTYPE */
+PGresult * PQdescribePrepared(PGconn *conn, const char *stmtName);
+PGresult * PQdescribePortal(PGconn *conn, const char *portalName);
+int PQsendDescribePrepared(PGconn *conn, const char *stmtName);
+int PQsendDescribePortal(PGconn *conn, const char *portalName);
+char *PQencryptPassword(const char *passwd, const char *user);
+#endif /* PG_BEFORE_080200 */
+
+#ifdef PG_BEFORE_080100
+Oid lo_create(PGconn *conn, Oid lobjId);
+#endif /* PG_BEFORE_080100 */
 
-#ifndef HAVE_PQSERVERVERSION
+#ifdef PG_BEFORE_080000
+PGresult *PQprepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes);
+int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes);
 int PQserverVersion(const PGconn* conn);
-#endif /* HAVE_PQSERVERVERSION */
+#endif /* PG_BEFORE_080000 */
+
+#ifdef PG_BEFORE_070400
+
+#define PG_DIAG_SEVERITY        'S'
+#define PG_DIAG_SQLSTATE        'C'
+#define PG_DIAG_MESSAGE_PRIMARY 'M'
+#define PG_DIAG_MESSAGE_DETAIL  'D'
+#define PG_DIAG_MESSAGE_HINT    'H'
+#define PG_DIAG_STATEMENT_POSITION 'P'
+#define PG_DIAG_CONTEXT         'W'
+#define PG_DIAG_SOURCE_FILE     'F'
+#define PG_DIAG_SOURCE_LINE     'L'
+#define PG_DIAG_SOURCE_FUNCTION 'R'
+
+#define PQfreemem(ptr) free(ptr)
+#define PGNOTIFY_EXTRA(notify) ""
+
+/* CONNECTION_SSL_STARTUP was added to an enum type
+ * after 7.3. For 7.3 in order to compile, we just need
+ * it to evaluate to something that is not present in that
+ * enum.
+ */
+#define CONNECTION_SSL_STARTUP 1000000
+
+typedef enum
+{
+	PQERRORS_TERSE,		/* single-line error messages */
+	PQERRORS_DEFAULT,	/* recommended style */
+	PQERRORS_VERBOSE	/* all the facts, ma'am */
+} PGVerbosity;
+
+typedef enum
+{
+	PQTRANS_IDLE,		/* connection idle */
+	PQTRANS_ACTIVE,		/* command in progress */
+	PQTRANS_INTRANS,	/* idle, within transaction block */
+	PQTRANS_INERROR,	/* idle, within failed transaction */
+	PQTRANS_UNKNOWN		/* cannot determine status */
+} PGTransactionStatusType;
 
-#ifndef HAVE_PQEXECPARAMS
 PGresult *PQexecParams(PGconn *conn, const char *command, int nParams, 
 	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
 	const int *paramFormats, int resultFormat);
-PGresult *PQexecParams_compat(PGconn *conn, VALUE command, VALUE values);
-#endif /* HAVE_PQEXECPARAMS */
-
-#ifndef HAVE_PQSENDDESCRIBEPREPARED
-int PQsendDescribePrepared(PGconn *conn, const char *stmtName);
-#endif /* HAVE_PQSENDDESCRIBEPREPARED */
-
-#ifndef HAVE_PQSENDDESCRIBEPORTAL
-int PQsendDescribePortal(PGconn *conn, const char *portalName);
-#endif /* HAVE_PQSENDDESCRIBEPORTAL */
+PGTransactionStatusType PQtransactionStatus(const PGconn *conn);
+char *PQparameterStatus(const PGconn *conn, const char *paramName);
+int PQprotocolVersion(const PGconn *conn);
+PGresult *PQexecPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat);
+int PQsendQueryParams(PGconn *conn, const char *command, int nParams,
+	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
+	const int *paramFormats, int resultFormat);
+int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat);
+int PQputCopyData(PGconn *conn, const char *buffer, int nbytes);
+int PQputCopyEnd(PGconn *conn, const char *errormsg);
+int PQgetCopyData(PGconn *conn, char **buffer, int async);
+PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
+Oid PQftable(const PGresult *res, int column_number);
+int PQftablecol(const PGresult *res, int column_number);
+int PQfformat(const PGresult *res, int column_number);
 
-#ifndef HAVE_PQSENDPREPARE
-int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
-	int nParams, const Oid *paramTypes);
-#endif /* HAVE_PQSENDPREPARE */
+#else
+#define PGNOTIFY_EXTRA(notify) ((notify)->extra)
+#endif /* PG_BEFORE_070400 */
 
-#ifndef HAVE_PQENCRYPTPASSWORD
-char *PQencryptPassword(const char *passwd, const char *user);
-#endif /* HAVE_PQENCRYPTPASSWORD */
+#ifdef PG_BEFORE_070300
+#error unsupported postgresql version, requires 7.3 or later.
+int PQsetClientEncoding(PGconn *conn, const char *encoding)
+size_t PQescapeString(char *to, const char *from, size_t length);
+unsigned char * PQescapeBytea(const unsigned char *bintext, size_t binlen, size_t *bytealen);
+unsigned char * PQunescapeBytea(const unsigned char *strtext, size_t *retbuflen);
+size_t PQescapeStringConn(PGconn *conn, char *to, const char *from, 
+	size_t length, int *error);
+unsigned char *PQescapeByteaConn(PGconn *conn, const unsigned char *from, 
+	size_t from_length, size_t *to_length);
+#endif /* PG_BEFORE_070300 */
 
 #endif /* __compat_h */

data/ext/extconf.rb

@@ -1,52 +1,80 @@
-if RUBY_VERSION < '1.3'
-  puts 'This library is for ruby-1.3 or higher.'
-  exit 1
+require 'mkmf'
+
+# OS X compatibility
+if(PLATFORM =~ /darwin/) then
+	# test if postgresql is probably universal
+	bindir = (IO.popen("pg_config --bindir").readline.chomp rescue nil)
+	filetype = (IO.popen("file #{bindir}/pg_config").
+		readline.chomp rescue nil)
+	# if it's not universal, ARCHFLAGS should be set
+	if((filetype !~ /universal binary/) && ENV['ARCHFLAGS'].nil?) then
+		arch = (IO.popen("uname -m").readline.chomp rescue nil)
+		$stderr.write %{
+		===========   WARNING   ===========
+		
+		You are building this extension on OS X without setting the 
+		ARCHFLAGS environment variable, and PostgreSQL does not appear 
+		to have been built as a universal binary. If you are seeing this 
+		message, that means that the build will probably fail.
+
+		Try setting the environment variable ARCHFLAGS 
+		to '-arch #{arch}' before building.
+
+		For example:
+		(in bash) $ export ARCHFLAGS='-arch #{arch}'
+		(in tcsh) % setenv ARCHFLAGS '-arch #{arch}'
+
+		Then try building again.
+
+		===================================
+		}
+		# We don't exit here. Who knows? It might build.
+	end
 end
 
-require 'mkmf'
+# windows compatibility, need different library name
+if(PLATFORM =~ /mingw|mswin/) then
+	$libname = '/ms/libpq'
+else
+	$libname = 'pq'
+end
+
+if RUBY_VERSION < '1.8'
+	puts 'This library is for ruby-1.8 or higher.'
+	exit 1
+end
 
 def config_value(type)
-  ENV["POSTGRES_#{type.upcase}"] || pg_config(type)
+	ENV["POSTGRES_#{type.upcase}"] || pg_config(type)
 end
 
 def pg_config(type)
-  IO.popen("pg_config --#{type}dir").readline.chomp rescue nil
+	IO.popen("pg_config --#{type}dir").readline.chomp rescue nil
 end
 
 def have_build_env
-  have_library('pq') && have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
+	have_library($libname) && have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
 end
 
 dir_config('pgsql', config_value('include'), config_value('lib'))
 
 desired_functions = %w(
-	PQsetClientEncoding 
-	PQfreemem 
-	PQescapeStringConn
-	PQprepare
-	PQescapeString
-	PQexecParams
 	PQconnectionUsedPassword
-	PQconnectionNeedsPassword
 	PQisthreadsafe
-	PQnparams
-	PQparamtype
-	PQsendDescribePrepared
-	PQsendDescribePortal
-	PQsendPrepare
-	PQencryptPassword
-	PQdescribePrepared
-	PQdescribePortal
+	PQprepare
+	PQexecParams
+	PQescapeString
+	PQescapeStringConn
 	lo_create
-	lo_truncate
 	pg_encoding_to_char 
+	PQsetClientEncoding 
 )
 
 if have_build_env
-  desired_functions.each(&method(:have_func))
-  $OBJS = ['pg.o','compat.o']
-  $CFLAGS << ' -Wall -Wmissing-prototypes'
-  create_makefile("pg")
+	desired_functions.each(&method(:have_func))
+	$OBJS = ['pg.o','compat.o']
+	create_makefile("pg")
 else
-  puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'
+	puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'
 end
+

data/ext/pg.c

@@ -9,7 +9,7 @@
   modified at: Wed Jan 20 16:41:51 1999
 
   $Author: jdavis $
-  $Date: 2008-01-08 18:03:23 -0800 (Tue, 08 Jan 2008) $
+  $Date: 2008-01-24 10:47:02 -0800 (Thu, 24 Jan 2008) $
 ************************************************/
 
 #include "pg.h"
@@ -627,7 +627,7 @@ pgconn_error_message(self)
 
 /*
  * call-seq:
- *    conn.backed_pid() -> Fixnum
+ *    conn.backend_pid() -> Fixnum
  *
  * Returns the process ID of the backend server
  * process for this connection.
@@ -1690,7 +1690,7 @@ pgconn_notifies(self)
 	hash = rb_hash_new();
 	relname = rb_tainted_str_new2(notify->relname);
 	be_pid = INT2NUM(notify->be_pid);
-	extra = rb_tainted_str_new2(notify->extra);
+	extra = rb_tainted_str_new2(PGNOTIFY_EXTRA(notify));
 	
     rb_hash_aset(hash, sym_relname, relname);
 	rb_hash_aset(hash, sym_be_pid, be_pid);
@@ -1788,6 +1788,7 @@ pgconn_get_copy_data( argc, argv, self )
 {
     VALUE async_in;
 	VALUE error;
+	VALUE result_str;
 	int ret;
 	int async;
 	char *buffer;
@@ -1810,7 +1811,9 @@ pgconn_get_copy_data( argc, argv, self )
 	if(ret == 0) { // would block
 		return Qfalse;
 	}
-	return rb_str_new(buffer, ret);
+	result_str = rb_str_new(buffer, ret);
+	PQfreemem(buffer);
+	return result_str;
 }
 
 /*
@@ -1902,6 +1905,142 @@ pgconn_set_client_encoding(self, str)
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *    conn.transaction { |conn| ... } -> nil
+ *
+ * Executes a +BEGIN+ at the start of the block,
+ * and a +COMMIT+ at the end of the block, or 
+ * +ROLLBACK+ if any exception occurs.
+ */
+static VALUE
+pgconn_transaction(VALUE self)
+{
+	PGconn *conn = get_pgconn(self);
+	PGresult *result;
+	VALUE rb_pgresult;
+	int status;
+	
+	if (rb_block_given_p()) {
+		result = PQexec(conn, "BEGIN");
+		rb_pgresult = new_pgresult(result);
+		pgresult_check(self, rb_pgresult);
+		fprintf(stderr,"BEGIN\n");
+		rb_protect(rb_yield, self, &status);
+		if(status == 0) {
+			result = PQexec(conn, "COMMIT");
+			rb_pgresult = new_pgresult(result);
+			pgresult_check(self, rb_pgresult);
+			fprintf(stderr,"COMMIT\n");
+		}
+		else {
+			/* exception occurred, ROLLBACK and re-raise */
+			result = PQexec(conn, "ROLLBACK");
+			rb_pgresult = new_pgresult(result);
+			pgresult_check(self, rb_pgresult);
+			fprintf(stderr,"ROLLBACK\n");
+			rb_jump_tag(status);
+		}
+			
+	}
+	else {
+		/* no block supplied? */
+		rb_raise(rb_eArgError, "Must supply block for PGconn#transaction");
+	}
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ *    PGconn.quote_ident( str ) -> String
+ *    conn.quote_ident( str ) -> String
+ *
+ * Returns a string that is safe for inclusion in a SQL query
+ * as an identifier. Note: this is not a quote function for values,
+ * but for identifiers.
+ * 
+ * For example, in a typical SQL query: +SELECT FOO FROM MYTABLE+
+ * The identifier +FOO+ is folded to lower case, so it actually means
+ * +foo+. If you really want to access the case-sensitive field name
+ * +FOO+, use this function like +PGconn.quote_ident('FOO')+, which
+ * will return +"FOO"+ (with double-quotes). PostgreSQL will see the
+ * double-quotes, and it will not fold to lower case.
+ *
+ * Similarly, this function also protects against special characters,
+ * and other things that might allow SQL injection if the identifier
+ * comes from an untrusted source.
+ */
+static VALUE
+pgconn_s_quote_ident(VALUE self, VALUE in_str)
+{
+	char *str = StringValuePtr(in_str);
+	/* result size at most NAMEDATALEN*2 plus surrounding
+     * double-quotes. */
+	char buffer[NAMEDATALEN*2+2];
+	int i=0,j=0;
+	
+	if(strlen(str) >= NAMEDATALEN) {
+		rb_raise(rb_eArgError, 
+			"Input string is longer than NAMEDATALEN-1 (%d)",
+			NAMEDATALEN-1);
+	}
+	buffer[j++] = '"';
+	for(i = 0; i < strlen(str) && str[i]; i++) {
+		if(str[i] == '"') 
+			buffer[j++] = '"';
+		buffer[j++] = str[i];
+	}
+	buffer[j++] = '"';
+	return rb_str_new(buffer,j);
+}
+
+
+/*
+ * call-seq:
+ *    conn.block( [ timeout ] ) -> Boolean
+ *
+ * Blocks until the server is no longer busy, or until the 
+ * optional _timeout_ is reached, whichever comes first.
+ * _timeout_ is measured in seconds and can be fractional.
+ * 
+ * Returns +false+ if _timeout_ is reached, +true+ otherwise.
+ * 
+ * If +true+ is returned, +conn.is_busy+ will return +false+
+ * and +conn.get_result+ will not block.
+ */
+static VALUE
+pgconn_block(int argc, VALUE *argv, VALUE self)
+{
+	PGconn *conn = get_pgconn(self);
+	int sd = PQsocket(conn);
+	int ret;
+	struct timeval timeout;
+	struct timeval *ptimeout = NULL;
+	VALUE timeout_in;
+	double timeout_sec;
+	fd_set sd_rset;
+
+	if (rb_scan_args(argc, argv, "01", &timeout_in) == 1) {
+		timeout_sec = NUM2DBL(timeout_in);
+		timeout.tv_sec = (long)timeout_sec;
+		timeout.tv_usec = (long)((timeout_sec - (long)timeout_sec) * 1e6);
+		ptimeout = &timeout;
+	}
+
+	PQconsumeInput(conn);
+	while(PQisBusy(conn)) {
+		FD_ZERO(&sd_rset);
+		FD_SET(sd, &sd_rset);
+		ret = rb_thread_select(sd+1, &sd_rset, NULL, NULL, ptimeout);
+		/* if select() times out, return false */
+		if(ret == 0) 
+			return Qfalse;
+		PQconsumeInput(conn);
+	} 
+
+	return Qtrue;
+}
+
 /*TODO */
 static void
 notice_proxy(self, message)
@@ -2839,6 +2978,7 @@ Init_pg()
     rb_define_singleton_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
     rb_define_singleton_method(rb_cPGconn, "isthreadsafe", pgconn_s_isthreadsafe, 0);
     rb_define_singleton_method(rb_cPGconn, "encrypt_password", pgconn_s_encrypt_password, 0);
+	rb_define_singleton_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 
 	/******     PGconn CLASS CONSTANTS: Connection Status     ******/
     rb_define_const(rb_cPGconn, "CONNECTION_OK", INT2FIX(CONNECTION_OK));
@@ -2881,6 +3021,7 @@ Init_pg()
     rb_define_method(rb_cPGconn, "initialize", pgconn_init, -1);
     rb_define_method(rb_cPGconn, "reset", pgconn_reset, 0);
     rb_define_method(rb_cPGconn, "finish", pgconn_finish, 0);
+    rb_define_alias(rb_cPGconn, "close", "finish");
 
 	/******     PGconn INSTANCE METHODS: Connection Status     ******/
     rb_define_method(rb_cPGconn, "db", pgconn_db, 0);
@@ -2904,6 +3045,7 @@ Init_pg()
 
 	/******     PGconn INSTANCE METHODS: Command Execution     ******/
     rb_define_method(rb_cPGconn, "exec", pgconn_exec, -1);
+	rb_define_alias(rb_cPGconn, "query", "exec");
     rb_define_method(rb_cPGconn, "prepare", pgconn_prepare, -1);
     rb_define_method(rb_cPGconn, "exec_prepared", pgconn_exec_prepared, -1);
     rb_define_method(rb_cPGconn, "describe_prepared", pgconn_describe_prepared, 1);
@@ -2949,9 +3091,12 @@ Init_pg()
     //rb_define_method(rb_cPGconn, "set_notice_receiver", pgconn_set_notice_receiver, 0);
     rb_define_method(rb_cPGconn, "set_notice_processor", pgconn_set_notice_processor, 0);
 
-	/******     PGconn INSTANCE METHODS: Other TODO    ******/
+	/******     PGconn INSTANCE METHODS: Other    ******/
     rb_define_method(rb_cPGconn, "get_client_encoding", pgconn_get_client_encoding, 0);
     rb_define_method(rb_cPGconn, "set_client_encoding", pgconn_set_client_encoding, 1);
+	rb_define_method(rb_cPGconn, "transaction", pgconn_transaction, 0);
+	rb_define_method(rb_cPGconn, "block", pgconn_block, -1);
+	rb_define_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 
 	/******     PGconn INSTANCE METHODS: Large Object Support     ******/
     rb_define_method(rb_cPGconn, "lo_creat", pgconn_locreat, -1);

data/ext/pg.h

@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
+#include <unistd.h>
 
 #include "ruby.h"
 #include "rubyio.h"
@@ -9,5 +10,25 @@
 
 #include "compat.h"
 
+#if RUBY_VERSION_CODE < 180
+#define rb_check_string_type(x) rb_check_convert_type(x, T_STRING, "String", "to_str")
+#endif /* RUBY_VERSION_CODE < 180 */
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(x) RARRAY((x))->len
+#endif /* RARRAY_LEN */
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(x) RSTRING((x))->len
+#endif /* RSTRING_LEN */
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(x) RSTRING((x))->ptr
+#endif /* RSTRING_PTR */
+
+#ifndef StringValuePtr
+#define StringValuePtr(x) STR2CSTR(x)
+#endif /* StringValuePtr */
+
 void Init_pg(void);
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: ruby-pg
 version: !ruby/object:Gem::Version 
-  version: 0.7.9.2008.01.08
-date: 2008-01-08 00:00:00 -08:00
+  version: 0.7.9.2008.01.24
+date: 2008-01-24 00:00:00 -08:00
 summary: Ruby extension library providing an API to PostgreSQL
 require_paths: 
 - lib