func (o *TwitterUser) UserTwitterTweets(exec boil.Executor, mods ...qm.QueryMod) twitterTweetQuery {
	var queryMods []qm.QueryMod
	if len(mods) != 0 {
		queryMods = append(queryMods, mods...)
	}
	queryMods = append(queryMods,
		qm.Where("\"twitter_tweets\".\"user_id\"=?", o.ID),
	)
	query := TwitterTweets(exec, queryMods...)
	queries.SetFrom(query.Query, "\"twitter_tweets\"")
	if len(queries.GetSelect(query.Query)) == 0 {
		queries.SetSelect(query.Query, []string{"\"twitter_tweets\".*"})
	}
	return query
}
UserTwitterTweets retrieves all the twitter_tweet's twitter tweets with an executor via user_id column.
package mdbmodels
import (
	"bytes"
	"database/sql"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"time"
	"github.com/Bnei-Baruch/sqlboiler/boil"
	"github.com/Bnei-Baruch/sqlboiler/queries"
	"github.com/Bnei-Baruch/sqlboiler/queries/qm"
	"github.com/Bnei-Baruch/sqlboiler/strmangle"
	"github.com/pkg/errors"
)
type TwitterUser struct {
	ID          int64  `boil:"id" json:"id" toml:"id" yaml:"id"`
	Username    string `boil:"username" json:"username" toml:"username" yaml:"username"`
	AccountID   string `boil:"account_id" json:"account_id" toml:"account_id" yaml:"account_id"`
	DisplayName string `boil:"display_name" json:"display_name" toml:"display_name" yaml:"display_name"`
	R *twitterUserR `boil:"-" json:"-" toml:"-" yaml:"-"`
	L twitterUserL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}
var TwitterUserColumns = struct {
	ID          string
	Username    string
	AccountID   string
	DisplayName string
}{
	ID:          "id",
	Username:    "username",
	AccountID:   "account_id",
	DisplayName: "display_name",
}
type twitterUserR struct {
	UserTwitterTweets TwitterTweetSlice
}
type twitterUserL struct{}
var (
	twitterUserColumns               = []string{"id", "username", "account_id", "display_name"}
	twitterUserColumnsWithoutDefault = []string{"username", "account_id", "display_name"}
	twitterUserColumnsWithDefault    = []string{"id"}
	twitterUserPrimaryKeyColumns     = []string{"id"}
)
type (
	TwitterUserSlice []*TwitterUser
	twitterUserQuery struct {
		*queries.Query
	}
)
var (
	twitterUserType                 = reflect.TypeOf(&TwitterUser{})
	twitterUserMapping              = queries.MakeStructMapping(twitterUserType)
	twitterUserPrimaryKeyMapping, _ = queries.BindMapping(twitterUserType, twitterUserMapping, twitterUserPrimaryKeyColumns)
	twitterUserInsertCacheMut       sync.RWMutex
	twitterUserInsertCache          = make(map[string]insertCache)
	twitterUserUpdateCacheMut       sync.RWMutex
	twitterUserUpdateCache          = make(map[string]updateCache)
	twitterUserUpsertCacheMut       sync.RWMutex
	twitterUserUpsertCache          = make(map[string]insertCache)
)
var (
	_ = time.Second
	_ = bytes.MinRead
)
func (q twitterUserQuery) OneP() *TwitterUser {
	o, err := q.One()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q twitterUserQuery) One() (*TwitterUser, error) {
	o := &TwitterUser{}
	queries.SetLimit(q.Query, 1)
	err := q.Bind(o)
	if err != nil {
		if errors.Cause(err) == sql.ErrNoRows {
			return nil, sql.ErrNoRows
		}
		return nil, errors.Wrap(err, "mdbmodels: failed to execute a one query for twitter_users")
	}
	return o, nil
}
func (q twitterUserQuery) AllP() TwitterUserSlice {
	o, err := q.All()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return o
}
func (q twitterUserQuery) All() (TwitterUserSlice, error) {
	var o []*TwitterUser
	err := q.Bind(&o)
	if err != nil {
		return nil, errors.Wrap(err, "mdbmodels: failed to assign all query results to TwitterUser slice")
	}
	return o, nil
}
func (q twitterUserQuery) CountP() int64 {
	c, err := q.Count()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return c
}
func (q twitterUserQuery) Count() (int64, error) {
	var count int64
	queries.SetSelect(q.Query, nil)
	queries.SetCount(q.Query)
	err := q.Query.QueryRow().Scan(&count)
	if err != nil {
		return 0, errors.Wrap(err, "mdbmodels: failed to count twitter_users rows")
	}
	return count, nil
}
func (q twitterUserQuery) ExistsP() bool {
	e, err := q.Exists()
	if err != nil {
		panic(boil.WrapErr(err))
	}
	return e
}
func (q twitterUserQuery) Exists() (bool, error) {
	var count int64
	queries.SetCount(q.Query)
	queries.SetLimit(q.Query, 1)
	err := q.Query.QueryRow().Scan(&count)
	if err != nil {
		return false, errors.Wrap(err, "mdbmodels: failed to check if twitter_users exists")
	}
	return count > 0, nil
}
func (o *TwitterUser) UserTwitterTweetsG(mods ...qm.QueryMod) twitterTweetQuery {
	return o.UserTwitterTweets(boil.GetDB(), mods...)
}