trilogy 2.9.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 998b06e77dcb78b2f30307834490a7c9c7d61422dea586f646cead7b74467058
-  data.tar.gz: e5bf1ecf9e8b2b675db0d3c3ee7531db4ab022aa725c4ed0c16db088884c6075
+  metadata.gz: 0625a7ff415d68c8f5e421188e66fe7c41ebadd2afc39a7d6b89c6318ea9ef9d
+  data.tar.gz: c6b10922d195af6ec3b5140963749b59d4ef4a967728aeeb826377bc66992bc0
 SHA512:
-  metadata.gz: bd2acff1c38bbed9bea64f3fbb9ad474e4d42198dccbcdca0aa1b8ba3b52e35711f1c9e2e1a6859c15a71c38ed08ba06b5adcb5fbb5054b1b4264fd51ae0933f
-  data.tar.gz: e032a04cfb901d48a4e1e711cd576c380562f2b7f871724d06568dff8bd3b599fd3ea86360b3bcbe2f8f9471f986d6b1cc8f8d8e69309877778d1ce442dd65f3
+  metadata.gz: 5da895e095a69094c7f1844d341ea2bf0c4461f7744f892a5a6f3aff1552761ebb8f099a5df151450c6c32e894e88cfebf72052c8190aef749be0d8d56ad0611
+  data.tar.gz: 60830ae194994fa09a975d3cea8146632300bfef62e98726c7cd6edfdb18a91bd3bce55a9fbf0d5b5d2fa0932d2a264333d87ccb57ae222e59a46bd3c5740fd7

data/README.md

@@ -13,7 +13,7 @@ gem 'trilogy'
 And then execute:
 
 ```
-$ bundle
+$ bundle install
 ```
 
 Or install it yourself as:

data/Rakefile

@@ -19,10 +19,25 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['test/*_test.rb']
   t.verbose = true
 end
-task :test => :compile
+
+task :test => [:compile, "db:clean"]
 
 task :default => :test
 
 task :console => :compile do
   sh "ruby -I lib -r trilogy -S irb"
 end
