chore: fix postgres stmts

store/db/postgres/memo_relation.go

@@ -3,127 +3,111 @@ package postgres
 import (
 	"context"
 	"database/sql"
-	"fmt"
-
-	"github.com/Masterminds/squirrel"
+	"strings"
 
 	"github.com/usememos/memos/store"
 )
 
 func (d *DB) UpsertMemoRelation(ctx context.Context, create *store.MemoRelation) (*store.MemoRelation, error) {
-	qb := squirrel.Insert("memo_relation").
-		Columns("memo_id", "related_memo_id", "type").
-		Values(create.MemoID, create.RelatedMemoID, create.Type).
-		Suffix("ON CONFLICT (version) DO NOTHING").
-		PlaceholderFormat(squirrel.Dollar)
-
-	stmt, args, err := qb.ToSql()
-	if err != nil {
+	stmt := `
+		INSERT INTO memo_relation (
+			memo_id,
+			related_memo_id,
+			type
+		)
+		VALUES (` + placeholders(3) + `)
+		RETURNING memo_id, related_memo_id, type
+	`
+	memoRelation := &store.MemoRelation{}
+	if err := d.db.QueryRowContext(
+		ctx,
+		stmt,
+		create.MemoID,
+		create.RelatedMemoID,
+		create.Type,
+	).Scan(
+		&memoRelation.MemoID,
+		&memoRelation.RelatedMemoID,
+		&memoRelation.Type,
+	); err != nil {
 		return nil, err
 	}
 
-	_, err = d.db.ExecContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &store.MemoRelation{
-		MemoID:        create.MemoID,
-		RelatedMemoID: create.RelatedMemoID,
-		Type:          create.Type,
-	}, nil
+	return memoRelation, nil
 }
 
 func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation) ([]*store.MemoRelation, error) {
-	qb := squirrel.Select("memo_id", "related_memo_id", "type").
-		From("memo_relation").
-		Where("TRUE").
-		PlaceholderFormat(squirrel.Dollar)
-
+	where, args := []string{"1 = 1"}, []any{}
 	if find.MemoID != nil {
-		qb = qb.Where(squirrel.Eq{"memo_id": *find.MemoID})
+		where, args = append(where, "memo_id = "+placeholder(len(args)+1)), append(args, find.MemoID)
 	}
 	if find.RelatedMemoID != nil {
-		qb = qb.Where(squirrel.Eq{"related_memo_id": *find.RelatedMemoID})
+		where, args = append(where, "related_memo_id = "+placeholder(len(args)+1)), append(args, find.RelatedMemoID)
 	}
 	if find.Type != nil {
-		qb = qb.Where(squirrel.Eq{"type": *find.Type})
+		where, args = append(where, "type = "+placeholder(len(args)+1)), append(args, find.Type)
 	}
 
-	query, args, err := qb.ToSql()
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := d.db.QueryContext(ctx, query, args...)
+	rows, err := d.db.QueryContext(ctx, `
+		SELECT
+			memo_id,
+			related_memo_id,
+			type
+		FROM memo_relation
+		WHERE `+strings.Join(where, " AND "), args...)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	var list []*store.MemoRelation
+	list := []*store.MemoRelation{}
 	for rows.Next() {
 		memoRelation := &store.MemoRelation{}
-		if err := rows.Scan(&memoRelation.MemoID, &memoRelation.RelatedMemoID, &memoRelation.Type); err != nil {
+		if err := rows.Scan(
+			&memoRelation.MemoID,
+			&memoRelation.RelatedMemoID,
+			&memoRelation.Type,
+		); err != nil {
 			return nil, err
 		}
 		list = append(list, memoRelation)
 	}
 
-	return list, rows.Err()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return list, nil
 }
 
 func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRelation) error {
-	qb := squirrel.Delete("memo_relation").
-		PlaceholderFormat(squirrel.Dollar)
-
+	where, args := []string{"1 = 1"}, []any{}
 	if delete.MemoID != nil {
-		qb = qb.Where(squirrel.Eq{"memo_id": *delete.MemoID})
+		where, args = append(where, "memo_id = "+placeholder(len(args)+1)), append(args, delete.MemoID)
 	}
 	if delete.RelatedMemoID != nil {
-		qb = qb.Where(squirrel.Eq{"related_memo_id": *delete.RelatedMemoID})
+		where, args = append(where, "related_memo_id = "+placeholder(len(args)+1)), append(args, delete.RelatedMemoID)
 	}
 	if delete.Type != nil {
-		qb = qb.Where(squirrel.Eq{"type": *delete.Type})
+		where, args = append(where, "type = "+placeholder(len(args)+1)), append(args, delete.Type)
 	}
-
-	stmt, args, err := qb.ToSql()
-	if err != nil {
-		return err
-	}
-
+	stmt := `DELETE FROM memo_relation WHERE ` + strings.Join(where, " AND ")
 	result, err := d.db.ExecContext(ctx, stmt, args...)
 	if err != nil {
 		return err
 	}
-
-	_, err = result.RowsAffected()
-	return err
+	if _, err = result.RowsAffected(); err != nil {
+		return err
+	}
+	return nil
 }
 
 func vacuumMemoRelations(ctx context.Context, tx *sql.Tx) error {
-	// First, build the subquery for memo_id
-	subQueryMemo, subArgsMemo, err := squirrel.Select("id").From("memo").PlaceholderFormat(squirrel.Dollar).ToSql()
-	if err != nil {
+	if _, err := tx.ExecContext(ctx, `
+		DELETE FROM memo_relation
+		WHERE memo_id NOT IN (SELECT id FROM memo) OR related_memo_id NOT IN (SELECT id FROM memo)
+	`); err != nil {
 		return err
 	}
-
-	// Note: The same subquery is used for related_memo_id as it's also checking against the "memo" table
-
-	// Now, build the main delete query using the subqueries
-	query, args, err := squirrel.Delete("memo_relation").
-		Where(fmt.Sprintf("memo_id NOT IN (%s)", subQueryMemo), subArgsMemo...).
-		Where(fmt.Sprintf("related_memo_id NOT IN (%s)", subQueryMemo), subArgsMemo...).
-		PlaceholderFormat(squirrel.Dollar).
-		ToSql()
-	if err != nil {
-		return err
-	}
-
-	// Combine the arguments for both instances of the same subquery
-	args = append(args, subArgsMemo...)
-
-	// Execute the query
-	_, err = tx.ExecContext(ctx, query, args...)
-	return err
+	return nil
 }