lensserious_db.c

Go to the documentation of this file.

/*
    LensSerious — reading the lens database.
 
    Copyright (C) 2026 Aurélien PIERRE.  License: LGPL-3.0-or-later.
 
    See include/lensserious_db.h for the contract. The short version: the file is opened
    read-only and immutable, so SQLite takes no file locks and keeps no shared state; the
    handle is opened NOMUTEX, so SQLite takes no mutex either. Neither does this file.
    What makes that safe is that a database is replaced by rename and never edited.
*/
 
#include "lensserious_db.h"
 
#include <sqlite3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define LS_DB_SCHEMA_VERSION 4
 
struct ls_db_t
{
  sqlite3 *sql;
  int schema_version;
  char error[256];
};
 
static void _db_err(ls_db_t *db, const char *what)
{
  if(!db) return;
  const char *detail = db->sql ? sqlite3_errmsg(db->sql) : "no connection";
  snprintf(db->error, sizeof(db->error), "%s: %s", what, detail);
}
 
static char *_db_build_uri(const char *path)
{
  if(!path || !*path) return NULL;
 
  const int is_uri = strncmp(path, "file:", 5) == 0;
  const size_t len = strlen(path);
  /* Worst case: every byte percent-encoded, plus the scheme and our parameters. */
  char *uri = (char *)malloc(len * 3 + 64);
  if(!uri) return NULL;
 
  size_t w = 0;
  if(is_uri)
  {
    memcpy(uri, path, len);
    w = len;
  }
  else
  {
    memcpy(uri, "file:", 5);
    w = 5;
    for(size_t i = 0; i < len; i++)
    {
      const unsigned char c = (unsigned char)path[i];
      if(c == '?' || c == '#' || c == '%')
      {
        static const char hex[] = "0123456789ABCDEF";
        uri[w++] = '%';
        uri[w++] = hex[c >> 4];
        uri[w++] = hex[c & 0xF];
      }
      else
        uri[w++] = (char)c;
    }
  }
 
  const char *sep = strchr(uri, '?') ? "&" : "?";
  w += (size_t)snprintf(uri + w, 64, "%smode=ro&immutable=1", sep);
  uri[w] = '\0';
  return uri;
}
 
ls_db_t *ls_db_open(const char *path)
{
  char *uri = _db_build_uri(path);
  if(!uri) return NULL;
 
  ls_db_t *db = (ls_db_t *)calloc(1, sizeof(ls_db_t));
  if(!db)
  {
    free(uri);
    return NULL;
  }
  db->schema_version = -1;
 
  /* NOMUTEX: this handle belongs to one thread and SQLite need not defend it. READONLY
   * and the immutable URI parameter between them mean no locking at all. */
  const int rc = sqlite3_open_v2(uri, &db->sql,
                                 SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_URI,
                                 NULL);
  free(uri);
  if(rc != SQLITE_OK)
  {
    ls_db_close(db);
    return NULL;
  }
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "PRAGMA user_version", -1, &st, NULL) == SQLITE_OK
     && sqlite3_step(st) == SQLITE_ROW)
    db->schema_version = sqlite3_column_int(st, 0);
  sqlite3_finalize(st);
 
  if(db->schema_version != LS_DB_SCHEMA_VERSION)
  {
    ls_db_close(db);
    return NULL;
  }
  return db;
}
 
void ls_db_close(ls_db_t *db)
{
  if(!db) return;
  if(db->sql) sqlite3_close(db->sql);
  free(db);
}
 
const char *ls_db_error(const ls_db_t *db)
{
  return (db && db->error[0]) ? db->error : NULL;
}
 
int ls_db_schema_version(const ls_db_t *db)
{
  return db ? db->schema_version : -1;
}
 
/* ------------------------------------------------------------------------- */
/* Name normalisation. Must match tools/import_lensfun_xml.c byte for byte,   */
/* since that is what filled the `norm` columns being compared against.       */
/* ------------------------------------------------------------------------- */
 
size_t ls_db_normalize(const char *in, char *out, size_t out_size)
{
  if(!out || out_size == 0) return 0;
  size_t w = 0;
  int pending_space = 0;
 
  for(const unsigned char *p = (const unsigned char *)(in ? in : ""); *p; p++)
  {
    unsigned char c = *p;
    if(c <= ' ' || c == '_' || c == '-' || c == '/' || c == '\\' || c == ',' || c == '.'
       || c == '(' || c == ')' || c == '[' || c == ']' || c == '\'' || c == '"' || c == ':'
       || c == ';' || c == '+' || c == '*')
    {
      if(w > 0) pending_space = 1;
      continue;
    }
    if(c >= 'A' && c <= 'Z') c = (unsigned char)(c - 'A' + 'a');
 
    if(pending_space)
    {
      if(w + 1 >= out_size) break;
      out[w++] = ' ';
      pending_space = 0;
    }
    if(w + 1 >= out_size) break;
    out[w++] = (char)c;
  }
  out[w] = '\0';
  return w;
}
 
/* ------------------------------------------------------------------------- */
 
