trilogy 2.11.1 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5072d4f5e6bf162eb99d8a465ffb746f0d4cc9673c18ae5bf8bf3972ea9bf061
-  data.tar.gz: 44b42a75a259456bad0f5ef3120f355ef2685cfb18d4440ea4656b1f48a55ced
+  metadata.gz: 9159fca1baf9c5d9f2a23ef0850ca007ba4f0fc2d1f70ed678bde01dedb0e9d8
+  data.tar.gz: f8239356e08a8fe724f0ae3c2fc2d628eed88a9a15a6ab1ef5b7b696bec6a8b6
 SHA512:
-  metadata.gz: 9dc778f0bfeefcbfc5233f61e4d43f549ceb47f95e407bdea29c1aaafe0b19945ad7e2a34d1a28eb73accae4fa447f9eb07a546cde0d1fe1015e9cdc6cf32b17
-  data.tar.gz: a03e0efd31525f14669ca4a0fdf5b77117ed7da34d6dacccea748c75468e0ec0f927eca797c966cfd7da5ebdd5a10dc458aed8af965e9e9b0a9a1920c86281a0
+  metadata.gz: cec828b0440de7874f7e2df56738e8e99b024649a2d40c256ea955b652ef9375a345bc0021c4ce083c7f0fb4ce56b0cfd84524ce4d055c0d934ae702399b4f79
+  data.tar.gz: a92b013118f91b5c7ff34b9cf3d0cc4eca2bf64199ced3191fc5f17ea9f450e2c2a860d20ed82acc659a2b057e7bf366a31525f8d8fee1bede64b794c2f1a66e

data/ext/trilogy-ruby/cast.c

@@ -1,13 +1,13 @@
 #include <ruby.h>
 #include <ruby/encoding.h>
-
-#include <trilogy.h>
+#include <time.h>
+#include <limits.h>
 
 #include "trilogy-ruby.h"
 
 #define CAST_STACK_SIZE 64
 
-static ID id_BigDecimal, id_Integer, id_new, id_local, id_localtime, id_utc;
+static ID id_BigDecimal, id_Integer, id_new;
 
 static const char *ruby_encoding_name_map[] = {
     [TRILOGY_ENCODING_ARMSCII8] = NULL,
@@ -54,17 +54,20 @@ static const char *ruby_encoding_name_map[] = {
     [TRILOGY_ENCODING_MAX] = NULL,
 };
 
-static int encoding_for_charset(TRILOGY_CHARSET_t charset)
+static rb_encoding * encoding_for_charset(TRILOGY_CHARSET_t charset)
 {
-    static int map[TRILOGY_CHARSET_MAX];
+    static rb_encoding * map[TRILOGY_CHARSET_MAX];
 
-    if (map[charset]) {
+    if (RB_LIKELY(map[charset])) {
         return map[charset];
     }
 
     const char *encoding_name = ruby_encoding_name_map[trilogy_encoding_from_charset(charset)];
-
-    return map[charset] = (encoding_name ? rb_enc_find_index(encoding_name) : -1);
+    map[charset] = rb_enc_find(encoding_name);
+    if (!map[charset]) {
+        map[charset] = rb_ascii8bit_encoding();
+    }
+    return map[charset];
 }
 
 static void cstr_from_value(char *buf, const trilogy_value_t *value, const char *errmsg)
@@ -78,6 +81,92 @@ static void cstr_from_value(char *buf, const trilogy_value_t *value, const char
     buf[value->data_len] = 0;
 }
 
+// For UTC: uses the Hinnant civil_to_days algorithm (C++20 std::chrono
+// foundation, handles the full MySQL 1000-9999 year range without timegm).
+// For local: uses mktime (standard C) which consults the system timezone.
+// http://howardhinnant.github.io/date_algorithms.html
+static time_t civil_to_epoch_utc(int year, int month, int day, int hour, int min, int sec)
+{
+    year -= (month <= 2);
+    int era = (year >= 0 ? year : year - 399) / 400;
+    unsigned yoe = (unsigned)(year - era * 400);
+    unsigned doy = (153 * (month > 2 ? month - 3 : month + 9) + 2) / 5 + (unsigned)day - 1;
+    unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    long days = (long)era * 146097 + (long)doe - 719468;
+    return (time_t)(days * 86400 + hour * 3600 + min * 60 + sec);
+}
+
+static VALUE trilogy_make_time(int year, int month, int day, int hour, int min, int sec,
+                               int usec, int local)
+{
+    struct timespec ts;
+    if (local) {
+        struct tm tm = {
+            .tm_year = year - 1900,
+            .tm_mon  = month - 1,
+            .tm_mday = day,
+            .tm_hour = hour,
+            .tm_min  = min,
+            .tm_sec  = sec,
+            .tm_isdst = -1,
+        };
+        ts.tv_sec = mktime(&tm);
+    } else {
+        ts.tv_sec = civil_to_epoch_utc(year, month, day, hour, min, sec);
+    }
+    ts.tv_nsec = (long)usec * 1000;
+    return rb_time_timespec_new(&ts, local ? INT_MAX : INT_MAX - 1);
+}
+
+// Byte-arithmetic datetime parsing helpers (inspired by Go's go-sql-driver/mysql)
+// These avoid sscanf overhead by parsing ASCII digits directly.
+
+static inline int byte_to_digit(const char b)
+{
+    if (b < '0' || b > '9')
+        return -1;
+    return b - '0';
+}
+
+static inline int parse_2digits(const char *p)
+{
+    int d1 = byte_to_digit(p[0]);
+    int d2 = byte_to_digit(p[1]);
+    if (d1 < 0 || d2 < 0)
+        return -1;
+    return d1 * 10 + d2;
+}
+
+static inline int parse_4digits(const char *p)
+{
+    int d0 = byte_to_digit(p[0]);
+    int d1 = byte_to_digit(p[1]);
+    int d2 = byte_to_digit(p[2]);
+    int d3 = byte_to_digit(p[3]);
+    if (d0 < 0 || d1 < 0 || d2 < 0 || d3 < 0)
+        return -1;
+    return d0 * 1000 + d1 * 100 + d2 * 10 + d3;
+}
+
+// Parse 1-6 fractional digits into microseconds (6-digit value).
+// "1"       => 100000
+// "12"      => 120000
+// "123"     => 123000
+// "123456"  => 123456
+static inline int parse_microseconds(const char *p, size_t len)
+{
+    int usec = 0;
+    int multiplier = 100000;
+    for (size_t i = 0; i < len && i < 6; i++) {
+        int d = byte_to_digit(p[i]);
+        if (d < 0)
+            return -1;
+        usec += d * multiplier;
+        multiplier /= 10;
+    }
+    return usec;
+}
+
 static unsigned long long ull_from_buf(const char *digits, size_t len)
 {
     if (!len)
@@ -166,16 +255,54 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
         }
         case TRILOGY_TYPE_TIMESTAMP:
         case TRILOGY_TYPE_DATETIME: {
-            int year, month, day, hour, min, sec;
-            char msec_char[7] = {0};
+            const char *p = (const char *)value->data;
+            size_t len = value->data_len;
+            int year, month, day, hour = 0, min = 0, sec = 0, usec = 0;
+
+            // Length-based dispatch like Go's parseDateTime:
+            // 10 = "YYYY-MM-DD"
+            // 19 = "YYYY-MM-DD HH:MM:SS"
+            // 21-26 = "YYYY-MM-DD HH:MM:SS.F" through "YYYY-MM-DD HH:MM:SS.FFFFFF"
+            if (len < 10)
+                return Qnil;
 
-            char cstr[CAST_STACK_SIZE];
-            cstr_from_value(cstr, value, "Invalid date: %.*s");
+            year = parse_4digits(p);
+            if (year < 0 || p[4] != '-')
+                return Qnil;
+
+            month = parse_2digits(p + 5);
+            if (month < 0 || p[7] != '-')
+                return Qnil;
+
+            day = parse_2digits(p + 8);
+            if (day < 0)
+                return Qnil;
+
+            if (len >= 19) {
+                if (p[10] != ' ')
+                    return Qnil;
 
-            int tokens = sscanf(cstr, "%4u-%2u-%2u %2u:%2u:%2u.%6s", &year, &month, &day, &hour, &min, &sec, msec_char);
+                hour = parse_2digits(p + 11);
+                if (hour < 0 || p[13] != ':')
+                    return Qnil;
 
-            // msec might not be present, so check for 6 tokens rather than 7
-            if (tokens < 6) {
+                min = parse_2digits(p + 14);
+                if (min < 0 || p[16] != ':')
+                    return Qnil;
+
+                sec = parse_2digits(p + 17);
+                if (sec < 0)
+                    return Qnil;
+
+                if (len > 19) {
+                    if (p[19] != '.' || len < 21 || len > 26)
+                        return Qnil;
+
+                    usec = parse_microseconds(p + 20, len - 20);
+                    if (usec < 0)
+                        return Qnil;
+                }
+            } else if (len != 10) {
                 return Qnil;
             }
 
@@ -187,28 +314,29 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
                 rb_raise(Trilogy_CastError, "Invalid date: %.*s", (int)value->data_len, (char *)value->data);
             }
 
-            // 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';
-            }
-
-            return rb_funcall(rb_cTime, options->database_local_time ? id_local : id_utc, 7, INT2NUM(year),
-                              INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec),
-                              INT2NUM(atoi(msec_char)));
+            return trilogy_make_time(year, month, day, hour, min, sec, usec,
+                                    options->database_local_time);
         }
         case TRILOGY_TYPE_DATE: {
-            int year, month, day;
+            const char *p = (const char *)value->data;
+            size_t len = value->data_len;
 
-            char cstr[CAST_STACK_SIZE];
-            cstr_from_value(cstr, value, "Invalid date: %.*s");
+            if (len != 10)
+                return Qnil;
 
-            int tokens = sscanf(cstr, "%4u-%2u-%2u", &year, &month, &day);
-            VALUE Date = rb_const_get(rb_cObject, rb_intern("Date"));
+            int year = parse_4digits(p);
+            if (year < 0 || p[4] != '-')
+                return Qnil;
 
-            if (tokens < 3) {
+            int month = parse_2digits(p + 5);
+            if (month < 0 || p[7] != '-')
                 return Qnil;
-            }
+
+            int day = parse_2digits(p + 8);
+            if (day < 0)
+                return Qnil;
+
+            VALUE Date = rb_const_get(rb_cObject, rb_intern("Date"));
 
             if (year == 0 && month == 0 && day == 0) {
                 return Qnil;
@@ -221,26 +349,37 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             return rb_funcall(Date, id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
         }
         case TRILOGY_TYPE_TIME: {
-            int hour, min, sec;
-            char msec_char[7] = {0};
+            const char *p = (const char *)value->data;
+            size_t len = value->data_len;
 
-            char cstr[CAST_STACK_SIZE];
-            cstr_from_value(cstr, value, "Invalid time: %.*s");
+            // Expected: "HH:MM:SS" (8) or "HH:MM:SS.F" through "HH:MM:SS.FFFFFF" (10-15)
+            if (len < 8)
+                return Qnil;
 
-            int tokens = sscanf(cstr, "%2u:%2u:%2u.%6s", &hour, &min, &sec, msec_char);
+            int hour = parse_2digits(p);
+            if (hour < 0 || p[2] != ':')
+                return Qnil;
 
-            if (tokens < 3) {
+            int min = parse_2digits(p + 3);
+            if (min < 0 || p[5] != ':')
                 return Qnil;
-            }
 
-            // 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';
+            int sec = parse_2digits(p + 6);
+            if (sec < 0)
+                return Qnil;
+
+            int usec = 0;
+            if (len > 8) {
+                if (p[8] != '.' || len < 10 || len > 15)
+                    return Qnil;
+
+                usec = parse_microseconds(p + 9, len - 9);
+                if (usec < 0)
+                    return Qnil;
             }
 
-            return rb_funcall(rb_cTime, options->database_local_time ? id_local : id_utc, 7, INT2NUM(2000), INT2NUM(1),
-                              INT2NUM(1), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(atoi(msec_char)));
+            return trilogy_make_time(2000, 1, 1, hour, min, sec, usec,
+                                    options->database_local_time);
         }
         default:
             break;
@@ -248,15 +387,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
     }
 
     // for all other types, just return a string
-
-    VALUE str = rb_str_new(value->data, value->data_len);
-
-    int encoding_index = encoding_for_charset(column->charset);
-    if (encoding_index != -1) {
-        rb_enc_associate_index(str, encoding_index);
-    }
-
-    return str;
+    return rb_enc_str_new(value->data, value->data_len, encoding_for_charset(column->charset));
 }
 
 void rb_trilogy_cast_init(void)
@@ -267,7 +398,4 @@ void rb_trilogy_cast_init(void)
     id_BigDecimal = rb_intern("BigDecimal");
     id_Integer = rb_intern("Integer");
     id_new = rb_intern("new");
-    id_local = rb_intern("local");
-    id_localtime = rb_intern("localtime");
-    id_utc = rb_intern("utc");
 }

data/ext/trilogy-ruby/cext.c

@@ -11,8 +11,6 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-#include <trilogy.h>
-
 #include "trilogy-ruby.h"
 
 typedef struct _buffer_pool_entry_struct {
@@ -41,9 +39,7 @@ static void buffer_pool_free(void *data)
     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[index].buff);
         }
         xfree(pool->entries);
     }
@@ -124,7 +120,7 @@ static void buffer_checkout(trilogy_buffer_t *buffer, size_t initial_capacity)
         buffer->buff = pool->entries[pool->len].buff;
         buffer->cap = pool->entries[pool->len].cap;
     } else {
-        buffer->buff = malloc(initial_capacity);
+        buffer->buff = xmalloc(initial_capacity);
         buffer->cap = initial_capacity;
     }
 }
@@ -134,7 +130,7 @@ static bool buffer_checkin(trilogy_buffer_t *buffer)
     buffer_pool * pool = get_buffer_pool();
 
     if (pool->len >= BUFFER_POOL_MAX_SIZE) {
-        free(buffer->buff);
+        xfree(buffer->buff);
         buffer->buff = NULL;
         buffer->cap = 0;
         return false;
@@ -165,10 +161,10 @@ 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;
@@ -938,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_ENC_INTERNED_STR
-        VALUE column_name = rb_enc_interned_str(column.name, column.name_len, ctx->encoding);
-#else
-        VALUE column_name = rb_enc_str_new(column.name, column.name_len, ctx->encoding);
-        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)
@@ -1466,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();
 

data/ext/trilogy-ruby/extconf.rb

@@ -10,7 +10,7 @@ File.binwrite("trilogy.c",
   }.join)
 
 $objs = %w[trilogy.o cast.o cext.o]
-append_cflags(["-I #{__dir__}/inc", "-std=gnu99", "-fvisibility=hidden"])
+append_cflags(["-I #{__dir__}/inc", "-std=gnu99", "-fvisibility=hidden", "-DTRILOGY_XALLOCATOR", "-g"])
 
 dir_config("openssl").any? || pkg_config("openssl")
 

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

@@ -0,0 +1,61 @@
+#ifndef TRILOGY_INTERNAL_ALLOCATOR_H
+#define TRILOGY_INTERNAL_ALLOCATOR_H
+
+/* If you build Trilogy with a custom allocator, configure it with
+ * "-D TRILOGY_XALLOCATOR" to use your own allocator that defines xmalloc,
+ * xrealloc, xcalloc, and xfree.
+ *
+ * For example, your `trilogy_xallocator.h` file could look like this:
+ *
+ * ```
+ * #ifndef TRILOGY_XALLOCATOR_H
+ * #define TRILOGY_XALLOCATOR_H
+ * #define xmalloc          my_malloc
+ * #define xrealloc         my_realloc
+ * #define xcalloc          my_calloc
+ * #define xfree            my_free
+ * #endif
+ * ```
+ */
+#ifdef TRILOGY_XALLOCATOR
+    #include "trilogy_xallocator.h"
+#else
+    #ifndef xmalloc
+        /* The malloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xmalloc malloc
+    #endif
+
+    #ifndef xrealloc
+        /* The realloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xrealloc realloc
+    #endif
+
+    #ifndef xcalloc
+        /* The calloc function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xcalloc calloc
+    #endif
+
+    #ifndef xfree
+        /* The free function that should be used. This can be overridden with
+         * the TRILOGY_XALLOCATOR define. */
+        #define xfree free
+    #endif
+#endif
+
+#include <string.h>
+static inline char *
+xstrdup(const char *str)
+{
+    char *tmp;
+    size_t len = strlen(str) + 1;
+
+    tmp = xmalloc(len);
+    memcpy(tmp, str, len);
+
+    return tmp;
+}
+
+#endif

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

@@ -1,6 +1,7 @@
 #ifndef TRILOGY_H
 #define TRILOGY_H
 
+#include "trilogy/allocator.h"
 #include "trilogy/blocking.h"
 #include "trilogy/client.h"
 #include "trilogy/error.h"

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

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "trilogy/allocator.h"
 #include "trilogy/buffer.h"
 #include "trilogy/error.h"
 
@@ -9,7 +10,7 @@ int trilogy_buffer_init(trilogy_buffer_t *buffer, size_t initial_capacity)
 {
     buffer->len = 0;
     buffer->cap = initial_capacity;
-    buffer->buff = malloc(initial_capacity);
+    buffer->buff = xmalloc(initial_capacity);
 
     if (buffer->buff == NULL) {
         return TRILOGY_SYSERR;
@@ -37,7 +38,7 @@ int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed)
             new_cap *= EXPAND_MULTIPLIER;
         }
 
-        uint8_t *new_buff = realloc(buffer->buff, new_cap);
+        uint8_t *new_buff = xrealloc(buffer->buff, new_cap);
         if (new_buff == NULL)
             return TRILOGY_SYSERR;
 
@@ -77,7 +78,7 @@ int trilogy_buffer_write(trilogy_buffer_t *buffer, const uint8_t *ptr, size_t le
 void trilogy_buffer_free(trilogy_buffer_t *buffer)
 {
     if (buffer->buff) {
-        free(buffer->buff);
+        xfree(buffer->buff);
         buffer->buff = NULL;
         buffer->len = buffer->cap = 0;
     }

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

@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "trilogy/allocator.h"
 #include "trilogy/client.h"
 #include "trilogy/error.h"
 
@@ -279,6 +280,21 @@ static int read_deprecated_eof_packet(trilogy_conn_t *conn)
     return TRILOGY_EOF;
 }
 
+bool is_eof_packet(trilogy_conn_t *conn)
+{
+    // An EOF packet first byte can mark an EOF/OK packet, a deprecated EOF packet, or a huge data packet.
+    if (current_packet_type(conn) == TRILOGY_PACKET_EOF) {
+        if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF) {
+            // The EOF/OK packet can contain an info message and/or session state info up to max packet length.
+            return conn->packet_buffer.len <= TRILOGY_MAX_PACKET_LEN;
+        } else {
+            // The deprecated EOF packet must be smaller than 9 bytes (one 8-byte length-encoded integer).
+            return conn->packet_buffer.len < 9;
+        }
+    }
+    return false;
+}
+
 static int read_eof_packet(trilogy_conn_t *conn)
 {
     int rc;
@@ -566,7 +582,7 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
         return TRILOGY_MEM_ERROR;
     }
     size_t plaintext_len = password_len + 1;
-    uint8_t *plaintext = malloc(plaintext_len);
+    uint8_t *plaintext = xmalloc(plaintext_len);
 
     if (plaintext == NULL) {
         return TRILOGY_MEM_ERROR;
@@ -585,7 +601,7 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
 
     BIO *bio = BIO_new_mem_buf((void *)key_data, (int)key_data_len);
     if (bio == NULL) {
-        free(plaintext);
+        xfree(plaintext);
         return TRILOGY_OPENSSL_ERR;
     }
 
@@ -600,7 +616,7 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
     if (public_key == NULL) {
         ERR_clear_error();
         memset(plaintext, 0, plaintext_len);
-        free(plaintext);
+        xfree(plaintext);
         return TRILOGY_AUTH_PLUGIN_ERROR;
     }
 
@@ -609,7 +625,7 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
     if (key_size <= 0) {
         EVP_PKEY_free(public_key);
         memset(plaintext, 0, plaintext_len);
-        free(plaintext);
+        xfree(plaintext);
         return TRILOGY_AUTH_PLUGIN_ERROR;
     }
     ciphertext_len = (size_t)key_size;
@@ -628,11 +644,11 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
         RSA_free(public_key);
 #endif
         memset(plaintext, 0, plaintext_len);
-        free(plaintext);
+        xfree(plaintext);
         return TRILOGY_AUTH_PLUGIN_ERROR;
     }
 
-    ciphertext = malloc(ciphertext_len);
+    ciphertext = xmalloc(ciphertext_len);
 
     if (ciphertext == NULL) {
 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
@@ -641,7 +657,7 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
         RSA_free(public_key);
 #endif
         memset(plaintext, 0, plaintext_len);
-        free(plaintext);
+        xfree(plaintext);
         return TRILOGY_MEM_ERROR;
     }
 
@@ -676,13 +692,13 @@ static int encrypt_password_with_public_key(const uint8_t *scramble, size_t scra
 #endif
 
     memset(plaintext, 0, plaintext_len);
-    free(plaintext);
+    xfree(plaintext);
 
     if (rc == TRILOGY_OK) {
         *encrypted_out = ciphertext;
     } else {
         memset(ciphertext, 0, ciphertext_len);
-        free(ciphertext);
+        xfree(ciphertext);
     }
 
     return rc;
@@ -755,7 +771,7 @@ static int handle_fast_auth_fail(trilogy_conn_t *conn, trilogy_handshake_t *hand
 
     rc = send_auth_buffer(conn, encrypted, encrypted_len);
     memset(encrypted, 0, encrypted_len);
-    free(encrypted);
+    xfree(encrypted);
 
     if (rc < 0) {
         return rc;
@@ -982,7 +998,7 @@ int trilogy_read_row(trilogy_conn_t *conn, trilogy_value_t *values_out)
         return rc;
     }
 
-    if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+    if (is_eof_packet(conn)) {
         if ((rc = read_eof_packet(conn)) != TRILOGY_OK) {
             return rc;
         }
@@ -1017,7 +1033,7 @@ int trilogy_drain_results(trilogy_conn_t *conn)
             return rc;
         }
 
-        if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+        if (is_eof_packet(conn)) {
             read_eof_packet(conn);
             return TRILOGY_OK;
         }
@@ -1260,7 +1276,7 @@ int trilogy_stmt_read_row(trilogy_conn_t *conn, trilogy_stmt_t *stmt, trilogy_co
         return rc;
     }
 
-    if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+    if (is_eof_packet(conn)) {
         if ((rc = read_eof_packet(conn)) != TRILOGY_OK) {
             return rc;
         }

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

@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 
+#include "trilogy/allocator.h"
 #include "trilogy/error.h"
 #include "trilogy/socket.h"
 
@@ -21,8 +22,9 @@
 struct trilogy_sock {
     trilogy_sock_t base;
     struct addrinfo *addr;
-    int fd;
     SSL *ssl;
+    int fd;
+    bool freeaddrinfo;
 };
 
 void trilogy_sock_set_fd(trilogy_sock_t *_sock, int fd)
@@ -109,30 +111,30 @@ static int _cb_raw_close(trilogy_sock_t *_sock)
     }
 
     if (sock->addr) {
-        if (sock->base.opts.hostname == NULL && sock->base.opts.path != NULL) {
-            /* We created these with calloc so must free them instead of calling freeaddrinfo */
-            free(sock->addr->ai_addr);
-            free(sock->addr);
-        } else {
+        if (sock->freeaddrinfo) {
             freeaddrinfo(sock->addr);
-        }
-    }
-
-    free(sock->base.opts.hostname);
-    free(sock->base.opts.path);
-    free(sock->base.opts.database);
-    free(sock->base.opts.username);
-    free(sock->base.opts.password);
-    free(sock->base.opts.ssl_ca);
-    free(sock->base.opts.ssl_capath);
-    free(sock->base.opts.ssl_cert);
-    free(sock->base.opts.ssl_cipher);
-    free(sock->base.opts.ssl_crl);
-    free(sock->base.opts.ssl_crlpath);
-    free(sock->base.opts.ssl_key);
-    free(sock->base.opts.tls_ciphersuites);
-
-    free(sock);
+        } else {
+            /* We created these with xcalloc so must free them instead of calling freeaddrinfo */
+            xfree(sock->addr->ai_addr);
+            xfree(sock->addr);
+        }
+    }
+
+    xfree(sock->base.opts.hostname);
+    xfree(sock->base.opts.path);
+    xfree(sock->base.opts.database);
+    xfree(sock->base.opts.username);
+    xfree(sock->base.opts.password);
+    xfree(sock->base.opts.ssl_ca);
+    xfree(sock->base.opts.ssl_capath);
+    xfree(sock->base.opts.ssl_cert);
+    xfree(sock->base.opts.ssl_cipher);
+    xfree(sock->base.opts.ssl_crl);
+    xfree(sock->base.opts.ssl_crlpath);
+    xfree(sock->base.opts.ssl_key);
+    xfree(sock->base.opts.tls_ciphersuites);
+
+    xfree(sock);
     return rc;
 }
 
@@ -306,12 +308,12 @@ static char *strdupnullok(const char *str)
     if (str == NULL) {
         return NULL;
     }
-    return strdup(str);
+    return xstrdup(str);
 }
 
 trilogy_sock_t *trilogy_sock_new(const trilogy_sockopt_t *opts)
 {
-    struct trilogy_sock *sock = malloc(sizeof(struct trilogy_sock));
+    struct trilogy_sock *sock = xmalloc(sizeof(struct trilogy_sock));
 
     sock->base.connect_cb = _cb_raw_connect;
     sock->base.read_cb = _cb_raw_read;
@@ -328,7 +330,7 @@ trilogy_sock_t *trilogy_sock_new(const trilogy_sockopt_t *opts)
     sock->base.opts.username = strdupnullok(opts->username);
 
     if (sock->base.opts.password) {
-        sock->base.opts.password = malloc(opts->password_len);
+        sock->base.opts.password = xmalloc(opts->password_len);
         memcpy(sock->base.opts.password, opts->password, opts->password_len);
     }
 
@@ -358,6 +360,7 @@ int trilogy_sock_resolve(trilogy_sock_t *_sock)
         char port[6];
         snprintf(port, sizeof(port), "%hu", sock->base.opts.port);
 
+        sock->freeaddrinfo = true;
         if (getaddrinfo(sock->base.opts.hostname, port, &hint, &sock->addr) != 0) {
             return TRILOGY_DNS_ERR;
         }
@@ -368,15 +371,16 @@ int trilogy_sock_resolve(trilogy_sock_t *_sock)
             goto fail;
         }
 
-        sa = calloc(1, sizeof(struct sockaddr_un));
+        sa = xcalloc(1, sizeof(struct sockaddr_un));
         sa->sun_family = AF_UNIX;
         strcpy(sa->sun_path, sock->base.opts.path);
 
-        sock->addr = calloc(1, sizeof(struct addrinfo));
+        sock->addr = xcalloc(1, sizeof(struct addrinfo));
         sock->addr->ai_family = PF_UNIX;
         sock->addr->ai_socktype = SOCK_STREAM;
         sock->addr->ai_addr = (struct sockaddr *)sa;
         sock->addr->ai_addrlen = sizeof(struct sockaddr_un);
+        sock->freeaddrinfo = false;
     } else {
         goto fail;
     }

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

@@ -1,10 +1,12 @@
 #ifndef TRILOGY_RUBY_H
 #define TRILOGY_RUBY_H
 
-#include <stdbool.h>
-
+#include <ruby.h>
+#include <trilogy_xallocator.h>
 #include <trilogy.h>
 
+#include <stdbool.h>
+
 #define TRILOGY_FLAGS_CAST 1
 #define TRILOGY_FLAGS_CAST_BOOLEANS 2
 #define TRILOGY_FLAGS_LOCAL_TIMEZONE 4

data/ext/trilogy-ruby/trilogy_xallocator.h

@@ -0,0 +1 @@
+#include <ruby.h>

data/lib/trilogy/result.rb

@@ -2,6 +2,22 @@ class Trilogy
   class Result
     attr_reader :fields, :rows, :query_time, :affected_rows, :last_insert_id
 
+    EMPTY_ARRAY = [].freeze
+    private_constant :EMPTY_ARRAY
+
+    def initialize(fields, rows, query_time, in_transaction, affected_rows, last_insert_id)
+      @fields = fields || EMPTY_ARRAY
+      @rows = rows || EMPTY_ARRAY
+      @query_time = query_time
+      @in_transaction = in_transaction
+      @affected_rows = affected_rows
+      @last_insert_id = last_insert_id
+    end
+
+    def in_transaction?
+      @in_transaction
+    end
+
     def count
       rows.count
     end

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.11.1"
+  VERSION = "2.12.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.11.1
+  version: 2.12.0
 platform: ruby
 authors:
 - GitHub Engineering
@@ -36,6 +36,7 @@ files:
 - ext/trilogy-ruby/cext.c
 - ext/trilogy-ruby/extconf.rb
 - ext/trilogy-ruby/inc/trilogy.h
+- ext/trilogy-ruby/inc/trilogy/allocator.h
 - ext/trilogy-ruby/inc/trilogy/blocking.h
 - ext/trilogy-ruby/inc/trilogy/buffer.h
 - ext/trilogy-ruby/inc/trilogy/builder.h
@@ -61,6 +62,7 @@ files:
 - ext/trilogy-ruby/src/vendor/curl_hostcheck.c
 - ext/trilogy-ruby/src/vendor/openssl_hostname_validation.c
 - ext/trilogy-ruby/trilogy-ruby.h
+- ext/trilogy-ruby/trilogy_xallocator.h
 - lib/trilogy.rb
 - lib/trilogy/encoding.rb
 - lib/trilogy/error.rb
@@ -85,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy
 test_files: []