bobb

type BktRequest struct {
	BktName      string
	Operation    string // "create", "delete", "nextseq", "list", "count"
	NextSeqCount int    // used with nextseq op to specify how many (max 100)
}

type BobbErr struct {
	ErrCode string // see Error code constants in codes.go
	Msg     string // error msg
	Key     []byte // bkt or index key depending on ErrCode
	Val     []byte // bkt or index val depending on ErrCode
}

type CopyDBRequest struct {
	FilePath string `json:"filePath"`
}

type CsvExport interface {
	CsvHeader(includeJoins bool) []string
	CsvData(includeJoins bool) []string
}

type DeleteRequest struct {
	BktName string
	Keys    []string // keys of records to be deleted
}

type ExportRequest struct {
	BktName  string
	StartKey string // if not "", keys >= this value
	EndKey   string // if not "", keys <= this value
	Limit    int    // max # recs to write
	FilePath string // where export file is written
}

type FindCondition struct {
	Fld        string   // field containing compare value
	Op         string   // defines match operation and value type
	ValStr     string   // for string ops, this value also converted based on StrOption
	ValInt     int      // for int Ops
	StrList    []string // used by op FindInStrList
	IntList    []int    // used by op FindInIntList
	Not        bool     // exclude records that meet condition
	UseDefault string   // controls what default value is used, see Default* codes in codes.go
	StrOption  string   // controls string conversion, see Str* codes in codes.go, default StrLowerCase
}

type FindGroup []FindCondition // QryRequest can have multiple FindGroups that are ORed together

type FldFormat struct {
	FldName    string // name of fld in record
	FldType    string // FldTypeStr or FldTypeInt  ("string" or "int")
	Length     int    // output length of value
	UseDefault string // controls value used when fld not found or null in data rec, use constant from codes.go: DefaultAlways, DefaultNever, DefaultIsNull, DefaultNotFound
	StrOption  string // for string flds, use Str* code (see codes.go) to control conversion, ex. StrLowerCase
}

type GetAllKeysRequest struct {
	BktName  string
	StartKey string // if not "", keys >= this value
	EndKey   string // if not "", keys <= this value
	Limit    int    // max # recs to return
}

type GetAllRequest struct {
	BktName  string
	IndexBkt string // name of bkt used as index
	StartKey string // if not "", keys >= this value
	EndKey   string // if not "", keys <= this value
	Limit    int    // max # recs to return
	ErrLimit int    // run stops when ErrLimit exceeded, default 0, settings.MaxErrs limit if -1
}

type GetOneRequest struct {
	BktName string
	Key     string // key of record to be returned
}

type GetRequest struct {
	BktName  string
	Keys     []string // keys of records to be returned
	ErrLimit int      // run stops when ErrLimit exceeded
}

type GetValuesRequest struct {
	BktName string
	Keys    []string // keys of records to be returned
	Fields  []string // field values to return
}

type GlobalVal struct {
	Lock  sync.RWMutex
	Value string
}

type IndexKeyVal struct {
	Key    string
	Val    string
	OldKey string // used when index rec already exists for data key
}

type IndexRequest struct {
	DataBkt        string      // name of data bkt, DataKeys refer to this bkt
	IndexBkt       string      // name of index bkt, where index entries will be written
	MergeFlds      []FldFormat // defines index composition
	FldSeparator   string      // separator used in merged field values
	KeySuffixWidth int         // using IndexBkt nextSeq# add numeric suffix to index key, 0 means use KeySuffixWidth from bobb_setting.json, -1 no suffix
	DataKeys       []string    // index specific data records
	StartKey       string      // index records in range from StartKey
	EndKey         string      // index records in range to EndKey
	IndexAll       bool        // index all records in DataBkt
	SkipOnErrLimit int         // if errors exceed this limit, fail request with rollback
}

type IndexSetting struct {
	DataBkt        string      // name of data bkt, ex. "inquiry"
	IndexBkt       string      // name of index bkt, must begin with value of DataBkt and end with "_index", ex. "inquiry_timestamp_index"
	KeyFlds        []FldFormat // defines how index key is constructed, if empty, index key is just IndexBkt NextSequence#
	FldSeparator   string      // optional separator used in merged field values, ex. "|" > "critical   |00033|temp high     "
	KeySuffixWidth int         // using IndexBkt nextSeq# add numeric suffix to index key, 0 means use KeySuffixWidth from bobb_setting.json, -1 no suffix
	SkipOnErr      bool        // if true, if error creating/updating index entry for a data rec, skip and do not fail entire PutRequest
}

type IndexSettingRequest struct {
	IndexSettings []IndexSetting
}

