trilogy 2.2.0 → 2.4.0

data/ext/trilogy-ruby/cext.c

@@ -8,29 +8,40 @@
 #include <sys/time.h>
 #include <sys/un.h>
 
+#include <unistd.h>
+#include <fcntl.h>
+
 #include <trilogy.h>
 
 #include "trilogy-ruby.h"
 
 #define TRILOGY_RB_TIMEOUT 1
 
-VALUE
-rb_cTrilogyError;
-
-static VALUE Trilogy_DatabaseError, Trilogy_Result;
+VALUE Trilogy_CastError;
+static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
+    Trilogy_ConnectionClosedError, Trilogy_ConnectionRefusedError, Trilogy_ConnectionResetError,
+    Trilogy_TimeoutError, Trilogy_SyscallError, Trilogy_Result;
 
 static ID id_socket, id_host, id_port, id_username, id_password, id_found_rows, id_connect_timeout, id_read_timeout,
     id_write_timeout, id_keepalive_enabled, id_keepalive_idle, id_keepalive_interval, id_keepalive_count,
     id_ivar_affected_rows, id_ivar_fields, id_ivar_last_insert_id, id_ivar_rows, id_ivar_query_time, id_password,
     id_database, id_ssl_ca, id_ssl_capath, id_ssl_cert, id_ssl_cipher, id_ssl_crl, id_ssl_crlpath, id_ssl_key,
-    id_ssl_mode, id_tls_ciphersuites, id_tls_min_version, id_tls_max_version;
+    id_ssl_mode, id_tls_ciphersuites, id_tls_min_version, id_tls_max_version, id_multi_statement, id_multi_result,
+    id_from_code, id_from_errno, id_connection_options;
 
 struct trilogy_ctx {
     trilogy_conn_t conn;
     char server_version[TRILOGY_SERVER_VERSION_SIZE + 1];
     unsigned int query_flags;
+    VALUE encoding;
 };
 
+static void mark_trilogy(void *ptr)
+{
+    struct trilogy_ctx *ctx = ptr;
+    rb_gc_mark(ctx->encoding);
+}
+
 static void free_trilogy(void *ptr)
 {
     struct trilogy_ctx *ctx = ptr;
@@ -50,10 +61,10 @@ static size_t trilogy_memsize(const void *ptr) {
     return memsize;
 }
 
-const rb_data_type_t trilogy_data_type = {
+static const rb_data_type_t trilogy_data_type = {
     .wrap_struct_name = "trilogy",
     .function = {
-        .dmark = NULL,
+        .dmark = mark_trilogy,
         .dfree = free_trilogy,
         .dsize = trilogy_memsize,
     },
@@ -72,12 +83,25 @@ static struct trilogy_ctx *get_open_ctx(VALUE obj)
     struct trilogy_ctx *ctx = get_ctx(obj);
 
     if (ctx->conn.socket == NULL) {
-        rb_raise(rb_eIOError, "connection closed");
+        rb_raise(Trilogy_ConnectionClosedError, "Attempted to use closed connection");
     }
 
     return ctx;
 }
 
+NORETURN(static void trilogy_syserr_fail_str(int, VALUE));
+static void trilogy_syserr_fail_str(int e, VALUE msg)
+{
+    if (e == ECONNREFUSED) {
+        rb_raise(Trilogy_ConnectionRefusedError, "%" PRIsVALUE, msg);
+    } else if (e == ECONNRESET) {
+        rb_raise(Trilogy_ConnectionResetError, "%" PRIsVALUE, msg);
+    } else {
+        VALUE exc = rb_funcall(Trilogy_SyscallError, id_from_errno, 2, INT2NUM(e), msg);
+        rb_exc_raise(exc);
+    }
+}
+
 NORETURN(static void handle_trilogy_error(struct trilogy_ctx *, int, const char *, ...));
 static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *msg, ...)
 {
@@ -88,16 +112,11 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
 
     switch (rc) {
     case TRILOGY_SYSERR:
-        rb_syserr_fail_str(errno, rbmsg);
+        trilogy_syserr_fail_str(errno, rbmsg);
 
     case TRILOGY_ERR: {
         VALUE message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
-        VALUE exc = rb_exc_new3(Trilogy_DatabaseError,
-                                rb_sprintf("%" PRIsVALUE ": %d %" PRIsVALUE, rbmsg, ctx->conn.error_code, message));
-
-        rb_ivar_set(exc, rb_intern("@error_code"), INT2FIX(ctx->conn.error_code));
-        rb_ivar_set(exc, rb_intern("@error_message"), message);
-
+        VALUE exc = rb_funcall(Trilogy_ProtocolError, id_from_code, 2, message, INT2NUM(ctx->conn.error_code));
         rb_exc_raise(exc);
     }
 
@@ -105,18 +124,23 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         unsigned long ossl_error = ERR_get_error();
         ERR_clear_error();
         if (ERR_GET_LIB(ossl_error) == ERR_LIB_SYS) {
-            rb_syserr_fail_str(ERR_GET_REASON(ossl_error), rbmsg);
+            int err_reason = ERR_GET_REASON(ossl_error);
+            trilogy_syserr_fail_str(err_reason, rbmsg);
         }
         // We can't recover from OpenSSL level errors if there's
         // an active connection.
         if (ctx->conn.socket != NULL) {
             trilogy_sock_shutdown(ctx->conn.socket);
         }
-        rb_raise(rb_cTrilogyError, "%" PRIsVALUE ": SSL Error: %s", rbmsg, ERR_reason_error_string(ossl_error));
+        rb_raise(Trilogy_SSLError, "%" PRIsVALUE ": SSL Error: %s", rbmsg, ERR_reason_error_string(ossl_error));
+    }
+
+    case TRILOGY_DNS_ERR: {
+        rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE ": TRILOGY_DNS_ERROR", rbmsg);
     }
 
     default:
-        rb_raise(rb_cTrilogyError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
+        rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
     }
 }
 
