xapian go quickstart

output

Creating WritableDatabase db1
TermGenerator SetDatabase
TermGenerator SetFlags
WritableDatabase BeginTransaction
Assembling document doc1encoding
ReplaceDocument 0 doc1encoding
Assembling document doc2encoding
ReplaceDocument 0 doc2encoding
Assembling document doc3encoding
ReplaceDocument 0 doc3encoding
WritableDatabase CommitTransaction
Creating WritableDatabase db2
TermGenerator SetDatabase
TermGenerator SetFlags
WritableDatabase BeginTransaction
Assembling document doc1encoding
ReplaceDocument 0 doc1encoding
Assembling document doc2encoding
ReplaceDocument 0 doc2encoding
Assembling document doc3encoding
ReplaceDocument 0 doc3encoding
WritableDatabase CommitTransaction
Creating Database db1
Creating Database db2
Adding Database to db1
Creating Enquire
Creating Query
Setting query
Got result somedoc
Got result someotherdoc

quickstart.go

package main

import (
  "fmt"
  "./xapian"
)

func main() {

  aDocs := [...]AssemblableDocument{{"data": "doc one", "text": [...]string{"text one two three four five six"},
    "terms": map[string]int{"a":1}, "values": map[int]string{1: "stuff"}, "id_term": "#dk83ndj"}}

  aPaths := []string{"db1", "db2"}

  for _, aPath := range aPaths {
    aWDb := xapian.NewWritableDatabase(aPath, 1)

    aTg := xapian.TermGenerator{}
    aTg.SetDatabase(aWDb)
    aTg.SetFlags(3)

    aWDb.BeginTransaction()
    for _, aDoc := range aDocs {
      aAssembledDoc := xapian.AssembleDocument(aDoc)
      aWDb.ReplaceDocument(0, aAssembledDoc)
    }
    aWDb.CommitTransaction()
  }

  aDbs := xapian.NewDatabase(aPaths[0])
  aDbs.AddDatabase(xapian.NewDatabase(aPaths[1]))

  aEnquire := xapian.NewEnquire(aDbs);
  aEnquire.SetQuery(xapian.NewQuery("queryencoding"))

  aMSet := aEnquire.GetMset(0,10);

  for _, msetval := range aMSet {
    fmt.Println("Got result", msetval.GetDocument().GetData())
  }
}

xapian.go

package xapian

import (
        "fmt"
)

type Database interface {
  AddDatabase (Database)
}

type WritableDatabase interface {
  BeginTransaction ()
  CommitTransaction ()
  ReplaceDocument (idterm int, doc Document)
}

type databaseObj struct {
  path string
  action int
  isWritable bool
}

func NewDatabase (path string) Database {
  fmt.Println("Creating Database", path);
  aDb := &databaseObj{path: path, isWritable: false}
  return Database(aDb)
}

func (db *databaseObj) AddDatabase (db2 Database) {
  fmt.Printf("Adding Database to %s\n", db.path);
}

func NewWritableDatabase (path string, action int) WritableDatabase {
  fmt.Println("Creating WritableDatabase", path);
  aWDb := &databaseObj{path, action, true}
  return WritableDatabase(aWDb)
}

func (wdb *databaseObj) BeginTransaction () {
  //if !wdb.isWritable error
  fmt.Println("WritableDatabase BeginTransaction")
}

func (wdb *databaseObj) CommitTransaction () {
  //if !wdb.isWritable error
  fmt.Println("WritableDatabase CommitTransaction")
}

func (wdb *databaseObj) ReplaceDocument (idterm int, doc Document) {
  //if !wdb.isWritable error
  fmt.Printf("ReplaceDocument %d %s\n", idterm, doc.str);
}



type TermGenerator struct {
  wdb WritableDatabase
  flags int
}

func (t *TermGenerator) SetDatabase (wdb WritableDatabase) {
  fmt.Println("TermGenerator SetDatabase");
  t.wdb = wdb
}

func (t *TermGenerator) SetFlags (flags int) {
  fmt.Println("TermGenerator SetFlags");
  t.flags = flags
}



type Document struct {
  str string
  idterm int
}

func AssembleDocument (s string) Document {
  fmt.Println("Assembling document " + s);
  return Document{s, 5}
}

func (doc Document) GetIdTerm () int {
  return doc.idterm;
}

func (doc Document) GetData () string {
  return doc.str;
}



type Enquire struct {
}

func NewEnquire (db Database) Enquire {
  fmt.Println("Creating Enquire")
  return Enquire{}
}

func (en *Enquire) SetQuery (query Query) {
  fmt.Println("Setting query")
}

func (en Enquire) GetMset (start, length int) []MSetValue {
  ret := []MSetValue{MSetValue{Document{str: "somedoc"}}, MSetValue{Document{str: "someotherdoc"}}}
  return ret
}



type Query struct {
}

func NewQuery (q string) Query {
  fmt.Println("Creating Query")
  return Query{}
}


type MSetValue struct {
  document Document
}

func (m MSetValue) GetDocument () Document {
  return m.document
}

This looks good. Keeping state in the go package prevents getX() calls to C++.
Which api functions should return an error param?
Missing: Stem, Document.GetData

Let's start off calling the swig api from our package (import xapswig "xapian_swig"). And we'll extend it to handle AssembleDoc, MSet collections, msgpack params/results, etc.

For a literal array, use [...]int{ 1, 2, 3 }. This creates a slice and array []int{1,2,3}

It's nice to be collaborating again :-)