mysql_dao

package
v0.0.0-...-e41513e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 10, 2020 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthChannelUpdatesStateDAO 

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

func NewAuthChannelUpdatesStateDAO 

func NewAuthChannelUpdatesStateDAO(db *sqlx.DB) *AuthChannelUpdatesStateDAO

func (*AuthChannelUpdatesStateDAO) Insert 

func (dao *AuthChannelUpdatesStateDAO) Insert(do *dataobject.AuthChannelUpdatesStateDO) int64

insert into auth_channel_updates_state(auth_key_id, user_id, channel_id, pts, pts2, `date`) values (:auth_key_id, :user_id, :channel_id, :pts, :pts2, :date) TODO(@benqi): sqlmap

func (*AuthChannelUpdatesStateDAO) SelectByAuthId 

func (dao *AuthChannelUpdatesStateDAO) SelectByAuthId(auth_key_id int64, channel_id int32) *dataobject.AuthChannelUpdatesStateDO

select auth_key_id, user_id, channel_id, pts, pts2, `date` from auth_channel_updates_state where auth_key_id = :auth_key_id and channel_id = :channel_id TODO(@benqi): sqlmap

func (*AuthChannelUpdatesStateDAO) UpdateChannelPts 

func (dao *AuthChannelUpdatesStateDAO) UpdateChannelPts(pts int32, auth_key_id int64, channel_id int32) int64

update auth_channel_updates_state set pts = :pts, pts2 = :pts where auth_key_id = :auth_key_id and channel_id = :channel_id TODO(@benqi): sqlmap

func (*AuthChannelUpdatesStateDAO) UpdateChannelPts2 

func (dao *AuthChannelUpdatesStateDAO) UpdateChannelPts2(pts2 int32, auth_key_id int64, channel_id int32) int64

update auth_channel_updates_state set pts2 = :pts2 where auth_key_id = :auth_key_id and channel_id = :channel_id TODO(@benqi): sqlmap

type ChannelMediaUnreadDAO 

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

func NewChannelMediaUnreadDAO 

func NewChannelMediaUnreadDAO(db *sqlx.DB) *ChannelMediaUnreadDAO

func (*ChannelMediaUnreadDAO) Insert 

func (dao *ChannelMediaUnreadDAO) Insert(do *dataobject.ChannelMediaUnreadDO) int64

insert into channel_media_unread(user_id, channel_id, channel_message_id, media_unread) values (:user_id, :channel_id, :channel_message_id, :media_unread) TODO(@benqi): sqlmap

func (*ChannelMediaUnreadDAO) SelectMediaUnread 

func (dao *ChannelMediaUnreadDAO) SelectMediaUnread(user_id int32, channel_id int32, channel_message_id int32) *dataobject.ChannelMediaUnreadDO

select media_unread from channel_media_unread where user_id = :user_id and channel_id = :channel_id and channel_message_id = :channel_message_id TODO(@benqi): sqlmap

func (*ChannelMediaUnreadDAO) UpdateMediaUnread 

func (dao *ChannelMediaUnreadDAO) UpdateMediaUnread(user_id int32, channel_id int32, channel_message_id int32) int64

update channel_media_unread set media_unread = 0 where user_id = :user_id and channel_id = :channel_id and channel_message_id = :channel_message_id TODO(@benqi): sqlmap

type ChannelMessageBoxesDAO 

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

func NewChannelMessageBoxesDAO 

func NewChannelMessageBoxesDAO(db *sqlx.DB) *ChannelMessageBoxesDAO

func (*ChannelMessageBoxesDAO) Insert 

func (dao *ChannelMessageBoxesDAO) Insert(do *dataobject.ChannelMessageBoxesDO) int64

insert into channel_message_boxes(sender_user_id, channel_id, channel_message_box_id, message_id, `date`) values (:sender_user_id, :channel_id, :channel_message_box_id, :message_id, :date) TODO(@benqi): sqlmap

func (*ChannelMessageBoxesDAO) SelectBackwardByOffsetLimit 

func (dao *ChannelMessageBoxesDAO) SelectBackwardByOffsetLimit(channel_id int32, channel_message_box_id int32, limit int32) []dataobject.ChannelMessageBoxesDO

select sender_user_id, channel_id, channel_message_box_id, message_id, `date` from channel_message_boxes where channel_id = :channel_id and channel_message_box_id < :channel_message_box_id and deleted = 0 order by channel_message_box_id desc limit :limit TODO(@benqi): sqlmap

func (*ChannelMessageBoxesDAO) SelectByMessageId 

func (dao *ChannelMessageBoxesDAO) SelectByMessageId(channel_id int32, channel_message_box_id int32) *dataobject.ChannelMessageBoxesDO

select sender_user_id, channel_id, channel_message_box_id, message_id, `date` from channel_message_boxes where channel_id = :channel_id and channel_message_box_id = :channel_message_box_id and deleted = 0 limit 1 TODO(@benqi): sqlmap