@@ -129,7 +153,8 @@ static VALUE allocate_trilogy(VALUE klass)
     ctx->query_flags = TRILOGY_FLAGS_DEFAULT;
 
     if (trilogy_init(&ctx->conn) < 0) {
-        rb_syserr_fail(errno, "trilogy_init");
+        VALUE rbmsg = rb_str_new("trilogy_init", 13);
+        trilogy_syserr_fail_str(errno, rbmsg);
     }
 
     return obj;
@@ -145,7 +170,7 @@ static int flush_writes(struct trilogy_ctx *ctx)
         }
 
         if (trilogy_sock_wait_write(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_flush_writes");
+            rb_raise(Trilogy_TimeoutError, "trilogy_flush_writes");
         }
     }
 }
@@ -279,7 +304,7 @@ static void auth_switch(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_auth_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
         }
     }
 }
@@ -305,7 +330,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
             }
         } else {
             if (ssl_mode != TRILOGY_SSL_PREFERRED_NOVERIFY) {
-                rb_raise(rb_cTrilogyError, "SSL required, not supported by server");
+                rb_raise(Trilogy_SSLError, "SSL required, not supported by server");
             }
         }
     }
@@ -332,7 +357,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_auth_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
         }
     }
 
@@ -341,14 +366,18 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
     }
 }
 
