postgres 0.7.9.2007.12.12 → 0.7.9.2007.12.22

data/compat-ruby-postgres/extconf.rb

@@ -20,13 +20,13 @@ end
 dir_config('pgsql', config_value('include'), config_value('lib'))
 
 required_libraries = []
-desired_functions = %w(PQsetClientEncoding pg_encoding_to_char PQfreemem)
+desired_functions = %w(PQsetClientEncoding pg_encoding_to_char PQfreemem PQserverVersion)
 compat_functions = %w(PQescapeString PQexecParams)
 
 if have_build_env
   required_libraries.each(&method(:have_library))
   desired_functions.each(&method(:have_func))
-  $objs = ['postgres.o'] if compat_functions.all?(&method(:have_func))
+  $objs = ['postgres.o','libpq-compat.o'] if compat_functions.all?(&method(:have_func))
   $CFLAGS << ' -Wall '
   create_makefile("postgres")
 else

data/compat-ruby-postgres/libpq-compat.c

@@ -0,0 +1,253 @@
+#include <stdlib.h>
+
+#ifndef HAVE_PQESCAPESTRING
+/*
+ * Escaping arbitrary strings to get valid SQL literal strings.
+ *
+ * Replaces "\\" with "\\\\" and "'" with "''".
+ *
+ * length is the length of the source string.  (Note: if a terminating NUL
+ * is encountered sooner, PQescapeString stops short of "length"; the behavior
+ * is thus rather like strncpy.)
+ *
+ * For safety the buffer at "to" must be at least 2*length + 1 bytes long.
+ * A terminating NUL character is added to the output string, whether the
+ * input is NUL-terminated or not.
+ *
+ * Returns the actual length of the output (not counting the terminating NUL).
+ */
+size_t
+PQescapeString(char *to, const char *from, size_t length)
+{
+	const char *source = from;
+	char	   *target = to;
+	size_t		remaining = length;
+
+	while (remaining > 0 && *source != '\0')
+	{
+		switch (*source)
+		{
+			case '\\':
+				*target++ = '\\';
+				*target++ = '\\';
+				break;
+
+			case '\'':
+				*target++ = '\'';
+				*target++ = '\'';
+				break;
+
+			default:
+				*target++ = *source;
+				break;
+		}
+		source++;
+		remaining--;
+	}
+
+	/* Write the terminating NUL character. */
+	*target = '\0';
+
+	return target - to;
+}
+
+/*
+ *		PQescapeBytea	- converts from binary string to the
+ *		minimal encoding necessary to include the string in an SQL
+ *		INSERT statement with a bytea type column as the target.
+ *
+ *		The following transformations are applied
+ *		'\0' == ASCII  0 == \\000
+ *		'\'' == ASCII 39 == \'
+ *		'\\' == ASCII 92 == \\\\
+ *		anything < 0x20, or > 0x7e ---> \\ooo
+ *										(where ooo is an octal expression)
+ */
+unsigned char *
+PQescapeBytea(const unsigned char *bintext, size_t binlen, size_t *bytealen)
+{
+	const unsigned char *vp;
+	unsigned char *rp;
+	unsigned char *result;
+	size_t		i;
+	size_t		len;
+
+	/*
+	 * empty string has 1 char ('\0')
+	 */
+	len = 1;
+
+	vp = bintext;
+	for (i = binlen; i > 0; i--, vp++)
+	{
+		if (*vp < 0x20 || *vp > 0x7e)
+			len += 5;			/* '5' is for '\\ooo' */
+		else if (*vp == '\'')
+			len += 2;
+		else if (*vp == '\\')
+			len += 4;
+		else
+			len++;
+	}
+
+	rp = result = (unsigned char *) malloc(len);
+	if (rp == NULL)
+		return NULL;
+
+	vp = bintext;
+	*bytealen = len;
+
+	for (i = binlen; i > 0; i--, vp++)
+	{
+		if (*vp < 0x20 || *vp > 0x7e)
+		{
+			(void) sprintf(rp, "\\\\%03o", *vp);
+			rp += 5;
+		}
+		else if (*vp == '\'')
+		{
+			rp[0] = '\\';
+			rp[1] = '\'';
+			rp += 2;
+		}
+		else if (*vp == '\\')
+		{
+			rp[0] = '\\';
+			rp[1] = '\\';
+			rp[2] = '\\';
+			rp[3] = '\\';
+			rp += 4;
+		}
+		else
+			*rp++ = *vp;
+	}
+	*rp = '\0';
+
+	return result;
+}
+
+#define ISFIRSTOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '3')
+#define ISOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '7')
+#define OCTVAL(CH) ((CH) - '0')
+
+/*
+ *		PQunescapeBytea - converts the null terminated string representation
+ *		of a bytea, strtext, into binary, filling a buffer. It returns a
+ *		pointer to the buffer (or NULL on error), and the size of the
+ *		buffer in retbuflen. The pointer may subsequently be used as an
+ *		argument to the function free(3). It is the reverse of PQescapeBytea.
+ *
+ *		The following transformations are made:
+ *		\\	 == ASCII 92 == \
+ *		\ooo == a byte whose value = ooo (ooo is an octal number)
+ *		\x	 == x (x is any character not matched by the above transformations)
+ */
+unsigned char *
+PQunescapeBytea(const unsigned char *strtext, size_t *retbuflen)
+{
+	size_t		strtextlen,
+				buflen;
+	unsigned char *buffer,
+			   *tmpbuf;
+	size_t		i,
+				j;
+
+	if (strtext == NULL)
+		return NULL;
+
+	strtextlen = strlen(strtext);
+
+	/*
+	 * Length of input is max length of output, but add one to avoid
+	 * unportable malloc(0) if input is zero-length.
+	 */
+	buffer = (unsigned char *) malloc(strtextlen + 1);
+	if (buffer == NULL)
+		return NULL;
+
+	for (i = j = 0; i < strtextlen;)
+	{
+		switch (strtext[i])
+		{
+			case '\\':
+				i++;
+				if (strtext[i] == '\\')
+					buffer[j++] = strtext[i++];
+				else
+				{
+					if ((ISFIRSTOCTDIGIT(strtext[i])) &&
+						(ISOCTDIGIT(strtext[i + 1])) &&
+						(ISOCTDIGIT(strtext[i + 2])))
+					{
+						int			byte;
+
+						byte = OCTVAL(strtext[i++]);
+						byte = (byte << 3) + OCTVAL(strtext[i++]);
+						byte = (byte << 3) + OCTVAL(strtext[i++]);
+						buffer[j++] = byte;
+					}
+				}
+
+				/*
+				 * Note: if we see '\' followed by something that isn't a
+				 * recognized escape sequence, we loop around having done
+				 * nothing except advance i.  Therefore the something will
+				 * be emitted as ordinary data on the next cycle. Corner
+				 * case: '\' at end of string will just be discarded.
+				 */
+				break;
+
+			default:
+				buffer[j++] = strtext[i++];
+				break;
+		}
+	}
+	buflen = j;					/* buflen is the length of the dequoted
+								 * data */
+
+	/* Shrink the buffer to be no larger than necessary */
+	/* +1 avoids unportable behavior when buflen==0 */
+	tmpbuf = realloc(buffer, buflen + 1);
+
+	/* It would only be a very brain-dead realloc that could fail, but... */
+	if (!tmpbuf)
+	{
+		free(buffer);
+		return NULL;
+	}
+
+	*retbuflen = buflen;
+	return tmpbuf;
+}
+#endif
+
+#ifndef HAVE_PQEXECPARAMS
+#include <ruby.h>
+#include <re.h>
+#include <libpq-fe.h>
+
+#define BIND_PARAM_PATTERN "\\$(\\d+)"
+#define BindParamNumber(match) (FIX2INT(rb_str_to_inum(rb_reg_nth_match(1, match), 10, 0))-1)
+
+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

