c25356d5978632df6203437e1953bcb29e0c736fTimo Sirainen

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen#include "lib.h"

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen#include "array.h"

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen#include "istream.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "hex-binary.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "hash.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "str.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "sql-api-private.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "sql-db-cache.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "dict-private.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "dict-sql-settings.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "dict-sql.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include "dict-sql-private.h"

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include <unistd.h>

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#include <fcntl.h>

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen#define DICT_SQL_MAX_UNUSED_CONNECTIONS 10

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainenenum sql_recurse_type {

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen SQL_DICT_RECURSE_NONE,

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen SQL_DICT_RECURSE_ONE,

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen SQL_DICT_RECURSE_FULL

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen};

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainenstruct sql_dict_param {

bf87a5247ca33660ab8f20c12556ad16d7159395Timo Sirainen enum dict_sql_type value_type;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen const char *value_str;

6cc0546c058f3e6253c6f99727b28dd602712974Timo Sirainen int64_t value_int64;

6cc0546c058f3e6253c6f99727b28dd602712974Timo Sirainen const void *value_binary;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen size_t value_binary_size;

6cc0546c058f3e6253c6f99727b28dd602712974Timo Sirainen};

0ce5f96804e81cb0f857e7df32c0272f1eed9377Timo SirainenARRAY_DEFINE_TYPE(sql_dict_param, struct sql_dict_param);

0ce5f96804e81cb0f857e7df32c0272f1eed9377Timo Sirainen

0ce5f96804e81cb0f857e7df32c0272f1eed9377Timo Sirainenstruct sql_dict_iterate_context {

0dffa25d211be541ee3c953b23566a1a990789dfTimo Sirainen struct dict_iterate_context ctx;

8b2cf1c1bd8ddcea0525b62fd35ba76e136828a1Timo Sirainen pool_t pool;

0dffa25d211be541ee3c953b23566a1a990789dfTimo Sirainen

0dffa25d211be541ee3c953b23566a1a990789dfTimo Sirainen enum dict_iterate_flags flags;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen const char **paths;

252db51b6c0a605163326b3ea5d09e9936ca3b29Timo Sirainen

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen struct sql_result *result;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen string_t *key;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen const struct dict_sql_map *map;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen size_t key_prefix_len, pattern_prefix_len;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen unsigned int path_idx, sql_fields_start_idx, next_map_idx;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen bool synchronous_result;

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen bool iter_query_sent;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen bool allow_null_map; /* allow next map to be NULL */

9b7eeffb5752b500ac62ba1fd01c4a8c4ada14e9Timo Sirainen const char *error;

9b7eeffb5752b500ac62ba1fd01c4a8c4ada14e9Timo Sirainen};

e93184a9055c2530366dfe617e07199603c399ddMartti Rannanjärvi

43834f87bf431198f986e86052a4f6e558fdb07dTimo Sirainenstruct sql_dict_inc_row {

43834f87bf431198f986e86052a4f6e558fdb07dTimo Sirainen struct sql_dict_inc_row *prev;

93fa87cf1a96c4f279ec4f5c311820313ba12c34Timo Sirainen unsigned int rows;

93fa87cf1a96c4f279ec4f5c311820313ba12c34Timo Sirainen};

93fa87cf1a96c4f279ec4f5c311820313ba12c34Timo Sirainen

93fa87cf1a96c4f279ec4f5c311820313ba12c34Timo Sirainenstruct sql_dict_transaction_context {

43834f87bf431198f986e86052a4f6e558fdb07dTimo Sirainen struct dict_transaction_context ctx;

b565a6a7a66fb9f224d00c06a950e3c1c585c18eTimo Sirainen

b565a6a7a66fb9f224d00c06a950e3c1c585c18eTimo Sirainen struct sql_transaction_context *sql_ctx;

0c1835a90dd1dcedaeaedd1cd91672299cbeb5beTimo Sirainen

0c1835a90dd1dcedaeaedd1cd91672299cbeb5beTimo Sirainen const struct dict_sql_map *prev_inc_map;

f4735bf7ec2019fdc730e9ebdb39e5a4ea580405Timo Sirainen char *prev_inc_key;

f4735bf7ec2019fdc730e9ebdb39e5a4ea580405Timo Sirainen long long prev_inc_diff;

f4735bf7ec2019fdc730e9ebdb39e5a4ea580405Timo Sirainen pool_t inc_row_pool;

981139bb2e446bb2050c1158614725f8413fd709Timo Sirainen struct sql_dict_inc_row *inc_row;

981139bb2e446bb2050c1158614725f8413fd709Timo Sirainen

981139bb2e446bb2050c1158614725f8413fd709Timo Sirainen const struct dict_sql_map *prev_set_map;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen char *prev_set_key;

8cb72c59d5ea4e9e5f638d7ec840bb853f5a188eTimo Sirainen char *prev_set_value;

8cb72c59d5ea4e9e5f638d7ec840bb853f5a188eTimo Sirainen

8cb72c59d5ea4e9e5f638d7ec840bb853f5a188eTimo Sirainen dict_transaction_commit_callback_t *async_callback;

8cb72c59d5ea4e9e5f638d7ec840bb853f5a188eTimo Sirainen void *async_context;

8cb72c59d5ea4e9e5f638d7ec840bb853f5a188eTimo Sirainen

8b247780e911909a9fdc47f69ce6d1478902ad98Timo Sirainen char *error;

8b247780e911909a9fdc47f69ce6d1478902ad98Timo Sirainen};

f988b93c2ef773987bcdcbfb4cca39b955e3a392Timo Sirainen

862ec874f9373e3e499e237d3b9f71fdf1413feeTimo Sirainenstatic struct sql_db_cache *dict_sql_db_cache;

8b247780e911909a9fdc47f69ce6d1478902ad98Timo Sirainen

e2ce8d4a6ac5d82a906178148453e7613fab9ba0Timo Sirainenstatic void sql_dict_prev_inc_flush(struct sql_dict_transaction_context *ctx);

cd56a23e21f1df3f79648cf07e2f4385e2fadebbTimo Sirainenstatic void sql_dict_prev_set_flush(struct sql_dict_transaction_context *ctx);

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainenstatic int

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainensql_dict_init(struct dict *driver, const char *uri,

d5cebe7f98e63d4e2822863ef2faa4971e8b3a5dTimo Sirainen const struct dict_settings *set,

d5cebe7f98e63d4e2822863ef2faa4971e8b3a5dTimo Sirainen struct dict **dict_r, const char **error_r)

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen{

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen struct sql_dict *dict;

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen pool_t pool;

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen pool = pool_alloconly_create("sql dict", 2048);

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen dict = p_new(pool, struct sql_dict, 1);

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen dict->pool = pool;

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen dict->dict = *driver;

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen dict->username = p_strdup(pool, set->username);

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen dict->set = dict_sql_settings_read(uri, error_r);

eb98a038ca8b0ef33d1d11794803ce09547496faTimo Sirainen if (dict->set == NULL) {

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen pool_unref(&pool);

e2ce8d4a6ac5d82a906178148453e7613fab9ba0Timo Sirainen return -1;

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen }

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen /* currently pgsql and sqlite don't support "ON DUPLICATE KEY" */

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen dict->has_on_duplicate_key = strcmp(driver->name, "mysql") == 0;

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen dict->db = sql_db_cache_new(dict_sql_db_cache, driver->name,

5ec4fc44e8d4e2160f07b1a7f4fce1ccfec3f6c1Timo Sirainen dict->set->connect);

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen if ((sql_get_flags(dict->db) & SQL_DB_FLAG_PREP_STATEMENTS) != 0) {

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen hash_table_create(&dict->prep_stmt_hash, dict->pool,

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen 0, str_hash, strcmp);

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen }

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen *dict_r = &dict->dict;

211ed7806d8715ec2280ffbf5d10f0d6e4f1beb2Timo Sirainen return 0;

a10ed8c47534b4c6b6bf2711ccfe577e720a47b4Timo Sirainen}

59151b71059df1190acd75d8717ed04a7920c862Timo Sirainen

27a44fcfd8d19bffe0f267f20a2b5d3fe7600fddTimo Sirainenstatic void sql_dict_prep_stmt_hash_free(struct sql_dict *dict)

27a44fcfd8d19bffe0f267f20a2b5d3fe7600fddTimo Sirainen{

27a44fcfd8d19bffe0f267f20a2b5d3fe7600fddTimo Sirainen struct hash_iterate_context *iter;

59151b71059df1190acd75d8717ed04a7920c862Timo Sirainen struct sql_prepared_statement *prep_stmt;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen const char *query;

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen

556f95092c3bc850517d5ab2bb502024a55645f1Timo Sirainen if (!hash_table_is_created(dict->prep_stmt_hash))

556f95092c3bc850517d5ab2bb502024a55645f1Timo Sirainen return;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen iter = hash_table_iterate_init(dict->prep_stmt_hash);

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen while (hash_table_iterate(iter, dict->prep_stmt_hash, &query, &prep_stmt))

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen sql_prepared_statement_deinit(&prep_stmt);

b688884f23be2333bea1a8bd4ee849336aebedaaTimo Sirainen hash_table_iterate_deinit(&iter);

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen

23c8c511f98924acfc7048e9dc4ccc982c34e320Timo Sirainen hash_table_destroy(&dict->prep_stmt_hash);

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen}

10ff47d5d6146995e16da00d36eca7d162064a7bTimo Sirainen

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainenstatic void sql_dict_deinit(struct dict *_dict)

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen{

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen struct sql_dict *dict = (struct sql_dict *)_dict;

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen sql_dict_prep_stmt_hash_free(dict);

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen sql_deinit(&dict->db);

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen pool_unref(&dict->pool);

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen}

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainenstatic void sql_dict_wait(struct dict *dict ATTR_UNUSED)

b56679429b82dfea1ceecc40efea50dd8e4e0ac5Timo Sirainen{

5238111c460098d9cc8cc22527026138a278b9a4Timo Sirainen /* FIXME: lib-sql doesn't support this yet */

5238111c460098d9cc8cc22527026138a278b9a4Timo Sirainen}

6ef7e31619edfaa17ed044b45861d106a86191efTimo Sirainen

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainenstatic bool

