trilogy 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f62d4a5617aaf6b532cfa2888b297eba7bfb18def74e98b6a12847d2845b81f
-  data.tar.gz: 7c74e6d32f1ec845bccbace0b989a269d833d1582ba38ffd78e8e5f35305883d
+  metadata.gz: 0730bbbdae7e8eab195c4ad745e223bcd55fe6299f98cb324c88beea15ebdc5e
+  data.tar.gz: 7779f268cbfae85bf5575f680ebff9fee6d22b78bb5d3d315ba664969ab9618a
 SHA512:
-  metadata.gz: 7ba24a84f4e946c1c7f797c10738fda98bcc9e1fbb0bd19f289fe9cc6cbb9bae252f9cf307c873c8a958c2d2519075d4a677cb681648e6429b18bf9c9a897bb7
-  data.tar.gz: 4ce6afb50256faf2ec873a71194295c9538a4d2188ecae65018b51f8869a97e4cb68eecef6829f9053ef31a5dca1defd107b46281478e02eb5b10606dae3da99
+  metadata.gz: 42c81e496210cfc0538ef1dd9f4f7c34e2ce94de45e5bcfe4c5815839c463a6b3ae78af529b88c63a670b3cd2035a6b931ef76fdfe1ec508f6b7851858b664d2
+  data.tar.gz: ad05962a8a47cea68ab66188badf405fe96342587bd86d91faf43dd028dc641949ea58d9a6d25547e820c4700c6cd9548d70a2494f0a215b08bb8a61c9c920c8

data/README.md

@@ -34,13 +34,22 @@ if client.ping
   result.each_hash do |user|
     p user
   end
+end
+```
 
-  # Multi-statement
+### Processing multiple result sets
 
-  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
+In order to send and receive multiple result sets, pass the `multi_statement` option when connecting.
+`Trilogy#more_results_exist?` will return true if more results exist, false if no more results exist, or raise
+an error if the respective query errored. `Trilogy#next_result` will retrieve the next result set, or return nil
+if no more results exist.
+
+``` ruby
+client = Trilogy.new(host: "127.0.0.1", port: 3306, username: "root", read_timeout: 2, multi_statement: true)
+
+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?
 ```
 
 ## Building

data/Rakefile

@@ -8,6 +8,12 @@ Rake::ExtensionTask.new do |ext|
   ext.lib_dir = "lib/trilogy"
 end
 
+# When any of the parent library's files change, we need to re-run extconf
+vendored_c_lib = FileList["ext/trilogy-ruby/src/**/*.c", "ext/trilogy-ruby/inc/**/*.h"]
+if extconf_task = Rake.application.tasks.find { |t| t.name =~ /Makefile/ }
+  task extconf_task => vendored_c_lib
+end
+
 Rake::TestTask.new do |t|
   t.libs << "test"
   t.test_files = FileList['test/*_test.rb']

data/ext/trilogy-ruby/cast.c

@@ -233,10 +233,6 @@ rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *co
                 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++) {

data/ext/trilogy-ruby/cext.c

@@ -15,8 +15,6 @@
 
 #include "trilogy-ruby.h"
 
-#define TRILOGY_RB_TIMEOUT 1
-
 VALUE Trilogy_CastError;
 static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
     Trilogy_ConnectionClosedError, Trilogy_ConnectionRefusedError, Trilogy_ConnectionResetError,
@@ -26,8 +24,8 @@ static ID id_socket, id_host, id_port, id_username, id_password, id_found_rows,
     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_multi_statement,
-    id_from_code, id_from_errno, id_connection_options;
+    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;
 
 struct trilogy_ctx {
     trilogy_conn_t conn;
@@ -96,12 +94,26 @@ static void trilogy_syserr_fail_str(int e, VALUE msg)
         rb_raise(Trilogy_ConnectionRefusedError, "%" PRIsVALUE, msg);
     } else if (e == ECONNRESET) {
         rb_raise(Trilogy_ConnectionResetError, "%" PRIsVALUE, msg);
+    } else if (e == EPIPE) {
+        // Backwards compatibility: This error class makes no sense, but matches legacy behavior
+        rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION", msg);
     } else {
         VALUE exc = rb_funcall(Trilogy_SyscallError, id_from_errno, 2, INT2NUM(e), msg);
         rb_exc_raise(exc);
     }
 }
 
+static int trilogy_error_recoverable_p(int rc)
+{
+    // TRILOGY_OPENSSL_ERR and TRILOGY_SYSERR (which can result from an SSL error) must shut down the socket, as further
+    // SSL calls would be invalid.
+    // TRILOGY_ERR, which represents an error message sent to us from the server, is recoverable.
+    // TRILOGY_MAX_PACKET_EXCEEDED is also recoverable as we do not send data when it occurs.
+    // For other exceptions we will also close the socket to prevent further use, as the connection is probably in an
+    // invalid state.
+    return rc == TRILOGY_ERR || rc == TRILOGY_MAX_PACKET_EXCEEDED;
+}
+
 NORETURN(static void handle_trilogy_error(struct trilogy_ctx *, int, const char *, ...));
 static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *msg, ...)
 {
@@ -110,10 +122,22 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
     VALUE rbmsg = rb_vsprintf(msg, args);
     va_end(args);
 
+    if (!trilogy_error_recoverable_p(rc)) {
+        if (ctx->conn.socket != NULL) {
+            // trilogy_sock_shutdown may affect errno
+            int errno_was = errno;
+            trilogy_sock_shutdown(ctx->conn.socket);
+            errno = errno_was;
+        }
+    }
+
     switch (rc) {
     case TRILOGY_SYSERR:
         trilogy_syserr_fail_str(errno, rbmsg);
 
+    case TRILOGY_TIMEOUT:
+        rb_raise(Trilogy_TimeoutError, "%" PRIsVALUE, rbmsg);
+
     case TRILOGY_ERR: {
         VALUE message = rb_str_new(ctx->conn.error_message, ctx->conn.error_message_len);
         VALUE exc = rb_funcall(Trilogy_ProtocolError, id_from_code, 2, message, INT2NUM(ctx->conn.error_code));
@@ -127,11 +151,6 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
             int err_reason = ERR_GET_REASON(ossl_error);
             trilogy_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(Trilogy_SSLError, "%" PRIsVALUE ": SSL Error: %s", rbmsg, ERR_reason_error_string(ossl_error));
     }
 
@@ -169,8 +188,9 @@ static int flush_writes(struct trilogy_ctx *ctx)
             return rc;
         }
 
-        if (trilogy_sock_wait_write(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_flush_writes");
+        rc = trilogy_sock_wait_write(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            return rc;
         }
     }
 }
@@ -190,6 +210,21 @@ static double timeval_to_double(struct timeval tv)
     return (double)tv.tv_sec + ((double)tv.tv_usec) / 1000000.0;
 }
 
+struct rb_trilogy_wait_args {
+    struct timeval *timeout;
+    int wait_flag;
+    int fd;
+    int rc;
+};
+
+static VALUE rb_trilogy_wait_protected(VALUE vargs) {
+    struct rb_trilogy_wait_args *args = (void *)vargs;
+
+    args->rc = rb_wait_for_single_fd(args->fd, args->wait_flag, args->timeout);
+
+    return Qnil;
+}
+
 static int _cb_ruby_wait(trilogy_sock_t *sock, trilogy_wait_t wait)
 {
     struct timeval *timeout = NULL;
@@ -219,11 +254,27 @@ static int _cb_ruby_wait(trilogy_sock_t *sock, trilogy_wait_t wait)
         timeout = NULL;
     }
 