+
+namespace :db do
+  task :create do
+    mysql_command = "mysql -uroot -e"
+    %x( #{mysql_command} "create DATABASE IF NOT EXISTS test DEFAULT CHARACTER SET utf8mb4" )
+  end
+
+  task :drop do
+    mysql_command = "mysql -uroot -e"
+    %x( #{mysql_command} "drop DATABASE IF EXISTS test" )
+  end
+
+  task :clean => ["db:drop", "db:create"]
+end 

data/ext/trilogy-ruby/cext.c

@@ -15,6 +15,149 @@
 
 #include "trilogy-ruby.h"
 
+typedef struct _buffer_pool_entry_struct {
+    size_t cap;
+    uint8_t *buff;
+} buffer_pool_entry;
+
+typedef struct _buffer_pool_struct {
+    size_t capa;
+    size_t len;
+    buffer_pool_entry *entries;
+} buffer_pool;
+
+#ifndef HAVE_RB_RACTOR_LOCAL_STORAGE_VALUE_NEWKEY
+static VALUE _global_buffer_pool = Qnil;
+#endif
+
+#define BUFFER_POOL_MAX_SIZE 8
+
+static void buffer_pool_free(void *data)
+{
+#ifndef HAVE_RB_RACTOR_LOCAL_STORAGE_VALUE_NEWKEY
+    _global_buffer_pool = Qnil;
+#endif
+
+    buffer_pool *pool = (buffer_pool *)data;
+    if (pool->capa) {
+        for (size_t index = 0; index < pool->len; index++) {
+            // NB: buff was allocated by trilogy/buffer.h using raw `malloc`
+            // hence we must use raw `free`.
+            free(pool->entries[index].buff);
+        }
+        xfree(pool->entries);
+    }
+    xfree(pool);
+}
+
+static size_t buffer_pool_memsize(const void *data)
+{
+    const buffer_pool *pool = (const buffer_pool *)data;
+
+    size_t memsize = sizeof(buffer_pool) + sizeof(buffer_pool_entry) * pool->capa;
+
+    if (pool->capa) {
+        for (size_t index = 0; index < pool->len; index++) {
+            memsize += pool->entries[index].cap;
+        }
+    }
+
+    return memsize;
+}
+
+static const rb_data_type_t buffer_pool_type = {
+    .wrap_struct_name = "trilogy/buffer_pool",
+    .function = {
+        .dmark = NULL,
+        .dfree = buffer_pool_free,
+        .dsize = buffer_pool_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE create_rb_buffer_pool(void)
+{
+    buffer_pool *pool;
+    return TypedData_Make_Struct(Qfalse, buffer_pool, &buffer_pool_type, pool);
+}
+
+#ifdef HAVE_RB_RACTOR_LOCAL_STORAGE_VALUE_NEWKEY
+#include <ruby/ractor.h>
+static rb_ractor_local_key_t buffer_pool_key;
+
+static VALUE get_rb_buffer_pool(void)
+{
+    VALUE pool;
+    if (!rb_ractor_local_storage_value_lookup(buffer_pool_key, &pool)) {
+        pool = create_rb_buffer_pool();
+        rb_ractor_local_storage_value_set(buffer_pool_key, pool);
+    }
+    return pool;
+}
+#else
+static VALUE get_rb_buffer_pool(void)
+{
+    if (NIL_P(_global_buffer_pool)) {
+        _global_buffer_pool = create_rb_buffer_pool();
+    }
+    return _global_buffer_pool;
+}
+#endif
+
+static inline buffer_pool *get_buffer_pool(void)
+{
+    buffer_pool *pool;
+    VALUE rb_pool = get_rb_buffer_pool();
+    if (NIL_P(rb_pool)) {
+        return NULL;
+    }
+
+    TypedData_Get_Struct(rb_pool, buffer_pool, &buffer_pool_type, pool);
+    return pool;
+}
+
+static void buffer_checkout(trilogy_buffer_t *buffer, size_t initial_capacity)
+{
+    buffer_pool * pool = get_buffer_pool();
+    if (pool->len) {
+        pool->len--;
+        buffer->buff = pool->entries[pool->len].buff;
+        buffer->cap = pool->entries[pool->len].cap;
+    } else {
+        buffer->buff = malloc(initial_capacity);
+        buffer->cap = initial_capacity;
+    }
+}
+
+static bool buffer_checkin(trilogy_buffer_t *buffer)
+{
+    buffer_pool * pool = get_buffer_pool();
+
+    if (pool->len >= BUFFER_POOL_MAX_SIZE) {
+        free(buffer->buff);
+        buffer->buff = NULL;
+        buffer->cap = 0;
+        return false;
+    }
+
+    if (!pool->capa) {
+        pool->entries = RB_ALLOC_N(buffer_pool_entry, 16);
+        pool->capa = 16;
+    } else if (pool->len >= pool->capa) {
+        pool->capa *= 2;
+        RB_REALLOC_N(pool->entries, buffer_pool_entry, pool->capa);
+    }
+
+    pool->entries[pool->len].buff = buffer->buff;
+    pool->entries[pool->len].cap = buffer->cap;
+    pool->len++;
+
+    buffer->buff = NULL;
+    buffer->cap = 0;
+
+    return true;
+}
+
 VALUE Trilogy_CastError;
 static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
     Trilogy_ConnectionClosedError,
@@ -29,20 +172,29 @@ static ID id_socket, id_host, id_port, id_username, id_password, id_found_rows,
 
 struct trilogy_ctx {
     trilogy_conn_t conn;
-    char server_version[TRILOGY_SERVER_VERSION_SIZE + 1];
+    rb_encoding *encoding;
     unsigned int query_flags;
-    VALUE encoding;
+    char server_version[TRILOGY_SERVER_VERSION_SIZE + 1];
 };
 
-static void mark_trilogy(void *ptr)
+static void rb_trilogy_acquire_buffer(struct trilogy_ctx *ctx)
 {
-    struct trilogy_ctx *ctx = ptr;
-    rb_gc_mark(ctx->encoding);
+    if (!ctx->conn.packet_buffer.buff) {
+        buffer_checkout(&ctx->conn.packet_buffer, TRILOGY_DEFAULT_BUF_SIZE);
+    }
+}
+
+static void rb_trilogy_release_buffer(struct trilogy_ctx *ctx)
+{
+    if (ctx->conn.packet_buffer.buff) {
+        buffer_checkin(&ctx->conn.packet_buffer);
+    }
 }
 
 static void free_trilogy(void *ptr)
 {
     struct trilogy_ctx *ctx = ptr;
+
     trilogy_free(&ctx->conn);
     xfree(ptr);
 }
@@ -60,7 +212,7 @@ static size_t trilogy_memsize(const void *ptr) {
 static const rb_data_type_t trilogy_data_type = {
     .wrap_struct_name = "trilogy",
     .function = {
-        .dmark = mark_trilogy,
+        .dmark = NULL,
         .dfree = free_trilogy,
         .dsize = trilogy_memsize,
     },
@@ -116,6 +268,8 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
     VALUE rbmsg = rb_vsprintf(msg, args);
     va_end(args);
 
+    rb_trilogy_release_buffer(ctx);
+
     if (!trilogy_error_recoverable_p(rc)) {
         if (ctx->conn.socket != NULL) {
             // trilogy_sock_shutdown may affect errno
@@ -178,7 +332,7 @@ static VALUE allocate_trilogy(VALUE klass)
 
     ctx->query_flags = TRILOGY_FLAGS_DEFAULT;
 
-    if (trilogy_init(&ctx->conn) < 0) {
+    if (trilogy_init_no_buffer(&ctx->conn) < 0) {
         VALUE rbmsg = rb_str_new("trilogy_init", 13);
         trilogy_syserr_fail_str(errno, rbmsg);
     }
@@ -295,42 +449,29 @@ static int _cb_ruby_wait(trilogy_sock_t *sock, trilogy_wait_t wait)
     return TRILOGY_OK;
 }
 
-struct nogvl_sock_args {
-    int rc;
-    trilogy_sock_t *sock;
-};
-
-static void *no_gvl_resolve(void *data)
+static int try_connect(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake, const trilogy_sockopt_t *opts, int fd)
 {
-    struct nogvl_sock_args *args = data;
-    args->rc = trilogy_sock_resolve(args->sock);
-    return NULL;
-}
+    if (fd < 0) {
+        return TRILOGY_ERR;
+    }
 
-static int try_connect(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake, const trilogy_sockopt_t *opts)
-{
     trilogy_sock_t *sock = trilogy_sock_new(opts);
     if (sock == NULL) {
         return TRILOGY_ERR;
     }
 
-    struct nogvl_sock_args args = {.rc = 0, .sock = sock};
-
-    // Do the DNS resolving with the GVL unlocked. At this point all
-    // configuration data is copied and available to the trilogy socket.
-    rb_thread_call_without_gvl(no_gvl_resolve, (void *)&args, RUBY_UBF_IO, NULL);
-
-    int rc = args.rc;
-
-    if (rc != TRILOGY_OK) {
-        trilogy_sock_close(sock);
-        return rc;
-    }
+    int rc;
 
     /* replace the default wait callback with our GVL-aware callback so we can
 escape the GVL on each wait operation without going through call_without_gvl */
     sock->wait_cb = _cb_ruby_wait;
-    rc = trilogy_connect_send_socket(&ctx->conn, sock);
+
+    int newfd = dup(fd);
+    if (newfd < 0) {
+        return TRILOGY_ERR;
+    }
+
+    rc = trilogy_connect_set_fd(&ctx->conn, sock, newfd);
     if (rc < 0) {
         trilogy_sock_close(sock);
         return rc;
@@ -374,7 +515,12 @@ static void auth_switch(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake)
         }
 
         if (rc != TRILOGY_AGAIN) {
-            handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
+            if (rc == TRILOGY_UNSUPPORTED) {
+                handle_trilogy_error(ctx, rc, "trilogy_auth_recv: caching_sha2_password requires either TCP with TLS or a unix socket");
+            }
+            else {
+                handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
+            }
         }
 
         rc = trilogy_sock_wait_read(ctx->conn.socket);
@@ -428,12 +574,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
         }
 
         if (rc != TRILOGY_AGAIN) {
-            if (rc == TRILOGY_UNSUPPORTED) {
-                handle_trilogy_error(ctx, rc, "trilogy_auth_recv: caching_sha2_password requires either TCP with TLS or a unix socket");
-            }
-            else {
-                handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
-            }
+            handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
         }
 
         rc = trilogy_sock_wait_read(ctx->conn.socket);
@@ -447,14 +588,24 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
     }
 }
 
-static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE opts)
+#ifndef HAVE_RB_IO_DESCRIPTOR /* Ruby < 3.1 */
+static int rb_io_descriptor(VALUE io)
+{
+    rb_io_t *fptr;
+    GetOpenFile(io, fptr);
+    rb_io_check_closed(fptr);
+    return fptr->fd;
+}
+#endif
+
+static VALUE rb_trilogy_connect(VALUE self, VALUE raw_socket, 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);
+    ctx->encoding = rb_to_encoding(encoding);
     connopt.encoding = NUM2INT(charset);
 
     Check_Type(opts, T_HASH);
@@ -602,7 +753,17 @@ static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE
         connopt.tls_max_version = NUM2INT(val);
     }
 
-    int rc = try_connect(ctx, &handshake, &connopt);
+    VALUE io = rb_io_get_io(raw_socket);
+
+    rb_io_t *fptr;
+    GetOpenFile(io, fptr);
+    rb_io_check_readable(fptr);
+    rb_io_check_writable(fptr);
+
+    int fd = rb_io_descriptor(io);
+
+    rb_trilogy_acquire_buffer(ctx);
+    int rc = try_connect(ctx, &handshake, &connopt, fd);
     if (rc != TRILOGY_OK) {
         if (connopt.path) {
             handle_trilogy_error(ctx, rc, "trilogy_connect - unable to connect to %s", connopt.path);
@@ -617,6 +778,8 @@ static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE
 
     authenticate(ctx, &handshake, connopt.ssl_mode);
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qnil;
 }
 
@@ -626,6 +789,8 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
 
     StringValue(database);
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_change_db_send(&ctx->conn, RSTRING_PTR(database), RSTRING_LEN(database));
 
     if (rc == TRILOGY_AGAIN) {
@@ -653,6 +818,8 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -660,6 +827,8 @@ static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
 {
     struct trilogy_ctx *ctx = get_open_ctx(self);
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_set_option_send(&ctx->conn, NUM2INT(option));
 
     if (rc == TRILOGY_AGAIN) {
@@ -687,6 +856,8 @@ static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -811,10 +982,10 @@ static VALUE read_query_response(VALUE vargs)
             }
         }
 
-#ifdef HAVE_RB_INTERNED_STR
-        VALUE column_name = rb_interned_str(column.name, column.name_len);
+#ifdef HAVE_RB_ENC_INTERNED_STR
+        VALUE column_name = rb_enc_interned_str(column.name, column.name_len, ctx->encoding);
 #else
-        VALUE column_name = rb_str_new(column.name, column.name_len);
+        VALUE column_name = rb_enc_str_new(column.name, column.name_len, ctx->encoding);
         OBJ_FREEZE(column_name);
 #endif
 
@@ -892,6 +1063,10 @@ static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
         handle_trilogy_error(ctx, args.rc, args.msg);
     }
 
+    if (!(ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS)) {
+        rb_trilogy_release_buffer(ctx);
+    }
+
     return result;
 }
 
@@ -917,12 +1092,39 @@ static VALUE rb_trilogy_more_results_exist(VALUE self)
     }
 }
 
+static VALUE rb_trilogy_abandon_results(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    long count = 0;
+    while (ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS) {
+        count++;
+        int rc = trilogy_drain_results(&ctx->conn);
+        while (rc == TRILOGY_AGAIN) {
+            rc = trilogy_sock_wait_read(ctx->conn.socket);
+            if (rc != TRILOGY_OK) {
+                handle_trilogy_error(ctx, rc, "trilogy_sock_wait_read");
+            }
+
+            rc = trilogy_drain_results(&ctx->conn);
+        }
+
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_drain_results");
+        }
+    }
+
+    return LONG2NUM(count);
+}
+
 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));
