dict-sql: Use sql_statement_set_timestamp() instead of adding it to query

diff --git a/src/lib-dict/dict-sql-private.h b/src/lib-dict/dict-sql-private.h
index 2891f76ee7cb84e295164865f5880131807dd62a..8c6ea392dc68d8aaaa788961107f3ccc9f1359f4 100644 (file)
--- a/src/lib-dict/dict-sql-private.h
+++ b/src/lib-dict/dict-sql-private.h
@@ -10,7 +10,6 @@ struct sql_dict {
        const struct dict_sql_settings *set;
 
        bool has_on_duplicate_key:1;
-       bool has_using_timestamp:1;
 };
 
 #endif

diff --git a/src/lib-dict/dict-sql.c b/src/lib-dict/dict-sql.c
index e468bc7422c5644a23f434aedb6ff711c3aa2985..5adb6500ed8be8fe9f98948d005a4ed9cb66ee4e 100644 (file)
--- a/src/lib-dict/dict-sql.c
+++ b/src/lib-dict/dict-sql.c
@@ -93,8 +93,6 @@ sql_dict_init(struct dict *driver, const char *uri,
 
        /* currently pgsql and sqlite don't support "ON DUPLICATE KEY" */
        dict->has_on_duplicate_key = strcmp(driver->name, "mysql") == 0;
-       /* only Cassandra CQL supports "USING TIMESTAMP" */
-       dict->has_using_timestamp = strcmp(driver->name, "cassandra") == 0;
 
        dict->db = sql_db_cache_new(dict_sql_db_cache, driver->name,
                                    dict->set->connect);
@@ -912,19 +910,16 @@ static void sql_dict_transaction_rollback(struct dict_transaction_context *_ctx)
        sql_dict_transaction_free(ctx);
 }
 
