trilogy_w_prepared_statements 2.2.0

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

@@ -0,0 +1,358 @@
+#include <errno.h>
+#include <poll.h>
+
+#include "trilogy/blocking.h"
+#include "trilogy/client.h"
+#include "trilogy/error.h"
+
+#define CHECKED(expr)                                                                                                  \
+    if ((rc = (expr)) < 0) {                                                                                           \
+        return rc;                                                                                                     \
+    }
+
+static int flush_full(trilogy_conn_t *conn)
+{
+    int rc;
+
+    while (1) {
+        CHECKED(trilogy_sock_wait_write(conn->socket));
+
+        rc = trilogy_flush_writes(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+    }
+}
+
+static int trilogy_connect_auth_switch(trilogy_conn_t *conn, trilogy_handshake_t *handshake)
+{
+    int rc = trilogy_auth_switch_send(conn, handshake);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_auth_recv(conn, handshake);
+
+        if (rc != TRILOGY_AGAIN) {
+            break;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+    return rc;
+}
+
+static int trilogy_connect_handshake(trilogy_conn_t *conn)
+{
+    trilogy_handshake_t handshake;
+    int rc;
+
+    while (1) {
+        rc = trilogy_connect_recv(conn, &handshake);
+
+        if (rc == TRILOGY_OK) {
+            break;
+        }
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+
+    rc = trilogy_auth_send(conn, &handshake);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_auth_recv(conn, &handshake);
+
+        if (rc != TRILOGY_AGAIN) {
+            break;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+
+    if (rc == TRILOGY_AUTH_SWITCH) {
+        return trilogy_connect_auth_switch(conn, &handshake);
+    }
+    return rc;
+}
+
+int trilogy_connect(trilogy_conn_t *conn, const trilogy_sockopt_t *opts)
+{
+    int rc = trilogy_connect_send(conn, opts);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return trilogy_connect_handshake(conn);
+}
+
+int trilogy_connect_sock(trilogy_conn_t *conn, trilogy_sock_t *sock)
+{
+    int rc = trilogy_connect_send_socket(conn, sock);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    return trilogy_connect_handshake(conn);
+}
+
+int trilogy_change_db(trilogy_conn_t *conn, const char *name, size_t name_len)
+{
+    int rc = trilogy_change_db_send(conn, name, name_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_change_db_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);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_ping_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_query(trilogy_conn_t *conn, const char *query, size_t query_len, uint64_t *column_count_out)
+{
+    int rc = trilogy_query_send(conn, query, query_len);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_query_recv(conn, column_count_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_read_full_column(trilogy_conn_t *conn, trilogy_column_t *column_out)
+{
+    int rc;
+
+    while (1) {
+        rc = trilogy_read_column(conn, column_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_read_full_row(trilogy_conn_t *conn, trilogy_value_t *values_out)
+{
+    int rc;
+
+    while (1) {
+        rc = trilogy_read_row(conn, values_out);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+int trilogy_close(trilogy_conn_t *conn)
+{
+    int rc = trilogy_close_send(conn);
+
+    if (rc == TRILOGY_AGAIN) {
+        rc = flush_full(conn);
+    }
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    while (1) {
+        rc = trilogy_close_recv(conn);
+
+        if (rc != TRILOGY_AGAIN) {
+            return rc;
+        }
+
+        CHECKED(trilogy_sock_wait_read(conn->socket));
+    }
+}
+
+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

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

@@ -0,0 +1,60 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "trilogy/buffer.h"
+#include "trilogy/error.h"
+
+int trilogy_buffer_init(trilogy_buffer_t *buffer, size_t initial_capacity)
+{
+    buffer->len = 0;
+    buffer->cap = initial_capacity;
+    buffer->buff = malloc(initial_capacity);
+
+    if (buffer->buff == NULL) {
+        return TRILOGY_SYSERR;
+    }
+
+    return TRILOGY_OK;
+}
+
+#define EXPAND_MULTIPLIER 2
+
+int trilogy_buffer_expand(trilogy_buffer_t *buffer, size_t needed)
+{
+    // expand buffer if necessary
+    if (buffer->len + needed > buffer->cap) {
+        size_t new_cap = buffer->cap;
+
+        while (buffer->len + needed > new_cap) {
+            // would this next step cause an overflow?
+            if (new_cap > SIZE_MAX / EXPAND_MULTIPLIER)
+                return TRILOGY_TYPE_OVERFLOW;
+
+            new_cap *= EXPAND_MULTIPLIER;
+        }
+
+        uint8_t *new_buff = realloc(buffer->buff, new_cap);
+        if (new_buff == NULL)
+            return TRILOGY_SYSERR;
+
+        buffer->buff = new_buff;
+        buffer->cap = new_cap;
+    }
+
+    return TRILOGY_OK;
+}
+
+int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c)
+{
+    int rc = trilogy_buffer_expand(buffer, 1);
+
+    if (rc) {
+        return rc;
+    }
+
+    buffer->buff[buffer->len++] = c;
+
+    return TRILOGY_OK;
+}
+
+void trilogy_buffer_free(trilogy_buffer_t *buffer) { free(buffer->buff); }

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

@@ -0,0 +1,236 @@
+#include "trilogy/builder.h"
+#include "trilogy/error.h"
+#include "trilogy/packet_parser.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int write_header(trilogy_builder_t *builder)
+{
+    int rc = trilogy_buffer_expand(builder->buffer, 4);
+
+    if (rc < 0) {
+        return rc;
+    }
+
+    builder->header_offset = builder->buffer->len;
+    builder->fragment_length = 0;
+
+    builder->buffer->buff[builder->buffer->len++] = 0;
+    builder->buffer->buff[builder->buffer->len++] = 0;
+    builder->buffer->buff[builder->buffer->len++] = 0;
+    builder->buffer->buff[builder->buffer->len++] = builder->seq++;
+
+    return TRILOGY_OK;
+}
+
+static int write_continuation_header(trilogy_builder_t *builder)
+{
+    builder->buffer->buff[builder->header_offset] = 0xff;
+    builder->buffer->buff[builder->header_offset + 1] = 0xff;
+    builder->buffer->buff[builder->header_offset + 2] = 0xff;
+
+    return write_header(builder);
+}
+
+int trilogy_builder_init(trilogy_builder_t *builder, trilogy_buffer_t *buff, uint8_t seq)
+{
+    builder->buffer = buff;
+    builder->buffer->len = 0;
+
+    builder->seq = seq;
+
+    return write_header(builder);
+}
+
+void trilogy_builder_finalize(trilogy_builder_t *builder)
+{
+    builder->buffer->buff[builder->header_offset + 0] = (builder->fragment_length >> 0) & 0xff;
+    builder->buffer->buff[builder->header_offset + 1] = (builder->fragment_length >> 8) & 0xff;
+    builder->buffer->buff[builder->header_offset + 2] = (builder->fragment_length >> 16) & 0xff;
+}
+
+#define CHECKED(expr)                                                                                                  \
+    {                                                                                                                  \
+        int rc = (expr);                                                                                               \
+        if (rc) {                                                                                                      \
+            return rc;                                                                                                 \
+        }                                                                                                              \
+    }
+
+int trilogy_builder_write_uint8(trilogy_builder_t *builder, uint8_t val)
+{
+    CHECKED(trilogy_buffer_expand(builder->buffer, 1));
+
+    builder->buffer->buff[builder->buffer->len++] = val;
+    builder->fragment_length++;
+
+    if (builder->fragment_length == TRILOGY_MAX_PACKET_LEN) {
+        CHECKED(write_continuation_header(builder));
+    }
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_uint16(trilogy_builder_t *builder, uint16_t val)
+{
+    CHECKED(trilogy_builder_write_uint8(builder, val & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 8) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_uint24(trilogy_builder_t *builder, uint32_t val)
+{
+    CHECKED(trilogy_builder_write_uint8(builder, val & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 8) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 16) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_uint32(trilogy_builder_t *builder, uint32_t val)
+{
+    CHECKED(trilogy_builder_write_uint8(builder, val & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 8) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 16) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 24) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_uint64(trilogy_builder_t *builder, uint64_t val)
+{
+    CHECKED(trilogy_builder_write_uint8(builder, val & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 8) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 16) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 24) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 32) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 40) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 48) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (val >> 56) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_float(trilogy_builder_t *builder, float val)
+{
+    union {
+        float f;
+        uint32_t u;
+    } float_val;
+
+    float_val.f = val;
+
+    CHECKED(trilogy_builder_write_uint8(builder, float_val.u & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (float_val.u >> 8) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (float_val.u >> 16) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (float_val.u >> 24) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_double(trilogy_builder_t *builder, double val)
+{
+    union {
+        double d;
+        uint64_t u;
+    } double_val;
+
+    double_val.d = val;
+
+    CHECKED(trilogy_builder_write_uint8(builder, double_val.u & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 8) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 16) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 24) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 32) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 40) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 48) & 0xff));
+    CHECKED(trilogy_builder_write_uint8(builder, (double_val.u >> 56) & 0xff));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_lenenc(trilogy_builder_t *builder, uint64_t val)
+{
+    if (val < 251) {
+        CHECKED(trilogy_builder_write_uint8(builder, (uint8_t)val));
+    } else if (val <= 0xffff) {
+        CHECKED(trilogy_builder_write_uint8(builder, 0xfc));
+        CHECKED(trilogy_builder_write_uint16(builder, (uint16_t)val));
+    } else if (val <= 0xffffff) {
+        CHECKED(trilogy_builder_write_uint8(builder, 0xfd));
+        CHECKED(trilogy_builder_write_uint24(builder, (uint32_t)val));
+    } else { // val <= 0xffffffffffffffff
+        CHECKED(trilogy_builder_write_uint8(builder, 0xfe));
+        CHECKED(trilogy_builder_write_uint64(builder, val));
+    }
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, size_t len)
+{
+    const char *ptr = data;
+
+    size_t fragment_remaining = TRILOGY_MAX_PACKET_LEN - builder->fragment_length;
+
+    // if this buffer write is not going to straddle a fragment boundary:
+    if (len < fragment_remaining) {
+        CHECKED(trilogy_buffer_expand(builder->buffer, len));
+
+        memcpy(builder->buffer->buff + builder->buffer->len, ptr, len);
+
+        builder->buffer->len += len;
+        builder->fragment_length += len;
+
+        return TRILOGY_OK;
+    }
+
+    // otherwise we're going to need to do this in multiple
+    while (len >= fragment_remaining) {
+        CHECKED(trilogy_buffer_expand(builder->buffer, fragment_remaining));
+
+        memcpy(builder->buffer->buff + builder->buffer->len, ptr, fragment_remaining);
+
+        builder->buffer->len += fragment_remaining;
+        builder->fragment_length += fragment_remaining;
+
+        ptr += fragment_remaining;
+        len -= fragment_remaining;
+
+        CHECKED(write_continuation_header(builder));
+        fragment_remaining = TRILOGY_MAX_PACKET_LEN;
+    }
+
+    if (len) {
+        CHECKED(trilogy_buffer_expand(builder->buffer, len));
+
+        memcpy(builder->buffer->buff + builder->buffer->len, ptr, len);
+
+        builder->buffer->len += len;
+        builder->fragment_length += len;
+    }
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_lenenc_buffer(trilogy_builder_t *builder, const void *data, size_t len)
+{
+    CHECKED(trilogy_builder_write_lenenc(builder, len));
+
+    CHECKED(trilogy_builder_write_buffer(builder, data, len));
+
+    return TRILOGY_OK;
+}
+
+int trilogy_builder_write_string(trilogy_builder_t *builder, const char *data)
+{
+    CHECKED(trilogy_builder_write_buffer(builder, (void *)data, strlen(data)));
+
+    CHECKED(trilogy_builder_write_uint8(builder, 0));
+
+    return TRILOGY_OK;
+}
+
+#undef CHECKED