dict-sql: Rename dict_sql_map.sql_fields to pattern_fields

diff --git a/src/lib-dict-backend/dict-sql-settings.c b/src/lib-dict-backend/dict-sql-settings.c
index 117ea933453df951e09f0b7293008c1a5207ef6c..bf745d558dfdb9aa7fde8757a35d06c563f965d3 100644 (file)
--- a/src/lib-dict-backend/dict-sql-settings.c
+++ b/src/lib-dict-backend/dict-sql-settings.c
@@ -90,7 +90,7 @@ static const char *dict_sql_fields_map(struct setting_parser_ctx *ctx)
        pattern = t_str_new(strlen(ctx->cur_map.pattern) + 1);
        fields = array_get_modifiable(&ctx->cur_fields, &count);
 
-       p_array_init(&ctx->cur_map.sql_fields, ctx->pool, count);
+       p_array_init(&ctx->cur_map.pattern_fields, ctx->pool, count);
        for (p = ctx->cur_map.pattern; *p != '\0';) {
                if (*p != '$') {
                        str_append_c(pattern, *p);
@@ -113,7 +113,7 @@ static const char *dict_sql_fields_map(struct setting_parser_ctx *ctx)
 
                /* mark this field as used */
                fields[i].variable = NULL;
-               array_push_back(&ctx->cur_map.sql_fields,
+               array_push_back(&ctx->cur_map.pattern_fields,
                                &fields[i].sql_field);
        }
 
@@ -186,9 +186,9 @@ static const char *dict_sql_map_finish(struct setting_parser_ctx *ctx)
                ctx->cur_map.username_field = "'username_field not set'";
        }
 
-       if (!array_is_created(&ctx->cur_map.sql_fields)) {
+       if (!array_is_created(&ctx->cur_map.pattern_fields)) {
                /* no fields besides value. allocate the array anyway. */
-               p_array_init(&ctx->cur_map.sql_fields, ctx->pool, 1);
+               p_array_init(&ctx->cur_map.pattern_fields, ctx->pool, 1);
                if (strchr(ctx->cur_map.pattern, '$') != NULL)
                        return "Missing fields for pattern variables";
        }

diff --git a/src/lib-dict-backend/dict-sql-settings.h b/src/lib-dict-backend/dict-sql-settings.h
index 0f0a3aff785e2ca08814aad5b4fad333cf639b46..b95bf29fb47b9a19218bfd6c5a0a1606d699f4a5 100644 (file)
--- a/src/lib-dict-backend/dict-sql-settings.h
+++ b/src/lib-dict-backend/dict-sql-settings.h
@@ -23,7 +23,8 @@ struct dict_sql_map {
        const char *value_type;
        bool value_hexblob;
 
-       ARRAY(struct dict_sql_field) sql_fields;
+       /* SQL field names, one for each $ variable in the pattern */
+       ARRAY(struct dict_sql_field) pattern_fields;
 
        /* generated: */
        unsigned int values_count;

diff --git a/src/lib-dict-backend/dict-sql.c b/src/lib-dict-backend/dict-sql.c
index 0891b9aa239f58be8a842ff435dc096fa338ad42..861cb1be5f3971294dafff551222496ececdde4a 100644 (file)
--- a/src/lib-dict-backend/dict-sql.c
+++ b/src/lib-dict-backend/dict-sql.c
@@ -350,11 +350,11 @@ sql_dict_where_build(struct sql_dict *dict, const struct dict_sql_map *map,
                     string_t *query, ARRAY_TYPE(sql_dict_param) *params,
                     const char **error_r)
 {
-       const struct dict_sql_field *sql_fields;
+       const struct dict_sql_field *pattern_fields;
        const char *const *values;
        unsigned int i, count, count2, exact_count;
 
-       sql_fields = array_get(&map->sql_fields, &count);
+       pattern_fields = array_get(&map->pattern_fields, &count);
        values = array_get(values_arr, &count2);
        /* if we came here from iteration code there may be less values */
        i_assert(count2 <= count);
@@ -370,8 +370,8 @@ sql_dict_where_build(struct sql_dict *dict, const struct dict_sql_map *map,
        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], "",
+               str_printfa(query, " %s = ?", pattern_fields[i].name);
+               if (sql_dict_field_get_value(map, &pattern_fields[i], values[i], "",
                                             params, error_r) < 0)
                        return -1;
        }
@@ -382,20 +382,21 @@ sql_dict_where_build(struct sql_dict *dict, const struct dict_sql_map *map,
                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],
+                       str_printfa(query, " %s LIKE ?", pattern_fields[i].name);
+                       if (sql_dict_field_get_value(map, &pattern_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],
+                       str_printfa(query, " AND %s NOT LIKE ?", pattern_fields[i].name);
+                       if (sql_dict_field_get_value(map, &pattern_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);
+                                   pattern_fields[i].name,
+                                   pattern_fields[i].name);
                }
                break;
        case SQL_DICT_RECURSE_FULL:
@@ -403,8 +404,8 @@ sql_dict_where_build(struct sql_dict *dict, const struct dict_sql_map *map,
                        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],
+                                   pattern_fields[i].name);
+                       if (sql_dict_field_get_value(map, &pattern_fields[i],
                                                     values[i], "/%",
                                                     params, error_r) < 0)
                                return -1;
@@ -510,7 +511,7 @@ sql_dict_result_unescape_field(const struct dict_sql_map *map, pool_t pool,
 {
        const struct dict_sql_field *sql_field;
 
-       sql_field = array_idx(&map->sql_fields, sql_field_idx);
+       sql_field = array_idx(&map->pattern_fields, sql_field_idx);
        return sql_dict_result_unescape(sql_field->value_type, pool,
                                        result, result_idx);
 }
@@ -616,7 +617,7 @@ sql_dict_iterate_find_next_map(struct sql_dict_iterate_context *ctx,
                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))) {
+                    array_count(values)+1 >= array_count(&maps[i].pattern_fields))) {
                        ctx->key_prefix_len = path_len;
                        ctx->pattern_prefix_len = pat_len;
                        ctx->next_map_idx = i + 1;
@@ -642,7 +643,7 @@ sql_dict_iterate_build_next_query(struct sql_dict_iterate_context *ctx,
        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;
+       const struct dict_sql_field *pattern_fields;
        enum sql_recurse_type recurse_type;
        unsigned int i, count;
 
@@ -667,7 +668,7 @@ sql_dict_iterate_build_next_query(struct sql_dict_iterate_context *ctx,
                str_printfa(query, "%s,", map->value_field);
 
        /* get all missing fields */
-       sql_fields = array_get(&map->sql_fields, &count);
+       pattern_fields = array_get(&map->pattern_fields, &count);
        i = array_count(&values);
        if (i == count) {
                /* we always want to know the last field since we're
@@ -677,7 +678,7 @@ sql_dict_iterate_build_next_query(struct sql_dict_iterate_context *ctx,
        }
        ctx->sql_fields_start_idx = i;
        for (; i < count; i++)
-               str_printfa(query, "%s,", sql_fields[i].name);
+               str_printfa(query, "%s,", pattern_fields[i].name);
        str_truncate(query, str_len(query)-1);
 
        str_printfa(query, " FROM %s", map->table);
@@ -699,7 +700,7 @@ sql_dict_iterate_build_next_query(struct sql_dict_iterate_context *ctx,
        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);
+                       str_printfa(query, "%s", pattern_fields[i].name);
                        if (i < count-1)
                                str_append_c(query, ',');
                }
@@ -1050,7 +1051,7 @@ static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,
 {
        struct sql_dict *dict = build->dict;
        const struct dict_sql_build_query_field *fields;
-       const struct dict_sql_field *sql_fields;
+       const struct dict_sql_field *pattern_fields;
        ARRAY_TYPE(sql_dict_param) params;
        const char *const *extra_values;
        unsigned int i, field_count, count, count2;
@@ -1089,13 +1090,13 @@ static int sql_dict_set_query(struct sql_dict_transaction_context *ctx,
        }
 
        /* add the other fields from the key */
-       sql_fields = array_get(&fields[0].map->sql_fields, &count);
+       pattern_fields = array_get(&fields[0].map->pattern_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_printfa(prefix, ",%s", pattern_fields[i].name);
                str_append(suffix, ",?");
-               if (sql_dict_field_get_value(fields[0].map, &sql_fields[i],
+               if (sql_dict_field_get_value(fields[0].map, &pattern_fields[i],
                                             extra_values[i], "",
                                             &params, error_r) < 0)
                        return -1;