1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112

// Copyright 2020 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package migrations

import (
	"fmt"
	"strconv"

	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/setting"

	"xorm.io/xorm"
)

func updateCodeCommentReplies(x *xorm.Engine) error {
	type Comment struct {
		ID          int64  `xorm:"pk autoincr"`
		CommitSHA   string `xorm:"VARCHAR(40)"`
		Patch       string `xorm:"TEXT patch"`
		Invalidated bool

		// Not extracted but used in the below query
		Type     int   `xorm:"INDEX"`
		Line     int64 // - previous line / + proposed line
		TreePath string
		ReviewID int64 `xorm:"index"`
	}

	if err := x.Sync2(new(Comment)); err != nil {
		return err
	}

	sqlSelect := `SELECT comment.id as id, first.commit_sha as commit_sha, first.patch as patch, first.invalidated as invalidated`
	sqlTail := ` FROM comment INNER JOIN (
		SELECT C.id, C.review_id, C.line, C.tree_path, C.patch, C.commit_sha, C.invalidated
		FROM comment AS C
		WHERE C.type = 21
			AND C.created_unix =
				(SELECT MIN(comment.created_unix)
					FROM comment
					WHERE comment.review_id = C.review_id
					AND comment.type = 21
					AND comment.line = C.line
					AND comment.tree_path = C.tree_path)
		) AS first
		ON comment.review_id = first.review_id
			AND comment.tree_path = first.tree_path AND comment.line = first.line
	WHERE comment.type = 21
		AND comment.id != first.id
		AND comment.commit_sha != first.commit_sha`

	var (
		sqlCmd    string
		start     = 0
		batchSize = 100
		sess      = x.NewSession()
	)
	defer sess.Close()
	for {
		if err := sess.Begin(); err != nil {
			return err
		}

		if setting.Database.UseMSSQL {
			if _, err := sess.Exec(sqlSelect + " INTO #temp_comments" + sqlTail); err != nil {
				log.Error("unable to create temporary table")
				return err
			}
		}

		comments := make([]*Comment, 0, batchSize)

		switch {
		case setting.Database.UseMySQL:
			sqlCmd = sqlSelect + sqlTail + " LIMIT " + strconv.Itoa(batchSize) + ", " + strconv.Itoa(start)
		case setting.Database.UsePostgreSQL:
			fallthrough
		case setting.Database.UseSQLite3:
			sqlCmd = sqlSelect + sqlTail + " LIMIT " + strconv.Itoa(batchSize) + " OFFSET " + strconv.Itoa(start)
		case setting.Database.UseMSSQL:
			sqlCmd = "SELECT TOP " + strconv.Itoa(batchSize) + " * FROM #temp_comments WHERE " +
				"(id NOT IN ( SELECT TOP " + strconv.Itoa(start) + " id FROM #temp_comments ORDER BY id )) ORDER BY id"
		default:
			return fmt.Errorf("Unsupported database type")
		}

		if err := sess.SQL(sqlCmd).Find(&comments); err != nil {
			log.Error("failed to select: %v", err)
			return err
		}

		for _, comment := range comments {
			if _, err := sess.Table("comment").ID(comment.ID).Cols("commit_sha", "patch", "invalidated").Update(comment); err != nil {
				log.Error("failed to update comment[%d]: %v %v", comment.ID, comment, err)
				return err
			}
		}

		start += len(comments)

		if err := sess.Commit(); err != nil {
			return err
		}
		if len(comments) < batchSize {
			break
		}
	}

	return nil
}