type Indexr struct {
	IndexBkt         *bolt.Bucket // pointer to index bkt where index entries are stored
	IndexBktName     string       // name of index bkt, used for error msgs
	IndexInvertedBkt *bolt.Bucket // maps data key to index key, so easy to find old index entry for data key
	KeyFlds          []FldFormat  // defines how index key, is constructed
	FldSeparator     string       // separator used in merged field values
	KeySuffixFormat  string       // using IndexBkt nextSeq#, formatted with leading zeros
	SkipOnErr        bool         // if true, on error skip writing index entry and don't fail PutRequest
}

type Join struct {
	JoinBkt    string // name of related bkt where value is pulled from
	JoinFld    string // fld in primary rec containing key value of join rec
	FromFld    string // fld in join rec where value comes from
	ToFld      string // fld in primary rec where value is loaded
	UseDefault bool   // if join problem, use default value, no error
}

type PutIndexRequest struct {
	BktName string
	Indexes []IndexKeyVal // slice of index key/val/oldkey structs
}

type PutParm struct {
	BktName        string   // data bkt where recs will be put, created if not exists
	KeyField       string   // fld in recs containing key value, default is defaultKeyFld from bobb_settings.json
	Recs           [][]byte // typically json marshaled value of records
	RequiredFlds   []string // optional, fld names that must be included in recs
	AddKeySuffix   bool     // if true, add bkt NextSeq# to end of key
	IndexingOption string   // see Indexing* codes in codes.go, IndexingNormal is default
	LogPut         bool     // if true, write record to bktname_putlog bkt. Key is dataKey|timestamp. Value is Rec. Provides point in time values.
}

type PutRequest struct {
	PutParms []PutParm
}

type QryRequest struct {
	BktName         string      // primary data bkt
	IndexBkt        string      // optional index bkt name, start/end keys use index
	Criteria        []FindGroup // if a record meets all conditions in any FindGroup, it is included in results
	SortKeys        []SortKey   // defines sort order, if omitted ressults returned in key order
	StartKey        string      // begin range, 1st key >=
	EndKey          string      // end range, last key <=
	Limit           int         // limits results before sort step
	Top             int         // limits results after sort step
	ErrLimit        int         // run stops when ErrLimit exceeded, default 0, settings.MaxErrs limit if -1
	JoinsBeforeFind []Join      // joined values can be used in find step (adds processing time)
	JoinsAfterFind  []Join      // joined values can be used for sort step but not find step
	CountOnly       bool        // if true, Response.Recs is nil, count in Response.GetCnt
}

type ReadLoop struct {
	Bkt         *bolt.Bucket // data bkt
	Index       *bolt.Bucket // index bkt
	Csr         *bolt.Cursor // if index set, index csr, else data bkt csr
	StartKey    string       // begin loop with 1st key >= StartKey
	EndKey      string       // end loop with 1st key > EndKey
	MatchPrefix bool         // if StartKey == EndKey, rec key prefix must match StartKey
	UsingIndex  bool         // indicates if index is being used
	NextKey     []byte       // used for resp.NextKey when range-end or limit hit
	Limit       int          // results limit
	Count       int          // Count equal Limit triggers loop end, Count updated by caller
}

type RecValues struct {
	Key     string            // record key
	FldVals map[string]string // fldName:value
}

type Request interface {
	IsUpdtReq() bool                 // true if request performs update
	Run(*bolt.Tx) (*Response, error) // executes the request
}

type Response struct {
	Status  string           // constants in codes.go (StatusOk, StatusWarning, StatusFail)
	Msg     string           // if status is not Ok, Msg will indicate reason
	Recs    [][]byte         // for request responses with potentially more than 1 record
	Rec     []byte           // for requests that only return 1 record
	PutCnt  int              // number of records either added or replaced by Put operation
	PutKeys map[int][]string // keys used in PutRequest (includes appended suffix if used), map key is PutParms index
	GetCnt  int              // used for other non Put counts
	NextSeq []int            // returned by Bkt request with Operation = "nextseq"
	NextKey string           // next key in bkt after last one returned in Recs
	Errs    []BobbErr        // errs occuring until req.ErrLimit hit
}

type SearchKeysRequest struct {
	BktName     string
	SearchValue string
	StartKey    string
	EndKey      string
	Limit       int
}

type SortKey struct {
	Fld        string // name of field
	Dir        string // direction (asc/desc) and field type (str/int)
	UseDefault string // controls what value is used when fld NotFound or IsNull, see codes.go
}

type SortRec struct {
	SortOn []string // Values extracted from record using SortKeys
	Value  []byte   // record value
}

type VerifyIndexRequest struct {
	DataBkt        string // data bkt
	IndexBkt       string //
	AllDataIndexed bool   //if true, verify all data keys have entry in index
	ErrLimit       int    // limit of BobbErr's returned in Response.Errs
}