-static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
+static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VALUE opts)
 {
     struct trilogy_ctx *ctx = get_ctx(self);
     trilogy_sockopt_t connopt = {0};
     trilogy_handshake_t handshake;
     VALUE val;
 
+    RB_OBJ_WRITE(self, &ctx->encoding, encoding);
+    connopt.encoding = NUM2INT(charset);
+
     Check_Type(opts, T_HASH);
+    rb_ivar_set(self, id_connection_options, opts);
 
     if ((val = rb_hash_lookup(opts, ID2SYM(id_ssl_mode))) != Qnil) {
         Check_Type(val, T_FIXNUM);
@@ -426,6 +455,14 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
         connopt.flags |= TRILOGY_CAPABILITIES_FOUND_ROWS;
     }
 
+    if (RTEST(rb_hash_aref(opts, ID2SYM(id_multi_result)))) {
+        connopt.flags |= TRILOGY_CAPABILITIES_MULTI_RESULTS;
+    }
+
+    if (RTEST(rb_hash_aref(opts, ID2SYM(id_multi_statement)))) {
+        connopt.flags |= TRILOGY_CAPABILITIES_MULTI_STATEMENTS | TRILOGY_CAPABILITIES_MULTI_RESULTS;
+    }
+
     if ((val = rb_hash_aref(opts, ID2SYM(id_ssl_ca))) != Qnil) {
         Check_Type(val, T_STRING);
         connopt.ssl_ca = StringValueCStr(val);
@@ -478,7 +515,7 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
 
     int rc = try_connect(ctx, &handshake, &connopt);
     if (rc == TRILOGY_RB_TIMEOUT) {
-        rb_syserr_fail(ETIMEDOUT, "trilogy_connect_recv");
+        rb_raise(Trilogy_TimeoutError, "trilogy_connect_recv");
     }
     if (rc != TRILOGY_OK) {
         if (connopt.path) {
@@ -525,29 +562,59 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_change_db_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_change_db_recv");
+        }
+    }
+
+    return Qtrue;
+}
+
+static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    int rc = trilogy_set_option_send(&ctx->conn, NUM2INT(option));
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_writes(ctx);
+    }
+
+    if (rc != TRILOGY_OK) {
+        handle_trilogy_error(ctx, rc, "trilogy_set_option_send");
+    }
+
+    while (1) {
+        rc = trilogy_set_option_recv(&ctx->conn);
+
+        if (rc == TRILOGY_OK) {
+            break;
+        }
+
+        if (rc != TRILOGY_AGAIN) {
+            handle_trilogy_error(ctx, rc, "trilogy_set_option_recv");
+        }
+
+        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
+            rb_raise(Trilogy_TimeoutError, "trilogy_set_option_recv");
         }
     }
 
     return Qtrue;
 }
 
+
 static void load_query_options(unsigned int query_flags, struct rb_trilogy_cast_options *cast_options)
 {
     cast_options->cast = (query_flags & TRILOGY_FLAGS_CAST) != 0;
     cast_options->cast_booleans = (query_flags & TRILOGY_FLAGS_CAST_BOOLEANS) != 0;
+    cast_options->cast_decimals_to_bigdecimals = (query_flags & TRILOGY_FLAGS_CAST_ALL_DECIMALS_TO_BIGDECIMALS) != 0;
     cast_options->database_local_time = (query_flags & TRILOGY_FLAGS_LOCAL_TIMEZONE) != 0;
     cast_options->flatten_rows = (query_flags & TRILOGY_FLAGS_FLATTEN_ROWS) != 0;
 }
 
-struct read_query_state {
+struct read_query_response_state {
     struct rb_trilogy_cast_options *cast_options;
     struct trilogy_ctx *ctx;
-    VALUE query;
-
-    // to free by caller:
-    struct column_info *column_info;
-    trilogy_value_t *row_values;
 
     // Error state for tracking
     const char *msg;
@@ -570,34 +637,25 @@ static void get_timespec_monotonic(struct timespec *ts)
 #endif
 }
 
-static VALUE read_query_error(struct read_query_state *args, int rc, const char *msg)
+static VALUE read_query_error(struct read_query_response_state *args, int rc, const char *msg)
 {
     args->rc = rc;
     args->msg = msg;
     return Qundef;
 }
 
-static VALUE execute_read_query(VALUE vargs)
+static VALUE read_query_response(VALUE vargs)
 {
-    struct read_query_state *args = (void *)vargs;
+    struct read_query_response_state *args = (void *)vargs;
     struct trilogy_ctx *ctx = args->ctx;
-    VALUE query = args->query;
 
     struct timespec start;
     get_timespec_monotonic(&start);
 
-    int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
-
-    if (rc == TRILOGY_AGAIN) {
-        rc = flush_writes(ctx);
-    }
-
-    if (rc < 0) {
-        return read_query_error(args, rc, "trilogy_query_send");
-    }
-
     uint64_t column_count = 0;
 
+    int rc;
+
     while (1) {
         rc = trilogy_query_recv(&ctx->conn, &column_count);
 
@@ -610,7 +668,7 @@ static VALUE execute_read_query(VALUE vargs)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_query_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_query_recv");
         }
     }
 
@@ -636,10 +694,13 @@ static VALUE execute_read_query(VALUE vargs)
         rb_ivar_set(result, id_ivar_affected_rows, ULL2NUM(ctx->conn.affected_rows));
 
         return result;
+    } else {
+        rb_ivar_set(result, id_ivar_last_insert_id, Qnil);
+        rb_ivar_set(result, id_ivar_affected_rows, Qnil);
     }
 
