goen.go

// Code generated by https://github.com/kamichidu/goen; DO NOT EDIT THIS FILE.
// Use of this source code is governed by a MIT license that can be found in
// the file located on https://github.com/kamichidu/goen repository.

package multiref

import (
	"context"
	"database/sql"

	"github.com/Masterminds/squirrel"
	"github.com/kamichidu/goen"
	github_com_satori_go_uuid "github.com/satori/go.uuid"
)

var metaSchema = goen.NewMetaSchema()

func init() {
	metaSchema.Register(Child{})
}

type ChildSqlizer interface {
	squirrel.Sqlizer

	ChildToSql() (string, []interface{}, error)
}

type _ChildSqlizer struct {
	squirrel.Sqlizer
}

func (sqlizer *_ChildSqlizer) ChildToSql() (string, []interface{}, error) {
	return sqlizer.ToSql()
}

type ChildColumnExpr interface {
	ChildColumnExpr() string

	String() string
}

type ChildOrderExpr interface {
	ChildOrderExpr() string
}

type ChildQueryBuilder struct {
	dbc *goen.DBContext

	includeLoaders goen.IncludeLoaderList

	builder squirrel.SelectBuilder
}

func newChildQueryBuilder(dbc *goen.DBContext) ChildQueryBuilder {
	stmtBuilder := squirrel.StatementBuilder.PlaceholderFormat(dbc.Dialect().PlaceholderFormat())
	metaT := metaSchema.LoadOf(&Child{})
	return ChildQueryBuilder{
		dbc: dbc,
		// columns provided later
		builder: stmtBuilder.Select().From(dbc.Dialect().Quote(metaT.TableName())),
	}
}

func (qb ChildQueryBuilder) Include(loaders ...goen.IncludeLoader) ChildQueryBuilder {
	qb.includeLoaders.Append(loaders...)
	return qb
}

func (qb ChildQueryBuilder) Where(conds ...ChildSqlizer) ChildQueryBuilder {
	for _, cond := range conds {
		qb.builder = qb.builder.Where(cond)
	}
	return qb
}

func (qb ChildQueryBuilder) WhereRaw(conds ...squirrel.Sqlizer) ChildQueryBuilder {
	for _, cond := range conds {
		qb.builder = qb.builder.Where(cond)
	}
	return qb
}

func (qb ChildQueryBuilder) Offset(offset uint64) ChildQueryBuilder {
	qb.builder = qb.builder.Offset(offset)
	return qb
}

func (qb ChildQueryBuilder) Limit(limit uint64) ChildQueryBuilder {
	qb.builder = qb.builder.Limit(limit)
	return qb
}

func (qb ChildQueryBuilder) OrderBy(orderBys ...ChildOrderExpr) ChildQueryBuilder {
	exprs := make([]string, len(orderBys))
	for i := range orderBys {
		exprs[i] = orderBys[i].ChildOrderExpr()
	}
	qb.builder = qb.builder.OrderBy(exprs...)
	return qb
}

func (qb ChildQueryBuilder) Count() (int64, error) {
	return qb.CountContext(context.Background())
}

func (qb ChildQueryBuilder) CountContext(ctx context.Context) (int64, error) {
	query, args, err := qb.builder.Columns("count(*)").ToSql()
	if err != nil {
		return 0, err
	}

	var count int64
	row := qb.dbc.QueryRowContext(ctx, query, args...)
	if err := row.Scan(&count); err != nil {
		return 0, err
	}
	return count, nil
}

func (qb ChildQueryBuilder) Query() ([]*Child, error) {
	return qb.QueryContext(context.Background())
}

func (qb ChildQueryBuilder) QueryContext(ctx context.Context) ([]*Child, error) {
	return qb.query(ctx)
}

func (qb ChildQueryBuilder) QueryRow() (*Child, error) {
	return qb.QueryRowContext(context.Background())
}

func (qb ChildQueryBuilder) QueryRowContext(ctx context.Context) (*Child, error) {
	qb.builder = qb.builder.Limit(1)
	if records, err := qb.query(ctx); err != nil {
		return nil, err
	} else if len(records) == 0 {
		return nil, sql.ErrNoRows
	} else {
		return records[0], nil
	}
}

