Updated go-sqlite Next function

Author: djthorpe

pkg/indexer/indexer.go

@@ -173,9 +173,6 @@ func (i *Indexer) IsIndexing() bool {
 // Walk will initiate a walk of the index, and block until context is
 // cancelled or walk is started
 func (i *Indexer) Walk(ctx context.Context, fn WalkFunc) error {
-	if fn == nil {
-		return ErrBadParameter.With("WalkFunc")
-	}
 	select {
 	case <-ctx.Done():
 		return ctx.Err()

pkg/indexer/indexer_test.go

@@ -14,7 +14,7 @@ const (
 )
 
 func Test_Indexer_000(t *testing.T) {
-	indexer, err := NewIndexer("test", TEST_PATH_1)
+	indexer, err := NewIndexer("test", TEST_PATH_1, nil)
 	if err != nil {
 		t.Fatal(err)
 	} else {
@@ -28,7 +28,7 @@ func Test_Indexer_001(t *testing.T) {
 	defer cancel()
 
 	// Create indexer
-	indexer, err := NewIndexer("test", TEST_PATH_1)
+	indexer, err := NewIndexer("test", TEST_PATH_1, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -54,7 +54,7 @@ func Test_Indexer_001(t *testing.T) {
 	indexer.Exclude("/bin")
 	indexer.Exclude("/Projects")
 	indexer.Exclude("/Documents")
-	if err := indexer.Walk(ctx); err != nil {
+	if err := indexer.Walk(ctx, nil); err != nil {
 		t.Error(err)
 	}
 

pkg/indexer/schema.go

@@ -8,7 +8,7 @@ import (
 	// Namespace imports
 	. "github.com/mutablelogic/go-sqlite"
 	. "github.com/mutablelogic/go-sqlite/pkg/lang"
-	"github.com/mutablelogic/go-sqlite/pkg/quote"
+	. "github.com/mutablelogic/go-sqlite/pkg/quote"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -81,7 +81,7 @@ func CreateSchema(ctx context.Context, conn SQConnection, schema string, tokeniz
 			"parent",
 			"filename",
 			"content="+filesTableName,
-			"tokenize="+quote.Quote(tokenizer),
+			"tokenize="+Quote(tokenizer),
 		).IfNotExists()); err != nil {
 			return err
 		}
@@ -117,8 +117,8 @@ func ListIndexWithCount(ctx context.Context, conn SQConnection, schema string) (
 			return err
 		}
 		for {
-			row, err := r.Next()
-			if err != nil {
+			row := r.Next()
+			if row == nil {
 				break
 			}
 			if len(row) == 2 {
@@ -155,15 +155,24 @@ func Delete(schema string, evt *QueueEvent) (SQStatement, []interface{}) {
 		[]interface{}{evt.Name, evt.Path}
 }
 
-func Query(schema string, indexes []string) SQSelect {
-	return S(N(searchTableName).WithSchema(schema)).
-		To(
-			N("rowid"),
-			N("rank"),
-			N("name"),
-			N("parent"),
-			N("filename"),
-		).
-		Where(Q(searchTableName, " MATCH ", P)).
-		Order(N("rank"))
+func Query(schema string) SQSelect {
+	// Set the query join
+	queryJoin := J(
+		N(searchTableName).WithSchema(schema),
+		N(filesTableName).WithSchema(schema),
+	).LeftJoin(Q(N(searchTableName), ".rowid=", N(filesTableName), ".rowid"))
+
+	// Return the select
+	return S(queryJoin).To(
+		N("rowid").WithSchema(searchTableName),
+		N("rank").WithSchema(searchTableName),
+		N("name").WithSchema(filesTableName),
+		N("path").WithSchema(filesTableName),
+		N("parent").WithSchema(filesTableName),
+		N("filename").WithSchema(filesTableName),
+		N("isdir").WithSchema(filesTableName),
+		N("ext").WithSchema(filesTableName),
+		N("modtime").WithSchema(filesTableName),
+		N("size").WithSchema(filesTableName),
+	).Where(Q(searchTableName, " MATCH ", P)).Order(N("rank"))
 }

pkg/lang/select.go

@@ -4,41 +4,42 @@ import (
 	"fmt"
 	"strings"
 
-	sqlite "github.com/mutablelogic/go-sqlite"
+	// Namespace imports
+	. "github.com/mutablelogic/go-sqlite"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type sel struct {
-	source        []sqlite.SQSource
+	source        []SQExpr
 	distinct      bool
 	limit, offset uint
 	where         []interface{}
-	to            []sqlite.SQSource
-	order         []sqlite.SQSource
+	to            []SQSource
+	order         []SQSource
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
 // S defines a select statement
-func S(sources ...sqlite.SQSource) sqlite.SQSelect {
+func S(sources ...SQExpr) SQSelect {
 	return &sel{sources, false, 0, 0, nil, nil, nil}
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PROPERTIES
 
-func (this *sel) WithDistinct() sqlite.SQSelect {
+func (this *sel) WithDistinct() SQSelect {
 	return &sel{this.source, true, this.limit, this.offset, this.where, this.to, this.order}
 }
 
-func (this *sel) WithLimitOffset(limit, offset uint) sqlite.SQSelect {
+func (this *sel) WithLimitOffset(limit, offset uint) SQSelect {
 	return &sel{this.source, this.distinct, limit, offset, this.where, this.to, this.order}
 }
 
-func (this *sel) Where(v ...interface{}) sqlite.SQSelect {
+func (this *sel) Where(v ...interface{}) SQSelect {
 	if len(v) == 0 {
 		// Reset where clause
 		return &sel{this.source, this.distinct, this.limit, this.offset, nil, this.to, this.order}
@@ -47,7 +48,7 @@ func (this *sel) Where(v ...interface{}) sqlite.SQSelect {
 	return &sel{this.source, this.distinct, this.limit, this.offset, append(this.where, v...), this.to, this.order}
 }
 
-func (this *sel) To(v ...sqlite.SQSource) sqlite.SQSelect {
+func (this *sel) To(v ...SQSource) SQSelect {
 	if len(v) == 0 {
 		// Reset to clause
 		return &sel{this.source, this.distinct, this.limit, this.offset, this.where, nil, this.order}
@@ -56,7 +57,7 @@ func (this *sel) To(v ...sqlite.SQSource) sqlite.SQSelect {
 	return &sel{this.source, this.distinct, this.limit, this.offset, this.where, append(this.to, v...), this.order}
 }
 
-func (this *sel) Order(v ...sqlite.SQSource) sqlite.SQSelect {
+func (this *sel) Order(v ...SQSource) SQSelect {
 	if len(v) == 0 {
 		// Reset order clause
 		return &sel{this.source, this.distinct, this.limit, this.offset, this.where, this.to, nil}

pkg/lang/select_test.go

@@ -59,3 +59,19 @@ func Test_Select_001(t *testing.T) {
 		}
 	}
 }
+
+func Test_Select_002(t *testing.T) {
+	tests := []struct {
+		In    SQStatement
+		Query string
+	}{
+		{S(J(N("a"), N("b"))), `SELECT * FROM a CROSS JOIN b`},
+		{S(J(N("a"), N("b")).Join(Q("a=b"))), `SELECT * FROM a JOIN b ON a=b`},
+	}
+
+	for i, test := range tests {
+		if v := test.In.Query(); v != test.Query {
+			t.Errorf("Test %d, Unexpected return from Query(): %q, wanted %q", i, v, test.Query)
+		}
+	}
+}

pkg/sqlite3/cache_test.go

@@ -2,8 +2,6 @@ package sqlite3_test
 
 import (
 	"context"
-	"errors"
-	"io"
 	"math/rand"
 	"sync"
 	"testing"
@@ -43,11 +41,9 @@ func Test_Cache_001(t *testing.T) {
 				}
 				defer r.Close()
 				for {
-					row, err := r.Next()
-					if errors.Is(err, io.EOF) {
+					row := r.Next()
+					if row == nil {
 						break
-					} else if err != nil {
-						t.Error("Next Error: ", err)
 					} else if len(row) != 1 {
 						t.Error("Unexpected row length: ", row, " expected [", n, "]", r.Columns())
 					} else if int64(n) != row[0] {

pkg/sqlite3/conn.go

@@ -214,17 +214,7 @@ func (txn *Txn) Query(st SQStatement, v ...interface{}) (SQResults, error) {
 	}
 
 	// Get a results object
-	r, err := txn.Conn.ConnCache.Prepare(txn.Conn.ConnEx, st.Query())
-	if err != nil {
-		return nil, err
-	}
-
-	// Execute first query
-	if err := r.NextQuery(v...); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return txn.Conn.ConnCache.Prepare(txn.Conn.ConnEx, st.Query())
 }
 
 // Flags returns the Open Flags

pkg/sqlite3/results.go

@@ -74,9 +74,9 @@ func (r *Results) NextQuery(v ...interface{}) error {
 }
 
 // Return a row from the results, or return io.EOF if all results have been consumed
-func (r *Results) Next(t ...reflect.Type) ([]interface{}, error) {
+func (r *Results) Next(t ...reflect.Type) []interface{} {
 	if r.results == nil {
-		return nil, io.EOF
+		return nil
 	} else {
 		return r.results.Next(t...)
 	}

pkg/sqobj/sqiterator.go

@@ -1,8 +1,6 @@
 package sqobj
 
 import (
-	"errors"
-	"io"
 	"reflect"
 
 	// Modules
@@ -49,13 +47,10 @@ func (i *Iterator) Next() interface{} {
 	if i.rs == nil {
 		return nil
 	}
-	v, err := i.rs.Next(i.t...)
-	if err != nil {
+	v := i.rs.Next(i.t...)
+	if v == nil {
 		i.rs = nil
 		i.rowid = 0
-		if !errors.Is(err, io.EOF) {
-			panic(err)
-		}
 		return nil
 	}
 

plugin/indexer/handlers.go

@@ -2,10 +2,11 @@ package main
 
 import (
 	"context"
-	"io"
 	"net/http"
+	"reflect"
 	"regexp"
 	"strings"
+	"time"
 
 	// Packages
 	router "github.com/mutablelogic/go-server/pkg/httprouter"
@@ -55,8 +56,13 @@ type ResultResponse struct {
 }
 
 type FileResponse struct {
-	Parent   string `json:"parent"`
-	Filename string `json:"filename"`
+	Path     string    `json:"path"`
+	Parent   string    `json:"parent"`
+	Filename string    `json:"filename"`
+	IsDir    bool      `json:"isdir,omitempty"`
+	Ext      string    `json:"ext"`
+	ModTime  time.Time `json:"modtime"`
+	Size     int64     `json:"size"`
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -182,11 +188,9 @@ func (p *plugin) ServeQuery(w http.ResponseWriter, req *http.Request) {
 		}
 		n := int64(0)
 		for {
-			rows, err := r.Next()
-			if err == io.EOF {
+			rows := r.Next(nil, nil, nil, nil, nil, nil, nil, nil, reflect.TypeOf(time.Time{}))
+			if rows == nil {
 				return nil
-			} else if err != nil {
-				return err
 			} else {
 				n = n + 1
 			}
@@ -196,8 +200,13 @@ func (p *plugin) ServeQuery(w http.ResponseWriter, req *http.Request) {
 				Rank:   rows[1].(float64),
 				Index:  rows[2].(string),
 				File: FileResponse{
-					Parent:   rows[3].(string),
-					Filename: rows[4].(string),
+					Path:     rows[3].(string),
+					Parent:   rows[4].(string),
+					Filename: rows[5].(string),
+					IsDir:    int64ToBool(rows[6].(int64)),
+					Ext:      rows[7].(string),
+					ModTime:  rows[8].(time.Time),
+					Size:     rows[9].(int64),
 				},
 			})
 		}

plugin/indexer/util.go

@@ -6,3 +6,10 @@ func uintMin(a, b uint) uint {
 	}
 	return b
 }
+
+func int64ToBool(i int64) bool {
+	if i == 0 {
+		return false
+	}
+	return true
+}

plugin/sqlite3/handlers.go

@@ -392,11 +392,9 @@ func results(r SQResults) (SqlResultResponse, error) {
 
 	// Iterate through the rows, break when maximum number of results is reached
 	for {
-		row, err := r.Next()
-		if errors.Is(err, io.EOF) {
+		row := r.Next()
+		if row == nil {
 			break
-		} else if err != nil {
-			return result, err
 		} else {
 			result.Results = append(result.Results, interfaceSliceCopy(row))
 		}

sqlite.go

@@ -107,7 +107,7 @@ type SQResults interface {
 	// if types are provided, then returned row is cast to
 	// appopriate types. The returned row needs to be copied
 	// if not transient
-	Next(...reflect.Type) ([]interface{}, error)
+	Next(...reflect.Type) []interface{}
 
 	// Close results and discard when done
 	Close() error

sys/sqlite3/README.md

@@ -232,16 +232,14 @@ func main() {
 ## Results
 
 Results are returned from the `Exec` method after a statement is executed. If there are no results,
-then a call to `func (*Results) Next() ([]interface{},error)` will return `nil` in place of an
+then a call to `func (*Results) Next() []interface{}` will return `nil` in place of an
 array of values. You should repeatedly call the `Next` method until this occurs. For example,
 
 ```go
 func ReadResults(r *Results) error {
     for {
-        row, err := r.Next()
-        if err != nil {
-            return err
-        } else if row == nil {
+        row := r.Next()
+        if row == nil {
             return nil
         }
         // Handle row
@@ -261,10 +259,8 @@ example,
 func ReadResults(r *Results) error {
     cast := []reflect.Type{ reflect.TypeOf(bool), reflect.TypeOf(uint) }
     for {
-        row, err := r.Next(cast...)
-        if err != nil {
-            return err
-        } else if row == nil {
+        row := r.Next(cast...)
+        if row == nil {
             return nil
         }
         // Handle row which has bool as first element and uint as second element