trilogy 2.2.0 → 2.4.0

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

@@ -299,6 +299,50 @@ int trilogy_change_db_send(trilogy_conn_t *conn, const char *name, size_t name_l
  */
 int trilogy_change_db_recv(trilogy_conn_t *conn);
 
+/* trilogy_set_option_send - Send a set option command to the server. This
+ * will change server capabilities based on the option selected.
+ *
+ * This should only be called while the connection is ready for commands.
+ *
+ * conn     - A connected trilogy_conn_t pointer. Using a disconnected
+ *            trilogy_conn_t is undefined.
+ * option   - The server option to send.
+ *
+ * Return values:
+ *   TRILOGY_OK     - The change database 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_set_option_send(trilogy_conn_t *conn, const uint16_t option);
+
+/* trilogy_set_option_recv - Read the set option command response from the
+ * server.
+ *
+ * This should be called after all data written by trilogy_set_option_send is
+ * flushed to the network. Calling this at any other time during the connection
+ * lifecycle is undefined.
+ *
+ * conn - A connected trilogy_conn_t pointer. Using a disconnected trilogy_conn_t is
+ *        undefined.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The set option command was successfully
+ *                                sent to 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_CLOSED_CONNECTION  - The connection is closed.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno.
+ */
+int trilogy_set_option_recv(trilogy_conn_t *conn);
+
 /* trilogy_query_send - Send a query command to the server.
  *
  * This should only be called while the connection is ready for commands.
@@ -543,4 +587,18 @@ int trilogy_close_recv(trilogy_conn_t *conn);
  */
 void trilogy_free(trilogy_conn_t *conn);
 
+/* trilogy_free - Discard the connection and free any internal buffers.
+ *
+ * The server won't be notified that connection was closed. This is useful to
+ * silently close connections that were inherited after forking without disrupting
+ * the parent's process connections.
+ *
+ * conn - A pre-initialized trilogy_conn_t pointer.
+ *
+ * Return values:
+ *   TRILOGY_OK                 - The connection was successfuly discarded and freed.
+ *   TRILOGY_SYSERR             - A system error occurred, check errno. The connection wasn't freed.
+ */
+int trilogy_discard(trilogy_conn_t *conn);
+
 #endif

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

@@ -90,16 +90,14 @@
      * From client: the client is interactive.                                                                         \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_INTERACTIVE, 0x00000400)                                                                   \
-    /* Not implemented.                                                                                                \
-     *                                                                                                                 \
-     * From server: the server supports ssl.                                                                           \
+    /* From server: the server supports ssl.                                                                           \
      *                                                                                                                 \
      * From client: tells the server it should switch to an ssl connection.                                            \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_SSL, 0x00000800)                                                                           \
-    /* Not used.                                                                                                       \
+    /* From server: the server supports transactions and is capable of reporting transaction status.                   \
      *                                                                                                                 \
-     * This is assumed for the 4.1+ protocol.                                                                          \
+     * From client: the client is aware of servers that support transactions.                                          \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_TRANSACTIONS, 0x00002000)                                                                  \
     /* Not used.                                                                                                       \
@@ -112,27 +110,21 @@
      * scheme. This will always be set.                                                                                \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_SECURE_CONNECTION, 0x00008000)                                                             \
-    /* Not implemented.                                                                                                \
-     *                                                                                                                 \
-     * From server: the server can handle multiple statements per                                                      \
+    /* From server: the server can handle multiple statements per                                                      \
      * query/prepared statement.                                                                                       \
      *                                                                                                                 \
      * From client: tells the server it may send multiple statements per                                               \
      * 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                                          \
      * sets from a query.                                                                                              \
      */                                                                                                                \
     XX(TRILOGY_CAPABILITIES_MULTI_RESULTS, 0x00020000)                                                                 \