func (qb ChildQueryBuilder) query(ctx context.Context) ([]*Child, error) {
	// for caching reason, wont support filtering columns
	metaT := metaSchema.LoadOf(&Child{})
	cols := make([]string, len(metaT.Columns()))
	for i := range metaT.Columns() {
		cols[i] = qb.dbc.Dialect().Quote(metaT.Columns()[i].ColumnName())
	}

	query, args, err := qb.builder.Columns(cols...).ToSql()
	if err != nil {
		return nil, err
	}
	rows, err := qb.dbc.QueryContext(ctx, query, args...)
	if err != nil {
		return nil, err
	}

	var records []*Child
	if err := qb.dbc.Scan(rows, &records); err != nil {
		rows.Close()
		return nil, err
	}
	rows.Close()

	sc := goen.NewScopeCache(metaSchema)
	for _, record := range records {
		sc.AddObject(record)
	}
	if err := qb.dbc.IncludeContext(ctx, records, sc, qb.includeLoaders); err != nil {
		return nil, err
	}

	return records, nil
}

// ToSqlizer returns Sqlizer that built by ChildQueryBuilder with given columns.
// The columns defaults to all columns of Child, if columns is zero-length.
func (qb ChildQueryBuilder) ToSqlizer(columns ...string) ChildSqlizer {
	if len(columns) == 0 {
		metaT := metaSchema.LoadOf(&Child{})
		columns = make([]string, len(metaT.Columns()))
		for i := range metaT.Columns() {
			columns[i] = qb.dbc.Dialect().Quote(metaT.Columns()[i].ColumnName())
		}
	}
	// only return, not to set qb.builder.
	return &_ChildSqlizer{qb.builder.Columns(columns...)}
}

type _Child_ChildID_OrderExpr string

func (s _Child_ChildID_OrderExpr) ChildOrderExpr() string {
	return string(s)
}

type _Child_ChildID struct {
	bs string
	qs string
}

// ChildColumnExpr implements _Child_ChildID_OrderExpr.
func (c _Child_ChildID) ChildColumnExpr() string {
	return c.QuotedString()
}

// String gets bare column name.
func (c _Child_ChildID) String() string {
	return c.bs
}

// QuotedString gets quoted column name.
func (c _Child_ChildID) QuotedString() string {
	return c.qs
}

func (c _Child_ChildID) Eq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_ChildID) NotEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_ChildID) In(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_ChildID) NotIn(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_ChildID) Like(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" LIKE ?", v)}
}

func (c _Child_ChildID) NotLike(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT LIKE ?", v)}
}

func (c _Child_ChildID) Lt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Lt{c.QuotedString(): v}}
}

func (c _Child_ChildID) LtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.LtOrEq{c.QuotedString(): v}}
}

func (c _Child_ChildID) Gt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Gt{c.QuotedString(): v}}
}

func (c _Child_ChildID) GtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.GtOrEq{c.QuotedString(): v}}
}

func (c _Child_ChildID) Between(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_ChildID) NotBetween(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_ChildID) Asc() ChildOrderExpr {
	return _Child_ChildID_OrderExpr(c.QuotedString())
}

func (c _Child_ChildID) Desc() ChildOrderExpr {
	return _Child_ChildID_OrderExpr(c.QuotedString() + " DESC")
}

type _Child_ParentID_OrderExpr string

func (s _Child_ParentID_OrderExpr) ChildOrderExpr() string {
	return string(s)
}

type _Child_ParentID struct {
	bs string
	qs string
}

// ChildColumnExpr implements _Child_ParentID_OrderExpr.
func (c _Child_ParentID) ChildColumnExpr() string {
	return c.QuotedString()
}

// String gets bare column name.
func (c _Child_ParentID) String() string {
	return c.bs
}

// QuotedString gets quoted column name.
func (c _Child_ParentID) QuotedString() string {
	return c.qs
}

func (c _Child_ParentID) Eq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_ParentID) NotEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_ParentID) In(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_ParentID) NotIn(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_ParentID) Like(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" LIKE ?", v)}
}

