trilogy 2.3.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 693efafac411af8e0859eee682d4432a501f17d90c3735faabad4cac4ab07537
-  data.tar.gz: 646bc59fce2e3b26058bf867f448496e5d5caf1344ca0832d706bd3e2db99a2f
+  metadata.gz: 2f62d4a5617aaf6b532cfa2888b297eba7bfb18def74e98b6a12847d2845b81f
+  data.tar.gz: 7c74e6d32f1ec845bccbace0b989a269d833d1582ba38ffd78e8e5f35305883d
 SHA512:
-  metadata.gz: 311d5640cdd3da6e3ba331c8222698ff18a10b06886d277712fb8da453924d862f4c9269163a5f748b73dcbc19087993ae2b3cbdc6fccbbd97a91c0c88f83bed
-  data.tar.gz: 77442107a8527f806c2f602d95c000d81c2e7b7a09f6efc8a77a5dcbb091eb4c6890948a1352a72a8fa2f7ef6fe1d74cb0eda84b0d385049514a8dd0236d597d
+  metadata.gz: 7ba24a84f4e946c1c7f797c10738fda98bcc9e1fbb0bd19f289fe9cc6cbb9bae252f9cf307c873c8a958c2d2519075d4a677cb681648e6429b18bf9c9a897bb7
+  data.tar.gz: 4ce6afb50256faf2ec873a71194295c9538a4d2188ecae65018b51f8869a97e4cb68eecef6829f9053ef31a5dca1defd107b46281478e02eb5b10606dae3da99

data/ext/trilogy-ruby/cast.c

@@ -145,7 +145,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             // TODO - optimize so we don't have to allocate a ruby string for
             // decimal columns
             VALUE str = rb_str_new(value->data, value->data_len);
-            if (column->decimals == 0) {
+            if (column->decimals == 0 && !options->cast_decimals_to_bigdecimals) {
                 return rb_funcall(rb_mKernel, id_Integer, 1, str);
             } else {
                 return rb_funcall(rb_mKernel, id_BigDecimal, 1, str);
@@ -240,7 +240,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             // pad out msec_char with zeroes at the end as it could be at any
             // level of precision
             for (size_t i = strlen(msec_char); i < sizeof(msec_char) - 1; i++) {
-                msec_char[i] = 0;
+                msec_char[i] = '0';
             }
 
             return rb_funcall(rb_cTime, options->database_local_time ? id_local : id_utc, 7, INT2NUM(2000), INT2NUM(1),

data/ext/trilogy-ruby/cext.c

@@ -8,6 +8,9 @@
 #include <sys/time.h>
 #include <sys/un.h>
 
+#include <unistd.h>
+#include <fcntl.h>
+
 #include <trilogy.h>
 
 #include "trilogy-ruby.h"
@@ -16,21 +19,29 @@
 
 VALUE Trilogy_CastError;
 static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
-    Trilogy_ConnectionClosedError, Trilogy_TimeoutError, Trilogy_Result;
+    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_multi_statement, id_from_code,
-    id_connection_options;
+    id_ssl_mode, id_tls_ciphersuites, id_tls_min_version, id_tls_max_version, id_multi_statement,
+    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,
     },
@@ -78,6 +89,19 @@ static struct trilogy_ctx *get_open_ctx(VALUE obj)
     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,12 +112,7 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
 
     switch (rc) {
     case TRILOGY_SYSERR:
-        if (errno == ECONNREFUSED || errno == ECONNRESET) {
-            rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE, rbmsg);
-        } else {
-            // TODO: All syserr should be wrapped.
-            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);
@@ -106,13 +125,7 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         ERR_clear_error();
         if (ERR_GET_LIB(ossl_error) == ERR_LIB_SYS) {
             int err_reason = ERR_GET_REASON(ossl_error);
-
-            if (err_reason == ECONNREFUSED || err_reason == ECONNRESET) {
-                rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE, rbmsg);
-            } else {
-                // TODO: All syserr should be wrapped.
-                rb_syserr_fail_str(err_reason, rbmsg);
-            }
+            trilogy_syserr_fail_str(err_reason, rbmsg);
         }
         // We can't recover from OpenSSL level errors if there's
         // an active connection.
@@ -140,13 +153,8 @@ static VALUE allocate_trilogy(VALUE klass)
     ctx->query_flags = TRILOGY_FLAGS_DEFAULT;
 
     if (trilogy_init(&ctx->conn) < 0) {
-        if (errno == ECONNREFUSED || errno == ECONNRESET) {
-            rb_raise(Trilogy_BaseConnectionError, "trilogy_init");
-        } else {
-            // TODO: All syserr should be wrapped.
-            VALUE rbmsg = rb_str_new("trilogy_init", 13);
-            rb_syserr_fail_str(errno, rbmsg);
-        }
+        VALUE rbmsg = rb_str_new("trilogy_init", 13);
+        trilogy_syserr_fail_str(errno, rbmsg);
     }
 
     return obj;
@@ -358,13 +366,16 @@ 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);
 