static int _fill_calibrations(ls_db_t *db, long long lens_id, ls_lens_t *out)
{
  static const struct
  {
    const char *sql;
    int terms;
  } q[3] = {
    { "SELECT model, focal, t0, t1, t2 FROM calib_distortion WHERE lens_id = ?1 ORDER BY ord", 3 },
    { "SELECT model, focal, t0, t1, t2, t3, t4, t5 FROM calib_tca WHERE lens_id = ?1 ORDER BY ord", 6 },
    { "SELECT model, focal, aperture, distance, t0, t1, t2 FROM calib_vignetting WHERE lens_id = ?1 ORDER BY ord", 3 },
  };
 
  for(int kind = 0; kind < 3; kind++)
  {
    sqlite3_stmt *st = NULL;
    if(sqlite3_prepare_v2(db->sql, q[kind].sql, -1, &st, NULL) != SQLITE_OK)
    {
      _db_err(db, "prepare calibration");
      return -1;
    }
    sqlite3_bind_int64(st, 1, lens_id);
 
    int n = 0;
    int overflow = 0;
    while(sqlite3_step(st) == SQLITE_ROW)
    {
      if(n >= LS_MAX_CALIB)
      {
        overflow = 1;
        break;
      }
      const int model = sqlite3_column_int(st, 0);
      const float focal = (float)sqlite3_column_double(st, 1);
 
      if(kind == 0)
      {
        ls_calib_dist_t *c = &out->dist[n];
        c->model = (ls_dist_model_t)model;
        c->focal = focal;
        for(int t = 0; t < 3; t++) c->terms[t] = (float)sqlite3_column_double(st, 2 + t);
      }
      else if(kind == 1)
      {
        ls_calib_tca_t *c = &out->tca[n];
        c->model = (ls_tca_model_t)model;
        c->focal = focal;
        for(int t = 0; t < 6; t++) c->terms[t] = (float)sqlite3_column_double(st, 2 + t);
      }
      else
      {
        ls_calib_vig_t *c = &out->vig[n];
        c->model = (ls_vig_model_t)model;
        c->focal = focal;
        c->aperture = (float)sqlite3_column_double(st, 2);
        c->distance = (float)sqlite3_column_double(st, 3);
        for(int t = 0; t < 3; t++) c->terms[t] = (float)sqlite3_column_double(st, 4 + t);
      }
      n++;
    }
    sqlite3_finalize(st);
 
    if(overflow)
    {
      /* Truncating would corrupt both the IDW weighting and the spline neighbours, so this
       * is an error rather than a partial answer. LS_MAX_CALIB is 512 against a densest
       * real lens of 440 vignetting points; a database that trips this needs the constant
       * raised, not the rows dropped. */
      snprintf(db->error, sizeof(db->error),
               "lens %lld has more than %d calibration entries of one kind",
               lens_id, (int)LS_MAX_CALIB);
      return -1;
    }
 
    if(kind == 0) out->n_dist = n;
    else if(kind == 1) out->n_tca = n;
    else out->n_vig = n;
  }
 
  /* <real-focal-length>. Its own query rather than a fourth entry in the table above: it
   * has no model and no terms, and bending the shared loop around that would cost more than
   * the six lines it saves. It is also ordered by focal rather than by ord, because the
   * spline picks neighbours by focal distance and a file written in any other order would
   * still have to be sorted somewhere. */
  {
    sqlite3_stmt *st = NULL;
    if(sqlite3_prepare_v2(db->sql,
                          "SELECT focal, real_focal FROM lens_real_focal WHERE lens_id = ?1"
                          " ORDER BY focal", -1, &st, NULL) != SQLITE_OK)
    {
      _db_err(db, "prepare real focal");
      return -1;
    }
    sqlite3_bind_int64(st, 1, lens_id);
    int n = 0;
    while(sqlite3_step(st) == SQLITE_ROW && n < LS_MAX_CALIB)
    {
      out->real_focal[n].focal = (float)sqlite3_column_double(st, 0);
      out->real_focal[n].real_focal = (float)sqlite3_column_double(st, 1);
      n++;
    }
    sqlite3_finalize(st);
    out->n_real_focal = n;
  }
  return 0;
}
 
int ls_db_lens_by_id(ls_db_t *db, long long lens_id, ls_lens_t *out)
{
  if(!db || !db->sql || !out) return -1;
  memset(out, 0, sizeof(*out));
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT type, crop_factor, aspect_ratio, center_x, center_y,"
                        "       min_focal, max_focal FROM lens WHERE id = ?1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lens");
    return -1;
  }
  sqlite3_bind_int64(st, 1, lens_id);
 
  if(sqlite3_step(st) != SQLITE_ROW)
  {
    sqlite3_finalize(st);
    return 0;
  }
  out->type = (ls_lens_type_t)sqlite3_column_int(st, 0);
  out->crop_factor = (float)sqlite3_column_double(st, 1);
  out->aspect_ratio = (float)sqlite3_column_double(st, 2);
  out->center_x = (float)sqlite3_column_double(st, 3);
  out->center_y = (float)sqlite3_column_double(st, 4);
  out->min_focal = (float)sqlite3_column_double(st, 5);
  out->max_focal = (float)sqlite3_column_double(st, 6);
  sqlite3_finalize(st);
 
  return (_fill_calibrations(db, lens_id, out) == 0) ? 1 : -1;
}
 
static long long _find_lens_id(ls_db_t *db, const char *maker, const char *model, float crop)
{
  char nmodel[512], nmaker[512];
  ls_db_normalize(model, nmodel, sizeof(nmodel));
  ls_db_normalize(maker, nmaker, sizeof(nmaker));
 
  /* One statement whether or not a maker was given: ?3 < 0 disables the maker test, so
   * there is a single query plan to reason about rather than two that can drift. */
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT l.id FROM lens l"
                        " JOIN lens_name m ON m.lens_id = l.id AND m.kind = 'model' AND m.norm = ?1"
                        " WHERE (?3 = 0 OR EXISTS (SELECT 1 FROM lens_name k"
                        "        WHERE k.lens_id = l.id AND k.kind = 'maker' AND k.norm = ?2))"
                        " ORDER BY abs(l.crop_factor - ?4) ASC, l.id ASC LIMIT 1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lens lookup");
    return -1;
  }
  sqlite3_bind_text(st, 1, nmodel, -1, SQLITE_STATIC);
  sqlite3_bind_text(st, 2, nmaker, -1, SQLITE_STATIC);
  sqlite3_bind_int(st, 3, (maker && *nmaker) ? 1 : 0);
  sqlite3_bind_double(st, 4, (crop > 0.f) ? (double)crop : 0.0);
 
  long long id = 0;
  if(sqlite3_step(st) == SQLITE_ROW) id = sqlite3_column_int64(st, 0);
  sqlite3_finalize(st);
  return id;
}
 
int ls_db_find_lens(ls_db_t *db, const char *maker, const char *model, float crop,
                    ls_lens_t *out)
{
  if(!db || !db->sql || !model || !out) return -1;
 
  const long long id = _find_lens_id(db, maker, model, crop);
  if(id < 0) return -1;
  if(id == 0) return 0;
  return ls_db_lens_by_id(db, id, out);
}
 
int ls_db_find_camera(ls_db_t *db, const char *maker, const char *model, ls_camera_t *out)
{
  if(!db || !db->sql || !model || !out) return -1;
  memset(out, 0, sizeof(*out));
 
  char nmodel[512], nmaker[512];
  ls_db_normalize(model, nmodel, sizeof(nmodel));
  ls_db_normalize(maker, nmaker, sizeof(nmaker));
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT c.crop_factor, ifnull(c.mount_id, 0), c.id FROM camera c"
                        " JOIN camera_name m ON m.camera_id = c.id AND m.kind = 'model' AND m.norm = ?1"
                        " WHERE (?3 = 0 OR EXISTS (SELECT 1 FROM camera_name k"
                        "        WHERE k.camera_id = c.id AND k.kind = 'maker' AND k.norm = ?2))"
                        " ORDER BY c.id ASC LIMIT 1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare camera lookup");
    return -1;
  }
  sqlite3_bind_text(st, 1, nmodel, -1, SQLITE_STATIC);
  sqlite3_bind_text(st, 2, nmaker, -1, SQLITE_STATIC);
  sqlite3_bind_int(st, 3, (maker && *nmaker) ? 1 : 0);
 
  int found = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    out->crop_factor = (float)sqlite3_column_double(st, 0);
    out->mount_id = sqlite3_column_int64(st, 1);
    out->id = sqlite3_column_int64(st, 2);
    found = 1;
  }
  sqlite3_finalize(st);
  return found;
}
 
int ls_db_lens_fits_mount(ls_db_t *db, long long lens_id, long long mount_id)
{
  if(!db || !db->sql) return -1;
  if(mount_id <= 0) return 0;
 
  sqlite3_stmt *st = NULL;
  /* Direct fit, or the camera's mount declares the lens's mount compatible. */
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT 1 FROM lens_mount lm WHERE lm.lens_id = ?1 AND ("
                        "  lm.mount_id = ?2"
                        "  OR EXISTS (SELECT 1 FROM mount_compat mc"
                        "             WHERE mc.mount_id = ?2 AND mc.compat_id = lm.mount_id))"
                        " LIMIT 1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare mount test");
    return -1;
  }
  sqlite3_bind_int64(st, 1, lens_id);
  sqlite3_bind_int64(st, 2, mount_id);
  const int fits = (sqlite3_step(st) == SQLITE_ROW) ? 1 : 0;
  sqlite3_finalize(st);
  return fits;
}
 
int ls_db_list_lenses(ls_db_t *db, long long *out_ids, int max)
{
  if(!db || !db->sql) return -1;
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT id FROM lens ORDER BY id ASC", -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lens list");
    return -1;
  }
  int n = 0;
  while(sqlite3_step(st) == SQLITE_ROW)
  {
    if(out_ids)
    {
      if(n >= max) break;
      out_ids[n] = sqlite3_column_int64(st, 0);
    }
    n++;
  }
  sqlite3_finalize(st);
  return n;
}
 
int ls_db_lens_name(ls_db_t *db, long long lens_id, char *maker, size_t maker_size,
                    char *model, size_t model_size)
{
  if(!db || !db->sql) return -1;
  if(maker && maker_size) maker[0] = '\0';
  if(model && model_size) model[0] = '\0';
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT maker, model FROM lens WHERE id = ?1", -1, &st, NULL)
     != SQLITE_OK)
  {
    _db_err(db, "prepare lens name");
    return -1;
  }
  sqlite3_bind_int64(st, 1, lens_id);
 
  int written = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    const char *a = (const char *)sqlite3_column_text(st, 0);
    const char *b = (const char *)sqlite3_column_text(st, 1);
    if(maker && maker_size && a)
    {
      snprintf(maker, maker_size, "%s", a);
      written += (int)strlen(maker);
    }
    if(model && model_size && b)
    {
      snprintf(model, model_size, "%s", b);
      written += (int)strlen(model);
    }
  }
  sqlite3_finalize(st);
  return written;
}
 
int ls_db_lens_range(ls_db_t *db, long long lens_id, float *min_focal, float *max_focal,
                     float *min_aperture, float *max_aperture)
{
  if(!db || !db->sql) return -1;
  if(min_focal) *min_focal = 0.f;
  if(max_focal) *max_focal = 0.f;
  if(min_aperture) *min_aperture = 0.f;
  if(max_aperture) *max_aperture = 0.f;
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT min_focal, max_focal, min_aperture, max_aperture"
                        " FROM lens WHERE id = ?1", -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lens range");
    return -1;
  }
  sqlite3_bind_int64(st, 1, lens_id);
  int found = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    found = 1;
    if(min_focal) *min_focal = (float)sqlite3_column_double(st, 0);
    if(max_focal) *max_focal = (float)sqlite3_column_double(st, 1);
    if(min_aperture) *min_aperture = (float)sqlite3_column_double(st, 2);
    if(max_aperture) *max_aperture = (float)sqlite3_column_double(st, 3);
  }
  sqlite3_finalize(st);
  return found;
}
 
int ls_db_lens_mounts(ls_db_t *db, long long lens_id, char *out, size_t out_size)
{
  if(!db || !db->sql) return -1;
  if(out && out_size) out[0] = '\0';
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT m.name FROM lens_mount lm JOIN mount m ON m.id = lm.mount_id"
                        " WHERE lm.lens_id = ?1 ORDER BY m.name", -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lens mounts");
    return -1;
  }
  sqlite3_bind_int64(st, 1, lens_id);
 
  int n = 0;
  size_t used = 0;
  while(sqlite3_step(st) == SQLITE_ROW)
  {
    const char *name = (const char *)sqlite3_column_text(st, 0);
    if(!name) continue;
    n++;
    if(!out || out_size == 0) continue;
    /* Truncate rather than fail: this string is shown to a person, and a picker that says
     * nothing because one lens has more mounts than the caller budgeted for is worse than
     * one that says most of them. The count returned is still the true count. */
    const size_t need = strlen(name) + (used ? 2 : 0);
    if(used + need >= out_size) continue;
    if(used) { memcpy(out + used, ", ", 2); used += 2; }
    memcpy(out + used, name, strlen(name));
    used += strlen(name);
    out[used] = '\0';
  }
  sqlite3_finalize(st);
  return n;
}
 
int ls_db_list_cameras(ls_db_t *db, long long *out_ids, int max)
{
  if(!db || !db->sql) return -1;
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT id FROM camera ORDER BY id", -1, &st, NULL)
     != SQLITE_OK)
  {
    _db_err(db, "prepare camera list");
    return -1;
  }
  int n = 0;
  while(sqlite3_step(st) == SQLITE_ROW)
  {
    if(out_ids && n < max) out_ids[n] = sqlite3_column_int64(st, 0);
    n++;
  }
  sqlite3_finalize(st);
  return (out_ids && n > max) ? max : n;
}
 
int ls_db_camera_name(ls_db_t *db, long long camera_id, char *maker, size_t maker_size,
                      char *model, size_t model_size, char *variant, size_t variant_size)
{
  if(!db || !db->sql) return -1;
  if(maker && maker_size) maker[0] = '\0';
  if(model && model_size) model[0] = '\0';
  if(variant && variant_size) variant[0] = '\0';
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT maker, model, variant FROM camera WHERE id = ?1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare camera name");
    return -1;
  }
  sqlite3_bind_int64(st, 1, camera_id);
  int found = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    found = 1;
    const char *a = (const char *)sqlite3_column_text(st, 0);
    const char *b = (const char *)sqlite3_column_text(st, 1);
    const char *c = (const char *)sqlite3_column_text(st, 2);
    if(maker && maker_size && a) snprintf(maker, maker_size, "%s", a);
    if(model && model_size && b) snprintf(model, model_size, "%s", b);
    if(variant && variant_size && c) snprintf(variant, variant_size, "%s", c);
  }
  sqlite3_finalize(st);
  return found;
}
 
int ls_db_camera_by_id(ls_db_t *db, long long camera_id, ls_camera_t *out)
{
  if(!db || !db->sql || !out) return -1;
  memset(out, 0, sizeof(*out));
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT crop_factor, mount_id FROM camera WHERE id = ?1",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare camera by id");
    return -1;
  }
  sqlite3_bind_int64(st, 1, camera_id);
  int found = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    found = 1;
    out->crop_factor = (float)sqlite3_column_double(st, 0);
    out->mount_id = sqlite3_column_int64(st, 1);
    out->id = camera_id;
  }
  sqlite3_finalize(st);
  return found;
}
 
int ls_db_mount_name(ls_db_t *db, long long mount_id, char *out, size_t out_size)
{
  if(!db || !db->sql || !out || out_size == 0) return -1;
  out[0] = '\0';
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT name FROM mount WHERE id = ?1", -1, &st, NULL)
     != SQLITE_OK)
  {
    _db_err(db, "prepare mount name");
    return -1;
  }
  sqlite3_bind_int64(st, 1, mount_id);
  int found = 0;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    const char *n = (const char *)sqlite3_column_text(st, 0);
    if(n)
    {
      snprintf(out, out_size, "%s", n);
      found = 1;
    }
  }
  sqlite3_finalize(st);
  return found;
}
 