+    query = rb_str_export_to_enc(query, ctx->encoding);
+
+    rb_trilogy_acquire_buffer(ctx);
 
     int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
 
@@ -941,6 +1143,8 @@ static VALUE rb_trilogy_ping(VALUE self)
 {
     struct trilogy_ctx *ctx = get_open_ctx(self);
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_ping_send(&ctx->conn);
 
     if (rc == TRILOGY_AGAIN) {
@@ -968,6 +1172,7 @@ static VALUE rb_trilogy_ping(VALUE self)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
     return Qtrue;
 }
 
@@ -985,13 +1190,19 @@ static VALUE rb_trilogy_escape(VALUE self, VALUE str)
     const char *escaped_str;
     size_t escaped_len;
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_escape(&ctx->conn, RSTRING_PTR(str), RSTRING_LEN(str), &escaped_str, &escaped_len);
 
     if (rc < 0) {
         handle_trilogy_error(ctx, rc, "trilogy_escape");
     }
 
-    return rb_enc_str_new(escaped_str, escaped_len, str_enc);
+    VALUE escaped_string = rb_enc_str_new(escaped_str, escaped_len, str_enc);
+
+    rb_trilogy_release_buffer(ctx);
+
+    return escaped_string;
 }
 
 static VALUE rb_trilogy_close(VALUE self)
