MM-17468 - Improving performance of fetching threads (#11980)

fetchThreads parameter support in the API

store/sqlstore/post_store.go

@@ -128,6 +128,12 @@ func (s *SqlPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
 		if _, err := s.GetMaster().Exec("UPDATE Posts SET UpdateAt = :UpdateAt WHERE Id = :RootId", map[string]interface{}{"UpdateAt": time, "RootId": post.RootId}); err != nil {
 			mlog.Error("Error updating Post UpdateAt.", mlog.Err(err))
 		}
+	} else {
+		if count, err := s.GetMaster().SelectInt("SELECT COUNT(*) FROM Posts WHERE RootId = :Id", map[string]interface{}{"Id": post.Id}); err != nil {
+			mlog.Error(fmt.Sprintf("Error fetching post's thread: %v", err.Error()))
+		} else {
+			post.ReplyCount = count
+		}
 	}
 
 	return post, nil
@@ -266,7 +272,7 @@ func (s *SqlPostStore) GetFlaggedPostsForChannel(userId, channelId string, offse
 	return pl, nil
 }
 
-func (s *SqlPostStore) Get(id string) (*model.PostList, *model.AppError) {
+func (s *SqlPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
 	pl := model.NewPostList()
 
 	if len(id) == 0 {
@@ -274,35 +280,40 @@ func (s *SqlPostStore) Get(id string) (*model.PostList, *model.AppError) {
 	}
 
 	var post model.Post
-	err := s.GetReplica().SelectOne(&post, "SELECT * FROM Posts WHERE Id = :Id AND DeleteAt = 0", map[string]interface{}{"Id": id})
+	var postFetchQuery string
+	if skipFetchThreads {
+		postFetchQuery = "SELECT p.*, (SELECT count(Posts.Id) FROM Posts WHERE Posts.RootId = p.RootId)  FROM Posts p WHERE p.Id = :Id AND p.DeleteAt = 0"
+	} else {
+		postFetchQuery = "SELECT * FROM Posts WHERE Id = :Id AND DeleteAt = 0"
+	}
+	err := s.GetReplica().SelectOne(&post, postFetchQuery, map[string]interface{}{"Id": id})
 	if err != nil {
 		return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "id="+id+err.Error(), http.StatusNotFound)
 	}
-
 	pl.AddPost(&post)
 	pl.AddOrder(id)
+	if !skipFetchThreads {
+		rootId := post.RootId
 
-	rootId := post.RootId
+		if rootId == "" {
+			rootId = post.Id
+		}
 
-	if rootId == "" {
-		rootId = post.Id
+		if len(rootId) == 0 {
+			return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId, http.StatusInternalServerError)
+		}
+
+		var posts []*model.Post
+		_, err = s.GetReplica().Select(&posts, "SELECT * FROM Posts WHERE (Id = :Id OR RootId = :RootId) AND DeleteAt = 0", map[string]interface{}{"Id": rootId, "RootId": rootId})
+		if err != nil {
+			return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId+err.Error(), http.StatusInternalServerError)
+		}
+
+		for _, p := range posts {
+			pl.AddPost(p)
+			pl.AddOrder(p.Id)
+		}
 	}
-
-	if len(rootId) == 0 {
-		return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId, http.StatusInternalServerError)
-	}
-
-	var posts []*model.Post
-	_, err = s.GetReplica().Select(&posts, "SELECT * FROM Posts WHERE (Id = :Id OR RootId = :RootId) AND DeleteAt = 0", map[string]interface{}{"Id": rootId, "RootId": rootId})
-	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId+err.Error(), http.StatusInternalServerError)
-	}
-
-	for _, p := range posts {
-		pl.AddPost(p)
-		pl.AddOrder(p.Id)
-	}
-
 	return pl, nil
 }
 
@@ -445,14 +456,14 @@ func (s *SqlPostStore) PermanentDeleteByChannel(channelId string) *model.AppErro
 	return nil
 }
 
