Ansel 0.0
A darktable fork - bloat + design vision
Loading...
Searching...
No Matches
image_repository.c
Go to the documentation of this file.
1/*
2 This file is part of darktable,
3 Copyright (C) 2025 Aurélien PIERRE.
4
5 darktable is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 darktable is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with darktable. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#include <math.h> // NAN, the "no colour matrix" sentinel restored below
20#include <string.h>
21
22#include "database/image_repository.h"
23
24#include "database/colorlabel_repository.h"
25#include "database/database.h"
26#include "common/datetime.h"
27#include "database/sql_debug.h"
28#include "common/image.h"
29#include "common/logging.h"
30#include "system/dtpthread.h"
31#include "system/macros.h"
32
33#include <inttypes.h>
34#include <sqlite3.h>
35
36/* One statement cache for the whole process, guarded by one mutex, exactly as the image cache
37 * held it before the split: these statements are reused on every image load and every write,
38 * and re-preparing them per call was measurable. The mutex is what makes reuse safe, and it
39 * is why the calls below serialise against each other. */
40static sqlite3_stmt *_image_load_stmt = NULL;
41static sqlite3_stmt *_image_write_history_hash_stmt = NULL;
42static sqlite3_stmt *_image_write_timestamp_select_stmt = NULL;
43static sqlite3_stmt *_image_write_timestamp_update_stmt = NULL;
44static sqlite3_stmt *_image_set_flags_stmt = NULL;
45static sqlite3_stmt *_image_set_flags_masked_stmt = NULL;
46static dt_pthread_mutex_t _image_stmt_mutex;
47static gsize _image_stmt_mutex_inited = 0;
48
57
58static sqlite3_stmt *_image_get_stmt(void)
59{
60 if(IS_NULL_PTR(_image_load_stmt))
61 {
62 // clang-format off
63 DT_DEBUG_SQLITE3_PREPARE_V2(
64 dt_database_get_sqlite3_global(),
65 "SELECT i.id, i.group_id, "
66 " (SELECT COUNT(id) FROM main.images WHERE group_id = i.group_id), "
67 " (SELECT COUNT(imgid) FROM main.history WHERE imgid = i.id), "
68 " COALESCE((SELECT current_hash FROM main.history_hash WHERE imgid = i.id), -1), "
69 " COALESCE((SELECT mipmap_hash FROM main.history_hash WHERE imgid = i.id), -1), "
70 " i.film_id, i.version, i.width, i.height, i.orientation, i.flags, "
71 " i.import_timestamp, i.change_timestamp, i.export_timestamp, i.print_timestamp, "
72 " i.exposure, i.exposure_bias, i.aperture, i.iso, i.focal_length, i.focus_distance, "
73 " i.datetime_taken, i.longitude, i.latitude, i.altitude, "
74 " i.filename, f.folder || '" G_DIR_SEPARATOR_S "' || i.filename, "
75 " i.maker, i.model, i.lens, f.folder, "
76 " COALESCE((SELECT SUM(1 << color) FROM main.color_labels WHERE imgid=i.id), 0), "
77 " i.crop, i.raw_parameters, i.color_matrix, i.colorspace, "
78 " i.raw_black, i.raw_maximum, i.aspect_ratio, i.output_width, i.output_height"
79 " FROM main.images AS i"
80 " LEFT JOIN main.film_rolls AS f ON f.id = i.film_id"
81 " WHERE i.id = ?1",
82 -1, &_image_load_stmt, NULL);
83 // clang-format on
84 }
85
86 sqlite3_reset(_image_load_stmt);
87 sqlite3_clear_bindings(_image_load_stmt);
88 return _image_load_stmt;
89}
90
91static void dt_image_from_stmt(dt_image_t *img, sqlite3_stmt *stmt)
92{
93 if(sqlite3_column_type(stmt, 0) != SQLITE_NULL) img->id = sqlite3_column_int(stmt, 0);
94 if(sqlite3_column_type(stmt, 1) != SQLITE_NULL) img->group_id = sqlite3_column_int(stmt, 1);
95 if(sqlite3_column_type(stmt, 2) != SQLITE_NULL) img->group_members = (uint32_t)sqlite3_column_int(stmt, 2);
96 if(sqlite3_column_type(stmt, 3) != SQLITE_NULL) img->history_items = (uint32_t)sqlite3_column_int(stmt, 3);
97 if(sqlite3_column_type(stmt, 4) != SQLITE_NULL) img->history_hash = sqlite3_column_int64(stmt, 4);
98 if(sqlite3_column_type(stmt, 5) != SQLITE_NULL) img->mipmap_hash = sqlite3_column_int64(stmt, 5);
99 if(sqlite3_column_type(stmt, 6) != SQLITE_NULL) img->film_id = sqlite3_column_int(stmt, 6);
100 if(sqlite3_column_type(stmt, 7) != SQLITE_NULL) img->version = sqlite3_column_int(stmt, 7);
101 if(sqlite3_column_type(stmt, 8) != SQLITE_NULL) img->width = sqlite3_column_int(stmt, 8);
102 if(sqlite3_column_type(stmt, 9) != SQLITE_NULL) img->height = sqlite3_column_int(stmt, 9);
103 if(sqlite3_column_type(stmt, 10) != SQLITE_NULL) img->orientation = sqlite3_column_int(stmt, 10);
104 if(sqlite3_column_type(stmt, 11) != SQLITE_NULL) img->flags = sqlite3_column_int(stmt, 11);
105 if(sqlite3_column_type(stmt, 12) != SQLITE_NULL) img->import_timestamp = sqlite3_column_int64(stmt, 12);
106 if(sqlite3_column_type(stmt, 13) != SQLITE_NULL) img->change_timestamp = sqlite3_column_int64(stmt, 13);
107 if(sqlite3_column_type(stmt, 14) != SQLITE_NULL) img->export_timestamp = sqlite3_column_int64(stmt, 14);
108 if(sqlite3_column_type(stmt, 15) != SQLITE_NULL) img->print_timestamp = sqlite3_column_int64(stmt, 15);
109 if(sqlite3_column_type(stmt, 16) != SQLITE_NULL) img->exif_exposure = sqlite3_column_double(stmt, 16);
110 if(sqlite3_column_type(stmt, 17) != SQLITE_NULL) img->exif_exposure_bias = sqlite3_column_double(stmt, 17);
111 if(sqlite3_column_type(stmt, 18) != SQLITE_NULL) img->exif_aperture = sqlite3_column_double(stmt, 18);
112 if(sqlite3_column_type(stmt, 19) != SQLITE_NULL) img->exif_iso = sqlite3_column_double(stmt, 19);
113 if(sqlite3_column_type(stmt, 20) != SQLITE_NULL) img->exif_focal_length = sqlite3_column_double(stmt, 20);
114 if(sqlite3_column_type(stmt, 21) != SQLITE_NULL) img->exif_focus_distance = sqlite3_column_double(stmt, 21);
115 if(sqlite3_column_type(stmt, 22) != SQLITE_NULL) img->exif_datetime_taken = sqlite3_column_int64(stmt, 22);
116 if(sqlite3_column_type(stmt, 23) != SQLITE_NULL) img->geoloc.longitude = sqlite3_column_double(stmt, 23);
117 if(sqlite3_column_type(stmt, 24) != SQLITE_NULL) img->geoloc.latitude = sqlite3_column_double(stmt, 24);
118 if(sqlite3_column_type(stmt, 25) != SQLITE_NULL) img->geoloc.elevation = sqlite3_column_double(stmt, 25);
119
120 const char *filename = (const char *)sqlite3_column_text(stmt, 26);
121 if(filename) g_strlcpy(img->filename, filename, sizeof(img->filename));
122 const char *fullpath = (const char *)sqlite3_column_text(stmt, 27);
123 if(fullpath) g_strlcpy(img->fullpath, fullpath, sizeof(img->fullpath));
124 const char *maker = (const char *)sqlite3_column_text(stmt, 28);
125 if(maker) g_strlcpy(img->exif_maker, maker, sizeof(img->exif_maker));
126 const char *model = (const char *)sqlite3_column_text(stmt, 29);
127 if(model) g_strlcpy(img->exif_model, model, sizeof(img->exif_model));
128 const char *lens = (const char *)sqlite3_column_text(stmt, 30);
129 if(lens) g_strlcpy(img->exif_lens, lens, sizeof(img->exif_lens));
130 const char *folder = (const char *)sqlite3_column_text(stmt, 31);
131 if(folder) g_strlcpy(img->folder, folder, sizeof(img->folder));
132
133 if(sqlite3_column_type(stmt, 32) != SQLITE_NULL) img->color_labels = sqlite3_column_int(stmt, 32);
134
135 if(sqlite3_column_type(stmt, 33) != SQLITE_NULL) img->exif_crop = sqlite3_column_double(stmt, 33);
136 if(sqlite3_column_type(stmt, 34) != SQLITE_NULL)
137 {
138 uint32_t tmp = sqlite3_column_int(stmt, 34);
139 memcpy(&img->legacy_flip, &tmp, sizeof(dt_image_raw_parameters_t));
140 }
141 /* Size the copy from the blob, not from the destination: the writer binds exactly
142 * sizeof(d65_color_matrix) (see dt_image_repository_store()), so anything shorter is a row this
143 * schema did not write so anything else is a row no writer of this schema produces and reading nine
144 * floats out of it is undefined. No null test: sqlite returns NULL only for a NULL or a zero-length
145 * value, so a size of exactly 36 already says the pointer is good. sqlite3_column_bytes() comes AFTER
146 * sqlite3_column_blob() on purpose -- that is the order sqlite3.h documents as safe, a size
147 * asked for first being allowed to describe a value the later call converts.
148 *
149 * The else branch is the one that runs in practice, on the NULL column of a row not yet stored.
150 * It matters because dt_image_cache_get_reload() reloads into an already populated struct
151 * WITHOUT going through dt_image_init(): the matrix from a previous load would otherwise
152 * survive a row that no longer carries one. NAN is the documented "no matrix" sentinel the
153 * readers test (imageio_profile.c, iop/colorin.c, pixel/illuminants.h). */
154 const void *color_matrix = sqlite3_column_blob(stmt, 35);
155 if(sqlite3_column_bytes(stmt, 35) == (int)sizeof(img->d65_color_matrix))
156 memcpy(img->d65_color_matrix, color_matrix, sizeof(img->d65_color_matrix));
157 else
158 img->d65_color_matrix[0] = NAN;
159 if(sqlite3_column_type(stmt, 36) != SQLITE_NULL) img->colorspace = sqlite3_column_int(stmt, 36);
160 if(sqlite3_column_type(stmt, 37) != SQLITE_NULL) img->raw_black_level = sqlite3_column_int(stmt, 37);
161 if(sqlite3_column_type(stmt, 38) != SQLITE_NULL) img->raw_white_point = sqlite3_column_int(stmt, 38);
162
163 if(img->fullpath[0])
164 dt_image_local_copy_paths_from_fullpath(img->fullpath, img->id, img->local_copy_path,
165 sizeof(img->local_copy_path), img->local_copy_legacy_path,
166 sizeof(img->local_copy_legacy_path));
167
168 img->exif_inited = (img->exif_focus_distance >= 0 && img->orientation >= 0);
169
170 if(img->folder[0])
171 g_strlcpy(img->filmroll, dt_image_film_roll_name(img->folder), sizeof(img->filmroll));
172
173 dt_datetime_gtimespan_to_local(img->datetime, sizeof(img->datetime), img->exif_datetime_taken, FALSE, FALSE);
174
175 // img->dsc are written by imageio drivers : never (re)set them from DB,
176 // they are not saved anyway. Until the codec decodes the file, seed a provisional
177 // descriptor from the (extension-derived) pipeline class so the image can be reasoned
178 // about and the first pipeline stage has a usable contract even before decoding.
179 dt_image_set_provisional_dsc(img);
180
181 /* Everything past the columns -- rating, monochrome and HDR predicates, the
182 * extension cross-check, makermodel -- is DERIVED, not stored, and needs symbols from
183 * imageio/ and views/. A row mapper that reached two layers up for them is what kept this
184 * code in common/. Callers run dt_image_derive_fields() next; see image_repository.h. */
185
186}
187
188static void _image_write_history_hash(const dt_image_t *img)
189{
190 if(IS_NULL_PTR(img) || img->id <= 0) return;
191
192 _image_stmt_mutex_ensure();
193 dt_pthread_mutex_lock(&_image_stmt_mutex);
194 if(!_image_write_history_hash_stmt)
195 {
196 // clang-format off
197 DT_DEBUG_SQLITE3_PREPARE_V2(
198 dt_database_get_sqlite3_global(),
199 "INSERT INTO main.history_hash (imgid, current_hash, basic_hash, auto_hash, mipmap_hash)"
200 " VALUES (?1, ?2, NULL, NULL, ?3)"
201 " ON CONFLICT (imgid)"
202 " DO UPDATE SET current_hash = ?2, basic_hash = NULL, auto_hash = NULL, mipmap_hash = ?3",
203 -1, &_image_write_history_hash_stmt, NULL);
204 // clang-format on
205 }
206 sqlite3_stmt *stmt = _image_write_history_hash_stmt;
207 sqlite3_reset(stmt);
208 sqlite3_clear_bindings(stmt);
209 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, img->id);
210 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 2, (sqlite3_int64)img->history_hash);
211 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 3, (sqlite3_int64)img->mipmap_hash);
212 sqlite3_step(stmt);
213 dt_pthread_mutex_unlock(&_image_stmt_mutex);
214}
215
216
217gboolean dt_image_repository_load(const int32_t imgid, dt_image_t *img)
218{
219 if(IS_NULL_PTR(img)) return FALSE;
220
221 gboolean found = FALSE;
222 _image_stmt_mutex_ensure();
223 dt_pthread_mutex_lock(&_image_stmt_mutex);
224
225 sqlite3_stmt *stmt = _image_get_stmt();
226 sqlite3_reset(stmt);
227 sqlite3_clear_bindings(stmt);
228 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
229 if(sqlite3_step(stmt) == SQLITE_ROW)
230 {
231 dt_image_from_stmt(img, stmt);
232 found = TRUE;
233 }
234 else
235 {
236 img->id = -1;
237 fprintf(stderr, "[image_repository_load] failed to open image %" PRId32 " from database: %s\n", imgid,
238 sqlite3_errmsg(dt_database_get_sqlite3_global()));
239 }
240
241 dt_pthread_mutex_unlock(&_image_stmt_mutex);
242 return found;
243}
244
245void dt_image_repository_foreach_collected(dt_image_repository_collected_cb cb, void *user_data)
246{
247 if(IS_NULL_PTR(cb)) return;
248
249 sqlite3_stmt *stmt = NULL;
250 // clang-format off
251 DT_DEBUG_SQLITE3_PREPARE_V2(
252 dt_database_get_sqlite3_global(),
253 // Same columns, same order, as the single-image load above -- dt_image_from_stmt() maps
254 // both. Only the source differs: the collection instead of one id.
255 "SELECT i.id, i.group_id, "
256 " (SELECT COUNT(id) FROM main.images WHERE group_id = i.group_id), "
257 " (SELECT COUNT(imgid) FROM main.history WHERE imgid = i.id), "
258 " COALESCE((SELECT current_hash FROM main.history_hash WHERE imgid = i.id), -1), "
259 " COALESCE((SELECT mipmap_hash FROM main.history_hash WHERE imgid = i.id), -1), "
260 " i.film_id, i.version, i.width, i.height, i.orientation, i.flags, "
261 " i.import_timestamp, i.change_timestamp, i.export_timestamp, i.print_timestamp, "
262 " i.exposure, i.exposure_bias, i.aperture, i.iso, i.focal_length, i.focus_distance, "
263 " i.datetime_taken, i.longitude, i.latitude, i.altitude, "
264 " i.filename, f.folder || '" G_DIR_SEPARATOR_S "' || i.filename, "
265 " i.maker, i.model, i.lens, f.folder, "
266 " COALESCE((SELECT SUM(1 << color) FROM main.color_labels WHERE imgid=i.id), 0), "
267 " i.crop, i.raw_parameters, i.color_matrix, i.colorspace, "
268 " i.raw_black, i.raw_maximum, i.aspect_ratio, i.output_width, i.output_height"
269 " FROM main.images AS i"
270 " JOIN memory.collected_images AS c ON i.id = c.imgid"
271 " LEFT JOIN main.film_rolls AS f ON f.id = i.film_id"
272 " ORDER BY c.rowid ASC",
273 -1, &stmt, NULL);
274 // clang-format on
275 if(IS_NULL_PTR(stmt)) return;
276
277 while(sqlite3_step(stmt) == SQLITE_ROW)
278 {
279 dt_image_t info;
280 dt_image_init(&info);
281 dt_image_from_stmt(&info, stmt);
282 // No lock is held here on purpose: see the header. cb() reaches the selection and the
283 // image cache, and either can come back through this function.
284 cb(user_data, &info);
285 }
286 sqlite3_finalize(stmt);
287}
288
289
290void dt_image_repository_store(const dt_image_t *img)
291{
292 if(IS_NULL_PTR(img) || img->id <= 0) return;
293
294 union {
295 struct dt_image_raw_parameters_t s;
296 uint32_t u;
297 } flip;
298
299 sqlite3_stmt *stmt;
300 // clang-format off
301 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
302 "UPDATE main.images"
303 " SET width = ?1, height = ?2, filename = ?3, maker = ?4, model = ?5,"
304 " lens = ?6, exposure = ?7, aperture = ?8, iso = ?9, focal_length = ?10,"
305 " focus_distance = ?11, film_id = ?12, datetime_taken = ?13, flags = ?14,"
306 " crop = ?15, orientation = ?16, raw_parameters = ?17, group_id = ?18,"
307 " longitude = ?19, latitude = ?20, altitude = ?21, color_matrix = ?22,"
308 " colorspace = ?23, raw_black = ?24, raw_maximum = ?25,"
309 " aspect_ratio = ROUND(?26,1), exposure_bias = ?27,"
310 " import_timestamp = ?28, change_timestamp = ?29, export_timestamp = ?30,"
311 " print_timestamp = ?31, output_width = ?32, output_height = ?33"
312 " WHERE id = ?34",
313 -1, &stmt, NULL);
314 // clang-format on
315 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, img->width);
316 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, img->height);
317 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, img->filename, -1, SQLITE_STATIC);
318 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, img->exif_maker, -1, SQLITE_STATIC);
319 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, img->exif_model, -1, SQLITE_STATIC);
320 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 6, img->exif_lens, -1, SQLITE_STATIC);
321 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, img->exif_exposure);
322 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, img->exif_aperture);
323 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, img->exif_iso);
324 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, img->exif_focal_length);
325 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 11, img->exif_focus_distance);
326 DT_DEBUG_SQLITE3_BIND_INT(stmt, 12, img->film_id);
327 if(img->exif_datetime_taken)
328 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 13, img->exif_datetime_taken);
329 DT_DEBUG_SQLITE3_BIND_INT(stmt, 14, img->flags);
330 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 15, img->exif_crop);
331 DT_DEBUG_SQLITE3_BIND_INT(stmt, 16, img->orientation);
332 flip.s = img->legacy_flip;
333 DT_DEBUG_SQLITE3_BIND_INT(stmt, 17, flip.u);
334 DT_DEBUG_SQLITE3_BIND_INT(stmt, 18, img->group_id);
335 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 19, img->geoloc.longitude);
336 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 20, img->geoloc.latitude);
337 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 21, img->geoloc.elevation);
338 DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 22, &img->d65_color_matrix, sizeof(img->d65_color_matrix), SQLITE_STATIC);
339 DT_DEBUG_SQLITE3_BIND_INT(stmt, 23, img->colorspace);
340 DT_DEBUG_SQLITE3_BIND_INT(stmt, 24, img->raw_black_level);
341 DT_DEBUG_SQLITE3_BIND_INT(stmt, 25, img->raw_white_point);
342 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 26, 0.); // img->aspect_ratio deprecated
343 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 27, img->exif_exposure_bias);
344 if(img->import_timestamp)
345 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 28, img->import_timestamp);
346 if(img->change_timestamp)
347 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 29, img->change_timestamp);
348 if(img->export_timestamp)
349 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 30, img->export_timestamp);
350 if(img->print_timestamp)
351 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 31, img->print_timestamp);
352 DT_DEBUG_SQLITE3_BIND_INT(stmt, 32, 0); // img->final_width deprecated
353 DT_DEBUG_SQLITE3_BIND_INT(stmt, 33, 0); // img->final_height deprecated
354 DT_DEBUG_SQLITE3_BIND_INT(stmt, 34, img->id);
355 const int rc = sqlite3_step(stmt);
356 if(rc != SQLITE_DONE) fprintf(stderr, "[image_cache_write_release] sqlite3 error %d\n", rc);
357 sqlite3_finalize(stmt);
358
359 /* Straight to the table. This used to call dt_colorlabels_set_labels() in common/, i.e.
360 * the persistence layer reaching up into the domain to have it issue the queries the
361 * persistence layer is for -- the only edge in that direction here. */
362 for(int color = 0; color < 5; color++)
363 {
364 if(img->color_labels & (1 << color))
365 dt_colorlabel_repository_set(img->id, color);
366 else
367 dt_colorlabel_repository_remove(img->id, color);
368 }
369 _image_write_history_hash(img);
370}
371
372
373/* ---------------------------------------------------------------------------------------
374 * Grouping
375 * ------------------------------------------------------------------------------------- */
376
377/* Collect the `id` column of a stepped statement into a list, dropping @p exclude_imgid. */
378static GList *_collect_ids(sqlite3_stmt *stmt, const int32_t exclude_imgid)
379{
380 GList *ids = NULL;
381 while(sqlite3_step(stmt) == SQLITE_ROW)
382 {
383 const int32_t id = sqlite3_column_int(stmt, 0);
384 if(id != exclude_imgid) ids = g_list_prepend(ids, GINT_TO_POINTER(id));
385 }
386 sqlite3_finalize(stmt);
387 return g_list_reverse(ids);
388}
389
390GList *dt_image_repository_get_group_members(const int32_t group_id, const int32_t exclude_imgid)
391{
392 sqlite3_stmt *stmt = NULL;
393 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
394 "SELECT id FROM main.images WHERE group_id = ?1", -1, &stmt, NULL);
395 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, group_id);
396 return _collect_ids(stmt, exclude_imgid);
397}
398
399void dt_image_group_member_free(gpointer data)
400{
401 dt_image_group_member_t *member = (dt_image_group_member_t *)data;
402 if(IS_NULL_PTR(member)) return;
403 dt_free(member->filename);
404 dt_free(member);
405}
406
407GList *dt_image_repository_get_group_member_rows(const int32_t group_id)
408{
409 GList *members = NULL;
410 sqlite3_stmt *stmt = NULL;
411 // clang-format off
412 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
413 "SELECT id, version, filename"
414 " FROM main.images"
415 " WHERE group_id = ?1", -1, &stmt,
416 NULL);
417 // clang-format on
418 if(IS_NULL_PTR(stmt)) return NULL;
419
420 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, group_id);
421 while(sqlite3_step(stmt) == SQLITE_ROW)
422 {
423 dt_image_group_member_t *member = (dt_image_group_member_t *)calloc(1, sizeof(dt_image_group_member_t));
424 if(IS_NULL_PTR(member)) break;
425 member->imgid = sqlite3_column_int(stmt, 0);
426 member->version = sqlite3_column_int(stmt, 1);
427 const char *filename = (const char *)sqlite3_column_text(stmt, 2);
428 member->filename = filename ? g_strdup(filename) : NULL;
429 members = g_list_prepend(members, member);
430 }
431 sqlite3_finalize(stmt);
432
433 // Row order: the caller walks it once to build a tooltip listing the group, and the order
434 // it reads is the order the rows came in.
435 return g_list_reverse(members);
436}
437
438int dt_image_repository_count_in_id_range(const int32_t min_imgid, const int32_t max_imgid)
439{
440 sqlite3_stmt *stmt = NULL;
441 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
442 "SELECT COUNT(*) FROM main.images WHERE id >= ?1 AND id <= ?2", -1,
443 &stmt, 0);
444 if(IS_NULL_PTR(stmt)) return -1;
445
446 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, min_imgid);
447 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, max_imgid);
448 const int count = (sqlite3_step(stmt) == SQLITE_ROW) ? sqlite3_column_int(stmt, 0) : -1;
449 sqlite3_finalize(stmt);
450
451 return count;
452}
453
454void dt_image_repository_foreach_in_id_range(const int32_t min_imgid, const int32_t max_imgid,
455 dt_image_repository_id_filename_cb cb,
456 void *user_data)
457{
458 if(IS_NULL_PTR(cb)) return;
459
460 sqlite3_stmt *stmt = NULL;
461 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
462 "SELECT id, filename FROM main.images WHERE id >= ?1 AND id <= ?2", -1,
463 &stmt, 0);
464 if(IS_NULL_PTR(stmt)) return;
465
466 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, min_imgid);
467 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, max_imgid);
468 while(sqlite3_step(stmt) == SQLITE_ROW)
469 cb(sqlite3_column_int(stmt, 0), (const char *)sqlite3_column_text(stmt, 1), user_data);
470 sqlite3_finalize(stmt);
471}
472
473
474void dt_image_repository_reassign_group(const int32_t from_group_id, const int32_t to_group_id,
475 const int32_t exclude_imgid)
476{
477 sqlite3_stmt *stmt = NULL;
478 // clang-format off
479 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
480 "UPDATE main.images SET group_id = ?1 WHERE group_id = ?2 AND id != ?3",
481 -1, &stmt, NULL);
482 // clang-format on
483 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, to_group_id);
484 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, from_group_id);
485 DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, exclude_imgid);
486 sqlite3_step(stmt);
487 sqlite3_finalize(stmt);
488}
489
490GList *dt_image_repository_get_ratings(const int32_t imgid)
491{
492 sqlite3_stmt *stmt = NULL;
493
494 if(imgid < 0)
495 {
496 // clang-format off
497 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
498 "SELECT flags FROM main.images WHERE id IN "
499 "(SELECT imgid FROM main.selected_images)",
500 -1, &stmt, NULL);
501 // clang-format on
502 }
503 else
504 {
505 // clang-format off
506 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
507 "SELECT flags FROM main.images WHERE id = ?1", -1, &stmt, NULL);
508 // clang-format on
509 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
510 }
511
512 GList *result = NULL;
513 while(sqlite3_step(stmt) == SQLITE_ROW)
514 {
515 const int stars = (sqlite3_column_int(stmt, 0) & 0x7) - 1;
516 result = g_list_prepend(result, GINT_TO_POINTER(stars));
517 }
518 sqlite3_finalize(stmt);
519
520 return g_list_reverse(result);
521}
522
523/* ---------------------------------------------------------------------------------------------
524 * Identity lookups
525 * ------------------------------------------------------------------------------------------ */
526
527int32_t dt_image_repository_find_by_film_and_filename(const int32_t film_id, const char *filename)
528{
529 if(IS_NULL_PTR(filename)) return -1;
530
531 int32_t id = -1;
532 sqlite3_stmt *stmt;
533 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
534 "SELECT id FROM main.images WHERE film_id = ?1 AND filename = ?2",
535 -1, &stmt, NULL);
536 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, film_id);
537 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename, -1, SQLITE_TRANSIENT);
538 if(sqlite3_step(stmt) == SQLITE_ROW) id=sqlite3_column_int(stmt, 0);
539 sqlite3_finalize(stmt);
540 return id;
541}
542
543int32_t dt_image_repository_find_by_folder_and_filename(const char *folder, const char *filename)
544{
545 if(IS_NULL_PTR(folder) || IS_NULL_PTR(filename)) return -1;
546
547 int32_t id = -1;
548 sqlite3_stmt *stmt;
549 // clang-format off
550 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
551 "SELECT images.id"
552 " FROM main.images, main.film_rolls"
553 " WHERE film_rolls.folder = ?1"
554 " AND images.film_id = film_rolls.id"
555 " AND images.filename = ?2",
556 -1, &stmt, NULL);
557 // clang-format on
558 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, folder, -1, SQLITE_STATIC);
559 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename, -1, SQLITE_STATIC);
560 if(sqlite3_step(stmt) == SQLITE_ROW) id=sqlite3_column_int(stmt, 0);
561 sqlite3_finalize(stmt);
562
563 return id;
564}
565
566
567/* ---------------------------------------------------------------------------------------------
568 * Versions, flags and the write timestamp
569 * ------------------------------------------------------------------------------------------ */
570
571int dt_image_repository_get_version(const int32_t imgid)
572{
573 int version = 0;
574 sqlite3_stmt *stmt;
575 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), "SELECT version FROM main.images WHERE id = ?1", -1,
576 &stmt, NULL);
577 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
578
579 if(sqlite3_step(stmt) == SQLITE_ROW) version = sqlite3_column_int(stmt, 0);
580 sqlite3_finalize(stmt);
581 return version;
582}
583
584gboolean dt_image_repository_set_version(const int32_t imgid, const int version)
585{
586 sqlite3_stmt *stmt;
587 DT_DEBUG_SQLITE3_PREPARE_V2
588 (dt_database_get_sqlite3_global(),
589 "UPDATE main.images SET version=?1, max_version = ?1 WHERE id = ?2", -1, &stmt, NULL);
590 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, version);
591 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
592 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
593 sqlite3_finalize(stmt);
594 return ok;
595}
596
597int dt_image_repository_count_others_with_flag(const int32_t imgid, const int flag)
598{
599 sqlite3_stmt *stmt;
600 int result = 1;
601
602 // clang-format off
603 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
604 "SELECT COUNT(*)"
605 " FROM main.images"
606 " WHERE id!=?1 AND flags&?2=?2"
607 " AND film_id=(SELECT film_id"
608 " FROM main.images"
609 " WHERE id=?1)"
610 " AND filename=(SELECT filename"
611 " FROM main.images"
612 " WHERE id=?1);",
613 -1, &stmt, NULL);
614 // clang-format on
615 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
616 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, flag);
617 if(sqlite3_step(stmt) == SQLITE_ROW) result = sqlite3_column_int(stmt, 0);
618 sqlite3_finalize(stmt);
619
620 return result;
621}
622
627static char *_id_set(GList *imgids)
628{
629 if(IS_NULL_PTR(imgids)) return NULL;
630
631 GString *set = g_string_new(NULL);
632 for(GList *l = imgids; l; l = g_list_next(l))
633 {
634 if(l != imgids) g_string_append_c(set, ',');
635 g_string_append_printf(set, "%d", GPOINTER_TO_INT(l->data));
636 }
637 return g_string_free(set, FALSE);
638}
639
640GList *dt_image_repository_get_ids_with_flag_among(GList *imgids, const int flag)
641{
642 char *set = _id_set(imgids);
643 if(IS_NULL_PTR(set)) return NULL;
644
645 GList *ids = NULL;
646 sqlite3_stmt *stmt;
647 char *query = g_strdup_printf("SELECT id FROM main.images WHERE id IN (%s) AND flags&?1=?1", set);
648 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), query, -1, &stmt, NULL);
649 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, flag);
650 while(sqlite3_step(stmt) == SQLITE_ROW)
651 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
652 sqlite3_finalize(stmt);
653 dt_free(query);
654 dt_free(set);
655 return g_list_reverse(ids); // row order
656}
657
658gboolean dt_image_repository_set_flag_among(GList *imgids, const int flag)
659{
660 char *set = _id_set(imgids);
661 if(IS_NULL_PTR(set)) return FALSE;
662
663 sqlite3_stmt *stmt;
664 char *query = g_strdup_printf("UPDATE main.images SET flags = (flags|?1) WHERE id IN (%s)", set);
665 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), query, -1, &stmt, NULL);
666 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, flag);
667 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
668 sqlite3_finalize(stmt);
669 dt_free(query);
670 dt_free(set);
671 return ok;
672}
673
674gboolean dt_image_repository_clear_flag_among(GList *imgids, const int flag)
675{
676 char *set = _id_set(imgids);
677 if(IS_NULL_PTR(set)) return FALSE;
678
679 sqlite3_stmt *stmt;
680 char *query = g_strdup_printf("UPDATE main.images SET flags = (flags & ~?1) WHERE id IN (%s)", set);
681 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), query, -1, &stmt, NULL);
682 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, flag);
683 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
684 sqlite3_finalize(stmt);
685 dt_free(query);
686 dt_free(set);
687 return ok;
688}
689
690GList *dt_image_repository_get_full_paths(GList *imgids)
691{
692 char *set = _id_set(imgids);
693 if(IS_NULL_PTR(set)) return NULL;
694
695 GList *list = NULL;
696 sqlite3_stmt *stmt;
697 // clang-format off
698 char *query = g_strdup_printf("SELECT DISTINCT folder || '" G_DIR_SEPARATOR_S "' || filename FROM "
699 "main.images i, main.film_rolls f "
700 "ON i.film_id = f.id WHERE i.id IN (%s)", set);
701 // clang-format on
702 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), query, -1, &stmt, NULL);
703 while(sqlite3_step(stmt) == SQLITE_ROW)
704 list = g_list_prepend(list, g_strdup((const gchar *)sqlite3_column_text(stmt, 0)));
705 sqlite3_finalize(stmt);
706 dt_free(query);
707 dt_free(set);
708 return g_list_reverse(list); // list was built in reverse order, so un-reverse it
709}
710
711GList *dt_image_repository_get_ids_with_flag(const int flag)
712{
713 GList *ids = NULL;
714 sqlite3_stmt *stmt;
715 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), "SELECT id FROM main.images WHERE flags&?1=?1", -1,
716 &stmt, NULL);
717 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, flag);
718
719 while(sqlite3_step(stmt) == SQLITE_ROW)
720 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
721 sqlite3_finalize(stmt);
722
723 // Row order, NOT reverse-row: the caller filters this list and prepends into its own, and
724 // that second prepend reproduces the single prepend the original did off the cursor.
725 return g_list_reverse(ids);
726}
727
755
756gboolean dt_image_repository_set_flags_masked(const int32_t imgid, const int mask, const int value)
757{
758 if(imgid <= 0 || mask == 0) return FALSE;
759
760 _image_stmt_mutex_ensure();
761 dt_pthread_mutex_lock(&_image_stmt_mutex);
762 if(IS_NULL_PTR(_image_set_flags_masked_stmt))
763 {
764 // The row supplies the bits outside the mask, so nothing this caller read earlier can be
765 // written back over them. Same shape as dt_image_repository_set_flag_among()'s
766 // `flags|?1` and its clearing twin, with both halves in one statement.
767 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
768 "UPDATE main.images SET flags = (flags & ~?1) | (?2 & ?1)"
769 " WHERE id = ?3",
770 -1, &_image_set_flags_masked_stmt, NULL);
771 }
772 if(IS_NULL_PTR(_image_set_flags_masked_stmt))
773 {
774 dt_pthread_mutex_unlock(&_image_stmt_mutex);
775 return FALSE;
776 }
777
778 DT_DEBUG_SQLITE3_BIND_INT(_image_set_flags_masked_stmt, 1, mask);
779 DT_DEBUG_SQLITE3_BIND_INT(_image_set_flags_masked_stmt, 2, value);
780 DT_DEBUG_SQLITE3_BIND_INT(_image_set_flags_masked_stmt, 3, imgid);
781 const gboolean ok = (sqlite3_step(_image_set_flags_masked_stmt) == SQLITE_DONE);
782 sqlite3_reset(_image_set_flags_masked_stmt);
783 sqlite3_clear_bindings(_image_set_flags_masked_stmt);
784 dt_pthread_mutex_unlock(&_image_stmt_mutex);
785
786 return ok;
787}
788
789void dt_image_repository_foreach_with_path(dt_image_repository_path_row_cb cb, void *user_data)
790{
791 if(IS_NULL_PTR(cb)) return;
792
793 sqlite3_stmt *stmt = NULL;
794 // clang-format off
795 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
796 "SELECT i.id, write_timestamp, version,"
797 " folder || '" G_DIR_SEPARATOR_S "' || filename, flags"
798 " FROM main.images i, main.film_rolls f"
799 " ON i.film_id = f.id"
800 " ORDER BY f.id, filename",
801 -1, &stmt, NULL);
802 // clang-format on
803 if(IS_NULL_PTR(stmt)) return;
804
805 while(sqlite3_step(stmt) == SQLITE_ROW)
806 {
807 // No lock is held here on purpose: cb() writes back through this repository.
808 if(!cb(sqlite3_column_int(stmt, 0),
809 sqlite3_column_int64(stmt, 1),
810 sqlite3_column_int(stmt, 2),
811 (const char *)sqlite3_column_text(stmt, 3),
812 sqlite3_column_int(stmt, 4),
813 user_data))
814 break;
815 }
816 sqlite3_finalize(stmt);
817}
818
819int *dt_image_repository_count_distinct_fields(GList *imgids)
820{
821 char *set = _id_set(imgids);
822 if(IS_NULL_PTR(set)) return NULL;
823
824 // One subquery per metadata key, each needing the id set again -- nine occurrences in all.
825 // clang-format off
826 char *query = g_strdup_printf("SELECT COUNT(DISTINCT film_id), "
827 "COUNT(DISTINCT film_id), "
828 "2, " // imgid always different
829 "COUNT(DISTINCT group_id), "
830 "COUNT(DISTINCT filename), "
831 "COUNT(DISTINCT version), "
832 "COUNT(DISTINCT film_id || '/' || filename), " //path
833 "COUNT(DISTINCT flags & 2048), " //local copy
834 "COUNT(DISTINCT import_timestamp), "
835 "COUNT(DISTINCT change_timestamp), "
836 "COUNT(DISTINCT export_timestamp), "
837 "COUNT(DISTINCT print_timestamp), "
838 "COUNT(DISTINCT flags), "
839 "COUNT(DISTINCT model), "
840 "COUNT(DISTINCT maker), "
841 "COUNT(DISTINCT lens), "
842 "COUNT(DISTINCT aperture), "
843 "COUNT(DISTINCT exposure), "
844 "COUNT(DISTINCT IFNULL(exposure_bias, '')), "
845 "COUNT(DISTINCT focal_length), "
846 "COUNT(DISTINCT focus_distance), "
847 "COUNT(DISTINCT iso), "
848 "COUNT(DISTINCT datetime_taken), "
849 "COUNT(DISTINCT width), "
850 "COUNT(DISTINCT height), "
851 "COUNT(DISTINCT IFNULL(output_width, '')), " //exported width
852 "COUNT(DISTINCT IFNULL(output_height, '')), " //exported height
853 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 2 WHERE images.id in (%s)), " //title
854 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 3 WHERE images.id in (%s)), " //description
855 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 0 WHERE images.id in (%s)), " //creator
856 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 1 WHERE images.id in (%s)), " //publisher
857 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 4 WHERE images.id in (%s)), " //rights
858 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 5 WHERE images.id in (%s)), " //notes
859 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 6 WHERE images.id in (%s)), " //version name
860 "(SELECT COUNT(DISTINCT IFNULL(value,'')) FROM images LEFT JOIN meta_data ON meta_data.id = images.id AND key = 7 WHERE images.id in (%s)), " //image id
861 "COUNT(DISTINCT IFNULL(latitude, '')), "
862 "COUNT(DISTINCT IFNULL(longitude, '')), "
863 "COUNT(DISTINCT IFNULL(altitude, '')) "
864 "FROM main.images "
865 "WHERE id IN (%s)",
866 set, set, set, set, set, set, set, set, set);
867 // clang-format on
868
869 sqlite3_stmt *stmt = NULL;
870 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), query, -1, &stmt, NULL);
871 dt_free(query);
872 dt_free(set);
873 if(IS_NULL_PTR(stmt)) return NULL;
874
875 int *counts = NULL;
876 if(sqlite3_step(stmt) == SQLITE_ROW)
877 {
878 const int col_count = sqlite3_column_count(stmt);
879 counts = (int *)calloc(DT_IMAGE_FIELD_COUNT, sizeof(int));
880 if(counts)
881 {
882 for(int i = 0; i < DT_IMAGE_FIELD_COUNT && i < col_count; i++)
883 counts[i] = sqlite3_column_int(stmt, i);
884 }
885 }
886 sqlite3_finalize(stmt);
887
888 return counts;
889}
890
891gboolean dt_image_repository_get_collected_geo_bounds(dt_image_geo_bounds_t *bounds)
892{
893 if(IS_NULL_PTR(bounds)) return FALSE;
894
895 bounds->min_latitude = INFINITY;
896 bounds->max_latitude = -INFINITY;
897 bounds->min_longitude = INFINITY;
898 bounds->max_longitude = -INFINITY;
899 bounds->count = 0;
900
901 sqlite3_stmt *stmt = NULL;
902 // clang-format off
903 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
904 "SELECT MIN(latitude), MAX(latitude),"
905 " MIN(longitude), MAX(longitude), COUNT(*)"
906 " FROM main.images AS i "
907 " JOIN memory.collected_images AS l ON l.imgid = i.id "
908 " WHERE latitude NOT NULL AND longitude NOT NULL",
909 -1, &stmt, NULL);
910 // clang-format on
911 if(IS_NULL_PTR(stmt)) return FALSE;
912
913 const gboolean ok = (sqlite3_step(stmt) == SQLITE_ROW);
914 if(ok)
915 {
916 bounds->min_latitude = sqlite3_column_double(stmt, 0);
917 bounds->max_latitude = sqlite3_column_double(stmt, 1);
918 bounds->min_longitude = sqlite3_column_double(stmt, 2);
919 bounds->max_longitude = sqlite3_column_double(stmt, 3);
920 bounds->count = sqlite3_column_int(stmt, 4);
921 }
922 sqlite3_finalize(stmt);
923
924 return ok;
925}
926
927dt_image_geo_point_t *dt_image_repository_get_collected_geo_points(const double lon1, const double lon2,
928 const double lat1, const double lat2,
929 int *count)
930{
931 if(IS_NULL_PTR(count)) return NULL;
932 *count = 0;
933
934 sqlite3_stmt *stmt = NULL;
935 // clang-format off
936 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
937 "SELECT * FROM"
938 " (SELECT i.id, i.longitude, i.latitude "
939 " FROM main.images i INNER JOIN memory.collected_images c ON i.id = c.imgid"
940 " WHERE longitude >= ?1 AND longitude <= ?2"
941 " AND latitude <= ?3 AND latitude >= ?4 "
942 " AND longitude NOT NULL AND latitude NOT NULL)"
943 " ORDER BY longitude ASC", // critical to make dbscan work
944 -1, &stmt, NULL);
945 // clang-format on
946 if(IS_NULL_PTR(stmt)) return NULL;
947
948 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, lon1);
949 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, lon2);
950 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 3, lat1);
951 DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 4, lat2);
952
953 // One pass into a growing array, where the caller used to step the whole cursor once to
954 // count the rows and a second time to fill an exactly-sized buffer.
955 GArray *points = g_array_new(FALSE, FALSE, sizeof(dt_image_geo_point_t));
956 while(sqlite3_step(stmt) == SQLITE_ROW)
957 {
958 dt_image_geo_point_t p = { .imgid = sqlite3_column_int(stmt, 0),
959 .longitude = sqlite3_column_double(stmt, 1),
960 .latitude = sqlite3_column_double(stmt, 2) };
961 g_array_append_val(points, p);
962 }
963 sqlite3_finalize(stmt);
964
965 *count = (int)points->len;
966 if(points->len == 0)
967 {
968 g_array_free(points, TRUE);
969 return NULL;
970 }
971
972 return (dt_image_geo_point_t *)g_array_free(points, FALSE); // hand over the buffer
973}
974
1003
1026
1027gboolean dt_image_repository_set_write_timestamp(const int32_t imgid, const int64_t timestamp)
1028{
1029 if(imgid <= 0) return FALSE;
1030
1031 sqlite3_stmt *stmt = NULL;
1032 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1033 "UPDATE main.images SET write_timestamp = ?2 WHERE id = ?1",
1034 -1, &stmt, NULL);
1035 if(IS_NULL_PTR(stmt)) return FALSE;
1036
1037 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1038 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 2, timestamp);
1039 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
1040 sqlite3_finalize(stmt);
1041
1042 return ok;
1043}
1044
1045gboolean dt_image_repository_delete(const int32_t imgid)
1046{
1047 gboolean ok = TRUE;
1048 sqlite3_stmt *stmt;
1049
1050 // due to foreign keys added in db version 33,
1051 // all entries from tables having references to the images are deleted as well
1052 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), "DELETE FROM main.images WHERE id = ?1", -1, &stmt,
1053 NULL);
1054 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1055 ok &= (sqlite3_step(stmt) == SQLITE_DONE);
1056 sqlite3_finalize(stmt); // the original overwrote `stmt` here and leaked this statement
1057
1058 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1059 "DELETE FROM main.meta_data WHERE id = ?1", -1, &stmt, NULL);
1060 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1061 ok &= (sqlite3_step(stmt) == SQLITE_DONE);
1062 sqlite3_finalize(stmt);
1063
1064 return ok;
1065}
1066
1067int32_t dt_image_repository_duplicate(const int32_t imgid, const int32_t newversion)
1068{
1069 sqlite3_stmt *stmt;
1070 int32_t newid = -1;
1071
1072 // clang-format off
1073 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1074 "SELECT a.id"
1075 " FROM main.images AS a JOIN main.images AS b"
1076 " WHERE a.film_id = b.film_id AND a.filename = b.filename"
1077 " AND b.id = ?1 AND a.version = ?2"
1078 " ORDER BY a.id DESC",
1079 -1, &stmt, NULL);
1080 // clang-format on
1081 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1082 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, newversion);
1083 if(sqlite3_step(stmt) == SQLITE_ROW)
1084 {
1085 newid = sqlite3_column_int(stmt, 0);
1086 }
1087 sqlite3_finalize(stmt);
1088
1089 // requested version is already present in DB, so we just return it
1090 if(newid != -1) return newid;
1091
1092 // clang-format off
1093 DT_DEBUG_SQLITE3_PREPARE_V2
1094 (dt_database_get_sqlite3_global(),
1095 "INSERT INTO main.images"
1096 " (id, group_id, film_id, width, height, filename, maker, model, lens, exposure,"
1097 " aperture, iso, focal_length, focus_distance, datetime_taken, flags,"
1098 " output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1099 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1100 " license, sha1sum, orientation, histogram, lightmap,"
1101 " longitude, latitude, altitude, color_matrix, colorspace, version, max_version, history_end,"
1102 " aspect_ratio, exposure_bias, import_timestamp)"
1103 " SELECT NULL, group_id, film_id, width, height, filename, maker, model, lens,"
1104 " exposure, aperture, iso, focal_length, focus_distance, datetime_taken,"
1105 " flags, output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1106 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1107 " license, sha1sum, orientation, histogram, lightmap,"
1108 " longitude, latitude, altitude, color_matrix, colorspace, NULL, NULL, 0,"
1109 " aspect_ratio, exposure_bias, import_timestamp"
1110 " FROM main.images WHERE id = ?1",
1111 -1, &stmt, NULL);
1112 // clang-format on
1113 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1114 sqlite3_step(stmt);
1115 sqlite3_finalize(stmt);
1116 // clang-format off
1117 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1118 "SELECT a.id, a.film_id, a.filename, b.max_version"
1119 " FROM main.images AS a JOIN main.images AS b"
1120 " WHERE a.film_id = b.film_id AND a.filename = b.filename AND b.id = ?1"
1121 " ORDER BY a.id DESC",
1122 -1, &stmt, NULL);
1123 // clang-format on
1124 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1125
1126 int32_t film_id = UNKNOWN_IMAGE;
1127 int32_t max_version = -1;
1128 gchar *filename = NULL;
1129 if(sqlite3_step(stmt) == SQLITE_ROW)
1130 {
1131 newid = sqlite3_column_int(stmt, 0);
1132 film_id = sqlite3_column_int(stmt, 1);
1133 filename = g_strdup((gchar *)sqlite3_column_text(stmt, 2));
1134 max_version = sqlite3_column_int(stmt, 3);
1135 }
1136 sqlite3_finalize(stmt);
1137
1138 if(newid != -1)
1139 {
1140 // clang-format off
1141 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1142 "INSERT INTO main.color_labels (imgid, color)"
1143 " SELECT ?1, color FROM main.color_labels WHERE imgid = ?2",
1144 -1, &stmt, NULL);
1145 // clang-format on
1146 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1147 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1148 sqlite3_step(stmt);
1149 sqlite3_finalize(stmt);
1150
1151 // clang-format off
1152 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1153 "INSERT INTO main.meta_data (id, key, value)"
1154 " SELECT ?1, key, value FROM main.meta_data WHERE id = ?2",
1155 -1, &stmt, NULL);
1156 // clang-format on
1157 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1158 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1159 sqlite3_step(stmt);
1160 sqlite3_finalize(stmt);
1161
1162 // clang-format off
1163 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1164 "INSERT INTO main.tagged_images (imgid, tagid, position)"
1165 " SELECT ?1, tagid, "
1166 " (SELECT (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000)"
1167 " FROM main.tagged_images)"
1168 " + (ROW_NUMBER() OVER (ORDER BY imgid) << 32)"
1169 " FROM main.tagged_images AS ti"
1170 " WHERE imgid = ?2",
1171 -1, &stmt, NULL);
1172 // clang-format on
1173 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1174 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1175 sqlite3_step(stmt);
1176 sqlite3_finalize(stmt);
1177
1178 // clang-format off
1179 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1180 "INSERT INTO main.module_order (imgid, iop_list, version)"
1181 " SELECT ?1, iop_list, version FROM main.module_order WHERE imgid = ?2",
1182 -1, &stmt, NULL);
1183 // clang-format on
1184 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1185 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1186 sqlite3_step(stmt);
1187 sqlite3_finalize(stmt);
1188
1189 // set version of new entry and max_version of all involved duplicates (with same film_id and filename)
1190 // this needs to happen before we do anything with the image cache, as version isn't updated through the cache
1191 const int32_t version = (newversion != -1) ? newversion : max_version + 1;
1192 max_version = (newversion != -1) ? MAX(max_version, newversion) : max_version + 1;
1193
1194 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(), "UPDATE main.images SET version=?1 WHERE id = ?2",
1195 -1, &stmt, NULL);
1196 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, version);
1197 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, newid);
1198 sqlite3_step(stmt);
1199 sqlite3_finalize(stmt);
1200
1201 // clang-format off
1202 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1203 "UPDATE main.images SET max_version=?1 WHERE film_id = ?2 AND filename = ?3", -1,
1204 &stmt, NULL);
1205 // clang-format on
1206 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, max_version);
1207 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, film_id);
1208 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, filename, -1, SQLITE_TRANSIENT);
1209 sqlite3_step(stmt);
1210 sqlite3_finalize(stmt);
1211
1212 dt_free(filename);
1213 }
1214 return newid;
1215}
1216
1217void dt_image_version_free(gpointer data)
1218{
1219 dt_image_version_t *v = (dt_image_version_t *)data;
1220 if(IS_NULL_PTR(v)) return;
1221 dt_free(v->version_name);
1222 dt_free(v);
1223}
1224
1225GList *dt_image_repository_get_versions(const int32_t film_id, const char *filename,
1226 const int name_keyid)
1227{
1228 if(IS_NULL_PTR(filename)) return NULL;
1229
1230 sqlite3_stmt *stmt;
1231 // clang-format off
1232 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1233 "SELECT i.version, i.id, m.value"
1234 " FROM images AS i"
1235 " LEFT JOIN meta_data AS m ON m.id = i.id AND m.key = ?3"
1236 " WHERE film_id = ?1 AND filename = ?2"
1237 " ORDER BY i.version",
1238 -1, &stmt, NULL);
1239 // clang-format on
1240 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, film_id);
1241 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename, -1, SQLITE_TRANSIENT);
1242 DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, name_keyid);
1243
1244 GList *versions = NULL;
1245 while(sqlite3_step(stmt) == SQLITE_ROW)
1246 {
1247 dt_image_version_t *v = g_malloc0(sizeof(dt_image_version_t));
1248 if(v)
1249 {
1250 v->version = sqlite3_column_int(stmt, 0);
1251 v->imgid = sqlite3_column_int(stmt, 1);
1252 const char *name = (const char *)sqlite3_column_text(stmt, 2);
1253 v->version_name = name ? g_strdup(name) : NULL;
1254 versions = g_list_prepend(versions, v);
1255 }
1256 }
1257 sqlite3_finalize(stmt);
1258
1259 return g_list_reverse(versions); // version order, as the query returns it
1260}
1261
1262GList *dt_image_repository_get_duplicate_ids(const int32_t imgid)
1263{
1264 GList *ids = NULL;
1265 sqlite3_stmt *stmt;
1266 // statement for getting ids of the image to be moved and its duplicates
1267 // clang-format off
1268 DT_DEBUG_SQLITE3_PREPARE_V2
1269 (dt_database_get_sqlite3_global(),
1270 "SELECT id"
1271 " FROM main.images"
1272 " WHERE filename IN (SELECT filename FROM main.images WHERE id = ?1)"
1273 " AND film_id IN (SELECT film_id FROM main.images WHERE id = ?1)",
1274 -1, &stmt, NULL);
1275 // clang-format on
1276 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1277
1278 while(sqlite3_step(stmt) == SQLITE_ROW)
1279 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
1280 sqlite3_finalize(stmt);
1281
1282 // Row order: the original prepended off the cursor and then reversed, and its caller walks
1283 // the list without prepending again.
1284 return g_list_reverse(ids);
1285}
1286
1287int32_t dt_image_repository_copy_to_film(const int32_t imgid, const int32_t filmid,
1288 const char *new_filename, const char *old_filename)
1289{
1290 int32_t newid = -1;
1291 gchar *filename = NULL;
1292 sqlite3_stmt *stmt;
1293
1294// update database
1295// clang-format off
1296DT_DEBUG_SQLITE3_PREPARE_V2
1297 (dt_database_get_sqlite3_global(),
1298 "INSERT INTO main.images"
1299 " (id, group_id, film_id, width, height, filename, maker, model, lens, exposure,"
1300 " aperture, iso, focal_length, focus_distance, datetime_taken, flags,"
1301 " output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1302 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1303 " license, sha1sum, orientation, histogram, lightmap,"
1304 " longitude, latitude, altitude, color_matrix, colorspace, version, max_version,"
1305 " aspect_ratio, exposure_bias)"
1306 " SELECT NULL, group_id, ?1 as film_id, width, height, ?2 as filename, maker, model, lens,"
1307 " exposure, aperture, iso, focal_length, focus_distance, datetime_taken,"
1308 " flags, width, height, crop, raw_parameters, raw_denoise_threshold,"
1309 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1310 " license, sha1sum, orientation, histogram, lightmap,"
1311 " longitude, latitude, altitude, color_matrix, colorspace, -1, -1,"
1312 " aspect_ratio, exposure_bias"
1313 " FROM main.images"
1314 " WHERE id = ?3",
1315 -1, &stmt, NULL);
1316// clang-format on
1317DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, filmid);
1318DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, new_filename, -1, SQLITE_TRANSIENT);
1319DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, imgid);
1320sqlite3_step(stmt);
1321sqlite3_finalize(stmt);
1322// clang-format off
1323DT_DEBUG_SQLITE3_PREPARE_V2
1324 (dt_database_get_sqlite3_global(),
1325 "SELECT a.id, a.filename"
1326 " FROM main.images AS a"
1327 " JOIN main.images AS b"
1328 " WHERE a.film_id = ?1 AND a.filename = ?2 AND b.filename = ?3 AND b.id = ?4"
1329 " ORDER BY a.id DESC",
1330 -1, &stmt, NULL);
1331// clang-format on
1332DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, filmid);
1333DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, new_filename, -1, SQLITE_TRANSIENT);
1334DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, old_filename, -1, SQLITE_TRANSIENT);
1335DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, imgid);
1336
1337if(sqlite3_step(stmt) == SQLITE_ROW)
1338{
1339 newid = sqlite3_column_int(stmt, 0);
1340 filename = g_strdup((gchar *)sqlite3_column_text(stmt, 1));
1341}
1342sqlite3_finalize(stmt);
1343
1344if(newid != -1)
1345{
1346 // clang-format off
1347 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1348 "INSERT INTO main.color_labels (imgid, color)"
1349 " SELECT ?1, color"
1350 " FROM main.color_labels"
1351 " WHERE imgid = ?2",
1352 -1, &stmt, NULL);
1353 // clang-format on
1354 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1355 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1356 sqlite3_step(stmt);
1357 sqlite3_finalize(stmt);
1358 // clang-format off
1359 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1360 "INSERT INTO main.meta_data (id, key, value)"
1361 " SELECT ?1, key, value"
1362 " FROM main.meta_data"
1363 " WHERE id = ?2",
1364 -1, &stmt, NULL);
1365 // clang-format on
1366 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1367 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1368 sqlite3_step(stmt);
1369 sqlite3_finalize(stmt);
1370
1371 // clang-format off
1372 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1373 "INSERT INTO main.tagged_images (imgid, tagid, position)"
1374 " SELECT ?1, tagid, "
1375 " (SELECT (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000)"
1376 " FROM main.tagged_images)"
1377 " + (ROW_NUMBER() OVER (ORDER BY imgid) << 32)"
1378 " FROM main.tagged_images AS ti"
1379 " WHERE imgid = ?2",
1380 -1, &stmt, NULL);
1381 // clang-format on
1382 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1383 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1384 sqlite3_step(stmt);
1385 sqlite3_finalize(stmt);
1386
1387 // get max_version of image duplicates in destination filmroll
1388 int32_t max_version = -1;
1389 // clang-format off
1390 DT_DEBUG_SQLITE3_PREPARE_V2
1391 (dt_database_get_sqlite3_global(),
1392 "SELECT MAX(a.max_version)"
1393 " FROM main.images AS a"
1394 " JOIN main.images AS b"
1395 " WHERE a.film_id = b.film_id AND a.filename = b.filename AND b.id = ?1",
1396 -1, &stmt, NULL);
1397 // clang-format on
1398 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1399
1400 if(sqlite3_step(stmt) == SQLITE_ROW) max_version = sqlite3_column_int(stmt, 0);
1401 sqlite3_finalize(stmt);
1402
1403 // set version of new entry and max_version of all involved duplicates (with same film_id and
1404 // filename)
1405 max_version = (max_version >= 0) ? max_version + 1 : 0;
1406 int32_t version = max_version;
1407
1408 DT_DEBUG_SQLITE3_PREPARE_V2
1409 (dt_database_get_sqlite3_global(),
1410 "UPDATE main.images SET version=?1 WHERE id = ?2", -1, &stmt, NULL);
1411 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, version);
1412 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, newid);
1413 sqlite3_step(stmt);
1414 sqlite3_finalize(stmt);
1415
1416 DT_DEBUG_SQLITE3_PREPARE_V2
1417 (dt_database_get_sqlite3_global(),
1418 "UPDATE main.images SET max_version=?1 WHERE film_id = ?2 AND filename = ?3",
1419 -1, &stmt, NULL);
1420 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, max_version);
1421 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, filmid);
1422 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, filename, -1, SQLITE_TRANSIENT);
1423 sqlite3_step(stmt);
1424 sqlite3_finalize(stmt);
1425
1426 // image group handling follows
1427 // get group_id of potential image duplicates in destination filmroll
1428 int32_t new_group_id = -1;
1429 // clang-format off
1430 DT_DEBUG_SQLITE3_PREPARE_V2
1431 (dt_database_get_sqlite3_global(),
1432 "SELECT DISTINCT a.group_id"
1433 " FROM main.images AS a"
1434 " JOIN main.images AS b"
1435 " WHERE a.film_id = b.film_id AND a.filename = b.filename"
1436 " AND b.id = ?1 AND a.id != ?1",
1437 -1, &stmt, NULL);
1438 // clang-format on
1439 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, newid);
1440
1441 if(sqlite3_step(stmt) == SQLITE_ROW) new_group_id = sqlite3_column_int(stmt, 0);
1442
1443 // then check if there are further duplicates belonging to different group(s)
1444 if(sqlite3_step(stmt) == SQLITE_ROW) new_group_id = -1;
1445 sqlite3_finalize(stmt);
1446
1447 // rationale:
1448 // if no group exists or if the image duplicates belong to multiple groups, then the
1449 // new image builds a group of its own, else it is added to the (one) existing group
1450 if(new_group_id == -1) new_group_id = newid;
1451
1452 // make copied image belong to a group
1453 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1454 "UPDATE main.images SET group_id=?1 WHERE id = ?2", -1, &stmt, NULL);
1455
1456 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, new_group_id);
1457 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, newid);
1458 sqlite3_step(stmt);
1459 sqlite3_finalize(stmt);
1460
1461 }
1462
1463 dt_free(filename);
1464 return newid;
1465}
1466
1467gboolean dt_image_repository_insert_import(const int32_t film_id, const char *filename,
1468 const int flags, const int64_t import_timestamp)
1469{
1470 sqlite3_stmt *stmt;
1471 //insert a v0 record (which may be updated later if no v0 xmp exists)
1472 // clang-format off
1473 DT_DEBUG_SQLITE3_PREPARE_V2
1474 (dt_database_get_sqlite3_global(),
1475 "INSERT INTO main.images (id, film_id, filename, license, sha1sum, flags, version, "
1476 " max_version, history_end, position, import_timestamp)"
1477 " SELECT NULL, ?1, ?2, '', '', ?3, 0, 0, 0, (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000) + (1 << 32), ?4 "
1478 " FROM images",
1479 -1, &stmt, NULL);
1480 // clang-format on
1481
1482 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, film_id);
1483 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename, -1, SQLITE_TRANSIENT);
1484 DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, flags);
1485 DT_DEBUG_SQLITE3_BIND_INT64(stmt, 4, import_timestamp);
1486
1487 const int rc = sqlite3_step(stmt);
1488 if(rc != SQLITE_DONE) fprintf(stderr, "sqlite3 error %d\n", rc);
1489 sqlite3_finalize(stmt);
1490 return (rc == SQLITE_DONE);
1491}
1492
1493int32_t dt_image_repository_find_group_for_pattern(const int32_t film_id,
1494 const char *filename_pattern,
1495 const gboolean leader_only,
1496 const int32_t exclude_imgid)
1497{
1498 int32_t group_id = -1;
1499 sqlite3_stmt *stmt;
1500
1501 if(leader_only)
1502 {
1503 // clang-format off
1504 DT_DEBUG_SQLITE3_PREPARE_V2
1505 (dt_database_get_sqlite3_global(),
1506 "SELECT group_id"
1507 " FROM main.images"
1508 " WHERE film_id = ?1 AND filename LIKE ?2 AND id = group_id", -1, &stmt,
1509 NULL);
1510 // clang-format on
1511 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, film_id);
1512 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename_pattern, -1, SQLITE_TRANSIENT);
1513 }
1514 else
1515 {
1516 // clang-format off
1517 DT_DEBUG_SQLITE3_PREPARE_V2
1518 (dt_database_get_sqlite3_global(),
1519 "SELECT group_id"
1520 " FROM main.images"
1521 " WHERE film_id = ?1 AND filename LIKE ?2 AND id != ?3", -1, &stmt, NULL);
1522 // clang-format on
1523 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, film_id);
1524 DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, filename_pattern, -1, SQLITE_TRANSIENT);
1525 DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, exclude_imgid);
1526 }
1527
1528 if(sqlite3_step(stmt) == SQLITE_ROW) group_id = sqlite3_column_int(stmt, 0);
1529 sqlite3_finalize(stmt);
1530 return group_id;
1531}
1532
1533gboolean dt_image_repository_set_group(const int32_t imgid, const int32_t group_id)
1534{
1535 sqlite3_stmt *stmt;
1536 DT_DEBUG_SQLITE3_PREPARE_V2
1537 (dt_database_get_sqlite3_global(),
1538 "UPDATE main.images SET group_id = ?1 WHERE id = ?2",
1539 -1, &stmt, NULL);
1540 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, group_id);
1541 DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
1542 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
1543 sqlite3_finalize(stmt);
1544 return ok;
1545}
1546
1547gboolean dt_image_repository_get_xmp_row(const int32_t imgid, dt_image_xmp_row_t *row)
1548{
1549 if(IS_NULL_PTR(row)) return FALSE;
1550 memset(row, 0, sizeof(*row));
1551
1552 gboolean found = FALSE;
1553 sqlite3_stmt *stmt;
1554 // clang-format off
1555 DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get_sqlite3_global(),
1556 "SELECT filename, flags, raw_parameters, "
1557 " longitude, latitude, altitude, history_end, datetime_taken"
1558 " FROM main.images"
1559 " WHERE id = ?1",
1560 -1, &stmt, NULL);
1561 // clang-format on
1562 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1563 if(sqlite3_step(stmt) == SQLITE_ROW)
1564 {
1565 // copied, not borrowed: the caller used to read it before finalising the statement, and
1566 // owning it removes the constraint rather than moving it across a module boundary
1567 const char *f = (const char *)sqlite3_column_text(stmt, 0);
1568 row->filename = f ? g_strdup(f) : NULL;
1569 row->flags = sqlite3_column_int(stmt, 1);
1570 row->raw_parameters = sqlite3_column_int(stmt, 2);
1571 if(sqlite3_column_type(stmt, 3) == SQLITE_FLOAT)
1572 {
1573 row->longitude = sqlite3_column_double(stmt, 3);
1574 row->has_longitude = TRUE;
1575 }
1576 if(sqlite3_column_type(stmt, 4) == SQLITE_FLOAT)
1577 {
1578 row->latitude = sqlite3_column_double(stmt, 4);
1579 row->has_latitude = TRUE;
1580 }
1581 if(sqlite3_column_type(stmt, 5) == SQLITE_FLOAT)
1582 {
1583 row->altitude = sqlite3_column_double(stmt, 5);
1584 row->has_altitude = TRUE;
1585 }
1586 row->history_end = sqlite3_column_int(stmt, 6);
1587 row->datetime_taken = sqlite3_column_int64(stmt, 7);
1588 found = TRUE;
1589 }
1590 sqlite3_finalize(stmt);
1591 return found;
1592}
1593
1594void dt_image_repository_xmp_row_cleanup(dt_image_xmp_row_t *row)
1595{
1596 if(IS_NULL_PTR(row)) return;
1597 dt_free(row->filename);
1598 row->filename = NULL;
1599}
1600
1601gboolean dt_image_repository_get_timestamps(const int32_t imgid, dt_image_timestamps_t *ts)
1602{
1603 if(IS_NULL_PTR(ts)) return FALSE;
1604 memset(ts, 0, sizeof(*ts));
1605
1606 gboolean found = FALSE;
1607 sqlite3_stmt *stmt;
1608 // clang-format off
1609 DT_DEBUG_SQLITE3_PREPARE_V2(
1610 dt_database_get_sqlite3_global(),
1611 "SELECT import_timestamp, change_timestamp, export_timestamp, print_timestamp"
1612 " FROM main.images"
1613 " WHERE id = ?1",
1614 -1, &stmt, NULL);
1615 DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
1616 // clang-format on
1617
1618 if(sqlite3_step(stmt) == SQLITE_ROW)
1619 {
1620 if(sqlite3_column_type(stmt, 0) != SQLITE_NULL)
1621 {
1622 ts->import_timestamp = sqlite3_column_int64(stmt, 0);
1623 ts->has_import = TRUE;
1624 }
1625 if(sqlite3_column_type(stmt, 1) != SQLITE_NULL)
1626 {
1627 ts->change_timestamp = sqlite3_column_int64(stmt, 1);
1628 ts->has_change = TRUE;
1629 }
1630 if(sqlite3_column_type(stmt, 2) != SQLITE_NULL)
1631 {
1632 ts->export_timestamp = sqlite3_column_int64(stmt, 2);
1633 ts->has_export = TRUE;
1634 }
1635 if(sqlite3_column_type(stmt, 3) != SQLITE_NULL)
1636 {
1637 ts->print_timestamp = sqlite3_column_int64(stmt, 3);
1638 ts->has_print = TRUE;
1639 }
1640 found = TRUE;
1641 }
1642 sqlite3_finalize(stmt);
1643 return found;
1644}
1645
1685
1686// clang-format off
1687// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
1688// vim: shiftwidth=2 expandtab tabstop=2 cindent
1689// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
1690// clang-format on
TRUE
#define TRUE
Definition ashift_lsd.c:162
FALSE
#define FALSE
Definition ashift_lsd.c:158
dt_colorlabel_repository_remove
void dt_colorlabel_repository_remove(const int32_t imgid, const int color)
Clear colour color on imgid. Clearing one that is not set does nothing.
Definition colorlabel_repository.c:64
dt_colorlabel_repository_set
void dt_colorlabel_repository_set(const int32_t imgid, const int color)
Set colour color on imgid. Setting one that is already set does nothing.
Definition colorlabel_repository.c:54
colorlabel_repository.h
main.color_labels: which of the five colour labels are set on an image.
f
const float f
Definition colorprofiles/iop_profile.h:541
v
const float v
Definition colorprofiles/iop_profile.h:536
i
const float i
Definition colorspaces_inline_conversions.h:441
L
const float L
Definition colorspaces_inline_conversions.h:494
p
const float p
Definition colorspaces_inline_conversions.h:680
row
static const int row
Definition colorspaces_inline_conversions.h:36
dt_image_init
void dt_image_init(dt_image_t *img)
Definition common/image.c:1909
dt_image_film_roll_name
const char * dt_image_film_roll_name(const char *path)
Definition common/image.c:535
dt_image_set_provisional_dsc
void dt_image_set_provisional_dsc(dt_image_t *img)
Definition common/image.c:394
dt_image_local_copy_paths_from_fullpath
void dt_image_local_copy_paths_from_fullpath(const char *fullpath, int32_t imgid, char *local_copy_path, size_t local_copy_len, char *local_copy_legacy_path, size_t local_copy_legacy_len)
Definition common/image.c:748
dt_database_get_sqlite3_global
sqlite3 * dt_database_get_sqlite3_global(void)
Definition database.c:3790
dt_datetime_gtimespan_to_local
gboolean dt_datetime_gtimespan_to_local(char *local, const size_t local_size, const GTimeSpan gts, const gboolean msec, const gboolean tz)
Definition datetime.c:178
folder
GtkWidget * folder
destination folder chooser
Definition doc_screenshot.c:108
dt_pthread_mutex_unlock
static int dt_pthread_mutex_unlock(dt_pthread_mutex_t *mutex) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Definition dtpthread.h:127
dt_pthread_mutex_init
static int dt_pthread_mutex_init(dt_pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)
Initialise a mutex. With mutexattr NULL – which is how 54 of the 56 call sites in this tree spell it ...
Definition dtpthread.h:104
dt_pthread_mutex_destroy
static int dt_pthread_mutex_destroy(dt_pthread_mutex_t *mutex)
Definition dtpthread.h:132
dt_pthread_mutex_lock
static int dt_pthread_mutex_lock(dt_pthread_mutex_t *mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Definition dtpthread.h:117
color
GdkRGBA color[]
Definition geotagging.c:541
UNKNOWN_IMAGE
#define UNKNOWN_IMAGE
Definition image.h:78
flag
const char flag
Definition image.h:311
dt_image_repository_get_version
int dt_image_repository_get_version(const int32_t imgid)
The duplicate version number of imgid, or 0.
Definition image_repository.c:571
dt_image_repository_touch_write_timestamp
void dt_image_repository_touch_write_timestamp(const int32_t imgid)
Set write_timestamp of imgid to now.
Definition image_repository.c:1004
_image_write_history_hash
static void _image_write_history_hash(const dt_image_t *img)
Definition image_repository.c:188
_image_stmt_mutex_inited
static gsize _image_stmt_mutex_inited
Definition image_repository.c:47
_image_write_timestamp_update_stmt
static sqlite3_stmt * _image_write_timestamp_update_stmt
Definition image_repository.c:43
dt_image_repository_count_others_with_flag
int dt_image_repository_count_others_with_flag(const int32_t imgid, const int flag)
How many OTHER images share this image's film roll and filename and carry flag.
Definition image_repository.c:597
dt_image_repository_count_in_id_range
int dt_image_repository_count_in_id_range(const int32_t min_imgid, const int32_t max_imgid)
How many images have an id in [min_imgid, max_imgid]. -1 when unreadable.
Definition image_repository.c:438
dt_image_repository_set_flags_masked
gboolean dt_image_repository_set_flags_masked(const int32_t imgid, const int mask, const int value)
Write only mask's bits of imgid's flags, taking them from value.
Definition image_repository.c:756
dt_image_repository_get_ids_with_flag_among
GList * dt_image_repository_get_ids_with_flag_among(GList *imgids, const int flag)
Of the images in imgids, those whose flags carry flag, in row order.
Definition image_repository.c:640
dt_image_repository_cleanup
void dt_image_repository_cleanup(void)
Finalise the prepared statements. Called at shutdown, after the last cache release and before the dat...
Definition image_repository.c:1646
_id_set
static char * _id_set(GList *imgids)
Definition image_repository.c:627
dt_image_repository_xmp_row_cleanup
void dt_image_repository_xmp_row_cleanup(dt_image_xmp_row_t *row)
Release what dt_image_repository_get_xmp_row() allocated.
Definition image_repository.c:1594
dt_image_repository_get_write_timestamp
int64_t dt_image_repository_get_write_timestamp(const int32_t imgid)
main.images.write_timestamp for imgid, or 0.
Definition image_repository.c:975
dt_image_repository_set_group
gboolean dt_image_repository_set_group(const int32_t imgid, const int32_t group_id)
Set imgid's group_id.
Definition image_repository.c:1533
_image_write_timestamp_select_stmt
static sqlite3_stmt * _image_write_timestamp_select_stmt
Definition image_repository.c:42
dt_image_repository_set_write_timestamp
gboolean dt_image_repository_set_write_timestamp(const int32_t imgid, const int64_t timestamp)
Set write_timestamp of imgid to timestamp (seconds since the epoch). Bound as a 64-bit integer; the c...
Definition image_repository.c:1027
dt_image_group_member_free
void dt_image_group_member_free(gpointer data)
Free one dt_image_group_member_t. Suits g_list_free_full().
Definition image_repository.c:399
dt_image_repository_get_collected_geo_bounds
gboolean dt_image_repository_get_collected_geo_bounds(dt_image_geo_bounds_t *bounds)
Bounding box of every collected image carrying coordinates.
Definition image_repository.c:891
dt_image_repository_foreach_collected
void dt_image_repository_foreach_collected(dt_image_repository_collected_cb cb, void *user_data)
Every image of the current collection, in collection order, already mapped.
Definition image_repository.c:245
dt_image_repository_load
gboolean dt_image_repository_load(const int32_t imgid, dt_image_t *img)
Fill img from the main.images row for imgid.
Definition image_repository.c:217
_image_set_flags_stmt
static sqlite3_stmt * _image_set_flags_stmt
Definition image_repository.c:44
dt_image_repository_find_group_for_pattern
int32_t dt_image_repository_find_group_for_pattern(const int32_t film_id, const char *filename_pattern, const gboolean leader_only, const int32_t exclude_imgid)
The group leader of an existing image in film_id matching filename_pattern (a LIKE pattern),...
Definition image_repository.c:1493
dt_image_repository_get_group_member_rows
GList * dt_image_repository_get_group_member_rows(const int32_t group_id)
Every member of group_id, in row order, named. Free with g_list_free_full(list, dt_image_group_member...
Definition image_repository.c:407
dt_image_repository_get_timestamps
gboolean dt_image_repository_get_timestamps(const int32_t imgid, dt_image_timestamps_t *ts)
Read imgid's four timestamps. FALSE when there is no such image.
Definition image_repository.c:1601
dt_image_repository_delete
gboolean dt_image_repository_delete(const int32_t imgid)
Delete imgid from main.images and main.meta_data.
Definition image_repository.c:1045
dt_image_repository_copy_to_film
int32_t dt_image_repository_copy_to_film(const int32_t imgid, const int32_t filmid, const char *new_filename, const char *old_filename)
Copy imgid into film roll filmid under new_filename, returning the new id.
Definition image_repository.c:1287
dt_image_repository_get_versions
GList * dt_image_repository_get_versions(const int32_t film_id, const char *filename, const int name_keyid)
Every version of the file (film_id, filename), in version order, each with the name stored under meta...
Definition image_repository.c:1225
dt_image_repository_set_flags
gboolean dt_image_repository_set_flags(const int32_t imgid, const int flags)
Replace imgid's whole flags word.
Definition image_repository.c:728
_image_set_flags_masked_stmt
static sqlite3_stmt * _image_set_flags_masked_stmt
Definition image_repository.c:45
dt_image_repository_get_duplicate_ids
GList * dt_image_repository_get_duplicate_ids(const int32_t imgid)
Every image id sharing imgid's film roll and filename, itself included, in row order – an image and i...
Definition image_repository.c:1262
_image_load_stmt
static sqlite3_stmt * _image_load_stmt
Definition image_repository.c:40
dt_image_repository_get_ids_with_flag
GList * dt_image_repository_get_ids_with_flag(const int flag)
Every image id whose flags carry flag, in row order.
Definition image_repository.c:711
dt_image_repository_foreach_in_id_range
void dt_image_repository_foreach_in_id_range(const int32_t min_imgid, const int32_t max_imgid, dt_image_repository_id_filename_cb cb, void *user_data)
Walk the images whose id falls in [min_imgid, max_imgid], in row order.
Definition image_repository.c:454
dt_image_repository_get_xmp_row
gboolean dt_image_repository_get_xmp_row(const int32_t imgid, dt_image_xmp_row_t *row)
Read imgid's sidecar fields. FALSE when there is no such image.
Definition image_repository.c:1547
dt_image_repository_clear_flag_among
gboolean dt_image_repository_clear_flag_among(GList *imgids, const int flag)
Clear flag on every image in imgids – the counterpart of dt_image_repository_set_flag_among(),...
Definition image_repository.c:674
_image_stmt_mutex
static dt_pthread_mutex_t _image_stmt_mutex
Definition image_repository.c:46
dt_image_version_free
void dt_image_version_free(gpointer data)
Release one dt_image_version_t. Use with g_list_free_full().
Definition image_repository.c:1217
dt_image_repository_reassign_group
void dt_image_repository_reassign_group(const int32_t from_group_id, const int32_t to_group_id, const int32_t exclude_imgid)
Move every member of from_group_id into to_group_id, except exclude_imgid.
Definition image_repository.c:474
dt_image_repository_duplicate
int32_t dt_image_repository_duplicate(const int32_t imgid, const int32_t newversion)
Duplicate imgid as a new version, returning the new image id (-1 on failure).
Definition image_repository.c:1067
dt_image_from_stmt
static void dt_image_from_stmt(dt_image_t *img, sqlite3_stmt *stmt)
Definition image_repository.c:91
_image_stmt_mutex_ensure
static void _image_stmt_mutex_ensure(void)
Definition image_repository.c:49
dt_image_repository_store
void dt_image_repository_store(const dt_image_t *img)
Write img back to main.images, plus its colour labels and history hash.
Definition image_repository.c:290
dt_image_repository_find_by_film_and_filename
int32_t dt_image_repository_find_by_film_and_filename(const int32_t film_id, const char *filename)
The image id for filename inside film roll film_id, or -1.
Definition image_repository.c:527
_image_get_stmt
static sqlite3_stmt * _image_get_stmt(void)
Definition image_repository.c:58
dt_image_repository_get_ratings
GList * dt_image_repository_get_ratings(const int32_t imgid)
Star ratings, as main.images.flags encodes them: the low three bits, minus one.
Definition image_repository.c:490
dt_image_repository_get_collected_geo_points
dt_image_geo_point_t * dt_image_repository_get_collected_geo_points(const double lon1, const double lon2, const double lat1, const double lat2, int *count)
Collected images inside the box, ordered by longitude ascending.
Definition image_repository.c:927
dt_image_repository_foreach_with_path
void dt_image_repository_foreach_with_path(dt_image_repository_path_row_cb cb, void *user_data)
Walk every image in the library, film roll by film roll, filename within each.
Definition image_repository.c:789
dt_image_repository_set_version
gboolean dt_image_repository_set_version(const int32_t imgid, const int version)
Set both version and max_version of imgid to version.
Definition image_repository.c:584
dt_image_repository_find_by_folder_and_filename
int32_t dt_image_repository_find_by_folder_and_filename(const char *folder, const char *filename)
The image id for a full path, split into its folder and filename, or -1.
Definition image_repository.c:543
dt_image_repository_set_flag_among
gboolean dt_image_repository_set_flag_among(GList *imgids, const int flag)
Set flag on every image in imgids.
Definition image_repository.c:658
dt_image_repository_get_group_members
GList * dt_image_repository_get_group_members(const int32_t group_id, const int32_t exclude_imgid)
Image ids in group group_id.
Definition image_repository.c:390
dt_image_repository_get_full_paths
GList * dt_image_repository_get_full_paths(GList *imgids)
"<folder>/<filename>" for every image in imgids, distinct, in row order. Caller owns the strings.
Definition image_repository.c:690
dt_image_repository_count_distinct_fields
int * dt_image_repository_count_distinct_fields(GList *imgids)
How many DISTINCT values each dt_image_field_t takes over imgids.
Definition image_repository.c:819
_image_write_history_hash_stmt
static sqlite3_stmt * _image_write_history_hash_stmt
Definition image_repository.c:41
dt_image_repository_insert_import
gboolean dt_image_repository_insert_import(const int32_t film_id, const char *filename, const int flags, const int64_t import_timestamp)
Insert a bare row for a file being imported, returning TRUE on success.
Definition image_repository.c:1467
_collect_ids
static GList * _collect_ids(sqlite3_stmt *stmt, const int32_t exclude_imgid)
Definition image_repository.c:378
image_repository.h
Reading and writing one dt_image_t to and from the library database. The SQL half of what used to be ...
DT_IMAGE_FIELD_COUNT
@ DT_IMAGE_FIELD_COUNT
Definition image_repository.h:408
dt_image_repository_path_row_cb
gboolean(* dt_image_repository_path_row_cb)(const int32_t imgid, const int64_t write_timestamp, const int version, const char *image_path, const int flags, void *user_data)
One row of dt_image_repository_foreach_with_path(). image_path is borrowed: it lives until the callba...
Definition image_repository.h:289
dt_image_repository_id_filename_cb
void(* dt_image_repository_id_filename_cb)(const int32_t imgid, const char *filename, void *user_data)
One row of dt_image_repository_foreach_in_id_range(). filename is borrowed.
Definition image_repository.h:471
dt_image_repository_collected_cb
void(* dt_image_repository_collected_cb)(void *user_data, const dt_image_t *info)
One image of the current collection. info is borrowed: it lives until the callback returns.
Definition image_repository.h:77
maker
const char * maker
Definition iop/tonecurve.c:453
model
const char * model
Definition iop/tonecurve.c:454
IS_NULL_PTR
#define IS_NULL_PTR(p)
C is way too permissive with !=, == and if(var) checks, which can mean too many things depending on w...
Definition macros.h:96
dt_free
#define dt_free(ptr)
g_free() ptr and set it to NULL, skipping both if it is already NULL.
Definition mem_alloc.h:171
flags
dt_mipmap_buffer_dsc_flags flags
Definition mipmap_cache.c:4
name
const char * name
Definition pdf.h:90
value
static const dt_aligned_pixel_simd_t value
Definition simd.h:144
sql_debug.h
Checked wrappers around the sqlite3_* calls: trace the statement, assert the return code,...
DT_DEBUG_SQLITE3_BIND_BLOB
#define DT_DEBUG_SQLITE3_BIND_BLOB(a, b, c, d, e)
Definition sql_debug.h:149
DT_DEBUG_SQLITE3_PREPARE_V2
#define DT_DEBUG_SQLITE3_PREPARE_V2(a, b, c, d, e)
Definition sql_debug.h:137
DT_DEBUG_SQLITE3_BIND_TEXT
#define DT_DEBUG_SQLITE3_BIND_TEXT(a, b, c, d, e)
Definition sql_debug.h:148
DT_DEBUG_SQLITE3_BIND_INT
#define DT_DEBUG_SQLITE3_BIND_INT(a, b, c)
Definition sql_debug.h:145
DT_DEBUG_SQLITE3_BIND_INT64
#define DT_DEBUG_SQLITE3_BIND_INT64(a, b, c)
Definition sql_debug.h:146
DT_DEBUG_SQLITE3_BIND_DOUBLE
#define DT_DEBUG_SQLITE3_BIND_DOUBLE(a, b, c)
Definition sql_debug.h:147
flip
const float const int flip
Definition src/iop/noise_generator.h:81
dt_image_geo_bounds_t
The extent of the collection's geotagged images.
Definition image_repository.h:324
dt_image_geo_bounds_t::count
int count
Definition image_repository.h:327
dt_image_geo_bounds_t::min_latitude
double min_latitude
Definition image_repository.h:325
dt_image_geo_bounds_t::min_longitude
double min_longitude
Definition image_repository.h:326
dt_image_geo_bounds_t::max_latitude
double max_latitude
Definition image_repository.h:325
dt_image_geo_bounds_t::max_longitude
double max_longitude
Definition image_repository.h:326
dt_image_geo_point_t
One geotagged image, in degrees as stored.
Definition image_repository.h:340
dt_image_geo_point_t::imgid
int32_t imgid
Definition image_repository.h:341
dt_image_geoloc_t::latitude
double latitude
Definition image.h:332
dt_image_geoloc_t::elevation
double elevation
Definition image.h:332
dt_image_geoloc_t::longitude
double longitude
Definition image.h:332
dt_image_group_member_t
One member of a group, with what a tooltip needs to name it.
Definition image_repository.h:454
dt_image_group_member_t::imgid
int32_t imgid
Definition image_repository.h:455
dt_image_raw_parameters_t
Definition image.h:198
dt_image_t
Definition image.h:363
dt_image_t::exif_exposure
float exif_exposure
Definition image.h:367
dt_image_t::height
int32_t height
Definition image.h:397
dt_image_t::export_timestamp
GTimeSpan export_timestamp
Definition image.h:415
dt_image_t::history_hash
uint64_t history_hash
Definition image.h:404
dt_image_t::exif_focus_distance
float exif_focus_distance
Definition image.h:372
dt_image_t::import_timestamp
GTimeSpan import_timestamp
Definition image.h:415
dt_image_t::group_id
int32_t group_id
Definition image.h:401
dt_image_t::exif_exposure_bias
float exif_exposure_bias
Definition image.h:368
dt_image_t::raw_black_level
uint16_t raw_black_level
Definition image.h:437
dt_image_t::exif_iso
float exif_iso
Definition image.h:370
dt_image_t::raw_white_point
uint32_t raw_white_point
Definition image.h:439
dt_image_t::exif_inited
int32_t exif_inited
Definition image.h:365
dt_image_t::exif_aperture
float exif_aperture
Definition image.h:369
dt_image_t::local_copy_path
char local_copy_path[DT_PATH_MAX]
Definition image.h:388
dt_image_t::version
int32_t version
Definition image.h:401
dt_image_t::mipmap_hash
uint64_t mipmap_hash
Definition image.h:411
dt_image_t::geoloc
dt_image_geoloc_t geoloc
Definition image.h:434
dt_image_t::flags
int32_t flags
Definition image.h:401
dt_image_t::orientation
dt_image_orientation_t orientation
Definition image.h:366
dt_image_t::width
int32_t width
Definition image.h:397
dt_image_t::exif_focal_length
float exif_focal_length
Definition image.h:371
dt_image_t::exif_maker
char exif_maker[64]
Definition image.h:374
dt_image_t::change_timestamp
GTimeSpan change_timestamp
Definition image.h:415
dt_image_t::history_items
uint32_t history_items
Definition image.h:403
dt_image_t::exif_lens
char exif_lens[128]
Definition image.h:376
dt_image_t::print_timestamp
GTimeSpan print_timestamp
Definition image.h:415
dt_image_t::film_id
int32_t film_id
Definition image.h:401
dt_image_t::folder
char folder[DT_PATH_MAX]
Definition image.h:390
dt_image_t::exif_datetime_taken
GTimeSpan exif_datetime_taken
Definition image.h:377
dt_image_t::color_labels
int color_labels
Definition image.h:472
dt_image_t::d65_color_matrix
float d65_color_matrix[9]
Definition image.h:421
dt_image_t::filmroll
char filmroll[DT_PATH_MAX]
Definition image.h:391
dt_image_t::exif_model
char exif_model[64]
Definition image.h:375
dt_image_t::colorspace
dt_image_colorspace_t colorspace
Definition image.h:429
dt_image_t::datetime
char datetime[200]
Definition image.h:392
dt_image_t::group_members
uint32_t group_members
Definition image.h:402
dt_image_t::local_copy_legacy_path
char local_copy_legacy_path[DT_PATH_MAX]
Definition image.h:389
dt_image_t::legacy_flip
dt_image_raw_parameters_t legacy_flip
Definition image.h:431
dt_image_t::filename
char filename[DT_MAX_FILENAME_LEN]
Definition image.h:386
dt_image_t::id
int32_t id
Definition image.h:401
dt_image_t::exif_crop
float exif_crop
Definition image.h:373
dt_image_t::fullpath
char fullpath[DT_PATH_MAX]
Definition image.h:387
dt_image_timestamps_t
The four timestamps, each with whether it is set at all.
Definition image_repository.h:199
dt_image_timestamps_t::has_change
gboolean has_change
Definition image_repository.h:201
dt_image_timestamps_t::import_timestamp
int64_t import_timestamp
Definition image_repository.h:200
dt_image_timestamps_t::has_import
gboolean has_import
Definition image_repository.h:201
dt_image_timestamps_t::has_print
gboolean has_print
Definition image_repository.h:201
dt_image_timestamps_t::export_timestamp
int64_t export_timestamp
Definition image_repository.h:200
dt_image_timestamps_t::change_timestamp
int64_t change_timestamp
Definition image_repository.h:200
dt_image_timestamps_t::has_export
gboolean has_export
Definition image_repository.h:201
dt_image_timestamps_t::print_timestamp
int64_t print_timestamp
Definition image_repository.h:200
dt_image_version_t
One version of a file: which duplicate it is, its id, and the name the user gave it.
Definition image_repository.h:133
dt_image_xmp_row_t
The main.images fields an XMP sidecar carries.
Definition image_repository.h:181
MAX
#define MAX(a, b)
Definition thinplate.c:29