func (c _Child_ParentID) NotLike(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT LIKE ?", v)}
}

func (c _Child_ParentID) Lt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Lt{c.QuotedString(): v}}
}

func (c _Child_ParentID) LtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.LtOrEq{c.QuotedString(): v}}
}

func (c _Child_ParentID) Gt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Gt{c.QuotedString(): v}}
}

func (c _Child_ParentID) GtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.GtOrEq{c.QuotedString(): v}}
}

func (c _Child_ParentID) Between(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_ParentID) NotBetween(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_ParentID) Asc() ChildOrderExpr {
	return _Child_ParentID_OrderExpr(c.QuotedString())
}

func (c _Child_ParentID) Desc() ChildOrderExpr {
	return _Child_ParentID_OrderExpr(c.QuotedString() + " DESC")
}

type _Child_GroupID_OrderExpr string

func (s _Child_GroupID_OrderExpr) ChildOrderExpr() string {
	return string(s)
}

type _Child_GroupID struct {
	bs string
	qs string
}

// ChildColumnExpr implements _Child_GroupID_OrderExpr.
func (c _Child_GroupID) ChildColumnExpr() string {
	return c.QuotedString()
}

// String gets bare column name.
func (c _Child_GroupID) String() string {
	return c.bs
}

// QuotedString gets quoted column name.
func (c _Child_GroupID) QuotedString() string {
	return c.qs
}

func (c _Child_GroupID) Eq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_GroupID) NotEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_GroupID) In(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Child_GroupID) NotIn(v ...github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Child_GroupID) Like(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" LIKE ?", v)}
}

func (c _Child_GroupID) NotLike(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT LIKE ?", v)}
}

func (c _Child_GroupID) Lt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Lt{c.QuotedString(): v}}
}

func (c _Child_GroupID) LtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.LtOrEq{c.QuotedString(): v}}
}

func (c _Child_GroupID) Gt(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Gt{c.QuotedString(): v}}
}

func (c _Child_GroupID) GtOrEq(v github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.GtOrEq{c.QuotedString(): v}}
}

func (c _Child_GroupID) Between(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_GroupID) NotBetween(v1, v2 github_com_satori_go_uuid.UUID) ChildSqlizer {
	return &_ChildSqlizer{squirrel.Expr(c.QuotedString()+" NOT BETWEEN ? AND ?", v1, v2)}
}

func (c _Child_GroupID) Asc() ChildOrderExpr {
	return _Child_GroupID_OrderExpr(c.QuotedString())
}

func (c _Child_GroupID) Desc() ChildOrderExpr {
	return _Child_GroupID_OrderExpr(c.QuotedString() + " DESC")
}

type ChildDBSet struct {
	dbc *goen.DBContext

	ChildID  _Child_ChildID
	ParentID _Child_ParentID
	GroupID  _Child_GroupID

	IncludeParent goen.IncludeLoader
}

func newChildDBSet(dbc *goen.DBContext) *ChildDBSet {
	dbset := &ChildDBSet{
		dbc: dbc,
	}
	dbset.ChildID = _Child_ChildID{"child_id", dbc.Dialect().Quote("child_id")}
	dbset.ParentID = _Child_ParentID{"parent_id", dbc.Dialect().Quote("parent_id")}
	dbset.GroupID = _Child_GroupID{"group_id", dbc.Dialect().Quote("group_id")}

	dbset.IncludeParent = goen.IncludeLoaderFunc(dbset.includeParent)

	return dbset
}

// String gets bare table name
func (dbset *ChildDBSet) String() string {
	return "child"
}

// QuotedString gets quoted table name
func (dbset *ChildDBSet) QuotedString() string {
	return dbset.dbc.Dialect().Quote("child")
}

func (dbset *ChildDBSet) Insert(v *Child) {
	dbset.dbc.Patch(metaSchema.InsertPatchOf(v))
}

func (dbset *ChildDBSet) Select() ChildQueryBuilder {
	return newChildQueryBuilder(dbset.dbc)
}

func (dbset *ChildDBSet) Update(v *Child) {
	dbset.dbc.Patch(metaSchema.UpdatePatchOf(v))
}

