trilogy 2.9.0 → 2.12.4

data/ext/trilogy-ruby/cext.c

@@ -11,10 +11,149 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-#include <trilogy.h>
-
 #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++) {
+            xfree(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 = xmalloc(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) {
+        xfree(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,
@@ -22,27 +161,36 @@ static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLErro
 
 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_enable_cleartext_plugin, id_ssl_ca, id_ssl_capath, id_ssl_cert, id_ssl_cipher, id_ssl_crl, id_ssl_crlpath, id_ssl_key,
+    id_password, id_database, id_enable_cleartext_plugin,
+    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_multi_result,
-    id_from_code, id_from_errno, id_connection_options, id_max_allowed_packet;
+    id_from_code, id_from_errno, id_max_allowed_packet;
 
 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 +208,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 +264,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 +328,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 +445,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 +511,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 +570,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 +584,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 +749,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 +774,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 +785,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 +814,8 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -660,6 +823,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 +852,8 @@ static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -767,102 +934,107 @@ static VALUE read_query_response(VALUE vargs)
     double query_time = finish.tv_sec - start.tv_sec;
     query_time += (double)(finish.tv_nsec - start.tv_nsec) / 1000000000.0;
 
-    VALUE result = rb_obj_alloc(Trilogy_Result);
-
-    VALUE column_names = rb_ary_new2(column_count);
-    rb_ivar_set(result, id_ivar_fields, column_names);
+    VALUE column_names = 0;
 
     VALUE rows = rb_ary_new();
-    rb_ivar_set(result, id_ivar_rows, rows);
-
-    rb_ivar_set(result, id_ivar_query_time, DBL2NUM(query_time));
 
+    VALUE last_insert_id = Qnil, affected_rows = Qnil;
     if (rc == TRILOGY_OK) {
-        rb_ivar_set(result, id_ivar_last_insert_id, ULL2NUM(ctx->conn.last_insert_id));
-
-        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);
+        last_insert_id = ULL2NUM(ctx->conn.last_insert_id);
+        affected_rows = ULL2NUM(ctx->conn.affected_rows);
     }
+    else {
+        VALUE rb_column_info;
+        struct column_info *column_info = ALLOCV_N(struct column_info, rb_column_info, column_count);
+        VALUE rb_ruby_values;
+        VALUE *row_ruby_values = ALLOCV_N(VALUE, rb_ruby_values, column_count);
 
-    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;
 
-    for (uint64_t i = 0; i < column_count; i++) {
-        trilogy_column_t column;
+            while (1) {
+                rc = trilogy_read_column(&ctx->conn, &column);
 
-        while (1) {
-            rc = trilogy_read_column(&ctx->conn, &column);
+                if (rc == TRILOGY_OK) {
+                    break;
+                }
 
-            if (rc == TRILOGY_OK) {
-                break;
-            }
+                if (rc != TRILOGY_AGAIN) {
+                    return read_query_error(args, rc, "trilogy_read_column");
+                }
 
-            if (rc != TRILOGY_AGAIN) {
-                return read_query_error(args, rc, "trilogy_read_column");
+                rc = trilogy_sock_wait_read(ctx->conn.socket);
+                if (rc != TRILOGY_OK) {
+                    return read_query_error(args, rc, "trilogy_read_column");
+                }
             }
 
-            rc = trilogy_sock_wait_read(ctx->conn.socket);
-            if (rc != TRILOGY_OK) {
-                return read_query_error(args, rc, "trilogy_read_column");
-            }
+    #ifdef HAVE_RB_ENC_INTERNED_STR
+            row_ruby_values[i] = rb_enc_interned_str(column.name, column.name_len, ctx->encoding);
+    #else
+            row_ruby_values[i] = rb_enc_str_new(column.name, column.name_len, ctx->encoding);
+            OBJ_FREEZE(row_ruby_values[i]);
+    #endif
+
+            column_info[i].type = column.type;
+            column_info[i].flags = column.flags;
+            column_info[i].len = column.len;
+            column_info[i].charset = column.charset;
+            column_info[i].decimals = column.decimals;
         }
 
-#ifdef HAVE_RB_INTERNED_STR
-        VALUE column_name = rb_interned_str(column.name, column.name_len);
-#else
-        VALUE column_name = rb_str_new(column.name, column.name_len);
-        OBJ_FREEZE(column_name);
-#endif
+        column_names = rb_ary_new_from_values(column_count, row_ruby_values);
 
-        rb_ary_push(column_names, column_name);
+        VALUE rb_trilogy_values;
+        trilogy_value_t *row_trilogy_values = ALLOCV_N(trilogy_value_t, rb_trilogy_values, column_count);
 
-        column_info[i].type = column.type;
-        column_info[i].flags = column.flags;
-        column_info[i].len = column.len;
-        column_info[i].charset = column.charset;
-        column_info[i].decimals = column.decimals;
-    }
+        while (1) {
+            int rc = trilogy_read_row(&ctx->conn, row_trilogy_values);
 
-    VALUE rb_row_values;
-    trilogy_value_t *row_values = ALLOCV_N(trilogy_value_t, rb_row_values, column_count);
+            if (rc == TRILOGY_AGAIN) {
+                rc = trilogy_sock_wait_read(ctx->conn.socket);
+                if (rc != TRILOGY_OK) {
+                    return read_query_error(args, rc, "trilogy_read_row");
+                }
+                continue;
+            }
 
-    while (1) {
-        int rc = trilogy_read_row(&ctx->conn, row_values);
+            if (rc == TRILOGY_EOF) {
+                break;
+            }
 
-        if (rc == TRILOGY_AGAIN) {
-            rc = trilogy_sock_wait_read(ctx->conn.socket);
             if (rc != TRILOGY_OK) {
                 return read_query_error(args, rc, "trilogy_read_row");
             }
-            continue;
-        }
-
-        if (rc == TRILOGY_EOF) {
-            break;
-        }
 
-        if (rc != TRILOGY_OK) {
-            return read_query_error(args, rc, "trilogy_read_row");
-        }
-
-        if (args->cast_options->flatten_rows) {
             for (uint64_t i = 0; i < column_count; i++) {
-                rb_ary_push(rows, rb_trilogy_cast_value(row_values + i, column_info + i, args->cast_options));
+                row_ruby_values[i] = rb_trilogy_cast_value(row_trilogy_values + i, column_info + i, args->cast_options);
             }
-        } else {
-            VALUE row = rb_ary_new2(column_count);
-            for (uint64_t i = 0; i < column_count; i++) {
-                rb_ary_push(row, rb_trilogy_cast_value(row_values + i, column_info + i, args->cast_options));
+
+            if (args->cast_options->flatten_rows) {
+                rb_ary_cat(rows, row_ruby_values, column_count);
+            } else {
+                rb_ary_push(rows, rb_ary_new_from_values(column_count, row_ruby_values));
             }
-            rb_ary_push(rows, row);
         }
-    }
 
-    return result;
+        ALLOCV_END(rb_column_info);
+        ALLOCV_END(rb_trilogy_values);
+        ALLOCV_END(rb_ruby_values);
+    }
+
+    return rb_class_new_instance(
+        6,
+        (VALUE []){
+            column_names,
+            rows,
+            DBL2NUM(query_time),
+            (ctx->conn.server_status & TRILOGY_SERVER_STATUS_IN_TRANS) ? Qtrue : Qfalse,
+            affected_rows,
+            last_insert_id,
+        },
+        Trilogy_Result
+    );
 }
 
 static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
@@ -892,6 +1064,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 +1093,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 +1144,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 +1173,7 @@ static VALUE rb_trilogy_ping(VALUE self)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
     return Qtrue;
 }
 
@@ -985,13 +1191,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 +1214,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 +1241,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 +1350,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 +1382,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));
@@ -1249,12 +1467,6 @@ RUBY_FUNC_EXPORTED void Init_cext(void)
     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();