pg-jdguyot 0.10.0

data/Rakefile.local

@@ -0,0 +1,298 @@
+#!rake
+
+require 'uri'
+require 'tempfile'
+require 'rbconfig'
+
+require 'rake/clean'
+require 'rake/extensiontask'
+require 'rake/extensioncompiler'
+
+MISCDIR = BASEDIR + 'misc'
+
+EXT_MAKEFILE  = EXTDIR + 'Makefile'
+EXT_SOURCES   = FileList[ EXTDIR + '*.c' ]
+EXT_SO        = EXTDIR + "pg_ext.#{CONFIG['DLEXT']}"
+
+NUM_CPUS = if File.exist?('/proc/cpuinfo')
+	File.read('/proc/cpuinfo').scan('processor').length
+elsif RUBY_PLATFORM.include?( 'darwin' )
+	`system_profiler SPHardwareDataType | grep 'Cores' | awk '{print $5}'`.chomp
+else
+	1
+end
+
+# Cross-compilation constants
+OPENSSL_VERSION            = ENV['OPENSSL_VERSION'] || '1.0.0a'
+POSTGRESQL_VERSION         = ENV['POSTGRESQL_VERSION'] || '9.0.1'
+
+COMPILE_HOME               = Pathname( "~/.rake-compiler" ).expand_path
+STATIC_SOURCESDIR          = COMPILE_HOME + 'sources'
+STATIC_BUILDDIR            = COMPILE_HOME + 'builds'
+
+# Static OpenSSL build vars
+STATIC_OPENSSL_BUILDDIR    = STATIC_BUILDDIR + "openssl-#{OPENSSL_VERSION}"
+
+OPENSSL_SOURCE_URI         =
+	URI( "http://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz" )
+OPENSSL_TARBALL            = STATIC_SOURCESDIR + File.basename( OPENSSL_SOURCE_URI.path )
+OPENSSL_MAKEFILE           = STATIC_OPENSSL_BUILDDIR + 'Makefile'
+
+LIBSSLEAY32                = STATIC_OPENSSL_BUILDDIR + 'libssleay32.a'
+LIBEAY32                   = STATIC_OPENSSL_BUILDDIR + 'libeay32.a'
+
+OPENSSL_PATCHES            = Rake::FileList[ MISCDIR + "openssl-#{OPENSSL_VERSION}.*.patch" ]
+
+# Static PostgreSQL build vars
+STATIC_POSTGRESQL_BUILDDIR = STATIC_BUILDDIR + "postgresql-#{POSTGRESQL_VERSION}"
+POSTGRESQL_SOURCE_URI      = begin
+	uristring = "http://ftp9.us.postgresql.org/pub/mirrors/postgresql/source/" +
+		"v%s/postgresql-%s.tar.gz" % [ POSTGRESQL_VERSION, POSTGRESQL_VERSION ]
+	URI( uristring )
+end
+POSTGRESQL_TARBALL         = STATIC_SOURCESDIR + File.basename( POSTGRESQL_SOURCE_URI.path )
+
+STATIC_POSTGRESQL_SRCDIR   = STATIC_POSTGRESQL_BUILDDIR + 'src'
+STATIC_POSTGRESQL_LIBDIR   = STATIC_POSTGRESQL_SRCDIR + 'interfaces/libpq'
+STATIC_POSTGRESQL_INCDIR   = STATIC_POSTGRESQL_SRCDIR + 'include'
+
+POSTGRESQL_GLOBAL_MAKEFILE = STATIC_POSTGRESQL_SRCDIR + 'Makefile.global'
+POSTGRESQL_SHLIB_MAKEFILE  = STATIC_POSTGRESQL_SRCDIR + 'Makefile.shlib'
+POSTGRESQL_SHLIB_MF_ORIG   = STATIC_POSTGRESQL_SRCDIR + 'Makefile.shlib.orig'
+POSTGRESQL_LIB             = STATIC_POSTGRESQL_LIBDIR + 'libpq.a'
+
+CROSS_PREFIX = if RUBY_PLATFORM.include?( 'darwin' )
+	'i386-mingw32'
+else
+	'i586-mingw32msvc'
+end
+
+# Make sure the spec data is packaged up with the gem
+SPEC_DATA = Rake::FileList[ SPECDIR + 'data/*' ]
+GEMSPEC.test_files += SPEC_DATA.to_a
+
+# Clean up any testing database directories
+TESTING_TMPDIRS = Rake::FileList[ "#{BASEDIR}/tmp_test_*" ]
+CLOBBER.include( STATIC_SOURCESDIR.to_s, *TESTING_TMPDIRS )
+
+# clean intermediate files and folders
+CLEAN.include( STATIC_BUILDDIR.to_s )
+
+
+#####################################################################
+###	T A S K S
+#####################################################################
+
+# Make both the default task and the spec task depend on building the extension
+task :local => :compile
+task :spec => :compile
+namespace :spec do
+	task :doc   => [ :compile ]
+	task :quiet => [ :compile ]
+	task :html  => [ :compile ]
+	task :text  => [ :compile ]
+end
+
+ENV['RUBY_CC_VERSION'] = '1.8.6:1.9.2'
+
+Rake::ExtensionTask.new do |ext|
+	ext.name = 'pg_ext'
+	ext.gem_spec = GEMSPEC
+	ext.ext_dir = EXTDIR.to_s
+	ext.lib_dir = LIBDIR.to_s
+	ext.source_pattern = "*.{c,h}"
+
+	# If there's an explicit 'compile' argument, use everything after it as options.
+	if offset = ARGV.index( 'compile' )
+		trace "config options = %p" % [ ARGV[(offset + 1)..-1] ]
+		ext.config_options = ARGV[ (offset + 1)..-1 ]
+	# Otherwise, just grab everything from the first option onward
+	elsif offset = ARGV.index( ARGV.find {|arg| arg =~ /^--/ } )
+		trace "config options = %p" % [ ARGV[offset..-1] ]
+		ext.config_options = ARGV[ offset..-1 ]
+	else
+		trace "No config options (ARGV = %p)" % [ ARGV ]
+	end
+
+	ext.cross_compile = true
+	ext.cross_platform = %w[i386-mswin32 i386-mingw32]
+
+	# configure options only for cross compile
+	ext.cross_config_options += [
+		"--with-pg-include=#{STATIC_POSTGRESQL_LIBDIR}",
+		"--with-opt-include=#{STATIC_POSTGRESQL_INCDIR}",
+		"--with-pg-lib=#{STATIC_POSTGRESQL_LIBDIR}",
+		"--with-opt-lib=#{STATIC_OPENSSL_BUILDDIR}",
+		"--enable-static-build",
+	]
+
+end
+
+task :cross do
+	ENV['CROSS_COMPILING'] = 'yes'
+end
+
+
+desc "Stop any Postmaster instances that remain after testing."
+task :cleanup_testing_dbs do
+    require 'spec/lib/helpers'
+    PgTestingHelpers.stop_existing_postmasters()
+    Rake::Task[:clean].invoke
+end
+
+
+#####################################################################
+###	C R O S S - C O M P I L A T I O N - T A S K S
+#####################################################################
+
+
+directory STATIC_SOURCESDIR.to_s
+
+#
+# Static OpenSSL build tasks
+#
+directory STATIC_OPENSSL_BUILDDIR.to_s
+
+# openssl source file should be stored there
+file OPENSSL_TARBALL => STATIC_SOURCESDIR do |t|
+	download( OPENSSL_SOURCE_URI, t.name )
+end
+
+# Extract the openssl builds
+file STATIC_OPENSSL_BUILDDIR => OPENSSL_TARBALL do |t|
+	trace "extracting %s to %s" % [ OPENSSL_TARBALL, STATIC_OPENSSL_BUILDDIR.parent ]
+	STATIC_OPENSSL_BUILDDIR.mkpath
+	run 'tar', '-xzf', OPENSSL_TARBALL.to_s, '-C', STATIC_OPENSSL_BUILDDIR.parent.to_s
+	OPENSSL_MAKEFILE.unlink if OPENSSL_MAKEFILE.exist?
+
+	OPENSSL_PATCHES.each do |patchfile|
+		trace "  applying patch #{patchfile}..."
+		run 'patch', '-Np1', '-d', STATIC_OPENSSL_BUILDDIR.to_s,
+			'-i', File.expand_path( patchfile, BASEDIR )
+	end
+end
+
+CMD_PRELUDE = [
+	'env',
+	"CC=#{CROSS_PREFIX}-gcc",
+	"CFLAGS=-DDSO_WIN32",
+	"AR=#{CROSS_PREFIX}-ar",
+	"RANLIB=#{CROSS_PREFIX}-ranlib"
+]
+
+
+# generate the makefile in a clean build location
+file OPENSSL_MAKEFILE => STATIC_OPENSSL_BUILDDIR do |t|
+	Dir.chdir( STATIC_OPENSSL_BUILDDIR ) do
+		cmd = CMD_PRELUDE.dup
+		cmd << "./Configure" << 'mingw'
+
+		run( *cmd )
+	end
+end
+
+desc "compile static openssl libraries"
+task :openssl_libs => [ LIBSSLEAY32, LIBEAY32 ]
+
+task :compile_static_openssl => OPENSSL_MAKEFILE do |t|
+	Dir.chdir( STATIC_OPENSSL_BUILDDIR ) do
+		cmd = CMD_PRELUDE.dup
+		cmd << 'make' << "-j#{NUM_CPUS}" << 'build_libs'
+
+		run( *cmd )
+	end
+end
+
+desc "compile static #{LIBEAY32}"
+file LIBEAY32 => :compile_static_openssl do |t|
+	FileUtils.cp( STATIC_OPENSSL_BUILDDIR + 'libcrypto.a', LIBEAY32.to_s )
+end
+
+desc "compile static #{LIBSSLEAY32}"
+file LIBSSLEAY32 => :compile_static_openssl do |t|
+	FileUtils.cp( STATIC_OPENSSL_BUILDDIR + 'libssl.a', LIBSSLEAY32.to_s )
+end
+
+
+
+#
+# Static PostgreSQL build tasks
+#
+directory STATIC_POSTGRESQL_BUILDDIR.to_s
+
+
+# postgresql source file should be stored there
+file POSTGRESQL_TARBALL => STATIC_SOURCESDIR do |t|
+	download( POSTGRESQL_SOURCE_URI, t.name )
+end
+
+# Extract the postgresql sources
+file STATIC_POSTGRESQL_BUILDDIR => POSTGRESQL_TARBALL do |t|
+	trace "extracting %s to %s" % [ POSTGRESQL_TARBALL, STATIC_POSTGRESQL_BUILDDIR.parent ]
+	STATIC_POSTGRESQL_BUILDDIR.mkpath
+	run 'tar', '-xzf', POSTGRESQL_TARBALL.to_s, '-C', STATIC_POSTGRESQL_BUILDDIR.parent.to_s
+	mv POSTGRESQL_SHLIB_MAKEFILE, POSTGRESQL_SHLIB_MF_ORIG
+end
+
+# generate the makefile in a clean build location
+file POSTGRESQL_GLOBAL_MAKEFILE => [ STATIC_POSTGRESQL_BUILDDIR, :openssl_libs ] do |t|
+	options = [
+		'--target=i386-mingw32',
+		"--host=#{Rake::ExtensionCompiler.mingw_host}",
+		'--with-openssl',
+		'--without-zlib',
+		'--disable-shared',
+	]
+
+	Dir.chdir( STATIC_POSTGRESQL_BUILDDIR ) do
+		configure_path = STATIC_POSTGRESQL_BUILDDIR + 'configure'
+		cmd = [ configure_path.to_s, *options ]
+		cmd << "CFLAGS=-L#{STATIC_OPENSSL_BUILDDIR}"
+		cmd << "LDFLAGS=-L#{STATIC_OPENSSL_BUILDDIR}"
+		cmd << "LDFLAGS_SL=-L#{STATIC_OPENSSL_BUILDDIR}"
+		cmd << "LIBS=-lwsock32 -lgdi32"
+		cmd << "CPPFLAGS=-I#{STATIC_OPENSSL_BUILDDIR}/include"
+
+		run( *cmd )
+	end
+end
+
+
+# patch the Makefile.shlib -- depend on the build dir so it's only
+# rewritten if the tarball is re-extracted.
+file POSTGRESQL_SHLIB_MAKEFILE => POSTGRESQL_SHLIB_MF_ORIG do |t|
+	tf = Tempfile.new( POSTGRESQL_SHLIB_MAKEFILE.basename )
+	POSTGRESQL_SHLIB_MF_ORIG.open( File::RDONLY ) do |ifh|
+		ifh.each_line do |line|
+			tf.print( line.sub(/^(\s*haslibarule\s*=\s*yes)/, "# \\1 ") )
+		end
+	end
+	tf.close
+
+	FileUtils.mv( tf.path, t.name, :verbose => $trace )
+end
+
+
+# make libpq.a
+file POSTGRESQL_LIB => [ POSTGRESQL_GLOBAL_MAKEFILE, POSTGRESQL_SHLIB_MAKEFILE ] do |t|
+	Dir.chdir( POSTGRESQL_LIB.dirname ) do
+		sh 'make', "-j#{NUM_CPUS}", POSTGRESQL_LIB.basename.to_s, 'PORTNAME=win32'
+	end
+end
+
+
+#desc 'compile static libpg.a'
+task :static_libpq => POSTGRESQL_LIB
+
+desc 'cross compile pg for win32'
+task :cross => [ :mingw32, :static_libpq ]
+
+task :mingw32 do
+	# Use Rake::ExtensionCompiler helpers to find the proper host
+	unless Rake::ExtensionCompiler.mingw_host then
+		warn "You need to install mingw32 cross compile functionality to be able to continue."
+		warn "Please refer to your distribution/package manager documentation about installation."
+		fail
+	end
+end
+

