comment.go

// Code generated by ModelQ
// comment.go contains model for the database table [blog.comment]

package mysql

import (
	"database/sql"
	"encoding/gob"
	"encoding/json"
	"fmt"
	"github.com/mijia/modelq/gmq"
	"strings"
	"time"
)

type Comment struct {
	UserId     int64     `json:"user_id"`
	ArticleId  int64     `json:"article_id"`
	Content    string    `json:"content"`
	CreateTime time.Time `json:"create_time"`
	UpdateTime time.Time `json:"update_time"`
}

// Start of the Comment APIs.

func (obj Comment) String() string {
	if data, err := json.Marshal(obj); err != nil {
		return fmt.Sprintf("<Comment UserId=%v ArticleId=%v>", obj.UserId, obj.ArticleId)
	} else {
		return string(data)
	}
}

func (obj Comment) Insert(dbtx gmq.DbTx) (Comment, error) {
	_, err := CommentObjs.Insert(obj).Run(dbtx)
	return obj, err
}

func (obj Comment) Update(dbtx gmq.DbTx) (int64, error) {
	fields := []string{"Content", "CreateTime"}
	filter := CommentObjs.FilterUserId("=", obj.UserId)
	filter = filter.And(CommentObjs.FilterArticleId("=", obj.ArticleId))
	if result, err := CommentObjs.Update(obj, fields...).Where(filter).Run(dbtx); err != nil {
		return 0, err
	} else {
		return result.RowsAffected()
	}
}

func (obj Comment) Delete(dbtx gmq.DbTx) (int64, error) {
	filter := CommentObjs.FilterUserId("=", obj.UserId)
	filter = filter.And(CommentObjs.FilterArticleId("=", obj.ArticleId))
	if result, err := CommentObjs.Delete().Where(filter).Run(dbtx); err != nil {
		return 0, err
	} else {
		return result.RowsAffected()
	}
}

// Start of the inner Query Api

type _CommentQuery struct {
	gmq.Query
}

func (q _CommentQuery) Where(f gmq.Filter) _CommentQuery {
	q.Query = q.Query.Where(f)
	return q
}

func (q _CommentQuery) OrderBy(by ...string) _CommentQuery {
	tBy := make([]string, 0, len(by))
	for _, b := range by {
		sortDir := ""
		if b[0] == '-' || b[0] == '+' {
			sortDir = string(b[0])
			b = b[1:]
		}
		if col, ok := CommentObjs.fcMap[b]; ok {
			tBy = append(tBy, sortDir+col)
		}
	}
	q.Query = q.Query.OrderBy(tBy...)
	return q
}

func (q _CommentQuery) GroupBy(by ...string) _CommentQuery {
	tBy := make([]string, 0, len(by))
	for _, b := range by {
		if col, ok := CommentObjs.fcMap[b]; ok {
			tBy = append(tBy, col)
		}
	}
	q.Query = q.Query.GroupBy(tBy...)
	return q
}

func (q _CommentQuery) Limit(offsets ...int64) _CommentQuery {
	q.Query = q.Query.Limit(offsets...)
	return q
}

func (q _CommentQuery) Page(number, size int) _CommentQuery {
	q.Query = q.Query.Page(number, size)
	return q
}

func (q _CommentQuery) Run(dbtx gmq.DbTx) (sql.Result, error) {
	return q.Query.Exec(dbtx)
}

type CommentRowVisitor func(obj Comment) bool

func (q _CommentQuery) Iterate(dbtx gmq.DbTx, functor CommentRowVisitor) error {
	return q.Query.SelectList(dbtx, func(columns []gmq.Column, rb []sql.RawBytes) bool {
		obj := CommentObjs.toComment(columns, rb)
		return functor(obj)
	})
}

func (q _CommentQuery) One(dbtx gmq.DbTx) (Comment, error) {
	var obj Comment
	err := q.Query.SelectOne(dbtx, func(columns []gmq.Column, rb []sql.RawBytes) bool {
		obj = CommentObjs.toComment(columns, rb)
		return true
	})
	return obj, err
}

func (q _CommentQuery) List(dbtx gmq.DbTx) ([]Comment, error) {
	result := make([]Comment, 0, 10)
	err := q.Query.SelectList(dbtx, func(columns []gmq.Column, rb []sql.RawBytes) bool {
		obj := CommentObjs.toComment(columns, rb)
		result = append(result, obj)
		return true
	})
	return result, err
}

// Start of the model facade Apis.

type _CommentObjs struct {
	fcMap map[string]string
}

func (o _CommentObjs) Names() (schema, tbl, alias string) {
	return "blog", "comment", "Comment"
}

func (o _CommentObjs) Select(fields ...string) _CommentQuery {
	q := _CommentQuery{}
	if len(fields) == 0 {
		fields = []string{"UserId", "ArticleId", "Content", "CreateTime", "UpdateTime"}
	}
	q.Query = gmq.Select(o, o.columns(fields...))
	return q
}

func (o _CommentObjs) Insert(obj Comment) _CommentQuery {
	q := _CommentQuery{}
	q.Query = gmq.Insert(o, o.columnsWithData(obj, "UserId", "ArticleId", "Content"))
	return q
}

func (o _CommentObjs) Update(obj Comment, fields ...string) _CommentQuery {
	q := _CommentQuery{}
	q.Query = gmq.Update(o, o.columnsWithData(obj, fields...))
	return q
}