-static void
-sql_dict_transaction_add_timestamp(struct sql_dict_transaction_context *ctx,
-                                  string_t *query)
+static struct sql_statement *
+sql_dict_transaction_stmt_init(struct sql_dict_transaction_context *ctx,
+                              const char *query)
 {
        struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;
-       unsigned long long timestamp_usecs;
-
-       if (ctx->ctx.timestamp.tv_sec == 0 || !dict->has_using_timestamp)
-               return;
+       struct sql_statement *stmt = sql_statement_init(dict->db, query);
 
-       timestamp_usecs = ctx->ctx.timestamp.tv_sec * 1000000ULL +
-               ctx->ctx.timestamp.tv_nsec / 1000;
-       str_printfa(query, " USING TIMESTAMP %llu", timestamp_usecs);
+       if (ctx->ctx.timestamp.tv_sec != 0)
+               sql_statement_set_timestamp(stmt, &ctx->ctx.timestamp);
+       return stmt;
 }
 
 struct dict_sql_build_query_field {
@@ -940,8 +935,7 @@ struct dict_sql_build_query {
        char key1;
 };
 
-static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,
-                             const struct dict_sql_build_query *build,
+static int sql_dict_set_query(const struct dict_sql_build_query *build,
                              const char **query_r, const char **error_r)
 {
        struct sql_dict *dict = build->dict;
@@ -993,7 +987,6 @@ static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,
 
        str_append_str(prefix, suffix);
        str_append_c(prefix, ')');
-       sql_dict_transaction_add_timestamp(ctx, prefix);
        if (!dict->has_on_duplicate_key) {
                *query_r = str_c(prefix);
                return 0;
@@ -1020,8 +1013,7 @@ static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,
 }
 
 static int
-sql_dict_update_query(struct sql_dict_transaction_context *ctx,
-                     const struct dict_sql_build_query *build,
+sql_dict_update_query(const struct dict_sql_build_query *build,
                      const char **query_r, const char **error_r)
 {
        struct sql_dict *dict = build->dict;
@@ -1033,9 +1025,7 @@ sql_dict_update_query(struct sql_dict_transaction_context *ctx,
        i_assert(field_count > 0);
 
        query = t_str_new(64);
-       str_printfa(query, "UPDATE %s", fields[0].map->table);
-       sql_dict_transaction_add_timestamp(ctx, query);
-       str_append(query, " SET ");
+       str_printfa(query, "UPDATE %s SET ", fields[0].map->table);
        for (i = 0; i < field_count; i++) {
                const char *first_value_field =
                        t_strcut(fields[i].map->value_field, ',');
@@ -1087,12 +1077,12 @@ static void sql_dict_set_real(struct dict_transaction_context *_ctx,
        build.extra_values = &values;
        build.key1 = key[0];
 
-       if (sql_dict_set_query(ctx, &build, &query, &error) < 0) {
+       if (sql_dict_set_query(&build, &query, &error) < 0) {
                ctx->error = i_strdup_printf("dict-sql: Failed to set %s=%s: %s",
                                             key, value, error);
        } else {
                struct sql_statement *stmt =
-                       sql_statement_init(dict->db, query);
+                       sql_dict_transaction_stmt_init(ctx, query);
                sql_update_stmt(ctx->sql_ctx, &stmt);
        }
 }
@@ -1123,14 +1113,13 @@ static void sql_dict_unset(struct dict_transaction_context *_ctx,
        }
 
        str_printfa(query, "DELETE FROM %s", map->table);
-       sql_dict_transaction_add_timestamp(ctx, query);
        if (sql_dict_where_build(dict, map, &values, key[0],
                                 SQL_DICT_RECURSE_NONE, query, &error) < 0) {
                ctx->error = i_strdup_printf(
                        "dict-sql: Failed to delete %s: %s", key, error);
        } else {
                struct sql_statement *stmt =
-                       sql_statement_init(dict->db, str_c(query));
+                       sql_dict_transaction_stmt_init(ctx, str_c(query));
                sql_update_stmt(ctx->sql_ctx, &stmt);
        }
 }
@@ -1177,12 +1166,12 @@ static void sql_dict_atomic_inc_real(struct sql_dict_transaction_context *ctx,
        build.extra_values = &values;
        build.key1 = key[0];
 
-       if (sql_dict_update_query(ctx, &build, &query, &error) < 0) {
+       if (sql_dict_update_query(&build, &query, &error) < 0) {
                ctx->error = i_strdup_printf(
                        "dict-sql: Failed to increase %s: %s", key, error);
        } else {
                struct sql_statement *stmt =
-                       sql_statement_init(dict->db, query);
+                       sql_dict_transaction_stmt_init(ctx, query);
                sql_update_stmt_get_rows(ctx->sql_ctx, &stmt,
                                         sql_dict_next_inc_row(ctx));
        }
@@ -1289,12 +1278,12 @@ static void sql_dict_set(struct dict_transaction_context *_ctx,
                field->map = map;
                field->value = value;
 
-               if (sql_dict_set_query(ctx, &build, &query, &error) < 0) {
+               if (sql_dict_set_query(&build, &query, &error) < 0) {
                        ctx->error = i_strdup_printf(
                                "dict-sql: Failed to set %s: %s", key, error);
                } else {
                        struct sql_statement *stmt =
-                               sql_statement_init(dict->db, query);
+                               sql_dict_transaction_stmt_init(ctx, query);
                        sql_update_stmt(ctx->sql_ctx, &stmt);
                }
                i_free_and_null(ctx->prev_set_value);
@@ -1353,12 +1342,12 @@ static void sql_dict_atomic_inc(struct dict_transaction_context *_ctx,
                field->map = map;
                field->value = t_strdup_printf("%lld", diff);
 
-               if (sql_dict_update_query(ctx, &build, &query, &error) < 0) {
+               if (sql_dict_update_query(&build, &query, &error) < 0) {
                        ctx->error = i_strdup_printf(
                                "dict-sql: Failed to increase %s: %s", key, error);
                } else {
                        struct sql_statement *stmt =
-                               sql_statement_init(dict->db, query);
+                               sql_dict_transaction_stmt_init(ctx, query);
                        sql_update_stmt_get_rows(ctx->sql_ctx, &stmt,
                                                 sql_dict_next_inc_row(ctx));
                }