func (dbset *ChildDBSet) Delete(v *Child) {
	dbset.dbc.Patch(metaSchema.DeletePatchOf(v))
}

func (dbset *ChildDBSet) includeParent(ctx context.Context, later *goen.IncludeBuffer, sc *goen.ScopeCache, records interface{}) error {
	entities, ok := records.([]*Child)
	if !ok {
		return nil
	}

	parentRowKeyOf := func(v *Child) goen.RowKey {
		return &goen.MapRowKey{
			Table: "parent",
			Key: map[string]interface{}{
				"parent_id": v.ParentID,
				"group_id":  v.GroupID,
			},
		}
	}

	// filter cached entity
	cachedChildRowKeys := make([]goen.RowKey, 0, len(entities))
	noCachedChildRowKeys := make([]goen.RowKey, 0, len(entities))
	for _, entity := range entities {
		key := parentRowKeyOf(entity)
		if sc.HasObject(goen.CardinalityManyToOne, key) {
			cachedChildRowKeys = append(cachedChildRowKeys, key)
		} else {
			noCachedChildRowKeys = append(noCachedChildRowKeys, key)
		}
	}
	if len(noCachedChildRowKeys) > 0 {
		cond := squirrel.Or{}
		for _, rowKey := range noCachedChildRowKeys {
			cond = append(cond, rowKey)
		}
		stmtBuilder := squirrel.StatementBuilder.PlaceholderFormat(dbset.dbc.Dialect().PlaceholderFormat())
		query, args, err := stmtBuilder.Select(
			dbset.dbc.Dialect().Quote("parent_id"),
			dbset.dbc.Dialect().Quote("group_id"),
		).From(dbset.dbc.Dialect().Quote("parent")).Where(cond).ToSql()
		if err != nil {
			return err
		}
		rows, err := dbset.dbc.QueryContext(ctx, query, args...)
		if err != nil {
			return err
		}

		var noCachedEntities []*Parent
		if err := dbset.dbc.Scan(rows, &noCachedEntities); err != nil {
			rows.Close()
			return err
		}
		rows.Close()

		for _, entity := range noCachedEntities {
			sc.AddObject(entity)
		}

		// for newly loaded entity, to be filled by includeLoader
		later.AddRecords(noCachedEntities)
	}

	for _, entity := range entities {
		parentRowKey := parentRowKeyOf(entity)
		raw := sc.GetObject(goen.CardinalityManyToOne, parentRowKey)
		if castover, ok := raw.(*Parent); ok {
			entity.Parent = castover
		}
	}

	return nil
}

func init() {
	metaSchema.Register(Parent{})
}

type ParentSqlizer interface {
	squirrel.Sqlizer

	ParentToSql() (string, []interface{}, error)
}

type _ParentSqlizer struct {
	squirrel.Sqlizer
}

func (sqlizer *_ParentSqlizer) ParentToSql() (string, []interface{}, error) {
	return sqlizer.ToSql()
}

type ParentColumnExpr interface {
	ParentColumnExpr() string

	String() string
}

type ParentOrderExpr interface {
	ParentOrderExpr() string
}

type ParentQueryBuilder struct {
	dbc *goen.DBContext

	includeLoaders goen.IncludeLoaderList

	builder squirrel.SelectBuilder
}

func newParentQueryBuilder(dbc *goen.DBContext) ParentQueryBuilder {
	stmtBuilder := squirrel.StatementBuilder.PlaceholderFormat(dbc.Dialect().PlaceholderFormat())
	metaT := metaSchema.LoadOf(&Parent{})
	return ParentQueryBuilder{
		dbc: dbc,
		// columns provided later
		builder: stmtBuilder.Select().From(dbc.Dialect().Quote(metaT.TableName())),
	}
}

func (qb ParentQueryBuilder) Include(loaders ...goen.IncludeLoader) ParentQueryBuilder {
	qb.includeLoaders.Append(loaders...)
	return qb
}

func (qb ParentQueryBuilder) Where(conds ...ParentSqlizer) ParentQueryBuilder {
	for _, cond := range conds {
		qb.builder = qb.builder.Where(cond)
	}
	return qb
}