@@ -554,10 +565,45 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
     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;
 }
@@ -566,10 +612,6 @@ struct read_query_response_state {
     struct rb_trilogy_cast_options *cast_options;
     struct trilogy_ctx *ctx;
 
-    // to free by caller:
-    struct column_info *column_info;
-    trilogy_value_t *row_values;
-
     // Error state for tracking
     const char *msg;
     int rc;
@@ -648,10 +690,13 @@ static VALUE read_query_response(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;
@@ -688,8 +733,8 @@ static VALUE read_query_response(VALUE vargs)
         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);
@@ -732,9 +777,7 @@ static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
 
     struct read_query_response_state args = {
         .cast_options = &cast_options,
-        .column_info = NULL,
         .ctx = ctx,
-        .row_values = NULL,
         .rc = TRILOGY_OK,
         .msg = NULL,
     };
@@ -742,9 +785,6 @@ static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
     int state = 0;
     VALUE result = rb_protect(read_query_response, (VALUE)&args, &state);
 
-    xfree(args.column_info);
-    xfree(args.row_values);
-
     // If we have seen an unexpected exception, jump to it so it gets raised.
     if (state) {
         trilogy_sock_shutdown(ctx->conn.socket);
@@ -787,6 +827,7 @@ 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));
 
@@ -902,6 +943,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); }
@@ -961,18 +1021,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_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);
@@ -987,6 +1048,7 @@ void Init_cext()
     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));
@@ -1001,6 +1063,7 @@ 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));
@@ -1017,6 +1080,12 @@ void Init_cext()
     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_BaseConnectionError = rb_const_get(Trilogy, rb_intern("BaseConnectionError"));
     rb_global_variable(&Trilogy_BaseConnectionError);
 
@@ -1026,12 +1095,12 @@ void Init_cext()
     Trilogy_Result = rb_const_get(Trilogy, rb_intern("Result"));
     rb_global_variable(&Trilogy_Result);
 
+    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);
 
-    rb_define_attr(Trilogy_Result, "affected_rows", 1, 0);
-    rb_define_attr(Trilogy_Result, "last_insert_id", 1, 0);
-
     id_socket = rb_intern("socket");
     id_host = rb_intern("host");
     id_port = rb_intern("port");
@@ -1059,6 +1128,7 @@ void Init_cext()
     id_tls_max_version = rb_intern("tls_max_version");
     id_multi_statement = rb_intern("multi_statement");
     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");
@@ -1072,4 +1142,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

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