-    /* 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 prepared statement.                                                                                           \
      *                                                                                                                 \
      * From client: tells the server it's capable of handling multiple result                                          \
@@ -193,7 +185,8 @@ 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_PLUGIN_AUTH | TRILOGY_CAPABILITIES_TRANSACTIONS |
+                                   TRILOGY_CAPABILITIES_MULTI_RESULTS)
 } TRILOGY_CAPABILITIES_t;
 
 #define TRILOGY_SERVER_STATUS(XX)                                                                                      \
@@ -399,22 +392,34 @@ typedef enum {
 #undef XX
 } TRILOGY_SESSION_TRACK_TYPE_t;
 
+#define TRILOGY_SET_SERVER_OPTION(XX)                                                                                  \
+    XX(TRILOGY_SET_SERVER_MULTI_STATEMENTS_ON, 0x00)                                                                   \
+    XX(TRILOGY_SET_SERVER_MULTI_STATEMENTS_OFF, 0x01)                                                                  \
+
+typedef enum {
+#define XX(name, code) name = code,
+    TRILOGY_SET_SERVER_OPTION(XX)
+#undef XX
+} TRILOGY_SET_SERVER_OPTION_TYPE_t;
+
 /* trilogy_build_auth_packet - Build a handshake response (or authentication)
  * packet.
  *
  * This should be sent in response to the initial handshake packet the server
  * sends upon connection.
  *
- * builder     - A pointer to a pre-initialized trilogy_builder_t.
- * user        - The username to use for authentication. Must be a C-string.
- * pass        - The password to use for authentication. Optional, and can be NULL.
- * pass_len    - The length of password in bytes.
- * auth_plugin - Plugin authentication mechanism that the server requested.
- * scramble    - The scramble value the server sent in the initial handshake.
- * flags       - Bitmask of TRILOGY_CAPABILITIES_t flags.
- *               The TRILOGY_CAPABILITIES_PROTOCOL_41 and
- *               TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
- *               internally.
+ * builder          - A pointer to a pre-initialized trilogy_builder_t.
+ * user             - The username to use for authentication. Must be a C-string.
+ * pass             - The password to use for authentication. Optional, and can be NULL.
+ * pass_len         - The length of password in bytes.
+ * database         - The initial database to connect to. Optional, and can be NULL.
+ * client_encoding  - The charset to use for the connection.
+ * auth_plugin      - Plugin authentication mechanism that the server requested.
+ * scramble         - The scramble value the server sent in the initial handshake.
+ * flags            - Bitmask of TRILOGY_CAPABILITIES_t flags.
+ *                    The TRILOGY_CAPABILITIES_PROTOCOL_41 and
+ *                    TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
+ *                    internally.
  *
  * Return values:
  *   TRILOGY_OK     - The packet was successfully built and written to the
@@ -422,8 +427,8 @@ typedef enum {
  *   TRILOGY_SYSERR - A system error occurred, check errno.
  */
 int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, const char *pass, size_t pass_len,
-                              const char *database, const char *auth_plugin, const char *scramble,
-                              TRILOGY_CAPABILITIES_t flags);
+                              const char *database, TRILOGY_CHARSET_t client_encoding, const char *auth_plugin,
+                              const char *scramble, TRILOGY_CAPABILITIES_t flags);
 
 /* trilogy_build_auth_switch_response_packet - Build a response for when
  * authentication switching it requested.
@@ -449,7 +454,7 @@ int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const
  * command will change the default database for the connection.
  *
  * builder  - A pointer to a pre-initialized trilogy_builder_t.
- * name     - The name of the databaset to set as the default.
+ * name     - The name of the database to set as the default.
  * name_len - The length of name in bytes.
  *
  * Return values:
@@ -459,6 +464,20 @@ int trilogy_build_auth_switch_response_packet(trilogy_builder_t *builder, const
  */
 int trilogy_build_change_db_packet(trilogy_builder_t *builder, const char *name, size_t name_len);
 
