do_postgres 0.10.1-x86-mingw32 → 0.10.2-x86-mingw32

data/ChangeLog.markdown

@@ -1,10 +1,15 @@
-## 0.10.1 (unreleased, in git)
+## 0.10.2 2010-05-19
+* Make Encoding.default_internal aware
+* Rework logging for making callbacks possible
+* Remove handling Object types directly
+
+## 0.10.1 2010-01-08
 
 * Support for Ruby 1.8 and 1.9 on Windows.
 * Switch to Jeweler for Gem building tasks (this change may be temporary).
 * Switch to using Bacon for running specs: This should make specs friendlier to
   new Ruby implementations that are not yet 100% MRI-compatible, and in turn,
-  prepared the road for our own IronRuby and MacRuby support.
+  pave the road for our own IronRuby and MacRuby support.
 * Switch to the newly added rake-compiler `JavaExtensionTask` for compiling
   JRuby extensions, instead of our (broken) home-grown solution.
 

data/Rakefile

@@ -11,7 +11,7 @@ JRUBY    = RUBY_PLATFORM =~ /java/
 IRONRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
 WINDOWS  = Gem.win_platform? || (JRUBY && ENV_JAVA['os.name'] =~ /windows/i)
 SUDO     = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
-BINARY_VERSION = '8.3.9'
+BINARY_VERSION = '8.3.10'
 
 CLEAN.include(%w[ {tmp,pkg}/ **/*.{o,so,bundle,jar,log,a,gem,dSYM,obj,pdb,exp,DS_Store,rbc,db} ext/do_postgres/Makefile ext-java/target ])
 

data/ext/do_postgres/do_postgres.c

@@ -38,52 +38,52 @@
 #include "error.h"
 #include "compat.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 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 DRIVER_CLASS(klass, parent) (rb_define_class_under(mPostgres, klass, parent))
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 
-#define DO_STR_NEW2(str, encoding) \
+#define DO_STR_NEW2(str, encoding, internal_encoding) \
   ({ \
     VALUE _string = rb_str_new2((const char *)str); \
     if(encoding != -1) { \
       rb_enc_associate_index(_string, encoding); \
     } \
+    if(internal_encoding) { \
+      _string = rb_str_export_to_enc(_string, internal_encoding); \
+    } \
     _string; \
   })
 
-#define DO_STR_NEW(str, len, encoding) \
+#define DO_STR_NEW(str, len, encoding, internal_encoding) \
   ({ \
     VALUE _string = rb_str_new((const char *)str, (long)len); \
     if(encoding != -1) { \
       rb_enc_associate_index(_string, encoding); \
     } \
+    if(internal_encoding) { \
+      _string = rb_str_export_to_enc(_string, internal_encoding); \
+    } \
     _string; \
   })
 
 #else
 
-#define DO_STR_NEW2(str, doc) \
+#define DO_STR_NEW2(str, encoding, internal_encoding) \
   rb_str_new2((const char *)str)
 
-#define DO_STR_NEW(str, len, doc) \
+#define DO_STR_NEW(str, len, encoding, internal_encoding) \
   rb_str_new((const char *)str, (long)len)
 #endif
 
-
 // To store rb_intern values
 static ID ID_NEW_DATE;
-static ID ID_LOGGER;
-static ID ID_DEBUG;
-static ID ID_LEVEL;
-static ID ID_TO_S;
 static ID ID_RATIONAL;
+static ID ID_CONST_GET;
+static ID ID_NEW;
+static ID ID_ESCAPE;
+static ID ID_LOG;
 
 static VALUE mExtlib;
 static VALUE mDO;
@@ -93,6 +93,8 @@ static VALUE cDO_Connection;
 static VALUE cDO_Command;
 static VALUE cDO_Result;
 static VALUE cDO_Reader;
+static VALUE cDO_Logger;
+static VALUE cDO_Logger_Message;
 
 static VALUE rb_cDate;
 static VALUE rb_cDateTime;
@@ -105,32 +107,19 @@ static VALUE cCommand;
 static VALUE cResult;
 static VALUE cReader;
 
-static VALUE eArgumentError;
 static VALUE eConnectionError;
 static VALUE eDataError;
 
-static void data_objects_debug(VALUE string, struct timeval* start) {
+static void data_objects_debug(VALUE connection, VALUE string, struct timeval* start) {
   struct timeval stop;
-  char *message;
-
-  const char *query = rb_str_ptr_readonly(string);
-  size_t length     = rb_str_len(string);
-  char total_time[32];
-  do_int64 duration = 0;
-
-  VALUE logger = rb_funcall(mPostgres, ID_LOGGER, 0);
-  int log_level = NUM2INT(rb_funcall(logger, ID_LEVEL, 0));
+  VALUE message;
 
-  if (0 == log_level) {
-    gettimeofday(&stop, NULL);
+  gettimeofday(&stop, NULL);
+  do_int64 duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
 
-    duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
+  message = rb_funcall(cDO_Logger_Message, ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
 
-    snprintf(total_time, 32, "%.6f", duration / 1000000.0);
-    message = (char *)calloc(length + strlen(total_time) + 4, sizeof(char));
-    snprintf(message, length + strlen(total_time) + 4, "(%s) %s", total_time, query);
-    rb_funcall(logger, ID_DEBUG, 1, rb_str_new(message, length + strlen(total_time) + 3));
-  }
+  rb_funcall(connection, ID_LOG, 1, message);
 }
 
 static const char * get_uri_option(VALUE query_hash, const char * key) {
@@ -352,10 +341,16 @@ static VALUE infer_ruby_type(Oid type) {
 
 static VALUE typecast(const char *value, long length, const VALUE type, int encoding) {
 
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding * internal_encoding = rb_default_internal_encoding();
+#else
+  void * internal_encoding = NULL;
+#endif
+
   if (type == rb_cInteger) {
     return rb_cstr2inum(value, 10);
   } else if (type == rb_cString) {
-    return DO_STR_NEW(value, length, encoding);
+    return DO_STR_NEW(value, length, encoding, internal_encoding);
   } else if (type == rb_cFloat) {
     return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
   } else if (type == rb_cBigDecimal) {
@@ -376,12 +371,10 @@ static VALUE typecast(const char *value, long length, const VALUE type, int enco
     return byte_array;
   } else if (type == rb_cClass) {
     return rb_funcall(mDO, rb_intern("full_const_get"), 1, rb_str_new(value, length));
-  } else if (type == rb_cObject) {
-    return rb_marshal_load(rb_str_new(value, length));
   } else if (type == rb_cNilClass) {
     return Qnil;
   } else {
-    return DO_STR_NEW(value, length, encoding);
+    return DO_STR_NEW(value, length, encoding, internal_encoding);
   }
 
 }
@@ -460,11 +453,11 @@ static VALUE cCommand_set_types(int argc, VALUE *argv, VALUE self) {
         if(TYPE(sub_entry) == T_CLASS) {
           rb_ary_push(type_strings, sub_entry);
         } else {
-          rb_raise(eArgumentError, "Invalid type given");
+          rb_raise(rb_eArgError, "Invalid type given");
         }
       }
     } else {
-      rb_raise(eArgumentError, "Invalid type given");
+      rb_raise(rb_eArgError, "Invalid type given");
     }
   }
 
@@ -506,7 +499,7 @@ 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 = DO_STR_NEW(escaped, quoted_length + 2, FIX2INT(rb_iv_get(self, "@encoding_id")));
+  result = DO_STR_NEW(escaped, quoted_length + 2, FIX2INT(rb_iv_get(self, "@encoding_id")), NULL);
 
   free(escaped);
   return result;
@@ -541,7 +534,7 @@ static VALUE cConnection_quote_byte_array(VALUE self, VALUE string) {
 static void full_connect(VALUE self, PGconn *db);
 
 #ifdef _WIN32
-static PGresult* cCommand_execute_sync(VALUE self, PGconn *db, VALUE query) {
+static PGresult* cCommand_execute_sync(VALUE self, VALUE connection, PGconn *db, VALUE query) {
   PGresult *response;
   struct timeval start;
   char* str = StringValuePtr(query);
@@ -554,15 +547,12 @@ static PGresult* cCommand_execute_sync(VALUE self, PGconn *db, VALUE query) {
 
   response = PQexec(db, str);
 
-  data_objects_debug(query, &start);
-
   if (response == NULL) {
     if(PQstatus(db) != CONNECTION_OK) {
       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);
       }
@@ -573,10 +563,12 @@ static PGresult* cCommand_execute_sync(VALUE self, PGconn *db, VALUE query) {
     }
   }
 
+  data_objects_debug(connection, query, &start);
+
   return response;
 }
 #else
-static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
+static PGresult* cCommand_execute_async(VALUE self, VALUE connection, PGconn *db, VALUE query) {
   int socket_fd;
   int retval;
   fd_set rset;
@@ -588,6 +580,8 @@ static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
     PQclear(response);
   }
 
+  gettimeofday(&start, NULL);
+
   retval = PQsendQuery(db, str);
 
   if (!retval) {
@@ -596,7 +590,6 @@ static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
       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);
       }
@@ -607,11 +600,8 @@ static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
     }
   }
 
-  gettimeofday(&start, NULL);
   socket_fd = PQsocket(db);
 
-  data_objects_debug(query, &start);
-
   for(;;) {
       FD_ZERO(&rset);
       FD_SET(socket_fd, &rset);
@@ -633,6 +623,8 @@ static PGresult* cCommand_execute_async(VALUE self, PGconn *db, VALUE query) {
       }
   }
 
+  data_objects_debug(connection, query, &start);
+
   return PQgetResult(db);
 }
 #endif
@@ -747,7 +739,7 @@ static void full_connect(VALUE self, PGconn *db) {
     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(self, db, r_query);
+    result = cCommand_execute(Qnil, self, db, r_query);
 
     if (PQresultStatus(result) != PGRES_COMMAND_OK) {
       free((void *)search_path_query);
@@ -758,21 +750,21 @@ static void full_connect(VALUE self, PGconn *db) {
   }
 
   r_options = rb_str_new2(backslash_off);
-  result = cCommand_execute(self, db, r_options);
+  result = cCommand_execute(Qnil, self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn("%s", PQresultErrorMessage(result));
   }
 
   r_options = rb_str_new2(standard_strings_on);
-  result = cCommand_execute(self, db, r_options);
+  result = cCommand_execute(Qnil, self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn("%s", PQresultErrorMessage(result));
   }
 
   r_options = rb_str_new2(warning_messages);
-  result = cCommand_execute(self, db, r_options);
+  result = cCommand_execute(Qnil, self, db, r_options);
 
   if (PQresultStatus(result) != PGRES_COMMAND_OK) {
     rb_warn("%s", PQresultErrorMessage(result));
@@ -823,7 +815,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(self, db, query);
+  response = cCommand_execute(self, connection, db, query);
 
   status = PQresultStatus(response);
 
@@ -863,7 +855,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv[], VALUE self) {
 
   query = build_query_from_args(self, argc, argv);
 
-  response = cCommand_execute(self, db, query);
+  response = cCommand_execute(self, connection, db, query);
 
   if ( PQresultStatus(response) != PGRES_TUPLES_OK ) {
     raise_error(self, response, query);
@@ -887,7 +879,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv[], VALUE self) {
     // Whoops...  wrong number of types passed to set_types.  Close the reader and raise
     // and error
     rb_funcall(reader, rb_intern("close"), 0);
-    rb_raise(eArgumentError, "Field-count mismatch. Expected %ld fields, but the query yielded %d", RARRAY_LEN(field_types), field_count);
+    rb_raise(rb_eArgError, "Field-count mismatch. Expected %ld fields, but the query yielded %d", RARRAY_LEN(field_types), field_count);
   }
 
   for ( i = 0; i < field_count; i++ ) {
@@ -993,24 +985,24 @@ static VALUE cReader_field_count(VALUE self) {
 void Init_do_postgres() {
   rb_require("date");
   rb_require("bigdecimal");
+  rb_require("data_objects");
+
+  ID_CONST_GET = rb_intern("const_get");
 
   // Get references classes needed for Date/Time parsing
   rb_cDate = CONST_GET(rb_mKernel, "Date");
   rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
   rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
 
-  rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("data_objects"));
-
 #ifdef RUBY_LESS_THAN_186
   ID_NEW_DATE = rb_intern("new0");
 #else
   ID_NEW_DATE = rb_intern("new!");
 #endif
-  ID_LOGGER = rb_intern("logger");
-  ID_DEBUG = rb_intern("debug");
-  ID_LEVEL = rb_intern("level");
-  ID_TO_S = rb_intern("to_s");
   ID_RATIONAL = rb_intern("Rational");
+  ID_NEW = rb_intern("new");
+  ID_ESCAPE = rb_intern("escape_sql");
+  ID_LOG = rb_intern("log");
 
   // Get references to the Extlib module
   mExtlib = CONST_GET(rb_mKernel, "Extlib");
@@ -1023,34 +1015,56 @@ void Init_do_postgres() {
   cDO_Command = CONST_GET(mDO, "Command");
   cDO_Result = CONST_GET(mDO, "Result");
   cDO_Reader = CONST_GET(mDO, "Reader");
+  cDO_Logger = CONST_GET(mDO, "Logger");
+  cDO_Logger_Message = CONST_GET(cDO_Logger, "Message");
 
-  eArgumentError = CONST_GET(rb_mKernel, "ArgumentError");
   mPostgres = rb_define_module_under(mDO, "Postgres");
   eConnectionError = CONST_GET(mDO, "ConnectionError");
   eDataError = CONST_GET(mDO, "DataError");
   mEncoding = rb_define_module_under(mPostgres, "Encoding");
 
-  cConnection = POSTGRES_CLASS("Connection", cDO_Connection);
+  cConnection = DRIVER_CLASS("Connection", cDO_Connection);
   rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
   rb_define_method(cConnection, "dispose", cConnection_dispose, 0);
   rb_define_method(cConnection, "character_set", cConnection_character_set , 0);
   rb_define_method(cConnection, "quote_string", cConnection_quote_string, 1);
   rb_define_method(cConnection, "quote_byte_array", cConnection_quote_byte_array, 1);
 
-  cCommand = POSTGRES_CLASS("Command", cDO_Command);
+  cCommand = DRIVER_CLASS("Command", cDO_Command);
   rb_define_method(cCommand, "set_types", cCommand_set_types, -1);
   rb_define_method(cCommand, "execute_non_query", cCommand_execute_non_query, -1);
   rb_define_method(cCommand, "execute_reader", cCommand_execute_reader, -1);
 
-  cResult = POSTGRES_CLASS("Result", cDO_Result);
+  cResult = DRIVER_CLASS("Result", cDO_Result);
 
-  cReader = POSTGRES_CLASS("Reader", cDO_Reader);
+  cReader = DRIVER_CLASS("Reader", cDO_Reader);
   rb_define_method(cReader, "close", cReader_close, 0);
   rb_define_method(cReader, "next!", cReader_next, 0);
   rb_define_method(cReader, "values", cReader_values, 0);
   rb_define_method(cReader, "fields", cReader_fields, 0);
   rb_define_method(cReader, "field_count", cReader_field_count, 0);
 
+  rb_global_variable(&ID_NEW_DATE);
+  rb_global_variable(&ID_RATIONAL);
+  rb_global_variable(&ID_CONST_GET);
+  rb_global_variable(&ID_ESCAPE);
+  rb_global_variable(&ID_LOG);
+  rb_global_variable(&ID_NEW);
+
+  rb_global_variable(&rb_cDate);
+  rb_global_variable(&rb_cDateTime);
+  rb_global_variable(&rb_cBigDecimal);
+  rb_global_variable(&rb_cByteArray);
+
+  rb_global_variable(&mDO);
+  rb_global_variable(&cDO_Logger_Message);
+
+  rb_global_variable(&cResult);
+  rb_global_variable(&cReader);
+
+  rb_global_variable(&eConnectionError);
+  rb_global_variable(&eDataError);
+
   struct errcodes *errs;
 
   for (errs = errors; errs->error_name; errs++) {

data/lib/do_postgres/version.rb

@@ -1,5 +1,5 @@
 module DataObjects
   module Postgres
-    VERSION = '0.10.1'.freeze
+    VERSION = '0.10.2'
   end
 end

data/spec/encoding_spec.rb

@@ -15,6 +15,7 @@ describe DataObjects::Postgres::Connection do
     #   can be overridden -- but for now, we won't support doing this.
     #
     behaves_like 'a driver supporting different encodings'
-    behaves_like 'returning correctly encoded strings for the default encoding'
+    behaves_like 'returning correctly encoded strings for the default database encoding'
+    behaves_like 'returning correctly encoded strings for the default internal encoding'
   end
 end

data/spec/spec_helper.rb

@@ -70,9 +70,8 @@ module DataObjectsSpecHelpers
 
     conn.create_command(<<-EOF).execute_non_query
       CREATE TABLE "invoices" (
-        "id" SERIAL,
         "invoice_number" varchar(50) NOT NULL,
-        PRIMARY KEY  ("id")
+        PRIMARY KEY  ("invoice_number")
       );
     EOF
 

data/tasks/compile.rake

@@ -73,7 +73,7 @@ begin
     ext.classpath = '../do_jdbc/lib/do_jdbc_internal.jar'
     ext.java_compiling do |gem|
       gem.add_dependency 'jdbc-postgres', '>=8.2'
-      gem.add_dependency 'do_jdbc',       '0.10.1'
+      gem.add_dependency 'do_jdbc',       '0.10.2'
     end
   end
 rescue LoadError

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: do_postgres
 version: !ruby/object:Gem::Version 
-  version: 0.10.1
+  prerelease: false
+  segments: 
+  - 0
+  - 10
+  - 2
+  version: 0.10.2
 platform: x86-mingw32
 authors: 
 - Dirkjan Bussink
@@ -9,39 +14,49 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-09 00:00:00 +01:00
+date: 2010-05-19 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: data_objects
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.10.1
-    version: 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: bacon
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
         version: "1.1"
-    version: 
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rake-compiler
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
         version: "0.7"
-    version: 
+  type: :development
+  version_requirements: *id003
 description: Implements the DataObjects API for PostgreSQL
 email: d.bussink@gmail.com
 executables: []
@@ -101,13 +116,13 @@ post_install_message: |+
     ======================================================================================================
   
       You've installed the binary version of do_postgres.
-      It was built using PostgreSQL version 8.3.9.
+      It was built using PostgreSQL version 8.3.10.
       It's recommended to use the exact same version to avoid potential issues.
   
       At the time of building this gem, the necessary DLL files where available
       in the following download:
   
-      http://wwwmaster.postgresql.org/redir/107/h/binary/v8.3.9/win32/postgresql-8.3.9-1-binaries-no-installer.zip
+      http://wwwmaster.postgresql.org/redir/107/h/binary/v8.3.10/win32/postgresql-8.3.10-1-binaries-no-installer.zip
   
       You can put the following files available in this package in your Ruby bin
       directory, for example C:\Ruby\bin
@@ -132,18 +147,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: dorb
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: DataObjects PostgreSQL Driver