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/gallery.go

@@ -5,84 +5,345 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"path/filepath"
+	"time"
 
+	"github.com/doug-martin/goqu/v9"
+	"github.com/doug-martin/goqu/v9/exp"
+	"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"
 )
 
-const galleryTable = "galleries"
+const (
+	galleryTable = "galleries"
 
-const performersGalleriesTable = "performers_galleries"
-const galleriesTagsTable = "galleries_tags"
-const galleriesImagesTable = "galleries_images"
-const galleriesScenesTable = "scenes_galleries"
-const galleryIDColumn = "gallery_id"
+	galleriesFilesTable      = "galleries_files"
+	performersGalleriesTable = "performers_galleries"
+	galleriesTagsTable       = "galleries_tags"
+	galleriesImagesTable     = "galleries_images"
+	galleriesScenesTable     = "scenes_galleries"
+	galleryIDColumn          = "gallery_id"
+)
 
-type galleryQueryBuilder struct {
-	repository
+type galleryRow struct {
+	ID        int               `db:"id" goqu:"skipinsert"`
+	Title     zero.String       `db:"title"`
+	URL       zero.String       `db:"url"`
+	Date      models.SQLiteDate `db:"date"`
+	Details   zero.String       `db:"details"`
+	Rating    null.Int          `db:"rating"`
+	Organized bool              `db:"organized"`
+	StudioID  null.Int          `db:"studio_id,omitempty"`
+	FolderID  null.Int          `db:"folder_id,omitempty"`
+	CreatedAt time.Time         `db:"created_at"`
+	UpdatedAt time.Time         `db:"updated_at"`
 }
 
-var GalleryReaderWriter = &galleryQueryBuilder{
-	repository{
-		tableName: galleryTable,
-		idColumn:  idColumn,
-	},
+func (r *galleryRow) fromGallery(o models.Gallery) {
+	r.ID = o.ID
+	r.Title = zero.StringFrom(o.Title)
+	r.URL = zero.StringFrom(o.URL)
+	if o.Date != nil {
+		_ = r.Date.Scan(o.Date.Time)
+	}
+	r.Details = zero.StringFrom(o.Details)
+	r.Rating = intFromPtr(o.Rating)
+	r.Organized = o.Organized
+	r.StudioID = intFromPtr(o.StudioID)
+	r.FolderID = nullIntFromFolderIDPtr(o.FolderID)
+	r.CreatedAt = o.CreatedAt
+	r.UpdatedAt = o.UpdatedAt
 }
 
-func (qb *galleryQueryBuilder) Create(ctx context.Context, newObject models.Gallery) (*models.Gallery, error) {
-	var ret models.Gallery
-	if err := qb.insertObject(ctx, newObject, &ret); err != nil {
-		return nil, err
+type galleryRowRecord struct {
+	updateRecord
+}
+
+func (r *galleryRowRecord) fromPartial(o models.GalleryPartial) {
+	r.setNullString("title", o.Title)
+	r.setNullString("url", o.URL)
+	r.setSQLiteDate("date", o.Date)
+	r.setNullString("details", o.Details)
+	r.setNullInt("rating", o.Rating)
+	r.setBool("organized", o.Organized)
+	r.setNullInt("studio_id", o.StudioID)
+	r.setTime("created_at", o.CreatedAt)
+	r.setTime("updated_at", o.UpdatedAt)
+}
+
+type galleryQueryRow struct {
+	galleryRow
+
+	relatedFileQueryRow
+
+	FolderPath null.String `db:"folder_path"`
+
+	SceneID     null.Int `db:"scene_id"`
+	TagID       null.Int `db:"tag_id"`
+	PerformerID null.Int `db:"performer_id"`
+}
+
+func (r *galleryQueryRow) resolve() *models.Gallery {
+	ret := &models.Gallery{
+		ID:         r.ID,
+		Title:      r.Title.String,
+		URL:        r.URL.String,
+		Date:       r.Date.DatePtr(),
+		Details:    r.Details.String,
+		Rating:     nullIntPtr(r.Rating),
+		Organized:  r.Organized,
+		StudioID:   nullIntPtr(r.StudioID),
+		FolderID:   nullIntFolderIDPtr(r.FolderID),
+		FolderPath: r.FolderPath.String,
+		CreatedAt:  r.CreatedAt,
+		UpdatedAt:  r.UpdatedAt,
 	}
 
-	return &ret, nil
+	r.appendRelationships(ret)
+
+	return ret
 }
 
-func (qb *galleryQueryBuilder) Update(ctx context.Context, updatedObject models.Gallery) (*models.Gallery, error) {
-	const partial = false
-	if err := qb.update(ctx, updatedObject.ID, updatedObject, partial); err != nil {
-		return nil, err
-	}
+func appendFileUnique(vs []file.File, toAdd file.File, isPrimary bool) []file.File {
+	// 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 {
 
-	return qb.Find(ctx, updatedObject.ID)
-}
-
-func (qb *galleryQueryBuilder) UpdatePartial(ctx context.Context, updatedObject models.GalleryPartial) (*models.Gallery, 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 *galleryQueryBuilder) UpdateChecksum(ctx context.Context, id int, checksum string) error {
-	return qb.updateMap(ctx, id, map[string]interface{}{
-		"checksum": checksum,
-	})
-}
-
-func (qb *galleryQueryBuilder) UpdateFileModTime(ctx context.Context, id int, modTime models.NullSQLiteTimestamp) error {
-	return qb.updateMap(ctx, id, map[string]interface{}{
-		"file_mod_time": modTime,
-	})
-}
-
-func (qb *galleryQueryBuilder) Destroy(ctx context.Context, id int) error {
-	return qb.destroyExisting(ctx, []int{id})
-}
-
-func (qb *galleryQueryBuilder) Find(ctx context.Context, id int) (*models.Gallery, error) {
-	var ret models.Gallery
-	if err := qb.getByID(ctx, id, &ret); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
+			// merge the two
+			mergeFiles(vs[i], toAdd)
+			return vs
 		}
-		return nil, err
 	}
-	return &ret, nil
+
+	if !isPrimary {
+		return append(vs, toAdd)
+	}
+
+	// primary should be first
+	return append([]file.File{toAdd}, vs...)
 }
 
-func (qb *galleryQueryBuilder) FindMany(ctx context.Context, ids []int) ([]*models.Gallery, error) {
+func (r *galleryQueryRow) appendRelationships(i *models.Gallery) {
+	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.SceneID.Valid {
+		i.SceneIDs = intslice.IntAppendUnique(i.SceneIDs, int(r.SceneID.Int64))
+	}
+
+	if r.relatedFileQueryRow.FileID.Valid {
+		f := r.fileQueryRow.resolve()
+		i.Files = appendFileUnique(i.Files, f, r.Primary.Bool)
+	}
+}
+
+type galleryQueryRows []galleryQueryRow
+
+func (r galleryQueryRows) resolve() []*models.Gallery {
+	var ret []*models.Gallery
+	var last *models.Gallery
+	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 GalleryStore struct {
+	repository
+
+	tableMgr      *table
+	queryTableMgr *table
+}
+
+func NewGalleryStore() *GalleryStore {
+	return &GalleryStore{
+		repository: repository{
+			tableName: galleryTable,
+			idColumn:  idColumn,
+		},
+		tableMgr:      galleryTableMgr,
+		queryTableMgr: galleryQueryTableMgr,
+	}
+}
+
+func (qb *GalleryStore) table() exp.IdentifierExpression {
+	return qb.tableMgr.table
+}
+
+func (qb *GalleryStore) queryTable() exp.IdentifierExpression {
+	return qb.queryTableMgr.table
+}
+
+func (qb *GalleryStore) Create(ctx context.Context, newObject *models.Gallery, fileIDs []file.ID) error {
+	var r galleryRow
+	r.fromGallery(*newObject)
+
+	id, err := qb.tableMgr.insertID(ctx, r)
+	if err != nil {
+		return err
+	}
+
+	if len(fileIDs) > 0 {
+		const firstPrimary = true
+		if err := galleriesFilesTableMgr.insertJoins(ctx, id, firstPrimary, fileIDs); err != nil {
+			return err
+		}
+	}
+
+	if err := galleriesPerformersTableMgr.insertJoins(ctx, id, newObject.PerformerIDs); err != nil {
+		return err
+	}
+	if err := galleriesTagsTableMgr.insertJoins(ctx, id, newObject.TagIDs); err != nil {
+		return err
+	}
+	if err := galleriesScenesTableMgr.insertJoins(ctx, id, newObject.SceneIDs); err != nil {
+		return err
+	}
+
+	updated, err := qb.Find(ctx, id)
+	if err != nil {
+		return fmt.Errorf("finding after create: %w", err)
+	}
+
+	*newObject = *updated
+
+	return nil
+}
+
+func (qb *GalleryStore) Update(ctx context.Context, updatedObject *models.Gallery) error {
+	var r galleryRow
+	r.fromGallery(*updatedObject)
+
+	if err := qb.tableMgr.updateByID(ctx, updatedObject.ID, r); err != nil {
+		return err
+	}
+
+	if err := galleriesPerformersTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.PerformerIDs); err != nil {
+		return err
+	}
+	if err := galleriesTagsTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.TagIDs); err != nil {
+		return err
+	}
+	if err := galleriesScenesTableMgr.replaceJoins(ctx, updatedObject.ID, updatedObject.SceneIDs); err != nil {
+		return err
+	}
+
+	fileIDs := make([]file.ID, len(updatedObject.Files))
+	for i, f := range updatedObject.Files {
+		fileIDs[i] = f.Base().ID
+	}
+
+	if err := galleriesFilesTableMgr.replaceJoins(ctx, updatedObject.ID, fileIDs); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (qb *GalleryStore) UpdatePartial(ctx context.Context, id int, partial models.GalleryPartial) (*models.Gallery, error) {
+	r := galleryRowRecord{
+		updateRecord{
+			Record: make(exp.Record),
+		},
+	}
+
+	r.fromPartial(partial)
+
+	if len(r.Record) > 0 {
+		if err := qb.tableMgr.updateByID(ctx, id, r.Record); err != nil {
+			return nil, err
+		}
+	}
+
+	if partial.PerformerIDs != nil {
+		if err := galleriesPerformersTableMgr.modifyJoins(ctx, id, partial.PerformerIDs.IDs, partial.PerformerIDs.Mode); err != nil {
+			return nil, err
+		}
+	}
+	if partial.TagIDs != nil {
+		if err := galleriesTagsTableMgr.modifyJoins(ctx, id, partial.TagIDs.IDs, partial.TagIDs.Mode); err != nil {
+			return nil, err
+		}
+	}
+	if partial.SceneIDs != nil {
+		if err := galleriesScenesTableMgr.modifyJoins(ctx, id, partial.SceneIDs.IDs, partial.SceneIDs.Mode); err != nil {
+			return nil, err
+		}
+	}
+
+	return qb.Find(ctx, id)
+}
+
+func (qb *GalleryStore) Destroy(ctx context.Context, id int) error {
+	return qb.tableMgr.destroyExisting(ctx, []int{id})
+}
+
+func (qb *GalleryStore) selectDataset() *goqu.SelectDataset {
+	return dialect.From(galleriesQueryTable).Select(galleriesQueryTable.All())
+}
+
+func (qb *GalleryStore) get(ctx context.Context, q *goqu.SelectDataset) (*models.Gallery, error) {
+	ret, err := qb.getMany(ctx, q)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ret) == 0 {
+		return nil, sql.ErrNoRows
+	}
+
+	return ret[0], nil
+}
+
+func (qb *GalleryStore) getMany(ctx context.Context, q *goqu.SelectDataset) ([]*models.Gallery, error) {
+	const single = false
+	var rows galleryQueryRows
+	if err := queryFunc(ctx, q, single, func(r *sqlx.Rows) error {
+		var f galleryQueryRow
+		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 *GalleryStore) Find(ctx context.Context, id int) (*models.Gallery, error) {
+	q := qb.selectDataset().Where(qb.queryTableMgr.byID(id))
+
+	ret, err := qb.get(ctx, q)
+	if err != nil {
+		return nil, fmt.Errorf("getting gallery by id %d: %w", id, err)
+	}
+
+	return ret, nil
+}
+
+func (qb *GalleryStore) FindMany(ctx context.Context, ids []int) ([]*models.Gallery, error) {
 	var galleries []*models.Gallery
 	for _, id := range ids {
 		gallery, err := qb.Find(ctx, id)
@@ -100,64 +361,176 @@ func (qb *galleryQueryBuilder) FindMany(ctx context.Context, ids []int) ([]*mode
 	return galleries, nil
 }
 
-func (qb *galleryQueryBuilder) FindByChecksum(ctx context.Context, checksum string) (*models.Gallery, error) {
-	query := "SELECT * FROM galleries WHERE checksum = ? LIMIT 1"
-	args := []interface{}{checksum}
-	return qb.queryGallery(ctx, query, args)
+func (qb *GalleryStore) findBySubquery(ctx context.Context, sq *goqu.SelectDataset) ([]*models.Gallery, error) {
+	table := qb.queryTable()
+
+	q := qb.selectDataset().Prepared(true).Where(
+		table.Col(idColumn).Eq(
+			sq,
+		),
+	)
+
+	return qb.getMany(ctx, q)
 }
 
-func (qb *galleryQueryBuilder) FindByChecksums(ctx context.Context, checksums []string) ([]*models.Gallery, error) {
-	query := "SELECT * FROM galleries WHERE checksum IN " + getInBinding(len(checksums))
-	var args []interface{}
-	for _, checksum := range checksums {
-		args = append(args, checksum)
+func (qb *GalleryStore) FindByFileID(ctx context.Context, fileID file.ID) ([]*models.Gallery, error) {
+	table := qb.queryTable()
+
+	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 gallery by file id %d: %w", fileID, err)
 	}
-	return qb.queryGalleries(ctx, query, args)
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) FindByPath(ctx context.Context, path string) (*models.Gallery, error) {
-	query := "SELECT * FROM galleries WHERE path = ? LIMIT 1"
-	args := []interface{}{path}
-	return qb.queryGallery(ctx, query, args)
+func (qb *GalleryStore) FindByFingerprints(ctx context.Context, fp []file.Fingerprint) ([]*models.Gallery, error) {
+	table := qb.queryTable()
+
+	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 gallery by fingerprints: %w", err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) FindBySceneID(ctx context.Context, sceneID int) ([]*models.Gallery, error) {
-	query := selectAll(galleryTable) + `
-		LEFT JOIN scenes_galleries as scenes_join on scenes_join.gallery_id = galleries.id
-		WHERE scenes_join.scene_id = ?
-		GROUP BY galleries.id
-	`
-	args := []interface{}{sceneID}
-	return qb.queryGalleries(ctx, query, args)
+func (qb *GalleryStore) FindByChecksum(ctx context.Context, checksum string) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+
+	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 gallery by checksum %s: %w", checksum, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) FindByImageID(ctx context.Context, imageID int) ([]*models.Gallery, error) {
-	query := selectAll(galleryTable) + `
-	INNER JOIN galleries_images as images_join on images_join.gallery_id = galleries.id
-	WHERE images_join.image_id = ?
-	GROUP BY galleries.id
-	`
-	args := []interface{}{imageID}
-	return qb.queryGalleries(ctx, query, args)
+func (qb *GalleryStore) FindByChecksums(ctx context.Context, checksums []string) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("fingerprint_type").Eq(file.FingerprintTypeMD5),
+		table.Col("fingerprint").In(checksums),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting gallery by checksums: %w", err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) CountByImageID(ctx context.Context, imageID int) (int, error) {
-	query := `SELECT image_id FROM galleries_images
-	WHERE image_id = ?
-	GROUP BY gallery_id`
-	args := []interface{}{imageID}
-	return qb.runCountQuery(ctx, qb.buildCountQuery(query), args)
+func (qb *GalleryStore) FindByPath(ctx context.Context, p string) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+	basename := filepath.Base(p)
+	dir, _ := path(filepath.Dir(p)).Value()
+	pp, _ := path(p).Value()
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		goqu.Or(
+			goqu.And(
+				table.Col("parent_folder_path").Eq(dir),
+				table.Col("basename").Eq(basename),
+			),
+			table.Col("folder_path").Eq(pp),
+		),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return nil, fmt.Errorf("getting gallery by path %s: %w", p, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) Count(ctx context.Context) (int, error) {
-	return qb.runCountQuery(ctx, qb.buildCountQuery("SELECT galleries.id FROM galleries"), nil)
+func (qb *GalleryStore) FindByFolderID(ctx context.Context, folderID file.FolderID) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("folder_id").Eq(folderID),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting galleries for folder %d: %w", folderID, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) All(ctx context.Context) ([]*models.Gallery, error) {
-	return qb.queryGalleries(ctx, selectAll("galleries")+qb.getGallerySort(nil), nil)
+func (qb *GalleryStore) FindBySceneID(ctx context.Context, sceneID int) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).Where(
+		table.Col("scene_id").Eq(sceneID),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting galleries for scene %d: %w", sceneID, err)
+	}
+
+	return ret, nil
 }
 
-func (qb *galleryQueryBuilder) validateFilter(galleryFilter *models.GalleryFilterType) error {
+func (qb *GalleryStore) FindByImageID(ctx context.Context, imageID int) ([]*models.Gallery, error) {
+	table := galleriesQueryTable
+
+	sq := dialect.From(table).Select(table.Col(idColumn)).InnerJoin(
+		galleriesImagesJoinTable,
+		goqu.On(table.Col(idColumn).Eq(galleriesImagesJoinTable.Col(galleryIDColumn))),
+	).Where(
+		galleriesImagesJoinTable.Col("image_id").Eq(imageID),
+	)
+
+	ret, err := qb.findBySubquery(ctx, sq)
+	if err != nil {
+		return nil, fmt.Errorf("getting galleries for image %d: %w", imageID, err)
+	}
+
+	return ret, nil
+}
+
+func (qb *GalleryStore) CountByImageID(ctx context.Context, imageID int) (int, error) {
+	joinTable := galleriesImagesJoinTable
+
+	q := dialect.Select(goqu.COUNT("*")).From(joinTable).Where(joinTable.Col(imageIDColumn).Eq(imageID))
+	return count(ctx, q)
+}
+
+func (qb *GalleryStore) Count(ctx context.Context) (int, error) {
+	q := dialect.Select(goqu.COUNT("*")).From(qb.table())
+	return count(ctx, q)
+}
+
+func (qb *GalleryStore) All(ctx context.Context) ([]*models.Gallery, error) {
+	return qb.getMany(ctx, qb.selectDataset())
+}
+
+func (qb *GalleryStore) validateFilter(galleryFilter *models.GalleryFilterType) error {
 	const and = "AND"
 	const or = "OR"
 	const not = "NOT"
@@ -188,7 +561,7 @@ func (qb *galleryQueryBuilder) validateFilter(galleryFilter *models.GalleryFilte
 	return nil
 }
 
-func (qb *galleryQueryBuilder) makeFilter(ctx context.Context, galleryFilter *models.GalleryFilterType) *filterBuilder {
+func (qb *GalleryStore) makeFilter(ctx context.Context, galleryFilter *models.GalleryFilterType) *filterBuilder {
 	query := &filterBuilder{}
 
 	if galleryFilter.And != nil {
@@ -203,9 +576,26 @@ func (qb *galleryQueryBuilder) makeFilter(ctx context.Context, galleryFilter *mo
 
 	query.handleCriterion(ctx, stringCriterionHandler(galleryFilter.Title, "galleries.title"))
 	query.handleCriterion(ctx, stringCriterionHandler(galleryFilter.Details, "galleries.details"))
-	query.handleCriterion(ctx, stringCriterionHandler(galleryFilter.Checksum, "galleries.checksum"))
-	query.handleCriterion(ctx, boolCriterionHandler(galleryFilter.IsZip, "galleries.zip"))
-	query.handleCriterion(ctx, stringCriterionHandler(galleryFilter.Path, "galleries.path"))
+
+	query.handleCriterion(ctx, criterionHandlerFunc(func(ctx context.Context, f *filterBuilder) {
+		if galleryFilter.Checksum != nil {
+			f.addLeftJoin(fingerprintTable, "fingerprints_md5", "galleries_query.file_id = fingerprints_md5.file_id AND fingerprints_md5.type = 'md5'")
+		}
+
+		stringCriterionHandler(galleryFilter.Checksum, "fingerprints_md5.fingerprint")(ctx, f)
+	}))
+
+	query.handleCriterion(ctx, criterionHandlerFunc(func(ctx context.Context, f *filterBuilder) {
+		if galleryFilter.IsZip != nil {
+			if *galleryFilter.IsZip {
+				f.addWhere("galleries_query.file_id IS NOT NULL")
+			} else {
+				f.addWhere("galleries_query.file_id IS NULL")
+			}
+		}
+	}))
+
+	query.handleCriterion(ctx, pathCriterionHandler(galleryFilter.Path, "galleries_query.parent_folder_path", "galleries_query.basename"))
 	query.handleCriterion(ctx, intCriterionHandler(galleryFilter.Rating, "galleries.rating"))
 	query.handleCriterion(ctx, stringCriterionHandler(galleryFilter.URL, "galleries.url"))
 	query.handleCriterion(ctx, boolCriterionHandler(galleryFilter.Organized, "galleries.organized"))
@@ -224,7 +614,7 @@ func (qb *galleryQueryBuilder) makeFilter(ctx context.Context, galleryFilter *mo
 	return query
 }
 
-func (qb *galleryQueryBuilder) makeQuery(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) (*queryBuilder, error) {
+func (qb *GalleryStore) makeQuery(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) (*queryBuilder, error) {
 	if galleryFilter == nil {
 		galleryFilter = &models.GalleryFilterType{}
 	}
@@ -235,8 +625,16 @@ func (qb *galleryQueryBuilder) makeQuery(ctx context.Context, galleryFilter *mod
 	query := qb.newQuery()
 	distinctIDs(&query, galleryTable)
 
+	// for convenience, join with the query view
+	query.addJoins(join{
+		table:    galleriesQueryTable.GetTable(),
+		onClause: "galleries.id = galleries_query.id",
+		joinType: "INNER",
+	})
+
 	if q := findFilter.Q; q != nil && *q != "" {
-		searchColumns := []string{"galleries.title", "galleries.path", "galleries.checksum"}
+		// add joins for files and checksum
+		searchColumns := []string{"galleries.title", "galleries_query.folder_path", "galleries_query.parent_folder_path", "galleries_query.basename", "galleries_query.fingerprint"}
 		query.parseQueryString(searchColumns, *q)
 	}
 
@@ -252,7 +650,7 @@ func (qb *galleryQueryBuilder) makeQuery(ctx context.Context, galleryFilter *mod
 	return &query, nil
 }
 
-func (qb *galleryQueryBuilder) Query(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) ([]*models.Gallery, int, error) {
+func (qb *GalleryStore) Query(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) ([]*models.Gallery, int, error) {
 	query, err := qb.makeQuery(ctx, galleryFilter, findFilter)
 	if err != nil {
 		return nil, 0, err
@@ -276,7 +674,7 @@ func (qb *galleryQueryBuilder) Query(ctx context.Context, galleryFilter *models.
 	return galleries, countResult, nil
 }
 
-func (qb *galleryQueryBuilder) QueryCount(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) (int, error) {
+func (qb *GalleryStore) QueryCount(ctx context.Context, galleryFilter *models.GalleryFilterType, findFilter *models.FindFilterType) (int, error) {
 	query, err := qb.makeQuery(ctx, galleryFilter, findFilter)
 	if err != nil {
 		return 0, err
@@ -285,7 +683,7 @@ func (qb *galleryQueryBuilder) QueryCount(ctx context.Context, galleryFilter *mo
 	return query.executeCount(ctx)
 }
 
-func galleryIsMissingCriterionHandler(qb *galleryQueryBuilder, isMissing *string) criterionHandlerFunc {
+func galleryIsMissingCriterionHandler(qb *GalleryStore, isMissing *string) criterionHandlerFunc {
 	return func(ctx context.Context, f *filterBuilder) {
 		if isMissing != nil && *isMissing != "" {
 			switch *isMissing {
@@ -309,7 +707,7 @@ func galleryIsMissingCriterionHandler(qb *galleryQueryBuilder, isMissing *string
 	}
 }
 
-func galleryTagsCriterionHandler(qb *galleryQueryBuilder, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func galleryTagsCriterionHandler(qb *GalleryStore, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	h := joinedHierarchicalMultiCriterionHandlerBuilder{
 		tx: qb.tx,
 
@@ -326,7 +724,7 @@ func galleryTagsCriterionHandler(qb *galleryQueryBuilder, tags *models.Hierarchi
 	return h.handler(tags)
 }
 
-func galleryTagCountCriterionHandler(qb *galleryQueryBuilder, tagCount *models.IntCriterionInput) criterionHandlerFunc {
+func galleryTagCountCriterionHandler(qb *GalleryStore, tagCount *models.IntCriterionInput) criterionHandlerFunc {
 	h := countCriterionHandlerBuilder{
 		primaryTable: galleryTable,
 		joinTable:    galleriesTagsTable,
@@ -336,7 +734,7 @@ func galleryTagCountCriterionHandler(qb *galleryQueryBuilder, tagCount *models.I
 	return h.handler(tagCount)
 }
 
-func galleryPerformersCriterionHandler(qb *galleryQueryBuilder, performers *models.MultiCriterionInput) criterionHandlerFunc {
+func galleryPerformersCriterionHandler(qb *GalleryStore, performers *models.MultiCriterionInput) criterionHandlerFunc {
 	h := joinedMultiCriterionHandlerBuilder{
 		primaryTable: galleryTable,
 		joinTable:    performersGalleriesTable,
@@ -352,7 +750,7 @@ func galleryPerformersCriterionHandler(qb *galleryQueryBuilder, performers *mode
 	return h.handler(performers)
 }
 
-func galleryPerformerCountCriterionHandler(qb *galleryQueryBuilder, performerCount *models.IntCriterionInput) criterionHandlerFunc {
+func galleryPerformerCountCriterionHandler(qb *GalleryStore, performerCount *models.IntCriterionInput) criterionHandlerFunc {
 	h := countCriterionHandlerBuilder{
 		primaryTable: galleryTable,
 		joinTable:    performersGalleriesTable,
@@ -362,7 +760,7 @@ func galleryPerformerCountCriterionHandler(qb *galleryQueryBuilder, performerCou
 	return h.handler(performerCount)
 }
 
-func galleryImageCountCriterionHandler(qb *galleryQueryBuilder, imageCount *models.IntCriterionInput) criterionHandlerFunc {
+func galleryImageCountCriterionHandler(qb *GalleryStore, imageCount *models.IntCriterionInput) criterionHandlerFunc {
 	h := countCriterionHandlerBuilder{
 		primaryTable: galleryTable,
 		joinTable:    galleriesImagesTable,
@@ -372,7 +770,7 @@ func galleryImageCountCriterionHandler(qb *galleryQueryBuilder, imageCount *mode
 	return h.handler(imageCount)
 }
 
-func galleryStudioCriterionHandler(qb *galleryQueryBuilder, studios *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func galleryStudioCriterionHandler(qb *GalleryStore, studios *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	h := hierarchicalMultiCriterionHandlerBuilder{
 		tx: qb.tx,
 
@@ -386,7 +784,7 @@ func galleryStudioCriterionHandler(qb *galleryQueryBuilder, studios *models.Hier
 	return h.handler(studios)
 }
 
-func galleryPerformerTagsCriterionHandler(qb *galleryQueryBuilder, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
+func galleryPerformerTagsCriterionHandler(qb *GalleryStore, tags *models.HierarchicalMultiCriterionInput) criterionHandlerFunc {
 	return func(ctx context.Context, f *filterBuilder) {
 		if tags != nil {
 			if tags.Modifier == models.CriterionModifierIsNull || tags.Modifier == models.CriterionModifierNotNull {
@@ -458,16 +856,18 @@ func galleryPerformerAgeCriterionHandler(performerAge *models.IntCriterionInput)
 	}
 }
 
-func galleryAverageResolutionCriterionHandler(qb *galleryQueryBuilder, resolution *models.ResolutionCriterionInput) criterionHandlerFunc {
+func galleryAverageResolutionCriterionHandler(qb *GalleryStore, resolution *models.ResolutionCriterionInput) criterionHandlerFunc {
 	return func(ctx context.Context, f *filterBuilder) {
 		if resolution != nil && resolution.Value.IsValid() {
 			qb.imagesRepository().join(f, "images_join", "galleries.id")
 			f.addLeftJoin("images", "", "images_join.image_id = images.id")
+			f.addLeftJoin("images_files", "", "images.id = images_files.image_id")
+			f.addLeftJoin("image_files", "", "images_files.file_id = image_files.file_id")
 
 			min := resolution.Value.GetMinResolution()
 			max := resolution.Value.GetMaxResolution()
 
-			const widthHeight = "avg(MIN(images.width, images.height))"
+			const widthHeight = "avg(MIN(image_files.width, image_files.height))"
 
 			switch resolution.Modifier {
 			case models.CriterionModifierEquals:
@@ -483,7 +883,7 @@ func galleryAverageResolutionCriterionHandler(qb *galleryQueryBuilder, resolutio
 	}
 }
 
-func (qb *galleryQueryBuilder) getGallerySort(findFilter *models.FindFilterType) string {
+func (qb *GalleryStore) getGallerySort(findFilter *models.FindFilterType) string {
 	if findFilter == nil || findFilter.Sort == nil || *findFilter.Sort == "" {
 		return ""
 	}
@@ -491,6 +891,11 @@ func (qb *galleryQueryBuilder) getGallerySort(findFilter *models.FindFilterType)
 	sort := findFilter.GetSort("path")
 	direction := findFilter.GetDirection()
 
+	// translate sort field
+	if sort == "file_mod_time" {
+		sort = "mod_time"
+	}
+
 	switch sort {
 	case "images_count":
 		return getCountSort(galleryTable, galleriesImagesTable, galleryIDColumn, direction)
@@ -498,29 +903,15 @@ func (qb *galleryQueryBuilder) getGallerySort(findFilter *models.FindFilterType)
 		return getCountSort(galleryTable, galleriesTagsTable, galleryIDColumn, direction)
 	case "performer_count":
 		return getCountSort(galleryTable, performersGalleriesTable, galleryIDColumn, direction)
+	case "path":
+		// special handling for path
+		return fmt.Sprintf(" ORDER BY galleries_query.parent_folder_path %s, galleries_query.basename %[1]s", direction)
 	default:
-		return getSort(sort, direction, "galleries")
+		return getSort(sort, direction, "galleries_query")
 	}
 }
 
-func (qb *galleryQueryBuilder) queryGallery(ctx context.Context, query string, args []interface{}) (*models.Gallery, error) {
-	results, err := qb.queryGalleries(ctx, query, args)
-	if err != nil || len(results) < 1 {
-		return nil, err
-	}
-	return results[0], nil
-}
-
-func (qb *galleryQueryBuilder) queryGalleries(ctx context.Context, query string, args []interface{}) ([]*models.Gallery, error) {
-	var ret models.Galleries
-	if err := qb.query(ctx, query, args, &ret); err != nil {
-		return nil, err
-	}
-
-	return []*models.Gallery(ret), nil
-}
-
-func (qb *galleryQueryBuilder) performersRepository() *joinRepository {
+func (qb *GalleryStore) performersRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -531,16 +922,7 @@ func (qb *galleryQueryBuilder) performersRepository() *joinRepository {
 	}
 }
 
-func (qb *galleryQueryBuilder) GetPerformerIDs(ctx context.Context, galleryID int) ([]int, error) {
-	return qb.performersRepository().getIDs(ctx, galleryID)
-}
-
-func (qb *galleryQueryBuilder) UpdatePerformers(ctx context.Context, galleryID int, performerIDs []int) error {
-	// Delete the existing joins and then create new ones
-	return qb.performersRepository().replace(ctx, galleryID, performerIDs)
-}
-
-func (qb *galleryQueryBuilder) tagsRepository() *joinRepository {
+func (qb *GalleryStore) tagsRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -551,16 +933,7 @@ func (qb *galleryQueryBuilder) tagsRepository() *joinRepository {
 	}
 }
 
-func (qb *galleryQueryBuilder) GetTagIDs(ctx context.Context, galleryID int) ([]int, error) {
-	return qb.tagsRepository().getIDs(ctx, galleryID)
-}
-
-func (qb *galleryQueryBuilder) UpdateTags(ctx context.Context, galleryID int, tagIDs []int) error {
-	// Delete the existing joins and then create new ones
-	return qb.tagsRepository().replace(ctx, galleryID, tagIDs)
-}
-
-func (qb *galleryQueryBuilder) imagesRepository() *joinRepository {
+func (qb *GalleryStore) imagesRepository() *joinRepository {
 	return &joinRepository{
 		repository: repository{
 			tx:        qb.tx,
@@ -571,31 +944,11 @@ func (qb *galleryQueryBuilder) imagesRepository() *joinRepository {
 	}
 }
 
-func (qb *galleryQueryBuilder) GetImageIDs(ctx context.Context, galleryID int) ([]int, error) {
+func (qb *GalleryStore) GetImageIDs(ctx context.Context, galleryID int) ([]int, error) {
 	return qb.imagesRepository().getIDs(ctx, galleryID)
 }
 
-func (qb *galleryQueryBuilder) UpdateImages(ctx context.Context, galleryID int, imageIDs []int) error {
+func (qb *GalleryStore) UpdateImages(ctx context.Context, galleryID int, imageIDs []int) error {
 	// Delete the existing joins and then create new ones
 	return qb.imagesRepository().replace(ctx, galleryID, imageIDs)
 }
-
-func (qb *galleryQueryBuilder) scenesRepository() *joinRepository {
-	return &joinRepository{
-		repository: repository{
-			tx:        qb.tx,
-			tableName: galleriesScenesTable,
-			idColumn:  galleryIDColumn,
-		},
-		fkColumn: sceneIDColumn,
-	}
-}
-
-func (qb *galleryQueryBuilder) GetSceneIDs(ctx context.Context, galleryID int) ([]int, error) {
-	return qb.scenesRepository().getIDs(ctx, galleryID)
-}
-
-func (qb *galleryQueryBuilder) UpdateScenes(ctx context.Context, galleryID int, sceneIDs []int) error {
-	// Delete the existing joins and then create new ones
-	return qb.scenesRepository().replace(ctx, galleryID, sceneIDs)
-}