-    struct column_info *column_info = ALLOC_N(struct column_info, column_count);
-    args->column_info = column_info;
+    VALUE rb_column_info;
+    struct column_info *column_info = ALLOCV_N(struct column_info, rb_column_info, column_count);
 
     for (uint64_t i = 0; i < column_count; i++) {
         trilogy_column_t column;
@@ -656,7 +717,7 @@ static VALUE execute_read_query(VALUE vargs)
             }
 
             if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_syserr_fail(ETIMEDOUT, "trilogy_read_column");
+                rb_raise(Trilogy_TimeoutError, "trilogy_read_column");
             }
         }
 
@@ -673,17 +734,18 @@ static VALUE execute_read_query(VALUE vargs)
         column_info[i].flags = column.flags;
         column_info[i].len = column.len;
         column_info[i].charset = column.charset;
+        column_info[i].decimals = column.decimals;
     }
 
-    trilogy_value_t *row_values = ALLOC_N(trilogy_value_t, column_count);
-    args->row_values = row_values;
+    VALUE rb_row_values;
+    trilogy_value_t *row_values = ALLOCV_N(trilogy_value_t, rb_row_values, column_count);
 
     while (1) {
         int rc = trilogy_read_row(&ctx->conn, row_values);
 
         if (rc == TRILOGY_AGAIN) {
             if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_syserr_fail(ETIMEDOUT, "trilogy_read_row");
+                rb_raise(Trilogy_TimeoutError, "trilogy_read_row");
             }
             continue;
         }
@@ -709,37 +771,23 @@ static VALUE execute_read_query(VALUE vargs)
         }
     }
 
-    if (ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS) {
-        rb_raise(rb_cTrilogyError, "MORE_RESULTS_EXIST");
-    }
-
     return result;
 }
 
-static VALUE rb_trilogy_query(VALUE self, VALUE query)
+static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
 {
-    struct trilogy_ctx *ctx = get_open_ctx(self);
-
-    StringValue(query);
-
     struct rb_trilogy_cast_options cast_options;
     load_query_options(ctx->query_flags, &cast_options);
 
-    struct read_query_state args = {
+    struct read_query_response_state args = {
         .cast_options = &cast_options,
-        .column_info = NULL,
         .ctx = ctx,
-        .query = query,
-        .row_values = NULL,
         .rc = TRILOGY_OK,
         .msg = NULL,
     };
 
     int state = 0;
-    VALUE result = rb_protect(execute_read_query, (VALUE)&args, &state);
-
-    xfree(args.column_info);
-    xfree(args.row_values);
+    VALUE result = rb_protect(read_query_response, (VALUE)&args, &state);
 
     // If we have seen an unexpected exception, jump to it so it gets raised.
     if (state) {
@@ -756,6 +804,48 @@ static VALUE rb_trilogy_query(VALUE self, VALUE query)
     return result;
 }
 
+static VALUE rb_trilogy_next_result(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    if (!(ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS)) {
+        return Qnil;
+    }
+
+    return execute_read_query_response(ctx);
+}
+
+static VALUE rb_trilogy_more_results_exist(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    if (ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_trilogy_query(VALUE self, VALUE query)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    StringValue(query);
+    query = rb_str_export_to_enc(query, rb_to_encoding(ctx->encoding));
+
+    int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_writes(ctx);
+    }
+
+    if (rc < 0) {
+        handle_trilogy_error(ctx, rc, "trilogy_query_send");
+    }
+
+    return execute_read_query_response(ctx);
+}
+
 static VALUE rb_trilogy_ping(VALUE self)
 {
     struct trilogy_ctx *ctx = get_open_ctx(self);
@@ -782,7 +872,7 @@ static VALUE rb_trilogy_ping(VALUE self)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_ping_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_ping_recv");
         }
     }
 
@@ -857,6 +947,25 @@ static VALUE rb_trilogy_closed(VALUE self)
     }
 }
 
