do_postgres 0.9.12-x86-mingw32 → 0.10.0-x86-mingw32

data/{History.txt → HISTORY.markdown}

@@ -1,8 +1,12 @@
-== 0.9.11 2009-01-19
+## 0.9.12 2009-05-17
+* Improvements
+  * Windows support
+
+## 0.9.11 2009-01-19
 * Improvements
   * Ruby 1.9 support
 * Fixes
   * Fix build issue on certain platforms introduces with 0.9.10
 
-== 0.9.9 2008-11-27
+## 0.9.9 2008-11-27
 * No changes since 0.9.8

data/Manifest.txt

@@ -1,8 +1,8 @@
 .gitignore
-History.txt
+HISTORY.markdown
 LICENSE
 Manifest.txt
-README.txt
+README.markdown
 Rakefile
 autobuild.rb
 buildfile

data/{README.txt → README.markdown}

@@ -1,3 +1,4 @@
-= do_postgres
+do_postgres
+===========
 
 A PostgreSQL driver for DataObjects

data/Rakefile

@@ -8,9 +8,9 @@ require 'lib/do_postgres/version'
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
 WINDOWS = Gem.win_platform?
-SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
+SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
 BINARY_VERSION = '5.0.77'
 
-Dir['tasks/*.rake'].each { |f| import f }
+Dir['tasks/*.rake'].sort.each { |f| import f }
 
 CLEAN.include(%w[ {tmp,pkg}/ **/*.{o,so,bundle,jar,log,a,gem,dSYM,obj,pdb,exp,DS_Store,rbc,db} ext/do_postgres_ext/Makefile ext-java/target ])

data/ext/do_postgres_ext/do_postgres_ext.c

@@ -2,6 +2,7 @@
 #include <postgres.h>
 #include <mb/pg_wchar.h>
 #include <catalog/pg_type.h>
+#include <utils/errcodes.h>
 
 /* Undefine constants Postgres also defines */
 #undef PACKAGE_BUGREPORT
@@ -30,14 +31,13 @@
 #include <math.h>
 #include <ctype.h>
 #include <time.h>
+#include "error.h"
 
 #define ID_CONST_GET rb_intern("const_get")
 #define ID_PATH rb_intern("path")
 #define ID_NEW rb_intern("new")
 #define ID_ESCAPE rb_intern("escape_sql")
 
-#define RUBY_STRING(char_ptr) rb_str_new2(char_ptr)
-#define TAINTED_STRING(name, length) rb_tainted_str_new(name, length)
 #define CONST_GET(scope, constant) (rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant)))
 #define POSTGRES_CLASS(klass, parent) (rb_define_class_under(mPostgres, klass, parent))
 #define DEBUG(value) data_objects_debug(value)
@@ -55,6 +55,36 @@
 #define RARRAY_LEN(a) RARRAY(a)->len
 #endif
 
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+
+#define DO_STR_NEW2(str, encoding) \
+  ({ \
+    VALUE _string = rb_str_new2((const char *)str); \
+    if(encoding != -1) { \
+      rb_enc_associate_index(_string, encoding); \
+    } \
+    _string; \
+  })
+
+#define DO_STR_NEW(str, len, encoding) \
+  ({ \
+    VALUE _string = rb_str_new((const char *)str, (long)len); \
+    if(encoding != -1) { \
+      rb_enc_associate_index(_string, encoding); \
+    } \
+    _string; \
+  })
+
+#else
+
+#define DO_STR_NEW2(str, doc) \
+  rb_str_new2((const char *)str)
+
+#define DO_STR_NEW(str, len, doc) \
+  rb_str_new((const char *)str, (long)len)
+#endif
+
 
 // To store rb_intern values
 static ID ID_NEW_DATE;
@@ -66,6 +96,7 @@ static ID ID_RATIONAL;
 
 static VALUE mExtlib;
 static VALUE mDO;
+static VALUE mEncoding;
 static VALUE cDO_Quoting;
 static VALUE cDO_Connection;
 static VALUE cDO_Command;
@@ -84,7 +115,8 @@ static VALUE cResult;
 static VALUE cReader;
 
 static VALUE eArgumentError;
-static VALUE ePostgresError;
+static VALUE eConnectionError;
+static VALUE eDataError;
 
 static void data_objects_debug(VALUE string, struct timeval* start) {
   struct timeval stop;
@@ -116,7 +148,7 @@ static char * get_uri_option(VALUE query_hash, char * key) {
 
   if(!rb_obj_is_kind_of(query_hash, rb_cHash)) { return NULL; }
 
-  query_value = rb_hash_aref(query_hash, RUBY_STRING(key));
+  query_value = rb_hash_aref(query_hash, rb_str_new2(key));
 
   if (Qnil != query_value) {
     value = StringValuePtr(query_value);
@@ -219,7 +251,7 @@ static VALUE parse_date_time(const char *date) {
       hour_offset = 0;
       minute_offset = 0;
       sec = 0;
-    }  
+    }
     // We read the Date and Time, default to the current locale's offset
 
     // Get localtime
@@ -241,7 +273,7 @@ static VALUE parse_date_time(const char *date) {
 
   } else {
     // Something went terribly wrong
-    rb_raise(ePostgresError, "Couldn't parse date: %s", date);
+    rb_raise(eDataError, "Couldn't parse date: %s", date);
   }
 
   jd = jd_from_date(year, month, day);
@@ -327,16 +359,16 @@ static VALUE infer_ruby_type(Oid type) {
   }
 }
 
-static VALUE typecast(const char *value, long length, const VALUE type) {
+static VALUE typecast(const char *value, long length, const VALUE type, int encoding) {
 
   if (type == rb_cInteger) {
     return rb_cstr2inum(value, 10);
   } else if (type == rb_cString) {
-    return TAINTED_STRING(value, length);
+    return DO_STR_NEW(value, length, encoding);
   } else if (type == rb_cFloat) {
     return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
   } else if (type == rb_cBigDecimal) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING(value, length));
+    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new(value, length));
   } else if (type == rb_cDate) {
     return parse_date(value);
   } else if (type == rb_cDateTime) {
@@ -348,21 +380,55 @@ static VALUE typecast(const char *value, long length, const VALUE type) {
   } else if (type == rb_cByteArray) {
     size_t new_length = 0;
     char* unescaped = (char *)PQunescapeBytea((unsigned char*)value, &new_length);
-    VALUE byte_array = rb_funcall(rb_cByteArray, ID_NEW, 1, TAINTED_STRING(unescaped, new_length));
+    VALUE byte_array = rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new(unescaped, new_length));
     PQfreemem(unescaped);
     return byte_array;
   } else if (type == rb_cClass) {
-    return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, TAINTED_STRING(value, length));
+    return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, rb_str_new(value, length));
   } else if (type == rb_cObject) {
-    return rb_marshal_load(rb_str_new2(value));
+    return rb_marshal_load(rb_str_new(value, length));
   } else if (type == rb_cNilClass) {
     return Qnil;
   } else {
-    return TAINTED_STRING(value, length);
+    return DO_STR_NEW(value, length, encoding);
   }
 
 }
 
