README ¶
GORM Data Types
JSON
sqlite, mysql, postgres supported
import "github.com/wubin1989/datatypes"
type UserWithJSON struct {
gorm.Model
Name string
Attributes datatypes.JSON
}
DB.Create(&UserWithJSON{
Name: "json-1",
Attributes: datatypes.JSON([]byte(`{"name": "jinzhu", "age": 18, "tags": ["tag1", "tag2"], "orgs": {"orga": "orga"}}`)),
}
// Check JSON has keys
datatypes.JSONQuery("attributes").HasKey(value, keys...)
db.Find(&user, datatypes.JSONQuery("attributes").HasKey("role"))
db.Find(&user, datatypes.JSONQuery("attributes").HasKey("orgs", "orga"))
// MySQL
// SELECT * FROM `users` WHERE JSON_EXTRACT(`attributes`, '$.role') IS NOT NULL
// SELECT * FROM `users` WHERE JSON_EXTRACT(`attributes`, '$.orgs.orga') IS NOT NULL
// PostgreSQL
// SELECT * FROM "user" WHERE "attributes"::jsonb ? 'role'
// SELECT * FROM "user" WHERE "attributes"::jsonb -> 'orgs' ? 'orga'
// Check JSON extract value from keys equal to value
datatypes.JSONQuery("attributes").Equals(value, keys...)
DB.First(&user, datatypes.JSONQuery("attributes").Equals("jinzhu", "name"))
DB.First(&user, datatypes.JSONQuery("attributes").Equals("orgb", "orgs", "orgb"))
// MySQL
// SELECT * FROM `user` WHERE JSON_EXTRACT(`attributes`, '$.name') = "jinzhu"
// SELECT * FROM `user` WHERE JSON_EXTRACT(`attributes`, '$.orgs.orgb') = "orgb"
// PostgreSQL
// SELECT * FROM "user" WHERE json_extract_path_text("attributes"::json,'name') = 'jinzhu'
// SELECT * FROM "user" WHERE json_extract_path_text("attributes"::json,'orgs','orgb') = 'orgb'
NOTE: SQlite need to build with json1
tag, e.g: go build --tags json1
, refer https://github.com/mattn/go-sqlite3#usage
Date
import "github.com/wubin1989/datatypes"
type UserWithDate struct {
gorm.Model
Name string
Date datatypes.Date
}
user := UserWithDate{Name: "jinzhu", Date: datatypes.Date(time.Now())}
DB.Create(&user)
// INSERT INTO `user_with_dates` (`name`,`date`) VALUES ("jinzhu","2020-07-17 00:00:00")
DB.First(&result, "name = ? AND date = ?", "jinzhu", datatypes.Date(curTime))
// SELECT * FROM user_with_dates WHERE name = "jinzhu" AND date = "2020-07-17 00:00:00" ORDER BY `user_with_dates`.`id` LIMIT 1
Time
MySQL, PostgreSQL, SQLite, SQLServer are supported.
Time with nanoseconds is supported for some databases which support for time with fractional second scale.
import "github.com/wubin1989/datatypes"
type UserWithTime struct {
gorm.Model
Name string
Time datatypes.Time
}
user := UserWithTime{Name: "jinzhu", Time: datatypes.NewTime(1, 2, 3, 0)}
DB.Create(&user)
// INSERT INTO `user_with_times` (`name`,`time`) VALUES ("jinzhu","01:02:03")
DB.First(&result, "name = ? AND time = ?", "jinzhu", datatypes.NewTime(1, 2, 3, 0))
// SELECT * FROM user_with_times WHERE name = "jinzhu" AND time = "01:02:03" ORDER BY `user_with_times`.`id` LIMIT 1
NOTE: If the current using database is SQLite, the field column type is defined as TEXT
type
when GORM AutoMigrate because SQLite doesn't have time type.
JSON_SET
sqlite, mysql, postgres supported
import (
"github.com/wubin1989/datatypes"
"github.com/wubin1989/gorm"
)
type UserWithJSON struct {
gorm.Model
Name string
Attributes datatypes.JSON
}
DB.Create(&UserWithJSON{
Name: "json-1",
Attributes: datatypes.JSON([]byte(`{"name": "json-1", "age": 18, "tags": ["tag1", "tag2"], "orgs": {"orga": "orga"}}`)),
})
type User struct {
Name string
Age int
}
friend := User{
Name: "Bob",
Age: 21,
}
// Set fields of JSON column
datatypes.JSONSet("attributes").Set("age", 20).Set("tags[0]", "tag2").Set("orgs.orga", "orgb")
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("age", 20).Set("tags[0]", "tag3").Set("orgs.orga", "orgb"))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("phones", []string{"10085", "10086"}))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("phones", gorm.Expr("CAST(? AS JSON)", `["10085", "10086"]`)))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("friend", friend))
// MySQL
// UPDATE `user_with_jsons` SET `attributes` = JSON_SET(`attributes`, '$.tags[0]', 'tag3', '$.orgs.orga', 'orgb', '$.age', 20) WHERE name = 'json-1'
// UPDATE `user_with_jsons` SET `attributes` = JSON_SET(`attributes`, '$.phones', CAST('["10085", "10086"]' AS JSON)) WHERE name = 'json-1'
// UPDATE `user_with_jsons` SET `attributes` = JSON_SET(`attributes`, '$.phones', CAST('["10085", "10086"]' AS JSON)) WHERE name = 'json-1'
// UPDATE `user_with_jsons` SET `attributes` = JSON_SET(`attributes`, '$.friend', CAST('{"Name": "Bob", "Age": 21}' AS JSON)) WHERE name = 'json-1'
NOTE: MariaDB does not support CAST(? AS JSON).
NOTE: Path in PostgreSQL is different.
// Set fields of JSON column
datatypes.JSONSet("attributes").Set("{age}", 20).Set("{tags, 0}", "tag2").Set("{orgs, orga}", "orgb")
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("{age}", 20).Set("{tags, 0}", "tag2").Set("{orgs, orga}", "orgb"))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("{phones}", []string{"10085", "10086"}))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("{phones}", gorm.Expr("?::jsonb", `["10085", "10086"]`)))
DB.Model(&UserWithJSON{}).Where("name = ?", "json-1").UpdateColumn("attributes", datatypes.JSONSet("attributes").Set("{friend}", friend))
// PostgreSQL
// UPDATE "user_with_jsons" SET "attributes" = JSONB_SET(JSONB_SET(JSONB_SET("attributes", '{age}', '20'), '{tags, 0}', '"tag2"'), '{orgs, orga}', '"orgb"') WHERE name = 'json-1'
// UPDATE "user_with_jsons" SET "attributes" = JSONB_SET("attributes", '{phones}', '["10085","10086"]') WHERE name = 'json-1'
// UPDATE "user_with_jsons" SET "attributes" = JSONB_SET("attributes", '{phones}', '["10085","10086"]'::jsonb) WHERE name = 'json-1'
// UPDATE "user_with_jsons" SET "attributes" = JSONB_SET("attributes", '{friend}', '{"Name": "Bob", "Age": 21}') WHERE name = 'json-1'
JSONType[T]
sqlite, mysql, postgres supported
import "github.com/wubin1989/datatypes"
type Attribute struct {
Sex int
Age int
Orgs map[string]string
Tags []string
Admin bool
Role string
}
type UserWithJSON struct {
gorm.Model
Name string
Attributes datatypes.JSONType[Attribute]
}
var user = UserWithJSON{
Name: "hello",
Attributes: datatypes.NewJSONType(Attribute{
Age: 18,
Sex: 1,
Orgs: map[string]string{"orga": "orga"},
Tags: []string{"tag1", "tag2", "tag3"},
}),
}
// Create
DB.Create(&user)
// First
var result UserWithJSON
DB.First(&result, user.ID)
// Update
jsonMap = UserWithJSON{
Attributes: datatypes.NewJSONType(Attribute{
Age: 18,
Sex: 1,
Orgs: map[string]string{"orga": "orga"},
Tags: []string{"tag1", "tag2", "tag3"},
}),
}
DB.Model(&user).Updates(jsonMap)
NOTE: it's not support json query
JSONSlice[T]
sqlite, mysql, postgres supported
import "github.com/wubin1989/datatypes"
type Tag struct {
Name string
Score float64
}
type UserWithJSON struct {
gorm.Model
Name string
Tags datatypes.JSONSlice[Tag]
}
var tags = []Tag{{Name: "tag1", Score: 0.1}, {Name: "tag2", Score: 0.2}}
var user = UserWithJSON{
Name: "hello",
Tags: datatypes.NewJSONSlice(tags),
}
// Create
DB.Create(&user)
// First
var result UserWithJSON
DB.First(&result, user.ID)
// Update
var tags2 = []Tag{{Name: "tag3", Score: 10.1}, {Name: "tag4", Score: 10.2}}
jsonMap = UserWithJSON{
Tags: datatypes.NewJSONSlice(tags2),
}
DB.Model(&user).Updates(jsonMap)
NOTE: it's not support json query and db.Pluck
method
JSONArray
mysql supported
import "github.com/wubin1989/datatypes"
type Param struct {
ID int
Letters string
Config datatypes.JSON
}
//Create
DB.Create(&Param{
Letters: "JSONArray-1",
Config: datatypes.JSON("[\"a\", \"b\"]"),
})
DB.Create(&Param{
Letters: "JSONArray-2",
Config: datatypes.JSON("[\"a\", \"c\"]"),
})
//Query
var retMultiple []Param
DB.Where(datatypes.JSONArrayQuery("config").Contains("c")).Find(&retMultiple)
}
UUID
MySQL, PostgreSQL, SQLServer and SQLite are supported.
import "gorm.io/datatypes"
type UserWithUUID struct {
gorm.Model
Name string
UserUUID datatypes.UUID
}
// Generate a new random UUID (version 4).
userUUID := datatypes.NewUUIDv4()
user := UserWithUUID{Name: "jinzhu", UserUUID: userUUID}
DB.Create(&user)
// INSERT INTO `user_with_uuids` (`name`,`user_uuid`) VALUES ("jinzhu","ca95a578-816c-4812-babd-a7602b042460")
var result UserWithUUID
DB.First(&result, "name = ? AND user_uuid = ?", "jinzhu", userUUID)
// SELECT * FROM user_with_uuids WHERE name = "jinzhu" AND user_uuid = "ca95a578-816c-4812-babd-a7602b042460" ORDER BY `user_with_uuids`.`id` LIMIT 1
// Use the datatype's Equals() to compare the UUIDs.
if userCreate.UserUUID.Equals(userFound.UserUUID) {
fmt.Println("User UUIDs match as expected.")
} else {
fmt.Println("User UUIDs do not match. Something is wrong.")
}
// Use the datatype's String() function to get the UUID as a string type.
fmt.Printf("User UUID is %s", userFound.UserUUID.String())
// Check the UUID value with datatype's IsNil() and IsEmpty() functions.
if userFound.UserUUID.IsNil() {
fmt.Println("User UUID is a nil UUID (i.e. all bits are zero)")
}
if userFound.UserUUID.IsEmpty() {
fmt.Println(
"User UUID is empty (i.e. either a nil UUID or a zero length string)",
)
}
Documentation ¶
Index ¶
- func Column(col string) columnExpression
- type BinUUID
- func (u BinUUID) Bytes() []byte
- func (u BinUUID) Equals(other BinUUID) bool
- func (BinUUID) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (BinUUID) GormDataType() string
- func (u BinUUID) IsEmpty() bool
- func (u *BinUUID) IsEmptyPtr() bool
- func (u BinUUID) IsNil() bool
- func (u *BinUUID) IsNilPtr() bool
- func (u BinUUID) Length() int
- func (u BinUUID) LengthBytes() int
- func (u *BinUUID) Scan(value interface{}) error
- func (u BinUUID) String() string
- func (u BinUUID) Value() (driver.Value, error)
- type Date
- func (date *Date) GobDecode(b []byte) error
- func (date Date) GobEncode() ([]byte, error)
- func (date Date) GormDataType() string
- func (date Date) MarshalJSON() ([]byte, error)
- func (date *Date) Scan(value interface{}) (err error)
- func (date *Date) UnmarshalJSON(b []byte) error
- func (date Date) Value() (driver.Value, error)
- type JSON
- func (JSON) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (JSON) GormDataType() string
- func (js JSON) GormValue(ctx context.Context, db *gorm.DB) clause.Expr
- func (j JSON) MarshalJSON() ([]byte, error)
- func (j *JSON) Scan(value interface{}) error
- func (j JSON) String() string
- func (j *JSON) UnmarshalJSON(b []byte) error
- func (j JSON) Value() (driver.Value, error)
- type JSONArrayExpression
- type JSONMap
- func (JSONMap) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (m JSONMap) GormDataType() string
- func (jm JSONMap) GormValue(ctx context.Context, db *gorm.DB) clause.Expr
- func (m JSONMap) MarshalJSON() ([]byte, error)
- func (m *JSONMap) Scan(val interface{}) error
- func (m *JSONMap) UnmarshalJSON(b []byte) error
- func (m JSONMap) Value() (driver.Value, error)
- type JSONOverlapsExpression
- type JSONQueryExpression
- func (jsonQuery *JSONQueryExpression) Build(builder clause.Builder)
- func (jsonQuery *JSONQueryExpression) Equals(value interface{}, keys ...string) *JSONQueryExpression
- func (jsonQuery *JSONQueryExpression) Extract(path string) *JSONQueryExpression
- func (jsonQuery *JSONQueryExpression) HasKey(keys ...string) *JSONQueryExpression
- func (jsonQuery *JSONQueryExpression) Likes(value interface{}, keys ...string) *JSONQueryExpression
- type JSONSetExpression
- type JSONSlice
- func (JSONSlice[T]) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (JSONSlice[T]) GormDataType() string
- func (j JSONSlice[T]) GormValue(ctx context.Context, db *gorm.DB) clause.Expr
- func (j *JSONSlice[T]) Scan(value interface{}) error
- func (j JSONSlice[T]) Value() (driver.Value, error)
- type JSONType
- func (j JSONType[T]) Data() T
- func (JSONType[T]) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (JSONType[T]) GormDataType() string
- func (js JSONType[T]) GormValue(ctx context.Context, db *gorm.DB) clause.Expr
- func (j JSONType[T]) MarshalJSON() ([]byte, error)
- func (j *JSONType[T]) Scan(value interface{}) error
- func (j *JSONType[T]) UnmarshalJSON(b []byte) error
- func (j JSONType[T]) Value() (driver.Value, error)
- type Time
- func (Time) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (Time) GormDataType() string
- func (t Time) MarshalJSON() ([]byte, error)
- func (t *Time) Scan(src interface{}) error
- func (t Time) String() string
- func (t *Time) UnmarshalJSON(data []byte) error
- func (t Time) Value() (driver.Value, error)
- type URL
- func (URL) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (URL) GormDataType() string
- func (u URL) MarshalJSON() ([]byte, error)
- func (u *URL) Scan(value interface{}) error
- func (u *URL) String() string
- func (u *URL) UnmarshalJSON(data []byte) error
- func (u URL) Value() (driver.Value, error)
- type UUID
- func (u UUID) Equals(other UUID) bool
- func (UUID) GormDBDataType(db *gorm.DB, field *schema.Field) string
- func (UUID) GormDataType() string
- func (u UUID) IsEmpty() bool
- func (u *UUID) IsEmptyPtr() bool
- func (u UUID) IsNil() bool
- func (u *UUID) IsNilPtr() bool
- func (u UUID) Length() int
- func (u *UUID) Scan(value interface{}) error
- func (u UUID) String() string
- func (u UUID) Value() (driver.Value, error)
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type BinUUID ¶ added in v0.0.2
This datatype is similar to datatypes.UUID, major difference being that this datatype stores the uuid in the database as a binary (byte) array instead of a string. Developers may use either as per their preference.
func BinUUIDFromString ¶ added in v0.0.2
BinUUIDFromString returns the BinUUID representation of the specified uuidStr.
func NewBinUUIDv1 ¶ added in v0.0.2
func NewBinUUIDv1() BinUUID
NewBinUUIDv1 generates a uuid version 1, panics on generation failure.
func NewBinUUIDv4 ¶ added in v0.0.2
func NewBinUUIDv4() BinUUID
NewBinUUIDv4 generates a uuid version 4, panics on generation failure.
func NewNilBinUUID ¶ added in v0.0.2
func NewNilBinUUID() BinUUID
NewNilBinUUID generates a nil uuid.
func (BinUUID) Equals ¶ added in v0.0.2
Equals returns true if bytes form of BinUUID matches other, false otherwise.
func (BinUUID) GormDBDataType ¶ added in v0.0.2
GormDBDataType gorm db data type.
func (BinUUID) GormDataType ¶ added in v0.0.2
GormDataType gorm common data type.
func (BinUUID) IsEmpty ¶ added in v0.0.2
IsEmpty returns true if BinUUID is nil uuid or of zero length, false otherwise.
func (*BinUUID) IsEmptyPtr ¶ added in v0.0.2
IsEmptyPtr returns true if caller BinUUID ptr is nil or it's value is empty.
func (BinUUID) IsNil ¶ added in v0.0.2
IsNil returns true if the BinUUID is nil uuid (all zeroes), false otherwise.
func (*BinUUID) IsNilPtr ¶ added in v0.0.2
IsNilPtr returns true if caller BinUUID ptr is nil, false otherwise.
func (BinUUID) Length ¶ added in v0.0.2
Length returns the number of characters in string form of UUID.
func (BinUUID) LengthBytes ¶ added in v0.0.2
Length returns the number of characters in string form of UUID.
type Date ¶
func (Date) GormDataType ¶
GormDataType gorm common data type
func (Date) MarshalJSON ¶
func (*Date) UnmarshalJSON ¶
type JSON ¶
type JSON json.RawMessage
JSON defined JSON data type, need to implements driver.Valuer, sql.Scanner interface
func (JSON) GormDBDataType ¶
GormDBDataType gorm db data type
func (JSON) MarshalJSON ¶
MarshalJSON to output non base64 encoded []byte
func (*JSON) UnmarshalJSON ¶
UnmarshalJSON to deserialize []byte
type JSONArrayExpression ¶
type JSONArrayExpression struct {
// contains filtered or unexported fields
}
func JSONArrayQuery ¶
func JSONArrayQuery(column string) *JSONArrayExpression
func (*JSONArrayExpression) Build ¶
func (json *JSONArrayExpression) Build(builder clause.Builder)
Build implements clause.Expression
func (*JSONArrayExpression) Contains ¶
func (json *JSONArrayExpression) Contains(value interface{}, keys ...string) *JSONArrayExpression
Contains checks if the column[keys] has contains the value given. The keys parameter is only supported for MySQL.
type JSONMap ¶
type JSONMap map[string]interface{}
JSONMap defined JSON data type, need to implements driver.Valuer, sql.Scanner interface
func (JSONMap) GormDBDataType ¶
GormDBDataType gorm db data type
func (JSONMap) GormDataType ¶
GormDataType gorm common data type
func (JSONMap) MarshalJSON ¶
MarshalJSON to output non base64 encoded []byte
func (*JSONMap) UnmarshalJSON ¶
UnmarshalJSON to deserialize []byte
type JSONOverlapsExpression ¶
type JSONOverlapsExpression struct {
// contains filtered or unexported fields
}
JSONOverlapsExpression JSON_OVERLAPS expression, implements clause.Expression interface to use as querier
func JSONOverlaps ¶
func JSONOverlaps(column clause.Expression, value string) *JSONOverlapsExpression
JSONOverlaps query column as json
func (*JSONOverlapsExpression) Build ¶
func (json *JSONOverlapsExpression) Build(builder clause.Builder)
Build implements clause.Expression only mysql support JSON_OVERLAPS
type JSONQueryExpression ¶
type JSONQueryExpression struct {
// contains filtered or unexported fields
}
JSONQueryExpression json query expression, implements clause.Expression interface to use as querier
func (*JSONQueryExpression) Build ¶
func (jsonQuery *JSONQueryExpression) Build(builder clause.Builder)
Build implements clause.Expression
func (*JSONQueryExpression) Equals ¶
func (jsonQuery *JSONQueryExpression) Equals(value interface{}, keys ...string) *JSONQueryExpression
Keys returns clause.Expression
func (*JSONQueryExpression) Extract ¶
func (jsonQuery *JSONQueryExpression) Extract(path string) *JSONQueryExpression
Extract extract json with path
func (*JSONQueryExpression) HasKey ¶
func (jsonQuery *JSONQueryExpression) HasKey(keys ...string) *JSONQueryExpression
HasKey returns clause.Expression
func (*JSONQueryExpression) Likes ¶
func (jsonQuery *JSONQueryExpression) Likes(value interface{}, keys ...string) *JSONQueryExpression
Likes return clause.Expression
type JSONSetExpression ¶
type JSONSetExpression struct {
// contains filtered or unexported fields
}
JSONSetExpression json set expression, implements clause.Expression interface to use as updater
func (*JSONSetExpression) Build ¶
func (jsonSet *JSONSetExpression) Build(builder clause.Builder)
Build implements clause.Expression support mysql, sqlite and postgres
func (*JSONSetExpression) Set ¶
func (jsonSet *JSONSetExpression) Set(path string, value interface{}) *JSONSetExpression
Set return clause.Expression.
{ "age": 20, "name": "json-1", "orgs": {"orga": "orgv"}, "tags": ["tag1", "tag2"] } // In MySQL/SQLite, path is `age`, `name`, `orgs.orga`, `tags[0]`, `tags[1]`. DB.UpdateColumn("attr", JSONSet("attr").Set("orgs.orga", 42)) // In PostgreSQL, path is `{age}`, `{name}`, `{orgs,orga}`, `{tags, 0}`, `{tags, 1}`. DB.UpdateColumn("attr", JSONSet("attr").Set("{orgs, orga}", "bar"))
type JSONSlice ¶
type JSONSlice[T any] []T
JSONSlice give a generic data type for json encoded slice data.
func NewJSONSlice ¶
func (JSONSlice[T]) GormDBDataType ¶
GormDBDataType gorm db data type
func (JSONSlice[T]) GormDataType ¶
GormDataType gorm common data type
type JSONType ¶
type JSONType[T any] struct { // contains filtered or unexported fields }
JSONType give a generic data type for json encoded data.
func NewJSONType ¶
func (JSONType[T]) GormDBDataType ¶
GormDBDataType gorm db data type
func (JSONType[T]) GormDataType ¶
GormDataType gorm common data type
func (JSONType[T]) MarshalJSON ¶
MarshalJSON to output non base64 encoded []byte
func (*JSONType[T]) UnmarshalJSON ¶
UnmarshalJSON to deserialize []byte
type Time ¶
Time is time data type.
func (Time) GormDBDataType ¶
GormDBDataType returns gorm DB data type based on the current using database.
func (Time) GormDataType ¶
GormDataType returns gorm common data type. This type is used for the field's column type.
func (Time) MarshalJSON ¶
MarshalJSON implements json.Marshaler to convert Time to json serialization.
func (*Time) UnmarshalJSON ¶
UnmarshalJSON implements json.Unmarshaler to deserialize json data.
type UUID ¶ added in v0.0.2
This datatype stores the uuid in the database as a string. To store the uuid in the database as a binary (byte) array, please refer to datatypes.BinUUID.
func NewUUIDv1 ¶ added in v0.0.2
func NewUUIDv1() UUID
NewUUIDv1 generates a UUID version 1, panics on generation failure.
func NewUUIDv4 ¶ added in v0.0.2
func NewUUIDv4() UUID
NewUUIDv4 generates a UUID version 4, panics on generation failure.
func (UUID) Equals ¶ added in v0.0.2
Equals returns true if string form of UUID matches other, false otherwise.
func (UUID) GormDBDataType ¶ added in v0.0.2
GormDBDataType gorm db data type.
func (UUID) GormDataType ¶ added in v0.0.2
GormDataType gorm common data type.
func (UUID) IsEmpty ¶ added in v0.0.2
IsEmpty returns true if UUID is nil UUID or of zero length, false otherwise.
func (*UUID) IsEmptyPtr ¶ added in v0.0.2
IsEmptyPtr returns true if caller UUID ptr is nil or it's value is empty.
func (UUID) IsNil ¶ added in v0.0.2
IsNil returns true if the UUID is a nil UUID (all zeroes), false otherwise.
func (*UUID) IsNilPtr ¶ added in v0.0.2
IsNilPtr returns true if caller UUID ptr is nil, false otherwise.
func (UUID) Length ¶ added in v0.0.2
Length returns the number of characters in string form of UUID.