Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

263 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package model

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"maps"
	"math"
	"math/rand"
	"os"
	"path/filepath"
	"slices"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode/utf8"

	"github.com/88250/go-humanize"
	"github.com/88250/gulu"
	"github.com/88250/lute/ast"
	"github.com/88250/lute/parse"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"github.com/siyuan-note/filelock"
	"github.com/siyuan-note/logging"
	"github.com/siyuan-note/siyuan/kernel/av"
	"github.com/siyuan-note/siyuan/kernel/cache"
	"github.com/siyuan-note/siyuan/kernel/filesys"
	"github.com/siyuan-note/siyuan/kernel/search"
	"github.com/siyuan-note/siyuan/kernel/sql"
	"github.com/siyuan-note/siyuan/kernel/treenode"
	"github.com/siyuan-note/siyuan/kernel/util"
	"github.com/xrash/smetrics"
)

func ValidateUnusedAttributeView(id string) error {
	if !ast.IsNodeIDPattern(id) {
		return fmt.Errorf("invalid attribute view ID: %s", id)
	}
	items, err := UnusedAttributeViews(false)
	if err != nil {
		return err
	}
	for _, item := range items {
		if item.Item == id {
			return nil
		}
	}
	return fmt.Errorf("attribute view is not unused: %s", id)
}

func RemoveUnusedAttributeView(id string) (err error) {
	// 防御性校验:ID 必须是合法的节点 ID 格式,防止通过路径穿越读取或删除任意文件
	if err = ValidateUnusedAttributeView(id); err != nil {
		return
	}

	base := filepath.Join(util.DataDir, "storage", "av")
	absPath := filepath.Join(base, id+".json")
	if !filelock.IsExist(absPath) {
		return fmt.Errorf("attribute view not found: %s", id)
	}

	historyDir, err := getHistoryDir(HistoryOpClean)
	if err != nil {
		logging.LogErrorf("get history dir failed: %s", err)
		return
	}

	newP := strings.TrimPrefix(absPath, util.DataDir)
	historyPath := filepath.Join(historyDir, newP)
	if filelock.IsExist(absPath) {
		if err = filelock.Copy(absPath, historyPath); err != nil {
			return
		}
	}

	if err = filelock.RemoveWithoutFatal(absPath); err != nil {
		logging.LogErrorf("remove unused asset [%s] failed: %s", absPath, err)
		util.PushErrMsg(fmt.Sprintf("%s", err), 7000)
		return
	}
	GlobalUndoLog.ClearAttributeView(id)

	IncSync()

	indexHistoryDir(filepath.Base(historyDir), util.NewLute())
	return
}

func RemoveUnusedAttributeViews() (ret []string, err error) {
	ret = []string{}
	unusedAttributeViews, err := UnusedAttributeViews(false)
	if err != nil {
		return
	}
	var size int64

	msgId := util.PushMsg(Conf.Language(100), 30*1000)
	defer func() {
		if err != nil {
			util.PushUpdateMsg(msgId, err.Error(), 7000)
			return
		}
		msg := fmt.Sprintf(Conf.Language(280), len(ret), humanize.BytesCustomCeil(uint64(size), 2))
		util.PushUpdateMsg(msgId, msg, 7000)
	}()

	historyDir, err := getHistoryDir(HistoryOpClean)
	if err != nil {
		logging.LogErrorf("get history dir failed: %s", err)
		return
	}

	for _, unusedAv := range unusedAttributeViews {
		id := unusedAv.Item
		srcPath := filepath.Join(util.DataDir, "storage", "av", id+".json")
		if filelock.IsExist(srcPath) {
			historyPath := filepath.Join(historyDir, "storage", "av", id+".json")
			if err = filelock.Copy(srcPath, historyPath); err != nil {
				return
			}
		}
	}

	for _, unusedAv := range unusedAttributeViews {
		id := unusedAv.Item
		absPath := filepath.Join(util.DataDir, "storage", "av", id+".json")
		if filelock.IsExist(absPath) {
			info, statErr := os.Stat(absPath)
			if statErr == nil {
				size += info.Size()
			}

			if removeErr := filelock.RemoveWithoutFatal(absPath); removeErr != nil {
				err = removeErr
				logging.LogErrorf("remove unused av [%s] failed: %s", absPath, removeErr)
				util.PushErrMsg(fmt.Sprintf("%s", removeErr), 7000)
				return
			}
			GlobalUndoLog.ClearAttributeView(id)
		}
		ret = append(ret, absPath)
	}
	if 0 < len(ret) {
		IncSync()
	}

	indexHistoryDir(filepath.Base(historyDir), util.NewLute())
	return
}

func UnusedAttributeViews(sorted bool) (ret []*UnusedItem, err error) {
	defer func() {
		if recovered := recover(); recovered != nil {
			ret = nil
			err = fmt.Errorf("scan database references failed: %v", recovered)
			logging.LogErrorf("%s", err)
		}
	}()
	ret = []*UnusedItem{}

	allAvIDs, err := getAllAvIDs()
	if err != nil {
		if os.IsNotExist(err) {
			return ret, nil
		}
		return
	}

	docReferencedAvIDs := map[string]bool{}
	luteEngine := util.NewLute()
	boxes := Conf.GetBoxes()
	for _, box := range boxes {
		if IsEncryptedBox(box.ID) {
			continue
		}
		pages, walkErr := pagedPathsWithError(filepath.Join(util.DataDir, box.ID), 32)
		if walkErr != nil {
			return nil, walkErr
		}
		for _, paths := range pages {
			var trees []*parse.Tree
			for _, localPath := range paths {
				tree, loadTreeErr := loadTree(localPath, luteEngine)
				if nil != loadTreeErr {
					return nil, fmt.Errorf("read database references [%s] failed: %w", localPath, loadTreeErr)
				}
				trees = append(trees, tree)
			}
			for _, tree := range trees {
				for _, id := range getAvIDs(tree, allAvIDs) {
					docReferencedAvIDs[id] = true
				}
			}
		}
	}

	templateAvIDs := search.FindAllMatchedTargets(filepath.Join(util.DataDir, "templates"), allAvIDs)
	for _, id := range templateAvIDs {
		docReferencedAvIDs[id] = true
	}

	checkedAvIDs := map[string]bool{}
	for _, id := range allAvIDs {
		if docReferencedAvIDs[id] {
			continue
		}
		referenced, scanErr := isRelatedSrcAvDocReferenced(id, docReferencedAvIDs, checkedAvIDs)
		if scanErr != nil {
			return nil, scanErr
		}
		if !referenced {
			name, _ := av.GetAttributeViewName(id)

			var modTime time.Time
			if sorted {
				p := filepath.Join(util.DataDir, "storage", "av", id+".json")
				if info, statErr := os.Stat(p); nil == statErr {
					modTime = info.ModTime()
				}
			}

			ret = append(ret, &UnusedItem{Item: id, Name: name, ModTime: modTime})
		}
	}

	if sorted {
		sort.Slice(ret, func(i, j int) bool {
			if !ret[i].ModTime.Equal(ret[j].ModTime) {
				return ret[i].ModTime.After(ret[j].ModTime)
			}
			return ret[i].Item > ret[j].Item
		})
	}
	return
}

func isRelatedSrcAvDocReferenced(destAvID string, docReferencedAvIDs, checkedAvIDs map[string]bool) (bool, error) {
	if checkedAvIDs[destAvID] {
		if docReferencedAvIDs[destAvID] {
			return true, nil
		}
		return false, nil
	}
	checkedAvIDs[destAvID] = true

	srcAvIDs, err := av.GetSrcAvIDsWithErr(destAvID)
	if err != nil {
		return false, fmt.Errorf("read database relations [%s] failed: %w", destAvID, err)
	}
	srcAvIDs = gulu.Str.RemoveElem(srcAvIDs, destAvID) // 忽略自身关联
	if 1 > len(srcAvIDs) {
		return false, nil
	}

	for _, srcAvID := range srcAvIDs {
		if docReferencedAvIDs[srcAvID] {
			return true, nil
		}
	}

	// 递归检查间接关联的 av
	for _, srcAvID := range srcAvIDs {
		referenced, err := isRelatedSrcAvDocReferenced(srcAvID, docReferencedAvIDs, checkedAvIDs)
		if err != nil || referenced {
			return referenced, err
		}
	}
	return false, nil
}

func getAvIDs(tree *parse.Tree, allAvIDs []string) (ret []string) {
	ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
		if !entering {
			return ast.WalkContinue
		}

		if ast.NodeAttributeView == n.Type {
			ret = append(ret, n.AttributeViewID)
		}

		for _, kv := range n.KramdownIAL {
			ids := util.GetContainsSubStrs(kv[1], allAvIDs)
			if 0 < len(ids) {
				ret = append(ret, ids...)
			}
		}

		return ast.WalkContinue
	})

	ret = gulu.Str.RemoveDuplicatedElem(ret)
	return
}

func getAllAvIDs() (ret []string, err error) {
	ret = []string{}

	// 只扫全局 AV 目录。加密笔记本的 AV 存在笔记本级目录(密文),不参与全局枚举——
	// 未引用清理功能在加密笔记本锁定时无法确认引用关系(loadTree 失败),枚举加密 AV 有误删风险
	entries, err := os.ReadDir(filepath.Join(util.DataDir, "storage", "av"))
	if nil != err {
		return
	}

	for _, entry := range entries {
		name := entry.Name()
		if !strings.HasSuffix(name, ".json") {
			continue
		}

		id := strings.TrimSuffix(name, ".json")
		if !ast.IsNodeIDPattern(id) {
			continue
		}

		ret = append(ret, id)
	}
	ret = gulu.Str.RemoveDuplicatedElem(ret)
	return
}

func GetAttributeViewItemIDs(avID string, blockIDs []string) (ret map[string]string) {
	ret = map[string]string{}
	for _, blockID := range blockIDs {
		ret[blockID] = ""
	}

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	blockKv := attrView.GetBlockKeyValues()
	for _, b := range blockKv.Values {
		if _, ok := ret[b.Block.ID]; ok {
			ret[b.Block.ID] = b.BlockID
		}
	}
	return
}

func GetAttributeViewBoundBlockIDs(avID string, itemIDs []string) (ret map[string]string) {
	ret = map[string]string{}
	for _, itemID := range itemIDs {
		ret[itemID] = ""
	}

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	blockKv := attrView.GetBlockKeyValues()
	for _, b := range blockKv.Values {
		if _, ok := ret[b.BlockID]; ok {
			ret[b.BlockID] = b.Block.ID
		}
	}
	return
}

func GetAttrViewAddingBlockDefaultValues(avID, blockID, viewID, groupID, previousBlockID, addingBlockID string) (ret map[string]*av.Value, err error) {
	ret = map[string]*av.Value{}

	attrView, err := avParseView(avID, blockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	view, err := resolveAttributeViewView(attrView, viewID, "", blockID)
	if nil == view {
		logging.LogErrorf("view [%s] not found in attribute view [%s]", viewID, avID)
		return
	}
	filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, blockID)
	if nil != contextErr {
		err = contextErr
		return
	}
	if nil != filterContext && 1 > len(filterContext.CurrentDocumentItemIDs) {
		err = av.ErrAttributeViewContextNotBound
		return
	}

	useGroupDefault := "" != groupID
	if 1 > len(view.Filters) && !useGroupDefault && nil == filterContext {
		// 没有过滤条件也没有分组条件时忽略
		return
	}

	groupView := view
	if useGroupDefault {
		groupView = view.GetGroupByID(groupID)
	}
	if nil == groupView {
		logging.LogErrorf("group [%s] not found in view [%s] of attribute view [%s]", groupID, viewID, avID)
		return
	}

	ret = getAttrViewAddingBlockDefaultValues(attrView, view, groupView, previousBlockID, addingBlockID, true,
		useGroupDefault, filterContext)
	for _, value := range ret {
		// 主键都不返回内容,避免闪烁 https://github.com/siyuan-note/siyuan/issues/15561#issuecomment-3184746195
		if av.KeyTypeBlock == value.Type {
			value.Block.Content = ""
		}
	}
	return
}

func newAttrViewValueSelect(option *av.SelectOption) *av.ValueSelect {
	ret := &av.ValueSelect{Content: option.Name, Color: option.Color}
	if nil != option.ResolvedColor {
		resolved := *option.ResolvedColor
		ret.ResolvedColor = &resolved
	}
	return ret
}

func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, groupView *av.View, previousItemID,
	addingItemID string, isCreate, useGroupDefault bool, filterContexts ...*av.FilterContext) (ret map[string]*av.Value) {
	ret = map[string]*av.Value{}
	filterContext := firstAttributeViewFilterContext(filterContexts)
	defer func() {
		applyAttributeViewContextFilterDefaultValue(attrView, addingItemID, filterContext, ret)
		for keyID, value := range ret {
			key, _ := attrView.GetKey(keyID)
			normalizeAttrViewAddingDefaultValue(key, value)
			attrView.ResolveValueSelectColors(value)
		}
	}()

	if 1 > len(view.Filters) && !useGroupDefault && nil == filterContext {
		// 没有过滤条件也没有分组条件时忽略
		return
	}

	nearItem := getNearItem(attrView, view, groupView, previousItemID, filterContext)

	// 使用模板或汇总进行过滤或分组时,需要解析涉及到的其他字段
	templateRelevantKeys, rollupRelevantKeys := map[string][]*av.Key{}, map[string]*av.Key{}
	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeTemplate == keyValues.Key.Type {
			if tplRelevantKeys := sql.GetTemplateKeyRelevantKeys(attrView, keyValues.Key); 0 < len(tplRelevantKeys) {
				for _, k := range tplRelevantKeys {
					templateRelevantKeys[keyValues.Key.ID] = append(templateRelevantKeys[keyValues.Key.ID], k)
				}
			}
		} else if av.KeyTypeRollup == keyValues.Key.Type {
			if nil != keyValues.Key.Rollup {
				relKey, _ := attrView.GetKey(keyValues.Key.Rollup.RelationKeyID)
				if nil != relKey && nil != relKey.Relation {
					if attrView.ID == relKey.Relation.AvID {
						if k, _ := attrView.GetKey(keyValues.Key.Rollup.KeyID); nil != k {
							rollupRelevantKeys[k.ID] = k
						}
					}
				}
			}
		}
	}

	filterKeyIDs := map[string]bool{}
	if applyFilterDefaultValues(view.Filters, attrView, addingItemID, nearItem, templateRelevantKeys, rollupRelevantKeys,
		ret, filterKeyIDs) {
		// 遇到 mAsset 过滤即结束全部默认值计算(保留原外层 return 语义)
		return
	}

	if !useGroupDefault {
		return
	}
	if nil != view.Group && av.ValueSourceRendered == view.Group.ValueSource {
		// 模板渲染结果无法反向推导分组字段的存储值。
		return
	}

	groupKey := view.GetGroupKey(attrView)
	if nil == groupKey {
		return
	}

	keyValues, _ := attrView.GetKeyValues(groupKey.ID)
	if nil == keyValues {
		return
	}

	newValue := getNewValueByNearItem(nearItem, groupKey, addingItemID)
	if av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type {
		// 因为单选或多选只能按选项分组,并且可能存在空白分组(找不到临近项),所以单选或多选类型的分组字段使用分组值内容对应的选项
		if opt := groupKey.GetOption(groupView.GetGroupValue()); nil != opt && groupValueDefault != groupView.GetGroupValue() {
			if nil == newValue {
				newValue = ret[groupKey.ID] // 如果没有临近项,则尝试从过滤结果中获取
			}
			if nil == newValue {
				newValue = keyValues.GetValue(addingItemID) // 尝试从已有值中获取
			}

			if nil != newValue {
				if !av.MSelectExistOption(newValue.MSelect, groupView.GetGroupValue()) {
					if 1 > len(newValue.MSelect) || av.KeyTypeMSelect == groupKey.Type {
						newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
					} else {
						newValue.MSelect = []*av.ValueSelect{newAttrViewValueSelect(opt)}
					}
				} else {
					var vals []*av.ValueSelect
					if isCreate {
						vals = append(vals, newAttrViewValueSelect(opt))
					} else {
						existingVal := keyValues.GetValue(addingItemID)
						if nil != existingVal {
							if !av.MSelectExistOption(existingVal.MSelect, opt.Name) {
								existingVal.MSelect = append(existingVal.MSelect, newAttrViewValueSelect(opt))
							}
							vals = existingVal.MSelect
						} else {
							vals = append(vals, newAttrViewValueSelect(opt))
						}
					}

					// 添加过滤结果选项的值
					if nil != ret[groupKey.ID] {
						for _, v := range ret[groupKey.ID].MSelect {
							if !av.MSelectExistOption(vals, v.Content) {
								vals = append(vals, v)
							}
						}
					}
					newValue.MSelect = vals
				}
			} else {
				newValue = av.GetAttributeViewDefaultValue(ast.NewNodeID(), groupKey.ID, addingItemID, groupKey.Type, false)
				newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
			}
		}

		if nil != newValue {
			ret[groupKey.ID] = newValue
		}
		return
	}

	if av.KeyTypeTemplate == keyValues.Key.Type && nil != nearItem {
		if keys := templateRelevantKeys[keyValues.Key.ID]; 0 < len(keys) {
			for _, k := range keys {
				if nil == ret[k.ID] {
					ret[k.ID] = getNewValueByNearItem(nearItem, k, addingItemID)
				}
			}
		}
		return
	}

	if av.KeyTypeRollup == keyValues.Key.Type && nil != nearItem {
		if relKey, ok := rollupRelevantKeys[keyValues.Key.ID]; ok {
			if nil == ret[relKey.ID] {
				ret[relKey.ID] = getNewValueByNearItem(nearItem, relKey, addingItemID)
			}
		}
		return
	}

	if nil != nearItem && filterKeyIDs[groupKey.ID] {
		// 临近项不为空并且分组字段和过滤字段相同时,优先使用临近项 https://github.com/siyuan-note/siyuan/issues/15591
		newValue = getNewValueByNearItem(nearItem, groupKey, addingItemID)
		ret[groupKey.ID] = newValue
		return
	}

	if nil == nearItem && !filterKeyIDs[groupKey.ID] {
		// 没有临近项并且分组字段和过滤字段不同时,使用分组值
		newValue = av.GetAttributeViewDefaultValue(ast.NewNodeID(), groupKey.ID, addingItemID, groupKey.Type, false)
		if av.KeyTypeText == groupView.GroupVal.Type {
			content := groupView.GroupVal.Text.Content
			if groupValueDefault == content {
				content = ""
			}

			switch newValue.Type {
			case av.KeyTypeBlock:
				newValue.Block.Content = content
			case av.KeyTypeText:
				newValue.Text.Content = content
			case av.KeyTypeNumber:
				num, _ := strconv.ParseFloat(strings.Split(content, " - ")[0], 64)
				newValue.Number.Content = num
				newValue.Number.IsNotEmpty = true
			case av.KeyTypeURL:
				newValue.URL.Content = content
			case av.KeyTypeEmail:
				newValue.Email.Content = content
			case av.KeyTypePhone:
				newValue.Phone.Content = content
			}
		} else if av.KeyTypeCheckbox == groupView.GroupVal.Type {
			newValue.Checkbox.Checked = groupView.GroupVal.Checkbox.Checked
		} else if av.KeyTypeRelation == groupKey.Type && av.KeyTypeRelation == groupView.GroupVal.Type &&
			nil != groupView.GroupVal.Relation && 0 < len(groupView.GroupVal.Relation.BlockIDs) {
			newValue.Relation.BlockIDs = []string{groupView.GroupVal.Relation.BlockIDs[0]}
		}

		ret[groupKey.ID] = newValue
		return
	}

	if nil != newValue && !filterKeyIDs[groupKey.ID] {
		ret[groupKey.ID] = newValue
	}
	return
}

func normalizeAttrViewAddingDefaultValue(key *av.Key, value *av.Value) {
	if nil == key || nil == value {
		return
	}
	if av.KeyTypeDate == value.Type && nil != value.Date {
		value.Date.IsNotTime = true
		if nil != key.Date {
			value.Date.IsNotTime = !key.Date.FillSpecificTime
			if key.Date.AutoFillNow {
				value.Date.Content = util.CurrentTimeMillis()
				value.Date.IsNotEmpty = true
			}
		}
	}
	if av.KeyTypeRelation == value.Type && nil != value.Relation {
		value.Relation.Contents = nil
	}
}

func firstAttributeViewFilterContext(contexts []*av.FilterContext) *av.FilterContext {
	if 0 < len(contexts) {
		return contexts[0]
	}
	return nil
}

// applyFilterDefaultValues 递归遍历过滤节点树,对叶子节点计算新增行的默认值。
// AND 分组合并后验证所有子节点,OR 分组采用首个可满足的分支;无法满足时不生成默认值。
// 返回 true 表示遇到 mAsset 过滤,调用方应立即终止全部默认值计算并丢弃已累积结果。
func applyFilterDefaultValues(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string, nearItem av.Item,
	templateRelevantKeys map[string][]*av.Key, rollupRelevantKeys map[string]*av.Key,
	ret map[string]*av.Value, filterKeyIDs map[string]bool) (stop bool) {
	originalRet := cloneDefaultValues(ret)
	originalFilterKeyIDs := cloneBoolMap(filterKeyIDs)
	if applyFilterDefaultValues0(filters, attrView, addingItemID, nearItem, templateRelevantKeys, rollupRelevantKeys,
		ret, filterKeyIDs) {
		return true
	}
	if !filterBranchesMatchDefaultValues(filters, attrView, addingItemID, ret) {
		replaceDefaultValues(ret, originalRet)
		replaceBoolMap(filterKeyIDs, originalFilterKeyIDs)
	}
	return false
}

func applyFilterDefaultValues0(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string, nearItem av.Item,
	templateRelevantKeys map[string][]*av.Key, rollupRelevantKeys map[string]*av.Key,
	ret map[string]*av.Value, filterKeyIDs map[string]bool) (stop bool) {
	for _, filter := range filters {
		if nil == filter {
			continue
		}
		if filter.IsGroup() {
			if av.FilterCombinationOr == filter.Combination && 0 < len(filter.Filters) {
				for _, child := range filter.Filters {
					candidateRet := cloneDefaultValues(ret)
					candidateFilterKeyIDs := cloneBoolMap(filterKeyIDs)
					childStop := applyFilterDefaultValues([]*av.ViewFilter{child}, attrView, addingItemID, nearItem,
						templateRelevantKeys, rollupRelevantKeys, candidateRet, candidateFilterKeyIDs)
					if childStop || filterBranchMatchesDefaultValues(child, attrView, addingItemID, candidateRet) {
						replaceDefaultValues(ret, candidateRet)
						replaceBoolMap(filterKeyIDs, candidateFilterKeyIDs)
						if childStop {
							return true
						}
						break
					}
				}
				continue
			}
			if applyFilterDefaultValues(filter.Filters, attrView, addingItemID, nearItem, templateRelevantKeys,
				rollupRelevantKeys, ret, filterKeyIDs) {
				return true
			}
			continue
		}

		keyValues, _ := attrView.GetKeyValues(filter.Column)
		if nil == keyValues {
			continue
		}
		if !filter.IsValid() {
			continue
		}
		if av.ValueSourceRendered == filter.ValueSource {
			// 显示模板结果无法反向推导字段存储值。
			continue
		}
		filterKeyIDs[filter.Column] = true

		if av.KeyTypeTemplate == keyValues.Key.Type && nil != nearItem {
			if keys := templateRelevantKeys[keyValues.Key.ID]; 0 < len(keys) {
				for _, k := range keys {
					if nil == ret[k.ID] {
						ret[k.ID] = getNewValueByNearItem(nearItem, k, addingItemID)
					}
				}
			}
			continue
		}

		if av.KeyTypeRollup == keyValues.Key.Type && nil != nearItem {
			if relKey, ok := rollupRelevantKeys[keyValues.Key.ID]; ok {
				if nil == ret[relKey.ID] {
					ret[relKey.ID] = getNewValueByNearItem(nearItem, relKey, addingItemID)
				}
			}
			continue
		}

		if av.KeyTypeMAsset == keyValues.Key.Type {
			if nil != nearItem {
				if _, ok := ret[keyValues.Key.ID]; !ok {
					ret[keyValues.Key.ID] = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID)
				}
			}
			return true // 保留原语义:遇到 mAsset 过滤即结束默认值计算
		}

		newValue, allowNearItem := filter.GetAffectValue(keyValues.Key, addingItemID)
		if nil == newValue && allowNearItem {
			newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID)
		}
		if nil != newValue {
			ret[keyValues.Key.ID] = newValue
		}
	}
	return false
}

func cloneDefaultValues(values map[string]*av.Value) (ret map[string]*av.Value) {
	ret = make(map[string]*av.Value, len(values))
	maps.Copy(ret, values)
	return
}

func cloneBoolMap(values map[string]bool) (ret map[string]bool) {
	ret = make(map[string]bool, len(values))
	maps.Copy(ret, values)
	return
}

func filterBranchesMatchDefaultValues(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string,
	values map[string]*av.Value) bool {
	for _, filter := range filters {
		if !filterBranchMatchesDefaultValues(filter, attrView, addingItemID, values) {
			return false
		}
	}
	return true
}

func filterBranchMatchesDefaultValues(filter *av.ViewFilter, attrView *av.AttributeView, addingItemID string,
	values map[string]*av.Value) bool {
	if nil == filter {
		return false
	}
	if filter.IsGroup() {
		if 1 > len(filter.Filters) {
			return av.FilterCombinationOr != filter.Combination
		}
		if av.FilterCombinationOr == filter.Combination {
			for _, child := range filter.Filters {
				if filterBranchMatchesDefaultValues(child, attrView, addingItemID, values) {
					return true
				}
			}
			return false
		}
		return filterBranchesMatchDefaultValues(filter.Filters, attrView, addingItemID, values)
	}

	keyValues, _ := attrView.GetKeyValues(filter.Column)
	if nil == keyValues {
		return false
	}
	if !filter.IsValid() {
		return true
	}
	if av.ValueSourceRendered == filter.ValueSource {
		// 显示模板结果无法在新增条目时根据存储值准确判断。
		return true
	}
	if av.HasKeyGroup(keyValues.Key.Type, av.KeyGroupRenderDependentFilter) {
		// 这些字段的最终值需要在渲染阶段计算,此处无法根据存储值准确判断。
		return true
	}

	value := values[filter.Column]
	if nil == value {
		value = av.GetAttributeViewDefaultValue(ast.NewNodeID(), filter.Column, addingItemID, keyValues.Key.Type, false)
	}
	return value.Filter(filter, attrView, addingItemID, nil, nil)
}

func applyAttributeViewContextFilterDefaultValue(attrView *av.AttributeView, addingItemID string,
	context *av.FilterContext, values map[string]*av.Value) {
	if nil == attrView || nil == context || "" == context.KeyID || 1 > len(context.CurrentDocumentItemIDs) {
		return
	}
	keyValues, err := attrView.GetKeyValues(context.KeyID)
	if nil != err || nil == keyValues || nil == keyValues.Key || av.KeyTypeRelation != keyValues.Key.Type {
		return
	}

	value := values[context.KeyID]
	if nil == value {
		if existing := keyValues.GetValue(addingItemID); nil != existing {
			value = existing.Clone()
		}
	}
	if nil == value {
		value = av.GetAttributeViewDefaultValue(ast.NewNodeID(), context.KeyID, addingItemID,
			av.KeyTypeRelation, false)
	}
	if nil == value.Relation {
		value.Relation = &av.ValueRelation{}
	}
	seen := map[string]bool{}
	blockIDs := value.Relation.BlockIDs[:0]
	for _, itemID := range value.Relation.BlockIDs {
		if "" == itemID || seen[itemID] {
			continue
		}
		seen[itemID] = true
		blockIDs = append(blockIDs, itemID)
	}
	value.Relation.BlockIDs = blockIDs
	for _, itemID := range context.CurrentDocumentItemIDs {
		if "" == itemID || seen[itemID] {
			continue
		}
		seen[itemID] = true
		value.Relation.BlockIDs = append(value.Relation.BlockIDs, itemID)
	}
	values[context.KeyID] = value
}

func replaceDefaultValues(target, source map[string]*av.Value) {
	clear(target)
	maps.Copy(target, source)
}

func replaceBoolMap(target, source map[string]bool) {
	clear(target)
	maps.Copy(target, source)
}

func (tx *Transaction) doSortAttrViewGroup(operation *Operation) (ret *TxErr) {
	if err := sortAttributeViewGroup(operation.AvID, operation.BlockID, operation.PreviousID, operation.ID); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func sortAttributeViewGroup(avID, blockID, previousGroupID, groupID string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return err
	}

	sortGroupViews(attrView, view)

	var groupView *av.View
	var index, previousIndex int
	for i, g := range view.Groups {
		if g.ID == groupID {
			groupView = g
			index = i
			break
		}
	}
	if nil == groupView {
		return
	}
	view.Group.Order = av.GroupOrderMan

	view.Groups = append(view.Groups[:index], view.Groups[index+1:]...)
	for i, g := range view.Groups {
		if g.ID == previousGroupID {
			previousIndex = i + 1
			break
		}
	}
	view.Groups = slices.Insert(view.Groups, previousIndex, groupView)

	for i, g := range view.Groups {
		g.GroupSort = i
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doRemoveAttrViewGroup(operation *Operation) (ret *TxErr) {
	if err := removeAttributeViewGroup(operation.AvID, operation.BlockID); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func removeAttributeViewGroup(avID, blockID string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return err
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return err
	}

	removeAttributeViewGroup0(view)
	err = av.SaveAttributeView(attrView)
	if err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return err
	}
	return nil
}

func removeAttributeViewGroup0(view *av.View) {
	view.Group, view.Groups, view.GroupCreated = nil, nil, 0
}

func (tx *Transaction) doSyncAttrViewTableColWidth(operation *Operation) (ret *TxErr) {
	err := syncAttrViewTableColWidth(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func syncAttrViewTableColWidth(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view := attrView.GetView(operation.ID)
	if nil == view {
		err = av.ErrViewNotFound
		logging.LogErrorf("view [%s] not found in attribute view [%s]", operation.ID, operation.AvID)
		return
	}

	var width string
	switch view.LayoutType {
	case av.LayoutTypeList, av.LayoutTypeCalendar:
		return
	case av.LayoutTypeTable:
		for _, column := range view.Table.Columns {
			if column.ID == operation.KeyID {
				width = column.Width
				break
			}
		}
	case av.LayoutTypeGallery, av.LayoutTypeKanban:
		return
	}

	for _, v := range attrView.Views {
		if av.LayoutTypeTable == v.LayoutType {
			for _, column := range v.Table.Columns {
				if column.ID == operation.KeyID {
					column.Width = width
					break
				}
			}
		}
	}

	err = av.SaveAttributeView(attrView)
	ReloadAttrView(attrView.ID)
	return
}

func (tx *Transaction) doHideAttrViewGroup(operation *Operation) (ret *TxErr) {
	if err := hideAttributeViewGroup(operation.AvID, operation.BlockID, operation.ID, int(operation.Data.(float64))); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func hideAttributeViewGroup(avID, blockID, groupID string, hidden int) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return
	}

	for _, group := range view.Groups {
		if group.ID == groupID {
			group.GroupHidden = hidden
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	if err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}
	return
}

func (tx *Transaction) doHideAttrViewAllGroups(operation *Operation) (ret *TxErr) {
	if err := hideAttributeViewAllGroups(operation.AvID, operation.BlockID, operation.Data.(bool)); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func hideAttributeViewAllGroups(avID, blockID string, hidden bool) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return
	}

	for _, group := range view.Groups {
		if hidden {
			group.GroupHidden = 2
		} else {
			group.GroupHidden = 0
		}
	}

	err = av.SaveAttributeView(attrView)
	if err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}
	return
}

func (tx *Transaction) doFoldAttrViewGroup(operation *Operation) (ret *TxErr) {
	if err := foldAttrViewGroup(operation.AvID, operation.BlockID, operation.ID, operation.Data.(bool)); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func foldAttrViewGroup(avID, blockID, groupID string, folded bool) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return err
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return err
	}

	if !view.IsGroupView() {
		return
	}

	for _, group := range view.Groups {
		if group.ID == groupID {
			group.GroupFolded = folded
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	if err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return err
	}
	return nil
}

func (tx *Transaction) doFoldAttrViewGroups(operation *Operation) (ret *TxErr) {
	folded := map[string]bool{}
	data, err := gulu.JSON.MarshalJSON(operation.Data)
	if nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	if err = gulu.JSON.UnmarshalJSON(data, &folded); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	if err = foldAttrViewGroups(operation.AvID, operation.BlockID, operation.ViewID, folded); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func foldAttrViewGroups(avID, blockID, viewID string, folded map[string]bool) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return err
	}

	var view *av.View
	if "" != viewID {
		view = attrView.GetView(viewID)
		if nil == view {
			return av.ErrViewNotFound
		}
	} else {
		view, err = getAttrViewViewByBlockID(attrView, blockID)
		if err != nil {
			return err
		}
	}

	if !view.IsGroupView() {
		return
	}

	for _, group := range view.Groups {
		if groupFolded, ok := folded[group.ID]; ok {
			group.GroupFolded = groupFolded
		}
	}

	err = av.SaveAttributeView(attrView)
	if err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return err
	}
	return nil
}

func (tx *Transaction) doSetAttrViewGroup(operation *Operation) (ret *TxErr) {
	data, err := gulu.JSON.MarshalJSON(operation.Data)
	if nil != err {
		logging.LogErrorf("marshal operation data failed: %s", err)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	group := &av.ViewGroup{}
	if err = gulu.JSON.UnmarshalJSON(data, &group); nil != err {
		logging.LogErrorf("unmarshal operation data failed: %s", err)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	if err = SetAttributeViewGroup(operation.AvID, operation.BlockID, group); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func SetAttributeViewGroup(avID, blockID string, group *av.ViewGroup) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return err
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return err
	}

	setAttributeViewGroup(attrView, view, group)

	err = av.SaveAttributeView(attrView)
	ReloadAttrView(avID)
	return
}

func setAttributeViewGroup(attrView *av.AttributeView, view *av.View, group *av.ViewGroup) {
	if nil == group || "" == group.Field {
		removeAttributeViewGroup0(view)
		return
	}
	if av.ValueSourceRendered == group.ValueSource {
		group.Method = av.GroupMethodValue
		group.Range = nil
		if av.GroupOrderSelectOption == group.Order {
			group.Order = av.GroupOrderAsc
		}
	}

	var firstInit, changeGroupField bool
	if nil != view.Group {
		changeGroupField = group.Field != view.Group.Field
	} else {
		firstInit = true
	}

	groupStates := getAttrViewGroupStates(view)
	view.Group = group
	genAttrViewGroups(view, attrView)
	setAttrViewGroupStates(view, groupStates)
	syncAttrViewGroupHiddenStates(attrView, view)

	if (firstInit || changeGroupField) && av.ValueSourceRendered != group.ValueSource { // 首次设置分组时
		if groupKey := view.GetGroupKey(attrView); nil != groupKey {
			if av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type {
				// 如果分组字段是单选或多选,则将分组排序方式改为按选项排序 https://github.com/siyuan-note/siyuan/issues/15534
				view.Group.Order = av.GroupOrderSelectOption
				sortGroupsBySelectOption(view, groupKey)
			} else if av.KeyTypeCheckbox == groupKey.Type {
				// 如果分组字段是复选框,则将分组排序改为手动排序,并且已勾选在前面
				view.Group.Order = av.GroupOrderMan
				checked := view.GetGroupByGroupValue(av.CheckboxCheckedStr)
				unchecked := view.GetGroupByGroupValue("")
				view.Groups = nil
				view.Groups = append(view.Groups, checked, unchecked)
			}

		}

		for i, g := range view.Groups {
			g.GroupSort = i
		}
	}
}

func syncAttrViewGroupHiddenStates(attrView *av.AttributeView, view *av.View) {
	if !view.IsGroupView() {
		return
	}
	if !view.Group.HideEmpty {
		for _, groupView := range view.Groups {
			if 2 != groupView.GroupHidden {
				groupView.GroupHidden = 0
			}
		}
		return
	}

	viewable := sql.RenderView(attrView, view, "", false)
	cachedAttrViews := map[string]*av.AttributeView{}
	rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
	if table := av.TableFromViewable(viewable); nil != table {
		// 过滤只依赖行字段值,先对完整父表执行一次,再按分组成员关系判断空分组。
		filtered := *table
		filtered.Rows = append([]*av.TableRow(nil), table.Rows...)
		av.Filter(&filtered, attrView, rollupFurtherCollections, cachedAttrViews)
		visibleItemIDs := make(map[string]bool, len(filtered.Rows))
		for _, row := range filtered.Rows {
			visibleItemIDs[row.ID] = true
		}
		for _, groupView := range view.Groups {
			if 2 == groupView.GroupHidden {
				continue
			}
			groupView.GroupHidden = 1
			for _, itemID := range groupView.GroupItemIDs {
				if visibleItemIDs[itemID] {
					groupView.GroupHidden = 0
					break
				}
			}
		}
		return
	}

	for _, groupView := range view.Groups {
		if 2 == groupView.GroupHidden {
			continue
		}
		groupViewable := sql.RenderGroupView(attrView, view, groupView, "")
		av.Filter(groupViewable, attrView, rollupFurtherCollections, cachedAttrViews)
		if 1 > groupViewable.(av.Collection).CountItems() {
			groupView.GroupHidden = 1
		} else {
			groupView.GroupHidden = 0
		}
	}
}

func (tx *Transaction) doSetAttrViewCardAspectRatio(operation *Operation) (ret *TxErr) {
	err := setAttrViewCardAspectRatio(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardAspectRatio(operation *Operation) (err error) {
	value, err := getAttrViewOperationNumber(operation)
	if nil != err {
		return
	}
	ratio := av.CardAspectRatio(value)
	if value != math.Trunc(value) || ratio < av.CardAspectRatio16_9 || av.CardAspectRatio1_1 < ratio {
		return fmt.Errorf("invalid card aspect ratio preset [%v]", value)
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CardAspectRatio = ratio
	cards.CardAspectRatioValue = av.CardAspectRatioValueByPreset(ratio)

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCardAspectRatioValue(operation *Operation) (ret *TxErr) {
	if err := setAttrViewCardAspectRatioValue(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardAspectRatioValue(operation *Operation) (err error) {
	ratio, err := getAttrViewOperationNumber(operation)
	if nil != err {
		return
	}
	if math.IsNaN(ratio) || math.IsInf(ratio, 0) ||
		ratio < av.CardAspectRatioValueMin || av.CardAspectRatioValueMax < ratio {
		return fmt.Errorf("invalid card aspect ratio [%v]", ratio)
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}
	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CardAspectRatioValue = ratio

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewBlockView(operation *Operation) (ret *TxErr) {
	err := SetDatabaseBlockView(operation.BlockID, operation.AvID, operation.ID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewBlockVisibleViews(operation *Operation) (ret *TxErr) {
	err := SetDatabaseBlockVisibleViews(operation.BlockID, operation.AvID, operation.ViewIDs)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func SetDatabaseBlockVisibleViews(blockID, avID string, viewIDs []string) (err error) {
	if 1 > len(viewIDs) {
		return errors.New("at least one visible view is required")
	}

	attrView, err := avParseView(avID, blockID)
	if nil != err {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	visible := map[string]bool{}
	for _, viewID := range viewIDs {
		if nil == attrView.GetView(viewID) {
			return fmt.Errorf("view [%s] not found in attribute view [%s]", viewID, avID)
		}
		visible[viewID] = true
	}

	var normalized []string
	for _, view := range attrView.Views {
		if visible[view.ID] {
			normalized = append(normalized, view.ID)
		}
	}
	if 1 > len(normalized) {
		return errors.New("at least one visible view is required")
	}

	node, tree, err := getAttributeViewInstanceNode(attrView, blockID)
	if nil != err {
		return
	}

	err = setNodeAttrs(node, tree, map[string]string{
		av.NodeAttrVisibleViewIDs: strings.Join(normalized, ","),
	})
	return
}

func (tx *Transaction) doChangeAttrViewLayout(operation *Operation) (ret *TxErr) {
	err := ChangeAttrViewLayout(operation.BlockID, operation.AvID, operation.Layout)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func ChangeAttrViewLayout(blockID, avID string, newLayout av.LayoutType) (err error) {
	return ChangeAttrViewLayoutForView(blockID, avID, "", "", newLayout)
}

// ChangeAttrViewLayoutForView 精确修改指定视图的布局,并同步显示该视图的镜像数据库块。
func ChangeAttrViewLayoutForView(blockID, avID, viewID, revision string, newLayout av.LayoutType) (err error) {
	if "" != viewID {
		FlushTxQueue()
	}
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}

	var view *av.View
	if "" != viewID {
		if _, _, err = getAttributeViewInstanceNode(attrView, blockID); nil != err {
			return
		}
		view = attrView.GetView(viewID)
		if nil == view {
			return av.ErrViewNotFound
		}
		if err = checkAttributeViewViewConfigRevision(view, revision); nil != err {
			return
		}
	} else {
		view, err = getAttrViewViewByBlockID(attrView, blockID)
		if err != nil {
			return
		}
	}

	if newLayout == view.LayoutType {
		return
	}

	if err = changeAttrViewLayout(attrView, view, newLayout); err != nil {
		return
	}

	blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
	for _, bID := range blockIDs {
		node, tree, _ := getNodeByBlockID(nil, bID)
		if nil == node || nil == tree {
			logging.LogErrorf("get node by block ID [%s] failed", bID)
			continue
		}

		changed := false
		attrs := parse.IAL2Map(node.KramdownIAL)
		if blockID == bID && "" == viewID { // 当前操作的镜像库
			attrs[av.NodeAttrView] = view.ID
			node.AttributeViewType = string(view.LayoutType)
			changed = true
		} else {
			if view.ID == attrs[av.NodeAttrView] {
				// 仅更新和当前操作的镜像库指定的视图相同的镜像库
				node.AttributeViewType = string(view.LayoutType)
				changed = true
			}
		}

		if changed {
			err = setNodeAttrs(node, tree, attrs)
			if err != nil {
				logging.LogWarnf("set node [%s] attrs failed: %s", bID, err)
				return
			}
		}
	}

	regenAttrViewGroups(attrView)

	if err = avSaveView(attrView, blockID); nil != err {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}

	ReloadAttrView(avID)
	return
}

func changeAttrViewLayout(attrView *av.AttributeView, view *av.View, newLayout av.LayoutType) (err error) {
	if newLayout == view.LayoutType {
		return
	}

	switch newLayout {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar, av.LayoutTypeGallery, av.LayoutTypeKanban:
	default:
		return av.ErrWrongLayoutType
	}

	oldLayout := view.LayoutType
	oldFields := attributeViewFieldIDs(view)
	view.LayoutType = newLayout
	if oldLayout == av.LayoutTypeCalendar && view.Name == av.GetAttributeViewI18n(string(oldLayout)) {
		view.Name = av.GetAttributeViewI18n(string(newLayout))
	}

	switch newLayout {
	case av.LayoutTypeCalendar:
		if view.Name == av.GetAttributeViewI18n(string(oldLayout)) {
			view.Name = av.GetAttributeViewI18n("calendar")
		}
		if nil == view.Calendar {
			view.Calendar = newAttributeViewCalendarLayout(attrView, oldFields)
		}
	case av.LayoutTypeList:
		if view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("gallery") || view.Name == av.GetAttributeViewI18n("kanban") {
			view.Name = av.GetAttributeViewI18n("list")
		}
		if nil == view.List {
			view.List = newAttributeViewListLayout(attrView, oldFields)
		}
	case av.LayoutTypeTable:
		if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("gallery") || view.Name == av.GetAttributeViewI18n("kanban") {
			view.Name = av.GetAttributeViewI18n("table")
		}

		if nil != view.Table {
			break
		}

		view.Table = av.NewLayoutTable()
		for _, id := range oldFields {
			view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: id}})
		}
	case av.LayoutTypeGallery:
		if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("kanban") {
			view.Name = av.GetAttributeViewI18n("gallery")
		}

		if nil != view.Gallery {
			break
		}

		view.Gallery = av.NewLayoutGallery()
		for _, id := range oldFields {
			view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: id}})
		}
	case av.LayoutTypeKanban:
		if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("gallery") {
			view.Name = av.GetAttributeViewI18n("kanban")
		}

		if nil != view.Kanban {
			break
		}

		view.Kanban = av.NewLayoutKanban()
		for _, id := range oldFields {
			view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: id}})
		}

		if !view.IsGroupView() {
			preferredGroupKey := getKanbanPreferredGroupKey(attrView)
			group := &av.ViewGroup{Field: preferredGroupKey.ID}
			setAttributeViewGroup(attrView, view, group)
		}
	}
	return
}

func (tx *Transaction) doSetAttrViewWrapField(operation *Operation) (ret *TxErr) {
	err := setAttrViewWrapField(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewWrapField(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	allFieldWrap := operation.Data.(bool)
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		view.GetTableLayout().WrapField = allFieldWrap
		for _, col := range view.GetTableLayout().Columns {
			col.Wrap = allFieldWrap
		}
	case av.LayoutTypeGallery:
		view.Gallery.WrapField = allFieldWrap
		for _, field := range view.Gallery.CardFields {
			field.Wrap = allFieldWrap
		}
	case av.LayoutTypeKanban:
		view.Kanban.WrapField = allFieldWrap
		for _, field := range view.Kanban.Fields {
			field.Wrap = allFieldWrap
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewShowIcon(operation *Operation) (ret *TxErr) {
	err := setAttrViewShowIcon(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewShowIcon(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	base := view.GetBaseLayout()
	if nil == base {
		return
	}
	base.ShowIcon = operation.Data.(bool)

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewFitImage(operation *Operation) (ret *TxErr) {
	err := setAttrViewFitImage(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewFitImage(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.FitImage = operation.Data.(bool)

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewDisplayFieldName(operation *Operation) (ret *TxErr) {
	err := setAttrViewDisplayFieldName(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewDisplayEmptyFields(operation *Operation) (ret *TxErr) {
	err := setAttrViewDisplayEmptyFields(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewFillColBackgroundColor(operation *Operation) (ret *TxErr) {
	err := setAttrViewFillColBackgroundColor(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewDisplayFieldName(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewOperationView(attrView, operation)
	if err != nil {
		return
	}

	if cards := view.GetCardSettings(); nil != cards {
		cards.DisplayFieldName = operation.Data.(bool)
	} else if av.LayoutTypeCalendar == view.LayoutType {
		view.Calendar.Settings.DisplayFieldName = operation.Data.(bool)
	} else {
		return
	}

	err = av.SaveAttributeView(attrView)
	return
}

func setAttrViewDisplayEmptyFields(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.DisplayEmptyFields = operation.Data.(bool)

	err = av.SaveAttributeView(attrView)
	return
}

func setAttrViewFillColBackgroundColor(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	if av.LayoutTypeKanban != view.LayoutType || nil == view.Kanban {
		return
	}
	view.Kanban.FillColBackgroundColor = operation.Data.(bool)

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCardSize(operation *Operation) (ret *TxErr) {
	err := setAttrViewCardSize(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardSize(operation *Operation) (err error) {
	value, err := getAttrViewOperationNumber(operation)
	if nil != err {
		return
	}
	size := av.CardSize(value)
	if value != math.Trunc(value) || size < av.CardSizeSmall || av.CardSizeLarge < size {
		return fmt.Errorf("invalid card size preset [%v]", value)
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CardSize = size
	cards.CardWidth = av.CardWidthBySize(size)

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCardWidth(operation *Operation) (ret *TxErr) {
	if err := setAttrViewCardWidth(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardWidth(operation *Operation) (err error) {
	value, err := getAttrViewOperationNumber(operation)
	if nil != err {
		return
	}
	if math.IsNaN(value) || math.IsInf(value, 0) || value != math.Trunc(value) ||
		value < av.CardWidthMin || av.CardWidthMax < value {
		return fmt.Errorf("invalid card width [%v]", value)
	}
	width := int(value)

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}
	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CardWidth = width

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCardLayout(operation *Operation) (ret *TxErr) {
	if err := setAttrViewCardLayout(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardLayout(operation *Operation) (err error) {
	value, err := getAttrViewOperationNumber(operation)
	if nil != err {
		return
	}
	layout := av.CardLayout(value)
	if value != math.Trunc(value) || !layout.IsValid() {
		return fmt.Errorf("invalid card layout [%v]", value)
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}
	view, err := getAttrViewOperationView(attrView, operation)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return av.ErrWrongLayoutType
	}
	cards.CardLayout = layout

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColFullRow(operation *Operation) (ret *TxErr) {
	if err := setAttrViewColFullRow(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewColFullRow(operation *Operation) (err error) {
	fullRow, ok := operation.Data.(bool)
	if !ok {
		return fmt.Errorf("invalid card field full row value [%v]", operation.Data)
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}
	view, err := getAttrViewOperationView(attrView, operation)
	if err != nil {
		return
	}

	found := false
	switch view.LayoutType {
	case av.LayoutTypeGallery:
		for _, field := range view.Gallery.CardFields {
			if field.ID == operation.ID {
				field.FullRow = fullRow
				found = true
				break
			}
		}
	case av.LayoutTypeKanban:
		for _, field := range view.Kanban.Fields {
			if field.ID == operation.ID {
				field.FullRow = fullRow
				found = true
				break
			}
		}
	default:
		return av.ErrWrongLayoutType
	}
	if !found {
		return fmt.Errorf("field [%s] not found in view [%s]", operation.ID, view.ID)
	}

	err = av.SaveAttributeView(attrView)
	return
}

func getAttrViewOperationView(attrView *av.AttributeView, operation *Operation) (ret *av.View, err error) {
	if "" != operation.ViewID {
		ret = attrView.GetView(operation.ViewID)
		if nil == ret {
			err = av.ErrViewNotFound
		}
		return
	}
	return getAttrViewViewByBlockID(attrView, operation.BlockID)
}

func getAttrViewOperationNumber(operation *Operation) (ret float64, err error) {
	var ok bool
	if ret, ok = operation.Data.(float64); !ok {
		err = fmt.Errorf("invalid card configuration value [%v]", operation.Data)
	}
	return
}

func (tx *Transaction) doSetAttrViewCoverFromAssetKeyID(operation *Operation) (ret *TxErr) {
	err := setAttrViewCoverFromAssetKeyID(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCoverFromAssetKeyID(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CoverFromAssetKeyID = operation.KeyID

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCoverFrom(operation *Operation) (ret *TxErr) {
	err := setAttrViewCoverFrom(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCoverFrom(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	cards := view.GetCardSettings()
	if nil == cards {
		return
	}
	cards.CoverFrom = av.CoverFrom(operation.Data.(float64))

	err = av.SaveAttributeView(attrView)
	return
}

type setAttrViewCardCoverPositionData struct {
	Source   string                `json:"source"`
	Position *av.CardCoverPosition `json:"position"`
}

func (tx *Transaction) doSetAttrViewCardCoverPosition(operation *Operation) (ret *TxErr) {
	if err := setAttrViewCardCoverPosition(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCardCoverPosition(operation *Operation) (err error) {
	dataJSON, err := json.Marshal(operation.Data)
	if nil != err {
		return
	}
	var data setAttrViewCardCoverPositionData
	if err = json.Unmarshal(dataJSON, &data); nil != err {
		return
	}
	if !av.IsValidCardCoverSource(data.Source) {
		return fmt.Errorf("invalid card cover source [%s]", data.Source)
	}
	if nil != data.Position {
		if "" == data.Position.Image || 32*1024 < len(data.Position.Image) {
			return errors.New("invalid card cover image")
		}
		if math.IsNaN(data.Position.X) || math.IsInf(data.Position.X, 0) ||
			math.IsNaN(data.Position.Y) || math.IsInf(data.Position.Y, 0) ||
			data.Position.X < 0 || 100 < data.Position.X || data.Position.Y < 0 || 100 < data.Position.Y {
			return fmt.Errorf("invalid card cover position [%v, %v]", data.Position.X, data.Position.Y)
		}
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if nil != err {
		return
	}
	if nil == attrView.GetBlockValue(operation.RowID) {
		return fmt.Errorf("attribute view item [%s] not found", operation.RowID)
	}
	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if nil != err {
		return
	}
	if av.LayoutTypeGallery != view.LayoutType && av.LayoutTypeKanban != view.LayoutType {
		return av.ErrWrongLayoutType
	}
	var source string
	if av.LayoutTypeGallery == view.LayoutType {
		source = av.CardCoverSource(view.Gallery.CoverFrom, view.Gallery.CoverFromAssetKeyID)
	} else {
		source = av.CardCoverSource(view.Kanban.CoverFrom, view.Kanban.CoverFromAssetKeyID)
	}
	if data.Source != source {
		return fmt.Errorf("card cover source [%s] does not match view [%s]", data.Source, view.ID)
	}
	if keyID := av.CardCoverSourceAssetKeyID(data.Source); "" != keyID {
		key, getErr := attrView.GetKey(keyID)
		if nil != getErr || nil == key || av.KeyTypeMAsset != key.Type {
			return fmt.Errorf("card cover asset field [%s] not found", keyID)
		}
	}

	attrView.SetCardCoverPosition(operation.RowID, data.Source, data.Position)
	err = av.SaveAttributeView(attrView)
	return
}

func AppendAttributeViewDetachedBlocksWithValues(avID string, blocksValues [][]*av.Value) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	now := util.CurrentTimeMillis()
	var blockIDs []string
	for _, blockValues := range blocksValues {
		blockID := ast.NewNodeID()
		if v := blockValues[0]; "" != v.BlockID {
			blockID = v.BlockID
		}
		blockIDs = append(blockIDs, blockID)
		for _, v := range blockValues {
			keyValues, _ := attrView.GetKeyValues(v.KeyID)
			if nil == keyValues {
				err = fmt.Errorf("key [%s] not found", v.KeyID)
				return
			}

			v.ID = ast.NewNodeID()
			v.BlockID = blockID
			v.Type = keyValues.Key.Type
			if av.KeyTypeBlock == v.Type {
				v.Block.Created = now
				v.Block.Updated = now
				v.Block.ID = ""
				v.Block.RefSubtype = ""
			}
			v.IsDetached = true
			v.CreatedAt = now
			v.UpdatedAt = now
			v.IsRenderAutoFill = false
			keyValues.Values = append(keyValues.Values, v)

			if av.KeyTypeSelect == v.Type || av.KeyTypeMSelect == v.Type {
				// 保存选项 https://github.com/siyuan-note/siyuan/issues/12475
				key, _ := attrView.GetKey(v.KeyID)
				if nil != key && 0 < len(v.MSelect) {
					for _, valOpt := range v.MSelect {
						if opt := key.GetOption(valOpt.Content); nil == opt {
							// 不存在的选项新建保存
							opt = &av.SelectOption{Name: valOpt.Content, Color: attrView.FilterColorValue(valOpt.Color)}
							key.Options = append(key.Options, opt)
						} else {
							// 已经存在的选项颜色需要保持不变
							valOpt.Color = opt.Color
						}
					}
				}
			}
		}
	}

	for _, v := range attrView.Views {
		for _, addingBlockID := range blockIDs {
			v.ItemIDs = append(v.ItemIDs, addingBlockID)
		}
	}

	regenAttrViewGroups(attrView)
	if err = av.SaveAttributeView(attrView); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}

	ReloadAttrView(avID)
	return
}

// DuplicateAttributeViewRow 创建源行的纯文本副本,复制除主键、Rollup、Created、Updated 外的所有字段值,
// 双向关联同步更新目标属性视图的反向关联列。新行 ID 由调用方(前端)生成并通过 newRowID 传入,
// 副本插入到 previousItemID(通常为最后选中的条目)之后。
func DuplicateAttributeViewRow(tx *Transaction, avID, previousItemID, srcRowID, newRowID string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	blockKeyValues := attrView.GetBlockKeyValues()
	if nil == blockKeyValues {
		err = fmt.Errorf("attribute view [%s] has no block key", avID)
		return
	}

	srcBlockVal := blockKeyValues.GetValue(srcRowID)
	if nil == srcBlockVal {
		err = fmt.Errorf("source row [%s] not found in attribute view [%s]", srcRowID, avID)
		return
	}

	if "" == newRowID {
		newRowID = ast.NewNodeID()
	}

	now := util.CurrentTimeMillis()

	// 创建副本的主键值,强制为纯文本(非绑定块)
	blockContent := ""
	if nil != srcBlockVal.Block {
		blockContent = srcBlockVal.Block.Content
	}
	newBlockVal := &av.Value{
		ID:         ast.NewNodeID(),
		KeyID:      blockKeyValues.Key.ID,
		BlockID:    newRowID,
		Type:       av.KeyTypeBlock,
		IsDetached: true,
		CreatedAt:  now,
		UpdatedAt:  now,
		Block:      &av.ValueBlock{Content: blockContent, Created: now, Updated: now},
	}
	blockKeyValues.Values = append(blockKeyValues.Values, newBlockVal)

	// 收集双向关联字段,循环结束后统一处理,避免跨属性视图重复 parse/save
	type pendingTwoWay struct {
		key *av.Key
		val *av.Value
	}
	var pendingTwoWays []*pendingTwoWay

	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeBlock == keyValues.Key.Type {
			continue // 主键已处理
		}
		if av.HasKeyGroup(keyValues.Key.Type, av.KeyGroupSkipRowCopy) {
			continue // 汇总/创建时间/更新时间字段在渲染或自动生成时处理,不复制
		}

		srcVal := keyValues.GetValue(srcRowID)
		if nil == srcVal {
			continue // 源行该字段无值,跳过
		}

		newVal := srcVal.Clone()
		if nil == newVal {
			continue
		}
		newVal.ID = ast.NewNodeID()
		newVal.BlockID = newRowID
		newVal.IsDetached = false
		newVal.CreatedAt = now
		newVal.UpdatedAt = now
		newVal.IsRenderAutoFill = false
		if nil != newVal.Relation {
			newVal.Relation.Contents = nil // 清除渲染期数据
		}

		// 单选/多选选项同步,保证目标属性视图存在对应选项 https://github.com/siyuan-note/siyuan/issues/12475
		if av.KeyTypeSelect == newVal.Type || av.KeyTypeMSelect == newVal.Type {
			if 0 < len(newVal.MSelect) {
				for _, valOpt := range newVal.MSelect {
					if opt := keyValues.Key.GetOption(valOpt.Content); nil == opt {
						opt = &av.SelectOption{Name: valOpt.Content, Color: attrView.FilterColorValue(valOpt.Color)}
						keyValues.Key.Options = append(keyValues.Key.Options, opt)
					} else {
						valOpt.Color = opt.Color
					}
				}
			}
		}

		keyValues.Values = append(keyValues.Values, newVal)

		// 双向关联值收集,稍后统一更新目标属性视图的反向列
		if av.KeyTypeRelation == newVal.Type && nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay && 0 < len(newVal.Relation.BlockIDs) {
			pendingTwoWays = append(pendingTwoWays, &pendingTwoWay{key: keyValues.Key, val: newVal})
		}
	}

	// 在所有视图上添加新行,插入位置为 previousItemID 之后
	for _, v := range attrView.Views {
		addRowToViewItems(v, newRowID, previousItemID)
	}
	attrView.CopyCardCoverPositions(srcRowID, newRowID)

	// 统一处理双向关联:按目标属性视图聚合,每个目标只 parse/save 一次
	twoWayByDestAv := map[string][]*pendingTwoWay{}
	for _, p := range pendingTwoWays {
		destAvID := p.key.Relation.AvID
		twoWayByDestAv[destAvID] = append(twoWayByDestAv[destAvID], p)
	}
	for destAvID, items := range twoWayByDestAv {
		if destAvID == attrView.ID {
			// 自关联,直接在内存对象上更新,随主属性视图一起保存
			for _, p := range items {
				updateTwoWayRelationDestAttrView(attrView, p.key, p.val, 1, nil)
			}
			continue
		}

		destAv, parseErr := av.ParseAttributeView(destAvID)
		if nil != parseErr || nil == destAv {
			logging.LogWarnf("parse dest attribute view [%s] failed: %s", destAvID, parseErr)
			continue
		}
		for _, p := range items {
			// 复用反向更新逻辑,传入 mode=1(增加)、oldBlockIDs 为空
			updateTwoWayRelationDestAttrView(destAv, p.key, p.val, 1, nil)
		}
		regenAttrViewGroups(destAv)
		if saveErr := av.SaveAttributeView(destAv); nil != saveErr {
			logging.LogErrorf("save dest attribute view [%s] failed: %s", destAvID, saveErr)
		}
		if nil != tx {
			tx.relatedAvIDs = append(tx.relatedAvIDs, destAvID)
		}
		ReloadAttrView(destAvID)
	}

	regenAttrViewGroups(attrView)
	if err = av.SaveAttributeView(attrView); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}
	return
}

// addRowToViewItems 将 newRowID 插入到视图及其所有分组的项目列表中,位置在 previousItemID 之后;
// 若 previousItemID 为空或未找到,则追加到末尾。
func addRowToViewItems(view *av.View, newRowID, previousItemID string) {
	view.ItemIDs = insertItemAfter(view.ItemIDs, newRowID, previousItemID)
	for _, g := range view.Groups {
		g.GroupItemIDs = insertItemAfter(g.GroupItemIDs, newRowID, previousItemID)
	}
}

// insertItemAfter 将 item 插入到 items 中 previousItemID 之后;若 previousItemID 为空或未找到,则追加到末尾。
func insertItemAfter(items []string, item, previousItemID string) []string {
	if "" != previousItemID {
		for i, id := range items {
			if id == previousItemID {
				items = append(items[:i+1], append([]string{item}, items[i+1:]...)...)
				return items
			}
		}
	}
	return append(items, item)
}

func DuplicateDatabaseBlock(avID string) (newAvID, newBlockID string, err error) {
	// 加密笔记本的 AV 定义在笔记本级目录,通过 fallback 查找实际路径
	oldAvPath, avBoxID := av.FindAttributeViewPath(avID)
	if oldAvPath == "" {
		oldAvPath = av.GetAttributeViewDataPath(avID)
	}
	newAvID, newBlockID = ast.NewNodeID(), ast.NewNodeID()

	oldAv, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	data, err := filelock.ReadFile(oldAvPath)
	if err != nil {
		logging.LogErrorf("read attribute view [%s] failed: %s", avID, err)
		return
	}

	// 加密笔记本的 AV 是密文,需先解密再处理(av.DecryptAVData 内部按 box 加密/已解锁路由)
	if avBoxID != "" && IsEncryptedBox(avBoxID) {
		var decErr error
		data, decErr = av.DecryptAVData(avBoxID, avID, data)
		if decErr != nil {
			logging.LogErrorf("decrypt attribute view [%s] failed: %s", avID, decErr)
			err = decErr
			return
		}
	}

	data = bytes.ReplaceAll(data, []byte(avID), []byte(newAvID))
	av.UpsertBlockRel(newAvID, newBlockID)

	newAv := &av.AttributeView{}
	if err = gulu.JSON.UnmarshalJSON(data, newAv); err != nil {
		logging.LogErrorf("unmarshal attribute view [%s] failed: %s", newAvID, err)
		return
	}

	if "" != newAv.Name {
		newAv.Name = oldAv.Name + " (Duplicated " + time.Now().Format("2006-01-02 15:04:05") + ")"
	}

	for _, keyValues := range newAv.KeyValues {
		if nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay {
			// 断开双向关联
			keyValues.Key.Relation.IsTwoWay = false
			keyValues.Key.Relation.BackKeyID = ""
		}
	}

	data, err = gulu.JSON.MarshalJSON(newAv)
	if err != nil {
		logging.LogErrorf("marshal attribute view [%s] failed: %s", newAvID, err)
		return
	}

	// 加密笔记本的新 AV 定义也存笔记本级目录,且需 avKey 加密
	newAvPath := filepath.Join(util.DataDir, "storage", "av", newAvID+".json")
	if avBoxID != "" {
		newAvPath = filepath.Join(util.DataDir, avBoxID, "storage", "av", newAvID+".json")
		var encErr error
		data, encErr = av.EncryptAVData(avBoxID, newAvID, data)
		if encErr != nil {
			logging.LogErrorf("encrypt attribute view [%s] failed: %s", newAvID, encErr)
			err = encErr
			return
		}
		av.SetAVBoxID(newAvID, avBoxID)
	}
	if err = filelock.WriteFile(newAvPath, data); err != nil {
		logging.LogErrorf("write attribute view [%s] failed: %s", newAvID, err)
		return
	}

	updateBoundBlockAvsAttribute([]string{newAvID}, avBoxID)
	return
}

func GetAttributeViewKeysByID(avID string, keyIDs ...string) (ret []*av.Key) {
	ret = []*av.Key{}

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	if 1 > len(keyIDs) {
		for _, keyValues := range attrView.KeyValues {
			key := keyValues.Key
			ret = append(ret, key)
		}
		return
	}

	for _, keyValues := range attrView.KeyValues {
		key := keyValues.Key
		for _, keyID := range keyIDs {
			if key.ID == keyID {
				ret = append(ret, key)
			}
		}
	}
	return ret
}

func SetDatabaseBlockView(blockID, avID, viewID string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if nil != err {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	view := attrView.GetView(viewID)
	if nil == view {
		err = av.ErrViewNotFound
		logging.LogErrorf("view [%s] not found in attribute view [%s]", viewID, avID)
		return
	}

	node, tree, err := getNodeByBlockID(nil, blockID)
	if err != nil {
		return
	}

	node.AttributeViewType = string(view.LayoutType)
	attrs := parse.IAL2Map(node.KramdownIAL)
	attrs[av.NodeAttrView] = viewID
	err = setNodeAttrs(node, tree, attrs)
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", blockID, err)
		return
	}
	return
}

// normalizeDatabaseBlockView 使数据库载体绑定的视图和布局保持一致。
func normalizeDatabaseBlockView(node *ast.Node, attrView *av.AttributeView) (changed bool) {
	if nil == node || nil == attrView || ast.NodeAttributeView != node.Type {
		return
	}

	viewID := node.IALAttr(av.NodeAttrView)
	var view *av.View
	if "" != viewID {
		view = attrView.GetView(viewID)
	}
	if nil == view {
		view, _ = attrView.GetFirstView()
	}
	if nil == view {
		return
	}

	layout := string(view.LayoutType)
	if layout != node.AttributeViewType {
		node.AttributeViewType = layout
		changed = true
	}
	if view.ID != viewID {
		node.SetIALAttr(av.NodeAttrView, view.ID)
		changed = true
	}
	return
}

func normalizeDatabaseBlockViews(node *ast.Node, boxID string, attrViews map[string]*av.AttributeView) (changed bool) {
	ast.Walk(node, func(n *ast.Node, entering bool) ast.WalkStatus {
		if !entering || ast.NodeAttributeView != n.Type {
			return ast.WalkContinue
		}

		attrView := cachedAttributeViewForBox(n.AttributeViewID, boxID, attrViews)
		if normalizeDatabaseBlockView(n, attrView) {
			changed = true
		}
		return ast.WalkContinue
	})
	return
}

func cachedAttributeViewForBox(avID, boxID string, attrViews map[string]*av.AttributeView) (ret *av.AttributeView) {
	cacheKey := boxID + "\x00" + avID
	if ret, ok := attrViews[cacheKey]; ok {
		return ret
	}

	var err error
	if IsEncryptedBox(boxID) {
		ret, err = av.ParseAttributeViewInBox(avID, boxID)
	} else {
		ret, err = av.ParseAttributeView(avID)
	}
	if nil != err {
		ret = nil
	}
	attrViews[cacheKey] = ret
	return
}

func GetAttributeViewPrimaryKeyValues(avID, keyword string, blockIDs []string, page, pageSize int) (attributeViewName string, databaseBlockIDs []string, keyValues *av.KeyValues, total int, err error) {
	waitForSyncingStorages()

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}
	if normalizeAttributeViewBlockRefSubtypes(attrView) {
		if saveErr := av.SaveAttributeView(attrView); nil != saveErr {
			logging.LogWarnf("save attribute view [%s] block reference subtypes failed: %s", avID, saveErr)
		}
	}
	attributeViewName = getAttrViewName(attrView)

	databaseBlockIDs = treenode.GetMirrorAttrViewBlockIDs(avID)

	keyValues = attrView.GetBlockKeyValues()
	if nil == keyValues {
		keyValues = &av.KeyValues{}
		return
	}
	var values []*av.Value
	valuesByBlockID := map[string]*av.Value{}
	for _, kv := range keyValues.Values {
		if !kv.IsDetached && !treenode.ExistBlockTree(kv.Block.ID) {
			continue
		}

		valuesByBlockID[kv.BlockID] = kv
		if strings.Contains(strings.ToLower(kv.String(true)), strings.ToLower(keyword)) {
			values = append(values, kv)
		}
	}
	if 0 < len(blockIDs) {
		values = nil
		for _, blockID := range blockIDs {
			if value := valuesByBlockID[blockID]; nil != value {
				values = append(values, value)
			}
		}
		keyValues.Values = values
		total = len(values)
		return
	}
	keyValues.Values = values

	sort.Slice(keyValues.Values, func(i, j int) bool {
		if keyValues.Values[i].Block.Updated == keyValues.Values[j].Block.Updated {
			return keyValues.Values[i].BlockID > keyValues.Values[j].BlockID
		}
		return keyValues.Values[i].Block.Updated > keyValues.Values[j].Block.Updated
	})

	total = len(keyValues.Values)
	if 1 > page {
		page = 1
	}
	if 1 > pageSize {
		pageSize = 16
	}
	start := min(len(keyValues.Values), (page-1)*pageSize)
	end := min(len(keyValues.Values), start+pageSize)
	keyValues.Values = keyValues.Values[start:end]
	return
}

func GetAttributeViewRelationCandidates(srcAvID, relationKeyID, keyword string, selectedBlockIDs []string, page, pageSize int, candidateSort *av.ViewSort, blockIDs ...string) (
	attributeViewName string, databaseBlockIDs []string, customColors []*av.AttributeViewCustomColor,
	columns []*av.TableColumn, selectedRows, rows []*av.TableRow,
	total int, err error,
) {
	waitForSyncingStorages()

	var srcAttrView *av.AttributeView
	if len(blockIDs) > 0 && blockIDs[0] != "" {
		srcAttrView, err = avParseView(srcAvID, blockIDs[0])
	} else {
		srcAttrView, err = av.ParseAttributeView(srcAvID)
	}
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", srcAvID, err)
		return
	}
	var relationKey *av.Key
	attrView := srcAttrView
	if "" != relationKeyID {
		relationKey, _ = srcAttrView.GetKey(relationKeyID)
		if nil == relationKey || av.KeyTypeRelation != relationKey.Type || nil == relationKey.Relation {
			err = av.ErrKeyNotFound
			return
		}
		if relationKey.Relation.AvID != srcAvID {
			if len(blockIDs) > 0 && blockIDs[0] != "" {
				_, boxID := av.FindAttributeViewPath(srcAvID)
				attrView, err = av.ParseAttributeViewInBox(relationKey.Relation.AvID, boxID)
			} else {
				attrView, err = av.ParseAttributeView(relationKey.Relation.AvID)
			}
		}
		if err != nil {
			logging.LogErrorf("parse attribute view [%s] failed: %s", relationKey.Relation.AvID, err)
			return
		}
	}
	attributeViewName = getAttrViewName(attrView)
	databaseBlockIDs = treenode.GetMirrorAttrViewBlockIDs(attrView.ID)
	customColors = attrView.Palette()

	table := renderAttributeViewRelationCandidates(attrView)
	if nil == table {
		err = av.ErrViewNotFound
		return
	}
	columns = table.Columns
	if candidateSort != nil {
		if candidateSort.Order != av.SortOrderAsc && candidateSort.Order != av.SortOrderDesc {
			err = errors.New("invalid relation candidate sort order")
			return
		}
		found := false
		for _, column := range columns {
			if column.ID == candidateSort.Column {
				found = true
				break
			}
		}
		if !found {
			err = av.ErrKeyNotFound
			return
		}
	}

	rowsByID := map[string]*av.TableRow{}
	for _, row := range table.Rows {
		rowsByID[row.ID] = row
	}
	for _, blockID := range selectedBlockIDs {
		if row := rowsByID[blockID]; nil != row {
			selectedRows = append(selectedRows, row)
		}
	}
	if nil == selectedRows {
		selectedRows = []*av.TableRow{}
	}

	if nil != relationKey && hasAttrViewFilterConditions(relationKey.Relation.CandidateFilters) {
		validColumns := map[string]bool{}
		for _, keyValues := range attrView.KeyValues {
			if nil != keyValues && nil != keyValues.Key {
				validColumns[keyValues.Key.ID] = true
			}
		}
		table.Filters, _ = av.PruneInvalidColumnFilters(
			av.CloneFilters(relationKey.Relation.CandidateFilters), validColumns)
		cachedAttrViews := map[string]*av.AttributeView{attrView.ID: attrView}
		av.Filter(table, attrView, sql.GetFurtherCollections(attrView, cachedAttrViews), cachedAttrViews)
	}

	rows, total = filterSortPageRelationCandidates(table, attrView, keyword, page, pageSize, candidateSort)
	return
}

func filterSortPageRelationCandidates(table *av.Table, attrView *av.AttributeView, keyword string, page, pageSize int, candidateSort *av.ViewSort) (
	rows []*av.TableRow, total int,
) {
	untitled := ""
	if strings.TrimSpace(keyword) != "" {
		untitled = util.I18nTerm(util.Lang, "untitled")
	}
	for _, row := range table.Rows {
		if relationCandidateMatches(row, keyword, untitled, table.Columns...) {
			rows = append(rows, row)
		}
	}
	sort.Slice(rows, func(i, j int) bool {
		iCreated := relationCandidateCreatedAt(rows[i])
		jCreated := relationCandidateCreatedAt(rows[j])
		if iCreated == jCreated {
			return rows[i].ID > rows[j].ID
		}
		return iCreated > jCreated
	})
	if candidateSort != nil {
		table.Rows = rows
		table.Sorts = []*av.ViewSort{candidateSort}
		av.Sort(table, attrView)
		rows = table.Rows
	}

	total = len(rows)
	if 1 > page {
		page = 1
	}
	if 1 > pageSize {
		pageSize = 16
	}
	start := min(len(rows), (page-1)*pageSize)
	end := min(len(rows), start+pageSize)
	rows = rows[start:end]
	if nil == rows {
		rows = []*av.TableRow{}
	}
	return
}

func renderAttributeViewRelationCandidates(attrView *av.AttributeView) (ret *av.Table) {
	if nil == attrView {
		return
	}

	keysByID := map[string]*av.Key{}
	for _, keyValues := range attrView.KeyValues {
		if nil != keyValues && nil != keyValues.Key {
			keysByID[keyValues.Key.ID] = keyValues.Key
		}
	}

	var keys []*av.Key
	added := map[string]bool{}
	if blockKey := attrView.GetBlockKey(); nil != blockKey {
		keys = append(keys, blockKey)
		added[blockKey.ID] = true
	}
	appendKey := func(key *av.Key) {
		if nil == key || added[key.ID] || av.KeyTypeLineNumber == key.Type {
			return
		}
		keys = append(keys, key)
		added[key.ID] = true
	}
	for _, keyID := range attrView.KeyIDs {
		appendKey(keysByID[keyID])
	}
	for _, keyValues := range attrView.KeyValues {
		if nil != keyValues {
			appendKey(keyValues.Key)
		}
	}

	view := &av.View{
		ID:         ast.NewNodeID(),
		Filters:    []*av.ViewFilter{},
		Sorts:      []*av.ViewSort{},
		PageSize:   av.ViewDefaultPageSize,
		LayoutType: av.LayoutTypeTable,
		Table:      av.NewLayoutTable(),
	}
	for _, key := range keys {
		view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{
			BaseField: &av.BaseField{ID: key.ID},
		})
	}

	viewable := sql.RenderView(attrView, view, "", false)
	ret, _ = viewable.(*av.Table)
	return
}

func relationCandidateMatches(row *av.TableRow, keyword, untitled string, columns ...*av.TableColumn) bool {
	keywords := strings.Fields(strings.TrimSpace(keyword))
	if 1 > len(keywords) {
		return true
	}
	for _, cell := range row.Cells {
		if nil == cell || nil == cell.Value {
			continue
		}
		content := cell.Value.String(true)
		// 仅匹配主键实际显示的未命名占位文字,不改变字段内容或显示模板的语义。
		if cell.ValueType == av.KeyTypeBlock && (cell.Value.Block == nil || cell.Value.Block.Content == "") &&
			!cell.Value.HasRenderTemplate && cell.Value.RenderedContent == "" {
			hasTemplate := false
			for _, column := range columns {
				if column.ID == cell.Value.KeyID && strings.TrimSpace(column.RenderTemplate) != "" {
					hasTemplate = true
					break
				}
			}
			if !hasTemplate {
				content = untitled
			}
		}
		allKeywordsHit := true
		for _, currentKeyword := range keywords {
			if util.SearchCaseSensitive.Load() {
				if !strings.Contains(content, currentKeyword) {
					allKeywordsHit = false
					break
				}
			} else if !strings.Contains(strings.ToLower(content), strings.ToLower(currentKeyword)) {
				allKeywordsHit = false
				break
			}
		}
		if allKeywordsHit {
			return true
		}
	}
	return false
}

func relationCandidateCreatedAt(row *av.TableRow) int64 {
	if nil == row {
		return 0
	}
	blockValue := row.GetBlockValue()
	if nil == blockValue {
		return 0
	}
	if 0 < blockValue.CreatedAt {
		return blockValue.CreatedAt
	}
	if nil != blockValue.Block {
		return blockValue.Block.Created
	}
	return 0
}

func GetAttributeViewFilterSort(avID, blockID string) (filters []*av.ViewFilter, sorts []*av.ViewSort) {
	waitForSyncingStorages()

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if nil == view || err != nil {
		logging.LogErrorf("get current view failed: %s", err)
		return
	}

	filters = view.Filters
	sorts = view.Sorts
	if 1 > len(filters) {
		filters = []*av.ViewFilter{}
	}
	if 1 > len(sorts) {
		sorts = []*av.ViewSort{}
	}
	return
}

func SearchAttributeViewRollupDestKeys(avID, keyword string) (ret []*av.Key) {
	waitForSyncingStorages()

	ret = []*av.Key{}
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeRollup != keyValues.Key.Type && av.KeyTypeLineNumber != keyValues.Key.Type {
			if strings.Contains(strings.ToLower(keyValues.Key.Name), strings.ToLower(keyword)) {
				ret = append(ret, keyValues.Key)
			}
		}
	}
	return
}

func SearchAttributeViewRelationKey(avID, keyword string) (ret []*av.Key) {
	waitForSyncingStorages()

	ret = []*av.Key{}
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeRelation == keyValues.Key.Type && nil != keyValues.Key.Relation {
			if strings.Contains(strings.ToLower(keyValues.Key.Name), strings.ToLower(keyword)) {
				ret = append(ret, keyValues.Key)
			}
		}
	}
	return
}

func GetAttributeView(avID string) (ret *av.AttributeView) {
	waitForSyncingStorages()

	ret, _ = av.ParseAttributeView(avID)
	return
}

// AttributeViewData 是面向外部接口的兼容数据,不参与数据库文件持久化。
type AttributeViewData struct {
	Spec               int                                         `json:"spec"`
	ID                 string                                      `json:"id"`
	Name               string                                      `json:"name"`
	CustomColors       []*av.AttributeViewCustomColor              `json:"customColors"`
	KeyValues          []*av.KeyValues                             `json:"keyValues"`
	KeyIDs             []string                                    `json:"keyIDs"`
	ViewID             string                                      `json:"viewID"`
	Views              []*av.View                                  `json:"views"`
	NewItemTemplates   []*av.NewItemTemplate                       `json:"newItemTemplates,omitempty"`
	DefaultTemplateID  string                                      `json:"defaultTemplateID,omitempty"`
	Automations        *av.AutomationConfig                        `json:"automations,omitempty"`
	CardCoverPositions map[string]map[string]*av.CardCoverPosition `json:"cardCoverPositions,omitempty"`
}

func NewAttributeViewData(attrView *av.AttributeView) (ret *AttributeViewData) {
	if nil == attrView {
		return
	}
	ret = &AttributeViewData{
		Spec: attrView.Spec, ID: attrView.ID, Name: attrView.Name, KeyValues: attrView.KeyValues, KeyIDs: attrView.KeyIDs,
		Views: attrView.Views, NewItemTemplates: attrView.NewItemTemplates, DefaultTemplateID: attrView.DefaultTemplateID,
		CardCoverPositions: attrView.CardCoverPositions, CustomColors: attrView.Palette(),
		Automations: attrView.Automations,
	}
	if view, _ := attrView.GetFirstView(); nil != view {
		ret.ViewID = view.ID
	}
	return
}

type AttributeViewFieldView struct {
	ID     string        `json:"id"`
	Icon   string        `json:"icon"`
	Name   string        `json:"name"`
	Type   av.LayoutType `json:"type"`
	Hidden bool          `json:"hidden"`
}

func GetAttributeViewFieldViews(avID, keyID string) (ret []*AttributeViewFieldView, err error) {
	waitForSyncingStorages()

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	for _, view := range attrView.Views {
		field := getAttributeViewField(view, keyID)
		if nil == field {
			err = fmt.Errorf("field [%s] not found in view [%s]", keyID, view.ID)
			return
		}
		ret = append(ret, &AttributeViewFieldView{
			ID:     view.ID,
			Icon:   view.Icon,
			Name:   view.Name,
			Type:   view.LayoutType,
			Hidden: field.Hidden,
		})
	}
	return
}

type AvSearchResult struct {
	AvID       string            `json:"avID"`
	AvName     string            `json:"avName"`
	ViewName   string            `json:"viewName"`
	ViewID     string            `json:"viewID"`
	ViewLayout av.LayoutType     `json:"viewLayout"`
	BlockID    string            `json:"blockID"`
	HPath      string            `json:"hPath"`
	Matched    bool              `json:"matched,omitempty"`
	Children   []*AvSearchResult `json:"children,omitempty"`
}

type AvSearchTempResult struct {
	AvID           string
	AvName         string
	AvUpdated      int64
	Score          float64
	Matched        bool
	SearchInfo     *av.AttributeViewSearchInfo
	MatchedViewIDs map[string]bool
}

type SearchAttributeViewOptions struct {
	Keyword            string
	ExcludeAvIDs       []string
	CurrentAvID        string
	CurrentBlockID     string
	IncludeViewMatches bool
}

type attributeViewSearchCacheWarmup struct {
	signature uint64
	cancel    context.CancelFunc
	running   bool
}

var attributeViewSearchCacheWarmups = struct {
	sync.Mutex
	states map[string]*attributeViewSearchCacheWarmup
}{states: map[string]*attributeViewSearchCacheWarmup{}}

var attributeViewSearchCacheWarmupDelay = 500 * time.Millisecond
var loadAttributeViewSearchInfo = av.GetAttributeViewSearchInfoInBox

const attributeViewSearchCacheWarmupHashOffset = uint64(1469598103934665603)
const attributeViewSearchCacheWarmupHashPrime = uint64(1099511628211)

func warmAttributeViewSearchCache(boxID string, avIDs []string, signature uint64) {
	if len(avIDs) == 0 {
		return
	}

	attributeViewSearchCacheWarmups.Lock()
	if state := attributeViewSearchCacheWarmups.states[boxID]; state != nil && state.signature == signature {
		attributeViewSearchCacheWarmups.Unlock()
		return
	}
	if state := attributeViewSearchCacheWarmups.states[boxID]; state != nil && state.cancel != nil {
		state.cancel()
	}
	ctx, cancel := context.WithCancel(context.Background())
	state := &attributeViewSearchCacheWarmup{signature: signature, cancel: cancel, running: true}
	attributeViewSearchCacheWarmups.states[boxID] = state
	attributeViewSearchCacheWarmups.Unlock()

	ids := slices.Clone(avIDs)
	delay := attributeViewSearchCacheWarmupDelay
	loader := loadAttributeViewSearchInfo
	go func() {
		completed := false
		defer func() {
			attributeViewSearchCacheWarmups.Lock()
			defer attributeViewSearchCacheWarmups.Unlock()
			if attributeViewSearchCacheWarmups.states[boxID] != state {
				return
			}
			if completed {
				state.cancel = nil
				state.running = false
			} else {
				delete(attributeViewSearchCacheWarmups.states, boxID)
			}
		}()

		timer := time.NewTimer(delay)
		defer timer.Stop()
		select {
		case <-ctx.Done():
			return
		case <-timer.C:
		}

		for _, avID := range ids {
			select {
			case <-ctx.Done():
				return
			default:
			}
			if isSyncingStorages() {
				return
			}
			_, _ = loader(avID, boxID)
		}
		completed = true
	}()
}

func stopAttributeViewSearchCacheWarmup(boxID string) {
	attributeViewSearchCacheWarmups.Lock()
	defer attributeViewSearchCacheWarmups.Unlock()
	state := attributeViewSearchCacheWarmups.states[boxID]
	if state == nil || !state.running {
		return
	}
	state.cancel()
	delete(attributeViewSearchCacheWarmups.states, boxID)
}

func updateAttributeViewSearchCacheWarmupSignature(signature uint64, avID string, info os.FileInfo) uint64 {
	for i := 0; i < len(avID); i++ {
		signature ^= uint64(avID[i])
		signature *= attributeViewSearchCacheWarmupHashPrime
	}
	if info != nil {
		signature ^= uint64(info.ModTime().UnixNano())
		signature *= attributeViewSearchCacheWarmupHashPrime
		signature ^= uint64(info.Size())
		signature *= attributeViewSearchCacheWarmupHashPrime
	}
	return signature
}

func matchAttributeViewSearchName(name string, keywords []string) (score float64, hit bool) {
	if name == "" || len(keywords) == 0 {
		return
	}

	lowerName := strings.ToLower(name)
	hit = true
	for _, keyword := range keywords {
		lowerKeyword := strings.ToLower(keyword)
		if !strings.Contains(lowerName, lowerKeyword) {
			return 0, false
		}
		score += smetrics.JaroWinkler(name, keyword, 0.7, 4)
	}
	return
}

func sortAndLimitAttributeViewSearchResults(results []*AvSearchTempResult, keyword string) []*AvSearchTempResult {
	if keyword == "" {
		sort.Slice(results, func(i, j int) bool { return results[i].AvUpdated > results[j].AvUpdated })
	} else {
		sort.SliceStable(results, func(i, j int) bool {
			if results[i].Score == results[j].Score {
				return results[i].AvUpdated > results[j].AvUpdated
			}
			return results[i].Score > results[j].Score
		})
	}
	if 12 < len(results) {
		return results[:12]
	}
	return results
}

func SearchAttributeView(keyword string, excludeAvIDs []string, currentAvID, currentBlockID string) []*AvSearchResult {
	return SearchAttributeViewWithOptions(SearchAttributeViewOptions{
		Keyword:        keyword,
		ExcludeAvIDs:   excludeAvIDs,
		CurrentAvID:    currentAvID,
		CurrentBlockID: currentBlockID,
	})
}

func SearchAttributeViewWithOptions(options SearchAttributeViewOptions) (ret []*AvSearchResult) {
	searchStart := time.Now()
	var waitSyncElapsed, readDirElapsed, getBlockRelsElapsed, scanElapsed, readNameElapsed time.Duration
	var readFileInfoElapsed, sortElapsed, resolveElapsed, loadTreeElapsed, findNodeElapsed time.Duration
	var readSearchInfoElapsed, resolveHPathElapsed time.Duration
	var directoryEntryCount, validFileCount, eligibleFileCount, matchedCount int
	var readNameCount, loadTreeCount, findNodeCount, readSearchInfoCount, resolveHPathCount int
	var eligibleFileSize int64
	defer func() {
		totalElapsed := time.Since(searchStart)
		if totalElapsed < 500*time.Millisecond {
			return
		}
		logging.LogInfof("search attribute views [total=%dms, waitSync=%dms, readDir=%dms, getBlockRels=%dms, scan=%dms, readNames=%dms, readFileInfo=%dms, sort=%dms, resolve=%dms, loadTrees=%dms, findNodes=%dms, readSearchInfo=%dms, resolveHPaths=%dms, entries=%d, validFiles=%d, eligibleFiles=%d, matched=%d, results=%d, readNameCount=%d, loadTreeCount=%d, findNodeCount=%d, readSearchInfoCount=%d, resolveHPathCount=%d, eligibleSizeBytes=%d, keywordEmpty=%t, includeViewMatches=%t]",
			totalElapsed.Milliseconds(), waitSyncElapsed.Milliseconds(), readDirElapsed.Milliseconds(),
			getBlockRelsElapsed.Milliseconds(), scanElapsed.Milliseconds(), readNameElapsed.Milliseconds(),
			readFileInfoElapsed.Milliseconds(), sortElapsed.Milliseconds(), resolveElapsed.Milliseconds(),
			loadTreeElapsed.Milliseconds(), findNodeElapsed.Milliseconds(), readSearchInfoElapsed.Milliseconds(),
			resolveHPathElapsed.Milliseconds(), directoryEntryCount, validFileCount, eligibleFileCount, matchedCount,
			len(ret), readNameCount, loadTreeCount, findNodeCount, readSearchInfoCount, resolveHPathCount,
			eligibleFileSize, strings.TrimSpace(options.Keyword) == "", options.IncludeViewMatches)
	}()

	waitSyncStart := time.Now()
	waitForSyncingStorages()
	waitSyncElapsed = time.Since(waitSyncStart)

	ret = []*AvSearchResult{}
	keyword := strings.TrimSpace(options.Keyword)
	keywords := strings.Fields(keyword)

	var avSearchTmpResults []*AvSearchTempResult
	var warmupAvIDs []string
	warmupSignature := attributeViewSearchCacheWarmupHashOffset
	warmupSignature ^= cache.GetAVCacheGeneration()
	warmupSignature *= attributeViewSearchCacheWarmupHashPrime
	boxID := ""
	if options.CurrentBlockID != "" {
		if bt := treenode.GetBlockTree(options.CurrentBlockID); nil != bt && IsEncryptedBox(bt.BoxID) {
			boxID = bt.BoxID
		}
	} else if options.CurrentAvID != "" {
		_, boxID = av.FindAttributeViewPath(options.CurrentAvID)
	}
	if keyword != "" {
		stopAttributeViewSearchCacheWarmup(boxID)
	}
	avDir := filepath.Join(util.DataDir, "storage", "av")
	if boxID != "" {
		avDir = filepath.Join(util.DataDir, boxID, "storage", "av")
	}
	readDirStart := time.Now()
	entries, err := os.ReadDir(avDir)
	readDirElapsed = time.Since(readDirStart)
	if err != nil {
		logging.LogErrorf("read directory [%s] failed: %s", avDir, err)
		return
	}
	directoryEntryCount = len(entries)

	getBlockRelsStart := time.Now()
	avBlockRels := av.GetBlockRels()
	getBlockRelsElapsed = time.Since(getBlockRelsStart)
	if 1 > len(avBlockRels) {
		return
	}

	scanStart := time.Now()
	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		id := strings.TrimSuffix(entry.Name(), ".json")
		if !ast.IsNodeIDPattern(id) {
			continue
		}
		validFileCount++

		if nil == avBlockRels[id] {
			continue
		}
		readFileInfoStart := time.Now()
		info, _ := entry.Info()
		readFileInfoElapsed += time.Since(readFileInfoStart)
		warmupAvIDs = append(warmupAvIDs, id)
		warmupSignature = updateAttributeViewSearchCacheWarmupSignature(warmupSignature, id, info)

		if gulu.Str.Contains(id, options.ExcludeAvIDs) {
			continue
		}
		eligibleFileCount++

		if info != nil {
			eligibleFileSize += info.Size()
		}
		a := &AvSearchTempResult{AvID: id}
		if nil != info && !info.ModTime().IsZero() {
			a.AvUpdated = info.ModTime().UnixMilli()
		}
		if keyword == "" {
			avSearchTmpResults = append(avSearchTmpResults, a)
			continue
		}

		var searchInfo *av.AttributeViewSearchInfo
		readSearchInfoStart := time.Now()
		searchInfo, _ = av.GetAttributeViewSearchInfoInBox(id, boxID)
		readSearchInfoElapsed += time.Since(readSearchInfoStart)
		readSearchInfoCount++
		var name string
		if searchInfo != nil {
			name = searchInfo.Name
		}
		if searchInfo == nil {
			readNameStart := time.Now()
			name, _ = av.GetAttributeViewNameInBox(id, boxID)
			readNameElapsed += time.Since(readNameStart)
			readNameCount++
		}
		score, hit := matchAttributeViewSearchName(name, keywords)
		matchedViewIDs := map[string]bool{}
		if options.IncludeViewMatches && searchInfo != nil {
			for _, view := range searchInfo.Views {
				viewScore, viewHit := matchAttributeViewSearchName(view.Name, keywords)
				if viewHit {
					matchedViewIDs[view.ID] = true
					if viewScore > score {
						score = viewScore
					}
				}
			}
		}

		if hit || len(matchedViewIDs) > 0 {
			a.AvName = name
			a.Score = score
			a.Matched = hit
			a.SearchInfo = searchInfo
			a.MatchedViewIDs = matchedViewIDs
			avSearchTmpResults = append(avSearchTmpResults, a)
		}
	}
	scanElapsed = time.Since(scanStart)

	sortStart := time.Now()
	matchedCount = len(avSearchTmpResults)
	avSearchTmpResults = sortAndLimitAttributeViewSearchResults(avSearchTmpResults, keyword)
	sortElapsed = time.Since(sortStart)

	resolveStart := time.Now()
	for _, tmpResult := range avSearchTmpResults {
		bIDs := avBlockRels[tmpResult.AvID]
		var node *ast.Node
		var treeHPath string
		for _, bID := range bIDs {
			loadTreeStart := time.Now()
			// 数据库块关系可能因删除、同步或索引尚未完成而暂时失效,搜索时静默跳过。
			tree, _ := loadTreeByBlockIDInBox0(bID, boxID, false)
			loadTreeElapsed += time.Since(loadTreeStart)
			loadTreeCount++
			if nil == tree {
				continue
			}

			findNodeStart := time.Now()
			node = treenode.GetNodeInTree(tree, bID)
			findNodeElapsed += time.Since(findNodeStart)
			findNodeCount++
			if nil == node || "" == node.AttributeViewID || ast.NodeAttributeView != node.Type {
				node = nil
				continue
			}

			treeHPath = tree.HPath
			break
		}

		if nil == node {
			continue
		}

		searchInfo := tmpResult.SearchInfo
		if searchInfo == nil {
			readSearchInfoStart := time.Now()
			searchInfo, _ = av.GetAttributeViewSearchInfoInBox(tmpResult.AvID, boxID)
			readSearchInfoElapsed += time.Since(readSearchInfoStart)
			readSearchInfoCount++
		}
		if searchInfo == nil {
			continue
		}
		if tmpResult.AvName == "" {
			tmpResult.AvName = searchInfo.Name
		}

		resolveHPathStart := time.Now()
		hPath := treeHPath
		box := Conf.Box(node.Box)
		if nil != box {
			hPath = box.Name + hPath
		}
		resolveHPathElapsed += time.Since(resolveHPathStart)
		resolveHPathCount++

		parent := &AvSearchResult{
			AvID:    tmpResult.AvID,
			AvName:  tmpResult.AvName,
			BlockID: node.ID,
			HPath:   hPath,
			Matched: tmpResult.Matched,
		}
		ret = append(ret, parent)

		for _, view := range searchInfo.Views {
			child := &AvSearchResult{
				AvID:       tmpResult.AvID,
				AvName:     tmpResult.AvName,
				ViewName:   view.Name,
				ViewID:     view.ID,
				ViewLayout: view.LayoutType,
				BlockID:    node.ID,
				HPath:      hPath,
				Matched:    tmpResult.MatchedViewIDs[view.ID],
			}
			parent.Children = append(parent.Children, child)
		}
	}
	resolveElapsed = time.Since(resolveStart)
	if keyword == "" {
		warmAttributeViewSearchCache(boxID, warmupAvIDs, warmupSignature)
	}
	return
}

type BlockAttributeViewKeys struct {
	AvID          string                         `json:"avID"`
	AvName        string                         `json:"avName"`
	CustomColors  []*av.AttributeViewCustomColor `json:"customColors"`
	BlockIDs      []string                       `json:"blockIDs"`
	KeyValues     []*av.KeyValues                `json:"keyValues"`
	ItemPositions []*AttributeViewItemPosition   `json:"itemPositions"`
}

type AttributeViewItemPosition struct {
	ViewID     string                            `json:"viewID"`
	PreviousID string                            `json:"previousID"`
	Groups     []*AttributeViewGroupItemPosition `json:"groups"`
}

type AttributeViewGroupItemPosition struct {
	GroupID    string `json:"groupID"`
	PreviousID string `json:"previousID"`
}

func getAttributeViewItemPositions(attrView *av.AttributeView, itemID string) (ret []*AttributeViewItemPosition) {
	for _, view := range attrView.Views {
		previousID, found := getAttributeViewPreviousItemID(view.ItemIDs, itemID)
		if !found {
			continue
		}

		position := &AttributeViewItemPosition{ViewID: view.ID, PreviousID: previousID}
		for _, group := range view.Groups {
			groupPreviousID, groupFound := getAttributeViewPreviousItemID(group.GroupItemIDs, itemID)
			if groupFound {
				position.Groups = append(position.Groups, &AttributeViewGroupItemPosition{
					GroupID: group.ID, PreviousID: groupPreviousID,
				})
			}
		}
		ret = append(ret, position)
	}
	return
}

func getAttributeViewPreviousItemID(itemIDs []string, itemID string) (previousID string, found bool) {
	for i, currentID := range itemIDs {
		if currentID != itemID {
			continue
		}
		if 0 < i {
			previousID = itemIDs[i-1]
		}
		found = true
		return
	}
	return
}

type AttributeViewBacklinkRelation struct {
	KeyID        string `json:"keyID"`
	KeyName      string `json:"keyName"`
	TargetAvID   string `json:"targetAvID"`
	TargetItemID string `json:"targetItemID"`
}

type AttributeViewBacklink struct {
	AvID            string                           `json:"avID"`
	AvName          string                           `json:"avName"`
	BlockIDs        []string                         `json:"blockIDs"`
	DatabaseBlockID string                           `json:"databaseBlockID"`
	BoxID           string                           `json:"boxID"`
	DatabasePath    string                           `json:"databasePath"`
	ItemID          string                           `json:"itemID"`
	ValueID         string                           `json:"valueID"`
	Title           string                           `json:"title"`
	Icon            string                           `json:"icon"`
	BoundBlockID    string                           `json:"boundBlockID"`
	IsDetached      bool                             `json:"isDetached"`
	Relations       []*AttributeViewBacklinkRelation `json:"relations"`
}

type AttributeViewBacklinks struct {
	Total int                      `json:"total"`
	Items []*AttributeViewBacklink `json:"items"`
}

type attributeViewBacklinkTarget struct {
	avID   string
	itemID string
}

func getAttributeViewBacklinkMatches(srcAttrView *av.AttributeView, target *attributeViewBacklinkTarget) (ret map[string][]*AttributeViewBacklinkRelation) {
	ret = map[string][]*AttributeViewBacklinkRelation{}
	seenRelations := map[string]bool{}
	for _, keyValues := range srcAttrView.KeyValues {
		key := keyValues.Key
		if av.KeyTypeRelation != key.Type || nil == key.Relation || key.Relation.AvID != target.avID {
			continue
		}

		for _, value := range keyValues.Values {
			if nil == value.Relation || !slices.Contains(value.Relation.BlockIDs, target.itemID) {
				continue
			}

			relationID := value.BlockID + "\x00" + key.ID + "\x00" + target.avID + "\x00" + target.itemID
			if seenRelations[relationID] {
				continue
			}
			seenRelations[relationID] = true
			ret[value.BlockID] = append(ret[value.BlockID], &AttributeViewBacklinkRelation{
				KeyID:        key.ID,
				KeyName:      key.Name,
				TargetAvID:   target.avID,
				TargetItemID: target.itemID,
			})
		}
	}
	return
}

func getAttributeViewBacklinkBlockValues(attrView *av.AttributeView) (ret map[string]*av.Value) {
	ret = map[string]*av.Value{}
	blockKeyValues := attrView.GetBlockKeyValues()
	if nil == blockKeyValues {
		return
	}
	for _, value := range blockKeyValues.Values {
		ret[value.BlockID] = value
	}
	return
}

func resolveAttributeViewBacklinkItemID(attrView *av.AttributeView, itemID, valueID string) string {
	if nil != attrView.GetBlockValue(itemID) {
		return itemID
	}
	if "" == valueID {
		return ""
	}
	for _, value := range getAttributeViewBacklinkBlockValues(attrView) {
		if value.ID == valueID {
			return value.BlockID
		}
	}
	return ""
}

func sortAttributeViewBacklinkBlockIDs(blockIDs []string, blockTrees map[string]*treenode.BlockTree) {
	sort.Slice(blockIDs, func(i, j int) bool {
		left, right := blockTrees[blockIDs[i]], blockTrees[blockIDs[j]]
		if nil == left || nil == right {
			if nil == left && nil != right {
				return false
			}
			if nil != left && nil == right {
				return true
			}
			return blockIDs[i] < blockIDs[j]
		}
		if left.HPath != right.HPath {
			return left.HPath < right.HPath
		}
		if left.BoxID != right.BoxID {
			return left.BoxID < right.BoxID
		}
		return blockIDs[i] < blockIDs[j]
	})
}

func GetAttributeViewBacklinks(nodeID, avID, itemID, valueID string) (ret *AttributeViewBacklinks) {
	waitForSyncingStorages()

	ret = &AttributeViewBacklinks{Items: []*AttributeViewBacklink{}}
	targets := getAttributeViewBacklinkTargets(nodeID, avID, itemID, valueID)
	if 1 > len(targets) {
		return
	}

	backlinks := map[string]*AttributeViewBacklink{}
	relationKeys := map[string]map[string]bool{}
	cachedAttrViews := map[string]*av.AttributeView{}
	cachedBlockValues := map[string]map[string]*av.Value{}
	cachedBlockIDs := map[string][]string{}
	cachedBlockTrees := map[string]map[string]*treenode.BlockTree{}
	for _, target := range targets {
		for _, srcAvID := range av.GetSrcAvIDs(target.avID) {
			srcAttrView := cachedAttrViews[srcAvID]
			if nil == srcAttrView {
				var err error
				srcAttrView, err = av.ParseAttributeView(srcAvID)
				if nil == srcAttrView {
					logging.LogErrorf("parse attribute view [%s] failed: %s", srcAvID, err)
					continue
				}
				cachedAttrViews[srcAvID] = srcAttrView
			}

			blockValues := cachedBlockValues[srcAvID]
			if nil == blockValues {
				blockValues = getAttributeViewBacklinkBlockValues(srcAttrView)
				cachedBlockValues[srcAvID] = blockValues
			}
			for sourceItemID, relations := range getAttributeViewBacklinkMatches(srcAttrView, target) {
				blockValue := blockValues[sourceItemID]
				if nil == blockValue || nil == blockValue.Block {
					continue
				}

				backlinkID := srcAvID + "\x00" + sourceItemID
				backlink := backlinks[backlinkID]
				if nil == backlink {
					blockIDs, cached := cachedBlockIDs[srcAvID]
					blockTrees := cachedBlockTrees[srcAvID]
					if !cached {
						blockIDs = treenode.GetMirrorAttrViewBlockIDs(srcAvID)
						blockTrees = treenode.GetBlockTrees(blockIDs)
						sortAttributeViewBacklinkBlockIDs(blockIDs, blockTrees)
						cachedBlockIDs[srcAvID] = blockIDs
						cachedBlockTrees[srcAvID] = blockTrees
					}
					backlink = &AttributeViewBacklink{
						AvID:         srcAvID,
						AvName:       getAttrViewName(srcAttrView),
						BlockIDs:     blockIDs,
						ItemID:       sourceItemID,
						ValueID:      blockValue.ID,
						Title:        blockValue.Block.Content,
						Icon:         blockValue.Block.Icon,
						BoundBlockID: blockValue.Block.ID,
						IsDetached:   blockValue.IsDetached || "" == blockValue.Block.ID,
						Relations:    []*AttributeViewBacklinkRelation{},
					}
					if 0 < len(blockIDs) {
						backlink.DatabaseBlockID = blockIDs[0]
						if bt := blockTrees[blockIDs[0]]; nil != bt {
							backlink.BoxID = bt.BoxID
							backlink.DatabasePath = bt.HPath
						}
					}
					backlinks[backlinkID] = backlink
					relationKeys[backlinkID] = map[string]bool{}
				}

				for _, relation := range relations {
					relationID := relation.KeyID + "\x00" + relation.TargetAvID + "\x00" + relation.TargetItemID
					if relationKeys[backlinkID][relationID] {
						continue
					}
					relationKeys[backlinkID][relationID] = true
					backlink.Relations = append(backlink.Relations, relation)
				}
			}
		}
	}

	for _, backlink := range backlinks {
		ret.Items = append(ret.Items, backlink)
	}
	sort.Slice(ret.Items, func(i, j int) bool {
		if ret.Items[i].AvName != ret.Items[j].AvName {
			return ret.Items[i].AvName < ret.Items[j].AvName
		}
		if ret.Items[i].Title != ret.Items[j].Title {
			return ret.Items[i].Title < ret.Items[j].Title
		}
		return ret.Items[i].ItemID < ret.Items[j].ItemID
	})
	ret.Total = len(ret.Items)
	return
}

func getAttributeViewBacklinkTargets(nodeID, avID, itemID, valueID string) (ret []*attributeViewBacklinkTarget) {
	if "" != avID && ("" != itemID || "" != valueID) {
		attrView, err := av.ParseAttributeView(avID)
		if nil == attrView {
			logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
			return
		}
		itemID = resolveAttributeViewBacklinkItemID(attrView, itemID, valueID)
		if "" != itemID {
			ret = append(ret, &attributeViewBacklinkTarget{avID: avID, itemID: itemID})
		}
		return
	}

	attrs := sql.GetBlockAttrs(nodeID)
	for targetAvID := range strings.SplitSeq(attrs[av.NodeAttrNameAvs], ",") {
		if "" == targetAvID {
			continue
		}
		attrView, err := av.ParseAttributeView(targetAvID)
		if nil == attrView {
			logging.LogErrorf("parse attribute view [%s] failed: %s", targetAvID, err)
			continue
		}
		blockValue := attrView.GetBlockValueByBoundID(nodeID)
		if nil != blockValue {
			ret = append(ret, &attributeViewBacklinkTarget{avID: targetAvID, itemID: blockValue.BlockID})
		}
	}
	return
}

func GetAttributeViewItemKeys(avID, itemID, valueID string) (ret []*BlockAttributeViewKeys) {
	waitForSyncingStorages()

	ret = []*BlockAttributeViewKeys{}
	attrView, err := av.ParseAttributeView(avID)
	if nil == attrView {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}
	if nil == attrView.GetBlockValue(itemID) && "" != valueID {
		blockKeyValues := attrView.GetBlockKeyValues()
		if nil != blockKeyValues {
			for _, value := range blockKeyValues.Values {
				if value.ID == valueID {
					itemID = value.BlockID
					break
				}
			}
		}
	}
	if nil == attrView.GetBlockValue(itemID) {
		return
	}

	view, err := getRenderAttributeViewView(attrView, "", "", "", true)
	if nil != err {
		return
	}
	viewable := sql.RenderView(attrView, view, "", false)
	collection, ok := viewable.(av.Collection)
	if !ok {
		return
	}
	keyValues := getAttributeViewItemKeyValues(attrView, collection, itemID, false)

	refreshAttrViewKeyIDs(attrView, true)
	sorts := map[string]int{}
	for i, keyID := range attrView.KeyIDs {
		sorts[keyID] = i
	}
	sort.Slice(keyValues, func(i, j int) bool {
		return sorts[keyValues[i].Key.ID] < sorts[keyValues[j].Key.ID]
	})

	ret = append(ret, &BlockAttributeViewKeys{
		AvID:          avID,
		AvName:        getAttrViewName(attrView),
		CustomColors:  attrView.Palette(),
		BlockIDs:      treenode.GetMirrorAttrViewBlockIDs(avID),
		KeyValues:     keyValues,
		ItemPositions: getAttributeViewItemPositions(attrView, itemID),
	})
	return
}

func GetBlockAttributeViewKeys(nodeID string) (ret []*BlockAttributeViewKeys) {
	waitForSyncingStorages()

	ret = []*BlockAttributeViewKeys{}
	attrs := sql.GetBlockAttrs(nodeID)
	avs := attrs[av.NodeAttrNameAvs]
	if "" == avs {
		return
	}

	cachedAttrViews := map[string]*av.AttributeView{}
	avIDs := strings.SplitSeq(avs, ",")
	for avID := range avIDs {
		attrView := cachedAttrViews[avID]
		if nil == attrView {
			var err error
			attrView, err = av.ParseAttributeView(avID)
			if nil == attrView {
				logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
				continue
			}
			cachedAttrViews[avID] = attrView
		}

		if !attrView.ExistBoundBlock(nodeID) {
			// 比如剪切后粘贴,块 ID 会变,但是属性还在块上,这里做一次数据订正
			// Auto verify the database name when clicking the block superscript icon https://github.com/siyuan-note/siyuan/issues/10861
			unbindBlockAv(nil, avID, nodeID)
			return
		}

		blockVal := attrView.GetBlockValueByBoundID(nodeID)
		if nil == blockVal {
			continue
		}

		itemID := blockVal.BlockID
		view, err := getRenderAttributeViewView(attrView, "", "", nodeID, true)
		if nil != err {
			continue
		}

		viewable := sql.RenderView(attrView, view, "", false)
		collection, ok := viewable.(av.Collection)
		if !ok {
			continue
		}
		keyValues := getAttributeViewItemKeyValues(attrView, collection, itemID, true)

		// 字段排序
		refreshAttrViewKeyIDs(attrView, true)
		sorts := map[string]int{}
		for i, k := range attrView.KeyIDs {
			sorts[k] = i
		}
		sort.Slice(keyValues, func(i, j int) bool {
			return sorts[keyValues[i].Key.ID] < sorts[keyValues[j].Key.ID]
		})

		blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
		if 1 > len(blockIDs) {
			// 老数据兼容处理
			boxID := ""
			if tree, _ := LoadTreeByBlockID(nodeID); tree != nil {
				boxID = tree.Box
			}
			avBts := treenode.GetBlockTreesByTypeInBox("av", boxID)
			for _, avBt := range avBts {
				if nil == avBt {
					continue
				}
				tree, _ := LoadTreeByBlockIDInExactBox(avBt.ID, avBt.BoxID)
				if nil == tree {
					continue
				}
				node := treenode.GetNodeInTree(tree, avBt.ID)
				if nil == node {
					continue
				}
				if avID == node.AttributeViewID {
					blockIDs = append(blockIDs, avBt.ID)
				}
			}
			if 1 > len(blockIDs) {
				tree, _ := LoadTreeByBlockID(nodeID)
				if nil != tree {
					node := treenode.GetNodeInTree(tree, nodeID)
					if nil != node {
						if removeErr := removeNodeAvID(node, avID, nil, tree); nil != removeErr {
							logging.LogErrorf("remove node avID [%s] failed: %s", avID, removeErr)
						}
					}
				}
				continue
			}
			blockIDs = gulu.Str.RemoveDuplicatedElem(blockIDs)
			for _, blockID := range blockIDs {
				av.UpsertBlockRel(avID, blockID)
			}
		}

		ret = append(ret, &BlockAttributeViewKeys{
			AvID:          avID,
			AvName:        getAttrViewName(attrView),
			CustomColors:  attrView.Palette(),
			BlockIDs:      blockIDs,
			KeyValues:     keyValues,
			ItemPositions: getAttributeViewItemPositions(attrView, itemID),
		})
	}
	return
}

func getAttributeViewItemKeyValues(attrView *av.AttributeView, collection av.Collection, itemID string,
	includeEmpty bool) (ret []*av.KeyValues) {
	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeLineNumber == keyValues.Key.Type {
			continue
		}

		itemKeyValues := &av.KeyValues{Key: keyValues.Key}
		if value := collection.GetValue(itemID, keyValues.Key.ID); nil != value {
			itemKeyValues.Values = append(itemKeyValues.Values, value)
		} else {
			for _, value := range keyValues.Values {
				if value.BlockID == itemID {
					itemKeyValues.Values = append(itemKeyValues.Values, value)
				}
			}
		}
		if includeEmpty || 0 < len(itemKeyValues.Values) {
			ret = append(ret, itemKeyValues)
		}
	}
	return
}

func genAttrViewGroups(view *av.View, attrView *av.AttributeView) {
	if !view.IsGroupView() {
		return
	}
	viewable := sql.RenderView(attrView, view, "", false)
	genAttrViewGroupsWithItems(view, attrView, viewable.(av.Collection).GetItems())
}

func genAttrViewGroupsWithItems(view *av.View, attrView *av.AttributeView, sourceItems []av.Item) {
	if !view.IsGroupView() {
		return
	}

	groupStates := getAttrViewGroupStates(view)

	group := view.Group
	view.Groups = nil
	items := append([]av.Item(nil), sourceItems...)

	groupKey := view.GetGroupKey(attrView)
	if nil == groupKey {
		return
	}
	groupByRendered := av.ValueSourceRendered == group.ValueSource
	groupMethod := group.Method
	if groupByRendered {
		// 显示模板结果按文本值分组,不应用源字段的数字或日期分组方法。
		groupMethod = av.GroupMethodValue
	}
	getGroupValue := func(item av.Item) *av.Value {
		return av.ResolveValueSource(item.GetValue(group.Field), group.ValueSource)
	}

	var rangeStart, rangeEnd float64
	switch groupMethod {
	case av.GroupMethodValue:
		if av.GroupOrderMan != group.Order {
			sort.SliceStable(items, func(i, j int) bool {
				return getGroupValue(items[i]).String(false) < getGroupValue(items[j]).String(false)
			})
		}
	case av.GroupMethodRangeNum:
		if nil == group.Range {
			return
		}

		rangeStart, rangeEnd = group.Range.NumStart, group.Range.NumStart+group.Range.NumStep
		sort.SliceStable(items, func(i, j int) bool {
			return items[i].GetValue(group.Field).Number.Content < items[j].GetValue(group.Field).Number.Content
		})
	case av.GroupMethodDateDay, av.GroupMethodDateWeek, av.GroupMethodDateMonth, av.GroupMethodDateYear, av.GroupMethodDateRelative:
		if av.KeyTypeCreated == groupKey.Type {
			sort.SliceStable(items, func(i, j int) bool {
				return items[i].GetValue(group.Field).Created.Content < items[j].GetValue(group.Field).Created.Content
			})
		} else if av.KeyTypeUpdated == groupKey.Type {
			sort.SliceStable(items, func(i, j int) bool {
				return items[i].GetValue(group.Field).Updated.Content < items[j].GetValue(group.Field).Updated.Content
			})
		} else if av.KeyTypeDate == groupKey.Type {
			sort.SliceStable(items, func(i, j int) bool {
				return items[i].GetValue(group.Field).Date.Content < items[j].GetValue(group.Field).Date.Content
			})
		}
	}

	todayStart := time.Now()
	todayStart = time.Date(todayStart.Year(), todayStart.Month(), todayStart.Day(), 0, 0, 0, 0, time.Local)

	var relationDestAv *av.AttributeView
	if !groupByRendered && av.KeyTypeRelation == groupKey.Type && nil != groupKey.Relation {
		if attrView.ID == groupKey.Relation.AvID {
			relationDestAv = attrView
		} else {
			relationDestAv, _ = av.ParseAttributeView(groupKey.Relation.AvID)
		}
	}

	groupItemsMap := map[string][]av.Item{}
	for _, item := range items {
		value := getGroupValue(item)
		if value.IsBlank() {
			groupItemsMap[groupValueDefault] = append(groupItemsMap[groupValueDefault], item)
			continue
		}

		var groupVal string
		switch groupMethod {
		case av.GroupMethodValue:
			if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
				for _, s := range value.MSelect {
					groupItemsMap[s.Content] = append(groupItemsMap[s.Content], item)
				}
				continue
			} else if !groupByRendered && av.KeyTypeRelation == groupKey.Type {
				if nil == relationDestAv {
					continue
				}

				for _, bID := range value.Relation.BlockIDs {
					groupItemsMap[bID] = append(groupItemsMap[bID], item)
				}
				continue
			}

			groupVal = value.String(false)
		case av.GroupMethodRangeNum:
			if group.Range.NumStart > value.Number.Content || group.Range.NumEnd < value.Number.Content {
				groupVal = groupValueNotInRange
				break
			}

			for rangeEnd <= group.Range.NumEnd && rangeEnd <= value.Number.Content {
				rangeStart += group.Range.NumStep
				rangeEnd += group.Range.NumStep
			}

			if rangeStart <= value.Number.Content && rangeEnd > value.Number.Content {
				groupVal = fmt.Sprintf("%s - %s", strconv.FormatFloat(rangeStart, 'f', -1, 64), strconv.FormatFloat(rangeEnd, 'f', -1, 64))
			}
		case av.GroupMethodDateDay, av.GroupMethodDateWeek, av.GroupMethodDateMonth, av.GroupMethodDateYear, av.GroupMethodDateRelative:
			var contentTime time.Time
			switch value.Type {
			case av.KeyTypeDate:
				contentTime = time.UnixMilli(value.Date.Content)
			case av.KeyTypeCreated:
				contentTime = time.UnixMilli(value.Created.Content)
			case av.KeyTypeUpdated:
				contentTime = time.UnixMilli(value.Updated.Content)
			}
			switch groupMethod {
			case av.GroupMethodDateDay:
				groupVal = contentTime.Format("2006-01-02")
			case av.GroupMethodDateWeek:
				year, week := contentTime.ISOWeek()
				groupVal = fmt.Sprintf("%d-W%02d", year, week)
			case av.GroupMethodDateMonth:
				groupVal = contentTime.Format("2006-01")
			case av.GroupMethodDateYear:
				groupVal = contentTime.Format("2006")
			case av.GroupMethodDateRelative:
				// 过去 30 天之前的按月分组
				// 过去 30 天、过去 7 天、昨天、今天、明天、未来 7 天、未来 30 天
				// 未来 30 天之后的按月分组
				if contentTime.Before(todayStart.AddDate(0, 0, -30)) {
					groupVal = contentTime.Format("2006-01") // 开头的数字用于排序
				} else if contentTime.Before(todayStart.AddDate(0, 0, -7)) {
					groupVal = groupValueLast30Days
				} else if contentTime.Before(todayStart.AddDate(0, 0, -1)) {
					groupVal = groupValueLast7Days
				} else if contentTime.Before(todayStart) {
					groupVal = groupValueYesterday
				} else if (contentTime.After(todayStart) || contentTime.Equal(todayStart)) && contentTime.Before(todayStart.AddDate(0, 0, 1)) {
					groupVal = groupValueToday
				} else if contentTime.After(todayStart.AddDate(0, 0, 30)) {
					groupVal = contentTime.Format("2006-01")
				} else if contentTime.After(todayStart.AddDate(0, 0, 7)) {
					groupVal = groupValueNext30Days
				} else if contentTime.Equal(todayStart.AddDate(0, 0, 2)) || contentTime.After(todayStart.AddDate(0, 0, 2)) {
					groupVal = groupValueNext7Days
				} else {
					groupVal = groupValueTomorrow
				}
			}
		}

		groupItemsMap[groupVal] = append(groupItemsMap[groupVal], item)
	}

	if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
		for _, o := range groupKey.Options {
			if _, ok := groupItemsMap[o.Name]; !ok {
				groupItemsMap[o.Name] = []av.Item{}
			}
		}
	}

	if groupByRendered || av.KeyTypeCheckbox != groupKey.Type {
		if 1 > len(groupItemsMap[groupValueDefault]) {
			// 始终保留默认分组 https://github.com/siyuan-note/siyuan/issues/15587
			groupItemsMap[groupValueDefault] = []av.Item{}
		}
	} else {
		// 对于复选框分组,空白分组表示未选中状态,始终保留 https://github.com/siyuan-note/siyuan/issues/15650
		if nil == groupItemsMap[""] {
			groupItemsMap[""] = []av.Item{}
		}
		if nil == groupItemsMap[av.CheckboxCheckedStr] {
			groupItemsMap[av.CheckboxCheckedStr] = []av.Item{}
		}
	}

	groupValues := make([]string, 0, len(groupItemsMap))
	for value := range groupItemsMap {
		groupValues = append(groupValues, value)
	}
	sort.Strings(groupValues)
	for _, groupValue := range groupValues {
		groupItems := groupItemsMap[groupValue]
		var v *av.View
		switch view.LayoutType {
		case av.LayoutTypeList:
			v = av.NewListView()
		case av.LayoutTypeTable:
			v = av.NewTableView()
			v.Table = av.NewLayoutTable()
		case av.LayoutTypeGallery:
			v = av.NewGalleryView()
			v.Gallery = av.NewLayoutGallery()
		case av.LayoutTypeKanban:
			v = av.NewKanbanView()
			v.Kanban = av.NewLayoutKanban()
		default:
			logging.LogWarnf("unknown layout type [%s] for group view", view.LayoutType)
			return
		}

		v.GroupItemIDs = []string{}
		for _, item := range groupItems {
			v.GroupItemIDs = append(v.GroupItemIDs, item.GetID())
		}

		v.Name = ""       // 分组视图的名称在渲染时才填充
		v.GroupHidden = 1 // 默认隐藏空白分组
		v.GroupKey = groupKey
		v.GroupVal = &av.Value{Type: av.KeyTypeText, Text: &av.ValueText{Content: groupValue}}
		if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
			if opt := groupKey.GetOption(groupValue); nil != opt {
				v.GroupVal.Text = nil
				v.GroupVal.Type = av.KeyTypeSelect
				v.GroupVal.MSelect = []*av.ValueSelect{newAttrViewValueSelect(opt)}
			}
		} else if !groupByRendered && av.KeyTypeRelation == groupKey.Type {
			if relationDestAv != nil && groupValueDefault != groupValue {
				v.GroupVal.Text = nil
				v.GroupVal.Type = av.KeyTypeRelation
				v.GroupVal.Relation = &av.ValueRelation{BlockIDs: []string{groupValue}}

				if destBlock := relationDestAv.GetBlockValue(groupValue); nil != destBlock {
					v.GroupVal.Relation.Contents = []*av.Value{destBlock}
				}
			}
		} else if !groupByRendered && av.KeyTypeCheckbox == groupKey.Type {
			v.GroupVal.Text = nil
			v.GroupVal.Type = av.KeyTypeCheckbox
			v.GroupVal.Checkbox = &av.ValueCheckbox{}
			if "" != groupValue {
				v.GroupVal.Checkbox.Checked = true
			}
		}
		v.GroupSort = -1
		view.Groups = append(view.Groups, v)
	}

	view.GroupCreated = time.Now().UnixMilli()
	setAttrViewGroupStates(view, groupStates)
}

// GroupState 用于临时记录每个分组视图的状态,以便后面重新生成分组后可以恢复这些状态。
type GroupState struct {
	ID         string
	LayoutID   string
	LayoutType av.LayoutType
	Position   int
	Folded     bool
	Hidden     int
	Sort       int
	ItemIDs    []string
}

func getAttrViewGroupStates(view *av.View) (groupStates map[string]*GroupState) {
	groupStates = map[string]*GroupState{}
	if !view.IsGroupView() {
		return
	}

	for position, groupView := range view.Groups {
		if av.LayoutTypeKanban == groupView.LayoutType {
			// 看板视图的分组不能折叠
			groupView.GroupFolded = false
		}

		groupStates[groupView.GetGroupValue()] = &GroupState{
			ID:         groupView.ID,
			LayoutID:   attrViewGroupLayoutID(groupView),
			LayoutType: groupView.LayoutType,
			Position:   position,
			Folded:     groupView.GroupFolded,
			Hidden:     groupView.GroupHidden,
			Sort:       groupView.GroupSort,
			ItemIDs:    groupView.GroupItemIDs,
		}
	}
	return
}

func setAttrViewGroupStates(view *av.View, groupStates map[string]*GroupState) {
	for _, groupView := range view.Groups {
		if state, ok := groupStates[groupView.GetGroupValue()]; ok {
			groupView.ID = state.ID
			groupView.GroupFolded = state.Folded
			groupView.GroupHidden = state.Hidden
			groupView.GroupSort = state.Sort
			if groupView.LayoutType == state.LayoutType && state.LayoutID != "" {
				if layout := groupView.GetBaseLayout(); nil != layout {
					layout.ID = state.LayoutID
				}
			}

			itemIDsSort := map[string]int{}
			for i, itemID := range state.ItemIDs {
				itemIDsSort[itemID] = i
			}

			sort.SliceStable(groupView.GroupItemIDs, func(i, j int) bool {
				return itemIDsSort[groupView.GroupItemIDs[i]] < itemIDsSort[groupView.GroupItemIDs[j]]
			})
		}
	}

	// 分组重建保留序列化顺序,避免未编辑的布局被记录为字段变更。
	sort.SliceStable(view.Groups, func(i, j int) bool {
		left, right := groupStates[view.Groups[i].GetGroupValue()], groupStates[view.Groups[j].GetGroupValue()]
		if left != nil && right != nil {
			return left.Position < right.Position
		}
		return left != nil && right == nil
	})
	defaultGroup := view.GetGroupByGroupValue(groupValueDefault)
	if nil != defaultGroup {
		if -1 == defaultGroup.GroupSort {
			view.RemoveGroupByID(defaultGroup.ID)
		} else {
			defaultGroup = nil
		}
	}

	for i, groupView := range view.Groups {
		if i != groupView.GroupSort && -1 == groupView.GroupSort {
			groupView.GroupSort = i
		}
	}

	if nil != defaultGroup {
		view.Groups = append(view.Groups, defaultGroup)
		defaultGroup.GroupSort = len(view.Groups) - 1
	}
}

// attrViewGroupLayoutID 返回可分组的布局 ID,日历不参与分组。
func attrViewGroupLayoutID(view *av.View) string {
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeGallery, av.LayoutTypeKanban:
		if layout := view.GetBaseLayout(); nil != layout {
			return layout.ID
		}
	}
	return ""
}

func GetCurrentAttributeViewImages(c *gin.Context, avID, blockID, viewID, query, groupID string) (ret []string, err error) {
	var attrView *av.AttributeView
	attrView, err = avParseView(avID, blockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	// 发布读者只能读取发布可访问数据库中的图片。逐行过滤会把游离行视为可访问,缺少数据库级门禁时会泄漏未授权
	// 数据库游离行的图片资源路径,因此这里与 renderAttributeView 保持一致,在提取资源前做顶层访问校验。
	if IsReadOnlyRoleContext(c) {
		if !CheckAttributeViewBlockAccessableByPublishAccess(c, GetPublishAccess(), avID, blockID) {
			err = av.ErrAttributeViewNotFound
			return
		}
	}

	var view *av.View

	view, err = resolveAttributeViewView(attrView, viewID, "", blockID)
	if nil != err {
		return
	}
	filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, blockID)
	if nil != contextErr {
		err = contextErr
		return
	}

	imageView := view
	if groupID != "" {
		// 动态分组沿用界面渲染的刷新规则,仅在内存中更新,不写入数据库。
		if view.Groups == nil || isGroupByTemplate(attrView, view) ||
			(isGroupByDate(view) && time.UnixMilli(view.GroupCreated).Format("2006-01-02") != time.Now().Format("2006-01-02")) {
			genAttrViewGroups(view, attrView)
		}
		group := view.GetGroupByID(groupID)
		if !view.IsGroupView() || group == nil {
			return nil, av.ErrViewNotFound
		}
		// 保留父视图字段、筛选及排序,使用分组条目集合和组内手动顺序。
		groupView := *view
		groupView.ID = group.ID
		groupView.GroupItemIDs = append([]string{}, group.GroupItemIDs...)
		// 分组生成可能缓存父视图,图片列表需要独立执行当前分组的搜索和筛选。
		delete(attrView.RenderedViewables, group.ID)
		imageView = &groupView
	}

	cachedAttrViews := map[string]*av.AttributeView{}
	rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
	table := getAttrViewTable(attrView, imageView, query)
	av.FilterWithContext(table, attrView, rollupFurtherCollections, cachedAttrViews, filterContext)
	av.Sort(table, attrView)
	if IsReadOnlyRoleContext(c) {
		// 顶层门禁已通过,这里再按行剔除绑定在不可发布文档中的行值
		table = FilterViewByPublishAccess(c, GetPublishAccess(), table).(*av.Table)
	}

	ids := map[string]bool{}
	for _, column := range table.Columns {
		ids[column.ID] = column.Hidden
	}

	for _, row := range table.Rows {
		for _, cell := range row.Cells {
			if nil != cell.Value && av.KeyTypeMAsset == cell.Value.Type && nil != cell.Value.MAsset && !ids[cell.Value.KeyID] {
				for _, a := range cell.Value.MAsset {
					if av.AssetTypeImage == a.Type {
						ret = append(ret, a.Content)
					}
				}
			}
		}
	}
	return
}

func (tx *Transaction) doSetAttrViewColDateFillCreated(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColDateFillCreated(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColDateFillCreated(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	keyID := operation.ID
	key, _ := attrView.GetKey(keyID)
	if nil == key || av.KeyTypeDate != key.Type {
		return
	}

	if nil == key.Date {
		key.Date = &av.Date{}
	}

	key.Date.AutoFillNow = operation.Data.(bool)
	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColDateFillSpecificTime(operation *Operation) (ret *TxErr) {
	err := setAttrViewColDateFillSpecificTime(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewColDateFillSpecificTime(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	keyID := operation.ID
	dateValues, _ := attrView.GetKeyValues(keyID)
	if nil == dateValues || av.KeyTypeDate != dateValues.Key.Type {
		return
	}

	if nil == dateValues.Key.Date {
		dateValues.Key.Date = &av.Date{}
	}

	dateValues.Key.Date.FillSpecificTime = operation.Data.(bool)
	for _, v := range dateValues.Values {
		if !v.IsEmpty() {
			continue
		}
		if nil == v.Date {
			v.Date = &av.ValueDate{}
		}
		v.Date.IsNotTime = !dateValues.Key.Date.FillSpecificTime
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewCreatedIncludeTime(operation *Operation) (ret *TxErr) {
	err := setAttrViewCreatedIncludeTime(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewCreatedIncludeTime(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	key, _ := attrView.GetKey(operation.ID)
	if nil == key {
		return
	}

	if nil == key.Created {
		key.Created = &av.Created{}
	}

	key.Created.IncludeTime = operation.Data.(bool)
	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewUpdatedIncludeTime(operation *Operation) (ret *TxErr) {
	err := setAttrViewUpdatedIncludeTime(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttrViewUpdatedIncludeTime(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	key, _ := attrView.GetKey(operation.ID)
	if nil == key {
		return
	}

	if nil == key.Updated {
		key.Updated = &av.Updated{}
	}

	key.Updated.IncludeTime = operation.Data.(bool)
	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doHideAttrViewName(operation *Operation) (ret *TxErr) {
	err := hideAttrViewName(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func hideAttrViewName(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", operation.AvID, err)
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if nil == view {
		logging.LogErrorf("get view [%s] failed: %s", operation.BlockID, err)
		return
	}

	view.HideAttrViewName = operation.Data.(bool)
	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doUpdateAttrViewColRollup(operation *Operation) (ret *TxErr) {
	err := updateAttributeViewColRollup(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColRollup(operation *Operation) (err error) {
	// operation.AvID 汇总字段所在 av
	// operation.ID 汇总字段 ID
	// operation.ParentID 汇总字段基于的关联字段 ID
	// operation.KeyID 目标字段 ID
	// operation.Data 计算方式

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	rollUpKey, _ := attrView.GetKey(operation.ID)
	if nil == rollUpKey {
		return
	}

	var filters []*av.ViewFilter
	oldDestAvID := ""
	if nil != rollUpKey.Rollup {
		filters = rollUpKey.Rollup.Filters
		if oldRelationKey, _ := attrView.GetKey(rollUpKey.Rollup.RelationKeyID); nil != oldRelationKey &&
			nil != oldRelationKey.Relation {
			oldDestAvID = oldRelationKey.Relation.AvID
		}
	}
	newDestAvID := ""
	if newRelationKey, _ := attrView.GetKey(operation.ParentID); nil != newRelationKey && nil != newRelationKey.Relation {
		newDestAvID = newRelationKey.Relation.AvID
	}
	if oldDestAvID != newDestAvID {
		filters = nil
	}
	rollUpKey.Rollup = &av.Rollup{
		RelationKeyID: operation.ParentID,
		KeyID:         operation.KeyID,
		Filters:       filters,
	}

	if nil == operation.Data {
		return
	}

	data := operation.Data.(map[string]any)
	if nil != data["calc"] {
		calcData, jsonErr := gulu.JSON.MarshalJSON(data["calc"])
		if nil != jsonErr {
			err = jsonErr
			return
		}
		if jsonErr = gulu.JSON.UnmarshalJSON(calcData, &rollUpKey.Rollup.Calc); nil != jsonErr {
			err = jsonErr
			return
		}
	}

	// 如果存在该汇总字段的过滤条件,则移除该过滤条件 https://github.com/siyuan-note/siyuan/issues/15660
	for _, view := range attrView.Views {
		view.Filters = av.RemoveFiltersByColumn(view.Filters, rollUpKey.ID)
		if 0 == len(view.Filters) {
			// 保持 spec 5 根组不变量:根组被裁空后补一个空 AND 根组
			view.Filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd}}
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doUpdateAttrViewColRelation(operation *Operation) (ret *TxErr) {
	if err := tx.prepareRelationSourceJournal(operation); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	err := updateAttributeViewColRelation(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColRelation(operation *Operation) (err error) {
	// operation.AvID 源 avID
	// operation.ID 目标 avID
	// operation.KeyID 源 av 关联字段 ID
	// operation.IsTwoWay 是否双向关联
	// operation.BackRelationKeyID 双向关联的目标关联字段 ID
	// operation.Name 双向关联的目标关联字段名称
	// operation.Format 源 av 关联字段名称

	srcAv, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	destAv, err := av.ParseAttributeView(operation.ID)
	if err != nil {
		return
	}

	isSameAv := srcAv.ID == destAv.ID
	if isSameAv {
		destAv = srcAv
	}

	oldDestAvID := ""
	for _, keyValues := range srcAv.KeyValues {
		if keyValues.Key.ID != operation.KeyID {
			continue
		}

		srcRel := keyValues.Key.Relation
		// 已经设置过双向关联的话需要先断开双向关联
		if nil != srcRel {
			oldDestAvID = srcRel.AvID
			if srcRel.IsTwoWay {
				oldDestAv, _ := av.ParseAttributeView(srcRel.AvID)
				if nil != oldDestAv {
					isOldSameAv := oldDestAv.ID == destAv.ID
					if isOldSameAv {
						oldDestAv = destAv
					}

					oldDestKey, _ := oldDestAv.GetKey(srcRel.BackKeyID)
					if nil != oldDestKey && nil != oldDestKey.Relation && oldDestKey.Relation.AvID == srcAv.ID && oldDestKey.Relation.IsTwoWay {
						oldDestKey.Relation.IsTwoWay = false
						oldDestKey.Relation.BackKeyID = ""
					}

					if !isOldSameAv {
						err = av.SaveAttributeView(oldDestAv)
						if err != nil {
							return
						}
					}
				}
			}
		}

		var candidateFilters []*av.ViewFilter
		if nil != srcRel && srcRel.AvID == operation.ID {
			candidateFilters = srcRel.CandidateFilters
		}
		srcRel = &av.Relation{
			AvID:             operation.ID,
			IsTwoWay:         operation.IsTwoWay,
			CandidateFilters: candidateFilters,
		}
		if operation.IsTwoWay {
			srcRel.BackKeyID = operation.BackRelationKeyID
		} else {
			srcRel.BackKeyID = ""
		}
		keyValues.Key.Relation = srcRel
		keyValues.Key.Name = operation.Format

		break
	}
	if oldDestAvID != operation.ID {
		srcAv.RemoveNewItemTemplateFieldValue(operation.KeyID)
		srcAv.RemoveExactRelationFilters(operation.KeyID)
		for _, keyValues := range srcAv.KeyValues {
			if nil != keyValues && nil != keyValues.Key && av.KeyTypeRollup == keyValues.Key.Type &&
				nil != keyValues.Key.Rollup && keyValues.Key.Rollup.RelationKeyID == operation.KeyID {
				keyValues.Key.Rollup.Filters = nil
			}
		}
	}

	destAdded := false
	backRelKey, _ := destAv.GetKey(operation.BackRelationKeyID)
	if nil != backRelKey {
		backRelKey.Relation = &av.Relation{
			AvID:      operation.AvID,
			IsTwoWay:  operation.IsTwoWay,
			BackKeyID: operation.KeyID,
		}
		destAdded = true
		if operation.IsTwoWay {
			name := strings.TrimSpace(operation.Name)
			if "" == name {
				name = srcAv.Name + " " + operation.Format
			}
			backRelKey.Name = strings.TrimSpace(name)
		} else {
			backRelKey.Relation.BackKeyID = ""
		}
	}

	if !destAdded && operation.IsTwoWay {
		// 新建双向关联目标字段
		name := strings.TrimSpace(operation.Name)
		if "" == name {
			name = srcAv.Name + " " + operation.Format
			name = strings.TrimSpace(name)
		}

		destKeyValues := &av.KeyValues{
			Key: &av.Key{
				ID:       operation.BackRelationKeyID,
				Name:     name,
				Type:     av.KeyTypeRelation,
				Relation: &av.Relation{AvID: operation.AvID, IsTwoWay: operation.IsTwoWay, BackKeyID: operation.KeyID},
			},
		}
		addAttributeViewKey(destAv, nil, destKeyValues.Key, "")
		destKeyValues, _ = destAv.GetKeyValues(operation.BackRelationKeyID)

		now := time.Now().UnixMilli()
		// 和现有值进行关联
		for _, keyValues := range srcAv.KeyValues {
			if keyValues.Key.ID != operation.KeyID {
				continue
			}

			for _, srcVal := range keyValues.Values {
				for _, blockID := range srcVal.Relation.BlockIDs {
					destVal := destAv.GetValue(destKeyValues.Key.ID, blockID)
					if nil == destVal {
						destVal = &av.Value{ID: ast.NewNodeID(), KeyID: destKeyValues.Key.ID, BlockID: blockID, Type: keyValues.Key.Type, Relation: &av.ValueRelation{}, CreatedAt: now, UpdatedAt: now + 1000}
					} else {
						destVal.Type = keyValues.Key.Type
						if nil == destVal.Relation {
							destVal.Relation = &av.ValueRelation{}
						}
						destVal.UpdatedAt = now
						destVal.IsRenderAutoFill = false
					}
					destVal.Relation.BlockIDs = append(destVal.Relation.BlockIDs, srcVal.BlockID)
					destVal.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(destVal.Relation.BlockIDs)
					destKeyValues.Values = append(destKeyValues.Values, destVal)
				}
			}
		}
	}

	regenAttrViewGroups(srcAv)
	err = av.SaveAttributeView(srcAv)
	if err != nil {
		return
	}
	if !isSameAv {
		regenAttrViewGroups(destAv)
		err = av.SaveAttributeView(destAv)
		if err != nil {
			return
		}
		ReloadAttrView(destAv.ID)
	}

	if oldDestAvID != "" && oldDestAvID != destAv.ID {
		stillRelated := false
		for _, kv := range srcAv.KeyValues {
			if kv.Key.Type == av.KeyTypeRelation && kv.Key.Relation != nil && kv.Key.Relation.AvID == oldDestAvID {
				stillRelated = true
				break
			}
		}
		if !stillRelated {
			if err = av.RemoveAvRelWithErr(srcAv.ID, oldDestAvID); err != nil {
				return
			}
		}
	}
	if err = av.UpsertAvBackRelWithErr(srcAv.ID, destAv.ID); err != nil {
		return
	}
	if operation.IsTwoWay && !isSameAv {
		if err = av.UpsertAvBackRelWithErr(destAv.ID, srcAv.ID); err != nil {
			return
		}
	}
	if "" != oldDestAvID && oldDestAvID != operation.ID && oldDestAvID != srcAv.ID {
		ReloadAttrView(oldDestAvID)
	}
	return
}

func (tx *Transaction) doSortAttrViewView(operation *Operation) (ret *TxErr) {
	avID := operation.AvID
	attrView, err := avParseView(avID, operation.BlockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", operation.AvID, err)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	view := attrView.GetView(operation.ID)
	if nil == view {
		logging.LogErrorf("get view failed: %s", operation.BlockID)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: av.ErrViewNotFound.Error()}
	}
	viewID := view.ID
	previousViewID := operation.PreviousID
	if "" != previousViewID && nil == attrView.GetView(previousViewID) {
		return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: av.ErrViewNotFound.Error()}
	}
	if viewID == previousViewID {
		return
	}

	var index, previousIndex int
	for i, v := range attrView.Views {
		if v.ID == viewID {
			view = v
			index = i
			break
		}
	}

	attrView.Views = append(attrView.Views[:index], attrView.Views[index+1:]...)
	for i, v := range attrView.Views {
		if v.ID == previousViewID {
			previousIndex = i + 1
			break
		}
	}
	attrView.Views = slices.Insert(attrView.Views, previousIndex, view)

	if err = avSaveView(attrView, operation.BlockID); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrCodeWriteTree, msg: err.Error(), id: avID}
	}
	return
}

func (tx *Transaction) doRemoveAttrViewView(operation *Operation) (ret *TxErr) {
	var err error
	avID := operation.AvID
	attrView, err := avParseView(avID, operation.BlockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrCodeBlockNotFound, id: avID}
	}

	if 1 >= len(attrView.Views) {
		logging.LogWarnf("can't remove last view [%s] of attribute view [%s]", operation.AvID, avID)
		return
	}

	view, err := getAttrViewViewToRemove(attrView, operation)
	if nil == view {
		logging.LogWarnf("get view [%s] to remove failed: %s", operation.ID, err)
		if nil == err {
			err = av.ErrViewNotFound
		}
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	viewID := view.ID
	var index int
	for i, view := range attrView.Views {
		if viewID == view.ID {
			attrView.Views = append(attrView.Views[:i], attrView.Views[i+1:]...)
			index = i - 1
			break
		}
	}
	if 0 > index {
		index = 0
	}

	view = attrView.Views[index]
	if err = avSaveView(attrView, operation.BlockID); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrCodeWriteTree, msg: err.Error(), id: avID}
	}

	trees, nodes := getMirrorBlocksNodes(avID)
	for _, node := range nodes {
		attrs := parse.IAL2Map(node.KramdownIAL)
		changed := false
		visibleViewIDsValue := attrs[av.NodeAttrVisibleViewIDs]
		visibleViewIDs := attrView.GetVisibleViewIDs(visibleViewIDsValue)
		if "" != visibleViewIDsValue {
			normalized := strings.Join(visibleViewIDs, ",")
			if normalized != visibleViewIDsValue {
				attrs[av.NodeAttrVisibleViewIDs] = normalized
				changed = true
			}
		}

		blockViewID := attrs[av.NodeAttrView]
		if blockViewID == viewID {
			attrs[av.NodeAttrView] = visibleViewIDs[0]
			fallbackView := attrView.GetView(visibleViewIDs[0])
			node.AttributeViewType = string(fallbackView.LayoutType)
			changed = true
		}
		if !changed {
			continue
		}

		// 镜像块节点未关联 tree,通过 blocktree 解析 boxID 以走加密笔记本守卫与 box-aware 缓存键
		boxID := ""
		if bt := treenode.GetBlockTree(node.ID); nil != bt {
			boxID = bt.BoxID
		}
		oldAttrs, e := setNodeAttrs0(node, attrs, boxID)
		if nil != e {
			logging.LogErrorf("set node attrs failed: %s", e)
			continue
		}

		cache.PutBlockIALInBox(node.ID, boxID, parse.IAL2Map(node.KramdownIAL))
		pushBlockAttrs(oldAttrs, node)
	}

	for _, tree := range trees {
		if err = indexWriteTreeUpsertQueue(tree); err != nil {
			return
		}
	}

	operation.RetData = view.LayoutType
	return
}

func getAttrViewViewToRemove(attrView *av.AttributeView, operation *Operation) (ret *av.View, err error) {
	if "" != operation.ID {
		ret = attrView.GetView(operation.ID)
		if nil == ret {
			err = av.ErrViewNotFound
		}
		return
	}
	return getAttrViewViewByBlockID(attrView, operation.BlockID)
}

func getMirrorBlocksNodes(avID string) (trees []*parse.Tree, nodes []*ast.Node) {
	mirrorBlockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
	mirrorBlockTrees := filesys.LoadTrees(mirrorBlockIDs)
	for id, tree := range mirrorBlockTrees {
		node := treenode.GetNodeInTree(tree, id)
		if nil == node {
			logging.LogErrorf("get node in tree by block ID [%s] failed", id)
			continue
		}
		nodes = append(nodes, node)
	}

	for _, tree := range mirrorBlockTrees {
		trees = append(trees, tree)
	}
	return
}

func freezeOtherAttrViewBlockVisibleViews(attrView *av.AttributeView, currentBlockID string, currentTree *parse.Tree) (err error) {
	var oldViewIDs []string
	for _, view := range attrView.Views {
		oldViewIDs = append(oldViewIDs, view.ID)
	}
	if 1 > len(oldViewIDs) {
		return
	}
	value := strings.Join(oldViewIDs, ",")

	var otherBlockIDs []string
	for _, blockID := range treenode.GetMirrorAttrViewBlockIDs(attrView.ID) {
		if blockID != currentBlockID {
			otherBlockIDs = append(otherBlockIDs, blockID)
		}
	}
	mirrorBlockTrees := filesys.LoadTrees(otherBlockIDs)
	changedTrees := map[string]*parse.Tree{}
	for blockID, tree := range mirrorBlockTrees {
		if tree.Root.ID == currentTree.Root.ID {
			tree = currentTree
		}
		node := treenode.GetNodeInTree(tree, blockID)
		if nil == node {
			logging.LogErrorf("get node in tree by block ID [%s] failed", blockID)
			continue
		}
		if "" != node.IALAttr(av.NodeAttrVisibleViewIDs) {
			continue
		}

		boxID := tree.Box
		oldAttrs, setErr := setNodeAttrs0(node, map[string]string{av.NodeAttrVisibleViewIDs: value}, boxID)
		if nil != setErr {
			return setErr
		}
		cache.PutBlockIALInBox(node.ID, boxID, parse.IAL2Map(node.KramdownIAL))
		pushBlockAttrs(oldAttrs, node)
		if tree.Root.ID != currentTree.Root.ID {
			changedTrees[tree.Root.ID] = tree
		}
	}

	for _, tree := range changedTrees {
		if err = indexWriteTreeUpsertQueue(tree); nil != err {
			return
		}
	}
	return
}

func (tx *Transaction) doDuplicateAttrViewRow(operation *Operation) (ret *TxErr) {
	srcRowID := ""
	if 0 < len(operation.SrcIDs) {
		srcRowID = operation.SrcIDs[0]
	}
	if "" == srcRowID {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "source row id is empty"}
	}
	if err := DuplicateAttributeViewRow(tx, operation.AvID, operation.PreviousID, srcRowID, operation.ID); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doDuplicateAttrViewView(operation *Operation) (ret *TxErr) {
	var err error
	avID := operation.AvID
	attrView, err := avParseView(avID, operation.BlockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrHandleAttributeView, id: avID}
	}

	masterView := attrView.GetView(operation.PreviousID)
	if nil == masterView {
		logging.LogErrorf("get master view failed: %s", avID)
		return &TxErr{code: TxErrHandleAttributeView, id: avID}
	}

	node, tree, _ := getNodeByBlockID(nil, operation.BlockID)
	if nil == node {
		logging.LogErrorf("get node by block ID [%s] failed", operation.BlockID)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID}
	}

	visibleViewIDs := attrView.GetVisibleViewIDs(node.IALAttr(av.NodeAttrVisibleViewIDs))
	visibleViewIDs = append(visibleViewIDs, operation.ID)
	if err = freezeOtherAttrViewBlockVisibleViews(attrView, operation.BlockID, tree); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	attrs := parse.IAL2Map(node.KramdownIAL)
	attrs[av.NodeAttrView] = operation.ID
	attrs[av.NodeAttrVisibleViewIDs] = strings.Join(visibleViewIDs, ",")
	node.AttributeViewType = string(masterView.LayoutType)
	err = setNodeAttrs(node, tree, attrs)
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", operation.BlockID, err)
		return
	}

	var view *av.View
	switch masterView.LayoutType {
	case av.LayoutTypeCalendar:
		view = av.NewCalendarView()
	case av.LayoutTypeList:
		view = av.NewListView()
	case av.LayoutTypeTable:
		view = av.NewTableView()
	case av.LayoutTypeGallery:
		view = av.NewGalleryView()
	case av.LayoutTypeKanban:
		view = av.NewKanbanView()
	}

	view.ID = operation.ID
	attrView.Views = append(attrView.Views, view)

	view.Icon = masterView.Icon
	view.Name = util.GetDuplicateName(masterView.Name)
	if name := strings.TrimSpace(operation.Name); "" != name {
		view.Name = name
	}
	view.HideAttrViewName = masterView.HideAttrViewName
	view.Desc = masterView.Desc
	view.LayoutType = masterView.LayoutType
	view.PageSize = masterView.PageSize

	view.Filters = av.CloneFilters(masterView.Filters)
	view.ConditionalColors = av.CloneConditionalColors(masterView.ConditionalColors)

	for _, s := range masterView.Sorts {
		view.Sorts = append(view.Sorts, &av.ViewSort{
			Column:       s.Column,
			ValueSource:  s.ValueSource,
			Order:        s.Order,
			DateEndpoint: s.DateEndpoint,
		})
	}

	if err = cloneAttributeViewLayouts(view, masterView); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: err.Error()}
	}

	view.ItemIDs = masterView.ItemIDs

	if nil != masterView.Group {
		view.Group = &av.ViewGroup{}
		if copyErr := copier.Copy(view.Group, masterView.Group); nil != copyErr {
			logging.LogErrorf("copy group failed: %s", copyErr)
			return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: copyErr.Error()}
		}

		view.GroupItemIDs = masterView.GroupItemIDs
		regenAttrViewGroups(attrView)
	}

	if err = avSaveView(attrView, operation.BlockID); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrHandleAttributeView, msg: err.Error(), id: avID}
	}
	return
}

func (tx *Transaction) doAddAttrViewView(operation *Operation) (ret *TxErr) {
	err := addAttrViewViewNamed(operation.AvID, operation.ID, operation.BlockID, operation.Name, operation.Layout)
	if nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func addAttrViewView(avID, viewID, blockID string, layout av.LayoutType) (err error) {
	return addAttrViewViewNamed(avID, viewID, blockID, "", layout)
}

func addAttrViewViewNamed(avID, viewID, blockID, name string, layout av.LayoutType) (err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}

	if 1 > len(attrView.Views) {
		logging.LogErrorf("no view in attribute view [%s]", avID)
		return
	}

	firstView := attrView.Views[0]
	if nil == firstView {
		logging.LogErrorf("get first view failed: %s", avID)
		return
	}

	if "" == layout {
		layout = av.LayoutTypeTable
	}

	fieldIDs := attributeViewFieldIDs(firstView)
	// 表格类布局之间复制字段时保留列宽和对齐,其他来源只带字段顺序。
	var tableColumns []*av.ViewTableColumn
	switch firstView.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		if table := firstView.GetTableLayout(); nil != table {
			tableColumns = table.Columns
		}
	}

	var view *av.View
	switch layout {
	case av.LayoutTypeCalendar:
		view = av.NewCalendarView()
		view.Calendar = newAttributeViewCalendarLayout(attrView, fieldIDs)
	case av.LayoutTypeList:
		view = av.NewListView()
		view.List = newAttributeViewListLayout(attrView, fieldIDs)
	case av.LayoutTypeTable:
		view = av.NewTableView()
		for i, id := range fieldIDs {
			column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: id}}
			if i < len(tableColumns) && nil != tableColumns[i] {
				column.Width, column.Align = tableColumns[i].Width, tableColumns[i].Align
			}
			view.Table.Columns = append(view.Table.Columns, column)
		}
	case av.LayoutTypeGallery:
		view = av.NewGalleryView()
		for _, id := range fieldIDs {
			view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: id}})
		}
	case av.LayoutTypeKanban:
		view = av.NewKanbanView()
		for _, id := range fieldIDs {
			view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: id}})
		}
	default:
		err = av.ErrWrongLayoutType
		logging.LogErrorf("wrong layout type [%s] for attribute view [%s]", layout, avID)
		return
	}

	node, tree, _ := getNodeByBlockID(nil, blockID)
	if nil == node {
		logging.LogErrorf("get node by block ID [%s] failed", blockID)
		return
	}
	visibleViewIDs := attrView.GetVisibleViewIDs(node.IALAttr(av.NodeAttrVisibleViewIDs))
	visibleViewIDs = append(visibleViewIDs, viewID)
	if err = freezeOtherAttrViewBlockVisibleViews(attrView, blockID, tree); nil != err {
		return
	}

	view.ItemIDs = firstView.ItemIDs
	view.ID = viewID
	if name = strings.TrimSpace(name); "" != name {
		view.Name = name
	}
	attrView.Views = append(attrView.Views, view)

	if av.LayoutTypeKanban == layout {
		preferredGroupKey := getKanbanPreferredGroupKey(attrView)
		group := &av.ViewGroup{Field: preferredGroupKey.ID}
		setAttributeViewGroup(attrView, view, group)
	}

	node.AttributeViewType = string(view.LayoutType)
	attrs := parse.IAL2Map(node.KramdownIAL)
	attrs[av.NodeAttrView] = viewID
	attrs[av.NodeAttrVisibleViewIDs] = strings.Join(visibleViewIDs, ",")
	err = setNodeAttrs(node, tree, attrs)
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", blockID, err)
		return
	}

	if err = avSaveView(attrView, blockID); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return
	}
	return
}

func getKanbanPreferredGroupKey(attrView *av.AttributeView) (ret *av.Key) {
	for _, kv := range attrView.KeyValues {
		if av.KeyTypeSelect == kv.Key.Type {
			ret = kv.Key
			break
		}
	}

	if nil == ret {
		name := av.GetAttributeViewI18n("select")
		ret = av.NewKey(ast.NewNodeID(), name, "", av.KeyTypeSelect)
		addAttributeViewKey(attrView, nil, ret, "")
	}
	return
}

// setAttrViewViewField 读取视图并应用 apply 修改后保存,供视图名称、图标、描述的写入共用。
// 视图不存在时按视图 ID 报错,不再沿用上层解析留下的 err,避免打印 "failed: <nil>"。
func (tx *Transaction) setAttrViewViewField(operation *Operation, apply func(view *av.View)) (ret *TxErr) {
	avID := operation.AvID
	attrView, err := avParseView(avID, operation.BlockID)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrHandleAttributeView, id: avID}
	}

	viewID := operation.ID
	view := attrView.GetView(viewID)
	if nil == view {
		logging.LogErrorf("attribute view [%s] has no view [%s]", avID, viewID)
		return &TxErr{code: TxErrHandleAttributeView, id: viewID}
	}

	apply(view)
	if err = avSaveView(attrView, operation.BlockID); err != nil {
		logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
		return &TxErr{code: TxErrHandleAttributeView, msg: err.Error(), id: avID}
	}
	return
}

func (tx *Transaction) doSetAttrViewViewName(operation *Operation) (ret *TxErr) {
	return tx.setAttrViewViewField(operation, func(view *av.View) {
		view.Name = strings.TrimSpace(operation.Data.(string))
	})
}

func (tx *Transaction) doSetAttrViewViewIcon(operation *Operation) (ret *TxErr) {
	return tx.setAttrViewViewField(operation, func(view *av.View) {
		view.Icon = filterAttrViewIconValue(operation.Data.(string))
	})
}

// filterAttrViewIconValue 过滤属性视图图标值,非法值置空,防止存储可执行标记
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-vx5w-qrvp-mmcq
func filterAttrViewIconValue(icon string) string {
	if filtered, valid := util.FilterIconValue(icon); valid {
		return filtered
	}
	return ""
}

func (tx *Transaction) doSetAttrViewViewDesc(operation *Operation) (ret *TxErr) {
	return tx.setAttrViewViewField(operation, func(view *av.View) {
		view.Desc = strings.TrimSpace(operation.Data.(string))
	})
}

func (tx *Transaction) doSetAttrViewName(operation *Operation) (ret *TxErr) {
	err := tx.setAttributeViewName(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewNewItemTemplates(operation *Operation) (ret *TxErr) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	data, err := gulu.JSON.MarshalJSON(operation.Data)
	if nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	config := &av.NewItemTemplatesConfig{}
	if err = gulu.JSON.UnmarshalJSON(data, config); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	if err = attrView.SetNewItemTemplates(config); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	if err = av.SaveAttributeView(attrView); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	ReloadAttrView(operation.AvID)
	return
}

const attrAvNameTpl = `<span data-av-id="${avID}" data-popover-url="/api/av/getMirrorDatabaseBlocks" class="popover__block">${avName}</span>`

func (tx *Transaction) setAttributeViewName(operation *Operation) (err error) {
	avID := operation.ID
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	attrView.Name = strings.TrimSpace(operation.Data.(string))
	attrView.Name = strings.ReplaceAll(attrView.Name, "\n", " ")
	if 512 < utf8.RuneCountInString(attrView.Name) {
		attrView.Name = gulu.Str.SubStr(attrView.Name, 512)
	}
	err = av.SaveAttributeView(attrView)

	_, nodes := tx.getAttrViewBoundNodes(attrView)
	for _, node := range nodes {
		avNames := getAvNames(node.IALAttr(av.NodeAttrNameAvs))
		oldAttrs := parse.IAL2Map(node.KramdownIAL)
		node.SetIALAttr(av.NodeAttrViewNames, avNames)
		pushBlockAttrs(oldAttrs, node)
	}
	return
}

func getAvNames(avIDs string) (ret string) {
	if "" == avIDs {
		return
	}
	avNames := bytes.Buffer{}
	nodeAvIDs := strings.SplitSeq(avIDs, ",")
	for nodeAvID := range nodeAvIDs {
		nodeAvName, getErr := av.GetAttributeViewName(nodeAvID)
		if nil != getErr {
			continue
		}
		if "" == nodeAvName {
			nodeAvName = Conf.language(105)
		}

		tpl := strings.ReplaceAll(attrAvNameTpl, "${avID}", nodeAvID)
		tpl = strings.ReplaceAll(tpl, "${avName}", util.EscapeHTML(nodeAvName))
		avNames.WriteString(tpl)
		avNames.WriteString("&nbsp;")
	}
	if 0 < avNames.Len() {
		avNames.Truncate(avNames.Len() - 6)
		ret = avNames.String()
	}
	return
}

func (tx *Transaction) getAttrViewBoundNodes(attrView *av.AttributeView) (trees map[string]*parse.Tree, nodes []*ast.Node) {
	blockKeyValues := attrView.GetBlockKeyValues()
	if nil == blockKeyValues || nil == blockKeyValues.Values {
		return
	}

	trees = map[string]*parse.Tree{}
	for _, blockKeyValue := range blockKeyValues.Values {
		if blockKeyValue.IsDetached || nil == blockKeyValue.Block {
			continue
		}

		blockID := blockKeyValue.Block.ID
		if "" == blockID {
			continue
		}

		var tree *parse.Tree
		tree = trees[blockID]
		if nil == tree {
			if nil == tx {
				tree, _ = LoadTreeByBlockID(blockID)
			} else {
				tree, _ = tx.loadTree(blockID)
			}
		}
		if nil == tree {
			continue
		}
		trees[blockID] = tree

		node := treenode.GetNodeInTree(tree, blockID)
		if nil == node {
			continue
		}

		nodes = append(nodes, node)
	}
	return
}

func (tx *Transaction) doSetAttrViewFilters(operation *Operation) (ret *TxErr) {
	err := SetAttrViewFilters(operation.AvID, operation.BlockID, operation.Data.([]any))
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewColRelationFilters(operation *Operation) (ret *TxErr) {
	err := setAttrViewColFilters(operation.AvID, operation.BlockID, operation.KeyID, operation.Data.([]any), true)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewColRollupFilters(operation *Operation) (ret *TxErr) {
	err := setAttrViewColFilters(operation.AvID, operation.BlockID, operation.KeyID, operation.Data.([]any), false)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

// avParseView 根据 blockID 推导 AV 的精确加密边界。
func avParseView(avID, blockID string) (*av.AttributeView, error) {
	boxID, exact, err := resolveAttributeViewCarrierBoxID(blockID)
	if nil != err {
		return nil, err
	}
	if exact {
		av.SetAVBoxID(avID, boxID)
		return av.ParseAttributeViewInBox(avID, boxID)
	}
	return av.ParseAttributeView(avID)
}

// avSaveView 根据 blockID 推导 box 上下文,使用 box-aware 或全局 AV 保存。
func avSaveView(attrView *av.AttributeView, blockID string) error {
	boxID, exact, err := resolveAttributeViewCarrierBoxID(blockID)
	if nil != err {
		return err
	}
	if exact {
		av.SetAVBoxID(attrView.ID, boxID)
	}
	return av.SaveAttributeView(attrView)
}

// GetAttributeViewContextFilter 读取物理数据库块独有的上下文筛选配置。
func GetAttributeViewContextFilter(attrView *av.AttributeView,
	blockID string) (ret *av.AttributeViewContextFilter, err error) {
	if nil == attrView || "" == blockID {
		return
	}
	node, _, err := getNodeByBlockID(nil, blockID)
	if nil != err {
		return nil, err
	}
	// 普通内容块的数据库属性面板也会以内容块 ID 渲染属性视图,此时不存在块级上下文筛选。
	if nil == node || ast.NodeAttributeView != node.Type {
		return nil, nil
	}
	if node.AttributeViewID != attrView.ID {
		return nil, fmt.Errorf("block [%s] is not an instance of attribute view [%s]", blockID, attrView.ID)
	}
	ret, err = av.ParseAttributeViewContextFilter(node.IALAttr(av.NodeAttrContextFilter))
	if nil != err {
		return nil, fmt.Errorf("parse attribute view context filter: %w", err)
	}
	return
}

func getAttributeViewInstanceNode(attrView *av.AttributeView,
	blockID string) (node *ast.Node, tree *parse.Tree, err error) {
	if nil == attrView || "" == blockID {
		return nil, nil, av.ErrAttributeViewNotFound
	}
	node, tree, err = getNodeByBlockID(nil, blockID)
	if nil != err {
		return
	}
	if nil == node || nil == tree || ast.NodeAttributeView != node.Type || node.AttributeViewID != attrView.ID {
		return nil, nil, fmt.Errorf("block [%s] is not an instance of attribute view [%s]", blockID, attrView.ID)
	}
	return
}

// SetAttributeViewContextFilter 设置物理数据库块独有的上下文筛选配置,keyID 为空时清除。
func SetAttributeViewContextFilter(blockID, avID, keyID string) (ret *av.AttributeViewContextFilter, err error) {
	return setAttributeViewContextFilter(nil, blockID, avID, keyID)
}

func setAttributeViewContextFilter(tx *Transaction, blockID, avID,
	keyID string) (ret *av.AttributeViewContextFilter, err error) {
	attrView, err := avParseView(avID, blockID)
	if nil != err {
		return nil, err
	}
	node, tree, err := getAttributeViewInstanceNode(attrView, blockID)
	if nil != err {
		return nil, err
	}

	var value string
	keyID = strings.TrimSpace(keyID)
	if "" != keyID {
		ret = &av.AttributeViewContextFilter{Spec: av.AttributeViewContextFilterSpec, KeyID: keyID}
		// undo/redo 重放需要能恢复字段删除或改型后留下的旧配置;普通事务和公开 API 仍严格校验。
		if nil == tx || !tx.isReplay {
			if _, err = resolveAttributeViewContextFilterTarget(attrView, ret, tree.Box); nil != err {
				return nil, fmt.Errorf("validate attribute view context filter target: %w", err)
			}
		}
		if value, err = ret.Marshal(); nil != err {
			return nil, err
		}
	}
	if value == node.IALAttr(av.NodeAttrContextFilter) {
		return
	}

	attrs := map[string]string{av.NodeAttrContextFilter: value}
	if nil != tx {
		err = setNodeAttrsWithTx(tx, node, tree, attrs)
	} else {
		err = setNodeAttrs(node, tree, attrs)
	}
	return
}

func (tx *Transaction) doSetAttrViewContextFilter(operation *Operation) (ret *TxErr) {
	_, err := setAttributeViewContextFilter(tx, operation.BlockID, operation.AvID, operation.KeyID)
	if nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

// resolveAttributeViewFilterContext 将数据库块所在根文档映射为关联目标数据库的条目 ID。
func resolveAttributeViewFilterContext(attrView *av.AttributeView, _ *av.View,
	blockID string) (*av.FilterContext, error) {
	if nil == attrView || "" == blockID {
		return nil, nil
	}
	contextFilter, err := GetAttributeViewContextFilter(attrView, blockID)
	if nil != err {
		return nil, err
	}
	if nil == contextFilter {
		return nil, nil
	}

	context := &av.FilterContext{KeyID: contextFilter.KeyID}
	// 字段删除、改型或关联目标失效时保留块级配置,并以空上下文安全渲染。
	// 这样撤销字段变更后配置可自动恢复,用户也可在界面中显式禁用。
	_, tree, err := getAttributeViewInstanceNode(attrView, blockID)
	if nil != err {
		return nil, err
	}
	targetAttrView, targetErr := resolveAttributeViewContextFilterTarget(attrView, contextFilter, tree.Box)
	if nil != targetErr {
		return context, nil
	}
	blockValue := targetAttrView.GetBlockValueByBoundID(tree.Root.ID)
	if nil != blockValue && "" != blockValue.BlockID {
		context.CurrentDocumentItemIDs = []string{blockValue.BlockID}
	}
	return context, nil
}

func resolveAttributeViewContextFilterTarget(attrView *av.AttributeView, contextFilter *av.AttributeViewContextFilter,
	carrierBoxID string) (ret *av.AttributeView, err error) {
	if nil == contextFilter || av.AttributeViewContextFilterSpec != contextFilter.Spec {
		return nil, av.ErrInvalidAttributeViewContextFilter
	}
	load := attributeViewContextFilterLoader(attrView, carrierBoxID)
	key, err := attrView.ResolveRelationKey(contextFilter.KeyID, load)
	if nil != err {
		return nil, err
	}
	return load(key.Relation.AvID)
}

// GetAttributeViewContextFilterFields 在承载数据库块的笔记本范围内解析上下文筛选候选。
func GetAttributeViewContextFilterFields(attrView *av.AttributeView, blockID string) []*av.AttributeViewContextFilterField {
	boxID, _, err := resolveAttributeViewCarrierBoxID(blockID)
	if nil != err {
		return []*av.AttributeViewContextFilterField{}
	}
	return attrView.ContextFilterFields(attributeViewContextFilterLoader(attrView, boxID))
}

func attributeViewContextFilterLoader(attrView *av.AttributeView,
	carrierBoxID string) func(string) (*av.AttributeView, error) {
	return func(avID string) (*av.AttributeView, error) {
		if nil != attrView && avID == attrView.ID {
			return attrView, nil
		}
		targetBoxID := ""
		if IsEncryptedBox(carrierBoxID) {
			targetBoxID = carrierBoxID
		}
		av.SetAVBoxID(avID, targetBoxID)
		ret, err := av.ParseAttributeViewInBox(avID, targetBoxID)
		if nil != err {
			return nil, err
		}
		if nil == ret {
			return nil, av.ErrAttributeViewNotFound
		}
		return ret, nil
	}
}

func getAttributeViewCarrierBlockTree(blockID string) *treenode.BlockTree {
	if "" == blockID {
		return nil
	}
	blockTree := treenode.GetBlockTree(blockID)
	if nil != blockTree {
		return blockTree
	}
	for _, encBoxID := range treenode.GetOpenedEncryptedBoxIDs() {
		if blockTree = treenode.GetBlockTreeInBox(blockID, encBoxID); nil != blockTree {
			return blockTree
		}
	}
	return nil
}

func resolveAttributeViewCarrierBoxID(blockID string) (boxID string, exact bool, err error) {
	if "" == blockID {
		return "", false, nil
	}
	blockTree := getAttributeViewCarrierBlockTree(blockID)
	if nil == blockTree {
		return "", true, fmt.Errorf("resolve attribute view carrier: block [%s] not found", blockID)
	}
	if IsEncryptedBox(blockTree.BoxID) {
		return blockTree.BoxID, true, nil
	}
	return "", true, nil
}

// SetAttrViewFilters 用新的过滤规则数组整体替换指定视图的过滤规则,并持久化。
// data 为 JSON 反序列化前的 []any(通常是前端传来的过滤节点树)。
func SetAttrViewFilters(avID, blockID string, data []any) (err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return
	}

	jsonData, err := gulu.JSON.MarshalJSON(data)
	if err != nil {
		return
	}

	var newFilters []*av.ViewFilter
	if err = gulu.JSON.UnmarshalJSON(jsonData, &newFilters); err != nil {
		return
	}
	view.Filters = newFilters

	// 归一化为单一根组:spec 5 起顶层应为一个根组。
	// 兜底旧前端/异常数据发来的扁平叶子数组,在内存里包成 AND 根组后再持久化。
	if 1 != len(view.Filters) || nil == view.Filters[0] || !view.Filters[0].IsGroup() {
		view.Filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd, Filters: view.Filters}}
	}

	// 限制筛选嵌套深度,防止异常数据创建过深的嵌套分组。
	if err = av.ValidateFilterDepth(view.Filters); nil != err {
		return
	}

	err = avSaveView(attrView, blockID)
	return
}

func setAttrViewColFilters(avID, blockID, keyID string, data []any, relation bool) (err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}

	key, _ := attrView.GetKey(keyID)
	if nil == key {
		return av.ErrKeyNotFound
	}

	destAvID := ""
	if relation {
		if av.KeyTypeRelation != key.Type || nil == key.Relation {
			return av.ErrKeyNotFound
		}
		destAvID = key.Relation.AvID
	} else {
		if av.KeyTypeRollup != key.Type || nil == key.Rollup {
			return av.ErrKeyNotFound
		}
		relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
		if nil == relationKey || nil == relationKey.Relation {
			return av.ErrKeyNotFound
		}
		destAvID = relationKey.Relation.AvID
	}

	destAttrView := attrView
	if destAvID != avID {
		destAttrView, err = av.ParseAttributeView(destAvID)
		if err != nil {
			return
		}
	}

	jsonData, err := gulu.JSON.MarshalJSON(data)
	if err != nil {
		return
	}
	var filters []*av.ViewFilter
	if err = gulu.JSON.UnmarshalJSON(jsonData, &filters); err != nil {
		return
	}
	if 0 < len(filters) && (1 != len(filters) || nil == filters[0] || !filters[0].IsGroup()) {
		filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd, Filters: filters}}
	}
	if err = av.ValidateFilterDepth(filters); nil != err {
		return
	}

	validColumns := map[string]bool{}
	for _, keyValues := range destAttrView.KeyValues {
		if nil != keyValues && nil != keyValues.Key {
			validColumns[keyValues.Key.ID] = true
		}
	}
	filters, _ = av.PruneInvalidColumnFilters(filters, validColumns)
	if !hasAttrViewFilterConditions(filters) {
		filters = nil
	}

	if relation {
		key.Relation.CandidateFilters = filters
	} else {
		key.Rollup.Filters = filters
	}
	err = avSaveView(attrView, blockID)
	return
}

func hasAttrViewFilterConditions(filters []*av.ViewFilter) bool {
	for _, filter := range filters {
		if nil == filter {
			continue
		}
		if filter.IsGroup() {
			if hasAttrViewFilterConditions(filter.Filters) {
				return true
			}
			continue
		}
		return true
	}
	return false
}

func attrViewFiltersContainColumn(filters []*av.ViewFilter, column string) bool {
	for _, filter := range filters {
		if nil == filter {
			continue
		}
		if filter.IsGroup() {
			if attrViewFiltersContainColumn(filter.Filters, column) {
				return true
			}
			continue
		}
		if filter.Column == column {
			return true
		}
	}
	return false
}

func attrViewFiltersContainOption(filters []*av.ViewFilter, column, optionContent string) bool {
	for _, filter := range filters {
		if nil == filter {
			continue
		}
		if filter.IsGroup() {
			if attrViewFiltersContainOption(filter.Filters, column, optionContent) {
				return true
			}
			continue
		}
		if filter.Column != column || nil == filter.Value {
			continue
		}
		for _, option := range filter.Value.MSelect {
			if nil != option && option.Content == optionContent {
				return true
			}
		}
	}
	return false
}

func removeAttrViewColumnFromFieldFilters(attrView *av.AttributeView, targetAvID, column string) (changed bool) {
	for _, keyValues := range attrView.KeyValues {
		if nil == keyValues || nil == keyValues.Key {
			continue
		}
		key := keyValues.Key
		if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
			attrViewFiltersContainColumn(key.Relation.CandidateFilters, column) {
			key.Relation.CandidateFilters = av.RemoveFiltersByColumn(key.Relation.CandidateFilters, column)
			if !hasAttrViewFilterConditions(key.Relation.CandidateFilters) {
				key.Relation.CandidateFilters = nil
			}
			changed = true
			continue
		}
		if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
			!attrViewFiltersContainColumn(key.Rollup.Filters, column) {
			continue
		}
		relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
		if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
			continue
		}
		key.Rollup.Filters = av.RemoveFiltersByColumn(key.Rollup.Filters, column)
		if !hasAttrViewFilterConditions(key.Rollup.Filters) {
			key.Rollup.Filters = nil
		}
		changed = true
	}
	return
}

func removeAttrViewOptionFromFieldFilters(attrView *av.AttributeView, targetAvID, column,
	optionContent string) (changed bool) {
	for _, keyValues := range attrView.KeyValues {
		if nil == keyValues || nil == keyValues.Key {
			continue
		}
		key := keyValues.Key
		if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
			attrViewFiltersContainOption(key.Relation.CandidateFilters, column, optionContent) {
			key.Relation.CandidateFilters = av.RemoveSelectOptionFromFilters(
				key.Relation.CandidateFilters, column, optionContent)
			if !hasAttrViewFilterConditions(key.Relation.CandidateFilters) {
				key.Relation.CandidateFilters = nil
			}
			changed = true
			continue
		}
		if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
			!attrViewFiltersContainOption(key.Rollup.Filters, column, optionContent) {
			continue
		}
		relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
		if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
			continue
		}
		key.Rollup.Filters = av.RemoveSelectOptionFromFilters(key.Rollup.Filters, column, optionContent)
		if !hasAttrViewFilterConditions(key.Rollup.Filters) {
			key.Rollup.Filters = nil
		}
		changed = true
	}
	return
}

func renameAttrViewOptionInFieldFilters(attrView *av.AttributeView, targetAvID, column,
	oldContent, newContent, newColor string) (changed bool) {
	for _, keyValues := range attrView.KeyValues {
		if nil == keyValues || nil == keyValues.Key {
			continue
		}
		key := keyValues.Key
		if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
			attrViewFiltersContainOption(key.Relation.CandidateFilters, column, oldContent) {
			av.RenameSelectOptionInFilters(key.Relation.CandidateFilters, column, oldContent, newContent, newColor)
			changed = true
			continue
		}
		if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
			!attrViewFiltersContainOption(key.Rollup.Filters, column, oldContent) {
			continue
		}
		relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
		if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
			continue
		}
		av.RenameSelectOptionInFilters(key.Rollup.Filters, column, oldContent, newContent, newColor)
		changed = true
	}
	return
}

func (tx *Transaction) doSetAttrViewSorts(operation *Operation) (ret *TxErr) {
	err := SetAttrViewSorts(operation.AvID, operation.BlockID, operation.Data.([]any))
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

// SetAttrViewSorts 用新的排序规则数组整体替换指定视图的排序规则,并持久化。
// data 为 JSON 反序列化前的 []any。
func SetAttrViewSorts(avID, blockID string, data []any) (err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return
	}

	jsonData, err := gulu.JSON.MarshalJSON(data)
	if err != nil {
		return
	}

	var newSorts []*av.ViewSort
	if err = gulu.JSON.UnmarshalJSON(jsonData, &newSorts); err != nil {
		return
	}
	view.Sorts = newSorts

	err = avSaveView(attrView, blockID)
	return
}

func (tx *Transaction) doSetAttrViewPageSize(operation *Operation) (ret *TxErr) {
	err := setAttributeViewPageSize(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewPageSize(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	view.PageSize = int(operation.Data.(float64))

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColCalc(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColumnCalc(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColumnCalc(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	operationData := operation.Data
	data, err := gulu.JSON.MarshalJSON(operationData)
	if err != nil {
		return
	}

	calc := &av.FieldCalc{}
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		if err = gulu.JSON.UnmarshalJSON(data, calc); err != nil {
			return
		}

		for _, column := range view.GetTableLayout().Columns {
			if column.ID == operation.ID {
				column.Calc = calc
				break
			}
		}
	case av.LayoutTypeGallery, av.LayoutTypeKanban:
		return
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doInsertAttrViewBlock(operation *Operation) (ret *TxErr) {
	if operation.attributeViewFields != nil {
		if err := tx.restoreDeletedAttributeViewBlocks(operation); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
		return
	}
	if nil != operation.attributeViewItems {
		if err := tx.restoreAttributeViewItems(operation); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
		return
	}
	result, err := addAttributeViewBlocks(tx, operation.Srcs, operation.AvID, operation.BlockID, operation.ViewID,
		operation.GroupID, operation.PreviousID, operation.IgnoreDefaultFill, operation.attributeViewAutomation, operation.attributeViewCollectionRuleID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	operation.RetData = result
	return
}

func AddAttributeViewBlock(tx *Transaction, srcs []map[string]any, avID, dbBlockID, viewID, groupID, previousItemID string, ignoreDefaultFill bool) (err error) {
	_, err = addAttributeViewBlocks(tx, srcs, avID, dbBlockID, viewID, groupID, previousItemID, ignoreDefaultFill, false)
	return
}

type insertAttrViewBlockResult struct {
	InsertedItemIDs []string `json:"insertedItemIDs"`
	ExistingItemIDs []string `json:"existingItemIDs"`
}

func addAttributeViewBlocks(tx *Transaction, srcs []map[string]any, avID, dbBlockID, viewID, groupID, previousItemID string,
	ignoreDefaultFill, databaseScope bool, collectionRuleIDs ...string) (result *insertAttrViewBlockResult, err error) {
	result = &insertAttrViewBlockResult{}
	if 0 == len(srcs) {
		return
	}
	slices.Reverse(srcs) // https://github.com/siyuan-note/siyuan/issues/11286
	attrView, err := avParseView(avID, dbBlockID)
	if err != nil {
		return
	}
	if err = tx.rememberAutomationView(attrView, dbBlockID); err != nil {
		return
	}

	// 整批校验完成后再写入,避免后续条目越界时已修改前面的绑定。
	boundTrees := map[string]*parse.Tree{}
	detachedSources := make([]bool, len(srcs))
	for index, src := range srcs {
		if nil == src {
			return result, fmt.Errorf("invalid attribute view source [%d]", index)
		}
		// 绑定条目的序列化数据可能省略值为 false 的字段,撤销重放时按绑定状态读取。
		isDetached, ok := src["isDetached"].(bool)
		if !ok && nil != src["isDetached"] {
			return result, fmt.Errorf("invalid attribute view source [%d]: isDetached must be a boolean", index)
		}
		detachedSources[index] = isDetached
		if isDetached {
			continue
		}
		id, ok := src["id"].(string)
		if !ok {
			return result, fmt.Errorf("invalid attribute view source [%d]: id must be a string", index)
		}
		if !ast.IsNodeIDPattern(id) {
			continue
		}
		var tree *parse.Tree
		if tx != nil {
			tree, err = tx.loadTree(id)
		} else {
			tree, err = LoadTreeByBlockID(id)
		}
		if err != nil {
			return
		}
		if err = validateAttributeViewBinding(avID, tree); err != nil {
			return
		}
		boundTrees[id] = tree
	}

	now := time.Now().UnixMilli()
	for index, src := range srcs {
		boundBlockID := ""
		srcItemID := ast.NewNodeID()
		if nil != src["itemID"] {
			srcItemID = src["itemID"].(string)
		}

		isDetached := detachedSources[index]
		var tree *parse.Tree
		if !isDetached {
			boundBlockID = src["id"].(string)
			if !ast.IsNodeIDPattern(boundBlockID) {
				continue
			}

			tree = boundTrees[boundBlockID]
		}

		var srcContent string
		if nil != src["content"] {
			srcContent = src["content"].(string)
		}
		if avErr := addAttributeViewBlock0(attrView, now, avID, dbBlockID, viewID, groupID, previousItemID, srcItemID, boundBlockID, srcContent, src, isDetached, ignoreDefaultFill, databaseScope, tree, tx, result, collectionRuleIDs...); nil != avErr {
			err = avErr
			return
		}
	}
	regenAttrViewGroups(attrView)
	err = av.SaveAttributeView(attrView)
	return
}

func addAttributeViewBlock(now int64, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent string, src map[string]any, isDetached, ignoreDefaultFill bool, tree *parse.Tree, tx *Transaction, result *insertAttrViewBlockResult) (err error) {
	attrView, err := avParseView(avID, dbBlockID)
	if err != nil {
		return
	}
	if err = addAttributeViewBlock0(attrView, now, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent, src, isDetached, ignoreDefaultFill, false, tree, tx, result); nil != err {
		return
	}
	regenAttrViewGroups(attrView)
	err = av.SaveAttributeView(attrView)
	return
}

func addAttributeViewBlock0(attrView *av.AttributeView, now int64, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent string, src map[string]any, isDetached, ignoreDefaultFill, databaseScope bool, tree *parse.Tree, tx *Transaction, result *insertAttrViewBlockResult, collectionRuleIDs ...string) (err error) {
	var node *ast.Node
	if !isDetached {
		if err = validateAttributeViewBinding(avID, tree); err != nil {
			return
		}
		node = treenode.GetNodeInTree(tree, addingBoundBlockID)
		if nil == node {
			err = ErrBlockNotFound
			return
		}
	} else {
		if "" == addingItemID {
			addingItemID = ast.NewNodeID()
			logging.LogWarnf("detached block id is empty, generate a new one [%s]", addingItemID)
		}
	}

	var blockIcon string
	var blockRefSubtype av.BlockRefSubtype
	if !isDetached {
		blockIcon, addingBlockContent = getNodeAvBlockText(node, avID)
		blockRefSubtype = getNodeAvBlockRefSubtype(node, avID)
		addingBlockContent = util.UnescapeHTML(addingBlockContent)
	}

	// 检查是否重复添加相同的块
	blockValues := attrView.GetBlockKeyValues()
	if nil == blockValues || nil == blockValues.Key {
		return fmt.Errorf("attribute view [%s] has no block key", avID)
	}
	for _, blockValue := range blockValues.Values {
		if nil == blockValue || nil == blockValue.Block {
			continue
		}
		if "" != addingBoundBlockID && blockValue.Block.ID == addingBoundBlockID {
			if !isDetached {
				// 重复绑定一下,比如剪切数据库块、取消绑定块后再次添加的场景需要
				bindBlockAv0(tx, avID, node, tree)
				blockValue.IsDetached = isDetached
				blockValue.Block.Icon = blockIcon
				blockValue.Block.Content = addingBlockContent
				blockValue.Block.RefSubtype = blockRefSubtype
				blockValue.UpdatedAt = now
			}

			msg := fmt.Sprintf(Conf.language(269), util.EscapeHTML(getAttrViewName(attrView)))
			util.PushMsg(msg, 5000)
			src["itemID"] = blockValue.BlockID
			if nil == err {
				result.ExistingItemIDs = append(result.ExistingItemIDs, blockValue.BlockID)
			}
			return
		}
	}

	blockValue := &av.Value{
		ID:         ast.NewNodeID(),
		KeyID:      blockValues.Key.ID,
		BlockID:    addingItemID,
		Type:       av.KeyTypeBlock,
		IsDetached: isDetached,
		CreatedAt:  now,
		UpdatedAt:  now,
		Block:      &av.ValueBlock{Icon: blockIcon, Content: addingBlockContent, RefSubtype: blockRefSubtype, Created: now, Updated: now}}
	if !isDetached {
		blockValue.Block.ID = addingBoundBlockID
		if len(collectionRuleIDs) > 0 {
			blockValue.Block.CollectionRuleID = collectionRuleIDs[0]
		}
	}

	blockValues.Values = append(blockValues.Values, blockValue)

	viewBlockID := dbBlockID
	if databaseScope {
		viewBlockID = ""
	}
	view, err := getAttrViewViewByBlockID(attrView, viewBlockID)
	if nil != err {
		logging.LogErrorf("get view by block ID [%s] failed: %s", dbBlockID, err)
		return
	}

	if "" != viewID {
		view = attrView.GetView(viewID)
		if nil == view {
			logging.LogErrorf("get view by view ID [%s] failed", viewID)
			return av.ErrViewNotFound
		}
	}

	groupView := view
	if "" != groupID {
		groupView = view.GetGroupByID(groupID)
	}

	useGroupDefault := "" != groupID
	var filterContext *av.FilterContext
	if !databaseScope {
		filterContext, err = resolveAttributeViewFilterContext(attrView, view, dbBlockID)
		if err != nil {
			return err
		}
	}
	if nil != filterContext && 1 > len(filterContext.CurrentDocumentItemIDs) {
		return av.ErrAttributeViewContextNotBound
	}
	if !ignoreDefaultFill {
		if err = fillDefaultValue(attrView, view, groupView, previousItemID, addingItemID, true, useGroupDefault,
			dbBlockID, filterContext); nil != err {
			return
		}
	} else {
		if err = fillAttributeViewContextFilterValue(attrView, groupView, addingItemID, filterContext,
			dbBlockID); nil != err {
			return
		}
	}

	// 处理日期字段默认填充当前创建时间
	// The database date field supports filling the current time by default https://github.com/siyuan-note/siyuan/issues/10823
	fillAttrViewAutoFillNowValues(attrView, addingItemID, isDetached, now)

	if !isDetached {
		bindBlockAv0(tx, avID, node, tree)
	}

	// 在所有视图上添加项目
	for _, v := range attrView.Views {
		if "" != previousItemID {
			changed := false
			for i, id := range v.ItemIDs {
				if id == previousItemID {
					v.ItemIDs = append(v.ItemIDs[:i+1], append([]string{addingItemID}, v.ItemIDs[i+1:]...)...)
					changed = true
					break
				}
			}
			if !changed {
				v.ItemIDs = append(v.ItemIDs, addingItemID)
			}
		} else {
			v.ItemIDs = append([]string{addingItemID}, v.ItemIDs...)
		}

		// 在所有分组视图中添加,目的是为了在重新分组的过程中保住排序状态 https://github.com/siyuan-note/siyuan/issues/15560
		for _, g := range v.Groups {
			if "" != previousItemID {
				changed := false
				for i, id := range g.GroupItemIDs {
					if id == previousItemID {
						g.GroupItemIDs = append(g.GroupItemIDs[:i+1], append([]string{addingItemID}, g.GroupItemIDs[i+1:]...)...)
						changed = true
						break
					}
				}
				if !changed {
					g.GroupItemIDs = append(g.GroupItemIDs, addingItemID)
				}
			} else {
				g.GroupItemIDs = append([]string{addingItemID}, g.GroupItemIDs...)
			}
		}
	}

	result.InsertedItemIDs = append(result.InsertedItemIDs, addingItemID)
	return
}

func fillAttrViewAutoFillNowValues(attrView *av.AttributeView, addingItemID string, isDetached bool, now int64) {
	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeDate == keyValues.Key.Type && nil != keyValues.Key.Date && keyValues.Key.Date.AutoFillNow {
			val := keyValues.GetValue(addingItemID)
			if nil == val {
				dateVal := &av.Value{
					ID: ast.NewNodeID(), KeyID: keyValues.Key.ID, BlockID: addingItemID, Type: av.KeyTypeDate, IsDetached: isDetached, CreatedAt: now, UpdatedAt: now + 1000,
					Date: &av.ValueDate{Content: now, IsNotEmpty: true, IsNotTime: !keyValues.Key.Date.FillSpecificTime},
				}
				keyValues.Values = append(keyValues.Values, dateVal)
			} else {
				if nil == val.Date {
					val.Date = &av.ValueDate{}
				}
				val.CreatedAt, val.UpdatedAt = now, now+1000
				val.Date.Content, val.Date.IsNotEmpty, val.Date.IsNotTime = now, true, !keyValues.Key.Date.FillSpecificTime
				val.IsRenderAutoFill = false
			}
		}
	}
}

func fillDefaultValue(attrView *av.AttributeView, view, groupView *av.View, previousItemID, addingItemID string,
	isCreate, useGroupDefault bool, blockID string, filterContexts ...*av.FilterContext) (err error) {
	filterContext := firstAttributeViewFilterContext(filterContexts)
	defaultValues := getAttrViewAddingBlockDefaultValues(attrView, view, groupView, previousItemID, addingItemID,
		isCreate, useGroupDefault, filterContext)
	err = writeAttributeViewDefaultValues(attrView, groupView, addingItemID, defaultValues, blockID)
	return
}

func fillAttributeViewContextFilterValue(attrView *av.AttributeView, groupView *av.View, addingItemID string,
	filterContext *av.FilterContext, blockID string) (err error) {
	defaultValues := map[string]*av.Value{}
	applyAttributeViewContextFilterDefaultValue(attrView, addingItemID, filterContext, defaultValues)
	err = writeAttributeViewDefaultValues(attrView, groupView, addingItemID, defaultValues, blockID)
	return
}

func writeAttributeViewDefaultValues(attrView *av.AttributeView, groupView *av.View, addingItemID string,
	defaultValues map[string]*av.Value, blockID string) (err error) {
	for keyID, newValue := range defaultValues {
		newValue.BlockID = addingItemID
		keyValues, getErr := attrView.GetKeyValues(keyID)
		if nil != getErr {
			continue
		}

		if av.KeyTypeRollup == newValue.Type {
			// 汇总字段的值是渲染时计算的,不需要添加到数据存储中
			continue
		}

		if nil != groupView && (av.KeyTypeSelect == newValue.Type || av.KeyTypeMSelect == newValue.Type) &&
			1 > len(newValue.MSelect) && groupValueDefault != groupView.GetGroupValue() {
			// 单选或多选类型的值可能需要从分组条件中获取默认值
			if opt := keyValues.Key.GetOption(groupView.GetGroupValue()); nil != opt {
				newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
			}
		}

		if av.KeyTypeRelation == newValue.Type && nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay {
			// 双向关联需要同时更新目标字段的值
			if err = updateTwoWayRelationDestAttrViewInBlock(attrView, keyValues.Key, newValue, 1, []string{},
				blockID); nil != err {
				return
			}
		}

		existingVal := keyValues.GetValue(addingItemID)
		if nil == existingVal {
			newValue.IsRenderAutoFill = false
			keyValues.Values = append(keyValues.Values, newValue)
		} else {
			newValueRaw := newValue.GetValByType(keyValues.Key.Type)
			if av.KeyTypeBlock != existingVal.Type || (av.KeyTypeBlock == existingVal.Type && existingVal.IsDetached) {
				// 非主键的值直接覆盖,主键的值只覆盖非绑定块
				existingVal.IsRenderAutoFill = false
				existingVal.SetValByType(keyValues.Key.Type, newValueRaw)
			}
		}
	}
	return
}

func getNewValueByNearItem(nearItem av.Item, key *av.Key, addingBlockID string) (ret *av.Value) {
	if nil == nearItem {
		return
	}

	defaultVal := nearItem.GetValue(key.ID)
	if nil == defaultVal {
		return
	}
	ret = defaultVal.Clone()
	if nil == ret {
		return
	}
	ret.ID = ast.NewNodeID()
	ret.KeyID = key.ID
	ret.BlockID = addingBlockID
	ret.CreatedAt = util.CurrentTimeMillis()
	ret.UpdatedAt = ret.CreatedAt + 1000
	return
}

func getNearItem(attrView *av.AttributeView, view, groupView *av.View, previousItemID string,
	filterContexts ...*av.FilterContext) (ret av.Item) {
	// 邻近条目查找会过滤和排序缓存,完成后清除临时结果,确保默认值写入后按完整数据重新生成分组。
	defer clear(attrView.RenderedViewables)
	cachedAttrViews := map[string]*av.AttributeView{}
	rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
	viewable := sql.RenderGroupView(attrView, view, groupView, "")
	av.FilterWithContext(viewable, attrView, rollupFurtherCollections, cachedAttrViews,
		firstAttributeViewFilterContext(filterContexts))
	av.Sort(viewable, attrView)
	items := viewable.(av.Collection).GetItems()
	if 0 < len(items) {
		if "" != previousItemID {
			for _, row := range items {
				if row.GetID() == previousItemID {
					ret = row
					return
				}
			}
		} else {
			if 0 < len(items) {
				ret = items[0]
				return
			}
		}
	}
	return
}

func (tx *Transaction) doRemoveAttrViewBlock(operation *Operation) (ret *TxErr) {
	if err := tx.prepareAttributeViewItemRemoval(operation); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	err := removeAttributeViewBlock(operation.SrcIDs, operation.AvID, operation.BlockID, tx)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func RemoveAttributeViewBlock(srcIDs []string, avID string) (err error) {
	err = removeAttributeViewBlock(srcIDs, avID, "", nil)
	return
}

func removeAttributeViewBlock(srcIDs []string, avID, blockID string, tx *Transaction) (err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}
	relationDestAvIDs := map[string]bool{}
	for _, keyValues := range attrView.KeyValues {
		if av.KeyTypeRelation != keyValues.Key.Type || nil == keyValues.Key.Relation {
			continue
		}
		for _, value := range keyValues.Values {
			if gulu.Str.Contains(value.BlockID, srcIDs) {
				relationDestAvIDs[keyValues.Key.Relation.AvID] = true
				break
			}
		}
	}

	trees := map[string]*parse.Tree{}
	removedValues := false
	for _, keyValues := range attrView.KeyValues {
		tmp := keyValues.Values[:0]
		for i, val := range keyValues.Values {
			if !gulu.Str.Contains(val.BlockID, srcIDs) {
				tmp = append(tmp, keyValues.Values[i])
			} else {
				removedValues = true
				if av.KeyTypeRelation == keyValues.Key.Type && nil != keyValues.Key.Relation &&
					keyValues.Key.Relation.IsTwoWay && nil != val.Relation && 0 < len(val.Relation.BlockIDs) {
					clearedValue := val.Clone()
					oldRelationBlockIDs := append([]string(nil), val.Relation.BlockIDs...)
					clearedValue.Relation.BlockIDs = nil
					if err = updateTwoWayRelationDestAttrViewInBlock(attrView, keyValues.Key, clearedValue, 2,
						oldRelationBlockIDs, blockID); nil != err {
						return
					}
					tx.invalidateAttributeViewHistory(keyValues.Key.Relation.AvID)
				}
				// Remove av block also remove node attr https://github.com/siyuan-note/siyuan/issues/9091#issuecomment-1709824006
				if !val.IsDetached && nil != val.Block {
					bt := attributeViewBindingBlockTree(val.Block.ID, av.GetAVBoxID(avID))
					if bt != nil && (tx == nil || tx.trees[bt.RootID] == nil) {
						if _, statErr := os.Stat(filepath.Join(util.DataDir, bt.BoxID, bt.Path)); statErr != nil {
							if !errors.Is(statErr, os.ErrNotExist) {
								return statErr
							}
							bt = nil
						}
					}
					if nil != bt {
						tree := trees[bt.RootID]
						if nil == tree {
							if nil != tx {
								tree, _ = tx.loadTree(val.Block.ID)
							} else {
								tree, _ = LoadTreeByBlockID(val.Block.ID)
							}
						}

						if nil != tree {
							trees[bt.RootID] = tree
							if node := treenode.GetNodeInTree(tree, val.Block.ID); nil != node {
								if err = removeNodeAvID(node, avID, tx, tree); err != nil {
									return
								}
							}
						}
					}
				}
			}
		}
		keyValues.Values = tmp
	}

	for _, view := range attrView.Views {
		for _, blockID := range srcIDs {
			view.ItemIDs = gulu.Str.RemoveElem(view.ItemIDs, blockID)
		}
	}
	for _, itemID := range srcIDs {
		attrView.RemoveCardCoverPositions(itemID)
	}
	attrView.RemoveNewItemTemplateRelationItems(avID, srcIDs)
	attrView.RemoveRelationFilterItems(avID, srcIDs)

	regenAttrViewGroups(attrView)

	err = avSaveView(attrView, blockID)
	if nil != err {
		return
	}
	if removedValues {
		tx.invalidateAttributeViewHistory(avID)
	}
	if err = removeRelatedRelationItems(avID, srcIDs, blockID, tx); nil != err {
		return
	}

	refreshRelatedSrcAvsInBlock(avID, blockID, tx)
	for destAvID := range relationDestAvIDs {
		if "" != destAvID && destAvID != avID {
			ReloadAttrView(destAvID)
		}
	}

	historyDir, err := getHistoryDir(HistoryOpUpdate)
	if err != nil {
		logging.LogErrorf("get history dir failed: %s", err)
		return
	}
	blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
	carrierBoxID, exact, _ := resolveAttributeViewCarrierBoxID(blockID)
	for _, mirrorBlockID := range blockIDs {
		if exact {
			mirrorBoxID, mirrorExact, resolveErr := resolveAttributeViewCarrierBoxID(mirrorBlockID)
			if nil != resolveErr || !mirrorExact || mirrorBoxID != carrierBoxID {
				continue
			}
		}
		tree := trees[mirrorBlockID]
		if nil == tree {
			tree, _ = LoadTreeByBlockID(mirrorBlockID)
		}
		if nil == tree {
			continue
		}

		historyPath := filepath.Join(historyDir, tree.Box, tree.Path)
		absPath := filepath.Join(util.DataDir, tree.Box, tree.Path)
		if err = filelock.Copy(absPath, historyPath); err != nil {
			logging.LogErrorf("backup [path=%s] to history [%s] failed: %s", absPath, historyPath, err)
			return
		}
	}

	var srcAvPath string
	if exact {
		srcAvPath, _ = av.FindAttributeViewPathInBox(avID, carrierBoxID)
	} else {
		srcAvPath, _ = av.FindAttributeViewPath(avID)
	}
	if srcAvPath == "" {
		return
	}
	destAvPath := filepath.Join(historyDir, "storage", "av", avID+".json")
	if exact && "" != carrierBoxID {
		destAvPath = filepath.Join(historyDir, carrierBoxID, "storage", "av", avID+".json")
	}
	if copyErr := filelock.Copy(srcAvPath, destAvPath); nil != copyErr {
		logging.LogErrorf("copy av [%s] failed: %s", srcAvPath, copyErr)
	}

	indexHistoryDir(filepath.Base(historyDir), util.NewLute())
	return
}

func removeRelatedRelationItems(avID string, itemIDs []string, blockID string, tx *Transaction) (err error) {
	for _, relatedAvID := range av.GetSrcAvIDs(avID) {
		if relatedAvID == avID {
			continue
		}
		relatedAv, parseErr := avParseView(relatedAvID, blockID)
		if nil != parseErr || nil == relatedAv {
			continue
		}
		templateChanged := relatedAv.RemoveNewItemTemplateRelationItems(avID, itemIDs)
		filterChanged := relatedAv.RemoveRelationFilterItems(avID, itemIDs)
		if !templateChanged && !filterChanged {
			continue
		}
		if err = avSaveView(relatedAv, blockID); nil != err {
			return
		}
		tx.invalidateAttributeViewHistory(relatedAvID)
		ReloadAttrView(relatedAvID)
	}
	return
}

func removeNodeAvID(node *ast.Node, avID string, tx *Transaction, tree *parse.Tree) (err error) {
	attrs := removeNodeAvIDAttrs(node, avID)
	if nil != tx {
		if err = setNodeAttrsWithTx(tx, node, tree, attrs); err != nil {
			return
		}
	} else {
		if err = setNodeAttrs(node, tree, attrs); err != nil {
			return
		}
	}
	return
}

func removeNodeAvIDAttrs(node *ast.Node, avID string) map[string]string {
	attrs := parse.IAL2Map(node.KramdownIAL)

	if avs := attrs[av.NodeAttrNameAvs]; "" != avs {
		avIDs := strings.Split(avs, ",")
		avIDs = gulu.Str.RemoveElem(avIDs, avID)
		var existAvIDs []string
		for _, attributeViewID := range avIDs {
			if av.IsAttributeViewExist(attributeViewID) {
				existAvIDs = append(existAvIDs, attributeViewID)
			}
		}
		avIDs = existAvIDs

		if 0 == len(avIDs) {
			attrs[av.NodeAttrNameAvs] = ""
		} else {
			attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
			node.SetIALAttr(av.NodeAttrNameAvs, strings.Join(avIDs, ","))
			avNames := getAvNames(node.IALAttr(av.NodeAttrNameAvs))
			attrs[av.NodeAttrViewNames] = avNames
		}
	}
	return attrs
}

func (tx *Transaction) doDuplicateAttrViewKey(operation *Operation) (ret *TxErr) {
	err := duplicateAttributeViewKey(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func duplicateAttributeViewKey(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	key, _ := attrView.GetKey(operation.KeyID)
	if nil == key {
		return
	}

	if av.KeyTypeBlock == key.Type || av.KeyTypeRelation == key.Type {
		return
	}

	copyKey := &av.Key{}
	if err = copier.Copy(copyKey, key); err != nil {
		logging.LogErrorf("clone key failed: %s", err)
	}
	copyKey.ID = operation.NextID
	copyKey.Name = util.GetDuplicateName(key.Name)

	attrView.KeyValues = append(attrView.KeyValues, &av.KeyValues{Key: copyKey})

	for _, view := range attrView.Views {
		for _, layout := range view.TableLayouts() {
			if nil == layout {
				continue
			}
			for i, column := range layout.Columns {
				if column.ID != key.ID {
					continue
				}
				cloned := &av.ViewTableColumn{}
				if err = copier.CopyWithOption(cloned, column, copier.Option{DeepCopy: true}); nil != err {
					return
				}
				cloned.ID = copyKey.ID
				if layout == view.List && av.LayoutTypeList != view.LayoutType ||
					view.Calendar != nil && layout == view.Calendar.LayoutTable && av.LayoutTypeCalendar != view.LayoutType {
					cloned.Hidden = true
				}
				layout.Columns = slices.Insert(layout.Columns, i+1, cloned)
				break
			}
		}
		if nil != view.Gallery {
			for i, field := range view.Gallery.CardFields {
				if field.ID != key.ID {
					continue
				}
				cloned := &av.ViewGalleryCardField{}
				if err = copier.CopyWithOption(cloned, field, copier.Option{DeepCopy: true}); nil != err {
					return
				}
				cloned.ID = copyKey.ID
				view.Gallery.CardFields = slices.Insert(view.Gallery.CardFields, i+1, cloned)
				break
			}
		}
		if nil != view.Kanban {
			for i, field := range view.Kanban.Fields {
				if field.ID != key.ID {
					continue
				}
				cloned := &av.ViewKanbanField{}
				if err = copier.CopyWithOption(cloned, field, copier.Option{DeepCopy: true}); nil != err {
					return
				}
				cloned.ID = copyKey.ID
				view.Kanban.Fields = slices.Insert(view.Kanban.Fields, i+1, cloned)
				break
			}
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnWidth(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColWidth(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColWidth(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	switch view.LayoutType {
	case av.LayoutTypeTable:
		for _, column := range view.Table.Columns {
			if column.ID == operation.ID {
				column.Width = av.FilterWidthValue(operation.Data.(string))
				break
			}
		}
	case av.LayoutTypeGallery, av.LayoutTypeKanban:
		return
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnsWidth(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColsWidth(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColsWidth(operation *Operation) (err error) {
	widthData, ok := operation.Data.(map[string]any)
	if !ok {
		return fmt.Errorf("invalid attribute view column widths")
	}
	widths := map[string]string{}
	for id, value := range widthData {
		width, valueOK := value.(string)
		if !valueOK {
			return fmt.Errorf("invalid width for attribute view column [%s]", id)
		}
		widths[id] = width
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return err
	}
	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return err
	}
	if av.LayoutTypeTable != view.LayoutType {
		return nil
	}
	for _, column := range view.Table.Columns {
		if width, found := widths[column.ID]; found {
			column.Width = av.FilterWidthValue(width)
		}
	}
	return av.SaveAttributeView(attrView)
}

func (tx *Transaction) doSetAttrViewColumnAlign(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColAlign(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColAlign(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	if av.LayoutTypeTable != view.LayoutType {
		return
	}

	alignValue, ok := operation.Data.(string)
	align := av.TableColumnAlign(alignValue)
	if !ok || !align.IsValid() {
		return av.ErrInvalidColumnAlign
	}
	for _, column := range view.Table.Columns {
		if column.ID == operation.ID {
			column.Align = align
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnWrap(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColWrap(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColWrap(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	newWrap := operation.Data.(bool)
	allFieldWrap := true
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		for _, column := range view.GetTableLayout().Columns {
			if column.ID == operation.ID {
				column.Wrap = newWrap
			}
			allFieldWrap = allFieldWrap && column.Wrap
		}
		view.GetTableLayout().WrapField = allFieldWrap
	case av.LayoutTypeGallery:
		for _, field := range view.Gallery.CardFields {
			if field.ID == operation.ID {
				field.Wrap = newWrap
			}
			allFieldWrap = allFieldWrap && field.Wrap
		}
		view.Gallery.WrapField = allFieldWrap
	case av.LayoutTypeKanban:
		for _, field := range view.Kanban.Fields {
			if field.ID == operation.ID {
				field.Wrap = newWrap
			}
			allFieldWrap = allFieldWrap && field.Wrap
		}
		view.Kanban.WrapField = allFieldWrap
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnHidden(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColHidden(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColHidden(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	viewIDs := operation.ViewIDs
	if 1 > len(viewIDs) {
		if "" != operation.ViewID {
			viewIDs = []string{operation.ViewID}
		} else {
			var view *av.View
			view, err = getAttrViewViewByBlockID(attrView, operation.BlockID)
			if err != nil {
				return
			}
			viewIDs = []string{view.ID}
		}
	}

	err = setAttributeViewFieldsHidden(attrView, operation.ID, viewIDs, operation.Data.(bool))
	if err != nil {
		return
	}
	err = av.SaveAttributeView(attrView)
	return
}

func setAttributeViewFieldsHidden(attrView *av.AttributeView, keyID string, viewIDs []string, hidden bool) (err error) {
	var fields []*av.BaseField
	seen := map[string]bool{}
	for _, viewID := range viewIDs {
		if seen[viewID] {
			continue
		}
		seen[viewID] = true

		view := attrView.GetView(viewID)
		if nil == view {
			return fmt.Errorf("view [%s] not found", viewID)
		}
		if hidden && (av.LayoutTypeList == view.LayoutType || av.LayoutTypeCalendar == view.LayoutType) {
			key, keyErr := attrView.GetKey(keyID)
			if nil != keyErr {
				return keyErr
			}
			if av.KeyTypeBlock == key.Type {
				return errors.New("cannot hide the primary key in a list view")
			}
		}
		field := getAttributeViewField(view, keyID)
		if nil == field {
			return fmt.Errorf("field [%s] not found in view [%s]", keyID, viewID)
		}
		fields = append(fields, field)
	}

	if 1 > len(fields) {
		return errors.New("view IDs is empty")
	}
	for _, field := range fields {
		field.Hidden = hidden
	}
	return
}

func getAttributeViewField(view *av.View, keyID string) (ret *av.BaseField) {
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		if nil == view.GetTableLayout() {
			return
		}
		for _, column := range view.GetTableLayout().Columns {
			if column.ID == keyID {
				return column.BaseField
			}
		}
	case av.LayoutTypeGallery:
		if nil == view.Gallery {
			return
		}
		for _, field := range view.Gallery.CardFields {
			if field.ID == keyID {
				return field.BaseField
			}
		}
	case av.LayoutTypeKanban:
		if nil == view.Kanban {
			return
		}
		for _, field := range view.Kanban.Fields {
			if field.ID == keyID {
				return field.BaseField
			}
		}
	}
	return
}

func (tx *Transaction) doSetAttrViewColumnPin(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColPin(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColPin(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
	if err != nil {
		return
	}

	switch view.LayoutType {
	case av.LayoutTypeTable:
		pin := operation.Data.(bool)
		for _, column := range view.Table.Columns {
			column.Pin = pin && column.ID == operation.ID
		}
	case av.LayoutTypeGallery, av.LayoutTypeKanban:
		return
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnIcon(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColIcon(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColIcon(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	for _, keyValues := range attrView.KeyValues {
		if keyValues.Key.ID == operation.ID {
			keyValues.Key.Icon = filterAttrViewIconValue(operation.Data.(string))
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColumnDesc(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColDesc(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColDesc(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	for _, keyValues := range attrView.KeyValues {
		if keyValues.Key.ID == operation.ID {
			keyValues.Key.Desc = operation.Data.(string)
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSortAttrViewRow(operation *Operation) (ret *TxErr) {
	err := tx.sortAttributeViewItem(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func sortAttributeViewRow(operation *Operation) (err error) {
	rowOrderOperation := isAttributeViewRowOrderOperation(operation.Data)
	if !rowOrderOperation && operation.ID == operation.PreviousID {
		// 拖拽到自己的下方,不做任何操作 https://github.com/siyuan-note/siyuan/issues/11048
		return
	}

	attrView, err := avParseView(operation.AvID, operation.BlockID)
	if err != nil {
		return
	}

	var view *av.View
	if "" != operation.ViewID {
		view = attrView.GetView(operation.ViewID)
		if nil == view {
			return av.ErrViewNotFound
		}
	} else {
		view, err = getAttrViewViewByBlockID(attrView, operation.BlockID)
		if err != nil {
			return
		}
	}

	if rowOrderOperation {
		if err = applyAttributeViewRowOrder(attrView, view, operation.Data); nil != err {
			return err
		}
		return avSaveView(attrView, operation.BlockID)
	}
	var itemID string
	var idx, previousIndex int

	if nil != view.Group && "" != operation.GroupID {
		if groupView := view.GetGroupByID(operation.GroupID); nil != groupView {
			groupKey := view.GetGroupKey(attrView)
			isAcrossGroup := operation.GroupID != operation.TargetGroupID
			if isAcrossGroup && (av.ValueSourceRendered == view.Group.ValueSource || av.KeyTypeTemplate == groupKey.Type ||
				av.KeyTypeCreated == groupKey.Type || av.KeyTypeUpdated == groupKey.Type) {
				// 这些字段类型不支持跨分组移动,因为它们的值是自动计算生成的
				return
			}

			for i, id := range groupView.GroupItemIDs {
				if id == operation.ID {
					itemID = id
					idx = i
					break
				}
			}
			if "" == itemID {
				itemID = operation.ID
				groupView.GroupItemIDs = append(groupView.GroupItemIDs, itemID)
				idx = len(groupView.GroupItemIDs) - 1
			}
			groupView.GroupItemIDs = append(groupView.GroupItemIDs[:idx], groupView.GroupItemIDs[idx+1:]...)

			if isAcrossGroup {
				if targetGroupView := view.GetGroupByID(operation.TargetGroupID); nil != targetGroupView && !gulu.Str.Contains(itemID, targetGroupView.GroupItemIDs) {
					filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, operation.BlockID)
					if nil != contextErr {
						return contextErr
					}
					if err = fillDefaultValue(attrView, view, targetGroupView, operation.PreviousID, itemID, false,
						true, operation.BlockID, filterContext); nil != err {
						return
					}

					if val := attrView.GetValue(groupKey.ID, itemID); nil != val {
						if av.MSelectExistOption(val.MSelect, groupView.GetGroupValue()) {
							// 移除旧分组的值
							val.MSelect = av.MSelectRemoveOption(val.MSelect, groupView.GetGroupValue())
						}

						now := time.Now().UnixMilli()
						val.SetUpdatedAt(now)
						if blockVal := attrView.GetBlockValue(itemID); nil != blockVal {
							blockVal.Block.Updated = now
							blockVal.SetUpdatedAt(now)
						}
					}

					for i, r := range targetGroupView.GroupItemIDs {
						if r == operation.PreviousID {
							previousIndex = i + 1
							break
						}
					}
					targetGroupView.GroupItemIDs = slices.Insert(targetGroupView.GroupItemIDs, previousIndex, itemID)
				}

				regenAttrViewGroups(attrView)
			} else { // 同分组内排序
				for i, r := range groupView.GroupItemIDs {
					if r == operation.PreviousID {
						previousIndex = i + 1
						break
					}
				}
				groupView.GroupItemIDs = slices.Insert(groupView.GroupItemIDs, previousIndex, itemID)
			}
		}
	} else {
		for i, id := range view.ItemIDs {
			if id == operation.ID {
				itemID = id
				idx = i
				break
			}
		}
		if "" == itemID {
			itemID = operation.ID
			view.ItemIDs = append(view.ItemIDs, itemID)
			idx = len(view.ItemIDs) - 1
		}

		view.ItemIDs = append(view.ItemIDs[:idx], view.ItemIDs[idx+1:]...)
		for i, r := range view.ItemIDs {
			if r == operation.PreviousID {
				previousIndex = i + 1
				break
			}
		}
		view.ItemIDs = slices.Insert(view.ItemIDs, previousIndex, itemID)
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSortAttrViewColumn(operation *Operation) (ret *TxErr) {
	err := SortAttributeViewViewKey(operation.AvID, operation.BlockID, operation.ID, operation.PreviousID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func SortAttributeViewViewKey(avID, blockID, keyID, previousKeyID string) (err error) {
	if keyID == previousKeyID {
		// 拖拽到自己的右侧,不做任何操作 https://github.com/siyuan-note/siyuan/issues/11048
		return
	}

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	view, err := getAttrViewViewByBlockID(attrView, blockID)
	if err != nil {
		return
	}

	var curIndex, previousIndex int
	switch view.LayoutType {
	case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
		var col *av.ViewTableColumn
		for i, column := range view.GetTableLayout().Columns {
			if column.ID == keyID {
				col = column
				curIndex = i
				break
			}
		}
		if nil == col {
			return
		}

		view.GetTableLayout().Columns = append(view.GetTableLayout().Columns[:curIndex], view.GetTableLayout().Columns[curIndex+1:]...)
		for i, column := range view.GetTableLayout().Columns {
			if column.ID == previousKeyID {
				previousIndex = i + 1
				break
			}
		}
		view.GetTableLayout().Columns = slices.Insert(view.GetTableLayout().Columns, previousIndex, col)
	case av.LayoutTypeGallery:
		var field *av.ViewGalleryCardField
		for i, cardField := range view.Gallery.CardFields {
			if cardField.ID == keyID {
				field = cardField
				curIndex = i
				break
			}
		}
		if nil == field {
			return
		}

		view.Gallery.CardFields = append(view.Gallery.CardFields[:curIndex], view.Gallery.CardFields[curIndex+1:]...)
		for i, cardField := range view.Gallery.CardFields {
			if cardField.ID == previousKeyID {
				previousIndex = i + 1
				break
			}
		}
		view.Gallery.CardFields = slices.Insert(view.Gallery.CardFields, previousIndex, field)
	case av.LayoutTypeKanban:
		var field *av.ViewKanbanField
		for i, kanbanField := range view.Kanban.Fields {
			if kanbanField.ID == keyID {
				field = kanbanField
				curIndex = i
				break
			}
		}
		if nil == field {
			return
		}

		view.Kanban.Fields = append(view.Kanban.Fields[:curIndex], view.Kanban.Fields[curIndex+1:]...)
		for i, kanbanField := range view.Kanban.Fields {
			if kanbanField.ID == previousKeyID {
				previousIndex = i + 1
				break
			}
		}
		view.Kanban.Fields = slices.Insert(view.Kanban.Fields, previousIndex, field)
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSortAttrViewKey(operation *Operation) (ret *TxErr) {
	err := SortAttributeViewKey(operation.AvID, operation.ID, operation.PreviousID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func SortAttributeViewKey(avID, keyID, previousKeyID string) (err error) {
	if keyID == previousKeyID {
		return
	}

	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	refreshAttrViewKeyIDs(attrView, false)

	var currentKeyID string
	var idx, previousIndex int
	for i, k := range attrView.KeyIDs {
		if k == keyID {
			currentKeyID = k
			idx = i
			break
		}
	}
	if "" == currentKeyID {
		return
	}

	attrView.KeyIDs = append(attrView.KeyIDs[:idx], attrView.KeyIDs[idx+1:]...)

	for i, k := range attrView.KeyIDs {
		if k == previousKeyID {
			previousIndex = i + 1
			break
		}
	}
	attrView.KeyIDs = slices.Insert(attrView.KeyIDs, previousIndex, currentKeyID)

	err = av.SaveAttributeView(attrView)
	return
}

func refreshAttrViewKeyIDs(attrView *av.AttributeView, needSave bool) {
	// 订正 keyIDs 数据

	existKeyIDs := map[string]bool{}
	for _, keyValues := range attrView.KeyValues {
		existKeyIDs[keyValues.Key.ID] = true
	}

	for k := range existKeyIDs {
		if !gulu.Str.Contains(k, attrView.KeyIDs) {
			attrView.KeyIDs = append(attrView.KeyIDs, k)
		}
	}

	var tmp []string
	for _, k := range attrView.KeyIDs {
		if ok := existKeyIDs[k]; ok {
			tmp = append(tmp, k)
		}
	}
	attrView.KeyIDs = tmp

	if needSave {
		av.SaveAttributeView(attrView)
	}
}

func (tx *Transaction) doAddAttrViewColumn(operation *Operation) (ret *TxErr) {
	if operation.attributeViewFields != nil {
		if err := tx.replayAttributeViewFields(operation); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
		return
	}
	var icon string
	if nil != operation.Data {
		icon = operation.Data.(string)
	}
	err := AddAttributeViewKey(operation.AvID, operation.BlockID, operation.ID, operation.Name, operation.Typ, icon, operation.PreviousID,
		av.DateDisplayFormat(operation.Format))

	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func AddAttributeViewKey(avID, blockID, keyID, keyName, keyType, keyIcon, previousKeyID string, dateFormat av.DateDisplayFormat) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	currentView, err := getAttrViewViewByBlockID(attrView, blockID)
	if nil != err {
		return
	}

	key, err := newAttributeViewKey(keyID, keyName, keyType, keyIcon, dateFormat)
	if nil != err {
		return err
	}
	addAttributeViewKey(attrView, currentView, key, previousKeyID)

	err = av.SaveAttributeView(attrView)
	return
}

func newAttributeViewKey(keyID, keyName, keyType, keyIcon string, dateFormat av.DateDisplayFormat) (ret *av.Key, err error) {
	keyTyp := av.KeyType(keyType)
	if av.KeyTypeBlock == keyTyp {
		return nil, errors.New("cannot add an attribute view block key")
	}
	if !av.IsKnownKeyType(keyTyp) {
		return nil, fmt.Errorf("unsupported attribute view key type [%s]", keyType)
	}

	ret = av.NewKey(keyID, keyName, filterAttrViewIconValue(keyIcon), keyTyp)
	if av.IsDateKeyType(keyTyp) {
		if !dateFormat.IsValid() {
			return nil, errors.New("invalid date display format")
		}
		if dateFormat == av.DateDisplayFormatLunar && keyTyp != av.KeyTypeDate {
			return nil, errors.New("lunar calendar is only available for date fields")
		}
		ret.DateFormat = dateFormat
	}
	if av.KeyTypeRollup == keyTyp {
		ret.Rollup = &av.Rollup{Calc: &av.RollupCalc{Operator: av.CalcOperatorNone}}
	}
	return
}

func addAttributeViewKey(attrView *av.AttributeView, currentView *av.View, key *av.Key, previousKeyID string) {
	attrView.KeyValues = append(attrView.KeyValues, &av.KeyValues{Key: key})

	for _, view := range attrView.Views {
		if nil != view.Calendar {
			hidden := nil == currentView || currentView.ID != view.ID || av.LayoutTypeCalendar != currentView.LayoutType
			column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: key.ID, Hidden: hidden, Wrap: view.Calendar.WrapField}}
			index := len(view.Calendar.Columns)
			for i, field := range view.Calendar.Columns {
				if field.ID == previousKeyID {
					index = i + 1
					break
				}
			}
			view.Calendar.Columns = slices.Insert(view.Calendar.Columns, index, column)
		}
		if nil != view.List {
			hidden := nil == currentView || currentView.ID != view.ID || av.LayoutTypeList != currentView.LayoutType
			column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: key.ID, Hidden: hidden, Wrap: view.List.WrapField}}
			index := len(view.List.Columns)
			for i, field := range view.List.Columns {
				if field.ID == previousKeyID {
					index = i + 1
					break
				}
			}
			view.List.Columns = slices.Insert(view.List.Columns, index, column)
		}
		if nil != view.Table {
			newField := &av.BaseField{ID: key.ID, Wrap: view.Table.WrapField}

			if "" == previousKeyID {
				if nil == currentView || av.LayoutTypeTable != currentView.LayoutType {
					// 非表格视图新增的字段追加到表格末尾。
					view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: newField})
				} else {
					view.Table.Columns = append([]*av.ViewTableColumn{{BaseField: newField}}, view.Table.Columns...)
				}
			} else {
				added := false
				for i, column := range view.Table.Columns {
					if column.ID == previousKeyID {
						view.Table.Columns = append(view.Table.Columns[:i+1], append([]*av.ViewTableColumn{{BaseField: newField}}, view.Table.Columns[i+1:]...)...)
						added = true
						break
					}
				}
				if !added {
					view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: newField})
				}
			}
		}

		if nil != view.Gallery {
			newField := &av.BaseField{ID: key.ID, Wrap: view.Gallery.WrapField}

			if "" == previousKeyID {
				view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: newField})
			} else {
				added := false
				for i, field := range view.Gallery.CardFields {
					if field.ID == previousKeyID {
						view.Gallery.CardFields = append(view.Gallery.CardFields[:i+1], append([]*av.ViewGalleryCardField{{BaseField: newField}}, view.Gallery.CardFields[i+1:]...)...)
						added = true
						break
					}
				}
				if !added {
					view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: newField})
				}
			}
		}

		if nil != view.Kanban {
			newField := &av.BaseField{ID: key.ID, Wrap: view.Kanban.WrapField}

			if "" == previousKeyID {
				view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
			} else {
				added := false
				for i, field := range view.Kanban.Fields {
					if field.ID == previousKeyID {
						view.Kanban.Fields = append(view.Kanban.Fields[:i+1], append([]*av.ViewKanbanField{{BaseField: newField}}, view.Kanban.Fields[i+1:]...)...)
						added = true
						break
					}
				}
				if !added {
					view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
				}
			}
		}
	}
}

func (tx *Transaction) doUpdateAttrViewColTemplate(operation *Operation) (ret *TxErr) {
	err := updateAttributeViewColTemplate(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColTemplate(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	templateContent, ok := operation.Data.(string)
	if !ok {
		return errors.New("invalid attribute view field template")
	}
	colType := av.KeyType(operation.Typ)
	for _, keyValues := range attrView.KeyValues {
		if keyValues.Key.ID != operation.ID || keyValues.Key.Type != colType {
			continue
		}
		if av.KeyTypeTemplate == colType {
			keyValues.Key.Template = templateContent
		} else {
			keyValues.Key.RenderTemplate = templateContent
		}
		break
	}

	regenAttrViewGroups(attrView)
	err = av.SaveAttributeView(attrView)
	return
}

// SetAttributeViewKeyTemplate 设置模板字段公式,复用字段模板保存和分组更新逻辑。
func SetAttributeViewKeyTemplate(avID, keyID, templateContent string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if nil != err {
		return err
	}
	key, err := attrView.GetKey(keyID)
	if nil != err {
		return err
	}
	if av.KeyTypeTemplate != key.Type {
		return errors.New("key must be a template field")
	}
	return updateAttributeViewColTemplate(&Operation{
		AvID: avID, ID: keyID, Typ: string(av.KeyTypeTemplate), Data: templateContent,
	})
}

func (tx *Transaction) doUpdateAttrViewColNumberFormat(operation *Operation) (ret *TxErr) {
	err := updateAttributeViewColNumberFormat(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColNumberFormat(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	colType := av.KeyType(operation.Typ)
	switch colType {
	case av.KeyTypeNumber:
		for _, keyValues := range attrView.KeyValues {
			if keyValues.Key.ID == operation.ID && av.KeyTypeNumber == keyValues.Key.Type {
				keyValues.Key.NumberFormat = av.NumberFormat(operation.Format)
				break
			}
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doSetAttrViewColDateFormat(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColDateFormat(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColDateFormat(operation *Operation) (err error) {
	format := av.DateDisplayFormat(operation.Format)
	if !format.IsValid() {
		return errors.New("invalid date display format")
	}

	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	colType := av.KeyType(operation.Typ)
	if !av.IsDateKeyType(colType) {
		return errors.New("date display format is only available for date fields")
	}
	if format == av.DateDisplayFormatLunar && colType != av.KeyTypeDate {
		return errors.New("lunar calendar is only available for date fields")
	}
	for _, keyValues := range attrView.KeyValues {
		if keyValues.Key.ID == operation.ID && keyValues.Key.Type == colType {
			keyValues.Key.DateFormat = format
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func (tx *Transaction) doUpdateAttrViewColumn(operation *Operation) (ret *TxErr) {
	err := updateAttributeViewColumn(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColumn(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	colType := av.KeyType(operation.Typ)
	changeType := false
	if av.IsKnownKeyType(colType) {
		for _, keyValues := range attrView.KeyValues {
			if keyValues.Key.ID == operation.ID {
				isPrimaryKey := av.KeyTypeBlock == keyValues.Key.Type
				if isPrimaryKey != (av.KeyTypeBlock == colType) {
					if isPrimaryKey {
						err = errors.New("cannot change type of primary key field")
					} else {
						err = errors.New("cannot change field type to primary key")
					}
					return
				}

				keyValues.Key.Name = strings.TrimSpace(operation.Name)

				changeType = keyValues.Key.Type != colType
				keyValues.Key.Type = colType

				for _, value := range keyValues.Values {
					value.Type = colType
				}

				break
			}
		}
	}

	if changeType {
		attrView.RemoveNewItemTemplateFieldValue(operation.ID)
		for _, view := range attrView.Views {
			if nil != view.Group {
				if groupKey := view.GetGroupKey(attrView); nil != groupKey && groupKey.ID == operation.ID {
					removeAttributeViewGroup0(view)
				}
			}
		}
		removeAttrViewColumnFromFieldFilters(attrView, attrView.ID, operation.ID)
	}

	if err = av.SaveAttributeView(attrView); nil != err {
		return
	}

	if changeType {
		relatedAvIDs := av.GetSrcAvIDs(attrView.ID)
		for _, relatedAvID := range relatedAvIDs {
			if relatedAvID == attrView.ID {
				continue
			}
			destAv, _ := av.ParseAttributeView(relatedAvID)
			if nil == destAv {
				continue
			}

			for _, keyValues := range destAv.KeyValues {
				if av.KeyTypeRollup == keyValues.Key.Type && nil != keyValues.Key.Rollup &&
					keyValues.Key.Rollup.KeyID == operation.ID {
					// 置空关联过来的汇总
					for _, val := range keyValues.Values {
						val.Rollup.Contents = nil
					}
					keyValues.Key.Rollup.Calc = &av.RollupCalc{Operator: av.CalcOperatorNone}
				}
			}
			removeAttrViewColumnFromFieldFilters(destAv, attrView.ID, operation.ID)

			regenAttrViewGroups(destAv)
			av.SaveAttributeView(destAv)
			ReloadAttrView(destAv.ID)
		}
	}
	return
}

func (tx *Transaction) doRemoveAttrViewColumn(operation *Operation) (ret *TxErr) {
	var err error
	if operation.attributeViewFields != nil {
		err = tx.replayAttributeViewFields(operation)
	} else {
		err = tx.removeAttributeViewField(operation)
	}
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func RemoveAttributeViewKey(avID, keyID string, removeRelationDest bool) (err error) {
	tx := &Transaction{trees: map[string]*parse.Tree{}}
	defer func() { tx.finishAttributeViewMutation(err != nil) }()
	return tx.removeAttributeViewField(&Operation{AvID: avID, ID: keyID, RemoveDest: removeRelationDest})
}

func (tx *Transaction) doReplaceAttrViewBlock(operation *Operation) (ret *TxErr) {
	if err := tx.replaceAttributeViewBinding(operation); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func replaceAttributeViewBlock(avID, oldBlockID, newBlockID string, isDetached bool, tx *Transaction) (targetItemID string, duplicate bool, err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}

	if targetItemID, duplicate, err = replaceAttributeViewBlock0(attrView, oldBlockID, newBlockID, isDetached, tx); nil != err {
		return
	}

	if err = av.SaveAttributeView(attrView); nil != err {
		return
	}
	return
}

func replaceAttributeViewBlock0(attrView *av.AttributeView, oldBlockID, newNodeID string, isDetached bool, tx *Transaction) (targetItemID string, duplicate bool, err error) {
	avID := attrView.ID
	targetItemID = oldBlockID
	var tree *parse.Tree
	var node *ast.Node
	if !isDetached {
		node, tree, _ = getNodeByBlockID(tx, newNodeID)
		if err = validateAttributeViewBinding(avID, tree); err != nil {
			return
		}
	}

	now := util.CurrentTimeMillis()
	// 检查是否已经存在绑定块,如果存在的话则重新绑定
	for _, blockVal := range attrView.GetBlockKeyValues().Values {
		if !isDetached && blockVal.Block.ID == newNodeID && nil != node && nil != tree {
			bindBlockAv0(tx, avID, node, tree)
			blockVal.IsDetached = false
			icon, content := getNodeAvBlockText(node, avID)
			content = util.UnescapeHTML(content)
			blockVal.Block.Icon, blockVal.Block.Content = icon, content
			blockVal.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
			blockVal.UpdatedAt = now
			regenAttrViewGroups(attrView)
			targetItemID = blockVal.BlockID
			duplicate = blockVal.BlockID != oldBlockID
			return
		}
	}

	for _, blockVal := range attrView.GetBlockKeyValues().Values {
		if blockVal.BlockID != oldBlockID {
			continue
		}

		if av.KeyTypeBlock == blockVal.Type {
			if !isDetached {
				if err = inheritAttributeViewBlockIcon(tx, node, tree, blockVal.Block.Icon); err != nil {
					return
				}
			}
			blockVal.IsDetached = isDetached
			blockVal.Block.CollectionRuleID = ""
			if !isDetached {
				if "" != blockVal.Block.ID && blockVal.Block.ID != newNodeID {
					unbindBlockAv(tx, avID, blockVal.Block.ID)
				}
				bindBlockAv(tx, avID, newNodeID)

				blockVal.Block.ID = newNodeID
				icon, content := getNodeAvBlockText(node, avID)
				content = util.UnescapeHTML(content)
				blockVal.Block.Icon, blockVal.Block.Content = icon, content
				blockVal.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)

				refreshRelatedSrcAvs(avID, tx)
			} else {
				blockVal.Block.ID = ""
				blockVal.Block.RefSubtype = ""
			}
		}
	}

	regenAttrViewGroups(attrView)
	return
}

func BatchReplaceAttributeViewBlocks(avID string, isDetached bool, oldNew []map[string]string) (err error) {
	attrView, err := av.ParseAttributeView(avID)
	if err != nil {
		return
	}
	if !isDetached {
		for _, replacements := range oldNew {
			for _, nodeID := range replacements {
				_, tree, loadErr := getNodeByBlockID(nil, nodeID)
				if loadErr != nil {
					return loadErr
				}
				if err = validateAttributeViewBinding(avID, tree); err != nil {
					return
				}
			}
		}
	}

	for _, oldNewMap := range oldNew {
		for oldBlockID, newNodeID := range oldNewMap {
			if _, _, err = replaceAttributeViewBlock0(attrView, oldBlockID, newNodeID, isDetached, nil); nil != err {
				return
			}
		}
	}

	if err = av.SaveAttributeView(attrView); nil != err {
		return
	}
	return
}

func (tx *Transaction) doUpdateAttrViewCell(operation *Operation) (ret *TxErr) {
	_, err := updateAttributeViewCellInBlock(tx, operation.AvID, operation.BlockID, operation.KeyID,
		operation.RowID, operation.Data)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doBatchUpdateAttrViewCells(operations []*Operation) (ret *TxErr) {
	attrView, err := avParseView(operations[0].AvID, operations[0].BlockID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operations[0].AvID, msg: err.Error()}
	}

	var cells []*AttrViewCellUpdate
	for _, operation := range operations {
		cells = append(cells, &AttrViewCellUpdate{KeyID: operation.KeyID, RowID: operation.RowID, Data: operation.Data})
	}
	if err = preflightAttributeViewCellBindings(tx, attrView, cells); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
	}
	for _, operation := range operations {
		if _, err = updateAttributeViewValue(tx, attrView, operation.KeyID, operation.RowID, operation.Data, false,
			operations[0].BlockID); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
	}
	regenAttrViewGroups(attrView)
	if err = avSaveView(attrView, operations[0].BlockID); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
	}
	refreshRelatedSrcAvsInBlock(attrView.ID, operations[0].BlockID, tx)
	return
}

func (tx *Transaction) doUpdateAttrViewCells(operation *Operation) (ret *TxErr) {
	if "" == operation.AvID || 0 == len(operation.CellUpdates) {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "invalid attribute view cell updates"}
	}
	attrView, err := avParseView(operation.AvID, operation.BlockID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	if err = preflightAttributeViewCellBindings(tx, attrView, operation.CellUpdates); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
	}
	context := newAttrViewValueUpdateContext(attrView)
	for _, cell := range operation.CellUpdates {
		if nil == cell || "" == cell.KeyID || "" == cell.RowID {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "invalid attribute view cell update"}
		}
		if _, err = updateAttributeViewValue0(tx, attrView, cell.KeyID, cell.RowID, cell.Data, false, context,
			operation.BlockID); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
	}
	regenAttrViewGroups(attrView)
	if err = avSaveView(attrView, operation.BlockID); err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
	}
	refreshRelatedSrcAvsInBlock(attrView.ID, operation.BlockID, tx)
	return
}

func UpdateAttributeViewCell(tx *Transaction, avID, keyID, itemID string, valueData any) (val *av.Value, err error) {
	return updateAttributeViewCellInBlock(tx, avID, "", keyID, itemID, valueData)
}

func updateAttributeViewCellInBlock(tx *Transaction, avID, blockID, keyID, itemID string,
	valueData any) (val *av.Value, err error) {
	attrView, err := avParseView(avID, blockID)
	if err != nil {
		return
	}

	val, err = updateAttributeViewValue(tx, attrView, keyID, itemID, valueData, false, blockID)
	if nil != err {
		return
	}
	regenAttrViewGroups(attrView)
	if err = avSaveView(attrView, blockID); nil != err {
		return
	}
	refreshRelatedSrcAvsInBlock(attrView.ID, blockID, tx)
	return
}

func updateAttributeViewValue(tx *Transaction, attrView *av.AttributeView, keyID, itemID string, valueData any,
	save bool, blockIDs ...string) (val *av.Value, err error) {
	return updateAttributeViewValue0(tx, attrView, keyID, itemID, valueData, save, nil, blockIDs...)
}

type attrViewValueUpdateContext struct {
	keyValues         map[string]*av.KeyValues
	blockValues       map[string]*av.Value
	values            map[string]map[string]*av.Value
	availableAVColors []int
}

func newAttrViewValueUpdateContext(attrView *av.AttributeView) *attrViewValueUpdateContext {
	context := &attrViewValueUpdateContext{
		keyValues:   map[string]*av.KeyValues{},
		blockValues: map[string]*av.Value{},
		values:      map[string]map[string]*av.Value{},
	}
	for _, keyValues := range attrView.KeyValues {
		if nil == keyValues || nil == keyValues.Key {
			continue
		}
		context.keyValues[keyValues.Key.ID] = keyValues
		values := map[string]*av.Value{}
		for _, value := range keyValues.Values {
			if nil == value {
				continue
			}
			if _, exists := values[value.BlockID]; !exists {
				values[value.BlockID] = value
			}
			if av.KeyTypeBlock == keyValues.Key.Type {
				if _, exists := context.blockValues[value.BlockID]; !exists {
					context.blockValues[value.BlockID] = value
				}
			}
		}
		context.values[keyValues.Key.ID] = values
	}
	return context
}

func updateAttributeViewValue0(tx *Transaction, attrView *av.AttributeView, keyID, itemID string, valueData any,
	save bool, context *attrViewValueUpdateContext, blockIDs ...string) (val *av.Value, err error) {
	avID := attrView.ID
	blockID := ""
	if 0 < len(blockIDs) {
		blockID = blockIDs[0]
	}
	if err = tx.rememberAutomationView(attrView, blockID); err != nil {
		return
	}
	var keyValues *av.KeyValues
	var blockVal *av.Value
	if nil == context {
		keyValues, err = attrView.GetKeyValues(keyID)
		if nil != err {
			return
		}
		blockVal = attrView.GetBlockValue(itemID)
	} else {
		keyValues = context.keyValues[keyID]
		if nil == keyValues {
			err = av.ErrKeyNotFound
			return
		}
		blockVal = context.blockValues[itemID]
	}
	if nil == blockVal {
		err = av.ErrItemNotFound
		return
	}

	now := time.Now().UnixMilli()
	oldIsDetached := blockVal.IsDetached
	oldBoundBlockID := blockVal.Block.ID
	oldCollectionRuleID := blockVal.Block.CollectionRuleID
	if nil == context {
		for _, value := range keyValues.Values {
			if itemID == value.BlockID {
				val = value
				break
			}
		}
	} else {
		val = context.values[keyID][itemID]
	}
	if nil != val && av.KeyTypeLocation != keyValues.Key.Type {
		val.Type = keyValues.Key.Type
	}

	created := false
	if nil == val {
		val = &av.Value{ID: ast.NewNodeID(), KeyID: keyID, BlockID: itemID, Type: keyValues.Key.Type, CreatedAt: now, UpdatedAt: now}
		created = true
	}

	valueID := val.ID
	valueType := keyValues.Key.Type
	valueCreatedAt := val.CreatedAt
	oldText := val.Text

	isUpdatingBlockKey := av.KeyTypeBlock == val.Type
	var oldRelationBlockIDs []string
	if av.KeyTypeRelation == val.Type {
		if nil != val.Relation {
			for _, bID := range val.Relation.BlockIDs {
				oldRelationBlockIDs = append(oldRelationBlockIDs, bID)
			}
		}
	}
	data, err := gulu.JSON.MarshalJSON(valueData)
	if err != nil {
		logging.LogErrorf("marshal value [%+v] failed: %s", valueData, err)
		return
	}
	updatedVal := val
	// 文本、位置和主键值先在副本上合并和校验,避免校验失败污染原值,并保留部分更新语义。
	if av.KeyTypeText == valueType || av.KeyTypeBlock == valueType || av.KeyTypeLocation == valueType {
		updatedVal = val.Clone()
		if nil == updatedVal {
			err = fmt.Errorf("clone attribute view text value [%s] failed", valueID)
			return
		}
	}
	if err = gulu.JSON.UnmarshalJSON(data, updatedVal); err != nil {
		logging.LogErrorf("unmarshal data [%s] failed: %s", data, err)
		return
	}
	updatedVal.ID = valueID
	updatedVal.KeyID = keyID
	updatedVal.BlockID = itemID
	updatedVal.Type = valueType
	updatedVal.CreatedAt = valueCreatedAt
	if av.KeyTypeBlock == valueType && updatedVal.Block != nil {
		updatedVal.Block.CollectionRuleID = ""
		if !updatedVal.IsDetached && !oldIsDetached && updatedVal.Block.ID == oldBoundBlockID {
			updatedVal.Block.CollectionRuleID = oldCollectionRuleID
		}
	}
	if av.KeyTypeBlock == valueType && !updatedVal.IsDetached {
		if updatedVal.Block == nil {
			return nil, ErrBlockNotFound
		}
		node, tree, loadErr := getNodeByBlockID(tx, updatedVal.Block.ID)
		if loadErr != nil {
			return nil, loadErr
		}
		if err = validateAttributeViewBinding(avID, tree); err != nil {
			return
		}
		if oldIsDetached || oldBoundBlockID != updatedVal.Block.ID {
			if err = inheritAttributeViewBlockIcon(tx, node, tree, blockVal.Block.Icon); err != nil {
				return
			}
		}
	}
	if av.KeyTypeText == updatedVal.Type && nil != updatedVal.Text {
		if nil != oldText && nil != oldText.Rich && !attributeViewTextRichFieldPresent(data) &&
			updatedVal.Text.Content != oldText.Content {
			updatedVal.Text.Rich = nil
		}
		if err = updatedVal.Text.NormalizeRichContent(); nil != err {
			return
		}
	}
	if av.KeyTypeLocation == valueType {
		if err = updatedVal.Location.Normalize(); nil != err {
			return
		}
		normalizeAttributeViewLocationProvenance(val.Location, updatedVal.Location, data)
	}
	if updatedVal != val {
		*val = *updatedVal
	}
	if created {
		keyValues.Values = append(keyValues.Values, val)
		if nil != context {
			context.values[keyID][itemID] = val
		}
	}

	key, _ := attrView.GetKey(keyID)

	if av.KeyTypeNumber == val.Type {
		if nil != val.Number {
			if !val.Number.IsNotEmpty {
				val.Number.Content = 0
				val.Number.FormattedContent = ""
			} else {
				val.Number.FormatNumber()
			}
		}
	} else if av.KeyTypeDate == val.Type {
		if nil != val.Date {
			if !val.Date.IsNotEmpty {
				val.Date.Content = 0
				val.Date.FormattedContent = ""
			} else if nil != key {
				val.Date.FormatDate(key.DateFormat)
			}
		}
	} else if av.KeyTypeSelect == val.Type || av.KeyTypeMSelect == val.Type {
		if nil != key && 0 < len(val.MSelect) {
			var tmp []*av.ValueSelect
			// 移除空选项 https://github.com/siyuan-note/siyuan/issues/15533
			for _, v := range val.MSelect {
				if "" != v.Content {
					tmp = append(tmp, v)
				}
			}
			val.MSelect = tmp

			if 1 > len(val.MSelect) {
				return
			}

			// The selection options are inconsistent after pasting data into the database https://github.com/siyuan-note/siyuan/issues/11409
			var availableColors []int
			for _, valOpt := range val.MSelect {
				if opt := key.GetOption(valOpt.Content); nil == opt {
					// 不存在的选项新建保存
					color := attrView.FilterColorValue(valOpt.Color)
					if "" == color {
						if nil == availableColors {
							if nil != context {
								if nil == context.availableAVColors {
									context.availableAVColors = getVisibleAVBuiltinColorIndexes()
								}
								availableColors = context.availableAVColors
							} else {
								availableColors = getVisibleAVBuiltinColorIndexes()
							}
						}
						color = fmt.Sprintf("%d", availableColors[rand.Intn(len(availableColors))])
					}
					opt = &av.SelectOption{Name: valOpt.Content, Color: color}
					key.Options = append(key.Options, opt)
				} else {
					// 已经存在的选项颜色需要保持不变
					valOpt.Color = opt.Color
				}
			}
		}
	}

	relationChangeMode := 0 // 0:不变(仅排序),1:增加,2:减少
	if av.KeyTypeRelation == val.Type {
		// 关联字段得 content 是自动渲染的,所以不需要保存
		val.Relation.Contents = nil
		val.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(val.Relation.BlockIDs)

		// 计算关联变更模式
		if !slices.Equal(oldRelationBlockIDs, val.Relation.BlockIDs) {
			if len(oldRelationBlockIDs) > len(val.Relation.BlockIDs) {
				relationChangeMode = 2
			} else {
				relationChangeMode = 1
			}
		}
	}

	// val.IsDetached 只有更新主键的时候才会传入,所以下面需要结合 isUpdatingBlockKey 来判断

	if isUpdatingBlockKey {
		if oldIsDetached {
			// 之前是非绑定块

			if !val.IsDetached { // 现在绑定了块
				bindBlockAv(tx, avID, val.Block.ID)
				node, _, _ := getNodeByBlockID(tx, val.Block.ID)
				if nil != node {
					icon, content := getNodeAvBlockText(node, avID)
					val.Block.Icon = icon
					val.Block.Content = util.UnescapeHTML(content)
					val.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
				} else {
					val.Block.RefSubtype = av.BlockRefSubtypeDynamic
				}
			} else {
				val.Block.RefSubtype = ""
			}
		} else {
			// 之前绑定了块

			if val.IsDetached { // 现在是非绑定块
				unbindBlockAv(tx, avID, val.Block.ID)
				val.Block.ID = ""
				val.Block.RefSubtype = ""
			} else {
				// 现在也绑定了块

				if oldBoundBlockID != val.Block.ID { // 之前绑定的块和现在绑定的块不一样
					// 换绑块
					unbindBlockAv(tx, avID, oldBoundBlockID)
					bindBlockAv(tx, avID, val.Block.ID)
					node, _, _ := getNodeByBlockID(tx, val.Block.ID)
					if nil != node {
						icon, content := getNodeAvBlockText(node, avID)
						val.Block.Icon = icon
						val.Block.Content = util.UnescapeHTML(content)
						val.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
					} else {
						val.Block.Content = util.UnescapeHTML(val.Block.Content)
						val.Block.RefSubtype = av.BlockRefSubtypeDynamic
					}
				} else { // 之前绑定的块和现在绑定的块一样
					content := strings.TrimSpace(val.Block.Content)
					node, tree, _ := getNodeByBlockID(tx, val.Block.ID)
					_, blockText := getNodeAvBlockText(node, "")
					if "" == content {
						// 使用动态锚文本
						val.Block.Content = util.UnescapeHTML(blockText)
						val.Block.RefSubtype = av.BlockRefSubtypeDynamic
						updateBlockValueStaticText(tx, node, tree, avID, "")
					} else {
						val.Block.Content = content
						val.Block.RefSubtype = av.BlockRefSubtypeStatic
						updateBlockValueStaticText(tx, node, tree, avID, content)
					}
				}
			}
		}
	}

	blockVal.Block.Updated = now
	blockVal.SetUpdatedAt(now)
	if isUpdatingBlockKey {
		blockVal.IsDetached = val.IsDetached
	}
	val.SetUpdatedAt(now)

	if nil != key && av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.IsTwoWay {
		// 双向关联需要同时更新目标字段的值
		if err = updateTwoWayRelationDestAttrViewInBlock(attrView, key, val, relationChangeMode,
			oldRelationBlockIDs, blockID); nil != err {
			return
		}
	}

	if save {
		regenAttrViewGroups(attrView)
		if err = avSaveView(attrView, blockID); nil != err {
			return
		}
	}
	if 0 != relationChangeMode && nil != key && nil != key.Relation && "" != key.Relation.AvID && key.Relation.AvID != avID {
		ReloadAttrView(key.Relation.AvID)
	}

	if save {
		refreshRelatedSrcAvsInBlock(avID, blockID, tx)
	}
	return
}

func attributeViewTextRichFieldPresent(data []byte) bool {
	var valueFields map[string]json.RawMessage
	if err := json.Unmarshal(data, &valueFields); nil != err {
		return false
	}
	textData, ok := valueFields["text"]
	if !ok {
		return false
	}
	var textFields map[string]json.RawMessage
	if err := json.Unmarshal(textData, &textFields); nil != err {
		return false
	}
	_, ret := textFields["rich"]
	return ret
}

func refreshRelatedSrcAvs(destAvID string, tx *Transaction) {
	refreshRelatedSrcAvsInBlock(destAvID, "", tx)
}

func refreshRelatedSrcAvsInBlock(destAvID, blockID string, tx *Transaction) {
	relatedAvIDs := av.GetSrcAvIDsForRefresh([]string{destAvID})

	if nil != tx {
		tx.relatedAvIDs = append(tx.relatedAvIDs, relatedAvIDs...)
	} else {
		for _, relatedAvID := range relatedAvIDs {
			destAv, _ := avParseView(relatedAvID, blockID)
			if nil == destAv {
				continue
			}

			regenAttrViewGroups(destAv)
			avSaveView(destAv, blockID)
			ReloadAttrView(relatedAvID)
		}
	}
}

// relationChangeMode
// 0:关联字段值不变(仅排序),不影响目标值
// 1:关联字段值增加,增加目标值
// 2:关联字段值减少,减少目标值
func updateTwoWayRelationDestAttrView(attrView *av.AttributeView, relKey *av.Key, val *av.Value, relationChangeMode int, oldRelationBlockIDs []string) {
	_ = updateTwoWayRelationDestAttrViewInBlock(attrView, relKey, val, relationChangeMode, oldRelationBlockIDs, "")
}

func updateTwoWayRelationDestAttrViewInBlock(attrView *av.AttributeView, relKey *av.Key, val *av.Value,
	relationChangeMode int, oldRelationBlockIDs []string, blockID string) (err error) {
	var destAv *av.AttributeView
	if attrView.ID == relKey.Relation.AvID {
		destAv = attrView
	} else {
		destAv, _ = avParseView(relKey.Relation.AvID, blockID)
	}

	// 目标数据库已删除或损坏时无法清理反向值,但不能因此阻止源条目删除。
	if nil == destAv {
		return
	}

	now := util.CurrentTimeMillis()
	if 0 != relationChangeMode {
		addBlockIDs := val.Relation.BlockIDs
		for _, bID := range oldRelationBlockIDs {
			addBlockIDs = gulu.Str.RemoveElem(addBlockIDs, bID)
		}

		for _, blockID := range addBlockIDs {
			for _, keyValues := range destAv.KeyValues {
				if keyValues.Key.ID != relKey.Relation.BackKeyID {
					continue
				}

				destVal := keyValues.GetValue(blockID)
				if nil == destVal {
					destVal = &av.Value{ID: ast.NewNodeID(), KeyID: keyValues.Key.ID, BlockID: blockID, Type: keyValues.Key.Type, Relation: &av.ValueRelation{}, CreatedAt: now, UpdatedAt: now + 1000}
					keyValues.Values = append(keyValues.Values, destVal)
				}

				destVal.Relation.BlockIDs = append(destVal.Relation.BlockIDs, val.BlockID)
				destVal.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(destVal.Relation.BlockIDs)
				break
			}
		}
	}
	if 0 != relationChangeMode {
		removeBlockIDs := oldRelationBlockIDs
		for _, bID := range val.Relation.BlockIDs {
			removeBlockIDs = gulu.Str.RemoveElem(removeBlockIDs, bID)
		}

		for _, blockID := range removeBlockIDs {
			for _, keyValues := range destAv.KeyValues {
				if keyValues.Key.ID != relKey.Relation.BackKeyID {
					continue
				}

				for _, value := range keyValues.Values {
					if value.BlockID == blockID {
						value.Relation.BlockIDs = gulu.Str.RemoveElem(value.Relation.BlockIDs, val.BlockID)
						value.SetUpdatedAt(now)
						break
					}
				}
			}
		}
	}

	if destAv != attrView {
		regenAttrViewGroups(destAv)
		err = avSaveView(destAv, blockID)
	}
	return
}

// regenAttrViewGroups 重新生成分组视图。
func regenAttrViewGroups(attrView *av.AttributeView) {
	for _, view := range attrView.Views {
		groupKey := view.GetGroupKey(attrView)
		if nil == groupKey {
			continue
		}

		genAttrViewGroups(view, attrView)
	}
}

func unbindBlockAv(tx *Transaction, avID, nodeID string) {
	node, tree, err := getNodeByBlockID(tx, nodeID)
	if err != nil {
		return
	}

	attrs := parse.IAL2Map(node.KramdownIAL)
	if "" == attrs[av.NodeAttrNameAvs] {
		return
	}

	avIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
	avIDs = gulu.Str.RemoveElem(avIDs, avID)
	if 0 == len(avIDs) {
		attrs[av.NodeAttrNameAvs] = ""
	} else {
		attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
	}

	avNames := getAvNames(attrs[av.NodeAttrNameAvs])
	if "" != avNames {
		attrs[av.NodeAttrViewNames] = avNames
	}

	if nil != tx {
		err = setNodeAttrsWithTx(tx, node, tree, attrs)
	} else {
		err = setNodeAttrs(node, tree, attrs)
	}
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", nodeID, err)
		return
	}
}

func (tx *Transaction) doSortAttrViewBinding(operation *Operation) (ret *TxErr) {
	tree, err := tx.loadTree(operation.ID)
	if err != nil {
		logging.LogErrorf("load tree [%s] failed: %s", operation.ID, err)
		return &TxErr{code: TxErrCodeBlockNotFound, id: operation.ID}
	}

	node := treenode.GetNodeInTree(tree, operation.ID)
	if nil == node {
		logging.LogErrorf("get node [%s] in tree [%s] failed", operation.ID, tree.Root.ID)
		return &TxErr{code: TxErrCodeBlockNotFound, id: operation.ID}
	}

	attrs := parse.IAL2Map(node.KramdownIAL)
	avIDs, err := sortAttrViewBindingIDs(strings.Split(attrs[av.NodeAttrNameAvs], ","), operation.AvID, operation.PreviousID)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}

	avs := strings.Join(avIDs, ",")
	if err = setNodeAttrsWithTx(tx, node, tree, map[string]string{
		av.NodeAttrNameAvs:   avs,
		av.NodeAttrViewNames: getAvNames(avs),
	}); err != nil {
		logging.LogErrorf("sort attribute view binding [%s] failed: %s", operation.AvID, err)
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func sortAttrViewBindingIDs(avIDs []string, avID, previousAvID string) (ret []string, err error) {
	ret = append([]string(nil), avIDs...)
	if avID == previousAvID {
		return
	}

	index := -1
	for i, id := range ret {
		if id == avID {
			index = i
			break
		}
	}
	if 0 > index {
		return nil, fmt.Errorf("attribute view [%s] is not bound", avID)
	}

	ret = append(ret[:index], ret[index+1:]...)
	previousIndex := -1
	if "" != previousAvID {
		for i, id := range ret {
			if id == previousAvID {
				previousIndex = i
				break
			}
		}
		if 0 > previousIndex {
			return nil, fmt.Errorf("previous attribute view [%s] is not bound", previousAvID)
		}
	}

	ret = slices.Insert(ret, previousIndex+1, avID)
	return
}

func bindBlockAv(tx *Transaction, avID, blockID string) {
	node, tree, err := getNodeByBlockID(tx, blockID)
	if err != nil {
		return
	}

	bindBlockAv0(tx, avID, node, tree)
}

func bindBlockAv0(tx *Transaction, avID string, node *ast.Node, tree *parse.Tree) {
	if err := validateAttributeViewBinding(avID, tree); err != nil {
		return
	}
	attrs := parse.IAL2Map(node.KramdownIAL)
	if "" == attrs[av.NodeAttrNameAvs] {
		attrs[av.NodeAttrNameAvs] = avID
	} else {
		avIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
		avIDs = append(avIDs, avID)
		avIDs = gulu.Str.RemoveDuplicatedElem(avIDs)
		attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
	}

	avNames := getAvNames(attrs[av.NodeAttrNameAvs])
	if "" != avNames {
		attrs[av.NodeAttrViewNames] = avNames
	}

	var err error
	if nil != tx {
		err = setNodeAttrsWithTx(tx, node, tree, attrs)
	} else {
		err = setNodeAttrs(node, tree, attrs)
	}
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", node.ID, err)
		return
	}
}

func updateBlockValueStaticText(tx *Transaction, node *ast.Node, tree *parse.Tree, avID, text string) {
	// 设置静态锚文本 Database-bound block primary key supports setting static anchor text https://github.com/siyuan-note/siyuan/issues/10049

	if nil == node {
		return
	}

	attrs := parse.IAL2Map(node.KramdownIAL)
	attrs[av.NodeAttrViewStaticText+"-"+avID] = text
	var err error
	if nil != tx {
		err = setNodeAttrsWithTx(tx, node, tree, attrs)
	} else {
		err = setNodeAttrs(node, tree, attrs)
	}
	if err != nil {
		logging.LogWarnf("set node [%s] attrs failed: %s", node.ID, err)
		return
	}
}

func getNodeByBlockID(tx *Transaction, blockID string) (node *ast.Node, tree *parse.Tree, err error) {
	if nil != tx {
		tree, err = tx.loadTree(blockID)
	} else {
		tree, err = LoadTreeByBlockID(blockID)
	}
	if err != nil {
		return
	}
	node = treenode.GetNodeInTree(tree, blockID)
	if nil == node {
		logging.LogWarnf("node [%s] not found in tree [%s]", blockID, tree.ID)
		return
	}
	return
}

func (tx *Transaction) doUpdateAttrViewColOptions(operation *Operation) (ret *TxErr) {
	if operation.attributeViewFields != nil {
		if err := tx.replayAttributeViewFields(operation); err != nil {
			return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
		}
		return nil
	}
	err := updateAttributeViewColumnOptions(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func updateAttributeViewColumnOptions(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	jsonData, err := gulu.JSON.MarshalJSON(operation.Data)
	if err != nil {
		return
	}

	options := []*av.SelectOption{}
	if err = gulu.JSON.UnmarshalJSON(jsonData, &options); err != nil {
		return
	}

	// 移除空选项 https://github.com/siyuan-note/siyuan/issues/15533
	var tmp []*av.SelectOption
	for _, opt := range options {
		if "" != opt.Name {
			tmp = append(tmp, opt)
		}
	}
	options = tmp
	if 1 > len(options) {
		return
	}

	optionSorts := map[string]int{}
	for i, opt := range options {
		optionSorts[opt.Name] = i
	}

	selectKey, _ := attrView.GetKey(operation.ID)
	if nil == selectKey {
		return
	}
	existingOptions := map[string]*av.SelectOption{}
	for _, opt := range selectKey.Options {
		existingOptions[opt.Name] = opt
	}
	colorChanges := map[string]string{}
	for _, opt := range options {
		if existingOpt, exists := existingOptions[opt.Name]; exists {
			// 如果选项已经存在则更新颜色和描述
			newColor := attrView.FilterColorValue(opt.Color)
			if existingOpt.Color != newColor {
				colorChanges[existingOpt.Name] = newColor
			}
			existingOpt.Color = newColor
			existingOpt.Desc = opt.Desc
		} else {
			// 如果选项不存在则添加新选项
			selectKey.Options = append(selectKey.Options, &av.SelectOption{
				Name:  opt.Name,
				Color: attrView.FilterColorValue(opt.Color),
				Desc:  opt.Desc,
			})
		}
	}

	sortAttributeViewColumnOptions(selectKey.Options, optionSorts)
	for name, color := range colorChanges {
		syncAttributeViewOptionColor(attrView, selectKey.ID, name, color)
	}

	regenAttrViewGroups(attrView)
	if err = av.SaveAttributeView(attrView); nil != err {
		return
	}
	if 0 == len(colorChanges) {
		return
	}

	for _, relatedAvID := range av.GetSrcAvIDs(attrView.ID) {
		if relatedAvID == attrView.ID {
			continue
		}
		relatedAttrView, parseErr := av.ParseAttributeView(relatedAvID)
		if nil != parseErr || nil == relatedAttrView {
			continue
		}
		changed := false
		for name, color := range colorChanges {
			changed = renameAttrViewOptionInFieldFilters(relatedAttrView, attrView.ID, selectKey.ID,
				name, name, color) || changed
		}
		if !changed {
			continue
		}
		if err = av.SaveAttributeView(relatedAttrView); nil != err {
			return
		}
		ReloadAttrView(relatedAvID)
	}
	return
}

func syncAttributeViewOptionColor(attrView *av.AttributeView, keyID, name, color string) {
	attrView.RenameNewItemTemplateSelectOption(keyID, name, name, color)
	for _, keyValues := range attrView.KeyValues {
		if nil == keyValues || nil == keyValues.Key || keyID != keyValues.Key.ID {
			continue
		}
		for _, value := range keyValues.Values {
			if nil == value {
				continue
			}
			for _, selection := range value.MSelect {
				if nil != selection && name == selection.Content {
					selection.Color = color
				}
			}
		}
		break
	}
	for _, view := range attrView.Views {
		av.RenameSelectOptionInFilters(view.Filters, keyID, name, name, color)
		for _, rule := range view.ConditionalColors {
			if nil != rule {
				av.RenameSelectOptionInFilters([]*av.ViewFilter{rule.Filter}, keyID, name, name, color)
			}
		}
	}
	renameAttrViewOptionInFieldFilters(attrView, attrView.ID, keyID, name, name, color)
}

func sortAttributeViewColumnOptions(options []*av.SelectOption, optionSorts map[string]int) {
	var sortableOptions []*av.SelectOption
	for _, opt := range options {
		if _, ok := optionSorts[opt.Name]; ok {
			sortableOptions = append(sortableOptions, opt)
		}
	}
	sort.SliceStable(sortableOptions, func(i, j int) bool {
		return optionSorts[sortableOptions[i].Name] < optionSorts[sortableOptions[j].Name]
	})

	// 仅重排请求中包含的选项,避免过期请求扰动其他请求新增的选项。
	sortableIndex := 0
	for i, opt := range options {
		if _, ok := optionSorts[opt.Name]; ok {
			options[i] = sortableOptions[sortableIndex]
			sortableIndex++
		}
	}
}

func (tx *Transaction) doSetAttrViewCustomColors(operation *Operation) (ret *TxErr) {
	if err := setAttrViewCustomColors(operation); nil != err {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func parseAttrViewCustomColorsData(data []byte) (colors []*av.AttributeViewCustomColor, order []string, err error) {
	trimmed := bytes.TrimSpace(data)
	if len(trimmed) > 0 && trimmed[0] == '{' {
		decoded := struct {
			Colors []*av.AttributeViewCustomColor `json:"colors"`
			Order  []string                       `json:"order"`
		}{}
		if err = gulu.JSON.UnmarshalJSON(data, &decoded); nil != err {
			return
		}
		return decoded.Colors, decoded.Order, nil
	}
	colors = []*av.AttributeViewCustomColor{}
	err = gulu.JSON.UnmarshalJSON(data, &colors)
	return
}

func setAttrViewCustomColors(operation *Operation) (err error) {
	attrView, err := avParseView(operation.AvID, operation.BlockID)
	if nil != err {
		return
	}
	if nil == operation.Data {
		return errors.New("attribute view custom colors must not be empty")
	}

	data, err := gulu.JSON.MarshalJSON(operation.Data)
	if nil != err {
		return
	}
	colors, order, err := parseAttrViewCustomColorsData(data)
	if nil != err {
		return
	}
	colors, err = av.NormalizeAttributeViewCustomColors(colors, true)
	if nil != err {
		return
	}

	oldColors := []*av.AttributeViewCustomColor{}
	oldOrder := []string{}
	if styles, stylesErr := GetInlineStyles(); nil == stylesErr && styles != nil && styles.AV != nil {
		oldColors = styles.AV.Colors
		oldOrder = styles.AV.Order
	}
	if nil == order {
		order = oldOrder
	}

	retainedIndexes := map[int]struct{}{}
	for _, color := range colors {
		retainedIndexes[color.Index] = struct{}{}
	}
	usedIndexes := map[int]struct{}{}
	for _, index := range attrView.UsedCustomColorIndexes() {
		usedIndexes[index] = struct{}{}
	}
	for _, oldColor := range oldColors {
		if nil == oldColor {
			continue
		}
		if _, retained := retainedIndexes[oldColor.Index]; !retained {
			if _, used := usedIndexes[oldColor.Index]; used {
				return fmt.Errorf("attribute view custom color [%d] is still in use", oldColor.Index)
			}
		}
	}

	if err = replaceWorkspaceAVPalette(colors, order); nil != err {
		return
	}
	ReloadAttrView(attrView.ID)
	for _, relatedAvID := range av.GetSrcAvIDs(attrView.ID) {
		if relatedAvID != attrView.ID {
			ReloadAttrView(relatedAvID)
		}
	}
	return
}

func (tx *Transaction) doRemoveAttrViewColOption(operation *Operation) (ret *TxErr) {
	err := tx.mutateAttributeViewOption(operation, true)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doUpdateAttrViewColOption(operation *Operation) (ret *TxErr) {
	err := tx.mutateAttributeViewOption(operation, false)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func (tx *Transaction) doSetAttrViewColOptionDesc(operation *Operation) (ret *TxErr) {
	err := setAttributeViewColumnOptionDesc(operation)
	if err != nil {
		return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
	}
	return
}

func setAttributeViewColumnOptionDesc(operation *Operation) (err error) {
	attrView, err := av.ParseAttributeView(operation.AvID)
	if err != nil {
		return
	}

	key, err := attrView.GetKey(operation.ID)
	if err != nil {
		return
	}

	data := operation.Data.(map[string]any)
	name := data["name"].(string)
	desc := data["desc"].(string)

	for i, opt := range key.Options {
		if name == opt.Name {
			key.Options[i].Desc = desc
			break
		}
	}

	err = av.SaveAttributeView(attrView)
	return
}

func resolveAttributeViewView(attrView *av.AttributeView, viewID, carrierViewID, blockID string) (ret *av.View, err error) {
	if "" != viewID {
		ret = attrView.GetView(viewID)
		if nil == ret {
			return nil, av.ErrViewNotFound
		}
		return
	}

	if "" != carrierViewID {
		if ret = attrView.GetView(carrierViewID); nil != ret {
			return
		}
	}

	if "" != blockID {
		node, _, _ := getNodeByBlockID(nil, blockID)
		if nil != node && ast.NodeAttributeView == node.Type && attrView.ID == node.AttributeViewID {
			if ret = attrView.GetView(node.IALAttr(av.NodeAttrView)); nil != ret {
				return
			}
		}
	}

	return attrView.GetFirstView()
}

func getAttrViewViewByBlockID(attrView *av.AttributeView, blockID string) (ret *av.View, err error) {
	return resolveAttributeViewView(attrView, "", "", blockID)
}

func getAttrViewName(attrView *av.AttributeView) string {
	ret := strings.TrimSpace(attrView.Name)
	if "" == ret {
		ret = Conf.language(105)
	}
	return ret
}

func updateBoundBlockAvsAttribute(avIDs []string, boxID string) {
	// 更新指定 avIDs 中绑定块的 avs 属性

	cachedTrees, saveTrees := map[string]*parse.Tree{}, map[string]*parse.Tree{}
	luteEngine := util.NewLute()
	for _, avID := range avIDs {
		attrView, _ := av.ParseAttributeViewInBox(avID, boxID)
		if nil == attrView {
			continue
		}

		blockKeyValues := attrView.GetBlockKeyValues()
		if nil == blockKeyValues || nil == blockKeyValues.Values {
			continue
		}

		for _, blockValue := range blockKeyValues.Values {
			if nil == blockValue || blockValue.IsDetached || nil == blockValue.Block {
				continue
			}

			boundBlockID := blockValue.Block.ID
			if "" == boundBlockID {
				continue
			}

			bt := attributeViewBindingBlockTree(boundBlockID, boxID)
			if nil == bt {
				continue
			}

			tree := cachedTrees[bt.RootID]
			if nil == tree {
				tree, _ = filesys.LoadTree(bt.BoxID, bt.Path, luteEngine)
				if nil == tree {
					continue
				}
				cachedTrees[bt.RootID] = tree
			}

			node := treenode.GetNodeInTree(tree, boundBlockID)
			if nil == node {
				continue
			}

			attrs := parse.IAL2Map(node.KramdownIAL)
			if "" == attrs[av.NodeAttrNameAvs] {
				attrs[av.NodeAttrNameAvs] = avID
			} else {
				nodeAvIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
				nodeAvIDs = append(nodeAvIDs, avID)
				nodeAvIDs = gulu.Str.RemoveDuplicatedElem(nodeAvIDs)
				attrs[av.NodeAttrNameAvs] = strings.Join(nodeAvIDs, ",")
				saveTrees[bt.RootID] = tree
			}

			avNames := getAvNames(attrs[av.NodeAttrNameAvs])
			if "" != avNames {
				attrs[av.NodeAttrViewNames] = avNames
			}

			oldAttrs, setErr := setNodeAttrs0(node, attrs, bt.BoxID)
			if nil != setErr {
				continue
			}
			cache.PutBlockIALInBox(node.ID, bt.BoxID, parse.IAL2Map(node.KramdownIAL))
			pushBlockAttrs(oldAttrs, node)
			if "" != avNames {
				node.RemoveIALAttr(av.NodeAttrViewNames)
			}
		}
	}

	for _, saveTree := range saveTrees {
		if treeErr := indexWriteTreeUpsertQueue(saveTree); nil != treeErr {
			logging.LogErrorf("index write tree upsert queue failed: %s", treeErr)
		}

		avNodes := saveTree.Root.ChildrenByType(ast.NodeAttributeView)
		av.BatchUpsertBlockRel(avNodes)
	}
}