-    int fd = trilogy_sock_fd(sock);
-    if (rb_wait_for_single_fd(fd, wait_flag, timeout) <= 0)
+    struct rb_trilogy_wait_args args;
+    args.fd = trilogy_sock_fd(sock);
+    args.wait_flag = wait_flag;
+    args.timeout = timeout;
+    args.rc = 0;
+
+    int state = 0;
+    rb_protect(rb_trilogy_wait_protected, (VALUE)&args, &state);
+    if (state) {
+        trilogy_sock_shutdown(sock);
+        rb_jump_tag(state);
+    }
+
+    // rc here comes from rb_wait_for_single_fd which (similar to poll(3)) returns 0 to indicate that the call timed out
+    // or -1 to indicate a system error with errno set.
+    if (args.rc < 0)
         return TRILOGY_SYSERR;
+    if (args.rc == 0)
+        return TRILOGY_TIMEOUT;
 
-    return 0;
+    return TRILOGY_OK;
 }
 
 struct nogvl_sock_args {
@@ -275,8 +326,10 @@ escape the GVL on each wait operation without going through call_without_gvl */
             return rc;
         }
 
-        if (trilogy_sock_wait(ctx->conn.socket, TRILOGY_WAIT_HANDSHAKE) < 0)
-            return TRILOGY_RB_TIMEOUT;
+        rc = trilogy_sock_wait(ctx->conn.socket, TRILOGY_WAIT_HANDSHAKE);
+        if (rc != TRILOGY_OK) {
+            return rc;
+        }
     }
 }
 
@@ -303,8 +356,9 @@ static void auth_switch(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake)
             handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
         }
     }
 }
@@ -356,8 +410,9 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
             handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_auth_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_auth_recv");
         }
     }
 
@@ -415,6 +470,11 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VA
         connopt.keepalive_interval = NUM2USHORT(val);
     }
 
+    if ((val = rb_hash_lookup(opts, ID2SYM(id_max_allowed_packet))) != Qnil) {
+        Check_Type(val, T_FIXNUM);
+        connopt.max_allowed_packet = NUM2SIZET(val);
+    }
+
     if ((val = rb_hash_lookup(opts, ID2SYM(id_host))) != Qnil) {
         Check_Type(val, T_STRING);
 
@@ -455,6 +515,10 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VA
         connopt.flags |= TRILOGY_CAPABILITIES_FOUND_ROWS;
     }
 
+    if (rb_hash_aref(opts, ID2SYM(id_multi_result)) != Qfalse) {
+        connopt.flags |= TRILOGY_CAPABILITIES_MULTI_RESULTS;
+    }
+
     if (RTEST(rb_hash_aref(opts, ID2SYM(id_multi_statement)))) {
         connopt.flags |= TRILOGY_CAPABILITIES_MULTI_STATEMENTS;
     }
@@ -510,7 +574,7 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VA
     }
 
     int rc = try_connect(ctx, &handshake, &connopt);
-    if (rc == TRILOGY_RB_TIMEOUT) {
+    if (rc == TRILOGY_TIMEOUT) {
         rb_raise(Trilogy_TimeoutError, "trilogy_connect_recv");
     }
     if (rc != TRILOGY_OK) {
@@ -557,8 +621,9 @@ static VALUE rb_trilogy_change_db(VALUE self, VALUE database)
             handle_trilogy_error(ctx, rc, "trilogy_change_db_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_change_db_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_change_db_recv");
         }
     }
 
@@ -590,8 +655,9 @@ static VALUE rb_trilogy_set_server_option(VALUE self, VALUE option)
             handle_trilogy_error(ctx, rc, "trilogy_set_option_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_set_option_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_set_option_recv");
         }
     }
 
@@ -663,8 +729,9 @@ static VALUE read_query_response(VALUE vargs)
             return read_query_error(args, rc, "trilogy_query_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_query_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_query_recv");
         }
     }
 
@@ -712,8 +779,9 @@ static VALUE read_query_response(VALUE vargs)
                 return read_query_error(args, rc, "trilogy_read_column");
             }
 