func (qb ParentQueryBuilder) WhereRaw(conds ...squirrel.Sqlizer) ParentQueryBuilder {
	for _, cond := range conds {
		qb.builder = qb.builder.Where(cond)
	}
	return qb
}

func (qb ParentQueryBuilder) Offset(offset uint64) ParentQueryBuilder {
	qb.builder = qb.builder.Offset(offset)
	return qb
}

func (qb ParentQueryBuilder) Limit(limit uint64) ParentQueryBuilder {
	qb.builder = qb.builder.Limit(limit)
	return qb
}

func (qb ParentQueryBuilder) OrderBy(orderBys ...ParentOrderExpr) ParentQueryBuilder {
	exprs := make([]string, len(orderBys))
	for i := range orderBys {
		exprs[i] = orderBys[i].ParentOrderExpr()
	}
	qb.builder = qb.builder.OrderBy(exprs...)
	return qb
}

func (qb ParentQueryBuilder) Count() (int64, error) {
	return qb.CountContext(context.Background())
}

func (qb ParentQueryBuilder) CountContext(ctx context.Context) (int64, error) {
	query, args, err := qb.builder.Columns("count(*)").ToSql()
	if err != nil {
		return 0, err
	}

	var count int64
	row := qb.dbc.QueryRowContext(ctx, query, args...)
	if err := row.Scan(&count); err != nil {
		return 0, err
	}
	return count, nil
}

func (qb ParentQueryBuilder) Query() ([]*Parent, error) {
	return qb.QueryContext(context.Background())
}

func (qb ParentQueryBuilder) QueryContext(ctx context.Context) ([]*Parent, error) {
	return qb.query(ctx)
}

func (qb ParentQueryBuilder) QueryRow() (*Parent, error) {
	return qb.QueryRowContext(context.Background())
}

func (qb ParentQueryBuilder) QueryRowContext(ctx context.Context) (*Parent, error) {
	qb.builder = qb.builder.Limit(1)
	if records, err := qb.query(ctx); err != nil {
		return nil, err
	} else if len(records) == 0 {
		return nil, sql.ErrNoRows
	} else {
		return records[0], nil
	}
}

func (qb ParentQueryBuilder) query(ctx context.Context) ([]*Parent, error) {
	// for caching reason, wont support filtering columns
	metaT := metaSchema.LoadOf(&Parent{})
	cols := make([]string, len(metaT.Columns()))
	for i := range metaT.Columns() {
		cols[i] = qb.dbc.Dialect().Quote(metaT.Columns()[i].ColumnName())
	}

	query, args, err := qb.builder.Columns(cols...).ToSql()
	if err != nil {
		return nil, err
	}
	rows, err := qb.dbc.QueryContext(ctx, query, args...)
	if err != nil {
		return nil, err
	}

	var records []*Parent
	if err := qb.dbc.Scan(rows, &records); err != nil {
		rows.Close()
		return nil, err
	}
	rows.Close()

	sc := goen.NewScopeCache(metaSchema)
	for _, record := range records {
		sc.AddObject(record)
	}
	if err := qb.dbc.IncludeContext(ctx, records, sc, qb.includeLoaders); err != nil {
		return nil, err
	}

	return records, nil
}

// ToSqlizer returns Sqlizer that built by ParentQueryBuilder with given columns.
// The columns defaults to all columns of Parent, if columns is zero-length.
func (qb ParentQueryBuilder) ToSqlizer(columns ...string) ParentSqlizer {
	if len(columns) == 0 {
		metaT := metaSchema.LoadOf(&Parent{})
		columns = make([]string, len(metaT.Columns()))
		for i := range metaT.Columns() {
			columns[i] = qb.dbc.Dialect().Quote(metaT.Columns()[i].ColumnName())
		}
	}
	// only return, not to set qb.builder.
	return &_ParentSqlizer{qb.builder.Columns(columns...)}
}

type _Parent_ParentID_OrderExpr string

func (s _Parent_ParentID_OrderExpr) ParentOrderExpr() string {
	return string(s)
}