68a4946b12583b88fa802e52ebee45cd96056772Timo Sirainendict_sql_map_match(const struct dict_sql_map *map, const char *path,

de954ff15b495be13007a8aca2c09fd1d356a283Timo Sirainen ARRAY_TYPE(const_string) *values, size_t *pat_len_r,

de954ff15b495be13007a8aca2c09fd1d356a283Timo Sirainen size_t *path_len_r, bool partial_ok, bool recurse)

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen{

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen const char *path_start = path;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen const char *pat, *field, *p;

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen size_t len;

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen array_clear(values);

2767104d81e97a109f0aa9758792bfa1da325a97Timo Sirainen pat = map->pattern;

0ce5f96804e81cb0f857e7df32c0272f1eed9377Timo Sirainen while (*pat != '\0' && *path != '\0') {

c0435c854a0e7246373b9752d163095cc4fbe985Timo Sirainen if (*pat == '$') {

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen /* variable */

ceb43cc04edb94445fab8f914bc4da6d740403d1Timo Sirainen pat++;

9de176ef7f3d28ff486c2a8805110b84389e4f19Timo Sirainen if (*pat == '\0') {

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen /* pattern ended with this variable,

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen len = strlen(path);

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen if (partial_ok) {

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen /* iterating - the last field never

84717f00ddbf5cd0ebe3f285090d5e97e458e19cTimo Sirainen pat--;

84717f00ddbf5cd0ebe3f285090d5e97e458e19cTimo Sirainen if (path[len-1] == '/') {

84717f00ddbf5cd0ebe3f285090d5e97e458e19cTimo Sirainen field = t_strndup(path, len-1);

84717f00ddbf5cd0ebe3f285090d5e97e458e19cTimo Sirainen array_append(values, &field, 1);

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen } else {

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen array_append(values, &path, 1);

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen }

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen } else {

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen array_append(values, &path, 1);

d6193a892452ae87548f5745dada01f82816765dTimo Sirainen path += len;

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen }

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen *path_len_r = path - path_start;

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen *pat_len_r = pat - map->pattern;

7660a5183e89459d255dc5873894ff08806711d5Timo Sirainen return TRUE;

7660a5183e89459d255dc5873894ff08806711d5Timo Sirainen }

7660a5183e89459d255dc5873894ff08806711d5Timo Sirainen /* pattern matches until the next '/' in path */

7660a5183e89459d255dc5873894ff08806711d5Timo Sirainen p = strchr(path, '/');

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen if (p != NULL) {

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen field = t_strdup_until(path, p);

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen array_append(values, &field, 1);

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen path = p;

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen } else {

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen /* no '/' anymore, but it'll still match a

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen array_append(values, &path, 1);

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen path += strlen(path);

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen pat++;

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen }

03f5c621d06d6b6d77a145196c9633a7aa64dc78Timo Sirainen } else if (*pat == *path) {

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen pat++;

6adf683655750bcb809275cd65dc75fd12214198Timo Sirainen path++;

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen } else {

378e6cb162b355d6f103526505bc00b9a78962e7Timo Sirainen return FALSE;

b90fb7f78aca271243c26074ddd6587cce112a1eTimo Sirainen }

34d5077c37dc6224a2d430a72ae51a3f38e9e4f6Timo Sirainen }

b90fb7f78aca271243c26074ddd6587cce112a1eTimo Sirainen

b90fb7f78aca271243c26074ddd6587cce112a1eTimo Sirainen *path_len_r = path - path_start;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen *pat_len_r = pat - map->pattern;

8cdb3234fe3c77e477c7a0e6934678f58fc54d4dTimo Sirainen

8cdb3234fe3c77e477c7a0e6934678f58fc54d4dTimo Sirainen if (*pat == '\0')

8cdb3234fe3c77e477c7a0e6934678f58fc54d4dTimo Sirainen return *path == '\0';

8cdb3234fe3c77e477c7a0e6934678f58fc54d4dTimo Sirainen else if (!partial_ok)

f8b6c3d6bc9d63665af5e0a3c8b604438e4c3a4eTimo Sirainen return FALSE;

f8b6c3d6bc9d63665af5e0a3c8b604438e4c3a4eTimo Sirainen else {

f8b6c3d6bc9d63665af5e0a3c8b604438e4c3a4eTimo Sirainen /* partial matches must end with '/'. */

f8b6c3d6bc9d63665af5e0a3c8b604438e4c3a4eTimo Sirainen if (pat != map->pattern && pat[-1] != '/')

f8b6c3d6bc9d63665af5e0a3c8b604438e4c3a4eTimo Sirainen return FALSE;

71da447014454c84828d9dface77219875554d7dTimo Sirainen /* if we're not recursing, there should be only one $variable

8aa8399893c66b40e2790a4568256807a6ec6742Stephan Bosch if (recurse)

71da447014454c84828d9dface77219875554d7dTimo Sirainen return TRUE;

71da447014454c84828d9dface77219875554d7dTimo Sirainen return pat[0] == '$' && strchr(pat, '/') == NULL;

ecc81625167ed96c04c02aa190a1ea5baa65b474Timo Sirainen }

}

static const struct dict_sql_map *

sql_dict_find_map(struct sql_dict *dict, const char *path,

ARRAY_TYPE(const_string) *values)

{

const struct dict_sql_map *maps;

unsigned int i, count;

size_t len;

t_array_init(values, dict->set->max_field_count);

maps = array_get(&dict->set->maps, &count);

for (i = 0; i < count; i++) {

if (dict_sql_map_match(&maps[i], path, values,

&len, &len, FALSE, FALSE))

return &maps[i];

}

return NULL;

}

static void

sql_dict_statement_bind(struct sql_statement *stmt, unsigned int column_idx,

const struct sql_dict_param *param)

{

switch (param->value_type) {

case DICT_SQL_TYPE_STRING:

sql_statement_bind_str(stmt, column_idx, param->value_str);

break;

case DICT_SQL_TYPE_INT:

case DICT_SQL_TYPE_UINT:

sql_statement_bind_int64(stmt, column_idx, param->value_int64);

break;

case DICT_SQL_TYPE_HEXBLOB:

sql_statement_bind_binary(stmt, column_idx, param->value_binary,

param->value_binary_size);

break;

}

}

static struct sql_statement *

sql_dict_statement_init(struct sql_dict *dict, const char *query,

const ARRAY_TYPE(sql_dict_param) *params)

{

struct sql_statement *stmt;

struct sql_prepared_statement *prep_stmt;

const struct sql_dict_param *param;

if (hash_table_is_created(dict->prep_stmt_hash)) {

prep_stmt = hash_table_lookup(dict->prep_stmt_hash, query);

if (prep_stmt == NULL) {

const char *query_dup = p_strdup(dict->pool, query);

prep_stmt = sql_prepared_statement_init(dict->db, query);

hash_table_insert(dict->prep_stmt_hash, query_dup, prep_stmt);

}

stmt = sql_statement_init_prepared(prep_stmt);

} else {

/* Prepared statements not supported by the backend.

stmt = sql_statement_init(dict->db, query);

}

array_foreach(params, param) {

sql_dict_statement_bind(stmt, array_foreach_idx(params, param),

param);

}

return stmt;

}

static int

sql_dict_value_get(const struct dict_sql_map *map,

enum dict_sql_type value_type, const char *field_name,

const char *value, const char *value_suffix,

ARRAY_TYPE(sql_dict_param) *params, const char **error_r)

{

struct sql_dict_param *param;

buffer_t *buf;

param = array_append_space(params);

param->value_type = value_type;

switch (value_type) {

case DICT_SQL_TYPE_STRING:

if (value_suffix[0] != '\0')

value = t_strconcat(value, value_suffix, NULL);

param->value_str = value;

return 0;

case DICT_SQL_TYPE_INT:

if (value_suffix[0] != '\0' ||

str_to_int64(value, &param->value_int64) < 0) {

*error_r = t_strdup_printf(

"%s field's value isn't 64bit signed integer: %s%s (in pattern: %s)",

field_name, value, value_suffix, map->pattern);

return -1;

}

return 0;

case DICT_SQL_TYPE_UINT:

if (value_suffix[0] != '\0' || value[0] == '-' ||

str_to_int64(value, &param->value_int64) < 0) {

*error_r = t_strdup_printf(

"%s field's value isn't 64bit unsigned integer: %s%s (in pattern: %s)",

field_name, value, value_suffix, map->pattern);

return -1;

}

return 0;

case DICT_SQL_TYPE_HEXBLOB:

break;

}

buf = t_buffer_create(strlen(value)/2);

if (hex_to_binary(value, buf) < 0) {

/* we shouldn't get untrusted input here. it's also a bit

*error_r = t_strdup_printf("%s field's value isn't hexblob: %s (in pattern: %s)",

field_name, value, map->pattern);

return -1;

}

str_append(buf, value_suffix);

param->value_binary = buf->data;

param->value_binary_size = buf->used;

return 0;

}

static int

sql_dict_field_get_value(const struct dict_sql_map *map,

const struct dict_sql_field *field,

const char *value, const char *value_suffix,

ARRAY_TYPE(sql_dict_param) *params,

const char **error_r)

{

return sql_dict_value_get(map, field->value_type, field->name,

value, value_suffix, params, error_r);

}

static int

sql_dict_where_build(struct sql_dict *dict, const struct dict_sql_map *map,

const ARRAY_TYPE(const_string) *values_arr,

char key1, enum sql_recurse_type recurse_type,

string_t *query, ARRAY_TYPE(sql_dict_param) *params,

const char **error_r)

{

const struct dict_sql_field *sql_fields;

const char *const *values;

unsigned int i, count, count2, exact_count;

bool priv = key1 == DICT_PATH_PRIVATE[0];

sql_fields = array_get(&map->sql_fields, &count);

values = array_get(values_arr, &count2);

/* if we came here from iteration code there may be less values */

i_assert(count2 <= count);

if (count2 == 0 && !priv) {

/* we want everything */

return 0;

}

str_append(query, " WHERE");

exact_count = count == count2 && recurse_type != SQL_DICT_RECURSE_NONE ?

count2-1 : count2;

for (i = 0; i < exact_count; i++) {

if (i > 0)

str_append(query, " AND");

str_printfa(query, " %s = ?", sql_fields[i].name);

if (sql_dict_field_get_value(map, &sql_fields[i], values[i], "",

params, error_r) < 0)

return -1;

}

switch (recurse_type) {

case SQL_DICT_RECURSE_NONE:

break;

case SQL_DICT_RECURSE_ONE:

if (i > 0)

str_append(query, " AND");

if (i < count2) {

str_printfa(query, " %s LIKE ?", sql_fields[i].name);

if (sql_dict_field_get_value(map, &sql_fields[i],

values[i], "/%",

params, error_r) < 0)

return -1;

str_printfa(query, " AND %s NOT LIKE ?", sql_fields[i].name);

if (sql_dict_field_get_value(map, &sql_fields[i],

values[i], "/%/%",

params, error_r) < 0)

return -1;

} else {

str_printfa(query, " %s LIKE '%%' AND "

"%s NOT LIKE '%%/%%'",

sql_fields[i].name, sql_fields[i].name);

}

break;

case SQL_DICT_RECURSE_FULL:

if (i < count2) {

if (i > 0)

str_append(query, " AND");

str_printfa(query, " %s LIKE ",

sql_fields[i].name);

if (sql_dict_field_get_value(map, &sql_fields[i],

values[i], "/%",

params, error_r) < 0)

return -1;

}

break;

}

if (priv) {

if (count2 > 0)

str_append(query, " AND");

str_printfa(query, " %s = '%s'", map->username_field,

sql_escape_string(dict->db, dict->username));

}

return 0;

}

static int

sql_lookup_get_query(struct sql_dict *dict, const char *key,

const struct dict_sql_map **map_r,

struct sql_statement **stmt_r,

const char **error_r)

{

const struct dict_sql_map *map;

ARRAY_TYPE(const_string) values;

const char *error;

map = *map_r = sql_dict_find_map(dict, key, &values);

if (map == NULL) {

*error_r = t_strdup_printf(

"sql dict lookup: Invalid/unmapped key: %s", key);

return -1;

}

string_t *query = t_str_new(256);

ARRAY_TYPE(sql_dict_param) params;

t_array_init(&params, 4);

str_printfa(query, "SELECT %s FROM %s",

map->value_field, map->table);

if (sql_dict_where_build(dict, map, &values, key[0],

SQL_DICT_RECURSE_NONE, query,

&params, &error) < 0) {

*error_r = t_strdup_printf(

"sql dict lookup: Failed to lookup key %s: %s", key, error);

return -1;

}

*stmt_r = sql_dict_statement_init(dict, str_c(query), &params);

return 0;

}

static const char *

sql_dict_result_unescape(enum dict_sql_type type, pool_t pool,

struct sql_result *result, unsigned int result_idx)

{

const unsigned char *data;

size_t size;

const char *value;

string_t *str;

switch (type) {

case DICT_SQL_TYPE_STRING:

case DICT_SQL_TYPE_INT:

case DICT_SQL_TYPE_UINT:

value = sql_result_get_field_value(result, result_idx);

return value == NULL ? "" : p_strdup(pool, value);

case DICT_SQL_TYPE_HEXBLOB:

break;

}

data = sql_result_get_field_value_binary(result, result_idx, &size);

str = str_new(pool, size*2 + 1);

binary_to_hex_append(str, data, size);

return str_c(str);

}

static const char *

sql_dict_result_unescape_value(const struct dict_sql_map *map, pool_t pool,

struct sql_result *result)

{

return sql_dict_result_unescape(map->value_types[0], pool, result, 0);

}

static const char *const *

sql_dict_result_unescape_values(const struct dict_sql_map *map, pool_t pool,

struct sql_result *result)

{

const char **values;

unsigned int i;

values = p_new(pool, const char *, map->values_count + 1);

for (i = 0; i < map->values_count; i++) {

values[i] = sql_dict_result_unescape(map->value_types[i],

pool, result, i);

}

return values;

}

static const char *

sql_dict_result_unescape_field(const struct dict_sql_map *map, pool_t pool,

struct sql_result *result, unsigned int result_idx,

unsigned int sql_field_idx)

{

const struct dict_sql_field *sql_field;

sql_field = array_idx(&map->sql_fields, sql_field_idx);

return sql_dict_result_unescape(sql_field->value_type, pool,

result, result_idx);

}

static int sql_dict_lookup(struct dict *_dict, pool_t pool, const char *key,

const char **value_r, const char **error_r)

{

struct sql_dict *dict = (struct sql_dict *)_dict;

const struct dict_sql_map *map;

struct sql_statement *stmt;

struct sql_result *result = NULL;

int ret;

*value_r = NULL;

if (sql_lookup_get_query(dict, key, &map, &stmt, error_r) < 0)

return -1;

result = sql_statement_query_s(&stmt);

ret = sql_result_next_row(result);

if (ret < 0) {

*error_r = t_strdup_printf("dict sql lookup failed: %s",

sql_result_get_error(result));

} else if (ret > 0) {

*value_r = sql_dict_result_unescape_value(map, pool, result);

}

sql_result_unref(result);

return ret;

}

struct sql_dict_lookup_context {

const struct dict_sql_map *map;

dict_lookup_callback_t *callback;

void *context;

};

static void

sql_dict_lookup_async_callback(struct sql_result *sql_result,

struct sql_dict_lookup_context *ctx)

{

struct dict_lookup_result result;

i_zero(&result);

result.ret = sql_result_next_row(sql_result);

if (result.ret < 0)

result.error = sql_result_get_error(sql_result);

else if (result.ret > 0) {

result.values = sql_dict_result_unescape_values(ctx->map,

pool_datastack_create(), sql_result);

result.value = result.values[0];

if (result.value == NULL) {

/* NULL value returned. we'll treat this as

result.ret = 0;

}

}

ctx->callback(&result, ctx->context);

i_free(ctx);

}

static void

sql_dict_lookup_async(struct dict *_dict, const char *key,

dict_lookup_callback_t *callback, void *context)

{

struct sql_dict *dict = (struct sql_dict *)_dict;

const struct dict_sql_map *map;

struct sql_dict_lookup_context *ctx;

struct sql_statement *stmt;

const char *error;

if (sql_lookup_get_query(dict, key, &map, &stmt, &error) < 0) {

struct dict_lookup_result result;

i_zero(&result);

result.ret = -1;

result.error = error;

callback(&result, context);

} else {

ctx = i_new(struct sql_dict_lookup_context, 1);

ctx->callback = callback;

ctx->context = context;

ctx->map = map;

sql_statement_query(&stmt, sql_dict_lookup_async_callback, ctx);

}

}

static const struct dict_sql_map *

sql_dict_iterate_find_next_map(struct sql_dict_iterate_context *ctx,

ARRAY_TYPE(const_string) *values)

{

struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;

const struct dict_sql_map *maps;

unsigned int i, count;

size_t pat_len, path_len;

bool recurse = (ctx->flags & DICT_ITERATE_FLAG_RECURSE) != 0;

t_array_init(values, dict->set->max_field_count);

maps = array_get(&dict->set->maps, &count);

for (i = ctx->next_map_idx; i < count; i++) {

if (dict_sql_map_match(&maps[i], ctx->paths[ctx->path_idx],

values, &pat_len, &path_len, TRUE, recurse) &&

(recurse ||

array_count(values)+1 >= array_count(&maps[i].sql_fields))) {

ctx->key_prefix_len = path_len;

ctx->pattern_prefix_len = pat_len;

ctx->next_map_idx = i + 1;

str_truncate(ctx->key, 0);

str_append(ctx->key, ctx->paths[ctx->path_idx]);

return &maps[i];

}

}

/* try the next path, if there is any */

ctx->path_idx++;

if (ctx->paths[ctx->path_idx] != NULL)

return sql_dict_iterate_find_next_map(ctx, values);

return NULL;

}

static int

sql_dict_iterate_build_next_query(struct sql_dict_iterate_context *ctx,

struct sql_statement **stmt_r,

const char **error_r)

{

struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;

const struct dict_sql_map *map;

ARRAY_TYPE(const_string) values;

const struct dict_sql_field *sql_fields;

enum sql_recurse_type recurse_type;

unsigned int i, count;

map = sql_dict_iterate_find_next_map(ctx, &values);

/* NULL map is allowed if we have already done some lookups */

if (map == NULL) {

if (!ctx->allow_null_map) {

*error_r = "Invalid/unmapped path";

return -1;

}

return 0;

}

if (ctx->result != NULL) {

sql_result_unref(ctx->result);

ctx->result = NULL;

}

string_t *query = t_str_new(256);

str_append(query, "SELECT ");

if ((ctx->flags & DICT_ITERATE_FLAG_NO_VALUE) == 0)

str_printfa(query, "%s,", map->value_field);

/* get all missing fields */

sql_fields = array_get(&map->sql_fields, &count);

i = array_count(&values);

if (i == count) {

/* we always want to know the last field since we're

i_assert(i > 0);

i--;

}

ctx->sql_fields_start_idx = i;

for (; i < count; i++)

str_printfa(query, "%s,", sql_fields[i].name);

str_truncate(query, str_len(query)-1);

str_printfa(query, " FROM %s", map->table);

if ((ctx->flags & DICT_ITERATE_FLAG_RECURSE) != 0)

recurse_type = SQL_DICT_RECURSE_FULL;

else if ((ctx->flags & DICT_ITERATE_FLAG_EXACT_KEY) != 0)

recurse_type = SQL_DICT_RECURSE_NONE;

else

recurse_type = SQL_DICT_RECURSE_ONE;

ARRAY_TYPE(sql_dict_param) params;

t_array_init(&params, 4);

if (sql_dict_where_build(dict, map, &values,

ctx->paths[ctx->path_idx][0],

recurse_type, query, &params, error_r) < 0)

return -1;

if ((ctx->flags & DICT_ITERATE_FLAG_SORT_BY_KEY) != 0) {

str_append(query, " ORDER BY ");

for (i = 0; i < count; i++) {

str_printfa(query, "%s", sql_fields[i].name);

if (i < count-1)

str_append_c(query, ',');

}

} else if ((ctx->flags & DICT_ITERATE_FLAG_SORT_BY_VALUE) != 0)

str_printfa(query, " ORDER BY %s", map->value_field);

if (ctx->ctx.max_rows > 0) {

i_assert(ctx->ctx.row_count < ctx->ctx.max_rows);

str_printfa(query, " LIMIT %"PRIu64,

ctx->ctx.max_rows - ctx->ctx.row_count);

}

*stmt_r = sql_dict_statement_init(dict, str_c(query), &params);

ctx->map = map;

return 1;

}

static void sql_dict_iterate_callback(struct sql_result *result,

struct sql_dict_iterate_context *ctx)

{

sql_result_ref(result);

ctx->result = result;

if (ctx->ctx.async_callback != NULL && !ctx->synchronous_result)

ctx->ctx.async_callback(ctx->ctx.async_context);

}

static int sql_dict_iterate_next_query(struct sql_dict_iterate_context *ctx)

{

struct sql_statement *stmt;

const char *error;

unsigned int path_idx = ctx->path_idx;

int ret;

ret = sql_dict_iterate_build_next_query(ctx, &stmt, &error);

if (ret <= 0) {

/* this is expected error */

if (ret == 0)

return ret;

/* failed */

ctx->error = p_strdup_printf(ctx->pool,

"sql dict iterate failed for %s: %s",

ctx->paths[path_idx], error);

return -1;

}

if ((ctx->flags & DICT_ITERATE_FLAG_ASYNC) == 0) {

ctx->result = sql_statement_query_s(&stmt);

} else {

i_assert(ctx->result == NULL);

ctx->synchronous_result = TRUE;

sql_statement_query(&stmt, sql_dict_iterate_callback, ctx);

ctx->synchronous_result = FALSE;

}

return ret;

}

static struct dict_iterate_context *

sql_dict_iterate_init(struct dict *_dict, const char *const *paths,

enum dict_iterate_flags flags)

{

struct sql_dict_iterate_context *ctx;

unsigned int i, path_count;

pool_t pool;

pool = pool_alloconly_create("sql dict iterate", 512);

ctx = p_new(pool, struct sql_dict_iterate_context, 1);

ctx->ctx.dict = _dict;

ctx->pool = pool;

ctx->flags = flags;

for (path_count = 0; paths[path_count] != NULL; path_count++) ;

ctx->paths = p_new(pool, const char *, path_count + 1);

for (i = 0; i < path_count; i++)

ctx->paths[i] = p_strdup(pool, paths[i]);

ctx->key = str_new(pool, 256);

return &ctx->ctx;

}

static bool sql_dict_iterate(struct dict_iterate_context *_ctx,

const char **key_r, const char **value_r)

{

struct sql_dict_iterate_context *ctx =

(struct sql_dict_iterate_context *)_ctx;

const char *p, *value;

unsigned int i, sql_field_i, count;

int ret;

_ctx->has_more = FALSE;

if (ctx->error != NULL)

return FALSE;

if (!ctx->iter_query_sent) {

ctx->iter_query_sent = TRUE;

if (sql_dict_iterate_next_query(ctx) <= 0)

return FALSE;

}

if (ctx->result == NULL) {

/* wait for async lookup to finish */

i_assert((ctx->flags & DICT_ITERATE_FLAG_ASYNC) != 0);

_ctx->has_more = TRUE;

return FALSE;

}

ret = sql_result_next_row(ctx->result);

while (ret == SQL_RESULT_NEXT_MORE) {

if ((ctx->flags & DICT_ITERATE_FLAG_ASYNC) == 0)

sql_result_more_s(&ctx->result);

else {

/* get more results asynchronously */

ctx->synchronous_result = TRUE;

sql_result_more(&ctx->result, sql_dict_iterate_callback, ctx);

ctx->synchronous_result = FALSE;

if (ctx->result == NULL) {

_ctx->has_more = TRUE;

return FALSE;

}

}

ret = sql_result_next_row(ctx->result);

}

if (ret == 0) {

/* see if there are more results in the next map.

if ((ctx->flags & DICT_ITERATE_FLAG_EXACT_KEY) != 0)

return FALSE;

ctx->iter_query_sent = FALSE;

/* we have gotten *SOME* results, so can allow

ctx->allow_null_map = TRUE;

return sql_dict_iterate(_ctx, key_r, value_r);

}

if (ret < 0) {

ctx->error = p_strdup_printf(ctx->pool,

"dict sql iterate failed: %s",

sql_result_get_error(ctx->result));

return FALSE;

}

/* convert fetched row to dict key */

str_truncate(ctx->key, ctx->key_prefix_len);

if (ctx->key_prefix_len > 0 &&

str_c(ctx->key)[ctx->key_prefix_len-1] != '/')

str_append_c(ctx->key, '/');

count = sql_result_get_fields_count(ctx->result);

i = (ctx->flags & DICT_ITERATE_FLAG_NO_VALUE) != 0 ? 0 :

ctx->map->values_count;

sql_field_i = ctx->sql_fields_start_idx;

for (p = ctx->map->pattern + ctx->pattern_prefix_len; *p != '\0'; p++) {

if (*p != '$')

str_append_c(ctx->key, *p);

else {

i_assert(i < count);

value = sql_dict_result_unescape_field(ctx->map,

pool_datastack_create(), ctx->result, i, sql_field_i);

if (value != NULL)

str_append(ctx->key, value);

i++; sql_field_i++;

}

}

*key_r = str_c(ctx->key);

if ((ctx->flags & DICT_ITERATE_FLAG_NO_VALUE) != 0)

*value_r = "";

else {

*value_r = sql_dict_result_unescape_value(ctx->map,

pool_datastack_create(), ctx->result);

}

return TRUE;

}

static int sql_dict_iterate_deinit(struct dict_iterate_context *_ctx,

const char **error_r)

{

struct sql_dict_iterate_context *ctx =

(struct sql_dict_iterate_context *)_ctx;

int ret = ctx->error != NULL ? -1 : 0;

*error_r = t_strdup(ctx->error);

if (ctx->result != NULL)

sql_result_unref(ctx->result);

pool_unref(&ctx->pool);

return ret;

}

static struct dict_transaction_context *

sql_dict_transaction_init(struct dict *_dict)

{

struct sql_dict *dict = (struct sql_dict *)_dict;

struct sql_dict_transaction_context *ctx;

ctx = i_new(struct sql_dict_transaction_context, 1);

ctx->ctx.dict = _dict;

ctx->sql_ctx = sql_transaction_begin(dict->db);

return &ctx->ctx;

}

static void sql_dict_transaction_free(struct sql_dict_transaction_context *ctx)

{

pool_unref(&ctx->inc_row_pool);

i_free(ctx->prev_inc_key);

i_free(ctx->error);

i_free(ctx);

}

static bool

sql_dict_transaction_has_nonexistent(struct sql_dict_transaction_context *ctx)

{

struct sql_dict_inc_row *inc_row;

for (inc_row = ctx->inc_row; inc_row != NULL; inc_row = inc_row->prev) {

i_assert(inc_row->rows != UINT_MAX);

if (inc_row->rows == 0)

return TRUE;

}

return FALSE;

}

static void

sql_dict_transaction_commit_callback(const struct sql_commit_result *sql_result,

struct sql_dict_transaction_context *ctx)

{

struct dict_commit_result result;

i_zero(&result);

if (sql_result->error == NULL)

result.ret = sql_dict_transaction_has_nonexistent(ctx) ?

DICT_COMMIT_RET_NOTFOUND : DICT_COMMIT_RET_OK;

else {

result.error = t_strdup_printf("sql dict: commit failed: %s",

sql_result->error);

switch (sql_result->error_type) {

case SQL_RESULT_ERROR_TYPE_UNKNOWN:

default:

result.ret = DICT_COMMIT_RET_FAILED;

break;

case SQL_RESULT_ERROR_TYPE_WRITE_UNCERTAIN:

result.ret = DICT_COMMIT_RET_WRITE_UNCERTAIN;

break;

}

}

if (ctx->async_callback != NULL)

ctx->async_callback(&result, ctx->async_context);

else if (result.ret < 0)

i_error("%s", result.error);

sql_dict_transaction_free(ctx);

}

static void

sql_dict_transaction_commit(struct dict_transaction_context *_ctx, bool async,

dict_transaction_commit_callback_t *callback,

void *context)

{

struct sql_dict_transaction_context *ctx =

(struct sql_dict_transaction_context *)_ctx;

const char *error;

struct dict_commit_result result;

if (ctx->prev_inc_map != NULL)

sql_dict_prev_inc_flush(ctx);

if (ctx->prev_set_map != NULL)

sql_dict_prev_set_flush(ctx);

/* note that the above calls might still set ctx->error */

i_zero(&result);

result.ret = DICT_COMMIT_RET_FAILED;

result.error = t_strdup(ctx->error);

if (ctx->error != NULL) {

sql_transaction_rollback(&ctx->sql_ctx);

} else if (!_ctx->changed) {

/* nothing changed, no need to commit */

sql_transaction_rollback(&ctx->sql_ctx);

result.ret = DICT_COMMIT_RET_OK;

} else if (async) {

ctx->async_callback = callback;

ctx->async_context = context;

sql_transaction_commit(&ctx->sql_ctx,

sql_dict_transaction_commit_callback, ctx);

return;

} else if (sql_transaction_commit_s(&ctx->sql_ctx, &error) < 0) {

result.error = t_strdup_printf(

"sql dict: commit failed: %s", error);

} else {

if (sql_dict_transaction_has_nonexistent(ctx))

result.ret = DICT_COMMIT_RET_NOTFOUND;

else

result.ret = DICT_COMMIT_RET_OK;

}

sql_dict_transaction_free(ctx);

callback(&result, context);

}

static void sql_dict_transaction_rollback(struct dict_transaction_context *_ctx)

{

struct sql_dict_transaction_context *ctx =

(struct sql_dict_transaction_context *)_ctx;

sql_transaction_rollback(&ctx->sql_ctx);

sql_dict_transaction_free(ctx);

}

static struct sql_statement *

sql_dict_transaction_stmt_init(struct sql_dict_transaction_context *ctx,

const char *query,

const ARRAY_TYPE(sql_dict_param) *params)

{

struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;

struct sql_statement *stmt =

sql_dict_statement_init(dict, query, params);

if (ctx->ctx.timestamp.tv_sec != 0)

sql_statement_set_timestamp(stmt, &ctx->ctx.timestamp);

return stmt;

}

struct dict_sql_build_query_field {

const struct dict_sql_map *map;

const char *value;

};

struct dict_sql_build_query {

struct sql_dict *dict;

ARRAY(struct dict_sql_build_query_field) fields;

const ARRAY_TYPE(const_string) *extra_values;

char key1;

};

static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,

const struct dict_sql_build_query *build,

struct sql_statement **stmt_r,

const char **error_r)

{

struct sql_dict *dict = build->dict;

const struct dict_sql_build_query_field *fields;

const struct dict_sql_field *sql_fields;

ARRAY_TYPE(sql_dict_param) params;

const char *const *extra_values;

unsigned int i, field_count, count, count2;

string_t *prefix, *suffix;

fields = array_get(&build->fields, &field_count);

i_assert(field_count > 0);

t_array_init(&params, 4);

prefix = t_str_new(64);

suffix = t_str_new(256);

str_printfa(prefix, "INSERT INTO %s", fields[0].map->table);

str_append(prefix, " (");

str_append(suffix, ") VALUES (");

for (i = 0; i < field_count; i++) {

if (i > 0) {

str_append_c(prefix, ',');

str_append_c(suffix, ',');

}

str_append(prefix, t_strcut(fields[i].map->value_field, ','));

enum dict_sql_type value_type =

fields[i].map->value_types[0];

str_append_c(suffix, '?');

if (sql_dict_value_get(fields[i].map,

value_type, "value", fields[i].value,

"", &params, error_r) < 0)

return -1;

}

if (build->key1 == DICT_PATH_PRIVATE[0]) {

str_printfa(prefix, ",%s", fields[0].map->username_field);

str_printfa(suffix, ",'%s'",

sql_escape_string(dict->db, dict->username));

}

/* add the other fields from the key */

sql_fields = array_get(&fields[0].map->sql_fields, &count);

extra_values = array_get(build->extra_values, &count2);

i_assert(count == count2);

for (i = 0; i < count; i++) {

str_printfa(prefix, ",%s", sql_fields[i].name);

str_append(suffix, ",?");

if (sql_dict_field_get_value(fields[0].map, &sql_fields[i],

extra_values[i], "",

&params, error_r) < 0)

return -1;

}

str_append_str(prefix, suffix);

str_append_c(prefix, ')');

if (!dict->has_on_duplicate_key) {

*stmt_r = sql_dict_transaction_stmt_init(ctx, str_c(prefix), &params);

return 0;

}

str_append(prefix, " ON DUPLICATE KEY UPDATE ");

for (i = 0; i < field_count; i++) {

const char *first_value_field =

t_strcut(fields[i].map->value_field, ',');

if (i > 0)

str_append_c(prefix, ',');

str_append(prefix, first_value_field);

str_append_c(prefix, '=');

enum dict_sql_type value_type =

fields[i].map->value_types[0];

str_append_c(prefix, '?');

if (sql_dict_value_get(fields[i].map,

value_type, "value", fields[i].value,

"", &params, error_r) < 0)

return -1;

}

*stmt_r = sql_dict_transaction_stmt_init(ctx, str_c(prefix), &params);

return 0;

}

static int

sql_dict_update_query(const struct dict_sql_build_query *build,

const char **query_r, ARRAY_TYPE(sql_dict_param) *params,

const char **error_r)

{

struct sql_dict *dict = build->dict;

const struct dict_sql_build_query_field *fields;

unsigned int i, field_count;

string_t *query;

fields = array_get(&build->fields, &field_count);

i_assert(field_count > 0);

query = t_str_new(64);

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, ',');

if (i > 0)

str_append_c(query, ',');

str_printfa(query, "%s=%s+?", first_value_field,

first_value_field);

}

if (sql_dict_where_build(dict, fields[0].map, build->extra_values,

build->key1, SQL_DICT_RECURSE_NONE, query,

params, error_r) < 0)

return -1;

*query_r = str_c(query);

return 0;

}

static void sql_dict_set_real(struct dict_transaction_context *_ctx,

const char *key, const char *value)

{

struct sql_dict_transaction_context *ctx =

(struct sql_dict_transaction_context *)_ctx;

struct sql_dict *dict = (struct sql_dict *)_ctx->dict;

const struct dict_sql_map *map;

struct sql_statement *stmt;

ARRAY_TYPE(const_string) values;

struct dict_sql_build_query build;

struct dict_sql_build_query_field field;

const char *error;

if (ctx->error != NULL)

return;

map = sql_dict_find_map(dict, key, &values);

if (map == NULL) {

ctx->error = i_strdup_printf(

"dict-sql: Invalid/unmapped key: %s", key);

return;

}

field.map = map;

field.value = value;

i_zero(&build);

build.dict = dict;