Need to understand the behavior, rows.Next_()

[Tracnac]

Hi,

I have a small comprehension problem, I try to figure out why Next_() does not return false when there's no more fetch to do, instead the loop run for the number of rows.
The purpose of Next_() is not to retrive the next rows based on the prefetch parameter ?
I'm a casual Go developper and English is not my native language, don't be too hard with me :)

A simplified and commented example with no specific logic, just to expose the question.

package main

import (
	"fmt"
	"os"

	go_ora "github.com/sijms/go-ora/v2"
)

func main() {
	var err error
	MsgErrorDie := func(msgText string, msgError error) {
		if msgError != nil {
			fmt.Println(msgText, msgError)
			os.Exit(1)
		}
	}

	DB, err := go_ora.NewConnection("oracle://tracnac:tracnac@192.168.122.90/xepdb1")
	MsgErrorDie("URL error: ", err)

	err = DB.Open()
	MsgErrorDie("DB open error: ", err)
	defer DB.Close()

	stmt := go_ora.NewStmt("select rownum as num from all_objects where rownum <= 25", DB)
	defer stmt.Close()

	rows, err := stmt.Query_(nil)
	MsgErrorDie("Query error: ", err)
	defer rows.Close()

	// We are fine here, 25 lines
	for k, v := range rows.Rows {
		fmt.Println(k, v)
	}

	count := 0
	for rows.Next_() { // There's no more fetch to do, why the method does not return False ?
		count += 1
	}
	// count = 25, it's the number of lines from the initial query fetch !?
	fmt.Println("Next count: ", count)
}

Thanks Yvan

[Tracnac]

Humm another questions...
Why RowCount always return 50 no matter the number of lines of the query ?
And is _hasMoreRows: false, that control the Next_() method ?

Thanks Yvan

[tracnac@blackhole test]$ dlv debug
Type 'help' for list of commands.
(dlv) break main.main
Breakpoint 1 set at 0x73059b for main.main() ./test.go:10
(dlv) continue
> main.main() ./test.go:10 (hits goroutine(1):1 total:1) (PC: 0x73059b)
     5:		"os"
     6:	
     7:		go_ora "github.com/sijms/go-ora/v2"
     8:	)
     9:	
=>  10:	func main() {
    11:		var err error
    12:		MsgErrorDie := func(msgText string, msgError error) {
    13:			if msgError != nil {
    14:				fmt.Println(msgText, msgError)
    15:				os.Exit(1)
(dlv) break main 30
Breakpoint main set at 0x73083f for main.main() ./test.go:30
(dlv) continue
> [main] main.main() ./test.go:30 (hits goroutine(1):1 total:1) (PC: 0x73083f)
    25:	
    26:		stmt := go_ora.NewStmt("select 1 from dual", DB)
    27:		defer stmt.Close()
    28:	
    29:		rows, err := stmt.Query_(nil)
=>  30:		MsgErrorDie("Query error: ", err)
    31:		defer rows.Close()
    32:	
    33:		// We are fine here, 25 lines
    34:		// for k, v := range rows.Rows {
    35:		// 	fmt.Println(k, v)
(dlv) print rows
*github.com/sijms/go-ora/v2.DataSet {
	ColumnCount: 1,
	RowCount: 50,
	UACBufferLength: 0,
	MaxRowSize: 2,
	Cols: []github.com/sijms/go-ora/v2.ParameterInfo len: 1, cap: 1, [
		(*"github.com/sijms/go-ora/v2.ParameterInfo")(0xc0001c0000),
	],
	Rows: []github.com/sijms/go-ora/v2.Row len: 1, cap: 1, [
		[
			*(*"database/sql/driver.Value")(0xc0000109e0),
		],
	],
	currentRow: github.com/sijms/go-ora/v2.Row len: 1, cap: 1, [
		nil,
	],
	lasterr: error nil,
	index: 0,
	parent: github.com/sijms/go-ora/v2.StmtInterface(*github.com/sijms/go-ora/v2.defaultStmt) *{
		connection: *(*"github.com/sijms/go-ora/v2.Connection")(0xc000132000),
		text: "select 1 from dual",
		arrayBindingCount: 0,
		disableCompression: false,
		_hasLONG: false,
		_hasBLOB: false,
		_hasMoreRows: false,
		_hasReturnClause: false,
		_noOfRowsToFetch: 25,
		stmtType: SELECT (1),
		cursorID: 1,
		queryID: 0,
		Pars: []github.com/sijms/go-ora/v2.ParameterInfo len: 0, cap: 0, nil,
		columns: []github.com/sijms/go-ora/v2.ParameterInfo len: 1, cap: 1, [
			(*"github.com/sijms/go-ora/v2.ParameterInfo")(0xc0001c00f0),
		],
		scnForSnapshot: []int len: 2, cap: 2, [25551823,0],
		arrayBindCount: 0,
		containOutputPars: false,},}
(dlv) 

[sijms]

HI Yvan
getting rows using dataSet.Rows is not correct because dataSet.Rows is an internal buffer act like circular buffer
to explain it more clear
repeat your query as follow:
select rownum as num from all_objects where rownum <= 90
the result of:

for k, v := range rows.Rows {
	fmt.Println(k, v)
}

will be only 50 rows which is actually the value of prefetch rows
but the result of:

count := 0
for rows.Next_() { 
    count += 1
}
fmt.Println("Next count: ", count)

will be 90
thus Next will act like forward-only cursor that retrieve any number of rows and only allocation memory that you defined by "PREFETCH_ROWS" url parameter

[Tracnac]

Hi,

Ok I understand my mistake scanning the rows.Rows as it's an array that has the size of the prefetch value (? not verified).
rows.Next take care of the fetch behind and reflect the actual number of lines of the query and it's NOT the number of fetch that are done database side.

Got it.

Thank you.

[sijms]

I will make a commit and hide all these parameters:

dataSet.rowCount
dataSet.row
dataSet.columnCount
dataSet.uACBufferLength
dataSet.maxRowSize

all these fields are used internally by DataSet to receive parameter from network and build necessary memory for reading operation
I make it exported before for testing and investigation purpose