trilogy_w_prepared_statements 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec4a87d044d75508eb0098cbc6ac7a51b9048219f4488c7781658b8cba7da314
+  data.tar.gz: 2b243fad0e3fa2c77f25dc73840c7bc3119aaa8303d4efa71f6995bc8fffcd88
+SHA512:
+  metadata.gz: 79ba68f9552342091f5ec2f7ae68a662d27fc16293b7dbd8973c5aaf8c5c1ddbdf8664c08355ecf5f12d913f967ca05839d5339efbf5901c5d08776a5c35f1da
+  data.tar.gz: ab40958952f5f330847a7eb03431c0251c22d8ba1bd3ca0d58d0b4832314e94932f120cf07e4895b4d54fbd12f2645acf59e4b0239813a6bb4675dc5e19b65a9

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012-2021 GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# trilogy
+
+Ruby bindings to the Trilogy client library
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+``` ruby
+gem 'trilogy'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install trilogy
+```
+
+## Usage
+
+``` ruby
+client = Trilogy.new(host: "127.0.0.1", port: 3306, username: "root", read_timeout: 2)
+if client.ping
+  client.query_options[:database_timezone] = :utc
+  client.change_db "mydb"
+
+  result = client.query("SELECT id, created_at FROM users LIMIT 10")
+  result.each_hash do |user|
+    p user
+  end
+
+  # Multi-statement
+
+  results = []
+  results << client.query("SELECT name FROM users WHERE id = 1; SELECT name FROM users WHERE id = 2")
+  results << client.next_result while client.more_results_exist?
+end
+```
+
+## Building
+You should use the rake commands to build/install/release the gem
+For instance:
+```shell
+bundle exec rake build
+```
+
+## Contributing
+
+The official Ruby bindings are inside of the canonical trilogy repository itself.
+
+1. Fork it ( https://github.com/github/trilogy/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## mysql2 gem compatibility
+
+The trilogy API was heavily inspired by the mysql2 gem but has a few notable
+differences:
+
+* The `query_options` hash doesn't inherit from the connection options hash.
+  This means that options like turning on/of casting will need to be set before
+  a query and not passed in at connect time.
+* For performance reasons there is no `application_timezone` query option. If
+  casting is enabled and your database timezone is different than what the
+  application is expecting you'll need to do the conversion yourself later.
+* While we still tag strings with the encoding configured on the field they came
+  from - for performance reasons no automatic transcoding into
+  `Encoding.default_internal` is done. Similarly to not automatically converting
+  Time objects from `database_timezone` into `application_timezone`, we leave
+  the transcoding step up to the caller.
+* There is no `as` query option. Calling `Trilogy::Result#each` will yield an array
+  of row values. If you want a hash you should use `Trilogy::Result#each_hash`.

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require "rake/testtask"
+
+Rake::ExtensionTask.new do |ext|
+  ext.name  = "cext"
+  ext.ext_dir = "ext/trilogy-ruby"
+  ext.lib_dir = "lib/trilogy"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+task :test => :compile
+
+task :default => :test
+
+task :console => :compile do
+  sh "ruby -I lib -r trilogy -S irb"
+end

data/ext/trilogy-ruby/cast.c

@@ -0,0 +1,277 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include <trilogy.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 const char *ruby_encoding_name_map[] = {
+    [TRILOGY_ENCODING_ARMSCII8] = NULL,
+    [TRILOGY_ENCODING_ASCII] = "US-ASCII",
+    [TRILOGY_ENCODING_BIG5] = "Big5",
+    [TRILOGY_ENCODING_BINARY] = "BINARY",
+    [TRILOGY_ENCODING_CP1250] = "Windows-1250",
+    [TRILOGY_ENCODING_CP1251] = "Windows-1251",
+    [TRILOGY_ENCODING_CP1256] = "Windows-1256",
+    [TRILOGY_ENCODING_CP1257] = "Windows-1257",
+    [TRILOGY_ENCODING_CP850] = "CP850",
+    [TRILOGY_ENCODING_CP852] = "CP852",
+    [TRILOGY_ENCODING_CP866] = "IBM866",
+    [TRILOGY_ENCODING_CP932] = "Windows-31J",
+    [TRILOGY_ENCODING_DEC8] = NULL,
+    [TRILOGY_ENCODING_EUCJPMS] = "eucJP-ms",
+    [TRILOGY_ENCODING_EUCKR] = "EUC-KR",
+    [TRILOGY_ENCODING_GB2312] = "GB2312",
+    [TRILOGY_ENCODING_GBK] = "GBK",
+    [TRILOGY_ENCODING_GEOSTD8] = NULL,
+    [TRILOGY_ENCODING_GREEK] = "ISO-8859-7",
+    [TRILOGY_ENCODING_HEBREW] = "ISO-8859-8",
+    [TRILOGY_ENCODING_HP8] = NULL,
+    [TRILOGY_ENCODING_KEYBCS2] = NULL,
+    [TRILOGY_ENCODING_KOI8R] = "KOI8-R",
+    [TRILOGY_ENCODING_KOI8U] = "KOI8-U",
+    [TRILOGY_ENCODING_LATIN1] = "ISO-8859-1",
+    [TRILOGY_ENCODING_LATIN2] = "ISO-8859-2",
+    [TRILOGY_ENCODING_LATIN5] = "ISO-8859-9",
+    [TRILOGY_ENCODING_LATIN7] = "ISO-8859-13",
+    [TRILOGY_ENCODING_MACCE] = "macCentEuro",
+    [TRILOGY_ENCODING_MACROMAN] = "macRoman",
+    [TRILOGY_ENCODING_NONE] = NULL,
+    [TRILOGY_ENCODING_SJIS] = "Shift_JIS",
+    [TRILOGY_ENCODING_SWE7] = NULL,
+    [TRILOGY_ENCODING_TIS620] = "TIS-620",
+    [TRILOGY_ENCODING_UCS2] = "UTF-16BE",
+    [TRILOGY_ENCODING_UJIS] = "eucJP-ms",
+    [TRILOGY_ENCODING_UTF16] = "UTF-16BE",
+    [TRILOGY_ENCODING_UTF32] = "UTF-32",
+    [TRILOGY_ENCODING_UTF8] = "UTF-8",
+    [TRILOGY_ENCODING_UTF8MB4] = "UTF-8",
+
+    [TRILOGY_ENCODING_MAX] = NULL,
+};
+
+static int encoding_for_charset(TRILOGY_CHARSET_t charset)
+{
+    static int map[TRILOGY_CHARSET_MAX];
+
+    if (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);
+}
+
+static void cstr_from_value(char *buf, const trilogy_value_t *value, const char *errmsg)
+{
+
+    if (value->data_len > CAST_STACK_SIZE - 1) {
+        rb_raise(rb_cTrilogyError, errmsg, (int)value->data_len, (char *)value->data);
+    }
+
+    memcpy(buf, value->data, value->data_len);
+    buf[value->data_len] = 0;
+}
+
+static unsigned long long ull_from_buf(const char *digits, size_t len)
+{
+    if (!len)
+        return 0;
+
+    unsigned long long val = 0;
+
+    while (len--) {
+        unsigned digit = *digits++ - '0';
+        val = val * 10 + digit;
+    }
+
+    return val;
+}
+
+static long long ll_from_buf(const char *digits, size_t len)
+{
+    if (!len)
+        return 0;
+
+    if (digits[0] == '-') {
+        return -(long long)ull_from_buf(&digits[1], len - 1);
+    } else {
+        return (long long)ull_from_buf(digits, len);
+    }
+}
+
+VALUE
+rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *column,
+                      const struct rb_trilogy_cast_options *options)
+{
+    if (value->is_null) {
+        return Qnil;
+    }
+
+    if (options->cast) {
+        switch (column->type) {
+        case TRILOGY_TYPE_BIT: {
+            if (options->cast_booleans && column->len == 1) {
+                return *(const char *)value->data == 1 ? Qtrue : Qfalse;
+            }
+            break;
+        }
+        case TRILOGY_TYPE_TINY: {
+            if (options->cast_booleans && column->len == 1) {
+                return *(const char *)value->data != '0' ? Qtrue : Qfalse;
+            }
+            /* fall through */
+        }
+        case TRILOGY_TYPE_SHORT:
+        case TRILOGY_TYPE_LONG:
+        case TRILOGY_TYPE_LONGLONG:
+        case TRILOGY_TYPE_INT24:
+        case TRILOGY_TYPE_YEAR: {
+            if (column->flags & TRILOGY_COLUMN_FLAG_UNSIGNED) {
+                unsigned long long num = ull_from_buf(value->data, value->data_len);
+                return ULL2NUM(num);
+            } else {
+                long long num = ll_from_buf(value->data, value->data_len);
+                return LL2NUM(num);
+            }
+        }
+        case TRILOGY_TYPE_DECIMAL:
+        case TRILOGY_TYPE_NEWDECIMAL: {
+            // TODO - optimize so we don't have to allocate a ruby string for
+            // decimal columns
+            VALUE str = rb_str_new(value->data, value->data_len);
+            if (column->decimals == 0) {
+                return rb_funcall(rb_mKernel, id_Integer, 1, str);
+            } else {
+                return rb_funcall(rb_mKernel, id_BigDecimal, 1, str);
+            }
+        }
+        case TRILOGY_TYPE_FLOAT:
+        case TRILOGY_TYPE_DOUBLE: {
+            char cstr[CAST_STACK_SIZE];
+            cstr_from_value(cstr, value, "Invalid double value: %.*s");
+
+            char *err;
+            double dbl = strtod(cstr, &err);
+
+            if (*err != 0) {
+                rb_raise(rb_cTrilogyError, "Invalid double value: %.*s", (int)value->data_len, (char *)value->data);
+            }
+            return rb_float_new(dbl);
+        }
+        case TRILOGY_TYPE_TIMESTAMP:
+        case TRILOGY_TYPE_DATETIME: {
+            int year, month, day, hour, min, sec;
+            char msec_char[7] = {0};
+
+            char cstr[CAST_STACK_SIZE];
+            cstr_from_value(cstr, value, "Invalid date: %.*s");
+
+            int tokens = sscanf(cstr, "%4u-%2u-%2u %2u:%2u:%2u.%6s", &year, &month, &day, &hour, &min, &sec, msec_char);
+
+            // msec might not be present, so check for 6 tokens rather than 7
+            if (tokens < 6) {
+                return Qnil;
+            }
+
+            if (year == 0 && month == 0 && day == 0 && hour == 0 && min == 0 && sec == 0) {
+                return Qnil;
+            }
+
+            if (month < 1 || day < 1) {
+                rb_raise(rb_cTrilogyError, "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)));
+        }
+        case TRILOGY_TYPE_DATE: {
+            int year, month, day;
+
+            char cstr[CAST_STACK_SIZE];
+            cstr_from_value(cstr, value, "Invalid date: %.*s");
+
+            int tokens = sscanf(cstr, "%4u-%2u-%2u", &year, &month, &day);
+            VALUE Date = rb_const_get(rb_cObject, rb_intern("Date"));
+
+            if (tokens < 3) {
+                return Qnil;
+            }
+
+            if (year == 0 && month == 0 && day == 0) {
+                return Qnil;
+            }
+
+            if (month < 1 || day < 1) {
+                rb_raise(rb_cTrilogyError, "Invalid date: %.*s", (int)value->data_len, (char *)value->data);
+            }
+
+            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};
+
+            char cstr[CAST_STACK_SIZE];
+            cstr_from_value(cstr, value, "Invalid time: %.*s");
+
+            int tokens = sscanf(cstr, "%2u:%2u:%2u.%6s", &hour, &min, &sec, msec_char);
+
+            if (tokens < 3) {
+                return Qnil;
+            }
+
+            if (hour == 0 && min == 0 && sec == 0) {
+                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;
+            }
+
+            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)));
+        }
+        default:
+            break;
+        }
+    }
+
+    // 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;
+}
+
+void rb_trilogy_cast_init(void)
+{
+    rb_require("bigdecimal");
+    rb_require("date");
+
+    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");
+}