@@ -299,6 +299,50 @@ int trilogy_change_db_send(trilogy_conn_t *conn, const char *name, size_t name_l
  */
 int trilogy_change_db_recv(trilogy_conn_t *conn);
 
+/* trilogy_set_option_send - Send a set option command to the server. This
+ * will change server capabilities based on the option selected.
+ *
+ * This should only be called while the connection is ready for commands.
+ *
+ * conn     - A connected trilogy_conn_t pointer. Using a disconnected
+ *            trilogy_conn_t is undefined.
+ * option   - The server option to send.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The change database command was successfully sent to the
+ *                    server.
+ *   TRILOGY_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_set_option_send(trilogy_conn_t *conn, const uint16_t option);
+
+/* trilogy_set_option_recv - Read the set option command response from the
+ * server.
+ *
+ * This should be called after all data written by trilogy_set_option_send is
+ * flushed to the network. Calling this at any other time during the connection
+ * lifecycle is undefined.
+ *
+ * conn - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *        undefined.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The set option command was successfully
+ *                                sent to the server.
+ *   TRILOGY_AGAIN              - The socket wasn't ready for reading. The
+ *                                caller should wait for readability using
+ *                                `conn->sock`. Then call this function until
+ *                                it returns a different value.
+ *   TRILOGY_UNEXPECTED_PACKET  - The response packet wasn't what was expected.
+ *   TRILOGY_PROTOCOL_VIOLATION - An error occurred while processing a network
+ *                                packet.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ */
+int trilogy_set_option_recv(trilogy_conn_t *conn);
+
 /* trilogy_query_send - Send a query command to the server.
  *
  * This should only be called while the connection is ready for commands.
@@ -543,4 +587,18 @@ int trilogy_close_recv(trilogy_conn_t *conn);
  */
 void trilogy_free(trilogy_conn_t *conn);
 
+/* trilogy_free - Discard the connection and free any internal buffers.
+ *
+ * The server won't be notified that connection was closed. This is useful to
+ * silently close connections that were inherited after forking without disrupting
+ * the parent's process connections.
+ *
+ * conn - A pre-initialized trilogy_conn_t pointer.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The connection was successfuly discarded and freed.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno. The connection wasn't freed.
+ */
+int trilogy_discard(trilogy_conn_t *conn);
+
 #endif

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

@@ -90,16 +90,14 @@
      * From client: the client is interactive.                                                                         \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_INTERACTIVE, 0x00000400)                                                                   \
-    /* Not implemented.                                                                                                \
-     *                                                                                                                 \
-     * From server: the server supports ssl.                                                                           \
+    /* From server: the server supports ssl.                                                                           \
      *                                                                                                                 \
      * From client: tells the server it should switch to an ssl connection.                                            \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_SSL, 0x00000800)                                                                           \
-    /* Not used.                                                                                                       \
+    /* From server: the server supports transactions and is capable of reporting transaction status.                   \
      *                                                                                                                 \
-     * This is assumed for the 4.1+ protocol.                                                                          \
+     * From client: the client is aware of servers that support transactions.                                          \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_TRANSACTIONS, 0x00002000)                                                                  \
     /* Not used.                                                                                                       \
@@ -112,9 +110,7 @@
      * scheme. This will always be set.                                                                                \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_SECURE_CONNECTION, 0x00008000)                                                             \
-    /* Not implemented.                                                                                                \
-     *                                                                                                                 \
-     * From server: the server can handle multiple statements per                                                      \
+    /* From server: the server can handle multiple statements per                                                      \
      * query/prepared statement.                                                                                       \
      *                                                                                                                 \
      * From client: tells the server it may send multiple statements per                                               \
@@ -191,7 +187,8 @@ typedef enum {
     /* A convenience bitmask with common client capabilities set. */
     TRILOGY_CAPABILITIES_CLIENT = (TRILOGY_CAPABILITIES_PROTOCOL_41 | TRILOGY_CAPABILITIES_SECURE_CONNECTION |
                                    TRILOGY_CAPABILITIES_DEPRECATE_EOF | TRILOGY_CAPABILITIES_SESSION_TRACK |
-                                   TRILOGY_CAPABILITIES_PLUGIN_AUTH | TRILOGY_CAPABILITIES_TRANSACTIONS)
+                                   TRILOGY_CAPABILITIES_PLUGIN_AUTH | TRILOGY_CAPABILITIES_TRANSACTIONS |
+                                   TRILOGY_CAPABILITIES_MULTI_RESULTS)
 } TRILOGY_CAPABILITIES_t;
 
 #define TRILOGY_SERVER_STATUS(XX)                                                                                      \
@@ -397,22 +394,34 @@ typedef enum {
 #undef XX
 } TRILOGY_SESSION_TRACK_TYPE_t;
 
