trilogy 2.4.0 → 2.5.0

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

@@ -601,4 +601,218 @@ void trilogy_free(trilogy_conn_t *conn);
  */
 int trilogy_discard(trilogy_conn_t *conn);
 
+/* trilogy_stmt_prepare_send - 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.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The quit command was successfully sent to the server.
+ *   TRILOGY_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_prepare_send(trilogy_conn_t *conn, const char *stmt, size_t stmt_len);
+
+/* trilogy_stmt_t - The trilogy client's prepared statement type.
+ */
+typedef trilogy_stmt_ok_packet_t trilogy_stmt_t;
+
+/* trilogy_stmt_prepare_recv - Read the prepared statement prepare command response
+ * from the MySQL-compatible server.
+ *
+ * This should be called after all data written by trilogy_stmt_prepare_send is flushed
+ * to the network. Calling this at any other time during the connection
+ * lifecycle is undefined.
+ *
+ * Following a successful call to this function, the caller will also need to read off
+ * `trilogy_stmt_t.column_count` parameters as column packets, then
+ * `trilogy_stmt_t.column_count` columns as column packets. This must be done before
+ * the socket will be command-ready again.
+ *
+ * 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_out - A pointer to a pre-allocated trilogy_stmt_t.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The prepare command response successfully read from
+ *                                the server.
+ *   TRILOGY_AGAIN              - The socket wasn't ready for reading. The caller
+ *                                should wait for readability using `conn->sock`.
+ *                                Then call this function until it returns a
+ *                                different value.
+ *   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_recv(trilogy_conn_t *conn, trilogy_stmt_t *stmt_out);
+
+/* trilogy_stmt_bind_data_send - Send a prepared statement bind long data command to the server.
+ *
+ * There is no pairing `trilogy_stmt_bind_data_recv` fucntion to this one because the server
+ * doesn't send a response to this command.
+ *
+ * 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_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_bind_data_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint16_t param_num, uint8_t *data,
+                                size_t data_len);
+
+/* trilogy_stmt_execute_send - 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`.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The execute command was successfully sent to the server.
+ *   TRILOGY_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_execute_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint8_t flags, trilogy_binary_value_t *binds);
+
+/* trilogy_stmt_execute_recv - Read the prepared statement execute command response
+ * from the MySQL-compatible server.
+ *
+ * This should be called after all data written by trilogy_stmt_execute_send is flushed
+ * to the network. Calling this at any other time during the connection
+ * lifecycle is undefined.
+ *
+ * conn             - A pre-initialized trilogy_conn_t pointer. It can also be connected but
+ *                    a disconnected trilogy_conn_t will also return TRILOGY_OK.
+ * 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 prepare command response successfully read from
+ *                                the server.
+ *   TRILOGY_AGAIN              - The socket wasn't ready for reading. The caller
+ *                                should wait for readability using `conn->sock`.
+ *                                Then call this function until it returns a
+ *                                different value.
+ *   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_recv(trilogy_conn_t *conn, uint64_t *column_count_out);
+
+/* trilogy_stmt_read_row - Read a row from the prepared statement execute response.
+ *
+ * This should only be called after a sucessful call to trilogy_stmt_execute_recv.
+ * 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_AGAIN              - The socket wasn't ready for reading. The caller
+ *                                should wait for readability using `conn->sock`.
+ *                                Then call this function until it returns a
+ *                                different value.
+ *   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_row(trilogy_conn_t *conn, trilogy_stmt_t *stmt, trilogy_column_packet_t *columns,
+                          trilogy_binary_value_t *values_out);
+
+/* trilogy_stmt_reset_send - 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_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_reset_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt);
+
+/* trilogy_stmt_reset_recv - Read the prepared statement reset command response
+ * from the MySQL-compatible server.
+ *
+ * This should be called after all data written by trilogy_stmt_reset_send is flushed
+ * to the network. Calling this at any other time during the connection
+ * lifecycle is undefined.
+ *
+ * conn - A pre-initialized trilogy_conn_t pointer. It can also be connected but
+ *      a disconnected trilogy_conn_t will also return TRILOGY_OK.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The reset command response successfully read from
+ *                                the server.
+ *   TRILOGY_AGAIN              - The socket wasn't ready for reading. The caller
+ *                                should wait for readability using `conn->sock`.
+ *                                Then call this function until it returns a
+ *                                different value.
+ *   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_recv(trilogy_conn_t *conn);
+
+/* trilogy_stmt_close_send - Send a prepared statement close command to the server.
+ *
+ * There is no pairing `trilogy_stmt_close_recv` fucntion to this one because the server
+ * doesn't send a response to this command.
+ *
+ * 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_AGAIN  - The socket wasn't ready for writing. The caller should wait
+ *                    for writeability using `conn->sock`. Then call
+ *                    trilogy_flush_writes.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_stmt_close_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt);
+
 #endif

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

@@ -21,7 +21,10 @@
     XX(TRILOGY_OPENSSL_ERR, -16) /* check ERR_get_error() */                                                           \
     XX(TRILOGY_UNSUPPORTED, -17)                                                                                       \
     XX(TRILOGY_DNS_ERR, -18)                                                                                           \
