trilogy 2.8.1 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314d8fc7b424ff0f7cb1a7b432fdf64d51d4a1c3bb0eb20dcf8ea67fb2445bd5
-  data.tar.gz: 66b842ec3cf4017226fcc43e4b0bb931701b1299ea1cb025d8764ad7705dd96e
+  metadata.gz: 6e84050730e47a4bd826b9c15b226d0f825a46df8849c3c4a89c01011e27fb6c
+  data.tar.gz: eddfedb0481b09220bb95f1de423b473aa78f2ad8058de692b85c52bba1c0480
 SHA512:
-  metadata.gz: 5cf6f57d91e14972b5fc61576c1b5be98644c03a4a6185dd6fe80aa2c4c22f629c792abb1572e37dbe6b53aec2208cbb344a5575d8877094d3072a16d011bcbe
-  data.tar.gz: e967b694945e7c2506240d20e2cb45fa67e0aca7f80ca4961cca7556d7fec8e27f1ab790a8459fc57de425a9144cdc808cc19547a607f35713640e59b752552f
+  metadata.gz: a1fa8ecb46aa1b1595c6d6f1a20b5dd4267452d5c59b0571fe31c4cc854907aeb8f8ad1496099e53ba83b29c0594f88dc6f4f45586ede8b1ad53d70b0ff2a774
+  data.tar.gz: a18b393f8b035c8ee3315d42b23d8a46e1597f4ccbac0347acab0161a8c041572eeb8a13d4d323c97a63040f9f18baa04e0742c73e65df33d5763fdd27b6c581

data/README.md

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

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 = RB_ALLOC_N(uint8_t, 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,
@@ -34,6 +177,20 @@ struct trilogy_ctx {
     VALUE encoding;
 };
 
+static void rb_trilogy_acquire_buffer(struct trilogy_ctx *ctx)
+{
+    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 mark_trilogy(void *ptr)
 {
     struct trilogy_ctx *ctx = ptr;
@@ -43,6 +200,7 @@ static void mark_trilogy(void *ptr)
 static void free_trilogy(void *ptr)
 {
     struct trilogy_ctx *ctx = ptr;
+
     trilogy_free(&ctx->conn);
     xfree(ptr);
 }
@@ -116,6 +274,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
@@ -133,7 +293,8 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         rb_raise(Trilogy_TimeoutError, "%" PRIsVALUE, rbmsg);
 
     case TRILOGY_ERR: {
-        VALUE message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
+        VALUE conn_message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
+        VALUE message = rb_sprintf("%" PRIsVALUE " (%" PRIsVALUE ")", conn_message, rbmsg);
         VALUE exc = rb_funcall(Trilogy_ProtocolError, id_from_code, 2, message, INT2NUM(ctx->conn.error_code));
         rb_exc_raise(exc);
     }
@@ -177,7 +338,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);
     }
@@ -601,6 +762,8 @@ static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE
         connopt.tls_max_version = NUM2INT(val);
     }
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = try_connect(ctx, &handshake, &connopt);
     if (rc != TRILOGY_OK) {
         if (connopt.path) {
@@ -616,6 +779,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;
 }
 
@@ -625,6 +790,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) {
@@ -652,6 +819,8 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -659,6 +828,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) {
@@ -686,6 +857,8 @@ static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
+
     return Qtrue;
 }
 
@@ -891,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;
 }
 
@@ -923,6 +1100,8 @@ static VALUE rb_trilogy_query(VALUE self, VALUE query)
     StringValue(query);
     query = rb_str_export_to_enc(query, rb_to_encoding(ctx->encoding));
 
+    rb_trilogy_acquire_buffer(ctx);
+
     int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
 
     if (rc == TRILOGY_AGAIN) {
@@ -940,6 +1119,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) {
@@ -967,6 +1148,7 @@ static VALUE rb_trilogy_ping(VALUE self)
         }
     }
 
+    rb_trilogy_release_buffer(ctx);
     return Qtrue;
 }
 
@@ -984,13 +1166,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)
@@ -1001,6 +1189,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) {
@@ -1026,6 +1216,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;
@@ -1133,6 +1325,11 @@ static VALUE rb_trilogy_server_version(VALUE self) { return rb_str_new_cstr(get_
 
 RUBY_FUNC_EXPORTED void Init_cext(void)
 {
+    #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);
 

data/ext/trilogy-ruby/extconf.rb

@@ -10,12 +10,12 @@ 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")
 
 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")
 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

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/protocol.h

@@ -289,6 +289,7 @@ typedef enum {
     XX(TRILOGY_TYPE_YEAR, 0x0d)                                                                                        \
     XX(TRILOGY_TYPE_VARCHAR, 0x0f)                                                                                     \
     XX(TRILOGY_TYPE_BIT, 0x10)                                                                                         \
+    XX(TRILOGY_TYPE_VECTOR, 0xf2)                                                                                      \
     XX(TRILOGY_TYPE_JSON, 0xf5)                                                                                        \
     XX(TRILOGY_TYPE_NEWDECIMAL, 0xf6)                                                                                  \
     XX(TRILOGY_TYPE_ENUM, 0xf7)                                                                                        \

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

@@ -1,5 +1,6 @@
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "trilogy/buffer.h"
 #include "trilogy/error.h"
@@ -23,6 +24,9 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed)
 {
     // expand buffer if necessary
     if (buffer->len + needed > buffer->cap) {
+        if (buffer->buff == NULL)
+            return TRILOGY_MEM_ERROR;
+
         size_t new_cap = buffer->cap;
 
         while (buffer->len + needed > new_cap) {
@@ -57,9 +61,24 @@ int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c)
     return TRILOGY_OK;
 }
 
+int trilogy_buffer_write(trilogy_buffer_t *buffer, const uint8_t *ptr, size_t len)
+{
+    int rc = trilogy_buffer_expand(buffer, len);
+    if (rc) {
+        return rc;
+    }
+
+    memcpy(buffer->buff + buffer->len, ptr, len);
+    buffer->len += len;
+
+    return TRILOGY_OK;
+}
+
 void trilogy_buffer_free(trilogy_buffer_t *buffer)
 {
-    free(buffer->buff);
-    buffer->buff = NULL;
-    buffer->len = buffer->cap = 0;
+    if (buffer->buff) {
+        free(buffer->buff);
+        buffer->buff = NULL;
+        buffer->len = buffer->cap = 0;
+    }
 }

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

@@ -182,7 +182,7 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
     size_t fragment_remaining = TRILOGY_MAX_PACKET_LEN - builder->fragment_length;
 
-    if (builder->packet_length >= builder->packet_max_length - len) {
+    if (builder->packet_length + len >= builder->packet_max_length) {
         return TRILOGY_MAX_PACKET_EXCEEDED;
     }
 

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

@@ -1,4 +1,5 @@
 #include <fcntl.h>
+#include <string.h>
 
 #include "trilogy/client.h"
 #include "trilogy/error.h"
@@ -117,10 +118,8 @@ static int begin_write(trilogy_conn_t *conn)
     return trilogy_flush_writes(conn);
 }
 
-int trilogy_init(trilogy_conn_t *conn)
+int trilogy_init_no_buffer(trilogy_conn_t *conn)
 {
-    int rc;
-
     conn->affected_rows = 0;
     conn->last_insert_id = 0;
     conn->warning_count = 0;
@@ -142,8 +141,14 @@ int trilogy_init(trilogy_conn_t *conn)
     trilogy_packet_parser_init(&conn->packet_parser, &packet_parser_callbacks);
     conn->packet_parser.user_data = &conn->packet_buffer;
 
-    CHECKED(trilogy_buffer_init(&conn->packet_buffer, TRILOGY_DEFAULT_BUF_SIZE));
+    return TRILOGY_OK;
+}
 
+int trilogy_init(trilogy_conn_t *conn)
+{
+    int rc;
+    trilogy_init_no_buffer(conn);
+    CHECKED(trilogy_buffer_init(&conn->packet_buffer, TRILOGY_DEFAULT_BUF_SIZE));
     return TRILOGY_OK;
 }
 
@@ -217,7 +222,7 @@ static int read_err_packet(trilogy_conn_t *conn)
     return TRILOGY_ERR;
 }
 
-static int read_eof_packet(trilogy_conn_t *conn)
+static int read_deprecated_eof_packet(trilogy_conn_t *conn)
 {
     trilogy_eof_packet_t eof_packet;
 
@@ -236,6 +241,21 @@ static int read_eof_packet(trilogy_conn_t *conn)
     return TRILOGY_EOF;
 }
 
+static int read_eof_packet(trilogy_conn_t *conn)
+{
+    int rc;
+
+    if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF) {
+        return read_ok_packet(conn);
+    } else {
+        if ((rc = read_deprecated_eof_packet(conn)) != TRILOGY_EOF) {
+            return rc;
+        }
+
+        return TRILOGY_OK;
+    }
+}
+
 static int read_auth_switch_packet(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
 {
     trilogy_auth_switch_request_packet_t auth_switch_packet;
@@ -646,15 +666,7 @@ static int read_eof(trilogy_conn_t *conn)
         return rc;
     }
 
-    if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF) {
-        return read_ok_packet(conn);
-    } else {
-        if ((rc = read_eof_packet(conn)) != TRILOGY_EOF) {
-            return rc;
-        }
-
-        return TRILOGY_OK;
-    }
+    return read_eof_packet(conn);
 }
 
 int trilogy_read_row(trilogy_conn_t *conn, trilogy_value_t *values_out)
@@ -679,14 +691,12 @@ int trilogy_read_row(trilogy_conn_t *conn, trilogy_value_t *values_out)
         return rc;
     }
 
-    if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF && current_packet_type(conn) == TRILOGY_PACKET_EOF) {
-        if ((rc = read_ok_packet(conn)) != TRILOGY_OK) {
+    if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+        if ((rc = read_eof_packet(conn)) != TRILOGY_OK) {
             return rc;
         }
 
         return TRILOGY_EOF;
-    } else if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
-        return read_eof_packet(conn);
     } else if (current_packet_type(conn) == TRILOGY_PACKET_ERR) {
         return read_err_packet(conn);
     } else {
@@ -722,7 +732,7 @@ int trilogy_drain_results(trilogy_conn_t *conn)
     }
 }
 