+#define TRILOGY_SET_SERVER_OPTION(XX)                                                                                  \
+    XX(TRILOGY_SET_SERVER_MULTI_STATEMENTS_ON, 0x00)                                                                   \
+    XX(TRILOGY_SET_SERVER_MULTI_STATEMENTS_OFF, 0x01)                                                                  \
+
+typedef enum {
+#define XX(name, code) name = code,
+    TRILOGY_SET_SERVER_OPTION(XX)
+#undef XX
+} TRILOGY_SET_SERVER_OPTION_TYPE_t;
+
 /* trilogy_build_auth_packet - Build a handshake response (or authentication)
  * packet.
  *
  * This should be sent in response to the initial handshake packet the server
  * sends upon connection.
  *
- * builder     - A pointer to a pre-initialized trilogy_builder_t.
- * user        - The username to use for authentication. Must be a C-string.
- * pass        - The password to use for authentication. Optional, and can be NULL.
- * pass_len    - The length of password in bytes.
- * auth_plugin - Plugin authentication mechanism that the server requested.
- * scramble    - The scramble value the server sent in the initial handshake.
- * flags       - Bitmask of TRILOGY_CAPABILITIES_t flags.
- *               The TRILOGY_CAPABILITIES_PROTOCOL_41 and
- *               TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
- *               internally.
+ * builder          - A pointer to a pre-initialized trilogy_builder_t.
+ * user             - The username to use for authentication. Must be a C-string.
+ * pass             - The password to use for authentication. Optional, and can be NULL.
+ * pass_len         - The length of password in bytes.
+ * database         - The initial database to connect to. Optional, and can be NULL.
+ * client_encoding  - The charset to use for the connection.
+ * auth_plugin      - Plugin authentication mechanism that the server requested.
+ * scramble         - The scramble value the server sent in the initial handshake.
+ * flags            - Bitmask of TRILOGY_CAPABILITIES_t flags.
+ *                    The TRILOGY_CAPABILITIES_PROTOCOL_41 and
+ *                    TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
+ *                    internally.
  *
  * Return values:
  *   TRILOGY_OK     - The packet was successfully built and written to the
@@ -420,8 +429,8 @@ typedef enum {
  *   TRILOGY_SYSERR - A system error occurred, check errno.
  */
 int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, const char *pass, size_t pass_len,
-                              const char *database, const char *auth_plugin, const char *scramble,
-                              TRILOGY_CAPABILITIES_t flags);
+                              const char *database, TRILOGY_CHARSET_t client_encoding, const char *auth_plugin,
+                              const char *scramble, TRILOGY_CAPABILITIES_t flags);
 
 /* trilogy_build_auth_switch_response_packet - Build a response for when
  * authentication switching it requested.
@@ -447,7 +456,7 @@ int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const
  * command will change the default database for the connection.
  *
  * builder  - A pointer to a pre-initialized trilogy_builder_t.
- * name     - The name of the databaset to set as the default.
+ * name     - The name of the database to set as the default.
  * name_len - The length of name in bytes.
  *
  * Return values:
@@ -457,6 +466,20 @@ int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const
  */
 int trilogy_build_change_db_packet(trilogy_builder_t *builder, const char *name, size_t name_len);
 
+/* trilogy_build_set_option_packet - Build a set option command packet. This
+ * command will enable/disable server capabilities for the connection. Options
+ * must be one of `enum_mysql_set_option`.
+ *
+ * builder  - A pointer to a pre-initialized trilogy_builder_t.
+ * option   - An integer corresponding to the operation to perform.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The packet was successfully built and written to the
+ *                    builder's internal buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_build_set_option_packet(trilogy_builder_t *builder, const uint16_t option);
+
 /* trilogy_build_ping_packet - Build a ping command packet.
  *
  * builder - A pointer to a pre-initialized trilogy_builder_t.
@@ -497,19 +520,21 @@ int trilogy_build_quit_packet(trilogy_builder_t *builder);
  * sends upon connection, where an auth packet would normally be sent. A regular
  * auth packet is to be sent after the SSL handshake completes.
  *
- * builder  - A pointer to a pre-initialized trilogy_builder_t.
- * flags    - Bitmask of TRILOGY_CAPABILITIES_t flags.
- *            The TRILOGY_CAPABILITIES_PROTOCOL_41 and
- *            TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
- *            internally.
- *            The TRILOGY_CAPABILITIES_SSL flag will also be set.
+ * builder         - A pointer to a pre-initialized trilogy_builder_t.
+ * flags           - Bitmask of TRILOGY_CAPABILITIES_t flags.
+ *                   The TRILOGY_CAPABILITIES_PROTOCOL_41 and
+ *                   TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
+ *                   internally.
+ *                   The TRILOGY_CAPABILITIES_SSL flag will also be set.
+ * client_encoding - The charset to use for the connection.
  *
  * Return values:
  *   TRILOGY_OK     - The packet was successfully built and written to the
  *                    builder's internal buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
  */