+static VALUE rb_trilogy_discard(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_ctx(self);
+
+    if (ctx->conn.socket == NULL) {
+        return Qtrue;
+    }
+
+    int rc = trilogy_discard(&ctx->conn);
+    switch (rc) {
+        case TRILOGY_OK:
+            return Qtrue;
+        case TRILOGY_SYSERR:
+            trilogy_syserr_fail_str(errno, rb_str_new_cstr("Failed to discard connection"));
+            UNREACHABLE_RETURN(Qfalse);
+    }
+    return Qfalse;
+}
+
 static VALUE rb_trilogy_last_insert_id(VALUE self) { return ULL2NUM(get_open_ctx(self)->conn.last_insert_id); }
 
 static VALUE rb_trilogy_affected_rows(VALUE self) { return ULL2NUM(get_open_ctx(self)->conn.affected_rows); }
@@ -916,19 +1025,19 @@ static VALUE rb_trilogy_server_status(VALUE self) { return LONG2FIX(get_open_ctx
 
 static VALUE rb_trilogy_server_version(VALUE self) { return rb_str_new_cstr(get_open_ctx(self)->server_version); }
 
-void Init_cext()
+RUBY_FUNC_EXPORTED void Init_cext()
 {
-    VALUE Trilogy = rb_define_class("Trilogy", rb_cObject);
-
+    VALUE Trilogy = rb_const_get(rb_cObject, rb_intern("Trilogy"));
     rb_define_alloc_func(Trilogy, allocate_trilogy);
 
-    rb_define_method(Trilogy, "initialize", rb_trilogy_initialize, 1);
+    rb_define_private_method(Trilogy, "_initialize", rb_trilogy_initialize, 3);
     rb_define_method(Trilogy, "change_db", rb_trilogy_change_db, 1);
     rb_define_method(Trilogy, "query", rb_trilogy_query, 1);
     rb_define_method(Trilogy, "ping", rb_trilogy_ping, 0);
     rb_define_method(Trilogy, "escape", rb_trilogy_escape, 1);
     rb_define_method(Trilogy, "close", rb_trilogy_close, 0);
     rb_define_method(Trilogy, "closed?", rb_trilogy_closed, 0);
+    rb_define_method(Trilogy, "discard!", rb_trilogy_discard, 0);
     rb_define_method(Trilogy, "last_insert_id", rb_trilogy_last_insert_id, 0);
     rb_define_method(Trilogy, "affected_rows", rb_trilogy_affected_rows, 0);
     rb_define_method(Trilogy, "warning_count", rb_trilogy_warning_count, 0);
@@ -941,6 +1050,9 @@ void Init_cext()
     rb_define_method(Trilogy, "write_timeout=", rb_trilogy_write_timeout_set, 1);
     rb_define_method(Trilogy, "server_status", rb_trilogy_server_status, 0);
     rb_define_method(Trilogy, "server_version", rb_trilogy_server_version, 0);
+    rb_define_method(Trilogy, "more_results_exist?", rb_trilogy_more_results_exist, 0);
+    rb_define_method(Trilogy, "next_result", rb_trilogy_next_result, 0);
+    rb_define_method(Trilogy, "set_server_option", rb_trilogy_set_server_option, 1);
     rb_define_const(Trilogy, "TLS_VERSION_10", INT2NUM(TRILOGY_TLS_VERSION_10));
     rb_define_const(Trilogy, "TLS_VERSION_11", INT2NUM(TRILOGY_TLS_VERSION_11));
     rb_define_const(Trilogy, "TLS_VERSION_12", INT2NUM(TRILOGY_TLS_VERSION_12));
@@ -955,27 +1067,43 @@ void Init_cext()
     rb_define_const(Trilogy, "QUERY_FLAGS_NONE", INT2NUM(0));
     rb_define_const(Trilogy, "QUERY_FLAGS_CAST", INT2NUM(TRILOGY_FLAGS_CAST));
     rb_define_const(Trilogy, "QUERY_FLAGS_CAST_BOOLEANS", INT2NUM(TRILOGY_FLAGS_CAST_BOOLEANS));
+    rb_define_const(Trilogy, "QUERY_FLAGS_CAST_ALL_DECIMALS_TO_BIGDECIMALS", INT2NUM(TRILOGY_FLAGS_CAST_ALL_DECIMALS_TO_BIGDECIMALS));
     rb_define_const(Trilogy, "QUERY_FLAGS_LOCAL_TIMEZONE", INT2NUM(TRILOGY_FLAGS_LOCAL_TIMEZONE));
     rb_define_const(Trilogy, "QUERY_FLAGS_FLATTEN_ROWS", INT2NUM(TRILOGY_FLAGS_FLATTEN_ROWS));
     rb_define_const(Trilogy, "QUERY_FLAGS_DEFAULT", INT2NUM(TRILOGY_FLAGS_DEFAULT));
 
-    rb_cTrilogyError = rb_define_class_under(Trilogy, "Error", rb_eStandardError);
-    rb_global_variable(&rb_cTrilogyError);
+    Trilogy_ProtocolError = rb_const_get(Trilogy, rb_intern("ProtocolError"));
+    rb_global_variable(&Trilogy_ProtocolError);
+
+    Trilogy_SSLError = rb_const_get(Trilogy, rb_intern("SSLError"));
+    rb_global_variable(&Trilogy_SSLError);
+
+    Trilogy_QueryError = rb_const_get(Trilogy, rb_intern("QueryError"));
+    rb_global_variable(&Trilogy_QueryError);
+
+    Trilogy_TimeoutError = rb_const_get(Trilogy, rb_intern("TimeoutError"));
+    rb_global_variable(&Trilogy_TimeoutError);
+
+    Trilogy_ConnectionRefusedError = rb_const_get(Trilogy, rb_intern("ConnectionRefusedError"));
+    rb_global_variable(&Trilogy_ConnectionRefusedError);
+
+    Trilogy_ConnectionResetError = rb_const_get(Trilogy, rb_intern("ConnectionResetError"));
+    rb_global_variable(&Trilogy_ConnectionResetError);
 
-    Trilogy_DatabaseError = rb_define_class_under(Trilogy, "DatabaseError", rb_cTrilogyError);
-    rb_global_variable(&Trilogy_DatabaseError);
+    Trilogy_BaseConnectionError = rb_const_get(Trilogy, rb_intern("BaseConnectionError"));
+    rb_global_variable(&Trilogy_BaseConnectionError);
 
-    rb_define_attr(Trilogy_DatabaseError, "error_code", 1, 0);
-    rb_define_attr(Trilogy_DatabaseError, "error_message", 1, 0);
+    Trilogy_ConnectionClosedError = rb_const_get(Trilogy, rb_intern("ConnectionClosed"));
+    rb_global_variable(&Trilogy_ConnectionClosedError);
 
-    Trilogy_Result = rb_define_class_under(Trilogy, "Result", rb_cObject);
+    Trilogy_Result = rb_const_get(Trilogy, rb_intern("Result"));
     rb_global_variable(&Trilogy_Result);
 
-    rb_define_attr(Trilogy_Result, "affected_rows", 1, 0);
-    rb_define_attr(Trilogy_Result, "fields", 1, 0);
-    rb_define_attr(Trilogy_Result, "last_insert_id", 1, 0);
-    rb_define_attr(Trilogy_Result, "rows", 1, 0);
-    rb_define_attr(Trilogy_Result, "query_time", 1, 0);
+    Trilogy_SyscallError = rb_const_get(Trilogy, rb_intern("SyscallError"));
+    rb_global_variable(&Trilogy_SyscallError);
+
+    Trilogy_CastError = rb_const_get(Trilogy, rb_intern("CastError"));
+    rb_global_variable(&Trilogy_CastError);
 
     id_socket = rb_intern("socket");
     id_host = rb_intern("host");
@@ -1002,12 +1130,16 @@ void Init_cext()
     id_tls_ciphersuites = rb_intern("tls_ciphersuites");
     id_tls_min_version = rb_intern("tls_min_version");
     id_tls_max_version = rb_intern("tls_max_version");
-
+    id_multi_statement = rb_intern("multi_statement");
+    id_multi_result = rb_intern("multi_result");
+    id_from_code = rb_intern("from_code");
+    id_from_errno = rb_intern("from_errno");
     id_ivar_affected_rows = rb_intern("@affected_rows");
     id_ivar_fields = rb_intern("@fields");
     id_ivar_last_insert_id = rb_intern("@last_insert_id");
     id_ivar_rows = rb_intern("@rows");
     id_ivar_query_time = rb_intern("@query_time");
+    id_connection_options = rb_intern("@connection_options");
 
     rb_trilogy_cast_init();
 
@@ -1015,4 +1147,14 @@ void Init_cext()
 #define XX(name, code) rb_const_set(Trilogy, rb_intern((char *)#name + strlen("TRILOGY_")), LONG2NUM(name));
     TRILOGY_SERVER_STATUS(XX)
 #undef XX
+
+// set_server_option options
+#define XX(name, code) rb_const_set(Trilogy, rb_intern((char *)#name + strlen("TRILOGY_")), LONG2NUM(name));
+    TRILOGY_SET_SERVER_OPTION(XX)
+#undef XX
+
+// charsets
+#define XX(name, code) rb_const_set(Trilogy, rb_intern((char *)#name + strlen("TRILOGY_")), LONG2NUM(name));
+    TRILOGY_CHARSETS(XX)
+#undef XX
 }

data/ext/trilogy-ruby/extconf.rb

@@ -6,7 +6,7 @@ File.binwrite("trilogy.c",
   Dir["#{__dir__}/src/**/*.c"].map { |src| File.binread(src) }.join)
 
 $objs = %w[trilogy.o cast.o cext.o]
-$CFLAGS << " -I #{__dir__}/inc -std=gnu99"
+$CFLAGS << " -I #{__dir__}/inc -std=gnu99 -fvisibility=hidden"
 
 dir_config("openssl")
 

data/ext/trilogy-ruby/inc/trilogy/blocking.h

@@ -50,7 +50,8 @@ int trilogy_connect_sock(trilogy_conn_t *conn, trilogy_sock_t *sock);
 /* trilogy_change_db - Change the default database for a connection.
  *
  * conn     - A connected trilogy_conn_t pointer. Using a disconnected
- * trilogy_conn_t is undefined. name     - Name of the database to set as default.
+ *            trilogy_conn_t is undefined.
+ * name     - Name of the database to set as default.
  * name_len - Length of the database name string in bytes.
  *
  * Return values
@@ -63,6 +64,22 @@ int trilogy_connect_sock(trilogy_conn_t *conn, trilogy_sock_t *sock);
  */
 int trilogy_change_db(trilogy_conn_t *conn, const char *name, size_t name_len);
 
+/* trilogy_set_option - Set server options for the connection.
+ *
+ * conn     - A connected trilogy_conn_t pointer. Using a disconnected
+ *            trilogy_conn_t is undefined.
+ * option   - The server option to set. See: TRILOGY_SET_SERVER_OPTION_TYPE_t;
+ *
+ * Return values
+ *   TRILOGY_OK                 - The change db command completed successfully.
+ *   TRILOGY_ERR                - The server returned an error.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ *   TRILOGY_PROTOCOL_VIOLATION - An error occurred while processing a network
+ *                             packet.
+ */
+int trilogy_set_option(trilogy_conn_t *conn, const uint16_t option);
+
 /* trilogy_query - Send and execute a query.
  *
  * conn             - A connected trilogy_conn_t pointer. Using a disconnected