701 lines
24 KiB
Go
701 lines
24 KiB
Go
package dao
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
|
|
"go-common/app/service/main/favorite/model"
|
|
"go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
"go-common/library/xstr"
|
|
)
|
|
|
|
const (
|
|
_folderSharding int64 = 100 // folder by mid
|
|
_relationSharding int64 = 500 // objects in folder by mid
|
|
_usersSharding int64 = 500 // objects faved by oid
|
|
_countSharding int64 = 50 // objects count by oid
|
|
// folder table
|
|
_cntFolderSQL = "SELECT COUNT(id) FROM fav_folder_%s WHERE type=? AND mid=? AND state=0"
|
|
_folderSQL = "SELECT id,type,mid,name,cover,description,count,attr,state,ctime,mtime FROM fav_folder_%s WHERE id=? AND type=? AND mid=?"
|
|
_userFoldersSQL = "SELECT id,type,mid,name,cover,description,count,attr,state,ctime,mtime FROM fav_folder_%s WHERE type=? AND mid=? AND state=0"
|
|
_folderByNameSQL = "SELECT id,type,mid,name,cover,description,count,attr,state,ctime,mtime FROM fav_folder_%s WHERE name=? AND type=? AND mid=? AND state=0"
|
|
_folderByIdsSQL = "SELECT id,type,mid,name,cover,description,count,attr,state,ctime,mtime FROM fav_folder_%s WHERE id in (%s)"
|
|
_defFolderSQL = "SELECT id,type,mid,name,cover,description,count,attr,state,ctime,mtime FROM fav_folder_%s WHERE type=? AND mid=? AND attr&2=0"
|
|
_addFolderSQL = `INSERT INTO fav_folder_%s (type,mid,name,cover,description,count,attr,state,ctime,mtime) VALUES (?,?,?,?,?,?,?,?,?,?)
|
|
ON DUPLICATE KEY UPDATE name=?,cover=?,description=?,count=?,attr=?,state=?,ctime=?,mtime=?`
|
|
_delFolderSQL = "UPDATE fav_folder_%s SET state=1 WHERE type=? AND id=?"
|
|
_updateFolderSQL = "UPDATE fav_folder_%s SET name=?,description=?,cover=?,attr=?,state=?,mtime=? WHERE type=? AND id=?"
|
|
_upFolderNameSQL = "UPDATE IGNORE fav_folder_%s SET name=? WHERE id=?"
|
|
_upFolderAttrSQL = "UPDATE fav_folder_%s SET attr=? WHERE id=?"
|
|
|
|
// relation table
|
|
_relationSQL = "SELECT id,type,oid,mid,fid,state,ctime,mtime,sequence FROM fav_relation_%s WHERE type=? AND mid=? AND fid=? AND oid=? AND state=0"
|
|
_relationsSQL = "SELECT id,type,oid,mid,fid,state,ctime,mtime,sequence FROM fav_relation_%s FORCE INDEX(ix_fid_state_type_mtime) WHERE fid=? AND state=0 AND type=? ORDER BY mtime DESC LIMIT ?,?"
|
|
_allRelationsSQL = "SELECT id,type,oid,mid,fid,state,ctime,mtime,sequence FROM fav_relation_%s FORCE INDEX(ix_fid_state_sequence) WHERE fid=? AND state=0 ORDER BY sequence DESC LIMIT ?,?"
|
|
_relationFidsSQL = "SELECT fid FROM fav_relation_%s WHERE type=? AND mid=? AND oid=? AND state=0"
|
|
_FidsByOidsSQL = "SELECT oid,fid FROM fav_relation_%s WHERE type=? AND mid=? AND oid in (%s) AND state=0"
|
|
_cntRelationSQL = "SELECT COUNT(id) FROM fav_relation_%s FORCE INDEX(ix_fid_state_type_mtime) WHERE fid=? AND state=0 AND type=?"
|
|
_cntAllRelationSQL = "SELECT COUNT(id) FROM fav_relation_%s FORCE INDEX(ix_fid_state_sequence) WHERE fid=? AND state=0"
|
|
_addRelationSQL = "INSERT INTO fav_relation_%s (type,oid,mid,fid,state,ctime,mtime) VALUES(?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE state=?,mtime=?"
|
|
_maddRelationsSQL = "INSERT INTO fav_relation_%s (type,oid,mid,fid,state) VALUES %s ON DUPLICATE KEY UPDATE state=0"
|
|
_delRelationSQL = "UPDATE fav_relation_%s SET state=1 WHERE type=? AND fid=? AND oid=?"
|
|
_delRelationsSQL = "UPDATE fav_relation_%s SET state=1 WHERE type=? AND fid=? AND oid in (%s)"
|
|
_recentOidsSQL = "SELECT oid,type FROM fav_relation_%s FORCE INDEX(ix_fid_state_mtime) WHERE fid=? AND state=0 ORDER BY mtime DESC LIMIT 3"
|
|
_copyRelationsSQL = `INSERT IGNORE INTO fav_relation_%s (type,oid,mid,fid)
|
|
SELECT %d,oid,%d,%d FROM fav_relation_%s WHERE type=? AND mid=? AND fid=? AND oid in (%s) AND state=0
|
|
ON DUPLICATE KEY UPDATE state=0`
|
|
_batchOidsSQL = `SELECT oid FROM fav_relation_%s WHERE type=? AND mid=? AND state=0 LIMIT ?`
|
|
|
|
// users table
|
|
_cntUsersSQL = "SELECT COUNT(id) FROM fav_users_%s WHERE type=? AND oid=? AND state=0"
|
|
_usersSQL = "SELECT id,type,oid,mid,state,ctime,mtime FROM fav_users_%s WHERE type=? AND oid=? AND state=0 ORDER BY mtime DESC LIMIT ?,?"
|
|
|
|
// folderSort table
|
|
_folderSortSQL = "SELECT id,type,mid,sort,ctime,mtime FROM fav_folder_sort WHERE type=? AND mid=?"
|
|
_setFolderSortSQL = "INSERT INTO fav_folder_sort (type,mid,sort,ctime,mtime) VALUES (?,?,?,?,?) ON DUPLICATE KEY UPDATE sort=?,mtime=?"
|
|
|
|
// count table
|
|
_countSQL = "SELECT count FROM fav_count_%s WHERE type=? AND oid=?"
|
|
_countsSQL = "SELECT oid,count FROM fav_count_%s WHERE type=? AND oid in (%s)"
|
|
_folderStatSQL = "SELECT fid,play,fav,share from fav_folder_stat_%s WHERE fid in (%s)"
|
|
)
|
|
|
|
// folderHit hit table by the mod of mid and _folderSharding.
|
|
func folderHit(mid int64) string {
|
|
return fmt.Sprintf("%02d", mid%_folderSharding)
|
|
}
|
|
|
|
// relationHit hit table by the mod of mid and _relationSharding.
|
|
func relationHit(mid int64) string {
|
|
return fmt.Sprintf("%03d", mid%_relationSharding)
|
|
}
|
|
|
|
// usersHit hit table by the mod of oid and _userSharding.
|
|
func usersHit(oid int64) string {
|
|
return fmt.Sprintf("%03d", oid%_usersSharding)
|
|
}
|
|
|
|
// countHit hit table by the mod of oid and _countSharding.
|
|
func countHit(oid int64) string {
|
|
return fmt.Sprintf("%02d", oid%_countSharding)
|
|
}
|
|
|
|
// pingMySQL check mysql connection.
|
|
func (d *Dao) pingMySQL(c context.Context) error {
|
|
if err := d.dbRead.Ping(c); err != nil {
|
|
return err
|
|
}
|
|
if err := d.dbPush.Ping(c); err != nil {
|
|
return err
|
|
}
|
|
return d.db.Ping(c)
|
|
}
|
|
|
|
// Folder get a Folder by fid from mysql.
|
|
func (d *Dao) Folder(c context.Context, tp int8, mid, fid int64) (f *model.Folder, err error) {
|
|
f = new(model.Folder)
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_folderSQL, folderHit(mid)), fid, tp, mid)
|
|
if err = row.Scan(&f.ID, &f.Type, &f.Mid, &f.Name, &f.Cover, &f.Description, &f.Count, &f.Attr, &f.State, &f.CTime, &f.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
f = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// FolderByName get a Folder by name from mysql.
|
|
func (d *Dao) FolderByName(c context.Context, tp int8, mid int64, name string) (f *model.Folder, err error) {
|
|
f = &model.Folder{}
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_folderByNameSQL, folderHit(mid)), name, tp, mid)
|
|
if err = row.Scan(&f.ID, &f.Type, &f.Mid, &f.Name, &f.Cover, &f.Description, &f.Count, &f.Attr, &f.State, &f.CTime, &f.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
f = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// DefaultFolder get default folder from mysql.
|
|
func (d *Dao) DefaultFolder(c context.Context, tp int8, mid int64) (f *model.Folder, err error) {
|
|
f = new(model.Folder)
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_defFolderSQL, folderHit(mid)), tp, mid)
|
|
if err = row.Scan(&f.ID, &f.Type, &f.Mid, &f.Name, &f.Cover, &f.Description, &f.Count, &f.Attr, &f.State, &f.CTime, &f.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
f = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddFolder add a new favorite folder to mysql.
|
|
func (d *Dao) AddFolder(c context.Context, f *model.Folder) (fid int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_addFolderSQL, folderHit(f.Mid)), f.Type, f.Mid, f.Name, f.Cover, f.Description, f.Count, f.Attr, f.State, f.CTime, f.MTime,
|
|
f.Name, f.Cover, f.Description, f.Count, f.Attr, f.State, f.CTime, f.MTime)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
// UpdateFolder add a new favorite folder to mysql.
|
|
func (d *Dao) UpdateFolder(c context.Context, f *model.Folder) (fid int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_updateFolderSQL, folderHit(f.Mid)), f.Name, f.Description, f.Cover, f.Attr, f.State, f.MTime, f.Type, f.ID)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpFolderName rename user's folder name to mysql.
|
|
func (d *Dao) UpFolderName(c context.Context, typ int8, mid, fid int64, name string) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_upFolderNameSQL, folderHit(mid)), name, fid)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpFolderAttr update user's folder attr to mysql.
|
|
func (d *Dao) UpFolderAttr(c context.Context, typ int8, mid, fid int64, attr int32) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_upFolderAttrSQL, folderHit(mid)), attr, fid)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// FolderRelations get favorite relations from mysql.
|
|
func (d *Dao) FolderRelations(c context.Context, typ int8, mid, fid int64, start, end int) (fr []*model.Favorite, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_relationsSQL, relationHit(mid)), fid, typ, start, end)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%s,%d,%d,%d,%d,%d) error(%v)", fmt.Sprintf(_relationsSQL, relationHit(mid)), typ, mid, fid, start, end, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
fr = make([]*model.Favorite, 0)
|
|
for rows.Next() {
|
|
var r = &model.Favorite{}
|
|
if err = rows.Scan(&r.ID, &r.Type, &r.Oid, &r.Mid, &r.Fid, &r.State, &r.CTime, &r.MTime, &r.Sequence); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
if r.Type != typ || r.Mid != mid {
|
|
log.Error("dirty data relations(%d,%d,%d)", typ, mid, fid)
|
|
continue
|
|
}
|
|
fr = append(fr, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// FolderAllRelations get favorite relations from mysql.
|
|
func (d *Dao) FolderAllRelations(c context.Context, mid, fid int64, start, end int) (fr []*model.Favorite, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_allRelationsSQL, relationHit(mid)), fid, start, end)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%s,%d,%d,%d,%d,%d) error(%v)", fmt.Sprintf(_allRelationsSQL, relationHit(mid)), mid, fid, start, end, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
fr = make([]*model.Favorite, 0)
|
|
for rows.Next() {
|
|
var r = &model.Favorite{}
|
|
if err = rows.Scan(&r.ID, &r.Type, &r.Oid, &r.Mid, &r.Fid, &r.State, &r.CTime, &r.MTime, &r.Sequence); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
if r.Mid != mid {
|
|
log.Error("dirty data relations(%d,%d,%d)", mid, fid)
|
|
continue
|
|
}
|
|
fr = append(fr, r)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// Folders get folders from mysql.
|
|
func (d *Dao) Folders(c context.Context, fvmids []*model.ArgFVmid) (fs map[string]*model.Folder, err error) {
|
|
tblMap := make(map[string][]int64, len(fvmids))
|
|
for _, fvmid := range fvmids {
|
|
folderHits := folderHit(fvmid.Vmid)
|
|
tblMap[folderHits] = append(tblMap[folderHits], fvmid.Fid)
|
|
}
|
|
fs = make(map[string]*model.Folder, len(fvmids))
|
|
for folderHit, fids := range tblMap {
|
|
fidsStr := xstr.JoinInts(fids)
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_folderByIdsSQL, folderHit, fidsStr)); err != nil {
|
|
log.Error("d.db.Query(%s,%s,%s) error(%v)", _folderByIdsSQL, folderHit, fidsStr, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
f := new(model.Folder)
|
|
if err = rows.Scan(&f.ID, &f.Type, &f.Mid, &f.Name, &f.Cover, &f.Description, &f.Count, &f.Attr, &f.State, &f.CTime, &f.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
fmid := xstr.JoinInts([]int64{f.ID, f.Mid})
|
|
fs[fmid] = f
|
|
}
|
|
err = rows.Err()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// RelationFidsByOid get favortied folders in relations by oid from mysql.
|
|
func (d *Dao) RelationFidsByOid(c context.Context, tp int8, mid, oid int64) (fids []int64, err error) {
|
|
var fid int64
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_relationFidsSQL, relationHit(mid)), tp, mid, oid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d,%d) error(%v)", tp, mid, oid, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
if err = rows.Scan(&fid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
fids = append(fids, fid)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// RelationFidsByOids get favortied folders in relations by oid from mysql.
|
|
func (d *Dao) RelationFidsByOids(c context.Context, tp int8, mid int64, oids []int64) (fidsMap map[int64][]int64, err error) {
|
|
oidsStr := xstr.JoinInts(oids)
|
|
rows, err := d.dbRead.Query(c, fmt.Sprintf(_FidsByOidsSQL, relationHit(mid), oidsStr), tp, mid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d,%d) error(%v)", mid, mid, oidsStr, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
var oid, fid int64
|
|
fidsMap = make(map[int64][]int64, len(oids))
|
|
for rows.Next() {
|
|
if err = rows.Scan(&oid, &fid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
fidsMap[oid] = append(fidsMap[oid], fid)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// CntRelations get favoried folders count in relation from mysql.
|
|
func (d *Dao) CntRelations(c context.Context, mid, fid int64, typ int8) (count int, err error) {
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_cntRelationSQL, relationHit(mid)), fid, typ)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// CntRelations get favoried folders count in relation from mysql.
|
|
func (d *Dao) CntAllRelations(c context.Context, mid, fid int64) (count int, err error) {
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_cntAllRelationSQL, relationHit(mid)), fid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// FolderCnt get user's folder count.
|
|
func (d *Dao) FolderCnt(c context.Context, tp int8, mid int64) (count int, err error) {
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_cntFolderSQL, folderHit(mid)), tp, mid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddFav add a favorite relation to mysql.
|
|
func (d *Dao) AddFav(c context.Context, fr *model.Favorite) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_addRelationSQL, relationHit(fr.Mid)), fr.Type, fr.Oid, fr.Mid, fr.Fid, fr.State, fr.CTime, fr.MTime, fr.State, fr.MTime)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// DelFav delete a favorite relation to mysql.
|
|
func (d *Dao) DelFav(c context.Context, tp int8, mid, fid, oid int64) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_delRelationSQL, relationHit(mid)), tp, fid, oid)
|
|
if err != nil {
|
|
log.Error("d.db.Exec(%d,%d,%d,%d) error(%v)", mid, tp, fid, oid, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// AddRelation add a favorite relation to mysql.
|
|
func (d *Dao) AddRelation(c context.Context, fr *model.Favorite) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_addRelationSQL, relationHit(fr.Mid)), fr.Type, fr.Oid, fr.Mid, fr.Fid, fr.State, fr.CTime, fr.MTime, fr.State, fr.MTime)
|
|
if err != nil {
|
|
log.Error("db.Exec error(%v)", err)
|
|
return
|
|
}
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
// Relation get a relation from mysql.
|
|
func (d *Dao) Relation(c context.Context, tp int8, mid, fid, oid int64) (m *model.Favorite, err error) {
|
|
m = &model.Favorite{}
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_relationSQL, relationHit(mid)), tp, mid, fid, oid)
|
|
if err = row.Scan(&m.ID, &m.Type, &m.Oid, &m.Mid, &m.Fid, &m.State, &m.CTime, &m.MTime, &m.Sequence); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
m = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// DelRelation delete a favorite relation to mysql.
|
|
func (d *Dao) DelRelation(c context.Context, tp int8, mid, fid, oid int64) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_delRelationSQL, relationHit(mid)), tp, fid, oid)
|
|
if err != nil {
|
|
log.Error("d.db.Exec(%d,%d,%d,%d) error(%v)", mid, tp, fid, oid, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// MultiDelRelations delete relations to mysql.
|
|
func (d *Dao) MultiDelRelations(c context.Context, tp int8, mid, fid int64, oids []int64) (rows int64, err error) {
|
|
if len(oids) <= 0 {
|
|
return
|
|
}
|
|
oidsStr := xstr.JoinInts(oids)
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_delRelationsSQL, relationHit(mid), oidsStr), tp, fid)
|
|
if err != nil {
|
|
log.Error("d.db.Exec(%d,%d,%d,%s) error(%v)", mid, tp, fid, oidsStr, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxMultiDelRelations delete relations to mysql.
|
|
func (d *Dao) TxMultiDelRelations(tx *sql.Tx, tp int8, mid, fid int64, oids []int64) (rows int64, err error) {
|
|
if len(oids) <= 0 {
|
|
return
|
|
}
|
|
oidsStr := xstr.JoinInts(oids)
|
|
res, err := tx.Exec(fmt.Sprintf(_delRelationsSQL, relationHit(mid), oidsStr), tp, fid)
|
|
if err != nil {
|
|
log.Error("d.db.Exec(%d,%d,%d,%s) error(%v)", mid, tp, fid, oidsStr, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// MultiAddRelations insert relations to mysql.
|
|
func (d *Dao) MultiAddRelations(c context.Context, tp int8, mid, fid int64, oids []int64) (rows int64, err error) {
|
|
var buffer bytes.Buffer
|
|
valuesTpl := "(%d,%d,%d,%d,%d),"
|
|
for _, oid := range oids {
|
|
buffer.WriteString(fmt.Sprintf(valuesTpl, tp, oid, mid, fid, 0))
|
|
}
|
|
buffer.Truncate(buffer.Len() - 1)
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_maddRelationsSQL, relationHit(mid), buffer.String()))
|
|
if err != nil {
|
|
log.Error("d.db.Exec(%d,%d,%d,%s) error(%v)", mid, tp, fid, oids, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// DelFolder delete a folder to mysql.
|
|
func (d *Dao) DelFolder(c context.Context, tp int8, mid, fid int64) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_delFolderSQL, folderHit(mid)), tp, fid)
|
|
if err != nil {
|
|
log.Error("d.db.Exec(mid:%d,tp:%d,fid:%d) error(%v)", mid, tp, fid, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// FolderStats get folders from mysql.
|
|
func (d *Dao) FolderStats(c context.Context, fvmids []*model.ArgFVmid) (fs map[int64]*model.Folder, err error) {
|
|
tblMap := make(map[int64][]int64, len(fvmids))
|
|
for _, fvmid := range fvmids {
|
|
tblMap[fvmid.Vmid] = append(tblMap[fvmid.Vmid], fvmid.Fid)
|
|
}
|
|
fs = make(map[int64]*model.Folder, len(fvmids))
|
|
for vmid, fids := range tblMap {
|
|
fidsStr := xstr.JoinInts(fids)
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_folderStatSQL, folderHit(vmid), fidsStr)); err != nil {
|
|
log.Error("d.db.Query(%s,%s,%s) error(%v)", _folderStatSQL, folderHit(vmid), fidsStr, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
stat := new(model.Folder)
|
|
if err = rows.Scan(&stat.ID, &stat.PlayCount, &stat.FavedCount, &stat.ShareCount); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
fs[stat.ID*100+vmid%100] = stat
|
|
}
|
|
err = rows.Err()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserFolders get user's folders.
|
|
func (d *Dao) UserFolders(c context.Context, typ int8, mid int64) (fs map[int64]*model.Folder, err error) {
|
|
rows, err := d.db.Query(c, fmt.Sprintf(_userFoldersSQL, folderHit(mid)), typ, mid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(mid:%d,typ:%d) error(%v)", mid, typ, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
fs = make(map[int64]*model.Folder)
|
|
for rows.Next() {
|
|
f := new(model.Folder)
|
|
if err = rows.Scan(&f.ID, &f.Type, &f.Mid, &f.Name, &f.Cover, &f.Description, &f.Count, &f.Attr, &f.State, &f.CTime, &f.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
fs[f.ID] = f
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// FolderSort return user's folders sort by type & mid.
|
|
func (d *Dao) FolderSort(c context.Context, typ int8, mid int64) (fst *model.FolderSort, err error) {
|
|
var b []byte
|
|
fst = new(model.FolderSort)
|
|
row := d.db.QueryRow(c, _folderSortSQL, typ, mid)
|
|
if err = row.Scan(&fst.ID, &fst.Type, &fst.Mid, &b, &fst.CTime, &fst.MTime); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
fst = nil
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
fst.SetIndex(b)
|
|
return
|
|
}
|
|
|
|
// UpFolderSort update user's folder sort.
|
|
func (d *Dao) UpFolderSort(c context.Context, fst *model.FolderSort) (rows int64, err error) {
|
|
sort := fst.Index()
|
|
res, err := d.db.Exec(c, _setFolderSortSQL, fst.Type, fst.Mid, sort, fst.CTime, fst.MTime, sort, fst.MTime)
|
|
if err != nil {
|
|
log.Error("d.db.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// RecentOids return user's three newest fav from a folder.
|
|
func (d *Dao) RecentOids(c context.Context, mid, fid int64, typ int8) (oids []int64, err error) {
|
|
rows, err := d.dbRead.Query(c, fmt.Sprintf(_recentOidsSQL, relationHit(mid)), fid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d) error(%v)", mid, fid, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var oid int64
|
|
var otyp int8
|
|
if err = rows.Scan(&oid, &otyp); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
if otyp == typ {
|
|
oids = append(oids, oid)
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// RecentOids return user's three newest fav from a folder.
|
|
func (d *Dao) RecentRes(c context.Context, mid, fid int64) (res []*model.Resource, err error) {
|
|
rows, err := d.dbRead.Query(c, fmt.Sprintf(_recentOidsSQL, relationHit(mid)), fid)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d) error(%v)", mid, fid, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var oid int64
|
|
var typ int32
|
|
if err = rows.Scan(&oid, &typ); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
res = append(res, &model.Resource{Oid: oid, Typ: typ})
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// TxCopyRelations copy resources from oldfid to newfid by oids.
|
|
func (d *Dao) TxCopyRelations(tx *sql.Tx, typ int8, oldmid, mid, oldfid, newfid int64, oids []int64) (rows int64, err error) {
|
|
res, err := tx.Exec(fmt.Sprintf(_copyRelationsSQL, relationHit(mid), typ, mid, newfid, relationHit(oldmid), xstr.JoinInts(oids)), typ, oldmid, oldfid)
|
|
if err != nil {
|
|
log.Error("db.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// CopyRelations copy resources from oldfid to newfid by oids.
|
|
func (d *Dao) CopyRelations(c context.Context, typ int8, oldmid, mid, oldfid, newfid int64, oids []int64) (rows int64, err error) {
|
|
res, err := d.db.Exec(c, fmt.Sprintf(_copyRelationsSQL, relationHit(mid), typ, mid, newfid, relationHit(oldmid), xstr.JoinInts(oids)), typ, oldmid, oldfid)
|
|
if err != nil {
|
|
log.Error("db.Exec() error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// CntUsers get favoried users count from mysql.
|
|
func (d *Dao) CntUsers(c context.Context, typ int8, oid int64) (count int, err error) {
|
|
row := d.dbPush.QueryRow(c, fmt.Sprintf(_cntUsersSQL, usersHit(oid)), typ, oid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Users get favorite users from mysql.
|
|
func (d *Dao) Users(c context.Context, typ int8, oid int64, start, end int) (us []*model.User, err error) {
|
|
rows, err := d.dbPush.Query(c, fmt.Sprintf(_usersSQL, usersHit(oid)), typ, oid, start, end)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d,%d,%d) error(%v)", typ, oid, start, end, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
us = make([]*model.User, 0)
|
|
for rows.Next() {
|
|
var u = new(model.User)
|
|
if err = rows.Scan(&u.ID, &u.Type, &u.Oid, &u.Mid, &u.State, &u.CTime, &u.MTime); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
us = append(us, u)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// OidCount get oid's fav count from mysql.
|
|
func (d *Dao) OidCount(c context.Context, typ int8, oid int64) (count int64, err error) {
|
|
row := d.dbPush.QueryRow(c, fmt.Sprintf(_countSQL, countHit(oid)), typ, oid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// OidsCount get oids's count from mysql.
|
|
func (d *Dao) OidsCount(c context.Context, typ int8, oids []int64) (counts map[int64]int64, err error) {
|
|
tblMap := make(map[string][]int64, len(oids))
|
|
for _, oid := range oids {
|
|
countHit := countHit(oid)
|
|
tblMap[countHit] = append(tblMap[countHit], oid)
|
|
}
|
|
counts = make(map[int64]int64, len(oids))
|
|
for countHit, oids := range tblMap {
|
|
oidsStr := xstr.JoinInts(oids)
|
|
var rows *sql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_countsSQL, countHit, oidsStr), typ); err != nil {
|
|
log.Error("d.db.Query(%s,%d) error(%v)", fmt.Sprintf(_countsSQL, countHit, oidsStr), typ, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var oid, count int64
|
|
if err = rows.Scan(&oid, &count); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
counts[oid] = count
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
log.Error("rows.Err() error(%v)", err)
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// BatchOids get batch oids from mysql.
|
|
func (d *Dao) BatchOids(c context.Context, typ int8, mid int64, limit int) (oids []int64, err error) {
|
|
rows, err := d.dbRead.Query(c, fmt.Sprintf(_batchOidsSQL, relationHit(mid)), typ, mid, limit)
|
|
if err != nil {
|
|
log.Error("d.db.Query(%d,%d,%d) error(%v)", typ, mid, limit, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var oid int64
|
|
if err = rows.Scan(&oid); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
oids = append(oids, oid)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
log.Error("rows.Err() error(%v)", err)
|
|
}
|
|
return
|
|
}
|