-int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags);
+int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags,
+                                     TRILOGY_CHARSET_t client_encoding);
 
 #define TRILOGY_SERVER_VERSION_SIZE 32
 

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

@@ -41,6 +41,7 @@ typedef struct {
     char *username;
     char *password;
     size_t password_len;
+    uint8_t encoding;
 
     trilogy_ssl_mode_t ssl_mode;
     trilogy_tls_version_t tls_min_version;
@@ -107,5 +108,6 @@ static inline int trilogy_sock_fd(trilogy_sock_t *sock) { return sock->fd_cb(soc
 trilogy_sock_t *trilogy_sock_new(const trilogy_sockopt_t *opts);
 int trilogy_sock_resolve(trilogy_sock_t *raw);
 int trilogy_sock_upgrade_ssl(trilogy_sock_t *raw);
+int trilogy_sock_discard(trilogy_sock_t *sock);
 
 #endif

data/ext/trilogy-ruby/src/blocking.c

@@ -139,6 +139,29 @@ int trilogy_change_db(trilogy_conn_t *conn, const char *name, size_t name_len)
     }
 }
 
+int trilogy_set_option(trilogy_conn_t *conn, const uint16_t option)
+{
+    int rc = trilogy_set_option_send(conn, option);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_set_option_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
 int trilogy_ping(trilogy_conn_t *conn)
 {
     int rc = trilogy_ping_send(conn);

data/ext/trilogy-ruby/src/client.c

@@ -357,8 +357,9 @@ int trilogy_auth_send(trilogy_conn_t *conn, const trilogy_handshake_t *handshake
     }
 
     rc = trilogy_build_auth_packet(&builder, conn->socket->opts.username, conn->socket->opts.password,
-                                   conn->socket->opts.password_len, conn->socket->opts.database, handshake->auth_plugin,
-                                   handshake->scramble, conn->socket->opts.flags);
+                                   conn->socket->opts.password_len, conn->socket->opts.database,
+                                   conn->socket->opts.encoding, handshake->auth_plugin, handshake->scramble,
+                                   conn->socket->opts.flags);
 
     if (rc < 0) {
         return rc;
@@ -378,7 +379,7 @@ int trilogy_ssl_request_send(trilogy_conn_t *conn)
     }
 
     conn->socket->opts.flags |= TRILOGY_CAPABILITIES_SSL;
-    rc = trilogy_build_ssl_request_packet(&builder, conn->socket->opts.flags);
+    rc = trilogy_build_ssl_request_packet(&builder, conn->socket->opts.flags, conn->socket->opts.encoding);
 
     if (rc < 0) {
         return rc;
@@ -466,6 +467,44 @@ int trilogy_change_db_send(trilogy_conn_t *conn, const char *name, size_t name_l
 
 int trilogy_change_db_recv(trilogy_conn_t *conn) { return read_generic_response(conn); }
 
+int trilogy_set_option_send(trilogy_conn_t *conn, const uint16_t option)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_set_option_packet(&builder, option);
+
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
+int trilogy_set_option_recv(trilogy_conn_t *conn) {
+    int rc = read_packet(conn);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    switch (current_packet_type(conn)) {
+    case TRILOGY_PACKET_OK:
+    case TRILOGY_PACKET_EOF: // COM_SET_OPTION returns an EOF packet, but it should be treated as an OK packet.
+        return read_ok_packet(conn);
+
+    case TRILOGY_PACKET_ERR:
+        return read_err_packet(conn);
+
+    default:
+        return TRILOGY_UNEXPECTED_PACKET;
+    }
+}
+
+
 int trilogy_ping_send(trilogy_conn_t *conn)
 {
     trilogy_builder_t builder;
@@ -725,4 +764,13 @@ void trilogy_free(trilogy_conn_t *conn)
     trilogy_buffer_free(&conn->packet_buffer);
 }
 
+int trilogy_discard(trilogy_conn_t *conn)
+{
+    int rc = trilogy_sock_discard(conn->socket);
+    if (rc == TRILOGY_OK) {
+        trilogy_free(conn);
+    }
+    return rc;
+}
+
 #undef CHECKED

data/ext/trilogy-ruby/src/protocol.c

@@ -10,6 +10,7 @@
 #define TRILOGY_CMD_CHANGE_DB 0x02
 #define TRILOGY_CMD_QUERY 0x03
 #define TRILOGY_CMD_PING 0x0e
+#define TRILOGY_CMD_SET_OPTION 0x1b
 
 #define SCRAMBLE_LEN 20
 
@@ -493,8 +494,8 @@ static void trilogy_pack_scramble_sha2_hash(const char *scramble, const char *pa
 }
 
 int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, const char *pass, size_t pass_len,
-                              const char *database, const char *auth_plugin, const char *scramble,
-                              TRILOGY_CAPABILITIES_t flags)
+                              const char *database, TRILOGY_CHARSET_t client_encoding, const char *auth_plugin,
+                              const char *scramble, TRILOGY_CAPABILITIES_t flags)
 {
     int rc = TRILOGY_OK;
 
@@ -506,8 +507,6 @@ int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, cons
 
     uint32_t max_packet_len = TRILOGY_MAX_PACKET_LEN;
 
-    uint8_t client_encoding = TRILOGY_CHARSET_UTF8_GENERAL_CI;
-
     unsigned int auth_response_len = 0;
     uint8_t auth_response[EVP_MAX_MD_SIZE];
 
@@ -646,12 +645,28 @@ fail:
     return rc;
 }
 
-int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags)
+int trilogy_build_set_option_packet(trilogy_builder_t *builder, const uint16_t option)
+{
+    int rc = TRILOGY_OK;
+
+    CHECKED(trilogy_builder_write_uint8(builder, TRILOGY_CMD_SET_OPTION));
+    CHECKED(trilogy_builder_write_uint16(builder, option));
+
+    trilogy_builder_finalize(builder);
+
+    return TRILOGY_OK;
+
+fail:
+    return rc;
+}
+
+
+int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags,
+                                     TRILOGY_CHARSET_t client_encoding)
 {
     static const char zeroes[23] = {0};
 
     const uint32_t max_packet_len = TRILOGY_MAX_PACKET_LEN;
-    const uint8_t client_encoding = TRILOGY_CHARSET_UTF8_GENERAL_CI;
     const uint32_t capabilities = flags | TRILOGY_CAPABILITIES_CLIENT | TRILOGY_CAPABILITIES_SSL;
 
     int rc = TRILOGY_OK;

data/ext/trilogy-ruby/src/socket.c

@@ -621,3 +621,28 @@ fail:
     sock->ssl = NULL;
     return TRILOGY_OPENSSL_ERR;
 }
