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 2256

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 1953 "informixc.ec"
#line 1954 "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 1960 "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 1983 "informixc.ec"
  {
#line 1984 "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 1984 "informixc.ec"
  }
  else
/*
 *    EXEC SQL connect to :dbname as :did with concurrent transaction;
 */
#line 1986 "informixc.ec"
  {
#line 1986 "informixc.ec"
  sqli_connect_open(ESQLINTVERSION, 0, dbname, did, (ifx_conn_t *)0, 1);
#line 1986 "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 1994 "informixc.ec"
  {
#line 1999 "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 1999 "informixc.ec"
  }

  if (SQLCODE < 0)
    raise_ifx_extended();

/*
 *  EXEC SQL declare :cid cursor for :sid;
 */
#line 2004 "informixc.ec"
  {
#line 2004 "informixc.ec"
  sqli_curs_decl_dynm(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 0), cid, sqli_curs_locate(ESQLINTVERSION, sid, 1), 0, 0);
#line 2004 "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 2009 "informixc.ec"
  {
#line 2015 "informixc.ec"
  static const char *sqlcmdtxt[] =
#line 2015 "informixc.ec"
    {
#line 2015 "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 2015 "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 2015 "informixc.ec"
    };
#line 2015 "informixc.ec"
  _sqobind[0].sqldata = (c_version).server_type;
#line 2015 "informixc.ec"
  _sqobind[1].sqldata = (c_version).major;
#line 2015 "informixc.ec"
  _sqobind[2].sqldata = (c_version).minor;
#line 2015 "informixc.ec"
  _sqobind[3].sqldata = (c_version).os;
#line 2015 "informixc.ec"
  _sqobind[4].sqldata = (c_version).level;
#line 2015 "informixc.ec"
  _sqobind[5].sqldata = (c_version).full;
#line 2015 "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 2015 "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 2433

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


  Data_Get_Struct(self, database_t, dbt);
  id = dbt->database_id;
/*
 *  EXEC SQL disconnect :id;
 */
#line 2049 "informixc.ec"
  {
#line 2049 "informixc.ec"
  sqli_connect_close(0, id, 0, 0);
#line 2049 "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 2735

static VALUE
rb_database_columns(VALUE self, VALUE tablename)
{
  VALUE v, column, result;
  const char *stype;
  static const 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 const char *qualifiers[] = {
    "YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"
  };

  database_t *dbt;
/*
 *  EXEC SQL begin declare section;
 */
#line 2231 "informixc.ec"
#line 2232 "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 2239 "informixc.ec"


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

  if (SQLCODE < 0)
    raise_ifx_extended();

  tabname = StringValueCStr(tablename);

/*
 *  EXEC SQL select tabid into :tabid from systables where tabname = :tabname;
 */
#line 2250 "informixc.ec"
  {
#line 2250 "informixc.ec"
  static const char *sqlcmdtxt[] =
#line 2250 "informixc.ec"
    {
#line 2250 "informixc.ec"
    "select tabid from systables where tabname = ?",
    0
    };
#line 2250 "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 2250 "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 2250 "informixc.ec"
    };
#line 2250 "informixc.ec"
  _sqibind[0].sqldata = tabname;
#line 2250 "informixc.ec"
  _sqobind[0].sqldata = (char *) &tabid;
#line 2250 "informixc.ec"
  sqli_slct(ESQLINTVERSION, &_SQ0,sqlcmdtxt,1,_sqibind,1,_sqobind,0,(ifx_literal_t *)0,(ifx_namelist_t *)0,0);
#line 2250 "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 2257 "informixc.ec"
  {
#line 2257 "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 2257 "informixc.ec"
    };
  static ifx_sqlda_t _SD0 = { 1, _sqibind, {0}, 1, 0 };
#line 2257 "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 2257 "informixc.ec"
  }

  if (SQLCODE < 0)
    raise_ifx_extended();

  for(;;) {
/*
 *    EXEC SQL fetch :cid into :colname, :coltype, :collength, :xid,
 *      :deftype, :defvalue;
 */
#line 2263 "informixc.ec"
  {
#line 2264 "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 2264 "informixc.ec"
    };
  static ifx_sqlda_t _SD0 = { 6, _sqobind, {0}, 6, 0 };
  static _FetchSpec _FS1 = { 0, 1, 0 };
#line 2264 "informixc.ec"
  _sqobind[0].sqldata = colname;
#line 2264 "informixc.ec"
  _sqobind[1].sqldata = (char *) &coltype;
#line 2264 "informixc.ec"
  _sqobind[2].sqldata = (char *) &collength;
#line 2264 "informixc.ec"
  _sqobind[3].sqldata = (char *) &xid;
#line 2264 "informixc.ec"
  _sqobind[4].sqldata = deftype;
#line 2264 "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 2264 "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 2358 "informixc.ec"
  {
#line 2358 "informixc.ec"
  sqli_curs_close(ESQLINTVERSION, sqli_curs_locate(ESQLINTVERSION, cid, 256));
#line 2358 "informixc.ec"
  }

  return result;
}

#commit ⇒ Object

db.commit => db

Commits a transaction and returns __self__.

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

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


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

  if (SQLCODE < 0)
    raise_ifx_extended();

/*
 *  EXEC SQL commit;
 */
#line 2143 "informixc.ec"
  {
#line 2143 "informixc.ec"
  sqli_trans_commit();
#line 2143 "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 2483

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


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

  if (SQLCODE < 0)
    raise_ifx_extended();

  query = StringValueCStr(arg);
/*
 *  EXEC SQL execute immediate :query;
 */
#line 2089 "informixc.ec"
  {
#line 2089 "informixc.ec"
  sqli_exec_immed(query);
#line 2089 "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 2536

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


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

  if (SQLCODE < 0)
    raise_ifx_extended();

/*
 *  EXEC SQL rollback;
 */
#line 2117 "informixc.ec"
  {
#line 2117 "informixc.ec"
  sqli_trans_rollback();
#line 2117 "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 2661

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


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

  if (SQLCODE < 0)
    raise_ifx_extended();

/*
 *  EXEC SQL commit;
 */
#line 2195 "informixc.ec"
  {
#line 2195 "informixc.ec"
  sqli_trans_commit();
#line 2195 "informixc.ec"
  }
/*
 *  EXEC SQL begin work;
 */
#line 2196 "informixc.ec"
  {
#line 2196 "informixc.ec"
  sqli_trans_begin2((mint)1);
#line 2196 "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 2202 "informixc.ec"
  {
#line 2202 "informixc.ec"
  sqli_trans_commit();
#line 2202 "informixc.ec"
  }

  return self;
}