mysql_dao

package

v0.87.1 Latest Latest Go to latest Published: Jun 17, 2022 License: Apache-2.0 Imports: 7 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/teamgram/teamgram-server

Links

Open Source Insights

Documentation ¶

Index ¶

type ChatParticipantsDAO
- func NewChatParticipantsDAO(db *sqlx.DB) *ChatParticipantsDAO
type ChatsDAO
- func NewChatsDAO(db *sqlx.DB) *ChatsDAO
type HashTagsDAO
- func NewHashTagsDAO(db *sqlx.DB) *HashTagsDAO
type MessagesDAO
- func NewMessagesDAO(db *sqlx.DB) *MessagesDAO

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type ChatParticipantsDAO ¶

type ChatParticipantsDAO struct {
	// contains filtered or unexported fields
}

func NewChatParticipantsDAO ¶

func NewChatParticipantsDAO(db *sqlx.DB) *ChatParticipantsDAO

func (*ChatParticipantsDAO) ClearDraft ¶

func (dao *ChatParticipantsDAO) ClearDraft(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

ClearDraft update chat_participants set draft_type = 0, draft_message_data = ” where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) ClearDraftTx ¶

func (dao *ChatParticipantsDAO) ClearDraftTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set draft_type = 0, draft_message_data = ” where user_id = :user_id and chat_id = :chat_id ClearDraftTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) Insert ¶

func (dao *ChatParticipantsDAO) Insert(ctx context.Context, do *dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

Insert insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) InsertBulk ¶

func (dao *ChatParticipantsDAO) InsertBulk(ctx context.Context, doList []*dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

InsertBulk insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) InsertBulkTx ¶

func (dao *ChatParticipantsDAO) InsertBulkTx(tx *sqlx.Tx, doList []*dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

InsertBulkTx insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) InsertOrUpdate ¶

func (dao *ChatParticipantsDAO) InsertOrUpdate(ctx context.Context, do *dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

InsertOrUpdate insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) on duplicate key update participant_type = values(participant_type), inviter_user_id = values(inviter_user_id), invited_at = values(invited_at), state = 0, kicked_at = 0, left_at = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) InsertOrUpdateTx ¶

func (dao *ChatParticipantsDAO) InsertOrUpdateTx(tx *sqlx.Tx, do *dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

InsertOrUpdateTx insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) on duplicate key update participant_type = values(participant_type), inviter_user_id = values(inviter_user_id), invited_at = values(invited_at), state = 0, kicked_at = 0, left_at = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) InsertTx ¶

func (dao *ChatParticipantsDAO) InsertTx(tx *sqlx.Tx, do *dataobject.ChatParticipantsDO) (lastInsertId, rowsAffected int64, err error)

InsertTx insert into chat_participants(chat_id, user_id, participant_type, inviter_user_id, invited_at, draft_message_data) values (:chat_id, :user_id, :participant_type, :inviter_user_id, :invited_at, ”) TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SaveDraft ¶

