func TestSelectFilter(t *testing.T) {
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect %s \n", e.Error())
return
}
defer c.Close()
csr, e := c.NewQuery().
Select("id", "name").
Where((dbox.Gt("id", "2222"))).
From("tes").Cursor(nil)
if e != nil {
t.Errorf("Cursor pre error: %s \n", e.Error())
return
}
if csr == nil {
t.Errorf("Cursor not initialized")
return
}
defer csr.Close()
//rets := []toolkit.M{}
ds, e := csr.Fetch(nil, 0, false)
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
fmt.Printf("Fetch N OK. Result: %v \n",
ds.Data)
}
}
func filterCondition(cond toolkit.M) *dbox.Filter {
fb := new(dbox.Filter)
for key, val := range cond {
if key == "$and" || key == "$or" {
afb := []*dbox.Filter{}
for _, sVal := range val.([]interface{}) {
rVal := sVal.(map[string]interface{})
mVal := toolkit.M{}
for rKey, mapVal := range rVal {
mVal.Set(rKey, mapVal)
}
afb = append(afb, filterCondition(mVal))
}
if key == "$and" {
fb = dbox.And(afb...)
} else {
fb = dbox.Or(afb...)
}
} else {
if reflect.ValueOf(val).Kind() == reflect.Map {
mVal := val.(map[string]interface{})
tomVal, _ := toolkit.ToM(mVal)
switch {
case tomVal.Has("$eq"):
fb = dbox.Eq(key, tomVal["$eq"].(string))
case tomVal.Has("$ne"):
fb = dbox.Ne(key, tomVal["$ne"].(string))
case tomVal.Has("$regex"):
fb = dbox.Contains(key, tomVal["$regex"].(string))
case tomVal.Has("$gt"):
fb = dbox.Gt(key, tomVal["$gt"].(string))
case tomVal.Has("$gte"):
fb = dbox.Gte(key, tomVal["$gte"].(string))
case tomVal.Has("$lt"):
fb = dbox.Lt(key, tomVal["$lt"].(string))
case tomVal.Has("$lte"):
fb = dbox.Lte(key, tomVal["$lte"].(string))
}
} else {
fb = dbox.Eq(key, val)
}
}
}
return fb
}
func TestSelect(t *testing.T) {
// t.Skip()
skipIfConnectionIsNil(t)
cursor, e := ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150), dbox.Eq("nama", "buku"))).
// Where(dbox.Contains("nama", "tem", "pe")).
// Order("nama").
// Skip(2).
// Take(1).
Cursor(nil)
// Where(dbox.And(dbox.Gt("price", "@price"), dbox.Eq("status", "@status"))).
// Cursor(toolkit.M{}.Set("@price", 100000).Set("@status", "available"))
// Where(dbox.And(dbox.Or(dbox.Eq("nama", "@name1"), dbox.Eq("nama", "@name2"),
// dbox.Eq("nama", "@name3")), dbox.Lt("quantity", "@quantity"))).
// Cursor(toolkit.M{}.Set("@name1", "buku").Set("@name2", "tas").
// Set("@name3", "dompet").Set("@quantity", 4))
if e != nil {
t.Fatalf("Cursor error: " + e.Error())
}
defer cursor.Close()
var results []toolkit.M
e = cursor.Fetch(&results, 0, false)
operation = "Test Select Filter"
sintaks = `
ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150000),
dbox.Eq("nama", "buku"))).
Cursor(nil)`
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
toolkit.Println("======================")
toolkit.Println(operation)
toolkit.Println("======================")
toolkit.Println(sintaks)
toolkit.Println("Fetch OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
// if e != nil {
// t.Errorf("Unable to fetch: %s \n", e.Error())
// } else {
// toolkit.Println("======================")
// toolkit.Println(operation)
// toolkit.Println("======================")
// toolkit.Println(sintaks)
// toolkit.Println("Fetch OK. Result:")
// for _, val := range results {
// toolkit.Printf("%v \n",
// toolkit.JsonString(val))
// }
// }
// }
func TestSelectFilter(t *testing.T) {
// t.Skip()
skipIfConnectionIsNil(t)
cursor, e := ctx.NewQuery().
Select("_id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150), dbox.Eq("nama", "buku"))).
Cursor(nil)
operation = "TestSelectFilter"
sintaks = `
ctx.NewQuery().
Select("_id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150000),
dbox.Eq("nama", "buku"))).
Cursor(nil)`
if e != nil {
t.Fatalf("Cursor error: " + e.Error())
}
defer cursor.Close()
if cursor.Count() == 0 {
t.Fatalf("No record found")
}
var results []toolkit.M
e = cursor.Fetch(&results, 0, false)
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
toolkit.Println("======================")
toolkit.Println(operation)
toolkit.Println("======================")
toolkit.Println(sintaks)
toolkit.Println("Fetch OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
func TestSelectParameter(t *testing.T) {
t.Skip()
skipIfConnectionIsNil(t)
cursor, e := ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("price", "@price"), dbox.Eq("status", "@status"))).
Cursor(toolkit.M{}.Set("@price", 100).Set("@status", "available"))
if e != nil {
t.Fatalf("Cursor error: " + e.Error())
}
defer cursor.Close()
var results []toolkit.M
e = cursor.Fetch(&results, 0, false)
operation = "Test Select Parameter"
sintaks = `
ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("price", "@price"),
dbox.Eq("status", "@status"))).
Cursor(toolkit.M{}.Set("@price", 100).
Set("@status", "available"))`
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
toolkit.Println("======================")
toolkit.Println(operation)
toolkit.Println("======================")
toolkit.Println(sintaks)
toolkit.Println("Fetch OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
func (d *DataSourceController) filterParse(where toolkit.M) *dbox.Filter {
field := where.Get("field", "").(string)
value := fmt.Sprintf("%v", where["value"])
if key := where.Get("key", "").(string); key == "Eq" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Eq(field, valueInt)
} else {
return dbox.Eq(field, value)
}
} else if key == "Ne" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Ne(field, valueInt)
} else {
return dbox.Ne(field, value)
}
} else if key == "Lt" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Lt(field, valueInt)
} else {
return dbox.Lt(field, value)
}
} else if key == "Lte" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Lte(field, valueInt)
} else {
return dbox.Lte(field, value)
}
} else if key == "Gt" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Gt(field, valueInt)
} else {
return dbox.Gt(field, value)
}
} else if key == "Gte" {
valueInt, errv := strconv.Atoi(fmt.Sprintf("%v", where["value"]))
if errv == nil {
return dbox.Gte(field, valueInt)
} else {
return dbox.Gte(field, value)
}
} else if key == "In" {
valueArray := []interface{}{}
for _, e := range strings.Split(value, ",") {
valueArray = append(valueArray, strings.Trim(e, ""))
}
return dbox.In(field, valueArray...)
} else if key == "Nin" {
valueArray := []interface{}{}
for _, e := range strings.Split(value, ",") {
valueArray = append(valueArray, strings.Trim(e, ""))
}
return dbox.Nin(field, valueArray...)
} else if key == "Contains" {
return dbox.Contains(field, value)
} else if key == "Or" {
subs := where.Get("value", []interface{}{}).([]interface{})
filtersToMerge := []*dbox.Filter{}
for _, eachSub := range subs {
eachWhere, _ := toolkit.ToM(eachSub)
filtersToMerge = append(filtersToMerge, d.filterParse(eachWhere))
}
return dbox.Or(filtersToMerge...)
} else if key == "And" {
subs := where.Get("value", []interface{}{}).([]interface{})
filtersToMerge := []*dbox.Filter{}
for _, eachSub := range subs {
eachWhere, _ := toolkit.ToM(eachSub)
filtersToMerge = append(filtersToMerge, d.filterParse(eachWhere))
}
return dbox.And(filtersToMerge...)
}
return nil
}
func filterCondition(cond toolkit.M) *dbox.Filter {
fb := new(dbox.Filter)
for key, val := range cond {
if key == "$and" || key == "$or" {
afb := []*dbox.Filter{}
for _, sVal := range val.([]interface{}) {
rVal := sVal.(map[string]interface{})
mVal := toolkit.M{}
for rKey, mapVal := range rVal {
mVal.Set(rKey, mapVal)
}
afb = append(afb, filterCondition(mVal))
}
if key == "$and" {
fb = dbox.And(afb...)
} else {
fb = dbox.Or(afb...)
}
} else {
if toolkit.TypeName(val) == "map[string]interface {}" {
mVal := val.(map[string]interface{})
tomVal, _ := toolkit.ToM(mVal)
switch {
case tomVal.Has("$eq"):
fb = dbox.Eq(key, tomVal["$eq"])
case tomVal.Has("$ne"):
fb = dbox.Ne(key, tomVal["$ne"])
case tomVal.Has("$regex"):
fb = dbox.Contains(key, toolkit.ToString(tomVal["$regex"]))
case tomVal.Has("$gt"):
fb = dbox.Gt(key, tomVal["$gt"])
case tomVal.Has("$gte"):
fb = dbox.Gte(key, tomVal["$gte"])
case tomVal.Has("$lt"):
fb = dbox.Lt(key, tomVal["$lt"])
case tomVal.Has("$lte"):
fb = dbox.Lte(key, tomVal["$lte"])
case tomVal.Has("$in"):
tval := make([]interface{}, 0, 0)
if toolkit.TypeName(tomVal["$in"]) == "[]interface {}" {
for _, tin := range tomVal["$in"].([]interface{}) {
tval = append(tval, tin)
}
} else {
tval = append(tval, tomVal["$in"])
}
fb = dbox.In(key, tval...)
case tomVal.Has("$nin"):
tval := make([]interface{}, 0, 0)
if toolkit.TypeName(tomVal["$nin"]) == "[]interface {}" {
for _, tin := range tomVal["$nin"].([]interface{}) {
tval = append(tval, tin)
}
} else {
tval = append(tval, tomVal["$nin"])
}
fb = dbox.Nin(key, tval...)
}
} else {
fb = dbox.Eq(key, val)
}
}
}
return fb
}