+static void raise_error(VALUE self, PGresult *result, VALUE query) {
+  VALUE exception;
+  char *message;
+  char *sqlstate;
+  int postgres_errno;
+
+  message  = PQresultErrorMessage(result);
+  sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
+  postgres_errno = MAKE_SQLSTATE(sqlstate[0], sqlstate[1], sqlstate[2], sqlstate[3], sqlstate[4]);
+  PQclear(result);
+
+  const char *exception_type = "SQLError";
+
+  struct errcodes *errs;
+
+  for (errs = errors; errs->error_name; errs++) {
+    if(errs->error_no == postgres_errno) {
+      exception_type = errs->exception;
+      break;
+    }
+  }
+
+  VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
+
+  exception = rb_funcall(CONST_GET(mDO, exception_type), ID_NEW, 5,
+                         rb_str_new2(message),
+                         INT2NUM(postgres_errno),
+                         rb_str_new2(sqlstate),
+                         query,
+                         uri);
+  rb_exc_raise(exception);
+}
+
+
 /* ====== Public API ======= */
 static VALUE cConnection_dispose(VALUE self) {
   VALUE connection_container = rb_iv_get(self, "@connection");
@@ -449,7 +515,8 @@ static VALUE cConnection_quote_string(VALUE self, VALUE string) {
   // Wrap the escaped string in single-quotes, this is DO's convention
   escaped[quoted_length + 1] = escaped[0] = '\'';
 
-  result = rb_str_new(escaped, quoted_length + 2);
+  result = DO_STR_NEW(escaped, quoted_length + 2, FIX2INT(rb_iv_get(self, "@encoding_id")));
+
   free(escaped);
   return result;
 }
@@ -474,14 +541,16 @@ static VALUE cConnection_quote_byte_array(VALUE self, VALUE string) {
   // Wrap the escaped string in single-quotes, this is DO's convention (replace trailing \0)
   escaped_quotes[quoted_length] = escaped_quotes[0] = '\'';
 
-  result = TAINTED_STRING((char*)escaped_quotes, quoted_length + 1);
+  result = rb_str_new((const char *)escaped_quotes, quoted_length + 1);
   PQfreemem(escaped);
   free(escaped_quotes);
   return result;
 }
 
+static void full_connect(VALUE self, PGconn *db);
+
 #ifdef _WIN32
-static PGresult* cCommand_execute_sync(PGconn *db, VALUE query) {
+static PGresult* cCommand_execute_sync(VALUE self, PGconn *db, VALUE query) {
   PGresult *response;
   struct timeval start;
   char* str = StringValuePtr(query);
@@ -499,11 +568,15 @@ static PGresult* cCommand_execute_sync(PGconn *db, VALUE query) {
       PQreset(db);
       if (PQstatus(db) == CONNECTION_OK) {
         response = PQexec(db, str);
+      } else {
+        VALUE connection = rb_iv_get(self, "@connection");
+        full_connect(connection, db);
+        response = PQexec(db, str);
       }
     }
 
     if(response == NULL) {
-      rb_raise(ePostgresError, PQerrorMessage(db));
+      rb_raise(eConnectionError, PQerrorMessage(db));
     }
   }
 
@@ -511,7 +584,7 @@ static PGresult* cCommand_execute_sync(PGconn *db, VALUE query) {
   return response;
 }
 #else
-static PGresult* cCommand_execute_async(PGconn *db, VALUE query) {
+static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
   int socket_fd;
   int retval;
   fd_set rset;
@@ -530,11 +603,15 @@ static PGresult* cCommand_execute_async(PGconn *db, VALUE query) {
       PQreset(db);
       if (PQstatus(db) == CONNECTION_OK) {
         retval = PQsendQuery(db, str);
+      } else {
+        VALUE connection = rb_iv_get(self, "@connection");
+        full_connect(connection, db);
+        retval = PQsendQuery(db, str);
       }
     }
 
     if(!retval) {
-      rb_raise(ePostgresError, PQerrorMessage(db));
+      rb_raise(eConnectionError, PQerrorMessage(db));
     }
   }
 
@@ -554,7 +631,7 @@ static PGresult* cCommand_execute_async(PGconn *db, VALUE query) {
       }
 
       if (PQconsumeInput(db) == 0) {
-          rb_raise(ePostgresError, PQerrorMessage(db));
+          rb_raise(eConnectionError, PQerrorMessage(db));
       }
 
       if (PQisBusy(db) == 0) {
@@ -568,52 +645,94 @@ static PGresult* cCommand_execute_async(PGconn *db, VALUE query) {
 #endif
 
 static VALUE cConnection_initialize(VALUE self, VALUE uri) {
-  PGresult *result = NULL;
-  VALUE r_host, r_user, r_password, r_path, r_port, r_query, r_options;
-  char *host = NULL, *user = NULL, *password = NULL, *path;
-  char *database = "", *port = "5432";
-  char *encoding = NULL;
-  char *search_path = NULL;
-  char *search_path_query = NULL;
-  char *backslash_off = "SET backslash_quote = off";
-  char *standard_strings_on = "SET standard_conforming_strings = on";
-  char *warning_messages = "SET client_min_messages = warning";
+  VALUE r_host, r_user, r_password, r_path, r_query, r_port;
 
-  PGconn *db;
+  PGconn *db = NULL;
+
+  rb_iv_set(self, "@using_socket", Qfalse);
 
   r_host = rb_funcall(uri, rb_intern("host"), 0);
-  if ( Qnil != r_host ) {
-    host = StringValuePtr(r_host);
+  if (Qnil != r_host) {
+    rb_iv_set(self, "@host", r_host);
   }
 
   r_user = rb_funcall(uri, rb_intern("user"), 0);
   if (Qnil != r_user) {
-    user = StringValuePtr(r_user);
+    rb_iv_set(self, "@user", r_user);
   }
 
   r_password = rb_funcall(uri, rb_intern("password"), 0);
   if (Qnil != r_password) {
-    password = StringValuePtr(r_password);
+    rb_iv_set(self, "@password", r_password);
   }
 
   r_path = rb_funcall(uri, rb_intern("path"), 0);
-  path = StringValuePtr(r_path);
   if (Qnil != r_path) {
-    database = strtok(path, "/");
-  }
-
-  if (NULL == database || 0 == strlen(database)) {
-    rb_raise(ePostgresError, "Database must be specified");
+    rb_iv_set(self, "@path", r_path);
   }
 
   r_port = rb_funcall(uri, rb_intern("port"), 0);
   if (Qnil != r_port) {
     r_port = rb_funcall(r_port, rb_intern("to_s"), 0);
-    port = StringValuePtr(r_port);
+    rb_iv_set(self, "@port", r_port);
   }
 
   // Pull the querystring off the URI
   r_query = rb_funcall(uri, rb_intern("query"), 0);
+  rb_iv_set(self, "@query", r_query);
+
+  const char* encoding = get_uri_option(r_query, "encoding");
+  if (!encoding) { encoding = get_uri_option(r_query, "charset"); }
+  if (!encoding) { encoding = "UTF-8"; }
+
+  rb_iv_set(self, "@encoding", rb_str_new2(encoding));
+
+  full_connect(self, db);
+
+  rb_iv_set(self, "@uri", uri);
+
+  return Qtrue;
+}
+
+static void full_connect(VALUE self, PGconn *db) {
+
+  PGresult *result = NULL;
+  VALUE r_host, r_user, r_password, r_path, r_port, r_query, r_options;
+  char *host = NULL, *user = NULL, *password = NULL, *path;
+  char *database = "", *port = "5432";
+  VALUE encoding = Qnil;
+  char *search_path = NULL;
+  char *search_path_query = NULL;
+  char *backslash_off = "SET backslash_quote = off";
+  char *standard_strings_on = "SET standard_conforming_strings = on";
+  char *warning_messages = "SET client_min_messages = warning";
+
+  if((r_host = rb_iv_get(self, "@host")) != Qnil) {
+    host     = StringValuePtr(r_host);
+  }
+
+  if((r_user = rb_iv_get(self, "@user")) != Qnil) {
+    user     = StringValuePtr(r_user);
+  }
+
+  if((r_password = rb_iv_get(self, "@password")) != Qnil) {
+    password = StringValuePtr(r_password);
+  }
+
+  if((r_port = rb_iv_get(self, "@port")) != Qnil) {
+    port = StringValuePtr(r_port);
+  }
+
+  if((r_path = rb_iv_get(self, "@path")) != Qnil) {
+    path = StringValuePtr(r_path);
+    database = strtok(path, "/");
+  }
+
+  if (NULL == database || 0 == strlen(database)) {
+    rb_raise(eConnectionError, "Database must be specified");
+  }
+
+  r_query        = rb_iv_get(self, "@query");
 
   search_path = get_uri_option(r_query, "search_path");
 
@@ -628,81 +747,78 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
   );
 
   if ( PQstatus(db) == CONNECTION_BAD ) {
-    rb_raise(ePostgresError, PQerrorMessage(db));
+    rb_raise(eConnectionError, PQerrorMessage(db));
   }
 
   if (search_path != NULL) {
     search_path_query = (char *)calloc(256, sizeof(char));
     snprintf(search_path_query, 256, "set search_path to %s;", search_path);
     r_query = rb_str_new2(search_path_query);
-    result = cCommand_execute(db, r_query);
+    result = cCommand_execute(self, db, r_query);
 
     if (PQresultStatus(result) != PGRES_COMMAND_OK) {
       free(search_path_query);
-      rb_raise(ePostgresError, PQresultErrorMessage(result));
+      raise_error(self, result, r_query);
     }
 
     free(search_path_query);
   }
 
   r_options = rb_str_new2(backslash_off);
-  result = cCommand_execute(db, r_options);
+  result = cCommand_execute(self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn(PQresultErrorMessage(result));
   }
 
   r_options = rb_str_new2(standard_strings_on);
-  result = cCommand_execute(db, r_options);
+  result = cCommand_execute(self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn(PQresultErrorMessage(result));
   }
 
   r_options = rb_str_new2(warning_messages);
-  result = cCommand_execute(db, r_options);
+  result = cCommand_execute(self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn(PQresultErrorMessage(result));
   }
 
-  encoding = get_uri_option(r_query, "encoding");
-  if (!encoding) { encoding = get_uri_option(r_query, "charset"); }
-  if (!encoding) { encoding = "utf8"; }
+  encoding = rb_iv_get(self, "@encoding");
 
 #ifdef HAVE_PQSETCLIENTENCODING
-  if(PQsetClientEncoding(db, encoding)) {
-    rb_raise(ePostgresError, "Couldn't set encoding: %s", encoding);
+  VALUE pg_encoding = rb_hash_aref(CONST_GET(mEncoding, "MAP"), encoding);
+  if(pg_encoding != Qnil) {
+    if(PQsetClientEncoding(db, RSTRING_PTR(pg_encoding))) {
+      rb_raise(eConnectionError, "Couldn't set encoding: %s", RSTRING_PTR(encoding));
+    } else {
+#ifdef HAVE_RUBY_ENCODING_H
+      rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(RSTRING_PTR(encoding))));
+#endif
+      rb_iv_set(self, "@pg_encoding", pg_encoding);
+    }
+  } else {
+    rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL\n", RSTRING_PTR(encoding));
+    rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
+#endif
+    rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8"));
   }
 #endif
-
-  rb_iv_set(self, "@uri", uri);
   rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
-
-  return Qtrue;
 }
 
 static VALUE cConnection_character_set(VALUE self) {
-  VALUE connection_container = rb_iv_get(self, "@connection");
-  PGconn *db;
-
-  const char *encoding;
-
-  if (Qnil == connection_container)
-    return Qfalse;
-
-  db = DATA_PTR(connection_container);
-
-  encoding = pg_encoding_to_char(PQclientEncoding(db));
-
-  return rb_funcall(RUBY_STRING(encoding), rb_intern("downcase"), 0);
+  return rb_iv_get(self, "@encoding");
 }
 
 static VALUE cCommand_execute_non_query(int argc, VALUE *argv[], VALUE self) {
   VALUE connection = rb_iv_get(self, "@connection");
   VALUE postgres_connection = rb_iv_get(connection, "@connection");
   if (Qnil == postgres_connection) {
-    rb_raise(ePostgresError, "This connection has already been closed.");
+    rb_raise(eConnectionError, "This connection has already been closed.");
   }
 
   PGconn *db = DATA_PTR(postgres_connection);
@@ -714,7 +830,7 @@ static VALUE cCommand_execute_non_query(int argc, VALUE *argv[], VALUE self) {
 
   VALUE query = build_query_from_args(self, argc, argv);
 
-  response = cCommand_execute(db, query);
+  response = cCommand_execute(self, db, query);
 
   status = PQresultStatus(response);
 
@@ -727,10 +843,7 @@ static VALUE cCommand_execute_non_query(int argc, VALUE *argv[], VALUE self) {
     affected_rows = INT2NUM(atoi(PQcmdTuples(response)));
   }
   else {
-    char *message = PQresultErrorMessage(response);
-    char *sqlstate = PQresultErrorField(response, PG_DIAG_SQLSTATE);
-    PQclear(response);
-    rb_raise(ePostgresError, "(sql_state=%s) %sQuery: %s\n", sqlstate, message, StringValuePtr(query));
+    raise_error(self, response, query);
   }
 
   PQclear(response);
@@ -749,7 +862,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv[], VALUE self) {
   VALUE connection = rb_iv_get(self, "@connection");
   VALUE postgres_connection = rb_iv_get(connection, "@connection");
   if (Qnil == postgres_connection) {
-    rb_raise(ePostgresError, "This connection has already been closed.");
+    rb_raise(eConnectionError, "This connection has already been closed.");
   }
 
   PGconn *db = DATA_PTR(postgres_connection);
@@ -757,17 +870,16 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv[], VALUE self) {
 
   query = build_query_from_args(self, argc, argv);
 
-  response = cCommand_execute(db, query);
+  response = cCommand_execute(self, db, query);
 
   if ( PQresultStatus(response) != PGRES_TUPLES_OK ) {
-    char *message = PQresultErrorMessage(response);
-    PQclear(response);
-    rb_raise(ePostgresError, "%sQuery: %s\n", message, StringValuePtr(query));
+    raise_error(self, response, query);
   }
 
   field_count = PQnfields(response);
 
   reader = rb_funcall(cReader, ID_NEW, 0);
+  rb_iv_set(reader, "@connection", connection);
   rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, response));
   rb_iv_set(reader, "@field_count", INT2NUM(field_count));
   rb_iv_set(reader, "@row_count", INT2NUM(PQntuples(response)));
@@ -834,17 +946,25 @@ static VALUE cReader_next(VALUE self) {
   field_types = rb_iv_get(self, "@field_types");
   position = NUM2INT(rb_iv_get(self, "@position"));
 
-  if ( position > (row_count-1) ) {
+  if ( position > (row_count - 1) ) {
     rb_iv_set(self, "@values", Qnil);
     return Qfalse;
   }
 
+  int enc = -1;
+#ifdef HAVE_RUBY_ENCODING_H
+  VALUE encoding_id = rb_iv_get(rb_iv_get(self, "@connection"), "@encoding_id");
+  if (encoding_id != Qnil) {
+    enc = FIX2INT(encoding_id);
+  }
+#endif
+
   for ( i = 0; i < field_count; i++ ) {
     field_type = rb_ary_entry(field_types, i);
 
     // Always return nil if the value returned from Postgres is null
     if (!PQgetisnull(reader, position, i)) {
-      value = typecast(PQgetvalue(reader, position, i), PQgetlength(reader, position, i), field_type);
+      value = typecast(PQgetvalue(reader, position, i), PQgetlength(reader, position, i), field_type, enc);
     } else {
       value = Qnil;
     }
@@ -862,7 +982,7 @@ static VALUE cReader_values(VALUE self) {
 
   VALUE values = rb_iv_get(self, "@values");
   if(values == Qnil) {
-    rb_raise(ePostgresError, "Reader not initialized");
+    rb_raise(eDataError, "Reader not initialized");
     return Qnil;
   } else {
     return values;
@@ -913,7 +1033,9 @@ void Init_do_postgres_ext() {
 
   eArgumentError = CONST_GET(rb_mKernel, "ArgumentError");
   mPostgres = rb_define_module_under(mDO, "Postgres");
-  ePostgresError = rb_define_class("PostgresError", rb_eStandardError);
+  eConnectionError = CONST_GET(mDO, "ConnectionError");
+  eDataError = CONST_GET(mDO, "DataError");
+  mEncoding = rb_define_module_under(mPostgres, "Encoding");
 
   cConnection = POSTGRES_CLASS("Connection", cDO_Connection);
   rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
@@ -936,4 +1058,10 @@ void Init_do_postgres_ext() {
   rb_define_method(cReader, "fields", cReader_fields, 0);
   rb_define_method(cReader, "field_count", cReader_field_count, 0);
 
+  struct errcodes *errs;
+
+  for (errs = errors; errs->error_name; errs++) {
+    rb_const_set(mPostgres, rb_intern(errs->error_name), INT2NUM(errs->error_no));
+  }
+
 }