+/* trilogy_build_set_option_packet - Build a set option command packet. This
+ * command will enable/disable server capabilities for the connection. Options
+ * must be one of `enum_mysql_set_option`.
+ *
+ * builder  - A pointer to a pre-initialized trilogy_builder_t.
+ * option   - An integer corresponding to the operation to perform.
+ *
+ * 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_set_option_packet(trilogy_builder_t *builder, const uint16_t option);
+
 /* trilogy_build_ping_packet - Build a ping command packet.
  *
  * builder - A pointer to a pre-initialized trilogy_builder_t.
@@ -499,19 +518,21 @@ int trilogy_build_quit_packet(trilogy_builder_t *builder);
  * sends upon connection, where an auth packet would normally be sent. A regular
  * auth packet is to be sent after the SSL handshake completes.
  *
- * builder  - A pointer to a pre-initialized trilogy_builder_t.
- * flags    - Bitmask of TRILOGY_CAPABILITIES_t flags.
- *            The TRILOGY_CAPABILITIES_PROTOCOL_41 and
- *            TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
- *            internally.
- *            The TRILOGY_CAPABILITIES_SSL flag will also be set.
+ * builder         - A pointer to a pre-initialized trilogy_builder_t.
+ * flags           - Bitmask of TRILOGY_CAPABILITIES_t flags.
+ *                   The TRILOGY_CAPABILITIES_PROTOCOL_41 and
+ *                   TRILOGY_CAPABILITIES_SECURE_CONNECTION flags will always be set
+ *                   internally.
+ *                   The TRILOGY_CAPABILITIES_SSL flag will also be set.
+ * client_encoding - The charset to use for the connection.
  *
  * 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_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags);
+int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags,
+                                     TRILOGY_CHARSET_t client_encoding);
 
 #define TRILOGY_SERVER_VERSION_SIZE 32
 

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

@@ -41,6 +41,7 @@ typedef struct {
     char *username;
     char *password;
     size_t password_len;
+    uint8_t encoding;
 
     trilogy_ssl_mode_t ssl_mode;
     trilogy_tls_version_t tls_min_version;
@@ -107,5 +108,6 @@ 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

@@ -139,6 +139,29 @@ int trilogy_change_db(trilogy_conn_t *conn, const char *name, size_t name_len)
     }
 }
 
+int trilogy_set_option(trilogy_conn_t *conn, const uint16_t option)
+{
+    int rc = trilogy_set_option_send(conn, option);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_set_option_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
 int trilogy_ping(trilogy_conn_t *conn)
 {
     int rc = trilogy_ping_send(conn);

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

@@ -357,8 +357,9 @@ int trilogy_auth_send(trilogy_conn_t *conn, const trilogy_handshake_t *handshake
     }
 
     rc = trilogy_build_auth_packet(&builder, conn->socket->opts.username, conn->socket->opts.password,
-                                   conn->socket->opts.password_len, conn->socket->opts.database, handshake->auth_plugin,
-                                   handshake->scramble, conn->socket->opts.flags);
+                                   conn->socket->opts.password_len, conn->socket->opts.database,
+                                   conn->socket->opts.encoding, handshake->auth_plugin, handshake->scramble,
+                                   conn->socket->opts.flags);
 
     if (rc < 0) {
         return rc;
@@ -378,7 +379,7 @@ int trilogy_ssl_request_send(trilogy_conn_t *conn)
     }
 
     conn->socket->opts.flags |= TRILOGY_CAPABILITIES_SSL;
-    rc = trilogy_build_ssl_request_packet(&builder, conn->socket->opts.flags);
+    rc = trilogy_build_ssl_request_packet(&builder, conn->socket->opts.flags, conn->socket->opts.encoding);
 
     if (rc < 0) {
         return rc;
@@ -466,6 +467,44 @@ int trilogy_change_db_send(trilogy_conn_t *conn, const char *name, size_t name_l
 
 int trilogy_change_db_recv(trilogy_conn_t *conn) { return read_generic_response(conn); }
 
+int trilogy_set_option_send(trilogy_conn_t *conn, const uint16_t option)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_set_option_packet(&builder, option);
+
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
+int trilogy_set_option_recv(trilogy_conn_t *conn) {
+    int rc = read_packet(conn);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    switch (current_packet_type(conn)) {
+    case TRILOGY_PACKET_OK:
+    case TRILOGY_PACKET_EOF: // COM_SET_OPTION returns an EOF packet, but it should be treated as an OK packet.
+        return read_ok_packet(conn);
+
+    case TRILOGY_PACKET_ERR:
+        return read_err_packet(conn);
+
+    default:
+        return TRILOGY_UNEXPECTED_PACKET;
+    }
+}
+
+
 int trilogy_ping_send(trilogy_conn_t *conn)
 {
     trilogy_builder_t builder;
@@ -725,4 +764,13 @@ void trilogy_free(trilogy_conn_t *conn)
     trilogy_buffer_free(&conn->packet_buffer);
 }
 
+int trilogy_discard(trilogy_conn_t *conn)
+{
+    int rc = trilogy_sock_discard(conn->socket);
+    if (rc == TRILOGY_OK) {
+        trilogy_free(conn);
+    }
+    return rc;
+}
+
 #undef CHECKED

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

@@ -10,6 +10,7 @@
 #define TRILOGY_CMD_CHANGE_DB 0x02
 #define TRILOGY_CMD_QUERY 0x03
 #define TRILOGY_CMD_PING 0x0e
+#define TRILOGY_CMD_SET_OPTION 0x1b
 
 #define SCRAMBLE_LEN 20
 
@@ -493,8 +494,8 @@ static void trilogy_pack_scramble_sha2_hash(const char *scramble, const char *pa
 }
 
 int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, const char *pass, size_t pass_len,
-                              const char *database, const char *auth_plugin, const char *scramble,
-                              TRILOGY_CAPABILITIES_t flags)
+                              const char *database, TRILOGY_CHARSET_t client_encoding, const char *auth_plugin,
+                              const char *scramble, TRILOGY_CAPABILITIES_t flags)
 {
     int rc = TRILOGY_OK;
 
@@ -506,8 +507,6 @@ int trilogy_build_auth_packet(trilogy_builder_t *builder, const char *user, cons
 
     uint32_t max_packet_len = TRILOGY_MAX_PACKET_LEN;
 
-    uint8_t client_encoding = TRILOGY_CHARSET_UTF8_GENERAL_CI;
-
     unsigned int auth_response_len = 0;
     uint8_t auth_response[EVP_MAX_MD_SIZE];
 
@@ -646,12 +645,28 @@ fail:
     return rc;
 }
 
-int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags)
+int trilogy_build_set_option_packet(trilogy_builder_t *builder, const uint16_t option)
+{
+    int rc = TRILOGY_OK;
+
+    CHECKED(trilogy_builder_write_uint8(builder, TRILOGY_CMD_SET_OPTION));
+    CHECKED(trilogy_builder_write_uint16(builder, option));
+
+    trilogy_builder_finalize(builder);
+
+    return TRILOGY_OK;
+
+fail:
+    return rc;
+}
+
+
+int trilogy_build_ssl_request_packet(trilogy_builder_t *builder, TRILOGY_CAPABILITIES_t flags,
+                                     TRILOGY_CHARSET_t client_encoding)
 {
     static const char zeroes[23] = {0};
 
     const uint32_t max_packet_len = TRILOGY_MAX_PACKET_LEN;
-    const uint8_t client_encoding = TRILOGY_CHARSET_UTF8_GENERAL_CI;
     const uint32_t capabilities = flags | TRILOGY_CAPABILITIES_CLIENT | TRILOGY_CAPABILITIES_SSL;
 
     int rc = TRILOGY_OK;

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

@@ -621,3 +621,28 @@ fail:
     sock->ssl = NULL;
     return TRILOGY_OPENSSL_ERR;
 }
+
+int trilogy_sock_discard(trilogy_sock_t *_sock)
+{
+    struct trilogy_sock *sock = (struct trilogy_sock *)_sock;
+
+    if (sock->fd < 0) {
+        return TRILOGY_OK;
+    }
+
+    int null_fd = open("/dev/null", O_RDWR | O_CLOEXEC);
+    if (null_fd < 0) {
+        return TRILOGY_SYSERR;
+    }
+
+    if (dup2(null_fd, sock->fd) < 0) {
+        close(null_fd);
+        return TRILOGY_SYSERR;
+    }
+
+    if (close(null_fd) < 0) {
+        return TRILOGY_SYSERR;
+    }
+
+    return TRILOGY_OK;
+}

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

@@ -9,6 +9,7 @@
 #define TRILOGY_FLAGS_CAST_BOOLEANS 2
 #define TRILOGY_FLAGS_LOCAL_TIMEZONE 4
 #define TRILOGY_FLAGS_FLATTEN_ROWS 8
+#define TRILOGY_FLAGS_CAST_ALL_DECIMALS_TO_BIGDECIMALS 16
 #define TRILOGY_FLAGS_DEFAULT (TRILOGY_FLAGS_CAST)
 
 struct rb_trilogy_cast_options {
@@ -16,6 +17,7 @@ struct rb_trilogy_cast_options {
     bool cast_booleans;
     bool database_local_time;
     bool flatten_rows;
+    bool cast_decimals_to_bigdecimals;
 };
 
 struct column_info {
@@ -23,9 +25,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.4.0"
 end