diff --git a/internal/application/repository/chunk.go b/internal/application/repository/chunk.go index 6b6d340c..ee27e841 100644 --- a/internal/application/repository/chunk.go +++ b/internal/application/repository/chunk.go @@ -224,11 +224,11 @@ func (r *chunkRepository) ListPagedChunksByKnowledgeID( db = db.Where("is_enabled = ?", *isEnabled) } if keyword != "" { - like := "%" + keyword + "%" + like := "%" + escapeLikeKeyword(keyword) + "%" // Document type: search content only if knowledgeType != types.KnowledgeTypeFAQ { - db = db.Where("content LIKE ?", like) + db = db.Where("content LIKE ? ESCAPE ?", like, likeEscapeChar) return db } @@ -240,32 +240,35 @@ func (r *chunkRepository) ListPagedChunksByKnowledgeID( case "standard_question": // Search only in standard_question field of metadata if isPostgres { - db = db.Where("metadata->>'standard_question' ILIKE ?", like) + db = db.Where("metadata->>'standard_question' ILIKE ? ESCAPE ?", like, likeEscapeChar) } else { // MySQL: metadata->>'$.standard_question' (MySQL 5.7.13+) // 也可以用 JSON_UNQUOTE(JSON_EXTRACT(metadata, '$.standard_question')) - db = db.Where("metadata->>'$.standard_question' LIKE ?", like) + db = db.Where("metadata->>'$.standard_question' LIKE ? ESCAPE ?", like, likeEscapeChar) } case "similar_questions": // Search in similar_questions array of metadata if isPostgres { - db = db.Where("(metadata->'similar_questions')::text ILIKE ?", like) + db = db.Where("(metadata->'similar_questions')::text ILIKE ? ESCAPE ?", like, likeEscapeChar) } else { - db = db.Where("JSON_EXTRACT(metadata, '$.similar_questions') LIKE ?", like) + db = db.Where("JSON_EXTRACT(metadata, '$.similar_questions') LIKE ? ESCAPE ?", + like, likeEscapeChar) } case "answers": // Search in answers array of metadata if isPostgres { - db = db.Where("(metadata->'answers')::text ILIKE ?", like) + db = db.Where("(metadata->'answers')::text ILIKE ? ESCAPE ?", like, likeEscapeChar) } else { - db = db.Where("JSON_EXTRACT(metadata, '$.answers') LIKE ?", like) + db = db.Where("JSON_EXTRACT(metadata, '$.answers') LIKE ? ESCAPE ?", like, likeEscapeChar) } default: // Search in all fields (content and metadata) if isPostgres { - db = db.Where("(content ILIKE ? OR metadata::text ILIKE ?)", like, like) + db = db.Where("(content ILIKE ? ESCAPE ? OR metadata::text ILIKE ? ESCAPE ?)", + like, likeEscapeChar, like, likeEscapeChar) } else { - db = db.Where("(content LIKE ? OR CAST(metadata AS CHAR) LIKE ?)", like, like) + db = db.Where("(content LIKE ? ESCAPE ? OR CAST(metadata AS CHAR) LIKE ? ESCAPE ?)", + like, likeEscapeChar, like, likeEscapeChar) } } } diff --git a/internal/application/repository/knowledge.go b/internal/application/repository/knowledge.go index eb33a620..9cfd90fd 100644 --- a/internal/application/repository/knowledge.go +++ b/internal/application/repository/knowledge.go @@ -139,7 +139,10 @@ func applyKnowledgeListFilter(query *gorm.DB, filter types.KnowledgeListFilter) // / `search sessions` filters. Plain LIKE is case-sensitive in // Postgres, which surprised callers searching with lowercase. escaped := strings.ToLower(escapeLikeKeyword(filter.Keyword)) - query = query.Where("(LOWER(file_name) LIKE ? OR LOWER(title) LIKE ?)", "%"+escaped+"%", "%"+escaped+"%") + query = query.Where( + "(LOWER(file_name) LIKE ? ESCAPE ? OR LOWER(title) LIKE ? ESCAPE ?)", + "%"+escaped+"%", likeEscapeChar, "%"+escaped+"%", likeEscapeChar, + ) } // FileType and Source share the same special-case routing onto `type` for // the "manual" / "url" values, so callers can pick either control. @@ -958,7 +961,10 @@ func (r *knowledgeRepository) SearchKnowledge( // If keyword is provided, filter by file_name or title (case-insensitive). if keyword != "" { escaped := strings.ToLower(escapeLikeKeyword(keyword)) - query = query.Where("(LOWER(knowledges.file_name) LIKE ? OR LOWER(knowledges.title) LIKE ?)", "%"+escaped+"%", "%"+escaped+"%") + query = query.Where( + "(LOWER(knowledges.file_name) LIKE ? ESCAPE ? OR LOWER(knowledges.title) LIKE ? ESCAPE ?)", + "%"+escaped+"%", likeEscapeChar, "%"+escaped+"%", likeEscapeChar, + ) } // If fileTypes is provided, filter by file extension or type @@ -1077,7 +1083,10 @@ func (r *knowledgeRepository) SearchKnowledgeInScopes( if keyword != "" { escaped := strings.ToLower(escapeLikeKeyword(keyword)) - query = query.Where("(LOWER(knowledges.file_name) LIKE ? OR LOWER(knowledges.title) LIKE ?)", "%"+escaped+"%", "%"+escaped+"%") + query = query.Where( + "(LOWER(knowledges.file_name) LIKE ? ESCAPE ? OR LOWER(knowledges.title) LIKE ? ESCAPE ?)", + "%"+escaped+"%", likeEscapeChar, "%"+escaped+"%", likeEscapeChar, + ) } if len(fileTypes) > 0 { diff --git a/internal/application/repository/like_escape_sqlite_test.go b/internal/application/repository/like_escape_sqlite_test.go new file mode 100644 index 00000000..f4cdbae3 --- /dev/null +++ b/internal/application/repository/like_escape_sqlite_test.go @@ -0,0 +1,306 @@ +package repository + +import ( + "context" + "testing" + + "github.com/Tencent/WeKnora/internal/types" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gorm.io/driver/sqlite" + "gorm.io/gorm" +) + +// SQLite — the database behind the Lite build — has no default LIKE escape +// character, while Postgres defaults to backslash. escapeLikeKeyword / +// escapeLikePattern emit \% and \_ on the assumption that the pattern is +// consumed by a predicate with an explicit ESCAPE clause; without one, SQLite +// searches for a literal backslash and silently returns zero rows (and a zero +// total) for any keyword containing %, _ or \. +// +// These tests pin that invariant at each fixed call site. Each case seeds a +// row whose name/content contains the literal character plus a decoy row that +// the same keyword would match if the character were still a wildcard, so a +// missing ESCAPE fails on "no rows" and a missing escape fails on "extra row". + +// likeEscapeTestDDL creates the join targets of the keyword searches that are +// not part of the AutoMigrate set below. +const likeEscapeTestDDL = ` +CREATE TABLE IF NOT EXISTS users ( + id VARCHAR(36) PRIMARY KEY, + username VARCHAR(100) NOT NULL DEFAULT '', + email VARCHAR(255) NOT NULL DEFAULT '', + deleted_at DATETIME +); +CREATE TABLE IF NOT EXISTS im_channel_sessions ( + session_id VARCHAR(36), + platform VARCHAR(32), + chat_id VARCHAR(255), + thread_id VARCHAR(255), + user_id VARCHAR(64), + agent_id VARCHAR(64), + im_channel_id VARCHAR(64) +); +` + +func setupLikeEscapeTestDB(t *testing.T) *gorm.DB { + t.Helper() + dsn := "file:" + uuid.New().String() + "?mode=memory&cache=shared&_busy_timeout=5000" + db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{}) + require.NoError(t, err) + sqlDB, err := db.DB() + require.NoError(t, err) + sqlDB.SetMaxOpenConns(1) + t.Cleanup(func() { _ = sqlDB.Close() }) + + // The knowledges / knowledge_bases schemas are inlined by the existing + // helpers (AutoMigrate does not map their jsonb columns onto SQLite). + require.NoError(t, db.Exec(knowledgesTestDDL).Error) + require.NoError(t, db.Exec(knowledgeBasesTestDDL).Error) + require.NoError(t, db.Exec(likeEscapeTestDDL).Error) + require.NoError(t, db.AutoMigrate( + &types.KnowledgeTag{}, + &types.Chunk{}, + &types.Session{}, + &types.Tenant{}, + &types.TenantMember{}, + )) + return db +} + +func seedLikeEscapeKnowledgeBase(t *testing.T, db *gorm.DB, tenantID uint64, kbID string) { + t.Helper() + require.NoError(t, db.Exec(` + INSERT INTO knowledge_bases (id, name, tenant_id, type, embedding_model_id, summary_model_id) + VALUES (?, 'like-escape-kb', ?, 'document', 'test-embedding', 'test-summary') + `, kbID, tenantID).Error) +} + +func seedLikeEscapeKnowledge( + t *testing.T, db *gorm.DB, tenantID uint64, kbID, id, fileName, title string, +) { + t.Helper() + require.NoError(t, db.Exec(` + INSERT INTO knowledges (id, tenant_id, knowledge_base_id, type, title, file_name, source, parse_status) + VALUES (?, ?, ?, 'file', ?, ?, 'manual', 'completed') + `, id, tenantID, kbID, title, fileName).Error) +} + +func seedLikeEscapeKnowledgeSet(t *testing.T, db *gorm.DB, tenantID uint64, kbID string) (literalID string) { + t.Helper() + literalID = uuid.New().String() + // Underscore: literal "IMG_2534" must not match "IMGx2534". + seedLikeEscapeKnowledge(t, db, tenantID, kbID, literalID, "IMG_2534.png", "IMG_2534") + seedLikeEscapeKnowledge(t, db, tenantID, kbID, uuid.New().String(), "IMGx2534.png", "IMGx2534") + // Percent: literal "100%" must not match "1000". + seedLikeEscapeKnowledge(t, db, tenantID, kbID, uuid.New().String(), "100% done.pdf", "100% done") + seedLikeEscapeKnowledge(t, db, tenantID, kbID, uuid.New().String(), "1000 done.pdf", "1000 done") + return literalID +} + +// Covers the document-list keyword filter in applyKnowledgeListFilter +// (reused by the agent list_documents tool and the MCP retrieve tool). +func TestListPagedKnowledgeKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewKnowledgeRepository(db).(*knowledgeRepository) + ctx := context.Background() + const tenantID = uint64(1) + kbID := uuid.New().String() + seedLikeEscapeKnowledgeBase(t, db, tenantID, kbID) + literalID := seedLikeEscapeKnowledgeSet(t, db, tenantID, kbID) + page := &types.Pagination{Page: 1, PageSize: 50} + + for _, keyword := range []string{"IMG_2534", "100%"} { + rows, total, err := repo.ListPagedKnowledgeByKnowledgeBaseID( + ctx, tenantID, kbID, page, types.KnowledgeListFilter{Keyword: keyword}, + ) + require.NoError(t, err, "keyword %q", keyword) + require.Len(t, rows, 1, "keyword %q must match the literal row only", keyword) + assert.Equal(t, int64(1), total, "keyword %q count", keyword) + if keyword == "IMG_2534" { + assert.Equal(t, literalID, rows[0].ID) + } + } +} + +// Covers SearchKnowledge. +func TestSearchKnowledgeKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewKnowledgeRepository(db).(*knowledgeRepository) + ctx := context.Background() + const tenantID = uint64(1) + kbID := uuid.New().String() + seedLikeEscapeKnowledgeBase(t, db, tenantID, kbID) + literalID := seedLikeEscapeKnowledgeSet(t, db, tenantID, kbID) + + rows, _, err := repo.SearchKnowledge(ctx, tenantID, "IMG_2534", 0, 10, nil) + require.NoError(t, err) + require.Len(t, rows, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literalID, rows[0].ID) + + rows, _, err = repo.SearchKnowledge(ctx, tenantID, "100%", 0, 10, nil) + require.NoError(t, err) + require.Len(t, rows, 1, "percent must match literally, not as a wildcard") + assert.Contains(t, rows[0].Title, "100%") +} + +// Covers SearchKnowledgeInScopes (GET /api/v1/knowledge/search). +func TestSearchKnowledgeInScopesKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewKnowledgeRepository(db).(*knowledgeRepository) + ctx := context.Background() + const tenantID = uint64(1) + kbID := uuid.New().String() + seedLikeEscapeKnowledgeBase(t, db, tenantID, kbID) + literalID := seedLikeEscapeKnowledgeSet(t, db, tenantID, kbID) + scopes := []types.KnowledgeSearchScope{{TenantID: tenantID, KBID: kbID}} + + rows, hasMore, total, err := repo.SearchKnowledgeInScopes(ctx, scopes, "IMG_2534", 0, 10, nil) + require.NoError(t, err) + require.Len(t, rows, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literalID, rows[0].ID) + assert.False(t, hasMore) + assert.Equal(t, int64(1), total) + + rows, _, total, err = repo.SearchKnowledgeInScopes(ctx, scopes, "100%", 0, 10, nil) + require.NoError(t, err) + require.Len(t, rows, 1, "percent must match literally, not as a wildcard") + assert.Equal(t, int64(1), total) +} + +// Covers both the count and the data query of the tag search. +func TestListTagsByKBKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewKnowledgeTagRepository(db).(*knowledgeTagRepository) + ctx := context.Background() + const tenantID = uint64(1) + kbID := uuid.New().String() + + literalID := uuid.New().String() + require.NoError(t, db.Create(&types.KnowledgeTag{ + ID: literalID, TenantID: tenantID, KnowledgeBaseID: kbID, Name: "v1_1", + }).Error) + require.NoError(t, db.Create(&types.KnowledgeTag{ + ID: uuid.New().String(), TenantID: tenantID, KnowledgeBaseID: kbID, Name: "v1x1", + }).Error) + + tags, total, err := repo.ListByKB(ctx, tenantID, kbID, &types.Pagination{Page: 1, PageSize: 50}, "v1_1") + require.NoError(t, err) + require.Len(t, tags, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literalID, tags[0].ID) + assert.Equal(t, int64(1), total, "the count query must use the same escape") +} + +// Covers both branches of SearchTenants (with and without a tenant id). +func TestSearchTenantsKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewTenantRepository(db).(*tenantRepository) + ctx := context.Background() + + literal := &types.Tenant{Name: "Acme_Prod", Description: "literal underscore", Status: "active"} + require.NoError(t, db.Create(literal).Error) + require.NoError(t, db.Create(&types.Tenant{ + Name: "AcmeXProd", Description: "wildcard decoy", Status: "active", + }).Error) + + // keyword-only branch (tenantID = 0). + tenants, total, err := repo.SearchTenants(ctx, "Acme_Prod", 0, 1, 20) + require.NoError(t, err) + require.Len(t, tenants, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literal.ID, tenants[0].ID) + assert.Equal(t, int64(1), total) + + // tenantID + keyword branch. + tenants, total, err = repo.SearchTenants(ctx, "Acme_Prod", literal.ID, 1, 20) + require.NoError(t, err) + require.Len(t, tenants, 1) + assert.Equal(t, literal.ID, tenants[0].ID) + assert.Equal(t, int64(1), total) +} + +// Covers both member-search paths (count and page) of the email/username join. +func TestTenantMemberSearchTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewTenantMemberRepository(db).(*tenantMemberRepository) + ctx := context.Background() + const tenantID = uint64(1) + + seedMember := func(id, username, email string) { + t.Helper() + require.NoError(t, db.Exec( + `INSERT INTO users (id, username, email) VALUES (?, ?, ?)`, id, username, email).Error) + require.NoError(t, db.Create(&types.TenantMember{ + UserID: id, TenantID: tenantID, Role: types.TenantRoleContributor, + Status: types.TenantMemberStatusActive, + }).Error) + } + literalID := uuid.New().String() + seedMember(literalID, "ann_bob", "ann_bob@example.com") + seedMember(uuid.New().String(), "annxbob", "annxbob@example.com") + + total, err := repo.CountFilteredByTenant(ctx, tenantID, "ann_bob") + require.NoError(t, err) + assert.Equal(t, int64(1), total, "underscore must match literally, not as a wildcard") + + members, err := repo.ListPagedByTenant(ctx, tenantID, "ann_bob", 0, 20) + require.NoError(t, err) + require.Len(t, members, 1) + assert.Equal(t, literalID, members[0].UserID) +} + +// Covers the session sidebar keyword filter in QueryPaged. +func TestSessionQueryPagedKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewSessionRepository(db) + ctx := context.Background() + const tenantID = uint64(7) + const userID = "web_user:alice" + + literal := &types.Session{TenantID: tenantID, UserID: userID, Title: "Deploy_Plan v1"} + require.NoError(t, db.Create(literal).Error) + require.NoError(t, db.Create(&types.Session{ + TenantID: tenantID, UserID: userID, Title: "DeployXPlan v1", + }).Error) + + rows, total, err := repo.QueryPaged(ctx, &types.SessionListQuery{ + TenantID: tenantID, UserID: userID, Keyword: "Deploy_Plan", Page: 1, PageSize: 20, + }) + require.NoError(t, err) + require.Len(t, rows, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literal.ID, rows[0].ID) + assert.Equal(t, int64(1), total, "the count query must use the same escape") +} + +// Covers the document chunk/Faq keyword filter, which previously did not +// escape the keyword at all (so % and _ acted as wildcards). +func TestListPagedChunksKeywordTreatsLikeWildcardsLiterally(t *testing.T) { + db := setupLikeEscapeTestDB(t) + repo := NewChunkRepository(db).(*chunkRepository) + ctx := context.Background() + const tenantID = uint64(1) + knowledgeID := uuid.New().String() + kbID := uuid.New().String() + + literal := &types.Chunk{ + ID: uuid.New().String(), TenantID: tenantID, KnowledgeID: knowledgeID, + KnowledgeBaseID: kbID, Content: "config v1_1 is active", + ChunkType: types.ChunkTypeText, Status: int(types.ChunkStatusIndexed), IsEnabled: true, + } + require.NoError(t, db.Create(literal).Error) + require.NoError(t, db.Create(&types.Chunk{ + ID: uuid.New().String(), TenantID: tenantID, KnowledgeID: knowledgeID, + KnowledgeBaseID: kbID, Content: "config v1x1 is active", + ChunkType: types.ChunkTypeText, Status: int(types.ChunkStatusIndexed), IsEnabled: true, + }).Error) + + chunks, total, err := repo.ListPagedChunksByKnowledgeID( + ctx, tenantID, knowledgeID, &types.Pagination{Page: 1, PageSize: 50}, + []types.ChunkType{types.ChunkTypeText}, nil, "v1_1", "", "", + types.KnowledgeBaseTypeDocument, nil, + ) + require.NoError(t, err) + require.Len(t, chunks, 1, "underscore must match literally, not as a wildcard") + assert.Equal(t, literal.ID, chunks[0].ID) + assert.Equal(t, int64(1), total) +} diff --git a/internal/application/repository/session.go b/internal/application/repository/session.go index b693487b..fcba558b 100644 --- a/internal/application/repository/session.go +++ b/internal/application/repository/session.go @@ -164,9 +164,9 @@ func (r *sessionRepository) QueryPaged( ) ([]*types.SessionListItem, int64, error) { // Dialect-aware bits so the same query works on Postgres and SQLite (Lite build). isPostgres := r.db.Dialector.Name() == "postgres" - titleLikeExpr := "LOWER(s.title) LIKE LOWER(?)" + titleLikeExpr := "LOWER(s.title) LIKE LOWER(?) ESCAPE ?" if isPostgres { - titleLikeExpr = "s.title ILIKE ?" + titleLikeExpr = "s.title ILIKE ? ESCAPE ?" } // SQLite (the driver used by Lite) does not support NULLS LAST; its default // nulls ordering puts NULLs first for DESC, which is actually what we want @@ -193,7 +193,7 @@ func (r *sessionRepository) QueryPaged( types.SkillMaintenanceSessionMarker+"%", ) if kw := strings.TrimSpace(q.Keyword); kw != "" { - db = db.Where(titleLikeExpr, "%"+escapeLikeKeyword(kw)+"%") + db = db.Where(titleLikeExpr, "%"+escapeLikeKeyword(kw)+"%", likeEscapeChar) } return db } diff --git a/internal/application/repository/tag.go b/internal/application/repository/tag.go index ca225605..7e39f400 100644 --- a/internal/application/repository/tag.go +++ b/internal/application/repository/tag.go @@ -108,7 +108,7 @@ func (r *knowledgeTagRepository) ListByKB( Where("tenant_id = ? AND knowledge_base_id = ?", tenantID, kbID) if keyword != "" { escaped := escapeLikeKeyword(keyword) - baseQuery = baseQuery.Where("name LIKE ?", "%"+escaped+"%") + baseQuery = baseQuery.Where("name LIKE ? ESCAPE ?", "%"+escaped+"%", likeEscapeChar) } if err := baseQuery.Count(&total).Error; err != nil { @@ -119,7 +119,7 @@ func (r *knowledgeTagRepository) ListByKB( Where("tenant_id = ? AND knowledge_base_id = ?", tenantID, kbID) if keyword != "" { escaped := escapeLikeKeyword(keyword) - dataQuery = dataQuery.Where("name LIKE ?", "%"+escaped+"%") + dataQuery = dataQuery.Where("name LIKE ? ESCAPE ?", "%"+escaped+"%", likeEscapeChar) } var tags []*types.KnowledgeTag diff --git a/internal/application/repository/tenant.go b/internal/application/repository/tenant.go index 9d026574..7b0fe99e 100644 --- a/internal/application/repository/tenant.go +++ b/internal/application/repository/tenant.go @@ -83,12 +83,16 @@ func (r *tenantRepository) SearchTenants(ctx context.Context, keyword string, te // Build search conditions if tenantID > 0 && keyword != "" { escaped := escapeLikeKeyword(keyword) - query = query.Where("id = ? OR name LIKE ? OR description LIKE ?", tenantID, "%"+escaped+"%", "%"+escaped+"%") + query = query.Where( + "id = ? OR name LIKE ? ESCAPE ? OR description LIKE ? ESCAPE ?", + tenantID, "%"+escaped+"%", likeEscapeChar, "%"+escaped+"%", likeEscapeChar) } else if tenantID > 0 { query = query.Where("id = ?", tenantID) } else if keyword != "" { escaped := escapeLikeKeyword(keyword) - query = query.Where("name LIKE ? OR description LIKE ?", "%"+escaped+"%", "%"+escaped+"%") + query = query.Where( + "name LIKE ? ESCAPE ? OR description LIKE ? ESCAPE ?", + "%"+escaped+"%", likeEscapeChar, "%"+escaped+"%", likeEscapeChar) } // Count total diff --git a/internal/application/repository/tenant_member.go b/internal/application/repository/tenant_member.go index 17c34a31..4201f829 100644 --- a/internal/application/repository/tenant_member.go +++ b/internal/application/repository/tenant_member.go @@ -109,7 +109,9 @@ func (r *tenantMemberRepository) CountFilteredByTenant( like := "%" + escapeLikePattern(search) + "%" err = q. Joins(`INNER JOIN users ON users.id = tenant_members.user_id AND users.deleted_at IS NULL`). - Where(`(LOWER(users.email) LIKE LOWER(?) OR LOWER(users.username) LIKE LOWER(?))`, like, like). + Where( + `(LOWER(users.email) LIKE LOWER(?) ESCAPE ? OR LOWER(users.username) LIKE LOWER(?) ESCAPE ?)`, + like, likeEscapeChar, like, likeEscapeChar). Count(&total).Error } return total, err @@ -134,7 +136,9 @@ func (r *tenantMemberRepository) ListPagedByTenant( like := "%" + escapeLikePattern(search) + "%" err = q. Joins(`INNER JOIN users ON users.id = tenant_members.user_id AND users.deleted_at IS NULL`). - Where(`(LOWER(users.email) LIKE LOWER(?) OR LOWER(users.username) LIKE LOWER(?))`, like, like). + Where( + `(LOWER(users.email) LIKE LOWER(?) ESCAPE ? OR LOWER(users.username) LIKE LOWER(?) ESCAPE ?)`, + like, likeEscapeChar, like, likeEscapeChar). Find(&members).Error } if err != nil { diff --git a/internal/application/repository/wiki_page.go b/internal/application/repository/wiki_page.go index 28430a72..22ce428b 100644 --- a/internal/application/repository/wiki_page.go +++ b/internal/application/repository/wiki_page.go @@ -1305,14 +1305,10 @@ func (r *wikiPageRepository) DeleteIssuesByKnowledgeBaseID( // escapeLikePattern escapes LIKE / ILIKE metacharacters so the returned string // can be safely concatenated with % wildcards without unintended matches. -// Order matters: escape the backslash first, then the wildcards. +// It is a thin alias for escapeLikeKeyword, which owns the (order-sensitive) +// escaping rules; both must stay paired with an explicit ESCAPE clause. func escapeLikePattern(s string) string { - replacer := strings.NewReplacer( - `\`, `\\`, - `%`, `\%`, - `_`, `\_`, - ) - return replacer.Replace(s) + return escapeLikeKeyword(s) } // Search performs full-text search on wiki pages within a knowledge base.