trilogy 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff98f0678711dd36bae4c5f8a7e0f399d3391f393816bc8df4c4281dbfd5d53f
-  data.tar.gz: 13914f66cde555a81814e4f2b1761895bb1e33b026a2e7d8e3b74888862e9b69
+  metadata.gz: 693efafac411af8e0859eee682d4432a501f17d90c3735faabad4cac4ab07537
+  data.tar.gz: 646bc59fce2e3b26058bf867f448496e5d5caf1344ca0832d706bd3e2db99a2f
 SHA512:
-  metadata.gz: 8f629502bc41dc22b8ebb65a00fb207d0bd41951d085b7bdd1d9de9956caf2b2c5f9504a533194b6fc5de30883330305482128091f4d417913b576233bf199e6
-  data.tar.gz: 2342f373109f087b89e6802a2d7e6c05f4c6c1ed938a820af404b87c961b8ef455dad3c3ec1d8b32270340583a3cbb31bf38251d9ff0a7fa892c13c3f55c8307
+  metadata.gz: 311d5640cdd3da6e3ba331c8222698ff18a10b06886d277712fb8da453924d862f4c9269163a5f748b73dcbc19087993ae2b3cbdc6fccbbd97a91c0c88f83bed
+  data.tar.gz: 77442107a8527f806c2f602d95c000d81c2e7b7a09f6efc8a77a5dcbb091eb4c6890948a1352a72a8fa2f7ef6fe1d74cb0eda84b0d385049514a8dd0236d597d

data/README.md

