ruby-informix 0.4.0 → 0.5.0

data/informix.ec

@@ -1,4 +1,4 @@
-/* $Id: informix.ec,v 1.56 2006/12/13 08:19:52 santana Exp $ */
+/* $Id: informix.ec,v 1.81 2006/12/27 20:57:39 santana Exp $ */
 /*
 * Copyright (c) 2006, Gerardo Santana Gomez Garrido <gerardo.santana@gmail.com>
 * All rights reserved.
@@ -33,30 +33,30 @@
 #include <sqlstype.h>
 #include <sqltypes.h>
 
-static VALUE rb_cDate;
+static VALUE rb_cDate, rb_cBigDecimal;
 
 static VALUE rb_mInformix;
 static VALUE rb_mSequentialCursor;
 static VALUE rb_mScrollCursor;
 static VALUE rb_mInsertCursor;
 
-static VALUE rb_cSlob;
+static VALUE rb_cSlob, rb_cSlobStat;
 static VALUE rb_cDatabase;
 static VALUE rb_cStatement;
 static VALUE rb_cCursor;
 
 static ID s_read, s_new, s_utc, s_day, s_month, s_year;
 static ID s_hour, s_min, s_sec, s_usec, s_to_s, s_to_i;
+
 static VALUE sym_name, sym_type, sym_nullable, sym_stype, sym_length;
 static VALUE sym_precision, sym_scale, sym_default, sym_xid;
 static VALUE sym_scroll, sym_hold;
 static VALUE sym_col_info, sym_sbspace, sym_estbytes, sym_extsz;
-static VALUE sym_createflags, sym_openflags;
+static VALUE sym_createflags, sym_openflags, sym_maxbytes;
+static VALUE sym_params;
 
 #define IDSIZE 30
 
-static char *currentdid = NULL;
-
 typedef struct {
 	short is_select, is_open;
 	struct sqlda daInput, *daOutput;
@@ -77,6 +77,11 @@ typedef struct {
 	char *database_id;
 } slob_t;
 
+typedef struct {
+	mint atime, ctime, mtime, refcnt;
+	ifx_int8_t size;
+} slobstat_t;
+
 #define NUM2INT8(num, int8addr) do { \
 	VALUE str = rb_funcall(num, s_to_s, 0); \
 	char *c_str = StringValueCStr(str); \
@@ -87,11 +92,185 @@ typedef struct {
 
 #define INT82NUM(int8addr, num) do { \
 	char str[21]; \
-	mint ret = ifx_int8toasc((int8addr), str, sizeof(str) - 1); \
+	ifx_int8toasc((int8addr), str, sizeof(str) - 1); \
 	str[sizeof(str) - 1] = 0; \
 	num = rb_cstr2inum(str, 10); \
 }while(0)
 
+/* class Slob::Stat ------------------------------------------------------ */
+
+static void
+slobstat_free(slobstat_t *stat)
+{
+	xfree(stat);
+}
+
+static VALUE
+slobstat_alloc(VALUE klass)
+{
+	slobstat_t *stat;
+
+	stat = ALLOC(slobstat_t);
+	return Data_Wrap_Struct(klass, 0, slobstat_free, stat);
+}
+
+/*
+ * call-seq:
+ * Slob::Stat.new(slob)  => stat
+ *
+ * Creates an Slob::Stat object with status information for the given Slob
+ * object.
+ */
+static VALUE
+rb_slobstat_initialize(VALUE self, VALUE slob)
+{
+	mint ret;
+	slob_t *sb;
+	slobstat_t *stat;
+	ifx_lo_stat_t *st;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(slob, slob_t, sb);
+	Data_Get_Struct(self, slobstat_t, stat);
+
+	if (sb->fd == -1)
+		rb_raise(rb_eRuntimeError,
+			"Open the Slob object before getting its status");
+
+	did = sb->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	ret = ifx_lo_stat(sb->fd, &st);
+
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	stat->atime = ifx_lo_stat_atime(st);
+	stat->ctime = ifx_lo_stat_ctime(st);
+	stat->mtime = ifx_lo_stat_mtime_sec(st);
+	stat->refcnt = ifx_lo_stat_refcnt(st);
+	ret = ifx_lo_stat_size(st, &stat->size);
+
+	ifx_lo_stat_free(st);
+
+	if (stat->atime == -1 || stat->ctime == -1 || stat->mtime == -1 ||
+	    stat->refcnt == -1 || ret == -1) {
+		rb_raise(rb_eRuntimeError, "Unable to get status");
+	}
+
+	return self;
+}
+
+/*
+ * call-seq:
+ * stat <=> other_stat  => -1, 0, 1
+ *
+ * Compares with another <code>Slob::Stat</code> object by comparing their
+ * modification times.
+ */
+static VALUE
+rb_slobstat_cmp(VALUE self, VALUE other)
+{
+	if (rb_obj_is_kind_of(other, rb_obj_class(self))) {
+		slobstat_t *stat;
+		time_t t1, t2;
+
+		Data_Get_Struct(self, slobstat_t, stat);  t1 = stat->mtime;
+		Data_Get_Struct(other, slobstat_t, stat); t2 = stat->mtime;
+
+		if (t1 == t2)
+			return INT2FIX(0);
+		else if (t1 < t2)
+			return INT2FIX(-1);
+		else
+			return INT2FIX(1);
+	}
+
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ * stat.atime  => time
+ *
+ * Returns the time of last access as a Time object.
+ */
+static VALUE
+rb_slobstat_atime(VALUE self)
+{
+	slobstat_t *stat;
+
+	Data_Get_Struct(self, slobstat_t, stat);
+	return rb_time_new(stat->atime, 0);
+}
+
+/*
+ * call-seq:
+ * stat.ctime  => time
+ *
+ * Returns the time of last change in status as a Time object.
+ */
+static VALUE
+rb_slobstat_ctime(VALUE self)
+{
+	slobstat_t *stat;
+
+	Data_Get_Struct(self, slobstat_t, stat);
+	return rb_time_new(stat->ctime, 0);
+}
+
+/*
+ * call-seq:
+ * stat.mtime  => time
+ *
+ * Returns the time of last modification as a Time object.
+ */
+static VALUE
+rb_slobstat_mtime(VALUE self)
+{
+	slobstat_t *stat;
+
+	Data_Get_Struct(self, slobstat_t, stat);
+	return rb_time_new(stat->mtime, 0);
+}
+
+/*
+ * call-seq:
+ * stat.refcnt  => fixnum
+ *
+ * Returns the number of references
+ */
+static VALUE
+rb_slobstat_refcnt(VALUE self)
+{
+	slobstat_t *stat;
+
+	Data_Get_Struct(self, slobstat_t, stat);
+	return INT2FIX(stat->refcnt);
+}
+
+/*
+ * call-seq:
+ * stat.size  => fixnum or bignum
+ *
+ * Returns the size in bytes
+ */
+static VALUE
+rb_slobstat_size(VALUE self)
+{
+	slobstat_t *stat;
+	VALUE size;
+
+	Data_Get_Struct(self, slobstat_t, stat);
+	INT82NUM(&stat->size, size);
+
+	return size;
+}
+
 /* class Slob ------------------------------------------------------------ */
 
 static void
@@ -109,16 +288,11 @@ slob_free(slob_t *slob)
 		EXEC SQL end   declare section;
 
 		did = slob->database_id;
-		if (currentdid != did) {
-			EXEC SQL set connection :did;
-			if (SQLCODE < 0)
-				goto exit;
-			currentdid = did;
-		}
-		ifx_lo_close(slob->fd);
+		EXEC SQL set connection :did;
+		if (SQLCODE >= 0)
+			ifx_lo_close(slob->fd);
 	}
 
-exit:
 	if (slob->spec)
 		ifx_lo_spec_free(slob->spec);
 
@@ -133,14 +307,17 @@ slob_alloc(VALUE klass)
 	slob = ALLOC(slob_t);
 	slob->spec = NULL;
 	slob->fd = -1;
+	slob->database_id = NULL;
 	slob->type = XID_CLOB;
+	slob->db = 0;
 
 	return Data_Wrap_Struct(klass, slob_mark, slob_free, slob);
 }
 
 /*
  * call-seq:
- * Slob.new(database, type = Slob::CLOB, options = nil)  => slob
+ * Slob.new(database, type = Slob::CLOB, options = nil)                  => slob
+ * Slob.new(database, type = Slob::CLOB, options = nil) {|slob| block }  => obj
  *
  * Creates a Smart Large Object of type <i>type</i> in <i>database</i>.
  * Returns a <code>Slob</code> object pointing to it.
@@ -159,7 +336,7 @@ slob_alloc(VALUE klass)
  *                   characteristics for the specified database column
  */
 static VALUE
