example

package
v0.0.10 Latest Latest
Warning

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

 Go to latest Published: Jan 31, 2020 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Example 
dbc := NewDBContext(prepareDB())
dbc.DebugMode(true)

src := []*Blog{
	&Blog{
		BlogID: uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828")),
		Name:   "testing1",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("b95e5d4d-7eb9-4612-882d-224daa4a59ee")),
		Name:   "testing2",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("22f931c8-ac87-4520-88e8-83fc0604b8f5")),
		Name:   "testing3",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("065c6554-9aff-4b42-ab3b-141ed5ef5624")),
		Name:   "testing4",
		Author: "kamichidu",
	},
}
for _, blog := range src {
	dbc.Blog.Insert(blog)
}
func(blog *Blog) {
	now, err := time.Parse(time.RFC3339, "2018-06-01T12:00:00Z")
	if err != nil {
		panic(err)
	}
	dbc.Post.Insert(&Post{
		BlogID:  blog.BlogID,
		Title:   "titleA",
		Content: "contentA",
		Timestamp: Timestamp{
			CreatedAt: now,
			UpdatedAt: now,
		},
	})
	dbc.Post.Insert(&Post{
		BlogID:  blog.BlogID,
		Title:   "titleB",
		Content: "contentB",
		Timestamp: Timestamp{
			CreatedAt: now,
			UpdatedAt: now,
		},
	})
}(src[0])
src[1].Author = "unknown"
dbc.Blog.Update(src[1])
dbc.Blog.Delete(src[2])
src[3].Name = "updating"
dbc.Blog.Update(src[3])
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}

// counting all records
numBlogs, err := dbc.Blog.Select().Count()
if err != nil {
	panic(err)
}
fmt.Printf("all blogs = %d\n", numBlogs)

// querying with conditions
blogs, err := dbc.Blog.Select().
	Include(dbc.Blog.IncludePosts, dbc.Post.IncludeBlog).
	Where(dbc.Blog.Name.Like(`%testing%`)).
	OrderBy(dbc.Blog.Name.Asc()).
	Query()
if err != nil {
	panic(err)
}
fmt.Printf("found blogs = %d\n", len(blogs))
spew.Config.SortKeys = true
spew.Config.MaxDepth = 1
for _, blog := range blogs {
	spew.Printf("%#v\n", blog)

	for _, post := range blog.Posts {
		spew.Printf("- %#v\n", post)
		spew.Printf("  CreatedAt:%q\n", post.Timestamp.CreatedAt.Format(time.RFC3339))
		spew.Printf("  UpdatedAt:%q\n", post.Timestamp.UpdatedAt.Format(time.RFC3339))
		if post.DeletedAt != nil {
			spew.Printf("  DeletedAt:%q\n", post.DeletedAt.Format(time.RFC3339))
		} else {
			spew.Print("  DeletedAt:nil\n")
		}
	}
}

Output:
all blogs = 3
found blogs = 2
(*example.Blog){BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 Name:(string)testing1 Author:(string)kamichidu Posts:([]*example.Post)[<max>]}
- (*example.Post){Timestamp:(example.Timestamp){<max>} BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 PostID:(int)1 Title:(string)titleA Content:(string)contentA Order:(int)0 Blog:(*example.Blog){<max>}}
  CreatedAt:"2018-06-01T12:00:00Z"
  UpdatedAt:"2018-06-01T12:00:00Z"
  DeletedAt:nil
- (*example.Post){Timestamp:(example.Timestamp){<max>} BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 PostID:(int)2 Title:(string)titleB Content:(string)contentB Order:(int)0 Blog:(*example.Blog){<max>}}
  CreatedAt:"2018-06-01T12:00:00Z"
  UpdatedAt:"2018-06-01T12:00:00Z"
  DeletedAt:nil
(*example.Blog){BlogID:(uuid.UUID)b95e5d4d-7eb9-4612-882d-224daa4a59ee Name:(string)testing2 Author:(string)unknown Posts:([]*example.Post)<nil>}
Example (BrokenManyToOneRelationWithNonForeignKey) 
dbc := NewDBContext(prepareDB())
dropForeignKeys(dbc.DB)

validBlogID := uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828"))
invalidBlogID := uuid.Must(uuid.FromString("0c816298-1d35-4948-870a-6f7b5bba14d3"))
dbc.Blog.Insert(&Blog{
	BlogID: validBlogID,
	Name:   "the blog",
})
dbc.Post.Insert(&Post{
	BlogID: validBlogID,
	Title:  "0 the valid post",
	Timestamp: Timestamp{
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	},
})
dbc.Post.Insert(&Post{
	BlogID: invalidBlogID,
	Title:  "1 the invalid post",
	Timestamp: Timestamp{
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	},
})
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}

posts, err := dbc.Post.Select().
	Include(dbc.Post.IncludeBlog).
	OrderBy(dbc.Post.Title.Asc()).
	Query()
if err != nil {
	panic(err)
}
for _, post := range posts {
	var blogName string
	if post.Blog != nil {
		blogName = post.Blog.Name
	} else {
		blogName = "<nil>"
	}
	fmt.Printf("%q with related blog %q\n", post.Title, blogName)
}

Output:
"0 the valid post" with related blog "the blog"
"1 the invalid post" with related blog "<nil>"
Example (Count) 
dbc := NewDBContext(prepareDB())
dbc.DebugMode(true)

for i := 0; i < 11; i++ {
	dbc.Blog.Insert(&Blog{
		BlogID: uuid.Must(uuid.NewV4()),
		Name:   fmt.Sprintf("name-%d", i),
		Author: "kamichidu",
	})
}

dbc.Compiler = goen.BulkCompiler
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}

// counting a record with conditions
count, err := dbc.Blog.Select().
	Where(dbc.Blog.Name.In(
		`name-3`,
		`name-4`,
		`name-5`,
		`name-6`,
		`name-7`,
	)).
	Count()
if err != nil {
	panic(err)
}
fmt.Printf("count = %d\n", count)

Output:
count = 5
Example (CustomDelete) 
dbc := NewDBContext(prepareDB())

// expect `delete from posts where blog_id = ?`
dbc.Patch(goen.DeletePatch(
	dbc.Post.String(),
	&goen.MapRowKey{
		Table: dbc.Post.String(),
		Key: map[string]interface{}{
			dbc.Post.BlogID.String(): uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828")),
		},
	}))
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}
Example (GeneratedSchemaFields) 
dbc := NewDBContext(dialectName, nil)

// can get quoted names
fmt.Printf("dbc.Blog = %s / %s\n", dbc.Blog, unifyQuery(dbc.Blog.QuotedString()))
fmt.Printf("dbc.Blog.BlogID = %s / %s\n", dbc.Blog.BlogID, unifyQuery(dbc.Blog.BlogID.QuotedString()))
fmt.Printf("dbc.Blog.Name = %s / %s\n", dbc.Blog.Name, unifyQuery(dbc.Blog.Name.QuotedString()))
fmt.Printf("dbc.Blog.Author = %s / %s\n", dbc.Blog.Author, unifyQuery(dbc.Blog.Author.QuotedString()))

Output:
dbc.Blog = blogs / `blogs`
dbc.Blog.BlogID = blog_id / `blog_id`
dbc.Blog.Name = name / `name`
dbc.Blog.Author = author / `author`
Example (NullableColumn) 
dbc := NewDBContext(prepareDB())
dbc.DebugMode(true)

blogID := uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828"))
dbc.Blog.Insert(&Blog{
	BlogID: blogID,
	Name:   "nullable",
	Author: "kamichidu",
})
now, err := time.Parse(time.RFC3339, "2018-08-09T13:48:29Z")
if err != nil {
	panic(err)
}
dbc.Post.Insert(&Post{
	BlogID: blogID,
	Title:  "p1",
	Timestamp: Timestamp{
		CreatedAt: now,
		UpdatedAt: now,
		DeletedAt: &now,
	},
})
dbc.Post.Insert(&Post{
	BlogID: blogID,
	Title:  "p2",
	Timestamp: Timestamp{
		CreatedAt: now,
		UpdatedAt: now,
		DeletedAt: nil,
	},
})
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}

fmt.Println("print all rows")
posts, err := dbc.Post.Select().
	OrderBy(dbc.Post.Title.Asc()).
	Query()
if err != nil {
	panic(err)
}
for _, post := range posts {
	if post.DeletedAt != nil {
		fmt.Printf("%q > DeletedAt = %q\n", post.Title, post.DeletedAt.Format(time.RFC3339))
	} else {
		fmt.Printf("%q > DeletedAt = nil\n", post.Title)
	}
}

fmt.Println("print filtered rows that deleted at is null")
posts, err = dbc.Post.Select().
	Where(dbc.Post.DeletedAt.Eq(nil)).
	OrderBy(dbc.Post.Title.Asc()).
	Query()
if err != nil {
	panic(err)
}
for _, post := range posts {
	if post.DeletedAt != nil {
		fmt.Printf("%q > DeletedAt = %q\n", post.Title, post.DeletedAt.Format(time.RFC3339))
	} else {
		fmt.Printf("%q > DeletedAt = nil\n", post.Title)
	}
}

Output:
print all rows
"p1" > DeletedAt = "2018-08-09T13:48:29Z"
"p2" > DeletedAt = nil
print filtered rows that deleted at is null
"p2" > DeletedAt = nil
Example (QueryBuilderAsSqlizer) 
dbc := NewDBContext(prepareDB())

query, args, err := dbc.Blog.Select().
	Where(dbc.Blog.Author.Eq("kamichidu")).
	ToSqlizer(dbc.Blog.BlogID.QuotedString()).
	ToSql()
if err != nil {
	panic(err)
}
// for stable output
query = unifyQuery(query)
fmt.Printf("%q\n", query)
fmt.Printf("%q\n", args)

Output:
"SELECT `blog_id` FROM `blogs` WHERE `author` = ?"
["kamichidu"]
Example (QueryRow) 
dbc := NewDBContext(prepareDB())
dbc.DebugMode(true)

src := []*Blog{
	&Blog{
		BlogID: uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828")),
		Name:   "testing1",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("b95e5d4d-7eb9-4612-882d-224daa4a59ee")),
		Name:   "testing2",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("22f931c8-ac87-4520-88e8-83fc0604b8f5")),
		Name:   "testing3",
		Author: "kamichidu",
	},
	&Blog{
		BlogID: uuid.Must(uuid.FromString("065c6554-9aff-4b42-ab3b-141ed5ef5624")),
		Name:   "testing4",
		Author: "kamichidu",
	},
}
for _, blog := range src {
	dbc.Blog.Insert(blog)
}
func(blog *Blog) {
	now, err := time.Parse(time.RFC3339, "2018-06-01T12:00:00Z")
	if err != nil {
		panic(err)
	}
	dbc.Post.Insert(&Post{
		BlogID:  blog.BlogID,
		Title:   "titleA",
		Content: "contentA",
		Timestamp: Timestamp{
			CreatedAt: now,
			UpdatedAt: now,
		},
	})
	dbc.Post.Insert(&Post{
		BlogID:  blog.BlogID,
		Title:   "titleB",
		Content: "contentB",
		Timestamp: Timestamp{
			CreatedAt: now,
			UpdatedAt: now,
		},
	})
}(src[0])
if err := dbc.SaveChanges(); err != nil {
	panic(err)
}

// when a record was not found, will get sql.ErrNoRows
_, err := dbc.Blog.Select().
	Where(dbc.Blog.Author.Eq("non-exists-author")).
	QueryRow()
if err == sql.ErrNoRows {
	fmt.Print("QueryRow returns sql.ErrNoRows when a record was not found.\n")
}

// querying a record with conditions
blog, err := dbc.Blog.Select().
	Include(dbc.Blog.IncludePosts, dbc.Post.IncludeBlog).
	Where(dbc.Blog.Name.Eq(`testing1`)).
	QueryRow()
if err != nil {
	panic(err)
}
spew.Config.SortKeys = true
spew.Config.MaxDepth = 1
spew.Printf("%#v\n", blog)
for _, post := range blog.Posts {
	spew.Printf("- %#v\n", post)
	spew.Printf("  CreatedAt:%q\n", post.Timestamp.CreatedAt.Format(time.RFC3339))
	spew.Printf("  UpdatedAt:%q\n", post.Timestamp.UpdatedAt.Format(time.RFC3339))
}

Output:
QueryRow returns sql.ErrNoRows when a record was not found.
(*example.Blog){BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 Name:(string)testing1 Author:(string)kamichidu Posts:([]*example.Post)[<max>]}
- (*example.Post){Timestamp:(example.Timestamp){<max>} BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 PostID:(int)1 Title:(string)titleA Content:(string)contentA Order:(int)0 Blog:(*example.Blog){<max>}}
  CreatedAt:"2018-06-01T12:00:00Z"
  UpdatedAt:"2018-06-01T12:00:00Z"
- (*example.Post){Timestamp:(example.Timestamp){<max>} BlogID:(uuid.UUID)d03bc237-eef4-4b6f-afe1-ea901357d828 PostID:(int)2 Title:(string)titleB Content:(string)contentB Order:(int)0 Blog:(*example.Blog){<max>}}
  CreatedAt:"2018-06-01T12:00:00Z"
  UpdatedAt:"2018-06-01T12:00:00Z"
Example (Transaction) 
dbc := NewDBContext(prepareDB())
dbc.DebugMode(true)

tx, err := dbc.DB.Begin()
if err != nil {
	panic(err)
}

txc := dbc.UseTx(tx)
blogID := uuid.Must(uuid.FromString("d03bc237-eef4-4b6f-afe1-ea901357d828"))
txc.Blog.Insert(&Blog{
	BlogID: blogID,
	Name:   "tx",
	Author: "kamichidu",
})
if err := txc.SaveChanges(); err != nil {
	panic(err)
}

n, err := dbc.Blog.Select().
	Where(dbc.Blog.BlogID.Eq(blogID)).
	Count()
if err != nil {
	panic(err)
}
fmt.Printf("dbc founds %d blogs when not committed yet\n", n)

n, err = txc.Blog.Select().
	Where(dbc.Blog.BlogID.Eq(blogID)).
	Count()
if err != nil {
	panic(err)
}
fmt.Printf("txc founds %d blogs when not committed yet since it's in same transaction\n", n)

if err := tx.Commit(); err != nil {
	panic(err)
}

n, err = dbc.Blog.Select().
	Where(dbc.Blog.BlogID.Eq(blogID)).
	Count()
if err != nil {
	panic(err)
}
fmt.Printf("dbc founds %d blogs after committed\n", n)

Output:
dbc founds 0 blogs when not committed yet
txc founds 1 blogs when not committed yet since it's in same transaction
dbc founds 1 blogs after committed

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Blog 

type Blog struct {
	BlogID uuid.UUID `goen:"" table:"blogs" primary_key:""`

	Name string

	Author string

	Posts []*Post `foreign_key:"blog_id"`
}

type BlogColumnExpr 

type BlogColumnExpr interface {
	BlogColumnExpr() string

	String() string
}

type BlogDBSet 

type BlogDBSet struct {
	BlogID _Blog_BlogID
	Name   _Blog_Name
	Author _Blog_Author

	IncludePosts goen.IncludeLoader
	// contains filtered or unexported fields
}

func (*BlogDBSet) Delete 

func (dbset *BlogDBSet) Delete(v *Blog)

func (*BlogDBSet) Insert 

func (dbset *BlogDBSet) Insert(v *Blog)

func (*BlogDBSet) QuotedString added in v0.0.3 

func (dbset *BlogDBSet) QuotedString() string

QuotedString gets quoted table name

func (*BlogDBSet) Select 

func (dbset *BlogDBSet) Select() BlogQueryBuilder

func (*BlogDBSet) String 

func (dbset *BlogDBSet) String() string

String gets bare table name

func (*BlogDBSet) Update 

func (dbset *BlogDBSet) Update(v *Blog)

type BlogOrderExpr 

type BlogOrderExpr interface {
	BlogOrderExpr() string
}

type BlogQueryBuilder 

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

func (BlogQueryBuilder) Count 

func (qb BlogQueryBuilder) Count() (int64, error)

func (BlogQueryBuilder) CountContext 

func (qb BlogQueryBuilder) CountContext(ctx context.Context) (int64, error)

func (BlogQueryBuilder) Include 

func (qb BlogQueryBuilder) Include(loaders ...goen.IncludeLoader) BlogQueryBuilder

func (BlogQueryBuilder) Limit 

func (qb BlogQueryBuilder) Limit(limit uint64) BlogQueryBuilder

func (BlogQueryBuilder) Offset 

func (qb BlogQueryBuilder) Offset(offset uint64) BlogQueryBuilder

func (BlogQueryBuilder) OrderBy 

func (qb BlogQueryBuilder) OrderBy(orderBys ...BlogOrderExpr) BlogQueryBuilder

func (BlogQueryBuilder) Query 

func (qb BlogQueryBuilder) Query() ([]*Blog, error)

func (BlogQueryBuilder) QueryContext 

func (qb BlogQueryBuilder) QueryContext(ctx context.Context) ([]*Blog, error)

func (BlogQueryBuilder) QueryRow 

func (qb BlogQueryBuilder) QueryRow() (*Blog, error)

func (BlogQueryBuilder) QueryRowContext 

func (qb BlogQueryBuilder) QueryRowContext(ctx context.Context) (*Blog, error)

func (BlogQueryBuilder) ToSqlizer added in v0.0.1 

func (qb BlogQueryBuilder) ToSqlizer(columns ...string) BlogSqlizer

ToSqlizer returns Sqlizer that built by BlogQueryBuilder with given columns. The columns defaults to all columns of Blog, if columns is zero-length.

