storm

KO | EN

gitlite — search

#python #java #python3 #arduino #golang #machine-learning #rust #html #flask #javascript #seismology #nodejs

★ 27 Open GitHub ↗

STORM is Semantically Terse Object Relational Mapping for Go

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# STORM

STORM is Semantically Terse Object Relational Mapping for Go

## WARNING!

This software is NOT ready for production use. It is currently an experimental proof of concept. The
code is fragile, volatile and not reliable!

That said, please contribute your ideas and feedback!

## Getting Started

1. `go get github.com/brendensoares/storm`
2. `import "github.com/brendensoares/storm"`
3. Add `storm.Model` to a Go struct (e.g. `type ModelName struct {...}`)
4. Create a `func NewModelName() *ModelName` that returns `storm.Factory(&ModelName{}).(*ModelName)`
5. `import 	_ "github.com/brendensoares/storm/driver/mysql"`
6. `modelName := NewModelName()` and start using your new model!

## Roadmap Features By Example

### Map Database Schema To Models

STORM's object generator is important because it allows a developer to use the database schema as the
authority for the design of the models. You can consider the generator as a tool to create a schema cache
that would otherwise be done dynamically.

Data containers (e.g. SQL table) are mapped to Go Structs and container fields (e.g. SQL columns) are mapped
to struct fields on each generated struct.

To generate a cache of your MySQL database's schema, simply run:
`storm generate mysql -host localhost -user dbuser -p dbpass -name dbname`

From there, you can customize the object's definition as long as the meta data remains so that STORM can properly
translate object data to the database.

### Define Model Struct

A generated STORM model is composed of typical Go data types along with tag-based meta data. A model could look
something like this:

```go
type Post struct {
	storm.Model           `container:"posts" driver:"mysql"`

Id int64              `alias:"post_id"`
	Title string          `length:"100" nullable:"true"`
	TransientTitle string `ignore:"yes"`
	Content string        `type:"text"`

CreatedAt time.Time
	UpdateAt time.Time
	DeletedAt time.Time

Categories *Category  `relation:"hasMany" through:"categories_posts/post_id"`
	Comments *Comment     `relation:"hasMany" key:"post_id"`
	Author *Author        `relation:"belongsTo" key:"author_id"`
	ParentPost *Post      `relation:"hasOne" key:"parent_post_id"`
}

func NewPost() *Post {
	return storm.Factory(&Post{}).(*Post)
}
```

### Validate Fields

```go
func (self *Post)Validate() bool {
	if self.len(Content) < 10000 {
		return true
	}
	return false
}
```

### Create

```go
post := NewPost()
post.Title = "Hello, World!"
saveError := post.Save()
```

### Update

```go
if post.IsLoaded() {
	post.Title = "Hello, Earth!"
	if saveError := post.Save(); saveError == nil {
    // Do stuff!
	}
}
```

### Read

#### Single Object By Identifier

```go
post1 := NewPost()
// For numeric `Id`
post1.Get(1)
post2 := NewPost()
// For string `Id`
post2.Get("2")
```

#### Single Matching Object By Criteria

```go
post := NewPost()
post.Where("title", "like", "Hello%").And("title", "not like", "%earth%").Or("title").Get()
fmt.Println(post.Title)
```

#### Many Matching Objects By Criteria

```go
post := NewPost()
matchedPosts := post.Where("title", "like", "hello%").Limit(5).Order("title", "asc").All()
for _, post := range matchedPosts {
	fmt.Println(post.Title)
}
```

### Delete

#### Loaded Object

```go
post.Delete()
```

### Many Objects By Criteria

```go
NewPost().Has("author", commentAuthor).Delete()
```

### Relationships

#### Read

##### Lazy Load "hasMany"

```go
if post.Load("Categories") {
	categoryTitle := post.Categories[0].Title
}
if post.Load("Comments") {
	commentAuthor := post.Comments[0].Author.DisplayName
}
```

##### "hasOne"

```go
if post.ParentPost != nil {
	parentTitle := post.ParentPost.Title
}
```

##### "belongsTo"

```go
if post.Author != nil {
	authorName := post.Author.DisplayName
}
```

#### Add

##### "hasMany"

```go
category1 := NewCategory()
category1.Title = "Test Category 1"
category2 := NewCategory()
category2.Title = "Test Category 2"
categoryCountBefore := len(post.Categories)
addError := post.Add("Categories", category1, category2)
categoryCountAfter := len(post.Categories)
if addError != nil || categoryCountAfter - categoryCountBefore != 2 {
	// Something smells fishy.
}
```

##### "hasOne"

```go
author := NewAuthor()
author.DisplayName = "John Smith"
post.Author = author
```

##### "belongsTo"

```go
parentPost := NewPost()
parentPost.Get(20)
post.ParentPost = parentPost
```

#### Remove

##### "hasMany"

```go
category := NewCategory()
category.Get(10)
if removeError := post.Remove("Categories", category); removeError != nil {
	// Error...The game is afoot!
}
```

##### "hasOne"

```go
post.Author = nil
```

##### "belongsTo"

```go
post.ParentPost = nil
```

#### Trigger Events

##### Save

##### Delete

storm

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README