@@ -1002,6 +1213,8 @@ static VALUE rb_trilogy_close(VALUE self)
         return Qnil;
     }
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_close_send(&ctx->conn);
 
     if (rc == TRILOGY_AGAIN) {
@@ -1027,6 +1240,8 @@ static VALUE rb_trilogy_close(VALUE self)
     // we must clear any SSL errors left in the queue from a read/write.
     ERR_clear_error();
 
+    rb_trilogy_release_buffer(ctx);
+
     trilogy_free(&ctx->conn);
 
     return Qnil;
@@ -1134,14 +1349,15 @@ static VALUE rb_trilogy_server_version(VALUE self) { return rb_str_new_cstr(get_
 
 RUBY_FUNC_EXPORTED void Init_cext(void)
 {
-    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+    #ifdef HAVE_RB_RACTOR_LOCAL_STORAGE_VALUE_NEWKEY
         rb_ext_ractor_safe(true);
+        buffer_pool_key = rb_ractor_local_storage_value_newkey();
     #endif
 
     VALUE Trilogy = rb_const_get(rb_cObject, rb_intern("Trilogy"));
     rb_define_alloc_func(Trilogy, allocate_trilogy);
 
-    rb_define_private_method(Trilogy, "_connect", rb_trilogy_connect, 3);
+    rb_define_private_method(Trilogy, "_connect", rb_trilogy_connect, 4);
     rb_define_method(Trilogy, "change_db", rb_trilogy_change_db, 1);
     rb_define_alias(Trilogy, "select_db", "change_db");
     rb_define_method(Trilogy, "query", rb_trilogy_query, 1);
@@ -1165,6 +1381,7 @@ RUBY_FUNC_EXPORTED void Init_cext(void)
     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, "abandon_results!", rb_trilogy_abandon_results, 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));

data/ext/trilogy-ruby/extconf.rb

@@ -10,12 +10,14 @@ File.binwrite("trilogy.c",
   }.join)
 
 $objs = %w[trilogy.o cast.o cext.o]
-$CFLAGS << " -I #{__dir__}/inc -std=gnu99 -fvisibility=hidden"
+append_cflags(["-I #{__dir__}/inc", "-std=gnu99", "-fvisibility=hidden"])
 
-dir_config("openssl")
+dir_config("openssl").any? || pkg_config("openssl")
 
 have_library("crypto", "CRYPTO_malloc")
 have_library("ssl", "SSL_new")
-have_func("rb_interned_str", "ruby.h")
+have_func("rb_ractor_local_storage_value_newkey", "ruby.h")
+have_func("rb_enc_interned_str", "ruby.h")
+have_func("rb_io_descriptor", "ruby.h") # Ruby 3.1+
 
 create_makefile "trilogy/cext"

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

@@ -53,6 +53,19 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed);
  */
 int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c);
 