-            if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_raise(Trilogy_TimeoutError, "trilogy_read_column");
+            rc = trilogy_sock_wait_read(ctx->conn.socket);
+            if (rc != TRILOGY_OK) {
+                return read_query_error(args, rc, "trilogy_read_column");
             }
         }
 
@@ -740,8 +808,9 @@ static VALUE read_query_response(VALUE vargs)
         int rc = trilogy_read_row(&ctx->conn, row_values);
 
         if (rc == TRILOGY_AGAIN) {
-            if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-                rb_raise(Trilogy_TimeoutError, "trilogy_read_row");
+            rc = trilogy_sock_wait_read(ctx->conn.socket);
+            if (rc != TRILOGY_OK) {
+                return read_query_error(args, rc, "trilogy_read_row");
             }
             continue;
         }
@@ -867,8 +936,9 @@ static VALUE rb_trilogy_ping(VALUE self)
             handle_trilogy_error(ctx, rc, "trilogy_ping_recv");
         }
 
-        if (trilogy_sock_wait_read(ctx->conn.socket) < 0) {
-            rb_raise(Trilogy_TimeoutError, "trilogy_ping_recv");
+        rc = trilogy_sock_wait_read(ctx->conn.socket);
+        if (rc != TRILOGY_OK) {
+            handle_trilogy_error(ctx, rc, "trilogy_ping_recv");
         }
     }
 
@@ -927,6 +997,10 @@ static VALUE rb_trilogy_close(VALUE self)
         }
     }
 
+    // We aren't checking or raising errors here (we need close to always close the socket and free the connection), so
+    // we must clear any SSL errors left in the queue from a read/write.
+    ERR_clear_error();
+
     trilogy_free(&ctx->conn);
 
     return Qnil;
@@ -1028,6 +1102,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
 
     rb_define_private_method(Trilogy, "_initialize", rb_trilogy_initialize, 3);
     rb_define_method(Trilogy, "change_db", rb_trilogy_change_db, 1);
+    rb_define_alias(Trilogy, "select_db", "change_db");
     rb_define_method(Trilogy, "query", rb_trilogy_query, 1);
     rb_define_method(Trilogy, "ping", rb_trilogy_ping, 0);
     rb_define_method(Trilogy, "escape", rb_trilogy_escape, 1);
@@ -1110,6 +1185,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
     id_connect_timeout = rb_intern("connect_timeout");
     id_read_timeout = rb_intern("read_timeout");
     id_write_timeout = rb_intern("write_timeout");
+    id_max_allowed_packet = rb_intern("max_allowed_packet");
     id_keepalive_enabled = rb_intern("keepalive_enabled");
     id_keepalive_idle = rb_intern("keepalive_idle");
     id_keepalive_count = rb_intern("keepalive_count");
@@ -1127,6 +1203,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
     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_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");

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

@@ -177,4 +177,122 @@ int trilogy_ping(trilogy_conn_t *conn);
  */
 int trilogy_close(trilogy_conn_t *conn);
 