@@ -34,6 +34,12 @@ if client.ping
   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
 ```
 
@@ -59,7 +65,7 @@ The official Ruby bindings are inside of the canonical trilogy repository itself
 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.
+* The `query_flags` don'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

data/ext/trilogy-ruby/cast.c

@@ -7,7 +7,7 @@
 
 #define CAST_STACK_SIZE 64
 
-static ID id_BigDecimal, id_new, id_local, id_localtime, id_utc;
+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,
@@ -71,7 +71,7 @@ static void cstr_from_value(char *buf, const trilogy_value_t *value, const char
 {
 
     if (value->data_len > CAST_STACK_SIZE - 1) {
-        rb_raise(rb_cTrilogyError, errmsg, (int)value->data_len, (char *)value->data);
+        rb_raise(Trilogy_CastError, errmsg, (int)value->data_len, (char *)value->data);
     }
 
     memcpy(buf, value->data, value->data_len);
@@ -145,7 +145,11 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             // 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);
-            return rb_funcall(rb_mKernel, id_BigDecimal, 1, str);
+            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: {
@@ -156,7 +160,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             double dbl = strtod(cstr, &err);
 
             if (*err != 0) {
-                rb_raise(rb_cTrilogyError, "Invalid double value: %.*s", (int)value->data_len, (char *)value->data);
+                rb_raise(Trilogy_CastError, "Invalid double value: %.*s", (int)value->data_len, (char *)value->data);
             }
             return rb_float_new(dbl);
         }
@@ -180,7 +184,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             }
 
             if (month < 1 || day < 1) {
-                rb_raise(rb_cTrilogyError, "Invalid date: %.*s", (int)value->data_len, (char *)value->data);
+                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
@@ -211,7 +215,7 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
             }
 
             if (month < 1 || day < 1) {
-                rb_raise(rb_cTrilogyError, "Invalid date: %.*s", (int)value->data_len, (char *)value->data);
+                rb_raise(Trilogy_CastError, "Invalid date: %.*s", (int)value->data_len, (char *)value->data);
             }
 
             return rb_funcall(Date, id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
@@ -265,6 +269,7 @@ void rb_trilogy_cast_init(void)
     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");

data/ext/trilogy-ruby/cext.c

@@ -14,16 +14,16 @@
 
 #define TRILOGY_RB_TIMEOUT 1
 
-VALUE
-rb_cTrilogyError;
-
-static VALUE Trilogy_DatabaseError, Trilogy_Result;
+VALUE Trilogy_CastError;
+static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
+    Trilogy_ConnectionClosedError, Trilogy_TimeoutError, Trilogy_Result;
 
 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_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_ssl_mode, id_tls_ciphersuites, id_tls_min_version, id_tls_max_version, id_multi_statement, id_from_code,
+    id_connection_options;
 
 struct trilogy_ctx {
     trilogy_conn_t conn;
@@ -72,7 +72,7 @@ static struct trilogy_ctx *get_open_ctx(VALUE obj)
     struct trilogy_ctx *ctx = get_ctx(obj);
 
     if (ctx->conn.socket == NULL) {
-        rb_raise(rb_eIOError, "connection closed");
+        rb_raise(Trilogy_ConnectionClosedError, "Attempted to use closed connection");
     }
 
     return ctx;
@@ -88,16 +88,16 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
 
     switch (rc) {
     case TRILOGY_SYSERR:
-        rb_syserr_fail_str(errno, rbmsg);
+        if (errno == ECONNREFUSED || errno == ECONNRESET) {
+            rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE, rbmsg);
+        } else {
+            // TODO: All syserr should be wrapped.
+            rb_syserr_fail_str(errno, rbmsg);
+        }
 
     case TRILOGY_ERR: {
         VALUE message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
-        VALUE exc = rb_exc_new3(Trilogy_DatabaseError,
-                                rb_sprintf("%" PRIsVALUE ": %d %" PRIsVALUE, rbmsg, ctx->conn.error_code, message));
-
-        rb_ivar_set(exc, rb_intern("@error_code"), INT2FIX(ctx->conn.error_code));
-        rb_ivar_set(exc, rb_intern("@error_message"), message);
-
+        VALUE exc = rb_funcall(Trilogy_ProtocolError, id_from_code, 2, message, INT2NUM(ctx->conn.error_code));
         rb_exc_raise(exc);
     }
 
@@ -105,18 +105,29 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         unsigned long ossl_error = ERR_get_error();
         ERR_clear_error();
         if (ERR_GET_LIB(ossl_error) == ERR_LIB_SYS) {
-            rb_syserr_fail_str(ERR_GET_REASON(ossl_error), rbmsg);
+            int err_reason = ERR_GET_REASON(ossl_error);
+
+            if (err_reason == ECONNREFUSED || err_reason == ECONNRESET) {
+                rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE, rbmsg);
+            } else {
+                // TODO: All syserr should be wrapped.
+                rb_syserr_fail_str(err_reason, rbmsg);
+            }
         }
         // We can't recover from OpenSSL level errors if there's
         // an active connection.
         if (ctx->conn.socket != NULL) {
             trilogy_sock_shutdown(ctx->conn.socket);
         }
-        rb_raise(rb_cTrilogyError, "%" PRIsVALUE ": SSL Error: %s", rbmsg, ERR_reason_error_string(ossl_error));
+        rb_raise(Trilogy_SSLError, "%" PRIsVALUE ": SSL Error: %s", rbmsg, ERR_reason_error_string(ossl_error));
+    }
+
+    case TRILOGY_DNS_ERR: {
+        rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE ": TRILOGY_DNS_ERROR", rbmsg);
     }
 
     default:
-        rb_raise(rb_cTrilogyError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
+        rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
     }
 }
 
@@ -129,7 +140,13 @@ static VALUE allocate_trilogy(VALUE klass)
     ctx->query_flags = TRILOGY_FLAGS_DEFAULT;
 
     if (trilogy_init(&ctx->conn) < 0) {
-        rb_syserr_fail(errno, "trilogy_init");
+        if (errno == ECONNREFUSED || errno == ECONNRESET) {
+            rb_raise(Trilogy_BaseConnectionError, "trilogy_init");
+        } else {
+            // TODO: All syserr should be wrapped.
+            VALUE rbmsg = rb_str_new("trilogy_init", 13);
+            rb_syserr_fail_str(errno, rbmsg);
+        }
     }
 
     return obj;
@@ -145,7 +162,7 @@ static int flush_writes(struct trilogy_ctx *ctx)
         }
 
         if (trilogy_sock_wait_write(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_flush_writes");
+            rb_raise(Trilogy_TimeoutError, "trilogy_flush_writes");
         }
     }
 }
@@ -279,7 +296,7 @@ static void auth_switch(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_auth_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
         }
     }
 }
@@ -305,7 +322,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
             }
         } else {
             if (ssl_mode != TRILOGY_SSL_PREFERRED_NOVERIFY) {
-                rb_raise(rb_cTrilogyError, "SSL required, not supported by server");
+                rb_raise(Trilogy_SSLError, "SSL required, not supported by server");
             }
         }
     }
@@ -332,7 +349,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_auth_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
         }
     }
 
@@ -349,6 +366,7 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
     VALUE val;
 
     Check_Type(opts, T_HASH);
+    rb_ivar_set(self, id_connection_options, opts);
 
     if ((val = rb_hash_lookup(opts, ID2SYM(id_ssl_mode))) != Qnil) {
         Check_Type(val, T_FIXNUM);
@@ -426,6 +444,10 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
         connopt.flags |= TRILOGY_CAPABILITIES_FOUND_ROWS;
     }
 
+    if (RTEST(rb_hash_aref(opts, ID2SYM(id_multi_statement)))) {
+        connopt.flags |= TRILOGY_CAPABILITIES_MULTI_STATEMENTS;
+    }
+
     if ((val = rb_hash_aref(opts, ID2SYM(id_ssl_ca))) != Qnil) {
         Check_Type(val, T_STRING);
         connopt.ssl_ca = StringValueCStr(val);
@@ -478,7 +500,7 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE opts)
 
     int rc = try_connect(ctx, &handshake, &connopt);
     if (rc == TRILOGY_RB_TIMEOUT) {
-        rb_syserr_fail(ETIMEDOUT, "trilogy_connect_recv");
+        rb_raise(Trilogy_TimeoutError, "trilogy_connect_recv");
     }
     if (rc != TRILOGY_OK) {
         if (connopt.path) {
@@ -525,7 +547,7 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_change_db_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_change_db_recv");
         }
     }
 
@@ -540,10 +562,9 @@ static void load_query_options(unsigned int query_flags, struct rb_trilogy_cast_
     cast_options->flatten_rows = (query_flags & TRILOGY_FLAGS_FLATTEN_ROWS) != 0;
 }
 
-struct read_query_state {
+struct read_query_response_state {
     struct rb_trilogy_cast_options *cast_options;
     struct trilogy_ctx *ctx;
-    VALUE query;
 
     // to free by caller:
     struct column_info *column_info;
@@ -570,34 +591,25 @@ static void get_timespec_monotonic(struct timespec *ts)
 #endif
 }
 
-static VALUE read_query_error(struct read_query_state *args, int rc, const char *msg)
+static VALUE read_query_error(struct read_query_response_state *args, int rc, const char *msg)
 {
     args->rc = rc;
     args->msg = msg;
     return Qundef;
 }
 
-static VALUE execute_read_query(VALUE vargs)
+static VALUE read_query_response(VALUE vargs)
 {
-    struct read_query_state *args = (void *)vargs;
+    struct read_query_response_state *args = (void *)vargs;
     struct trilogy_ctx *ctx = args->ctx;
-    VALUE query = args->query;
 
     struct timespec start;
     get_timespec_monotonic(&start);
 
-    int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
-
-    if (rc == TRILOGY_AGAIN) {
-        rc = flush_writes(ctx);
-    }
-
-    if (rc < 0) {
-        return read_query_error(args, rc, "trilogy_query_send");
-    }
-
     uint64_t column_count = 0;
 
+    int rc;
+
     while (1) {
         rc = trilogy_query_recv(&ctx->conn, &column_count);
 
@@ -610,7 +622,7 @@ static VALUE execute_read_query(VALUE vargs)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_query_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_query_recv");
         }
     }
 
@@ -656,7 +668,7 @@ static VALUE execute_read_query(VALUE vargs)
             }
 
             if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_syserr_fail(ETIMEDOUT, "trilogy_read_column");
+                rb_raise(Trilogy_TimeoutError, "trilogy_read_column");
             }
         }
 
@@ -673,6 +685,7 @@ static VALUE execute_read_query(VALUE vargs)
         column_info[i].flags = column.flags;
         column_info[i].len = column.len;
         column_info[i].charset = column.charset;
+        column_info[i].decimals = column.decimals;
     }
 
     trilogy_value_t *row_values = ALLOC_N(trilogy_value_t, column_count);
@@ -683,7 +696,7 @@ static VALUE execute_read_query(VALUE vargs)
 
         if (rc == TRILOGY_AGAIN) {
             if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_syserr_fail(ETIMEDOUT, "trilogy_read_row");
+                rb_raise(Trilogy_TimeoutError, "trilogy_read_row");
             }
             continue;
         }
@@ -709,34 +722,25 @@ static VALUE execute_read_query(VALUE vargs)
         }
     }
 
-    if (ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS) {
-        rb_raise(rb_cTrilogyError, "MORE_RESULTS_EXIST");
-    }
-
     return result;
 }
 
-static VALUE rb_trilogy_query(VALUE self, VALUE query)
+static VALUE execute_read_query_response(struct trilogy_ctx *ctx)
 {
-    struct trilogy_ctx *ctx = get_open_ctx(self);
-
-    StringValue(query);
-
     struct rb_trilogy_cast_options cast_options;
     load_query_options(ctx->query_flags, &cast_options);
 
-    struct read_query_state args = {
+    struct read_query_response_state args = {
         .cast_options = &cast_options,
         .column_info = NULL,
         .ctx = ctx,
-        .query = query,
         .row_values = NULL,
         .rc = TRILOGY_OK,
         .msg = NULL,
     };
 
     int state = 0;
-    VALUE result = rb_protect(execute_read_query, (VALUE)&args, &state);
+    VALUE result = rb_protect(read_query_response, (VALUE)&args, &state);
 
     xfree(args.column_info);
     xfree(args.row_values);
@@ -756,6 +760,47 @@ static VALUE rb_trilogy_query(VALUE self, VALUE query)
     return result;
 }
 
+static VALUE rb_trilogy_next_result(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    if (!(ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS)) {
+        return Qnil;
+    }
+
+    return execute_read_query_response(ctx);
+}
+
+static VALUE rb_trilogy_more_results_exist(VALUE self)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    if (ctx->conn.server_status & TRILOGY_SERVER_STATUS_MORE_RESULTS_EXISTS) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_trilogy_query(VALUE self, VALUE query)
+{
+    struct trilogy_ctx *ctx = get_open_ctx(self);
+
+    StringValue(query);
+
+    int rc = trilogy_query_send(&ctx->conn, RSTRING_PTR(query), RSTRING_LEN(query));
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_writes(ctx);
+    }
+
+    if (rc < 0) {
+        handle_trilogy_error(ctx, rc, "trilogy_query_send");
+    }
+
+    return execute_read_query_response(ctx);
+}
+
 static VALUE rb_trilogy_ping(VALUE self)
 {
     struct trilogy_ctx *ctx = get_open_ctx(self);
@@ -782,7 +827,7 @@ static VALUE rb_trilogy_ping(VALUE self)
         }
 
         if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_syserr_fail(ETIMEDOUT, "trilogy_ping_recv");
+            rb_raise(Trilogy_TimeoutError, "trilogy_ping_recv");
         }
     }
 
@@ -918,8 +963,7 @@ static VALUE rb_trilogy_server_version(VALUE self) { return rb_str_new_cstr(get_
 
 void Init_cext()
 {
-    VALUE Trilogy = rb_define_class("Trilogy", rb_cObject);
-
+    VALUE Trilogy = rb_const_get(rb_cObject, rb_intern("Trilogy"));
     rb_define_alloc_func(Trilogy, allocate_trilogy);
 
     rb_define_method(Trilogy, "initialize", rb_trilogy_initialize, 1);
@@ -941,6 +985,8 @@ void Init_cext()
     rb_define_method(Trilogy, "write_timeout=", rb_trilogy_write_timeout_set, 1);
     rb_define_method(Trilogy, "server_status", rb_trilogy_server_status, 0);
     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_const(Trilogy, "TLS_VERSION_10", INT2NUM(TRILOGY_TLS_VERSION_10));
     rb_define_const(Trilogy, "TLS_VERSION_11", INT2NUM(TRILOGY_TLS_VERSION_11));
     rb_define_const(Trilogy, "TLS_VERSION_12", INT2NUM(TRILOGY_TLS_VERSION_12));
@@ -959,23 +1005,32 @@ void Init_cext()
     rb_define_const(Trilogy, "QUERY_FLAGS_FLATTEN_ROWS", INT2NUM(TRILOGY_FLAGS_FLATTEN_ROWS));
     rb_define_const(Trilogy, "QUERY_FLAGS_DEFAULT", INT2NUM(TRILOGY_FLAGS_DEFAULT));
 
-    rb_cTrilogyError = rb_define_class_under(Trilogy, "Error", rb_eStandardError);
-    rb_global_variable(&rb_cTrilogyError);
+    Trilogy_ProtocolError = rb_const_get(Trilogy, rb_intern("ProtocolError"));
+    rb_global_variable(&Trilogy_ProtocolError);
+
+    Trilogy_SSLError = rb_const_get(Trilogy, rb_intern("SSLError"));
+    rb_global_variable(&Trilogy_SSLError);
 
-    Trilogy_DatabaseError = rb_define_class_under(Trilogy, "DatabaseError", rb_cTrilogyError);
-    rb_global_variable(&Trilogy_DatabaseError);
+    Trilogy_QueryError = rb_const_get(Trilogy, rb_intern("QueryError"));
+    rb_global_variable(&Trilogy_QueryError);
 
-    rb_define_attr(Trilogy_DatabaseError, "error_code", 1, 0);
-    rb_define_attr(Trilogy_DatabaseError, "error_message", 1, 0);
+    Trilogy_TimeoutError = rb_const_get(Trilogy, rb_intern("TimeoutError"));
+    rb_global_variable(&Trilogy_TimeoutError);
 
-    Trilogy_Result = rb_define_class_under(Trilogy, "Result", rb_cObject);
+    Trilogy_BaseConnectionError = rb_const_get(Trilogy, rb_intern("BaseConnectionError"));
+    rb_global_variable(&Trilogy_BaseConnectionError);
+
+    Trilogy_ConnectionClosedError = rb_const_get(Trilogy, rb_intern("ConnectionClosed"));
+    rb_global_variable(&Trilogy_ConnectionClosedError);
+
+    Trilogy_Result = rb_const_get(Trilogy, rb_intern("Result"));
     rb_global_variable(&Trilogy_Result);
 
+    Trilogy_CastError = rb_const_get(Trilogy, rb_intern("CastError"));
+    rb_global_variable(&Trilogy_CastError);
+
     rb_define_attr(Trilogy_Result, "affected_rows", 1, 0);
-    rb_define_attr(Trilogy_Result, "fields", 1, 0);
     rb_define_attr(Trilogy_Result, "last_insert_id", 1, 0);
-    rb_define_attr(Trilogy_Result, "rows", 1, 0);
-    rb_define_attr(Trilogy_Result, "query_time", 1, 0);
 
     id_socket = rb_intern("socket");
     id_host = rb_intern("host");
@@ -1002,12 +1057,14 @@ void Init_cext()
     id_tls_ciphersuites = rb_intern("tls_ciphersuites");
     id_tls_min_version = rb_intern("tls_min_version");
     id_tls_max_version = rb_intern("tls_max_version");
-
+    id_multi_statement = rb_intern("multi_statement");
+    id_from_code = rb_intern("from_code");
     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/inc/trilogy/protocol.h

@@ -121,9 +121,7 @@
      * query/ prepared statement.                                                                                      \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_MULTI_STATEMENTS, 0x00010000)                                                              \
-    /* Not implemented.                                                                                                \
-     *                                                                                                                 \
-     * From server: the server is capable of sending multiple result sets from                                         \
+    /* From server: the server is capable of sending multiple result sets from                                         \
      * a query.                                                                                                        \
      *                                                                                                                 \
      * From client: tells the server it's capable of handling multiple result                                          \

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

@@ -23,9 +23,10 @@ struct column_info {
     TRILOGY_CHARSET_t charset;
     uint32_t len;
     uint16_t flags;
+    uint8_t decimals;
 };
 
-extern VALUE rb_cTrilogyError;
+extern VALUE Trilogy_CastError;
 
 VALUE
 rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *column,

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end

data/lib/trilogy.rb

@@ -1,7 +1,101 @@
-require "trilogy/cext"
 require "trilogy/version"
 
 class Trilogy
+  # Trilogy::Error is the base error type. All errors raised by Trilogy
+  # should be descendants of Trilogy::Error
+  module Error
+  end
+
+  # Trilogy::ConnectionError is the base error type for all potentially transient
+  # network errors.
+  module ConnectionError
+    include Error
+  end
+
+  class BaseError < StandardError
+    include Error
+
+    attr_reader :error_code
+
+    def initialize(error_message = nil, error_code = nil)
+      message = error_code ? "#{error_code}: #{error_message}" : error_message
+      super(message)
+      @error_code = error_code
+    end
+  end
+
+  class BaseConnectionError < BaseError
+    include ConnectionError
+  end
+
+  # Trilogy::ClientError is the base error type for invalid queries or parameters
+  # that shouldn't be retried.
+  class ClientError < BaseError
+    include Error
+  end
+
+  class QueryError < ClientError
+  end
+
+  class CastError < ClientError
+  end
+
+  class TimeoutError < Errno::ETIMEDOUT
+    include ConnectionError
+
+    attr_reader :error_code
+
+    def initialize(error_message = nil, error_code = nil)
+      super
+      @error_code = error_code
+    end
+  end
+
+  # DatabaseError was replaced by ProtocolError, but we'll keep it around as an
+  # ancestor of ProtocolError for compatibility reasons (e.g. so `rescue DatabaseError`
+  # still works. We can remove this class in the next major release.
+  module DatabaseError
+  end
+
+  class ProtocolError < BaseError
+    include DatabaseError
+
+    ERROR_CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+      1044 => BaseConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => BaseConnectionError, # ER_ACCESS_DENIED_ERROR
+      1064 => QueryError, # ER_PARSE_ERROR
+      1152 => BaseConnectionError, # ER_ABORTING_CONNECTION
+      1153 => BaseConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => BaseConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => BaseConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => BaseConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => BaseConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => BaseConnectionError, # ER_NET_READ_ERROR
+      1159 => BaseConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => BaseConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => BaseConnectionError, # ER_NET_WRITE_INTERRUPTED
+      1927 => BaseConnectionError, # ER_CONNECTION_KILLED
+    }
+    class << self
+      def from_code(message, code)
+        ERROR_CODES.fetch(code, self).new(message, code)
+      end
+    end
+  end
+
+  class SSLError < BaseError
+    include ConnectionError
+  end
+
+  class ConnectionClosed < IOError
+    include ConnectionError
+  end
+
+  def connection_options
+    @connection_options.dup.freeze
+  end
+
   def in_transaction?
     (server_status & SERVER_STATUS_IN_TRANS) != 0
   end
@@ -28,34 +122,38 @@ class Trilogy
   ensure
     self.query_flags = old_flags
   end
-end
 
-Trilogy::Result.class_eval do
-  def count
-    rows.count
-  end
+  class Result
+    attr_reader :fields, :rows, :query_time
+
+    def count
+      rows.count
+    end
+
+    def each_hash
+      return enum_for(:each_hash) unless block_given?
 
-  def each_hash
-    return enum_for(:each_hash) unless block_given?
+      rows.each do |row|
+        this_row = {}
 
-    rows.each do |row|
-      this_row = {}
+        idx = 0
+        row.each do |col|
+          this_row[fields[idx]] = col
+          idx += 1
+        end
 
-      idx = 0
-      row.each do |col|
-        this_row[fields[idx]] = col
-        idx += 1
+        yield this_row
       end
 
-      yield this_row
+      self
     end
 
-    self
-  end
+    def each(&bk)
+      rows.each(&bk)
+    end
 
-  def each(&bk)
-    rows.each(&bk)
+    include Enumerable
   end
-
-  include Enumerable
 end
+
+require "trilogy/cext"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-17 00:00:00.000000000 Z
+date: 2023-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.7
 signing_key:
 specification_version: 4
 summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy