Add database optimizations for photo search and pagination

Implement database-level sorting with composite indexes for efficient date and tag queries. Add pagination metadata support and optimize tag count queries using batch processing.

src/database/mod.rs

@@ -296,6 +296,17 @@ pub trait ExifDao: Sync + Send {
         &mut self,
         context: &opentelemetry::Context,
     ) -> Result<Vec<String>, DbError>;
+
+    /// Get files sorted by date with optional pagination
+    /// Returns (sorted_file_paths, total_count)
+    fn get_files_sorted_by_date(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_paths: &[String],
+        ascending: bool,
+        limit: Option<i64>,
+        offset: i64,
+    ) -> Result<(Vec<String>, i64), DbError>;
 }
 
 pub struct SqliteExifDao {
@@ -581,4 +592,65 @@ impl ExifDao for SqliteExifDao {
         })
         .map_err(|_| DbError::new(DbErrorKind::QueryError))
     }
+
+    fn get_files_sorted_by_date(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_paths: &[String],
+        ascending: bool,
+        limit: Option<i64>,
+        offset: i64,
+    ) -> Result<(Vec<String>, i64), DbError> {
+        trace_db_call(context, "query", "get_files_sorted_by_date", |span| {
+            use diesel::dsl::count_star;
+            use opentelemetry::KeyValue;
+            use opentelemetry::trace::Span;
+            use schema::image_exif::dsl::*;
+
+            span.set_attributes(vec![
+                KeyValue::new("file_count", file_paths.len() as i64),
+                KeyValue::new("ascending", ascending.to_string()),
+                KeyValue::new("limit", limit.map(|l| l.to_string()).unwrap_or_default()),
+                KeyValue::new("offset", offset.to_string()),
+            ]);
+
+            if file_paths.is_empty() {
+                return Ok((Vec::new(), 0));
+            }
+
+            let connection = &mut *self.connection.lock().unwrap();
+
+            // Get total count of files that have EXIF data
+            let total_count: i64 = image_exif
+                .filter(file_path.eq_any(file_paths))
+                .select(count_star())
+                .first(connection)
+                .map_err(|_| anyhow::anyhow!("Count query error"))?;
+
+            // Build sorted query
+            let mut query = image_exif.filter(file_path.eq_any(file_paths)).into_boxed();
+
+            // Apply sorting
+            // Note: SQLite NULL handling varies - NULLs appear first for ASC, last for DESC by default
+            if ascending {
+                query = query.order(date_taken.asc());
+            } else {
+                query = query.order(date_taken.desc());
+            }
+
+            // Apply pagination if requested
+            if let Some(limit_val) = limit {
+                query = query.limit(limit_val).offset(offset);
+            }
+
+            // Execute and extract file paths
+            let results: Vec<String> = query
+                .select(file_path)
+                .load::<String>(connection)
+                .map_err(|_| anyhow::anyhow!("Query error"))?;
+
+            Ok((results, total_count))
+        })
+        .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
 }