data/ext/compat.c

@@ -0,0 +1,541 @@
+/************************************************
+
+  compat.c -
+
+  Author: matz 
+  created at: Tue May 13 20:07:35 JST 1997
+
+  Author: ematsu
+  modified at: Wed Jan 20 16:41:51 1999
+
+  $Author$
+  $Date$
+************************************************/
+
+#include <ctype.h>
+#include "compat.h"
+
+#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.");
+}
+
+PGresult *
+PQdescribePortal(PGconn *conn, const char *portalName)
+{
+	rb_raise(rb_eStandardError, "PQdescribePortal not supported by this client version.");
+}
+
+int
+PQsendDescribePrepared(PGconn *conn, const char *stmtName)
+{
+	rb_raise(rb_eStandardError, "PQsendDescribePrepared not supported by this client version.");
+}
+
+int
+PQsendDescribePortal(PGconn *conn, const char *portalName)
+{
+	rb_raise(rb_eStandardError, "PQsendDescribePortal not supported by this client version.");
+}
+
+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.");
+}
+
+int
+PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes)
+{
+	rb_raise(rb_eStandardError, "PQsendPrepare not supported by this client version.");
+}
+
+int
+PQserverVersion(const PGconn* conn)
+{
+	rb_raise(rb_eStandardError, "PQserverVersion not supported by this client version.");
+}
+#endif /* PG_BEFORE_080000 */
+
+#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)
+{
+	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.");
+}
+
+int
+PQprotocolVersion(const PGconn *conn)
+{
+	rb_raise(rb_eStandardError, "PQprotocolVersion not supported by this client version.");
+}
+
+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, "PQexecPrepared not supported by this client version.");
+}
+
+int
+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, "PQsendQueryParams not supported by this client version.");
+}
+
+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, "PQsendQueryPrepared not supported by this client version.");
+}
+
+int
+PQputCopyData(PGconn *conn, const char *buffer, int nbytes)
+{
+	rb_raise(rb_eStandardError, "PQputCopyData not supported by this client version.");
+}
+
+int
+PQputCopyEnd(PGconn *conn, const char *errormsg)
+{
+	rb_raise(rb_eStandardError, "PQputCopyEnd not supported by this client version.");
+}
+
+int
+PQgetCopyData(PGconn *conn, char **buffer, int async)
+{
+	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.");
+}
+
+int
+PQftablecol(const PGresult *res, int column_number)
+{
+	rb_raise(rb_eStandardError, "PQftablecol not supported by this client version.");
+}
+
+int
+PQfformat(const PGresult *res, int column_number)
+{
+	rb_raise(rb_eStandardError, "PQfformat not supported by this client version.");
+}
+
+PQnoticeReceiver 
+PQsetNoticeReceiver(PGconn *conn, PQnoticeReceiver proc, void *arg)
+{
+	rb_raise(rb_eStandardError, "PQsetNoticeReceiver not supported by this client version.");
+}
+
+char *
+PQresultErrorField(const PGresult *res, int fieldcode)
+{
+	rb_raise(rb_eStandardError, "PQresultErrorField not supported by this client version.");
+}
+#endif /* PG_BEFORE_070400 */
+
+#ifdef PG_BEFORE_070300
+size_t
+PQescapeStringConn(PGconn *conn, char *to, const char *from, 
+	size_t length, int *error)
+{
+	return PQescapeString(to,from,length);
+}
+
+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.
+
+***************************************************************************
+
+Portions of code after this point were copied from the PostgreSQL source
+distribution, available at http://www.postgresql.org
+
+***************************************************************************
+
+Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
+
+Portions Copyright (c) 1994, The Regents of the University of California
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose, without fee, and without a written agreement
+is hereby granted, provided that the above copyright notice and this
+paragraph and the following two paragraphs appear in all copies.
+
+IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
+LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+
+**************************************************************************/
+
+#ifndef HAVE_PQSETCLIENTENCODING
+int
+PQsetClientEncoding(PGconn *conn, const char *encoding)
+{
+	char        qbuf[128];
+	static const char query[] = "set client_encoding to '%s'";
+	PGresult   *res;
+	int         status;
+
+	if (!conn || PQstatus(conn) != CONNECTION_OK)
+		return -1;
+
+	if (!encoding)
+		return -1;
+
+	/* check query buffer overflow */
+	if (sizeof(qbuf) < (sizeof(query) + strlen(encoding)))
+		return -1;
+
+	/* ok, now send a query */
+	sprintf(qbuf, query, encoding);
+	res = PQexec(conn, qbuf);
+
+	if (res == NULL)
+	return -1;
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	status = -1;
+	else
+	{
+		/*
+		 * In protocol 2 we have to assume the setting will stick, and adjust
+		 * our state immediately.  In protocol 3 and up we can rely on the
+		 * backend to report the parameter value, and we'll change state at
+		 * that time.
+		 */
+		if (PQprotocolVersion(conn) < 3)
+			pqSaveParameterStatus(conn, "client_encoding", encoding);
+		status = 0;             /* everything is ok */
+	}
+	PQclear(res);
+	return status;
+}
+#endif /* HAVE_PQSETCLIENTENCODING */
+
+#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
+