func CountContent(ctx context.Context, targets string, condition Condition) (int, error) {
	condition = condition.Limit(0, 0)
	count, err := BindContent(ctx, nil, targets, condition)
	return count, err
}
Count content separately
package db
import (
	"context"
	"database/sql"
	"fmt"
	"github.com/digimakergo/digimaker/core/definition"
	"github.com/digimakergo/digimaker/core/log"
	"github.com/digimakergo/digimaker/core/util"
	"github.com/volatiletech/sqlboiler/queries"
)
type SingleQuery struct {
	Table     string
	Alias     string
	Select    []string
	Condition Condition
	Relation  Condition
}
type ContentOption struct {
	WithAuthor       bool
	WithRelation     []string  
	WithRelationlist []string  
}
type Query struct {
	Queries     []SingleQuery
	Groupby     []string  
	LimitArr    []int
	LeftQueries []SingleQuery
	SortArr     []string
	AlwaysCount bool
}
func (q *Query) Add(added SingleQuery) {
	queries := append(q.Queries, added)
	q.Queries = queries
}
func (q *Query) AddLeft(query SingleQuery) {
	queries := append(q.LeftQueries, query)
	q.LeftQueries = queries
}
func (q *Query) Join(name string, condition Condition, joinCondition Condition) Query {
	tableName, alias, _ := getTableAlias(name)
	oneQuery := SingleQuery{
		Table:     tableName,
		Alias:     alias,
		Select:    handler.GetColumns(tableName),
		Condition: condition,
		Relation:  joinCondition,
	}
	q.Add(oneQuery)
	return *q
}
func (q *Query) Sortby(sortby ...string) Query {
	q.SortArr = sortby
	return *q
}
func (q *Query) Limit(offset int, limit int) Query {
	q.LimitArr = []int{offset, limit}
	return *q
}
func getTableAlias(target string) (string, string, string) {
	nameArr := util.Split(target, " ")
	targetName := nameArr[0]
	targetAlias := ""
	if len(nameArr) > 1 {
		targetAlias = nameArr[1]
	}
	tableName := ""
	def, err := definition.GetDefinition(targetName)
	if err == nil {
		tableName = def.TableName
	} else {
		tableName = targetName
	}
	return tableName, targetAlias, targetName
}
func CreateQuery(targets string, condition Condition) (string, Query) {
	targetArr := util.Split(targets, ",")
	firstTarget := ""
	queries := []SingleQuery{}
	for i, target := range targetArr {
		table, alias, target := getTableAlias(target)
		sQuery := SingleQuery{
			Table:     table,
			Alias:     alias,
			Condition: condition,
		}
		if i == 0 {
			firstTarget = target
		}
		queries = append(queries, sQuery)
	}
	query := Query{
		Queries:     queries,
		SortArr:     condition.Option.Sortby,
		LimitArr:    condition.Option.LimitArr,
		AlwaysCount: condition.Option.AlwaysCount,
	}
	return firstTarget, query
}
func BindContent(ctx context.Context, entity interface{}, targets string, condition Condition) (int, error) {
	contentType, query := CreateQuery(targets, condition)
	def, _ := definition.GetDefinition(contentType)
	withAuthor := false
	if def.HasLocation {
		withAuthor = true
	}
	count, err := BindContentWithQuery(ctx, entity, contentType, query, ContentOption{WithAuthor: withAuthor})
	return count, err
}