-slob_initialize(int argc, VALUE *argv, VALUE self)
+rb_slob_initialize(int argc, VALUE *argv, VALUE self)
 {
 	mint ret, error;
 	slob_t *slob;
@@ -172,18 +349,15 @@ slob_initialize(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, "12", &db, &type, &options);
 	Data_Get_Struct(db, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	Data_Get_Struct(self, slob_t, slob);
 	slob->db = db;
 	slob->database_id = did;
 
-	if (RTEST(type)) {
+	if (!NIL_P(type)) {
 		int t = FIX2INT(type);
 		if (t != XID_CLOB && t != XID_BLOB)
 			rb_raise(rb_eRuntimeError, "Invalid type %d for an SLOB", t);
@@ -192,32 +366,34 @@ slob_initialize(int argc, VALUE *argv, VALUE self)
 
 	col_info = sbspace = estbytes = extsz = createflags = openflags = maxbytes = Qnil;
 
-	if (RTEST(options)) {
+	if (!NIL_P(options)) {
+		Check_Type(options, T_HASH);
 		col_info = rb_hash_aref(options, sym_col_info);
 		sbspace = rb_hash_aref(options, sym_sbspace);
 		estbytes = rb_hash_aref(options, sym_estbytes);
 		extsz = rb_hash_aref(options, sym_extsz);
 		createflags = rb_hash_aref(options, sym_createflags);
 		openflags = rb_hash_aref(options, sym_openflags);
+		maxbytes = rb_hash_aref(options, sym_maxbytes);
 	}
 
 	ret = ifx_lo_def_create_spec(&slob->spec);
 	if (ret < 0)
 		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
 
-	if (RTEST(col_info)) {
+	if (!NIL_P(col_info)) {
 		ret = ifx_lo_col_info(StringValueCStr(col_info), slob->spec);
 
 		if (ret < 0)
 			rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
 	}
-	if (RTEST(sbspace)) {
+	if (!NIL_P(sbspace)) {
 		char *c_sbspace = StringValueCStr(sbspace);
 		ret = ifx_lo_specset_sbspace(slob->spec, c_sbspace);
 		if (ret == -1)
 			rb_raise(rb_eRuntimeError, "Could not set sbspace name to %s", c_sbspace);
 	}
-	if (RTEST(estbytes)) {
+	if (!NIL_P(estbytes)) {
 		ifx_int8_t estbytes8;
 
 		NUM2INT8(estbytes, &estbytes8);
@@ -225,17 +401,17 @@ slob_initialize(int argc, VALUE *argv, VALUE self)
 		if (ret == -1)
 			rb_raise(rb_eRuntimeError, "Could not set estbytes");
 	}
-	if (RTEST(extsz)) {
+	if (!NIL_P(extsz)) {
 		ret = ifx_lo_specset_extsz(slob->spec, FIX2LONG(extsz));
 		if (ret == -1)
 			rb_raise(rb_eRuntimeError, "Could not set extsz to %d", FIX2LONG(extsz));
 	}
-	if (RTEST(createflags)) {
+	if (!NIL_P(createflags)) {
 		ret = ifx_lo_specset_flags(slob->spec, FIX2LONG(createflags));
 		if (ret == -1)
 			rb_raise(rb_eRuntimeError, "Could not set crate-time flags to 0x%X", FIX2LONG(createflags));
 	}
-	if (RTEST(maxbytes)) {
+	if (!NIL_P(maxbytes)) {
 		ifx_int8_t maxbytes8;
 
 		NUM2INT8(maxbytes, (&maxbytes8));
@@ -243,26 +419,62 @@ slob_initialize(int argc, VALUE *argv, VALUE self)
 		if (ret == -1)
 			rb_raise(rb_eRuntimeError, "Could not set maxbytes");
 	}
+
 	slob->fd = ifx_lo_create(slob->spec, RTEST(openflags)? FIX2LONG(openflags): LO_RDWR, &slob->lo, &error);
-	if (slob->fd == -1) {
+	if (slob->fd == -1)
 		rb_raise(rb_eRuntimeError, "Informix Error: %d\n", error);
-	}
+
 	return self;
 }
 
+/*
+ * call-seq:
+ * Slob.new(database, type = Slob::CLOB, options = nil)                  => slob
+ * Slob.new(database, type = Slob::CLOB, options = nil) {|slob| block }  => obj
+ *
+ * Creates a Smart Large Object of type <i>type</i> in <i>database</i>.
+ * Returns a <code>Slob</code> object pointing to it.
+ *
+ * <i>type</i> can be Slob::BLOB or Slob::CLOB
+ *
+ * <i>options</i> can be nil or a Hash object with the following possible keys:
+ *
+ *   :sbspace     => Sbspace name
+ *   :estbytes    => Estimated size, in bytes
+ *   :extsz       => Allocation extent size
+ *   :createflags => Create-time flags
+ *   :openflags   => Access mode
+ *   :maxbytes    => Maximum size
+ *   :col_info    => Get the previous values from the column-level storage
+ *                   characteristics for the specified database column
+ */
+static VALUE rb_slob_close(VALUE self);
+static VALUE
+rb_slob_s_new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE slob;
+
+	slob = rb_class_new_instance(argc, argv, klass);
+
+	if (rb_block_given_p())
+		return rb_ensure(rb_yield, slob, rb_slob_close, slob);
+
+	return slob;
+}
+
 /*
  * call-seq:
  * slob.open(access = Slob::RDONLY)  => slob
  *
  * Opens the Smart Large Object in <i>access</i> mode.
  *
- * access modes:
+ * Access modes:
  * 
  * Slob::RDONLY::		Read only
  * Slob::DIRTY_READ::	Read uncommitted data
  * Slob::WRONLY::	Write only
- * Slob::APPEND::	Append data to the end, if combined with RDRW or WRONLY; read only otherwise
- * Slob::RDRW::		Read/Write
+ * Slob::APPEND::	Append data to the end, if combined with RDWR or WRONLY; read only otherwise
+ * Slob::RDWR::		Read/Write
  * Slob::BUFFER::	Use standard database server buffer pool
  * Slob::NOBUFFER::	Use private buffer from the session pool of the database server
  * Slob::LOCKALL::		Lock the entire Smart Large Object
@@ -271,7 +483,7 @@ slob_initialize(int argc, VALUE *argv, VALUE self)
  * Returns __self__.
  */
 static VALUE
-slob_open(int argc, VALUE *argv, VALUE self)
+rb_slob_open(int argc, VALUE *argv, VALUE self)
 {
 	VALUE access;
 	slob_t *slob;
@@ -286,12 +498,9 @@ slob_open(int argc, VALUE *argv, VALUE self)
 		return self;
 
 	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	rb_scan_args(argc, argv, "01", &access);
 
@@ -310,7 +519,7 @@ slob_open(int argc, VALUE *argv, VALUE self)
  * Closes the Smart Large Object and returns __self__.
  */
 static VALUE
-slob_close(VALUE self)
+rb_slob_close(VALUE self)
 {
 	slob_t *slob;
 
@@ -321,12 +530,9 @@ slob_close(VALUE self)
 		EXEC SQL end   declare section;
 
 		did = slob->database_id;
-		if (currentdid != did) {
-			EXEC SQL set connection :did;
-			if (SQLCODE < 0)
-				return self;
-			currentdid = did;
-		}
+		EXEC SQL set connection :did;
+		if (SQLCODE < 0)
+			return self;
 
 		ifx_lo_close(slob->fd);
 		slob->fd = -1;
@@ -344,7 +550,7 @@ slob_close(VALUE self)
  * Returns the bytes read as a String object.
  */
 static VALUE
-slob_read(VALUE self, VALUE nbytes)
+rb_slob_read(VALUE self, VALUE nbytes)
 {
 	slob_t *slob;
 	mint error, ret;
@@ -362,19 +568,18 @@ slob_read(VALUE self, VALUE nbytes)
 		rb_raise(rb_eRuntimeError, "Open the Slob object before reading");
 
 	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	c_nbytes = FIX2LONG(nbytes);
 	buffer = ALLOC_N(char, c_nbytes);
 	ret = ifx_lo_read(slob->fd, buffer, c_nbytes, &error);
 
-	if (ret == -1)
+	if (ret == -1) {
+		xfree(buffer);
 		rb_raise(rb_eRuntimeError, "Informix Error: %d\n", error);
+	}
 
 	str = rb_str_new(buffer, ret);
 	xfree(buffer);
@@ -386,12 +591,13 @@ slob_read(VALUE self, VALUE nbytes)
  * call-seq:
  * slob.write(data)  => fixnum or bignum
  * 
- * Writes <i>data</i> to the Smart Large Object.
+ * Writes <i>data</i> to the Smart Large Object. If <i>data</i> is not a
+ * String object it will be converted to String using <code>to_s</code>.
  *
  * Returns the number of bytes written.
  */
 static VALUE
-slob_write(VALUE self, VALUE data)
+rb_slob_write(VALUE self, VALUE data)
 {
 	slob_t *slob;
 	mint error, ret;
@@ -408,14 +614,11 @@ slob_write(VALUE self, VALUE data)
 		rb_raise(rb_eRuntimeError, "Open the Slob object before writing");
 
 	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
-	str = StringValue(data);
+	str = rb_obj_as_string(data);
 	buffer = RSTRING(str)->ptr;
 	nbytes = RSTRING(str)->len;
 
@@ -427,6 +630,22 @@ slob_write(VALUE self, VALUE data)
 	return LONG2NUM(ret);
 }
 
+/*
+ * call-seq:
+ * slob << data   => slob
+ *
+ * Writes <i>data</i> to the Smart Large Object. If <i>data</i> is not a
+ * String object it will be converted to String using <code>to_s</code>.
+ *
+ * Returns self.
+ */
+static VALUE
+rb_slob_addstr(VALUE self, VALUE data)
+{
+	rb_slob_write(self, data);
+	return self;
+}
+
 /*
  * call-seq:
  * slob.seek(offset, whence)  => fixnum or bignum
@@ -447,7 +666,7 @@ slob_write(VALUE self, VALUE data)
  * Returns the new position.
  */
 static VALUE
-slob_seek(VALUE self, VALUE offset, VALUE whence)
+rb_slob_seek(VALUE self, VALUE offset, VALUE whence)
 {
 	slob_t *slob;
 	mint ret;
@@ -463,12 +682,9 @@ slob_seek(VALUE self, VALUE offset, VALUE whence)
 		rb_raise(rb_eRuntimeError, "Open the Slob object first");
 
 	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	NUM2INT8(offset, &offset8);
 	ret = ifx_lo_seek(slob->fd, &offset8, FIX2INT(whence), &seek_pos8);
@@ -482,13 +698,37 @@ slob_seek(VALUE self, VALUE offset, VALUE whence)
 
 /*
  * call-seq:
- * slob.tell  => fixnum or bignum
+ * slob.pos = integer    => integer
+ *
+ * Seeks to the given position (in bytes) in _slob_.
+ */
+static VALUE
+rb_slob_set_pos(VALUE self, VALUE pos)
+{
+	return rb_slob_seek(self, pos, LO_SEEK_SET);
+}
+
+/*
+ * call-seq:
+ * slob.rewind  => fixnum
+ *
+ * Moves the cursor position to the start of the Smart Large Object.
+ */
+static VALUE
+rb_slob_rewind(VALUE self)
+{
+	return rb_slob_seek(self, INT2FIX(0), LO_SEEK_SET);
+}
+
+/*
+ * call-seq:
+ * slob.tell  => integer
+ * slob.pos   => integer
  * 
- * Returns the current file or seek position for an
- * open Smart Large Object
+ * Returns the current file or seek position for an open Smart Large Object
  */
 static VALUE
-slob_tell(VALUE self)
+rb_slob_tell(VALUE self)
 {
 	slob_t *slob;
 	mint ret;
@@ -504,12 +744,9 @@ slob_tell(VALUE self)
 		rb_raise(rb_eRuntimeError, "Open the Slob object first");
 
 	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	ret = ifx_lo_tell(slob->fd, &seek_pos8);
 	if (ret < 0)
@@ -522,41 +759,486 @@ slob_tell(VALUE self)
 
 /*
  * call-seq:
- * slob.truncate(offset)  => slob
- * 
- * Truncates a Smart Large Object at a specified byte position.
+ * slob.truncate(offset)  => slob
+ * 
+ * Truncates a Smart Large Object at a specified byte position.
+ *
+ * Returns __self__.
+ */
+static VALUE
+rb_slob_truncate(VALUE self, VALUE offset)
+{
+	slob_t *slob;
+	mint ret;
+	ifx_int8_t offset8;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError, "Open the Slob object first");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	NUM2INT8(offset, &offset8);
+	ret = ifx_lo_truncate(slob->fd, &offset8);
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	return self;
+}
+
+/*
+ * call-seq:
+ * slob.stat  => stat
+ *
+ * Creates and returns an Slob::Stat object with status information for _slob_.
+ */
+static VALUE
+rb_slob_stat(VALUE self)
+{
+	return rb_class_new_instance(1, &self, rb_cSlobStat);
+}
+
+/*
+ * call-seq:
+ * slob.lock(offset, whence, range, mode)  =>  slob
+ *
+ * Locks _range_ number of bytes, starting from _offset_ bytes from
+ * _whence_, in _mode_ mode.
+ *
+ * Returns _self_.
+ *
+ * Possible values:
+ *
+ *   offset  =>  integer
+ *   whence  =>  Slob::SEEK_SET, Slob::SEEK_CUR, Slob::SEEK_END
+ *   range   =>  integer, Slob::CURRENT_END, Slob::MAX_END
+ *   mode    =>  Slob::SHARED_MODE, Slob::EXCLUSIVE_MODE
+ */
+static VALUE
+rb_slob_lock(VALUE self, VALUE offset, VALUE whence, VALUE range, VALUE mode)
+{
+	slob_t *slob;
+	mint ret;
+	ifx_int8_t offset8, range8;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError, "Open the Slob object first");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	NUM2INT8(offset, &offset8);
+	NUM2INT8(range, &range8);
+	ret = ifx_lo_lock(slob->fd, &offset8, FIX2INT(whence), &range8, FIX2INT(mode));
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	return self;
+}
+
+/*
+ * call-seq:
+ * slob.unlock(offset, whence, range)  =>  slob
+ *
+ * Unlocks _range_ number of bytes, starting from _offset_ bytes from
+ * _whence_.
+ *
+ * Returns _self_.
+ *
+ * Possible values:
+ *
+ *   offset  =>  integer
+ *   whence  =>  Slob::SEEK_SET, Slob::SEEK_CUR, Slob::SEEK_END
+ *   range   =>  integer
+ */
+static VALUE
+rb_slob_unlock(VALUE self, VALUE offset, VALUE whence, VALUE range)
+{
+	slob_t *slob;
+	mint ret;
+	ifx_int8_t offset8, range8;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError, "Open the Slob object first");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	NUM2INT8(offset, &offset8);
+	NUM2INT8(range, &range8);
+	ret = ifx_lo_unlock(slob->fd, &offset8, FIX2INT(whence), &range8);
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	return self;
+}
+
+typedef enum {
+	slob_estbytes, slob_extsz, slob_flags, slob_maxbytes, slob_sbspace
+} slob_option_t;
+static char *str_slob_options[] = {
+	"estbytes", "extsz", "flags", "maxbytes", "sbspace"};
+/*
+ * Base function for getting storage charasteristics
+ */
+static VALUE
+slob_specget(VALUE self, slob_option_t option)
+{
+	slob_t *slob;
+	mint ret;
+	ifx_lo_stat_t *stat;
+	ifx_lo_create_spec_t *spec;
+	ifx_int8_t int8;
+	char buffer[129];
+	VALUE item;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError, "Open the Slob object first");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	ret = ifx_lo_stat(slob->fd, &stat);
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	spec = ifx_lo_stat_cspec(stat);
+	if (spec == NULL) {
+		ifx_lo_stat_free(stat);
+		rb_raise(rb_eRuntimeError, "Unable to get storage characteristics");
+	}
+
+	switch(option) {
+	case slob_estbytes:
+		ret = ifx_lo_specget_estbytes(spec, &int8);
+		break;
+	case slob_extsz:
+		ret = ifx_lo_specget_extsz(spec);
+		break;
+	case slob_flags:
+		ret = ifx_lo_specget_flags(spec);
+		break;
+	case slob_maxbytes:
+		ret = ifx_lo_specget_maxbytes(spec, &int8);
+		break;
+	case slob_sbspace:
+		ret = ifx_lo_specget_sbspace(spec, buffer, sizeof(buffer));
+	}
+
+	ifx_lo_stat_free(stat);
+	if (ret == -1)
+		rb_raise(rb_eRuntimeError, "Unable to get information for %s", str_slob_options[option]);
+
+	switch(option) {
+	case slob_estbytes:
+	case slob_maxbytes:
+		INT82NUM(&int8, item);
+		return item;
+	case slob_extsz:
+	case slob_flags:
+		return INT2FIX(ret);
+	case slob_sbspace:
+		return rb_str_new2(buffer);
+	}
+
+	return Qnil; /* Not reached */
+}
+
+/*
+ * Base function for setting extsz and flags
+ */
+static VALUE
+slob_specset(VALUE self, slob_option_t option, VALUE value)
+{
+	slob_t *slob;
+	mint ret;
+	ifx_lo_stat_t *stat;
+	ifx_lo_create_spec_t *spec;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError, "Open the Slob object first");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	ret = ifx_lo_stat(slob->fd, &stat);
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	spec = ifx_lo_stat_cspec(stat);
+	if (spec == NULL) {
+		ifx_lo_stat_free(stat);
+		rb_raise(rb_eRuntimeError, "Unable to get storage characteristics");
+	}
+
+	switch(option) {
+	case slob_extsz:
+		ret = ifx_lo_specset_extsz(spec, FIX2INT(value));
+		break;
+	case slob_flags:
+		ret = ifx_lo_specset_flags(spec, FIX2INT(value));
+		break;
+	default:
+		break; /* Not reached */
+	}
+
+	ifx_lo_stat_free(stat);
+	if (ret == -1)
+		rb_raise(rb_eRuntimeError, "Unable to set information for %s", str_slob_options[option]);
+
+	return value;
+}
+
+/*
+ * call-seq:
+ * slob.estbytes  => fixnum or bignum
+ *
+ * Returns the estimated size of the SLOB
+ */
+static VALUE
+rb_slob_estbytes(VALUE self)
+{
+	return slob_specget(self, slob_estbytes);
+}
+
+/*
+ * call-seq:
+ * slob.extsz  => fixnum
+ *
+ * Returns the allocation extent size of the SLOB
+ */
+static VALUE
+rb_slob_extsz(VALUE self)
+{
+	return slob_specget(self, slob_extsz);
+}
+
+/*
+ * call-seq:
+ * slob.flags  => fixnum
+ *
+ * Returns the create-time flags of the SLOB
+ */
+static VALUE
+rb_slob_flags(VALUE self)
+{
+	return slob_specget(self, slob_flags);
+}
+
+/*
+ * call-seq:
+ * slob.maxbytes  => fixnum or bignum
+ *
+ * Returns the maximum size of the SLOB
+ */
+static VALUE
+rb_slob_maxbytes(VALUE self)
+{
+	return slob_specget(self, slob_maxbytes);
+}
+
+/*
+ * call-seq:
+ * slob.sbspace  => string
+ *
+ * Returns the name of the sbspace where the SLOB is stored
+ */
+static VALUE
+rb_slob_sbspace(VALUE self)
+{
+	return slob_specget(self, slob_sbspace);
+}
+
+/*
+ * call-seq:
+ * slob.extsz = fixnum    => fixnum
+ *
+ * Sets the allocation extent size for the SLOB
+ */
+static VALUE
+rb_slob_set_extsz(VALUE self, VALUE value)
+{
+	return slob_specset(self, slob_extsz, value);
+}
+
+/*
+ * call-seq:
+ * slob.flags = fixnum    => fixnum
+ *
+ * Sets the create-time flags of the SLOB
+ */
+static VALUE
+rb_slob_set_flags(VALUE self, VALUE value)
+{
+	return slob_specset(self, slob_flags, value);
+}
+
+typedef enum { slob_atime, slob_ctime, slob_mtime, slob_refcnt, slob_size } slob_stat_t;
+static char *str_slob_stats[] = {
+	"atime", "ctime", "mtime", "refcnt", "size"
+};
+
+/*
+ * Base function for getting status information
+ */
+static VALUE
+slob_stat(VALUE self, slob_stat_t stat)
+{
+	mint ret;
+	slob_t *slob;
+	ifx_lo_stat_t *st;
+	ifx_int8_t int8;
+	VALUE result;
+	EXEC SQL begin declare section;
+		char *did;
+	EXEC SQL end   declare section;
+
+	Data_Get_Struct(self, slob_t, slob);
+
+	if (slob->fd == -1)
+		rb_raise(rb_eRuntimeError,
+			"Open the Slob object before getting its status");
+
+	did = slob->database_id;
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+
+	ret = ifx_lo_stat(slob->fd, &st);
+
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+
+	switch(stat) {
+	case slob_atime:
+		ret = ifx_lo_stat_atime(st);
+		break;
+	case slob_ctime:
+		ret = ifx_lo_stat_ctime(st);
+		break;
+	case slob_mtime:
+		ret = ifx_lo_stat_mtime_sec(st);
+		break;
+	case slob_refcnt:
+		ret = ifx_lo_stat_refcnt(st);
+		break;
+	case slob_size:
+		ret = ifx_lo_stat_size(st, &int8);
+	}
+
+	ifx_lo_stat_free(st);
+
+	if (ret == -1)
+		rb_raise(rb_eRuntimeError, "Unable to get value of %s", str_slob_stats[stat]);
+
+	switch(stat) {
+		case slob_atime:
+		case slob_ctime:
+		case slob_mtime:
+			return rb_time_new(ret, 0);
+		case slob_refcnt:
+			return INT2FIX(ret);
+		case slob_size:
+			INT82NUM(&int8, result);
+			return result;
+	}
+
+	return Qnil; /* Not reached */
+}
+
+/*
+ * call-seq:
+ * slob.atime  => time
+ *
+ * Returns the time of last access as a Time object.
+ */
+static VALUE
+rb_slob_atime(VALUE self)
+{
+	return slob_stat(self, slob_atime);
+}
+
+/*
+ * call-seq:
+ * stat.ctime  => time
+ *
+ * Returns the time of last change in status as a Time object.
+ */
+static VALUE
+rb_slob_ctime(VALUE self)
+{
+	return slob_stat(self, slob_ctime);
+}
+
+/*
+ * call-seq:
+ * stat.mtime  => time
+ *
+ * Returns the time of last modification as a Time object.
+ */
+static VALUE
+rb_slob_mtime(VALUE self)
+{
+	return slob_stat(self, slob_mtime);
+}
+
+/*
+ * call-seq:
+ * stat.refcnt  => fixnum
  *
- * Returns __self__.
+ * Returns the number of references
  */
 static VALUE
-slob_truncate(VALUE self, VALUE offset)
+rb_slob_refcnt(VALUE self)
 {
-	slob_t *slob;
-	mint ret;
-	ifx_int8_t offset8;
-	EXEC SQL begin declare section;
-		char *did;
-	EXEC SQL end   declare section;
-
-	Data_Get_Struct(self, slob_t, slob);
-
-	if (slob->fd == -1)
-		rb_raise(rb_eRuntimeError, "Open the Slob object first");
-
-	did = slob->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
-
-	NUM2INT8(offset, &offset8);
-	ret = ifx_lo_truncate(slob->fd, &offset8);
-	if (ret < 0)
-		rb_raise(rb_eRuntimeError, "Informix Error: %d", ret);
+	return slob_stat(self, slob_refcnt);
+}
 
-	return self;
+/*
+ * call-seq:
+ * stat.size  => fixnum or bignum
+ *
+ * Returns the size in bytes
+ */
+static VALUE
+rb_slob_size(VALUE self)
+{
+	return slob_stat(self, slob_size);
 }
 
 /* Helper functions ------------------------------------------------------- */
@@ -564,7 +1246,8 @@ slob_truncate(VALUE self, VALUE offset)
 /*
  * Counts the number of markers '?' in the query
  */
-static int count_markers(const char *query)
+static int
+count_markers(const char *query)
 {
 	register char c, quote = 0;
 	register int count = 0;
@@ -844,6 +1527,16 @@ bind_input_params(cursor_t *c, VALUE *argv)
 				*var->sqlind = 0;
 				break;
 			}
+			if (klass == rb_cBigDecimal) {
+				data = rb_funcall(data, s_to_s, 0);
+				var->sqldata = (char *)ALLOC(dec_t);
+				deccvasc(RSTRING(data)->ptr, RSTRING(data)->len,
+					(dec_t *)var->sqldata);
+				var->sqltype = CDECIMALTYPE;
+				var->sqllen = sizeof(dec_t);
+				*var->sqlind = 0;
+				break;
+			}
 			if (rb_respond_to(data, s_read)) {
 				char *str;
 				loc_t *loc;
@@ -1005,9 +1698,17 @@ make_result(cursor_t *c, VALUE record)
 		}
 		case SQLDECIMAL:
 		case SQLMONEY: {
-			double dblValue;
-			dectodbl((dec_t *)var->sqldata, &dblValue);
-			item = rb_float_new(dblValue);
+			char buffer[40];
+			mint ret;
+
+			ret = dectoasc((dec_t *)var->sqldata, buffer,
+					sizeof(buffer) - 1, -1);
+			if (ret)
+				rb_raise(rb_eRuntimeError,
+					"Unable to convert DECIMAL to BigDecimal");
+
+			buffer[sizeof(buffer) - 1] = 0;
+			item = rb_funcall(rb_cBigDecimal, s_new, 1, rb_str_new2(buffer));
 			break;
 		}
 		case SQLBOOL:
@@ -1028,6 +1729,8 @@ make_result(cursor_t *c, VALUE record)
 				Data_Get_Struct(item, slob_t, slob);
 				memcpy(&slob->lo, var->sqldata, sizeof(ifx_lo_t));
 				slob->type = var->sqlxid;
+				slob->database_id = c->database_id;
+				slob->db = c->db;
 				break;
 			}
 		case SQLSET:
@@ -1062,16 +1765,22 @@ make_result(cursor_t *c, VALUE record)
 
 /*
  * call-seq:
- * Informix.connect(dbname, user = nil, password = nil)  => database
+ * Informix.connect(dbname, user=nil, password=nil)                      => database
+ * Informix.connect(dbname, user=nil, password=nil) {|database| block }  => obj
  *
- * Returns a <code>Database</code> object connected to <i>dbname</i> as
+ * Creates a <code>Database</code> object connected to <i>dbname</i> as
  * <i>user</i> with <i>password</i>. If these are not given, connects to
  * <i>dbname</i> as the current user.
+ *
+ * The Database object is passed to the block if it's given, and automatically
+ * closes the connection when the block terminates, returning the value of
+ * the block.
  */
+static VALUE rb_database_s_open(int argc, VALUE *argv, VALUE klass);
 static VALUE
 informix_connect(int argc, VALUE *argv, VALUE self)
 {
-	return rb_class_new_instance(argc, argv, rb_cDatabase);
+	return rb_database_s_open(argc, argv, rb_cDatabase);
 }
 
 
@@ -1086,8 +1795,6 @@ database_free(void *p)
 
 	did = p;
 	EXEC SQL disconnect :did;
-	if (currentdid == did)
-		currentdid = NULL;
 	xfree(p);
 }
 
@@ -1096,21 +1803,13 @@ database_alloc(VALUE klass)
 {
 	char *did;
 
-	did = ALLOC_N(char, IDSIZE);
-	did[0] = 0;
+	did = ALLOC_N(char, IDSIZE<<1);
+	did[0] = did[IDSIZE] = 0;
 	return Data_Wrap_Struct(klass, 0, database_free, did);
 }
 
-/*
- * call-seq:
- * Database.new(dbname, user = nil, password = nil)  => database
- *
- * Returns a <code>Database</code> object connected to <i>dbname</i> as
- * <i>user</i> with <i>password</i>. If these are not given, connects to
- * <i>dbname</i> as the current user.
- */
 static VALUE
-database_initialize(int argc, VALUE *argv, VALUE self)
+rb_database_initialize(int argc, VALUE *argv, VALUE self)
 {
 	VALUE arg[3];
 
@@ -1143,11 +1842,38 @@ database_initialize(int argc, VALUE *argv, VALUE self)
 	if (SQLCODE < 0)
 		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
-	currentdid = did;
-
 	return self;
 }
 
+/*
+ * call-seq:
+ * Database.new(dbname, user = nil, password = nil)                      => database
+ * Database.open(dbname, user = nil, password = nil)                      => database
+ * Database.new(dbname, user = nil, password = nil) {|database| block }  => obj
+ * Database.open(dbname, user = nil, password = nil) {|database| block }  => obj
+ *
+ * Creates a <code>Database</code> object connected to <i>dbname</i> as
+ * <i>user</i> with <i>password</i>. If these are not given, connects to
+ * <i>dbname</i> as the current user.
+ *
+ * The Database object is passed to the block if it's given, and automatically
+ * closes the connection when the block terminates, returning the value of
+ * the block.
+ */
+static VALUE rb_database_close(VALUE self);
+static VALUE
+rb_database_s_open(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE database;
+
+	database = rb_class_new_instance(argc, argv, klass);
+
+	if (rb_block_given_p())
+		return rb_ensure(rb_yield, database, rb_database_close, database);
+
+	return database;
+}
+
 /*
  * call-seq:
  * db.close  => db
@@ -1155,16 +1881,18 @@ database_initialize(int argc, VALUE *argv, VALUE self)
  * Disconnects <i>db</i> and returns __self__
  */
 static VALUE
-database_close(VALUE self)
+rb_database_close(VALUE self)
 {
 	EXEC SQL begin declare section;
 		char *did;
 	EXEC SQL end   declare section;
 
 	Data_Get_Struct(self, char, did);
+	did += IDSIZE;
+	if (*did)
+		EXEC SQL free :did;
+	did -= IDSIZE;
 	EXEC SQL disconnect :did;
-	if (did == currentdid)
-		currentdid = NULL;
 
 	return self;
 }
@@ -1179,7 +1907,7 @@ database_close(VALUE self)
  */
 
 static VALUE
-database_immediate(VALUE self, VALUE arg)
+rb_database_immediate(VALUE self, VALUE arg)
 {
 	EXEC SQL begin declare section;
 		char *query, *did;
@@ -1187,12 +1915,9 @@ database_immediate(VALUE self, VALUE arg)
 
 	Data_Get_Struct(self, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	query = StringValueCStr(arg);
 	EXEC SQL execute immediate :query;
@@ -1209,7 +1934,7 @@ database_immediate(VALUE self, VALUE arg)
  * Rolls back a transaction and returns __self__.
  */
 static VALUE
-database_rollback(VALUE self)
+rb_database_rollback(VALUE self)
 {
 	EXEC SQL begin declare section;
 		char *did;
@@ -1217,12 +1942,9 @@ database_rollback(VALUE self)
 
 	Data_Get_Struct(self, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	EXEC SQL rollback;
 	return self;
@@ -1235,7 +1957,7 @@ database_rollback(VALUE self)
  * Commits a transaction and returns __self__.
  */
 static VALUE
-database_commit(VALUE self)
+rb_database_commit(VALUE self)
 {
 	EXEC SQL begin declare section;
 		char *did;
@@ -1243,12 +1965,9 @@ database_commit(VALUE self)
 
 	Data_Get_Struct(self, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	EXEC SQL commit;
 	return self;
@@ -1257,7 +1976,7 @@ database_commit(VALUE self)
 static VALUE
 database_transfail(VALUE self)
 {
-	database_rollback(self);
+	rb_database_rollback(self);
 	return Qundef;
 }
 
@@ -1272,7 +1991,7 @@ database_transfail(VALUE self)
  * Returns __self__.
  */
 static VALUE
-database_transaction(VALUE self)
+rb_database_transaction(VALUE self)
 {
 	VALUE ret;
 	EXEC SQL begin declare section;
@@ -1281,12 +2000,9 @@ database_transaction(VALUE self)
 
 	Data_Get_Struct(self, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	EXEC SQL commit;
 
@@ -1300,20 +2016,27 @@ database_transaction(VALUE self)
 
 /*
  * call-seq:
- * db.prepare(query)  => statement
+ * db.prepare(query)                  => statement
+ * db.prepare(query) {|stmt| block }  => obj
+ *
+ * Creates a <code>Statement</code> object based on <i>query</i>.
+ * In the first form the Statement object is returned.
+ * In the second form the Statement object is passed to the block and when it
+ * terminates, the Statement object is dropped, returning the value of the
+ * block.
  *
- * Returns a <code>Statement</code> object based on <i>query</i>.
  * <i>query</i> may contain '?' placeholders for input parameters;
  * it must not be a query returning more than one row
  * (use <code>Database#cursor</code> instead.)
  */
+static VALUE statement_s_new(int, VALUE *, VALUE);
 static VALUE
-database_prepare(VALUE self, VALUE query)
+rb_database_prepare(VALUE self, VALUE query)
 {
 	VALUE argv[2];
 
 	argv[0] = self; argv[1] = query;
-	return rb_class_new_instance(2, argv, rb_cStatement);
+	return statement_s_new(2, argv, rb_cStatement);
 }
 
 /*
@@ -1330,7 +2053,7 @@ database_prepare(VALUE self, VALUE query)
  *
  */
 static VALUE
-database_cursor(int argc, VALUE *argv, VALUE self)
+rb_database_cursor(int argc, VALUE *argv, VALUE self)
 {
 	VALUE arg[3];
 
@@ -1339,6 +2062,37 @@ database_cursor(int argc, VALUE *argv, VALUE self)
 	return rb_class_new_instance(3, arg, rb_cCursor);
 }
 
+/*
+ * call-seq:
+ * db.slob(type = Slob::CLOB, options = nil)                  => slob
+ * db.slob(type = Slob::CLOB, options = nil) {|slob| block }  => obj
+ *
+ * Creates a Smart Large Object of type <i>type</i>.
+ * Returns a <code>Slob</code> object pointing to it.
+ *
+ * <i>type</i> can be Slob::BLOB or Slob::CLOB
+ *
+ * <i>options</i> can be nil or a Hash object with the following possible keys:
+ *
+ *   :sbspace     => Sbspace name
+ *   :estbytes    => Estimated size, in bytes
+ *   :extsz       => Allocation extent size
+ *   :createflags => Create-time flags
+ *   :openflags   => Access mode
+ *   :maxbytes    => Maximum size
+ *   :col_info    => Get the previous values from the column-level storage
+ *                   characteristics for the specified database column
+ */
+static VALUE
+rb_database_slob(int argc, VALUE *argv, VALUE self)
+{
+	VALUE arg[3];
+
+	arg[0] = self;
+	rb_scan_args(argc, argv, "02", &arg[1], &arg[2]);
+	return rb_slob_s_new(3, arg, rb_cSlob);
+}
+
 /*
  * call-seq:
  * db.columns(tablename)  => array
@@ -1346,7 +2100,7 @@ database_cursor(int argc, VALUE *argv, VALUE self)
  * Returns an array with information for every column of the given table.
  */
 static VALUE
-database_columns(VALUE self, VALUE tablename)
+rb_database_columns(VALUE self, VALUE tablename)
 {
 	VALUE v, column, result;
 	char *stype;
@@ -1363,7 +2117,7 @@ database_columns(VALUE self, VALUE tablename)
 	};
 
 	EXEC SQL begin declare section;
-		char *did;
+		char *did, *cid;
 		char *tabname;
 		int tabid, xid;
 		varchar colname[129];
@@ -1374,12 +2128,9 @@ database_columns(VALUE self, VALUE tablename)
 
 	Data_Get_Struct(self, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	tabname = StringValueCStr(tablename);
 
@@ -1390,21 +2141,28 @@ database_columns(VALUE self, VALUE tablename)
 
 	result = rb_ary_new();
 
-	EXEC SQL declare cur cursor for
-		select colname, coltype, collength, extended_id, type, default, c.colno
-		from syscolumns c, outer sysdefaults d
-		where c.tabid = :tabid and c.tabid = d.tabid and c.colno = d.colno
-		order by c.colno;
-
-	if (SQLCODE < 0)
-		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+	cid = did + IDSIZE;
+	if (!*cid) {
+		snprintf(cid, IDSIZE, "COLS%lX", self);
+		EXEC SQL declare :cid cursor for
+			select colname, coltype, collength, extended_id,
+				type, default, c.colno
+			from syscolumns c, outer sysdefaults d
+			where c.tabid = :tabid and c.tabid = d.tabid
+				and c.colno = d.colno
+			order by c.colno;
+		if (SQLCODE < 0) {
+			cid[0] = 0;
+			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
+		}
+	}
 
-	EXEC SQL open cur;
+	EXEC SQL open :cid;
 	if (SQLCODE < 0)
 		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	for(;;) {
-		EXEC SQL fetch cur into :colname, :coltype, :collength, :xid,
+		EXEC SQL fetch :cid into :colname, :coltype, :collength, :xid,
 			:deftype, :defvalue;
 		if (SQLCODE < 0)
 			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
@@ -1499,8 +2257,7 @@ database_columns(VALUE self, VALUE tablename)
 		rb_ary_push(result, column);
 	}
 
-	EXEC SQL close cur;
-	EXEC SQL free cur;
+	EXEC SQL close :cid;
 
 	return result;
 }
@@ -1530,17 +2287,12 @@ statement_free(void *p)
 	free_output_slots(p);
 
 	did = ((cursor_t *)p)->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			goto exit;
-		currentdid = did;
+	EXEC SQL set connection :did;
+	if (SQLCODE >= 0) {
+		sid = ((cursor_t *)p)->stmt_id;
+		EXEC SQL free :sid;
 	}
 
-	sid = ((cursor_t *)p)->stmt_id;
-	EXEC SQL free :sid;
-
-exit:
 	xfree(p);
 }
 
@@ -1556,10 +2308,19 @@ statement_alloc(VALUE klass)
 
 /*
  * call-seq:
- * Statement.new(database, query) => statement
+ * Statement.new(database, query)                 => statement
+ * Statement.new(database, query) {|stmt| block } => obj
  *
- * Prepares <i>query</i> in the context of <i>database</i> and returns
- * a <code>Statement</code> object.
+ * Creates a <code>Statement</code> object based on <i>query</i> in the
+ * context of <i>database</i>.
+ * In the first form the <code>Statement</code> object is returned.
+ * In the second form the Statement object is passed to the block and when it
+ * terminates, the Statement object is dropped, returning the value of the
+ * block.
+ *
+ * <i>query</i> may contain '?' placeholders for input parameters;
+ * it must not be a query returning more than one row
+ * (use <code>Cursor</code> instead.)
  */
 static VALUE
 statement_initialize(VALUE self, VALUE db, VALUE query)
@@ -1571,12 +2332,9 @@ statement_initialize(VALUE self, VALUE db, VALUE query)
 	EXEC SQL end   declare section;
 
 	Data_Get_Struct(db, char, did);
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	Data_Get_Struct(self, cursor_t, c);
 	c->db = db;
@@ -1606,6 +2364,35 @@ statement_initialize(VALUE self, VALUE db, VALUE query)
 	return self;
 }
 
+/*
+ * call-seq:
+ * Statement.new(database, query)                 => statement
+ * Statement.new(database, query) {|stmt| block } => obj
+ *
+ * Creates a <code>Statement</code> object based on <i>query</i> in the
+ * context of <i>database</i>.
+ * In the first form the <code>Statement</code> object is returned.
+ * In the second form the Statement object is passed to the block and when it
+ * terminates, the Statement object is dropped, returning the value of the
+ * block.
+ *
+ * <i>query</i> may contain '?' placeholders for input parameters;
+ * it must not be a query returning more than one row
+ * (use <code>Cursor</code> instead.)
+ */
+static VALUE statement_drop(VALUE);
+static VALUE
+statement_s_new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE stmt;
+
+	stmt = rb_class_new_instance(argc, argv, klass);
+
+	if (rb_block_given_p())
+		return rb_ensure(rb_yield, stmt, statement_drop, stmt);
+
+	return stmt;
+}
 
 /*
  * call-seq:
@@ -1629,12 +2416,9 @@ statement_call(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, cursor_t, c);
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	output = c->daOutput;
 	input = &c->daInput;
@@ -1695,19 +2479,15 @@ statement_drop(VALUE self)
 	free_output_slots(c);
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			return Qnil;
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		return Qnil;
 	sid = c->stmt_id;
 	EXEC SQL free :sid;
 
 	return Qnil;
 }
 
-
 /* module SequentialCursor ----------------------------------------------- */
 
 /* Decides whether to use an Array or a Hash, and instantiate a new
@@ -1752,12 +2532,9 @@ fetch(VALUE self, VALUE type, int bang)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	output = c->daOutput;
 	cid = c->cursor_id;
@@ -1855,12 +2632,9 @@ fetch_many(VALUE self, VALUE n, VALUE type)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	output = c->daOutput;
 	cid = c->cursor_id;
@@ -1960,12 +2734,9 @@ each(VALUE self, VALUE type, int bang)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	output = c->daOutput;
 	cid = c->cursor_id;
@@ -2115,12 +2886,9 @@ inscur_put(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	input = &c->daInput;
 	cid = c->cursor_id;
@@ -2160,12 +2928,9 @@ inscur_flush(VALUE self)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	cid = c->cursor_id;
 	EXEC SQL flush :cid;
@@ -2194,12 +2959,9 @@ scrollcur_entry(VALUE self, VALUE index, VALUE type, int bang)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			return Qnil;
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		return Qnil;
 
 	output = c->daOutput;
 	cid = c->cursor_id;
@@ -2230,11 +2992,8 @@ scrollcur_entry(VALUE self, VALUE index, VALUE type, int bang)
 static VALUE
 scrollcur_subseq(VALUE self, VALUE start, VALUE length, VALUE type)
 {
-	cursor_t *c;
-	struct sqlda *output;
 	VALUE first, records;
 	EXEC SQL begin declare section;
-		char *cid, *did;
 		long pos;
 	EXEC SQL end   declare section;
 
@@ -2374,12 +3133,9 @@ scrollcur_rel(int argc, VALUE *argv, VALUE self, int dir, VALUE type, int bang)
 		rb_raise(rb_eRuntimeError, "Open the cursor object first");
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			return Qnil;
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		return Qnil;
 
 	rb_scan_args(argc, argv, "01", &offset);
 	pos = dir*(NIL_P(offset)? 1: NUM2LONG(offset));
@@ -2698,12 +3454,9 @@ cursor_close_or_free(cursor_t *c, short op)
 	}
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			return;
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		return;
 
 	cid = c->cursor_id;
 	EXEC SQL close :cid;
@@ -2745,19 +3498,20 @@ cursor_alloc(VALUE klass)
 
 /*
  * call-seq:
- * Cursor.new(database, query, options) => cursor
+ * Cursor.new(database, query, options = nil) => cursor
  *
  * Prepares <i>query</i> in the context of <i>database</i> with <i>options</i>
  * and returns a <code>Cursor</code> object.
  *
- * <i>options</i> can be nil or a hash with the following possible keys:
+ * <i>options</i> can be nil or a Hash object with the following possible keys:
  *
  *   :scroll => true or false
- *   :hold => true or false
+ *   :hold   => true or false
  */
 static VALUE
-cursor_initialize(VALUE self, VALUE db, VALUE query, VALUE options)
+cursor_initialize(int argc, VALUE *argv, VALUE self)
 {
+	VALUE db, query, options;
 	VALUE scroll, hold;
 	struct sqlda *output;
 	cursor_t *c;
@@ -2766,14 +3520,12 @@ cursor_initialize(VALUE self, VALUE db, VALUE query, VALUE options)
 		char *cid, *sid, *did;
 	EXEC SQL end   declare section;
 
+	rb_scan_args(argc, argv, "21", &db, &query, &options);
 	Data_Get_Struct(db, char, did);
 
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	Data_Get_Struct(self, cursor_t, c);
 	c->db = db;
@@ -2784,7 +3536,8 @@ cursor_initialize(VALUE self, VALUE db, VALUE query, VALUE options)
 	cid = c->cursor_id; sid = c->stmt_id;
 	c_query = StringValueCStr(query);
 
-	if (RTEST(options)) {
+	if (!NIL_P(options)) {
+		Check_Type(options, T_HASH);
 		scroll = rb_hash_aref(options, sym_scroll);
 		hold = rb_hash_aref(options, sym_hold);
 	}
@@ -2825,6 +3578,53 @@ cursor_initialize(VALUE self, VALUE db, VALUE query, VALUE options)
 	return self;
 }
 
+/*
+ * call-seq:
+ * Cursor.open(database, query, options)                    => cursor
+ * Cursor.open(database, query, options) {|cursor| block }  => obj
+ *
+ * Creates and opens a Cursor object based on <i>query</i> using <i>options</i>
+ * in the context of <i>database</i>.
+ * In the first form the Cursor object is returned.
+ * In the second form the Cursor object is passed to the block and when it
+ * terminates, the Cursor object is dropped, returning the value of the block.
+ * 
+ * <i>options</i> can be nil or a Hash object with the following possible keys:
+ * 
+ *   :scroll => true or false
+ *   :hold   => true or false
+ *   :params => input parameters as an Array or nil
+ */
+static VALUE cursor_open(int argc, VALUE *argv, VALUE self);
+static VALUE cursor_drop(VALUE self);
+static VALUE
+cursor_s_open(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE cursor, options, params;
+	int open_argc;
+
+	rb_scan_args(argc, argv, "21", 0, 0, &options);
+	open_argc = 0; params = Qnil;
+
+	if (!NIL_P(options)) {
+		Check_Type(options, T_HASH);
+		params = rb_hash_aref(options, sym_params);
+
+		if (TYPE(params) == T_ARRAY)
+			open_argc = RARRAY(params)->len;
+		else if (params != Qnil)
+			rb_raise(rb_eRuntimeError, "Parameters must be supplied as an Array");
+	}
+
+	cursor = rb_class_new_instance(argc, argv, klass);
+	cursor_open(open_argc, &params, cursor);
+
+	if (rb_block_given_p())
+		return rb_ensure(rb_yield, cursor, cursor_drop, cursor);
+
+	return cursor;
+}
+
 /*
  * call-seq:
  * cursor.id  => string
@@ -2864,12 +3664,9 @@ cursor_open(int argc, VALUE *argv, VALUE self)
 		return self;
 
 	did = c->database_id;
-	if (currentdid != did) {
-		EXEC SQL set connection :did;
-		if (SQLCODE < 0)
-			rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
-		currentdid = did;
-	}
+	EXEC SQL set connection :did;
+	if (SQLCODE < 0)
+		rb_raise(rb_eRuntimeError, "Informix Error: %d", SQLCODE);
 
 	input = &c->daInput;
 	cid = c->cursor_id;
@@ -2945,20 +3742,44 @@ void Init_informix(void)
 	/* class Slob --------------------------------------------------------- */
 	rb_cSlob = rb_define_class_under(rb_mInformix, "Slob", rb_cObject);
 	rb_define_alloc_func(rb_cSlob, slob_alloc);
-	rb_define_method(rb_cSlob, "initialize", slob_initialize, -1);
-	rb_define_method(rb_cSlob, "open", slob_open, -1);
-	rb_define_method(rb_cSlob, "close", slob_close, 0);
-	rb_define_method(rb_cSlob, "read", slob_read, 1);
-	rb_define_method(rb_cSlob, "write", slob_write, 1);
-	rb_define_method(rb_cSlob, "seek", slob_seek, 2);
-	rb_define_method(rb_cSlob, "tell", slob_tell, 0);
-	rb_define_method(rb_cSlob, "truncate", slob_truncate, 1);
+	rb_define_method(rb_cSlob, "initialize", rb_slob_initialize, -1);
+	rb_define_singleton_method(rb_cSlob, "new", rb_slob_s_new, -1);
+	rb_define_method(rb_cSlob, "open", rb_slob_open, -1);
+	rb_define_method(rb_cSlob, "close", rb_slob_close, 0);
+	rb_define_method(rb_cSlob, "read", rb_slob_read, 1);
+	rb_define_method(rb_cSlob, "write", rb_slob_write, 1);
+	rb_define_method(rb_cSlob, "seek", rb_slob_seek, 2);
+	rb_define_method(rb_cSlob, "tell", rb_slob_tell, 0);
+	rb_define_alias(rb_cSlob, "pos", "tell");
+	rb_define_method(rb_cSlob, "pos=", rb_slob_set_pos, 1);
+	rb_define_method(rb_cSlob, "truncate", rb_slob_truncate, 1);
+	rb_define_method(rb_cSlob, "stat", rb_slob_stat, 0);
+	rb_define_method(rb_cSlob, "<<", rb_slob_addstr, 1);
+	rb_define_method(rb_cSlob, "rewind", rb_slob_rewind, 0);
+	rb_define_method(rb_cSlob, "lock", rb_slob_lock, 4);
+	rb_define_method(rb_cSlob, "unlock", rb_slob_unlock, 3);
+
+	rb_define_method(rb_cSlob, "atime", rb_slob_atime, 0);
+	rb_define_method(rb_cSlob, "ctime", rb_slob_ctime, 0);
+	rb_define_method(rb_cSlob, "mtime", rb_slob_mtime, 0);
+	rb_define_method(rb_cSlob, "refcnt", rb_slob_refcnt, 0);
+	rb_define_method(rb_cSlob, "size", rb_slob_size, 0);
+
+	rb_define_method(rb_cSlob, "estbytes", rb_slob_estbytes, 0);
+	rb_define_method(rb_cSlob, "extsz", rb_slob_extsz, 0);
+	rb_define_method(rb_cSlob, "flags", rb_slob_flags, 0);
+	rb_define_method(rb_cSlob, "maxbytes", rb_slob_maxbytes, 0);
+	rb_define_method(rb_cSlob, "sbspace", rb_slob_sbspace, 0);
+
+	rb_define_method(rb_cSlob, "extsz=", rb_slob_set_extsz, 1);
+	rb_define_method(rb_cSlob, "flags=", rb_slob_set_flags, 1);
 
 	rb_define_const(rb_cSlob, "CLOB", INT2FIX(XID_CLOB));
 	rb_define_const(rb_cSlob, "BLOB", INT2FIX(XID_BLOB));
 
 	#define DEF_SLOB_CONST(k) rb_define_const(rb_cSlob, #k, INT2FIX(LO_##k))
 
+	/* Access modes */
 	DEF_SLOB_CONST(RDONLY);
 	DEF_SLOB_CONST(DIRTY_READ);
 	DEF_SLOB_CONST(WRONLY);
@@ -2972,25 +3793,58 @@ void Init_informix(void)
 	DEF_SLOB_CONST(SEEK_CUR);
 	DEF_SLOB_CONST(SEEK_END);
 
+	/* Creation-time flags */
+	DEF_SLOB_CONST(LOG);
+	DEF_SLOB_CONST(NOLOG);
+	DEF_SLOB_CONST(KEEP_LASTACCESS_TIME);
+	DEF_SLOB_CONST(NOKEEP_LASTACCESS_TIME);
+
+	/* Ranges */
+	DEF_SLOB_CONST(CURRENT_END);
+	DEF_SLOB_CONST(MAX_END);
+
+	/* Lock modes */
+	DEF_SLOB_CONST(SHARED_MODE);
+	DEF_SLOB_CONST(EXCLUSIVE_MODE);
+
+	/* class Slob::Stat --------------------------------------------------- */
+
+	rb_cSlobStat = rb_define_class_under(rb_cSlob, "Stat", rb_cObject);
+	rb_define_alloc_func(rb_cSlobStat, slobstat_alloc);
+	rb_define_method(rb_cSlobStat, "initialize", rb_slobstat_initialize, 1);
+
+	rb_include_module(rb_cSlobStat, rb_mComparable);
+	rb_define_method(rb_cSlobStat, "<=>", rb_slobstat_cmp, 1);
+
+	rb_define_method(rb_cSlobStat, "atime", rb_slobstat_atime, 0);
+	rb_define_method(rb_cSlobStat, "ctime", rb_slobstat_ctime, 0);
+	rb_define_method(rb_cSlobStat, "mtime", rb_slobstat_mtime, 0);
+	rb_define_method(rb_cSlobStat, "refcnt", rb_slobstat_refcnt, 0);
+	rb_define_method(rb_cSlobStat, "size", rb_slobstat_size, 0);
+
 	/* class Database ----------------------------------------------------- */
 	rb_cDatabase = rb_define_class_under(rb_mInformix, "Database", rb_cObject);
 	rb_define_alloc_func(rb_cDatabase, database_alloc);
-	rb_define_method(rb_cDatabase, "initialize", database_initialize, -1);
-	rb_define_alias(rb_cDatabase, "open", "initialize");
-	rb_define_method(rb_cDatabase, "close", database_close, 0);
-	rb_define_method(rb_cDatabase, "immediate", database_immediate, 1);
+	rb_define_method(rb_cDatabase, "initialize", rb_database_initialize, -1);
+	rb_define_singleton_method(rb_cDatabase, "open", rb_database_s_open, -1);
+	rb_define_alias(rb_cDatabase, "new", "open");
+	rb_define_method(rb_cDatabase, "close", rb_database_close, 0);
+	rb_define_alias(rb_cDatabase, "disconnect", "close");
+	rb_define_method(rb_cDatabase, "immediate", rb_database_immediate, 1);
 	rb_define_alias(rb_cDatabase, "do", "immediate");
-	rb_define_method(rb_cDatabase, "rollback", database_rollback, 0);
-	rb_define_method(rb_cDatabase, "commit", database_commit, 0);
-	rb_define_method(rb_cDatabase, "transaction", database_transaction, 0);
-	rb_define_method(rb_cDatabase, "prepare", database_prepare, 1);
-	rb_define_method(rb_cDatabase, "columns", database_columns, 1);
-	rb_define_method(rb_cDatabase, "cursor", database_cursor, -1);
+	rb_define_method(rb_cDatabase, "rollback", rb_database_rollback, 0);
+	rb_define_method(rb_cDatabase, "commit", rb_database_commit, 0);
+	rb_define_method(rb_cDatabase, "transaction", rb_database_transaction, 0);
+	rb_define_method(rb_cDatabase, "prepare", rb_database_prepare, 1);
+	rb_define_method(rb_cDatabase, "columns", rb_database_columns, 1);
+	rb_define_method(rb_cDatabase, "cursor", rb_database_cursor, -1);
+	rb_define_method(rb_cDatabase, "slob", rb_database_slob, -1);
 
 	/* class Statement ---------------------------------------------------- */
 	rb_cStatement = rb_define_class_under(rb_mInformix, "Statement", rb_cObject);
 	rb_define_alloc_func(rb_cStatement, statement_alloc);
 	rb_define_method(rb_cStatement, "initialize", statement_initialize, 2);
+	rb_define_singleton_method(rb_cStatement, "new", statement_s_new, -1);
 	rb_define_method(rb_cStatement, "[]", statement_call, -1);
 	rb_define_alias(rb_cStatement, "call", "[]");
 	rb_define_alias(rb_cStatement, "execute", "[]");
@@ -3047,7 +3901,8 @@ void Init_informix(void)
 	/* class Cursor ------------------------------------------------------- */
 	rb_cCursor = rb_define_class_under(rb_mInformix, "Cursor", rb_cObject);
 	rb_define_alloc_func(rb_cCursor, cursor_alloc);
-	rb_define_method(rb_cCursor, "initialize", cursor_initialize, 3);
+	rb_define_method(rb_cCursor, "initialize", cursor_initialize, -1);
+	rb_define_singleton_method(rb_cCursor, "open", cursor_s_open, -1);
 	rb_define_method(rb_cCursor, "id", cursor_id, 0);
 	rb_define_method(rb_cCursor, "open", cursor_open, -1);
 	rb_define_method(rb_cCursor, "close", cursor_close, 0);
@@ -3056,20 +3911,15 @@ void Init_informix(void)
 	/* Global constants --------------------------------------------------- */
 	rb_require("date");
 	rb_cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+	rb_require("bigdecimal");
+	rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 
 	/* Global symbols ----------------------------------------------------- */
-	s_read = rb_intern("read");
-	s_new = rb_intern("new");
-	s_utc = rb_intern("utc");
-	s_day = rb_intern("day");
-	s_month = rb_intern("month");
-	s_year = rb_intern("year");
-	s_hour = rb_intern("hour");
-	s_min = rb_intern("min");
-	s_sec = rb_intern("sec");
-	s_usec = rb_intern("usec");
-	s_to_s = rb_intern("to_s");
-	s_to_i = rb_intern("to_i");
+	#define INTERN(sym) s_##sym = rb_intern(#sym)
+	INTERN(read); INTERN(new);
+	INTERN(utc);  INTERN(day); INTERN(month); INTERN(year);
+	INTERN(hour); INTERN(min); INTERN(sec); INTERN(usec);
+	INTERN(to_s); INTERN(to_i);
 
 	sym_name = ID2SYM(rb_intern("name"));
 	sym_type = ID2SYM(rb_intern("type"));
@@ -3090,4 +3940,7 @@ void Init_informix(void)
 	sym_extsz = ID2SYM(rb_intern("extsz"));
 	sym_createflags = ID2SYM(rb_intern("createflags"));
 	sym_openflags = ID2SYM(rb_intern("openflags"));
+	sym_maxbytes = ID2SYM(rb_intern("maxbytes"));
+
+	sym_params = ID2SYM(rb_intern("params"));
 }