mirror of https://github.com/rocboss/paopao-ce
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
750 lines
18 KiB
750 lines
18 KiB
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.25.0
|
|
// source: comments.sql
|
|
|
|
package pgc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const createComment = `-- name: CreateComment :one
|
|
INSERT INTO p_comment (post_id, user_id, ip, ip_loc, created_on)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
RETURNING id
|
|
`
|
|
|
|
type CreateCommentParams struct {
|
|
PostID int64
|
|
UserID int64
|
|
Ip string
|
|
IpLoc string
|
|
CreatedOn int64
|
|
}
|
|
|
|
func (q *Queries) CreateComment(ctx context.Context, arg *CreateCommentParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, createComment,
|
|
arg.PostID,
|
|
arg.UserID,
|
|
arg.Ip,
|
|
arg.IpLoc,
|
|
arg.CreatedOn,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const createCommentContent = `-- name: CreateCommentContent :one
|
|
INSERT INTO p_comment_content (comment_id, user_id, content, type, sort, created_on)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING id
|
|
`
|
|
|
|
type CreateCommentContentParams struct {
|
|
CommentID int64
|
|
UserID int64
|
|
Content string
|
|
Type int16
|
|
Sort int64
|
|
CreatedOn int64
|
|
}
|
|
|
|
func (q *Queries) CreateCommentContent(ctx context.Context, arg *CreateCommentContentParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, createCommentContent,
|
|
arg.CommentID,
|
|
arg.UserID,
|
|
arg.Content,
|
|
arg.Type,
|
|
arg.Sort,
|
|
arg.CreatedOn,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const createCommentReply = `-- name: CreateCommentReply :one
|
|
INSERT INTO p_comment_reply (comment_id, user_id, content, at_user_id, ip, ip_loc, created_on)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
|
RETURNING id
|
|
`
|
|
|
|
type CreateCommentReplyParams struct {
|
|
CommentID int64
|
|
UserID int64
|
|
Content string
|
|
AtUserID int64
|
|
Ip string
|
|
IpLoc string
|
|
CreatedOn int64
|
|
}
|
|
|
|
func (q *Queries) CreateCommentReply(ctx context.Context, arg *CreateCommentReplyParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, createCommentReply,
|
|
arg.CommentID,
|
|
arg.UserID,
|
|
arg.Content,
|
|
arg.AtUserID,
|
|
arg.Ip,
|
|
arg.IpLoc,
|
|
arg.CreatedOn,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const createThumbsUpDownComment = `-- name: CreateThumbsUpDownComment :one
|
|
INSERT INTO p_tweet_comment_thumbs (user_id, tweet_id, comment_id,
|
|
reply_id, is_thumbs_up, is_thumbs_down, comment_type, created_on)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING id
|
|
`
|
|
|
|
type CreateThumbsUpDownCommentParams struct {
|
|
UserID int64
|
|
TweetID int64
|
|
CommentID int64
|
|
ReplyID pgtype.Int8
|
|
IsThumbsUp int16
|
|
IsThumbsDown int16
|
|
CommentType int16
|
|
CreatedOn int64
|
|
}
|
|
|
|
func (q *Queries) CreateThumbsUpDownComment(ctx context.Context, arg *CreateThumbsUpDownCommentParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, createThumbsUpDownComment,
|
|
arg.UserID,
|
|
arg.TweetID,
|
|
arg.CommentID,
|
|
arg.ReplyID,
|
|
arg.IsThumbsUp,
|
|
arg.IsThumbsDown,
|
|
arg.CommentType,
|
|
arg.CreatedOn,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const decrCommentReplyCount = `-- name: DecrCommentReplyCount :exec
|
|
UPDATE p_comment
|
|
SET reply_count=reply_count-1,
|
|
modified_on=$1
|
|
WHERE id=$2 AND is_del=0
|
|
`
|
|
|
|
type DecrCommentReplyCountParams struct {
|
|
ModifiedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) DecrCommentReplyCount(ctx context.Context, arg *DecrCommentReplyCountParams) error {
|
|
_, err := q.db.Exec(ctx, decrCommentReplyCount, arg.ModifiedOn, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const deleteComment = `-- name: DeleteComment :exec
|
|
|
|
UPDATE p_comment SET deleted_on=$1, is_del=1 WHERE id=$2 AND is_del=0
|
|
`
|
|
|
|
type DeleteCommentParams struct {
|
|
DeletedOn int64
|
|
ID int64
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------
|
|
// comment_manage sql dml
|
|
// ------------------------------------------------------------------------------
|
|
func (q *Queries) DeleteComment(ctx context.Context, arg *DeleteCommentParams) error {
|
|
_, err := q.db.Exec(ctx, deleteComment, arg.DeletedOn, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const deleteCommentReply = `-- name: DeleteCommentReply :exec
|
|
UPDATE p_comment_reply SET deleted_on=$1, is_del=1 WHERE id=$2 AND is_del=0
|
|
`
|
|
|
|
type DeleteCommentReplyParams struct {
|
|
DeletedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteCommentReply(ctx context.Context, arg *DeleteCommentReplyParams) error {
|
|
_, err := q.db.Exec(ctx, deleteCommentReply, arg.DeletedOn, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const deleteCommentThumbs = `-- name: DeleteCommentThumbs :exec
|
|
UPDATE p_tweet_comment_thumbs
|
|
SET deleted_on=$1, is_del=1
|
|
WHERE user_id=$2 AND tweet_id=$3 AND comment_id=$4 AND is_del=0
|
|
`
|
|
|
|
type DeleteCommentThumbsParams struct {
|
|
DeletedOn int64
|
|
UserID int64
|
|
TweetID int64
|
|
CommentID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteCommentThumbs(ctx context.Context, arg *DeleteCommentThumbsParams) error {
|
|
_, err := q.db.Exec(ctx, deleteCommentThumbs,
|
|
arg.DeletedOn,
|
|
arg.UserID,
|
|
arg.TweetID,
|
|
arg.CommentID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const deleteReplyThumbs = `-- name: DeleteReplyThumbs :exec
|
|
UPDATE p_tweet_comment_thumbs
|
|
SET deleted_on=$1, is_del=1
|
|
WHERE user_id=$2 AND comment_id=$3 AND reply_id=$4 AND is_del=0
|
|
`
|
|
|
|
type DeleteReplyThumbsParams struct {
|
|
DeletedOn int64
|
|
UserID int64
|
|
CommentID int64
|
|
ReplyID pgtype.Int8
|
|
}
|
|
|
|
func (q *Queries) DeleteReplyThumbs(ctx context.Context, arg *DeleteReplyThumbsParams) error {
|
|
_, err := q.db.Exec(ctx, deleteReplyThumbs,
|
|
arg.DeletedOn,
|
|
arg.UserID,
|
|
arg.CommentID,
|
|
arg.ReplyID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const getCommentById = `-- name: GetCommentById :one
|
|
SELECT id, post_id, user_id, ip, ip_loc, created_on, modified_on, deleted_on, is_del, thumbs_up_count, thumbs_down_count, is_essence, reply_count FROM p_comment WHERE id=$1 AND is_del=0
|
|
`
|
|
|
|
func (q *Queries) GetCommentById(ctx context.Context, id int64) (*PComment, error) {
|
|
row := q.db.QueryRow(ctx, getCommentById, id)
|
|
var i PComment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.PostID,
|
|
&i.UserID,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
&i.IsEssence,
|
|
&i.ReplyCount,
|
|
)
|
|
return &i, err
|
|
}
|
|
|
|
const getCommentContentsByIds = `-- name: GetCommentContentsByIds :many
|
|
SELECT id, comment_id, user_id, content, type, sort, created_on, modified_on, deleted_on, is_del FROM p_comment_content WHERE comment_id = ANY($1::BIGINT[])
|
|
`
|
|
|
|
func (q *Queries) GetCommentContentsByIds(ctx context.Context, ids []int64) ([]*PCommentContent, error) {
|
|
rows, err := q.db.Query(ctx, getCommentContentsByIds, ids)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*PCommentContent
|
|
for rows.Next() {
|
|
var i PCommentContent
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CommentID,
|
|
&i.UserID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.Sort,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getCommentCount = `-- name: GetCommentCount :one
|
|
SELECT count(*) FROM p_comment WHERE post_id=$1 AND is_del=0
|
|
`
|
|
|
|
func (q *Queries) GetCommentCount(ctx context.Context, postID int64) (int64, error) {
|
|
row := q.db.QueryRow(ctx, getCommentCount, postID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const getCommentRepliesByIds = `-- name: GetCommentRepliesByIds :many
|
|
SELECT id, comment_id, user_id, at_user_id, content, ip, ip_loc, created_on, modified_on, deleted_on, is_del, thumbs_up_count, thumbs_down_count
|
|
FROM p_comment_reply
|
|
WHERE comment_id = ANY($1::BIGINT[])
|
|
ORDER BY id ASC
|
|
`
|
|
|
|
func (q *Queries) GetCommentRepliesByIds(ctx context.Context, ids []int64) ([]*PCommentReply, error) {
|
|
rows, err := q.db.Query(ctx, getCommentRepliesByIds, ids)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*PCommentReply
|
|
for rows.Next() {
|
|
var i PCommentReply
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CommentID,
|
|
&i.UserID,
|
|
&i.AtUserID,
|
|
&i.Content,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getCommentReplyById = `-- name: GetCommentReplyById :one
|
|
SELECT id, comment_id, user_id, at_user_id, content, ip, ip_loc, created_on, modified_on, deleted_on, is_del, thumbs_up_count, thumbs_down_count FROM p_comment_reply WHERE id=$1 AND is_del=0
|
|
`
|
|
|
|
func (q *Queries) GetCommentReplyById(ctx context.Context, id int64) (*PCommentReply, error) {
|
|
row := q.db.QueryRow(ctx, getCommentReplyById, id)
|
|
var i PCommentReply
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CommentID,
|
|
&i.UserID,
|
|
&i.AtUserID,
|
|
&i.Content,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
)
|
|
return &i, err
|
|
}
|
|
|
|
const getCommentReplyThumb = `-- name: GetCommentReplyThumb :one
|
|
SELECT id, user_id, tweet_id, comment_id, reply_id, comment_type, is_thumbs_up, is_thumbs_down, created_on, modified_on, deleted_on, is_del
|
|
FROM p_tweet_comment_thumbs
|
|
WHERE user_id=$1 AND tweet_id=$2 AND comment_id=$3 AND reply_id=$4 AND comment_type=1 AND is_del=0
|
|
`
|
|
|
|
type GetCommentReplyThumbParams struct {
|
|
UserID int64
|
|
TweetID int64
|
|
CommentID int64
|
|
ReplyID pgtype.Int8
|
|
}
|
|
|
|
func (q *Queries) GetCommentReplyThumb(ctx context.Context, arg *GetCommentReplyThumbParams) (*PTweetCommentThumb, error) {
|
|
row := q.db.QueryRow(ctx, getCommentReplyThumb,
|
|
arg.UserID,
|
|
arg.TweetID,
|
|
arg.CommentID,
|
|
arg.ReplyID,
|
|
)
|
|
var i PTweetCommentThumb
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.TweetID,
|
|
&i.CommentID,
|
|
&i.ReplyID,
|
|
&i.CommentType,
|
|
&i.IsThumbsUp,
|
|
&i.IsThumbsDown,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
)
|
|
return &i, err
|
|
}
|
|
|
|
const getCommentThumbs = `-- name: GetCommentThumbs :many
|
|
SELECT user_id,
|
|
tweet_id,
|
|
comment_id,
|
|
reply_id,
|
|
comment_type,
|
|
is_thumbs_up,
|
|
is_thumbs_down
|
|
FROM p_tweet_comment_thumbs
|
|
WHERE user_id=$1 AND tweet_id=$2
|
|
`
|
|
|
|
type GetCommentThumbsParams struct {
|
|
UserID int64
|
|
TweetID int64
|
|
}
|
|
|
|
type GetCommentThumbsRow struct {
|
|
UserID int64
|
|
TweetID int64
|
|
CommentID int64
|
|
ReplyID pgtype.Int8
|
|
CommentType int16
|
|
IsThumbsUp int16
|
|
IsThumbsDown int16
|
|
}
|
|
|
|
func (q *Queries) GetCommentThumbs(ctx context.Context, arg *GetCommentThumbsParams) ([]*GetCommentThumbsRow, error) {
|
|
rows, err := q.db.Query(ctx, getCommentThumbs, arg.UserID, arg.TweetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*GetCommentThumbsRow
|
|
for rows.Next() {
|
|
var i GetCommentThumbsRow
|
|
if err := rows.Scan(
|
|
&i.UserID,
|
|
&i.TweetID,
|
|
&i.CommentID,
|
|
&i.ReplyID,
|
|
&i.CommentType,
|
|
&i.IsThumbsUp,
|
|
&i.IsThumbsDown,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getDefaultComments = `-- name: GetDefaultComments :many
|
|
SELECT id, post_id, user_id, ip, ip_loc, created_on, modified_on, deleted_on, is_del, thumbs_up_count, thumbs_down_count, is_essence, reply_count
|
|
FROM p_comment
|
|
WHERE post_id=$1 AND is_del=0
|
|
ORDER BY is_essence DESC, id ASC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type GetDefaultCommentsParams struct {
|
|
PostID int64
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) GetDefaultComments(ctx context.Context, arg *GetDefaultCommentsParams) ([]*PComment, error) {
|
|
rows, err := q.db.Query(ctx, getDefaultComments, arg.PostID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*PComment
|
|
for rows.Next() {
|
|
var i PComment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.PostID,
|
|
&i.UserID,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
&i.IsEssence,
|
|
&i.ReplyCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getHotsComments = `-- name: GetHotsComments :many
|
|
SELECT c.id, c.post_id, c.user_id, c.ip, c.ip_loc, c.created_on, c.modified_on, c.deleted_on, c.is_del, c.thumbs_up_count, c.thumbs_down_count, c.is_essence, c.reply_count
|
|
FROM p_comment c
|
|
LEFT JOIN p_comment_metric m
|
|
ON c.id=m.comment_id
|
|
WHERE c.post_id=$1 AND c.is_del=0 AND m.is_del=0
|
|
ORDER BY is_essence DESC, m.rank_score DESC, c.id DESC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type GetHotsCommentsParams struct {
|
|
PostID int64
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) GetHotsComments(ctx context.Context, arg *GetHotsCommentsParams) ([]*PComment, error) {
|
|
rows, err := q.db.Query(ctx, getHotsComments, arg.PostID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*PComment
|
|
for rows.Next() {
|
|
var i PComment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.PostID,
|
|
&i.UserID,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
&i.IsEssence,
|
|
&i.ReplyCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getNewestComments = `-- name: GetNewestComments :many
|
|
|
|
SELECT id, post_id, user_id, ip, ip_loc, created_on, modified_on, deleted_on, is_del, thumbs_up_count, thumbs_down_count, is_essence, reply_count
|
|
FROM p_comment
|
|
WHERE post_id=$1 AND is_del=0
|
|
ORDER BY is_essence DESC, id DESC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type GetNewestCommentsParams struct {
|
|
PostID int64
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------
|
|
// comment sql dml
|
|
// ------------------------------------------------------------------------------
|
|
func (q *Queries) GetNewestComments(ctx context.Context, arg *GetNewestCommentsParams) ([]*PComment, error) {
|
|
rows, err := q.db.Query(ctx, getNewestComments, arg.PostID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []*PComment
|
|
for rows.Next() {
|
|
var i PComment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.PostID,
|
|
&i.UserID,
|
|
&i.Ip,
|
|
&i.IpLoc,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
&i.ThumbsUpCount,
|
|
&i.ThumbsDownCount,
|
|
&i.IsEssence,
|
|
&i.ReplyCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, &i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTweetCommentThumb = `-- name: GetTweetCommentThumb :one
|
|
SELECT id, user_id, tweet_id, comment_id, reply_id, comment_type, is_thumbs_up, is_thumbs_down, created_on, modified_on, deleted_on, is_del
|
|
FROM p_tweet_comment_thumbs
|
|
WHERE user_id=$1 AND tweet_id=$2 AND comment_id=$3 AND comment_type=0 AND is_del=0
|
|
`
|
|
|
|
type GetTweetCommentThumbParams struct {
|
|
UserID int64
|
|
TweetID int64
|
|
CommentID int64
|
|
}
|
|
|
|
func (q *Queries) GetTweetCommentThumb(ctx context.Context, arg *GetTweetCommentThumbParams) (*PTweetCommentThumb, error) {
|
|
row := q.db.QueryRow(ctx, getTweetCommentThumb, arg.UserID, arg.TweetID, arg.CommentID)
|
|
var i PTweetCommentThumb
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.TweetID,
|
|
&i.CommentID,
|
|
&i.ReplyID,
|
|
&i.CommentType,
|
|
&i.IsThumbsUp,
|
|
&i.IsThumbsDown,
|
|
&i.CreatedOn,
|
|
&i.ModifiedOn,
|
|
&i.DeletedOn,
|
|
&i.IsDel,
|
|
)
|
|
return &i, err
|
|
}
|
|
|
|
const highlightComment = `-- name: HighlightComment :one
|
|
UPDATE p_comment
|
|
SET is_essence=1-is_essence,
|
|
modified_on=$1
|
|
WHERE id=$2 AND user_id=$3 AND is_del=0
|
|
RETURNING is_essence
|
|
`
|
|
|
|
type HighlightCommentParams struct {
|
|
ModifiedOn int64
|
|
ID int64
|
|
UserID int64
|
|
}
|
|
|
|
func (q *Queries) HighlightComment(ctx context.Context, arg *HighlightCommentParams) (int16, error) {
|
|
row := q.db.QueryRow(ctx, highlightComment, arg.ModifiedOn, arg.ID, arg.UserID)
|
|
var is_essence int16
|
|
err := row.Scan(&is_essence)
|
|
return is_essence, err
|
|
}
|
|
|
|
const incrCommentReplyCount = `-- name: IncrCommentReplyCount :exec
|
|
UPDATE p_comment
|
|
SET reply_count=reply_count+1,
|
|
modified_on=$1
|
|
WHERE id=$2 AND is_del=0
|
|
`
|
|
|
|
type IncrCommentReplyCountParams struct {
|
|
ModifiedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) IncrCommentReplyCount(ctx context.Context, arg *IncrCommentReplyCountParams) error {
|
|
_, err := q.db.Exec(ctx, incrCommentReplyCount, arg.ModifiedOn, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const updateCommentThumbsCount = `-- name: UpdateCommentThumbsCount :exec
|
|
UPDATE p_comment
|
|
SET thumbs_up_count=$1, Thumbs_down_count=$2, modified_on=$3
|
|
WHERE id=$4 AND is_del=0
|
|
`
|
|
|
|
type UpdateCommentThumbsCountParams struct {
|
|
ThumbsUpCount int32
|
|
ThumbsDownCount int32
|
|
ModifiedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateCommentThumbsCount(ctx context.Context, arg *UpdateCommentThumbsCountParams) error {
|
|
_, err := q.db.Exec(ctx, updateCommentThumbsCount,
|
|
arg.ThumbsUpCount,
|
|
arg.ThumbsDownCount,
|
|
arg.ModifiedOn,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateReplyThumbsCount = `-- name: UpdateReplyThumbsCount :exec
|
|
UPDATE p_comment_reply
|
|
SET thumbs_up_count=$1, thumbs_down_count=$2, modified_on=$3
|
|
WHERE id=$4 AND is_del=0
|
|
`
|
|
|
|
type UpdateReplyThumbsCountParams struct {
|
|
ThumbsUpCount int32
|
|
ThumbsDownCount int32
|
|
ModifiedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateReplyThumbsCount(ctx context.Context, arg *UpdateReplyThumbsCountParams) error {
|
|
_, err := q.db.Exec(ctx, updateReplyThumbsCount,
|
|
arg.ThumbsUpCount,
|
|
arg.ThumbsDownCount,
|
|
arg.ModifiedOn,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateThumbsUpDownComment = `-- name: UpdateThumbsUpDownComment :exec
|
|
UPDATE p_tweet_comment_thumbs
|
|
SET is_thumbs_up=$1,
|
|
is_thumbs_down=$2,
|
|
modified_on=$3
|
|
WHERE id=$4 AND is_del=0
|
|
`
|
|
|
|
type UpdateThumbsUpDownCommentParams struct {
|
|
IsThumbsUp int16
|
|
IsThumbsDown int16
|
|
ModifiedOn int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateThumbsUpDownComment(ctx context.Context, arg *UpdateThumbsUpDownCommentParams) error {
|
|
_, err := q.db.Exec(ctx, updateThumbsUpDownComment,
|
|
arg.IsThumbsUp,
|
|
arg.IsThumbsDown,
|
|
arg.ModifiedOn,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|