+
+int trilogy_sock_discard(trilogy_sock_t *_sock)
+{
+    struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+
+    if (sock->fd < 0) {
+        return TRILOGY_OK;
+    }
+
+    int null_fd = open("/dev/null", O_RDWR | O_CLOEXEC);
+    if (null_fd < 0) {
+        return TRILOGY_SYSERR;
+    }
+
+    if (dup2(null_fd, sock->fd) < 0) {
+        close(null_fd);
+        return TRILOGY_SYSERR;
+    }
+
+    if (close(null_fd) < 0) {
+        return TRILOGY_SYSERR;
+    }
+
+    return TRILOGY_OK;
+}

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

@@ -9,6 +9,7 @@
 #define TRILOGY_FLAGS_CAST_BOOLEANS 2
 #define TRILOGY_FLAGS_LOCAL_TIMEZONE 4
 #define TRILOGY_FLAGS_FLATTEN_ROWS 8
+#define TRILOGY_FLAGS_CAST_ALL_DECIMALS_TO_BIGDECIMALS 16
 #define TRILOGY_FLAGS_DEFAULT (TRILOGY_FLAGS_CAST)
 
 struct rb_trilogy_cast_options {
@@ -16,6 +17,7 @@ struct rb_trilogy_cast_options {
     bool cast_booleans;
     bool database_local_time;
     bool flatten_rows;
+    bool cast_decimals_to_bigdecimals;
 };
 
 struct column_info {

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.3.0"
+  VERSION = "2.4.1"
 end

data/lib/trilogy.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require "trilogy/version"
 
 class Trilogy
   # Trilogy::Error is the base error type. All errors raised by Trilogy
   # should be descendants of Trilogy::Error
   module Error
+    attr_reader :error_code
   end
 
   # Trilogy::ConnectionError is the base error type for all potentially transient
@@ -12,11 +15,30 @@ class Trilogy
     include Error
   end
 
+  # Trilogy may raise various syscall errors, which we treat as Trilogy::Errors.
+  class SyscallError
+    ERRORS = {}
+
+    Errno.constants
+      .map { |c| Errno.const_get(c) }.uniq
+      .select { |c| c.is_a?(Class) && c < SystemCallError }
+      .each do |c|
+        errno_name = c.to_s.split('::').last
+        ERRORS[c::Errno] = const_set(errno_name, Class.new(c) { include Trilogy::Error })
+      end
+
+    ERRORS.freeze
+
+    class << self
+      def from_errno(errno, message)
+        ERRORS[errno].new(message)
+      end
+    end
+  end
+
   class BaseError < StandardError
     include Error
 
-    attr_reader :error_code
-
     def initialize(error_message = nil, error_code = nil)
       message = error_code ? "#{error_code}: #{error_message}" : error_message
       super(message)
@@ -43,14 +65,20 @@ class Trilogy
   class TimeoutError < Errno::ETIMEDOUT
     include ConnectionError
 
-    attr_reader :error_code
-
     def initialize(error_message = nil, error_code = nil)
       super
       @error_code = error_code
     end
   end
 
+  class ConnectionRefusedError < Errno::ECONNREFUSED
+    include ConnectionError
+  end
+
+  class ConnectionResetError < Errno::ECONNRESET
+    include ConnectionError
+  end
+
   # DatabaseError was replaced by ProtocolError, but we'll keep it around as an
   # ancestor of ProtocolError for compatibility reasons (e.g. so `rescue DatabaseError`
   # still works. We can remove this class in the next major release.
@@ -92,6 +120,60 @@ class Trilogy
     include ConnectionError
   end
 
+  MYSQL_TO_RUBY_ENCODINGS_MAP = {
+    "big5"     => "Big5",
+    "dec8"     => nil,
+    "cp850"    => "CP850",
+    "hp8"      => nil,
+    "koi8r"    => "KOI8-R",
+    "latin1"   => "ISO-8859-1",
+    "latin2"   => "ISO-8859-2",
+    "swe7"     => nil,
+    "ascii"    => "US-ASCII",
+    "ujis"     => "eucJP-ms",
+    "sjis"     => "Shift_JIS",
+    "hebrew"   => "ISO-8859-8",
+    "tis620"   => "TIS-620",
+    "euckr"    => "EUC-KR",
+    "koi8u"    => "KOI8-R",
+    "gb2312"   => "GB2312",
+    "greek"    => "ISO-8859-7",
+    "cp1250"   => "Windows-1250",
+    "gbk"      => "GBK",
+    "latin5"   => "ISO-8859-9",
+    "armscii8" => nil,
+    "utf8"     => "UTF-8",
+    "ucs2"     => "UTF-16BE",
+    "cp866"    => "IBM866",
+    "keybcs2"  => nil,
+    "macce"    => "macCentEuro",
+    "macroman" => "macRoman",
+    "cp852"    => "CP852",
+    "latin7"   => "ISO-8859-13",
+    "utf8mb4"  => "UTF-8",
+    "cp1251"   => "Windows-1251",
+    "utf16"    => "UTF-16",
+    "cp1256"   => "Windows-1256",
+    "cp1257"   => "Windows-1257",
+    "utf32"    => "UTF-32",
+    "binary"   => "ASCII-8BIT",
+    "geostd8"  => nil,
+    "cp932"    => "Windows-31J",
+    "eucjpms"  => "eucJP-ms",
+    "utf16le"  => "UTF-16LE",
+    "gb18030"  => "GB18030",
+  }.freeze
+
+  def initialize(options = {})
+    mysql_encoding = options[:encoding] || "utf8mb4"
+    unless rb_encoding = MYSQL_TO_RUBY_ENCODINGS_MAP[mysql_encoding]
+      raise ArgumentError, "Unknown or unsupported encoding: #{mysql_encoding}"
+    end
+    encoding = Encoding.find(rb_encoding)
+    charset = charset_for_mysql_encoding(mysql_encoding)
+    _initialize(encoding, charset, **options)
+  end
+
   def connection_options
     @connection_options.dup.freeze
   end
@@ -124,7 +206,7 @@ class Trilogy
   end
 
   class Result
-    attr_reader :fields, :rows, :query_time
+    attr_reader :fields, :rows, :query_time, :affected_rows, :last_insert_id
 
     def count
       rows.count
@@ -154,6 +236,49 @@ class Trilogy
 
     include Enumerable
   end
+
+  private
+
+  def charset_for_mysql_encoding(mysql_encoding)
+    @mysql_encodings_map ||= {
+      "big5"     => CHARSET_BIG5_CHINESE_CI,
+      "cp850"    => CHARSET_CP850_GENERAL_CI,
+      "koi8r"    => CHARSET_KOI8R_GENERAL_CI,
+      "latin1"   => CHARSET_LATIN1_GENERAL_CI,
+      "latin2"   => CHARSET_LATIN2_GENERAL_CI,
+      "ascii"    => CHARSET_ASCII_GENERAL_CI,
+      "ujis"     => CHARSET_UJIS_JAPANESE_CI,
+      "sjis"     => CHARSET_SJIS_JAPANESE_CI,
+      "hebrew"   => CHARSET_HEBREW_GENERAL_CI,
+      "tis620"   => CHARSET_TIS620_THAI_CI,
+      "euckr"    => CHARSET_EUCKR_KOREAN_CI,
+      "koi8u"    => CHARSET_KOI8U_GENERAL_CI,
+      "gb2312"   => CHARSET_GB2312_CHINESE_CI,
+      "greek"    => CHARSET_GREEK_GENERAL_CI,
+      "cp1250"   => CHARSET_CP1250_GENERAL_CI,
+      "gbk"      => CHARSET_GBK_CHINESE_CI,
+      "latin5"   => CHARSET_LATIN5_TURKISH_CI,
+      "utf8"     => CHARSET_UTF8_GENERAL_CI,
+      "ucs2"     => CHARSET_UCS2_GENERAL_CI,
+      "cp866"    => CHARSET_CP866_GENERAL_CI,
+      "cp932"    => CHARSET_CP932_JAPANESE_CI,
+      "eucjpms"  => CHARSET_EUCJPMS_JAPANESE_CI,
+      "utf16le"  => CHARSET_UTF16_GENERAL_CI,
+      "gb18030"  => CHARSET_GB18030_CHINESE_CI,
+      "macce"    => CHARSET_MACCE_GENERAL_CI,
+      "macroman" => CHARSET_MACROMAN_GENERAL_CI,
+      "cp852"    => CHARSET_CP852_GENERAL_CI,
+      "latin7"   => CHARSET_LATIN7_GENERAL_CI,
+      "utf8mb4"  => CHARSET_UTF8MB4_GENERAL_CI,
+      "cp1251"   => CHARSET_CP1251_GENERAL_CI,
+      "utf16"    => CHARSET_UTF16_GENERAL_CI,
+      "cp1256"   => CHARSET_CP1256_GENERAL_CI,
+      "cp1257"   => CHARSET_CP1257_GENERAL_CI,
+      "utf32"    => CHARSET_UTF32_GENERAL_CI,
+      "binary"   => CHARSET_BINARY,
+    }.freeze
+    @mysql_encodings_map[mysql_encoding]
+  end
 end
 
 require "trilogy/cext"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.1
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler