trilogy 2.9.0 → 2.12.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 998b06e77dcb78b2f30307834490a7c9c7d61422dea586f646cead7b74467058
-  data.tar.gz: e5bf1ecf9e8b2b675db0d3c3ee7531db4ab022aa725c4ed0c16db088884c6075
+  metadata.gz: 9f4205f6f8754fd3b29bbf4d5ae3330e15b719565bbc9ab46039946cba683c1b
+  data.tar.gz: 65a8b6472442d8568b195fd45a61c0c337ef8507fa6528ebc1babf4e15ada1df
 SHA512:
-  metadata.gz: bd2acff1c38bbed9bea64f3fbb9ad474e4d42198dccbcdca0aa1b8ba3b52e35711f1c9e2e1a6859c15a71c38ed08ba06b5adcb5fbb5054b1b4264fd51ae0933f
-  data.tar.gz: e032a04cfb901d48a4e1e711cd576c380562f2b7f871724d06568dff8bd3b599fd3ea86360b3bcbe2f8f9471f986d6b1cc8f8d8e69309877778d1ce442dd65f3
+  metadata.gz: 3fd1f19a93dd462a532cf0d2afcea6ac9b0949da83bc51569c5de9f5eb31c681e4214c16caa8e5779a3a7d14996fd3f3bbdc363bde875899458584d84420fecc
+  data.tar.gz: 17a7c0129f4cf5acfcc7f2b85ca305506f87548660ad2419f973ca45f1bbd81b45f52df9255b628f4914ec7a749570329941b3d7fbb83546509780cca1843aba

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/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, id_local;
 
 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,89 @@ 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)
+{
+    if (local) {
+        return rb_funcall(
+            rb_cTime, id_local, 7,
+            INT2NUM(year), INT2NUM(month), INT2NUM(day),
+            INT2NUM(hour), INT2NUM(min), INT2NUM(sec),
+            INT2NUM(usec)
+        );
+    }
+
+    struct timespec ts = {
+        .tv_sec = civil_to_epoch_utc(year, month, day, hour, min, sec),
+        .tv_nsec = (long)usec * 1000,
+    };
+    return rb_time_timespec_new(&ts, 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 +252,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 +311,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 +346,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 +384,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)
@@ -268,6 +396,4 @@ void rb_trilogy_cast_init(void)
     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");
 }