data/compat-ruby-postgres/postgres.c

@@ -25,6 +25,22 @@
 #include <stdlib.h>
 #include <sys/types.h>
 
+#ifndef HAVE_PQSERVERVERSION
+static int
+PQserverVersion(const PGconn *conn)
+{
+	rb_raise(rb_eArgError,"this version of libpq doesn't support PQserverVersion");
+}
+#endif /* HAVE_PQSERVERVERSION */
+
+#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 HAVE_PG_ENCODING_TO_CHAR
 #define pg_encoding_to_char(x) "SQL_ASCII"
 #endif
@@ -175,9 +191,11 @@ pgconn_connect(argc, argv, self)
         rb_raise(rb_ePGError, StringValuePtr(message));
     }
 
+#ifdef HAVE_PQSERVERVERSION
     if (PQserverVersion(conn) >= 80100) {
         rb_define_singleton_method(self, "lastval", pgconn_lastval, 0);
     }
+#endif /* HAVE_PQSERVERVERSION */
 
     Data_Set_Struct(self, conn);
     return self;
@@ -259,8 +277,8 @@ pgconn_s_quote(self, obj)
     if (TYPE(obj) == T_STRING) {
         /* length * 2 because every char could require escaping */
         /* + 2 for the quotes, + 1 for the null terminator */
-        quoted = ALLOCA_N(char, RSTRING(obj)->len * 2 + 2 + 1);
-        size = PQescapeString(quoted + 1, RSTRING(obj)->ptr, RSTRING(obj)->len);
+        quoted = ALLOCA_N(char, RSTRING_LEN(obj) * 2 + 2 + 1);
+        size = PQescapeString(quoted + 1, RSTRING_PTR(obj), RSTRING_LEN(obj));
         *quoted = *(quoted + size + 1) = SINGLE_QUOTE;
         result = rb_str_new(quoted, size + 2);
         OBJ_INFECT(result, obj);
@@ -299,8 +317,9 @@ pgconn_quote(self, obj)
     if (TYPE(obj) == T_STRING) {
         /* length * 2 because every char could require escaping */
         /* + 2 for the quotes, + 1 for the null terminator */
-        quoted = ALLOCA_N(char, RSTRING(obj)->len * 2 + 2 + 1);
-        size = PQescapeStringConn(get_pgconn(self),quoted + 1, RSTRING(obj)->ptr, RSTRING(obj)->len, &error);
+        quoted = ALLOCA_N(char, RSTRING_LEN(obj) * 2 + 2 + 1);
+        size = PQescapeStringConn(get_pgconn(self),quoted + 1, 
+				RSTRING_PTR(obj), RSTRING_LEN(obj), &error);
         *quoted = *(quoted + size + 1) = SINGLE_QUOTE;
         result = rb_str_new(quoted, size + 2);
         OBJ_INFECT(result, obj);
@@ -321,8 +340,8 @@ pgconn_s_quote_connstr(string)
 
     Check_Type(string, T_STRING);
     
-	ptr = RSTRING(string)->ptr;
-	len = RSTRING(string)->len;
+	ptr = RSTRING_PTR(string);
+	len = RSTRING_LEN(string);
     str = ALLOCA_N(char, len * 2 + 2 + 1);
 	str[j++] = '\'';
 	for(i = 0; i < len; i++) {
@@ -366,8 +385,8 @@ pgconn_s_quote_ident(self, string)
 
     Check_Type(string, T_STRING);
     
-	ptr = RSTRING(string)->ptr;
-	len = RSTRING(string)->len;
+	ptr = RSTRING_PTR(string);
+	len = RSTRING_LEN(string);
     str = ALLOCA_N(char, len * 2 + 2 + 1);
 	str[j++] = '"';
 	for(i = 0; i < len; i++) {
@@ -397,8 +416,8 @@ pgconn_s_escape(self, string)
 
     Check_Type(string, T_STRING);
     
-    escaped = ALLOCA_N(char, RSTRING(string)->len * 2 + 1);
-    size = PQescapeString(escaped, RSTRING(string)->ptr, RSTRING(string)->len);
+    escaped = ALLOCA_N(char, RSTRING_LEN(string) * 2 + 1);
+    size = PQescapeString(escaped, RSTRING_PTR(string), RSTRING_LEN(string));
     result = rb_str_new(escaped, size);
     OBJ_INFECT(result, string);
     return result;
@@ -418,8 +437,9 @@ pgconn_escape(self, string)
 
     Check_Type(string, T_STRING);
     
-    escaped = ALLOCA_N(char, RSTRING(string)->len * 2 + 1);
-    size = PQescapeStringConn(get_pgconn(self),escaped, RSTRING(string)->ptr, RSTRING(string)->len, &error);
+    escaped = ALLOCA_N(char, RSTRING_LEN(string) * 2 + 1);
+    size = PQescapeStringConn(get_pgconn(self),escaped, RSTRING_PTR(string),
+				RSTRING_LEN(string), &error);
     result = rb_str_new(escaped, size);
     OBJ_INFECT(result, string);
     return result;
@@ -450,8 +470,8 @@ pgconn_s_escape_bytea(self, obj)
     VALUE ret;
     
     Check_Type(obj, T_STRING);
-    from      = RSTRING(obj)->ptr;
-    from_len  = RSTRING(obj)->len;
+    from      = RSTRING_PTR(obj);
+    from_len  = RSTRING_LEN(obj);
     
     to = (char *)PQescapeBytea(from, from_len, &to_len);
     
@@ -488,8 +508,8 @@ pgconn_escape_bytea(self, obj)
     VALUE ret;
     
     Check_Type(obj, T_STRING);
-    from      = RSTRING(obj)->ptr;
-    from_len  = RSTRING(obj)->len;
+    from      = RSTRING_PTR(obj);
+    from_len  = RSTRING_LEN(obj);
     
     to = (char *)PQescapeByteaConn(get_pgconn(self),from, from_len, &to_len);
     
@@ -653,13 +673,13 @@ translate_to_pg(VALUE value, char const** result, int* length, int* format)
       return;
     case T_STRING:
       *result = StringValuePtr(value);
-      *length = RSTRING(value)->len;
+      *length = RSTRING_LEN(value);
       *format = BINARY_FORMAT;
       return;
     default:  {
         VALUE formatted = pgconn_s_format(rb_cPGconn, value);
         *result = StringValuePtr(formatted);
-        *length = RSTRING(formatted)->len;
+        *length = RSTRING_LEN(formatted);
         *format = TEXT_FORMAT;
       }
     }
@@ -735,7 +755,7 @@ pgconn_exec(argc, argv, obj)
     case PGRES_BAD_RESPONSE:
     case PGRES_FATAL_ERROR:
     case PGRES_NONFATAL_ERROR:
-      msg = RSTRING(rb_str_new2(PQresultErrorMessage(result)))->ptr;
+      msg = RSTRING_PTR(rb_str_new2(PQresultErrorMessage(result)));
       break;
     default:
       msg = "internal error : unknown result status.";
@@ -771,7 +791,7 @@ pgconn_async_exec(obj, str)
         PQclear(result);
     }
 
-    if (!PQsendQuery(conn, RSTRING(str)->ptr)) {
+    if (!PQsendQuery(conn, RSTRING_PTR(str))) {
         rb_raise(rb_ePGError, PQerrorMessage(conn));
     }
 
@@ -814,7 +834,7 @@ pgconn_async_exec(obj, str)
     case PGRES_BAD_RESPONSE:
     case PGRES_FATAL_ERROR:
     case PGRES_NONFATAL_ERROR:
-      msg = RSTRING(rb_str_new2(PQresultErrorMessage(result)))->ptr;
+      msg = RSTRING_PTR(rb_str_new2(PQresultErrorMessage(result)));
       break;
     default:
       msg = "internal error : unknown result status.";
@@ -925,9 +945,9 @@ pgconn_insert_table(obj, table, values)
         }
     }
     
-    buffer = rb_str_new(0, RSTRING(table)->len + 17 + 1);
+    buffer = rb_str_new(0, RSTRING_LEN(table) + 17 + 1);
     /* starts query */
-    snprintf(RSTRING(buffer)->ptr, RSTRING(buffer)->len, "copy %s from stdin ", StringValuePtr(table));
+    snprintf(RSTRING_PTR(buffer), RSTRING_LEN(buffer), "copy %s from stdin ", StringValuePtr(table));
     
     result = PQexec(conn, StringValuePtr(buffer));
     if (!result){
@@ -945,7 +965,7 @@ pgconn_insert_table(obj, table, values)
             } else {
                 s = rb_obj_as_string(row->ptr[j]);
                 rb_funcall(s,pg_gsub_bang_id,2,pg_escape_regex,pg_escape_str);
-                rb_str_cat(buffer, StringValuePtr(s), RSTRING(s)->len);
+                rb_str_cat(buffer, StringValuePtr(s), RSTRING_LEN(s));
             }
         }
         rb_str_cat(buffer, "\n\0", 2);
