pg 0.13.2-x86-mingw32 → 0.14.0.pre.353-x86-mingw32

data/ext/pg.h

@@ -107,8 +107,8 @@ void init_pg_result                                    _(( void ));
 
 PGconn *pg_get_pgconn	                               _(( VALUE ));
 
-VALUE pg_new_result                                    _(( PGresult *, PGconn * ));
-void pg_check_result                                   _(( VALUE, VALUE ));
+VALUE pg_new_result                                    _(( PGresult *, VALUE ));
+VALUE pg_result_check                                  _(( VALUE ));
 VALUE pg_result_clear                                  _(( VALUE ));
 
 #ifdef M17N_SUPPORTED

data/ext/pg_connection.c

@@ -21,7 +21,7 @@
  *    # Equivalent to:
  *    #  res  = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
  *
- * See the PGresult class for information on working with the results of a query.
+ * See the PG::Result class for information on working with the results of a query.
  *
  */
 VALUE rb_cPGconn;
@@ -31,7 +31,9 @@ static PQnoticeProcessor default_notice_processor = NULL;
 
 static PGconn *pgconn_check( VALUE );
 static VALUE pgconn_finish( VALUE );
-
+#ifdef M17N_SUPPORTED
+static VALUE pgconn_set_default_encoding( VALUE self );
+#endif
 
 /*
  * Global functions
@@ -164,10 +166,6 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 	PGconn *conn = NULL;
 	VALUE conninfo;
 	VALUE error;
-#ifdef M17N_SUPPORTED	
-	rb_encoding *enc;
-	const char *encname;
-#endif
 
 	conninfo = rb_funcall2( rb_cPGconn, rb_intern("parse_connect_args"), argc, argv );
 	conn = PQconnectdb(StringValuePtr(conninfo));
@@ -185,14 +183,7 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 	}
 
 #ifdef M17N_SUPPORTED
-	/* If Ruby has its Encoding.default_internal set, set PostgreSQL's client_encoding 
-	 * to match */
-	if (( enc = rb_default_internal_encoding() )) {
-		encname = pg_get_rb_encoding_as_pg_encoding( enc );
-		if ( PQsetClientEncoding(conn, encname) != 0 )
-			rb_warn( "Failed to set the default_internal encoding to %s: '%s'",
-			         encname, PQerrorMessage(conn) );
-	}
+	pgconn_set_default_encoding( self );
 #endif
 
 	if (rb_block_given_p()) {
@@ -251,6 +242,39 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	return rb_conn;
 }
 
+#ifdef HAVE_PQPING
+/*
+ * call-seq:
+ *    PG::Connection.ping(connection_hash)       -> Fixnum
+ *    PG::Connection.ping(connection_string)     -> Fixnum
+ *    PG::Connection.ping(host, port, options, tty, dbname, login, password) ->  Fixnum
+ *
+ * Check server status.
+ *
+ * Returns one of:
+ * [+PQPING_OK+]
+ *   server is accepting connections
+ * [+PQPING_REJECT+]
+ *   server is alive but rejecting connections
+ * [+PQPING_NO_RESPONSE+]
+ *   could not establish connection
+ * [+PQPING_NO_ATTEMPT+]
+ *   connection not attempted (bad params)
+ */
+static VALUE
+pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
+{
+	PGPing ping;
+	VALUE conninfo;
+	VALUE error;
+
+	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
+	ping     = PQping( StringValuePtr(conninfo) );
+
+	return INT2FIX((int)ping);
+}
+#endif
+
 /*
  * call-seq:
  *    PG::Connection.conndefaults() -> Array
@@ -336,19 +360,6 @@ pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
 }
 
 
-/*
- * call-seq:
- *    PG::Connection.isthreadsafe() -> Boolean
- *
- * Returns +true+ if libpq is thread safe, +false+ otherwise.
- */
-static VALUE
-pgconn_s_isthreadsafe(VALUE self)
-{
-	UNUSED( self );
-	return PQisthreadsafe() ? Qtrue : Qfalse;
-}
-
 /**************************************************************************
  * PG::Connection INSTANCE METHODS
  **************************************************************************/
