File storage rewrite (#2676)

* Restructure data layer part 2 (#2599)
* Refactor and separate image model
* Refactor image query builder
* Handle relationships in image query builder
* Remove relationship management methods
* Refactor gallery model/query builder
* Add scenes to gallery model
* Convert scene model
* Refactor scene models
* Remove unused methods
* Add unit tests for gallery
* Add image tests
* Add scene tests
* Convert unnecessary scene value pointers to values
* Convert unnecessary pointer values to values
* Refactor scene partial
* Add scene partial tests
* Refactor ImagePartial
* Add image partial tests
* Refactor gallery partial update
* Add partial gallery update tests
* Use zero/null package for null values
* Add files and scan system
* Add sqlite implementation for files/folders
* Add unit tests for files/folders
* Image refactors
* Update image data layer
* Refactor gallery model and creation
* Refactor scene model
* Refactor scenes
* Don't set title from filename
* Allow galleries to freely add/remove images
* Add multiple scene file support to graphql and UI
* Add multiple file support for images in graphql/UI
* Add multiple file for galleries in graphql/UI
* Remove use of some deprecated fields
* Remove scene path usage
* Remove gallery path usage
* Remove path from image
* Move funscript to video file
* Refactor caption detection
* Migrate existing data
* Add post commit/rollback hook system
* Lint. Comment out import/export tests
* Add WithDatabase read only wrapper
* Prepend tasks to list
* Add 32 pre-migration
* Add warnings in release and migration notes

pkg/sqlite/image.go

@@ -5,125 +5,294 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"path/filepath"
+	"time"
 
+	"github.com/jmoiron/sqlx"
+	"github.com/stashapp/stash/pkg/file"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/sliceutil/intslice"
+	"gopkg.in/guregu/null.v4"
+	"gopkg.in/guregu/null.v4/zero"
+
+	"github.com/doug-martin/goqu/v9"
+	"github.com/doug-martin/goqu/v9/exp"
 )
 
-const imageTable = "images"
-const imageIDColumn = "image_id"
-const performersImagesTable = "performers_images"
-const imagesTagsTable = "images_tags"
+var imageTable = "images"
 
-var imagesForGalleryQuery = selectAll(imageTable) + `
-INNER JOIN galleries_images as galleries_join on galleries_join.image_id = images.id
-WHERE galleries_join.gallery_id = ?
-GROUP BY images.id
-`
+const (
+	imageIDColumn         = "image_id"
+	performersImagesTable = "performers_images"
+	imagesTagsTable       = "images_tags"
+	imagesFilesTable      = "images_files"
+)
 
-var countImagesForGalleryQuery = `
-SELECT gallery_id FROM galleries_images
-WHERE gallery_id = ?
-GROUP BY image_id
-`
+type imageRow struct {
+	ID        int         `db:"id" goqu:"skipinsert"`
+	Title     zero.String `db:"title"`
+	Rating    null.Int    `db:"rating"`
+	Organized bool        `db:"organized"`
+	OCounter  int         `db:"o_counter"`
+	StudioID  null.Int    `db:"studio_id,omitempty"`
+	CreatedAt time.Time   `db:"created_at"`
+	UpdatedAt time.Time   `db:"updated_at"`
+}
 
-type imageQueryBuilder struct {
+func (r *imageRow) fromImage(i models.Image) {
+	r.ID = i.ID
+	r.Title = zero.StringFrom(i.Title)
+	r.Rating = intFromPtr(i.Rating)
+	r.Organized = i.Organized
+	r.OCounter = i.OCounter
+	r.StudioID = intFromPtr(i.StudioID)
+	r.CreatedAt = i.CreatedAt
+	r.UpdatedAt = i.UpdatedAt
+}
+
+type imageRowRecord struct {
+	updateRecord
+}
+
+func (r *imageRowRecord) fromPartial(i models.ImagePartial) {
+	r.setNullString("title", i.Title)
+	r.setNullInt("rating", i.Rating)
+	r.setBool("organized", i.Organized)
+	r.setInt("o_counter", i.OCounter)
+	r.setNullInt("studio_id", i.StudioID)
+	r.setTime("created_at", i.CreatedAt)
+	r.setTime("updated_at", i.UpdatedAt)
+}
+
+type imageQueryRow struct {
+	imageRow
+
+	relatedFileQueryRow
+
+	GalleryID   null.Int `db:"gallery_id"`
+	TagID       null.Int `db:"tag_id"`
+	PerformerID null.Int `db:"performer_id"`
+}
+
+func (r *imageQueryRow) resolve() *models.Image {
+	ret := &models.Image{
+		ID:        r.ID,
+		Title:     r.Title.String,
+		Rating:    nullIntPtr(r.Rating),
+		Organized: r.Organized,
+		OCounter:  r.OCounter,
+		StudioID:  nullIntPtr(r.StudioID),
+		CreatedAt: r.CreatedAt,
+		UpdatedAt: r.UpdatedAt,
+	}
+
+	r.appendRelationships(ret)
+
+	return ret
+}
+
+func appendImageFileUnique(vs []*file.ImageFile, toAdd *file.ImageFile, isPrimary bool) []*file.ImageFile {
+	// check in reverse, since it's most likely to be the last one
+	for i := len(vs) - 1; i >= 0; i-- {
+		if vs[i].Base().ID == toAdd.Base().ID {
+
+			// merge the two
+			mergeFiles(vs[i], toAdd)
+			return vs
+		}
+	}
+
+	if !isPrimary {
+		return append(vs, toAdd)
+	}
+
+	// primary should be first
+	return append([]*file.ImageFile{toAdd}, vs...)
+}
+
+func (r *imageQueryRow) appendRelationships(i *models.Image) {
+	if r.GalleryID.Valid {
+		i.GalleryIDs = intslice.IntAppendUnique(i.GalleryIDs, int(r.GalleryID.Int64))
+	}
+	if r.TagID.Valid {
+		i.TagIDs = intslice.IntAppendUnique(i.TagIDs, int(r.TagID.Int64))
+	}
+	if r.PerformerID.Valid {
+		i.PerformerIDs = intslice.IntAppendUnique(i.PerformerIDs, int(r.PerformerID.Int64))
+	}
+
+	if r.relatedFileQueryRow.FileID.Valid {
+		f := r.fileQueryRow.resolve().(*file.ImageFile)
+		i.Files = appendImageFileUnique(i.Files, f, r.Primary.Bool)
+	}
+}
+
+type imageQueryRows []imageQueryRow
+
+func (r imageQueryRows) resolve() []*models.Image {
+	var ret []*models.Image
+	var last *models.Image
+	var lastID int
+
+	for _, row := range r {
+		if last == nil || lastID != row.ID {
+			f := row.resolve()
+			last = f
+			lastID = row.ID
+			ret = append(ret, last)
+			continue
+		}
+
+		// must be merging with previous row
+		row.appendRelationships(last)
+	}
+
+	return ret
+}
+
+type ImageStore struct {
 	repository
+
+	tableMgr      *table
+	queryTableMgr *table
+	oCounterManager
 }
 
-var ImageReaderWriter = &imageQueryBuilder{
-	repository{
-		tableName: imageTable,
-		idColumn:  idColumn,
-	},
-}
-
-func (qb *imageQueryBuilder) Create(ctx context.Context, newObject models.Image) (*models.Image, error) {
-	var ret models.Image
-	if err := qb.insertObject(ctx, newObject, &ret); err != nil {
-		return nil, err
+func NewImageStore() *ImageStore {
+	return &ImageStore{
+		repository: repository{
+			tableName: imageTable,
+			idColumn:  idColumn,
+		},
+		tableMgr:        imageTableMgr,
+		queryTableMgr:   imageQueryTableMgr,
+		oCounterManager: oCounterManager{imageTableMgr},
 	}
-
-	return &ret, nil
 }
 
-func (qb *imageQueryBuilder) Update(ctx context.Context, updatedObject models.ImagePartial) (*models.Image, error) {
-	const partial = true
-	if err := qb.update(ctx, updatedObject.ID, updatedObject, partial); err != nil {
-		return nil, err
-	}
-
-	return qb.find(ctx, updatedObject.ID)
+func (qb *ImageStore) table() exp.IdentifierExpression {
+	return qb.tableMgr.table
 }
 
-func (qb *imageQueryBuilder) UpdateFull(ctx context.Context, updatedObject models.Image) (*models.Image, error) {
-	const partial = false
-	if err := qb.update(ctx, updatedObject.ID, updatedObject, partial); err != nil {
-		return nil, err
-	}
-
-	return qb.find(ctx, updatedObject.ID)
+func (qb *ImageStore) queryTable() exp.IdentifierExpression {
+	return qb.queryTableMgr.table
 }
 
-func (qb *imageQueryBuilder) IncrementOCounter(ctx context.Context, id int) (int, error) {
-	_, err := qb.tx.Exec(ctx,
-		`UPDATE `+imageTable+` SET o_counter = o_counter + 1 WHERE `+imageTable+`.id = ?`,
-		id,
-	)
+func (qb *ImageStore) Create(ctx context.Context, newObject *models.ImageCreateInput) error {
+	var r imageRow
+	r.fromImage(*newObject.Image)
+
+	id, err := qb.tableMgr.insertID(ctx, r)
 	if err != nil {
-		return 0, err
+		return err
 	}
 
-	image, err := qb.find(ctx, id)
+	if len(newObject.FileIDs) > 0 {
+		const firstPrimary = true
+		if err := imagesFilesTableMgr.insertJoins(ctx, id, firstPrimary, newObject.FileIDs); err != nil {
+			return err
+		}
+	}
+
+	if len(newObject.GalleryIDs) > 0 {
+		if err := imageGalleriesTableMgr.insertJoins(ctx, id, newObject.GalleryIDs); err != nil {
+			return err
+		}
+	}
+	if len(newObject.PerformerIDs) > 0 {
+		if err := imagesPerformersTableMgr.insertJoins(ctx, id, newObject.PerformerIDs); err != nil {
+			return err
+		}
+	}
+	if len(newObject.TagIDs) > 0 {
+		if err := imagesTagsTableMgr.insertJoins(ctx, id, newObject.TagIDs); err != nil {
+			return err
+		}
+	}
+
+	updated, err := qb.Find(ctx, id)
 	if err != nil {
-		return 0, err
+		return fmt.Errorf("finding after create: %w", err)
 	}
 
-	return image.OCounter, nil
+	*newObject.Image = *updated
+
+	return nil
 }
 
-func (qb *imageQueryBuilder) DecrementOCounter(ctx context.Context, id int) (int, error) {
-	_, err := qb.tx.Exec(ctx,
-		`UPDATE `+imageTable+` SET o_counter = o_counter - 1 WHERE `+imageTable+`.id = ? and `+imageTable+`.o_counter > 0`,
-		id,
-	)
-	if err != nil {
-		return 0, err
+func (qb *ImageStore) UpdatePartial(ctx context.Context, id int, partial models.ImagePartial) (*models.Image, error) {
+	r := imageRowRecord{
+		updateRecord{
+			Record: make(exp.Record),
+		},
 	}
 
-	image, err := qb.find(ctx, id)
-	if err != nil {
-		return 0, err
+	r.fromPartial(partial)
+
+	if len(r.Record) > 0 {
+		if err := qb.tableMgr.updateByID(ctx, id, r.Record); err != nil {
+			return nil, err
+		}
 	}
 
-	return image.OCounter, nil
-}
-
-func (qb *imageQueryBuilder) ResetOCounter(ctx context.Context, id int) (int, error) {
-	_, err := qb.tx.Exec(ctx,
-		`UPDATE `+imageTable+` SET o_counter = 0 WHERE `+imageTable+`.id = ?`,
-		id,
-	)
-	if err != nil {
-		return 0, err
+	if partial.GalleryIDs != nil {
+		if err := imageGalleriesTableMgr.modifyJoins(ctx, id, partial.GalleryIDs.IDs, partial.GalleryIDs.Mode); err != nil {
+			return nil, err
+		}
+	}
+	if partial.PerformerIDs != nil {
+		if err := imagesPerformersTableMgr.modifyJoins(ctx, id, partial.PerformerIDs.IDs, partial.PerformerIDs.Mode); err != nil {
+			return nil, err
+		}
+	}
+	if partial.TagIDs != nil {
+		if err := imagesTagsTableMgr.modifyJoins(ctx, id, partial.TagIDs.IDs, partial.TagIDs.Mode); err != nil {
+			return nil, err
+		}
 	}
 
-	image, err := qb.find(ctx, id)
-	if err != nil {
-		return 0, err
-	}
-
-	return image.OCounter, nil
-}
-
-func (qb *imageQueryBuilder) Destroy(ctx context.Context, id int) error {
-	return qb.destroyExisting(ctx, []int{id})
-}
-
-func (qb *imageQueryBuilder) Find(ctx context.Context, id int) (*models.Image, error) {
 	return qb.find(ctx, id)
 }
 
-func (qb *imageQueryBuilder) FindMany(ctx context.Context, ids []int) ([]*models.Image, error) {
+func (qb *ImageStore) Update(ctx context.Context, updatedObject *models.Image) error {
+	var r imageRow
+	r.fromImage(*updatedObject)
+
+	if err := qb.tableMgr.updateByID(ctx, updatedObject.ID, r); err != nil {
+		return err
+	}
+
+	if err := imageGalleriesTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.GalleryIDs); err != nil {
+		return err
+	}
+	if err := imagesPerformersTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.PerformerIDs); err != nil {
+		return err
+	}
+	if err := imagesTagsTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.TagIDs); err != nil {
+		return err
+	}
+
+	fileIDs := make([]file.ID, len(updatedObject.Files))
+	for i, f := range updatedObject.Files {
+		fileIDs[i] = f.ID
+	}
+
+	if err := imagesFilesTableMgr.replaceJoins(ctx, updatedObject.ID, fileIDs); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (qb *ImageStore) Destroy(ctx context.Context, id int) error {
+	return qb.tableMgr.destroyExisting(ctx, []int{id})
+}
+
+func (qb *ImageStore) Find(ctx context.Context, id int) (*models.Image, error) {
+	return qb.find(ctx, id)
+}
+
+func (qb *ImageStore) FindMany(ctx context.Context, ids []int) ([]*models.Image, error) {
 	var images []*models.Image
 	for _, id := range ids {
 		image, err := qb.Find(ctx, id)
@@ -131,67 +300,217 @@ func (qb *imageQueryBuilder) FindMany(ctx context.Context, ids []int) ([]*models
 			return nil, err
 		}
 
-		if image == nil {
-			return nil, fmt.Errorf("image with id %d not found", id)
-		}
-
 		images = append(images, image)
 	}
 
 	return images, nil
 }
 
-func (qb *imageQueryBuilder) find(ctx context.Context, id int) (*models.Image, error) {
-	var ret models.Image
-	if err := qb.getByID(ctx, id, &ret); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
+func (qb *ImageStore) selectDataset() *goqu.SelectDataset {
+	return dialect.From(imagesQueryTable).Select(imagesQueryTable.All())
+}
+
+func (qb *ImageStore) get(ctx context.Context, q *goqu.SelectDataset) (*models.Image, error) {
+	ret, err := qb.getMany(ctx, q)
+	if err != nil {
 		return nil, err
 	}
-	return &ret, nil
+
+	if len(ret) == 0 {
+		return nil, sql.ErrNoRows
+	}
+
+	return ret[0], nil
 }
 
-func (qb *imageQueryBuilder) FindByChecksum(ctx context.Context, checksum string) (*models.Image, error) {
-	query := "SELECT * FROM images WHERE checksum = ? LIMIT 1"
-	args := []interface{}{checksum}
-	return qb.queryImage(ctx, query, args)
+func (qb *ImageStore) getMany(ctx context.Context, q *goqu.SelectDataset) ([]*models.Image, error) {
+	const single = false
+	var rows imageQueryRows
+	if err := queryFunc(ctx, q, single, func(r *sqlx.Rows) error {
+		var f imageQueryRow
+		if err := r.StructScan(&f); err != nil {
+			return err
+		}
+
+		rows = append(rows, f)
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	return rows.resolve(), nil
 }
 
-func (qb *imageQueryBuilder) FindByPath(ctx context.Context, path string) (*models.Image, error) {
-	query := selectAll(imageTable) + "WHERE path = ? LIMIT 1"
-	args := []interface{}{path}
-	return qb.queryImage(ctx, query, args)
+func (qb *ImageStore) find(ctx context.Context, id int) (*models.Image, error) {
+	q := qb.selectDataset().Where(qb.queryTableMgr.byID(id))
+
+	ret, err := qb.get(ctx, q)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by id %d: %w", id, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *imageQueryBuilder) FindByGalleryID(ctx context.Context, galleryID int) ([]*models.Image, error) {
-	args := []interface{}{galleryID}
-	sort := "path"
-	sortDir := models.SortDirectionEnumAsc
-	return qb.queryImages(ctx, imagesForGalleryQuery+qb.getImageSort(&models.FindFilterType{
-		Sort:      &sort,
-		Direction: &sortDir,
-	}), args)
+func (qb *ImageStore) findBySubquery(ctx context.Context, sq *goqu.SelectDataset) ([]*models.Image, error) {
+	table := qb.queryTable()
+
+	q := qb.selectDataset().Prepared(true).Where(
+		table.Col(idColumn).Eq(
+			sq,
+		),
+	)
+
+	return qb.getMany(ctx, q)
 }
 
-func (qb *imageQueryBuilder) CountByGalleryID(ctx context.Context, galleryID int) (int, error) {
-	args := []interface{}{galleryID}
-	return qb.runCountQuery(ctx, qb.buildCountQuery(countImagesForGalleryQuery), args)
+func (qb *ImageStore) FindByFileID(ctx context.Context, fileID file.ID) ([]*models.Image, error) {
+	table := imagesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("file_id").Eq(fileID),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by file id %d: %w", fileID, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *imageQueryBuilder) Count(ctx context.Context) (int, error) {
-	return qb.runCountQuery(ctx, qb.buildCountQuery("SELECT images.id FROM images"), nil)
+func (qb *ImageStore) FindByFingerprints(ctx context.Context, fp []file.Fingerprint) ([]*models.Image, error) {
+	table := imagesQueryTable
+
+	var ex []exp.Expression
+
+	for _, v := range fp {
+		ex = append(ex, goqu.And(
+			table.Col("fingerprint_type").Eq(v.Type),
+			table.Col("fingerprint").Eq(v.Fingerprint),
+		))
+	}
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(goqu.Or(ex...))
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by fingerprints: %w", err)
+	}
+
+	return ret, nil
 }
 
-func (qb *imageQueryBuilder) Size(ctx context.Context) (float64, error) {
-	return qb.runSumQuery(ctx, "SELECT SUM(cast(size as double)) as sum FROM images", nil)
+func (qb *ImageStore) FindByChecksum(ctx context.Context, checksum string) ([]*models.Image, error) {
+	table := imagesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("fingerprint_type").Eq(file.FingerprintTypeMD5),
+		table.Col("fingerprint").Eq(checksum),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by checksum %s: %w", checksum, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *imageQueryBuilder) All(ctx context.Context) ([]*models.Image, error) {
-	return qb.queryImages(ctx, selectAll(imageTable)+qb.getImageSort(nil), nil)
+func (qb *ImageStore) FindByPath(ctx context.Context, p string) ([]*models.Image, error) {
+	table := imagesQueryTable
+	basename := filepath.Base(p)
+	dir, _ := path(filepath.Dir(p)).Value()
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("parent_folder_path").Eq(dir),
+		table.Col("basename").Eq(basename),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return nil, fmt.Errorf("getting image by path %s: %w", p, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *imageQueryBuilder) validateFilter(imageFilter *models.ImageFilterType) error {
+func (qb *ImageStore) FindByGalleryID(ctx context.Context, galleryID int) ([]*models.Image, error) {
+	table := qb.queryTable()
+
+	q := qb.selectDataset().Where(
+		table.Col("gallery_id").Eq(galleryID),
+	).GroupBy(table.Col(idColumn)).Order(table.Col("parent_folder_path").Asc(), table.Col("basename").Asc())
+
+	ret, err := qb.getMany(ctx, q)
+	if err != nil {
+		return nil, fmt.Errorf("getting images for gallery %d: %w", galleryID, err)
+	}
+
+	return ret, nil
+}
+
+func (qb *ImageStore) CountByGalleryID(ctx context.Context, galleryID int) (int, error) {
+	joinTable := goqu.T(galleriesImagesTable)
+
+	q := dialect.Select(goqu.COUNT("*")).From(joinTable).Where(joinTable.Col("gallery_id").Eq(galleryID))
+	return count(ctx, q)
+}
+
+func (qb *ImageStore) FindByFolderID(ctx context.Context, folderID file.FolderID) ([]*models.Image, error) {
+	table := qb.queryTable()
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(table.Col("parent_folder_id").Eq(folderID))
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by folder: %w", err)
+	}
+
+	return ret, nil
+}
+
+func (qb *ImageStore) FindByZipFileID(ctx context.Context, zipFileID file.ID) ([]*models.Image, error) {
+	table := qb.queryTable()
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(table.Col("zip_file_id").Eq(zipFileID))
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting image by zip file: %w", err)
+	}
+
+	return ret, nil
+}
+
+func (qb *ImageStore) Count(ctx context.Context) (int, error) {
+	q := dialect.Select(goqu.COUNT("*")).From(qb.table())
+	return count(ctx, q)
+}
+
+func (qb *ImageStore) Size(ctx context.Context) (float64, error) {
+	table := qb.table()
+	fileTable := fileTableMgr.table
+	q := dialect.Select(
+		goqu.SUM(fileTableMgr.table.Col("size")),
+	).From(table).InnerJoin(
+		imagesFilesJoinTable,
+		goqu.On(table.Col(idColumn).Eq(imagesFilesJoinTable.Col(imageIDColumn))),
+	).InnerJoin(
+		fileTable,
+		goqu.On(imagesFilesJoinTable.Col(fileIDColumn).Eq(fileTable.Col(idColumn))),
+	)
+	var ret float64
+	if err := querySimple(ctx, q, &ret); err != nil {
+		return 0, err
+	}
+
+	return ret, nil
+}
+
+func (qb *ImageStore) All(ctx context.Context) ([]*models.Image, error) {
+	return qb.getMany(ctx, qb.selectDataset())
+}
+
+func (qb *ImageStore) validateFilter(imageFilter *models.ImageFilterType) error {
 	const and = "AND"
 	const or = "OR"
 	const not = "NOT"
@@ -222,7 +541,7 @@ func (qb *imageQueryBuilder) validateFilter(imageFilter *models.ImageFilterType)
 	return nil
 }
 
-func (qb *imageQueryBuilder) makeFilter(ctx context.Context, imageFilter *models.ImageFilterType) *filterBuilder {
+func (qb *ImageStore) makeFilter(ctx context.Context, imageFilter *models.ImageFilterType) *filterBuilder {
 	query := &filterBuilder{}
 
 	if imageFilter.And != nil {
@@ -235,13 +554,21 @@ func (qb *imageQueryBuilder) makeFilter(ctx context.Context, imageFilter *models
 		query.not(qb.makeFilter(ctx, imageFilter.Not))
 	}
 
-	query.handleCriterion(ctx, stringCriterionHandler(imageFilter.Checksum, "images.checksum"))
+	query.handleCriterion(ctx, criterionHandlerFunc(func(ctx context.Context, f *filterBuilder) {
+		if imageFilter.Checksum != nil {
+			f.addLeftJoin(fingerprintTable, "fingerprints_md5", "galleries_query.file_id = fingerprints_md5.file_id AND fingerprints_md5.type = 'md5'")
+		}
+
+		stringCriterionHandler(imageFilter.Checksum, "fingerprints_md5.fingerprint")(ctx, f)
+	}))
 	query.handleCriterion(ctx, stringCriterionHandler(imageFilter.Title, "images.title"))
-	query.handleCriterion(ctx, stringCriterionHandler(imageFilter.Path, "images.path"))
+
+	query.handleCriterion(ctx, pathCriterionHandler(imageFilter.Path, "images_query.parent_folder_path", "images_query.basename"))
 	query.handleCriterion(ctx, intCriterionHandler(imageFilter.Rating, "images.rating"))
 	query.handleCriterion(ctx, intCriterionHandler(imageFilter.OCounter, "images.o_counter"))
 	query.handleCriterion(ctx, boolCriterionHandler(imageFilter.Organized, "images.organized"))
-	query.handleCriterion(ctx, resolutionCriterionHandler(imageFilter.Resolution, "images.height", "images.width"))
+
+	query.handleCriterion(ctx, resolutionCriterionHandler(imageFilter.Resolution, "images_query.image_height", "images_query.image_width"))
 	query.handleCriterion(ctx, imageIsMissingCriterionHandler(qb, imageFilter.IsMissing))
 
 	query.handleCriterion(ctx, imageTagsCriterionHandler(qb, imageFilter.Tags))
@@ -256,7 +583,7 @@ func (qb *imageQueryBuilder) makeFilter(ctx context.Context, imageFilter *models
 	return query
 }
 
-func (qb *imageQueryBuilder) makeQuery(ctx context.Context, imageFilter *models.ImageFilterType, findFilter *models.FindFilterType) (*queryBuilder, error) {
+func (qb *ImageStore) makeQuery(ctx context.Context, imageFilter *models.ImageFilterType, findFilter *models.FindFilterType) (*queryBuilder, error) {
 	if imageFilter == nil {
 		imageFilter = &models.ImageFilterType{}
 	}
@@ -267,8 +594,15 @@ func (qb *imageQueryBuilder) makeQuery(ctx context.Context, imageFilter *models.
 	query := qb.newQuery()
 	distinctIDs(&query, imageTable)
 
+	// for convenience, join with the query view
+	query.addJoins(join{
+		table:    imagesQueryTable.GetTable(),
+		onClause: "images.id = images_query.id",
+		joinType: "INNER",
+	})
+
 	if q := findFilter.Q; q != nil && *q != "" {
-		searchColumns := []string{"images.title", "images.path", "images.checksum"}
+		searchColumns := []string{"images.title", "images_query.parent_folder_path", "images_query.basename", "images_query.fingerprint"}
 		query.parseQueryString(searchColumns, *q)
 	}
 
@@ -284,7 +618,7 @@ func (qb *imageQueryBuilder) makeQuery(ctx context.Context, imageFilter *models.
 	return &query, nil
 }
 
-func (qb *imageQueryBuilder) Query(ctx context.Context, options models.ImageQueryOptions) (*models.ImageQueryResult, error) {
+func (qb *ImageStore) Query(ctx context.Context, options models.ImageQueryOptions) (*models.ImageQueryResult, error) {
 	query, err := qb.makeQuery(ctx, options.ImageFilter, options.FindFilter)
 	if err != nil {
 		return nil, err
@@ -304,7 +638,7 @@ func (qb *imageQueryBuilder) Query(ctx context.Context, options models.ImageQuer
 	return result, nil
 }
 
-func (qb *imageQueryBuilder) queryGroupedFields(ctx context.Context, options models.ImageQueryOptions, query queryBuilder) (*models.ImageQueryResult, error) {
+func (qb *ImageStore) queryGroupedFields(ctx context.Context, options models.ImageQueryOptions, query queryBuilder) (*models.ImageQueryResult, error) {
 	if !options.Count && !options.Megapixels && !options.TotalSize {
 		// nothing to do - return empty result
 		return models.NewImageQueryResult(qb), nil
@@ -316,15 +650,16 @@ func (qb *imageQueryBuilder) queryGroupedFields(ctx context.Context, options mod
 		aggregateQuery.addColumn("COUNT(temp.id) as total")
 	}
 
-	if options.Megapixels {
-		query.addColumn("COALESCE(images.width, 0) * COALESCE(images.height, 0) / 1000000 as megapixels")
-		aggregateQuery.addColumn("COALESCE(SUM(temp.megapixels), 0) as megapixels")
-	}
+	// TODO - this doesn't work yet
+	// if options.Megapixels {
+	// 	query.addColumn("COALESCE(images.width, 0) * COALESCE(images.height, 0) / 1000000 as megapixels")
+	// 	aggregateQuery.addColumn("COALESCE(SUM(temp.megapixels), 0) as megapixels")
+	// }
 
-	if options.TotalSize {
-		query.addColumn("COALESCE(images.size, 0) as size")
-		aggregateQuery.addColumn("COALESCE(SUM(temp.size), 0) as size")
-	}
+	// if options.TotalSize {
+	// 	query.addColumn("COALESCE(images.size, 0) as size")
+	// 	aggregateQuery.addColumn("COALESCE(SUM(temp.size), 0) as size")
+	// }
 
 	const includeSortPagination = false
 	aggregateQuery.from = fmt.Sprintf("(%s) as temp", query.toSQL(includeSortPagination))
@@ -345,7 +680,7 @@ func (qb *imageQueryBuilder) queryGroupedFields(ctx context.Context, options mod
 	return ret, nil
 }
 
-func (qb *imageQueryBuilder) QueryCount(ctx context.Context, imageFilter *models.ImageFilterType, findFilter *models.FindFilterType) (int, error) {
+func (qb *ImageStore) QueryCount(ctx context.Context, imageFilter *models.ImageFilterType, findFilter *models.FindFilterType) (int, error) {
 	query, err := qb.makeQuery(ctx, imageFilter, findFilter)
 	if err != nil {
 		return 0, err
@@ -354,7 +689,7 @@ func (qb *imageQueryBuilder) QueryCount(ctx context.Context, imageFilter *models
 	return query.executeCount(ctx)
 }
 
-func imageIsMissingCriterionHandler(qb *imageQueryBuilder, isMissing *string) criterionHandlerFunc {
+func imageIsMissingCriterionHandler(qb *ImageStore, isMissing *string) criterionHandlerFunc {
 	return func(ctx context.Context, f *filterBuilder) {
 		if isMissing != nil && *isMissing != "" {
 			switch *isMissing {
@@ -376,7 +711,7 @@ func imageIsMissingCriterionHandler(qb *imageQueryBuilder, isMissing *string) cr
 	}
 }
 
-func (qb *imageQueryBuilder) getMultiCriterionHandlerBuilder(foreignTable, joinTable, foreignFK string, addJoinsFunc func(f *filterBuilder)) multiCriterionHandlerBuilder {
+func (qb *ImageStore) getMultiCriterionHandlerBuilder(foreignTable, joinTable, foreignFK string, addJoinsFunc func(f *filterBuilder)) multiCriterionHandlerBuilder {
 	return multiCriterionHandlerBuilder{
 		primaryTable: imageTable,
 		foreignTable: foreignTable,
@@ -387,7 +722,7 @@ func (qb *imageQueryBuilder) getMultiCriterionHandlerBuilder(foreignTable, joinT
 	}
 }
 
-func imageTagsCriterionHandler(qb *imageQueryBuilder, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func imageTagsCriterionHandler(qb *ImageStore, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	h := joinedHierarchicalMultiCriterionHandlerBuilder{
 		tx: qb.tx,
 
@@ -404,7 +739,7 @@ func imageTagsCriterionHandler(qb *imageQueryBuilder, tags *models.HierarchicalM
 	return h.handler(tags)
 }
 
-func imageTagCountCriterionHandler(qb *imageQueryBuilder, tagCount *models.IntCriterionInput) criterionHandlerFunc {
+func imageTagCountCriterionHandler(qb *ImageStore, tagCount *models.IntCriterionInput) criterionHandlerFunc {
 	h := countCriterionHandlerBuilder{
 		primaryTable: imageTable,
 		joinTable:    imagesTagsTable,
@@ -414,7 +749,7 @@ func imageTagCountCriterionHandler(qb *imageQueryBuilder, tagCount *models.IntCr
 	return h.handler(tagCount)
 }
 
-func imageGalleriesCriterionHandler(qb *imageQueryBuilder, galleries *models.MultiCriterionInput) criterionHandlerFunc {
+func imageGalleriesCriterionHandler(qb *ImageStore, galleries *models.MultiCriterionInput) criterionHandlerFunc {
 	addJoinsFunc := func(f *filterBuilder) {
 		qb.galleriesRepository().join(f, "", "images.id")
 		f.addLeftJoin(galleryTable, "", "galleries_images.gallery_id = galleries.id")
@@ -424,7 +759,7 @@ func imageGalleriesCriterionHandler(qb *imageQueryBuilder, galleries *models.Mul
 	return h.handler(galleries)
 }
 
-func imagePerformersCriterionHandler(qb *imageQueryBuilder, performers *models.MultiCriterionInput) criterionHandlerFunc {
+func imagePerformersCriterionHandler(qb *ImageStore, performers *models.MultiCriterionInput) criterionHandlerFunc {
 	h := joinedMultiCriterionHandlerBuilder{
 		primaryTable: imageTable,
 		joinTable:    performersImagesTable,
@@ -440,7 +775,7 @@ func imagePerformersCriterionHandler(qb *imageQueryBuilder, performers *models.M
 	return h.handler(performers)
 }
 
-func imagePerformerCountCriterionHandler(qb *imageQueryBuilder, performerCount *models.IntCriterionInput) criterionHandlerFunc {
+func imagePerformerCountCriterionHandler(qb *ImageStore, performerCount *models.IntCriterionInput) criterionHandlerFunc {
 	h := countCriterionHandlerBuilder{
 		primaryTable: imageTable,
 		joinTable:    performersImagesTable,
@@ -470,7 +805,7 @@ GROUP BY performers_images.image_id HAVING SUM(performers.favorite) = 0)`, "nofa
 	}
 }
 
-func imageStudioCriterionHandler(qb *imageQueryBuilder, studios *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func imageStudioCriterionHandler(qb *ImageStore, studios *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	h := hierarchicalMultiCriterionHandlerBuilder{
 		tx: qb.tx,
 
@@ -484,7 +819,7 @@ func imageStudioCriterionHandler(qb *imageQueryBuilder, studios *models.Hierarch
 	return h.handler(studios)
 }
 
-func imagePerformerTagsCriterionHandler(qb *imageQueryBuilder, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func imagePerformerTagsCriterionHandler(qb *ImageStore, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	return func(ctx context.Context, f *filterBuilder) {
 		if tags != nil {
 			if tags.Modifier == models.CriterionModifierIsNull || tags.Modifier == models.CriterionModifierNotNull {
@@ -519,41 +854,31 @@ INNER JOIN (` + valuesClause + `) t ON t.column2 = pt.tag_id
 	}
 }
 
-func (qb *imageQueryBuilder) getImageSort(findFilter *models.FindFilterType) string {
+func (qb *ImageStore) getImageSort(findFilter *models.FindFilterType) string {
 	if findFilter == nil || findFilter.Sort == nil || *findFilter.Sort == "" {
 		return ""
 	}
 	sort := findFilter.GetSort("title")
 	direction := findFilter.GetDirection()
 
+	// translate sort field
+	if sort == "file_mod_time" {
+		sort = "mod_time"
+	}
+
 	switch sort {
+	case "path":
+		return " ORDER BY images_query.parent_folder_path " + direction + ", images_query.basename " + direction
 	case "tag_count":
 		return getCountSort(imageTable, imagesTagsTable, imageIDColumn, direction)
 	case "performer_count":
 		return getCountSort(imageTable, performersImagesTable, imageIDColumn, direction)
 	default:
-		return getSort(sort, direction, "images")
+		return getSort(sort, direction, "images_query")
 	}
 }
 
-func (qb *imageQueryBuilder) queryImage(ctx context.Context, query string, args []interface{}) (*models.Image, error) {
-	results, err := qb.queryImages(ctx, query, args)
-	if err != nil || len(results) < 1 {
-		return nil, err
-	}
-	return results[0], nil
-}
-
-func (qb *imageQueryBuilder) queryImages(ctx context.Context, query string, args []interface{}) ([]*models.Image, error) {
-	var ret models.Images
-	if err := qb.query(ctx, query, args, &ret); err != nil {
-		return nil, err
-	}
-
-	return []*models.Image(ret), nil
-}
-
-func (qb *imageQueryBuilder) galleriesRepository() *joinRepository {
+func (qb *ImageStore) galleriesRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -564,16 +889,16 @@ func (qb *imageQueryBuilder) galleriesRepository() *joinRepository {
 	}
 }
 
-func (qb *imageQueryBuilder) GetGalleryIDs(ctx context.Context, imageID int) ([]int, error) {
-	return qb.galleriesRepository().getIDs(ctx, imageID)
-}
+// func (qb *imageQueryBuilder) GetGalleryIDs(ctx context.Context, imageID int) ([]int, error) {
+// 	return qb.galleriesRepository().getIDs(ctx, imageID)
+// }
 
-func (qb *imageQueryBuilder) UpdateGalleries(ctx context.Context, imageID int, galleryIDs []int) error {
-	// Delete the existing joins and then create new ones
-	return qb.galleriesRepository().replace(ctx, imageID, galleryIDs)
-}
+// func (qb *imageQueryBuilder) UpdateGalleries(ctx context.Context, imageID int, galleryIDs []int) error {
+// 	// Delete the existing joins and then create new ones
+// 	return qb.galleriesRepository().replace(ctx, imageID, galleryIDs)
+// }
 
-func (qb *imageQueryBuilder) performersRepository() *joinRepository {
+func (qb *ImageStore) performersRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -584,16 +909,16 @@ func (qb *imageQueryBuilder) performersRepository() *joinRepository {
 	}
 }
 
-func (qb *imageQueryBuilder) GetPerformerIDs(ctx context.Context, imageID int) ([]int, error) {
+func (qb *ImageStore) GetPerformerIDs(ctx context.Context, imageID int) ([]int, error) {
 	return qb.performersRepository().getIDs(ctx, imageID)
 }
 
-func (qb *imageQueryBuilder) UpdatePerformers(ctx context.Context, imageID int, performerIDs []int) error {
+func (qb *ImageStore) UpdatePerformers(ctx context.Context, imageID int, performerIDs []int) error {
 	// Delete the existing joins and then create new ones
 	return qb.performersRepository().replace(ctx, imageID, performerIDs)
 }
 
-func (qb *imageQueryBuilder) tagsRepository() *joinRepository {
+func (qb *ImageStore) tagsRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -604,11 +929,11 @@ func (qb *imageQueryBuilder) tagsRepository() *joinRepository {
 	}
 }
 
-func (qb *imageQueryBuilder) GetTagIDs(ctx context.Context, imageID int) ([]int, error) {
+func (qb *ImageStore) GetTagIDs(ctx context.Context, imageID int) ([]int, error) {
 	return qb.tagsRepository().getIDs(ctx, imageID)
 }
 
-func (qb *imageQueryBuilder) UpdateTags(ctx context.Context, imageID int, tagIDs []int) error {
+func (qb *ImageStore) UpdateTags(ctx context.Context, imageID int, tagIDs []int) error {
 	// Delete the existing joins and then create new ones
 	return qb.tagsRepository().replace(ctx, imageID, tagIDs)
 }