func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) (
*dbox.DataSet, error) {
if closeWhenDone {
defer c.Close()
}
e := c.prepIter()
if e != nil {
return nil, errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
ds := dbox.NewDataSet(m)
// lineCount := 0
//=============================
maxGetData := c.count
if n > 0 {
maxGetData = c.fetchRow + n
}
linecount := 0
for _, row := range c.reader.Sheet[c.sheetname].Rows {
isAppend := true
recData := toolkit.M{}
appendData := toolkit.M{}
for i, cell := range row.Cells {
if i < len(c.headerColumn) {
recData.Set(c.headerColumn[i].name, cell.Value)
if c.ConditionVal.Select == nil || c.ConditionVal.Select.Get("*", 0).(int) == 1 {
appendData.Set(c.headerColumn[i].name, cell.Value)
} else {
if c.ConditionVal.Select.Get(c.headerColumn[i].name, 0).(int) == 1 {
appendData.Set(c.headerColumn[i].name, cell.Value)
}
}
}
}
isAppend = c.ConditionVal.getCondition(recData)
if c.fetchRow < c.ConditionVal.skip || (c.fetchRow > (c.ConditionVal.skip+c.ConditionVal.limit) && c.ConditionVal.limit > 0) {
isAppend = false
}
if isAppend && len(appendData) > 0 {
linecount += 1
if linecount > c.fetchRow {
ds.Data = append(ds.Data, appendData)
c.fetchRow += 1
}
}
if c.fetchRow >= maxGetData {
break
}
}
return ds, nil
}
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) (
*dbox.DataSet, error) {
ds := dbox.NewDataSet(m)
fmt.Println(c.QueryString)
rows, e := c.session.Query(c.QueryString)
if e != nil {
return nil, e
}
defer rows.Close()
columns, e := rows.Columns()
if e != nil {
return nil, e
}
count := len(columns)
tableData := make([]map[string]interface{}, 0)
values := make([]interface{}, count)
valuePtrs := make([]interface{}, count)
for rows.Next() {
for i := 0; i < count; i++ {
valuePtrs[i] = &values[i]
}
rows.Scan(valuePtrs...)
entry := make(map[string]interface{})
for i, col := range columns {
var v interface{}
val := values[i]
b, ok := val.([]byte)
if ok {
v = string(b)
} else {
v = val
}
entry[col] = v
}
tableData = append(tableData, entry)
}
if e != nil {
return nil, e
}
if n == 0 {
for i := 0; i < len(tableData); i++ {
ds.Data = append(ds.Data, tableData[i])
}
} else {
end := c.start + n
if end > len(tableData) {
e = errors.New("index out of range")
} else {
for i := c.start; i < end; i++ {
ds.Data = append(ds.Data, tableData[i])
c.start = i + 1
}
e = nil
}
}
return ds, e
}
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) (
*dbox.DataSet, error) {
if closeWhenDone {
c.Close()
}
e := c.prepIter()
if e != nil {
return nil, errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
if c.jsonSelect == nil {
return nil, errorlib.Error(packageName, modCursor, "Fetch", "Iter object is not yet initialized")
}
datas := []interface{}{}
dec := json.NewDecoder(strings.NewReader(string(c.readFile)))
dec.Decode(&datas)
ds := dbox.NewDataSet(m)
if n == 0 {
whereFieldsToMap, _ := toolkit.ToM(c.whereFields)
b := c.getCondition(whereFieldsToMap)
var foundSelected = toolkit.M{}
var foundData = []toolkit.M{}
var getRemField = toolkit.M{}
if c.isWhere {
if b {
for _, v := range datas {
for i, subData := range v.(map[string]interface{}) {
getRemField[i] = i //append(getRemField, i)
for _, vWhere := range whereFieldsToMap {
for _, subWhere := range vWhere.([]interface{}) {
for _, subsubWhere := range subWhere.(map[string]interface{}) {
if len(c.jsonSelect.([]string)) == 0 {
if strings.ToLower(subData.(string)) == strings.ToLower(subsubWhere.(string)) {
ds.Data = append(ds.Data, v)
}
} else {
if strings.ToLower(subData.(string)) == strings.ToLower(subsubWhere.(string)) {
foundData = append(foundData, v.(map[string]interface{}))
}
}
}
}
}
}
}
itemToRemove := removeDuplicatesUnordered(getRemField, c.jsonSelect.([]string))
if len(foundData) > 0 {
var found toolkit.M
for _, found = range foundData {
for _, remitem := range itemToRemove {
found.Unset(remitem)
}
ds.Data = append(ds.Data, found)
}
}
} else {
for _, v := range datas {
for _, v2 := range v.(map[string]interface{}) {
for _, vWhere := range c.whereFields.(toolkit.M) {
if reflect.ValueOf(v2).Kind() == reflect.String {
if strings.ToLower(v2.(string)) == strings.ToLower(vWhere.(string)) {
if len(c.jsonSelect.([]string)) == 0 {
ds.Data = append(ds.Data, v)
} else {
// fmt.Println(c.jsonSelect.([]string)[0])
// fmt.Println(v.(map[string]interface{}))
foundData = append(foundData, v.(map[string]interface{}))
}
}
}
}
}
}
if len(foundData) > 0 {
for _, found := range foundData {
for i, subData := range found {
for _, selected := range c.jsonSelect.([]string) {
if strings.ToLower(selected) == strings.ToLower(i) {
foundSelected[i] = subData
} else if selected == "*" {
foundSelected[i] = subData
}
}
}
}
ds.Data = append(ds.Data, foundSelected)
}
}
} else {
if c.jsonSelect.([]string)[0] != "*" {
for _, v := range datas {
for i, _ := range v.(map[string]interface{}) {
getRemField[i] = i
}
}
itemToRemove := removeDuplicatesUnordered(getRemField, c.jsonSelect.([]string))
for _, found := range datas {
toMap := toolkit.M(found.(map[string]interface{}))
for _, remitem := range itemToRemove {
toMap.Unset(remitem)
}
ds.Data = append(ds.Data, found)
}
} else {
ds.Data = datas
}
}
} else if n > 0 {
fetched := 0
fetching := true
///read line
fetchFile, e := os.OpenFile(c.tempPathFile, os.O_RDWR, 0)
defer fetchFile.Close()
if e != nil {
return nil, errorlib.Error(packageName, modQuery+".Exec", "Fetch file", e.Error())
}
c.fetchSession = fetchFile
scanner := bufio.NewScanner(fetchFile)
lines := 0
for scanner.Scan() {
lines++
}
if lines > 0 {
fetched = lines
n = n + lines
}
for fetching {
var dataM = toolkit.M{}
if c.jsonSelect.([]string)[0] != "*" {
for i := 0; i < len(c.jsonSelect.([]string)); i++ {
dataM[c.jsonSelect.([]string)[i]] = datas[fetched].(map[string]interface{})[c.jsonSelect.([]string)[i]]
if len(dataM) == len(c.jsonSelect.([]string)) {
ds.Data = append(ds.Data, dataM)
}
}
} else {
ds.Data = append(ds.Data, datas[fetched])
}
io.WriteString(fetchFile, toolkit.JsonString(dataM)+"\n")
fetched++
if fetched == n {
fetching = false
}
}
}
// c.Close()
return ds, nil
}
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) (
*dbox.DataSet, error) {
if closeWhenDone {
defer c.Close()
}
e := c.prepIter()
if e != nil {
return nil, errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
ds := dbox.NewDataSet(m)
lineCount := 0
//=============================
for {
isAppend := true
c.count += 1
recData := toolkit.M{}
appendData := toolkit.M{}
dataTemp, e := c.reader.Read()
for i, val := range dataTemp {
recData[c.headerColumn[i].name] = val
if c.ConditionVal.Select == nil || c.ConditionVal.Select.Get("*", 0).(int) == 1 {
appendData[c.headerColumn[i].name] = val
} else {
if c.ConditionVal.Select.Get(c.headerColumn[i].name, 0).(int) == 1 {
appendData[c.headerColumn[i].name] = val
}
}
}
isAppend = c.ConditionVal.getCondition(recData)
if c.count < c.ConditionVal.skip || (c.count > (c.ConditionVal.skip+c.ConditionVal.limit) && c.ConditionVal.limit > 0) {
isAppend = false
}
if e == io.EOF {
if isAppend && len(appendData) > 0 {
ds.Data = append(ds.Data, appendData)
lineCount += 1
}
break
} else if e != nil {
return ds, errorlib.Error(packageName, modCursor,
"Fetch", e.Error())
}
if isAppend && len(appendData) > 0 {
ds.Data = append(ds.Data, appendData)
lineCount += 1
}
if n > 0 {
if lineCount >= n {
break
}
}
}
return ds, nil
}