type _Parent_ParentID struct {
	bs string
	qs string
}

// ParentColumnExpr implements _Parent_ParentID_OrderExpr.
func (c _Parent_ParentID) ParentColumnExpr() string {
	return c.QuotedString()
}

// String gets bare column name.
func (c _Parent_ParentID) String() string {
	return c.bs
}

// QuotedString gets quoted column name.
func (c _Parent_ParentID) QuotedString() string {
	return c.qs
}

func (c _Parent_ParentID) Eq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) NotEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) In(v ...github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) NotIn(v ...github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) Like(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" LIKE ?", v)}
}

func (c _Parent_ParentID) NotLike(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" NOT LIKE ?", v)}
}

func (c _Parent_ParentID) Lt(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Lt{c.QuotedString(): v}}
}

func (c _Parent_ParentID) LtOrEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.LtOrEq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) Gt(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Gt{c.QuotedString(): v}}
}

func (c _Parent_ParentID) GtOrEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.GtOrEq{c.QuotedString(): v}}
}

func (c _Parent_ParentID) Between(v1, v2 github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" BETWEEN ? AND ?", v1, v2)}
}

func (c _Parent_ParentID) NotBetween(v1, v2 github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" NOT BETWEEN ? AND ?", v1, v2)}
}

func (c _Parent_ParentID) Asc() ParentOrderExpr {
	return _Parent_ParentID_OrderExpr(c.QuotedString())
}

func (c _Parent_ParentID) Desc() ParentOrderExpr {
	return _Parent_ParentID_OrderExpr(c.QuotedString() + " DESC")
}

type _Parent_GroupID_OrderExpr string

func (s _Parent_GroupID_OrderExpr) ParentOrderExpr() string {
	return string(s)
}

type _Parent_GroupID struct {
	bs string
	qs string
}

// ParentColumnExpr implements _Parent_GroupID_OrderExpr.
func (c _Parent_GroupID) ParentColumnExpr() string {
	return c.QuotedString()
}

// String gets bare column name.
func (c _Parent_GroupID) String() string {
	return c.bs
}

// QuotedString gets quoted column name.
func (c _Parent_GroupID) QuotedString() string {
	return c.qs
}

func (c _Parent_GroupID) Eq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) NotEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) In(v ...github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Eq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) NotIn(v ...github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.NotEq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) Like(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" LIKE ?", v)}
}

func (c _Parent_GroupID) NotLike(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" NOT LIKE ?", v)}
}

func (c _Parent_GroupID) Lt(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Lt{c.QuotedString(): v}}
}

func (c _Parent_GroupID) LtOrEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.LtOrEq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) Gt(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Gt{c.QuotedString(): v}}
}

func (c _Parent_GroupID) GtOrEq(v github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.GtOrEq{c.QuotedString(): v}}
}

func (c _Parent_GroupID) Between(v1, v2 github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" BETWEEN ? AND ?", v1, v2)}
}

func (c _Parent_GroupID) NotBetween(v1, v2 github_com_satori_go_uuid.UUID) ParentSqlizer {
	return &_ParentSqlizer{squirrel.Expr(c.QuotedString()+" NOT BETWEEN ? AND ?", v1, v2)}
}

func (c _Parent_GroupID) Asc() ParentOrderExpr {
	return _Parent_GroupID_OrderExpr(c.QuotedString())
}

func (c _Parent_GroupID) Desc() ParentOrderExpr {
	return _Parent_GroupID_OrderExpr(c.QuotedString() + " DESC")
}

type ParentDBSet struct {
	dbc *goen.DBContext

	ParentID _Parent_ParentID
	GroupID  _Parent_GroupID

	IncludeChildren goen.IncludeLoader
}

func newParentDBSet(dbc *goen.DBContext) *ParentDBSet {
	dbset := &ParentDBSet{
		dbc: dbc,
	}
	dbset.ParentID = _Parent_ParentID{"parent_id", dbc.Dialect().Quote("parent_id")}
	dbset.GroupID = _Parent_GroupID{"group_id", dbc.Dialect().Quote("group_id")}

	dbset.IncludeChildren = goen.IncludeLoaderFunc(dbset.includeChildren)

	return dbset
}