-    XX(TRILOGY_AUTH_SWITCH, -19)
+    XX(TRILOGY_AUTH_SWITCH, -19)                                                                                       \
+    XX(TRILOGY_MAX_PACKET_EXCEEDED, -20)                                                                               \
+    XX(TRILOGY_UNKNOWN_TYPE, -21)                                                                                      \
+    XX(TRILOGY_TIMEOUT, -22)
 
 enum {
 #define XX(name, code) name = code,

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

@@ -124,7 +124,9 @@
      * sets from a query.                                                                                              \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_MULTI_RESULTS, 0x00020000)                                                                 \
-    /* From server: the server is capable of sending multiple result sets from                                         \
+    /* Not implemented.                                                                                                \
+     *                                                                                                                 \
+     * From server: the server is capable of sending multiple result sets from                                         \
      * a prepared statement.                                                                                           \
      *                                                                                                                 \
      * From client: tells the server it's capable of handling multiple result                                          \
@@ -185,8 +187,7 @@ typedef enum {
     /* A convenience bitmask with common client capabilities set. */
     TRILOGY_CAPABILITIES_CLIENT = (TRILOGY_CAPABILITIES_PROTOCOL_41 | TRILOGY_CAPABILITIES_SECURE_CONNECTION |
                                    TRILOGY_CAPABILITIES_DEPRECATE_EOF | TRILOGY_CAPABILITIES_SESSION_TRACK |
-                                   TRILOGY_CAPABILITIES_PLUGIN_AUTH | TRILOGY_CAPABILITIES_TRANSACTIONS |
-                                   TRILOGY_CAPABILITIES_MULTI_RESULTS)
+                                   TRILOGY_CAPABILITIES_PLUGIN_AUTH | TRILOGY_CAPABILITIES_TRANSACTIONS)
 } TRILOGY_CAPABILITIES_t;
 
 #define TRILOGY_SERVER_STATUS(XX)                                                                                      \
@@ -563,6 +564,15 @@ typedef struct {
     size_t last_gtid_len;
 } trilogy_ok_packet_t;
 