func (dao *ChatParticipantsDAO) SaveDraft(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

SaveDraft update chat_participants set draft_type = 2, draft_message_data = :draft_message_data where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SaveDraftTx ¶

func (dao *ChatParticipantsDAO) SaveDraftTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set draft_type = 2, draft_message_data = :draft_message_data where user_id = :user_id and chat_id = :chat_id SaveDraftTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectByOffsetId ¶

func (dao *ChatParticipantsDAO) SelectByOffsetId(ctx context.Context, user_id int64, userId2 int32, limit int32) (rList []dataobject.ChatParticipantsDO, err error)

SelectByOffsetId select id, user_id, chat_id, participant_type, is_pinned, top_message, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where user_id = :user_id and chat_id in (select id from chats where id in (select chat_id from chat_participants where user_id = :userId2) and deactivated = 0) and top_message < :top_message and (state = 0 or state = 2) order by top_message desc limit :limit TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectByOffsetIdWithCB ¶

func (dao *ChatParticipantsDAO) SelectByOffsetIdWithCB(ctx context.Context, user_id int64, userId2 int32, limit int32, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectByOffsetIdWithCB select id, user_id, chat_id, participant_type, is_pinned, top_message, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where user_id = :user_id and chat_id in (select id from chats where id in (select chat_id from chat_participants where user_id = :userId2) and deactivated = 0) and top_message < :top_message and (state = 0 or state = 2) order by top_message desc limit :limit TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectByParticipant ¶

func (dao *ChatParticipantsDAO) SelectByParticipant(ctx context.Context, chat_id int64, user_id int64) (rValue *dataobject.ChatParticipantsDO, err error)

SelectByParticipant select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where chat_id = :chat_id and user_id = :user_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectDraftList ¶

func (dao *ChatParticipantsDAO) SelectDraftList(ctx context.Context, user_id int64) (rList []dataobject.ChatParticipantsDO, err error)

SelectDraftList select user_id, chat_id, draft_type, draft_message_data from chat_participants where user_id = :user_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectDraftListWithCB ¶

func (dao *ChatParticipantsDAO) SelectDraftListWithCB(ctx context.Context, user_id int64, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectDraftListWithCB select user_id, chat_id, draft_type, draft_message_data from chat_participants where user_id = :user_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectExcludePinnedByOffsetId ¶

func (dao *ChatParticipantsDAO) SelectExcludePinnedByOffsetId(ctx context.Context, user_id int64, userId2 int32, limit int32) (rList []dataobject.ChatParticipantsDO, err error)

SelectExcludePinnedByOffsetId select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where user_id = :user_id and is_pinned = 0 and chat_id in (select id from chats where id in (select chat_id from chat_participants where user_id = :userId2) and deactivated = 0) and top_message < :top_message and (state = 0 or state = 2) order by top_message desc limit :limit TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectExcludePinnedByOffsetIdWithCB ¶

func (dao *ChatParticipantsDAO) SelectExcludePinnedByOffsetIdWithCB(ctx context.Context, user_id int64, userId2 int32, limit int32, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectExcludePinnedByOffsetIdWithCB select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where user_id = :user_id and is_pinned = 0 and chat_id in (select id from chats where id in (select chat_id from chat_participants where user_id = :userId2) and deactivated = 0) and top_message < :top_message and (state = 0 or state = 2) order by top_message desc limit :limit TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectList ¶

func (dao *ChatParticipantsDAO) SelectList(ctx context.Context, chat_id int64) (rList []dataobject.ChatParticipantsDO, err error)

SelectList select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectListByChatIdList ¶

func (dao *ChatParticipantsDAO) SelectListByChatIdList(ctx context.Context, user_id int64, idList []int32) (rList []dataobject.ChatParticipantsDO, err error)

SelectListByChatIdList select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, date2 from chat_participants where user_id = :user_id and chat_id in (:idList) order by top_message desc TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectListByChatIdListWithCB ¶

func (dao *ChatParticipantsDAO) SelectListByChatIdListWithCB(ctx context.Context, user_id int64, idList []int32, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectListByChatIdListWithCB select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, date2 from chat_participants where user_id = :user_id and chat_id in (:idList) order by top_message desc TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectListWithCB ¶

func (dao *ChatParticipantsDAO) SelectListWithCB(ctx context.Context, chat_id int64, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectListWithCB select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, state, date2 from chat_participants where chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectMarkDialogUnreadList ¶

func (dao *ChatParticipantsDAO) SelectMarkDialogUnreadList(ctx context.Context, user_id int64) (rList []int64, err error)

SelectMarkDialogUnreadList select chat_id from chat_participants where user_id = :user_id and unread_mark = 1 and state = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectMarkDialogUnreadListWithCB ¶

func (dao *ChatParticipantsDAO) SelectMarkDialogUnreadListWithCB(ctx context.Context, user_id int64, cb func(i int, v int64)) (rList []int64, err error)

SelectMarkDialogUnreadListWithCB select chat_id from chat_participants where user_id = :user_id and unread_mark = 1 and state = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectPinnedDialogs ¶

func (dao *ChatParticipantsDAO) SelectPinnedDialogs(ctx context.Context, user_id int64) (rList []dataobject.ChatParticipantsDO, err error)

SelectPinnedDialogs select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, date2 from chat_participants where user_id = :user_id and is_pinned = 1 and state = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) SelectPinnedDialogsWithCB ¶

func (dao *ChatParticipantsDAO) SelectPinnedDialogsWithCB(ctx context.Context, user_id int64, cb func(i int, v *dataobject.ChatParticipantsDO)) (rList []dataobject.ChatParticipantsDO, err error)

SelectPinnedDialogsWithCB select id, user_id, chat_id, participant_type, is_pinned, top_message, pinned_msg_id, read_inbox_max_id, read_outbox_max_id, unread_count, unread_mentions_count, unread_mark, draft_type, draft_message_data, inviter_user_id, invited_at, date2 from chat_participants where user_id = :user_id and is_pinned = 1 and state = 0 TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) Update ¶

func (dao *ChatParticipantsDAO) Update(ctx context.Context, participant_type int32, inviter_user_id int64, invited_at int64, id int64) (rowsAffected int64, err error)

Update update chat_participants set participant_type = :participant_type, inviter_user_id = :inviter_user_id, invited_at = :invited_at, state = 0, kicked_at = 0, left_at = 0 where id = :id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateCustomMap ¶

func (dao *ChatParticipantsDAO) UpdateCustomMap(ctx context.Context, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateCustomMap update chat_participants set %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateCustomMapTx ¶

func (dao *ChatParticipantsDAO) UpdateCustomMapTx(tx *sqlx.Tx, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateCustomMapTx update chat_participants set %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateInboxDialog ¶

func (dao *ChatParticipantsDAO) UpdateInboxDialog(ctx context.Context, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateInboxDialog update chat_participants set unread_count = unread_count + 1, %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateInboxDialogTx ¶

func (dao *ChatParticipantsDAO) UpdateInboxDialogTx(tx *sqlx.Tx, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateInboxDialogTx update chat_participants set unread_count = unread_count + 1, %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateKicked ¶

func (dao *ChatParticipantsDAO) UpdateKicked(ctx context.Context, kicked_at int64, id int64) (rowsAffected int64, err error)

UpdateKicked update chat_participants set state = 2, kicked_at = :kicked_at where id = :id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateKickedTx ¶

func (dao *ChatParticipantsDAO) UpdateKickedTx(tx *sqlx.Tx, kicked_at int64, id int64) (rowsAffected int64, err error)

update chat_participants set state = 2, kicked_at = :kicked_at where id = :id UpdateKickedTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateLeft ¶

func (dao *ChatParticipantsDAO) UpdateLeft(ctx context.Context, left_at int64, id int64) (rowsAffected int64, err error)

UpdateLeft update chat_participants set state = 1, left_at = :left_at where id = :id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateLeftTx ¶

func (dao *ChatParticipantsDAO) UpdateLeftTx(tx *sqlx.Tx, left_at int64, id int64) (rowsAffected int64, err error)

update chat_participants set state = 1, left_at = :left_at where id = :id UpdateLeftTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateMarkDialogUnread ¶

func (dao *ChatParticipantsDAO) UpdateMarkDialogUnread(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateMarkDialogUnread update chat_participants set unread_mark = :unread_mark where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateMarkDialogUnreadTx ¶

func (dao *ChatParticipantsDAO) UpdateMarkDialogUnreadTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set unread_mark = :unread_mark where user_id = :user_id and chat_id = :chat_id UpdateMarkDialogUnreadTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateOutboxDialog ¶

func (dao *ChatParticipantsDAO) UpdateOutboxDialog(ctx context.Context, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateOutboxDialog update chat_participants set unread_count = 0, %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateOutboxDialogTx ¶

func (dao *ChatParticipantsDAO) UpdateOutboxDialogTx(tx *sqlx.Tx, cMap map[string]interface{}, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateOutboxDialogTx update chat_participants set unread_count = 0, %s where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateParticipantType ¶

func (dao *ChatParticipantsDAO) UpdateParticipantType(ctx context.Context, participant_type int32, id int64) (rowsAffected int64, err error)

UpdateParticipantType update chat_participants set participant_type = :participant_type where id = :id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateParticipantTypeTx ¶

func (dao *ChatParticipantsDAO) UpdateParticipantTypeTx(tx *sqlx.Tx, participant_type int32, id int64) (rowsAffected int64, err error)

update chat_participants set participant_type = :participant_type where id = :id UpdateParticipantTypeTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdatePinned ¶

func (dao *ChatParticipantsDAO) UpdatePinned(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdatePinned update chat_participants set is_pinned = :is_pinned where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdatePinnedMsgId ¶

func (dao *ChatParticipantsDAO) UpdatePinnedMsgId(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdatePinnedMsgId update chat_participants set pinned_msg_id = :pinned_msg_id where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdatePinnedMsgIdTx ¶

func (dao *ChatParticipantsDAO) UpdatePinnedMsgIdTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set pinned_msg_id = :pinned_msg_id where user_id = :user_id and chat_id = :chat_id UpdatePinnedMsgIdTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdatePinnedTx ¶

func (dao *ChatParticipantsDAO) UpdatePinnedTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set is_pinned = :is_pinned where user_id = :user_id and chat_id = :chat_id UpdatePinnedTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateReadOutboxMaxIdByPeer ¶

func (dao *ChatParticipantsDAO) UpdateReadOutboxMaxIdByPeer(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateReadOutboxMaxIdByPeer update chat_participants set read_outbox_max_id = :read_outbox_max_id where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateReadOutboxMaxIdByPeerTx ¶

func (dao *ChatParticipantsDAO) UpdateReadOutboxMaxIdByPeerTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set read_outbox_max_id = :read_outbox_max_id where user_id = :user_id and chat_id = :chat_id UpdateReadOutboxMaxIdByPeerTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateTx ¶

func (dao *ChatParticipantsDAO) UpdateTx(tx *sqlx.Tx, participant_type int32, inviter_user_id int64, invited_at int64, id int64) (rowsAffected int64, err error)

update chat_participants set participant_type = :participant_type, inviter_user_id = :inviter_user_id, invited_at = :invited_at, state = 0, kicked_at = 0, left_at = 0 where id = :id UpdateTx TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateUnreadByPeer ¶

func (dao *ChatParticipantsDAO) UpdateUnreadByPeer(ctx context.Context, user_id int64, chat_id int64) (rowsAffected int64, err error)

UpdateUnreadByPeer update chat_participants set unread_count = 0, unread_mark = 0, read_inbox_max_id = :read_inbox_max_id where user_id = :user_id and chat_id = :chat_id TODO(@benqi): sqlmap

func (*ChatParticipantsDAO) UpdateUnreadByPeerTx ¶

func (dao *ChatParticipantsDAO) UpdateUnreadByPeerTx(tx *sqlx.Tx, user_id int64, chat_id int64) (rowsAffected int64, err error)

update chat_participants set unread_count = 0, unread_mark = 0, read_inbox_max_id = :read_inbox_max_id where user_id = :user_id and chat_id = :chat_id UpdateUnreadByPeerTx TODO(@benqi): sqlmap

type ChatsDAO ¶

type ChatsDAO struct {
	// contains filtered or unexported fields
}

func NewChatsDAO ¶

func NewChatsDAO(db *sqlx.DB) *ChatsDAO

func (*ChatsDAO) Insert ¶

func (dao *ChatsDAO) Insert(ctx context.Context, do *dataobject.ChatsDO) (lastInsertId, rowsAffected int64, err error)

Insert insert into chats(creator_user_id, access_hash, random_id, participant_count, title, about, `date`) values (:creator_user_id, :access_hash, :random_id, :participant_count, :title, :about, :date) TODO(@benqi): sqlmap

func (*ChatsDAO) InsertTx ¶

func (dao *ChatsDAO) InsertTx(tx *sqlx.Tx, do *dataobject.ChatsDO) (lastInsertId, rowsAffected int64, err error)

InsertTx insert into chats(creator_user_id, access_hash, random_id, participant_count, title, about, `date`) values (:creator_user_id, :access_hash, :random_id, :participant_count, :title, :about, :date) TODO(@benqi): sqlmap

func (*ChatsDAO) Select ¶

func (dao *ChatsDAO) Select(ctx context.Context, id int64) (rValue *dataobject.ChatsDO, err error)

Select select id, creator_user_id, access_hash, participant_count, title, about, photo_id, link, admins_enabled, default_banned_rights, migrated_to_id, migrated_to_access_hash, deactivated, version, `date` from chats where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) SelectByIdList ¶

func (dao *ChatsDAO) SelectByIdList(ctx context.Context, idList []int32) (rList []dataobject.ChatsDO, err error)

SelectByIdList select id, creator_user_id, access_hash, participant_count, title, about, photo_id, admins_enabled, default_banned_rights, migrated_to_id, migrated_to_access_hash, deactivated, version, `date` from chats where id in (:idList) TODO(@benqi): sqlmap

func (*ChatsDAO) SelectByIdListWithCB ¶

func (dao *ChatsDAO) SelectByIdListWithCB(ctx context.Context, idList []int32, cb func(i int, v *dataobject.ChatsDO)) (rList []dataobject.ChatsDO, err error)

SelectByIdListWithCB select id, creator_user_id, access_hash, participant_count, title, about, photo_id, admins_enabled, default_banned_rights, migrated_to_id, migrated_to_access_hash, deactivated, version, `date` from chats where id in (:idList) TODO(@benqi): sqlmap

func (*ChatsDAO) SelectByLink ¶

func (dao *ChatsDAO) SelectByLink(ctx context.Context) (rValue *dataobject.ChatsDO, err error)

SelectByLink select id, creator_user_id, access_hash, participant_count, title, about, photo_id, link, admins_enabled, default_banned_rights, migrated_to_id, migrated_to_access_hash, deactivated, version, `date` from chats where deactivated = 0 and link = :link TODO(@benqi): sqlmap

func (*ChatsDAO) SelectLastCreator ¶

func (dao *ChatsDAO) SelectLastCreator(ctx context.Context, creator_user_id int64) (rValue *dataobject.ChatsDO, err error)

SelectLastCreator select id, creator_user_id, access_hash, participant_count, title, about, photo_id, link, admins_enabled, default_banned_rights, migrated_to_id, migrated_to_access_hash, deactivated, version, `date` from chats where creator_user_id = :creator_user_id order by `date` desc limit 1 TODO(@benqi): sqlmap

func (*ChatsDAO) SelectPhotoId ¶

func (dao *ChatsDAO) SelectPhotoId(ctx context.Context, id int64) (rValue int64, err error)

SelectPhotoId select photo_id from chats where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateAbout ¶

func (dao *ChatsDAO) UpdateAbout(ctx context.Context, about string, id int64) (rowsAffected int64, err error)

UpdateAbout update chats set about = :about where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateAboutTx ¶

func (dao *ChatsDAO) UpdateAboutTx(tx *sqlx.Tx, about string, id int64) (rowsAffected int64, err error)

update chats set about = :about where id = :id UpdateAboutTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateAdminsEnabled ¶

func (dao *ChatsDAO) UpdateAdminsEnabled(ctx context.Context, id int64) (rowsAffected int64, err error)

UpdateAdminsEnabled update chats set admins_enabled = :admins_enabled, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateAdminsEnabledTx ¶

func (dao *ChatsDAO) UpdateAdminsEnabledTx(tx *sqlx.Tx, id int64) (rowsAffected int64, err error)

update chats set admins_enabled = :admins_enabled, version = version + 1 where id = :id UpdateAdminsEnabledTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateDeactivated ¶

func (dao *ChatsDAO) UpdateDeactivated(ctx context.Context, deactivated bool, id int64) (rowsAffected int64, err error)

UpdateDeactivated update chats set deactivated = :deactivated, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateDeactivatedTx ¶

func (dao *ChatsDAO) UpdateDeactivatedTx(tx *sqlx.Tx, deactivated bool, id int64) (rowsAffected int64, err error)

update chats set deactivated = :deactivated, version = version + 1 where id = :id UpdateDeactivatedTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateDefaultBannedRights ¶

func (dao *ChatsDAO) UpdateDefaultBannedRights(ctx context.Context, default_banned_rights int64, id int64) (rowsAffected int64, err error)

UpdateDefaultBannedRights update chats set default_banned_rights = :default_banned_rights, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateDefaultBannedRightsTx ¶

func (dao *ChatsDAO) UpdateDefaultBannedRightsTx(tx *sqlx.Tx, default_banned_rights int64, id int64) (rowsAffected int64, err error)

update chats set default_banned_rights = :default_banned_rights, version = version + 1 where id = :id UpdateDefaultBannedRightsTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateLink ¶

func (dao *ChatsDAO) UpdateLink(ctx context.Context, date int64, id int64) (rowsAffected int64, err error)

UpdateLink update chats set link = :link, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateLinkTx ¶

func (dao *ChatsDAO) UpdateLinkTx(tx *sqlx.Tx, date int64, id int64) (rowsAffected int64, err error)

update chats set link = :link, `date` = :date, version = version + 1 where id = :id UpdateLinkTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateMigratedTo ¶

func (dao *ChatsDAO) UpdateMigratedTo(ctx context.Context, migrated_to_id int64, migrated_to_access_hash int64, id int64) (rowsAffected int64, err error)

UpdateMigratedTo update chats set migrated_to_id = :migrated_to_id, migrated_to_access_hash = :migrated_to_access_hash, participant_count = 0, deactivated = 1, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateMigratedToTx ¶

func (dao *ChatsDAO) UpdateMigratedToTx(tx *sqlx.Tx, migrated_to_id int64, migrated_to_access_hash int64, id int64) (rowsAffected int64, err error)

update chats set migrated_to_id = :migrated_to_id, migrated_to_access_hash = :migrated_to_access_hash, participant_count = 0, deactivated = 1, version = version + 1 where id = :id UpdateMigratedToTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateParticipantCount ¶

func (dao *ChatsDAO) UpdateParticipantCount(ctx context.Context, participant_count int32, id int64) (rowsAffected int64, err error)

UpdateParticipantCount update chats set participant_count = :participant_count, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateParticipantCountTx ¶

func (dao *ChatsDAO) UpdateParticipantCountTx(tx *sqlx.Tx, participant_count int32, id int64) (rowsAffected int64, err error)

update chats set participant_count = :participant_count, version = version + 1 where id = :id UpdateParticipantCountTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdatePhotoId ¶

func (dao *ChatsDAO) UpdatePhotoId(ctx context.Context, photo_id int64, id int64) (rowsAffected int64, err error)

UpdatePhotoId update chats set photo_id = :photo_id, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdatePhotoIdTx ¶

func (dao *ChatsDAO) UpdatePhotoIdTx(tx *sqlx.Tx, photo_id int64, id int64) (rowsAffected int64, err error)

update chats set photo_id = :photo_id, version = version + 1 where id = :id UpdatePhotoIdTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateTitle ¶

func (dao *ChatsDAO) UpdateTitle(ctx context.Context, title string, id int64) (rowsAffected int64, err error)

UpdateTitle update chats set title = :title, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateTitleTx ¶

func (dao *ChatsDAO) UpdateTitleTx(tx *sqlx.Tx, title string, id int64) (rowsAffected int64, err error)

update chats set title = :title, version = version + 1 where id = :id UpdateTitleTx TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateVersion ¶

func (dao *ChatsDAO) UpdateVersion(ctx context.Context, id int64) (rowsAffected int64, err error)

UpdateVersion update chats set version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChatsDAO) UpdateVersionTx ¶

func (dao *ChatsDAO) UpdateVersionTx(tx *sqlx.Tx, id int64) (rowsAffected int64, err error)

update chats set version = version + 1 where id = :id UpdateVersionTx TODO(@benqi): sqlmap

type HashTagsDAO ¶

type HashTagsDAO struct {
	// contains filtered or unexported fields
}

func NewHashTagsDAO ¶

func NewHashTagsDAO(db *sqlx.DB) *HashTagsDAO

func (*HashTagsDAO) DeleteHashTagMessageId ¶

func (dao *HashTagsDAO) DeleteHashTagMessageId(ctx context.Context, user_id int64, hash_tag_message_id int32) (rowsAffected int64, err error)

DeleteHashTagMessageId update hash_tags set deleted = 1 where user_id = :user_id and hash_tag_message_id = :hash_tag_message_id TODO(@benqi): sqlmap

func (*HashTagsDAO) DeleteHashTagMessageIdTx ¶

func (dao *HashTagsDAO) DeleteHashTagMessageIdTx(tx *sqlx.Tx, user_id int64, hash_tag_message_id int32) (rowsAffected int64, err error)

update hash_tags set deleted = 1 where user_id = :user_id and hash_tag_message_id = :hash_tag_message_id DeleteHashTagMessageIdTx TODO(@benqi): sqlmap

func (*HashTagsDAO) InsertOrUpdate ¶

func (dao *HashTagsDAO) InsertOrUpdate(ctx context.Context, do *dataobject.HashTagsDO) (lastInsertId, rowsAffected int64, err error)

InsertOrUpdate insert into hash_tags(user_id, peer_type, peer_id, hash_tag, hash_tag_message_id) values (:user_id, :peer_type, :peer_id, :hash_tag, :hash_tag_message_id) on duplicate key update deleted = 0 TODO(@benqi): sqlmap

func (*HashTagsDAO) InsertOrUpdateTx ¶

func (dao *HashTagsDAO) InsertOrUpdateTx(tx *sqlx.Tx, do *dataobject.HashTagsDO) (lastInsertId, rowsAffected int64, err error)

InsertOrUpdateTx insert into hash_tags(user_id, peer_type, peer_id, hash_tag, hash_tag_message_id) values (:user_id, :peer_type, :peer_id, :hash_tag, :hash_tag_message_id) on duplicate key update deleted = 0 TODO(@benqi): sqlmap

func (*HashTagsDAO) SelectPeerHashTagList ¶

func (dao *HashTagsDAO) SelectPeerHashTagList(ctx context.Context, user_id int64, peer_type int32, peer_id int64, hash_tag string) (rList []int32, err error)

SelectPeerHashTagList select hash_tag_message_id from hash_tags where user_id = :user_id and peer_type = :peer_type and peer_id = :peer_id and hash_tag = :hash_tag and deleted = 0 TODO(@benqi): sqlmap

func (*HashTagsDAO) SelectPeerHashTagListWithCB ¶

func (dao *HashTagsDAO) SelectPeerHashTagListWithCB(ctx context.Context, user_id int64, peer_type int32, peer_id int64, hash_tag string, cb func(i int, v int32)) (rList []int32, err error)

SelectPeerHashTagListWithCB select hash_tag_message_id from hash_tags where user_id = :user_id and peer_type = :peer_type and peer_id = :peer_id and hash_tag = :hash_tag and deleted = 0 TODO(@benqi): sqlmap

type MessagesDAO ¶

type MessagesDAO struct {
	// contains filtered or unexported fields
}

func NewMessagesDAO ¶

func NewMessagesDAO(db *sqlx.DB) *MessagesDAO

func (*MessagesDAO) DeleteMessagesByMessageIdList ¶

func (dao *MessagesDAO) DeleteMessagesByMessageIdList(ctx context.Context, user_id int64, idList []int32) (rowsAffected int64, err error)

DeleteMessagesByMessageIdList update messages set deleted = 1 where user_id = :user_id and user_message_box_id in (:idList) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) DeleteMessagesByMessageIdListTx ¶

func (dao *MessagesDAO) DeleteMessagesByMessageIdListTx(tx *sqlx.Tx, user_id int64, idList []int32) (rowsAffected int64, err error)

update messages set deleted = 1 where user_id = :user_id and user_message_box_id in (:idList) and deleted = 0 DeleteMessagesByMessageIdListTx TODO(@benqi): sqlmap

func (*MessagesDAO) InsertOrReturnId ¶

func (dao *MessagesDAO) InsertOrReturnId(ctx context.Context, do *dataobject.MessagesDO) (lastInsertId, rowsAffected int64, err error)

InsertOrReturnId insert into messages(user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, date2) values (:user_id, :user_message_box_id, :dialog_id1, :dialog_id2, :dialog_message_id, :sender_user_id, :peer_type, :peer_id, :random_id, :message_filter_type, :message_data, :message, :mentioned, :media_unread, :pinned, :date2) on duplicate key update id = last_insert_id(id) TODO(@benqi): sqlmap

func (*MessagesDAO) InsertOrReturnIdTx ¶

func (dao *MessagesDAO) InsertOrReturnIdTx(tx *sqlx.Tx, do *dataobject.MessagesDO) (lastInsertId, rowsAffected int64, err error)

InsertOrReturnIdTx insert into messages(user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, date2) values (:user_id, :user_message_box_id, :dialog_id1, :dialog_id2, :dialog_message_id, :sender_user_id, :peer_type, :peer_id, :random_id, :message_filter_type, :message_data, :message, :mentioned, :media_unread, :pinned, :date2) on duplicate key update id = last_insert_id(id) TODO(@benqi): sqlmap

func (*MessagesDAO) Search ¶

func (dao *MessagesDAO) Search(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, q2 string, limit int32) (rList []dataobject.MessagesDO, err error)

Search select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and deleted = 0 and message != ” and message like :q2 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SearchGlobal ¶

func (dao *MessagesDAO) SearchGlobal(ctx context.Context, user_id int64, user_message_box_id int32, q2 string, limit int32) (rList []dataobject.MessagesDO, err error)

SearchGlobal select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and user_message_box_id < :user_message_box_id and deleted = 0 and message != ” and message like :q2 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SearchGlobalWithCB ¶

func (dao *MessagesDAO) SearchGlobalWithCB(ctx context.Context, user_id int64, user_message_box_id int32, q2 string, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SearchGlobalWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and user_message_box_id < :user_message_box_id and deleted = 0 and message != ” and message like :q2 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SearchWithCB ¶

func (dao *MessagesDAO) SearchWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, q2 string, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SearchWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and deleted = 0 and message != ” and message like :q2 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardByOffsetDateLimit ¶

func (dao *MessagesDAO) SelectBackwardByOffsetDateLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, date2 int64, limit int32) (rList []dataobject.MessagesDO, err error)

SelectBackwardByOffsetDateLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and date2 < :date2 and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardByOffsetDateLimitWithCB ¶

func (dao *MessagesDAO) SelectBackwardByOffsetDateLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, date2 int64, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectBackwardByOffsetDateLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and date2 < :date2 and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardByOffsetIdLimit ¶

func (dao *MessagesDAO) SelectBackwardByOffsetIdLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectBackwardByOffsetIdLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardByOffsetIdLimitWithCB ¶

func (dao *MessagesDAO) SelectBackwardByOffsetIdLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectBackwardByOffsetIdLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardBySendUserIdOffsetIdLimit ¶ added in v0.86.3

func (dao *MessagesDAO) SelectBackwardBySendUserIdOffsetIdLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, sender_user_id int64, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectBackwardBySendUserIdOffsetIdLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and sender_user_id = :sender_user_id and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardBySendUserIdOffsetIdLimitWithCB ¶ added in v0.86.3

func (dao *MessagesDAO) SelectBackwardBySendUserIdOffsetIdLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, sender_user_id int64, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectBackwardBySendUserIdOffsetIdLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and sender_user_id = :sender_user_id and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardUnreadMentionsByOffsetIdLimit ¶

func (dao *MessagesDAO) SelectBackwardUnreadMentionsByOffsetIdLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectBackwardUnreadMentionsByOffsetIdLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and mentioned = 1 and media_unread = 1 and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectBackwardUnreadMentionsByOffsetIdLimitWithCB ¶

func (dao *MessagesDAO) SelectBackwardUnreadMentionsByOffsetIdLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectBackwardUnreadMentionsByOffsetIdLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id < :user_message_box_id and mentioned = 1 and media_unread = 1 and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMediaType ¶

func (dao *MessagesDAO) SelectByMediaType(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, message_filter_type int32, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectByMediaType select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and message_filter_type = :message_filter_type and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMediaTypeWithCB ¶

func (dao *MessagesDAO) SelectByMediaTypeWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, message_filter_type int32, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectByMediaTypeWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and message_filter_type = :message_filter_type and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageDataId ¶

func (dao *MessagesDAO) SelectByMessageDataId(ctx context.Context, user_id int64, dialog_message_id int64) (rValue *dataobject.MessagesDO, err error)

SelectByMessageDataId select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and dialog_message_id = :dialog_message_id and deleted = 0 limit 1 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageDataIdList ¶

func (dao *MessagesDAO) SelectByMessageDataIdList(ctx context.Context, idList []int64) (rList []dataobject.MessagesDO, err error)

SelectByMessageDataIdList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where deleted = 0 and dialog_message_id in (:idList) order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageDataIdListWithCB ¶

func (dao *MessagesDAO) SelectByMessageDataIdListWithCB(ctx context.Context, idList []int64, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectByMessageDataIdListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where deleted = 0 and dialog_message_id in (:idList) order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageId ¶

func (dao *MessagesDAO) SelectByMessageId(ctx context.Context, user_id int64, user_message_box_id int32) (rValue *dataobject.MessagesDO, err error)

SelectByMessageId select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and user_message_box_id = :user_message_box_id and deleted = 0 limit 1 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageIdList ¶

func (dao *MessagesDAO) SelectByMessageIdList(ctx context.Context, user_id int64, idList []int32) (rList []dataobject.MessagesDO, err error)

SelectByMessageIdList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and deleted = 0 and user_message_box_id in (:idList) order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByMessageIdListWithCB ¶

func (dao *MessagesDAO) SelectByMessageIdListWithCB(ctx context.Context, user_id int64, idList []int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectByMessageIdListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and deleted = 0 and user_message_box_id in (:idList) order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectByRandomId ¶

func (dao *MessagesDAO) SelectByRandomId(ctx context.Context, sender_user_id int64, random_id int64) (rValue *dataobject.MessagesDO, err error)

SelectByRandomId select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where sender_user_id = :sender_user_id and random_id = :random_id and deleted = 0 limit 1 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogLastMessageId ¶

func (dao *MessagesDAO) SelectDialogLastMessageId(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64) (rValue int32, err error)

SelectDialogLastMessageId select user_message_box_id from messages where user_id = :user_id and dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2 and deleted = 0 order by user_message_box_id desc limit 1 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogLastMessageIdNotIdList ¶ added in v0.86.3

func (dao *MessagesDAO) SelectDialogLastMessageIdNotIdList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, idList []int32) (rValue int32, err error)

SelectDialogLastMessageIdNotIdList select user_message_box_id from messages where user_id = :user_id and dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2 and user_message_box_id not in (:idList) and deleted = 0 order by user_message_box_id desc limit 1 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogLastMessageList ¶

func (dao *MessagesDAO) SelectDialogLastMessageList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, limit int32) (rList []dataobject.MessagesDO, err error)

SelectDialogLastMessageList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogLastMessageListWithCB ¶

func (dao *MessagesDAO) SelectDialogLastMessageListWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectDialogLastMessageListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogMessageIdList ¶

func (dao *MessagesDAO) SelectDialogMessageIdList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64) (rList []dataobject.MessagesDO, err error)

SelectDialogMessageIdList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogMessageIdListWithCB ¶

func (dao *MessagesDAO) SelectDialogMessageIdListWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectDialogMessageIdListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogMessageListByMessageId ¶

func (dao *MessagesDAO) SelectDialogMessageListByMessageId(ctx context.Context, user_id int64, user_message_box_id int32) (rList []dataobject.MessagesDO, err error)

SelectDialogMessageListByMessageId select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where dialog_message_id = (select dialog_message_id from messages where user_id = :user_id and user_message_box_id = :user_message_box_id) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogMessageListByMessageIdWithCB ¶

func (dao *MessagesDAO) SelectDialogMessageListByMessageIdWithCB(ctx context.Context, user_id int64, user_message_box_id int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectDialogMessageListByMessageIdWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where dialog_message_id = (select dialog_message_id from messages where user_id = :user_id and user_message_box_id = :user_message_box_id) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogsByMessageIdList ¶

func (dao *MessagesDAO) SelectDialogsByMessageIdList(ctx context.Context, user_id int64, idList []int32) (rList []dataobject.MessagesDO, err error)

SelectDialogsByMessageIdList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and user_message_box_id in (:idList) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectDialogsByMessageIdListWithCB ¶

func (dao *MessagesDAO) SelectDialogsByMessageIdListWithCB(ctx context.Context, user_id int64, idList []int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectDialogsByMessageIdListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and user_message_box_id in (:idList) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardByOffsetDateLimit ¶

func (dao *MessagesDAO) SelectForwardByOffsetDateLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, date2 int64, limit int32) (rList []dataobject.MessagesDO, err error)

SelectForwardByOffsetDateLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and date2 >= :date2 and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardByOffsetDateLimitWithCB ¶

func (dao *MessagesDAO) SelectForwardByOffsetDateLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, date2 int64, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectForwardByOffsetDateLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and date2 >= :date2 and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardByOffsetIdLimit ¶

func (dao *MessagesDAO) SelectForwardByOffsetIdLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectForwardByOffsetIdLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id >= :user_message_box_id and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardByOffsetIdLimitWithCB ¶

func (dao *MessagesDAO) SelectForwardByOffsetIdLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectForwardByOffsetIdLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id >= :user_message_box_id and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardUnreadMentionsByOffsetIdLimit ¶

func (dao *MessagesDAO) SelectForwardUnreadMentionsByOffsetIdLimit(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectForwardUnreadMentionsByOffsetIdLimit select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id >= :user_message_box_id and mentioned = 1 and media_unread = 1 and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectForwardUnreadMentionsByOffsetIdLimitWithCB ¶

func (dao *MessagesDAO) SelectForwardUnreadMentionsByOffsetIdLimitWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectForwardUnreadMentionsByOffsetIdLimitWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and user_message_box_id >= :user_message_box_id and mentioned = 1 and media_unread = 1 and deleted = 0 order by user_message_box_id asc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectLastTwoPinnedList ¶

func (dao *MessagesDAO) SelectLastTwoPinnedList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64) (rList []int32, err error)

SelectLastTwoPinnedList select user_message_box_id from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc limit 2 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectLastTwoPinnedListWithCB ¶

func (dao *MessagesDAO) SelectLastTwoPinnedListWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, cb func(i int, v int32)) (rList []int32, err error)

SelectLastTwoPinnedListWithCB select user_message_box_id from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc limit 2 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerDialogMessageIdList ¶

func (dao *MessagesDAO) SelectPeerDialogMessageIdList(ctx context.Context, user_id int64, idList []int32) (rList []dataobject.MessagesDO, err error)

SelectPeerDialogMessageIdList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id != :user_id and dialog_message_id in (select dialog_message_id from messages where user_id = :user_id and user_message_box_id in (:idList)) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerDialogMessageIdListWithCB ¶

func (dao *MessagesDAO) SelectPeerDialogMessageIdListWithCB(ctx context.Context, user_id int64, idList []int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectPeerDialogMessageIdListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id != :user_id and dialog_message_id in (select dialog_message_id from messages where user_id = :user_id and user_message_box_id in (:idList)) and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerMessageList ¶

func (dao *MessagesDAO) SelectPeerMessageList(ctx context.Context, user_id int64, dialog_message_id int64) (rList []dataobject.MessagesDO, err error)

SelectPeerMessageList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id != :user_id and dialog_message_id = :dialog_message_id and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerMessageListWithCB ¶

func (dao *MessagesDAO) SelectPeerMessageListWithCB(ctx context.Context, user_id int64, dialog_message_id int64, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectPeerMessageListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id != :user_id and dialog_message_id = :dialog_message_id and deleted = 0 TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerUserMessage ¶

func (dao *MessagesDAO) SelectPeerUserMessage(ctx context.Context, peerId int64, user_id int64, user_message_box_id int32) (rValue *dataobject.MessagesDO, err error)

SelectPeerUserMessage select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :peerId and deleted = 0 and dialog_message_id = (select dialog_message_id from messages where user_id = :user_id and user_message_box_id = :user_message_box_id and deleted = 0 limit 1) TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPeerUserMessageId ¶

func (dao *MessagesDAO) SelectPeerUserMessageId(ctx context.Context, peerId int32, user_id int64, user_message_box_id int32) (rValue *dataobject.MessagesDO, err error)

SelectPeerUserMessageId select user_message_box_id, message_box_type from messages where user_id = :peerId and deleted = 0 and dialog_message_id = (select dialog_message_id from messages where user_id = :user_id and user_message_box_id = :user_message_box_id and deleted = 0 limit 1) TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPhoneCallList ¶

func (dao *MessagesDAO) SelectPhoneCallList(ctx context.Context, user_id int64, message_filter_type int32, user_message_box_id int32, limit int32) (rList []dataobject.MessagesDO, err error)

SelectPhoneCallList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and message_filter_type = :message_filter_type and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPhoneCallListWithCB ¶

func (dao *MessagesDAO) SelectPhoneCallListWithCB(ctx context.Context, user_id int64, message_filter_type int32, user_message_box_id int32, limit int32, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectPhoneCallListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and message_filter_type = :message_filter_type and user_message_box_id < :user_message_box_id and deleted = 0 order by user_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPinnedList ¶

func (dao *MessagesDAO) SelectPinnedList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64) (rList []dataobject.MessagesDO, err error)

SelectPinnedList select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPinnedListWithCB ¶

func (dao *MessagesDAO) SelectPinnedListWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, cb func(i int, v *dataobject.MessagesDO)) (rList []dataobject.MessagesDO, err error)

SelectPinnedListWithCB select user_id, user_message_box_id, dialog_id1, dialog_id2, dialog_message_id, sender_user_id, peer_type, peer_id, random_id, message_filter_type, message_data, message, mentioned, media_unread, pinned, has_reaction, reaction, reaction_date, reaction_unread, date2 from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPinnedMessageIdList ¶

func (dao *MessagesDAO) SelectPinnedMessageIdList(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64) (rList []int32, err error)

SelectPinnedMessageIdList select user_message_box_id from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) SelectPinnedMessageIdListWithCB ¶

func (dao *MessagesDAO) SelectPinnedMessageIdListWithCB(ctx context.Context, user_id int64, dialog_id1 int64, dialog_id2 int64, cb func(i int, v int32)) (rList []int32, err error)

SelectPinnedMessageIdListWithCB select user_message_box_id from messages where user_id = :user_id and (dialog_id1 = :dialog_id1 and dialog_id2 = :dialog_id2) and pinned = 1 and deleted = 0 order by user_message_box_id desc TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateCustomMap ¶ added in v0.86.3

func (dao *MessagesDAO) UpdateCustomMap(ctx context.Context, cMap map[string]interface{}, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdateCustomMap update messages set %s where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateCustomMapTx ¶ added in v0.86.3

func (dao *MessagesDAO) UpdateCustomMapTx(tx *sqlx.Tx, cMap map[string]interface{}, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdateCustomMapTx update messages set %s where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateEditMessage ¶

func (dao *MessagesDAO) UpdateEditMessage(ctx context.Context, message_data string, message string, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdateEditMessage update messages set message_data = :message_data, message = :message where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateEditMessageTx ¶

func (dao *MessagesDAO) UpdateEditMessageTx(tx *sqlx.Tx, message_data string, message string, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

update messages set message_data = :message_data, message = :message where user_id = :user_id and user_message_box_id = :user_message_box_id UpdateEditMessageTx TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateMediaUnread ¶

func (dao *MessagesDAO) UpdateMediaUnread(ctx context.Context, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdateMediaUnread update messages set media_unread = 0 where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateMediaUnreadTx ¶

func (dao *MessagesDAO) UpdateMediaUnreadTx(tx *sqlx.Tx, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

update messages set media_unread = 0 where user_id = :user_id and user_message_box_id = :user_message_box_id UpdateMediaUnreadTx TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateMentionedAndMediaUnread ¶

func (dao *MessagesDAO) UpdateMentionedAndMediaUnread(ctx context.Context, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdateMentionedAndMediaUnread update messages set mentioned = 0, media_unread = 0 where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateMentionedAndMediaUnreadTx ¶

func (dao *MessagesDAO) UpdateMentionedAndMediaUnreadTx(tx *sqlx.Tx, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

update messages set mentioned = 0, media_unread = 0 where user_id = :user_id and user_message_box_id = :user_message_box_id UpdateMentionedAndMediaUnreadTx TODO(@benqi): sqlmap

func (*MessagesDAO) UpdatePinned ¶

func (dao *MessagesDAO) UpdatePinned(ctx context.Context, pinned bool, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

UpdatePinned update messages set pinned = :pinned where user_id = :user_id and user_message_box_id = :user_message_box_id TODO(@benqi): sqlmap

func (*MessagesDAO) UpdatePinnedTx ¶

func (dao *MessagesDAO) UpdatePinnedTx(tx *sqlx.Tx, pinned bool, user_id int64, user_message_box_id int32) (rowsAffected int64, err error)

update messages set pinned = :pinned where user_id = :user_id and user_message_box_id = :user_message_box_id UpdatePinnedTx TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateUnPinnedByIdList ¶

func (dao *MessagesDAO) UpdateUnPinnedByIdList(ctx context.Context, user_id int64, idList []int32) (rowsAffected int64, err error)

UpdateUnPinnedByIdList update messages set pinned = 0 where user_id = :user_id and user_message_box_id in (:idList) TODO(@benqi): sqlmap

func (*MessagesDAO) UpdateUnPinnedByIdListTx ¶

func (dao *MessagesDAO) UpdateUnPinnedByIdListTx(tx *sqlx.Tx, user_id int64, idList []int32) (rowsAffected int64, err error)

update messages set pinned = 0 where user_id = :user_id and user_message_box_id in (:idList) UpdateUnPinnedByIdListTx TODO(@benqi): sqlmap

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL