cubrid 0.61-x86-mingw32

data/ext/conn.c

@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution. 
+ *
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met: 
+ *
+ * - Redistributions of source code must retain the above copyright notice, 
+ *   this list of conditions and the following disclaimer. 
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice, 
+ *   this list of conditions and the following disclaimer in the documentation 
+ *   and/or other materials provided with the distribution. 
+ *
+ * - Neither the name of the <ORGANIZATION> nor the names of its contributors 
+ *   may be used to endorse or promote products derived from this software without 
+ *   specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+ * OF SUCH DAMAGE. 
+ *
+ */
+
+#include "cubrid.h"
+
+extern VALUE cConnection;
+
+extern VALUE cubrid_stmt_new(Connection *con, char *stmt, int option);
+extern VALUE cubrid_stmt_execute(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_stmt_fetch(VALUE self);
+extern VALUE cubrid_stmt_close(VALUE self);
+extern VALUE cubrid_oid_new(Connection *con, char *oid_str);
+
+static void
+cubrid_conn_free(void *p) 
+{
+  Connection *c = (Connection *)p;
+  T_CCI_ERROR error;
+
+  if (c->handle) {
+    cci_disconnect(c->handle, &error);
+    c->handle = 0;
+  }
+
+  free(p);
+}
+
+VALUE 
+cubrid_conn_new(char *host, int port, char *db, char *user, char *passwd)
+{
+  VALUE conn;
+  Connection *c;
+  int handle;
+
+  handle = cci_connect(host, port, db, user, passwd);
+  if (handle < 0) {
+    cubrid_handle_error(handle, NULL);
+    return Qnil;
+  }
+
+  conn = Data_Make_Struct(cConnection, Connection, 0, cubrid_conn_free, c);
+
+  c->handle = handle;
+  strcpy(c->host, host);
+  c->port = port;
+  strcpy(c->db, db);
+  strcpy(c->user, user);
+  c->auto_commit = Qfalse;
+
+  return conn;
+}
+
+/* call-seq:
+ *   close() -> nil
+ *
+ * 데이터베이스와의 연결을 헤제합니다. 이 연결로부터 생성된 Statement도 모두 close됩니다.
+ */
+VALUE 
+cubrid_conn_close(VALUE self)
+{
+  Connection *c;
+  T_CCI_ERROR error;
+
+  GET_CONN_STRUCT(self, c);
+
+  if (c->handle) {
+    cci_disconnect(c->handle, &error);
+    c->handle = 0;
+  }
+
+  return Qnil;
+}
+
+static VALUE 
+cubrid_conn_prepare_internal(int argc, VALUE* argv, VALUE self)
+{
+  Connection *con;
+  VALUE sql, option;
+
+  GET_CONN_STRUCT(self, con);
+  CHECK_CONNECTION(con, Qnil);
+
+  rb_scan_args(argc, argv, "11", &sql, &option);
+
+  if (NIL_P(sql)) {
+    rb_raise(rb_eStandardError, "SQL is required.");
+  }
+
+  if (NIL_P(option)) {
+    option = INT2NUM(0);
+  }
+
+  return cubrid_stmt_new(con, StringValueCStr(sql), NUM2INT(option));
+}
+
+/* call-seq:
+ *   prepare(sql <, option>) -> Statement
+ *   prepare(sql <, option>) { |stmt| block } -> nil
+ *
+ * 주어진 SQL을 실행할 준비를 하고 Statement 객체를 반환합니다. 
+ * SQL은 데이터베이스 서버로 보내져 파싱되어 실행할 수 있도록 준비됩니다.
+ *
+ * option으로 Cubrid::INCLUDE_OID를 줄 수 있는데, 이것은 SQL 실행 결과에 OID를 포함하도록 합니다.
+ * 실행 결과에 포함된 OID는 Statement.get_oid 메쏘드로 얻을 수 있습니다.
+ *
+ * block 주어지면 생성된 Statement 객체를 인수로 전달하여 block을 실행시킵니다. 
+ * block의 수행이 끝나면 Statement 객체는 더이상 유효하지 않습니다.
+ *
+ *  con = Cubrid.connect('demodb')
+ *  stmt = con.prepare('SELECT * FROM db_user')
+ *  stmt.execute
+ *  r = stmt.fetch
+ *  stmt.close
+ *  con.close
+ *
+ *  con.prepare('SELECT * FROM db_user') { |stmt|
+ *    stmt.execute
+ *    r = stmt.fetch
+ *  }
+ *  con.close
+ *
+ */
+VALUE 
+cubrid_conn_prepare(int argc, VALUE* argv, VALUE self)
+{
+  VALUE stmt;
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+
+  stmt = cubrid_conn_prepare_internal(argc, argv, self);
+  
+  if (rb_block_given_p()) {
+    rb_yield(stmt);
+    cubrid_stmt_close(stmt);
+    return Qnil;
+  }
+  
+  return stmt;
+}
+
+/* call-seq:
+ *   query(sql <, option>) -> Statement
+ *   query(sql <, option>) { |row| block } -> nil
+ *
+ * 주어진 SQL을 실행할 준비를 하고 실행까지 시킨 후 Statement 객체를 반환합니다. 
+ * 따라서 Statement.execute를 수행할 필요없이 바로 결과를 받아올 수 있습니다.
+ * 
+ * option으로 Cubrid::INCLUDE_OID를 줄 수 있는데, 이것은 prepare 메쏘드의 그것과 동일합니다.
+ *
+ * block 주어지면 Statement.fetch를 호출하여 얻어온 결과를 인수로 전달하여 block을 실행시킵니다. 
+ * block은 SQL 실행 결과로 넘어온 모든 row 대해서 한번씩 호출됩니다.
+ * block이 끝나면 Statement 객체는 더 이상 유효하지 않습니다.
+ *
+ *  con = Cubrid.connect('demodb')
+ *  stmt = con.query('SELECT * FROM db_user')
+ *  while row = stmt.fetch 
+ *    print row
+ *  end
+ *  stmt.close
+ *  con.close
+ * 
+ *  stmt = con.query('SELECT * FROM db_user') { |row|
+ *    print row
+ *  }
+ *  con.close
+ */
+VALUE 
+cubrid_conn_query(int argc, VALUE* argv, VALUE self)
+{
+  VALUE stmt;
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+
+  stmt = cubrid_conn_prepare_internal(argc, argv, self);
+  cubrid_stmt_execute(0, NULL, stmt);
+  
+  if (rb_block_given_p()) {
+    VALUE row;
+    
+    while(1) {
+      row = cubrid_stmt_fetch(stmt);
+      if (NIL_P(row)) {
+        break;
+      }
+      rb_yield(row);
+    }
+    
+    cubrid_stmt_close(stmt);
+    return Qnil;
+  }
+
+  return stmt;
+}
+
+VALUE
+cubrid_conn_end_tran(Connection *con, int type)
+{
+  int res;
+  T_CCI_ERROR error;
+
+  CHECK_CONNECTION(con, Qnil);
+
+  res = cci_end_tran(con->handle, type, &error);
+  if (res < 0){
+    cubrid_handle_error(res, &error);
+  }
+
+  return Qnil;
+}
+
+/* call-seq:
+ *   commit() -> nil
+ * 
+ * 트랜잭션을 commit으로 종료합니다. 
+ * 트랜잭션이 종료되면 이 연결로 부터 생성된 모든 Statement 객체도 모두 close 됩니다.
+ *
+ */
+VALUE
+cubrid_conn_commit(VALUE self)
+{
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  cubrid_conn_end_tran(con, CCI_TRAN_COMMIT);
+  
+  return Qnil;
+}
+
+/* call-seq:
+ *   rollback() -> nil
+ * 
+ * 트랜잭션을 rollback으로 종료합니다. 
+ * 트랜잭션이 종료되면 이 연결로 부터 생성된 모든 Statement 객체도 모두 close 됩니다.
+ *
+ */
+VALUE
+cubrid_conn_rollback(VALUE self)
+{
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  cubrid_conn_end_tran(con, CCI_TRAN_ROLLBACK);
+  
+  return Qnil;
+}
+
+/* call-seq:
+ *   auto_commit? -> true or false
+ *
+ * Connection이 auto commit 모드인지 아닌지를 반환합니다. 
+ * Connection은 기본적으로 auto commit 모드가 아니며, auto_commit= 메쏘드로 auto commit 여부를 설정할 수 있습니다.
+ *
+ */
+VALUE
+cubrid_conn_get_auto_commit(VALUE self)
+{
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  CHECK_CONNECTION(con, Qnil);
+
+  return con->auto_commit;
+}
+
+/* call-seq:
+ *   auto_commit= true or false -> nil
+ *
+ * Connection의 auto commit 모드를 설정합니다.
+ * auto commit이 true로 설정되면 Statement.execute의 실행이 끝난 후 바로 commit이 실행됩니다. 
+ *
+ */
+VALUE
+cubrid_conn_set_auto_commit(VALUE self, VALUE auto_commit)
+{
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  CHECK_CONNECTION(con, self);
+
+  con->auto_commit = auto_commit;
+  return Qnil;
+}
+
+/* call-seq:
+ *   to_s() -> string
+ *
+ * Connection의 현재 연결 정보를 문자열로 반환합니다.
+ */
+VALUE
+cubrid_conn_to_s(VALUE self)
+{
+  char buf[MAX_STR_LEN];
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  sprintf(buf, "host: %s, port: %d, db: %s, user: %s", con->host, con->port, con->db, con->user);
+
+  return rb_str_new2(buf);
+}
+
+/* call-seq:
+ *   glo_new(classname <, filename>) -> Oid
+ *
+ * 새로운 GLO 객체를 생성하고 Oid로 반환합니다.
+ * CUBRID는 바이너리 데이터를 저장할 수 있도록 GLO를 제공합니다. GLO 객체는 OID로 직접 접근할 수 있습니다.
+ *
+ * filename이 주어지면 해당 파일의 데이터를 데이터베이스에 저장합니다. 주어지지 않으면 빈 GLO 객체를 생성합니다.
+ * 
+ *  con = Cubrid.connect('subway')
+ *  con.query('create table attachfile under glo (name string)')
+ *  con.commit
+ *
+ *  glo = con.glo_new('attachfile', 'pic.jpg')
+ *  glo.glo_size  #=> 1234
+ *
+ *  glo = con.glo_new('attachfile')
+ *  glo.glo_size  #=> 0
+ *  glo.glo_save('pic.jpg')
+ *  glo.glo_size  #=> 1234
+ */
+VALUE
+cubrid_conn_glo_new(VALUE self, VALUE table, VALUE file)
+{
+  char oid_str[MAX_STR_LEN], *table_name, *file_name;
+  int res;
+  T_CCI_ERROR error;
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  CHECK_CONNECTION(con, Qnil);
+
+  if (NIL_P(table)) {
+    rb_raise(rb_eArgError, "class name is required.");
+    return Qnil;
+  }
+  table_name = StringValueCStr(table);
+  
+  if (NIL_P(file)) {
+    file_name = NULL;
+  } else {
+    file_name = StringValueCStr(file);
+  }
+   
+  res = cci_glo_new(con->handle, table_name, file_name, oid_str, &error);
+  if (res < 0) {
+    cubrid_handle_error(res, &error);
+    return Qnil;
+  }
+
+  return cubrid_oid_new(con, oid_str);
+}
+
+/* call-seq:
+ *   server_version() -> string
+ *
+ * 연결된 서버의 버전을 문자열로 반환합니다.
+ */
+VALUE
+cubrid_conn_server_version(VALUE self)
+{
+  char ver_str[MAX_STR_LEN];
+  int res;
+  Connection *con;
+
+  GET_CONN_STRUCT(self, con);
+  CHECK_CONNECTION(con, Qnil);
+
+  res = cci_get_db_version(con->handle, ver_str, MAX_STR_LEN);
+  if (res < 0) {
+    cubrid_handle_error(res, NULL);
+    return Qnil;
+  }
+
+  return rb_str_new2(ver_str);
+}
+

data/ext/cubrid.c

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution. 
+ *
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met: 
+ *
+ * - Redistributions of source code must retain the above copyright notice, 
+ *   this list of conditions and the following disclaimer. 
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice, 
+ *   this list of conditions and the following disclaimer in the documentation 
+ *   and/or other materials provided with the distribution. 
+ *
+ * - Neither the name of the <ORGANIZATION> nor the names of its contributors 
+ *   may be used to endorse or promote products derived from this software without 
+ *   specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+ * OF SUCH DAMAGE. 
+ *
+ */
+
+#include "cubrid.h"
+
+char *cci_client_name = "CCI"; /* for lower than 7.0 */
+VALUE cCubrid, cConnection, cStatement, cOid;
+extern VALUE cubrid_conn_new(char *host, int port, char *db, char *user, char *passwd);
+
+/* call-seq:
+ *   connect(db, host, port, user, password) -> Connection
+ *
+ * 데이터베이스 서버에 연결하고 Connection 객체를 반환합니다.
+ * db는 반드시 주어져야 하고, host, port, user, password는 옵션입니다. 
+ * 이들의 디폴트 값은 각각 'localhost', 30000, 'PUBLIC', '' 입니다.
+ *
+ *  con = Cubrid.connect('demodb', '192.168.1.1', '33000', 'foo','bar')
+ *  con.to_s  #=>  host: 192.168.1.1, port: 33000, db: demodb, user: foo
+ *
+ *  con = Cubrid.connect('subway')
+ *  con.to_s  #=>  host: localhost, port: 30000, db: subway, user: PUBLIC
+ *
+ *  con = Cubrid.connect('subway', '192.168.1.2')
+ *  con.to_s  #=>  host: 192.168.1.2, port: 33000, db: subway, user: PUBLIC
+ */
+VALUE cubrid_connect(int argc, VALUE* argv, VALUE self)
+{
+  VALUE host, port, db, user, passwd;
+
+  rb_scan_args(argc, argv, "14", &db, &host, &port, &user, &passwd);
+  
+  if (NIL_P(db))
+    rb_raise(rb_eStandardError, "DB name is required.");
+
+  if (NIL_P(host))
+    host = rb_str_new2("localhost");
+    
+  if (NIL_P(port))
+    port = INT2NUM(30000);
+    
+  if (NIL_P(user))
+    user = rb_str_new2("PUBLIC");
+
+  if (NIL_P(passwd))
+    passwd = rb_str_new2("");
+
+  return cubrid_conn_new(StringValueCStr(host), NUM2INT(port), 
+                         StringValueCStr(db), StringValueCStr(user), StringValueCStr(passwd));
+}
+
+/* from conn.c */
+extern VALUE cubrid_conn_close(VALUE self);
+extern VALUE cubrid_conn_prepare(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_conn_query(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_conn_commit(VALUE self);
+extern VALUE cubrid_conn_rollback(VALUE self);
+extern VALUE cubrid_conn_get_auto_commit(VALUE self);
+extern VALUE cubrid_conn_set_auto_commit(VALUE self, VALUE auto_commit);
+extern VALUE cubrid_conn_to_s(VALUE self);
+extern VALUE cubrid_conn_glo_new(VALUE self, VALUE table, VALUE file);
+extern VALUE cubrid_conn_server_version(VALUE self);
+
+/* from stmt.c */
+extern VALUE cubrid_stmt_close(VALUE self);
+extern VALUE cubrid_stmt_bind(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_stmt_execute(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_stmt_affected_rows(VALUE self);
+extern VALUE cubrid_stmt_fetch(VALUE self);
+extern VALUE cubrid_stmt_fetch_hash(VALUE self);
+extern VALUE cubrid_stmt_each(VALUE self);
+extern VALUE cubrid_stmt_each_hash(VALUE self);
+extern VALUE cubrid_stmt_column_info(VALUE self);
+extern VALUE cubrid_stmt_get_oid(VALUE self);
+
+/* from oid.c */
+extern VALUE cubrid_oid_to_s(VALUE self);
+extern VALUE cubrid_oid_table(VALUE self);
+extern VALUE cubrid_oid_refresh(VALUE self);
+extern VALUE cubrid_oid_get_value(VALUE self, VALUE attr_name);
+extern VALUE cubrid_oid_set_value(VALUE self, VALUE attr_name, VALUE val);
+extern VALUE cubrid_oid_save(VALUE self);
+extern VALUE cubrid_oid_drop(VALUE self);
+extern VALUE cubrid_oid_lock(VALUE self);
+extern VALUE cubrid_oid_glo_load(VALUE self, VALUE file_name);
+extern VALUE cubrid_oid_glo_save(VALUE self, VALUE file_name);
+extern VALUE cubrid_oid_glo_drop(VALUE self);
+extern VALUE cubrid_oid_glo_size(VALUE self);
+extern VALUE cubrid_oid_each(VALUE self);
+extern VALUE cubrid_oid_method_missing(int argc, VALUE* argv, VALUE self);
+extern VALUE cubrid_oid_to_hash(VALUE self);
+
+/* CUBRID[http://www.cubrid.com] ruby driver
+ * 
+ * CUBRID ruby driver는 ruby에서 CUBRID 데이터베이스 서버에 접속하여 질의를 할 수 있도록 해주는 모듈입니다.
+ *
+ * * Connection
+ * * Statement
+ * * Oid
+ *
+ *  con = Cubrid.connect('demodb', '192.168.1.1', '33000', 'foo','bar')
+ *  stmt = con.prepare('SELECT * FROM db_user')
+ *  stmt.execute
+ *  stmt.each { |row|
+ *    print row
+ *  }
+ *  stmt.close
+ *  con.close
+ *  
+ */
+void Init_cubrid() 
+{
+  cCubrid = rb_define_module("Cubrid");
+  rb_define_module_function(cCubrid, "connect", cubrid_connect, -1);
+
+  rb_define_const(cCubrid, "CHAR",      INT2NUM(CCI_U_TYPE_CHAR));
+  rb_define_const(cCubrid, "VARCHAR",   INT2NUM(CCI_U_TYPE_STRING));
+  rb_define_const(cCubrid, "STRING",    INT2NUM(CCI_U_TYPE_STRING));
+  rb_define_const(cCubrid, "NCHAR",     INT2NUM(CCI_U_TYPE_NCHAR));
+  rb_define_const(cCubrid, "VARNCHAR",  INT2NUM(CCI_U_TYPE_VARNCHAR));
+  rb_define_const(cCubrid, "BIT",       INT2NUM(CCI_U_TYPE_BIT));
+  rb_define_const(cCubrid, "VARBIT",    INT2NUM(CCI_U_TYPE_VARBIT));
+  rb_define_const(cCubrid, "NUMERIC",   INT2NUM(CCI_U_TYPE_NUMERIC));
+  rb_define_const(cCubrid, "INT",       INT2NUM(CCI_U_TYPE_INT));
+  rb_define_const(cCubrid, "SHORT",     INT2NUM(CCI_U_TYPE_SHORT));
+  rb_define_const(cCubrid, "MONETARY",  INT2NUM(CCI_U_TYPE_MONETARY));
+  rb_define_const(cCubrid, "FLOAT",     INT2NUM(CCI_U_TYPE_FLOAT));
+  rb_define_const(cCubrid, "DOUBLE",    INT2NUM(CCI_U_TYPE_DOUBLE));
+  rb_define_const(cCubrid, "DATE",      INT2NUM(CCI_U_TYPE_DATE));
+  rb_define_const(cCubrid, "TIME",      INT2NUM(CCI_U_TYPE_TIME));
+  rb_define_const(cCubrid, "TIMESTAMP", INT2NUM(CCI_U_TYPE_TIMESTAMP));
+  rb_define_const(cCubrid, "SET",       INT2NUM(CCI_U_TYPE_SET));
+  rb_define_const(cCubrid, "MULTISET",  INT2NUM(CCI_U_TYPE_MULTISET));
+  rb_define_const(cCubrid, "SEQUENCE",  INT2NUM(CCI_U_TYPE_SEQUENCE));
+  rb_define_const(cCubrid, "OBJECT",    INT2NUM(CCI_U_TYPE_OBJECT));
+  
+  rb_define_const(cCubrid, "INCLUDE_OID", INT2NUM(CCI_PREPARE_INCLUDE_OID));
+  rb_define_const(cCubrid, "READ_LOCK",   INT2NUM(CCI_OID_LOCK_READ));
+  rb_define_const(cCubrid, "WRITE_LOCK",  INT2NUM(CCI_OID_LOCK_WRITE));
+
+  /* connection */
+  cConnection  = rb_define_class_under(cCubrid, "Connection", rb_cObject);
+  rb_define_method(cConnection, "close", cubrid_conn_close, 0); /* in conn.c */
+  rb_define_method(cConnection, "commit", cubrid_conn_commit, 0); /* in conn.c */
+  rb_define_method(cConnection, "rollback", cubrid_conn_rollback, 0); /* in conn.c */
+  rb_define_method(cConnection, "prepare", cubrid_conn_prepare, -1); /* in conn.c */
+  rb_define_method(cConnection, "query", cubrid_conn_query, -1); /* in conn.c */
+  rb_define_method(cConnection, "auto_commit?", cubrid_conn_get_auto_commit, 0); /* in conn.c */
+  rb_define_method(cConnection, "auto_commit=", cubrid_conn_set_auto_commit, 1); /* in conn.c */
+  rb_define_method(cConnection, "to_s", cubrid_conn_to_s, 0); /* in conn.c */
+  rb_define_method(cConnection, "glo_new", cubrid_conn_glo_new, 2); /* in conn.c */
+  rb_define_method(cConnection, "server_version", cubrid_conn_server_version, 0); /* in conn.c */
+
+  /* statement */
+  cStatement  = rb_define_class_under(cCubrid, "Statement", rb_cObject);
+  rb_define_method(cStatement, "bind", cubrid_stmt_bind, -1); /* in stmt.c */
+  rb_define_method(cStatement, "execute", cubrid_stmt_execute, -1); /* in stmt.c */
+  rb_define_method(cStatement, "affected_rows", cubrid_stmt_affected_rows, 0); /* in stmt.c */
+  rb_define_method(cStatement, "column_info", cubrid_stmt_column_info, 0); /* in stmt.c */
+  rb_define_method(cStatement, "fetch", cubrid_stmt_fetch, 0); /* in stmt.c */
+  rb_define_method(cStatement, "fetch_hash", cubrid_stmt_fetch_hash, 0); /* in stmt.c */
+  rb_define_method(cStatement, "each", cubrid_stmt_each, 0); /* in stmt.c */
+  rb_define_method(cStatement, "each_hash", cubrid_stmt_each_hash, 0); /* in stmt.c */
+  rb_define_method(cStatement, "close", cubrid_stmt_close, 0); /* in stmt.c */
+  rb_define_method(cStatement, "get_oid", cubrid_stmt_get_oid, 0); /* in stmt.c */
+  /* stmt.to_s */
+
+  /* oid */
+  cOid = rb_define_class_under(cCubrid, "Oid", rb_cObject);
+  rb_define_method(cOid, "to_s", cubrid_oid_to_s, 0); /* in oid.c */
+  rb_define_method(cOid, "table", cubrid_oid_table, 0); /* in oid.c */
+  rb_define_method(cOid, "[]", cubrid_oid_get_value, 1); /* in oid.c */
+  rb_define_method(cOid, "[]=", cubrid_oid_set_value, 2); /* in oid.c */
+  rb_define_method(cOid, "each", cubrid_oid_each, 0); /* in oid.c */
+  rb_define_method(cOid, "refresh", cubrid_oid_refresh, 0); /* in oid.c */
+  rb_define_method(cOid, "save", cubrid_oid_save, 0); /* in oid.c */
+  rb_define_method(cOid, "drop", cubrid_oid_drop, 0); /* in oid.c */
+  rb_define_method(cOid, "lock", cubrid_oid_lock, 1); /* in oid.c */
+  rb_define_method(cOid, "to_hash", cubrid_oid_to_hash, 0); /* in oid.c */
+  rb_define_method(cOid, "glo_load", cubrid_oid_glo_load, 1); /* in oid.c */
+  rb_define_method(cOid, "glo_save", cubrid_oid_glo_save, 1); /* in oid.c */
+  rb_define_method(cOid, "glo_drop", cubrid_oid_glo_drop, 0); /* in oid.c */
+  rb_define_method(cOid, "glo_size", cubrid_oid_glo_size, 0); /* in oid.c */
+  rb_define_method(cOid, "method_missing", cubrid_oid_method_missing, -1); /* in oid.c */
+}
+
+/* Document-class: Cubrid::Connection
+ * Connection 클래스는 데이터베이스 서버에 대한 연결을 유지하고 트랜잭션을 연산을 수행합니다.
+ */
+
+/* Document-class: Cubrid::Statement
+ * Statement 클래스는 질의문을 수행하고 그 결과를 반환합니다.
+ */
+
+/* Document-class: Cubrid::Oid
+ * Oid 클래스는 CUBRID instance에 대하여 직접 연산을 수행할 수 있도록 합니다.
+ * CUBRID는 저장되어 있는 instance들의 고유한 식별자를 OID라는 이름으로 제공합니다. 
+ * OID를 통해서 직접 해당하는 instance에 접근하여 read/write/update/delete 연산을 할 수 있습니다.
+ * 
+ */
+
+/* TODO: 
+		 bind method & stored procedure
+		 save point
+		 db parameter : isolation level, max result count, lock time out, ..
+		 glo : load to buffer, save from buffer, performance task
+		 schema infomation
+*/
+