Andreas/siyuan
1
0
Fork 0
mirror of https://github.com/siyuan-note/siyuan.git synced 2025-12-28 20:38:49 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

♻️ 日志组件单独抽取项目 https://github.com/siyuan-note/siyuan/issues/5439

Browse source
This commit is contained in:
Liang Ding 2022-07-17 12:22:32 +08:00
parent c8ea858976
commit 505b973c2d
No known key found for this signature in database
GPG key ID: 136F30F901A2231D
70 changed files with 671 additions and 942 deletions
Download patch file Download diff file Expand all files Collapse all files

9
kernel/sql/aseet.go
View file

@ -25,6 +25,7 @@ import (
"github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -73,7 +74,7 @@ func docTitleImgAsset(root *ast.Node) *Asset {
var err error
absPath := filepath.Join(util.DataDir, p)
if hash, err = util.GetEtag(absPath); nil != err {
util.LogErrorf("read asset [%s] data failed: %s", absPath, err)
logging.LogErrorf("read asset [%s] data failed: %s", absPath, err)
hash = fmt.Sprintf("%x", sha256.Sum256([]byte(gulu.Rand.String(7))))
}
name, _ := util.LastID(p)
@ -99,7 +100,7 @@ func QueryAssetByHash(hash string) (ret *Asset) {
var asset Asset
if err := row.Scan(&asset.ID, &asset.BlockID, &asset.RootID, &asset.Box, &asset.DocPath, &asset.Path, &asset.Name, &asset.Title, &asset.Hash); nil != err {
if sql.ErrNoRows != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
}
return
}
@ -111,7 +112,7 @@ func QueryRootBlockAssets(rootID string) (ret []*Asset) {
sqlStmt := "SELECT * FROM assets WHERE root_id = ?"
rows, err := query(sqlStmt, rootID)
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -125,7 +126,7 @@ func QueryRootBlockAssets(rootID string) (ret []*Asset) {
func scanAssetRows(rows *sql.Rows) (ret *Asset) {
var asset Asset
if err := rows.Scan(&asset.ID, &asset.BlockID, &asset.RootID, &asset.Box, &asset.DocPath, &asset.Path, &asset.Name, &asset.Title, &asset.Hash); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = &asset

53
kernel/sql/block_query.go
View file

@ -26,6 +26,7 @@ import (
"github.com/88250/lute/ast"
"github.com/88250/vitess-sqlparser/sqlparser"
"github.com/emirpasic/gods/sets/hashset"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -34,7 +35,7 @@ func queryBlockHashes(rootID string) (ret map[string]string) {
stmt := "SELECT id, hash FROM blocks WHERE root_id = ?"
rows, err := query(stmt, rootID)
if nil != err {
util.LogErrorf("sql query failed: %s", stmt, err)
logging.LogErrorf("sql query failed: %s", stmt, err)
return
}
defer rows.Close()
@ -42,7 +43,7 @@ func queryBlockHashes(rootID string) (ret map[string]string) {
for rows.Next() {
var id, hash string
if err = rows.Scan(&id, &hash); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret[id] = hash
@ -54,7 +55,7 @@ func QueryRootBlockByCondition(condition string) (ret []*Block) {
sqlStmt := "SELECT *, length(hpath) - length(replace(hpath, '/', '')) AS lv FROM blocks WHERE type = 'd' AND " + condition + " ORDER BY box DESC,lv ASC LIMIT 128"
rows, err := query(sqlStmt)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -62,7 +63,7 @@ func QueryRootBlockByCondition(condition string) (ret []*Block) {
var block Block
var sepCount int
if err = rows.Scan(&block.ID, &block.ParentID, &block.RootID, &block.Hash, &block.Box, &block.Path, &block.HPath, &block.Name, &block.Alias, &block.Memo, &block.Tag, &block.Content, &block.FContent, &block.Markdown, &block.Length, &block.Type, &block.SubType, &block.IAL, &block.Sort, &block.Created, &block.Updated, &sepCount); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = append(ret, &block)
@ -85,7 +86,7 @@ func IsBlockFolded(id string) (ret bool) {
var pid, ial string
if err := row.Scan(&pid, &ial); nil != err {
if sql.ErrNoRows != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
}
return
}
@ -110,7 +111,7 @@ func queryBlockIDByParentID(parentID string) (ret []string) {
sqlStmt := "SELECT id FROM blocks WHERE parent_id = ?"
rows, err := query(sqlStmt, parentID)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -129,7 +130,7 @@ func QueryRecentUpdatedBlocks() (ret []*Block) {
}
rows, err := query(sqlStmt)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -152,7 +153,7 @@ func QueryBlockAliases(rootID string) (ret []string) {
sqlStmt := "SELECT alias FROM blocks WHERE root_id = ? AND alias != ''"
rows, err := query(sqlStmt, rootID)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -185,7 +186,7 @@ func queryNames() (ret []string) {
sqlStmt := "SELECT name FROM blocks WHERE name != '' LIMIT ?"
rows, err := query(sqlStmt, 10240)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -218,7 +219,7 @@ func queryAliases() (ret []string) {
sqlStmt := "SELECT alias FROM blocks WHERE alias != '' LIMIT ?"
rows, err := query(sqlStmt, 10240)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -252,7 +253,7 @@ func queryDocIDsByTitle(title string, excludeIDs []string) (ret []string) {
sqlStmt := "SELECT id FROM blocks WHERE type = 'd' AND content = ? AND id NOT IN " + notIn + " LIMIT ?"
rows, err := query(sqlStmt, title, 32)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -275,7 +276,7 @@ func queryDocTitles() (ret []string) {
sqlStmt := "SELECT content FROM blocks WHERE type = 'd' LIMIT ?"
rows, err := query(sqlStmt, 10240)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -307,7 +308,7 @@ func QueryBlockNamesByRootID(rootID string) (ret []string) {
sqlStmt := "SELECT DISTINCT name FROM blocks WHERE root_id = ? AND name != ''"
rows, err := query(sqlStmt, rootID)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -323,7 +324,7 @@ func QueryBookmarkBlocksByKeyword(bookmark string) (ret []*Block) {
sqlStmt := "SELECT * FROM blocks WHERE ial LIKE ?"
rows, err := query(sqlStmt, "%bookmark=%")
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -339,7 +340,7 @@ func QueryBookmarkBlocks() (ret []*Block) {
sqlStmt := "SELECT * FROM blocks WHERE ial LIKE ?"
rows, err := query(sqlStmt, "%bookmark=%")
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -356,7 +357,7 @@ func QueryBookmarkLabels() (ret []string) {
sqlStmt := "SELECT * FROM blocks WHERE ial LIKE ?"
rows, err := query(sqlStmt, "%bookmark=%")
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -380,7 +381,7 @@ func Query(stmt string) (ret []map[string]interface{}, err error) {
ret = []map[string]interface{}{}
rows, err := query(stmt)
if nil != err {
util.LogWarnf("sql query [%s] failed: %s", stmt, err)
logging.LogWarnf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -447,7 +448,7 @@ func SelectBlocksRawStmt(stmt string, limit int) (ret []*Block) {
if strings.Contains(err.Error(), "syntax error") {
return
}
util.LogWarnf("sql query [%s] failed: %s", stmt, err)
logging.LogWarnf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -484,7 +485,7 @@ func selectBlocksRawStmt(stmt string, limit int) (ret []*Block) {
func scanBlockRows(rows *sql.Rows) (ret *Block) {
var block Block
if err := rows.Scan(&block.ID, &block.ParentID, &block.RootID, &block.Hash, &block.Box, &block.Path, &block.HPath, &block.Name, &block.Alias, &block.Memo, &block.Tag, &block.Content, &block.FContent, &block.Markdown, &block.Length, &block.Type, &block.SubType, &block.IAL, &block.Sort, &block.Created, &block.Updated); nil != err {
util.LogErrorf("query scan field failed: %s\n%s", err, util.ShortStack())
logging.LogErrorf("query scan field failed: %s\n%s", err, logging.ShortStack())
return
}
ret = &block
@ -495,7 +496,7 @@ func scanBlockRow(row *sql.Row) (ret *Block) {
var block Block
if err := row.Scan(&block.ID, &block.ParentID, &block.RootID, &block.Hash, &block.Box, &block.Path, &block.HPath, &block.Name, &block.Alias, &block.Memo, &block.Tag, &block.Content, &block.FContent, &block.Markdown, &block.Length, &block.Type, &block.SubType, &block.IAL, &block.Sort, &block.Created, &block.Updated); nil != err {
if sql.ErrNoRows != err {
util.LogErrorf("query scan field failed: %s\n%s", err, util.ShortStack())
logging.LogErrorf("query scan field failed: %s\n%s", err, logging.ShortStack())
}
return
}
@ -517,7 +518,7 @@ func GetChildBlocks(parentID, condition string) (ret []*Block) {
}
rows, err := query(sqlStmt)
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -537,7 +538,7 @@ func GetAllChildBlocks(rootID, condition string) (ret []*Block) {
}
rows, err := query(sqlStmt, rootID)
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -553,7 +554,7 @@ func GetRefUnresolvedBlocks() (ret []*Block) {
stmt := "SELECT * FROM blocks WHERE content LIKE ?"
rows, err := query(stmt, "%ref resolve failed%")
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", stmt, err)
logging.LogErrorf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -569,7 +570,7 @@ func GetRefExistedBlocks() (ret []*Block) {
stmt := "SELECT * FROM blocks WHERE markdown LIKE ? OR markdown LIKE ?"
rows, err := query(stmt, "%((20%", "%<<20%")
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", stmt, err)
logging.LogErrorf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -598,7 +599,7 @@ func GetAllRootBlocks() (ret []*Block) {
stmt := "SELECT * FROM blocks WHERE type = 'd'"
rows, err := query(stmt)
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", stmt, err)
logging.LogErrorf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -626,7 +627,7 @@ func GetBlocks(ids []string) (ret []*Block) {
sqlStmt := stmtBuilder.String()
rows, err := query(sqlStmt, args...)
if nil != err {
util.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
logging.LogErrorf("sql query [%s] failed: %s", sqlStmt, err)
return
}
defer rows.Close()

46
kernel/sql/block_ref_query.go
View file

@ -24,7 +24,7 @@ import (
"github.com/88250/gulu"
"github.com/88250/lute/parse"
"github.com/emirpasic/gods/sets/hashset"
"github.com/siyuan-note/siyuan/kernel/util"
"github.com/siyuan-note/logging"
)
func QueryVirtualRefKeywords(name, alias, anchor, doc bool) (ret []string) {
@ -58,7 +58,7 @@ func queryRefTexts() (ret []string) {
sqlStmt := "SELECT DISTINCT content FROM refs LIMIT 1024"
rows, err := query(sqlStmt)
if nil != err {
util.LogErrorf("sql query failed: %s", sqlStmt, err)
logging.LogErrorf("sql query failed: %s", sqlStmt, err)
return
}
defer rows.Close()
@ -82,7 +82,7 @@ func QueryRootChildrenRefCount(defRootID string) (ret map[string]int) {
ret = map[string]int{}
rows, err := query("SELECT def_block_id, COUNT(*) AS ref_cnt FROM refs WHERE def_block_root_id = ? GROUP BY def_block_id", defRootID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -90,7 +90,7 @@ func QueryRootChildrenRefCount(defRootID string) (ret map[string]int) {
var id string
var cnt int
if err = rows.Scan(&id, &cnt); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret[id] = cnt
@ -103,7 +103,7 @@ func QueryRootBlockRefCount() (ret map[string]int) {
rows, err := query("SELECT def_block_root_id, COUNT(*) AS ref_cnt FROM refs GROUP BY def_block_root_id")
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -111,7 +111,7 @@ func QueryRootBlockRefCount() (ret map[string]int) {
var id string
var cnt int
if err = rows.Scan(&id, &cnt); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret[id] = cnt
@ -122,7 +122,7 @@ func QueryRootBlockRefCount() (ret map[string]int) {
func QueryDefRootBlocksByRefRootID(refRootID string) (ret []*Block) {
rows, err := query("SELECT * FROM blocks WHERE id IN (SELECT DISTINCT def_block_root_id FROM refs WHERE root_id = ?)", refRootID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -137,7 +137,7 @@ func QueryDefRootBlocksByRefRootID(refRootID string) (ret []*Block) {
func QueryRefRootBlocksByDefRootID(defRootID string) (ret []*Block) {
rows, err := query("SELECT * FROM blocks WHERE id IN (SELECT DISTINCT root_id FROM refs WHERE def_block_root_id = ?)", defRootID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -197,14 +197,14 @@ func queryDefIDsByDefText(keyword string, excludeIDs []string) (ret []string) {
notIn := "('" + strings.Join(excludeIDs, "','") + "')"
rows, err := query("SELECT DISTINCT(def_block_id) FROM refs WHERE content = ? AND def_block_id NOT IN "+notIn, keyword)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
for rows.Next() {
var id string
if err = rows.Scan(&id); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = append(ret, id)
@ -217,14 +217,14 @@ func queryDefIDsByNameAlias(keyword string, excludeIDs []string) (ret []string)
notIn := "('" + strings.Join(excludeIDs, "','") + "')"
rows, err := query("SELECT DISTINCT(id), name, alias FROM blocks WHERE (name = ? OR alias LIKE ?) AND id NOT IN "+notIn, keyword, "%"+keyword+"%")
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
for rows.Next() {
var id, name, alias string
if err = rows.Scan(&id, &name, &alias); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
if name == keyword {
@ -254,14 +254,14 @@ func QueryChildDefIDsByRootDefID(rootDefID string) (ret []string) {
ret = []string{}
rows, err := query("SELECT DISTINCT(def_block_id) FROM refs WHERE def_block_root_id = ?", rootDefID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
for rows.Next() {
var id string
if err = rows.Scan(&id); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = append(ret, id)
@ -279,14 +279,14 @@ func QueryRefIDsByDefID(defID string, containChildren bool) (refIDs, refTexts []
rows, err = query("SELECT block_id, content FROM refs WHERE def_block_id = ?", defID)
}
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
for rows.Next() {
var id, content string
if err = rows.Scan(&id, &content); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
refIDs = append(refIDs, id)
@ -298,7 +298,7 @@ func QueryRefIDsByDefID(defID string, containChildren bool) (refIDs, refTexts []
func QueryRefsRecent() (ret []*Ref) {
rows, err := query("SELECT * FROM refs GROUP BY def_block_id ORDER BY id desc LIMIT 32")
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -332,7 +332,7 @@ func QueryRefsByDefID(defBlockID string, containChildren bool) (ret []*Ref) {
}
}
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -347,7 +347,7 @@ func QueryRefsByDefIDRefID(defBlockID, refBlockID string) (ret []*Ref) {
stmt := "SELECT * FROM refs WHERE def_block_id = ? AND block_id = ?"
rows, err := query(stmt, defBlockID, refBlockID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -367,7 +367,7 @@ func DefRefs(condition string) (ret []map[*Block]*Block) {
rows, err := query(stmt)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -377,7 +377,7 @@ func DefRefs(condition string) (ret []map[*Block]*Block) {
var rel string
if err = rows.Scan(&ref.ID, &ref.ParentID, &ref.RootID, &ref.Hash, &ref.Box, &ref.Path, &ref.HPath, &ref.Name, &ref.Alias, &ref.Memo, &ref.Tag, &ref.Content, &ref.FContent, &ref.Markdown, &ref.Length, &ref.Type, &ref.SubType, &ref.IAL, &ref.Sort, &ref.Created, &ref.Updated,
&rel); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
refs[rel] = &ref
@ -385,7 +385,7 @@ func DefRefs(condition string) (ret []map[*Block]*Block) {
rows, err = query("SELECT def.* FROM blocks AS def, refs AS r WHERE def.id = r.def_block_id")
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -412,7 +412,7 @@ func DefRefs(condition string) (ret []map[*Block]*Block) {
func scanRefRows(rows *sql.Rows) (ret *Ref) {
var ref Ref
if err := rows.Scan(&ref.ID, &ref.DefBlockID, &ref.DefBlockParentID, &ref.DefBlockRootID, &ref.DefBlockPath, &ref.BlockID, &ref.RootID, &ref.Box, &ref.Path, &ref.Content, &ref.Markdown, &ref.Type); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = &ref

51
kernel/sql/database.go
View file

@ -33,6 +33,7 @@ import (
"github.com/88250/lute/parse"
"github.com/mattn/go-sqlite3"
_ "github.com/mattn/go-sqlite3"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -69,7 +70,7 @@ func InitDatabase(forceRebuild bool) (err error) {
db.Close()
if gulu.File.IsExist(util.DBPath) {
if err = removeDatabaseFile(); nil != err {
util.LogErrorf("remove database file [%s] failed: %s", util.DBPath, err)
logging.LogErrorf("remove database file [%s] failed: %s", util.DBPath, err)
util.PushClearProgress()
return
}
@ -81,7 +82,7 @@ func InitDatabase(forceRebuild bool) (err error) {
initDBConnection()
initDBTables()
util.LogInfof("reinitialized database [%s]", util.DBPath)
logging.LogInfof("reinitialized database [%s]", util.DBPath)
return
}
@ -89,56 +90,56 @@ func initDBTables() {
db.Exec("DROP TABLE stat")
_, err := db.Exec("CREATE TABLE stat (key, value)")
if nil != err {
util.LogFatalf("create table [stat] failed: %s", err)
logging.LogFatalf("create table [stat] failed: %s", err)
}
setDatabaseVer()
db.Exec("DROP TABLE blocks")
_, err = db.Exec("CREATE TABLE blocks (id, parent_id, root_id, hash, box, path, hpath, name, alias, memo, tag, content, fcontent, markdown, length, type, subtype, ial, sort, created, updated)")
if nil != err {
util.LogFatalf("create table [blocks] failed: %s", err)
logging.LogFatalf("create table [blocks] failed: %s", err)
}
db.Exec("DROP TABLE blocks_fts")
_, err = db.Exec("CREATE VIRTUAL TABLE blocks_fts USING fts5(id UNINDEXED, parent_id UNINDEXED, root_id UNINDEXED, hash UNINDEXED, box UNINDEXED, path UNINDEXED, hpath, name, alias, memo, tag, content, fcontent, markdown UNINDEXED, length UNINDEXED, type UNINDEXED, subtype UNINDEXED, ial, sort UNINDEXED, created UNINDEXED, updated UNINDEXED, tokenize=\"siyuan\")")
if nil != err {
util.LogFatalf("create table [blocks_fts] failed: %s", err)
logging.LogFatalf("create table [blocks_fts] failed: %s", err)
}
db.Exec("DROP TABLE blocks_fts_case_insensitive")
_, err = db.Exec("CREATE VIRTUAL TABLE blocks_fts_case_insensitive USING fts5(id UNINDEXED, parent_id UNINDEXED, root_id UNINDEXED, hash UNINDEXED, box UNINDEXED, path UNINDEXED, hpath, name, alias, memo, tag, content, fcontent, markdown UNINDEXED, length UNINDEXED, type UNINDEXED, subtype UNINDEXED, ial, sort UNINDEXED, created UNINDEXED, updated UNINDEXED, tokenize=\"siyuan case_insensitive\")")
if nil != err {
util.LogFatalf("create table [blocks_fts_case_insensitive] failed: %s", err)
logging.LogFatalf("create table [blocks_fts_case_insensitive] failed: %s", err)
}
db.Exec("DROP TABLE spans")
_, err = db.Exec("CREATE TABLE spans (id, block_id, root_id, box, path, content, markdown, type, ial)")
if nil != err {
util.LogFatalf("create table [spans] failed: %s", err)
logging.LogFatalf("create table [spans] failed: %s", err)
}
db.Exec("DROP TABLE assets")
_, err = db.Exec("CREATE TABLE assets (id, block_id, root_id, box, docpath, path, name, title, hash)")
if nil != err {
util.LogFatalf("create table [assets] failed: %s", err)
logging.LogFatalf("create table [assets] failed: %s", err)
}
db.Exec("DROP TABLE attributes")
_, err = db.Exec("CREATE TABLE attributes (id, name, value, type, block_id, root_id, box, path)")
if nil != err {
util.LogFatalf("create table [attributes] failed: %s", err)
logging.LogFatalf("create table [attributes] failed: %s", err)
}
db.Exec("DROP TABLE refs")
_, err = db.Exec("CREATE TABLE refs (id, def_block_id, def_block_parent_id, def_block_root_id, def_block_path, block_id, root_id, box, path, content, markdown, type)")
if nil != err {
util.LogFatalf("create table [refs] failed: %s", err)
logging.LogFatalf("create table [refs] failed: %s", err)
}
db.Exec("DROP TABLE file_annotation_refs")
_, err = db.Exec("CREATE TABLE file_annotation_refs (id, file_path, annotation_id, block_id, root_id, box, path, content, type)")
if nil != err {
util.LogFatalf("create table [refs] failed: %s", err)
logging.LogFatalf("create table [refs] failed: %s", err)
}
}
@ -159,7 +160,7 @@ func IndexMode() {
var err error
db, err = sql.Open("sqlite3_extended", dsn)
if nil != err {
util.LogFatalf("create database failed: %s", err)
logging.LogFatalf("create database failed: %s", err)
}
db.SetMaxIdleConns(1)
db.SetMaxOpenConns(1)
@ -186,7 +187,7 @@ func initDBConnection() {
var err error
db, err = sql.Open("sqlite3_extended", dsn)
if nil != err {
util.LogFatalf("create database failed: %s", err)
logging.LogFatalf("create database failed: %s", err)
}
db.SetMaxIdleConns(20)
db.SetMaxOpenConns(20)
@ -542,7 +543,7 @@ func buildSpanFromNode(n *ast.Node, tree *parse.Tree, rootID, boxID, p string) (
if !gulu.File.IsDir(lp) {
hash, hashErr = util.GetEtag(lp)
if nil != hashErr {
util.LogErrorf("calc asset [%s] hash failed: %s", lp, hashErr)
logging.LogErrorf("calc asset [%s] hash failed: %s", lp, hashErr)
}
}
}
@ -572,7 +573,7 @@ func buildSpanFromNode(n *ast.Node, tree *parse.Tree, rootID, boxID, p string) (
htmlRoot := &html.Node{Type: html.ElementNode}
nodes, err := html.ParseFragment(strings.NewReader(gulu.Str.FromBytes(n.Tokens)), htmlRoot)
if nil != err {
util.LogErrorf("parse HTML failed: %s", err)
logging.LogErrorf("parse HTML failed: %s", err)
walkStatus = ast.WalkContinue
return
}
@ -616,7 +617,7 @@ func buildSpanFromNode(n *ast.Node, tree *parse.Tree, rootID, boxID, p string) (
if lp := assetLocalPath(dest, boxLocalPath, docDirLocalPath); "" != lp {
hash, hashErr = util.GetEtag(lp)
if nil != hashErr {
util.LogErrorf("calc asset [%s] hash failed: %s", lp, hashErr)
logging.LogErrorf("calc asset [%s] hash failed: %s", lp, hashErr)
}
}
@ -1027,14 +1028,14 @@ func batchUpdateHPath(tx *sql.Tx, boxID, rootID, oldHPath, newHPath string) (err
func CloseDatabase() {
if err := db.Close(); nil != err {
util.LogErrorf("close database failed: %s", err)
logging.LogErrorf("close database failed: %s", err)
}
}
func queryRow(query string, args ...interface{}) *sql.Row {
query = strings.TrimSpace(query)
if "" == query {
util.LogErrorf("statement is empty")
logging.LogErrorf("statement is empty")
return nil
}
return db.QueryRow(query, args...)
@ -1050,7 +1051,7 @@ func query(query string, args ...interface{}) (*sql.Rows, error) {
func BeginTx() (tx *sql.Tx, err error) {
if tx, err = db.Begin(); nil != err {
util.LogErrorf("begin tx failed: %s\n %s", err, util.ShortStack())
logging.LogErrorf("begin tx failed: %s\n %s", err, logging.ShortStack())
if strings.Contains(err.Error(), "database is locked") {
os.Exit(util.ExitCodeReadOnlyDatabase)
}
@ -1060,19 +1061,19 @@ func BeginTx() (tx *sql.Tx, err error) {
func CommitTx(tx *sql.Tx) (err error) {
if nil == tx {
util.LogErrorf("tx is nil")
logging.LogErrorf("tx is nil")
return errors.New("tx is nil")
}
if err = tx.Commit(); nil != err {
util.LogErrorf("commit tx failed: %s\n %s", err, util.ShortStack())
logging.LogErrorf("commit tx failed: %s\n %s", err, logging.ShortStack())
}
return
}
func RollbackTx(tx *sql.Tx) {
if err := tx.Rollback(); nil != err {
util.LogErrorf("rollback tx failed: %s\n %s", err, util.ShortStack())
logging.LogErrorf("rollback tx failed: %s\n %s", err, logging.ShortStack())
}
}
@ -1082,7 +1083,7 @@ func prepareExecInsertTx(tx *sql.Tx, stmtSQL string, args []interface{}) (err er
return
}
if _, err = stmt.Exec(args...); nil != err {
util.LogErrorf("exec database stmt [%s] failed: %s", stmtSQL, err)
logging.LogErrorf("exec database stmt [%s] failed: %s", stmtSQL, err)
return
}
return
@ -1094,9 +1095,9 @@ func execStmtTx(tx *sql.Tx, stmt string, args ...interface{}) (err error) {
tx.Rollback()
db.Close()
removeDatabaseFile()
util.LogFatalf("database disk image [%s] is malformed, please restart SiYuan kernel to rebuild it", util.DBPath)
logging.LogFatalf("database disk image [%s] is malformed, please restart SiYuan kernel to rebuild it", util.DBPath)
}
util.LogErrorf("exec database stmt [%s] failed: %s\n %s", stmt, err, util.ShortStack())
logging.LogErrorf("exec database stmt [%s] failed: %s\n %s", stmt, err, logging.ShortStack())
return
}
return

6
kernel/sql/file_annotation_ref.go
View file

@ -17,7 +17,7 @@
package sql
import (
"github.com/siyuan-note/siyuan/kernel/util"
"github.com/siyuan-note/logging"
)
type FileAnnotationRef struct {
@ -36,14 +36,14 @@ func QueryRefIDsByAnnotationID(annotationID string) (refIDs, refTexts []string)
refIDs = []string{}
rows, err := query("SELECT block_id, content FROM file_annotation_refs WHERE annotation_id = ?", annotationID)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
for rows.Next() {
var id, content string
if err = rows.Scan(&id, &content); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
refIDs = append(refIDs, id)

17
kernel/sql/queue.go
View file

@ -27,6 +27,7 @@ import (
"github.com/88250/lute/parse"
"github.com/emirpasic/gods/sets/hashset"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -64,11 +65,11 @@ func WaitForWritingDatabase() {
for i := 0; isWritingDatabase(); i++ {
time.Sleep(50 * time.Millisecond)
if 200 < i && !printLog { // 10s 后打日志
util.LogWarnf("database is writing: \n%s", util.ShortStack())
logging.LogWarnf("database is writing: \n%s", logging.ShortStack())
printLog = true
}
if 1200 < i && !lastPrintLog { // 60s 后打日志
util.LogWarnf("database is still writing")
logging.LogWarnf("database is still writing")
lastPrintLog = true
}
}
@ -102,7 +103,7 @@ func flushTreeQueue() {
case "upsert":
tree := op.upsertTree
if err = upsertTree(tx, tree); nil != err {
util.LogErrorf("upsert tree [%s] into database failed: %s", tree.Box+tree.Path, err)
logging.LogErrorf("upsert tree [%s] into database failed: %s", tree.Box+tree.Path, err)
}
boxes.Add(op.upsertTree.Box)
case "delete":
@ -116,13 +117,13 @@ func flushTreeQueue() {
updateRootContent(tx, path.Base(op.renameTreeNewHPath), op.renameTreeID)
boxes.Add(op.renameTreeBox)
default:
util.LogErrorf("unknown operation [%s]", op.action)
logging.LogErrorf("unknown operation [%s]", op.action)
}
}
CommitTx(tx)
elapsed := time.Now().Sub(start).Milliseconds()
if 5000 < elapsed {
util.LogInfof("op tx [%dms]", elapsed)
logging.LogInfof("op tx [%dms]", elapsed)
}
start = time.Now()
@ -136,7 +137,7 @@ func flushTreeQueue() {
CommitTx(tx)
elapsed = time.Now().Sub(start).Milliseconds()
if 1000 < elapsed {
util.LogInfof("hash tx [%dms]", elapsed)
logging.LogInfof("hash tx [%dms]", elapsed)
}
}
@ -219,7 +220,7 @@ func updateBoxHash(tx *sql.Tx, boxID string) {
func boxChecksum(box string) (ret string) {
rows, err := query("SELECT hash FROM blocks WHERE type = 'd' AND box = ? ORDER BY id DESC", box)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -227,7 +228,7 @@ func boxChecksum(box string) (ret string) {
for rows.Next() {
var hash string
if err = rows.Scan(&hash); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
buf.WriteString(hash)

12
kernel/sql/span.go
View file

@ -22,7 +22,7 @@ import (
"strings"
"github.com/88250/vitess-sqlparser/sqlparser"
"github.com/siyuan-note/siyuan/kernel/util"
"github.com/siyuan-note/logging"
)
type Span struct {
@ -40,7 +40,7 @@ type Span struct {
func SelectSpansRawStmt(stmt string, limit int) (ret []*Span) {
parsedStmt, err := sqlparser.Parse(stmt)
if nil != err {
//util.LogErrorf("select [%s] failed: %s", stmt, err)
//logging.LogErrorf("select [%s] failed: %s", stmt, err)
return
}
switch parsedStmt.(type) {
@ -69,7 +69,7 @@ func SelectSpansRawStmt(stmt string, limit int) (ret []*Span) {
if strings.Contains(err.Error(), "syntax error") {
return
}
util.LogWarnf("sql query [%s] failed: %s", stmt, err)
logging.LogWarnf("sql query [%s] failed: %s", stmt, err)
return
}
defer rows.Close()
@ -85,7 +85,7 @@ func QueryTagSpansByKeyword(keyword string, limit int) (ret []*Span) {
stmt += " LIMIT " + strconv.Itoa(limit)
rows, err := query(stmt)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -104,7 +104,7 @@ func QueryTagSpans(p string, limit int) (ret []*Span) {
stmt += " LIMIT " + strconv.Itoa(limit)
rows, err := query(stmt)
if nil != err {
util.LogErrorf("sql query failed: %s", err)
logging.LogErrorf("sql query failed: %s", err)
return
}
defer rows.Close()
@ -118,7 +118,7 @@ func QueryTagSpans(p string, limit int) (ret []*Span) {
func scanSpanRows(rows *sql.Rows) (ret *Span) {
var span Span
if err := rows.Scan(&span.ID, &span.BlockID, &span.RootID, &span.Box, &span.Path, &span.Content, &span.Markdown, &span.Type, &span.IAL); nil != err {
util.LogErrorf("query scan field failed: %s", err)
logging.LogErrorf("query scan field failed: %s", err)
return
}
ret = &span

3
kernel/sql/stat.go
View file

@ -20,6 +20,7 @@ import (
"database/sql"
"strings"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -34,7 +35,7 @@ func getDatabaseVer() (ret string) {
row := db.QueryRow(stmt, key)
if err := row.Scan(&ret); nil != err {
if !strings.Contains(err.Error(), "no such table") {
util.LogErrorf("query database version failed: %s", err)
logging.LogErrorf("query database version failed: %s", err)
}
}
return

7
kernel/sql/upsert.go
View file

@ -23,6 +23,7 @@ import (
"github.com/88250/lute/parse"
"github.com/emirpasic/gods/sets/hashset"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
@ -35,14 +36,14 @@ func init() {
func InsertBlocksSpans(tx *sql.Tx, tree *parse.Tree) (err error) {
if err = insertBlocksSpans(tx, tree); nil != err {
util.LogErrorf("insert tree [%s] into database failed: %s", tree.Box+tree.Path, err)
logging.LogErrorf("insert tree [%s] into database failed: %s", tree.Box+tree.Path, err)
}
return
}
func InsertRefs(tx *sql.Tx, tree *parse.Tree) {
if err := insertRef(tx, tree); nil != err {
util.LogErrorf("insert refs tree [%s] into database failed: %s", tree.Box+tree.Path, err)
logging.LogErrorf("insert refs tree [%s] into database failed: %s", tree.Box+tree.Path, err)
}
}
@ -465,7 +466,7 @@ func upsertTree(tx *sql.Tx, tree *parse.Tree) (err error) {
}
subTree := parse.Parse("", []byte(block.Markdown), luteEngine.ParseOptions)
if nil == subTree {
util.LogErrorf("parse temp block [%s] failed: %s", block.ID, err)
logging.LogErrorf("parse temp block [%s] failed: %s", block.ID, err)
continue
}
if 0 < len(treenode.GetLegacyDynamicBlockRefDefIDs(subTree.Root)) {