+/* trilogy_buffer_write - Appends multiple bytes to the buffer, resizing the underlying
+ * allocation if necessary.
+ *
+ * buffer - A pointer to a pre-initialized trilogy_buffer_t.
+ * ptr    - The pointer to the byte array.
+ * len    - How many bytes to append.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The character was appended to the buffer
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_buffer_write(trilogy_buffer_t *buffer, const uint8_t *ptr, size_t len);
+
 /* trilogy_buffer_free - Free an trilogy_buffer_t's underlying storage. The buffer
  * must be re-initialized with trilogy_buffer_init if it is to be reused. Any
  * operations performed on an unintialized or freed buffer are undefined.

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

@@ -106,6 +106,15 @@ typedef struct {
  */
 int trilogy_init(trilogy_conn_t *conn);
 
+/* trilogy_init_no_buffer - Same as trilogy_init but doesn't allocate the packet buffer
+ *
+ * conn - A pre-allocated trilogy_conn_t pointer.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The trilogy_conn_t pointer was properly initialized
+ */
+int trilogy_init_no_buffer(trilogy_conn_t *conn);
+
 /* trilogy_flush_writes - Attempt to flush the internal packet buffer to the
  * network. This must be used if a `_send` function returns TRILOGY_AGAIN, and
  * should continue to be called until it returns a value other than
@@ -150,6 +159,8 @@ int trilogy_connect_send(trilogy_conn_t *conn, const trilogy_sockopt_t *opts);
  */
 int trilogy_connect_send_socket(trilogy_conn_t *conn, trilogy_sock_t *sock);
 