// String gets bare table name
func (dbset *ParentDBSet) String() string {
	return "parent"
}

// QuotedString gets quoted table name
func (dbset *ParentDBSet) QuotedString() string {
	return dbset.dbc.Dialect().Quote("parent")
}

func (dbset *ParentDBSet) Insert(v *Parent) {
	dbset.dbc.Patch(metaSchema.InsertPatchOf(v))
}

func (dbset *ParentDBSet) Select() ParentQueryBuilder {
	return newParentQueryBuilder(dbset.dbc)
}

func (dbset *ParentDBSet) Update(v *Parent) {
	dbset.dbc.Patch(metaSchema.UpdatePatchOf(v))
}

func (dbset *ParentDBSet) Delete(v *Parent) {
	dbset.dbc.Patch(metaSchema.DeletePatchOf(v))
}

func (dbset *ParentDBSet) includeChildren(ctx context.Context, later *goen.IncludeBuffer, sc *goen.ScopeCache, records interface{}) error {
	entities, ok := records.([]*Parent)
	if !ok {
		return nil
	}

	childRowKeyOf := func(v *Parent) goen.RowKey {
		return &goen.MapRowKey{
			Table: "child",
			Key: map[string]interface{}{
				"parent_id": v.ParentID,
				"group_id":  v.GroupID,
			},
		}
	}

	// filter cached entity
	cachedChildRowKeys := make([]goen.RowKey, 0, len(entities))
	noCachedChildRowKeys := make([]goen.RowKey, 0, len(entities))
	for _, entity := range entities {
		key := childRowKeyOf(entity)
		if sc.HasObject(goen.CardinalityOneToMany, key) {
			cachedChildRowKeys = append(cachedChildRowKeys, key)
		} else {
			noCachedChildRowKeys = append(noCachedChildRowKeys, key)
		}
	}
	if len(noCachedChildRowKeys) > 0 {
		cond := squirrel.Or{}
		for _, rowKey := range noCachedChildRowKeys {
			cond = append(cond, rowKey)
		}
		stmtBuilder := squirrel.StatementBuilder.PlaceholderFormat(dbset.dbc.Dialect().PlaceholderFormat())
		query, args, err := stmtBuilder.Select(
			dbset.dbc.Dialect().Quote("child_id"),
			dbset.dbc.Dialect().Quote("parent_id"),
			dbset.dbc.Dialect().Quote("group_id"),
		).From(dbset.dbc.Dialect().Quote("child")).Where(cond).ToSql()
		if err != nil {
			return err
		}
		rows, err := dbset.dbc.QueryContext(ctx, query, args...)
		if err != nil {
			return err
		}

		var noCachedEntities []*Child
		if err := dbset.dbc.Scan(rows, &noCachedEntities); err != nil {
			rows.Close()
			return err
		}
		rows.Close()

		for _, entity := range noCachedEntities {
			sc.AddObject(entity)
		}

		// for newly loaded entity, to be filled by includeLoader
		later.AddRecords(noCachedEntities)
	}

	for _, entity := range entities {
		childRowKey := childRowKeyOf(entity)
		raw := sc.GetObject(goen.CardinalityOneToMany, childRowKey)
		if refes, ok := raw.([]interface{}); ok {
			for _, refe := range refes {
				entity.Children = append(entity.Children, refe.(*Child))
			}
		}
	}

	return nil
}

type DBContext struct {
	*goen.DBContext

	Child *ChildDBSet

	Parent *ParentDBSet
}

func NewDBContext(dialectName string, db *sql.DB) *DBContext {
	dbc := goen.NewDBContext(dialectName, db)
	return &DBContext{
		DBContext: dbc,
		Child:     newChildDBSet(dbc),
		Parent:    newParentDBSet(dbc),
	}
}

func (dbc *DBContext) UseTx(tx *sql.Tx) *DBContext {
	clone := dbc.DBContext.UseTx(tx)
	return &DBContext{
		DBContext: clone,
		Child:     newChildDBSet(clone),
		Parent:    newParentDBSet(clone),
	}
}