+/* trilogy_stmt_ok_packet_t - Represents a MySQL binary protocol prepare response packet.
+ */
+typedef struct {
+    uint32_t id;
+    uint16_t column_count;
+    uint16_t parameter_count;
+    uint16_t warning_count;
+} trilogy_stmt_ok_packet_t;
+
 typedef struct {
     uint16_t warning_count;
     uint16_t status_flags;
@@ -613,6 +623,219 @@ typedef struct {
     size_t data_len;
 } trilogy_value_t;
 
+/* trilogy_binary_value_t - MySQL binary protocol value type
+ *
+ */
+typedef struct {
+    // Flag denoting the value is NULL.
+    bool is_null;
+
+    /* Flag denoting the numeric value is unsigned.
+     * If this is true, the unsigned numerical value types should be used
+     * from the `as` union below.
+     *
+     * For example, if the value's MySQL type is TRILOGY_TYPE_LONGLONG and
+     * `is_unsigned` is `true`, the caller should use the `.as.uint64` field
+     * below to access the properly unsigned value.
+     */
+    bool is_unsigned;
+
+    // The MySQL column type of this value.
+    TRILOGY_TYPE_t type;
+
+    /* This union is used for accessing the underlying binary type for the value.
+     * Each field member is documented with the MySQL column/value type it maps to.
+     */
+    union {
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_DOUBLE
+         */
+        double dbl;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_LONGLONG
+         *
+         * Refer to the `is_unsigned` field above to see which member below should
+         * be used to access the value.
+         */
+        int64_t int64;
+        uint64_t uint64;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_FLOAT
+         */
+        float flt;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_LONG
+         * TRILOGY_TYPE_INT24
+         *
+         * Refer to the `is_unsigned` field above to see which member below should
+         * be used to access the value.
+         */
+        uint32_t uint32;
+        int32_t int32;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_SHORT
+         *
+         * Refer to the `is_unsigned` field above to see which member below should
+         * be used to access the value.
+         */
+        uint16_t uint16;
+        int16_t int16;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_TINY
+         *
+         * Refer to the `is_unsigned` field above to see which member below should
+         * be used to access the value.
+         */
+        uint8_t uint8;
+        int8_t int8;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_STRING
+         * TRILOGY_TYPE_VARCHAR
+         * TRILOGY_TYPE_VAR_STRING
+         * TRILOGY_TYPE_ENUM
+         * TRILOGY_TYPE_SET
+         * TRILOGY_TYPE_LONG_BLOB
+         * TRILOGY_TYPE_MEDIUM_BLOB
+         * TRILOGY_TYPE_BLOB
+         * TRILOGY_TYPE_TINY_BLOB
+         * TRILOGY_TYPE_GEOMETRY
+         * TRILOGY_TYPE_BIT
+         * TRILOGY_TYPE_DECIMAL
+         * TRILOGY_TYPE_NEWDECIMAL
+         */
+        struct {
+            const void *data;
+            size_t len;
+        } str;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_YEAR
+         */
+        uint16_t year;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_DATE
+         * TRILOGY_TYPE_DATETIME
+         * TRILOGY_TYPE_TIMESTAMP
+         */
+        struct {
+            uint16_t year;
+            uint8_t month, day;
+            struct {
+                uint8_t hour, minute, second;
+                uint32_t micro_seconds;
+            } datetime;
+        } date;
+
+        /* MySQL types that use this field:
+         *
+         * TRILOGY_TYPE_TIME
+         */
+        struct {
+            bool is_negative;
+            uint32_t days;
+            uint8_t hour, minute, second;
+            uint32_t micro_seconds;
+        } time;
+    } as;
+} trilogy_binary_value_t;
+
+/* trilogy_build_stmt_prepare_packet - Build a prepared statement prepare command packet.
+ *
+ * builder   - A pointer to a pre-initialized trilogy_builder_t.
+ * query     - The query string to be used by the prepared statement.
+ * query_len - The length of query in bytes.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The packet was successfully built and written to the
+ *                    builder's internal buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_build_stmt_prepare_packet(trilogy_builder_t *builder, const char *sql, size_t sql_len);
+
+// Prepared statement flags
+typedef enum {
+    TRILOGY_CURSOR_TYPE_NO_CURSOR  = 0x00,
+    TRILOGY_CURSOR_TYPE_READ_ONLY  = 0x01,
+    TRILOGY_CURSOR_TYPE_FOR_UPDATE = 0x02,
+    TRILOGY_CURSOR_TYPE_SCROLLABLE = 0x04,
+    TRILOGY_CURSOR_TYPE_UNKNOWN
+} TRILOGY_STMT_FLAGS_t;
+
+/* trilogy_build_stmt_execute_packet - Build a prepared statement execute command packet.
+ *
+ * builder   - A pointer to a pre-initialized trilogy_builder_t.
+ * stmt_id   - The statement id for which to build the execute packet with.
+ * 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.
+ * num_binds - The number of elements in the binds array above.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The packet was successfully built and written to the
+ *                                builder's internal buffer.
+ *   TRILOGY_PROTOCOL_VIOLATION - num_binds is > 0 but binds is NULL.
+ *   TRILOGY_UNKNOWN_TYPE       - An unsupported or unknown MySQL type was used in the list
+ *                                of binds.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ */
+int trilogy_build_stmt_execute_packet(trilogy_builder_t *builder, uint32_t stmt_id, uint8_t flags,
+                                      trilogy_binary_value_t *binds, uint16_t num_binds);
+
+/* trilogy_build_stmt_bind_data_packet - Build a prepared statement bind long data command packet.
+ *
+ * builder  - A pointer to a pre-initialized trilogy_builder_t.
+ * stmt_id  - The statement id for which to build the bind data packet with.
+ * param_id - 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 packet was successfully built and written to the
+ *                    builder's internal buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_build_stmt_bind_data_packet(trilogy_builder_t *builder, uint32_t stmt_id, uint16_t param_id, uint8_t *data,
+                                        size_t data_len);
+
+/* trilogy_build_stmt_reset_packet - Build a prepared statement reset command packet.
+ *
+ * builder - A pointer to a pre-initialized trilogy_builder_t.
+ * stmt_id - The statement id for which to build the reset packet with.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The packet was successfully built and written to the
+ *                    builder's internal buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_build_stmt_reset_packet(trilogy_builder_t *builder, uint32_t stmt_id);
+
+/* trilogy_build_stmt_close_packet - Build a prepared statement close command packet.
+ *
+ * builder - A pointer to a pre-initialized trilogy_builder_t.
+ * stmt_id - The statement id for which to build the close packet with.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The packet was successfully built and written to the
+ *                    builder's internal buffer.
+ *   TRILOGY_SYSERR - A system error occurred, check errno.
+ */
+int trilogy_build_stmt_close_packet(trilogy_builder_t *builder, uint32_t stmt_id);
+
 /* The following parsing functions assume the buffer and length passed in point
  * to one full MySQL-compatible packet. If the buffer contains more than one packet or
  * has any extra data at the end, these functions will return
@@ -769,4 +992,47 @@ int trilogy_parse_column_packet(const uint8_t *buff, size_t len, bool field_list
  */
 int trilogy_parse_row_packet(const uint8_t *buff, size_t len, uint64_t column_count, trilogy_value_t *out_values);
 
+/* trilogy_parse_stmt_ok_packet - Parse a prepared statement ok packet.
+ *
+ * buff         - A pointer to the buffer containing the result packet data.
+ * len          - The length of buffer in bytes.
+ * out_packet   - Out parameter; A pointer to a pre-allocated trilogy_stmt_ok_packet_t.
+ *
+ * Return values:
+ *   TRILOGY_OK                   - The packet was was parsed and the out
+ *                                  parameter has been filled in.
+ *   TRILOGY_TRUNCATED_PACKET     - There isn't enough data in the buffer
+ *                                  to parse the packet.
+ *   TRILOGY_PROTOCOL_VIOLATION   - Filler byte was something other than zero.
+ *   TRILOGY_EXTRA_DATA_IN_PACKET - There are unparsed bytes left in the
+ *                                  buffer.
+ */
+int trilogy_parse_stmt_ok_packet(const uint8_t *buff, size_t len, trilogy_stmt_ok_packet_t *out_packet);
+
+/* trilogy_parse_stmt_row_packet - Parse a prepared statement row packet.
+ *
+ * buff         - A pointer to the buffer containing the result packet data.
+ * len          - The length of buffer in bytes.
+ * columns      - The list of columns from the prepared statement. This parser needs
+ *                this in order to match up the value types.
+ * column_count - The number of columns in prepared statement. This parser needs this
+ *                in order to know how many values to parse.
+ * out_values   - 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 packet was was parsed and the out
+ *                                  parameter has been filled in.
+ *   TRILOGY_TRUNCATED_PACKET     - There isn't enough data in the buffer
+ *                                  to parse the packet.
+ *   TRILOGY_PROTOCOL_VIOLATION   - Invalid length parsed for a TIME/DATETIME/TIMESTAMP value.
+ *   TRILOGY_UNKNOWN_TYPE         - An unsupported or unknown MySQL type was seen in the packet.
+ *   TRILOGY_EXTRA_DATA_IN_PACKET - There are unparsed bytes left in the
+ *                                  buffer.
+ */
+int trilogy_parse_stmt_row_packet(const uint8_t *buff, size_t len, trilogy_column_packet_t *columns,
+                                  uint64_t column_count, trilogy_binary_value_t *out_values);
+
 #endif

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

@@ -90,6 +90,10 @@ int trilogy_reader_get_uint32(trilogy_reader_t *reader, uint32_t *out);
  */
 int trilogy_reader_get_uint64(trilogy_reader_t *reader, uint64_t *out);
 
+int trilogy_reader_get_float(trilogy_reader_t *reader, float *out);
+
+int trilogy_reader_get_double(trilogy_reader_t *reader, double *out);
+
 /* trilogy_reader_get_lenenc - Parse an unsigned, length-encoded integer.
  *
  * reader - A pointer to a pre-initialized trilogy_reader_t.

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

@@ -67,6 +67,8 @@ typedef struct {
     uint16_t keepalive_interval;
 
     TRILOGY_CAPABILITIES_t flags;
+
+    size_t max_allowed_packet;
 } trilogy_sockopt_t;
 
 typedef struct trilogy_sock_t {
@@ -108,6 +110,5 @@ static inline int trilogy_sock_fd(trilogy_sock_t *sock) { return sock->fd_cb(soc
 trilogy_sock_t *trilogy_sock_new(const trilogy_sockopt_t *opts);
 int trilogy_sock_resolve(trilogy_sock_t *raw);
 int trilogy_sock_upgrade_ssl(trilogy_sock_t *raw);
-int trilogy_sock_discard(trilogy_sock_t *sock);
 
 #endif

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

@@ -261,4 +261,121 @@ int trilogy_close(trilogy_conn_t *conn)
     }
 }
 
+int trilogy_stmt_prepare(trilogy_conn_t *conn, const char *stmt, size_t stmt_len, trilogy_stmt_t *stmt_out)
+{
+    int rc = trilogy_stmt_prepare_send(conn, stmt, stmt_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_stmt_prepare_recv(conn, stmt_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+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)
+{
+    int rc = trilogy_stmt_execute_send(conn, stmt, flags, binds);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_stmt_execute_recv(conn, column_count_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_stmt_bind_data(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint16_t param_num, uint8_t *data,
+                           size_t data_len)
+{
+    int rc = trilogy_stmt_bind_data_send(conn, stmt, param_num, data, data_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return TRILOGY_OK;
+}
+
+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)
+{
+    int rc;
+
+    while (1) {
+        rc = trilogy_stmt_read_row(conn, stmt, columns, values_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_stmt_reset(trilogy_conn_t *conn, trilogy_stmt_t *stmt)
+{
+    int rc = trilogy_stmt_reset_send(conn, stmt);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_stmt_reset_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_stmt_close(trilogy_conn_t *conn, trilogy_stmt_t *stmt)
+{
+    int rc = trilogy_stmt_close_send(conn, stmt);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return TRILOGY_OK;
+}
+
 #undef CHECKED