func (o _CommentObjs) Delete() _CommentQuery {
	q := _CommentQuery{}
	q.Query = gmq.Delete(o)
	return q
}

///// Managed Objects Filters definition

func (o _CommentObjs) FilterUserId(op string, p int64, ps ...int64) gmq.Filter {
	params := make([]interface{}, 1+len(ps))
	params[0] = p
	for i := range ps {
		params[i+1] = ps[i]
	}
	return o.newFilter("user_id", op, params...)
}

func (o _CommentObjs) FilterArticleId(op string, p int64, ps ...int64) gmq.Filter {
	params := make([]interface{}, 1+len(ps))
	params[0] = p
	for i := range ps {
		params[i+1] = ps[i]
	}
	return o.newFilter("article_id", op, params...)
}

func (o _CommentObjs) FilterContent(op string, p string, ps ...string) gmq.Filter {
	params := make([]interface{}, 1+len(ps))
	params[0] = p
	for i := range ps {
		params[i+1] = ps[i]
	}
	return o.newFilter("content", op, params...)
}

func (o _CommentObjs) FilterCreateTime(op string, p time.Time, ps ...time.Time) gmq.Filter {
	params := make([]interface{}, 1+len(ps))
	params[0] = p
	for i := range ps {
		params[i+1] = ps[i]
	}
	return o.newFilter("create_time", op, params...)
}

func (o _CommentObjs) FilterUpdateTime(op string, p time.Time, ps ...time.Time) gmq.Filter {
	params := make([]interface{}, 1+len(ps))
	params[0] = p
	for i := range ps {
		params[i+1] = ps[i]
	}
	return o.newFilter("update_time", op, params...)
}

///// Managed Objects Columns definition

func (o _CommentObjs) ColumnUserId(p ...int64) gmq.Column {
	var value interface{}
	if len(p) > 0 {
		value = p[0]
	}
	return gmq.Column{"user_id", value}
}

func (o _CommentObjs) ColumnArticleId(p ...int64) gmq.Column {
	var value interface{}
	if len(p) > 0 {
		value = p[0]
	}
	return gmq.Column{"article_id", value}
}

func (o _CommentObjs) ColumnContent(p ...string) gmq.Column {
	var value interface{}
	if len(p) > 0 {
		value = p[0]
	}
	return gmq.Column{"content", value}
}

func (o _CommentObjs) ColumnCreateTime(p ...time.Time) gmq.Column {
	var value interface{}
	if len(p) > 0 {
		value = p[0]
	}
	return gmq.Column{"create_time", value}
}

func (o _CommentObjs) ColumnUpdateTime(p ...time.Time) gmq.Column {
	var value interface{}
	if len(p) > 0 {
		value = p[0]
	}
	return gmq.Column{"update_time", value}
}

////// Internal helper funcs

func (o _CommentObjs) newFilter(name, op string, params ...interface{}) gmq.Filter {
	if strings.ToUpper(op) == "IN" {
		return gmq.InFilter(name, params)
	}
	return gmq.UnitFilter(name, op, params[0])
}

func (o _CommentObjs) toComment(columns []gmq.Column, rb []sql.RawBytes) Comment {
	obj := Comment{}
	if len(columns) == len(rb) {
		for i := range columns {
			switch columns[i].Name {
			case "user_id":
				obj.UserId = gmq.AsInt64(rb[i])
			case "article_id":
				obj.ArticleId = gmq.AsInt64(rb[i])
			case "content":
				obj.Content = gmq.AsString(rb[i])
			case "create_time":
				obj.CreateTime = gmq.AsTime(rb[i])
			case "update_time":
				obj.UpdateTime = gmq.AsTime(rb[i])
			}
		}
	}
	return obj
}

func (o _CommentObjs) columns(fields ...string) []gmq.Column {
	data := make([]gmq.Column, 0, len(fields))
	for _, f := range fields {
		switch f {
		case "UserId":
			data = append(data, o.ColumnUserId())
		case "ArticleId":
			data = append(data, o.ColumnArticleId())
		case "Content":
			data = append(data, o.ColumnContent())
		case "CreateTime":
			data = append(data, o.ColumnCreateTime())
		case "UpdateTime":
			data = append(data, o.ColumnUpdateTime())
		}
	}
	return data
}

func (o _CommentObjs) columnsWithData(obj Comment, fields ...string) []gmq.Column {
	data := make([]gmq.Column, 0, len(fields))
	for _, f := range fields {
		switch f {
		case "UserId":
			data = append(data, o.ColumnUserId(obj.UserId))
		case "ArticleId":
			data = append(data, o.ColumnArticleId(obj.ArticleId))
		case "Content":
			data = append(data, o.ColumnContent(obj.Content))
		case "CreateTime":
			data = append(data, o.ColumnCreateTime(obj.CreateTime))
		case "UpdateTime":
			data = append(data, o.ColumnUpdateTime(obj.UpdateTime))
		}
	}
	return data
}

var CommentObjs _CommentObjs

func init() {
	CommentObjs.fcMap = map[string]string{
		"UserId":     "user_id",
		"ArticleId":  "article_id",
		"Content":    "content",
		"CreateTime": "create_time",
		"UpdateTime": "update_time",
	}
	gob.Register(Comment{})
}