func (*ChannelMessageBoxesDAO) SelectByMessageIdList 

func (dao *ChannelMessageBoxesDAO) SelectByMessageIdList(channel_id int32, idList []int32) []dataobject.ChannelMessageBoxesDO

select sender_user_id, channel_id, channel_message_box_id, message_id, `date` from channel_message_boxes where channel_id = :channel_id and deleted = 0 and channel_message_box_id in (:idList) order by channel_message_box_id desc TODO(@benqi): sqlmap

func (*ChannelMessageBoxesDAO) SelectForwardByOffsetLimit 

func (dao *ChannelMessageBoxesDAO) SelectForwardByOffsetLimit(channel_id int32, channel_message_box_id int32, limit int32) []dataobject.ChannelMessageBoxesDO

select sender_user_id, channel_id, channel_message_box_id, message_id, `date` from channel_message_boxes where channel_id = :channel_id and channel_message_box_id >= :channel_message_box_id and deleted = 0 order by channel_message_box_id asc limit :limit TODO(@benqi): sqlmap

type ChannelMessagesDAO 

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

func NewChannelMessagesDAO 

func NewChannelMessagesDAO(db *sqlx.DB) *ChannelMessagesDAO

func (*ChannelMessagesDAO) Insert 

func (dao *ChannelMessagesDAO) Insert(do *dataobject.ChannelMessagesDO) int64