func (BlogQueryBuilder) Where 

func (qb BlogQueryBuilder) Where(conds ...BlogSqlizer) BlogQueryBuilder

func (BlogQueryBuilder) WhereRaw 

func (qb BlogQueryBuilder) WhereRaw(conds ...squirrel.Sqlizer) BlogQueryBuilder

type BlogSqlizer 

type BlogSqlizer interface {
	squirrel.Sqlizer

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

type DBContext 

type DBContext struct {
	*goen.DBContext

	Blog *BlogDBSet

	Post *PostDBSet
}

func NewDBContext 

func NewDBContext(dialectName string, db *sql.DB) *DBContext

func (*DBContext) UseTx 

func (dbc *DBContext) UseTx(tx *sql.Tx) *DBContext

type Post 

type Post struct {
	Timestamp

	BlogID uuid.UUID `goen:"" table:"posts"`

	PostID int `primary_key:",omitempty"`

	Title string

	Content string

	// "order" is a sql keyword
	Order int

	Blog *Blog `foreign_key:"blog_id"`
}

type PostColumnExpr 

type PostColumnExpr interface {
	PostColumnExpr() string

	String() string
}

type PostDBSet 

type PostDBSet struct {
	CreatedAt _Post_CreatedAt
	UpdatedAt _Post_UpdatedAt
	DeletedAt _Post_DeletedAt
	BlogID    _Post_BlogID
	PostID    _Post_PostID
	Title     _Post_Title
	Content   _Post_Content
	Order     _Post_Order

	IncludeBlog goen.IncludeLoader
	// contains filtered or unexported fields
}

func (*PostDBSet) Delete 

func (dbset *PostDBSet) Delete(v *Post)

func (*PostDBSet) Insert 

func (dbset *PostDBSet) Insert(v *Post)

func (*PostDBSet) QuotedString added in v0.0.3 

func (dbset *PostDBSet) QuotedString() string

QuotedString gets quoted table name

func (*PostDBSet) Select 

func (dbset *PostDBSet) Select() PostQueryBuilder

func (*PostDBSet) String 

func (dbset *PostDBSet) String() string

String gets bare table name

func (*PostDBSet) Update 

func (dbset *PostDBSet) Update(v *Post)

type PostOrderExpr 

type PostOrderExpr interface {
	PostOrderExpr() string
}

type PostQueryBuilder 

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

func (PostQueryBuilder) Count 

func (qb PostQueryBuilder) Count() (int64, error)

func (PostQueryBuilder) CountContext 

func (qb PostQueryBuilder) CountContext(ctx context.Context) (int64, error)

func (PostQueryBuilder) Include 

func (qb PostQueryBuilder) Include(loaders ...goen.IncludeLoader) PostQueryBuilder

func (PostQueryBuilder) Limit 

func (qb PostQueryBuilder) Limit(limit uint64) PostQueryBuilder

func (PostQueryBuilder) Offset 

func (qb PostQueryBuilder) Offset(offset uint64) PostQueryBuilder

func (PostQueryBuilder) OrderBy 

func (qb PostQueryBuilder) OrderBy(orderBys ...PostOrderExpr) PostQueryBuilder

func (PostQueryBuilder) Query 

func (qb PostQueryBuilder) Query() ([]*Post, error)

func (PostQueryBuilder) QueryContext 

func (qb PostQueryBuilder) QueryContext(ctx context.Context) ([]*Post, error)

func (PostQueryBuilder) QueryRow 

func (qb PostQueryBuilder) QueryRow() (*Post, error)

func (PostQueryBuilder) QueryRowContext 

func (qb PostQueryBuilder) QueryRowContext(ctx context.Context) (*Post, error)

func (PostQueryBuilder) ToSqlizer added in v0.0.1 

func (qb PostQueryBuilder) ToSqlizer(columns ...string) PostSqlizer

ToSqlizer returns Sqlizer that built by PostQueryBuilder with given columns. The columns defaults to all columns of Post, if columns is zero-length.

func (PostQueryBuilder) Where 

func (qb PostQueryBuilder) Where(conds ...PostSqlizer) PostQueryBuilder

func (PostQueryBuilder) WhereRaw 

func (qb PostQueryBuilder) WhereRaw(conds ...squirrel.Sqlizer) PostQueryBuilder

type PostSqlizer 

type PostSqlizer interface {
	squirrel.Sqlizer

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

type Timestamp 

type Timestamp struct {
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt *time.Time
}

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.