66 "SELECT i.id, i.group_id, "
67 " (SELECT COUNT(id) FROM main.images WHERE group_id = i.group_id), "
68 " (SELECT COUNT(imgid) FROM main.history WHERE imgid = i.id), "
69 " COALESCE((SELECT current_hash FROM main.history_hash WHERE imgid = i.id), -1), "
70 " COALESCE((SELECT mipmap_hash FROM main.history_hash WHERE imgid = i.id), -1), "
71 " i.film_id, i.version, i.width, i.height, i.orientation, i.flags, "
72 " i.import_timestamp, i.change_timestamp, i.export_timestamp, i.print_timestamp, "
73 " i.exposure, i.exposure_bias, i.aperture, i.iso, i.focal_length, i.focus_distance, "
74 " i.datetime_taken, i.longitude, i.latitude, i.altitude, "
75 " i.filename, f.folder || '" G_DIR_SEPARATOR_S
"' || i.filename, "
76 " i.maker, i.model, i.lens, f.folder, "
77 " COALESCE((SELECT SUM(1 << color) FROM main.color_labels WHERE imgid=i.id), 0), "
78 " i.crop, i.raw_parameters, i.color_matrix, i.colorspace, "
79 " i.raw_black, i.raw_maximum, i.aspect_ratio, i.output_width, i.output_height"
80 " FROM main.images AS i"
81 " LEFT JOIN main.film_rolls AS f ON f.id = i.film_id"
94 if(sqlite3_column_type(stmt, 0) != SQLITE_NULL) img->
id = sqlite3_column_int(stmt, 0);
95 if(sqlite3_column_type(stmt, 1) != SQLITE_NULL) img->
group_id = sqlite3_column_int(stmt, 1);
96 if(sqlite3_column_type(stmt, 2) != SQLITE_NULL) img->
group_members = (uint32_t)sqlite3_column_int(stmt, 2);
97 if(sqlite3_column_type(stmt, 3) != SQLITE_NULL) img->
history_items = (uint32_t)sqlite3_column_int(stmt, 3);
98 if(sqlite3_column_type(stmt, 4) != SQLITE_NULL) img->
history_hash = sqlite3_column_int64(stmt, 4);
99 if(sqlite3_column_type(stmt, 5) != SQLITE_NULL) img->
mipmap_hash = sqlite3_column_int64(stmt, 5);
100 if(sqlite3_column_type(stmt, 6) != SQLITE_NULL) img->
film_id = sqlite3_column_int(stmt, 6);
101 if(sqlite3_column_type(stmt, 7) != SQLITE_NULL) img->
version = sqlite3_column_int(stmt, 7);
102 if(sqlite3_column_type(stmt, 8) != SQLITE_NULL) img->
width = sqlite3_column_int(stmt, 8);
103 if(sqlite3_column_type(stmt, 9) != SQLITE_NULL) img->
height = sqlite3_column_int(stmt, 9);
104 if(sqlite3_column_type(stmt, 10) != SQLITE_NULL) img->
orientation = sqlite3_column_int(stmt, 10);
105 if(sqlite3_column_type(stmt, 11) != SQLITE_NULL) img->
flags = sqlite3_column_int(stmt, 11);
106 if(sqlite3_column_type(stmt, 12) != SQLITE_NULL) img->
import_timestamp = sqlite3_column_int64(stmt, 12);
107 if(sqlite3_column_type(stmt, 13) != SQLITE_NULL) img->
change_timestamp = sqlite3_column_int64(stmt, 13);
108 if(sqlite3_column_type(stmt, 14) != SQLITE_NULL) img->
export_timestamp = sqlite3_column_int64(stmt, 14);
109 if(sqlite3_column_type(stmt, 15) != SQLITE_NULL) img->
print_timestamp = sqlite3_column_int64(stmt, 15);
110 if(sqlite3_column_type(stmt, 16) != SQLITE_NULL) img->
exif_exposure = sqlite3_column_double(stmt, 16);
111 if(sqlite3_column_type(stmt, 17) != SQLITE_NULL) img->
exif_exposure_bias = sqlite3_column_double(stmt, 17);
112 if(sqlite3_column_type(stmt, 18) != SQLITE_NULL) img->
exif_aperture = sqlite3_column_double(stmt, 18);
113 if(sqlite3_column_type(stmt, 19) != SQLITE_NULL) img->
exif_iso = sqlite3_column_double(stmt, 19);
114 if(sqlite3_column_type(stmt, 20) != SQLITE_NULL) img->
exif_focal_length = sqlite3_column_double(stmt, 20);
115 if(sqlite3_column_type(stmt, 21) != SQLITE_NULL) img->
exif_focus_distance = sqlite3_column_double(stmt, 21);
116 if(sqlite3_column_type(stmt, 22) != SQLITE_NULL) img->
exif_datetime_taken = sqlite3_column_int64(stmt, 22);
117 if(sqlite3_column_type(stmt, 23) != SQLITE_NULL) img->
geoloc.
longitude = sqlite3_column_double(stmt, 23);
118 if(sqlite3_column_type(stmt, 24) != SQLITE_NULL) img->
geoloc.
latitude = sqlite3_column_double(stmt, 24);
119 if(sqlite3_column_type(stmt, 25) != SQLITE_NULL) img->
geoloc.
elevation = sqlite3_column_double(stmt, 25);
121 const char *filename = (
const char *)sqlite3_column_text(stmt, 26);
123 const char *fullpath = (
const char *)sqlite3_column_text(stmt, 27);
125 const char *
maker = (
const char *)sqlite3_column_text(stmt, 28);
127 const char *
model = (
const char *)sqlite3_column_text(stmt, 29);
129 const char *lens = (
const char *)sqlite3_column_text(stmt, 30);
131 const char *
folder = (
const char *)sqlite3_column_text(stmt, 31);
134 if(sqlite3_column_type(stmt, 32) != SQLITE_NULL) img->
color_labels = sqlite3_column_int(stmt, 32);
136 if(sqlite3_column_type(stmt, 33) != SQLITE_NULL) img->
exif_crop = sqlite3_column_double(stmt, 33);
137 if(sqlite3_column_type(stmt, 34) != SQLITE_NULL)
139 uint32_t tmp = sqlite3_column_int(stmt, 34);
155 const void *color_matrix = sqlite3_column_blob(stmt, 35);
160 if(sqlite3_column_type(stmt, 36) != SQLITE_NULL) img->
colorspace = sqlite3_column_int(stmt, 36);
161 if(sqlite3_column_type(stmt, 37) != SQLITE_NULL) img->
raw_black_level = sqlite3_column_int(stmt, 37);
162 if(sqlite3_column_type(stmt, 38) != SQLITE_NULL) img->
raw_white_point = sqlite3_column_int(stmt, 38);
200 "INSERT INTO main.history_hash (imgid, current_hash, basic_hash, auto_hash, mipmap_hash)"
201 " VALUES (?1, ?2, NULL, NULL, ?3)"
202 " ON CONFLICT (imgid)"
203 " DO UPDATE SET current_hash = ?2, basic_hash = NULL, auto_hash = NULL, mipmap_hash = ?3",
209 sqlite3_clear_bindings(stmt);
222 gboolean found =
FALSE;
228 sqlite3_clear_bindings(stmt);
230 const int rc = sqlite3_step(stmt);
236 else if(rc == SQLITE_DONE)
247 fprintf(stderr,
"[image_repository_load] could not read image %" PRId32
" from the database: %s\n",
248 imgid, sqlite3_errstr(rc));
259 sqlite3_stmt *stmt = NULL;
265 "SELECT i.id, i.group_id, "
266 " (SELECT COUNT(id) FROM main.images WHERE group_id = i.group_id), "
267 " (SELECT COUNT(imgid) FROM main.history WHERE imgid = i.id), "
268 " COALESCE((SELECT current_hash FROM main.history_hash WHERE imgid = i.id), -1), "
269 " COALESCE((SELECT mipmap_hash FROM main.history_hash WHERE imgid = i.id), -1), "
270 " i.film_id, i.version, i.width, i.height, i.orientation, i.flags, "
271 " i.import_timestamp, i.change_timestamp, i.export_timestamp, i.print_timestamp, "
272 " i.exposure, i.exposure_bias, i.aperture, i.iso, i.focal_length, i.focus_distance, "
273 " i.datetime_taken, i.longitude, i.latitude, i.altitude, "
274 " i.filename, f.folder || '" G_DIR_SEPARATOR_S
"' || i.filename, "
275 " i.maker, i.model, i.lens, f.folder, "
276 " COALESCE((SELECT SUM(1 << color) FROM main.color_labels WHERE imgid=i.id), 0), "
277 " i.crop, i.raw_parameters, i.color_matrix, i.colorspace, "
278 " i.raw_black, i.raw_maximum, i.aspect_ratio, i.output_width, i.output_height"
279 " FROM main.images AS i"
280 " JOIN memory.collected_images AS c ON i.id = c.imgid"
281 " LEFT JOIN main.film_rolls AS f ON f.id = i.film_id"
282 " ORDER BY c.rowid ASC",
287 while(sqlite3_step(stmt) == SQLITE_ROW)
294 cb(user_data, &info);
296 sqlite3_finalize(stmt);
313 " SET width = ?1, height = ?2, filename = ?3, maker = ?4, model = ?5,"
314 " lens = ?6, exposure = ?7, aperture = ?8, iso = ?9, focal_length = ?10,"
315 " focus_distance = ?11, film_id = ?12, datetime_taken = ?13, flags = ?14,"
316 " crop = ?15, orientation = ?16, raw_parameters = ?17, group_id = ?18,"
317 " longitude = ?19, latitude = ?20, altitude = ?21, color_matrix = ?22,"
318 " colorspace = ?23, raw_black = ?24, raw_maximum = ?25,"
319 " aspect_ratio = ROUND(?26,1), exposure_bias = ?27,"
320 " import_timestamp = ?28, change_timestamp = ?29, export_timestamp = ?30,"
321 " print_timestamp = ?31, output_width = ?32, output_height = ?33"
365 const int rc = sqlite3_step(stmt);
366 if(rc != SQLITE_DONE) fprintf(stderr,
"[image_cache_write_release] sqlite3 error %d\n", rc);
367 sqlite3_finalize(stmt);
388static GList *
_collect_ids(sqlite3_stmt *stmt,
const int32_t exclude_imgid)
391 while(sqlite3_step(stmt) == SQLITE_ROW)
393 const int32_t
id = sqlite3_column_int(stmt, 0);
394 if(
id != exclude_imgid) ids = g_list_prepend(ids, GINT_TO_POINTER(
id));
396 sqlite3_finalize(stmt);
397 return g_list_reverse(ids);
402 sqlite3_stmt *stmt = NULL;
404 "SELECT id FROM main.images WHERE group_id = ?1", -1, &stmt, NULL);
419 GList *members = NULL;
420 sqlite3_stmt *stmt = NULL;
423 "SELECT id, version, filename"
425 " WHERE group_id = ?1", -1, &stmt,
431 while(sqlite3_step(stmt) == SQLITE_ROW)
435 member->
imgid = sqlite3_column_int(stmt, 0);
436 member->
version = sqlite3_column_int(stmt, 1);
437 const char *filename = (
const char *)sqlite3_column_text(stmt, 2);
438 member->
filename = filename ? g_strdup(filename) : NULL;
439 members = g_list_prepend(members, member);
441 sqlite3_finalize(stmt);
445 return g_list_reverse(members);
450 sqlite3_stmt *stmt = NULL;
452 "SELECT COUNT(*) FROM main.images WHERE id >= ?1 AND id <= ?2", -1,
458 const int count = (sqlite3_step(stmt) == SQLITE_ROW) ? sqlite3_column_int(stmt, 0) : -1;
459 sqlite3_finalize(stmt);
470 sqlite3_stmt *stmt = NULL;
472 "SELECT id, filename FROM main.images WHERE id >= ?1 AND id <= ?2", -1,
478 while(sqlite3_step(stmt) == SQLITE_ROW)
479 cb(sqlite3_column_int(stmt, 0), (
const char *)sqlite3_column_text(stmt, 1), user_data);
480 sqlite3_finalize(stmt);
485 const int32_t exclude_imgid)
487 sqlite3_stmt *stmt = NULL;
490 "UPDATE main.images SET group_id = ?1 WHERE group_id = ?2 AND id != ?3",
497 sqlite3_finalize(stmt);
502 sqlite3_stmt *stmt = NULL;
508 "SELECT flags FROM main.images WHERE id IN "
509 "(SELECT imgid FROM main.selected_images)",
517 "SELECT flags FROM main.images WHERE id = ?1", -1, &stmt, NULL);
522 GList *result = NULL;
523 while(sqlite3_step(stmt) == SQLITE_ROW)
525 const int stars = (sqlite3_column_int(stmt, 0) & 0x7) - 1;
526 result = g_list_prepend(result, GINT_TO_POINTER(stars));
528 sqlite3_finalize(stmt);
530 return g_list_reverse(result);
544 "SELECT id FROM main.images WHERE film_id = ?1 AND filename = ?2",
548 if(sqlite3_step(stmt) == SQLITE_ROW)
id=sqlite3_column_int(stmt, 0);
549 sqlite3_finalize(stmt);
562 " FROM main.images, main.film_rolls"
563 " WHERE film_rolls.folder = ?1"
564 " AND images.film_id = film_rolls.id"
565 " AND images.filename = ?2",
570 if(sqlite3_step(stmt) == SQLITE_ROW)
id=sqlite3_column_int(stmt, 0);
571 sqlite3_finalize(stmt);
589 if(sqlite3_step(stmt) == SQLITE_ROW) version = sqlite3_column_int(stmt, 0);
590 sqlite3_finalize(stmt);
599 "UPDATE main.images SET version=?1, max_version = ?1 WHERE id = ?2", -1, &stmt, NULL);
602 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
603 sqlite3_finalize(stmt);
616 " WHERE id!=?1 AND flags&?2=?2"
617 " AND film_id=(SELECT film_id"
620 " AND filename=(SELECT filename"
627 if(sqlite3_step(stmt) == SQLITE_ROW) result = sqlite3_column_int(stmt, 0);
628 sqlite3_finalize(stmt);
641 GString *set = g_string_new(NULL);
642 for(GList *l = imgids; l; l = g_list_next(l))
644 if(l != imgids) g_string_append_c(set,
',');
645 g_string_append_printf(set,
"%d", GPOINTER_TO_INT(l->data));
647 return g_string_free(set,
FALSE);
657 char *query = g_strdup_printf(
"SELECT id FROM main.images WHERE id IN (%s) AND flags&?1=?1", set);
660 while(sqlite3_step(stmt) == SQLITE_ROW)
661 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
662 sqlite3_finalize(stmt);
665 return g_list_reverse(ids);
674 char *query = g_strdup_printf(
"UPDATE main.images SET flags = (flags|?1) WHERE id IN (%s)", set);
677 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
678 sqlite3_finalize(stmt);
690 char *query = g_strdup_printf(
"UPDATE main.images SET flags = (flags & ~?1) WHERE id IN (%s)", set);
693 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
694 sqlite3_finalize(stmt);
708 char *query = g_strdup_printf(
"SELECT DISTINCT folder || '" G_DIR_SEPARATOR_S
"' || filename FROM "
709 "main.images i, main.film_rolls f "
710 "ON i.film_id = f.id WHERE i.id IN (%s)", set);
713 while(sqlite3_step(stmt) == SQLITE_ROW)
714 list = g_list_prepend(list, g_strdup((
const gchar *)sqlite3_column_text(stmt, 0)));
715 sqlite3_finalize(stmt);
718 return g_list_reverse(list);
729 while(sqlite3_step(stmt) == SQLITE_ROW)
730 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
731 sqlite3_finalize(stmt);
735 return g_list_reverse(ids);
740 if(imgid <= 0)
return FALSE;
747 "UPDATE main.images SET flags = ?1 WHERE id = ?2",
768 if(imgid <= 0 || mask == 0)
return FALSE;
778 "UPDATE main.images SET flags = (flags & ~?1) | (?2 & ?1)"
803 sqlite3_stmt *stmt = NULL;
806 "SELECT i.id, write_timestamp, version,"
807 " folder || '" G_DIR_SEPARATOR_S
"' || filename, flags"
808 " FROM main.images i, main.film_rolls f"
809 " ON i.film_id = f.id"
810 " ORDER BY f.id, filename",
815 while(sqlite3_step(stmt) == SQLITE_ROW)
818 if(!cb(sqlite3_column_int(stmt, 0),
819 sqlite3_column_int64(stmt, 1),
820 sqlite3_column_int(stmt, 2),
821 (
const char *)sqlite3_column_text(stmt, 3),
822 sqlite3_column_int(stmt, 4),
826 sqlite3_finalize(stmt);
836 char *query = g_strdup_printf(
"SELECT COUNT(DISTINCT film_id), "
837 "COUNT(DISTINCT film_id), "
839 "COUNT(DISTINCT group_id), "
840 "COUNT(DISTINCT filename), "
841 "COUNT(DISTINCT version), "
842 "COUNT(DISTINCT film_id || '/' || filename), "
843 "COUNT(DISTINCT flags & 2048), "
844 "COUNT(DISTINCT import_timestamp), "
845 "COUNT(DISTINCT change_timestamp), "
846 "COUNT(DISTINCT export_timestamp), "
847 "COUNT(DISTINCT print_timestamp), "
848 "COUNT(DISTINCT flags), "
849 "COUNT(DISTINCT model), "
850 "COUNT(DISTINCT maker), "
851 "COUNT(DISTINCT lens), "
852 "COUNT(DISTINCT aperture), "
853 "COUNT(DISTINCT exposure), "
854 "COUNT(DISTINCT IFNULL(exposure_bias, '')), "
855 "COUNT(DISTINCT focal_length), "
856 "COUNT(DISTINCT focus_distance), "
857 "COUNT(DISTINCT iso), "
858 "COUNT(DISTINCT datetime_taken), "
859 "COUNT(DISTINCT width), "
860 "COUNT(DISTINCT height), "
861 "COUNT(DISTINCT IFNULL(output_width, '')), "
862 "COUNT(DISTINCT IFNULL(output_height, '')), "
863 "(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)), "
864 "(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)), "
865 "(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)), "
866 "(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)), "
867 "(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)), "
868 "(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)), "
869 "(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)), "
870 "(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)), "
871 "COUNT(DISTINCT IFNULL(latitude, '')), "
872 "COUNT(DISTINCT IFNULL(longitude, '')), "
873 "COUNT(DISTINCT IFNULL(altitude, '')) "
876 set, set, set, set, set, set, set, set, set);
879 sqlite3_stmt *stmt = NULL;
886 if(sqlite3_step(stmt) == SQLITE_ROW)
888 const int col_count = sqlite3_column_count(stmt);
893 counts[
i] = sqlite3_column_int(stmt,
i);
896 sqlite3_finalize(stmt);
911 sqlite3_stmt *stmt = NULL;
914 "SELECT MIN(latitude), MAX(latitude),"
915 " MIN(longitude), MAX(longitude), COUNT(*)"
916 " FROM main.images AS i "
917 " JOIN memory.collected_images AS l ON l.imgid = i.id "
918 " WHERE latitude NOT NULL AND longitude NOT NULL",
923 const gboolean ok = (sqlite3_step(stmt) == SQLITE_ROW);
930 bounds->
count = sqlite3_column_int(stmt, 4);
932 sqlite3_finalize(stmt);
938 const double lat1,
const double lat2,
944 sqlite3_stmt *stmt = NULL;
948 " (SELECT i.id, i.longitude, i.latitude "
949 " FROM main.images i INNER JOIN memory.collected_images c ON i.id = c.imgid"
950 " WHERE longitude >= ?1 AND longitude <= ?2"
951 " AND latitude <= ?3 AND latitude >= ?4 "
952 " AND longitude NOT NULL AND latitude NOT NULL)"
953 " ORDER BY longitude ASC",
966 while(sqlite3_step(stmt) == SQLITE_ROW)
969 .longitude = sqlite3_column_double(stmt, 1),
970 .latitude = sqlite3_column_double(stmt, 2) };
971 g_array_append_val(points,
p);
973 sqlite3_finalize(stmt);
975 *count = (int)points->len;
978 g_array_free(points,
TRUE);
987 if(imgid <= 0)
return 0;
994 "SELECT write_timestamp FROM main.images WHERE id = ?1",
1003 int64_t write_timestamp = 0;
1011 return write_timestamp;
1016 if(imgid <= 0)
return;
1024 "UPDATE main.images SET write_timestamp = STRFTIME('%s', 'now') WHERE id = ?1",
1039 if(imgid <= 0)
return FALSE;
1041 sqlite3_stmt *stmt = NULL;
1043 "UPDATE main.images SET write_timestamp = ?2 WHERE id = ?1",
1049 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
1050 sqlite3_finalize(stmt);
1065 ok &= (sqlite3_step(stmt) == SQLITE_DONE);
1066 sqlite3_finalize(stmt);
1069 "DELETE FROM main.meta_data WHERE id = ?1", -1, &stmt, NULL);
1071 ok &= (sqlite3_step(stmt) == SQLITE_DONE);
1072 sqlite3_finalize(stmt);
1085 " FROM main.images AS a JOIN main.images AS b"
1086 " WHERE a.film_id = b.film_id AND a.filename = b.filename"
1087 " AND b.id = ?1 AND a.version = ?2"
1088 " ORDER BY a.id DESC",
1093 if(sqlite3_step(stmt) == SQLITE_ROW)
1095 newid = sqlite3_column_int(stmt, 0);
1097 sqlite3_finalize(stmt);
1100 if(newid != -1)
return newid;
1105 "INSERT INTO main.images"
1106 " (id, group_id, film_id, width, height, filename, maker, model, lens, exposure,"
1107 " aperture, iso, focal_length, focus_distance, datetime_taken, flags,"
1108 " output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1109 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1110 " license, sha1sum, orientation, histogram, lightmap,"
1111 " longitude, latitude, altitude, color_matrix, colorspace, version, max_version, history_end,"
1112 " aspect_ratio, exposure_bias, import_timestamp)"
1113 " SELECT NULL, group_id, film_id, width, height, filename, maker, model, lens,"
1114 " exposure, aperture, iso, focal_length, focus_distance, datetime_taken,"
1115 " flags, output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1116 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1117 " license, sha1sum, orientation, histogram, lightmap,"
1118 " longitude, latitude, altitude, color_matrix, colorspace, NULL, NULL, 0,"
1119 " aspect_ratio, exposure_bias, import_timestamp"
1120 " FROM main.images WHERE id = ?1",
1125 sqlite3_finalize(stmt);
1128 "SELECT a.id, a.film_id, a.filename, b.max_version"
1129 " FROM main.images AS a JOIN main.images AS b"
1130 " WHERE a.film_id = b.film_id AND a.filename = b.filename AND b.id = ?1"
1131 " ORDER BY a.id DESC",
1137 int32_t max_version = -1;
1138 gchar *filename = NULL;
1139 if(sqlite3_step(stmt) == SQLITE_ROW)
1141 newid = sqlite3_column_int(stmt, 0);
1142 film_id = sqlite3_column_int(stmt, 1);
1143 filename = g_strdup((gchar *)sqlite3_column_text(stmt, 2));
1144 max_version = sqlite3_column_int(stmt, 3);
1146 sqlite3_finalize(stmt);
1152 "INSERT INTO main.color_labels (imgid, color)"
1153 " SELECT ?1, color FROM main.color_labels WHERE imgid = ?2",
1159 sqlite3_finalize(stmt);
1163 "INSERT INTO main.meta_data (id, key, value)"
1164 " SELECT ?1, key, value FROM main.meta_data WHERE id = ?2",
1170 sqlite3_finalize(stmt);
1174 "INSERT INTO main.tagged_images (imgid, tagid, position)"
1175 " SELECT ?1, tagid, "
1176 " (SELECT (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000)"
1177 " FROM main.tagged_images)"
1178 " + (ROW_NUMBER() OVER (ORDER BY imgid) << 32)"
1179 " FROM main.tagged_images AS ti"
1180 " WHERE imgid = ?2",
1186 sqlite3_finalize(stmt);
1190 "INSERT INTO main.module_order (imgid, iop_list, version)"
1191 " SELECT ?1, iop_list, version FROM main.module_order WHERE imgid = ?2",
1197 sqlite3_finalize(stmt);
1201 const int32_t version = (newversion != -1) ? newversion : max_version + 1;
1202 max_version = (newversion != -1) ?
MAX(max_version, newversion) : max_version + 1;
1209 sqlite3_finalize(stmt);
1213 "UPDATE main.images SET max_version=?1 WHERE film_id = ?2 AND filename = ?3", -1,
1220 sqlite3_finalize(stmt);
1236 const int name_keyid)
1243 "SELECT i.version, i.id, m.value"
1245 " LEFT JOIN meta_data AS m ON m.id = i.id AND m.key = ?3"
1246 " WHERE film_id = ?1 AND filename = ?2"
1247 " ORDER BY i.version",
1254 GList *versions = NULL;
1255 while(sqlite3_step(stmt) == SQLITE_ROW)
1260 v->version = sqlite3_column_int(stmt, 0);
1261 v->imgid = sqlite3_column_int(stmt, 1);
1262 const char *
name = (
const char *)sqlite3_column_text(stmt, 2);
1263 v->version_name =
name ? g_strdup(
name) : NULL;
1264 versions = g_list_prepend(versions,
v);
1267 sqlite3_finalize(stmt);
1269 return g_list_reverse(versions);
1282 " WHERE filename IN (SELECT filename FROM main.images WHERE id = ?1)"
1283 " AND film_id IN (SELECT film_id FROM main.images WHERE id = ?1)",
1288 while(sqlite3_step(stmt) == SQLITE_ROW)
1289 ids = g_list_prepend(ids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));
1290 sqlite3_finalize(stmt);
1294 return g_list_reverse(ids);
1298 const char *new_filename,
const char *old_filename)
1301 gchar *filename = NULL;
1308 "INSERT INTO main.images"
1309 " (id, group_id, film_id, width, height, filename, maker, model, lens, exposure,"
1310 " aperture, iso, focal_length, focus_distance, datetime_taken, flags,"
1311 " output_width, output_height, crop, raw_parameters, raw_denoise_threshold,"
1312 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1313 " license, sha1sum, orientation, histogram, lightmap,"
1314 " longitude, latitude, altitude, color_matrix, colorspace, version, max_version,"
1315 " aspect_ratio, exposure_bias)"
1316 " SELECT NULL, group_id, ?1 as film_id, width, height, ?2 as filename, maker, model, lens,"
1317 " exposure, aperture, iso, focal_length, focus_distance, datetime_taken,"
1318 " flags, width, height, crop, raw_parameters, raw_denoise_threshold,"
1319 " raw_auto_bright_threshold, raw_black, raw_maximum,"
1320 " license, sha1sum, orientation, histogram, lightmap,"
1321 " longitude, latitude, altitude, color_matrix, colorspace, -1, -1,"
1322 " aspect_ratio, exposure_bias"
1331sqlite3_finalize(stmt);
1335 "SELECT a.id, a.filename"
1336 " FROM main.images AS a"
1337 " JOIN main.images AS b"
1338 " WHERE a.film_id = ?1 AND a.filename = ?2 AND b.filename = ?3 AND b.id = ?4"
1339 " ORDER BY a.id DESC",
1347if(sqlite3_step(stmt) == SQLITE_ROW)
1349 newid = sqlite3_column_int(stmt, 0);
1350 filename = g_strdup((gchar *)sqlite3_column_text(stmt, 1));
1352sqlite3_finalize(stmt);
1358 "INSERT INTO main.color_labels (imgid, color)"
1360 " FROM main.color_labels"
1361 " WHERE imgid = ?2",
1367 sqlite3_finalize(stmt);
1370 "INSERT INTO main.meta_data (id, key, value)"
1371 " SELECT ?1, key, value"
1372 " FROM main.meta_data"
1379 sqlite3_finalize(stmt);
1383 "INSERT INTO main.tagged_images (imgid, tagid, position)"
1384 " SELECT ?1, tagid, "
1385 " (SELECT (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000)"
1386 " FROM main.tagged_images)"
1387 " + (ROW_NUMBER() OVER (ORDER BY imgid) << 32)"
1388 " FROM main.tagged_images AS ti"
1389 " WHERE imgid = ?2",
1395 sqlite3_finalize(stmt);
1398 int32_t max_version = -1;
1402 "SELECT MAX(a.max_version)"
1403 " FROM main.images AS a"
1404 " JOIN main.images AS b"
1405 " WHERE a.film_id = b.film_id AND a.filename = b.filename AND b.id = ?1",
1410 if(sqlite3_step(stmt) == SQLITE_ROW) max_version = sqlite3_column_int(stmt, 0);
1411 sqlite3_finalize(stmt);
1415 max_version = (max_version >= 0) ? max_version + 1 : 0;
1416 int32_t version = max_version;
1420 "UPDATE main.images SET version=?1 WHERE id = ?2", -1, &stmt, NULL);
1424 sqlite3_finalize(stmt);
1428 "UPDATE main.images SET max_version=?1 WHERE film_id = ?2 AND filename = ?3",
1434 sqlite3_finalize(stmt);
1438 int32_t new_group_id = -1;
1442 "SELECT DISTINCT a.group_id"
1443 " FROM main.images AS a"
1444 " JOIN main.images AS b"
1445 " WHERE a.film_id = b.film_id AND a.filename = b.filename"
1446 " AND b.id = ?1 AND a.id != ?1",
1451 if(sqlite3_step(stmt) == SQLITE_ROW) new_group_id = sqlite3_column_int(stmt, 0);
1454 if(sqlite3_step(stmt) == SQLITE_ROW) new_group_id = -1;
1455 sqlite3_finalize(stmt);
1460 if(new_group_id == -1) new_group_id = newid;
1464 "UPDATE main.images SET group_id=?1 WHERE id = ?2", -1, &stmt, NULL);
1469 sqlite3_finalize(stmt);
1478 const int flags,
const int64_t import_timestamp)
1485 "INSERT INTO main.images (id, film_id, filename, license, sha1sum, flags, version, "
1486 " max_version, history_end, position, import_timestamp)"
1487 " SELECT NULL, ?1, ?2, '', '', ?3, 0, 0, 0, (IFNULL(MAX(position),0) & 0xFFFFFFFF00000000) + (1 << 32), ?4 "
1497 const int rc = sqlite3_step(stmt);
1498 if(rc != SQLITE_DONE) fprintf(stderr,
"sqlite3 error %d\n", rc);
1499 sqlite3_finalize(stmt);
1500 return (rc == SQLITE_DONE);
1504 const char *filename_pattern,
1505 const gboolean leader_only,
1506 const int32_t exclude_imgid)
1508 int32_t group_id = -1;
1518 " WHERE film_id = ?1 AND filename LIKE ?2 AND id = group_id", -1, &stmt,
1531 " WHERE film_id = ?1 AND filename LIKE ?2 AND id != ?3", -1, &stmt, NULL);
1538 if(sqlite3_step(stmt) == SQLITE_ROW) group_id = sqlite3_column_int(stmt, 0);
1539 sqlite3_finalize(stmt);
1548 "UPDATE main.images SET group_id = ?1 WHERE id = ?2",
1552 const gboolean ok = (sqlite3_step(stmt) == SQLITE_DONE);
1553 sqlite3_finalize(stmt);
1560 memset(
row, 0,
sizeof(*
row));
1562 gboolean found =
FALSE;
1566 "SELECT filename, flags, raw_parameters, "
1567 " longitude, latitude, altitude, history_end, datetime_taken"
1573 if(sqlite3_step(stmt) == SQLITE_ROW)
1577 const char *
f = (
const char *)sqlite3_column_text(stmt, 0);
1578 row->filename =
f ? g_strdup(
f) : NULL;
1579 row->flags = sqlite3_column_int(stmt, 1);
1580 row->raw_parameters = sqlite3_column_int(stmt, 2);
1581 if(sqlite3_column_type(stmt, 3) == SQLITE_FLOAT)
1583 row->longitude = sqlite3_column_double(stmt, 3);
1586 if(sqlite3_column_type(stmt, 4) == SQLITE_FLOAT)
1588 row->latitude = sqlite3_column_double(stmt, 4);
1591 if(sqlite3_column_type(stmt, 5) == SQLITE_FLOAT)
1593 row->altitude = sqlite3_column_double(stmt, 5);
1596 row->history_end = sqlite3_column_int(stmt, 6);
1597 row->datetime_taken = sqlite3_column_int64(stmt, 7);
1600 sqlite3_finalize(stmt);
1608 row->filename = NULL;
1614 memset(ts, 0,
sizeof(*ts));
1616 gboolean found =
FALSE;
1621 "SELECT import_timestamp, change_timestamp, export_timestamp, print_timestamp"
1628 if(sqlite3_step(stmt) == SQLITE_ROW)
1630 if(sqlite3_column_type(stmt, 0) != SQLITE_NULL)
1635 if(sqlite3_column_type(stmt, 1) != SQLITE_NULL)
1640 if(sqlite3_column_type(stmt, 2) != SQLITE_NULL)
1645 if(sqlite3_column_type(stmt, 3) != SQLITE_NULL)
1652 sqlite3_finalize(stmt);
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.
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.
main.color_labels: which of the five colour labels are set on an image.
void dt_image_init(dt_image_t *img)
const char * dt_image_film_roll_name(const char *path)
void dt_image_set_provisional_dsc(dt_image_t *img)
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)
sqlite3 * dt_database_get_sqlite3_global(void)
gboolean dt_datetime_gtimespan_to_local(char *local, const size_t local_size, const GTimeSpan gts, const gboolean msec, const gboolean tz)
GtkWidget * folder
destination folder chooser
static int dt_pthread_mutex_unlock(dt_pthread_mutex_t *mutex) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
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 ...
static int dt_pthread_mutex_destroy(dt_pthread_mutex_t *mutex)
static int dt_pthread_mutex_lock(dt_pthread_mutex_t *mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
memcpy(roundtrip, origin, sizeof(roundtrip))
int dt_image_repository_get_version(const int32_t imgid)
The duplicate version number of imgid, or 0.
void dt_image_repository_touch_write_timestamp(const int32_t imgid)
Set write_timestamp of imgid to now.
static void _image_write_history_hash(const dt_image_t *img)
static gsize _image_stmt_mutex_inited
static sqlite3_stmt * _image_write_timestamp_update_stmt
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.
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.
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.
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.
void dt_image_repository_cleanup(void)
Finalise the prepared statements. Called at shutdown, after the last cache release and before the dat...
static char * _id_set(GList *imgids)
void dt_image_repository_xmp_row_cleanup(dt_image_xmp_row_t *row)
Release what dt_image_repository_get_xmp_row() allocated.
int64_t dt_image_repository_get_write_timestamp(const int32_t imgid)
main.images.write_timestamp for imgid, or 0.
gboolean dt_image_repository_set_group(const int32_t imgid, const int32_t group_id)
Set imgid's group_id.
static sqlite3_stmt * _image_write_timestamp_select_stmt
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...
void dt_image_group_member_free(gpointer data)
Free one dt_image_group_member_t. Suits g_list_free_full().
gboolean dt_image_repository_get_collected_geo_bounds(dt_image_geo_bounds_t *bounds)
Bounding box of every collected image carrying coordinates.
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.
gboolean dt_image_repository_load(const int32_t imgid, dt_image_t *img)
Fill img from the main.images row for imgid.
static sqlite3_stmt * _image_set_flags_stmt
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),...
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...
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.
gboolean dt_image_repository_delete(const int32_t imgid)
Delete imgid from main.images and main.meta_data.
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.
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...
gboolean dt_image_repository_set_flags(const int32_t imgid, const int flags)
Replace imgid's whole flags word.
static sqlite3_stmt * _image_set_flags_masked_stmt
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...
static sqlite3_stmt * _image_load_stmt
GList * dt_image_repository_get_ids_with_flag(const int flag)
Every image id whose flags carry flag, in row order.
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.
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.
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(),...
static dt_pthread_mutex_t _image_stmt_mutex
void dt_image_version_free(gpointer data)
Release one dt_image_version_t. Use with g_list_free_full().
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.
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).
static void dt_image_from_stmt(dt_image_t *img, sqlite3_stmt *stmt)
static void _image_stmt_mutex_ensure(void)
void dt_image_repository_store(const dt_image_t *img)
Write img back to main.images, plus its colour labels and history hash.
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.
static sqlite3_stmt * _image_get_stmt(void)
GList * dt_image_repository_get_ratings(const int32_t imgid)
Star ratings, as main.images.flags encodes them: the low three bits, minus one.
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.
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.
gboolean dt_image_repository_set_version(const int32_t imgid, const int version)
Set both version and max_version of imgid to version.
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.
gboolean dt_image_repository_set_flag_among(GList *imgids, const int flag)
Set flag on every image in imgids.
GList * dt_image_repository_get_group_members(const int32_t group_id, const int32_t exclude_imgid)
Image ids in group group_id.
GList * dt_image_repository_get_full_paths(GList *imgids)
"<folder>/<filename>" for every image in imgids, distinct, in row order. Caller owns the strings.
int * dt_image_repository_count_distinct_fields(GList *imgids)
How many DISTINCT values each dt_image_field_t takes over imgids.
static sqlite3_stmt * _image_write_history_hash_stmt
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.
static GList * _collect_ids(sqlite3_stmt *stmt, const int32_t exclude_imgid)
Reading and writing one dt_image_t to and from the library database. The SQL half of what used to be ...
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...
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.
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.
#define IS_NULL_PTR(p)
C is way too permissive with !=, == and if(var) checks, which can mean too many things depending on w...
#define dt_free(ptr)
g_free() ptr and set it to NULL, skipping both if it is already NULL.
dt_mipmap_buffer_dsc_flags flags
Checked wrappers around the sqlite3_* calls: trace the statement, assert the return code,...
#define DT_DEBUG_SQLITE3_BIND_BLOB(a, b, c, d, e)
#define DT_DEBUG_SQLITE3_PREPARE_V2(a, b, c, d, e)
#define DT_DEBUG_SQLITE3_BIND_TEXT(a, b, c, d, e)
#define DT_DEBUG_SQLITE3_BIND_INT(a, b, c)
#define DT_DEBUG_SQLITE3_BIND_INT64(a, b, c)
#define DT_DEBUG_SQLITE3_BIND_DOUBLE(a, b, c)
const float const int flip
The extent of the collection's geotagged images.
One geotagged image, in degrees as stored.
One member of a group, with what a tooltip needs to name it.
GTimeSpan export_timestamp
float exif_focus_distance
GTimeSpan import_timestamp
char local_copy_path[DT_PATH_MAX]
dt_image_orientation_t orientation
GTimeSpan change_timestamp
GTimeSpan print_timestamp
GTimeSpan exif_datetime_taken
float d65_color_matrix[9]
char filmroll[DT_PATH_MAX]
dt_image_colorspace_t colorspace
char local_copy_legacy_path[DT_PATH_MAX]
dt_image_raw_parameters_t legacy_flip
char filename[DT_MAX_FILENAME_LEN]
char fullpath[DT_PATH_MAX]
The four timestamps, each with whether it is set at all.
One version of a file: which duplicate it is, its id, and the name the user gave it.
The main.images fields an XMP sidecar carries.