-static uint8_t escape_lookup_table[256] = {
+static const uint8_t escape_lookup_table[256] = {
     ['"'] = '"', ['\0'] = '0', ['\''] = '\'', ['\\'] = '\\', ['\n'] = 'n', ['\r'] = 'r', [26] = 'Z',
 };
 
@@ -735,28 +745,40 @@ int trilogy_escape(trilogy_conn_t *conn, const char *str, size_t len, const char
 
     b->len = 0;
 
-    if (conn->server_status & TRILOGY_SERVER_STATUS_NO_BACKSLASH_ESCAPES) {
-        for (size_t i = 0; i < len; i++) {
-            const uint8_t c = (uint8_t)str[i];
+    // Escaped string will be at least as large as the source string,
+    // so might as well pre-expand the buffer.
+    CHECKED(trilogy_buffer_expand(b, len));
+
+    const uint8_t *cursor = (const uint8_t *)str;
+    const uint8_t *end = cursor + len;
 
-            if (c == '\'') {
-                CHECKED(trilogy_buffer_putc(b, '\''));
-                CHECKED(trilogy_buffer_putc(b, '\''));
+    if (conn->server_status & TRILOGY_SERVER_STATUS_NO_BACKSLASH_ESCAPES) {
+        while (cursor < end) {
+            uint8_t *next_escape = memchr(cursor, '\'', (size_t)(end - cursor));
+            if (next_escape) {
+                CHECKED(trilogy_buffer_write(b, cursor, (size_t)(next_escape - cursor)));
+                CHECKED(trilogy_buffer_write(b, (uint8_t *)"\'\'", 2));
+                cursor = next_escape + 1;
             } else {
-                CHECKED(trilogy_buffer_putc(b, c));
+                CHECKED(trilogy_buffer_write(b, cursor, (size_t)(end - cursor)));
+                break;
             }
         }
     } else {
-        for (size_t i = 0; i < len; i++) {
-            const uint8_t c = (uint8_t)str[i];
-
-            uint8_t escaped = escape_lookup_table[(uint8_t)c];
+        while (cursor < end) {
+            uint8_t escaped = 0;
+            const uint8_t *start = cursor;
+            while (cursor < end && !(escaped = escape_lookup_table[*cursor])) {
+                cursor++;
+            }
 
+            CHECKED(trilogy_buffer_write(b, start, (size_t)(cursor - start)));
             if (escaped) {
                 CHECKED(trilogy_buffer_putc(b, '\\'));
                 CHECKED(trilogy_buffer_putc(b, escaped));
+                cursor++;
             } else {
-                CHECKED(trilogy_buffer_putc(b, c));
+                break;
             }
         }
     }
@@ -940,20 +962,18 @@ int trilogy_stmt_bind_data_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint
 int trilogy_stmt_read_row(trilogy_conn_t *conn, trilogy_stmt_t *stmt, trilogy_column_packet_t *columns,
                           trilogy_binary_value_t *values_out)
 {
-    int err = read_packet(conn);
+    int rc = read_packet(conn);
 
-    if (err < 0) {
-        return err;
+    if (rc < 0) {
+        return rc;
     }
 
-    if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF && current_packet_type(conn) == TRILOGY_PACKET_EOF) {
-        if ((err = read_ok_packet(conn)) != TRILOGY_OK) {
-            return err;
+    if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+        if ((rc = read_eof_packet(conn)) != TRILOGY_OK) {
+            return rc;
         }
 
         return TRILOGY_EOF;
-    } else if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
-        return read_eof_packet(conn);
     } else if (current_packet_type(conn) == TRILOGY_PACKET_ERR) {
         return read_err_packet(conn);
     } else {

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

@@ -926,6 +926,8 @@ int trilogy_build_stmt_execute_packet(trilogy_builder_t *builder, uint32_t stmt_
             case TRILOGY_TYPE_VAR_STRING:
             case TRILOGY_TYPE_STRING:
             case TRILOGY_TYPE_GEOMETRY:
+            case TRILOGY_TYPE_JSON:
+            case TRILOGY_TYPE_VECTOR:
                 CHECKED(trilogy_builder_write_lenenc_buffer(builder, val.as.str.data, val.as.str.len));
 
                 break;
@@ -1059,6 +1061,7 @@ int trilogy_parse_stmt_row_packet(const uint8_t *buff, size_t len, trilogy_colum
             case TRILOGY_TYPE_DECIMAL:
             case TRILOGY_TYPE_NEWDECIMAL:
             case TRILOGY_TYPE_JSON:
+            case TRILOGY_TYPE_VECTOR:
                 CHECKED(trilogy_reader_get_lenenc_buffer(&reader, &out_values[i].as.str.len,
                                                       (const void **)&out_values[i].as.str.data));
 

data/lib/trilogy/encoding.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Trilogy
   module Encoding
     RUBY_ENCODINGS = {

data/lib/trilogy/result.rb

@@ -6,6 +6,8 @@ class Trilogy
       rows.count
     end
 
+    alias_method :size, :count
+
     def each_hash
       return enum_for(:each_hash) unless block_given?
 

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.8.1"
+  VERSION = "2.10.0"
 end

data/trilogy.gemspec

@@ -22,6 +22,10 @@ Gem::Specification.new do |s|
 
   s.require_paths = ["lib"]
 
+  s.required_ruby_version = ">= 3.0"
+
+  s.add_dependency "bigdecimal"
+
   s.add_development_dependency "rake-compiler", "~> 1.0"
   s.add_development_dependency "minitest", "~> 5.5"
 end

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.10.0
 platform: ruby
 authors:
 - GitHub Engineering
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +51,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.5'
-description:
 email: opensource+trilogy@github.com
 executables: []
 extensions:
@@ -87,7 +99,6 @@ homepage: https://github.com/trilogy-libraries/trilogy
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,15 +106,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy
 test_files: []