func main() {
sess, err := db.Open("mongo", settings)
if err != nil {
fmt.Println("Unable to connect:", err.Error())
return
}
defer sess.Close()
birthdayCollection, err := sess.Collection("birthdays")
if err != nil {
if err != db.ErrCollectionDoesNotExists {
fmt.Println("Could not use collection:", err.Error())
return
}
} else {
err = birthdayCollection.Truncate()
if err != nil {
fmt.Println(err.Error())
return
}
}
birthdayCollection.Append(Birthday{
Name: "Hayao Miyazaki",
Born: time.Date(1941, time.January, 5, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Nobuo Uematsu",
Born: time.Date(1959, time.March, 21, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Hironobu Sakaguchi",
Born: time.Date(1962, time.November, 25, 0, 0, 0, 0, time.UTC),
})
var res db.Result
res = birthdayCollection.Find()
var birthdays []Birthday
err = res.All(&birthdays)
if err != nil {
panic(err.Error())
return
}
for _, birthday := range birthdays {
fmt.Printf("%s was born in %s.\n", birthday.Name, birthday.Born.Format("January 2, 2006"))
}
}
// This test tries to use an empty filter and count how many elements were
// added into the artist collection.
func TestResultCount(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(Adapter, settings)
if err != nil {
t.Fatal(err)
}
defer sess.Close()
// We should close the database when it's no longer in use.
artist, _ := sess.Collection("artist")
res = artist.Find()
// Counting all the matching rows.
total, err := res.Count()
if err != nil {
t.Fatal(err)
}
if total == 0 {
t.Fatalf("Should not be empty, we've just added some rows!")
}
}
// Attempts to count all rows in our newly defined set.
func TestResultCount(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
var total uint64
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
// We should close the database when it's no longer in use.
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
// Defining a set with no conditions.
res = artist.Find()
// Counting all the matching rows.
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total == 0 {
t.Fatalf("Counter should not be zero, we've just added some rows!")
}
}
func (self *Dh) RemoveForeverByConditions(conditions interface{}) api.Err {
var res db.Result
var errs api.Err
res = Collection.Find(conditions)
exist, err := res.Count()
if exist == 0 {
errs.Push(api.Msg{
Field: "Delete: ",
Error: api.ErrNoSuchRow,
})
return errs
}
err = res.Remove()
if err == nil {
return errs
} else {
errs.Push(api.Msg{
Field: "Database delete error: ",
Error: err.Error(),
})
}
return errs
}
func (self *Dh) Delete() api.Err {
var res db.Result
var errs api.Err
id := reflect.ValueOf(self.Model).Elem().FieldByName("Id").Interface().(int64)
res = Collection.Find(db.Cond{"id": id})
exist, err := res.Count()
if exist == 0 {
errs.Push(api.Msg{
Field: "Delete: ",
Error: api.ErrNoSuchRow,
})
return errs
}
err = res.Remove()
if err == nil {
return errs
} else {
errs.Push(api.Msg{
Field: "Database delete error: ",
Error: err.Error(),
})
}
return errs
}
func main() {
sess, err := db.Open("sqlite", settings)
if err != nil {
fmt.Println("Please create the `example.db` sqlite3 database.")
return
}
defer sess.Close()
birthdayCollection, err := sess.Collection("birthdays")
if err != nil {
fmt.Println(err.Error())
return
}
err = birthdayCollection.Truncate()
if err != nil {
fmt.Println(err.Error())
return
}
birthdayCollection.Append(Birthday{
Name: "Hayao Miyazaki",
Born: time.Date(1941, time.January, 5, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Nobuo Uematsu",
Born: time.Date(1959, time.March, 21, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Hironobu Sakaguchi",
Born: time.Date(1962, time.November, 25, 0, 0, 0, 0, time.UTC),
})
var res db.Result
res = birthdayCollection.Find()
var birthdays []Birthday
err = res.All(&birthdays)
if err != nil {
panic(err.Error())
return
}
for _, birthday := range birthdays {
fmt.Printf("%s was born in %s.\n", birthday.Name, birthday.Born.Format("January 2, 2006"))
}
}
func (self *Dh) FindAllByConditionsSortBy(bar interface{}, conditions interface{}, sort string) api.Err {
var res db.Result
var errs api.Err
res = Collection.Find(conditions).Sort(sort)
err := res.All(bar)
if err != nil {
errs.Push(api.Msg{
Field: "Not found",
Error: api.ErrNoSuchRow,
})
}
return errs
}
// Attempts to add many different datatypes to a single row in a collection,
// then it tries to get the stored datatypes and check if the stored and the
// original values match.
func TestDataTypes(t *testing.T) {
var res db.Result
var sess db.Database
var dataTypes db.Collection
var err error
var id interface{}
var exists uint64
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
// Getting a pointer to the "data_types" collection.
if dataTypes, err = sess.Collection("data_types"); err != nil {
t.Fatal(err)
}
// Removing all data.
if err = dataTypes.Truncate(); err != nil {
t.Fatal(err)
}
// Appending our test subject.
if id, err = dataTypes.Append(testValues); err != nil {
t.Fatal(err)
}
// Defining our set.
res = dataTypes.Find(db.Cond{"id": id})
if exists, err = res.Count(); err != nil {
t.Fatal(err)
}
if exists == 0 {
t.Fatalf("Expecting an item.")
}
// Trying to dump the subject into an empty structure of the same type.
var item testValuesStruct
res.One(&item)
// The original value and the test subject must match.
if reflect.DeepEqual(item, testValues) == false {
t.Fatalf("Struct is different.")
}
}
func (self *Dh) FindAllSortBy(bar interface{}, sort string) api.Err {
var res db.Result
var errs api.Err
res = Collection.Find().Sort(sort)
count, _ := res.Count()
if count == 0 {
errs.Push(api.Msg{
Field: "Select All",
Error: api.ErrSelectAll,
})
}
res.All(bar)
return errs
}
// This test tries to add many different datatypes to a single row in a
// collection, then it tries to get the stored datatypes and check if the
// stored and the original values match.
func TestDataTypes(t *testing.T) {
var res db.Result
// Opening database.
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
// We should close the database when it's no longer in use.
defer sess.Close()
// Getting a pointer to the "data_types" collection.
dataTypes, err := sess.Collection("data_types")
dataTypes.Truncate()
// Appending our test subject.
id, err := dataTypes.Append(testValues)
if err != nil {
t.Fatalf(err.Error())
}
// Trying to get the same subject we added.
res, err = dataTypes.Find(db.Cond{"id": id})
if err != nil {
t.Fatalf(err.Error())
}
exists, err := res.Count()
if err != nil {
t.Fatalf(err.Error())
}
if exists == 0 {
t.Errorf("Expecting an item.")
}
// Trying to dump the subject into an empty structure of the same type.
var item testValuesStruct
res.One(&item)
// The original value and the test subject must match.
if reflect.DeepEqual(item, testValues) == false {
t.Errorf("Struct is different.")
}
}
func (self *Dh) FindByConditions(conditions interface{}) (uint64, api.Err) {
var errs api.Err
var res db.Result
res = Collection.Find(conditions)
count, _ := res.Count()
if count == 0 {
errs.Push(api.Msg{
Field: "Not found",
Error: api.ErrNoSuchRow,
})
return count, errs
}
res.One(self.Model)
return count, errs
}
func (self *Dh) FindByFieldValue(field string, value interface{}) (interface{}, api.Err) {
var errs api.Err
var res db.Result
res = Collection.Find(db.Cond{field: value})
count, _ := res.Count()
if count == 0 {
errs.Push(api.Msg{
Field: "Not found",
Error: api.ErrNoSuchRow,
})
return nil, errs
}
res.One(self.Model)
return self.Model, errs
}
// Nombre: Exist
// Verifica que exista un elemento en nuestra base de datos
// La busca por su PK
func (self *Dh) Exist() bool {
s := reflect.ValueOf(self.Model).Elem().Field(0)
id := s.Interface().(int64)
// change the field id
// fmt.Println(s.Interface().(int64))
// fmt.Println(reflect.ValueOf(self.Model).Elem().FieldByName("Id"),"data")
// id := reflect.ValueOf(self.Model).Elem().FieldByName("Id").Interface().(int64)
var res db.Result
res = Collection.Find(db.Cond{"id": id})
count, _ := res.Count()
if count == 0 {
return false
}
return true
}
// FindById
// Podemos hacer busquedas por PK Id este metodo
// recibe como parametro la pk de la tabla y trae todos sus
// elementos.
func (self *Dh) FindById(id int64) (interface{}, api.Err) {
var errs api.Err
var res db.Result
res = Collection.Find(db.Cond{"id": id})
count, _ := res.Count()
if count == 0 {
errs.Push(api.Msg{
Field: "Not found",
Error: api.ErrNoSuchRow,
})
return nil, errs
}
res.One(self.Model)
return self.Model, errs
}
// Nombre: Update
// Este metodo se encarga de actualizar un registro
// si ya fue creado en nuestra base de datos es llamado por el
// metodo save
func (self *Dh) Update() (interface{}, api.Err) {
var errs api.Err
var res db.Result
id := reflect.ValueOf(self.Model).Elem().FieldByName("Id").Interface().(int64)
res = Collection.Find(db.Cond{"id": id})
err := res.Update(self.Model)
if err != nil {
errs.Push(api.Msg{
Field: "Save",
Error: err.Error(),
})
return nil, errs
}
dataUpdate, errr := self.FindById(id)
return dataUpdate, errr
}
func (self *Dh) DeleteLogic() api.Err {
var errs api.Err
var res db.Result
id := reflect.ValueOf(self.Model).Elem().FieldByName("Id").Interface().(int64)
res = Collection.Find(db.Cond{"id": id})
res.One(self.Model)
reflect.ValueOf(self.Model).Elem().FieldByName("Status").SetBool(false)
// Estatus := reflect.ValueOf(self.Model).Elem().FieldByName("Estatus").Interface().(bool)
err := res.Update(self.Model)
if err != nil {
errs.Push(api.Msg{
Field: "Save",
Error: err.Error(),
})
return errs
}
return errs
}
// Attempts to delete previously added rows.
func TestRemove(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
// Getting the artist with id = 1
res = artist.Find(db.Cond{"id": 1})
// Trying to remove the row.
if err = res.Remove(); err != nil {
t.Fatal(err)
}
}
// Test database functions
func TestFunction(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(Adapter, settings)
if err != nil {
t.Fatal(err)
}
// We should close the database when it's no longer in use.
defer sess.Close()
// Getting a pointer to the "artist" collection.
artist, err := sess.Collection("artist")
if err != nil {
t.Fatal(err)
}
row_s := struct {
Id uint64
Name string
}{}
res = artist.Find(db.Cond{"_id $nin": []int{0, -1}})
if err = res.One(&row_s); err != nil {
t.Fatalf("One: %q", err)
}
res = artist.Find(db.Cond{"_id": db.Func{"$nin", []int{0, -1}}})
if err = res.One(&row_s); err != nil {
t.Fatalf("One: %q", err)
}
res.Close()
}
// Attempts to use functions within database queries.
func TestFunction(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
var total uint64
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
row_s := struct {
Id uint64
Name string
}{}
res = artist.Find(db.Cond{"id NOT IN": []int{0, -1}})
if err = res.One(&row_s); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 3 {
t.Fatalf("Expecting 3 items.")
}
res = artist.Find(db.Cond{"id": db.Func{"NOT IN", []int{0, -1}}})
if err = res.One(&row_s); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 3 {
t.Fatalf("Expecting 3 items.")
}
res.Close()
}
// Attempts to use functions within database queries.
func TestFunction(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
var total uint64
var rowMap map[string]interface{}
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
rowStruct := struct {
ID uint64
Name string
}{}
res = artist.Find(db.Cond{"id NOT IN": []int{0, -1}})
if err = res.One(&rowStruct); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 4 {
t.Fatalf("Expecting 4 items.")
}
// Testing conditions
res = artist.Find(db.Cond{"id": db.Func{"NOT IN", []int{0, -1}}})
if err = res.One(&rowStruct); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 4 {
t.Fatalf("Expecting 4 items.")
}
// Testing DISTINCT (function)
res = artist.Find().Select(
db.Func{`DISTINCT`, `name`},
)
if err = res.One(&rowMap); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 4 {
t.Fatalf("Expecting 4 items.")
}
// Testing DISTINCT (raw)
res = artist.Find().Select(
db.Raw{`DISTINCT(name)`},
)
if err = res.One(&rowMap); err != nil {
t.Fatal(err)
}
if total, err = res.Count(); err != nil {
t.Fatal(err)
}
if total != 4 {
t.Fatalf("Expecting 4 items.")
}
res.Close()
}
// Attempts to fetch results one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
// Dumping into a map.
rowMap := map[string]interface{}{}
res = artist.Find()
for {
err = res.Next(&rowMap)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if to.Int64(rowMap["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
if to.String(rowMap["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into an struct with no tags.
rowStruct := struct {
ID uint64
Name string
}{}
res = artist.Find()
for {
err = res.Next(&rowStruct)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if rowStruct.ID == 0 {
t.Fatalf("Expecting a not null ID.")
}
if rowStruct.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into a tagged struct.
rowStruct2 := struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&rowStruct2)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if rowStruct2.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
if rowStruct2.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into an slice of maps.
allRowsMap := []map[string]interface{}{}
res = artist.Find()
if err = res.All(&allRowsMap); err != nil {
t.Fatal(err)
}
if len(allRowsMap) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowMap := range allRowsMap {
if to.Int64(singleRowMap["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Dumping into an slice of structs.
allRowsStruct := []struct {
ID uint64
Name string
}{}
res = artist.Find()
if err = res.All(&allRowsStruct); err != nil {
t.Fatal(err)
}
if len(allRowsStruct) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowStruct := range allRowsStruct {
if singleRowStruct.ID == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Dumping into an slice of tagged structs.
allRowsStruct2 := []struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
if err = res.All(&allRowsStruct2); err != nil {
t.Fatal(err)
}
if len(allRowsStruct2) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowStruct2 := range allRowsStruct2 {
if singleRowStruct2.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
}
func (self *Dh) CountByConditions(conditions interface{}) uint64 {
var res db.Result
res = Collection.Find(conditions)
count, _ := res.Count()
return count
}
func (self *Dh) FindAllCount() uint64 {
var res db.Result
res = Collection.Find()
count, _ := res.Count()
return count
}
func main() {
// Attemping to establish a connection to the database.
sess, err := db.Open("postgresql", settings)
if err != nil {
log.Fatalf("db.Open(): %q\n", err)
}
// Remember to close the database session.
defer sess.Close()
// Pointing to the "birthdays" table.
birthdayCollection, err := sess.Collection("birthdays")
if err != nil {
log.Fatalf("sess.Collection(): %q\n", err)
}
// Attempt to remove existing rows (if any).
err = birthdayCollection.Truncate()
if err != nil {
log.Fatalf("Truncate(): %q\n", err)
}
// Inserting some rows into the "birthdays" table.
birthdayCollection.Append(Birthday{
Name: "Hayao Miyazaki",
Born: time.Date(1941, time.January, 5, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Nobuo Uematsu",
Born: time.Date(1959, time.March, 21, 0, 0, 0, 0, time.UTC),
})
birthdayCollection.Append(Birthday{
Name: "Hironobu Sakaguchi",
Born: time.Date(1962, time.November, 25, 0, 0, 0, 0, time.UTC),
})
// Let's query for the results we've just inserted.
var res db.Result
res = birthdayCollection.Find()
var birthdays []Birthday
// Query all results and fill the birthdays variable with them.
err = res.All(&birthdays)
if err != nil {
log.Fatalf("res.All(): %q\n", err)
}
// Printing to stdout.
for _, birthday := range birthdays {
fmt.Printf("%s was born in %s.\n", birthday.Name, birthday.Born.Format("January 2, 2006"))
}
}
// This test uses and result and tries to fetch items one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(Adapter, settings)
if err != nil {
t.Fatal(err)
}
// We should close the database when it's no longer in use.
defer sess.Close()
artist, err := sess.Collection("artist")
if err != nil {
t.Fatal(err)
}
// Testing map
res = artist.Find()
row_m := map[string]interface{}{}
for {
err = res.Next(&row_m)
if err == db.ErrNoMoreRows {
// No more row_ms left.
break
}
if err == nil {
if row_m["_id"] == nil {
t.Fatalf("Expecting an ID.")
}
if _, ok := row_m["_id"].(bson.ObjectId); ok != true {
t.Fatalf("Expecting a bson.ObjectId.")
}
if row_m["_id"].(bson.ObjectId).Valid() != true {
t.Fatalf("Expecting a valid bson.ObjectId.")
}
if to.String(row_m["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing struct
row_s := struct {
Id bson.ObjectId `bson:"_id"`
Name string `bson:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_s)
if err == db.ErrNoMoreRows {
// No more row_s' left.
break
}
if err == nil {
if row_s.Id.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
if row_s.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing tagged struct
row_t := struct {
Value1 bson.ObjectId `bson:"_id"`
Value2 string `bson:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_t)
if err == db.ErrNoMoreRows {
// No more row_t's left.
break
}
if err == nil {
if row_t.Value1.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
if row_t.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing Result.All() with a slice of maps.
res = artist.Find()
all_rows_m := []map[string]interface{}{}
err = res.All(&all_rows_m)
if err != nil {
t.Fatal(err)
}
for _, single_row_m := range all_rows_m {
if single_row_m["_id"] == nil {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of structs.
res = artist.Find()
all_rows_s := []struct {
Id bson.ObjectId `bson:"_id"`
Name string
}{}
err = res.All(&all_rows_s)
if err != nil {
t.Fatal(err)
}
for _, single_row_s := range all_rows_s {
if single_row_s.Id.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of tagged structs.
res = artist.Find()
all_rows_t := []struct {
Value1 bson.ObjectId `bson:"_id"`
Value2 string `bson:"name"`
}{}
err = res.All(&all_rows_t)
if err != nil {
t.Fatal(err)
}
for _, single_row_t := range all_rows_t {
if single_row_t.Value1.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
}
}
func (r *result) buildQuery(col db.Collection) (db.Result, error) {
var res db.Result
if r.args.where == nil {
res = col.Find(db.Cond{})
} else {
res = col.Find((*r.args.where)...)
}
if r.args.limit != nil {
res = res.Limit(*r.args.limit)
}
if r.args.skip != nil {
res = res.Skip(*r.args.skip)
}
if r.args.sort != nil {
res = res.Sort((*r.args.sort)...)
}
if r.args.fields != nil {
res = res.Select((*r.args.fields)...)
}
if r.args.group != nil {
res = res.Group((*r.args.group)...)
}
return res, nil
}
func TestExplicitAndDefaultMapping(t *testing.T) {
var err error
var col db.Collection
var sess db.Database
var res db.Result
var testE mapE
var testN mapN
for _, wrapper := range wrappers {
if settings[wrapper] == nil {
t.Fatalf(`No such settings entry for wrapper %s.`, wrapper)
} else {
if sess, err = db.Open(wrapper, *settings[wrapper]); err != nil {
t.Fatalf(`Test for wrapper %s failed: %q`, wrapper, err)
}
defer sess.Close()
col, err = sess.Collection("Case_Test")
if col, err = sess.Collection("CaSe_TesT"); err != nil {
if wrapper == `mongo` && err == db.ErrCollectionDoesNotExist {
// Nothing, it's expected.
} else {
t.Fatal(err)
}
}
if err = col.Truncate(); err != nil {
if wrapper == `mongo` {
// Nothing, it's expected.
} else {
t.Fatal(err)
}
}
// Testing explicit mapping.
testE = mapE{
CaseTest: "Hello!",
}
if _, err = col.Append(testE); err != nil {
t.Fatal(err)
}
res = col.Find(db.Cond{"Case_Test": "Hello!"})
if wrapper == `ql` {
res = res.Select(`id() as ID`, `Case_Test`)
}
if err = res.One(&testE); err != nil {
t.Fatal(err)
}
if wrapper == `mongo` {
if testE.MongoID.Valid() == false {
t.Fatalf("Expecting an ID.")
}
} else {
if testE.ID == 0 {
t.Fatalf("Expecting an ID.")
}
}
// Testing default mapping.
testN = mapN{
Casetest: "World!",
}
if _, err = col.Append(testN); err != nil {
t.Fatal(err)
}
if wrapper == `mongo` {
// We don't have this kind of control with mongodb.
res = col.Find(db.Cond{"casetest": "World!"})
} else {
res = col.Find(db.Cond{"Case_Test": "World!"})
}
if wrapper == `ql` {
res = res.Select(`id() as ID`, `Case_Test`)
}
if err = res.One(&testN); err != nil {
t.Fatal(err)
}
if wrapper == `mongo` {
if testN.MongoID.Valid() == false {
t.Fatalf("Expecting an ID.")
}
} else {
if testN.ID == 0 {
t.Fatalf("Expecting an ID.")
}
}
}
}
}
func TestFibonacci(t *testing.T) {
var err error
var res db.Result
var total uint64
for _, wrapper := range wrappers {
if settings[wrapper] == nil {
t.Fatalf(`No such settings entry for wrapper %s.`, wrapper)
} else {
var sess db.Database
sess, err = db.Open(wrapper, *settings[wrapper])
if err != nil {
t.Fatalf(`Test for wrapper %s failed: %q`, wrapper, err)
}
defer sess.Close()
var col db.Collection
col, err = sess.Collection("fibonacci")
if err != nil {
if wrapper == `mongo` && err == db.ErrCollectionDoesNotExist {
// Expected error with mongodb.
} else {
t.Fatalf(`Could not use collection with wrapper %s: %q`, wrapper, err)
}
}
// Adding some items.
var i uint64
for i = 0; i < 10; i++ {
item := fibonacci{Input: i, Output: fib(i)}
_, err = col.Append(item)
if err != nil {
t.Fatalf(`Could not append item with wrapper %s: %q`, wrapper, err)
}
}
// Testing sorting by function.
res = col.Find(
// 5, 6, 7, 3
db.Or{
db.And{
db.Cond{"input >=": 5},
db.Cond{"input <=": 7},
},
db.Cond{"input": 3},
},
)
// Testing sort by function.
switch wrapper {
case `postgresql`:
res = res.Sort(db.Raw{`RANDOM()`})
case `sqlite`:
res = res.Sort(db.Raw{`RANDOM()`})
case `mysql`:
res = res.Sort(db.Raw{`RAND()`})
}
total, err = res.Count()
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf("%s: Expecting a count of 4, got %d.", wrapper, total)
}
// Find() with IN/$in
var whereIn db.Cond
switch wrapper {
case `mongo`:
whereIn = db.Cond{"input": db.Func{"$in", []int{3, 5, 6, 7}}}
default:
whereIn = db.Cond{"input": db.Func{"IN", []int{3, 5, 6, 7}}}
}
res = col.Find(whereIn).Sort("input")
total, err = res.Count()
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf(`Expecting a count of 4.`)
}
res = res.Skip(1).Limit(2)
for {
var item fibonacci
err = res.Next(&item)
if err == nil {
switch item.Input {
case 5:
case 6:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
} else if err == db.ErrNoMoreRows {
break
} else {
t.Fatalf(`%s: %q`, wrapper, err)
}
}
// Find() with range
res = col.Find(
// 5, 6, 7, 3
db.Or{
db.And{
db.Cond{"input >=": 5},
db.Cond{"input <=": 7},
},
db.Cond{"input": 3},
},
).Sort("-input")
if total, err = res.Count(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf(`Expecting a count of 4.`)
}
// Skipping.
res = res.Skip(1).Limit(2)
for {
var item fibonacci
err = res.Next(&item)
if err == nil {
switch item.Input {
case 5:
case 6:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
} else if err == db.ErrNoMoreRows {
break
} else {
t.Fatalf(`%s: %q`, wrapper, err)
}
}
if err = res.Remove(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total, err = res.Count(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 0 {
t.Fatalf(`%s: Unexpected count %d.`, wrapper, total)
}
res = col.Find()
total, err = res.Count()
if total != 6 {
t.Fatalf(`%s: Unexpected count %d.`, wrapper, total)
}
var items []fibonacci
err = res.All(&items)
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
for _, item := range items {
switch item.Input {
case 0:
case 1:
case 2:
case 4:
case 8:
case 9:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
}
err = res.Close()
if err != nil {
t.Errorf("Failed to close result %s: %q.", wrapper, err)
}
err = sess.Close()
if err != nil {
t.Errorf("Failed to close %s: %q.", wrapper, err)
}
}
}
}
func TestSimpleCRUD(t *testing.T) {
var err error
var controlItem birthday
for _, wrapper := range wrappers {
if settings[wrapper] == nil {
t.Fatalf(`No such settings entry for wrapper %s.`, wrapper)
} else {
var sess db.Database
sess, err = db.Open(wrapper, *settings[wrapper])
if err != nil {
t.Fatalf(`Test for wrapper %s failed: %q`, wrapper, err)
}
defer sess.Close()
born := time.Date(1941, time.January, 5, 0, 0, 0, 0, time.Local)
controlItem = birthday{
Name: "Hayao Miyazaki",
Born: born,
BornUT: &timeType{born},
}
col, err := sess.Collection(`birthdays`)
if err != nil {
if wrapper == `mongo` && err == db.ErrCollectionDoesNotExist {
// Expected error with mongodb.
} else {
t.Fatalf(`Could not use collection with wrapper %s: %q`, wrapper, err)
}
}
var id interface{}
if id, err = col.Append(controlItem); err != nil {
t.Fatalf(`Could not append item with wrapper %s: %q`, wrapper, err)
}
var res db.Result
switch wrapper {
case `mongo`:
res = col.Find(db.Cond{"_id": id.(bson.ObjectId)})
case `ql`:
res = col.Find(db.Cond{"id()": id})
default:
res = col.Find(db.Cond{"id": id})
}
var total uint64
total, err = res.Count()
if total != 1 {
t.Fatalf("%s: Expecting one row.", wrapper)
}
// No support for Marshaler and Unmarshaler is implemeted for QL and
// MongoDB.
if wrapper == `ql` || wrapper == `mongo` {
continue
}
var testItem birthday
err = res.One(&testItem)
if err != nil {
t.Fatalf("%s One(): %s", wrapper, err)
}
if reflect.DeepEqual(testItem, controlItem) == false {
t.Errorf("%s: testItem: %v (ts: %v)\n", wrapper, testItem, testItem.BornUT.value.Unix())
t.Errorf("%s: controlItem: %v (ts: %v)\n", wrapper, controlItem, controlItem.BornUT.value.Unix())
t.Fatalf("%s: Structs are different", wrapper)
}
var testItems []birthday
err = res.All(&testItems)
if err != nil {
t.Fatalf("%s All(): %s", wrapper, err)
}
if len(testItems) == 0 {
t.Fatalf("%s All(): Expecting at least one row.", wrapper)
}
for _, testItem = range testItems {
if reflect.DeepEqual(testItem, controlItem) == false {
t.Errorf("%s: testItem: %v\n", wrapper, testItem)
t.Errorf("%s: controlItem: %v\n", wrapper, controlItem)
t.Fatalf("%s: Structs are different", wrapper)
}
}
controlItem.Name = `宮崎駿`
err = res.Update(controlItem)
if err != nil {
t.Fatalf(`Could not update with wrapper %s: %q`, wrapper, err)
}
res.One(&testItem)
if reflect.DeepEqual(testItem, controlItem) == false {
t.Fatalf("Struct is different with wrapper %s.", wrapper)
}
err = res.Remove()
if err != nil {
t.Fatalf(`Could not remove with wrapper %s: %q`, wrapper, err)
}
total, err = res.Count()
if total != 0 {
t.Fatalf(`Expecting no items %s: %q`, wrapper, err)
}
err = res.Close()
if err != nil {
t.Errorf("Failed to close result %s: %q.", wrapper, err)
}
err = sess.Close()
if err != nil {
t.Errorf("Failed to close %s: %q.", wrapper, err)
}
}
}
}
// This test uses and result and tries to fetch items one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
// We should close the database when it's no longer in use.
defer sess.Close()
artist, err := sess.Collection("artist")
if err != nil {
t.Fatalf(err.Error())
}
// Testing map
res = artist.Find()
row_m := map[string]interface{}{}
for {
err = res.Next(&row_m)
if err == db.ErrNoMoreRows {
// No more row_ms left.
break
}
if err == nil {
if to.Int64(row_m["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
if to.String(row_m["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing struct
row_s := struct {
Id uint64
Name string
}{}
res = artist.Find()
for {
err = res.Next(&row_s)
if err == db.ErrNoMoreRows {
// No more row_s' left.
break
}
if err == nil {
if row_s.Id == 0 {
t.Fatalf("Expecting a not null ID.")
}
if row_s.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing tagged struct
row_t := struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_t)
if err == db.ErrNoMoreRows {
// No more row_t's left.
break
}
if err == nil {
if row_t.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
if row_t.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing Result.All() with a slice of maps.
res = artist.Find()
all_rows_m := []map[string]interface{}{}
err = res.All(&all_rows_m)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_m := range all_rows_m {
if to.Int64(single_row_m["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of structs.
res = artist.Find()
all_rows_s := []struct {
Id uint64
Name string
}{}
err = res.All(&all_rows_s)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_s := range all_rows_s {
if single_row_s.Id == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of tagged structs.
res = artist.Find()
all_rows_t := []struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
err = res.All(&all_rows_t)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_t := range all_rows_t {
if single_row_t.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
}