+int trilogy_connect_set_fd(trilogy_conn_t *conn, trilogy_sock_t *sock, int fd);
+
 /* trilogy_connect_recv - Read the initial handshake from the server.
  *
  * This should be called after trilogy_connect_send returns TRILOGY_OK. Calling

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

@@ -25,7 +25,8 @@
     XX(TRILOGY_MAX_PACKET_EXCEEDED, -20)                                                                               \
     XX(TRILOGY_UNKNOWN_TYPE, -21)                                                                                      \
     XX(TRILOGY_TIMEOUT, -22)                                                                                           \
-    XX(TRILOGY_AUTH_PLUGIN_ERROR, -23)
+    XX(TRILOGY_AUTH_PLUGIN_ERROR, -23)                                                                                 \
+    XX(TRILOGY_MEM_ERROR, -24)
 
 enum {
 #define XX(name, code) name = code,

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

@@ -88,6 +88,8 @@ typedef struct trilogy_sock_t {
 
 static inline int trilogy_sock_connect(trilogy_sock_t *sock) { return sock->connect_cb(sock); }
 
+void trilogy_sock_set_fd(trilogy_sock_t *sock, int fd);
+
 static inline ssize_t trilogy_sock_read(trilogy_sock_t *sock, void *buf, size_t n)
 {
     return sock->read_cb(sock, buf, n);