-func (s *SqlPostStore) GetPosts(channelId string, offset int, limit int, allowFromCache bool) (*model.PostList, *model.AppError) {
-	if limit > 1000 {
-		return nil, model.NewAppError("SqlPostStore.GetLinearPosts", "store.sql_post.get_posts.app_error", nil, "channelId="+channelId, http.StatusBadRequest)
+func (s *SqlPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
+	if options.PerPage > 1000 {
+		return nil, model.NewAppError("SqlPostStore.GetLinearPosts", "store.sql_post.get_posts.app_error", nil, "channelId="+options.ChannelId, http.StatusBadRequest)
 	}
-
+	offset := options.PerPage * options.Page
 	// Caching only occurs on limits of 30 and 60, the common limits requested by MM clients
-	if allowFromCache && offset == 0 && (limit == 60 || limit == 30) {
-		if cacheItem, ok := s.lastPostsCache.Get(fmt.Sprintf("%s%v", channelId, limit)); ok {
+	if allowFromCache && offset == 0 && (options.PerPage == 60 || options.PerPage == 30) {
+		if cacheItem, ok := s.lastPostsCache.Get(fmt.Sprintf("%s%v", options.ChannelId, options.PerPage)); ok {
 			if s.metrics != nil {
 				s.metrics.IncrementMemCacheHitCounter("Last Posts Cache")
 			}
@@ -466,13 +477,13 @@ func (s *SqlPostStore) GetPosts(channelId string, offset int, limit int, allowFr
 
 	rpc := make(chan store.StoreResult, 1)
 	go func() {
-		posts, err := s.getRootPosts(channelId, offset, limit)
+		posts, err := s.getRootPosts(options.ChannelId, offset, options.PerPage, options.SkipFetchThreads)
 		rpc <- store.StoreResult{Data: posts, Err: err}
 		close(rpc)
 	}()
 	cpc := make(chan store.StoreResult, 1)
 	go func() {
-		posts, err := s.getParentsPosts(channelId, offset, limit)
+		posts, err := s.getParentsPosts(options.ChannelId, offset, options.PerPage, options.SkipFetchThreads)
 		cpc <- store.StoreResult{Data: posts, Err: err}
 		close(cpc)
 	}()
@@ -505,18 +516,18 @@ func (s *SqlPostStore) GetPosts(channelId string, offset int, limit int, allowFr
 	list.MakeNonNil()
 
 	// Caching only occurs on limits of 30 and 60, the common limits requested by MM clients
-	if offset == 0 && (limit == 60 || limit == 30) {
-		s.lastPostsCache.AddWithExpiresInSecs(fmt.Sprintf("%s%v", channelId, limit), list, LAST_POSTS_CACHE_SEC)
+	if offset == 0 && (options.PerPage == 60 || options.PerPage == 30) {
+		s.lastPostsCache.AddWithExpiresInSecs(fmt.Sprintf("%s%v", options.ChannelId, options.PerPage), list, LAST_POSTS_CACHE_SEC)
 	}
 
 	return list, err
 }
 
-func (s *SqlPostStore) GetPostsSince(channelId string, time int64, allowFromCache bool) (*model.PostList, *model.AppError) {
+func (s *SqlPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
 	if allowFromCache {
 		// If the last post in the channel's time is less than or equal to the time we are getting posts since,
 		// we can safely return no posts.
-		if cacheItem, ok := s.lastPostTimeCache.Get(channelId); ok && cacheItem.(int64) <= time {
+		if cacheItem, ok := s.lastPostTimeCache.Get(options.ChannelId); ok && cacheItem.(int64) <= options.Time {
 			if s.metrics != nil {
 				s.metrics.IncrementMemCacheHitCounter("Last Post Time")
 			}
@@ -556,19 +567,19 @@ func (s *SqlPostStore) GetPostsSince(channelId string, time int64, allowFromCach
 						AND ChannelId = :ChannelId
 				LIMIT 1000) temp_tab))
 		ORDER BY CreateAt DESC`,
-		map[string]interface{}{"ChannelId": channelId, "Time": time})
+		map[string]interface{}{"ChannelId": options.ChannelId, "Time": options.Time})
 
 	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetPostsSince", "store.sql_post.get_posts_since.app_error", nil, "channelId="+channelId+err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlPostStore.GetPostsSince", "store.sql_post.get_posts_since.app_error", nil, "channelId="+options.ChannelId+err.Error(), http.StatusInternalServerError)
 	}
 
 	list := model.NewPostList()
 
-	latestUpdate := time
+	latestUpdate := options.Time
 
 	for _, p := range posts {
 		list.AddPost(p)
-		if p.UpdateAt > time {
+		if p.UpdateAt > options.Time {
 			list.AddOrder(p.Id)
 		}
 		if latestUpdate < p.UpdateAt {
@@ -576,21 +587,25 @@ func (s *SqlPostStore) GetPostsSince(channelId string, time int64, allowFromCach
 		}
 	}
 
-	s.lastPostTimeCache.AddWithExpiresInSecs(channelId, latestUpdate, LAST_POST_TIME_CACHE_SEC)
+	s.lastPostTimeCache.AddWithExpiresInSecs(options.ChannelId, latestUpdate, LAST_POST_TIME_CACHE_SEC)
 
 	return list, nil
 }
 
-func (s *SqlPostStore) GetPostsBefore(channelId string, postId string, limit int, offset int) (*model.PostList, *model.AppError) {
-	return s.getPostsAround(channelId, postId, limit, offset, true)
+func (s *SqlPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
+	return s.getPostsAround(true, options)
 }
 
-func (s *SqlPostStore) GetPostsAfter(channelId string, postId string, limit int, offset int) (*model.PostList, *model.AppError) {
-	return s.getPostsAround(channelId, postId, limit, offset, false)
+func (s *SqlPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
+	return s.getPostsAround(false, options)
 }
 
-func (s *SqlPostStore) getPostsAround(channelId string, postId string, limit int, offset int, before bool) (*model.PostList, *model.AppError) {
-	var direction, sort string
+func (s *SqlPostStore) getPostsAround(before bool, options model.GetPostsOptions) (*model.PostList, *model.AppError) {
+	offset := options.Page * options.PerPage
+	var posts, parents []*model.Post
+
+	var direction string
+	var sort string
 	if before {
 		direction = "<"
 		sort = "DESC"
@@ -598,23 +613,29 @@ func (s *SqlPostStore) getPostsAround(channelId string, postId string, limit int
 		direction = ">"
 		sort = "ASC"
 	}
+	replyCountSubQuery := s.getQueryBuilder().Select("COUNT(Posts.Id)").From("Posts").Where(sq.Expr("p.RootId = '' AND RootId = p.Id"))
+	query := s.getQueryBuilder().Select("p.*")
+	if options.SkipFetchThreads {
+		query = query.Column(sq.Alias(replyCountSubQuery, "ReplyCount"))
+	}
+	query = query.From("Posts p").
+		Where(sq.And{
+			sq.Expr(`CreateAt `+direction+` (SELECT CreateAt FROM Posts WHERE Id = ?)`, options.PostId),
+			sq.Eq{"ChannelId": options.ChannelId},
+			sq.Eq{"DeleteAt": int(0)},
+		}).
+		OrderBy("CreateAt " + sort).
+		Limit(uint64(options.PerPage)).
+		Offset(uint64(offset))
+
+	queryString, args, err := query.ToSql()
 
-	var posts, parents []*model.Post
-	_, err := s.GetReplica().Select(&posts,
-		`SELECT
-			*
-		FROM
-			Posts
-		WHERE
-			CreateAt `+direction+` (SELECT CreateAt FROM Posts WHERE Id = :PostId)
-				AND ChannelId = :ChannelId
-				AND DeleteAt = 0
-		ORDER BY CreateAt `+sort+`
-		LIMIT :Limit
-		OFFSET :Offset`,
-		map[string]interface{}{"ChannelId": channelId, "PostId": postId, "Limit": limit, "Offset": offset})
 	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get.app_error", nil, "channelId="+channelId+err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get.app_error", nil, "channelId="+options.ChannelId+err.Error(), http.StatusInternalServerError)
+	}
+	_, err = s.GetMaster().Select(&posts, queryString, args...)
+	if err != nil {
+		return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get.app_error", nil, "channelId="+options.ChannelId+err.Error(), http.StatusInternalServerError)
 	}
 
 	if len(posts) > 0 {
@@ -625,28 +646,29 @@ func (s *SqlPostStore) getPostsAround(channelId string, postId string, limit int
 				rootIds = append(rootIds, post.RootId)
 			}
 		}
+		rootQuery := s.getQueryBuilder().Select("p.*")
+		if options.SkipFetchThreads {
+			rootQuery = rootQuery.Column(sq.Alias(replyCountSubQuery, "ReplyCount"))
+		}
+		rootQuery = rootQuery.From("Posts p").
+			Where(sq.And{
+				sq.Or{
+					sq.Eq{"RootId": rootIds},
+					sq.Eq{"Id": rootIds},
+				},
+				sq.Eq{"ChannelId": options.ChannelId},
+				sq.Eq{"DeleteAt": 0},
+			}).
+			OrderBy("CreateAt DESC")
 
-		keys, params := MapStringsToQueryParams(rootIds, "PostId")
-
-		params["ChannelId"] = channelId
-		params["PostId"] = postId
-		params["Limit"] = limit
-		params["Offset"] = offset
-
-		_, err = s.GetReplica().Select(&parents,
-			`SELECT
-				*
-			FROM
-				Posts
-			WHERE
-				(Id IN `+keys+` OR RootId IN `+keys+`)
-				AND ChannelId = :ChannelId
-				AND DeleteAt = 0
-			ORDER BY CreateAt DESC`,
-			params)
+		rootQueryString, rootArgs, err := rootQuery.ToSql()
 
 		if err != nil {
-			return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get_parent.app_error", nil, "channelId="+channelId+err.Error(), http.StatusInternalServerError)
+			return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get_parent.app_error", nil, "channelId="+options.ChannelId+err.Error(), http.StatusInternalServerError)
+		}
+		_, err = s.GetMaster().Select(&parents, rootQueryString, rootArgs...)
+		if err != nil {
+			return nil, model.NewAppError("SqlPostStore.GetPostContext", "store.sql_post.get_posts_around.get_parent.app_error", nil, "channelId="+options.ChannelId+err.Error(), http.StatusInternalServerError)
 		}
 	}
 
@@ -745,20 +767,29 @@ func (s *SqlPostStore) GetPostAfterTime(channelId string, time int64) (*model.Po
 	return post, nil
 }
 
-func (s *SqlPostStore) getRootPosts(channelId string, offset int, limit int) ([]*model.Post, *model.AppError) {
+func (s *SqlPostStore) getRootPosts(channelId string, offset int, limit int, skipFetchThreads bool) ([]*model.Post, *model.AppError) {
 	var posts []*model.Post
-	_, err := s.GetReplica().Select(&posts, "SELECT * FROM Posts WHERE ChannelId = :ChannelId AND DeleteAt = 0 ORDER BY CreateAt DESC LIMIT :Limit OFFSET :Offset", map[string]interface{}{"ChannelId": channelId, "Offset": offset, "Limit": limit})
+	var fetchQuery string
+	if skipFetchThreads {
+		fetchQuery = "SELECT p.*, (SELECT COUNT(Posts.Id) FROM Posts WHERE p.RootId = '' AND Posts.RootId = p.Id) as ReplyCount FROM Posts p WHERE ChannelId = :ChannelId AND DeleteAt = 0 ORDER BY CreateAt DESC LIMIT :Limit OFFSET :Offset"
+	} else {
+		fetchQuery = "SELECT * FROM Posts WHERE ChannelId = :ChannelId AND DeleteAt = 0 ORDER BY CreateAt DESC LIMIT :Limit OFFSET :Offset"
+	}
+	_, err := s.GetReplica().Select(&posts, fetchQuery, map[string]interface{}{"ChannelId": channelId, "Offset": offset, "Limit": limit})
 	if err != nil {
 		return nil, model.NewAppError("SqlPostStore.GetLinearPosts", "store.sql_post.get_root_posts.app_error", nil, "channelId="+channelId+err.Error(), http.StatusInternalServerError)
 	}
 	return posts, nil
 }
 
-func (s *SqlPostStore) getParentsPosts(channelId string, offset int, limit int) ([]*model.Post, *model.AppError) {
+func (s *SqlPostStore) getParentsPosts(channelId string, offset int, limit int, skipFetchThreads bool) ([]*model.Post, *model.AppError) {
 	var posts []*model.Post
+	replyCountQuery := ""
+	if skipFetchThreads {
+		replyCountQuery = ` ,(SELECT COUNT(Posts.Id) FROM Posts WHERE q2.RootId = '' AND Posts.RootId = q2.Id) as ReplyCount`
+	}
 	_, err := s.GetReplica().Select(&posts,
-		`SELECT
-			q2.*
+		`SELECT q2.*`+replyCountQuery+`
 		FROM
 			Posts q2
 				INNER JOIN

store/store.go

@@ -200,18 +200,18 @@ type ChannelMemberHistoryStore interface {
 type PostStore interface {
 	Save(post *model.Post) (*model.Post, *model.AppError)
 	Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError)
-	Get(id string) (*model.PostList, *model.AppError)
+	Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError)
 	GetSingle(id string) (*model.Post, *model.AppError)
 	Delete(postId string, time int64, deleteByID string) *model.AppError
 	PermanentDeleteByUser(userId string) *model.AppError
 	PermanentDeleteByChannel(channelId string) *model.AppError
-	GetPosts(channelId string, offset int, limit int, allowFromCache bool) (*model.PostList, *model.AppError)
+	GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, *model.AppError)
 	GetFlaggedPosts(userId string, offset int, limit int) (*model.PostList, *model.AppError)
 	GetFlaggedPostsForTeam(userId, teamId string, offset int, limit int) (*model.PostList, *model.AppError)
 	GetFlaggedPostsForChannel(userId, channelId string, offset int, limit int) (*model.PostList, *model.AppError)
-	GetPostsBefore(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError)
-	GetPostsAfter(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError)
-	GetPostsSince(channelId string, time int64, allowFromCache bool) (*model.PostList, *model.AppError)
+	GetPostsBefore(options model.GetPostsOptions) (*model.PostList, *model.AppError)
+	GetPostsAfter(options model.GetPostsOptions) (*model.PostList, *model.AppError)
+	GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, *model.AppError)
 	GetPostAfterTime(channelId string, time int64) (*model.Post, *model.AppError)
 	GetPostIdAfterTime(channelId string, time int64) (string, *model.AppError)
 	GetPostIdBeforeTime(channelId string, time int64) (string, *model.AppError)

store/storetest/mocks/PostStore.go

@@ -108,13 +108,13 @@ func (_m *PostStore) Delete(postId string, time int64, deleteByID string) *model
 	return r0
 }
 
-// Get provides a mock function with given fields: id
-func (_m *PostStore) Get(id string) (*model.PostList, *model.AppError) {
-	ret := _m.Called(id)
+// Get provides a mock function with given fields: id, skipFetchThreads
+func (_m *PostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
+	ret := _m.Called(id, skipFetchThreads)
 
 	var r0 *model.PostList
-	if rf, ok := ret.Get(0).(func(string) *model.PostList); ok {
-		r0 = rf(id)
+	if rf, ok := ret.Get(0).(func(string, bool) *model.PostList); ok {
+		r0 = rf(id, skipFetchThreads)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.PostList)
@@ -122,8 +122,8 @@ func (_m *PostStore) Get(id string) (*model.PostList, *model.AppError) {
 	}
 
 	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
-		r1 = rf(id)
+	if rf, ok := ret.Get(1).(func(string, bool) *model.AppError); ok {
+		r1 = rf(id, skipFetchThreads)
 	} else {
 		if ret.Get(1) != nil {
 			r1 = ret.Get(1).(*model.AppError)
@@ -382,13 +382,13 @@ func (_m *PostStore) GetPostIdBeforeTime(channelId string, time int64) (string,
 	return r0, r1
 }
 
-// GetPosts provides a mock function with given fields: channelId, offset, limit, allowFromCache
-func (_m *PostStore) GetPosts(channelId string, offset int, limit int, allowFromCache bool) (*model.PostList, *model.AppError) {
-	ret := _m.Called(channelId, offset, limit, allowFromCache)
+// GetPosts provides a mock function with given fields: options, allowFromCache
+func (_m *PostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
+	ret := _m.Called(options, allowFromCache)
 
 	var r0 *model.PostList
-	if rf, ok := ret.Get(0).(func(string, int, int, bool) *model.PostList); ok {
-		r0 = rf(channelId, offset, limit, allowFromCache)
+	if rf, ok := ret.Get(0).(func(model.GetPostsOptions, bool) *model.PostList); ok {
+		r0 = rf(options, allowFromCache)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.PostList)
@@ -396,8 +396,8 @@ func (_m *PostStore) GetPosts(channelId string, offset int, limit int, allowFrom
 	}
 
 	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, int, int, bool) *model.AppError); ok {
-		r1 = rf(channelId, offset, limit, allowFromCache)
+	if rf, ok := ret.Get(1).(func(model.GetPostsOptions, bool) *model.AppError); ok {
+		r1 = rf(options, allowFromCache)
 	} else {
 		if ret.Get(1) != nil {
 			r1 = ret.Get(1).(*model.AppError)
@@ -407,13 +407,13 @@ func (_m *PostStore) GetPosts(channelId string, offset int, limit int, allowFrom
 	return r0, r1
 }
 
-// GetPostsAfter provides a mock function with given fields: channelId, postId, numPosts, offset
-func (_m *PostStore) GetPostsAfter(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError) {
-	ret := _m.Called(channelId, postId, numPosts, offset)
+// GetPostsAfter provides a mock function with given fields: options
+func (_m *PostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
+	ret := _m.Called(options)
 
 	var r0 *model.PostList
-	if rf, ok := ret.Get(0).(func(string, string, int, int) *model.PostList); ok {
-		r0 = rf(channelId, postId, numPosts, offset)
+	if rf, ok := ret.Get(0).(func(model.GetPostsOptions) *model.PostList); ok {
+		r0 = rf(options)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.PostList)
@@ -421,8 +421,8 @@ func (_m *PostStore) GetPostsAfter(channelId string, postId string, numPosts int
 	}
 
 	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
-		r1 = rf(channelId, postId, numPosts, offset)
+	if rf, ok := ret.Get(1).(func(model.GetPostsOptions) *model.AppError); ok {
+		r1 = rf(options)
 	} else {
 		if ret.Get(1) != nil {
 			r1 = ret.Get(1).(*model.AppError)
@@ -457,13 +457,13 @@ func (_m *PostStore) GetPostsBatchForIndexing(startTime int64, endTime int64, li
 	return r0, r1
 }
 
-// GetPostsBefore provides a mock function with given fields: channelId, postId, numPosts, offset
-func (_m *PostStore) GetPostsBefore(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError) {
-	ret := _m.Called(channelId, postId, numPosts, offset)
+// GetPostsBefore provides a mock function with given fields: options
+func (_m *PostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
+	ret := _m.Called(options)
 
 	var r0 *model.PostList
-	if rf, ok := ret.Get(0).(func(string, string, int, int) *model.PostList); ok {
-		r0 = rf(channelId, postId, numPosts, offset)
+	if rf, ok := ret.Get(0).(func(model.GetPostsOptions) *model.PostList); ok {
+		r0 = rf(options)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.PostList)
@@ -471,8 +471,8 @@ func (_m *PostStore) GetPostsBefore(channelId string, postId string, numPosts in
 	}
 
 	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string, int, int) *model.AppError); ok {
-		r1 = rf(channelId, postId, numPosts, offset)
+	if rf, ok := ret.Get(1).(func(model.GetPostsOptions) *model.AppError); ok {
+		r1 = rf(options)
 	} else {
 		if ret.Get(1) != nil {
 			r1 = ret.Get(1).(*model.AppError)
@@ -532,13 +532,13 @@ func (_m *PostStore) GetPostsCreatedAt(channelId string, time int64) ([]*model.P
 	return r0, r1
 }
 
-// GetPostsSince provides a mock function with given fields: channelId, time, allowFromCache
-func (_m *PostStore) GetPostsSince(channelId string, time int64, allowFromCache bool) (*model.PostList, *model.AppError) {
-	ret := _m.Called(channelId, time, allowFromCache)
+// GetPostsSince provides a mock function with given fields: options, allowFromCache
+func (_m *PostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
+	ret := _m.Called(options, allowFromCache)
 
 	var r0 *model.PostList
-	if rf, ok := ret.Get(0).(func(string, int64, bool) *model.PostList); ok {
-		r0 = rf(channelId, time, allowFromCache)
+	if rf, ok := ret.Get(0).(func(model.GetPostsSinceOptions, bool) *model.PostList); ok {
+		r0 = rf(options, allowFromCache)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.PostList)
@@ -546,8 +546,8 @@ func (_m *PostStore) GetPostsSince(channelId string, time int64, allowFromCache
 	}
 
 	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, int64, bool) *model.AppError); ok {
-		r1 = rf(channelId, time, allowFromCache)
+	if rf, ok := ret.Get(1).(func(model.GetPostsSinceOptions, bool) *model.AppError); ok {
+		r1 = rf(options, allowFromCache)
 	} else {
 		if ret.Get(1) != nil {
 			r1 = ret.Get(1).(*model.AppError)

store/storetest/post_store.go

@@ -134,7 +134,7 @@ func testPostStoreGet(t *testing.T, ss store.Store) {
 		t.Fatal("Invalid Etag")
 	}
 
-	r1, err := ss.Post().Get(o1.Id)
+	r1, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -142,11 +142,11 @@ func testPostStoreGet(t *testing.T, ss store.Store) {
 		t.Fatal("invalid returned post")
 	}
 
-	if _, err = ss.Post().Get("123"); err == nil {
+	if _, err = ss.Post().Get("123", false); err == nil {
 		t.Fatal("Missing id should have failed")
 	}
 
-	if _, err = ss.Post().Get(""); err == nil {
+	if _, err = ss.Post().Get("", false); err == nil {
 		t.Fatal("should fail for blank post ids")
 	}
 }
@@ -232,17 +232,17 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 	o3, err = ss.Post().Save(o3)
 	require.Nil(t, err)
 
-	r1, err := ss.Post().Get(o1.Id)
+	r1, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro1 := r1.Posts[o1.Id]
-	r2, err := ss.Post().Get(o1.Id)
+	r2, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro2 := r2.Posts[o2.Id]
-	r3, err := ss.Post().Get(o3.Id)
+	r3, err := ss.Post().Get(o3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -259,7 +259,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r1, err = ss.Post().Get(o1.Id)
+	r1, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -276,7 +276,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r2, err = ss.Post().Get(o1.Id)
+	r2, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -293,7 +293,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r3, err = ss.Post().Get(o3.Id)
+	r3, err = ss.Post().Get(o3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -311,7 +311,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 	})
 	require.Nil(t, err)
 
-	r4, err := ss.Post().Get(o4.Id)
+	r4, err := ss.Post().Get(o4.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -325,7 +325,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r4, err = ss.Post().Get(o4.Id)
+	r4, err = ss.Post().Get(o4.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -352,7 +352,7 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
 	o1, err := ss.Post().Save(o1)
 	require.Nil(t, err)
 
-	if r1, err := ss.Post().Get(o1.Id); err != nil {
+	if r1, err := ss.Post().Get(o1.Id, false); err != nil {
 		t.Fatal(err)
 	} else {
 		if r1.Posts[o1.Id].CreateAt != o1.CreateAt {
@@ -371,7 +371,7 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
 		t.Errorf("Expected (*Post).Props[model.POST_PROPS_DELETE_BY] to be %v but got %v.", deleteByID, actual)
 	}
 
-	if r3, err := ss.Post().Get(o1.Id); err == nil {
+	if r3, err := ss.Post().Get(o1.Id, false); err == nil {
 		t.Log(r3)
 		t.Fatal("Missing id should have failed")
 	}
@@ -403,11 +403,11 @@ func testPostStoreDelete1Level(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	if _, err := ss.Post().Get(o1.Id); err == nil {
+	if _, err := ss.Post().Get(o1.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o2.Id); err == nil {
+	if _, err := ss.Post().Get(o2.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 }
@@ -449,19 +449,19 @@ func testPostStoreDelete2Level(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	if _, err := ss.Post().Get(o1.Id); err == nil {
+	if _, err := ss.Post().Get(o1.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o2.Id); err == nil {
+	if _, err := ss.Post().Get(o2.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o3.Id); err == nil {
+	if _, err := ss.Post().Get(o3.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o4.Id); err != nil {
+	if _, err := ss.Post().Get(o4.Id, false); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -494,11 +494,11 @@ func testPostStorePermDelete1Level(t *testing.T, ss store.Store) {
 		t.Fatal(err2)
 	}
 
-	if _, err := ss.Post().Get(o1.Id); err != nil {
+	if _, err := ss.Post().Get(o1.Id, false); err != nil {
 		t.Fatal("Deleted id shouldn't have failed")
 	}
 
-	if _, err := ss.Post().Get(o2.Id); err == nil {
+	if _, err := ss.Post().Get(o2.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
@@ -506,7 +506,7 @@ func testPostStorePermDelete1Level(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	if _, err := ss.Post().Get(o3.Id); err == nil {
+	if _, err := ss.Post().Get(o3.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 }
@@ -539,15 +539,15 @@ func testPostStorePermDelete1Level2(t *testing.T, ss store.Store) {
 		t.Fatal(err2)
 	}
 
-	if _, err := ss.Post().Get(o1.Id); err == nil {
+	if _, err := ss.Post().Get(o1.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o2.Id); err == nil {
+	if _, err := ss.Post().Get(o2.Id, false); err == nil {
 		t.Fatal("Deleted id should have failed")
 	}
 
-	if _, err := ss.Post().Get(o3.Id); err != nil {
+	if _, err := ss.Post().Get(o3.Id, false); err != nil {
 		t.Fatal("Deleted id shouldn't have failed")
 	}
 }
@@ -578,7 +578,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
 	o3, err = ss.Post().Save(o3)
 	require.Nil(t, err)
 
-	pl, err := ss.Post().Get(o1.Id)
+	pl, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -591,7 +591,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
 		t.Fatal(dErr)
 	}
 
-	pl, err = ss.Post().Get(o1.Id)
+	pl, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -604,7 +604,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
 		t.Fatal(dErr)
 	}
 
-	pl, err = ss.Post().Get(o1.Id)
+	pl, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -670,7 +670,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
 	o5, err = ss.Post().Save(o5)
 	require.Nil(t, err)
 
-	r1, err := ss.Post().GetPosts(o1.ChannelId, 0, 4, false)
+	r1, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, false)
 	require.Nil(t, err)
 
 	if r1.Order[0] != o5.Id {
@@ -697,7 +697,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
 		t.Fatal("Missing parent")
 	}
 
-	r2, err := ss.Post().GetPosts(o1.ChannelId, 0, 4, true)
+	r2, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, true)
 	require.Nil(t, err)
 
 	if r2.Order[0] != o5.Id {
@@ -725,7 +725,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
 	}
 
 	// Run once to fill cache
-	_, err = ss.Post().GetPosts(o1.ChannelId, 0, 30, true)
+	_, err = ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, true)
 	require.Nil(t, err)
 
 	o6 := &model.Post{}
@@ -736,14 +736,14 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Should only be 6 since we hit the cache
-	r3, err := ss.Post().GetPosts(o1.ChannelId, 0, 30, true)
+	r3, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, true)
 	require.Nil(t, err)
 	assert.Equal(t, 6, len(r3.Order))
 
 	ss.Post().InvalidateLastPostTimeCache(o1.ChannelId)
 
 	// Cache was invalidated, we should get all the posts
-	r4, err := ss.Post().GetPosts(o1.ChannelId, 0, 30, true)
+	r4, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, true)
 	require.Nil(t, err)
 	assert.Equal(t, 7, len(r4.Order))
 }
@@ -768,7 +768,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		}
 
 		t.Run("should not return anything before the first post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsBefore(channelId, posts[0].Id, 10, 0)
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: 0, PerPage: 10})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{}, postList.Order)
@@ -776,7 +776,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should return posts before a post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsBefore(channelId, posts[5].Id, 10, 0)
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, Page: 0, PerPage: 10})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{posts[4].Id, posts[3].Id, posts[2].Id, posts[1].Id, posts[0].Id}, postList.Order)
@@ -790,7 +790,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should limit posts before", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsBefore(channelId, posts[5].Id, 2, 0)
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{posts[4].Id, posts[3].Id}, postList.Order)
@@ -801,7 +801,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should not return anything after the last post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsAfter(channelId, posts[len(posts)-1].Id, 10, 0)
+			postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[len(posts)-1].Id, PerPage: 10})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{}, postList.Order)
@@ -809,7 +809,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should return posts after a post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsAfter(channelId, posts[5].Id, 10, 0)
+			postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 10})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{posts[9].Id, posts[8].Id, posts[7].Id, posts[6].Id}, postList.Order)
@@ -822,7 +822,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should limit posts after", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsAfter(channelId, posts[5].Id, 2, 0)
+			postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{posts[7].Id, posts[6].Id}, postList.Order)
@@ -832,7 +832,6 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 			}, postList.Posts)
 		})
 	})
-
 	t.Run("with threads", func(t *testing.T) {
 		channelId := model.NewId()
 		userId := model.NewId()
@@ -903,7 +902,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		post2.UpdateAt = post6.UpdateAt
 
 		t.Run("should return each post and thread before a post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsBefore(channelId, post4.Id, 2, 0)
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order)
@@ -917,7 +916,116 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
 		})
 
 		t.Run("should return each post and the root of each thread after a post", func(t *testing.T) {
-			postList, err := ss.Post().GetPostsAfter(channelId, post4.Id, 2, 0)
+			postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2})
+			assert.Nil(t, err)
+
+			assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order)
+			assert.Equal(t, map[string]*model.Post{
+				post2.Id: post2,
+				post4.Id: post4,
+				post5.Id: post5,
+				post6.Id: post6,
+			}, postList.Posts)
+		})
+	})
+	t.Run("with threads (skipFetchThreads)", func(t *testing.T) {
+		channelId := model.NewId()
+		userId := model.NewId()
+
+		// This creates a series of posts that looks like:
+		// post1
+		// post2
+		// post3 (in response to post1)
+		// post4 (in response to post2)
+		// post5
+		// post6 (in response to post2)
+
+		post1, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			Message:   "post1",
+		})
+		require.Nil(t, err)
+		post1.ReplyCount = 1
+		time.Sleep(time.Millisecond)
+
+		post2, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			Message:   "post2",
+		})
+		require.Nil(t, err)
+		post2.ReplyCount = 2
+		time.Sleep(time.Millisecond)
+
+		post3, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			ParentId:  post1.Id,
+			RootId:    post1.Id,
+			Message:   "post3",
+		})
+		require.Nil(t, err)
+		time.Sleep(time.Millisecond)
+
+		post4, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			RootId:    post2.Id,
+			ParentId:  post2.Id,
+			Message:   "post4",
+		})
+		require.Nil(t, err)
+		time.Sleep(time.Millisecond)
+
+		post5, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			Message:   "post5",
+		})
+		require.Nil(t, err)
+		time.Sleep(time.Millisecond)
+
+		post6, err := ss.Post().Save(&model.Post{
+			ChannelId: channelId,
+			UserId:    userId,
+			ParentId:  post2.Id,
+			RootId:    post2.Id,
+			Message:   "post6",
+		})
+		require.Nil(t, err)
+
+		// Adding a post to a thread changes the UpdateAt timestamp of the parent post
+		post1.UpdateAt = post3.UpdateAt
+		post2.UpdateAt = post6.UpdateAt
+
+		t.Run("should return each post and thread before a post", func(t *testing.T) {
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true})
+			assert.Nil(t, err)
+
+			assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order)
+			assert.Equal(t, map[string]*model.Post{
+				post1.Id: post1,
+				post2.Id: post2,
+				post3.Id: post3,
+				post4.Id: post4,
+				post6.Id: post6,
+			}, postList.Posts)
+		})
+
+		t.Run("should return each post and thread before a post with limit", func(t *testing.T) {
+			postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 1, SkipFetchThreads: true})
+			assert.Nil(t, err)
+
+			assert.Equal(t, []string{post3.Id}, postList.Order)
+			assert.Equal(t, map[string]*model.Post{
+				post1.Id: post1,
+				post3.Id: post3,
+			}, postList.Posts)
+		})
+
+		t.Run("should return each post and the root of each thread after a post", func(t *testing.T) {
+			postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true})
 			assert.Nil(t, err)
 
 			assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order)
@@ -986,7 +1094,7 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		time.Sleep(time.Millisecond)
 
-		postList, err := ss.Post().GetPostsSince(channelId, post3.CreateAt, false)
+		postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post3.CreateAt}, false)
 		assert.Nil(t, err)
 
 		assert.Equal(t, []string{
@@ -1017,7 +1125,7 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		time.Sleep(time.Millisecond)
 
-		postList, err := ss.Post().GetPostsSince(channelId, post1.CreateAt, false)
+		postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, false)
 		assert.Nil(t, err)
 
 		assert.Equal(t, []string{}, postList.Order)
@@ -1039,12 +1147,12 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
 		time.Sleep(time.Millisecond)
 
 		// Make a request that returns no results
-		postList, err := ss.Post().GetPostsSince(channelId, post1.CreateAt, true)
+		postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, true)
 		require.Nil(t, err)
 		require.Equal(t, model.NewPostList(), postList)
 
 		// And then ensure that it doesn't cause future requests to also return no results
-		postList, err = ss.Post().GetPostsSince(channelId, post1.CreateAt-1, true)
+		postList, err = ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt - 1}, true)
 		assert.Nil(t, err)
 
 		assert.Equal(t, []string{post1.Id}, postList.Order)
@@ -2173,17 +2281,17 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 	o3.Message = "zz" + model.NewId() + "QQQQQQQQQQ"
 	o3, err = ss.Post().Save(o3)
 
-	r1, err := ss.Post().Get(o1.Id)
+	r1, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro1 := r1.Posts[o1.Id]
-	r2, err := ss.Post().Get(o1.Id)
+	r2, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro2 := r2.Posts[o2.Id]
-	r3, err := ss.Post().Get(o3.Id)
+	r3, err := ss.Post().Get(o3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2201,7 +2309,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r1, err = ss.Post().Get(o1.Id)
+	r1, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2219,7 +2327,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r2, err = ss.Post().Get(o1.Id)
+	r2, err = ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2237,7 +2345,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r3, err = ss.Post().Get(o3.Id)
+	r3, err = ss.Post().Get(o3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2255,7 +2363,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 	})
 	require.Nil(t, err)
 
-	r4, err := ss.Post().Get(o4.Id)
+	r4, err := ss.Post().Get(o4.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2270,7 +2378,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	r4, err = ss.Post().Get(o4.Id)
+	r4, err = ss.Post().Get(o4.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2306,17 +2414,17 @@ func testPostStoreGetPostsByIds(t *testing.T, ss store.Store) {
 	o3, err = ss.Post().Save(o3)
 	require.Nil(t, err)
 
-	r1, err := ss.Post().Get(o1.Id)
+	r1, err := ss.Post().Get(o1.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro1 := r1.Posts[o1.Id]
-	r2, err := ss.Post().Get(o2.Id)
+	r2, err := ss.Post().Get(o2.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ro2 := r2.Posts[o2.Id]
-	r3, err := ss.Post().Get(o3.Id)
+	r3, err := ss.Post().Get(o3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2444,15 +2552,15 @@ func testPostStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
 	_, err = ss.Post().PermanentDeleteBatch(2000, 1000)
 	require.Nil(t, err)
 
-	if _, err := ss.Post().Get(o1.Id); err == nil {
+	if _, err := ss.Post().Get(o1.Id, false); err == nil {
 		t.Fatalf("Should have not found post 1 after purge")
 	}
 
-	if _, err := ss.Post().Get(o2.Id); err == nil {
+	if _, err := ss.Post().Get(o2.Id, false); err == nil {
 		t.Fatalf("Should have not found post 2 after purge")
 	}
 
-	if _, err := ss.Post().Get(o3.Id); err != nil {
+	if _, err := ss.Post().Get(o3.Id, false); err != nil {
 		t.Fatalf("Should have not found post 3 after purge")
 	}
 }

store/storetest/reaction_store.go

@@ -42,7 +42,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 	}
 
 	var secondUpdateAt int64
-	postList, err := ss.Post().Get(reaction1.PostId)
+	postList, err := ss.Post().Get(reaction1.PostId, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -69,7 +69,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 		t.Fatal(err)
 	}
 
-	postList, err = ss.Post().Get(reaction2.PostId)
+	postList, err = ss.Post().Get(reaction2.PostId, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -123,7 +123,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 
 	_, err = ss.Reaction().Save(reaction)
 	require.Nil(t, err)
-	result, err := ss.Post().Get(reaction.PostId)
+	result, err := ss.Post().Get(reaction.PostId, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -138,7 +138,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 	} else if len(reactions) != 0 {
 		t.Fatal("should've deleted reaction")
 	}
-	postList, err := ss.Post().Get(post.Id)
+	postList, err := ss.Post().Get(post.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -316,7 +316,7 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store) {
 	}
 
 	// check that the posts are updated
-	postList, err := ss.Post().Get(post.Id)
+	postList, err := ss.Post().Get(post.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -324,7 +324,7 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store) {
 		t.Fatal("post should still have reactions")
 	}
 
-	postList, err = ss.Post().Get(post2.Id)
+	postList, err = ss.Post().Get(post2.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -332,7 +332,7 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store) {
 		t.Fatal("post should still have reactions")
 	}
 
-	postList, err = ss.Post().Get(post3.Id)
+	postList, err = ss.Post().Get(post3.Id, false)
 	if err != nil {
 		t.Fatal(err)
 	}

store/timer_layer.go

@@ -3728,6 +3728,23 @@ func (s *TimerLayerOAuthStore) UpdateApp(app *model.OAuthApp) (*model.OAuthApp,
 	return resultVar0, resultVar1
 }
 
+func (s *TimerLayerPluginStore) CompareAndDelete(keyVal *model.PluginKeyValue, oldValue []byte) (bool, *model.AppError) {
+	start := timemodule.Now()
+
+	resultVar0, resultVar1 := s.PluginStore.CompareAndDelete(keyVal, oldValue)
+
+	t := timemodule.Now()
+	elapsed := t.Sub(start)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if resultVar1 == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.CompareAndDelete", success, float64(elapsed))
+	}
+	return resultVar0, resultVar1
+}
+
 func (s *TimerLayerPluginStore) CompareAndSet(keyVal *model.PluginKeyValue, oldValue []byte) (bool, *model.AppError) {
 	start := timemodule.Now()
 
@@ -3932,10 +3949,10 @@ func (s *TimerLayerPostStore) Delete(postId string, time int64, deleteByID strin
 	return resultVar0
 }
 
-func (s *TimerLayerPostStore) Get(id string) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
 	start := timemodule.Now()
 
-	resultVar0, resultVar1 := s.PostStore.Get(id)
+	resultVar0, resultVar1 := s.PostStore.Get(id, skipFetchThreads)
 
 	t := timemodule.Now()
 	elapsed := t.Sub(start)
@@ -4136,10 +4153,10 @@ func (s *TimerLayerPostStore) GetPostIdBeforeTime(channelId string, time int64)
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) GetPosts(channelId string, offset int, limit int, allowFromCache bool) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
 	start := timemodule.Now()
 
-	resultVar0, resultVar1 := s.PostStore.GetPosts(channelId, offset, limit, allowFromCache)
+	resultVar0, resultVar1 := s.PostStore.GetPosts(options, allowFromCache)
 
 	t := timemodule.Now()
 	elapsed := t.Sub(start)
@@ -4153,10 +4170,10 @@ func (s *TimerLayerPostStore) GetPosts(channelId string, offset int, limit int,
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) GetPostsAfter(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
 	start := timemodule.Now()
 
-	resultVar0, resultVar1 := s.PostStore.GetPostsAfter(channelId, postId, numPosts, offset)
+	resultVar0, resultVar1 := s.PostStore.GetPostsAfter(options)
 
 	t := timemodule.Now()
 	elapsed := t.Sub(start)
@@ -4187,10 +4204,10 @@ func (s *TimerLayerPostStore) GetPostsBatchForIndexing(startTime int64, endTime
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) GetPostsBefore(channelId string, postId string, numPosts int, offset int) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
 	start := timemodule.Now()
 
-	resultVar0, resultVar1 := s.PostStore.GetPostsBefore(channelId, postId, numPosts, offset)
+	resultVar0, resultVar1 := s.PostStore.GetPostsBefore(options)
 
 	t := timemodule.Now()
 	elapsed := t.Sub(start)
@@ -4238,10 +4255,10 @@ func (s *TimerLayerPostStore) GetPostsCreatedAt(channelId string, time int64) ([
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) GetPostsSince(channelId string, time int64, allowFromCache bool) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, *model.AppError) {
 	start := timemodule.Now()
 
-	resultVar0, resultVar1 := s.PostStore.GetPostsSince(channelId, time, allowFromCache)
+	resultVar0, resultVar1 := s.PostStore.GetPostsSince(options, allowFromCache)
 
 	t := timemodule.Now()
 	elapsed := t.Sub(start)