cp result to outd

go.mod

@@ -4,16 +4,23 @@ go 1.23.0
 
 toolchain go1.23.9
 
-require modernc.org/sqlite v1.37.1
+require (
+	github.com/glebarez/sqlite v1.11.0
+	github.com/google/uuid v1.6.0
+	modernc.org/sqlite v1.37.1 // indirect
+)
 
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/google/uuid v1.6.0 // indirect
+	github.com/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
 	golang.org/x/sys v0.33.0 // indirect
+	gorm.io/gorm v1.25.7 // indirect
 	modernc.org/libc v1.65.7 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -1,9 +1,17 @@
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
+github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
+github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
+github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
@@ -21,6 +29,8 @@ golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
 golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
 modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
 modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=

main.go

@@ -11,98 +11,280 @@ import (
 	"slices"
 	"strings"
 
+	//_ "github.com/glebarez/sqlite"
+	"github.com/google/uuid"
 	_ "modernc.org/sqlite"
 )
 
 const (
-	jellyDB   = "jellyfin.db"
-	libraryDB = "library.db"
+	jellyDB = "jellyfin.db"
+	libDB   = "library.db"
 )
 
 func main() {
 	data := os.Args[1]
 	fromU := os.Args[2]
 	toU := os.Args[3]
-	_ = toU
+	outd := os.Args[4]
 
 	workd, err := ioutil.TempDir(os.TempDir(), "jellyfin-user-clone.*")
 	if err != nil {
-		panic(err)
+		log.Fatalf("%v", err)
 	}
 
 	{
 		if err := cp(path.Join(data, jellyDB), path.Join(workd, jellyDB)); err != nil {
-			panic(err)
-		} else if err := cp(path.Join(data, libraryDB), path.Join(workd, libraryDB)); err != nil {
-			panic(err)
+			log.Fatalf("%v", err)
+		} else if err := cp(path.Join(data, libDB), path.Join(workd, libDB)); err != nil {
+			log.Fatalf("%v", err)
 		}
 	}
 
 	jellyfinDB, err := sql.Open("sqlite", path.Join(workd, jellyDB))
 	if err != nil {
-		panic(err)
+		log.Fatalf("%v", err)
 	}
 	defer jellyfinDB.Close()
 
+	libraryDB, err := sql.Open("sqlite", path.Join(workd, libDB))
+	if err != nil {
+		log.Fatalf("%v", err)
+	}
+	defer libraryDB.Close()
+
 	fromUUID, err := SelectOne[string](jellyfinDB, `SELECT Id FROM Users WHERE Username = $1`, fromU)
 	if err != nil {
-		panic(err)
+		log.Fatalf("%v", err)
 	}
 	fromID, err := SelectOne[int](jellyfinDB, `SELECT InternalId FROM Users WHERE Id = $1`, fromUUID)
 	if err != nil {
-		panic(err)
+		log.Fatalf("%v", err)
 	}
 	log.Println(fromU, fromUUID, fromID)
 
 	if n, err := SelectOne[int](jellyfinDB, `SELECT COUNT(*) FROM Users WHERE Username = $1`, toU); err != nil {
-		panic(err)
-	} else if n == 1 {
-	} else if err := Exec(jellyfinDB, `INSERT INTO Users () SELECT * FROM Users WHERE Id = $1`, fromUUID); err != nil {
-		panic(err)
-	}
-
-	panic("not impl get toU, toUUID")
-
-	tables, err := Tables(jellyfinDB)
-	if err != nil {
-		panic(err)
-	}
-
-	for _, table := range tables {
-		columns, err := Columns(jellyfinDB, table)
+		log.Fatalf("%v", err)
+	} else if n != 1 {
+		nextID, err := SelectOne[int](libraryDB, `SELECT COALESCE(MAX(userId), 0)+1 FROM UserDatas`)
 		if err != nil {
-			panic(err)
-		}
-		log.Println(table, columns)
-
-		userColumns := slices.DeleteFunc(slices.Clone(columns), func(s string) bool {
-			return !slices.Contains([]string{
-				"user",
-				"userid",
-			}, strings.ToLower(s))
-		})
-		if len(userColumns) == 0 {
-			continue
+			log.Fatalf("failed to get max userid ever: %v", err)
 		}
 
-		for _, column := range userColumns {
-			if n, err := SelectOne[int](jellyfinDB, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromID); err != nil {
-				panic(err)
-			} else if n > 0 {
-				notThisColumn := strings.Join(slices.DeleteFunc(slices.Clone(columns), func(s string) bool { return s == column }), ", ")
-				if err := Exec(jellyfinDB, fmt.Sprintf(`INSERT INTO %q (%q, %s) SELECT $2, %s FROM %q WHERE %q = $1`, table, column, notThisColumn, notThisColumn, table, column), fromID, toID); err != nil {
-					panic(err)
+		if err := CloneForColumn(jellyfinDB, `Users`, `Username`, fromU, toU, map[string]any{`InternalId`: nextID}); err != nil {
+			log.Fatalf("%v", err)
+		}
+
+		if n, err := SelectOne[int](jellyfinDB, `SELECT COUNT(*) FROM Users WHERE Username = $1 AND InternalId = $2`, toU, nextID); err != nil {
+			log.Fatalf("%v", err)
+		} else if n != 1 {
+			log.Fatalf("still no username=%q after insert", toU)
+		}
+	}
+
+	toUUID, err := SelectOne[string](jellyfinDB, `SELECT Id FROM Users WHERE Username = $1`, toU)
+	if err != nil {
+		log.Fatalf("%v", err)
+	}
+	toID, err := SelectOne[int](jellyfinDB, `SELECT InternalId FROM Users WHERE Id = $1`, toUUID)
+	if err != nil {
+		log.Fatalf("%v", err)
+	}
+	log.Println(toU, toUUID, toID)
+
+	for _, db := range []*sql.DB{jellyfinDB, libraryDB} {
+		tables, err := Tables(db)
+		if err != nil {
+			log.Fatalf("%v", err)
+		}
+
+		for _, table := range tables {
+			columns, err := Columns(db, table)
+			if err != nil {
+				log.Fatalf("%v", err)
+			}
+
+			userColumns := slices.DeleteFunc(slices.Clone(columns), func(s string) bool {
+				return !slices.Contains([]string{
+					"user",
+					"userid",
+				}, strings.ToLower(s))
+			})
+			if len(userColumns) == 0 {
+				continue
+			}
+
+			for _, column := range userColumns {
+				log.Println(table, column, "...")
+
+				if n, err := SelectOne[int](db, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromID); err != nil {
+					log.Fatalf("%v", err)
+				} else if n > 0 {
+					if err := CloneForColumn(db, table, column, fromID, toID, nil); err != nil {
+						log.Fatalf("%v", err)
+					}
+				} else if n, err := SelectOne[int](db, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromUUID); err != nil {
+					log.Fatalf("%v", err)
+				} else if n > 0 {
+					if err := CloneForColumn(db, table, column, fromUUID, toUUID, nil); err != nil {
+						log.Fatalf("%v", err)
+					}
 				}
-			} else if n, err := SelectOne[int](jellyfinDB, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromUUID); err != nil {
-				panic(err)
-			} else if n > 0 {
-				panic("not impl: col is uuid")
 			}
 		}
-
-		log.Println(table, userColumns)
-		panic("not impl")
 	}
+
+	entries, err := os.ReadDir(workd)
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, entry := range entries {
+		os.MkdirAll(path.Dir(path.Join(path.Join(outd, entry.Name()))), os.ModePerm)
+		if err := cp(path.Join(workd, entry.Name()), path.Join(outd, entry.Name())); err != nil {
+			log.Fatal(err)
+		} else if err := os.Remove(path.Join(workd, entry.Name())); err != nil {
+			log.Fatal(err)
+		}
+	}
+}
+
+func CloneForColumn[T any](db *sql.DB, table, column string, from, to T, fixed map[string]any) error {
+	columns, err := Columns(db, table)
+	if err != nil {
+		return err
+	}
+
+	uniqueIntColumns, err := UniqueTypeColumns(db, "INTEGER", table)
+	if err != nil {
+		return err
+	}
+	uniqueTextColumns, err := UniqueTypeColumns(db, "TEXT", table)
+	if err != nil {
+		return err
+	}
+
+	log.Printf("unique text columns %+v, unique int columns %+v", uniqueTextColumns, uniqueIntColumns)
+
+	extraUniques := []string{}
+	for k := range fixed {
+		extraUniques = append(extraUniques, k)
+	}
+	omit := append(append(extraUniques, uniqueIntColumns...), uniqueTextColumns...)
+	notTheseColumns := slices.DeleteFunc(slices.Clone(columns), func(s string) bool {
+		return s == column || slices.Contains(omit, s) || slices.Contains(extraUniques, s)
+	})
+	for i := range notTheseColumns {
+		notTheseColumns[i] = fmt.Sprintf("%q", notTheseColumns[i])
+	}
+
+	notNullTextColumns, err := NotNullTextColumns(db, table)
+	if err != nil {
+		return err
+	}
+	uuidGenColumns := slices.DeleteFunc(notNullTextColumns, func(s string) bool {
+		return s == column || !slices.Contains(omit, s) || slices.Contains(extraUniques, s)
+	})
+	for i := range uuidGenColumns {
+		uuidGenColumns[i] = fmt.Sprintf("%q", uuidGenColumns[i])
+	}
+
+	notNullIntColumns, err := NotNullIntColumns(db, table)
+	if err != nil {
+		return err
+	}
+	incrGenColumns := slices.DeleteFunc(notNullIntColumns, func(s string) bool {
+		return s == column || !slices.Contains(omit, s) || slices.Contains(extraUniques, s)
+	})
+	for i := range incrGenColumns {
+		incrGenColumns[i] = fmt.Sprintf("%q", incrGenColumns[i])
+	}
+
+	return ForEach(db, func(args []any) error {
+		selectMaxes := ""
+		for _, col := range incrGenColumns {
+			selectMaxes += fmt.Sprintf(`(SELECT COALESCE(MAX(%s)+1, 1) FROM %q), `, col, table)
+		}
+
+		values := []any{}
+		for _ = range uuidGenColumns {
+			values = append(values, fmt.Sprintf("'%s'", strings.ToUpper(uuid.New().String())))
+		}
+		for _, arg := range args {
+			values = append(values, *(arg.(*any)))
+		}
+		for _, k := range extraUniques {
+			values = append(values, fixed[k])
+		}
+		values = append(values, to)
+
+		q := fmt.Sprintf(
+			`INSERT INTO %q (%s, %q) VALUES (%s %s)`,
+			table, strings.Join(append(append(incrGenColumns, append(uuidGenColumns, notTheseColumns...)...), extraUniques...), ", "), column,
+			selectMaxes, strings.Join(slices.Repeat([]string{"?"}, len(values)), ", "),
+		)
+
+		log.Printf("INSERT | %s (%+v)", q, values)
+		return Exec(db, q, values...)
+	}, fmt.Sprintf(`SELECT %s FROM %q WHERE %q = $1`, strings.Join(notTheseColumns, ", "), table, column), from)
+	/*
+		q := fmt.Sprintf(
+			`INSERT INTO %q (%q, %s) SELECT $1, %s %s %s FROM %q WHERE %q = $2`,
+			table, column, strings.Join(append(incrGenColumns, append(uuidGenColumns, notTheseColumns...)...), ", "),
+			func() string {
+				incrs := make([]string, len(incrGenColumns))
+				for i := range incrs {
+					incrs[i] = fmt.Sprintf(`(SELECT COALESCE(MAX(%s), 1) FROM %q)`, incrGenColumns[i], table)
+				}
+				s := strings.Join(incrs, ", ")
+				if len(incrs) > 0 {
+					s += ", "
+				}
+				return s
+			}(),
+			func() string {
+				uuids := make([]string, len(uuidGenColumns))
+				for i := range uuids {
+					uuids[i] = fmt.Sprintf("'%s'", strings.ToUpper(uuid.New().String()))
+				}
+				s := strings.Join(uuids, ", ")
+				if len(uuids) > 0 {
+					s += ", "
+				}
+				return s
+			}(), strings.Join(notTheseColumns, ", "), table, column,
+		)
+		log.Printf("EXEC | %s (%v, %v)", q, to, from)
+		return Insert(db, q, to, from)
+	*/
+}
+
+func ForEach(db *sql.DB, cb func([]any) error, q string, args ...any) error {
+	rows, err := db.Query(q, args...)
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+
+	columns, err := rows.Columns()
+	if err != nil {
+		return err
+	}
+	cols := make([]any, len(columns))
+
+	for rows.Next() {
+		for i := range cols {
+			var a any
+			cols[i] = &a
+		}
+
+		if err := rows.Scan(cols...); err != nil {
+			return err
+		}
+		if err := cb(cols); err != nil {
+			return err
+		}
+	}
+
+	return rows.Err()
 }
 
 func cp(from, to string) error {
@@ -123,11 +305,59 @@ func cp(from, to string) error {
 }
 
 func Tables(db *sql.DB) ([]string, error) {
-	return Select[string](jellyfinDB, `SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`)
+	return Select[string](db, `SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`)
 }
 
 func Columns(db *sql.DB, table string) ([]string, error) {
-	return Select[string](jellyfinDB, `SELECT name FROM PRAGMA_TABLE_INFO($1)`, table)
+	return Select[string](db, `SELECT name FROM PRAGMA_TABLE_INFO($1)`, table)
+}
+
+func NotNullTextColumns(db *sql.DB, table string) ([]string, error) {
+	return Select[string](db, `SELECT name FROM PRAGMA_TABLE_INFO($1) WHERE "notnull" = 1 AND "type" = 'TEXT'`, table)
+}
+
+func NotNullIntColumns(db *sql.DB, table string) ([]string, error) {
+	return Select[string](db, `SELECT name FROM PRAGMA_TABLE_INFO($1) WHERE "notnull" = 1 AND "type" = 'INTEGER'`, table)
+}
+
+func UniqueTypeColumns(db *sql.DB, t, table string) ([]string, error) {
+	pks, err := Select[string](db, `SELECT name FROM PRAGMA_TABLE_INFO($1) WHERE "pk" AND "type" = $2`, table, t)
+	if err != nil {
+		return nil, err
+	}
+
+	idxes, err := Select[string](db, `SELECT name AS idx_name FROM PRAGMA_INDEX_LIST($1) WHERE "unique"`, table)
+	if err != nil {
+		return nil, err
+	}
+	uniqueIdxCols := []string{}
+	for _, idx := range idxes {
+		cols, err := Select[string](db, `SELECT name FROM PRAGMA_INDEX_INFO($1)`, idx)
+		if err != nil {
+			return nil, err
+		}
+		if len(cols) > 1 {
+			log.Printf("not impl: compound unique indexes like %s.%s's %+v", table, idx, cols)
+			continue
+		}
+		col := cols[0]
+
+		if n, err := SelectOne[int](db, `SELECT COUNT(*) FROM PRAGMA_TABLE_INFO($1) WHERE "name" = $2 AND "type" = $3`, table, col, t); err != nil {
+			return nil, err
+		} else if n > 0 {
+			uniqueIdxCols = append(uniqueIdxCols, col)
+		}
+	}
+
+	cols := append(pks, uniqueIdxCols...)
+	slices.Sort(cols)
+	cols = slices.Compact(cols)
+	return cols, nil
+}
+
+func Insert(db *sql.DB, q string, args ...any) error {
+	_, err := db.Exec(q, args...)
+	return err
 }
 
 func Exec(db *sql.DB, q string, args ...any) error {