@@ -733,12 +744,12 @@ pgconn_connection_used_password(VALUE self)
 
 /*
  * call-seq:
- *    conn.exec(sql [, params, result_format ] ) -> PGresult
+ *    conn.exec(sql [, params, result_format ] ) -> PG::Result
  *    conn.exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL.
- * Returns a PGresult instance on success.
- * On failure, it raises a PGError exception.
+ * Returns a PG::Result instance on success.
+ * On failure, it raises a PG::Error.
  *
  * +params+ is an optional array of the bind parameters for the SQL query.
  * Each element of the +params+ array may be either:
@@ -764,7 +775,7 @@ pgconn_connection_used_password(VALUE self)
  * for binary.
  *
  * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PGresult object will  automatically be cleared when the block terminates. 
+ * and the PG::Result object will  automatically be cleared when the block terminates. 
  * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
@@ -793,8 +804,8 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	/* If called with no parameters, use PQexec */
 	if(NIL_P(params)) {
 		result = PQexec(conn, StringValuePtr(command));
-		rb_pgresult = pg_new_result(result, conn);
-		pg_check_result(self, rb_pgresult);
+		rb_pgresult = pg_new_result(result, self);
+		pg_result_check(rb_pgresult);
 		if (rb_block_given_p()) {
 			return rb_ensure(rb_yield, rb_pgresult, pg_result_clear, rb_pgresult);
 		}
@@ -876,8 +887,8 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	xfree(paramLengths);
 	xfree(paramFormats);
 
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	if (rb_block_given_p()) {
 		return rb_ensure(rb_yield, rb_pgresult, 
 			pg_result_clear, rb_pgresult);
@@ -887,11 +898,11 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.prepare(stmt_name, sql [, param_types ] ) -> PGresult
+ *    conn.prepare(stmt_name, sql [, param_types ] ) -> PG::Result
  *
  * Prepares statement _sql_ with name _name_ to be executed later.
- * Returns a PGresult instance on success.
- * On failure, it raises a PGError exception.
+ * Returns a PG::Result instance on success.
+ * On failure, it raises a PG::Error.
  *
  * +param_types+ is an optional parameter to specify the Oids of the 
  * types of the parameters.
@@ -939,19 +950,19 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 
 	xfree(paramTypes);
 
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	return rb_pgresult;
 }
 
 /*
  * call-seq:
- *    conn.exec_prepared(statement_name [, params, result_format ] ) -> PGresult
+ *    conn.exec_prepared(statement_name [, params, result_format ] ) -> PG::Result
  *    conn.exec_prepared(statement_name [, params, result_format ] ) {|pg_result| block }
  *
  * Execute prepared named statement specified by _statement_name_.
- * Returns a PGresult instance on success.
- * On failure, it raises a PGError exception.
+ * Returns a PG::Result instance on success.
+ * On failure, it raises a PG::Error.
  *
  * +params+ is an array of the optional bind parameters for the 
  * SQL query. Each element of the +params+ array may be either:
@@ -970,7 +981,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * for binary.
  *
  * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PGresult object will  automatically be cleared when the block terminates. 
+ * and the PG::Result object will  automatically be cleared when the block terminates. 
  * In this instance, <code>conn.exec_prepared</code> returns the value of the block.
  */
 static VALUE
@@ -1063,8 +1074,8 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 	xfree(paramLengths);
 	xfree(paramFormats);
 
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	if (rb_block_given_p()) {
 		return rb_ensure(rb_yield, rb_pgresult, 
 			pg_result_clear, rb_pgresult);
@@ -1074,7 +1085,7 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.describe_prepared( statement_name ) -> PGresult
+ *    conn.describe_prepared( statement_name ) -> PG::Result
  *
  * Retrieve information about the prepared statement
  * _statement_name_.
@@ -1094,15 +1105,15 @@ pgconn_describe_prepared(VALUE self, VALUE stmt_name)
 		stmt = StringValuePtr(stmt_name);
 	}
 	result = PQdescribePrepared(conn, stmt);
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	return rb_pgresult;
 }
 
 
 /*
  * call-seq:
- *    conn.describe_portal( portal_name ) -> PGresult
+ *    conn.describe_portal( portal_name ) -> PG::Result
  *
  * Retrieve information about the portal _portal_name_.
  */