+/* trilogy_stmt_prepare - Send a prepared statement prepare command to the server.
+ *
+ * conn     - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *            undefined.
+ * stmt     - A pointer to the buffer containing the statement to prepare.
+ * stmt_len - The length of the data buffer.
+ * stmt_out - A pointer to a pre-allocated trilogy_stmt_t.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The prepare command was successfully sent to the server.
+ *   TRILOGY_UNEXPECTED_PACKET  - The response packet wasn't what was expected.
+ *   TRILOGY_PROTOCOL_VIOLATION - An error occurred while processing a network
+ *                                packet.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ */
+int trilogy_stmt_prepare(trilogy_conn_t *conn, const char *stmt, size_t stmt_len, trilogy_stmt_t *stmt_out);
+
+/* trilogy_stmt_execute - Send a prepared statement execute command to the server.
+ *
+ * conn             - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *                    undefined.
+ * stmt             - Pointer to a valid trilogy_stmt_t, representing the prepared statement you're
+ *                    requesting to execute.
+ * flags            - The flags (TRILOGY_STMT_FLAGS_t) to be used with this execute command packet.
+ * binds            - Pointer to an array of trilogy_binary_value_t's. The array size should
+ *                    match that of `trilogy_stmt_t.column_count`.
+ * column_count_out - Out parameter; A pointer to a pre-allocated uint64_t. Represents the
+ *                    number of columns in the response.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The execute command was successfully sent to the server.
+ *   TRILOGY_UNEXPECTED_PACKET  - The response packet wasn't what was expected.
+ *   TRILOGY_PROTOCOL_VIOLATION - An error occurred while processing a network
+ *                                packet.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ */
+int trilogy_stmt_execute(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint8_t flags, trilogy_binary_value_t *binds,
+                         uint64_t *column_count_out);
+
+/* trilogy_stmt_bind_data - Send a prepared statement bind long data command to the server.
+ *
+ * conn      - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *             undefined.
+ * stmt      - Pointer to a valid trilogy_stmt_t, representing the prepared statement for which
+ *             to bind the supplied parameter data to.
+ * param_num - The parameter index for which the supplied data should be bound to.
+ * data      - A pointer to the buffer containing the data to be bound.
+ * data_len  - The length of the data buffer.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The bind data command was successfully sent to the server.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_bind_data(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint16_t param_num, uint8_t *data,
+                           size_t data_len);
+
+/* trilogy_stmt_read_full_row - Read a row from the prepared statement execute response.
+ *
+ * This should only be called after a sucessful call to trilogy_stmt_execute.
+ * You should continue calling this until TRILOGY_EOF is returned. Denoting the end
+ * of the result set.
+ *
+ * conn         - A pre-initialized trilogy_conn_t pointer. It can also be connected but
+ *                a disconnected trilogy_conn_t will also return TRILOGY_OK.
+ * stmt         - Pointer to a valid trilogy_stmt_t, representing the prepared statement you're
+ *                requesting to execute.
+ * columns      - The list of columns from the prepared statement.
+ * column_count - The number of columns in prepared statement.
+ * values_out   - Out parameter; A pointer to a pre-allocated array of
+ *                trilogy_binary_value_t's. There must be enough space to fit all of the
+ *                values. This can be computed with:
+ *                `(sizeof(trilogy_binary_value_t) * column_count)`.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The prepare command response successfully read from
+ *                                the server.
+ *   TRILOGY_EOF                - There are no more rows to read from the result set.
+ *   TRILOGY_UNEXPECTED_PACKET  - The response packet wasn't what was expected.
+ *   TRILOGY_PROTOCOL_VIOLATION - Invalid length parsed for a TIME/DATETIME/TIMESTAMP value.
+ *   TRILOGY_UNKNOWN_TYPE       - An unsupported or unknown MySQL type was seen.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ */
+int trilogy_stmt_read_full_row(trilogy_conn_t *conn, trilogy_stmt_t *stmt, trilogy_column_packet_t *columns,
+                               trilogy_binary_value_t *values_out);
+
+/* trilogy_stmt_reset - Send a prepared statement reset command to the server.
+ *
+ * conn  - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *         undefined.
+ * stmt  - Pointer to a valid trilogy_stmt_t, representing the prepared statement you're
+ *         requesting to reset.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The reset command was successfully sent to the server.
+ *   TRILOGY_UNEXPECTED_PACKET  - The response packet wasn't what was expected.
+ *   TRILOGY_PROTOCOL_VIOLATION - An error occurred while processing a network
+ *                                packet.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ *   TRILOGY_CLOSED_CONNECTION  - The connection is closed.
+ */
+int trilogy_stmt_reset(trilogy_conn_t *conn, trilogy_stmt_t *stmt);
+
+/* trilogy_stmt_close_send - Send a prepared statement close command to the server.
+ *
+ * conn  - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *         undefined.
+ * stmt  - Pointer to a valid trilogy_stmt_t, representing the prepared statement you're
+ *         requesting to close.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The close command was successfully sent to the server.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_close(trilogy_conn_t *conn, trilogy_stmt_t *stmt);
+
 #endif

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

@@ -16,6 +16,8 @@
 typedef struct {
     trilogy_buffer_t *buffer;
     size_t header_offset;
+    size_t packet_length;
+    size_t packet_max_length;
     uint32_t fragment_length;
     uint8_t seq;
 } trilogy_builder_t;
@@ -54,6 +56,8 @@ void trilogy_builder_finalize(trilogy_builder_t *builder);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_uint8(trilogy_builder_t *builder, uint8_t val);
 
@@ -66,6 +70,8 @@ int trilogy_builder_write_uint8(trilogy_builder_t *builder, uint8_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_uint16(trilogy_builder_t *builder, uint16_t val);
 
@@ -78,6 +84,8 @@ int trilogy_builder_write_uint16(trilogy_builder_t *builder, uint16_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_uint24(trilogy_builder_t *builder, uint32_t val);
 
@@ -90,6 +98,8 @@ int trilogy_builder_write_uint24(trilogy_builder_t *builder, uint32_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_uint32(trilogy_builder_t *builder, uint32_t val);
 
@@ -102,9 +112,37 @@ int trilogy_builder_write_uint32(trilogy_builder_t *builder, uint32_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_uint64(trilogy_builder_t *builder, uint64_t val);
 
+/* trilogy_builder_write_float - Append a float to the packet buffer.
+ *
+ * builder - A pre-initialized trilogy_builder_t pointer
+ * val     - The value to append to the buffer
+ *
+ * Return values:
+ *   TRILOGY_OK     - The value was appended to the packet buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
+ */
+int trilogy_builder_write_float(trilogy_builder_t *builder, float val);
+
+/* trilogy_builder_write_double - Append a double to the packet buffer.
+ *
+ * builder - A pre-initialized trilogy_builder_t pointer
+ * val     - The value to append to the buffer
+ *
+ * Return values:
+ *   TRILOGY_OK     - The value was appended to the packet buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
+ */
+int trilogy_builder_write_double(trilogy_builder_t *builder, double val);
+
 /* trilogy_builder_write_lenenc - Append a length-encoded integer to the packet
  * buffer.
  *
@@ -117,6 +155,8 @@ int trilogy_builder_write_uint64(trilogy_builder_t *builder, uint64_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_lenenc(trilogy_builder_t *builder, uint64_t val);
 
@@ -130,6 +170,8 @@ int trilogy_builder_write_lenenc(trilogy_builder_t *builder, uint64_t val);
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, size_t len);
 
@@ -144,6 +186,8 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_lenenc_buffer(trilogy_builder_t *builder, const void *data, size_t len);
 
@@ -155,7 +199,23 @@ int trilogy_builder_write_lenenc_buffer(trilogy_builder_t *builder, const void *
  * Return values:
  *   TRILOGY_OK     - The value was appended to the packet buffer.
  *   TRILOGY_SYSERR - A system error occurred, check errno.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - Appending this value would exceed the maximum
+ *                                 packet size.
  */
 int trilogy_builder_write_string(trilogy_builder_t *builder, const char *data);
 
+/* trilogy_builder_set_max_packet_length - Set the maximum packet length for
+ * the builder. Writing data to the builder that would cause the packet length
+ * to exceed this value will cause the builder to error.
+ *
+ * builder    - A pre-initialized trilogy_builder_t pointer
+ * max_length - The new maximum packet length to set
+ *
+ * Return values:
+ *   TRILOGY_OK                  - The maximum packet length was set.
+ *   TRILOGY_MAX_PACKET_EXCEEDED - The current packet length is already
+ *                                 larger than the requested maximum.
+ */
+int trilogy_builder_set_max_packet_length(trilogy_builder_t *builder, size_t max_length);
+
 #endif