gl.go

package main

import (
	"fmt"
	"log"
	"os"
	"runtime"

	std "github.com/jtejido/golucene/analysis/standard"
	_ "github.com/jtejido/golucene/core/codec/lucene410"
	"github.com/jtejido/golucene/core/document"
	"github.com/jtejido/golucene/core/index"
	"github.com/jtejido/golucene/core/index/model"
	"github.com/jtejido/golucene/core/search"
	"github.com/jtejido/golucene/core/search/similarities"
	"github.com/jtejido/golucene/core/store"
	"github.com/jtejido/golucene/core/util"
	"github.com/jtejido/golucene/queryparser/classic"
)

func main() {
	n := runtime.NumCPU()
	var err error
	err = util.SetDefaultInfoStream(util.NewPrintStreamInfoStream(os.Stdout))
	if err != nil {
		log.Fatalf("error: %s", err.Error())
	}
	index.DefaultSimilarity = func() index.Similarity {
		return similarities.NewDefaultBM25Similarity()
	}

	directory, err := store.OpenFSDirectory("test_index")
	if err != nil {
		log.Fatalf("error: %s", err.Error())
	}
	analyzer := std.NewStandardAnalyzer()
	conf := index.NewIndexWriterConfig(util.VERSION_LATEST, analyzer)
	conf.MergeScheduler().(*index.ConcurrentMergeScheduler).SetMaxMergesAndRoutines(n, n)
	writer, err := index.NewIndexWriter(directory, conf)
	if err != nil {
		log.Fatalf("error: %s", err.Error())
	}

	// here's a custom field type to test term vector indexing
	ft := document.NewFieldType()
	ft.SetIndexed(true)
	ft.SetIndexOptions(model.INDEX_OPT_DOCS_ONLY)
	ft.SetTokenized(true)
	ft.SetStoreTermVectors(true)
	ft.SetStoreTermVectorPositions(true)
	ft.SetStored(true)

	d := document.NewDocument()
	d.Add(document.NewFieldFromString("body", "test 1 Lorem", ft))
	writer.AddDocument(d.Fields())

	d2 := document.NewDocument()
	ft2 := document.NewFieldType()
	ft2.SetIndexed(true)
	ft2.SetTokenized(true)
	ft2.SetStored(true)
	ft2.SetStoreTermVectors(true)
	ft2.SetStoreTermVectorPositions(true)
	ft2.SetOmitNorms(true)
	ft2.SetIndexOptions(model.INDEX_OPT_DOCS_ONLY)
	ft2.SetNumericType(document.FIELD_TYPE_NUMERIC_INT)
	ft2.SetNumericPrecisionStep(util.NUMERIC_PRECISION_STEP_DEFAULT_32)
	// or just use below, reranking requires that we store term vectors so a custom fieldtype had to be created
	// in order to set StoreTermVectors and StoreTermVectorPositions to true
	// d2.Add(document.NewIntField("body", 2, STORE_YES))
	d2.Add(document.NewIntFieldFromType("body", 2, ft2))
	writer.AddDocument(d2.Fields())

	d3 := document.NewDocument()
	d3.Add(document.NewFieldFromString("body", "test 2 Lorem", ft))
	writer.AddDocument(d3.Fields())
	// writer.Commit()
	writer.Close() // ensure index is written

	reader, _ := index.OpenDirectoryReader(directory)
	searcher := search.NewIndexSearcher(reader)

	parser := classic.NewQueryParser(util.VERSION_LATEST, "body", analyzer)
	// parser := simple.NewSimpleQueryParser(analyzer, "body")
	// parser.SetDefaultOperator(search.MUST)
	var q search.Query
	// testing prefix
	if q, err = parser.Parse(`2 NOT test`); err != nil {
		log.Fatalf("error: %s", err.Error())
	}

	// reranking requires that you use STORE_YES as it iterates terms, it will panic on terms that isn't stored.
	// exp := expansion.NewDefaultRocchioReranker(analyzer, "body")
	// ctx := search.NewExpanderContext(searcher, q, "test")
	// res, err := searcher.SearchExpand(q, nil, 1000, exp, ctx)
	// if err != nil {
	// 	log.Fatalf("error: %s", err.Error())
	// }
	res, _ := searcher.Search(q, nil, 1000)
	fmt.Printf("Found %v hit(s).\n", res.TotalHits)
	for _, hit := range res.ScoreDocs {
		fmt.Printf("Doc %v score: %v\n", hit.Doc, hit.Score)
		doc, _ := reader.Document(hit.Doc)
		fmt.Printf("body -> %v\n", doc.Get("body"))
	}
}