scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-09-09 22:51:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

GoRename Frame to Field in index.go

Browse source
This commit is contained in:
Travis Turner 2018-06-05 22:33:48 -05:00
parent 1d3c4d6fcb
commit 3531c128c4
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
25 changed files with 139 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
api.go
View file

@ -230,7 +230,7 @@ func (api *API) CreateFrame(ctx context.Context, indexName string, frameName str
}
// Create frame.
frame, err := index.CreateFrame(frameName, options)
frame, err := index.CreateField(frameName, options)
if err != nil {
return nil, errors.Wrap(err, "creating frame")
}
@ -265,7 +265,7 @@ func (api *API) DeleteFrame(ctx context.Context, indexName string, frameName str
}
// Delete frame from the index.
if err := index.DeleteFrame(frameName); err != nil {
if err := index.DeleteField(frameName); err != nil {
return errors.Wrap(err, "deleting frame")
}
@ -357,7 +357,7 @@ func (api *API) UnmarshalFragment(ctx context.Context, indexName string, frameNa
// Retrieve frame.
f := api.Holder.Frame(indexName, frameName)
if f == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
// Retrieve view.
@ -497,7 +497,7 @@ func (api *API) Views(ctx context.Context, indexName string, frameName string) (
// Retrieve views.
f := api.Holder.Frame(indexName, frameName)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
// Fetch views.
@ -514,7 +514,7 @@ func (api *API) DeleteView(ctx context.Context, indexName string, frameName stri
// Retrieve frame.
f := api.Holder.Frame(indexName, frameName)
if f == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
// Delete the view.
@ -582,7 +582,7 @@ func (api *API) FrameAttrDiff(ctx context.Context, indexName string, frameName s
// Retrieve index from holder.
f := api.Holder.Frame(indexName, frameName)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
// Retrieve local blocks.
@ -695,10 +695,10 @@ func (api *API) indexFrame(indexName string, frameName string, slice uint64) (*I
}
// Retrieve frame.
frame := index.Frame(frameName)
frame := index.Field(frameName)
if frame == nil {
api.Logger.Printf("frame error: index=%s, frame=%s, slice=%d, err=%s", indexName, frameName, slice, ErrFrameNotFound.Error())
return nil, nil, ErrFrameNotFound
api.Logger.Printf("frame error: index=%s, frame=%s, slice=%d, err=%s", indexName, frameName, slice, ErrFieldNotFound.Error())
return nil, nil, ErrFieldNotFound
}
return index, frame, nil
}

14
client.go
View file

@ -273,7 +273,7 @@ func (c *InternalHTTPClient) Import(ctx context.Context, index, frame string, sl
if index == "" {
return ErrIndexRequired
} else if frame == "" {
return ErrFrameRequired
return ErrFieldRequired
}
buf, err := marshalImportPayload(index, frame, slice, bits)
@ -302,7 +302,7 @@ func (c *InternalHTTPClient) ImportK(ctx context.Context, index, frame string, c
if index == "" {
return ErrIndexRequired
} else if frame == "" {
return ErrFrameRequired
return ErrFieldRequired
}
buf, err := marshalImportPayloadK(index, frame, columns)
@ -332,7 +332,7 @@ func (c *InternalHTTPClient) EnsureIndex(ctx context.Context, name string, optio
func (c *InternalHTTPClient) EnsureFrame(ctx context.Context, indexName string, frameName string, options FieldOptions) error {
err := c.CreateFrame(ctx, indexName, frameName, options)
if err == nil || err == ErrFrameExists {
if err == nil || err == ErrFieldExists {
return nil
}
return err
@ -424,7 +424,7 @@ func (c *InternalHTTPClient) ImportValue(ctx context.Context, index, frame strin
if index == "" {
return ErrIndexRequired
} else if frame == "" {
return ErrFrameRequired
return ErrFieldRequired
}
buf, err := marshalImportValuePayload(index, frame, slice, vals)
@ -511,7 +511,7 @@ func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, frame string,
if index == "" {
return ErrIndexRequired
} else if frame == "" {
return ErrFrameRequired
return ErrFieldRequired
}
// Retrieve a list of nodes that own the slice.
@ -658,7 +658,7 @@ func (c *InternalHTTPClient) CreateFrame(ctx context.Context, index, frame strin
case http.StatusOK:
return nil // ok
case http.StatusConflict:
return ErrFrameExists
return ErrFieldExists
default:
return errors.New(string(body))
}
@ -822,7 +822,7 @@ func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame strin
switch resp.StatusCode {
case http.StatusOK: // ok
case http.StatusNotFound:
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
default:
return nil, fmt.Errorf("unexpected status: code=%d", resp.StatusCode)
}

4
cluster.go
View file

@ -627,7 +627,7 @@ func (c *Cluster) fragsByHost(idx *Index) fragsByHost {
// frameViews is a map of frame to slice of views.
frameViews := make(viewsByFrame)
for _, frame := range idx.Frames() {
for _, frame := range idx.Fields() {
for _, view := range frame.Views() {
frameViews.addView(frame.Name(), view.Name())
@ -1242,7 +1242,7 @@ func (c *Cluster) FollowResizeInstruction(instr *internal.ResizeInstruction) err
// Retrieve frame.
f := c.Holder.Frame(src.Index, src.Frame)
if f == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
// Create view.

2
cluster_internal_test.go
View file

@ -145,7 +145,7 @@ func TestFragSources(t *testing.T) {
c5.addNodeBasicSorted(node3)
idx := newIndexWithTempPath("i")
frame, err := idx.CreateFrameIfNotExists("f", FieldOptions{})
frame, err := idx.CreateFieldIfNotExists("f", FieldOptions{})
if err != nil {
t.Fatal(err)
}

2
ctl/export.go
View file

@ -58,7 +58,7 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
if cmd.Index == "" {
return pilosa.ErrIndexRequired
} else if cmd.Frame == "" {
return pilosa.ErrFrameRequired
return pilosa.ErrFieldRequired
}
// Use output file, if specified.

4
ctl/export_test.go
View file

@ -38,8 +38,8 @@ func TestExportCommand_Validation(t *testing.T) {
cm.Index = "i"
err = cm.Run(context.Background())
if err != pilosa.ErrFrameRequired {
t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFrameRequired, err)
if err != pilosa.ErrFieldRequired {
t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFieldRequired, err)
}
}

4
ctl/import.go
View file

@ -84,7 +84,7 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
if cmd.Index == "" {
return pilosa.ErrIndexRequired
} else if cmd.Frame == "" {
return pilosa.ErrFrameRequired
return pilosa.ErrFieldRequired
} else if len(cmd.Paths) == 0 {
return errors.New("path required")
}
@ -110,7 +110,7 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
}
for _, index := range schema {
if index.Name == cmd.Index {
for _, frame := range index.Frames {
for _, frame := range index.Fields {
if frame.Name == cmd.Frame {
frameType = frame.Options.Type
}

4
ctl/import_test.go
View file

@ -39,8 +39,8 @@ func TestImportCommand_Validation(t *testing.T) {
cm.Index = "i"
err = cm.Run(context.Background())
if err != pilosa.ErrFrameRequired {
t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFrameRequired, err)
if err != pilosa.ErrFieldRequired {
t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFieldRequired, err)
}
cm.Frame = "f"

2
diagnostics.go
View file

@ -225,7 +225,7 @@ func (d *DiagnosticsCollector) EnrichWithSchemaProperties() {
for _, index := range d.server.Holder.Indexes() {
numSlices += index.MaxSlice() + 1
numIndexes += 1
for _, frame := range index.Frames() {
for _, frame := range index.Fields() {
numFrames += 1
if frame.Type() == FieldTypeInt {
bsiFieldCount += 1

26
executor.go
View file

@ -313,7 +313,7 @@ func (e *Executor) executeBitmapCall(ctx context.Context, index string, c *pql.C
return nil, err
} else {
frame, _ := c.Args["frame"].(string)
if fr := idx.Frame(frame); fr != nil {
if fr := idx.Field(frame); fr != nil {
rowID, _, err := c.UintArg(rowLabel)
if err != nil {
return nil, errors.Wrap(err, "getting row")
@ -634,7 +634,7 @@ func (e *Executor) executeBitmapSlice(ctx context.Context, index string, c *pql.
}
f := e.Holder.Frame(index, frame)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
rowID, rowOK, rowErr := c.UintArg(rowLabel)
@ -694,9 +694,9 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
}
// Retrieve base frame.
f := idx.Frame(frame)
f := idx.Field(frame)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
// Read row & column id.
@ -769,7 +769,7 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
f := e.Holder.Frame(index, frameName)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
// EQ null (not implemented: flip frag.NotNull with max ColumnID)
@ -959,9 +959,9 @@ func (e *Executor) executeClearBit(ctx context.Context, index string, c *pql.Cal
if idx == nil {
return false, ErrIndexNotFound
}
f := idx.Frame(frame)
f := idx.Field(frame)
if f == nil {
return false, ErrFrameNotFound
return false, ErrFieldNotFound
}
// Read fields using labels.
@ -1024,9 +1024,9 @@ func (e *Executor) executeSetBit(ctx context.Context, index string, c *pql.Call,
if idx == nil {
return false, ErrIndexNotFound
}
f := idx.Frame(frame)
f := idx.Field(frame)
if f == nil {
return false, ErrFrameNotFound
return false, ErrFieldNotFound
}
// Read fields using labels.
@ -1110,7 +1110,7 @@ func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Cal
// Retrieve frame.
frame := e.Holder.Frame(index, name)
if frame == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
switch value := value.(type) {
@ -1159,7 +1159,7 @@ func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
// Retrieve frame.
frame := e.Holder.Frame(index, frameName)
if frame == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
// Parse labels.
@ -1219,7 +1219,7 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
// Retrieve frame.
f := e.Holder.Frame(index, frame)
if f == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
rowID, ok, err := c.UintArg(rowLabel)
@ -1257,7 +1257,7 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
// Retrieve frame.
frame := e.Holder.Frame(index, name)
if frame == nil {
return nil, ErrFrameNotFound
return nil, ErrFieldNotFound
}
// Set attributes.

28
executor_test.go
View file

@ -388,9 +388,9 @@ func TestExecutor_Execute_TopN(t *testing.T) {
// Set columns for rows 0, 10, & 20 across two slices.
if idx, err := hldr.CreateIndex("i", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateFrame("f", pilosa.FieldOptions{}); err != nil {
} else if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateFrame("other", pilosa.FieldOptions{}); err != nil {
} else if _, err := idx.CreateField("other", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if _, err := e.Execute(context.Background(), "i", test.MustParse(`
SetBit(frame=f, row=0, col=0)
@ -572,11 +572,11 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("x", pilosa.FieldOptions{}); err != nil {
if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateFrame("f", pilosa.FieldOptions{
if _, err := idx.CreateField("f", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: -10,
Max: 100,
@ -667,11 +667,11 @@ func TestExecutor_Execute_Sum(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("x", pilosa.FieldOptions{}); err != nil {
if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateFrame("foo", pilosa.FieldOptions{
if _, err := idx.CreateField("foo", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 10,
Max: 100,
@ -679,7 +679,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{
if _, err := idx.CreateField("bar", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 0,
Max: 100000,
@ -687,7 +687,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("other", pilosa.FieldOptions{
if _, err := idx.CreateField("other", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 0,
Max: 1000,
@ -780,11 +780,11 @@ func TestExecutor_Execute_Range(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("f", pilosa.FieldOptions{}); err != nil {
if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateFrame("foo", pilosa.FieldOptions{
if _, err := idx.CreateField("foo", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 10,
Max: 100,
@ -792,7 +792,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{
if _, err := idx.CreateField("bar", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 0,
Max: 100000,
@ -800,7 +800,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("other", pilosa.FieldOptions{
if _, err := idx.CreateField("other", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: 0,
Max: 1000,
@ -808,7 +808,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateFrame("edge", pilosa.FieldOptions{
if _, err := idx.CreateField("edge", pilosa.FieldOptions{
Type: pilosa.FieldTypeInt,
Min: -100,
Max: 100,
@ -945,7 +945,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
})
t.Run("ErrFrameNotFound", func(t *testing.T) {
if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(bad_frame >= 20)`), nil, nil); err != pilosa.ErrFrameNotFound {
if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(bad_frame >= 20)`), nil, nil); err != pilosa.ErrFieldNotFound {
t.Fatal(err)
}
})

2
fragment_test.go
View file

@ -961,7 +961,7 @@ func TestFragment_RankCache_Persistence(t *testing.T) {
}
// Re-fetch fragment.
f = index.Frame("f").View(pilosa.ViewStandard).Fragment(0)
f = index.Field("f").View(pilosa.ViewStandard).Fragment(0)
// Re-verify correct cache type and size.
if cache, ok := f.Cache().(*pilosa.RankCache); !ok {

6
handler.go
View file

@ -522,7 +522,7 @@ func (h *Handler) handlePostFrame(w http.ResponseWriter, r *http.Request) {
switch errors.Cause(err) {
case ErrIndexNotFound:
http.Error(w, err.Error(), http.StatusNotFound)
case ErrFrameExists:
case ErrFieldExists:
http.Error(w, err.Error(), http.StatusConflict)
default:
http.Error(w, err.Error(), http.StatusInternalServerError)
@ -749,7 +749,7 @@ func (h *Handler) handlePostImport(w http.ResponseWriter, r *http.Request) {
switch errors.Cause(err) {
case ErrIndexNotFound:
fallthrough
case ErrFrameNotFound:
case ErrFieldNotFound:
http.Error(w, err.Error(), http.StatusNotFound)
case ErrClusterDoesNotOwnSlice:
http.Error(w, err.Error(), http.StatusPreconditionFailed)
@ -802,7 +802,7 @@ func (h *Handler) handlePostImportValue(w http.ResponseWriter, r *http.Request)
switch errors.Cause(err) {
case ErrIndexNotFound:
fallthrough
case ErrFrameNotFound:
case ErrFieldNotFound:
http.Error(w, err.Error(), http.StatusNotFound)
case ErrClusterDoesNotOwnSlice:
http.Error(w, err.Error(), http.StatusPreconditionFailed)

2
handler_test.go
View file

@ -712,7 +712,7 @@ func TestHandler_DeleteFrame(t *testing.T) {
t.Fatalf("unexpected status code: %d", w.Code)
} else if body := w.Body.String(); body != `{}`+"\n" {
t.Fatalf("unexpected body: %s", body)
} else if f := hldr.Index("i0").Frame("f1"); f != nil {
} else if f := hldr.Index("i0").Field("f1"); f != nil {
t.Fatal("expected nil frame")
}
}

20
holder.go
View file

@ -214,15 +214,15 @@ func (h *Holder) Schema() []*IndexInfo {
var a []*IndexInfo
for _, index := range h.Indexes() {
di := &IndexInfo{Name: index.Name()}
for _, frame := range index.Frames() {
for _, frame := range index.Fields() {
fi := &FieldInfo{Name: frame.Name(), Options: frame.Options()}
for _, view := range frame.Views() {
fi.Views = append(fi.Views, &ViewInfo{Name: view.Name()})
}
sort.Sort(viewInfoSlice(fi.Views))
di.Frames = append(di.Frames, fi)
di.Fields = append(di.Fields, fi)
}
sort.Sort(fieldInfoSlice(di.Frames))
sort.Sort(fieldInfoSlice(di.Fields))
a = append(a, di)
}
sort.Sort(indexInfoSlice(a))
@ -241,7 +241,7 @@ func (h *Holder) ApplySchema(schema *internal.Schema) error {
// Create frames that don't exist.
for _, f := range index.Frames {
opt := decodeFieldOptions(f.Meta)
frame, err := idx.CreateFrameIfNotExists(f.Name, *opt)
frame, err := idx.CreateFieldIfNotExists(f.Name, *opt)
if err != nil {
return errors.Wrap(err, "creating frame")
}
@ -396,7 +396,7 @@ func (h *Holder) Frame(index, name string) *Field {
if idx == nil {
return nil
}
return idx.Frame(name)
return idx.Field(name)
}
// View returns the view for an index, frame, and name.
@ -435,7 +435,7 @@ func (h *Holder) monitorCacheFlush() {
func (h *Holder) flushCaches() {
for _, index := range h.Indexes() {
for _, frame := range index.Frames() {
for _, frame := range index.Fields() {
for _, view := range frame.Views() {
for _, fragment := range view.Fragments() {
select {
@ -600,7 +600,7 @@ func (s *HolderSyncer) SyncHolder() error {
}
tf := time.Now()
for _, fi := range di.Frames {
for _, fi := range di.Fields {
// Verify syncer has not closed.
if s.IsClosing() {
return nil
@ -713,7 +713,7 @@ func (s *HolderSyncer) syncFrame(index, name string) error {
// Retrieve attributes from differing blocks.
// Skip update and recomputation if no attributes have changed.
m, err := client.RowAttrDiff(context.Background(), index, name, blks)
if err == ErrFrameNotFound {
if err == ErrFieldNotFound {
continue // frame not created remotely yet, skip
} else if err != nil {
return errors.Wrap(err, "getting differing blocks")
@ -742,7 +742,7 @@ func (s *HolderSyncer) syncFragment(index, frame, view string, slice uint64) err
// Retrieve local frame.
f := s.Holder.Frame(index, frame)
if f == nil {
return ErrFrameNotFound
return ErrFieldNotFound
}
// Ensure view exists locally.
@ -806,7 +806,7 @@ func (c *HolderCleaner) CleanHolder() error {
containedSlices := c.Cluster.ContainsSlices(index.Name(), index.MaxSlice(), c.Node)
// Get the fragments registered in memory.
for _, frame := range index.Frames() {
for _, frame := range index.Fields() {
for _, view := range frame.Views() {
for _, fragment := range view.Fragments() {
fragSlice := fragment.Slice()

16
holder_test.go
View file

@ -100,7 +100,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if err := h.Holder.Close(); err != nil {
t.Fatal(err)
@ -119,7 +119,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if err := h.Holder.Close(); err != nil {
t.Fatal(err)
@ -137,7 +137,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if err := h.Holder.Close(); err != nil {
t.Fatal(err)
@ -159,7 +159,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
t.Fatal(err)
@ -183,7 +183,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
t.Fatal(err)
@ -208,7 +208,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
t.Fatal(err)
@ -231,7 +231,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
t.Fatal(err)
@ -257,7 +257,7 @@ func TestHolder_Open(t *testing.T) {
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
t.Fatal(err)

88
index.go
View file

@ -34,8 +34,8 @@ type Index struct {
path string
name string
// Frames by name.
frames map[string]*Field
// Fields by name.
fields map[string]*Field
// Max Slice on any node in the cluster, according to this node.
remoteMaxSlice uint64
@ -61,7 +61,7 @@ func NewIndex(path, name string) (*Index, error) {
return &Index{
path: path,
name: name,
frames: make(map[string]*Field),
fields: make(map[string]*Field),
remoteMaxSlice: 0,
@ -106,7 +106,7 @@ func (i *Index) Open() error {
return errors.Wrap(err, "loading meta file")
}
if err := i.openFrames(); err != nil {
if err := i.openFields(); err != nil {
return errors.Wrap(err, "opening frames")
}
@ -117,8 +117,8 @@ func (i *Index) Open() error {
return nil
}
// openFrames opens and initializes the frames inside the index.
func (i *Index) openFrames() error {
// openFields opens and initializes the frames inside the index.
func (i *Index) openFields() error {
f, err := os.Open(i.path)
if err != nil {
return errors.Wrap(err, "opening directory")
@ -135,14 +135,14 @@ func (i *Index) openFrames() error {
continue
}
fr, err := i.newFrame(i.FramePath(filepath.Base(fi.Name())), filepath.Base(fi.Name()))
fld, err := i.newField(i.FieldPath(filepath.Base(fi.Name())), filepath.Base(fi.Name()))
if err != nil {
return ErrName
}
if err := fr.Open(); err != nil {
return fmt.Errorf("open frame: name=%s, err=%s", fr.Name(), err)
if err := fld.Open(); err != nil {
return fmt.Errorf("open frame: name=%s, err=%s", fld.Name(), err)
}
i.frames[fr.Name()] = fr
i.fields[fld.Name()] = fld
}
return nil
}
@ -198,12 +198,12 @@ func (i *Index) Close() error {
i.columnAttrStore.Close()
// Close all frames.
for _, f := range i.frames {
for _, f := range i.fields {
if err := f.Close(); err != nil {
return errors.Wrap(err, "closing frame")
}
}
i.frames = make(map[string]*Field)
i.fields = make(map[string]*Field)
return nil
}
@ -217,7 +217,7 @@ func (i *Index) MaxSlice() uint64 {
defer i.mu.RUnlock()
max := i.remoteMaxSlice
for _, f := range i.frames {
for _, f := range i.fields {
if slice := f.MaxSlice(); slice > max {
max = slice
}
@ -234,25 +234,25 @@ func (i *Index) SetRemoteMaxSlice(newmax uint64) {
i.remoteMaxSlice = newmax
}
// FramePath returns the path to a frame in the index.
func (i *Index) FramePath(name string) string { return filepath.Join(i.path, name) }
// FieldPath returns the path to a field in the index.
func (i *Index) FieldPath(name string) string { return filepath.Join(i.path, name) }
// Frame returns a frame in the index by name.
func (i *Index) Frame(name string) *Field {
// Field returns a frame in the index by name.
func (i *Index) Field(name string) *Field {
i.mu.RLock()
defer i.mu.RUnlock()
return i.frame(name)
return i.field(name)
}
func (i *Index) frame(name string) *Field { return i.frames[name] }
func (i *Index) field(name string) *Field { return i.fields[name] }
// Frames returns a list of all frames in the index.
func (i *Index) Frames() []*Field {
// Fields returns a list of all fields in the index.
func (i *Index) Fields() []*Field {
i.mu.RLock()
defer i.mu.RUnlock()
a := make([]*Field, 0, len(i.frames))
for _, f := range i.frames {
a := make([]*Field, 0, len(i.fields))
for _, f := range i.fields {
a = append(a, f)
}
sort.Sort(fieldSlice(a))
@ -262,37 +262,37 @@ func (i *Index) Frames() []*Field {
// RecalculateCaches recalculates caches on every frame in the index.
func (i *Index) RecalculateCaches() {
for _, frame := range i.Frames() {
for _, frame := range i.Fields() {
frame.RecalculateCaches()
}
}
// CreateFrame creates a frame.
func (i *Index) CreateFrame(name string, opt FieldOptions) (*Field, error) {
// CreateField creates a field.
func (i *Index) CreateField(name string, opt FieldOptions) (*Field, error) {
i.mu.Lock()
defer i.mu.Unlock()
// Ensure frame doesn't already exist.
if i.frames[name] != nil {
return nil, ErrFrameExists
if i.fields[name] != nil {
return nil, ErrFieldExists
}
return i.createFrame(name, opt)
return i.createField(name, opt)
}
// CreateFrameIfNotExists creates a frame with the given options if it doesn't exist.
func (i *Index) CreateFrameIfNotExists(name string, opt FieldOptions) (*Field, error) {
// CreateFieldIfNotExists creates a field with the given options if it doesn't exist.
func (i *Index) CreateFieldIfNotExists(name string, opt FieldOptions) (*Field, error) {
i.mu.Lock()
defer i.mu.Unlock()
// Find frame in cache first.
if f := i.frames[name]; f != nil {
if f := i.fields[name]; f != nil {
return f, nil
}
return i.createFrame(name, opt)
return i.createField(name, opt)
}
func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
func (i *Index) createField(name string, opt FieldOptions) (*Field, error) {
if name == "" {
return nil, errors.New("frame name required")
} else if opt.CacheType != "" && !IsValidCacheType(opt.CacheType) {
@ -305,7 +305,7 @@ func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
}
// Initialize frame.
f, err := i.newFrame(i.FramePath(name), name)
f, err := i.newField(i.FieldPath(name), name)
if err != nil {
return nil, errors.Wrap(err, "initializing")
}
@ -327,12 +327,12 @@ func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
}
// Add to index's frame lookup.
i.frames[name] = f
i.fields[name] = f
return f, nil
}
func (i *Index) newFrame(path, name string) (*Field, error) {
func (i *Index) newField(path, name string) (*Field, error) {
f, err := NewField(path, i.name, name)
if err != nil {
return nil, err
@ -344,13 +344,13 @@ func (i *Index) newFrame(path, name string) (*Field, error) {
return f, nil
}
// DeleteFrame removes a frame from the index.
func (i *Index) DeleteFrame(name string) error {
// DeleteField removes a field from the index.
func (i *Index) DeleteField(name string) error {
i.mu.Lock()
defer i.mu.Unlock()
// Ignore if frame doesn't exist.
f := i.frame(name)
f := i.field(name)
if f == nil {
return nil
}
@ -361,12 +361,12 @@ func (i *Index) DeleteFrame(name string) error {
}
// Delete frame directory.
if err := os.RemoveAll(i.FramePath(name)); err != nil {
if err := os.RemoveAll(i.FieldPath(name)); err != nil {
return errors.Wrap(err, "removing directory")
}
// Remove reference.
delete(i.frames, name)
delete(i.fields, name)
return nil
}
@ -380,7 +380,7 @@ func (p indexSlice) Less(i, j int) bool { return p[i].Name() < p[j].Name() }
// IndexInfo represents schema information for an index.
type IndexInfo struct {
Name string `json:"name"`
Frames []*FieldInfo `json:"frames"`
Fields []*FieldInfo `json:"fields"`
}
type indexInfoSlice []*IndexInfo
@ -402,7 +402,7 @@ func EncodeIndexes(a []*Index) []*internal.Index {
func encodeIndex(d *Index) *internal.Index {
return &internal.Index{
Name: d.name,
Frames: encodeFields(d.Frames()),
Frames: encodeFields(d.Fields()),
}
}

10
index_test.go
View file

@ -44,7 +44,7 @@ func TestIndex_CreateFrameIfNotExists(t *testing.T) {
t.Fatal("frame mismatch")
}
if f.Field != index.Frame("f") {
if f.Field != index.Field("f") {
t.Fatal("frame mismatch")
}
}
@ -89,7 +89,7 @@ func TestIndex_CreateFrame(t *testing.T) {
// Reopen the index & verify the fields are loaded.
if err := index.Reopen(); err != nil {
t.Fatal(err)
} else if f := index.Frame("f"); !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
} else if f := index.Field("f"); !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
t.Fatalf("unexpected type after reopen: %#v", f.Type())
}
})
@ -185,14 +185,14 @@ func TestIndex_DeleteFrame(t *testing.T) {
}
// Delete frame & verify it's gone.
if err := index.DeleteFrame("f"); err != nil {
if err := index.DeleteField("f"); err != nil {
t.Fatal(err)
} else if index.Frame("f") != nil {
} else if index.Field("f") != nil {
t.Fatal("expected nil frame")
}
// Delete again to make sure it doesn't error.
if err := index.DeleteFrame("f"); err != nil {
if err := index.DeleteField("f"); err != nil {
t.Fatal(err)
}
}

8
pilosa.go
View file

@ -31,10 +31,10 @@ var (
ErrIndexExists = errors.New("index already exists")
ErrIndexNotFound = errors.New("index not found")
// ErrFrameRequired is returned when no frame is specified.
ErrFrameRequired = errors.New("frame required")
ErrFrameExists = errors.New("frame already exists")
ErrFrameNotFound = errors.New("frame not found")
// ErrFieldRequired is returned when no field is specified.
ErrFieldRequired = errors.New("field required")
ErrFieldExists = errors.New("field already exists")
ErrFieldNotFound = errors.New("field not found")
ErrBSIGroupNotFound = errors.New("bsigroup not found")
ErrBSIGroupExists = errors.New("bsigroup already exists")

4
server.go
View file

@ -461,13 +461,13 @@ func (s *Server) ReceiveMessage(pb proto.Message) error {
return fmt.Errorf("Local Index not found: %s", obj.Index)
}
opt := decodeFieldOptions(obj.Meta)
_, err := idx.CreateFrame(obj.Frame, *opt)
_, err := idx.CreateField(obj.Frame, *opt)
if err != nil {
return err
}
case *internal.DeleteFrameMessage:
idx := s.Holder.Index(obj.Index)
if err := idx.DeleteFrame(obj.Frame); err != nil {
if err := idx.DeleteField(obj.Frame); err != nil {
return err
}
case *internal.CreateViewMessage:

4
server/cluster_test.go
View file

@ -66,7 +66,7 @@ func TestMain_SendReceiveMessage(t *testing.T) {
received0 := map[string][]string{}
for _, idx := range schema0 {
received0[idx.Name] = []string{}
for _, frame := range idx.Frames {
for _, frame := range idx.Fields {
received0[idx.Name] = append(received0[idx.Name], frame.Name)
}
}
@ -82,7 +82,7 @@ func TestMain_SendReceiveMessage(t *testing.T) {
received1 := map[string][]string{}
for _, idx := range schema1 {
received1[idx.Name] = []string{}
for _, frame := range idx.Frames {
for _, frame := range idx.Fields {
received1[idx.Name] = append(received1[idx.Name], frame.Name)
}
}

2
stats_test.go
View file

@ -298,7 +298,7 @@ func TestStatsCount_DeleteFrame(t *testing.T) {
called := false
// Create index.
indx, _ := hldr.CreateIndexIfNotExists("i", pilosa.IndexOptions{})
if _, err := indx.CreateFrameIfNotExists("test", pilosa.FieldOptions{}); err != nil {
if _, err := indx.CreateFieldIfNotExists("test", pilosa.FieldOptions{}); err != nil {
t.Fatal(err)
}
s.Handler.API.Holder.Stats = &MockStats{

2
test/cluster.go
View file

@ -120,7 +120,7 @@ func (t *TestCluster) CreateFrame(index, frame string, opt pilosa.FieldOptions)
if err != nil {
return err
}
if _, err := idx.CreateFrame(frame, opt); err != nil {
if _, err := idx.CreateField(frame, opt); err != nil {
return err
}
}

4
test/index.go
View file

@ -75,7 +75,7 @@ func (i *Index) Reopen() error {
// CreateFrame creates a frame with the given options.
func (i *Index) CreateFrame(name string, opt pilosa.FieldOptions) (*Frame, error) {
f, err := i.Index.CreateFrame(name, opt)
f, err := i.Index.CreateField(name, opt)
if err != nil {
return nil, err
}
@ -84,7 +84,7 @@ func (i *Index) CreateFrame(name string, opt pilosa.FieldOptions) (*Frame, error
// CreateFrameIfNotExists creates a frame with the given options if it doesn't exist.
func (i *Index) CreateFrameIfNotExists(name string, opt pilosa.FieldOptions) (*Frame, error) {
f, err := i.Index.CreateFrameIfNotExists(name, opt)
f, err := i.Index.CreateFieldIfNotExists(name, opt)
if err != nil {
return nil, err
}

2
utils_test.go
View file

@ -110,7 +110,7 @@ func (t *ClusterCluster) CreateFrame(index, frame string, opt FieldOptions) erro
if err != nil {
return err
}
if _, err := idx.CreateFrame(frame, opt); err != nil {
if _, err := idx.CreateField(frame, opt); err != nil {
return err
}
}