Class: Informix::Database

Inherits:

Object

• Object
• Informix::Database

Defined in:

lib/informix.rb,
ext/informixc.c

Constant Summary

IfxVersion =

rb_struct_define("IfxVersion", "server_type", "major",
"minor", "level", "os", "full", NULL)

Instance Attribute Summary

• #version ⇒ Object readonly

  Exact version of the database server to which a Database object is connected.

Class Method Summary

• .open(dbname, user = nil, password = nil) ⇒ Object

  Creates a Database object connected to dbname as user with password.

Instance Method Summary

• #close ⇒ Object (also: #disconnect)

  db.close => db.

• #columns(tablename) ⇒ Object

  db.columns(tablename) => array.

• #commit ⇒ Object

  db.commit => db.

• #cursor(query, options = nil, &block) ⇒ Object

  Shortcut to create a cursor object based on query using options.

• #execute(query, *args) ⇒ Object

  Shortcut to create, execute and release a Statement object from query.

• #foreach(query, options = nil, &block) ⇒ Object

  Shortcut to create, open and iterate a cursor object based on query using options.

• #foreach_hash(query, options = nil, &block) ⇒ Object

  Similar to Database#foreach, except that retrieves records as hashes instead of arrays.

• #immediate(arg) ⇒ Object

  db.immediate(query) => fixnum.

• #initialize(*args) ⇒ Object constructor

  :nodoc:.

• #prepare(query, &block) ⇒ Object

  Shortcut to create a Statement object from query.

• #rollback ⇒ Object

  db.rollback => db.

• #slob(type = Slob::CLOB, options = nil, &block) ⇒ Object

  Shortcut to create a Slob object.

• #transaction ⇒ Object

  db.transaction {|db| block } => db.

Constructor Details

#initialize(*args) ⇒ Object

:nodoc:

# File 'ext/informixc.c', line 2257

