trilogy 2.4.1 → 2.5.0

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

@@ -39,6 +39,8 @@ int trilogy_builder_init(trilogy_builder_t *builder, trilogy_buffer_t *buff, uin
     builder->buffer->len = 0;
 
     builder->seq = seq;
+    builder->packet_length = 0;
+    builder->packet_max_length = SIZE_MAX;
 
     return write_header(builder);
 }
@@ -60,10 +62,15 @@ void trilogy_builder_finalize(trilogy_builder_t *builder)
 
 int trilogy_builder_write_uint8(trilogy_builder_t *builder, uint8_t val)
 {
+    if (builder->packet_length >= builder->packet_max_length - 1) {
+        return TRILOGY_MAX_PACKET_EXCEEDED;
+    }
+
     CHECKED(trilogy_buffer_expand(builder->buffer, 1));
 
     builder->buffer->buff[builder->buffer->len++] = val;
     builder->fragment_length++;
+    builder->packet_length++;
 
     if (builder->fragment_length == TRILOGY_MAX_PACKET_LEN) {
         CHECKED(write_continuation_header(builder));
@@ -113,6 +120,44 @@ int trilogy_builder_write_uint64(trilogy_builder_t *builder, uint64_t val)
     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) {
@@ -137,6 +182,10 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
     size_t fragment_remaining = TRILOGY_MAX_PACKET_LEN - builder->fragment_length;
 
+    if (builder->packet_length >= builder->packet_max_length - len) {
+        return TRILOGY_MAX_PACKET_EXCEEDED;
+    }
+
     // if this buffer write is not going to straddle a fragment boundary:
     if (len < fragment_remaining) {
         CHECKED(trilogy_buffer_expand(builder->buffer, len));
@@ -145,6 +194,7 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
         builder->buffer->len += len;
         builder->fragment_length += len;
+        builder->packet_length += len;
 
         return TRILOGY_OK;
     }
@@ -157,6 +207,7 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
         builder->buffer->len += fragment_remaining;
         builder->fragment_length += fragment_remaining;
+        builder->packet_length += fragment_remaining;
 
         ptr += fragment_remaining;
         len -= fragment_remaining;
@@ -172,6 +223,7 @@ int trilogy_builder_write_buffer(trilogy_builder_t *builder, const void *data, s
 
         builder->buffer->len += len;
         builder->fragment_length += len;
+        builder->packet_length += len;
     }
 
     return TRILOGY_OK;
@@ -195,4 +247,15 @@ int trilogy_builder_write_string(trilogy_builder_t *builder, const char *data)
     return TRILOGY_OK;
 }
 
+int trilogy_builder_set_max_packet_length(trilogy_builder_t *builder, size_t max_length)
+{
+    if (builder->packet_length > max_length) {
+        return TRILOGY_MAX_PACKET_EXCEEDED;
+    }
+
+    builder->packet_max_length = max_length;
+
+    return TRILOGY_OK;
+}
+
 #undef CHECKED

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

@@ -1,4 +1,3 @@
-#include <errno.h>
 #include <fcntl.h>
 
 #include "trilogy/client.h"
@@ -60,6 +59,10 @@ static int begin_command_phase(trilogy_builder_t *builder, trilogy_conn_t *conn,
         return rc;
     }
 
+    if (conn->socket->opts.max_allowed_packet > 0) {
+        trilogy_builder_set_max_packet_length(builder, conn->socket->opts.max_allowed_packet);
+    }
+
     conn->packet_parser.sequence_number = seq + 1;
 
     return 0;
@@ -72,11 +75,6 @@ static int read_packet(trilogy_conn_t *conn)
 
         if (nread < 0) {
             int rc = (int)nread;
-            if (rc == TRILOGY_SYSERR) {
-                if (errno == EINTR || errno == EAGAIN) {
-                    return TRILOGY_AGAIN;
-                }
-            }
             return rc;
         }
 
@@ -158,16 +156,6 @@ int trilogy_flush_writes(trilogy_conn_t *conn)
 
     if (bytes < 0) {
         int rc = (int)bytes;
-        if (rc == TRILOGY_SYSERR) {
-            if (errno == EINTR || errno == EAGAIN) {
-                return TRILOGY_AGAIN;
-            }
-
-            if (errno == EPIPE) {
-                return TRILOGY_CLOSED_CONNECTION;
-            }
-        }
-
         return rc;
     }
 
@@ -766,11 +754,186 @@ void trilogy_free(trilogy_conn_t *conn)
 
 int trilogy_discard(trilogy_conn_t *conn)
 {
-    int rc = trilogy_sock_discard(conn->socket);
+    int rc = trilogy_sock_shutdown(conn->socket);
     if (rc == TRILOGY_OK) {
         trilogy_free(conn);
     }
     return rc;
 }
 
+int trilogy_stmt_prepare_send(trilogy_conn_t *conn, const char *stmt, size_t stmt_len)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_stmt_prepare_packet(&builder, stmt, stmt_len);
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
+int trilogy_stmt_prepare_recv(trilogy_conn_t *conn, trilogy_stmt_t *stmt_out)
+{
+    int err = read_packet(conn);
+
+    if (err < 0) {
+        return err;
+    }
+
+    switch (current_packet_type(conn)) {
+    case TRILOGY_PACKET_OK: {
+        err = trilogy_parse_stmt_ok_packet(conn->packet_buffer.buff, conn->packet_buffer.len, stmt_out);
+
+        if (err < 0) {
+            return err;
+        }
+
+        conn->warning_count = stmt_out->warning_count;
+
+        return TRILOGY_OK;
+    }
+
+    case TRILOGY_PACKET_ERR:
+        return read_err_packet(conn);
+
+    default:
+        return TRILOGY_UNEXPECTED_PACKET;
+    }
+}
+
+int trilogy_stmt_execute_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt, uint8_t flags, trilogy_binary_value_t *binds)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_stmt_execute_packet(&builder, stmt->id, flags, binds, stmt->parameter_count);
+
+    if (err < 0) {
+        return err;
+    }
+
+    conn->packet_parser.sequence_number = builder.seq;
+
+    return begin_write(conn);
+}
+
+int trilogy_stmt_execute_recv(trilogy_conn_t *conn, uint64_t *column_count_out)
+{
+    int err = read_packet(conn);
+
+    if (err < 0) {
+        return err;
+    }
+
+    switch (current_packet_type(conn)) {
+    case TRILOGY_PACKET_OK:
+        return read_ok_packet(conn);
+
+    case TRILOGY_PACKET_ERR:
+        return read_err_packet(conn);
+
+    default: {
+        trilogy_result_packet_t result_packet;
+        err = trilogy_parse_result_packet(conn->packet_buffer.buff, conn->packet_buffer.len, &result_packet);
+
+        if (err < 0) {
+            return err;
+        }
+
+        conn->column_count = result_packet.column_count;
+        *column_count_out = result_packet.column_count;
+
+        return TRILOGY_OK;
+    }
+    }
+}
+
+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_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_stmt_bind_data_packet(&builder, stmt->id, param_num, data, data_len);
+
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
+int trilogy_stmt_read_row(trilogy_conn_t *conn, trilogy_stmt_t *stmt, trilogy_column_packet_t *columns,
+                          trilogy_binary_value_t *values_out)
+{
+    int err = read_packet(conn);
+
+    if (err < 0) {
+        return err;
+    }
+
+    if (conn->capabilities & TRILOGY_CAPABILITIES_DEPRECATE_EOF && current_packet_type(conn) == TRILOGY_PACKET_EOF) {
+        if ((err = read_ok_packet(conn)) != TRILOGY_OK) {
+            return err;
+        }
+
+        return TRILOGY_EOF;
+    } else if (current_packet_type(conn) == TRILOGY_PACKET_EOF && conn->packet_buffer.len < 9) {
+        return read_eof_packet(conn);
+    } else if (current_packet_type(conn) == TRILOGY_PACKET_ERR) {
+        return read_err_packet(conn);
+    } else {
+        return trilogy_parse_stmt_row_packet(conn->packet_buffer.buff, conn->packet_buffer.len, columns,
+                                             stmt->column_count, values_out);
+    }
+}
+
+int trilogy_stmt_reset_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_stmt_reset_packet(&builder, stmt->id);
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
+int trilogy_stmt_reset_recv(trilogy_conn_t *conn) {
+    return read_generic_response(conn);
+}
+
+int trilogy_stmt_close_send(trilogy_conn_t *conn, trilogy_stmt_t *stmt)
+{
+    trilogy_builder_t builder;
+    int err = begin_command_phase(&builder, conn, 0);
+    if (err < 0) {
+        return err;
+    }
+
+    err = trilogy_build_stmt_close_packet(&builder, stmt->id);
+
+    if (err < 0) {
+        return err;
+    }
+
+    return begin_write(conn);
+}
+
 #undef CHECKED