@@ -1122,17 +1133,17 @@ pgconn_describe_portal(self, stmt_name)
 		stmt = StringValuePtr(stmt_name);
 	}
 	result = PQdescribePortal(conn, stmt);
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	return rb_pgresult;
 }
 
 
 /*
  * call-seq:
- *    conn.make_empty_pgresult( status ) -> PGresult
+ *    conn.make_empty_pgresult( status ) -> PG::Result
  *
- * Constructs and empty PGresult with status _status_.
+ * Constructs and empty PG::Result with status _status_.
  * _status_ may be one of:
  * * +PGRES_EMPTY_QUERY+
  * * +PGRES_COMMAND_OK+
@@ -1142,6 +1153,7 @@ pgconn_describe_portal(self, stmt_name)
  * * +PGRES_BAD_RESPONSE+
  * * +PGRES_NONFATAL_ERROR+
  * * +PGRES_FATAL_ERROR+
+ * * +PGRES_COPY_BOTH+
  */
 static VALUE
 pgconn_make_empty_pgresult(VALUE self, VALUE status)
@@ -1150,8 +1162,8 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
 	VALUE rb_pgresult;
 	PGconn *conn = pg_get_pgconn(self);
 	result = PQmakeEmptyPGresult(conn, NUM2INT(status));
-	rb_pgresult = pg_new_result(result, conn);
-	pg_check_result(self, rb_pgresult);
+	rb_pgresult = pg_new_result(result, self);
+	pg_result_check(rb_pgresult);
 	return rb_pgresult;
 }
 
@@ -1290,13 +1302,79 @@ pgconn_s_unescape_bytea(VALUE self, VALUE str)
 	return ret;
 }
 
+#ifdef HAVE_PQESCAPELITERAL
+/*
+ * call-seq:
+ *    conn.escape_literal( str ) -> String
+ *
+ * Escape an arbitrary String +str+ as a literal.
+ */
+static VALUE
+pgconn_escape_literal(VALUE self, VALUE string)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	char *escaped = NULL;
+	VALUE error;
+	VALUE result = Qnil;
+
+	Check_Type(string, T_STRING);
+
+	escaped = PQescapeLiteral(conn, RSTRING_PTR(string), RSTRING_LEN(string));
+	if (escaped == NULL)
+	{
+		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		rb_iv_set(error, "@connection", self);
+		rb_exc_raise(error);
+		return Qnil;
+	}
+	result = rb_str_new2(escaped);
+	PQfreemem(escaped);
+	OBJ_INFECT(result, string);
+
+	return result;
+}
+#endif
+
+#ifdef HAVE_PQESCAPEIDENTIFIER
+/*
+ * call-seq:
+ *    conn.escape_identifier( str ) -> String
+ *
+ * Escape an arbitrary String +str+ as an identifier.
+ */
+static VALUE
+pgconn_escape_identifier(VALUE self, VALUE string)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	char *escaped = NULL;
+	VALUE error;
+	VALUE result = Qnil;
+
+	Check_Type(string, T_STRING);
+
+	escaped = PQescapeIdentifier(conn, RSTRING_PTR(string), RSTRING_LEN(string));
+	if (escaped == NULL)
+	{
+		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		rb_iv_set(error, "@connection", self);
+		rb_exc_raise(error);
+		return Qnil;
+	}
+	result = rb_str_new2(escaped);
+	PQfreemem(escaped);
+	OBJ_INFECT(result, string);
+
+	return result;
+}
+#endif
+
 /*
  * call-seq:
  *    conn.send_query(sql [, params, result_format ] ) -> nil
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL for
  * asynchronous processing, and immediately returns.
- * On failure, it raises a PGError exception.
+ * On failure, it raises a PG::Error.
  *
  * +params+ is an optional array of the bind parameters for the SQL query.
  * Each element of the +params+ array may be either:
@@ -1442,7 +1520,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
  *
  * Prepares statement _sql_ with name _name_ to be executed later.
  * Sends prepare command asynchronously, and returns immediately.
- * On failure, it raises a PGError exception.
+ * On failure, it raises a PG::Error.
  *
  * +param_types+ is an optional parameter to specify the Oids of the 
  * types of the parameters.
@@ -1505,7 +1583,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  *
  * Execute prepared named statement specified by _statement_name_
  * asynchronously, and returns immediately.
- * On failure, it raises a PGError exception.
+ * On failure, it raises a PG::Error.
  *
  * +params+ is an array of the optional bind parameters for the 
  * SQL query. Each element of the +params+ array may be either:
@@ -1667,7 +1745,7 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
 
 /*
  * call-seq:
- *    conn.get_result() -> PGresult
+ *    conn.get_result() -> PG::Result
  *    conn.get_result() {|pg_result| block }
  *
  * Blocks waiting for the next result from a call to
@@ -1678,7 +1756,7 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
  * you will not be able to issue further commands.
  *
  * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PGresult object will  automatically be cleared when the block terminates. 
+ * and the PG::Result object will  automatically be cleared when the block terminates. 
  * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
@@ -1691,7 +1769,7 @@ pgconn_get_result(VALUE self)
 	result = PQgetResult(conn);
 	if(result == NULL)
 		return Qnil;
-	rb_pgresult = pg_new_result(result, conn);
+	rb_pgresult = pg_new_result(result, self);
 	if (rb_block_given_p()) {
 		return rb_ensure(rb_yield, rb_pgresult,
 			pg_result_clear, rb_pgresult);
@@ -1797,7 +1875,7 @@ pgconn_isnonblocking(self)
  * Returns +true+ if data is successfully flushed, +false+
  * if not (can only return +false+ if connection is
  * nonblocking.
- * Raises PGError exception if some other failure occurred.
+ * Raises PG::Error if some other failure occurred.
  */
 static VALUE
 pgconn_flush(self)
