void Init_do_sqlite3_ext() {
rb_require("bigdecimal");
rb_require("date");
// Get references classes needed for Date/Time parsing
rb_cDate = CONST_GET(rb_mKernel, "Date");
rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
rb_cTime = CONST_GET(rb_mKernel, "Time");
rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("data_objects"));
#ifdef RUBY_LESS_THAN_186
ID_NEW_DATE = rb_intern("new0");
#else
ID_NEW_DATE = rb_intern("new!");
#endif
ID_RATIONAL = rb_intern("Rational");
ID_LOGGER = rb_intern("logger");
ID_DEBUG = rb_intern("debug");
ID_LEVEL = rb_intern("level");
// Get references to the DataObjects module and its classes
mDO = CONST_GET(rb_mKernel, "DataObjects");
cDO_Quoting = CONST_GET(mDO, "Quoting");
cDO_Connection = CONST_GET(mDO, "Connection");
cDO_Command = CONST_GET(mDO, "Command");
cDO_Result = CONST_GET(mDO, "Result");
cDO_Reader = CONST_GET(mDO, "Reader");
// Initialize the DataObjects::Sqlite3 module, and define its classes
mSqlite3 = rb_define_module_under(mDO, "Sqlite3");
eSqlite3Error = rb_define_class("Sqlite3Error", rb_eStandardError);
cConnection = SQLITE3_CLASS("Connection", cDO_Connection);
rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
rb_define_method(cConnection, "dispose", cConnection_dispose, 0);
cCommand = SQLITE3_CLASS("Command", cDO_Command);
rb_include_module(cCommand, cDO_Quoting);
rb_define_method(cCommand, "set_types", cCommand_set_types, 1);
rb_define_method(cCommand, "execute_non_query", cCommand_execute_non_query, -1);
rb_define_method(cCommand, "execute_reader", cCommand_execute_reader, -1);
rb_define_method(cCommand, "quote_boolean", cCommand_quote_boolean, 1);
rb_define_method(cCommand, "quote_string", cCommand_quote_string, 1);
cResult = SQLITE3_CLASS("Result", cDO_Result);
cReader = SQLITE3_CLASS("Reader", cDO_Reader);
rb_define_method(cReader, "close", cReader_close, 0);
rb_define_method(cReader, "next!", cReader_next, 0);
rb_define_method(cReader, "values", cReader_values, 0);
rb_define_method(cReader, "fields", cReader_fields, 0);
rb_define_method(cReader, "field_count", cReader_field_count, 0);
rb_define_method(cReader, "row_count", cReader_row_count, 0);
}
void Init_pg_typecast() {
rb_require("pg");
rb_require("date");
rb_require("stringio");
rb_require("bigdecimal");
fnew = rb_intern("new");
cStringIO = CONST_GET(rb_mKernel, "StringIO");
cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
VALUE cPGresult = rb_define_class("PGresult", rb_cObject);
rb_include_module(cPGresult, CONST_GET(rb_mKernel, "Enumerable"));
rb_define_method(cPGresult, "each", RUBY_METHOD_FUNC(result_each), 0);
}
void init_swift_db_postgres_typecast() {
rb_require("bigdecimal");
rb_require("stringio");
rb_require("date");
cStringIO = CONST_GET(rb_mKernel, "StringIO");
cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
cDateTime = CONST_GET(rb_mKernel, "DateTime");
fnew = rb_intern("new");
fto_date = rb_intern("to_date");
fstrftime = rb_intern("strftime");
dtformat = rb_str_new2("%F %T.%N %z");
rb_global_variable(&dtformat);
}
static void raise_error(VALUE self, PGresult *result, VALUE query) {
VALUE exception;
char *message;
char *sqlstate;
int postgres_errno;
message = PQresultErrorMessage(result);
sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
postgres_errno = MAKE_SQLSTATE(sqlstate[0], sqlstate[1], sqlstate[2], sqlstate[3], sqlstate[4]);
PQclear(result);
const char *exception_type = "SQLError";
struct errcodes *errs;
for (errs = errors; errs->error_name; errs++) {
if(errs->error_no == postgres_errno) {
exception_type = errs->exception;
break;
}
}
VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
exception = rb_funcall(CONST_GET(mDO, exception_type), ID_NEW, 5,
rb_str_new2(message),
INT2NUM(postgres_errno),
rb_str_new2(sqlstate),
query,
uri);
rb_exc_raise(exception);
}
static void raise_error(VALUE self, MYSQL *db, VALUE query) {
VALUE exception;
const char *exception_type = "SQLError";
char *mysql_error_message = (char *)mysql_error(db);
int mysql_error_code = mysql_errno(db);
struct errcodes *errs;
for (errs = errors; errs->error_name; errs++) {
if(errs->error_no == mysql_error_code) {
exception_type = errs->exception;
break;
}
}
VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
exception = rb_funcall(CONST_GET(mDO, exception_type), ID_NEW, 5,
rb_str_new2(mysql_error_message),
INT2NUM(mysql_error_code),
rb_str_new2(mysql_sqlstate(db)),
query,
uri);
rb_exc_raise(exception);
}
void Init_do_oracle() {
// rb_require("oci8");
rb_require("date");
rb_require("rational");
rb_require("bigdecimal");
rb_require("data_objects");
// Get references classes needed for Date/Time parsing
rb_cDate = CONST_GET(rb_mKernel, "Date");
rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("data_objects"));
DO_ID_NEW = rb_intern("new");
DO_ID_LOGGER = rb_intern("logger");
DO_ID_DEBUG = rb_intern("debug");
DO_ID_LEVEL = rb_intern("level");
DO_ID_LOG = rb_intern("log");
DO_ID_TO_S = rb_intern("to_s");
DO_ID_RATIONAL = rb_intern("Rational");
DO_ID_NAME = rb_intern("name");
DO_ID_NUMBER = rb_intern("number");
DO_ID_VARCHAR2 = rb_intern("varchar2");
DO_ID_CHAR = rb_intern("char");
DO_ID_DATE = rb_intern("date");
DO_ID_TIMESTAMP = rb_intern("timestamp");
DO_ID_TIMESTAMP_TZ = rb_intern("timestamp_tz");
DO_ID_TIMESTAMP_LTZ = rb_intern("timestamp_ltz");
DO_ID_CLOB = rb_intern("clob");
DO_ID_BLOB = rb_intern("blob");
DO_ID_LONG = rb_intern("long");
DO_ID_RAW = rb_intern("raw");
DO_ID_LONG_RAW = rb_intern("long_raw");
DO_ID_BFILE = rb_intern("bfile");
DO_ID_BINARY_FLOAT = rb_intern("binary_float");
DO_ID_BINARY_DOUBLE = rb_intern("binary_double");
DO_ID_TO_A = rb_intern("to_a");
DO_ID_TO_I = rb_intern("to_i");
DO_ID_TO_S = rb_intern("to_s");
DO_ID_TO_F = rb_intern("to_f");
DO_ID_UTC_OFFSET = rb_intern("utc_offset");
DO_ID_ZONE = rb_intern("zone");
DO_ID_FULL_CONST_GET = rb_intern("full_const_get");
DO_ID_PARSE = rb_intern("parse");
DO_ID_FETCH = rb_intern("fetch");
DO_ID_TYPE = rb_intern("type");
DO_ID_EXECUTE = rb_intern("execute");
DO_ID_EXEC = rb_intern("exec");
DO_ID_SELECT_STMT = rb_intern("select_stmt");
DO_ID_COLUMN_METADATA = rb_intern("column_metadata");
DO_ID_PRECISION = rb_intern("precision");
DO_ID_SCALE = rb_intern("scale");
DO_ID_BIND_PARAM = rb_intern("bind_param");
DO_ID_ELEM = rb_intern("[]");
DO_ID_READ = rb_intern("read");
DO_ID_CLOSE = rb_intern("close");
DO_ID_LOGOFF = rb_intern("logoff");
// Get references to the Extlib module
mExtlib = CONST_GET(rb_mKernel, "Extlib");
rb_cByteArray = CONST_GET(mExtlib, "ByteArray");
// Get reference to OCI8 class
cOCI8 = CONST_GET(rb_mKernel, "OCI8");
cOCI8_Cursor = CONST_GET(cOCI8, "Cursor");
cOCI8_BLOB = CONST_GET(cOCI8, "BLOB");
cOCI8_CLOB = CONST_GET(cOCI8, "CLOB");
// Get references to the DataObjects module and its classes
mDO = CONST_GET(rb_mKernel, "DataObjects");
cDO_Quoting = CONST_GET(mDO, "Quoting");
cDO_Connection = CONST_GET(mDO, "Connection");
cDO_Command = CONST_GET(mDO, "Command");
cDO_Result = CONST_GET(mDO, "Result");
cDO_Reader = CONST_GET(mDO, "Reader");
cDO_Logger = CONST_GET(mDO, "Logger");
cDO_Logger_Message = CONST_GET(cDO_Logger, "Message");
// Top Level Module that all the classes live under
mDO_Oracle = rb_define_module_under(mDO, "Oracle");
eArgumentError = CONST_GET(rb_mKernel, "ArgumentError");
eDO_SQLError = CONST_GET(mDO, "SQLError");
eDO_ConnectionError = CONST_GET(mDO, "ConnectionError");
eDO_DataError = CONST_GET(mDO, "DataError");
// eOracleError = rb_define_class("OracleError", rb_eStandardError);
cDO_OracleConnection = ORACLE_CLASS("Connection", cDO_Connection);
rb_define_method(cDO_OracleConnection, "initialize", cDO_OracleConnection_initialize, 1);
rb_define_method(cDO_OracleConnection, "dispose", cDO_OracleConnection_dispose, 0);
cDO_OracleCommand = ORACLE_CLASS("Command", cDO_Command);
rb_define_method(cDO_OracleCommand, "set_types", cDO_OracleCommand_set_types, -1);
rb_define_method(cDO_OracleCommand, "execute_non_query", cDO_OracleCommand_execute_non_query, -1);
rb_define_method(cDO_OracleCommand, "execute_reader", cDO_OracleCommand_execute_reader, -1);
rb_define_method(cDO_OracleCommand, "execute_internal", cDO_OracleCommand_execute_internal, 3);
cDO_OracleResult = ORACLE_CLASS("Result", cDO_Result);
cDO_OracleReader = ORACLE_CLASS("Reader", cDO_Reader);
rb_define_method(cDO_OracleReader, "close", cDO_OracleReader_close, 0);
rb_define_method(cDO_OracleReader, "next!", cDO_OracleReader_next, 0);
rb_define_method(cDO_OracleReader, "values", cDO_OracleReader_values, 0);
rb_define_method(cDO_OracleReader, "fields", cDO_OracleReader_fields, 0);
rb_define_method(cDO_OracleReader, "field_count", cDO_OracleReader_field_count, 0);
}
void Init_do_postgres_ext() {
rb_require("date");
rb_require("bigdecimal");
// Get references classes needed for Date/Time parsing
rb_cDate = CONST_GET(rb_mKernel, "Date");
rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("data_objects"));
#ifdef RUBY_LESS_THAN_186
ID_NEW_DATE = rb_intern("new0");
#else
ID_NEW_DATE = rb_intern("new!");
#endif
ID_LOGGER = rb_intern("logger");
ID_DEBUG = rb_intern("debug");
ID_LEVEL = rb_intern("level");
ID_TO_S = rb_intern("to_s");
ID_RATIONAL = rb_intern("Rational");
// Get references to the Extlib module
mExtlib = CONST_GET(rb_mKernel, "Extlib");
rb_cByteArray = CONST_GET(mExtlib, "ByteArray");
// Get references to the DataObjects module and its classes
mDO = CONST_GET(rb_mKernel, "DataObjects");
cDO_Quoting = CONST_GET(mDO, "Quoting");
cDO_Connection = CONST_GET(mDO, "Connection");
cDO_Command = CONST_GET(mDO, "Command");
cDO_Result = CONST_GET(mDO, "Result");
cDO_Reader = CONST_GET(mDO, "Reader");
eArgumentError = CONST_GET(rb_mKernel, "ArgumentError");
mPostgres = rb_define_module_under(mDO, "Postgres");
eConnectionError = CONST_GET(mDO, "ConnectionError");
eDataError = CONST_GET(mDO, "DataError");
mEncoding = rb_define_module_under(mPostgres, "Encoding");
cConnection = POSTGRES_CLASS("Connection", cDO_Connection);
rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
rb_define_method(cConnection, "dispose", cConnection_dispose, 0);
rb_define_method(cConnection, "character_set", cConnection_character_set , 0);
rb_define_method(cConnection, "quote_string", cConnection_quote_string, 1);
rb_define_method(cConnection, "quote_byte_array", cConnection_quote_byte_array, 1);
cCommand = POSTGRES_CLASS("Command", cDO_Command);
rb_define_method(cCommand, "set_types", cCommand_set_types, -1);
rb_define_method(cCommand, "execute_non_query", cCommand_execute_non_query, -1);
rb_define_method(cCommand, "execute_reader", cCommand_execute_reader, -1);
cResult = POSTGRES_CLASS("Result", cDO_Result);
cReader = POSTGRES_CLASS("Reader", cDO_Reader);
rb_define_method(cReader, "close", cReader_close, 0);
rb_define_method(cReader, "next!", cReader_next, 0);
rb_define_method(cReader, "values", cReader_values, 0);
rb_define_method(cReader, "fields", cReader_fields, 0);
rb_define_method(cReader, "field_count", cReader_field_count, 0);
struct errcodes *errs;
for (errs = errors; errs->error_name; errs++) {
rb_const_set(mPostgres, rb_intern(errs->error_name), INT2NUM(errs->error_no));
}
}
static void full_connect(VALUE self, PGconn *db) {
PGresult *result = NULL;
VALUE r_host, r_user, r_password, r_path, r_port, r_query, r_options;
char *host = NULL, *user = NULL, *password = NULL, *path;
char *database = "", *port = "5432";
VALUE encoding = Qnil;
char *search_path = NULL;
char *search_path_query = NULL;
char *backslash_off = "SET backslash_quote = off";
char *standard_strings_on = "SET standard_conforming_strings = on";
char *warning_messages = "SET client_min_messages = warning";
if((r_host = rb_iv_get(self, "@host")) != Qnil) {
host = StringValuePtr(r_host);
}
if((r_user = rb_iv_get(self, "@user")) != Qnil) {
user = StringValuePtr(r_user);
}
if((r_password = rb_iv_get(self, "@password")) != Qnil) {
password = StringValuePtr(r_password);
}
if((r_port = rb_iv_get(self, "@port")) != Qnil) {
port = StringValuePtr(r_port);
}
if((r_path = rb_iv_get(self, "@path")) != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/");
}
if (NULL == database || 0 == strlen(database)) {
rb_raise(eConnectionError, "Database must be specified");
}
r_query = rb_iv_get(self, "@query");
search_path = get_uri_option(r_query, "search_path");
db = PQsetdbLogin(
host,
port,
NULL,
NULL,
database,
user,
password
);
if ( PQstatus(db) == CONNECTION_BAD ) {
rb_raise(eConnectionError, PQerrorMessage(db));
}
if (search_path != NULL) {
search_path_query = (char *)calloc(256, sizeof(char));
snprintf(search_path_query, 256, "set search_path to %s;", search_path);
r_query = rb_str_new2(search_path_query);
result = cCommand_execute(self, db, r_query);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
free(search_path_query);
raise_error(self, result, r_query);
}
free(search_path_query);
}
r_options = rb_str_new2(backslash_off);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn(PQresultErrorMessage(result));
}
r_options = rb_str_new2(standard_strings_on);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn(PQresultErrorMessage(result));
}
r_options = rb_str_new2(warning_messages);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn(PQresultErrorMessage(result));
}
encoding = rb_iv_get(self, "@encoding");
#ifdef HAVE_PQSETCLIENTENCODING
VALUE pg_encoding = rb_hash_aref(CONST_GET(mEncoding, "MAP"), encoding);
if(pg_encoding != Qnil) {
if(PQsetClientEncoding(db, RSTRING_PTR(pg_encoding))) {
rb_raise(eConnectionError, "Couldn't set encoding: %s", RSTRING_PTR(encoding));
} else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(RSTRING_PTR(encoding))));
#endif
rb_iv_set(self, "@pg_encoding", pg_encoding);
}
} else {
rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL\n", RSTRING_PTR(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8"));
}
#endif
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
void Init_do_mysql() {
rb_require("bigdecimal");
rb_require("date");
rb_require("data_objects");
ID_CONST_GET = rb_intern("const_get");
// Get references classes needed for Date/Time parsing
rb_cDate = CONST_GET(rb_mKernel, "Date");
rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
ID_NEW = rb_intern("new");
#ifdef RUBY_LESS_THAN_186
ID_NEW_DATE = rb_intern("new0");
#else
ID_NEW_DATE = rb_intern("new!");
#endif
ID_CONST_GET = rb_intern("const_get");
ID_RATIONAL = rb_intern("Rational");
ID_ESCAPE = rb_intern("escape_sql");
ID_STRFTIME = rb_intern("strftime");
ID_LOG = rb_intern("log");
// Get references to the Extlib module
mExtlib = CONST_GET(rb_mKernel, "Extlib");
rb_cByteArray = CONST_GET(mExtlib, "ByteArray");
// Get references to the DataObjects module and its classes
mDO = CONST_GET(rb_mKernel, "DataObjects");
cDO_Quoting = CONST_GET(mDO, "Quoting");
cDO_Connection = CONST_GET(mDO, "Connection");
cDO_Command = CONST_GET(mDO, "Command");
cDO_Result = CONST_GET(mDO, "Result");
cDO_Reader = CONST_GET(mDO, "Reader");
cDO_Logger = CONST_GET(mDO, "Logger");
cDO_Logger_Message = CONST_GET(cDO_Logger, "Message");
// Top Level Module that all the classes live under
mMysql = rb_define_module_under(mDO, "Mysql");
eConnectionError = CONST_GET(mDO, "ConnectionError");
eDataError = CONST_GET(mDO, "DataError");
mEncoding = rb_define_module_under(mMysql, "Encoding");
cConnection = DRIVER_CLASS("Connection", cDO_Connection);
rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
rb_define_method(cConnection, "using_socket?", cConnection_is_using_socket, 0);
rb_define_method(cConnection, "ssl_cipher", cConnection_ssl_cipher, 0);
rb_define_method(cConnection, "character_set", cConnection_character_set , 0);
rb_define_method(cConnection, "dispose", cConnection_dispose, 0);
rb_define_method(cConnection, "quote_string", cConnection_quote_string, 1);
rb_define_method(cConnection, "quote_date", cConnection_quote_date, 1);
rb_define_method(cConnection, "quote_time", cConnection_quote_time, 1);
rb_define_method(cConnection, "quote_datetime", cConnection_quote_date_time, 1);
cCommand = DRIVER_CLASS("Command", cDO_Command);
rb_define_method(cCommand, "set_types", cCommand_set_types, -1);
rb_define_method(cCommand, "execute_non_query", cCommand_execute_non_query, -1);
rb_define_method(cCommand, "execute_reader", cCommand_execute_reader, -1);
// Non-Query result
cResult = DRIVER_CLASS("Result", cDO_Result);
// Query result
cReader = DRIVER_CLASS("Reader", cDO_Reader);
rb_define_method(cReader, "close", cReader_close, 0);
rb_define_method(cReader, "next!", cReader_next, 0);
rb_define_method(cReader, "values", cReader_values, 0);
rb_define_method(cReader, "fields", cReader_fields, 0);
rb_define_method(cReader, "field_count", cReader_field_count, 0);
rb_global_variable(&ID_NEW_DATE);
rb_global_variable(&ID_RATIONAL);
rb_global_variable(&ID_CONST_GET);
rb_global_variable(&ID_ESCAPE);
rb_global_variable(&ID_LOG);
rb_global_variable(&ID_NEW);
rb_global_variable(&rb_cDate);
rb_global_variable(&rb_cDateTime);
rb_global_variable(&rb_cBigDecimal);
rb_global_variable(&rb_cByteArray);
rb_global_variable(&mDO);
rb_global_variable(&cDO_Logger_Message);
rb_global_variable(&cResult);
rb_global_variable(&cReader);
rb_global_variable(&eConnectionError);
rb_global_variable(&eDataError);
struct errcodes *errs;
for (errs = errors; errs->error_name; errs++) {
rb_const_set(mMysql, rb_intern(errs->error_name), INT2NUM(errs->error_no));
}
}
static void full_connect(VALUE self, MYSQL* db) {
// Check to see if we're on the db machine. If so, try to use the socket
VALUE r_host, r_user, r_password, r_path, r_query, r_port;
const char *host = "localhost", *user = "******";
char *database = NULL, *socket = NULL, *password = NULL, *path = NULL;
VALUE encoding = Qnil;
MYSQL *result;
int port = 3306;
unsigned long client_flags = 0;
int encoding_error;
if((r_host = rb_iv_get(self, "@host")) != Qnil) {
host = StringValuePtr(r_host);
}
if((r_user = rb_iv_get(self, "@user")) != Qnil) {
user = StringValuePtr(r_user);
}
if((r_password = rb_iv_get(self, "@password")) != Qnil) {
password = StringValuePtr(r_password);
}
if((r_port = rb_iv_get(self, "@port")) != Qnil) {
port = NUM2INT(r_port);
}
if((r_path = rb_iv_get(self, "@path")) != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/");
}
if (NULL == database || 0 == strlen(database)) {
rb_raise(eConnectionError, "Database must be specified");
}
r_query = rb_iv_get(self, "@query");
if (0 == strcasecmp(host, "localhost")) {
socket = get_uri_option(r_query, "socket");
if (NULL != socket) {
rb_iv_set(self, "@using_socket", Qtrue);
}
}
#ifdef HAVE_MYSQL_SSL_SET
char *ssl_client_key, *ssl_client_cert, *ssl_ca_cert, *ssl_ca_path, *ssl_cipher;
VALUE r_ssl;
if(rb_obj_is_kind_of(r_query, rb_cHash)) {
r_ssl = rb_hash_aref(r_query, rb_str_new2("ssl"));
if(rb_obj_is_kind_of(r_ssl, rb_cHash)) {
ssl_client_key = get_uri_option(r_ssl, "client_key");
ssl_client_cert = get_uri_option(r_ssl, "client_cert");
ssl_ca_cert = get_uri_option(r_ssl, "ca_cert");
ssl_ca_path = get_uri_option(r_ssl, "ca_path");
ssl_cipher = get_uri_option(r_ssl, "cipher");
assert_file_exists(ssl_client_key, "client_key doesn't exist");
assert_file_exists(ssl_client_cert, "client_cert doesn't exist");
assert_file_exists(ssl_ca_cert, "ca_cert doesn't exist");
mysql_ssl_set(db, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
} else if(r_ssl != Qnil) {
rb_raise(rb_eArgError, "ssl must be passed a hash");
}
}
#endif
result = (MYSQL *)mysql_real_connect(
db,
host,
user,
password,
database,
port,
socket,
client_flags
);
if (NULL == result) {
raise_error(self, db, Qnil);
}
#ifdef HAVE_MYSQL_SSL_SET
const char *ssl_cipher_used = mysql_get_ssl_cipher(db);
if (NULL != ssl_cipher_used) {
rb_iv_set(self, "@ssl_cipher", rb_str_new2(ssl_cipher_used));
}
#endif
#ifdef MYSQL_OPT_RECONNECT
my_bool reconnect = 1;
mysql_options(db, MYSQL_OPT_RECONNECT, &reconnect);
#endif
// Set the connections character set
encoding = rb_iv_get(self, "@encoding");
VALUE my_encoding = rb_hash_aref(CONST_GET(mEncoding, "MAP"), encoding);
if(my_encoding != Qnil) {
encoding_error = mysql_set_character_set(db, rb_str_ptr_readonly(my_encoding));
if (0 != encoding_error) {
raise_error(self, db, Qnil);
} else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));
#endif
rb_iv_set(self, "@my_encoding", my_encoding);
}
} else {
rb_warn("Encoding %s is not a known Ruby encoding for MySQL\n", rb_str_ptr_readonly(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@my_encoding", rb_str_new2("utf8"));
}
// Disable sql_auto_is_null
cCommand_execute(Qnil, self, db, rb_str_new2("SET sql_auto_is_null = 0"));
// removed NO_AUTO_VALUE_ON_ZERO because of MySQL bug http://bugs.mysql.com/bug.php?id=42270
// added NO_BACKSLASH_ESCAPES so that backslashes should not be escaped as in other databases
//4.x versions do not support certain session parameters
if(mysql_get_server_version(db) < 50000 ){
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_DIR_IN_CREATE,NO_UNSIGNED_SUBTRACTION'"));
}else{
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'"));
}
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