@@ -996,7 +1016,7 @@ pgconn_getline(obj)
     str = rb_tainted_str_new(0, size);
 
     for (;;) {
-        ret = PQgetline(conn, RSTRING(str)->ptr + bytes, size - bytes);
+        ret = PQgetline(conn, RSTRING_PTR(str) + bytes, size - bytes);
         switch (ret) {
         case EOF:
           return Qnil;
@@ -1182,7 +1202,7 @@ pgconn_error(obj)
     return rb_tainted_str_new2(error);
 }
 
-/*
+/*TODO broken for ruby 1.9
  * call-seq:
  *    conn.trace( port )
  * 
@@ -1194,12 +1214,12 @@ static VALUE
 pgconn_trace(obj, port)
     VALUE obj, port;
 {
-    OpenFile* fp;
+    //OpenFile* fp;
 
     Check_Type(port, T_FILE);
-    GetOpenFile(port, fp);
+    //GetOpenFile(port, fp);
 
-    PQtrace(get_pgconn(obj), fp->f2?fp->f2:fp->f);
+    //PQtrace(get_pgconn(obj), fp->f2?fp->f2:fp->f);
 
     return obj;
 }
@@ -2287,7 +2307,7 @@ loread_all(obj)
 
     str = rb_tainted_str_new(0,siz);
     for (;;) {
-        n = lo_read(pglarge->pgconn, pglarge->lo_fd, RSTRING(str)->ptr + bytes,siz - bytes);
+        n = lo_read(pglarge->pgconn, pglarge->lo_fd, RSTRING_PTR(str) + bytes,siz - bytes);
         if (n == 0 && bytes == 0) return Qnil;
         bytes += n;
         if (bytes < siz ) break;
@@ -2332,7 +2352,7 @@ pglarge_read(argc, argv, obj)
         rb_raise(rb_ePGError, "error while reading");
     }
     if (len == 0) return Qnil;
-    RSTRING(str)->len = len;
+    RSTRING_LEN(str) = len;
     return str;
 }
 
@@ -2352,10 +2372,11 @@ pglarge_write(obj, buffer)
 
     Check_Type(buffer, T_STRING);
 
-    if( RSTRING(buffer)->len < 0) {
+    if( RSTRING_LEN(buffer) < 0) {
         rb_raise(rb_ePGError, "write buffer zero string");
     }
-    if((n = lo_write(pglarge->pgconn, pglarge->lo_fd, StringValuePtr(buffer), RSTRING(buffer)->len)) == -1) {
+    if((n = lo_write(pglarge->pgconn, pglarge->lo_fd, StringValuePtr(buffer), 
+				RSTRING_LEN(buffer))) == -1) {
         rb_raise(rb_ePGError, "buffer truncated during write");
     }