int ls_db_lenses_for_mount(ls_db_t *db, long long mount_id, long long *out_ids, int max)
{
  if(!db || !db->sql) return -1;
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql,
                        "SELECT lens_id FROM lens_mount WHERE mount_id = ?1 ORDER BY lens_id",
                        -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare lenses for mount");
    return -1;
  }
  sqlite3_bind_int64(st, 1, mount_id);
  int n = 0;
  while(sqlite3_step(st) == SQLITE_ROW)
  {
    if(out_ids && n < max) out_ids[n] = sqlite3_column_int64(st, 0);
    n++;
  }
  sqlite3_finalize(st);
  return (out_ids && n > max) ? max : n;
}
 
int ls_db_meta(ls_db_t *db, const char *key, char *out, size_t out_size)
{
  if(!db || !db->sql || !key || !out || out_size == 0) return -1;
  out[0] = '\0';
 
  sqlite3_stmt *st = NULL;
  if(sqlite3_prepare_v2(db->sql, "SELECT value FROM meta WHERE key = ?1", -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare meta");
    return -1;
  }
  sqlite3_bind_text(st, 1, key, -1, SQLITE_STATIC);
 
  int n = -1;
  if(sqlite3_step(st) == SQLITE_ROW)
  {
    const char *v = (const char *)sqlite3_column_text(st, 0);
    if(v)
    {
      snprintf(out, out_size, "%s", v);
      n = (int)strlen(out);
    }
  }
  sqlite3_finalize(st);
  return n;
}
 
/* ------------------------------------------------------------------------- */
/* Fuzzy matching.                                                            */
/*                                                                            */
/* A raw file names a lens the way its vendor abbreviates it, and upstream     */
/* names it the way upstream chose. "16-35mm f/4G ED VR" has to reach "Nikon   */
/* AF-S Nikkor 16-35mm f/4G ED VR" with most of the tokens missing.            */
/*                                                                            */
/* The weights below are not derived from anything: they were calibrated       */
/* against liblensfun's own decisions, which tests/match_lensfun.c re-checks    */
/* over the whole database. Change one and run that test.                      */
/* ------------------------------------------------------------------------- */
 
enum { LS_MAX_TOKENS = 32, LS_TOKEN_LEN = 48 };
 
typedef struct
{
  char t[LS_MAX_TOKENS][LS_TOKEN_LEN];
  unsigned h[LS_MAX_TOKENS];       
  unsigned char len[LS_MAX_TOKENS];
  unsigned long long bloom;
  int n;
} ls_tokens_t;
 
int ls_db_tokenize(const char *norm, char *out_tokens, int max, int stride)
{
  int n = 0;
  const char *p = norm ? norm : "";
  while(*p && n < max)
  {
    while(*p == ' ') p++;
    if(!*p) break;
 
    char *w = out_tokens + (size_t)n * stride;
    int len = 0;
    int prev_digit = -1;
    while(*p && *p != ' ' && len < stride - 1)
    {
      const int is_digit = (*p >= '0' && *p <= '9');
      if(prev_digit >= 0 && is_digit != prev_digit) break;   /* letter<->digit boundary */
      w[len++] = *p++;
      prev_digit = is_digit;
    }
    w[len] = '\0';
    if(len) n++;
  }
  return n;
}
 
unsigned ls_db_token_hash(const char *token)
{
  unsigned hash = 2166136261u;      /* FNV-1a */
  for(const char *c = token; *c; c++)
  {
    hash ^= (unsigned char)*c;
    hash *= 16777619u;
  }
  return hash;
}
 
size_t ls_db_token_digest(const char *norm, unsigned char *out, size_t out_size)
{
  char toks[LS_MAX_TOKENS][LS_TOKEN_LEN];
  const int n = ls_db_tokenize(norm, &toks[0][0], LS_MAX_TOKENS, LS_TOKEN_LEN);
  const size_t need = 2 + (size_t)n * 5;
  if(out_size < need) return 0;
 
  out[0] = (unsigned char)(n & 0xFF);
  out[1] = (unsigned char)((n >> 8) & 0xFF);
  for(int i = 0; i < n; i++)
  {
    const unsigned h = ls_db_token_hash(toks[i]);
    unsigned char *p = out + 2 + (size_t)i * 4;
    p[0] = (unsigned char)(h & 0xFF);
    p[1] = (unsigned char)((h >> 8) & 0xFF);
    p[2] = (unsigned char)((h >> 16) & 0xFF);
    p[3] = (unsigned char)((h >> 24) & 0xFF);
    out[2 + (size_t)n * 4 + i] = (unsigned char)strlen(toks[i]);
  }
  return need;
}
 
static int _digest_load(const unsigned char *blob, int bytes, ls_tokens_t *out)
{
  out->n = 0;
  out->bloom = 0;
  if(!blob || bytes < 2) return 0;
 
  int n = blob[0] | (blob[1] << 8);
  if(n > LS_MAX_TOKENS) n = LS_MAX_TOKENS;
  if(bytes < 2 + n * 5) return 0;
 
  for(int i = 0; i < n; i++)
  {
    const unsigned char *p = blob + 2 + (size_t)i * 4;
    const unsigned h = (unsigned)p[0] | ((unsigned)p[1] << 8)
                     | ((unsigned)p[2] << 16) | ((unsigned)p[3] << 24);
    out->h[i] = h;
    out->len[i] = blob[2 + (size_t)n * 4 + i];
    out->bloom |= 1ULL << (h & 63u);
  }
  out->n = n;
  return n;
}
 
static void _tokenize(const char *norm, ls_tokens_t *out)
{
  out->n = ls_db_tokenize(norm, &out->t[0][0], LS_MAX_TOKENS, LS_TOKEN_LEN);
  out->bloom = 0;
  for(int i = 0; i < out->n; i++)
  {
    const unsigned hash = ls_db_token_hash(out->t[i]);
    out->h[i] = hash;
    out->len[i] = (unsigned char)strlen(out->t[i]);
    out->bloom |= 1ULL << (hash & 63u);
  }
}
 
static float _score_tokens(const ls_tokens_t *pat, const ls_tokens_t *cand)
{
  if(pat->n == 0 || cand->n == 0) return 0.f;
 
  unsigned char used[LS_MAX_TOKENS] = { 0 };
  float got = 0.f;
 
  for(int i = 0; i < pat->n; i++)
  {
    const unsigned hi = pat->h[i];
    const int li = pat->len[i];
    float best = 0.f;
    int best_j = -1;
    for(int j = 0; j < cand->n; j++)
    {
      if(used[j]) continue;
      float s = 0.f;
      /* Hash and length, and nothing else: the candidate's token TEXT is not read from the
       * database at all -- only this digest is -- so there is no string to compare against.
       * A 32-bit FNV plus the length is ~40 bits of discrimination over ~47000 tokens; the
       * agreement test is what says that is enough, and it reports the same 99.0% as the
       * version that compared the bytes. */
      if(hi == cand->h[j] && li == cand->len[j])
        s = 1.f;
      if(s > best)
      {
        best = s;
        best_j = j;
      }
    }
    if(best_j >= 0 && best > 0.f)
    {
      used[best_j] = 1;
      got += best;
    }
  }
 
  const float forward = got / (float)pat->n;                    /* pattern covered */
  int unmatched = 0;
  for(int j = 0; j < cand->n; j++) if(!used[j]) unmatched++;
  const float verbosity = (float)unmatched / (float)cand->n;    /* candidate's extra words */
 
  float score = 100.f * (forward - 0.15f * verbosity * forward);
  if(score < 0.f) score = 0.f;
  return score;
}
 
static void _parse_focal_range(const char *name, float *minf, float *maxf)
{
  *minf = 0.f;
  *maxf = 0.f;
  if(!name) return;
 
  /* Upstream refuses to read numbers out of these (GuessParameters): a teleconverter or an
   * adapter carries a magnification, not a focal length, and reading "1.4x" as a focal
   * rejects every lens it could pair with. Same list, same reason. */
  static const char *const not_a_lens[]
      = { "adapter", "reducer", "booster", "extender", "converter", "ext.", "ext ", NULL };
  for(int i = 0; not_a_lens[i]; i++)
  {
    /* case-insensitively, since this sees raw names */
    for(const char *h = name; *h; h++)
    {
      const char *a = h, *b = not_a_lens[i];
      while(*a && *b && ((*a | 32) == (*b | 32))) { a++; b++; }
      if(!*b) return;
    }
  }
 
  for(const char *c = name; *c; c++)
  {
    if(*c < '0' || *c > '9') continue;
    /* Whitespace or start of string, and NOTHING else -- upstream's regex begins
     * ([[:space:]]+|^) and this must not be more eager than that.
     *
     * Accepting '-' as a boundary too, which is what this did first, half-parses the names
     * vendors actually write: "XF18-55mmF2.8-4" has no space before the 18, so the 18 is
     * skipped, the 55 after the dash is taken instead, and an 18-55 zoom is read as a 55mm
     * prime -- which then rejects the very lens being searched for. Upstream cannot parse
     * that name either, and answers by leaving the range UNSET, which makes the filter
     * neutral and the lens findable. Failing to parse is the safe outcome here; parsing
     * wrongly is not. Measured: six lenses across ten images went from resolved to not
     * found at all. */
    if(c != name && c[-1] != ' ') continue;
 
    char *end = NULL;
    const float a = strtof(c, &end);
    if(!end || end == c) continue;
 
    float b = a;
    const char *p = end;
    if(*p == '-')
    {
      char *end2 = NULL;
      const float t = strtof(p + 1, &end2);
      if(end2 && end2 != p + 1) { b = t; p = end2; }
    }
    while(*p == ' ') p++;
    if((p[0] == 'm' || p[0] == 'M') && (p[1] == 'm' || p[1] == 'M') && a > 0.f && b >= a)
    {
      *minf = a;
      *maxf = b;
      return;                 /* upstream takes the first match too */
    }
    c = end - 1;
  }
}
 
static int _compare_num(const float a, const float b)
{
  if(a == 0.f || b == 0.f) return 0;
  const float r = a / b;
  return (r <= 0.99f || r >= 1.01f) ? -1 : +1;
}
 
static float _crop_score(const float cam, const float calib)
{
  if(cam <= 0.01f || calib <= 0.f) return 0.f;   /* unknown: the rule cannot be applied */
  if(cam < calib * 0.96f) return -1.f;           /* the calibration does not cover the frame */
 
  if(cam >= calib * 1.41f) return 2.f;
  if(cam >= calib * 1.31f) return 4.f;
  if(cam >= calib * 1.21f) return 6.f;
  if(cam >= calib * 1.11f) return 8.f;
  if(cam >= calib * 1.01f) return 10.f;
  if(cam >= calib) return 5.f;
  return 3.f;                                    /* within the 4% tolerance, but smaller */
}
 
int ls_db_match_lens(ls_db_t *db, const char *maker, const char *model, long long mount_id,
                     float crop, ls_db_match_t *out, int max)
{
  if(!db || !db->sql || !model || !out || max <= 0) return -1;
 
  char nmodel[512], nmaker[512];
  ls_db_normalize(model, nmodel, sizeof(nmodel));
  ls_db_normalize(maker, nmaker, sizeof(nmaker));
 
  ls_tokens_t pat, pat_maker;
  _tokenize(nmodel, &pat);
  _tokenize(nmaker, &pat_maker);
  if(pat.n == 0) return 0;
 
  /* Two phases, and the first one is what makes this cheap.
   *
   * Scoring every name in the catalogue costs 610 ns each -- 88% of a lookup, measured --
   * and there are ~4700 of them. The fix is not to score faster (hashing the tokens first
   * was tried and moved nothing: the per-comparison cost was already ~5 ns, there were
   * simply half a million comparisons). The fix is to score far fewer names.
   *
   * So: ask lens_token which of the QUERY's tokens is rarest, and gather only the lenses
   * carrying it. "16" or "nikkor" reaches tens of lenses where "mm" or "f" reaches
   * thousands, which is exactly why gathering on ALL the query's tokens -- also tried, also
   * measured -- is no better than the full scan it replaces.
   *
   * The frequencies come from token_df, precomputed at import. Deriving them here with a
   * GROUP BY over lens_token was the first attempt and cost 0.6 ms on its own: counting how
   * often "mm" occurs means walking every one of its index rows.
   *
   * If that yields nothing (a query whose rarest token no catalogue name shares), the scan
   * runs after all, so the answer never depends on the pruning. */
  char in_list[LS_MAX_TOKENS * (LS_TOKEN_LEN + 4) + 8];
  {
    size_t w = 0;
    in_list[w++] = '(';
    for(int i = 0; i < pat.n; i++)
    {
      if(i) in_list[w++] = ',';
      in_list[w++] = '\'';
      for(const char *c = pat.t[i]; *c; c++)
        if(*c != '\'') in_list[w++] = *c;   /* tokens are [a-z0-9] after normalisation */
      in_list[w++] = '\'';
    }
    in_list[w++] = ')';
    in_list[w] = '\0';
  }
 
  char rarest[LS_TOKEN_LEN] = { 0 };
  {
    char sqlbuf[sizeof(in_list) + 256];
    snprintf(sqlbuf, sizeof(sqlbuf),
             "SELECT token FROM token_df WHERE kind = 'model' AND token IN %s"
             " ORDER BY df ASC LIMIT 1", in_list);
    sqlite3_stmt *rq = NULL;
    if(sqlite3_prepare_v2(db->sql, sqlbuf, -1, &rq, NULL) == SQLITE_OK)
    {
      if(sqlite3_step(rq) == SQLITE_ROW)
      {
        const char *t = (const char *)sqlite3_column_text(rq, 0);
        if(t) snprintf(rarest, sizeof(rarest), "%s", t);
      }
      sqlite3_finalize(rq);
    }
  }
 
  sqlite3_stmt *st = NULL;
  char sqlbuf[1024];
  const char *mount_clause =
      (mount_id > 0)
          ? " AND EXISTS (SELECT 1 FROM lens_mount lm WHERE lm.lens_id = n.lens_id AND ("
            "   lm.mount_id = ?1 OR EXISTS (SELECT 1 FROM mount_compat mc"
            "     WHERE mc.mount_id = ?1 AND mc.compat_id = lm.mount_id)))"
          : "";
  if(rarest[0])
    snprintf(sqlbuf, sizeof(sqlbuf),
             "SELECT n.lens_id, n.tokens, n.kind FROM lens_name n"
             " WHERE n.lens_id IN (SELECT lens_id FROM lens_token"
             "                     WHERE kind = 'model' AND token = ?2)%s", mount_clause);
  else
    snprintf(sqlbuf, sizeof(sqlbuf),
             "SELECT n.lens_id, n.tokens, n.kind FROM lens_name n WHERE 1%s", mount_clause);
 
  if(sqlite3_prepare_v2(db->sql, sqlbuf, -1, &st, NULL) != SQLITE_OK)
  {
    _db_err(db, "prepare match");
    return -1;
  }
  if(rarest[0]) sqlite3_bind_text(st, 2, rarest, -1, SQLITE_STATIC);
  if(mount_id > 0) sqlite3_bind_int64(st, 1, mount_id);
 
  /* Best score per lens, kept in a small open-addressed table: a lens has several names
   * and several of them may score, but only its best counts. */
  enum { SLOTS = 4096 };
  long long *ids = (long long *)calloc(SLOTS, sizeof(long long));
  float *best = (float *)calloc(SLOTS, sizeof(float));
  float *maker_bonus = (float *)calloc(SLOTS, sizeof(float));
  if(!ids || !best || !maker_bonus)
  {
    free(ids); free(best); free(maker_bonus);
    sqlite3_finalize(st);
    return -1;
  }
 
  while(sqlite3_step(st) == SQLITE_ROW)
  {
    const long long id = sqlite3_column_int64(st, 0);
    const unsigned char *blob = (const unsigned char *)sqlite3_column_blob(st, 1);
    const int blob_bytes = sqlite3_column_bytes(st, 1);
    const char *kind = (const char *)sqlite3_column_text(st, 2);
    if(!blob || !kind) continue;
 
    /* Decoded, not parsed. The tokens were split and hashed once, at import; this reads
     * fixed-width fields out of a blob that came straight from a covering index. */
    ls_tokens_t cand;
    if(!_digest_load(blob, blob_bytes, &cand)) continue;
 
    /* No shared token means no score, and the quadratic comparison below would only
     * discover that the expensive way. One AND settles it for most of the catalogue. */
    if(!(cand.bloom & ((kind[0] == 'm' && kind[1] == 'o') ? pat.bloom : pat_maker.bloom)))
      continue;
 
    size_t slot = (size_t)id % SLOTS;
    while(ids[slot] && ids[slot] != id) slot = (slot + 1) % SLOTS;
    ids[slot] = id;
 
    if(kind[0] == 'm' && kind[1] == 'o')          /* "model" */
    {
      const float s = _score_tokens(&pat, &cand);
      if(s > best[slot]) best[slot] = s;
    }
    else if(pat_maker.n)                          /* "maker" */
    {
      /* The maker is corroboration, not a filter: vendors and upstream disagree about
       * their own names often enough ("Nikon Corporation" vs "Nikon") that requiring it
       * loses more matches than the false positives it prevents. */
      const float s = _score_tokens(&pat_maker, &cand);
      if(s > maker_bonus[slot]) maker_bonus[slot] = s;
    }
  }
  sqlite3_finalize(st);
 
  /* The calibration crop factor of every candidate, in one query rather than one per
   * candidate: the set is small by now, but a round trip each would undo the work the
   * rarest-token pruning just did. */
  /* The exact terms -- crop factor and focal range -- are tie-breaks, NOT score terms, and
   * this constant is what makes them so. Their REJECTS stay absolute (a calibration that
   * cannot cover the sensor, or a 20mm answering a 50mm query, is out whatever its name);
   * their positive weights are scaled far below the resolution of a name score so that they
   * can only order candidates whose names are otherwise equal.
   *
   * The distinction is not cosmetic, and both halves of it were measured. Upstream ships
   * "Nikon AF-S Nikkor 50mm f/1.4G" twice, one row carrying a stray "160" in its name and
   * no vignetting or TCA data; the names differ by 1.36 and the crop term, added at full
   * weight, was worth 3 -- so the emptier row won on a D7200 and the render silently lost
   * two corrections. Conversely the Sigma 70-200mm and Tokina 11-20mm have rows whose names
   * are IDENTICAL and differ only in calibration sensor, and there the crop term is the only
   * thing that can choose; weakening it uniformly (which was the first attempt) got the
   * Nikon right and those two wrong.
   *
   * Name first, exact facts to break ties, is what satisfies both. */
  const float EXACT_TIE = 1e-4f;
 
  float q_minf = 0.f, q_maxf = 0.f;
  /* The RAW name, not the normalised one. Normalisation collapses punctuation, so
   * "16-35mm" arrives as "16 35mm" and a zoom reads as a 35mm prime -- which then rejects
   * the very lens being searched for. Measured: 99.0% agreement fell to 68.9%. */
  _parse_focal_range(model, &q_minf, &q_maxf);
 
  sqlite3_stmt *cq = NULL;
  if(crop > 0.01f || q_minf > 0.f)
    sqlite3_prepare_v2(db->sql,
                       "SELECT crop_factor, min_focal, max_focal FROM lens WHERE id = ?1",
                       -1, &cq, NULL);
 
  int n = 0;
  for(size_t slot = 0; slot < SLOTS; slot++)
  {
    if(!ids[slot] || best[slot] <= 0.f) continue;
    float score = best[slot] + 0.10f * maker_bonus[slot];
 
    if(cq)
    {
      sqlite3_reset(cq);
      sqlite3_bind_int64(cq, 1, ids[slot]);
      if(sqlite3_step(cq) != SQLITE_ROW) continue;
      const float calib = (float)sqlite3_column_double(cq, 0);
      const float c_minf = (float)sqlite3_column_double(cq, 1);
      const float c_maxf = (float)sqlite3_column_double(cq, 2);
 
      const float w = _crop_score(crop, calib);
      if(w < 0.f) continue;           /* rejected: this calibration cannot serve this frame */
      /* A TIE-BREAK, scaled so it cannot outweigh a name difference -- see EXACT_TIE. */
      score += w * EXACT_TIE;
 
      /* The focal range the NAME claims, as upstream's hard filter. A 50mm query must not
       * resolve to a 20mm lens however well the rest of the tokens line up. */
      const int fmin = _compare_num(q_minf, c_minf);
      const int fmax = _compare_num(q_maxf, c_maxf);
      if(fmin < 0 || fmax < 0) continue;
      if(fmin > 0) score += 10.f * EXACT_TIE;
      if(fmax > 0) score += 10.f * EXACT_TIE;
    }
 
    /* Insertion sort into the caller's top-N: max is small (a GUI shows a handful). */
    int at = n;
    while(at > 0 && out[at - 1].score < score)
    {
      if(at < max) out[at] = out[at - 1];
      at--;
    }
    if(at < max)
    {
      out[at].lens_id = ids[slot];
      out[at].score = score;
      if(n < max) n++;
    }
  }
 
  if(cq) sqlite3_finalize(cq);
  free(ids);
  free(best);
  free(maker_bonus);
  return n;
}