diff --git a/mysql/mysql.go b/mysql/mysql.go
index c62a2f5d9ba368dac6ac7595b4745c20ced964a8..e111cb7ad67c13ac9f73f9acea920e94395617f6 100644
--- a/mysql/mysql.go
+++ b/mysql/mysql.go
@@ -43,6 +43,10 @@ var Debug = false
const dateFormat = "2006-01-02 15:04:05.000000000"
const timeFormat = "%d:%02d:%02d.%09d"
+func init() {
+ db.Register("mysql", &MysqlDataSource{})
+}
+
type myQuery struct {
Query []string
SqlArgs []string
@@ -97,6 +101,10 @@ type MysqlDataSource struct {
collections map[string]db.Collection
}
+func (my *MysqlDataSource) Name() string {
+ return my.config.Database
+}
+
// Returns all items from a query.
func (t *MysqlTable) myFetchAll(rows sql.Rows) []db.Item {
@@ -241,6 +249,13 @@ func (my *MysqlDataSource) Close() error {
return nil
}
+// Opens a connection.
+func (self *MysqlDataSource) Setup(config db.DataSource) error {
+ self.config = config
+ self.collections = make(map[string]db.Collection)
+ return self.Open()
+}
+
// Tries to open a connection to the current MySQL session.
func (my *MysqlDataSource) Open() error {
var err error
@@ -559,7 +574,7 @@ func (t *MysqlTable) FindAll(terms ...interface{}) []db.Item {
}
if rcollection == nil {
- rcollection = t.parent.Collection(rname)
+ rcollection = t.parent.ExistentCollection(rname)
}
relations = append(relations, sugar.Tuple{"all": false, "name": rname, "collection": rcollection, "terms": rterms})
@@ -582,7 +597,7 @@ func (t *MysqlTable) FindAll(terms ...interface{}) []db.Item {
}
if rcollection == nil {
- rcollection = t.parent.Collection(rname)
+ rcollection = t.parent.ExistentCollection(rname)
}
relations = append(relations, sugar.Tuple{"all": true, "name": rname, "collection": rcollection, "terms": rterms})
@@ -676,6 +691,27 @@ func (t *MysqlTable) Count(terms ...interface{}) (int, error) {
return 0, nil
}
+func (t *MysqlTable) Exists() bool {
+ result, err := t.parent.myExec(
+ "Query",
+ fmt.Sprintf(`
+ SELECT table_name
+ FROM information_schema.tables
+ WHERE table_schema = '%s' AND table_name = '%s'
+ `,
+ t.parent.Name(),
+ t.Name(),
+ ),
+ )
+ if err != nil {
+ panic(err.Error())
+ }
+ if result.Next() == true {
+ return true
+ }
+ return false
+}
+
// Returns the first row in the table that matches certain conditions.
func (t *MysqlTable) Find(terms ...interface{}) db.Item {
@@ -745,11 +781,24 @@ func (t *MysqlTable) Append(items ...interface{}) ([]db.Id, error) {
return ids, nil
}
+func (t *MysqlTable) Name() string {
+ return t.name
+}
+
+func (my *MysqlDataSource) ExistentCollection(name string) db.Collection {
+ col, err := my.Collection(name)
+ if err != nil {
+ panic(err.Error())
+ }
+ return col
+}
+
// Returns a MySQL table structure by name.
-func (my *MysqlDataSource) Collection(name string) db.Collection {
+func (my *MysqlDataSource) Collection(name string) (db.Collection, error) {
+ var rerr error
- if collection, ok := my.collections[name]; ok == true {
- return collection
+ if col, ok := my.collections[name]; ok == true {
+ return col, nil
}
t := &MysqlTable{}
@@ -757,60 +806,67 @@ func (my *MysqlDataSource) Collection(name string) db.Collection {
t.parent = my
t.name = name
- // Fetching table datatypes and mapping to internal gotypes.
+ // Table exists?
+ if t.Exists() == false {
+ rerr = fmt.Errorf("Table %s does not exists.", name)
+ }
+ // Fetching table datatypes and mapping to internal gotypes.
rows, err := t.parent.myExec(
"Query",
"SHOW COLUMNS FROM", t.name,
)
- if err != nil {
- panic(err)
- }
- columns := t.myFetchAll(rows)
+ if err == nil {
- pattern, _ := regexp.Compile("^([a-z]+)\\(?([0-9,]+)?\\)?\\s?([a-z]*)?")
+ columns := t.myFetchAll(rows)
- t.types = make(map[string]reflect.Kind, len(columns))
+ pattern, _ := regexp.Compile("^([a-z]+)\\(?([0-9,]+)?\\)?\\s?([a-z]*)?")
- for _, column := range columns {
- cname := strings.ToLower(column["field"].(string))
- ctype := strings.ToLower(column["type"].(string))
- results := pattern.FindStringSubmatch(ctype)
+ t.types = make(map[string]reflect.Kind, len(columns))
- // Default properties.
- dextra := ""
- dtype := "varchar"
+ for _, column := range columns {
+ cname := strings.ToLower(column["field"].(string))
+ ctype := strings.ToLower(column["type"].(string))
+ results := pattern.FindStringSubmatch(ctype)
- dtype = results[1]
+ // Default properties.
+ dextra := ""
+ dtype := "varchar"
- if len(results) > 3 {
- dextra = results[3]
- }
+ dtype = results[1]
- vtype := reflect.String
-
- // Guessing datatypes.
- switch dtype {
- case "tinyint", "smallint", "mediumint", "int", "bigint":
- if dextra == "unsigned" {
- vtype = reflect.Uint64
- } else {
- vtype = reflect.Int64
+ if len(results) > 3 {
+ dextra = results[3]
}
- case "decimal", "float", "double":
- vtype = reflect.Float64
- }
+ vtype := reflect.String
+
+ // Guessing datatypes.
+ switch dtype {
+ case "tinyint", "smallint", "mediumint", "int", "bigint":
+ if dextra == "unsigned" {
+ vtype = reflect.Uint64
+ } else {
+ vtype = reflect.Int64
+ }
+ case "decimal", "float", "double":
+ vtype = reflect.Float64
+ }
- /*
- fmt.Printf("Imported %v (from %v)\n", vtype, dtype)
- */
+ /*
+ fmt.Printf("Imported %v (from %v)\n", vtype, dtype)
+ */
- t.types[cname] = vtype
+ t.types[cname] = vtype
+ }
+ } else {
+ rerr = err
}
- my.collections[name] = t
+ if rerr == nil {
+ my.collections[name] = t
+ }
- return t
+ return t, rerr
}
diff --git a/mysql/mysql_test.go b/mysql/mysql_test.go
index a18671f2805a981c3d9148b3e258a07367245163..8ee1292c868334087b86354fc41147358078a325 100644
--- a/mysql/mysql_test.go
+++ b/mysql/mysql_test.go
@@ -4,19 +4,18 @@ import (
"database/sql"
"fmt"
"github.com/gosexy/db"
- "github.com/gosexy/sugar"
"github.com/kr/pretty"
"math/rand"
"testing"
"time"
)
-const myHost = "debian"
-const myDatabase = "gotest"
-const myUser = "gouser"
-const myPassword = "gopass"
+const host = "debian"
+const dbname = "gotest"
+const username = "gouser"
+const password = "gopass"
-func getTestData() db.Item {
+func testItem() db.Item {
_time, _ := time.ParseDuration("17h20m")
@@ -62,21 +61,20 @@ func TestEnableDebug(t *testing.T) {
Debug = true
}
-func TestMyTruncate(t *testing.T) {
+func TestTruncate(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
+ defer sess.Close()
+
collections := sess.Collections()
for _, name := range collections {
- col := sess.Collection(name)
+ col := sess.ExistentCollection(name)
col.Truncate()
total, _ := col.Count()
@@ -88,28 +86,34 @@ func TestMyTruncate(t *testing.T) {
}
-func TestMyAppend(t *testing.T) {
+func TestAppend(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
- col := sess.Collection("people")
+ defer sess.Close()
- col.Truncate()
+ _, err = sess.Collection("doesnotexists")
+
+ if err == nil {
+ t.Errorf("Collection should not exists.")
+ return
+ }
+
+ people := sess.ExistentCollection("people")
+
+ people.Truncate()
names := []string{"Juan", "José", "Pedro", "MarÃa", "Roberto", "Manuel", "Miguel"}
for i := 0; i < len(names); i++ {
- col.Append(db.Item{"name": names[i]})
+ people.Append(db.Item{"name": names[i]})
}
- total, _ := col.Count()
+ total, _ := people.Count()
if total != len(names) {
t.Error("Could not append all items.")
@@ -117,20 +121,19 @@ func TestMyAppend(t *testing.T) {
}
-func TestMyFind(t *testing.T) {
-
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
+func TestFind(t *testing.T) {
- err := sess.Open()
- defer sess.Close()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
- col := sess.Collection("people")
+ defer sess.Close()
+
+ people, _ := sess.Collection("people")
- result := col.Find(db.Cond{"name": "José"})
+ result := people.Find(db.Cond{"name": "José"})
if result["name"] != "José" {
t.Error("Could not find a recently appended item.")
@@ -138,139 +141,137 @@ func TestMyFind(t *testing.T) {
}
-func TestMyDelete(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+func TestDelete(t *testing.T) {
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
- col := sess.Collection("people")
+ defer sess.Close()
+
+ people, _ := sess.Collection("people")
- col.Remove(db.Cond{"name": "Juan"})
+ people.Remove(db.Cond{"name": "Juan"})
- result := col.Find(db.Cond{"name": "Juan"})
+ result := people.Find(db.Cond{"name": "Juan"})
if len(result) > 0 {
t.Error("Could not remove a recently appended item.")
}
}
-func TestMyUpdate(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+func TestUpdate(t *testing.T) {
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
+ defer sess.Close()
+
sess.Use("test")
- col := sess.Collection("people")
+ people, _ := sess.Collection("people")
- col.Update(db.Cond{"name": "José"}, db.Set{"name": "Joseph"})
+ people.Update(db.Cond{"name": "José"}, db.Set{"name": "Joseph"})
- result := col.Find(db.Cond{"name": "Joseph"})
+ result := people.Find(db.Cond{"name": "Joseph"})
if len(result) == 0 {
t.Error("Could not update a recently appended item.")
}
}
-func TestMyPopulate(t *testing.T) {
- var i int
-
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
+func TestPopulate(t *testing.T) {
- err := sess.Open()
- defer sess.Close()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
- sess.Use("test")
+ defer sess.Close()
- places := []string{"Alaska", "Nebraska", "Alaska", "Acapulco", "Rome", "Singapore", "Alabama", "Cancún"}
+ people, _ := sess.Collection("people")
+ places, _ := sess.Collection("places")
+ children, _ := sess.Collection("children")
+ visits, _ := sess.Collection("visits")
- for i = 0; i < len(places); i++ {
- sess.Collection("places").Append(db.Item{
+ values := []string{"Alaska", "Nebraska", "Alaska", "Acapulco", "Rome", "Singapore", "Alabama", "Cancún"}
+
+ for i, value := range values {
+ places.Append(db.Item{
"code_id": i,
- "name": places[i],
+ "name": value,
})
}
- people := sess.Collection("people").FindAll(
+ results := people.FindAll(
db.Fields{"id", "name"},
db.Sort{"name": "ASC", "id": -1},
)
- for i = 0; i < len(people); i++ {
- person := people[i]
+ for _, person := range results {
// Has 5 children.
+
for j := 0; j < 5; j++ {
- sess.Collection("children").Append(db.Item{
+ children.Append(db.Item{
"name": fmt.Sprintf("%s's child %d", person["name"], j+1),
- "parent_id": person["id"],
+ "parent_id": person["_id"],
})
}
// Lives in
- sess.Collection("people").Update(
- db.Cond{"id": person["id"]},
- db.Set{"place_code_id": int(rand.Float32() * float32(len(places)))},
+ people.Update(
+ db.Cond{"_id": person["_id"]},
+ db.Set{"place_code_id": int(rand.Float32() * float32(len(results)))},
)
// Has visited
for k := 0; k < 3; k++ {
- place := sess.Collection("places").Find(db.Cond{
- "code_id": int(rand.Float32() * float32(len(places))),
+ place := places.Find(db.Cond{
+ "code_id": int(rand.Float32() * float32(len(results))),
})
- sess.Collection("visits").Append(db.Item{
- "place_id": place["id"],
- "person_id": person["id"],
+ visits.Append(db.Item{
+ "place_id": place["_id"],
+ "person_id": person["_id"],
})
}
}
}
-func TestMyRelation(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+func TestRelation(t *testing.T) {
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
- col := sess.Collection("people")
+ defer sess.Close()
- result := col.FindAll(
+ people, _ := sess.Collection("people")
+
+ results := people.FindAll(
db.Relate{
"lives_in": db.On{
- sess.Collection("places"),
+ sess.ExistentCollection("places"),
db.Cond{"code_id": "{place_code_id}"},
},
},
db.RelateAll{
"has_children": db.On{
- sess.Collection("children"),
+ sess.ExistentCollection("children"),
db.Cond{"parent_id": "{id}"},
},
"has_visited": db.On{
- sess.Collection("visits"),
+ sess.ExistentCollection("visits"),
db.Cond{"person_id": "{id}"},
db.Relate{
"place": db.On{
- sess.Collection("places"),
+ sess.ExistentCollection("places"),
db.Cond{"id": "{place_id}"},
},
},
@@ -278,19 +279,18 @@ func TestMyRelation(t *testing.T) {
},
)
- fmt.Printf("%# v\n", pretty.Formatter(result))
+ fmt.Printf("%# v\n", pretty.Formatter(results))
}
func TestCustom(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
- defer sess.Close()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
if err != nil {
panic(err)
}
+ defer sess.Close()
+
_, err = sess.Driver().(*sql.DB).Query("SELECT NOW()")
if err != nil {
@@ -301,36 +301,38 @@ func TestCustom(t *testing.T) {
func TestDataTypes(t *testing.T) {
- sess := Session(db.DataSource{Host: myHost, Database: myDatabase, User: myUser, Password: myPassword})
-
- err := sess.Open()
+ sess, err := db.Open("mysql", db.DataSource{Host: host, Database: dbname, User: username, Password: password})
- if err == nil {
- defer sess.Close()
+ if err != nil {
+ t.Errorf(err.Error())
+ return
}
- col := sess.Collection("data_types")
+ defer sess.Close()
+
+ dataTypes, _ := sess.Collection("data_types")
- col.Truncate()
+ dataTypes.Truncate()
- data := getTestData()
+ testData := testItem()
- ids, err := col.Append(data)
+ ids, err := dataTypes.Append(testData)
if err != nil {
t.Errorf("Could not append test data.")
}
- found, _ := col.Count(db.Cond{"id": db.Id(ids[0])})
+ found, _ := dataTypes.Count(db.Cond{"id": db.Id(ids[0])})
if found == 0 {
t.Errorf("Cannot find recently inserted item (by ID).")
}
// Getting and reinserting.
- item := col.Find()
- _, err = col.Append(item)
+ item := dataTypes.Find()
+
+ _, err = dataTypes.Append(item)
if err == nil {
t.Errorf("Expecting duplicated-key error.")
@@ -338,18 +340,17 @@ func TestDataTypes(t *testing.T) {
delete(item, "id")
- _, err = col.Append(item)
+ _, err = dataTypes.Append(item)
if err != nil {
t.Errorf("Could not append second element.")
}
// Testing rows
- items := col.FindAll()
- for i := 0; i < len(items); i++ {
+ results := dataTypes.FindAll()
- item := items[i]
+ for _, item := range results {
for key, _ := range item {
@@ -362,7 +363,7 @@ func TestDataTypes(t *testing.T) {
"_int16",
"_int32",
"_int64":
- if item.GetInt(key) != int64(data["_int"].(int)) {
+ if item.GetInt(key) != int64(testData["_int"].(int)) {
t.Errorf("Wrong datatype %v.", key)
}
@@ -376,50 +377,46 @@ func TestDataTypes(t *testing.T) {
"_uint64",
"_byte",
"_rune":
- if item.GetInt(key) != int64(data["_uint"].(uint)) {
+ if item.GetInt(key) != int64(testData["_uint"].(uint)) {
t.Errorf("Wrong datatype %v.", key)
}
// Floating point.
case "_float32":
case "_float64":
- if item.GetFloat(key) != data["_float64"].(float64) {
+ if item.GetFloat(key) != testData["_float64"].(float64) {
t.Errorf("Wrong datatype %v.", key)
}
// Boolean
case "_bool":
- if item.GetBool(key) != data["_bool"].(bool) {
+ if item.GetBool(key) != testData["_bool"].(bool) {
t.Errorf("Wrong datatype %v.", key)
}
// String
case "_string":
- if item.GetString(key) != data["_string"].(string) {
- t.Errorf("Wrong datatype %v.", key)
- }
-
- // Map
- case "_map":
- if item.GetTuple(key)["a"] != data["_map"].(sugar.Tuple)["a"] {
+ if item.GetString(key) != testData["_string"].(string) {
t.Errorf("Wrong datatype %v.", key)
}
- // Array
- case "_list":
- if item.GetList(key)[0] != data["_list"].(sugar.List)[0] {
- t.Errorf("Wrong datatype %v.", key)
- }
+ /*
+ // Map
+ case "_map":
+ if item.GetTuple(key)["a"] != testData["_map"].(sugar.Tuple)["a"] {
+ t.Errorf("Wrong datatype %v.", key)
+ }
- // Time
- case "_time":
- if item.GetDuration(key).String() != data["_time"].(time.Duration).String() {
- t.Errorf("Wrong datatype %v.", key)
- }
+ // Array
+ case "_list":
+ if item.GetList(key)[0] != testData["_list"].(sugar.List)[0] {
+ t.Errorf("Wrong datatype %v.", key)
+ }
+ */
// Date
case "_date":
- if item.GetDate(key).Equal(data["_date"].(time.Time)) == false {
+ if item.GetDate(key).Equal(testData["_date"].(time.Time)) == false {
t.Errorf("Wrong datatype %v.", key)
}
}