static VALUE
rb_database_initialize(int argc, VALUE *argv, VALUE self)
{
	VALUE arg[3], version;
	VALUE server_type, major, minor, os, level, full;
	database_t *dbt;

/*
 * 	EXEC SQL begin declare section;
 */
#line 1954 "informixc.ec"
#line 1955 "informixc.ec"
  char *dbname, *user = NULL, *pass = NULL;
  char *did, *cid, *sid;
struct version_t
  {
      char server_type[41], major[3], minor[3], os[3], level[3];
      char full[61];
  }  c_version;
/*
 * 	EXEC SQL end   declare section;
 */
#line 1961 "informixc.ec"


	rb_scan_args(argc, argv, "12", &arg[0], &arg[1], &arg[2]);

	if (NIL_P(arg[0]))
		rb_raise(rb_eProgrammingError, "A database name must be specified");

	Data_Get_Struct(self, database_t, dbt);

	dbname  = StringValueCStr(arg[0]);
	snprintf(dbt->database_id, IDSIZE, "DB%lX", self);
	snprintf(dbt->cursor_id, IDSIZE, "CUR%lX", dbt->idcount);
	snprintf(dbt->stmt_id, IDSIZE, "STMT%lX", dbt->idcount);
	++dbt->idcount;
	did = dbt->database_id;

	if (!NIL_P(arg[1]))
		user = StringValueCStr(arg[1]);

	if (!NIL_P(arg[2]))
		pass = StringValueCStr(arg[2]);

	if (user && pass)
/*
 * 		EXEC SQL connect to :dbname as :did user :user
 * 			using :pass with concurrent transaction;
 */
#line 1984 "informixc.ec"
  {
#line 1985 "informixc.ec"
  ifx_conn_t      *_sqiconn;
  _sqiconn = (ifx_conn_t *)ifx_alloc_conn_user(user, pass);
  sqli_connect_open(ESQLINTVERSION, 0, dbname, did, _sqiconn, 1);
  ifx_free_conn_user(&_sqiconn);
#line 1985 "informixc.ec"
  }
	else
/*
 * 		EXEC SQL connect to :dbname as :did with concurrent transaction;
 */
#line 1987 "informixc.ec"
  {
#line 1987 "informixc.ec"
  sqli_connect_open(ESQLINTVERSION, 0, dbname, did, (ifx_conn_t *)0, 1);
#line 1987 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

	cid = dbt->cursor_id;
	sid = dbt->stmt_id;

/*
 * 	EXEC SQL prepare :sid from
 * 		'select colname, coltype, collength, extended_id,
 * 			type, default, c.colno
 * 		from syscolumns c, outer sysdefaults d
 * 		where c.tabid = ? and c.tabid = d.tabid and c.colno = d.colno
 * 		order by c.colno';
 */
#line 1995 "informixc.ec"
  {
#line 2000 "informixc.ec"
  sqli_prep(ESQLINTVERSION, sid, "select colname, coltype, collength, extended_id,			type, default, c.colno		from syscolumns c, outer sysdefaults d		where c.tabid = ? and c.tabid = d.tabid and c.colno = d.colno		order by c.colno",(ifx_literal_t *)0, (ifx_namelist_t *)0, 2, 0, 0 ); 
#line 2000 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

/*
 * 	EXEC SQL declare :cid cursor for :sid;
 */
#line 2005 "informixc.ec"
  {
#line 2005 "informixc.ec"
  sqli_curs_decl_dynm(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 0), cid, sqli_curs_locate(ESQLINTVERSION, sid, 1), 0, 0);
#line 2005 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

/*
 * 	EXEC SQL select dbinfo('version', 'server-type'),
 * 					dbinfo('version', 'major'),
 * 					dbinfo('version', 'minor'),
 * 					dbinfo('version', 'os'),
 * 					dbinfo('version', 'level'),
 * 					dbinfo('version', 'full')
 * 			  into :c_version from systables where tabid = 1;
 */
#line 2010 "informixc.ec"
  {
#line 2016 "informixc.ec"
  static const char *sqlcmdtxt[] =
#line 2016 "informixc.ec"
    {
#line 2016 "informixc.ec"
    "select dbinfo ( 'version' , 'server-type' ) , dbinfo ( 'version' , 'major' ) , dbinfo ( 'version' , 'minor' ) , dbinfo ( 'version' , 'os' ) , dbinfo ( 'version' , 'level' ) , dbinfo ( 'version' , 'full' ) from systables where tabid = 1",
    0
    };
#line 2016 "informixc.ec"
static ifx_cursor_t _SQ0 = {0};
  static ifx_sqlvar_t _sqobind[] = 
    {
      { 114, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
#line 2016 "informixc.ec"
    };
#line 2016 "informixc.ec"
  _sqobind[0].sqldata = (c_version).server_type;
#line 2016 "informixc.ec"
  _sqobind[1].sqldata = (c_version).major;
#line 2016 "informixc.ec"
  _sqobind[2].sqldata = (c_version).minor;
#line 2016 "informixc.ec"
  _sqobind[3].sqldata = (c_version).os;
#line 2016 "informixc.ec"
  _sqobind[4].sqldata = (c_version).level;
#line 2016 "informixc.ec"
  _sqobind[5].sqldata = (c_version).full;
#line 2016 "informixc.ec"
  sqli_slct(ESQLINTVERSION, &_SQ0,sqlcmdtxt,0,(ifx_sqlvar_t *)0,6,_sqobind,0,(ifx_literal_t *)0,(ifx_namelist_t *)0,0);
#line 2016 "informixc.ec"
  }


	OBJ_FREEZE(server_type = rb_str_new2(c_version.server_type));
	OBJ_FREEZE(major = rb_str_new2(c_version.major));
	OBJ_FREEZE(minor = rb_str_new2(c_version.minor));
	OBJ_FREEZE(os = rb_str_new2(c_version.os));
	OBJ_FREEZE(level = rb_str_new2(c_version.level));
	OBJ_FREEZE(full = rb_str_new2(c_version.full));

	version = rb_struct_new(rb_cIfxVersion, server_type, major, minor, os,
							level, full, NULL);
	OBJ_FREEZE(version);
	rb_iv_set(self, "@version", version);

	return self;
}

Instance Attribute Details

#version ⇒ Object (readonly)

Exact version of the database server to which a Database object is connected

# File 'lib/informix.rb', line 76

def version
  @version
end

Class Method Details

.open(dbname, user = nil, password = nil) ⇒ Object

Creates a Database object connected to dbname as user with password. If these are not given, connects to dbname 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.

# File 'lib/informix.rb', line 100

def self.open(dbname, user = nil, password = nil)
  db = new(dbname, user, password)
  return db unless block_given?
  begin
    yield db
  ensure
    db.close
  end
end

Instance Method Details

#close ⇒ Object Also known as: disconnect

db.close => db

Disconnects db and returns nil.

# File 'ext/informixc.c', line 2434

static VALUE
rb_database_close(VALUE self)
{
	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2044 "informixc.ec"
#line 2045 "informixc.ec"
  char *id;
/*
 * 	EXEC SQL end   declare section;
 */
#line 2046 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	id = dbt->database_id;
/*
 * 	EXEC SQL disconnect :id;
 */
#line 2050 "informixc.ec"
  {
#line 2050 "informixc.ec"
  sqli_connect_close(0, id, 0, 0);
#line 2050 "informixc.ec"
  }

	return Qnil;
}

#columns(tablename) ⇒ Object

db.columns(tablename) => array

Returns an array with information for every column of the given table.

# File 'ext/informixc.c', line 2736

static VALUE
rb_database_columns(VALUE self, VALUE tablename)
{
	VALUE v, column, result;
	char *stype;
	static char *stypes[] = {
		"CHAR", "SMALLINT", "INTEGER", "FLOAT", "SMALLFLOAT", "DECIMAL",
		"SERIAL", "DATE", "MONEY", "NULL", "DATETIME", "BYTE",
		"TEXT", "VARCHAR", "INTERVAL", "NCHAR", "NVARCHAR", "INT8",
		"SERIAL8", "SET", "MULTISET", "LIST", "UNNAMED ROW", "NAMED ROW",
		"VARIABLE-LENGTH OPAQUE TYPE"
	};

	static char *qualifiers[] = {
		"YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"
	};

	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2232 "informixc.ec"
#line 2233 "informixc.ec"
  char *did, *cid;
  char *tabname;
int tabid, xid;
  char colname[129];
short coltype, collength;
  char deftype[2];
  char defvalue[257];
/*
 * 	EXEC SQL end   declare section;
 */
#line 2240 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	did = dbt->database_id;
/*
 * 	EXEC SQL set connection :did;
 */
#line 2244 "informixc.ec"
  {
#line 2244 "informixc.ec"
  sqli_connect_set(0, did, 0);
#line 2244 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

	tabname = StringValueCStr(tablename);

/*
 * 	EXEC SQL select tabid into :tabid from systables where tabname = :tabname;
 */
#line 2251 "informixc.ec"
  {
#line 2251 "informixc.ec"
  static const char *sqlcmdtxt[] =
#line 2251 "informixc.ec"
    {
#line 2251 "informixc.ec"
    "select tabid from systables where tabname = ?",
    0
    };
#line 2251 "informixc.ec"
static ifx_cursor_t _SQ0 = {0};
  static ifx_sqlvar_t _sqibind[] = 
    {
      { 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
#line 2251 "informixc.ec"
    };
  static ifx_sqlvar_t _sqobind[] = 
    {
      { 102, sizeof(tabid), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
#line 2251 "informixc.ec"
    };
#line 2251 "informixc.ec"
  _sqibind[0].sqldata = tabname;
#line 2251 "informixc.ec"
  _sqobind[0].sqldata = (char *) &tabid;
#line 2251 "informixc.ec"
  sqli_slct(ESQLINTVERSION, &_SQ0,sqlcmdtxt,1,_sqibind,1,_sqobind,0,(ifx_literal_t *)0,(ifx_namelist_t *)0,0);
#line 2251 "informixc.ec"
  }

	if (SQLCODE == SQLNOTFOUND)
		rb_raise(rb_eProgrammingError, "Table '%s' doesn't exist", tabname);

	result = rb_ary_new();
	cid = dbt->cursor_id;
/*
 * 	EXEC SQL open :cid using :tabid;
 */
#line 2258 "informixc.ec"
  {
#line 2258 "informixc.ec"
  static ifx_sqlvar_t _sqibind[] = 
    {
      { 102, sizeof(tabid), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
#line 2258 "informixc.ec"
    };
  static ifx_sqlda_t _SD0 = { 1, _sqibind, {0}, 1, 0 };
#line 2258 "informixc.ec"
  _sqibind[0].sqldata = (char *) &tabid;
  sqli_curs_open(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 256), &_SD0, (char *)0, (struct value *)0, 1, 0);
#line 2258 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

	for(;;) {
/*
 * 		EXEC SQL fetch :cid into :colname, :coltype, :collength, :xid,
 * 			:deftype, :defvalue;
 */
#line 2264 "informixc.ec"
  {
#line 2265 "informixc.ec"
  static ifx_sqlvar_t _sqobind[] = 
    {
      { 114, 129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 101, sizeof(coltype), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 101, sizeof(collength), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 102, sizeof(xid), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 100, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
      { 114, 257, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
#line 2265 "informixc.ec"
    };
  static ifx_sqlda_t _SD0 = { 6, _sqobind, {0}, 6, 0 };
  static _FetchSpec _FS1 = { 0, 1, 0 };
#line 2265 "informixc.ec"
  _sqobind[0].sqldata = colname;
#line 2265 "informixc.ec"
  _sqobind[1].sqldata = (char *) &coltype;
#line 2265 "informixc.ec"
  _sqobind[2].sqldata = (char *) &collength;
#line 2265 "informixc.ec"
  _sqobind[3].sqldata = (char *) &xid;
#line 2265 "informixc.ec"
  _sqobind[4].sqldata = deftype;
#line 2265 "informixc.ec"
  _sqobind[5].sqldata = defvalue;
  sqli_curs_fetch(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 256), (ifx_sqlda_t *)0, &_SD0, (char *)0, &_FS1);
#line 2265 "informixc.ec"
  }
		if (SQLCODE < 0)
			raise_ifx_extended();

		if (SQLCODE == SQLNOTFOUND)
			break;

		column = rb_hash_new();
		rb_hash_aset(column, sym_name, rb_str_new2(colname));
		rb_hash_aset(column, sym_type, INT2FIX(coltype));
		rb_hash_aset(column, sym_nullable, coltype&0x100? Qfalse: Qtrue);
		rb_hash_aset(column, sym_xid, INT2FIX(xid));

		if ((coltype&0xFF) < 23) {
			stype = coltype == 4118? stypes[23]: stypes[coltype&0xFF];
		}
		else {
			stype = stypes[24];
		}
		rb_hash_aset(column, sym_stype, rb_str_new2(stype));
		rb_hash_aset(column, sym_length, INT2FIX(collength));

		switch(coltype&0xFF) {
		case SQLVCHAR:
		case SQLNVCHAR:
		case SQLMONEY:
		case SQLDECIMAL:
			rb_hash_aset(column, sym_precision, INT2FIX(collength >> 8));
			rb_hash_aset(column, sym_scale, INT2FIX(collength&0xFF));
			break;
		case SQLDATE:
		case SQLDTIME:
		case SQLINTERVAL:
			rb_hash_aset(column, sym_length, INT2FIX(collength >> 8));
			rb_hash_aset(column, sym_precision, INT2FIX((collength&0xF0) >> 4));
			rb_hash_aset(column, sym_scale, INT2FIX(collength&0xF));
			break;
		default:
			rb_hash_aset(column, sym_precision, INT2FIX(0));
			rb_hash_aset(column, sym_scale, INT2FIX(0));
		}

		if (!deftype[0]) {
			v = Qnil;
		}
		else {
			switch(deftype[0]) {
			case 'C': {
				char current[28];
				snprintf(current, sizeof(current), "CURRENT %s TO %s",
					qualifiers[(collength&0xF0) >> 5],
					qualifiers[(collength&0xF)>>1]);
				v = rb_str_new2(current);
				break;
			}
			case 'L':
				switch (coltype & 0xFF) {
				case SQLCHAR:
				case SQLNCHAR:
				case SQLVCHAR:
				case SQLNVCHAR:
					v = rb_str_new2(defvalue);
					break;
				default: {
					char *s = defvalue;
					while(*s++ != ' ');
					if ((coltype&0xFF) == SQLFLOAT ||
						(coltype&0xFF) == SQLSMFLOAT ||
						(coltype&0xFF) == SQLMONEY ||
						(coltype&0xFF) == SQLDECIMAL)
						v = rb_float_new(atof(s));
					else
						v = LONG2FIX(atol(s));
				}
				}
				break;
			case 'N':
				v = rb_str_new2("NULL");
				break;
			case 'T':
				v = rb_str_new2("today");
				break;
			case 'U':
				v = rb_str_new2("user");
				break;
			case 'S':
			default: /* XXX */
				v = Qnil;
			}
		}
		rb_hash_aset(column, sym_default, v);
		rb_ary_push(result, column);
	}

/*
 * 	EXEC SQL close :cid;
 */
#line 2359 "informixc.ec"
  {
#line 2359 "informixc.ec"
  sqli_curs_close(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 256));
#line 2359 "informixc.ec"
  }

	return result;
}

#commit ⇒ Object

db.commit => db

Commits a transaction and returns __self__.

# File 'ext/informixc.c', line 2587

static VALUE
rb_database_commit(VALUE self)
{
	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2133 "informixc.ec"
#line 2134 "informixc.ec"
  char *did;
/*
 * 	EXEC SQL end   declare section;
 */
#line 2135 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	did = dbt->database_id;
/*
 * 	EXEC SQL set connection :did;
 */
#line 2139 "informixc.ec"
  {
#line 2139 "informixc.ec"
  sqli_connect_set(0, did, 0);
#line 2139 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

/*
 * 	EXEC SQL commit;
 */
#line 2144 "informixc.ec"
  {
#line 2144 "informixc.ec"
  sqli_trans_commit();
#line 2144 "informixc.ec"
  }

	return self;
}

#cursor(query, options = nil, &block) ⇒ Object

Shortcut to create a cursor object based on query using options.

The cursor object is passed to the block if it’s given, and automatically released when the block terminates, returning the value of the block.

query may contain ‘?’ placeholders for input parameters.

options can be a Hash object with the following possible keys:

:scroll => true or false
:hold   => true or false

Examples:

This creates a SequentialCursor

cur = db.cursor('select * from orders where order_date > ?')

This creates a ScrollCursor

cur = db.cursor('select * from customer', :scroll => true)

This creates an InsertCursor

cur = db.cursor('insert into stock values(?, ?, ?, ?, ?, ?)')

# File 'lib/informix.rb', line 177

def cursor(query, options = nil, &block)
  Cursor.new(self, query, options, &block)
end

#execute(query, *args) ⇒ Object

Shortcut to create, execute and release a Statement object from query.

query may contain ‘?’ placeholders for input parameters; it cannot be a query returning more than one row (use Database#cursor instead.)

Returns the record retrieved, in the case of a singleton select, or the number of rows affected, in the case of any other statement.

Examples:

Deleting records:

db.execute('delete from orders where order_date = ?', Date.today)

Updating a record:

db.execute('update items set quantity = ? where item_num = ?', 10, 101)

# File 'lib/informix.rb', line 152

def execute(query, *args)
  Statement.new(self, query) {|stmt| stmt.execute(*args) }
end

#foreach(query, options = nil, &block) ⇒ Object

Shortcut to create, open and iterate a cursor object based on query using options. The records are retrieved as arrays.

The cursor object is passed to the block and automatically released when the block terminates. Returns __self__.

query may contain ‘?’ placeholders for input parameters.

options can be a Hash object with the following possible keys:

:scroll => true or false
:hold   => true or false
:params => input parameters as an Array or nil

Examples:

Iterating over a table:

db.foreach('select * from customer') do |cust|
  # do something with cust
  puts "#{cust[0] cust[1]}"
end

Same thing, using input parameters:

query = 'select * from orders where order_date = ?'
db.foreach(query, :params => [Date.today]) do |order|
  # do something with order
end

# File 'lib/informix.rb', line 207

def foreach(query, options = nil, &block)
  Cursor.open(self, query, options) {|cur| cur.each(&block)}
  self
end

#foreach_hash(query, options = nil, &block) ⇒ Object

Similar to Database#foreach, except that retrieves records as hashes instead of arrays.

Examples:

Iterating over a table:

db.foreach_hash('select * from customer') do |cust|
  # do something with cust
  puts "#{cust['fname'] cust['lname']}"
end

# File 'lib/informix.rb', line 222

def foreach_hash(query, options = nil, &block)
  Cursor.open(self, query, options) {|cur| cur.each_hash(&block)}
  self
end

#immediate(arg) ⇒ Object

db.immediate(query) => fixnum

Executes query and returns the number of rows affected. query must not return rows. Executes efficiently any DDL (CREATE, DROP, ALTER), DCL (GRANT, REVOKE) and non-parameterized DML (INSERT, UPDATE, DELETE) statements, except SELECT.

Examples:

Granting CONNECT to user:

db.immediate "grant connect to #{user}"

Creating a table:

db.immediate 'create table test(id serial, code char(2), desc varchar(30))'

Deleting records:

db.immediate 'delete from test where id = 7'

# File 'ext/informixc.c', line 2484

static VALUE
rb_database_immediate(VALUE self, VALUE arg)
{
	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2078 "informixc.ec"
#line 2079 "informixc.ec"
  char *query, *did;
/*
 * 	EXEC SQL end   declare section;
 */
#line 2080 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	did = dbt->database_id;
/*
 * 	EXEC SQL set connection :did;
 */
#line 2084 "informixc.ec"
  {
#line 2084 "informixc.ec"
  sqli_connect_set(0, did, 0);
#line 2084 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

	query = StringValueCStr(arg);
/*
 * 	EXEC SQL execute immediate :query;
 */
#line 2090 "informixc.ec"
  {
#line 2090 "informixc.ec"
  sqli_exec_immed(query);
#line 2090 "informixc.ec"
  }
	if (SQLCODE < 0)
		raise_ifx_extended();

	return INT2FIX(sqlca.sqlerrd[2]);
}

#prepare(query, &block) ⇒ Object

Shortcut to create a Statement object from query.

The Statement object is passed to the block if it’s given, and automatically released when the block terminates, returning the value of the block.

query may contain ‘?’ placeholders for input parameters; it must NOT be a query returning more than one row (use Database#cursor instead.)

Examples:

Preparing a statement:

st = db.prepare('delete from orders where order_date = ?')

Using a block:

query 'update items set quantity = ? where item_num = ?'
db.prepare(query) do |st|
  # do something with st
  # the last expression evaluated will be returned
end

# File 'lib/informix.rb', line 131

def prepare(query, &block)
  Statement.new(self, query, &block)
end

#rollback ⇒ Object

db.rollback => db

Rolls back a transaction and returns __self__.

# File 'ext/informixc.c', line 2537

static VALUE
rb_database_rollback(VALUE self)
{
	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2107 "informixc.ec"
#line 2108 "informixc.ec"
  char *did;
/*
 * 	EXEC SQL end   declare section;
 */
#line 2109 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	did = dbt->database_id;
/*
 * 	EXEC SQL set connection :did;
 */
#line 2113 "informixc.ec"
  {
#line 2113 "informixc.ec"
  sqli_connect_set(0, did, 0);
#line 2113 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

/*
 * 	EXEC SQL rollback;
 */
#line 2118 "informixc.ec"
  {
#line 2118 "informixc.ec"
  sqli_trans_rollback();
#line 2118 "informixc.ec"
  }

	return self;
}

#slob(type = Slob::CLOB, options = nil, &block) ⇒ Object

Shortcut to create a Slob object.

The Slob object is passed to the block if it’s given, and automatically closes it when the block terminates, returning the value of the block.

type can be Slob::BLOB or Slob::CLOB

options can be 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

Examples:

Creating a CLOB:

slob = db.slob

Creating a BLOB without log and passing it to a block:

slob = db.slob(Slob::BLOB, :createflags=>Slob:NOLOG) do |slob|
  # do something with slob
end

# File 'lib/informix.rb', line 255

def slob(type = Slob::CLOB, options = nil, &block)
  Slob.new(self, type, options, &block)
end

#transaction ⇒ Object

db.transaction {|db| block } => db

Opens a transaction and executes block, passing __self__ as parameter. If an exception is raised, the transaction is rolled back. It is commited otherwise.

Returns __self__.

Examples:

A bulk insert using an insert cursor. Requires a transaction:

db.transaction do |db|
  db.cursor('insert into stock values(?, ?, ?, ?, ?, ?)') |cur|
    cur.open
    # Loading a file separated by '|'
    File.open(filename).each do |line|
      fields = line.split('|')
      cur.put(*fields)
    end
  end
end

# File 'ext/informixc.c', line 2662

static VALUE
rb_database_transaction(VALUE self)
{
	VALUE ret;
	database_t *dbt;
/*
 * 	EXEC SQL begin declare section;
 */
#line 2185 "informixc.ec"
#line 2186 "informixc.ec"
  char *did;
/*
 * 	EXEC SQL end   declare section;
 */
#line 2187 "informixc.ec"


	Data_Get_Struct(self, database_t, dbt);
	did = dbt->database_id;
/*
 * 	EXEC SQL set connection :did;
 */
#line 2191 "informixc.ec"
  {
#line 2191 "informixc.ec"
  sqli_connect_set(0, did, 0);
#line 2191 "informixc.ec"
  }

	if (SQLCODE < 0)
		raise_ifx_extended();

/*
 * 	EXEC SQL commit;
 */
#line 2196 "informixc.ec"
  {
#line 2196 "informixc.ec"
  sqli_trans_commit();
#line 2196 "informixc.ec"
  }
/*
 * 	EXEC SQL begin work;
 */
#line 2197 "informixc.ec"
  {
#line 2197 "informixc.ec"
  sqli_trans_begin2((mint)1);
#line 2197 "informixc.ec"
  }
	ret = rb_rescue(rb_yield, self, database_transfail, self);

	if (ret == Qundef)
		rb_raise(rb_eOperationalError, "Transaction rolled back");

/*
 * 	EXEC SQL commit;
 */
#line 2203 "informixc.ec"
  {
#line 2203 "informixc.ec"
  sqli_trans_commit();
#line 2203 "informixc.ec"
  }

	return self;
}