insert ignore into channel_messages(channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date`) values (:channel_id, :channel_message_id, :sender_user_id, :random_id, :message_data_id, :message_type, :message_data, :has_media_unread, :edit_message, :edit_date, :views, :date) TODO(@benqi): sqlmap

func (*ChannelMessagesDAO) SelectBackwardByOffsetLimit 

func (dao *ChannelMessagesDAO) SelectBackwardByOffsetLimit(channel_id int32, channel_message_id int32, limit int32) []dataobject.ChannelMessagesDO

select channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date` from channel_messages where channel_id = :channel_id and channel_message_id < :channel_message_id and deleted = 0 order by channel_message_id desc limit :limit TODO(@benqi): sqlmap

func (*ChannelMessagesDAO) SelectByMessageId 

func (dao *ChannelMessagesDAO) SelectByMessageId(channel_id int32, channel_message_id int32) *dataobject.ChannelMessagesDO

select channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date` from channel_messages where channel_id = :channel_id and channel_message_id = :channel_message_id and deleted = 0 limit 1 TODO(@benqi): sqlmap

func (*ChannelMessagesDAO) SelectByMessageIdList 

func (dao *ChannelMessagesDAO) SelectByMessageIdList(channel_id int32, idList []int32) []dataobject.ChannelMessagesDO

select channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date` from channel_messages where channel_id = :channel_id and deleted = 0 and channel_message_id in (:idList) order by channel_message_id desc TODO(@benqi): sqlmap

func (*ChannelMessagesDAO) SelectByRandomId 

func (dao *ChannelMessagesDAO) SelectByRandomId(sender_user_id int32, random_id int64) *dataobject.ChannelMessagesDO

select channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date` from channel_messages where sender_user_id = :sender_user_id and random_id = :random_id TODO(@benqi): sqlmap

func (*ChannelMessagesDAO) SelectForwardByOffsetLimit 

func (dao *ChannelMessagesDAO) SelectForwardByOffsetLimit(channel_id int32, channel_message_id int32, limit int32) []dataobject.ChannelMessagesDO

select channel_id, channel_message_id, sender_user_id, random_id, message_data_id, message_type, message_data, has_media_unread, edit_message, edit_date, views, `date` from channel_messages where channel_id = :channel_id and channel_message_id >= :channel_message_id and deleted = 0 order by channel_message_id asc limit :limit TODO(@benqi): sqlmap

type ChannelParticipantsDAO 

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

func NewChannelParticipantsDAO 

func NewChannelParticipantsDAO(db *sqlx.DB) *ChannelParticipantsDAO

func (*ChannelParticipantsDAO) DeleteChannelUser 

func (dao *ChannelParticipantsDAO) DeleteChannelUser(id int32) int64

update channel_participants set state = 1 where id = :id TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) Insert 

func (dao *ChannelParticipantsDAO) Insert(do *dataobject.ChannelParticipantsDO) int64

insert into channel_participants(channel_id, user_id, participant_type, inviter_user_id, invited_at, joined_at, state) values (:channel_id, :user_id, :participant_type, :inviter_user_id, :invited_at, :joined_at, :state) TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) SelectByChannelId 

func (dao *ChannelParticipantsDAO) SelectByChannelId(channel_id int32) []dataobject.ChannelParticipantsDO

select id, channel_id, user_id, participant_type, inviter_user_id, invited_at, joined_at, state from channel_participants where channel_id = :channel_id TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) SelectByUserId 

func (dao *ChannelParticipantsDAO) SelectByUserId(channel_id int32, user_id int32) *dataobject.ChannelParticipantsDO

select id, channel_id, user_id, participant_type, inviter_user_id, invited_at, joined_at, state from channel_participants where channel_id = :channel_id and user_id = :user_id TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) SelectByUserIdList 

func (dao *ChannelParticipantsDAO) SelectByUserIdList(channel_id int32, idList []int32) []dataobject.ChannelParticipantsDO

select id, channel_id, user_id, participant_type, inviter_user_id, invited_at, joined_at, state from channel_participants where channel_id = :channel_id and user_id in (:idList) TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) Update 

func (dao *ChannelParticipantsDAO) Update(inviter_user_id int32, invited_at int32, joined_at int32, id int32) int64

update channel_participants set inviter_user_id = :inviter_user_id, invited_at = :invited_at, joined_at = :joined_at, state = 0 where id = :id TODO(@benqi): sqlmap

func (*ChannelParticipantsDAO) UpdateParticipantType 

func (dao *ChannelParticipantsDAO) UpdateParticipantType(participant_type int8, id int32) int64

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

type ChannelPtsUpdatesDAO 

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

func NewChannelPtsUpdatesDAO 

func NewChannelPtsUpdatesDAO(db *sqlx.DB) *ChannelPtsUpdatesDAO

func (*ChannelPtsUpdatesDAO) Insert 

func (dao *ChannelPtsUpdatesDAO) Insert(do *dataobject.ChannelPtsUpdatesDO) int64

insert into channel_pts_updates(channel_id, pts, pts_count, update_type, update_data, date2) values (:channel_id, :pts, :pts_count, :update_type, :update_data, :date2) TODO(@benqi): sqlmap

func (*ChannelPtsUpdatesDAO) SelectByGtPts 

func (dao *ChannelPtsUpdatesDAO) SelectByGtPts(channel_id int32, pts int32) []dataobject.ChannelPtsUpdatesDO

select channel_id, pts, pts_count, update_type, update_data from channel_pts_updates where channel_id = :channel_id and pts > :pts order by pts asc TODO(@benqi): sqlmap

func (*ChannelPtsUpdatesDAO) SelectLastPts 

func (dao *ChannelPtsUpdatesDAO) SelectLastPts(channel_id int32) *dataobject.ChannelPtsUpdatesDO

select pts from channel_pts_updates where channel_id = :channel_id order by pts desc limit 1 TODO(@benqi): sqlmap

type ChannelsDAO 

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

func NewChannelsDAO 

func NewChannelsDAO(db *sqlx.DB) *ChannelsDAO

func (*ChannelsDAO) Insert 

func (dao *ChannelsDAO) Insert(do *dataobject.ChannelsDO) int64

insert into channels(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 (*ChannelsDAO) Select 

func (dao *ChannelsDAO) Select(id int32) *dataobject.ChannelsDO

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

func (*ChannelsDAO) SelectByIdList 

func (dao *ChannelsDAO) SelectByIdList(idList []int32) []dataobject.ChannelsDO

select id, access_hash, participant_count, title, about, photo_id, admins_enabled, deactivated, version, `date` from channels where id in (:idList) TODO(@benqi): sqlmap

func (*ChannelsDAO) UpdateAbout 

func (dao *ChannelsDAO) UpdateAbout(about string, date int32, id int32) int64

update channels set about = :about, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChannelsDAO) UpdateAdminsEnabled 

func (dao *ChannelsDAO) UpdateAdminsEnabled(admins_enabled int8, date int32, id int32) int64

update channels set admins_enabled = :admins_enabled, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap 

func (dao *ChannelsDAO) UpdateLink(link string, date int32, id int32) int64

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

func (*ChannelsDAO) UpdateParticipantCount 

func (dao *ChannelsDAO) UpdateParticipantCount(participant_count int32, date int32, id int32) int64

update channels set participant_count = :participant_count, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChannelsDAO) UpdatePhotoId 

func (dao *ChannelsDAO) UpdatePhotoId(photo_id int64, date int32, id int32) int64

update channels set photo_id = :photo_id, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChannelsDAO) UpdateTitle 

func (dao *ChannelsDAO) UpdateTitle(title string, date int32, id int32) int64

update channels set title = :title, `date` = :date, version = version + 1 where id = :id TODO(@benqi): sqlmap

func (*ChannelsDAO) UpdateVersion 

func (dao *ChannelsDAO) UpdateVersion(date int32, id int32) int64

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

type CommonDAO 

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

func NewCommonDAO 

func NewCommonDAO(db *sqlx.DB) *CommonDAO

func (*CommonDAO) CheckExists 

func (dao *CommonDAO) CheckExists(table string, params map[string]interface{}) bool

检查是否存在 TODO(@benqi): SELECT count(id) 是否会快一点？

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.