@@ -2243,7 +2321,7 @@ notice_receiver_proxy(void *arg, const PGresult *result)
  * the work in the notice receiver.
  *
  * This function takes a new block to act as the handler, which should
- * accept a single parameter that will be a PGresult object, and returns 
+ * accept a single parameter that will be a PG::Result object, and returns 
  * the Proc object previously set, or +nil+ if it was previously the default.
  *
  * If you pass no arguments, it will reset the handler to the default.
@@ -2387,19 +2465,19 @@ pgconn_transaction(VALUE self)
 
 	if (rb_block_given_p()) {
 		result = PQexec(conn, "BEGIN");
-		rb_pgresult = pg_new_result(result, conn);
-		pg_check_result(self, rb_pgresult);
+		rb_pgresult = pg_new_result(result, self);
+		pg_result_check(rb_pgresult);
 		rb_protect(rb_yield, self, &status);
 		if(status == 0) {
 			result = PQexec(conn, "COMMIT");
-			rb_pgresult = pg_new_result(result, conn);
-			pg_check_result(self, rb_pgresult);
+			rb_pgresult = pg_new_result(result, self);
+			pg_result_check(rb_pgresult);
 		}
 		else {
 			/* exception occurred, ROLLBACK and re-raise */
 			result = PQexec(conn, "ROLLBACK");
-			rb_pgresult = pg_new_result(result, conn);
-			pg_check_result(self, rb_pgresult);
+			rb_pgresult = pg_new_result(result, self);
+			pg_result_check(rb_pgresult);
 			rb_jump_tag(status);
 		}
 
@@ -2664,7 +2742,7 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 
 /*
  * call-seq:
- *    conn.get_last_result( ) -> PGresult
+ *    conn.get_last_result( ) -> PG::Result
  *
  * This function retrieves all available results
  * on the current connection (from previously issued
@@ -2697,8 +2775,8 @@ pgconn_get_last_result(VALUE self)
 	}
 
 	if (prev) {
-		rb_pgresult = pg_new_result(prev, conn);
-		pg_check_result(self, rb_pgresult);
+		rb_pgresult = pg_new_result( prev, self );
+		pg_result_check(rb_pgresult);
 	}
 
 	return rb_pgresult;
@@ -2707,7 +2785,7 @@ pgconn_get_last_result(VALUE self)
 
 /*
  * call-seq:
- *    conn.async_exec(sql [, params, result_format ] ) -> PGresult
+ *    conn.async_exec(sql [, params, result_format ] ) -> PG::Result
  *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * This function has the same behavior as #exec,
@@ -2745,7 +2823,7 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
  *    conn.lo_creat( [mode] ) -> Fixnum
  *
  * Creates a large object with mode _mode_. Returns a large object Oid.
- * On failure, it raises PGError exception.
+ * On failure, it raises PG::Error.
  */
 static VALUE
 pgconn_locreat(int argc, VALUE *argv, VALUE self)
@@ -2772,7 +2850,7 @@ pgconn_locreat(int argc, VALUE *argv, VALUE self)
  *    conn.lo_create( oid ) -> Fixnum
  *
  * Creates a large object with oid _oid_. Returns the large object Oid.
- * On failure, it raises PGError exception.
+ * On failure, it raises PG::Error.
  */
 static VALUE
 pgconn_locreate(VALUE self, VALUE in_lo_oid)
@@ -2794,7 +2872,7 @@ pgconn_locreate(VALUE self, VALUE in_lo_oid)
  *
  * Import a file to a large object. Returns a large object Oid.
  *
- * On failure, it raises a PGError exception.
+ * On failure, it raises a PG::Error.
  */
 static VALUE
 pgconn_loimport(VALUE self, VALUE filename)
@@ -3107,9 +3185,8 @@ pgconn_internal_encoding_set(VALUE self, VALUE enc)
  * call-seq:
  *   conn.external_encoding() -> Encoding
  *
- * defined in Ruby 1.9 or later.
- * - Returns the server_encoding of the connected database as a Ruby Encoding object.
- * - Maps 'SQL_ASCII' to ASCII-8BIT.
+ * Return the +server_encoding+ of the connected database as a Ruby Encoding object.
+ * The <tt>SQL_ASCII</tt> encoding is mapped to to <tt>ASCII_8BIT</tt>.
  */
 static VALUE
 pgconn_external_encoding(VALUE self)
@@ -3131,6 +3208,35 @@ pgconn_external_encoding(VALUE self)
 	return encoding;
 }
 
+
+
+/*
+ * call-seq:
+ *   conn.set_default_encoding() -> Encoding
+ *
+ * If Ruby has its Encoding.default_internal set, set PostgreSQL's client_encoding
+ * to match. Returns the new Encoding, or +nil+ if the default internal encoding
+ * wasn't set.
+ */
+static VALUE
+pgconn_set_default_encoding( VALUE self )
+{
+	PGconn *conn = pg_get_pgconn( self );
+	rb_encoding *enc;
+	const char *encname;
+
+	if (( enc = rb_default_internal_encoding() )) {
+		encname = pg_get_rb_encoding_as_pg_encoding( enc );
+		if ( PQsetClientEncoding(conn, encname) != 0 )
+			rb_warn( "Failed to set the default_internal encoding to %s: '%s'",
+			         encname, PQerrorMessage(conn) );
+		return rb_enc_from_encoding( enc );
+	} else {
+		return Qnil;
+	}
+}
+
+
 #endif /* M17N_SUPPORTED */
 
 
@@ -3152,11 +3258,13 @@ init_pg_connection()
 	SINGLETON_ALIAS(rb_cPGconn, "escape", "escape_string");
 	rb_define_singleton_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	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, 2);
 	rb_define_singleton_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 	rb_define_singleton_method(rb_cPGconn, "connect_start", pgconn_s_connect_start, -1);
 	rb_define_singleton_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
+#ifdef HAVE_PQPING
+	rb_define_singleton_method(rb_cPGconn, "ping", pgconn_s_ping, -1);
+#endif
 
 	/******     PG::Connection INSTANCE METHODS: Connection Control     ******/
 	rb_define_method(rb_cPGconn, "initialize", pgconn_init, -1);
@@ -3199,6 +3307,12 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "make_empty_pgresult", pgconn_make_empty_pgresult, 1);
 	rb_define_method(rb_cPGconn, "escape_string", pgconn_s_escape, 1);
 	rb_define_alias(rb_cPGconn, "escape", "escape_string");
+#ifdef HAVE_PQESCAPELITERAL
+	rb_define_method(rb_cPGconn, "escape_literal", pgconn_escape_literal, 1);
+#endif
+#ifdef HAVE_PQESCAPEIDENTIFIER
+	rb_define_method(rb_cPGconn, "escape_identifier", pgconn_escape_identifier, 1);
+#endif
 	rb_define_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	rb_define_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
 
@@ -3281,6 +3395,7 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "internal_encoding", pgconn_internal_encoding, 0);
 	rb_define_method(rb_cPGconn, "internal_encoding=", pgconn_internal_encoding_set, 1);
 	rb_define_method(rb_cPGconn, "external_encoding", pgconn_external_encoding, 0);
+	rb_define_method(rb_cPGconn, "set_default_encoding", pgconn_set_default_encoding, 0);
 #endif /* M17N_SUPPORTED */
 
 }