diff --git a/api.go b/api.go
index e528a4b21..56eaece56 100644
--- a/api.go
+++ b/api.go
@@ -217,9 +217,9 @@ func (api *API) DeleteIndex(ctx context.Context, indexName string) error {
 	return nil
 }
 
-// CreateFrame makes the named frame in the named index with the given options.
-func (api *API) CreateFrame(ctx context.Context, indexName string, frameName string, options FrameOptions) (*Frame, error) {
-	if err := api.validate(apiCreateFrame); err != nil {
+// CreateField makes the named field in the named index with the given options.
+func (api *API) CreateField(ctx context.Context, indexName string, fieldName string, options FieldOptions) (*Field, error) {
+	if err := api.validate(apiCreateField); err != nil {
 		return nil, errors.Wrap(err, "validating api method")
 	}
 
@@ -229,32 +229,32 @@ func (api *API) CreateFrame(ctx context.Context, indexName string, frameName str
 		return nil, ErrIndexNotFound
 	}
 
-	// Create frame.
-	frame, err := index.CreateFrame(frameName, options)
+	// Create field.
+	field, err := index.CreateField(fieldName, options)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating frame")
+		return nil, errors.Wrap(err, "creating field")
 	}
 
-	// Send the create frame message to all nodes.
+	// Send the create field message to all nodes.
 	err = api.Broadcaster.SendSync(
-		&internal.CreateFrameMessage{
+		&internal.CreateFieldMessage{
 			Index: indexName,
-			Frame: frameName,
+			Field: fieldName,
 			Meta:  options.Encode(),
 		})
 	if err != nil {
-		api.Logger.Printf("problem sending CreateFrame message: %s", err)
-		return nil, errors.Wrap(err, "sending CreateFrame message")
+		api.Logger.Printf("problem sending CreateField message: %s", err)
+		return nil, errors.Wrap(err, "sending CreateField message")
 	}
-	api.Holder.Stats.CountWithCustomTags("createFrame", 1, 1.0, []string{fmt.Sprintf("index:%s", indexName)})
-	return frame, nil
+	api.Holder.Stats.CountWithCustomTags("createField", 1, 1.0, []string{fmt.Sprintf("index:%s", indexName)})
+	return field, nil
 }
 
-// DeleteFrame removes the named frame from the named index. If the index is not
-// found, an error is returned. If the frame is not found, it is ignored and no
+// DeleteField removes the named field from the named index. If the index is not
+// found, an error is returned. If the field is not found, it is ignored and no
 // action is taken.
-func (api *API) DeleteFrame(ctx context.Context, indexName string, frameName string) error {
-	if err := api.validate(apiDeleteFrame); err != nil {
+func (api *API) DeleteField(ctx context.Context, indexName string, fieldName string) error {
+	if err := api.validate(apiDeleteField); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
 
@@ -264,28 +264,28 @@ func (api *API) DeleteFrame(ctx context.Context, indexName string, frameName str
 		return ErrIndexNotFound
 	}
 
-	// Delete frame from the index.
-	if err := index.DeleteFrame(frameName); err != nil {
-		return errors.Wrap(err, "deleting frame")
+	// Delete field from the index.
+	if err := index.DeleteField(fieldName); err != nil {
+		return errors.Wrap(err, "deleting field")
 	}
 
-	// Send the delete frame message to all nodes.
+	// Send the delete field message to all nodes.
 	err := api.Broadcaster.SendSync(
-		&internal.DeleteFrameMessage{
+		&internal.DeleteFieldMessage{
 			Index: indexName,
-			Frame: frameName,
+			Field: fieldName,
 		})
 	if err != nil {
-		api.Logger.Printf("problem sending DeleteFrame message: %s", err)
-		return errors.Wrap(err, "sending DeleteFrame message")
+		api.Logger.Printf("problem sending DeleteField message: %s", err)
+		return errors.Wrap(err, "sending DeleteField message")
 	}
-	api.Holder.Stats.CountWithCustomTags("deleteFrame", 1, 1.0, []string{fmt.Sprintf("index:%s", indexName)})
+	api.Holder.Stats.CountWithCustomTags("deleteField", 1, 1.0, []string{fmt.Sprintf("index:%s", indexName)})
 	return nil
 }
 
-// ExportCSV encodes the fragment designated by the index,frame,slice as
+// ExportCSV encodes the fragment designated by the index,field,slice as
 // CSV of the form <row>,<col>
-func (api *API) ExportCSV(ctx context.Context, indexName string, frameName string, slice uint64, w io.Writer) error {
+func (api *API) ExportCSV(ctx context.Context, indexName string, fieldName string, slice uint64, w io.Writer) error {
 	if err := api.validate(apiExportCSV); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
@@ -297,7 +297,7 @@ func (api *API) ExportCSV(ctx context.Context, indexName string, frameName strin
 	}
 
 	// Find the fragment.
-	f := api.Holder.Fragment(indexName, frameName, ViewStandard, slice)
+	f := api.Holder.Fragment(indexName, fieldName, ViewStandard, slice)
 	if f == nil {
 		return ErrFragmentNotFound
 	}
@@ -333,13 +333,13 @@ func (api *API) SliceNodes(ctx context.Context, indexName string, slice uint64)
 // MarshalFragment returns an object which can write the specified fragment's data
 // to an io.Writer. The serialized data can be read back into a fragment with
 // the UnmarshalFragment API call.
-func (api *API) MarshalFragment(ctx context.Context, indexName string, frameName string, slice uint64) (io.WriterTo, error) {
+func (api *API) MarshalFragment(ctx context.Context, indexName string, fieldName string, slice uint64) (io.WriterTo, error) {
 	if err := api.validate(apiMarshalFragment); err != nil {
 		return nil, errors.Wrap(err, "validating api method")
 	}
 
 	// Retrieve fragment from holder.
-	f := api.Holder.Fragment(indexName, frameName, ViewStandard, slice)
+	f := api.Holder.Fragment(indexName, fieldName, ViewStandard, slice)
 	if f == nil {
 		return nil, ErrFragmentNotFound
 	}
@@ -349,15 +349,15 @@ func (api *API) MarshalFragment(ctx context.Context, indexName string, frameName
 // UnmarshalFragment creates a new fragment (if necessary) and reads data from a
 // Reader which was previously written by MarshalFragment to populate the
 // fragment's data.
-func (api *API) UnmarshalFragment(ctx context.Context, indexName string, frameName string, slice uint64, reader io.ReadCloser) error {
+func (api *API) UnmarshalFragment(ctx context.Context, indexName string, fieldName string, slice uint64, reader io.ReadCloser) error {
 	if err := api.validate(apiUnmarshalFragment); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
 
-	// Retrieve frame.
-	f := api.Holder.Frame(indexName, frameName)
+	// Retrieve field.
+	f := api.Holder.Field(indexName, fieldName)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Retrieve view.
@@ -366,7 +366,7 @@ func (api *API) UnmarshalFragment(ctx context.Context, indexName string, frameNa
 		return errors.Wrap(err, "creating view")
 	}
 
-	// Retrieve fragment from frame.
+	// Retrieve fragment from field.
 	frag, err := view.CreateFragmentIfNotExists(slice)
 	if err != nil {
 		return errors.Wrap(err, "creating fragment")
@@ -397,7 +397,7 @@ func (api *API) FragmentBlockData(ctx context.Context, body io.Reader) ([]byte,
 	}
 
 	// Retrieve fragment from holder.
-	f := api.Holder.Fragment(req.Index, req.Frame, ViewStandard, req.Slice)
+	f := api.Holder.Fragment(req.Index, req.Field, ViewStandard, req.Slice)
 	if f == nil {
 		return nil, ErrFragmentNotFound
 	}
@@ -415,13 +415,13 @@ func (api *API) FragmentBlockData(ctx context.Context, body io.Reader) ([]byte,
 }
 
 // FragmentBlocks returns the checksums and block ids for all blocks in the specified fragment.
-func (api *API) FragmentBlocks(ctx context.Context, indexName string, frameName string, slice uint64) ([]FragmentBlock, error) {
+func (api *API) FragmentBlocks(ctx context.Context, indexName string, fieldName string, slice uint64) ([]FragmentBlock, error) {
 	if err := api.validate(apiFragmentBlocks); err != nil {
 		return nil, errors.Wrap(err, "validating api method")
 	}
 
 	// Retrieve fragment from holder.
-	f := api.Holder.Fragment(indexName, frameName, ViewStandard, slice)
+	f := api.Holder.Fragment(indexName, fieldName, ViewStandard, slice)
 	if f == nil {
 		return nil, ErrFragmentNotFound
 	}
@@ -482,22 +482,22 @@ func (api *API) LocalID() string {
 	return api.Cluster.Node.ID
 }
 
-// Schema returns information about each index in Pilosa including which frames
+// Schema returns information about each index in Pilosa including which fields
 // and views they contain.
 func (api *API) Schema(ctx context.Context) []*IndexInfo {
 	return api.Holder.Schema()
 }
 
-// Views returns the views in the given frame.
-func (api *API) Views(ctx context.Context, indexName string, frameName string) ([]*View, error) {
+// Views returns the views in the given field.
+func (api *API) Views(ctx context.Context, indexName string, fieldName string) ([]*View, error) {
 	if err := api.validate(apiViews); err != nil {
 		return nil, errors.Wrap(err, "validating api method")
 	}
 
 	// Retrieve views.
-	f := api.Holder.Frame(indexName, frameName)
+	f := api.Holder.Field(indexName, fieldName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Fetch views.
@@ -506,15 +506,15 @@ func (api *API) Views(ctx context.Context, indexName string, frameName string) (
 }
 
 // DeleteView removes the given view.
-func (api *API) DeleteView(ctx context.Context, indexName string, frameName string, viewName string) error {
+func (api *API) DeleteView(ctx context.Context, indexName string, fieldName string, viewName string) error {
 	if err := api.validate(apiDeleteView); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
 
-	// Retrieve frame.
-	f := api.Holder.Frame(indexName, frameName)
+	// Retrieve field.
+	f := api.Holder.Field(indexName, fieldName)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Delete the view.
@@ -529,7 +529,7 @@ func (api *API) DeleteView(ctx context.Context, indexName string, frameName stri
 	err := api.Broadcaster.SendSync(
 		&internal.DeleteViewMessage{
 			Index: indexName,
-			Frame: frameName,
+			Field: fieldName,
 			View:  viewName,
 		})
 	if err != nil {
@@ -574,15 +574,15 @@ func (api *API) IndexAttrDiff(ctx context.Context, indexName string, blocks []At
 	return attrs, nil
 }
 
-func (api *API) FrameAttrDiff(ctx context.Context, indexName string, frameName string, blocks []AttrBlock) (map[uint64]map[string]interface{}, error) {
-	if err := api.validate(apiFrameAttrDiff); err != nil {
+func (api *API) FieldAttrDiff(ctx context.Context, indexName string, fieldName string, blocks []AttrBlock) (map[uint64]map[string]interface{}, error) {
+	if err := api.validate(apiFieldAttrDiff); err != nil {
 		return nil, errors.Wrap(err, "validating api method")
 	}
 
 	// Retrieve index from holder.
-	f := api.Holder.Frame(indexName, frameName)
+	f := api.Holder.Field(indexName, fieldName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Retrieve local blocks.
@@ -608,15 +608,15 @@ func (api *API) FrameAttrDiff(ctx context.Context, indexName string, frameName s
 	return attrs, nil
 }
 
-// Import bulk imports data into a particular index,frame,slice.
+// Import bulk imports data into a particular index,field,slice.
 func (api *API) Import(ctx context.Context, req internal.ImportRequest) error {
 	if err := api.validate(apiImport); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
 
-	_, frame, err := api.indexFrame(req.Index, req.Frame, req.Slice)
+	_, field, err := api.indexField(req.Index, req.Field, req.Slice)
 	if err != nil {
-		return errors.Wrap(err, "getting frame")
+		return errors.Wrap(err, "getting field")
 	}
 
 	// Convert timestamps to time.Time.
@@ -630,9 +630,9 @@ func (api *API) Import(ctx context.Context, req internal.ImportRequest) error {
 	}
 
 	// Import into fragment.
-	err = frame.Import(req.RowIDs, req.ColumnIDs, timestamps)
+	err = field.Import(req.RowIDs, req.ColumnIDs, timestamps)
 	if err != nil {
-		api.Logger.Printf("import error: index=%s, frame=%s, slice=%d, columns=%d, err=%s", req.Index, req.Frame, req.Slice, len(req.ColumnIDs), err)
+		api.Logger.Printf("import error: index=%s, field=%s, slice=%d, columns=%d, err=%s", req.Index, req.Field, req.Slice, len(req.ColumnIDs), err)
 	}
 	return errors.Wrap(err, "importing")
 }
@@ -643,15 +643,15 @@ func (api *API) ImportValue(ctx context.Context, req internal.ImportValueRequest
 		return errors.Wrap(err, "validating api method")
 	}
 
-	_, frame, err := api.indexFrame(req.Index, req.Frame, req.Slice)
+	_, field, err := api.indexField(req.Index, req.Field, req.Slice)
 	if err != nil {
-		return errors.Wrap(err, "getting frame")
+		return errors.Wrap(err, "getting field")
 	}
 
 	// Import into fragment.
-	err = frame.ImportValue(req.ColumnIDs, req.Values)
+	err = field.ImportValue(req.ColumnIDs, req.Values)
 	if err != nil {
-		api.Logger.Printf("import error: index=%s, frame=%s, slice=%d, columns=%d, err=%s", req.Index, req.Frame, req.Slice, len(req.ColumnIDs), err)
+		api.Logger.Printf("import error: index=%s, field=%s, slice=%d, columns=%d, err=%s", req.Index, req.Field, req.Slice, len(req.ColumnIDs), err)
 	}
 	return errors.Wrap(err, "importing")
 }
@@ -679,7 +679,7 @@ func (api *API) LongQueryTime() time.Duration {
 	return api.Cluster.LongQueryTime
 }
 
-func (api *API) indexFrame(indexName string, frameName string, slice uint64) (*Index, *Frame, error) {
+func (api *API) indexField(indexName string, fieldName string, slice uint64) (*Index, *Field, error) {
 	// Validate that this handler owns the slice.
 	if !api.Cluster.OwnsSlice(api.LocalID(), indexName, slice) {
 		api.Logger.Printf("node %s does not own slice %d of index %s", api.LocalID(), slice, indexName)
@@ -687,20 +687,20 @@ func (api *API) indexFrame(indexName string, frameName string, slice uint64) (*I
 	}
 
 	// Find the Index.
-	api.Logger.Printf("importing: %v %v %v", indexName, frameName, slice)
+	api.Logger.Printf("importing: %v %v %v", indexName, fieldName, slice)
 	index := api.Holder.Index(indexName)
 	if index == nil {
-		api.Logger.Printf("fragment error: index=%s, frame=%s, slice=%d, err=%s", indexName, frameName, slice, ErrIndexNotFound.Error())
+		api.Logger.Printf("fragment error: index=%s, field=%s, slice=%d, err=%s", indexName, fieldName, slice, ErrIndexNotFound.Error())
 		return nil, nil, ErrIndexNotFound
 	}
 
-	// Retrieve frame.
-	frame := index.Frame(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
+	// Retrieve field.
+	field := index.Field(fieldName)
+	if field == nil {
+		api.Logger.Printf("field error: index=%s, field=%s, slice=%d, err=%s", indexName, fieldName, slice, ErrFieldNotFound.Error())
+		return nil, nil, ErrFieldNotFound
 	}
-	return index, frame, nil
+	return index, field, nil
 }
 
 // SetCoordinator makes a new Node the cluster coordinator.
@@ -790,15 +790,15 @@ type apiMethod int
 // API validation constants.
 const (
 	apiClusterMessage apiMethod = iota
-	apiCreateFrame
+	apiCreateField
 	apiCreateIndex
-	apiDeleteFrame
+	apiDeleteField
 	apiDeleteIndex
 	apiDeleteView
 	apiExportCSV
 	apiFragmentBlockData
 	apiFragmentBlocks
-	apiFrameAttrDiff
+	apiFieldAttrDiff
 	//apiHosts // not implemented
 	apiImport
 	apiImportValue
@@ -833,15 +833,15 @@ var methodsResizing = map[apiMethod]struct{}{
 }
 
 var methodsNormal = map[apiMethod]struct{}{
-	apiCreateFrame:       struct{}{},
+	apiCreateField:       struct{}{},
 	apiCreateIndex:       struct{}{},
-	apiDeleteFrame:       struct{}{},
+	apiDeleteField:       struct{}{},
 	apiDeleteIndex:       struct{}{},
 	apiDeleteView:        struct{}{},
 	apiExportCSV:         struct{}{},
 	apiFragmentBlockData: struct{}{},
 	apiFragmentBlocks:    struct{}{},
-	apiFrameAttrDiff:     struct{}{},
+	apiFieldAttrDiff:     struct{}{},
 	apiImport:            struct{}{},
 	apiImportValue:       struct{}{},
 	apiIndex:             struct{}{},
diff --git a/apimethod_string.go b/apimethod_string.go
index ce119196f..a2b934e0f 100644
--- a/apimethod_string.go
+++ b/apimethod_string.go
@@ -4,7 +4,7 @@ package pilosa
 
 import "fmt"
 
-const _apiMethod_name = "apiClusterMessageapiCreateFrameapiCreateIndexapiDeleteFrameapiDeleteIndexapiDeleteViewapiExportCSVapiFragmentBlockDataapiFragmentBlocksapiFrameAttrDiffapiImportapiImportValueapiIndexapiIndexAttrDiffapiMarshalFragmentapiQueryapiRecalculateCachesapiRemoveNodeapiResizeAbortapiSetCoordinatorapiSliceNodesapiUnmarshalFragmentapiViews"
+const _apiMethod_name = "apiClusterMessageapiCreateFieldapiCreateIndexapiDeleteFieldapiDeleteIndexapiDeleteViewapiExportCSVapiFragmentBlockDataapiFragmentBlocksapiFieldAttrDiffapiImportapiImportValueapiIndexapiIndexAttrDiffapiMarshalFragmentapiQueryapiRecalculateCachesapiRemoveNodeapiResizeAbortapiSetCoordinatorapiSliceNodesapiUnmarshalFragmentapiViews"
 
 var _apiMethod_index = [...]uint16{0, 17, 31, 45, 59, 73, 86, 98, 118, 135, 151, 160, 174, 182, 198, 216, 224, 244, 257, 271, 288, 301, 321, 329}
 
diff --git a/broadcast.go b/broadcast.go
index 933ca05a5..6b26b5d58 100644
--- a/broadcast.go
+++ b/broadcast.go
@@ -123,8 +123,8 @@ const (
 	MessageTypeCreateSlice = iota
 	MessageTypeCreateIndex
 	MessageTypeDeleteIndex
-	MessageTypeCreateFrame
-	MessageTypeDeleteFrame
+	MessageTypeCreateField
+	MessageTypeDeleteField
 	MessageTypeCreateView
 	MessageTypeDeleteView
 	MessageTypeClusterStatus
@@ -147,10 +147,10 @@ func MarshalMessage(m proto.Message) ([]byte, error) {
 		typ = MessageTypeCreateIndex
 	case *internal.DeleteIndexMessage:
 		typ = MessageTypeDeleteIndex
-	case *internal.CreateFrameMessage:
-		typ = MessageTypeCreateFrame
-	case *internal.DeleteFrameMessage:
-		typ = MessageTypeDeleteFrame
+	case *internal.CreateFieldMessage:
+		typ = MessageTypeCreateField
+	case *internal.DeleteFieldMessage:
+		typ = MessageTypeDeleteField
 	case *internal.CreateViewMessage:
 		typ = MessageTypeCreateView
 	case *internal.DeleteViewMessage:
@@ -193,10 +193,10 @@ func UnmarshalMessage(buf []byte) (proto.Message, error) {
 		m = &internal.CreateIndexMessage{}
 	case MessageTypeDeleteIndex:
 		m = &internal.DeleteIndexMessage{}
-	case MessageTypeCreateFrame:
-		m = &internal.CreateFrameMessage{}
-	case MessageTypeDeleteFrame:
-		m = &internal.DeleteFrameMessage{}
+	case MessageTypeCreateField:
+		m = &internal.CreateFieldMessage{}
+	case MessageTypeDeleteField:
+		m = &internal.DeleteFieldMessage{}
 	case MessageTypeCreateView:
 		m = &internal.CreateViewMessage{}
 	case MessageTypeDeleteView:
diff --git a/client.go b/client.go
index 1d78dde23..81f750a39 100644
--- a/client.go
+++ b/client.go
@@ -107,7 +107,7 @@ func (c *InternalHTTPClient) maxSliceByIndex(ctx context.Context) (map[string]ui
 	return rsp.Standard, nil
 }
 
-// Schema returns all index and frame schema information.
+// Schema returns all index and field schema information.
 func (c *InternalHTTPClient) Schema(ctx context.Context) ([]*IndexInfo, error) {
 	// Execute request against the host.
 	u := c.defaultURI.Path("/schema")
@@ -269,14 +269,14 @@ func (c *InternalHTTPClient) QueryNode(ctx context.Context, uri *URI, index stri
 }
 
 // Import bulk imports bits for a single slice to a host.
-func (c *InternalHTTPClient) Import(ctx context.Context, index, frame string, slice uint64, bits []Bit) error {
+func (c *InternalHTTPClient) Import(ctx context.Context, index, field string, slice uint64, bits []Bit) error {
 	if index == "" {
 		return ErrIndexRequired
-	} else if frame == "" {
-		return ErrFrameRequired
+	} else if field == "" {
+		return ErrFieldRequired
 	}
 
-	buf, err := marshalImportPayload(index, frame, slice, bits)
+	buf, err := marshalImportPayload(index, field, slice, bits)
 	if err != nil {
 		return fmt.Errorf("Error Creating Payload: %s", err)
 	}
@@ -298,14 +298,14 @@ func (c *InternalHTTPClient) Import(ctx context.Context, index, frame string, sl
 }
 
 // ImportK bulk imports bits specified by string keys to a host.
-func (c *InternalHTTPClient) ImportK(ctx context.Context, index, frame string, columns []Bit) error {
+func (c *InternalHTTPClient) ImportK(ctx context.Context, index, field string, columns []Bit) error {
 	if index == "" {
 		return ErrIndexRequired
-	} else if frame == "" {
-		return ErrFrameRequired
+	} else if field == "" {
+		return ErrFieldRequired
 	}
 
-	buf, err := marshalImportPayloadK(index, frame, columns)
+	buf, err := marshalImportPayloadK(index, field, columns)
 	if err != nil {
 		return fmt.Errorf("Error Creating Payload: %s", err)
 	}
@@ -330,16 +330,16 @@ func (c *InternalHTTPClient) EnsureIndex(ctx context.Context, name string, optio
 	return err
 }
 
-func (c *InternalHTTPClient) EnsureFrame(ctx context.Context, indexName string, frameName string, options FrameOptions) error {
-	err := c.CreateFrame(ctx, indexName, frameName, options)
-	if err == nil || err == ErrFrameExists {
+func (c *InternalHTTPClient) EnsureField(ctx context.Context, indexName string, fieldName string, options FieldOptions) error {
+	err := c.CreateField(ctx, indexName, fieldName, options)
+	if err == nil || err == ErrFieldExists {
 		return nil
 	}
 	return err
 }
 
 // marshalImportPayload marshalls the import parameters into a protobuf byte slice.
-func marshalImportPayload(index, frame string, slice uint64, bits []Bit) ([]byte, error) {
+func marshalImportPayload(index, field string, slice uint64, bits []Bit) ([]byte, error) {
 	// Separate row and column IDs to reduce allocations.
 	rowIDs := Bits(bits).RowIDs()
 	columnIDs := Bits(bits).ColumnIDs()
@@ -348,7 +348,7 @@ func marshalImportPayload(index, frame string, slice uint64, bits []Bit) ([]byte
 	// Marshal data to protobuf.
 	buf, err := proto.Marshal(&internal.ImportRequest{
 		Index:      index,
-		Frame:      frame,
+		Field:      field,
 		Slice:      slice,
 		RowIDs:     rowIDs,
 		ColumnIDs:  columnIDs,
@@ -361,7 +361,7 @@ func marshalImportPayload(index, frame string, slice uint64, bits []Bit) ([]byte
 }
 
 // marshalImportPayloadK marshalls the import parameters into a protobuf byte slice.
-func marshalImportPayloadK(index, frame string, bits []Bit) ([]byte, error) {
+func marshalImportPayloadK(index, field string, bits []Bit) ([]byte, error) {
 	// Separate row and column IDs to reduce allocations.
 	rowKeys := Bits(bits).RowKeys()
 	columnKeys := Bits(bits).ColumnKeys()
@@ -370,7 +370,7 @@ func marshalImportPayloadK(index, frame string, bits []Bit) ([]byte, error) {
 	// Marshal data to protobuf.
 	buf, err := proto.Marshal(&internal.ImportRequest{
 		Index:      index,
-		Frame:      frame,
+		Field:      field,
 		RowKeys:    rowKeys,
 		ColumnKeys: columnKeys,
 		Timestamps: timestamps,
@@ -420,14 +420,14 @@ func (c *InternalHTTPClient) importNode(ctx context.Context, node *Node, buf []b
 }
 
 // ImportValue bulk imports field values for a single slice to a host.
-func (c *InternalHTTPClient) ImportValue(ctx context.Context, index, frame string, slice uint64, vals []FieldValue) error {
+func (c *InternalHTTPClient) ImportValue(ctx context.Context, index, field string, slice uint64, vals []FieldValue) error {
 	if index == "" {
 		return ErrIndexRequired
-	} else if frame == "" {
-		return ErrFrameRequired
+	} else if field == "" {
+		return ErrFieldRequired
 	}
 
-	buf, err := marshalImportValuePayload(index, frame, slice, vals)
+	buf, err := marshalImportValuePayload(index, field, slice, vals)
 	if err != nil {
 		return fmt.Errorf("Error Creating Payload: %s", err)
 	}
@@ -449,7 +449,7 @@ func (c *InternalHTTPClient) ImportValue(ctx context.Context, index, frame strin
 }
 
 // marshalImportValuePayload marshalls the import parameters into a protobuf byte slice.
-func marshalImportValuePayload(index, frame string, slice uint64, vals []FieldValue) ([]byte, error) {
+func marshalImportValuePayload(index, field string, slice uint64, vals []FieldValue) ([]byte, error) {
 	// Separate row and column IDs to reduce allocations.
 	columnIDs := FieldValues(vals).ColumnIDs()
 	values := FieldValues(vals).Values()
@@ -457,7 +457,7 @@ func marshalImportValuePayload(index, frame string, slice uint64, vals []FieldVa
 	// Marshal data to protobuf.
 	buf, err := proto.Marshal(&internal.ImportValueRequest{
 		Index:     index,
-		Frame:     frame,
+		Field:     field,
 		Slice:     slice,
 		ColumnIDs: columnIDs,
 		Values:    values,
@@ -507,11 +507,11 @@ func (c *InternalHTTPClient) importValueNode(ctx context.Context, node *Node, bu
 }
 
 // ExportCSV bulk exports data for a single slice from a host to CSV format.
-func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, frame string, slice uint64, w io.Writer) error {
+func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, field string, slice uint64, w io.Writer) error {
 	if index == "" {
 		return ErrIndexRequired
-	} else if frame == "" {
-		return ErrFrameRequired
+	} else if field == "" {
+		return ErrFieldRequired
 	}
 
 	// Retrieve a list of nodes that own the slice.
@@ -525,7 +525,7 @@ func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, frame string,
 	for _, i := range rand.Perm(len(nodes)) {
 		node := nodes[i]
 
-		if err := c.exportNodeCSV(ctx, node, index, frame, slice, w); err != nil {
+		if err := c.exportNodeCSV(ctx, node, index, field, slice, w); err != nil {
 			e = fmt.Errorf("export node: host=%s, err=%s", node.URI, err)
 			continue
 		} else {
@@ -537,12 +537,12 @@ func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, frame string,
 }
 
 // exportNode copies a CSV export from a node to w.
-func (c *InternalHTTPClient) exportNodeCSV(ctx context.Context, node *Node, index, frame string, slice uint64, w io.Writer) error {
+func (c *InternalHTTPClient) exportNodeCSV(ctx context.Context, node *Node, index, field string, slice uint64, w io.Writer) error {
 	// Create URL.
 	u := nodePathToURL(node, "/export")
 	u.RawQuery = url.Values{
 		"index": {index},
-		"frame": {frame},
+		"field": {field},
 		"slice": {strconv.FormatUint(slice, 10)},
 	}.Encode()
 
@@ -574,18 +574,18 @@ func (c *InternalHTTPClient) exportNodeCSV(ctx context.Context, node *Node, inde
 	return nil
 }
 
-func (c *InternalHTTPClient) RetrieveSliceFromURI(ctx context.Context, index, frame string, slice uint64, uri URI) (io.ReadCloser, error) {
+func (c *InternalHTTPClient) RetrieveSliceFromURI(ctx context.Context, index, field string, slice uint64, uri URI) (io.ReadCloser, error) {
 	node := &Node{
 		URI: uri,
 	}
-	return c.backupSliceNode(ctx, index, frame, slice, node)
+	return c.backupSliceNode(ctx, index, field, slice, node)
 }
 
-func (c *InternalHTTPClient) backupSliceNode(ctx context.Context, index, frame string, slice uint64, node *Node) (io.ReadCloser, error) {
+func (c *InternalHTTPClient) backupSliceNode(ctx context.Context, index, field string, slice uint64, node *Node) (io.ReadCloser, error) {
 	u := nodePathToURL(node, "/fragment/data")
 	u.RawQuery = url.Values{
 		"index": {index},
-		"frame": {frame},
+		"field": {field},
 		"slice": {strconv.FormatUint(slice, 10)},
 	}.Encode()
 
@@ -615,14 +615,14 @@ func (c *InternalHTTPClient) backupSliceNode(ctx context.Context, index, frame s
 	return resp.Body, nil
 }
 
-// CreateFrame creates a new frame on the server.
-func (c *InternalHTTPClient) CreateFrame(ctx context.Context, index, frame string, opt FrameOptions) error {
+// CreateField creates a new field on the server.
+func (c *InternalHTTPClient) CreateField(ctx context.Context, index, field string, opt FieldOptions) error {
 	if index == "" {
 		return ErrIndexRequired
 	}
 
 	// Encode query request.
-	buf, err := json.Marshal(&postFrameRequest{
+	buf, err := json.Marshal(&postFieldRequest{
 		Options: opt,
 	})
 	if err != nil {
@@ -630,7 +630,7 @@ func (c *InternalHTTPClient) CreateFrame(ctx context.Context, index, frame strin
 	}
 
 	// Create URL & HTTP request.
-	u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/frame/%s", index, frame))
+	u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/field/%s", index, field))
 	req, err := http.NewRequest("POST", u.String(), bytes.NewReader(buf))
 	if err != nil {
 		return errors.Wrap(err, "creating request")
@@ -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))
 	}
@@ -666,11 +666,11 @@ func (c *InternalHTTPClient) CreateFrame(ctx context.Context, index, frame strin
 
 // FragmentBlocks returns a list of block checksums for a fragment on a host.
 // Only returns blocks which contain data.
-func (c *InternalHTTPClient) FragmentBlocks(ctx context.Context, index, frame string, slice uint64) ([]FragmentBlock, error) {
+func (c *InternalHTTPClient) FragmentBlocks(ctx context.Context, index, field string, slice uint64) ([]FragmentBlock, error) {
 	u := uriPathToURL(c.defaultURI, "/fragment/blocks")
 	u.RawQuery = url.Values{
 		"index": {index},
-		"frame": {frame},
+		"field": {field},
 		"slice": {strconv.FormatUint(slice, 10)},
 	}.Encode()
 
@@ -707,10 +707,10 @@ func (c *InternalHTTPClient) FragmentBlocks(ctx context.Context, index, frame st
 }
 
 // BlockData returns row/column id pairs for a block.
-func (c *InternalHTTPClient) BlockData(ctx context.Context, index, frame string, slice uint64, block int) ([]uint64, []uint64, error) {
+func (c *InternalHTTPClient) BlockData(ctx context.Context, index, field string, slice uint64, block int) ([]uint64, []uint64, error) {
 	buf, err := proto.Marshal(&internal.BlockDataRequest{
 		Index: index,
-		Frame: frame,
+		Field: field,
 		Slice: slice,
 		Block: uint64(block),
 	})
@@ -794,11 +794,11 @@ func (c *InternalHTTPClient) ColumnAttrDiff(ctx context.Context, index string, b
 }
 
 // RowAttrDiff returns data from differing blocks on a remote host.
-func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame string, blks []AttrBlock) (map[uint64]map[string]interface{}, error) {
-	u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/frame/%s/attr/diff", index, frame))
+func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, field string, blks []AttrBlock) (map[uint64]map[string]interface{}, error) {
+	u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/field/%s/attr/diff", index, field))
 
 	// Encode request.
-	buf, err := json.Marshal(postFrameAttrDiffRequest{Blocks: blks})
+	buf, err := json.Marshal(postFieldAttrDiffRequest{Blocks: blks})
 	if err != nil {
 		return nil, errors.Wrap(err, "marshaling")
 	}
@@ -822,13 +822,13 @@ 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)
 	}
 
 	// Decode response object.
-	var rsp postFrameAttrDiffResponse
+	var rsp postFieldAttrDiffResponse
 	if err := json.NewDecoder(resp.Body).Decode(&rsp); err != nil {
 		return nil, errors.Wrap(err, "decoding")
 	}
@@ -961,7 +961,7 @@ func (p Bits) GroupBySlice() map[uint64][]Bit {
 }
 
 // FieldValues represents the value for a column within a
-// range-encoded frame.
+// range-encoded field.
 type FieldValue struct {
 	ColumnID uint64
 	Value    int64
@@ -1053,16 +1053,16 @@ type InternalClient interface {
 	FragmentNodes(ctx context.Context, index string, slice uint64) ([]*Node, error)
 	Query(ctx context.Context, index string, queryRequest *internal.QueryRequest) (*internal.QueryResponse, error)
 	QueryNode(ctx context.Context, uri *URI, index string, queryRequest *internal.QueryRequest) (*internal.QueryResponse, error)
-	Import(ctx context.Context, index, frame string, slice uint64, bits []Bit) error
-	ImportK(ctx context.Context, index, frame string, bits []Bit) error
+	Import(ctx context.Context, index, field string, slice uint64, bits []Bit) error
+	ImportK(ctx context.Context, index, field string, bits []Bit) error
 	EnsureIndex(ctx context.Context, name string, options IndexOptions) error
-	EnsureFrame(ctx context.Context, indexName string, frameName string, options FrameOptions) error
-	ImportValue(ctx context.Context, index, frame string, slice uint64, vals []FieldValue) error
-	ExportCSV(ctx context.Context, index, frame string, slice uint64, w io.Writer) error
-	CreateFrame(ctx context.Context, index, frame string, opt FrameOptions) error
-	FragmentBlocks(ctx context.Context, index, frame string, slice uint64) ([]FragmentBlock, error)
-	BlockData(ctx context.Context, index, frame string, slice uint64, block int) ([]uint64, []uint64, error)
+	EnsureField(ctx context.Context, indexName string, fieldName string, options FieldOptions) error
+	ImportValue(ctx context.Context, index, field string, slice uint64, vals []FieldValue) error
+	ExportCSV(ctx context.Context, index, field string, slice uint64, w io.Writer) error
+	CreateField(ctx context.Context, index, field string, opt FieldOptions) error
+	FragmentBlocks(ctx context.Context, index, field string, slice uint64) ([]FragmentBlock, error)
+	BlockData(ctx context.Context, index, field string, slice uint64, block int) ([]uint64, []uint64, error)
 	ColumnAttrDiff(ctx context.Context, index string, blks []AttrBlock) (map[uint64]map[string]interface{}, error)
-	RowAttrDiff(ctx context.Context, index, frame string, blks []AttrBlock) (map[uint64]map[string]interface{}, error)
+	RowAttrDiff(ctx context.Context, index, field string, blks []AttrBlock) (map[uint64]map[string]interface{}, error)
 	SendMessage(ctx context.Context, uri *URI, pb proto.Message) error
 }
diff --git a/client_test.go b/client_test.go
index 1edd37bc2..d2e194805 100644
--- a/client_test.go
+++ b/client_test.go
@@ -145,7 +145,7 @@ func TestClient_MultiNode(t *testing.T) {
 
 	topN := 4
 	queryRequest := &internal.QueryRequest{
-		Query:  fmt.Sprintf(`TopN(frame="%s", n=%d)`, "f", topN),
+		Query:  fmt.Sprintf(`TopN(field="%s", n=%d)`, "f", topN),
 		Remote: false,
 	}
 	result, err := client[0].Query(context.Background(), "i", queryRequest)
@@ -246,15 +246,15 @@ func TestClient_ImportValue(t *testing.T) {
 
 	fldName := "f"
 
-	fo := pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	fo := pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  -100,
 		Max:  100,
 	}
 
 	// Load bitmap into cache to ensure cache gets updated.
 	index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	frame, err := index.CreateFrameIfNotExists(fldName, fo)
+	field, err := index.CreateFieldIfNotExists(fldName, fo)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -276,7 +276,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Sum.
-	sum, cnt, err := frame.Sum(nil, fldName)
+	sum, cnt, err := field.Sum(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -285,7 +285,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Min.
-	min, cnt, err := frame.Min(nil, fldName)
+	min, cnt, err := field.Min(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -294,11 +294,11 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Min with Filter.
-	filter, err := frame.Range(fldName, pql.GT, 40)
+	filter, err := field.Range(fldName, pql.GT, 40)
 	if err != nil {
 		t.Fatal(err)
 	}
-	min, cnt, err = frame.Min(filter, fldName)
+	min, cnt, err = field.Min(filter, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -307,7 +307,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Max.
-	max, cnt, err := frame.Max(nil, fldName)
+	max, cnt, err := field.Max(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/cluster.go b/cluster.go
index 63f4f62b8..9723e5bce 100644
--- a/cluster.go
+++ b/cluster.go
@@ -584,7 +584,7 @@ func (c *Cluster) removeNodeBasicSorted(node *Node) bool {
 
 // frag is a struct of basic fragment information.
 type frag struct {
-	frame string
+	field string
 	view  string
 	slice uint64
 }
@@ -617,36 +617,36 @@ func (a fragsByHost) add(b fragsByHost) fragsByHost {
 	return a
 }
 
-type viewsByFrame map[string][]string
+type viewsByField map[string][]string
 
-func (a viewsByFrame) addView(frame, view string) {
-	a[frame] = append(a[frame], view)
+func (a viewsByField) addView(field, view string) {
+	a[field] = append(a[field], view)
 }
 
 func (c *Cluster) fragsByHost(idx *Index) fragsByHost {
-	// frameViews is a map of frame to slice of views.
-	frameViews := make(viewsByFrame)
+	// fieldViews is a map of field to slice of views.
+	fieldViews := make(viewsByField)
 
-	for _, frame := range idx.Frames() {
-		for _, view := range frame.Views() {
-			frameViews.addView(frame.Name(), view.Name())
+	for _, field := range idx.Fields() {
+		for _, view := range field.Views() {
+			fieldViews.addView(field.Name(), view.Name())
 
 		}
 	}
-	return c.fragCombos(idx.Name(), idx.MaxSlice(), frameViews)
+	return c.fragCombos(idx.Name(), idx.MaxSlice(), fieldViews)
 }
 
 // fragCombos returns a map (by uri) of lists of fragments for a given index
-// by creating every combination of frame/view specified in `frameViews` up to maxSlice.
-func (c *Cluster) fragCombos(idx string, maxSlice uint64, frameViews viewsByFrame) fragsByHost {
+// by creating every combination of field/view specified in `fieldViews` up to maxSlice.
+func (c *Cluster) fragCombos(idx string, maxSlice uint64, fieldViews viewsByField) fragsByHost {
 	t := make(fragsByHost)
 	for i := uint64(0); i <= maxSlice; i++ {
 		nodes := c.SliceNodes(idx, i)
 		for _, n := range nodes {
-			// for each frame/view combination:
-			for frame, views := range frameViews {
+			// for each field/view combination:
+			for field, views := range fieldViews {
 				for _, view := range views {
-					t[n.ID] = append(t[n.ID], frag{frame, view, i})
+					t[n.ID] = append(t[n.ID], frag{field, view, i})
 				}
 			}
 		}
@@ -770,7 +770,7 @@ func (c *Cluster) fragSources(to *Cluster, idx *Index) (map[string][]*internal.R
 			src := &internal.ResizeSource{
 				Node:  EncodeNode(c.nodeByID(srcNodeID)),
 				Index: idx.Name(),
-				Frame: frag.frame,
+				Field: frag.field,
 				View:  frag.view,
 				Slice: frag.slice,
 			}
@@ -1239,10 +1239,10 @@ func (c *Cluster) FollowResizeInstruction(instr *internal.ResizeInstruction) err
 
 				srcURI := decodeURI(src.Node.URI)
 
-				// Retrieve frame.
-				f := c.Holder.Frame(src.Index, src.Frame)
+				// Retrieve field.
+				f := c.Holder.Field(src.Index, src.Field)
 				if f == nil {
-					return ErrFrameNotFound
+					return ErrFieldNotFound
 				}
 
 				// Create view.
@@ -1259,7 +1259,7 @@ func (c *Cluster) FollowResizeInstruction(instr *internal.ResizeInstruction) err
 
 				// Stream slice from remote node.
 				c.Logger.Printf("retrieve slice %d for index %s from host %s", src.Slice, src.Index, src.Node.URI)
-				rd, err := client.RetrieveSliceFromURI(context.Background(), src.Index, src.Frame, src.Slice, srcURI)
+				rd, err := client.RetrieveSliceFromURI(context.Background(), src.Index, src.Field, src.Slice, srcURI)
 				if err != nil {
 					// For now it is an acceptable error if the fragment is not found
 					// on the remote node. This occurs when a slice has been skipped and
@@ -1275,7 +1275,7 @@ func (c *Cluster) FollowResizeInstruction(instr *internal.ResizeInstruction) err
 					return fmt.Errorf("slice %v doesn't exist on host: %s", src.Slice, src.Node.URI)
 				}
 
-				// Write to local frame and always close reader.
+				// Write to local field and always close reader.
 				if err := func() error {
 					defer rd.Close()
 					_, err := frag.ReadFrom(rd)
diff --git a/cluster_internal_test.go b/cluster_internal_test.go
index 6b1f6e72b..f97775b96 100644
--- a/cluster_internal_test.go
+++ b/cluster_internal_test.go
@@ -45,13 +45,13 @@ func TestFragCombos(t *testing.T) {
 	tests := []struct {
 		idx        string
 		maxSlice   uint64
-		frameViews viewsByFrame
+		fieldViews viewsByField
 		expected   fragsByHost
 	}{
 		{
 			idx:        "i",
 			maxSlice:   uint64(2),
-			frameViews: viewsByFrame{"f": []string{"v1", "v2"}},
+			fieldViews: viewsByField{"f": []string{"v1", "v2"}},
 			expected: fragsByHost{
 				"node0": []frag{{"f", "v1", uint64(0)}, {"f", "v2", uint64(0)}},
 				"node1": []frag{{"f", "v1", uint64(1)}, {"f", "v2", uint64(1)}, {"f", "v1", uint64(2)}, {"f", "v2", uint64(2)}},
@@ -60,7 +60,7 @@ func TestFragCombos(t *testing.T) {
 		{
 			idx:        "foo",
 			maxSlice:   uint64(3),
-			frameViews: viewsByFrame{"f": []string{"v0"}},
+			fieldViews: viewsByField{"f": []string{"v0"}},
 			expected: fragsByHost{
 				"node0": []frag{{"f", "v0", uint64(1)}, {"f", "v0", uint64(2)}},
 				"node1": []frag{{"f", "v0", uint64(0)}, {"f", "v0", uint64(3)}},
@@ -69,7 +69,7 @@ func TestFragCombos(t *testing.T) {
 	}
 	for _, test := range tests {
 
-		actual := c.fragCombos(test.idx, test.maxSlice, test.frameViews)
+		actual := c.fragCombos(test.idx, test.maxSlice, test.fieldViews)
 		if !reflect.DeepEqual(actual, test.expected) {
 			t.Errorf("expected: %v, but got: %v", test.expected, actual)
 		}
@@ -145,23 +145,23 @@ func TestFragSources(t *testing.T) {
 	c5.addNodeBasicSorted(node3)
 
 	idx := newIndexWithTempPath("i")
-	frame, err := idx.CreateFrameIfNotExists("f", FrameOptions{})
+	field, err := idx.CreateFieldIfNotExists("f", FieldOptions{})
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = frame.SetBit("standard", 1, 101, nil)
+	_, err = field.SetBit("standard", 1, 101, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = frame.SetBit("standard", 1, 1300000, nil)
+	_, err = field.SetBit("standard", 1, 1300000, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = frame.SetBit("standard", 1, 2600000, nil)
+	_, err = field.SetBit("standard", 1, 2600000, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = frame.SetBit("standard", 1, 3900000, nil)
+	_, err = field.SetBit("standard", 1, 3900000, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/cluster_test.go b/cluster_test.go
index 99b322a0e..a977b3536 100644
--- a/cluster_test.go
+++ b/cluster_test.go
@@ -416,7 +416,7 @@ func TestCluster_ResizeStates(t *testing.T) {
 		}
 
 		// Add Bit Data to node0.
-		if err := tc.CreateFrame("i", "f", FrameOptions{}); err != nil {
+		if err := tc.CreateField("i", "f", FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 		tc.SetBit("i", "f", "standard", 1, 101, nil)
@@ -424,8 +424,8 @@ func TestCluster_ResizeStates(t *testing.T) {
 
 		// Before starting the resize, get the CheckSum to use for
 		// comparison later.
-		node0Frame := node0.Holder.Frame("i", "f")
-		node0View := node0Frame.View("standard")
+		node0Field := node0.Holder.Field("i", "f")
+		node0View := node0Field.View("standard")
 		node0Fragment := node0View.Fragment(1)
 		node0Checksum := node0Fragment.Checksum()
 
@@ -453,8 +453,8 @@ func TestCluster_ResizeStates(t *testing.T) {
 
 		// Bits
 		// Verify that node-1 contains the fragment (i/f/standard/1) transferred from node-0.
-		node1Frame := node1.Holder.Frame("i", "f")
-		node1View := node1Frame.View("standard")
+		node1Field := node1.Holder.Field("i", "f")
+		node1View := node1Field.View("standard")
 		node1Fragment := node1View.Fragment(1)
 
 		// Ensure checksums are the same.
diff --git a/cmd/export.go b/cmd/export.go
index 951c4a0a9..9613d9544 100644
--- a/cmd/export.go
+++ b/cmd/export.go
@@ -52,7 +52,7 @@ The file does not contain any headers.
 
 	flags.StringVarP(&Exporter.Host, "host", "", "localhost:10101", "host:port of Pilosa.")
 	flags.StringVarP(&Exporter.Index, "index", "i", "", "Pilosa index to export")
-	flags.StringVarP(&Exporter.Frame, "frame", "f", "", "Frame to export")
+	flags.StringVarP(&Exporter.Field, "field", "f", "", "Field to export")
 	flags.StringVarP(&Exporter.Path, "output-file", "o", "", "File to write export to - default stdout")
 	ctl.SetTLSConfig(flags, &Exporter.TLS.CertificatePath, &Exporter.TLS.CertificateKeyPath, &Exporter.TLS.SkipVerify)
 
diff --git a/cmd/export_test.go b/cmd/export_test.go
index 2b30116c6..6f7a49b8f 100644
--- a/cmd/export_test.go
+++ b/cmd/export_test.go
@@ -37,13 +37,13 @@ func TestExportConfig(t *testing.T) {
 			env:  map[string]string{"PILOSA_HOST": "localhost:12345"},
 			cfgFileContent: `
 index = "myindex"
-frame = "f1"
+field = "f1"
 `,
 			validation: func() error {
 				v := validator{}
 				v.Check(cmd.Exporter.Host, "localhost:12345")
 				v.Check(cmd.Exporter.Index, "myindex")
-				v.Check(cmd.Exporter.Frame, "f1")
+				v.Check(cmd.Exporter.Field, "f1")
 				v.Check(cmd.Exporter.Path, "/somefile")
 				return v.Error()
 			},
diff --git a/cmd/import.go b/cmd/import.go
index ea489f59d..db5cebf8d 100644
--- a/cmd/import.go
+++ b/cmd/import.go
@@ -32,7 +32,7 @@ func NewImportCommand(stdin io.Reader, stdout, stderr io.Writer) *cobra.Command
 	importCmd := &cobra.Command{
 		Use:   "import",
 		Short: "Bulk load data into pilosa.",
-		Long: `Bulk imports one or more CSV files to a host's index and frame. The data
+		Long: `Bulk imports one or more CSV files to a host's index and field. The data
 of the CSV file are grouped by slice for the most efficient import.
 
 The format of the CSV file is:
@@ -54,14 +54,14 @@ omitted. If it is present then its format should be YYYY-MM-DDTHH:MM.
 	flags := importCmd.Flags()
 	flags.StringVarP(&Importer.Host, "host", "", "localhost:10101", "host:port of Pilosa.")
 	flags.StringVarP(&Importer.Index, "index", "i", "", "Pilosa index to import into.")
-	flags.StringVarP(&Importer.Frame, "frame", "f", "", "Frame to import into.")
+	flags.StringVarP(&Importer.Field, "field", "f", "", "Field to import into.")
 	flags.BoolVar(&Importer.StringKeys, "string-keys", false, "Treat payload as string keys.")
 	flags.IntVarP(&Importer.BufferSize, "buffer-size", "s", 10000000, "Number of bits to buffer/sort before importing.")
 	flags.BoolVarP(&Importer.Sort, "sort", "", false, "Enables sorting before import.")
 	flags.BoolVarP(&Importer.CreateSchema, "create", "e", false, "Create the schema if it does not exist before import.")
-	flags.Var(&Importer.FrameOptions.TimeQuantum, "frame-time-quantum", "Time quantum for the frame")
-	flags.StringVar(&Importer.FrameOptions.CacheType, "frame-cache-type", pilosa.CacheTypeRanked, "Cache type for the frame; valid values: none, lru, ranked")
-	flags.Uint32Var(&Importer.FrameOptions.CacheSize, "frame-cache-size", 50000, "Cache size for the frame")
+	flags.Var(&Importer.FieldOptions.TimeQuantum, "field-time-quantum", "Time quantum for the field")
+	flags.StringVar(&Importer.FieldOptions.CacheType, "field-cache-type", pilosa.CacheTypeRanked, "Cache type for the field; valid values: none, lru, ranked")
+	flags.Uint32Var(&Importer.FieldOptions.CacheSize, "field-cache-size", 50000, "Cache size for the field")
 	ctl.SetTLSConfig(flags, &Importer.TLS.CertificatePath, &Importer.TLS.CertificateKeyPath, &Importer.TLS.SkipVerify)
 
 	return importCmd
diff --git a/cmd/import_test.go b/cmd/import_test.go
index 8117d46fa..e8e5d61f4 100644
--- a/cmd/import_test.go
+++ b/cmd/import_test.go
@@ -37,13 +37,13 @@ func TestImportConfig(t *testing.T) {
 			env:  map[string]string{"PILOSA_HOST": "localhost:12345"},
 			cfgFileContent: `
 index = "myindex"
-frame = "f1"
+field = "f1"
 `,
 			validation: func() error {
 				v := validator{}
 				v.Check(cmd.Importer.Host, "localhost:12345")
 				v.Check(cmd.Importer.Index, "myindex")
-				v.Check(cmd.Importer.Frame, "f1")
+				v.Check(cmd.Importer.Field, "f1")
 				return v.Error()
 			},
 		},
diff --git a/ctl/export.go b/ctl/export.go
index 5ee8d2120..090904807 100644
--- a/ctl/export.go
+++ b/ctl/export.go
@@ -30,9 +30,9 @@ type ExportCommand struct {
 	// Remote host and port.
 	Host string
 
-	// Name of the index & frame to export from.
+	// Name of the index & field to export from.
 	Index string
-	Frame string
+	Field string
 
 	// Filename to export to.
 	Path string
@@ -57,8 +57,8 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	// Validate arguments.
 	if cmd.Index == "" {
 		return pilosa.ErrIndexRequired
-	} else if cmd.Frame == "" {
-		return pilosa.ErrFrameRequired
+	} else if cmd.Field == "" {
+		return pilosa.ErrFieldRequired
 	}
 
 	// Use output file, if specified.
@@ -89,7 +89,7 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	// Export each slice.
 	for slice := uint64(0); slice <= maxSlices[cmd.Index]; slice++ {
 		logger.Printf("exporting slice: %d", slice)
-		if err := client.ExportCSV(ctx, cmd.Index, cmd.Frame, slice, w); err != nil {
+		if err := client.ExportCSV(ctx, cmd.Index, cmd.Field, slice, w); err != nil {
 			return errors.Wrap(err, "exporting")
 		}
 	}
diff --git a/ctl/export_test.go b/ctl/export_test.go
index 469ca7d75..5e87334d9 100644
--- a/ctl/export_test.go
+++ b/ctl/export_test.go
@@ -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)
 	}
 }
 
@@ -59,10 +59,10 @@ func TestExportCommand_Run(t *testing.T) {
 	cm.Host = s.Host()
 
 	http.DefaultClient.Do(test.MustNewHTTPRequest("POST", s.URL+"/index/i", strings.NewReader("")))
-	http.DefaultClient.Do(test.MustNewHTTPRequest("POST", s.URL+"/index/i/frame/f", strings.NewReader("")))
+	http.DefaultClient.Do(test.MustNewHTTPRequest("POST", s.URL+"/index/i/field/f", strings.NewReader("")))
 
 	cm.Index = "i"
-	cm.Frame = "f"
+	cm.Field = "f"
 	if err := cm.Run(context.Background()); err != nil {
 		t.Fatalf("Export Run doesn't work: %s", err)
 	}
diff --git a/ctl/import.go b/ctl/import.go
index 45bf81d42..9383c300f 100644
--- a/ctl/import.go
+++ b/ctl/import.go
@@ -35,13 +35,13 @@ type ImportCommand struct {
 	// Destination host and port.
 	Host string `json:"host"`
 
-	// Name of the index & frame to import into.
+	// Name of the index & field to import into.
 	Index string `json:"index"`
-	Frame string `json:"frame"`
+	Field string `json:"field"`
 
-	// Options for index & frame to be created if they don't exist
+	// Options for index & field to be created if they don't exist
 	IndexOptions pilosa.IndexOptions
-	FrameOptions pilosa.FrameOptions
+	FieldOptions pilosa.FieldOptions
 
 	// CreateSchema ensures the schema exists before import
 	CreateSchema bool
@@ -80,11 +80,11 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 	logger := log.New(cmd.Stderr, "", log.LstdFlags)
 
 	// Validate arguments.
-	// Index and frame are validated early before the files are parsed.
+	// Index and field are validated early before the files are parsed.
 	if cmd.Index == "" {
 		return pilosa.ErrIndexRequired
-	} else if cmd.Frame == "" {
-		return pilosa.ErrFrameRequired
+	} else if cmd.Field == "" {
+		return pilosa.ErrFieldRequired
 	} else if len(cmd.Paths) == 0 {
 		return errors.New("path required")
 	}
@@ -102,17 +102,17 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 		}
 	}
 
-	// Determine the frame type in order to correctly handle the input data.
-	frameType := pilosa.DefaultFrameType
+	// Determine the field type in order to correctly handle the input data.
+	fieldType := pilosa.DefaultFieldType
 	schema, err := cmd.Client.Schema(ctx)
 	if err != nil {
 		return errors.Wrap(err, "getting schema")
 	}
 	for _, index := range schema {
 		if index.Name == cmd.Index {
-			for _, frame := range index.Frames {
-				if frame.Name == cmd.Frame {
-					frameType = frame.Options.Type
+			for _, field := range index.Fields {
+				if field.Name == cmd.Field {
+					fieldType = field.Options.Type
 				}
 			}
 		}
@@ -121,7 +121,7 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 	// Import each path and import by slice.
 	for _, path := range cmd.Paths {
 		logger.Printf("parsing: %s", path)
-		if err := cmd.importPath(ctx, frameType, path); err != nil {
+		if err := cmd.importPath(ctx, fieldType, path); err != nil {
 			return err
 		}
 	}
@@ -134,17 +134,17 @@ func (cmd *ImportCommand) ensureSchema(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("Error Creating Index: %s", err)
 	}
-	err = cmd.Client.EnsureFrame(ctx, cmd.Index, cmd.Frame, cmd.FrameOptions)
+	err = cmd.Client.EnsureField(ctx, cmd.Index, cmd.Field, cmd.FieldOptions)
 	if err != nil {
-		return fmt.Errorf("Error Creating Frame: %s", err)
+		return fmt.Errorf("Error Creating Field: %s", err)
 	}
 	return nil
 }
 
 // importPath parses a path into bits and imports it to the server.
-func (cmd *ImportCommand) importPath(ctx context.Context, frameType, path string) error {
-	// If frameType is `int`, treat the import data as values to be range-encoded.
-	if frameType == pilosa.FrameTypeInt {
+func (cmd *ImportCommand) importPath(ctx context.Context, fieldType, path string) error {
+	// If fieldType is `int`, treat the import data as values to be range-encoded.
+	if fieldType == pilosa.FieldTypeInt {
 		return cmd.bufferValues(ctx, path)
 	} else {
 		if cmd.StringKeys {
@@ -254,7 +254,7 @@ func (cmd *ImportCommand) importBits(ctx context.Context, bits []pilosa.Bit) err
 		}
 
 		logger.Printf("importing slice: %d, n=%d", slice, len(chunk))
-		if err := cmd.Client.Import(ctx, cmd.Index, cmd.Frame, slice, chunk); err != nil {
+		if err := cmd.Client.Import(ctx, cmd.Index, cmd.Field, slice, chunk); err != nil {
 			return errors.Wrap(err, "importing")
 		}
 	}
@@ -351,7 +351,7 @@ func (cmd *ImportCommand) importBitsK(ctx context.Context, bits []pilosa.Bit) er
 	// TODO: does it help to sort the rowKeys?
 
 	logger.Printf("importing keys: n=%d", len(bits))
-	if err := cmd.Client.ImportK(ctx, cmd.Index, cmd.Frame, bits); err != nil {
+	if err := cmd.Client.ImportK(ctx, cmd.Index, cmd.Field, bits); err != nil {
 		return errors.Wrap(err, "importing keys")
 	}
 
@@ -448,7 +448,7 @@ func (cmd *ImportCommand) importValues(ctx context.Context, vals []pilosa.FieldV
 		}
 
 		logger.Printf("importing slice: %d, n=%d", slice, len(vals))
-		if err := cmd.Client.ImportValue(ctx, cmd.Index, cmd.Frame, slice, vals); err != nil {
+		if err := cmd.Client.ImportValue(ctx, cmd.Index, cmd.Field, slice, vals); err != nil {
 			return errors.Wrap(err, "importing values")
 		}
 	}
diff --git a/ctl/import_test.go b/ctl/import_test.go
index 7c64944f6..ba8a9dc6e 100644
--- a/ctl/import_test.go
+++ b/ctl/import_test.go
@@ -39,11 +39,11 @@ 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"
+	cm.Field = "f"
 	err = cm.Run(context.Background())
 	if err.Error() != "path required" {
 		t.Fatalf("Command not working, expect: %s, actual: '%s'", "path required", err)
@@ -73,7 +73,7 @@ func TestImportCommand_Run(t *testing.T) {
 	cm.Host = s.Host()
 
 	cm.Index = "i"
-	cm.Frame = "f"
+	cm.Field = "f"
 	cm.CreateSchema = true
 	cm.Paths = []string{file.Name()}
 	err = cm.Run(ctx)
@@ -106,10 +106,10 @@ func TestImportCommand_RunValue(t *testing.T) {
 	cm.Host = s.Host()
 
 	http.DefaultClient.Do(MustNewHTTPRequest("POST", s.URL+"/index/i", strings.NewReader("")))
-	http.DefaultClient.Do(MustNewHTTPRequest("POST", s.URL+"/index/i/frame/f", strings.NewReader(`{"options":{"type": "int", "min": 0, "max": 100}}`)))
+	http.DefaultClient.Do(MustNewHTTPRequest("POST", s.URL+"/index/i/field/f", strings.NewReader(`{"options":{"type": "int", "min": 0, "max": 100}}`)))
 
 	cm.Index = "i"
-	cm.Frame = "f"
+	cm.Field = "f"
 	cm.Paths = []string{file.Name()}
 	err = cm.Run(ctx)
 	if err != nil {
@@ -133,7 +133,7 @@ func TestImportCommand_InvalidFile(t *testing.T) {
 	cm := NewImportCommand(stdin, stdout, stderr)
 	cm.Host = s.Host()
 	cm.Index = "i"
-	cm.Frame = "f"
+	cm.Field = "f"
 	file, err := ioutil.TempFile("", "import.csv")
 	file.Write([]byte("a,2\n3,5\n5,6"))
 	if err != nil {
diff --git a/diagnostics.go b/diagnostics.go
index 1968a4e74..e4067c6e3 100644
--- a/diagnostics.go
+++ b/diagnostics.go
@@ -217,7 +217,7 @@ func (d *DiagnosticsCollector) EnrichWithMemoryInfo() {
 // EnrichWithSchemaProperties adds schema info to the diagnostics payload.
 func (d *DiagnosticsCollector) EnrichWithSchemaProperties() {
 	var numSlices uint64
-	numFrames := 0
+	numFields := 0
 	numIndexes := 0
 	bsiFieldCount := 0
 	timeQuantumEnabled := false
@@ -225,19 +225,19 @@ func (d *DiagnosticsCollector) EnrichWithSchemaProperties() {
 	for _, index := range d.server.Holder.Indexes() {
 		numSlices += index.MaxSlice() + 1
 		numIndexes += 1
-		for _, frame := range index.Frames() {
-			numFrames += 1
-			if frame.Type() == FrameTypeInt {
+		for _, field := range index.Fields() {
+			numFields += 1
+			if field.Type() == FieldTypeInt {
 				bsiFieldCount += 1
 			}
-			if frame.TimeQuantum() != "" {
+			if field.TimeQuantum() != "" {
 				timeQuantumEnabled = true
 			}
 		}
 	}
 
 	d.Set("NumIndexes", numIndexes)
-	d.Set("NumFrames", numFrames)
+	d.Set("NumFields", numFields)
 	d.Set("NumSlices", numSlices)
 	d.Set("BSIFieldCount", bsiFieldCount)
 	d.Set("TimeQuantumEnabled", timeQuantumEnabled)
diff --git a/executor.go b/executor.go
index eee4fa0ee..411039d40 100644
--- a/executor.go
+++ b/executor.go
@@ -26,9 +26,9 @@ import (
 	"github.com/pkg/errors"
 )
 
-// DefaultFrame is the frame used if one is not specified.
+// DefaultField is the field used if one is not specified.
 const (
-	DefaultFrame = "general"
+	DefaultField = "general"
 
 	// MinThreshold is the lowest count to use in a Top-N operation when
 	// looking for additional id/count pairs.
@@ -174,8 +174,8 @@ func (e *Executor) validateCallArgs(c *pql.Call) error {
 
 // executeSum executes a Sum() call.
 func (e *Executor) executeSum(ctx context.Context, index string, c *pql.Call, slices []uint64, opt *ExecOptions) (ValCount, error) {
-	if frame := c.Args["frame"]; frame == "" {
-		return ValCount{}, errors.New("Sum(): frame required")
+	if field := c.Args["field"]; field == "" {
+		return ValCount{}, errors.New("Sum(): field required")
 	}
 
 	if len(c.Children) > 1 {
@@ -207,8 +207,8 @@ func (e *Executor) executeSum(ctx context.Context, index string, c *pql.Call, sl
 
 // executeMin executes a Min() call.
 func (e *Executor) executeMin(ctx context.Context, index string, c *pql.Call, slices []uint64, opt *ExecOptions) (ValCount, error) {
-	if frame := c.Args["frame"]; frame == "" {
-		return ValCount{}, errors.New("Min(): frame required")
+	if field := c.Args["field"]; field == "" {
+		return ValCount{}, errors.New("Min(): field required")
 	}
 
 	if len(c.Children) > 1 {
@@ -240,8 +240,8 @@ func (e *Executor) executeMin(ctx context.Context, index string, c *pql.Call, sl
 
 // executeMax executes a Max() call.
 func (e *Executor) executeMax(ctx context.Context, index string, c *pql.Call, slices []uint64, opt *ExecOptions) (ValCount, error) {
-	if frame := c.Args["frame"]; frame == "" {
-		return ValCount{}, errors.New("Max(): frame required")
+	if field := c.Args["field"]; field == "" {
+		return ValCount{}, errors.New("Max(): field required")
 	}
 
 	if len(c.Children) > 1 {
@@ -312,8 +312,8 @@ func (e *Executor) executeBitmapCall(ctx context.Context, index string, c *pql.C
 				} else if err != nil {
 					return nil, err
 				} else {
-					frame, _ := c.Args["frame"].(string)
-					if fr := idx.Frame(frame); fr != nil {
+					field, _ := c.Args["field"].(string)
+					if fr := idx.Field(field); fr != nil {
 						rowID, _, err := c.UintArg(rowLabel)
 						if err != nil {
 							return nil, errors.Wrap(err, "getting row")
@@ -367,19 +367,19 @@ func (e *Executor) executeSumCountSlice(ctx context.Context, index string, c *pq
 		filter = row
 	}
 
-	frameName, _ := c.Args["frame"].(string)
+	fieldName, _ := c.Args["field"].(string)
 
-	frame := e.Holder.Frame(index, frameName)
-	if frame == nil {
+	field := e.Holder.Field(index, fieldName)
+	if field == nil {
 		return ValCount{}, nil
 	}
 
-	bsig := frame.bsiGroup(frameName)
+	bsig := field.bsiGroup(fieldName)
 	if bsig == nil {
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+	fragment := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -405,19 +405,19 @@ func (e *Executor) executeMinSlice(ctx context.Context, index string, c *pql.Cal
 		filter = row
 	}
 
-	frameName, _ := c.Args["frame"].(string)
+	fieldName, _ := c.Args["field"].(string)
 
-	frame := e.Holder.Frame(index, frameName)
-	if frame == nil {
+	field := e.Holder.Field(index, fieldName)
+	if field == nil {
 		return ValCount{}, nil
 	}
 
-	bsig := frame.bsiGroup(frameName)
+	bsig := field.bsiGroup(fieldName)
 	if bsig == nil {
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+	fragment := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -443,19 +443,19 @@ func (e *Executor) executeMaxSlice(ctx context.Context, index string, c *pql.Cal
 		filter = row
 	}
 
-	frameName, _ := c.Args["frame"].(string)
+	fieldName, _ := c.Args["field"].(string)
 
-	frame := e.Holder.Frame(index, frameName)
-	if frame == nil {
+	field := e.Holder.Field(index, fieldName)
+	if field == nil {
 		return ValCount{}, nil
 	}
 
-	bsig := frame.bsiGroup(frameName)
+	bsig := field.bsiGroup(fieldName)
 	if bsig == nil {
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+	fragment := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -538,7 +538,7 @@ func (e *Executor) executeTopNSlices(ctx context.Context, index string, c *pql.C
 
 // executeTopNSlice executes a TopN call for a single slice.
 func (e *Executor) executeTopNSlice(ctx context.Context, index string, c *pql.Call, slice uint64) ([]Pair, error) {
-	frame, _ := c.Args["frame"].(string)
+	field, _ := c.Args["field"].(string)
 	n, _, err := c.UintArg("n")
 	if err != nil {
 		return nil, fmt.Errorf("executeTopNSlice: %v", err)
@@ -570,12 +570,12 @@ func (e *Executor) executeTopNSlice(ctx context.Context, index string, c *pql.Ca
 		return nil, errors.New("TopN() can only have one input bitmap")
 	}
 
-	// Set default frame.
-	if frame == "" {
-		frame = DefaultFrame
+	// Set default field.
+	if field == "" {
+		field = DefaultField
 	}
 
-	f := e.Holder.Fragment(index, frame, ViewStandard, slice)
+	f := e.Holder.Fragment(index, field, ViewStandard, slice)
 	if f == nil {
 		return nil, nil
 	}
@@ -627,14 +627,14 @@ func (e *Executor) executeBitmapSlice(ctx context.Context, index string, c *pql.
 		return nil, ErrIndexNotFound
 	}
 
-	// Fetch frame & row label based on argument.
-	frame, _ := c.Args["frame"].(string)
-	if frame == "" {
-		frame = DefaultFrame
+	// Fetch field & row label based on argument.
+	field, _ := c.Args["field"].(string)
+	if field == "" {
+		field = DefaultField
 	}
-	f := e.Holder.Frame(index, frame)
+	f := e.Holder.Field(index, field)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	rowID, rowOK, rowErr := c.UintArg(rowLabel)
@@ -645,7 +645,7 @@ func (e *Executor) executeBitmapSlice(ctx context.Context, index string, c *pql.
 		return nil, fmt.Errorf("Bitmap() must specify %v", rowLabel)
 	}
 
-	frag := e.Holder.Fragment(index, frame, ViewStandard, slice)
+	frag := e.Holder.Fragment(index, field, ViewStandard, slice)
 	if frag == nil {
 		return NewRow(), nil
 	}
@@ -681,10 +681,10 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 		return e.executeBSIGroupRangeSlice(ctx, index, c, slice)
 	}
 
-	// Parse frame, use default if unset.
-	frame, _ := c.Args["frame"].(string)
-	if frame == "" {
-		frame = DefaultFrame
+	// Parse field, use default if unset.
+	field, _ := c.Args["field"].(string)
+	if field == "" {
+		field = DefaultField
 	}
 
 	// Retrieve column label.
@@ -693,10 +693,10 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 		return nil, ErrIndexNotFound
 	}
 
-	// Retrieve base frame.
-	f := idx.Frame(frame)
+	// Retrieve base field.
+	f := idx.Field(field)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Read row & column id.
@@ -734,10 +734,10 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 		return &Row{}, nil
 	}
 
-	// Union bitmaps across all time-based subframes.
+	// Union bitmaps across all time-based views.
 	row := &Row{}
 	for _, view := range ViewsByTimeRange(ViewStandard, startTime, endTime, q) {
-		f := e.Holder.Fragment(index, frame, view, slice)
+		f := e.Holder.Fragment(index, field, view, slice)
 		if f == nil {
 			continue
 		}
@@ -757,19 +757,19 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 	}
 
 	// Extract conditional.
-	var frameName string
+	var fieldName string
 	var cond *pql.Condition
 	for k, v := range c.Args {
 		vv, ok := v.(*pql.Condition)
 		if !ok {
 			return nil, fmt.Errorf("Range(): %q: expected condition argument, got %v", k, v)
 		}
-		frameName, cond = k, vv
+		fieldName, cond = k, vv
 	}
 
-	f := e.Holder.Frame(index, frameName)
+	f := e.Holder.Field(index, fieldName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// EQ null           (not implemented: flip frag.NotNull with max ColumnID)
@@ -782,13 +782,13 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 	// Handle `!= null`.
 	if cond.Op == pql.NEQ && cond.Value == nil {
 		// Find bsiGroup.
-		bsig := f.bsiGroup(frameName)
+		bsig := f.bsiGroup(fieldName)
 		if bsig == nil {
 			return nil, ErrBSIGroupNotFound
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+		frag := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -808,11 +808,11 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 		}
 
 		// The reason we don't just call:
-		//     return f.RangeBetween(frameName, predicates[0], predicates[1])
+		//     return f.RangeBetween(fieldName, predicates[0], predicates[1])
 		// here is because we need the call to be slice-specific.
 
 		// Find bsiGroup.
-		bsig := f.bsiGroup(frameName)
+		bsig := f.bsiGroup(fieldName)
 		if bsig == nil {
 			return nil, ErrBSIGroupNotFound
 		}
@@ -823,7 +823,7 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+		frag := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -845,7 +845,7 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 		}
 
 		// Find bsiGroup.
-		bsig := f.bsiGroup(frameName)
+		bsig := f.bsiGroup(fieldName)
 		if bsig == nil {
 			return nil, ErrBSIGroupNotFound
 		}
@@ -856,7 +856,7 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+frameName, slice)
+		frag := e.Holder.Fragment(index, fieldName, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -949,19 +949,19 @@ func (e *Executor) executeCount(ctx context.Context, index string, c *pql.Call,
 
 // executeClearBit executes a ClearBit() call.
 func (e *Executor) executeClearBit(ctx context.Context, index string, c *pql.Call, opt *ExecOptions) (bool, error) {
-	frame, ok := c.Args["frame"].(string)
+	field, ok := c.Args["field"].(string)
 	if !ok {
-		return false, errors.New("ClearBit() frame required")
+		return false, errors.New("ClearBit() field required")
 	}
 
-	// Retrieve frame.
+	// Retrieve field.
 	idx := e.Holder.Index(index)
 	if idx == nil {
 		return false, ErrIndexNotFound
 	}
-	f := idx.Frame(frame)
+	f := idx.Field(field)
 	if f == nil {
-		return false, ErrFrameNotFound
+		return false, ErrFieldNotFound
 	}
 
 	// Read fields using labels.
@@ -983,7 +983,7 @@ func (e *Executor) executeClearBit(ctx context.Context, index string, c *pql.Cal
 }
 
 // executeClearBitView executes a ClearBit() call for a single view.
-func (e *Executor) executeClearBitView(ctx context.Context, index string, c *pql.Call, f *Frame, view string, colID, rowID uint64, opt *ExecOptions) (bool, error) {
+func (e *Executor) executeClearBitView(ctx context.Context, index string, c *pql.Call, f *Field, view string, colID, rowID uint64, opt *ExecOptions) (bool, error) {
 	slice := colID / SliceWidth
 	ret := false
 	for _, node := range e.Cluster.SliceNodes(index, slice) {
@@ -1014,19 +1014,19 @@ func (e *Executor) executeClearBitView(ctx context.Context, index string, c *pql
 
 // executeSetBit executes a SetBit() call.
 func (e *Executor) executeSetBit(ctx context.Context, index string, c *pql.Call, opt *ExecOptions) (bool, error) {
-	frame, ok := c.Args["frame"].(string)
+	field, ok := c.Args["field"].(string)
 	if !ok {
-		return false, errors.New("SetBit() field required: frame")
+		return false, errors.New("SetBit() field required: field")
 	}
 
-	// Retrieve frame.
+	// Retrieve field.
 	idx := e.Holder.Index(index)
 	if idx == nil {
 		return false, ErrIndexNotFound
 	}
-	f := idx.Frame(frame)
+	f := idx.Field(field)
 	if f == nil {
-		return false, ErrFrameNotFound
+		return false, ErrFieldNotFound
 	}
 
 	// Read fields using labels.
@@ -1058,7 +1058,7 @@ func (e *Executor) executeSetBit(ctx context.Context, index string, c *pql.Call,
 }
 
 // executeSetBitView executes a SetBit() call for a specific view.
-func (e *Executor) executeSetBitView(ctx context.Context, index string, c *pql.Call, f *Frame, view string, colID, rowID uint64, timestamp *time.Time, opt *ExecOptions) (bool, error) {
+func (e *Executor) executeSetBitView(ctx context.Context, index string, c *pql.Call, f *Field, view string, colID, rowID uint64, timestamp *time.Time, opt *ExecOptions) (bool, error) {
 	slice := colID / SliceWidth
 	ret := false
 
@@ -1101,27 +1101,27 @@ func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Cal
 
 	// Copy args and remove reserved fields.
 	args := pql.CopyArgs(c.Args)
-	// While frame could technically work as a ColumnAttr argument, we are treating it as a reserved word primarily to avoid confusion.
-	// Also, if we ever need to make ColumnAttrs frame-specific, then having this reserved word prevents backward incompatibility.
+	// While field could technically work as a ColumnAttr argument, we are treating it as a reserved word primarily to avoid confusion.
+	// Also, if we ever need to make ColumnAttrs field-specific, then having this reserved word prevents backward incompatibility.
 	delete(args, columnLabel)
 
 	// Set values.
 	for name, value := range args {
-		// Retrieve frame.
-		frame := e.Holder.Frame(index, name)
-		if frame == nil {
-			return ErrFrameNotFound
+		// Retrieve field.
+		field := e.Holder.Field(index, name)
+		if field == nil {
+			return ErrFieldNotFound
 		}
 
 		switch value := value.(type) {
 		case int64:
-			if _, err := frame.SetValue(columnID, value); err != nil {
+			if _, err := field.SetValue(columnID, value); err != nil {
 				return err
 			}
 		default:
 			return ErrInvalidBSIGroupValueType
 		}
-		frame.Stats.Count("SetValue", 1, 1.0)
+		field.Stats.Count("SetValue", 1, 1.0)
 	}
 
 	// Do not forward call if this is already being forwarded.
@@ -1151,15 +1151,15 @@ func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Cal
 
 // executeSetRowAttrs executes a SetRowAttrs() call.
 func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.Call, opt *ExecOptions) error {
-	frameName, ok := c.Args["frame"].(string)
+	fieldName, ok := c.Args["field"].(string)
 	if !ok {
-		return errors.New("SetRowAttrs() frame required")
+		return errors.New("SetRowAttrs() field required")
 	}
 
-	// Retrieve frame.
-	frame := e.Holder.Frame(index, frameName)
-	if frame == nil {
-		return ErrFrameNotFound
+	// Retrieve field.
+	field := e.Holder.Field(index, fieldName)
+	if field == nil {
+		return ErrFieldNotFound
 	}
 
 	// Parse labels.
@@ -1172,14 +1172,14 @@ func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
 
 	// Copy args and remove reserved fields.
 	attrs := pql.CopyArgs(c.Args)
-	delete(attrs, "frame")
+	delete(attrs, "field")
 	delete(attrs, rowLabel)
 
 	// Set attributes.
-	if err := frame.RowAttrStore().SetAttrs(rowID, attrs); err != nil {
+	if err := field.RowAttrStore().SetAttrs(rowID, attrs); err != nil {
 		return err
 	}
-	frame.Stats.Count("SetRowAttrs", 1, 1.0)
+	field.Stats.Count("SetRowAttrs", 1, 1.0)
 
 	// Do not forward call if this is already being forwarded.
 	if opt.Remote {
@@ -1208,18 +1208,18 @@ func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
 
 // executeBulkSetRowAttrs executes a set of SetRowAttrs() calls.
 func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, calls []*pql.Call, opt *ExecOptions) ([]interface{}, error) {
-	// Collect attributes by frame/id.
+	// Collect attributes by field/id.
 	m := make(map[string]map[uint64]map[string]interface{})
 	for _, c := range calls {
-		frame, ok := c.Args["frame"].(string)
+		field, ok := c.Args["field"].(string)
 		if !ok {
-			return nil, errors.New("SetRowAttrs() frame required")
+			return nil, errors.New("SetRowAttrs() field required")
 		}
 
-		// Retrieve frame.
-		f := e.Holder.Frame(index, frame)
+		// Retrieve field.
+		f := e.Holder.Field(index, field)
 		if f == nil {
-			return nil, ErrFrameNotFound
+			return nil, ErrFieldNotFound
 		}
 
 		rowID, ok, err := c.UintArg(rowLabel)
@@ -1231,20 +1231,20 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 
 		// Copy args and remove reserved fields.
 		attrs := pql.CopyArgs(c.Args)
-		delete(attrs, "frame")
+		delete(attrs, "field")
 		delete(attrs, rowLabel)
 
-		// Create frame group, if not exists.
-		frameMap := m[frame]
-		if frameMap == nil {
-			frameMap = make(map[uint64]map[string]interface{})
-			m[frame] = frameMap
+		// Create field group, if not exists.
+		fieldMap := m[field]
+		if fieldMap == nil {
+			fieldMap = make(map[uint64]map[string]interface{})
+			m[field] = fieldMap
 		}
 
 		// Set or merge attributes.
-		attr := frameMap[rowID]
+		attr := fieldMap[rowID]
 		if attr == nil {
-			frameMap[rowID] = cloneAttrs(attrs)
+			fieldMap[rowID] = cloneAttrs(attrs)
 		} else {
 			for k, v := range attrs {
 				attr[k] = v
@@ -1252,19 +1252,19 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 		}
 	}
 
-	// Bulk insert attributes by frame.
-	for name, frameMap := range m {
-		// Retrieve frame.
-		frame := e.Holder.Frame(index, name)
-		if frame == nil {
-			return nil, ErrFrameNotFound
+	// Bulk insert attributes by field.
+	for name, fieldMap := range m {
+		// Retrieve field.
+		field := e.Holder.Field(index, name)
+		if field == nil {
+			return nil, ErrFieldNotFound
 		}
 
 		// Set attributes.
-		if err := frame.RowAttrStore().SetBulkAttrs(frameMap); err != nil {
+		if err := field.RowAttrStore().SetBulkAttrs(fieldMap); err != nil {
 			return nil, err
 		}
-		frame.Stats.Count("SetRowAttrs", 1, 1.0)
+		field.Stats.Count("SetRowAttrs", 1, 1.0)
 	}
 
 	// Do not forward call if this is already being forwarded.
@@ -1309,7 +1309,7 @@ func (e *Executor) executeSetColumnAttrs(ctx context.Context, index string, c *p
 	// Copy args and remove reserved fields.
 	attrs := pql.CopyArgs(c.Args)
 	delete(attrs, columnLabel)
-	delete(attrs, "frame")
+	delete(attrs, "field")
 
 	// Set attributes.
 	if err := idx.ColumnAttrStore().SetAttrs(col, attrs); err != nil {
diff --git a/executor_test.go b/executor_test.go
index 89e54a1de..01c99e9c5 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -33,7 +33,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		hldr := test.MustOpenHolder()
 		defer hldr.Close()
 		index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-		f, err := index.CreateFrame("f", pilosa.FrameOptions{})
+		f, err := index.CreateField("f", pilosa.FieldOptions{})
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -42,9 +42,9 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 
 		// Set bits.
 		if _, err := e.Execute(context.Background(), "i", test.MustParse(``+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 10, 3)+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 10, SliceWidth+1)+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 20, SliceWidth+1),
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 10, 3)+
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 10, SliceWidth+1)+
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 20, SliceWidth+1),
 		), nil, nil); err != nil {
 			t.Fatal(err)
 		}
@@ -52,7 +52,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, nil); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, field=f)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if bits := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(bits, []uint64{3, SliceWidth + 1}) {
 			t.Fatalf("unexpected columns: %+v", bits)
@@ -61,7 +61,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		}
 
 		// Inhibit column attributes.
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeColumns: true}); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, field=f)`), nil, &pilosa.ExecOptions{ExcludeColumns: true}); err != nil {
 			t.Fatal(err)
 		} else if columns := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, []uint64{}) {
 			t.Fatalf("unexpected columns: %+v", columns)
@@ -70,7 +70,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		}
 
 		// Inhibit row attributes.
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeRowAttrs: true}); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, field=f)`), nil, &pilosa.ExecOptions{ExcludeRowAttrs: true}); err != nil {
 			t.Fatal(err)
 		} else if columns := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, []uint64{3, SliceWidth + 1}) {
 			t.Fatalf("unexpected columns: %+v", columns)
@@ -83,7 +83,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		hldr := test.MustOpenHolder()
 		defer hldr.Close()
 		index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-		if _, err := index.CreateFrame("f", pilosa.FrameOptions{}); err != nil {
+		if _, err := index.CreateField("f", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
@@ -91,9 +91,9 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 
 		// Set bits.
 		if _, err := e.Execute(context.Background(), "i", test.MustParse(``+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 10, 3)+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 10, SliceWidth+1)+
-			fmt.Sprintf("SetBit(frame=f, row=%d, col=%d)\n", 20, SliceWidth+1),
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 10, 3)+
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 10, SliceWidth+1)+
+			fmt.Sprintf("SetBit(field=f, row=%d, col=%d)\n", 20, SliceWidth+1),
 		), nil, nil); err != nil {
 			t.Fatal(err)
 		}
@@ -225,7 +225,7 @@ func TestExecutor_Execute_Count(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).MustSetBits(10, SliceWidth+2)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, frame=f))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, field=f))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if res[0] != uint64(3) {
 		t.Fatalf("unexpected n: %d", res[0])
@@ -243,7 +243,7 @@ func TestExecutor_Execute_SetBit(t *testing.T) {
 		t.Fatalf("unexpected bitmap count: %d", n)
 	}
 
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, frame=f, col=1)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, field=f, col=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else {
 		if !res[0].(bool) {
@@ -254,7 +254,7 @@ func TestExecutor_Execute_SetBit(t *testing.T) {
 	if n := f.Row(11).Count(); n != 1 {
 		t.Fatalf("unexpected bitmap count: %d", n)
 	}
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, frame=f, col=1)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, field=f, col=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else {
 		if res[0].(bool) {
@@ -269,15 +269,15 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 		hldr := test.MustOpenHolder()
 		defer hldr.Close()
 
-		// Create frames.
+		// Create felds.
 		index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-		if _, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		if _, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  0,
 			Max:  50,
 		}); err != nil {
 			t.Fatal(err)
-		} else if _, err := index.CreateFrameIfNotExists("xxx", pilosa.FrameOptions{}); err != nil {
+		} else if _, err := index.CreateFieldIfNotExists("xxx", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
@@ -289,7 +289,7 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		f := hldr.Frame("i", "f")
+		f := hldr.Field("i", "f")
 		if value, exists, err := f.Value(10); err != nil {
 			t.Fatal(err)
 		} else if !exists {
@@ -311,8 +311,8 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 		hldr := test.MustOpenHolder()
 		defer hldr.Close()
 		index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-		if _, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		if _, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  0,
 			Max:  100,
 		}); err != nil {
@@ -347,31 +347,31 @@ func TestExecutor_Execute_SetRowAttrs(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 
-	// Create frames.
+	// Create fields.
 	index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	if _, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{}); err != nil {
+	if _, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
-	} else if _, err := index.CreateFrameIfNotExists("xxx", pilosa.FrameOptions{}); err != nil {
+	} else if _, err := index.CreateFieldIfNotExists("xxx", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
 	// Set two attrs on f/10.
-	// Also set attrs on other bitmaps and frames to test isolation.
+	// Also set attrs on other bitmaps and fields to test isolation.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=f, foo="bar")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, field=f, foo="bar")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=200, frame=f, YYY=1)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=200, field=f, YYY=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=xxx, YYY=1)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, field=xxx, YYY=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=f, baz=123, bat=true)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, field=f, baz=123, bat=true)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
-	f := hldr.Frame("i", "f")
+	f := hldr.Field("i", "f")
 	if m, err := f.RowAttrStore().Attrs(10); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(m, map[string]interface{}{"foo": "bar", "baz": int64(123), "bat": true}) {
@@ -388,20 +388,20 @@ 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.FrameOptions{}); err != nil {
+	} else if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
-	} else if _, err := idx.CreateFrame("other", pilosa.FrameOptions{}); 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)
-		SetBit(frame=f, row=0, col=1)
-		SetBit(frame=f, row=0, col=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=f, row=0, col=`+strconv.Itoa(SliceWidth+2)+`)
-		SetBit(frame=f, row=0, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
-		SetBit(frame=f, row=10, col=0)
-		SetBit(frame=f, row=10, col=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=f, row=20, col=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=other, row=0, col=0)
+		SetBit(field=f, row=0, col=0)
+		SetBit(field=f, row=0, col=1)
+		SetBit(field=f, row=0, col=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(field=f, row=0, col=`+strconv.Itoa(SliceWidth+2)+`)
+		SetBit(field=f, row=0, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
+		SetBit(field=f, row=10, col=0)
+		SetBit(field=f, row=10, col=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(field=f, row=20, col=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(field=other, row=0, col=0)
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
@@ -411,7 +411,7 @@ func TestExecutor_Execute_TopN(t *testing.T) {
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 5).RecalculateCache()
 
 	t.Run("Standard", func(t *testing.T) {
-		if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(frame=f, n=2)`), nil, nil); err != nil {
+		if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(field=f, n=2)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(result[0], []pilosa.Pair{
 			{ID: 0, Count: 5},
@@ -436,7 +436,7 @@ func TestExecutor_Execute_TopN_fill(t *testing.T) {
 
 	// Execute query.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(frame=f, n=1)`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(field=f, n=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 0, Count: 4},
@@ -470,7 +470,7 @@ func TestExecutor_Execute_TopN_fill_small(t *testing.T) {
 
 	// Execute query.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(frame=f, n=1)`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(field=f, n=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 0, Count: 5},
@@ -505,7 +505,7 @@ func TestExecutor_Execute_TopN_Src(t *testing.T) {
 
 	// Execute query.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=100, frame=other), frame=f, n=3)`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=100, field=other), field=f, n=3)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 20, Count: 3},
@@ -525,11 +525,11 @@ func TestExecutor_Execute_TopN_Attr(t *testing.T) {
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 0).SetBit(0, 1)
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).SetBit(10, SliceWidth)
 
-	if err := hldr.Frame("i", "f").RowAttrStore().SetAttrs(10, map[string]interface{}{"category": int64(123)}); err != nil {
+	if err := hldr.Field("i", "f").RowAttrStore().SetAttrs(10, map[string]interface{}{"category": int64(123)}); err != nil {
 		t.Fatal(err)
 	}
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(frame="f", n=1, attrName="category", attrValues=[123])`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(field="f", n=1, attrName="category", attrValues=[123])`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 10, Count: 1},
@@ -548,11 +548,11 @@ func TestExecutor_Execute_TopN_Attr_Src(t *testing.T) {
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 0).SetBit(0, 1)
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).SetBit(10, SliceWidth)
 
-	if err := hldr.Frame("i", "f").RowAttrStore().SetAttrs(10, map[string]interface{}{"category": uint64(123)}); err != nil {
+	if err := hldr.Field("i", "f").RowAttrStore().SetAttrs(10, map[string]interface{}{"category": uint64(123)}); err != nil {
 		t.Fatal(err)
 	}
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=10,frame=f),frame="f", n=1, attrName="category", attrValues=[123])`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=10,field=f),field="f", n=1, attrName="category", attrValues=[123])`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 10, Count: 1},
@@ -572,12 +572,12 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("x", pilosa.FrameOptions{}); err != nil {
+	if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("f", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("f", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  -10,
 		Max:  100,
 	}); err != nil {
@@ -585,11 +585,11 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 	}
 
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=x, row=0, col=0)
-		SetBit(frame=x, row=0, col=3)
-		SetBit(frame=x, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
-		SetBit(frame=x, row=1, col=1)
-		SetBit(frame=x, row=2, col=`+strconv.Itoa(SliceWidth+2)+`)
+		SetBit(field=x, row=0, col=0)
+		SetBit(field=x, row=0, col=3)
+		SetBit(field=x, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetBit(field=x, row=1, col=1)
+		SetBit(field=x, row=2, col=`+strconv.Itoa(SliceWidth+2)+`)
 
 		SetValue(f=20, col=0)
 		SetValue(f=-5, col=1)
@@ -610,16 +610,16 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 			cnt    int64
 		}{
 			{filter: ``, exp: -5, cnt: 2},
-			{filter: `Bitmap(frame=x, row=0)`, exp: 10, cnt: 1},
-			{filter: `Bitmap(frame=x, row=1)`, exp: -5, cnt: 1},
-			{filter: `Bitmap(frame=x, row=2)`, exp: 40, cnt: 1},
+			{filter: `Bitmap(field=x, row=0)`, exp: 10, cnt: 1},
+			{filter: `Bitmap(field=x, row=1)`, exp: -5, cnt: 1},
+			{filter: `Bitmap(field=x, row=2)`, exp: 40, cnt: 1},
 		}
 		for i, tt := range tests {
 			var pql string
 			if tt.filter == "" {
-				pql = `Min(frame=f)`
+				pql = `Min(field=f)`
 			} else {
-				pql = fmt.Sprintf(`Min(%s, frame=f)`, tt.filter)
+				pql = fmt.Sprintf(`Min(%s, field=f)`, tt.filter)
 			}
 			if result, err := e.Execute(context.Background(), "i", test.MustParse(pql), nil, nil); err != nil {
 				t.Fatal(err)
@@ -636,16 +636,16 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 			cnt    int64
 		}{
 			{filter: ``, exp: 60, cnt: 1},
-			{filter: `Bitmap(frame=x, row=0)`, exp: 60, cnt: 1},
-			{filter: `Bitmap(frame=x, row=1)`, exp: -5, cnt: 1},
-			{filter: `Bitmap(frame=x, row=2)`, exp: 40, cnt: 1},
+			{filter: `Bitmap(field=x, row=0)`, exp: 60, cnt: 1},
+			{filter: `Bitmap(field=x, row=1)`, exp: -5, cnt: 1},
+			{filter: `Bitmap(field=x, row=2)`, exp: 40, cnt: 1},
 		}
 		for i, tt := range tests {
 			var pql string
 			if tt.filter == "" {
-				pql = `Max(frame=f)`
+				pql = `Max(field=f)`
 			} else {
-				pql = fmt.Sprintf(`Max(%s, frame=f)`, tt.filter)
+				pql = fmt.Sprintf(`Max(%s, field=f)`, tt.filter)
 			}
 			if result, err := e.Execute(context.Background(), "i", test.MustParse(pql), nil, nil); err != nil {
 				t.Fatal(err)
@@ -667,28 +667,28 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("x", pilosa.FrameOptions{}); err != nil {
+	if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("foo", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("foo", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  10,
 		Max:  100,
 	}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("bar", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("bar", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  100000,
 	}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("other", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("other", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  1000,
 	}); err != nil {
@@ -696,8 +696,8 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 	}
 
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=x, row=0, col=0)
-		SetBit(frame=x, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetBit(field=x, row=0, col=0)
+		SetBit(field=x, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
 
 		SetValue(foo=20, col=0)
 		SetValue(bar=2000, col=0)
@@ -711,7 +711,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 	}
 
 	t.Run("NoFilter", func(t *testing.T) {
-		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(frame=foo)`), nil, nil); err != nil {
+		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(field=foo)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(result[0], pilosa.ValCount{Val: 200, Count: 5}) {
 			t.Fatalf("unexpected result: %s", spew.Sdump(result))
@@ -719,7 +719,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 	})
 
 	t.Run("WithFilter", func(t *testing.T) {
-		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(Bitmap(frame=x, row=0), frame=foo)`), nil, nil); err != nil {
+		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(Bitmap(field=x, row=0), field=foo)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(result[0], pilosa.ValCount{Val: 80, Count: 2}) {
 			t.Fatalf("unexpected result: %s", spew.Sdump(result))
@@ -736,9 +736,9 @@ func TestExecutor_Execute_BSIGroupRange(t *testing.T) {
 	// Create index.
 	index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
 
-	// Create frame.
-	if _, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{
-		Type:        pilosa.FrameTypeTime,
+	// Create field.
+	if _, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{
+		Type:        pilosa.FieldTypeTime,
 		TimeQuantum: pilosa.TimeQuantum("YMDH"),
 	}); err != nil {
 		t.Fatal(err)
@@ -746,22 +746,22 @@ func TestExecutor_Execute_BSIGroupRange(t *testing.T) {
 
 	// Set columns.
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-        SetBit(frame=f, row=1, col=2, timestamp="1999-12-31T00:00")
-        SetBit(frame=f, row=1, col=3, timestamp="2000-01-01T00:00")
-        SetBit(frame=f, row=1, col=4, timestamp="2000-01-02T00:00")
-        SetBit(frame=f, row=1, col=5, timestamp="2000-02-01T00:00")
-        SetBit(frame=f, row=1, col=6, timestamp="2001-01-01T00:00")
-        SetBit(frame=f, row=1, col=7, timestamp="2002-01-01T02:00")
+        SetBit(field=f, row=1, col=2, timestamp="1999-12-31T00:00")
+        SetBit(field=f, row=1, col=3, timestamp="2000-01-01T00:00")
+        SetBit(field=f, row=1, col=4, timestamp="2000-01-02T00:00")
+        SetBit(field=f, row=1, col=5, timestamp="2000-02-01T00:00")
+        SetBit(field=f, row=1, col=6, timestamp="2001-01-01T00:00")
+        SetBit(field=f, row=1, col=7, timestamp="2002-01-01T02:00")
 
-        SetBit(frame=f, row=1, col=2, timestamp="1999-12-30T00:00")
-        SetBit(frame=f, row=1, col=2, timestamp="2002-02-01T00:00")
-        SetBit(frame=f, row=10, col=2, timestamp="2001-01-01T00:00")
+        SetBit(field=f, row=1, col=2, timestamp="1999-12-30T00:00")
+        SetBit(field=f, row=1, col=2, timestamp="2002-02-01T00:00")
+        SetBit(field=f, row=10, col=2, timestamp="2001-01-01T00:00")
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
 	t.Run("Standard", func(t *testing.T) {
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Range(row=1, frame=f, start="1999-12-31T00:00", end="2002-01-01T03:00")`), nil, nil); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Range(row=1, field=f, start="1999-12-31T00:00", end="2002-01-01T03:00")`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if columns := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, []uint64{2, 3, 4, 5, 6, 7}) {
 			t.Fatalf("unexpected columns: %+v", columns)
@@ -780,36 +780,36 @@ func TestExecutor_Execute_Range(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("f", pilosa.FrameOptions{}); err != nil {
+	if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("foo", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("foo", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  10,
 		Max:  100,
 	}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("bar", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("bar", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  100000,
 	}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("other", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("other", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  1000,
 	}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("edge", pilosa.FrameOptions{
-		Type: pilosa.FrameTypeInt,
+	if _, err := idx.CreateField("edge", pilosa.FieldOptions{
+		Type: pilosa.FieldTypeInt,
 		Min:  -100,
 		Max:  100,
 	}); err != nil {
@@ -817,8 +817,8 @@ func TestExecutor_Execute_Range(t *testing.T) {
 	}
 
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=f, row=0, col=0)
-		SetBit(frame=f, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetBit(field=f, row=0, col=0)
+		SetBit(field=f, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
 
 		SetValue(foo=20, col=50)
 		SetValue(bar=2000, col=50)
@@ -944,8 +944,8 @@ 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 {
+	t.Run("ErrFieldNotFound", func(t *testing.T) {
+		if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(bad_field >= 20)`), nil, nil); err != pilosa.ErrFieldNotFound {
 			t.Fatal(err)
 		}
 	})
@@ -969,7 +969,7 @@ func TestExecutor_Execute_Remote_Row(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != "i" {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `Bitmap(frame="f", row=10)` {
+		} else if query.String() != `Bitmap(field="f", row=10)` {
 			t.Fatalf("unexpected query: %s", query.String())
 		} else if !reflect.DeepEqual(slices, []uint64{1}) {
 			t.Fatalf("unexpected slices: %+v", slices)
@@ -992,7 +992,7 @@ func TestExecutor_Execute_Remote_Row(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).MustSetBits(10, (1*SliceWidth)+1)
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, field=f)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if columns := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, []uint64{1, 2, 2*SliceWidth + 4}) {
 		t.Fatalf("unexpected columns: %+v", columns)
@@ -1027,7 +1027,7 @@ func TestExecutor_Execute_Remote_Count(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 2).MustSetBits(10, (2*SliceWidth)+2)
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, frame=f))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, field=f))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if res[0] != uint64(12) {
 		t.Fatalf("unexpected n: %d", res[0])
@@ -1055,7 +1055,7 @@ func TestExecutor_Execute_Remote_SetBit(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != `i` {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `SetBit(col=2, frame="f", row=10)` {
+		} else if query.String() != `SetBit(col=2, field="f", row=10)` {
 			t.Fatalf("unexpected query: %s", query.String())
 		}
 		remoteCalled = true
@@ -1067,13 +1067,13 @@ func TestExecutor_Execute_Remote_SetBit(t *testing.T) {
 	defer hldr.Close()
 	s.Handler.API.Holder = hldr.Holder
 
-	// Create frame.
-	if _, err := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{}).CreateFrame("f", pilosa.FrameOptions{}); err != nil {
+	// Create field.
+	if _, err := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{}).CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, frame=f, col=2)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, field=f, col=2)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1107,7 +1107,7 @@ func TestExecutor_Execute_Remote_SetBit_With_Timestamp(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != `i` {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `SetBit(col=2, frame="f", row=10, timestamp="2016-12-11T10:09")` {
+		} else if query.String() != `SetBit(col=2, field="f", row=10, timestamp="2016-12-11T10:09")` {
 			t.Fatalf("unexpected query: %s", query.String())
 		}
 		remoteCalled = true
@@ -1119,15 +1119,15 @@ func TestExecutor_Execute_Remote_SetBit_With_Timestamp(t *testing.T) {
 	defer hldr.Close()
 	s.Handler.API.Holder = hldr.Holder
 
-	// Create frame.
-	if f, err := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{}).CreateFrame("f", pilosa.FrameOptions{}); err != nil {
+	// Create field.
+	if f, err := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{}).CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if err := f.SetTimeQuantum("Y"); err != nil {
 		t.Fatal(err)
 	}
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, frame=f, col=2, timestamp="2016-12-11T10:09")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, field=f, col=2, timestamp="2016-12-11T10:09")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1168,11 +1168,11 @@ func TestExecutor_Execute_Remote_TopN(t *testing.T) {
 		// slices and a second time to get the counts for a set of bitmaps.
 		switch remoteExecN {
 		case 0:
-			if query.String() != `TopN(frame="f", n=3)` {
+			if query.String() != `TopN(field="f", n=3)` {
 				t.Fatalf("unexpected query(0): %s", query.String())
 			}
 		case 1:
-			if query.String() != `TopN(frame="f", ids=[0,10,30], n=3)` {
+			if query.String() != `TopN(field="f", ids=[0,10,30], n=3)` {
 				t.Fatalf("unexpected query(1): %s", query.String())
 			}
 		default:
@@ -1196,7 +1196,7 @@ func TestExecutor_Execute_Remote_TopN(t *testing.T) {
 	hldr.MustCreateRankedFragmentIfNotExists("i", "f", pilosa.ViewStandard, 4).MustSetBits(30, (4*SliceWidth)+2)
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(frame=f, n=3)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(field=f, n=3)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(res, []interface{}{[]pilosa.Pair{
 		{ID: 0, Count: 5},
@@ -1218,23 +1218,23 @@ func TestExecutor_Execute_ErrMaxWritesPerRequest(t *testing.T) {
 	}
 }
 
-// Ensure SetColumnAttrs doesn't save `frame` as an attribute
-func TestExectutor_SetColumnAttrs_ExcludeFrame(t *testing.T) {
+// Ensure SetColumnAttrs doesn't save `field` as an attribute
+func TestExectutor_SetColumnAttrs_ExcludeField(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 	index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	index.CreateFrame("f", pilosa.FrameOptions{})
+	index.CreateField("f", pilosa.FieldOptions{})
 	targetAttrs := map[string]interface{}{
 		"foo": "bar",
 	}
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
 
-	// SetColumnAttrs call should exclude the frame attribute
-	_, err := e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', row=1, col=10)"), nil, nil)
+	// SetColumnAttrs call should exclude the field attribute
+	_, err := e.Execute(context.Background(), "i", test.MustParse("SetBit(field='f', row=1, col=10)"), nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = e.Execute(context.Background(), "i", test.MustParse("SetColumnAttrs(frame='f', col=10, foo='bar')"), nil, nil)
+	_, err = e.Execute(context.Background(), "i", test.MustParse("SetColumnAttrs(field='f', col=10, foo='bar')"), nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1246,8 +1246,8 @@ func TestExectutor_SetColumnAttrs_ExcludeFrame(t *testing.T) {
 		t.Fatalf("%#v != %#v", targetAttrs, attrs)
 	}
 
-	// SetColumnAttrs call should not break if frame is not specified
-	_, err = e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', row=1, col=20)"), nil, nil)
+	// SetColumnAttrs call should not break if field is not specified
+	_, err = e.Execute(context.Background(), "i", test.MustParse("SetBit(field='f', row=1, col=20)"), nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/frame.go b/field.go
similarity index 78%
rename from frame.go
rename to field.go
index ac9eb5ee7..0e1f79d66 100644
--- a/frame.go
+++ b/field.go
@@ -29,25 +29,25 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Default frame settings.
+// Default field settings.
 const (
-	DefaultFrameType = FrameTypeSet
+	DefaultFieldType = FieldTypeSet
 
 	DefaultCacheType = CacheTypeRanked
 
-	// Default ranked frame cache
+	// Default ranked field cache
 	DefaultCacheSize = 50000
 )
 
-// Frame types.
+// Field types.
 const (
-	FrameTypeSet  = "set"
-	FrameTypeInt  = "int"
-	FrameTypeTime = "time"
+	FieldTypeSet  = "set"
+	FieldTypeInt  = "int"
+	FieldTypeTime = "time"
 )
 
-// Frame represents a container for views.
-type Frame struct {
+// Field represents a container for views.
+type Field struct {
 	mu    sync.RWMutex
 	path  string
 	index string
@@ -61,33 +61,33 @@ type Frame struct {
 	broadcaster Broadcaster
 	Stats       StatsClient
 
-	// Frame options.
-	options FrameOptions
+	// Field options.
+	options FieldOptions
 
 	bsiGroups []*bsiGroup
 
 	Logger Logger
 }
 
-// FrameOption is a functional option type for pilosa.Frame.
-type FrameOption func(f *Frame) error
+// FieldOption is a functional option type for pilosa.Fielde.
+type FieldOption func(f *Field) error
 
-// TODO: break these out into separate Options (not a FrameOptions object)
-func OptFrameFrameOptions(o FrameOptions) FrameOption {
-	return func(f *Frame) error {
+// TODO: break these out into separate Options (not a FieldOptions object)
+func OptFieldFieldOptions(o FieldOptions) FieldOption {
+	return func(f *Field) error {
 		f.options = o
 		return nil
 	}
 }
 
-// NewFrame returns a new instance of frame.
-func NewFrame(path, index, name string, opts ...FrameOption) (*Frame, error) {
+// NewField returns a new instance of field.
+func NewField(path, index, name string, opts ...FieldOption) (*Field, error) {
 	err := ValidateName(name)
 	if err != nil {
 		return nil, err
 	}
 
-	f := &Frame{
+	f := &Field{
 		path:  path,
 		index: index,
 		name:  name,
@@ -99,8 +99,8 @@ func NewFrame(path, index, name string, opts ...FrameOption) (*Frame, error) {
 		broadcaster: NopBroadcaster,
 		Stats:       NopStatsClient,
 
-		options: FrameOptions{
-			Type:      DefaultFrameType,
+		options: FieldOptions{
+			Type:      DefaultFieldType,
 			CacheType: DefaultCacheType,
 			CacheSize: DefaultCacheSize,
 		},
@@ -118,20 +118,20 @@ func NewFrame(path, index, name string, opts ...FrameOption) (*Frame, error) {
 	return f, nil
 }
 
-// Name returns the name the frame was initialized with.
-func (f *Frame) Name() string { return f.name }
+// Name returns the name the field was initialized with.
+func (f *Field) Name() string { return f.name }
 
-// Index returns the index name the frame was initialized with.
-func (f *Frame) Index() string { return f.index }
+// Index returns the index name the field was initialized with.
+func (f *Field) Index() string { return f.index }
 
-// Path returns the path the frame was initialized with.
-func (f *Frame) Path() string { return f.path }
+// Path returns the path the field was initialized with.
+func (f *Field) Path() string { return f.path }
 
 // RowAttrStore returns the attribute storage.
-func (f *Frame) RowAttrStore() AttrStore { return f.rowAttrStore }
+func (f *Field) RowAttrStore() AttrStore { return f.rowAttrStore }
 
-// MaxSlice returns the max slice in the frame.
-func (f *Frame) MaxSlice() uint64 {
+// MaxSlice returns the max slice in the field.
+func (f *Field) MaxSlice() uint64 {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 
@@ -144,15 +144,15 @@ func (f *Frame) MaxSlice() uint64 {
 	return max
 }
 
-// Type returns the frame type.
-func (f *Frame) Type() string {
+// Type returns the field type.
+func (f *Field) Type() string {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	return f.options.Type
 }
 
-// CacheType returns the caching mode for the frame.
-func (f *Frame) CacheType() string {
+// CacheType returns the caching mode for the field.
+func (f *Field) CacheType() string {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	return f.options.CacheType
@@ -160,7 +160,7 @@ func (f *Frame) CacheType() string {
 
 // SetCacheSize sets the cache size for ranked fames. Persists to meta file on update.
 // defaults to DefaultCacheSize 50000
-func (f *Frame) SetCacheSize(v uint32) error {
+func (f *Field) SetCacheSize(v uint32) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -178,34 +178,34 @@ func (f *Frame) SetCacheSize(v uint32) error {
 	return nil
 }
 
-// CacheSize returns the ranked frame cache size.
-func (f *Frame) CacheSize() uint32 {
+// CacheSize returns the ranked field cache size.
+func (f *Field) CacheSize() uint32 {
 	f.mu.RLock()
 	v := f.options.CacheSize
 	f.mu.RUnlock()
 	return v
 }
 
-// Options returns all options for this frame.
-func (f *Frame) Options() FrameOptions {
+// Options returns all options for this field.
+func (f *Field) Options() FieldOptions {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	return f.options
 }
 
-// Open opens and initializes the frame.
-func (f *Frame) Open() error {
+// Open opens and initializes the field.
+func (f *Field) Open() error {
 	if err := func() error {
-		// Ensure the frame's path exists.
+		// Ensure the field's path exists.
 		if err := os.MkdirAll(f.path, 0777); err != nil {
-			return errors.Wrap(err, "creating frame dir")
+			return errors.Wrap(err, "creating field dir")
 		}
 
 		if err := f.loadMeta(); err != nil {
 			return errors.Wrap(err, "loading meta")
 		}
 
-		// Apply the frame options loaded from meta.
+		// Apply the field options loaded from meta.
 		if err := f.applyOptions(f.options); err != nil {
 			return errors.Wrap(err, "applying options")
 		}
@@ -227,8 +227,8 @@ func (f *Frame) Open() error {
 	return nil
 }
 
-// openViews opens and initializes the views inside the frame.
-func (f *Frame) openViews() error {
+// openViews opens and initializes the views inside the field.
+func (f *Field) openViews() error {
 	file, err := os.Open(filepath.Join(f.path, "views"))
 	if os.IsNotExist(err) {
 		return nil
@@ -259,9 +259,9 @@ func (f *Frame) openViews() error {
 	return nil
 }
 
-// loadMeta reads meta data for the frame, if any.
-func (f *Frame) loadMeta() error {
-	var pb internal.FrameMeta
+// loadMeta reads meta data for the field, if any.
+func (f *Field) loadMeta() error {
+	var pb internal.FieldOptions
 
 	// Read data from meta file.
 	buf, err := ioutil.ReadFile(filepath.Join(f.path, ".meta"))
@@ -286,8 +286,8 @@ func (f *Frame) loadMeta() error {
 	return nil
 }
 
-// saveMeta writes meta data for the frame.
-func (f *Frame) saveMeta() error {
+// saveMeta writes meta data for the field.
+func (f *Field) saveMeta() error {
 	// Marshal metadata.
 	fo := f.options
 	buf, err := proto.Marshal(fo.Encode())
@@ -303,11 +303,11 @@ func (f *Frame) saveMeta() error {
 	return nil
 }
 
-// applyOptions configures the frame based on opt.
-func (f *Frame) applyOptions(opt FrameOptions) error {
+// applyOptions configures the field based on opt.
+func (f *Field) applyOptions(opt FieldOptions) error {
 	switch opt.Type {
-	case FrameTypeSet, "":
-		f.options.Type = FrameTypeSet
+	case FieldTypeSet, "":
+		f.options.Type = FieldTypeSet
 		if opt.CacheType != "" {
 			f.options.CacheType = opt.CacheType
 		}
@@ -317,7 +317,7 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 		f.options.Min = 0
 		f.options.Max = 0
 		f.options.TimeQuantum = ""
-	case FrameTypeInt:
+	case FieldTypeInt:
 		f.options.Type = opt.Type
 		f.options.CacheType = CacheTypeNone
 		f.options.CacheSize = 0
@@ -339,7 +339,7 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 		if err := f.createBSIGroup(bsig); err != nil {
 			return errors.Wrap(err, "creating bsigroup")
 		}
-	case FrameTypeTime:
+	case FieldTypeTime:
 		f.options.Type = opt.Type
 		f.options.CacheType = CacheTypeNone
 		f.options.CacheSize = 0
@@ -351,14 +351,14 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 			return errors.Wrap(err, "setting time quantum")
 		}
 	default:
-		return errors.New("invalid frame type")
+		return errors.New("invalid field type")
 	}
 
 	return nil
 }
 
-// Close closes the frame and its views.
-func (f *Frame) Close() error {
+// Close closes the field and its views.
+func (f *Field) Close() error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -379,7 +379,7 @@ func (f *Frame) Close() error {
 }
 
 // bsiGroup returns a bsiGroup by name.
-func (f *Frame) bsiGroup(name string) *bsiGroup {
+func (f *Field) bsiGroup(name string) *bsiGroup {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	for _, bsig := range f.bsiGroups {
@@ -390,8 +390,8 @@ func (f *Frame) bsiGroup(name string) *bsiGroup {
 	return nil
 }
 
-// hasBSIGroup returns true if a bsiGroup exists on the frame.
-func (f *Frame) hasBSIGroup(name string) bool {
+// hasBSIGroup returns true if a bsiGroup exists on the field.
+func (f *Field) hasBSIGroup(name string) bool {
 	for _, bsig := range f.bsiGroups {
 		if bsig.Name == name {
 			return true
@@ -400,8 +400,8 @@ func (f *Frame) hasBSIGroup(name string) bool {
 	return false
 }
 
-// createBSIGroup creates a new bsiGroup on the frame.
-func (f *Frame) createBSIGroup(bsig *bsiGroup) error {
+// createBSIGroup creates a new bsiGroup on the field.
+func (f *Field) createBSIGroup(bsig *bsiGroup) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -414,7 +414,7 @@ func (f *Frame) createBSIGroup(bsig *bsiGroup) error {
 }
 
 // addBSIGroup adds a single bsiGroup to bsiGroups.
-func (f *Frame) addBSIGroup(bsig *bsiGroup) error {
+func (f *Field) addBSIGroup(bsig *bsiGroup) error {
 	if err := bsig.validate(); err != nil {
 		return errors.Wrap(err, "validating bsigroup")
 	} else if f.hasBSIGroup(bsig.Name) {
@@ -433,7 +433,7 @@ func (f *Frame) addBSIGroup(bsig *bsiGroup) error {
 }
 
 // deleteBSIGroupAndView deletes an existing bsiGroup on the schema.
-func (f *Frame) deleteBSIGroupAndView(name string) error {
+func (f *Field) deleteBSIGroupAndView(name string) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -458,7 +458,7 @@ func (f *Frame) deleteBSIGroupAndView(name string) error {
 }
 
 // deleteBSIGroup removes a single bsiGroup from bsiGroups.
-func (f *Frame) deleteBSIGroup(name string) error {
+func (f *Field) deleteBSIGroup(name string) error {
 	for i, bsig := range f.bsiGroups {
 		if bsig.Name == name {
 			copy(f.bsiGroups[i:], f.bsiGroups[i+1:])
@@ -469,15 +469,15 @@ func (f *Frame) deleteBSIGroup(name string) error {
 	return ErrBSIGroupNotFound
 }
 
-// TimeQuantum returns the time quantum for the frame.
-func (f *Frame) TimeQuantum() TimeQuantum {
+// TimeQuantum returns the time quantum for the field.
+func (f *Field) TimeQuantum() TimeQuantum {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.options.TimeQuantum
 }
 
-// SetTimeQuantum sets the time quantum for the frame.
-func (f *Frame) SetTimeQuantum(q TimeQuantum) error {
+// SetTimeQuantum sets the time quantum for the field.
+func (f *Field) SetTimeQuantum(q TimeQuantum) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -486,7 +486,7 @@ func (f *Frame) SetTimeQuantum(q TimeQuantum) error {
 		return ErrInvalidTimeQuantum
 	}
 
-	// Update value on frame.
+	// Update value on field.
 	f.options.TimeQuantum = q
 
 	// Persist meta data to disk.
@@ -497,22 +497,22 @@ func (f *Frame) SetTimeQuantum(q TimeQuantum) error {
 	return nil
 }
 
-// ViewPath returns the path to a view in the frame.
-func (f *Frame) ViewPath(name string) string {
+// ViewPath returns the path to a view in the field.
+func (f *Field) ViewPath(name string) string {
 	return filepath.Join(f.path, "views", name)
 }
 
-// View returns a view in the frame by name.
-func (f *Frame) View(name string) *View {
+// View returns a view in the field by name.
+func (f *Field) View(name string) *View {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	return f.view(name)
 }
 
-func (f *Frame) view(name string) *View { return f.views[name] }
+func (f *Field) view(name string) *View { return f.views[name] }
 
-// Views returns a list of all views in the frame.
-func (f *Frame) Views() []*View {
+// Views returns a list of all views in the field.
+func (f *Field) Views() []*View {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 
@@ -523,8 +523,8 @@ func (f *Frame) Views() []*View {
 	return other
 }
 
-// viewNames returns a list of all views (as a string) in the frame.
-func (f *Frame) viewNames() []string {
+// viewNames returns a list of all views (as a string) in the field.
+func (f *Field) viewNames() []string {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -535,8 +535,8 @@ func (f *Frame) viewNames() []string {
 	return other
 }
 
-// RecalculateCaches recalculates caches on every view in the frame.
-func (f *Frame) RecalculateCaches() {
+// RecalculateCaches recalculates caches on every view in the field.
+func (f *Field) RecalculateCaches() {
 	for _, view := range f.Views() {
 		view.RecalculateCaches()
 	}
@@ -544,7 +544,7 @@ func (f *Frame) RecalculateCaches() {
 
 // CreateViewIfNotExists returns the named view, creating it if necessary.
 // Additionally, a CreateViewMessage is sent to the cluster.
-func (f *Frame) CreateViewIfNotExists(name string) (*View, error) {
+func (f *Field) CreateViewIfNotExists(name string) (*View, error) {
 
 	view, created, err := f.createViewIfNotExistsBase(name)
 	if err != nil {
@@ -556,7 +556,7 @@ func (f *Frame) CreateViewIfNotExists(name string) (*View, error) {
 		err = f.broadcaster.SendSync(
 			&internal.CreateViewMessage{
 				Index: f.index,
-				Frame: f.name,
+				Field: f.name,
 				View:  name,
 			})
 		if err != nil {
@@ -569,7 +569,7 @@ func (f *Frame) CreateViewIfNotExists(name string) (*View, error) {
 
 // createViewIfNotExistsBase returns the named view, creating it if necessary.
 // The returned bool indicates whether the view was created or not.
-func (f *Frame) createViewIfNotExistsBase(name string) (*View, bool, error) {
+func (f *Field) createViewIfNotExistsBase(name string) (*View, bool, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -588,7 +588,7 @@ func (f *Frame) createViewIfNotExistsBase(name string) (*View, bool, error) {
 	return view, true, nil
 }
 
-func (f *Frame) newView(path, name string) *View {
+func (f *Field) newView(path, name string) *View {
 	view := NewView(path, f.index, f.name, name, f.options.CacheSize)
 	view.cacheType = f.options.CacheType
 	view.Logger = f.Logger
@@ -598,8 +598,8 @@ func (f *Frame) newView(path, name string) *View {
 	return view
 }
 
-// DeleteView removes the view from the frame.
-func (f *Frame) DeleteView(name string) error {
+// DeleteView removes the view from the field.
+func (f *Field) DeleteView(name string) error {
 	view := f.views[name]
 	if view == nil {
 		return ErrInvalidView
@@ -620,8 +620,8 @@ func (f *Frame) DeleteView(name string) error {
 	return nil
 }
 
-// SetBit sets a bit on a view within the frame.
-func (f *Frame) SetBit(name string, rowID, colID uint64, t *time.Time) (changed bool, err error) {
+// SetBit sets a bit on a view within the field.
+func (f *Field) SetBit(name string, rowID, colID uint64, t *time.Time) (changed bool, err error) {
 	// Validate view name.
 	if !IsValidView(name) {
 		return false, ErrInvalidView
@@ -662,8 +662,8 @@ func (f *Frame) SetBit(name string, rowID, colID uint64, t *time.Time) (changed
 	return changed, nil
 }
 
-// ClearBit clears a bit within the frame.
-func (f *Frame) ClearBit(name string, rowID, colID uint64, t *time.Time) (changed bool, err error) {
+// ClearBit clears a bit within the field.
+func (f *Field) ClearBit(name string, rowID, colID uint64, t *time.Time) (changed bool, err error) {
 	// Validate view name.
 	if !IsValidView(name) {
 		return false, ErrInvalidView
@@ -704,8 +704,8 @@ func (f *Frame) ClearBit(name string, rowID, colID uint64, t *time.Time) (change
 	return changed, nil
 }
 
-// Value reads a frame value for a column.
-func (f *Frame) Value(columnID uint64) (value int64, exists bool, err error) {
+// Value reads a field value for a column.
+func (f *Field) Value(columnID uint64) (value int64, exists bool, err error) {
 	bsig := f.bsiGroup(f.name)
 	if bsig == nil {
 		return 0, false, ErrBSIGroupNotFound
@@ -726,8 +726,8 @@ func (f *Frame) Value(columnID uint64) (value int64, exists bool, err error) {
 	return int64(v) + bsig.Min, true, nil
 }
 
-// SetValue sets a frame value for a column.
-func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error) {
+// SetValue sets a field value for a column.
+func (f *Field) SetValue(columnID uint64, value int64) (changed bool, err error) {
 	// Fetch bsiGroup and validate value.
 	bsig := f.bsiGroup(f.name)
 	if bsig == nil {
@@ -750,9 +750,9 @@ func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error)
 	return view.setValue(columnID, bsig.BitDepth(), baseValue)
 }
 
-// Sum returns the sum and count for a frame.
+// Sum returns the sum and count for a field.
 // An optional filtering row can be provided.
-func (f *Frame) Sum(filter *Row, name string) (sum, count int64, err error) {
+func (f *Field) Sum(filter *Row, name string) (sum, count int64, err error) {
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -770,9 +770,9 @@ func (f *Frame) Sum(filter *Row, name string) (sum, count int64, err error) {
 	return int64(vsum) + (int64(vcount) * bsig.Min), int64(vcount), nil
 }
 
-// Min returns the min for a frame.
+// Min returns the min for a field.
 // An optional filtering row can be provided.
-func (f *Frame) Min(filter *Row, name string) (min, count int64, err error) {
+func (f *Field) Min(filter *Row, name string) (min, count int64, err error) {
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -790,9 +790,9 @@ func (f *Frame) Min(filter *Row, name string) (min, count int64, err error) {
 	return int64(vmin) + bsig.Min, int64(vcount), nil
 }
 
-// Max returns the max for a frame.
+// Max returns the max for a field.
 // An optional filtering row can be provided.
-func (f *Frame) Max(filter *Row, name string) (max, count int64, err error) {
+func (f *Field) Max(filter *Row, name string) (max, count int64, err error) {
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -810,7 +810,7 @@ func (f *Frame) Max(filter *Row, name string) (max, count int64, err error) {
 	return int64(vmax) + bsig.Min, int64(vcount), nil
 }
 
-func (f *Frame) Range(name string, op pql.Token, predicate int64) (*Row, error) {
+func (f *Field) Range(name string, op pql.Token, predicate int64) (*Row, error) {
 	// Retrieve and validate bsiGroup.
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
@@ -833,7 +833,7 @@ func (f *Frame) Range(name string, op pql.Token, predicate int64) (*Row, error)
 	return view.rangeOp(op, bsig.BitDepth(), baseValue)
 }
 
-func (f *Frame) RangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
+func (f *Field) RangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
 	// Retrieve and validate bsiGroup.
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
@@ -857,11 +857,11 @@ func (f *Frame) RangeBetween(name string, predicateMin, predicateMax int64) (*Ro
 }
 
 // Import bulk imports data.
-func (f *Frame) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) error {
+func (f *Field) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) error {
 	// Determine quantum if timestamps are set.
 	q := f.TimeQuantum()
 	if hasTime(timestamps) && q == "" {
-		return errors.New("time quantum not set in either index or frame")
+		return errors.New("time quantum not set in field")
 	}
 
 	// Split import data by fragment.
@@ -914,7 +914,7 @@ func (f *Frame) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) erro
 }
 
 // ImportValue bulk imports range-encoded value data.
-func (f *Frame) ImportValue(columnIDs []uint64, values []int64) error {
+func (f *Field) ImportValue(columnIDs []uint64, values []int64) error {
 	viewName := viewBSIGroupPrefix + f.name
 	// Get the bsiGroup so we know bitDepth.
 	bsig := f.bsiGroup(f.name)
@@ -970,83 +970,83 @@ func (f *Frame) ImportValue(columnIDs []uint64, values []int64) error {
 	return nil
 }
 
-// encodeFrames converts a into its internal representation.
-func encodeFrames(a []*Frame) []*internal.Frame {
-	other := make([]*internal.Frame, len(a))
+// encodeFields converts a into its internal representation.
+func encodeFields(a []*Field) []*internal.Field {
+	other := make([]*internal.Field, len(a))
 	for i := range a {
-		other[i] = encodeFrame(a[i])
+		other[i] = encodeField(a[i])
 	}
 	return other
 }
 
-// encodeFrame converts f into its internal representation.
-func encodeFrame(f *Frame) *internal.Frame {
+// encodeField converts f into its internal representation.
+func encodeField(f *Field) *internal.Field {
 	fo := f.options
-	return &internal.Frame{
+	return &internal.Field{
 		Name:  f.name,
 		Meta:  fo.Encode(),
 		Views: f.viewNames(),
 	}
 }
 
-type frameSlice []*Frame
+type fieldSlice []*Field
 
-func (p frameSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
-func (p frameSlice) Len() int           { return len(p) }
-func (p frameSlice) Less(i, j int) bool { return p[i].Name() < p[j].Name() }
+func (p fieldSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p fieldSlice) Len() int           { return len(p) }
+func (p fieldSlice) Less(i, j int) bool { return p[i].Name() < p[j].Name() }
 
-// FrameInfo represents schema information for a frame.
-type FrameInfo struct {
+// FieldInfo represents schema information for a field.
+type FieldInfo struct {
 	Name    string       `json:"name"`
-	Options FrameOptions `json:"options"`
+	Options FieldOptions `json:"options"`
 	Views   []*ViewInfo  `json:"views,omitempty"`
 }
 
-type frameInfoSlice []*FrameInfo
+type fieldInfoSlice []*FieldInfo
 
-func (p frameInfoSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
-func (p frameInfoSlice) Len() int           { return len(p) }
-func (p frameInfoSlice) Less(i, j int) bool { return p[i].Name < p[j].Name }
+func (p fieldInfoSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p fieldInfoSlice) Len() int           { return len(p) }
+func (p fieldInfoSlice) Less(i, j int) bool { return p[i].Name < p[j].Name }
 
-// FrameOptions represents options to set when initializing a frame.
-type FrameOptions struct {
+// FieldOptions represents options to set when initializing a field.
+type FieldOptions struct {
 	Type        string      `json:"type,omitempty"`
 	CacheType   string      `json:"cacheType,omitempty"`
 	CacheSize   uint32      `json:"cacheSize,omitempty"`
 	Min         int64       `json:"min,omitempty"`
 	Max         int64       `json:"max,omitempty"`
-	TimeQuantum TimeQuantum `json:"timeQuantum,omitempty"` // TODO: rename this Quantum?
+	TimeQuantum TimeQuantum `json:"timeQuantum,omitempty"`
 }
 
-// Validate ensures that FrameOption values are valid.
-func (o *FrameOptions) Validate() error {
+// Validate ensures that FieldOption values are valid.
+func (o *FieldOptions) Validate() error {
 	switch o.Type {
-	case FrameTypeSet, "":
+	case FieldTypeSet, "":
 		// TODO: cacheType, cacheSize validation
-	case FrameTypeInt:
+	case FieldTypeInt:
 		if o.Min > o.Max {
 			return ErrInvalidBSIGroupRange
 		}
-	case FrameTypeTime:
+	case FieldTypeTime:
 		if o.TimeQuantum == "" || !o.TimeQuantum.Valid() {
 			return ErrInvalidTimeQuantum
 		}
 	default:
-		return errors.New("invalid frame type")
+		return errors.New("invalid field type")
 	}
 	return nil
 }
 
 // Encode converts o into its internal representation.
-func (o *FrameOptions) Encode() *internal.FrameMeta {
-	return encodeFrameOptions(o)
+func (o *FieldOptions) Encode() *internal.FieldOptions {
+	return encodeFieldOptions(o)
 }
 
-func encodeFrameOptions(o *FrameOptions) *internal.FrameMeta {
+func encodeFieldOptions(o *FieldOptions) *internal.FieldOptions {
 	if o == nil {
 		return nil
 	}
-	return &internal.FrameMeta{
+	return &internal.FieldOptions{
 		Type:        o.Type,
 		CacheType:   o.CacheType,
 		CacheSize:   o.CacheSize,
@@ -1056,11 +1056,11 @@ func encodeFrameOptions(o *FrameOptions) *internal.FrameMeta {
 	}
 }
 
-func decodeFrameOptions(options *internal.FrameMeta) *FrameOptions {
+func decodeFieldOptions(options *internal.FieldOptions) *FieldOptions {
 	if options == nil {
 		return nil
 	}
-	return &FrameOptions{
+	return &FieldOptions{
 		Type:        options.Type,
 		CacheType:   options.CacheType,
 		CacheSize:   options.CacheSize,
@@ -1084,7 +1084,7 @@ func isValidBSIGroupType(v string) bool {
 	}
 }
 
-// bsiGroup represents a group of range-encoded rows on a frame.
+// bsiGroup represents a group of range-encoded rows on a field.
 type bsiGroup struct {
 	Name string `json:"name,omitempty"`
 	Type string `json:"type,omitempty"`
diff --git a/frame_internal_test.go b/field_internal_test.go
similarity index 100%
rename from frame_internal_test.go
rename to field_internal_test.go
diff --git a/frame_test.go b/field_test.go
similarity index 73%
rename from frame_test.go
rename to field_test.go
index 3964af785..10e4d9a97 100644
--- a/frame_test.go
+++ b/field_test.go
@@ -22,9 +22,9 @@ import (
 	"github.com/pilosa/pilosa/test"
 )
 
-// Ensure frame can open and retrieve a view.
-func TestFrame_CreateViewIfNotExists(t *testing.T) {
-	f := test.MustOpenFrame()
+// Ensure field can open and retrieve a view.
+func TestField_CreateViewIfNotExists(t *testing.T) {
+	f := test.MustOpenField()
 	defer f.Close()
 
 	// Create view.
@@ -48,12 +48,12 @@ func TestFrame_CreateViewIfNotExists(t *testing.T) {
 	}
 }
 
-// Ensure frame can set its time quantum.
-func TestFrame_SetTimeQuantum(t *testing.T) {
-	fo := pilosa.FrameOptions{
+// Ensure field can set its time quantum.
+func TestField_SetTimeQuantum(t *testing.T) {
+	fo := pilosa.FieldOptions{
 		Type: "time",
 	}
-	f := test.MustOpenFrame(pilosa.OptFrameFrameOptions(fo))
+	f := test.MustOpenField(pilosa.OptFieldFieldOptions(fo))
 	defer f.Close()
 
 	// Set & retrieve time quantum.
@@ -63,7 +63,7 @@ func TestFrame_SetTimeQuantum(t *testing.T) {
 		t.Fatalf("unexpected quantum: %s", q)
 	}
 
-	// Reload frame and verify that it is persisted.
+	// Reload field and verify that it is persisted.
 	if err := f.Reopen(); err != nil {
 		t.Fatal(err)
 	} else if q := f.TimeQuantum(); q != pilosa.TimeQuantum("YMDH") {
@@ -71,14 +71,14 @@ func TestFrame_SetTimeQuantum(t *testing.T) {
 	}
 }
 
-// Ensure a frame can set & read a bsiGroup value.
-func TestFrame_SetValue(t *testing.T) {
+// Ensure a field can set & read a bsiGroup value.
+func TestField_SetValue(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
-		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		f, err := idx.CreateField("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  0,
 			Max:  30,
 		})
@@ -86,7 +86,7 @@ func TestFrame_SetValue(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		// Set value on frame.
+		// Set value on field.
 		if changed, err := f.SetValue(100, 21); err != nil {
 			t.Fatal(err)
 		} else if !changed {
@@ -114,8 +114,8 @@ func TestFrame_SetValue(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
-		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		f, err := idx.CreateField("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  0,
 			Max:  30,
 		})
@@ -151,8 +151,8 @@ func TestFrame_SetValue(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
-		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeSet,
+		f, err := idx.CreateField("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeSet,
 		})
 		if err != nil {
 			t.Fatal(err)
@@ -168,8 +168,8 @@ func TestFrame_SetValue(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
-		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		f, err := idx.CreateField("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  20,
 			Max:  30,
 		})
@@ -187,8 +187,8 @@ func TestFrame_SetValue(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
-		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
+		f, err := idx.CreateField("f", pilosa.FieldOptions{
+			Type: pilosa.FieldTypeInt,
 			Min:  20,
 			Max:  30,
 		})
@@ -203,27 +203,27 @@ func TestFrame_SetValue(t *testing.T) {
 	})
 }
 
-func TestFrame_NameRestriction(t *testing.T) {
-	path, err := ioutil.TempDir("", "pilosa-frame-")
+func TestField_NameRestriction(t *testing.T) {
+	path, err := ioutil.TempDir("", "pilosa-field-")
 	if err != nil {
 		panic(err)
 	}
-	frame, err := pilosa.NewFrame(path, "i", ".meta")
-	if frame != nil {
-		t.Fatalf("unexpected frame name %s", err)
+	field, err := pilosa.NewField(path, "i", ".meta")
+	if field != nil {
+		t.Fatalf("unexpected field name %s", err)
 	}
 }
 
-// Ensure that frame name validation is consistent.
-func TestFrame_NameValidation(t *testing.T) {
-	validFrameNames := []string{
+// Ensure that field name validation is consistent.
+func TestField_NameValidation(t *testing.T) {
+	validFieldNames := []string{
 		"foo",
 		"hyphen-ated",
 		"under_score",
 		"abc123",
 		"trailing_",
 	}
-	invalidFrameNames := []string{
+	invalidFieldNames := []string{
 		"",
 		"123abc",
 		"x.y",
@@ -235,27 +235,27 @@ func TestFrame_NameValidation(t *testing.T) {
 		"a12345678901234567890123456789012345678901234567890123456789012345",
 	}
 
-	path, err := ioutil.TempDir("", "pilosa-frame-")
+	path, err := ioutil.TempDir("", "pilosa-field-")
 	if err != nil {
 		panic(err)
 	}
-	for _, name := range validFrameNames {
-		_, err := pilosa.NewFrame(path, "i", name)
+	for _, name := range validFieldNames {
+		_, err := pilosa.NewField(path, "i", name)
 		if err != nil {
-			t.Fatalf("unexpected frame name: %s %s", name, err)
+			t.Fatalf("unexpected field name: %s %s", name, err)
 		}
 	}
-	for _, name := range invalidFrameNames {
-		_, err := pilosa.NewFrame(path, "i", name)
+	for _, name := range invalidFieldNames {
+		_, err := pilosa.NewField(path, "i", name)
 		if err == nil {
-			t.Fatalf("expected error on frame name: %s", name)
+			t.Fatalf("expected error on field name: %s", name)
 		}
 	}
 }
 
-// Ensure frame can open and retrieve a view.
-func TestFrame_DeleteView(t *testing.T) {
-	f := test.MustOpenFrame()
+// Ensure field can open and retrieve a view.
+func TestField_DeleteView(t *testing.T) {
+	f := test.MustOpenField()
 	defer f.Close()
 
 	viewName := pilosa.ViewStandard + "_v"
@@ -274,7 +274,7 @@ func TestFrame_DeleteView(t *testing.T) {
 	}
 
 	if f.View(viewName) != nil {
-		t.Fatal("view still exists in frame")
+		t.Fatal("view still exists in field")
 	}
 
 	// Recreate view with same name, verify that the old view was not reused.
diff --git a/fragment.go b/fragment.go
index dd0f05ed2..1dfa9d09f 100644
--- a/fragment.go
+++ b/fragment.go
@@ -66,13 +66,13 @@ const (
 	DefaultFragmentMaxOpN = 2000
 )
 
-// Fragment represents the intersection of a frame and slice in an index.
+// Fragment represents the intersection of a field and slice in an index.
 type Fragment struct {
 	mu sync.RWMutex
 
 	// Composite identifiers
 	index string
-	frame string
+	field string
 	view  string
 	slice uint64
 
@@ -84,7 +84,7 @@ type Fragment struct {
 	opN         int // number of ops since snapshot
 
 	// Cache for row counts.
-	CacheType string // passed in by frame
+	CacheType string // passed in by field
 	cache     Cache
 	CacheSize uint32
 
@@ -106,18 +106,18 @@ type Fragment struct {
 	Logger Logger
 
 	// Row attribute storage.
-	// This is set by the parent frame unless overridden for testing.
+	// This is set by the parent field unless overridden for testing.
 	RowAttrStore AttrStore
 
 	stats StatsClient
 }
 
 // NewFragment returns a new instance of Fragment.
-func NewFragment(path, index, frame, view string, slice uint64) *Fragment {
+func NewFragment(path, index, field, view string, slice uint64) *Fragment {
 	return &Fragment{
 		path:      path,
 		index:     index,
-		frame:     frame,
+		field:     field,
 		view:      view,
 		slice:     slice,
 		CacheType: DefaultCacheType,
@@ -139,8 +139,8 @@ func (f *Fragment) CachePath() string { return f.path + CacheExt }
 // Index returns the index that the fragment was initialized with.
 func (f *Fragment) Index() string { return f.index }
 
-// Frame returns the frame the fragment was initialized with.
-func (f *Fragment) Frame() string { return f.frame }
+// Field returns the field the fragment was initialized with.
+func (f *Fragment) Field() string { return f.field }
 
 // View returns the view the fragment was initialized with.
 func (f *Fragment) View() string { return f.view }
@@ -247,7 +247,7 @@ func (f *Fragment) openStorage() error {
 
 // openCache initializes the cache from row ids persisted to disk.
 func (f *Fragment) openCache() error {
-	// Determine cache type from frame name.
+	// Determine cache type from field name.
 	switch f.CacheType {
 	case CacheTypeRanked:
 		f.cache = NewRankCache(f.CacheSize)
@@ -1452,8 +1452,8 @@ func track(start time.Time, message string, stats StatsClient, logger Logger) {
 }
 
 func (f *Fragment) snapshot() error {
-	f.Logger.Printf("fragment: snapshotting %s/%s/%s/%d", f.index, f.frame, f.view, f.slice)
-	completeMessage := fmt.Sprintf("fragment: snapshot complete %s/%s/%s/%d", f.index, f.frame, f.view, f.slice)
+	f.Logger.Printf("fragment: snapshotting %s/%s/%s/%d", f.index, f.field, f.view, f.slice)
+	completeMessage := fmt.Sprintf("fragment: snapshot complete %s/%s/%s/%d", f.index, f.field, f.view, f.slice)
 	start := time.Now()
 	defer track(start, completeMessage, f.stats, f.Logger)
 
@@ -1783,7 +1783,7 @@ func (s *FragmentSyncer) SyncFragment() error {
 
 		// Retrieve remote blocks.
 		client := NewInternalHTTPClientFromURI(&node.URI, s.RemoteClient)
-		blocks, err := client.FragmentBlocks(context.Background(), s.Fragment.Index(), s.Fragment.Frame(), s.Fragment.Slice())
+		blocks, err := client.FragmentBlocks(context.Background(), s.Fragment.Index(), s.Fragment.Field(), s.Fragment.Slice())
 		if err != nil && err != ErrFragmentNotFound {
 			return errors.Wrap(err, "getting blocks")
 		}
@@ -1862,7 +1862,7 @@ func (s *FragmentSyncer) syncBlock(id int) error {
 		clients = append(clients, client)
 
 		// Only sync the standard block.
-		rowIDs, columnIDs, err := client.BlockData(context.Background(), f.Index(), f.Frame(), f.Slice(), id)
+		rowIDs, columnIDs, err := client.BlockData(context.Background(), f.Index(), f.Field(), f.Slice(), id)
 		if err != nil {
 			return errors.Wrap(err, "getting block")
 		}
@@ -1904,11 +1904,11 @@ func (s *FragmentSyncer) syncBlock(id int) error {
 
 		// Only sync the standard block.
 		for j := 0; j < len(set.ColumnIDs); j++ {
-			fmt.Fprintf(&(buffers[count/maxWrites]), "SetBit(frame=%q, row=%d, col=%d)\n", f.Frame(), set.RowIDs[j], (f.Slice()*SliceWidth)+set.ColumnIDs[j])
+			fmt.Fprintf(&(buffers[count/maxWrites]), "SetBit(field=%q, row=%d, col=%d)\n", f.Field(), set.RowIDs[j], (f.Slice()*SliceWidth)+set.ColumnIDs[j])
 			count++
 		}
 		for j := 0; j < len(clear.ColumnIDs); j++ {
-			fmt.Fprintf(&(buffers[count/maxWrites]), "ClearBit(frame=%q, row=%d, col=%d)\n", f.Frame(), clear.RowIDs[j], (f.Slice()*SliceWidth)+clear.ColumnIDs[j])
+			fmt.Fprintf(&(buffers[count/maxWrites]), "ClearBit(field=%q, row=%d, col=%d)\n", f.Field(), clear.RowIDs[j], (f.Slice()*SliceWidth)+clear.ColumnIDs[j])
 			count++
 		}
 
diff --git a/fragment_test.go b/fragment_test.go
index b72450fbb..747602348 100644
--- a/fragment_test.go
+++ b/fragment_test.go
@@ -753,14 +753,14 @@ func TestFragment_TopN_CacheSize(t *testing.T) {
 	index := test.MustOpenIndex()
 	defer index.Close()
 
-	// Create frame.
-	frame, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{CacheType: pilosa.CacheTypeRanked, CacheSize: cacheSize})
+	// Create field.
+	field, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{CacheType: pilosa.CacheTypeRanked, CacheSize: cacheSize})
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Create view.
-	view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard)
+	view, err := field.CreateViewIfNotExists(pilosa.ViewStandard)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -923,14 +923,14 @@ func TestFragment_RankCache_Persistence(t *testing.T) {
 	index := test.MustOpenIndex()
 	defer index.Close()
 
-	// Create frame.
-	frame, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{CacheType: pilosa.CacheTypeRanked})
+	// Create field.
+	field, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{CacheType: pilosa.CacheTypeRanked})
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Create view.
-	view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard)
+	view, err := field.CreateViewIfNotExists(pilosa.ViewStandard)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -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 {
diff --git a/handler.go b/handler.go
index d4ed5ab37..083d40279 100644
--- a/handler.go
+++ b/handler.go
@@ -62,7 +62,7 @@ var externalPrefixFlag = map[string]bool{
 	"import":  true,
 	"export":  true,
 	"index":   true,
-	"frame":   true,
+	"field":   true,
 	"nodes":   true,
 	"version": true,
 }
@@ -108,10 +108,10 @@ func (h *Handler) populateValidators() {
 	h.validators["GetFragmentNodes"] = queryValidationSpecRequired("slice", "index")
 	h.validators["GetSliceMax"] = queryValidationSpecRequired()
 	h.validators["PostQuery"] = queryValidationSpecRequired().Optional("slices", "columnAttrs", "excludeRowAttrs", "excludeColumns")
-	h.validators["GetExport"] = queryValidationSpecRequired("index", "frame", "slice")
-	h.validators["GetFragmentData"] = queryValidationSpecRequired("index", "frame", "slice")
-	h.validators["PostFragmentData"] = queryValidationSpecRequired("index", "frame", "slice")
-	h.validators["GetFragmentBlocks"] = queryValidationSpecRequired("index", "frame", "slice")
+	h.validators["GetExport"] = queryValidationSpecRequired("index", "field", "slice")
+	h.validators["GetFragmentData"] = queryValidationSpecRequired("index", "field", "slice")
+	h.validators["PostFragmentData"] = queryValidationSpecRequired("index", "field", "slice")
+	h.validators["GetFragmentBlocks"] = queryValidationSpecRequired("index", "field", "slice")
 }
 
 func (h *Handler) queryArgValidator(next http.Handler) http.Handler {
@@ -165,10 +165,10 @@ func NewRouter(handler *Handler) *mux.Router {
 	router.HandleFunc("/index/{index}", handler.handlePostIndex).Methods("POST")
 	router.HandleFunc("/index/{index}", handler.handleDeleteIndex).Methods("DELETE")
 	router.HandleFunc("/index/{index}/attr/diff", handler.handlePostIndexAttrDiff).Methods("POST")
-	//router.HandleFunc("/index/{index}/frame", handler.handleGetFrames).Methods("GET") // Not implemented.
-	router.HandleFunc("/index/{index}/frame/{frame}", handler.handlePostFrame).Methods("POST")
-	router.HandleFunc("/index/{index}/frame/{frame}", handler.handleDeleteFrame).Methods("DELETE")
-	router.HandleFunc("/index/{index}/frame/{frame}/attr/diff", handler.handlePostFrameAttrDiff).Methods("POST")
+	//router.HandleFunc("/index/{index}/field", handler.handleGetFields).Methods("GET") // Not implemented.
+	router.HandleFunc("/index/{index}/field/{field}", handler.handlePostField).Methods("POST")
+	router.HandleFunc("/index/{index}/field/{field}", handler.handleDeleteField).Methods("DELETE")
+	router.HandleFunc("/index/{index}/field/{field}/attr/diff", handler.handlePostFieldAttrDiff).Methods("POST")
 	router.HandleFunc("/index/{index}/query", handler.handlePostQuery).Methods("POST").Name("PostQuery")
 	router.HandleFunc("/recalculate-caches", handler.handleRecalculateCaches).Methods("POST")
 
@@ -502,27 +502,27 @@ type postIndexAttrDiffResponse struct {
 	Attrs map[uint64]map[string]interface{} `json:"attrs"`
 }
 
-// handlePostFrame handles POST /frame request.
-func (h *Handler) handlePostFrame(w http.ResponseWriter, r *http.Request) {
+// handlePostField handles POST /field request.
+func (h *Handler) handlePostField(w http.ResponseWriter, r *http.Request) {
 	indexName := mux.Vars(r)["index"]
-	frameName := mux.Vars(r)["frame"]
+	fieldName := mux.Vars(r)["field"]
 
 	// Decode request.
-	var req postFrameRequest
+	var req postFieldRequest
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err == io.EOF {
-		// If no data was provided (EOF), we still create the frame
+		// If no data was provided (EOF), we still create the field
 		// with default values.
 	} else if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	_, err = h.API.CreateFrame(r.Context(), indexName, frameName, req.Options)
+	_, err = h.API.CreateField(r.Context(), indexName, fieldName, req.Options)
 	if err != nil {
 		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)
@@ -530,30 +530,30 @@ func (h *Handler) handlePostFrame(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// Encode response.
-	if err := json.NewEncoder(w).Encode(postFrameResponse{}); err != nil {
+	if err := json.NewEncoder(w).Encode(postFieldResponse{}); err != nil {
 		h.Logger.Printf("response encoding error: %s", err)
 	}
 }
 
-type _postFrameRequest postFrameRequest
+type _postFieldRequest postFieldRequest
 
-// Custom Unmarshal JSON to validate request body when creating a new frame. If there's new FrameOptions,
-// adding it to validFrameOptions to make sure the new option is validated, otherwise the request will be failed
-func (p *postFrameRequest) UnmarshalJSON(b []byte) error {
+// Custom Unmarshal JSON to validate request body when creating a new field. If there's new FieldOptions,
+// adding it to validFieldOptions to make sure the new option is validated, otherwise the request will be failed
+func (p *postFieldRequest) UnmarshalJSON(b []byte) error {
 	// m is an overflow map used to capture additional, unexpected keys.
 	m := make(map[string]interface{})
 	if err := json.Unmarshal(b, &m); err != nil {
 		return errors.Wrap(err, "unmarshaling unexpected keys")
 	}
 
-	validFrameOptions := getValidOptions(FrameOptions{})
-	err := validateOptions(m, validFrameOptions)
+	validFieldOptions := getValidOptions(FieldOptions{})
+	err := validateOptions(m, validFieldOptions)
 	if err != nil {
 		return err
 	}
 
 	// Unmarshal expected values.
-	var _p _postFrameRequest
+	var _p _postFieldRequest
 	if err := json.Unmarshal(b, &_p); err != nil {
 		return errors.Wrap(err, "unmarshalling expected keys")
 	}
@@ -574,18 +574,18 @@ func getValidOptions(option interface{}) []string {
 	return validOptions
 }
 
-type postFrameRequest struct {
-	Options FrameOptions `json:"options"`
+type postFieldRequest struct {
+	Options FieldOptions `json:"options"`
 }
 
-type postFrameResponse struct{}
+type postFieldResponse struct{}
 
-// handleDeleteFrame handles DELETE /frame request.
-func (h *Handler) handleDeleteFrame(w http.ResponseWriter, r *http.Request) {
+// handleDeleteField handles DELETE /field request.
+func (h *Handler) handleDeleteField(w http.ResponseWriter, r *http.Request) {
 	indexName := mux.Vars(r)["index"]
-	frameName := mux.Vars(r)["frame"]
+	fieldName := mux.Vars(r)["field"]
 
-	err := h.API.DeleteFrame(r.Context(), indexName, frameName)
+	err := h.API.DeleteField(r.Context(), indexName, fieldName)
 	if err != nil {
 		if errors.Cause(err) == ErrIndexNotFound {
 			if err := json.NewEncoder(w).Encode(deleteIndexResponse{}); err != nil {
@@ -598,26 +598,26 @@ func (h *Handler) handleDeleteFrame(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Encode response.
-	if err := json.NewEncoder(w).Encode(deleteFrameResponse{}); err != nil {
+	if err := json.NewEncoder(w).Encode(deleteFieldResponse{}); err != nil {
 		h.Logger.Printf("response encoding error: %s", err)
 	}
 }
 
-type deleteFrameResponse struct{}
+type deleteFieldResponse struct{}
 
-// handlePostFrameAttrDiff handles POST /frame/attr/diff requests.
-func (h *Handler) handlePostFrameAttrDiff(w http.ResponseWriter, r *http.Request) {
+// handlePostFieldAttrDiff handles POST /field/attr/diff requests.
+func (h *Handler) handlePostFieldAttrDiff(w http.ResponseWriter, r *http.Request) {
 	indexName := mux.Vars(r)["index"]
-	frameName := mux.Vars(r)["frame"]
+	fieldName := mux.Vars(r)["field"]
 
 	// Decode request.
-	var req postFrameAttrDiffRequest
+	var req postFieldAttrDiffRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
-	attrs, err := h.API.FrameAttrDiff(r.Context(), indexName, frameName, req.Blocks)
+	attrs, err := h.API.FieldAttrDiff(r.Context(), indexName, fieldName, req.Blocks)
 	if err != nil {
 		switch errors.Cause(err) {
 		case ErrFragmentNotFound:
@@ -629,18 +629,18 @@ func (h *Handler) handlePostFrameAttrDiff(w http.ResponseWriter, r *http.Request
 	}
 
 	// Encode response.
-	if err := json.NewEncoder(w).Encode(postFrameAttrDiffResponse{
+	if err := json.NewEncoder(w).Encode(postFieldAttrDiffResponse{
 		Attrs: attrs,
 	}); err != nil {
 		h.Logger.Printf("response encoding error: %s", err)
 	}
 }
 
-type postFrameAttrDiffRequest struct {
+type postFieldAttrDiffRequest struct {
 	Blocks []AttrBlock `json:"blocks"`
 }
 
-type postFrameAttrDiffResponse struct {
+type postFieldAttrDiffResponse struct {
 	Attrs map[uint64]map[string]interface{} `json:"attrs"`
 }
 
@@ -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)
@@ -839,7 +839,7 @@ func (h *Handler) handleGetExport(w http.ResponseWriter, r *http.Request) {
 func (h *Handler) handleGetExportCSV(w http.ResponseWriter, r *http.Request) {
 	// Parse query parameters.
 	q := r.URL.Query()
-	index, frame := q.Get("index"), q.Get("frame")
+	index, field := q.Get("index"), q.Get("field")
 
 	slice, err := strconv.ParseUint(q.Get("slice"), 10, 64)
 	if err != nil {
@@ -847,7 +847,7 @@ func (h *Handler) handleGetExportCSV(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if err = h.API.ExportCSV(r.Context(), index, frame, slice, w); err != nil {
+	if err = h.API.ExportCSV(r.Context(), index, field, slice, w); err != nil {
 		switch errors.Cause(err) {
 		case ErrFragmentNotFound:
 			break
@@ -915,7 +915,7 @@ func (h *Handler) handleGetFragmentBlocks(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	blocks, err := h.API.FragmentBlocks(r.Context(), q.Get("index"), q.Get("frame"), slice)
+	blocks, err := h.API.FragmentBlocks(r.Context(), q.Get("index"), q.Get("field"), slice)
 	if err != nil {
 		if errors.Cause(err) == ErrFragmentNotFound {
 			http.Error(w, err.Error(), http.StatusNotFound)
diff --git a/handler_internal_test.go b/handler_internal_test.go
index ceaeb707c..837c456ca 100644
--- a/handler_internal_test.go
+++ b/handler_internal_test.go
@@ -55,23 +55,23 @@ func TestPostIndexRequestUnmarshalJSON(t *testing.T) {
 	}
 }
 
-// Test custom UnmarshalJSON for postFrameRequest object
-func TestPostFrameRequestUnmarshalJSON(t *testing.T) {
+// Test custom UnmarshalJSON for postFieldRequest object
+func TestPostFieldRequestUnmarshalJSON(t *testing.T) {
 	tests := []struct {
 		json     string
-		expected postFrameRequest
+		expected postFieldRequest
 		err      string
 	}{
-		{json: `{"options": {}}`, expected: postFrameRequest{Options: FrameOptions{}}},
+		{json: `{"options": {}}`, expected: postFieldRequest{Options: FieldOptions{}}},
 		{json: `{"options": 4}`, err: "options is not map[string]interface{}"},
 		{json: `{"option": {}}`, err: "Unknown key: option:map[]"},
 		{json: `{"options": {"badKey": "test"}}`, err: "Unknown key: badKey:test"},
 		{json: `{"options": {"inverseEnabled": true}}`, err: "Unknown key: inverseEnabled:true"},
-		{json: `{"options": {"cacheType": "type"}}`, expected: postFrameRequest{Options: FrameOptions{CacheType: "type"}}},
+		{json: `{"options": {"cacheType": "type"}}`, expected: postFieldRequest{Options: FieldOptions{CacheType: "type"}}},
 		{json: `{"options": {"inverse": true, "cacheType": "type"}}`, err: "Unknown key: inverse:true"},
 	}
 	for _, test := range tests {
-		actual := &postFrameRequest{}
+		actual := &postFieldRequest{}
 		err := json.Unmarshal([]byte(test.json), actual)
 		if err != nil {
 			if test.err == "" || test.err != err.Error() {
diff --git a/handler_test.go b/handler_test.go
index 30bba9254..036512de4 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -83,17 +83,17 @@ func TestHandler_Schema(t *testing.T) {
 	i0 := hldr.MustCreateIndexIfNotExists("i0", pilosa.IndexOptions{})
 	i1 := hldr.MustCreateIndexIfNotExists("i1", pilosa.IndexOptions{})
 
-	if f, err := i0.CreateFrameIfNotExists("f1", pilosa.FrameOptions{}); err != nil {
+	if f, err := i0.CreateFieldIfNotExists("f1", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if _, err := f.SetBit(pilosa.ViewStandard, 0, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if f, err := i1.CreateFrameIfNotExists("f0", pilosa.FrameOptions{}); err != nil {
+	if f, err := i1.CreateFieldIfNotExists("f0", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if _, err := f.SetBit(pilosa.ViewStandard, 0, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := i0.CreateFrameIfNotExists("f0", pilosa.FrameOptions{}); err != nil {
+	if _, err := i0.CreateFieldIfNotExists("f0", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -104,8 +104,8 @@ func TestHandler_Schema(t *testing.T) {
 	h.ServeHTTP(w, test.MustNewHTTPRequest("GET", "/schema", nil))
 	if w.Code != http.StatusOK {
 		t.Fatalf("unexpected status code: %d", w.Code)
-	} else if body := w.Body.String(); body != `{"indexes":[{"name":"i0","frames":[{"name":"f0"},{"name":"f1","views":[{"name":"standard"}]}]},{"name":"i1","frames":[{"name":"f0","views":[{"name":"standard"}]}]}]}`+"\n" {
-	} else if body := w.Body.String(); body != `{"indexes":[{"name":"i0","frames":[{"name":"f0","options":{"cacheType":"ranked","cacheSize":50000}},{"name":"f1","options":{"cacheType":"ranked","cacheSize":50000},"views":[{"name":"standard"}]}]},{"name":"i1","frames":[{"name":"f0","options":{"cacheType":"ranked","cacheSize":50000},"views":[{"name":"standard"}]}]}]}`+"\n" {
+	} else if body := w.Body.String(); body != `{"indexes":[{"name":"i0","fields":[{"name":"f0"},{"name":"f1","views":[{"name":"standard"}]}]},{"name":"i1","fields":[{"name":"f0","views":[{"name":"standard"}]}]}]}`+"\n" {
+	} else if body := w.Body.String(); body != `{"indexes":[{"name":"i0","fields":[{"name":"f0","options":{"cacheType":"ranked","cacheSize":50000}},{"name":"f1","options":{"cacheType":"ranked","cacheSize":50000},"views":[{"name":"standard"}]}]},{"name":"i1","fields":[{"name":"f0","options":{"cacheType":"ranked","cacheSize":50000},"views":[{"name":"standard"}]}]}]}`+"\n" {
 		t.Fatalf("unexpected body: %s", body)
 	}
 }
@@ -120,17 +120,17 @@ func TestHandler_Status(t *testing.T) {
 	i0 := hldr.MustCreateIndexIfNotExists("i0", pilosa.IndexOptions{})
 	i1 := hldr.MustCreateIndexIfNotExists("i1", pilosa.IndexOptions{})
 
-	if f, err := i0.CreateFrameIfNotExists("f1", pilosa.FrameOptions{}); err != nil {
+	if f, err := i0.CreateFieldIfNotExists("f1", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if _, err := f.SetBit(pilosa.ViewStandard, 0, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if f, err := i1.CreateFrameIfNotExists("f0", pilosa.FrameOptions{}); err != nil {
+	if f, err := i1.CreateFieldIfNotExists("f0", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if _, err := f.SetBit(pilosa.ViewStandard, 0, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := i0.CreateFrameIfNotExists("f0", pilosa.FrameOptions{}); err != nil {
+	if _, err := i0.CreateFieldIfNotExists("f0", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -536,7 +536,7 @@ func TestHandler_Query_Pairs_JSON(t *testing.T) {
 	}
 
 	w := httptest.NewRecorder()
-	h.ServeHTTP(w, test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(frame=x, n=2)`)))
+	h.ServeHTTP(w, test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(field=x, n=2)`)))
 	if w.Code != http.StatusOK {
 		t.Fatalf("unexpected status code: %d", w.Code)
 	} else if body := w.Body.String(); body != `{"results":[[{"id":1,"count":2},{"id":3,"count":4}]]}`+"\n" {
@@ -560,7 +560,7 @@ func TestHandler_Query_Pairs_Protobuf(t *testing.T) {
 	}
 
 	w := httptest.NewRecorder()
-	r := test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(frame=x, n=2)`))
+	r := test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(field=x, n=2)`))
 	r.Header.Set("Accept", "application/x-protobuf")
 	h.ServeHTTP(w, r)
 	if w.Code != http.StatusOK {
@@ -611,7 +611,7 @@ func TestHandler_Query_Err_Protobuf(t *testing.T) {
 	}
 
 	w := httptest.NewRecorder()
-	r := test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(frame=x, n=2)`))
+	r := test.MustNewHTTPRequest("POST", "/index/i/query", strings.NewReader(`TopN(field=x, n=2)`))
 	r.Header.Set("Accept", "application/x-protobuf")
 	h.ServeHTTP(w, r)
 	if w.Code != http.StatusBadRequest {
@@ -694,12 +694,12 @@ func TestHandler_Index_Delete(t *testing.T) {
 	}
 }
 
-// Ensure handler can delete a frame.
-func TestHandler_DeleteFrame(t *testing.T) {
+// Ensure handler can delete a field.
+func TestHandler_DeleteField(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 	i0 := hldr.MustCreateIndexIfNotExists("i0", pilosa.IndexOptions{})
-	if _, err := i0.CreateFrameIfNotExists("f1", pilosa.FrameOptions{}); err != nil {
+	if _, err := i0.CreateFieldIfNotExists("f1", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -707,13 +707,13 @@ func TestHandler_DeleteFrame(t *testing.T) {
 	h.API.Holder = hldr.Holder
 	h.API.Cluster = test.NewCluster(1)
 	w := httptest.NewRecorder()
-	h.ServeHTTP(w, test.MustNewHTTPRequest("DELETE", "/index/i0/frame/f1", strings.NewReader("")))
+	h.ServeHTTP(w, test.MustNewHTTPRequest("DELETE", "/index/i0/field/f1", strings.NewReader("")))
 	if w.Code != http.StatusOK {
 		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 {
-		t.Fatal("expected nil frame")
+	} else if f := hldr.Index("i0").Field("f1"); f != nil {
+		t.Fatal("expected nil field")
 	}
 }
 
@@ -766,8 +766,8 @@ func TestHandler_Index_AttrStore_Diff(t *testing.T) {
 	}
 }
 
-// Ensure the handler can return data in differing blocks for a frame.
-func TestHandler_Frame_AttrStore_Diff(t *testing.T) {
+// Ensure the handler can return data in differing blocks for a field.
+func TestHandler_Field_AttrStore_Diff(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 
@@ -777,7 +777,7 @@ func TestHandler_Frame_AttrStore_Diff(t *testing.T) {
 
 	// Set attributes on the index.
 	idx := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	f, err := idx.CreateFrameIfNotExists("meta", pilosa.FrameOptions{})
+	f, err := idx.CreateFieldIfNotExists("meta", pilosa.FieldOptions{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -801,7 +801,7 @@ func TestHandler_Frame_AttrStore_Diff(t *testing.T) {
 
 	// Send block checksums to determine diff.
 	resp, err := http.Post(
-		s.URL+"/index/i/frame/meta/attr/diff",
+		s.URL+"/index/i/field/meta/attr/diff",
 		"application/json",
 		strings.NewReader(`{"blocks":`+string(test.MustMarshalJSON(blks))+`}`),
 	)
diff --git a/holder.go b/holder.go
index 6d13159b9..e8db140ce 100644
--- a/holder.go
+++ b/holder.go
@@ -209,20 +209,20 @@ func (h *Holder) MaxSlices() map[string]uint64 {
 	return a
 }
 
-// Schema returns schema information for all indexes, frames, and views.
+// Schema returns schema information for all indexes, fields, and views.
 func (h *Holder) Schema() []*IndexInfo {
 	var a []*IndexInfo
 	for _, index := range h.Indexes() {
 		di := &IndexInfo{Name: index.Name()}
-		for _, frame := range index.Frames() {
-			fi := &FrameInfo{Name: frame.Name(), Options: frame.Options()}
-			for _, view := range frame.Views() {
+		for _, field := range index.Fields() {
+			fi := &FieldInfo{Name: field.Name(), Options: field.Options()}
+			for _, view := range field.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(frameInfoSlice(di.Frames))
+		sort.Sort(fieldInfoSlice(di.Fields))
 		a = append(a, di)
 	}
 	sort.Sort(indexInfoSlice(a))
@@ -238,16 +238,16 @@ func (h *Holder) ApplySchema(schema *internal.Schema) error {
 		if err != nil {
 			return errors.Wrap(err, "creating index")
 		}
-		// Create frames that don't exist.
-		for _, f := range index.Frames {
-			opt := decodeFrameOptions(f.Meta)
-			frame, err := idx.CreateFrameIfNotExists(f.Name, *opt)
+		// Create fields that don't exist.
+		for _, f := range index.Fields {
+			opt := decodeFieldOptions(f.Meta)
+			field, err := idx.CreateFieldIfNotExists(f.Name, *opt)
 			if err != nil {
-				return errors.Wrap(err, "creating frame")
+				return errors.Wrap(err, "creating field")
 			}
 			// Create views that don't exist.
 			for _, v := range f.Views {
-				_, err := frame.CreateViewIfNotExists(v)
+				_, err := field.CreateViewIfNotExists(v)
 				if err != nil {
 					return errors.Wrap(err, "creating view")
 				}
@@ -390,27 +390,27 @@ func (h *Holder) DeleteIndex(name string) error {
 	return nil
 }
 
-// Frame returns the frame for an index and name.
-func (h *Holder) Frame(index, name string) *Frame {
+// Field returns the field for an index and name.
+func (h *Holder) Field(index, name string) *Field {
 	idx := h.Index(index)
 	if idx == nil {
 		return nil
 	}
-	return idx.Frame(name)
+	return idx.Field(name)
 }
 
-// View returns the view for an index, frame, and name.
-func (h *Holder) View(index, frame, name string) *View {
-	f := h.Frame(index, frame)
+// View returns the view for an index, field, and name.
+func (h *Holder) View(index, field, name string) *View {
+	f := h.Field(index, field)
 	if f == nil {
 		return nil
 	}
 	return f.View(name)
 }
 
-// Fragment returns the fragment for an index, frame & slice.
-func (h *Holder) Fragment(index, frame, view string, slice uint64) *Fragment {
-	v := h.View(index, frame, view)
+// Fragment returns the fragment for an index, field & slice.
+func (h *Holder) Fragment(index, field, view string, slice uint64) *Fragment {
+	v := h.View(index, field, view)
 	if v == nil {
 		return nil
 	}
@@ -435,8 +435,8 @@ func (h *Holder) monitorCacheFlush() {
 
 func (h *Holder) flushCaches() {
 	for _, index := range h.Indexes() {
-		for _, frame := range index.Frames() {
-			for _, view := range frame.Views() {
+		for _, field := range index.Fields() {
+			for _, view := range field.Views() {
 				for _, fragment := range view.Fragments() {
 					select {
 					case <-h.closing:
@@ -600,15 +600,15 @@ 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
 			}
 
-			// Sync frame row attributes.
-			if err := s.syncFrame(di.Name, fi.Name); err != nil {
-				return fmt.Errorf("frame sync error: index=%s, frame=%s, err=%s", di.Name, fi.Name, err)
+			// Sync field row attributes.
+			if err := s.syncField(di.Name, fi.Name); err != nil {
+				return fmt.Errorf("field sync error: index=%s, field=%s, err=%s", di.Name, fi.Name, err)
 			}
 
 			for _, vi := range fi.Views {
@@ -630,11 +630,11 @@ func (s *HolderSyncer) SyncHolder() error {
 
 					// Sync fragment if own it.
 					if err := s.syncFragment(di.Name, fi.Name, vi.Name, slice); err != nil {
-						return fmt.Errorf("fragment sync error: index=%s, frame=%s, slice=%d, err=%s", di.Name, fi.Name, slice, err)
+						return fmt.Errorf("fragment sync error: index=%s, field=%s, slice=%d, err=%s", di.Name, fi.Name, slice, err)
 					}
 				}
 			}
-			s.Stats.Histogram("syncFrame", float64(time.Since(tf)), 1.0)
+			s.Stats.Histogram("syncField", float64(time.Since(tf)), 1.0)
 			tf = time.Now() // reset tf
 		}
 		s.Stats.Histogram("syncIndex", float64(time.Since(ti)), 1.0)
@@ -689,22 +689,22 @@ func (s *HolderSyncer) syncIndex(index string) error {
 	return nil
 }
 
-// syncFrame synchronizes frame attributes with the rest of the cluster.
-func (s *HolderSyncer) syncFrame(index, name string) error {
-	// Retrieve frame reference.
-	f := s.Holder.Frame(index, name)
+// syncField synchronizes field attributes with the rest of the cluster.
+func (s *HolderSyncer) syncField(index, name string) error {
+	// Retrieve field reference.
+	f := s.Holder.Field(index, name)
 	if f == nil {
 		return nil
 	}
 	indexTag := fmt.Sprintf("index:%s", index)
-	frameTag := fmt.Sprintf("frame:%s", name)
+	fieldTag := fmt.Sprintf("field:%s", name)
 
 	// Read block checksums.
 	blks, err := f.RowAttrStore().Blocks()
 	if err != nil {
 		return errors.Wrap(err, "getting blocks")
 	}
-	s.Stats.CountWithCustomTags("RowAttrStoreBlocks", int64(len(blks)), 1.0, []string{indexTag, frameTag})
+	s.Stats.CountWithCustomTags("RowAttrStoreBlocks", int64(len(blks)), 1.0, []string{indexTag, fieldTag})
 
 	// Sync with every other host.
 	for _, node := range Nodes(s.Cluster.Nodes).FilterID(s.Node.ID) {
@@ -713,14 +713,14 @@ 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 {
-			continue // frame not created remotely yet, skip
+		if err == ErrFieldNotFound {
+			continue // field not created remotely yet, skip
 		} else if err != nil {
 			return errors.Wrap(err, "getting differing blocks")
 		} else if len(m) == 0 {
 			continue
 		}
-		s.Stats.CountWithCustomTags("RowAttrDiff", int64(len(m)), 1.0, []string{indexTag, frameTag, node.ID})
+		s.Stats.CountWithCustomTags("RowAttrDiff", int64(len(m)), 1.0, []string{indexTag, fieldTag, node.ID})
 
 		// Update local copy.
 		if err := f.RowAttrStore().SetBulkAttrs(m); err != nil {
@@ -738,11 +738,11 @@ func (s *HolderSyncer) syncFrame(index, name string) error {
 }
 
 // syncFragment synchronizes a fragment with the rest of the cluster.
-func (s *HolderSyncer) syncFragment(index, frame, view string, slice uint64) error {
-	// Retrieve local frame.
-	f := s.Holder.Frame(index, frame)
+func (s *HolderSyncer) syncFragment(index, field, view string, slice uint64) error {
+	// Retrieve local field.
+	f := s.Holder.Field(index, field)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Ensure view exists locally.
@@ -806,8 +806,8 @@ 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 _, view := range frame.Views() {
+		for _, field := range index.Fields() {
+			for _, view := range field.Views() {
 				for _, fragment := range view.Fragments() {
 					fragSlice := fragment.Slice()
 					// Ignore fragments that should be present.
diff --git a/holder_test.go b/holder_test.go
index c7877e3ba..5f41cfab7 100644
--- a/holder_test.go
+++ b/holder_test.go
@@ -91,7 +91,7 @@ func TestHolder_Open(t *testing.T) {
 		}
 	})
 
-	t.Run("ErrFramePermission", func(t *testing.T) {
+	t.Run("ErrFieldPermission", func(t *testing.T) {
 		if os.Geteuid() == 0 {
 			t.Skip("Skipping permissions test since user is root.")
 		}
@@ -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.FrameOptions{}); 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)
@@ -113,13 +113,13 @@ func TestHolder_Open(t *testing.T) {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
-	t.Run("ErrFrameMetaCorrupt", func(t *testing.T) {
+	t.Run("ErrFieldOptionsCorrupt", func(t *testing.T) {
 		h := test.MustOpenHolder()
 		defer h.Close()
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := idx.CreateFrame("bar", pilosa.FrameOptions{}); 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)
@@ -127,17 +127,17 @@ func TestHolder_Open(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if err := h.Reopen(); err == nil || !strings.Contains(err.Error(), "open index: name=foo, err=opening frames: open frame: name=bar, err=loading meta: unmarshaling: unexpected EOF") {
+		if err := h.Reopen(); err == nil || !strings.Contains(err.Error(), "open index: name=foo, err=opening fields: open field: name=bar, err=loading meta: unmarshaling: unexpected EOF") {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
-	t.Run("ErrFrameAttrStoreCorrupt", func(t *testing.T) {
+	t.Run("ErrFieldAttrStoreCorrupt", func(t *testing.T) {
 		h := test.MustOpenHolder()
 		defer h.Close()
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := idx.CreateFrame("bar", pilosa.FrameOptions{}); 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)
@@ -145,7 +145,7 @@ func TestHolder_Open(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if err := h.Reopen(); err == nil || !strings.Contains(err.Error(), "open index: name=foo, err=opening frames: open frame: name=bar, err=opening attrstore: opening storage: invalid database") {
+		if err := h.Reopen(); err == nil || !strings.Contains(err.Error(), "open index: name=foo, err=opening fields: open field: name=bar, err=opening attrstore: opening storage: invalid database") {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
@@ -159,9 +159,9 @@ 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.FrameOptions{}); err != nil {
+		} else if field, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
+		} else if _, err := field.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
 		} else if err := h.Holder.Close(); err != nil {
 			t.Fatal(err)
@@ -183,9 +183,9 @@ 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.FrameOptions{}); err != nil {
+		} else if field, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
+		} else if _, err := field.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
 		} else if err := h.Holder.Close(); err != nil {
 			t.Fatal(err)
@@ -208,9 +208,9 @@ 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.FrameOptions{}); err != nil {
+		} else if field, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
-		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
+		} else if view, err := field.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
 		} else if _, err := view.SetBit(0, 0); err != nil {
 			t.Fatal(err)
@@ -231,9 +231,9 @@ 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.FrameOptions{}); err != nil {
+		} else if field, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
-		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
+		} else if view, err := field.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
 		} else if _, err := view.SetBit(0, 0); err != nil {
 			t.Fatal(err)
@@ -257,9 +257,9 @@ 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.FrameOptions{}); err != nil {
+		} else if field, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
-		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
+		} else if view, err := field.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
 		} else if _, err := view.SetBit(0, 0); err != nil {
 			t.Fatal(err)
@@ -391,11 +391,11 @@ func TestHolderSyncer_SyncHolder(t *testing.T) {
 	cluster.Nodes[0].URI = test.NewURIFromHostPort("localhost", 0)
 	cluster.Nodes[1].URI = *uri
 
-	// Create frames on nodes.
+	// Create fields on nodes.
 	for _, hldr := range []*test.Holder{hldr0, hldr1} {
-		hldr.MustCreateFrameIfNotExists("i", "f")
-		hldr.MustCreateFrameIfNotExists("i", "f0")
-		hldr.MustCreateFrameIfNotExists("y", "z")
+		hldr.MustCreateFieldIfNotExists("i", "f")
+		hldr.MustCreateFieldIfNotExists("i", "f0")
+		hldr.MustCreateFieldIfNotExists("y", "z")
 	}
 
 	// Set data on the local holder.
@@ -496,11 +496,11 @@ func TestHolderCleaner_CleanHolder(t *testing.T) {
 
 	cluster.Nodes[0].URI = test.NewURIFromHostPort("localhost", 0)
 
-	// Create frames on nodes.
+	// Create fields on nodes.
 	for _, hldr := range []*test.Holder{hldr0} {
-		hldr.MustCreateFrameIfNotExists("i", "f")
-		hldr.MustCreateFrameIfNotExists("i", "f0")
-		hldr.MustCreateFrameIfNotExists("y", "z")
+		hldr.MustCreateFieldIfNotExists("i", "f")
+		hldr.MustCreateFieldIfNotExists("i", "f0")
+		hldr.MustCreateFieldIfNotExists("y", "z")
 	}
 
 	// Set data on the local holder.
diff --git a/index.go b/index.go
index 7829903aa..80a5c2eb8 100644
--- a/index.go
+++ b/index.go
@@ -28,14 +28,14 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Index represents a container for frames.
+// Index represents a container for fields.
 type Index struct {
 	mu   sync.RWMutex
 	path string
 	name string
 
-	// Frames by name.
-	frames map[string]*Frame
+	// 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]*Frame),
+		fields: make(map[string]*Field),
 
 		remoteMaxSlice: 0,
 
@@ -106,8 +106,8 @@ func (i *Index) Open() error {
 		return errors.Wrap(err, "loading meta file")
 	}
 
-	if err := i.openFrames(); err != nil {
-		return errors.Wrap(err, "opening frames")
+	if err := i.openFields(); err != nil {
+		return errors.Wrap(err, "opening fields")
 	}
 
 	if err := i.columnAttrStore.Open(); err != nil {
@@ -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 fields 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 field: name=%s, err=%s", fld.Name(), err)
 		}
-		i.frames[fr.Name()] = fr
+		i.fields[fld.Name()] = fld
 	}
 	return nil
 }
@@ -189,7 +189,7 @@ func (i *Index) saveMeta() error {
 }
 */
 
-// Close closes the index and its frames.
+// Close closes the index and its fields.
 func (i *Index) Close() error {
 	i.mu.Lock()
 	defer i.mu.Unlock()
@@ -197,13 +197,13 @@ func (i *Index) Close() error {
 	// Close the attribute store.
 	i.columnAttrStore.Close()
 
-	// Close all frames.
-	for _, f := range i.frames {
+	// Close all fields.
+	for _, f := range i.fields {
 		if err := f.Close(); err != nil {
-			return errors.Wrap(err, "closing frame")
+			return errors.Wrap(err, "closing field")
 		}
 	}
-	i.frames = make(map[string]*Frame)
+	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,67 +234,67 @@ 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) *Frame {
+// Field returns a field 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) *Frame { 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() []*Frame {
+// Fields returns a list of all fields in the index.
+func (i *Index) Fields() []*Field {
 	i.mu.RLock()
 	defer i.mu.RUnlock()
 
-	a := make([]*Frame, 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(frameSlice(a))
+	sort.Sort(fieldSlice(a))
 
 	return a
 }
 
-// RecalculateCaches recalculates caches on every frame in the index.
+// RecalculateCaches recalculates caches on every field in the index.
 func (i *Index) RecalculateCaches() {
-	for _, frame := range i.Frames() {
-		frame.RecalculateCaches()
+	for _, field := range i.Fields() {
+		field.RecalculateCaches()
 	}
 }
 
-// CreateFrame creates a frame.
-func (i *Index) CreateFrame(name string, opt FrameOptions) (*Frame, 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
+	// Ensure field doesn't already exist.
+	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 FrameOptions) (*Frame, 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 {
+	// Find field in cache first.
+	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 FrameOptions) (*Frame, error) {
+func (i *Index) createField(name string, opt FieldOptions) (*Field, error) {
 	if name == "" {
-		return nil, errors.New("frame name required")
+		return nil, errors.New("field name required")
 	} else if opt.CacheType != "" && !IsValidCacheType(opt.CacheType) {
 		return nil, ErrInvalidCacheType
 	}
@@ -304,18 +304,18 @@ func (i *Index) createFrame(name string, opt FrameOptions) (*Frame, error) {
 		return nil, errors.Wrap(err, "validating options")
 	}
 
-	// Initialize frame.
-	f, err := i.newFrame(i.FramePath(name), name)
+	// Initialize field.
+	f, err := i.newField(i.FieldPath(name), name)
 	if err != nil {
 		return nil, errors.Wrap(err, "initializing")
 	}
 
-	// Open frame.
+	// Open field.
 	if err := f.Open(); err != nil {
 		return nil, errors.Wrap(err, "opening")
 	}
 
-	// Apply frame options.
+	// Apply field options.
 	if err := f.applyOptions(opt); err != nil {
 		f.Close()
 		return nil, errors.Wrap(err, "applying options")
@@ -326,47 +326,47 @@ func (i *Index) createFrame(name string, opt FrameOptions) (*Frame, error) {
 		return nil, errors.Wrap(err, "saving meta")
 	}
 
-	// Add to index's frame lookup.
-	i.frames[name] = f
+	// Add to index's field lookup.
+	i.fields[name] = f
 
 	return f, nil
 }
 
-func (i *Index) newFrame(path, name string) (*Frame, error) {
-	f, err := NewFrame(path, i.name, name)
+func (i *Index) newField(path, name string) (*Field, error) {
+	f, err := NewField(path, i.name, name)
 	if err != nil {
 		return nil, err
 	}
 	f.Logger = i.Logger
-	f.Stats = i.Stats.WithTags(fmt.Sprintf("frame:%s", name))
+	f.Stats = i.Stats.WithTags(fmt.Sprintf("field:%s", name))
 	f.broadcaster = i.broadcaster
 	f.rowAttrStore = i.NewAttrStore(filepath.Join(f.path, ".data"))
 	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)
+	// Ignore if field doesn't exist.
+	f := i.field(name)
 	if f == nil {
 		return nil
 	}
 
-	// Close frame.
+	// Close field.
 	if err := f.Close(); err != nil {
 		return errors.Wrap(err, "closing")
 	}
 
-	// Delete frame directory.
-	if err := os.RemoveAll(i.FramePath(name)); err != nil {
+	// Delete field directory.
+	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 []*FrameInfo `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: encodeFrames(d.Frames()),
+		Fields: encodeFields(d.Fields()),
 	}
 }
 
diff --git a/index_test.go b/index_test.go
index 86d9043ce..6f067f0e7 100644
--- a/index_test.go
+++ b/index_test.go
@@ -23,85 +23,85 @@ import (
 	"github.com/pilosa/pilosa/test"
 )
 
-// Ensure index can open and retrieve a frame.
-func TestIndex_CreateFrameIfNotExists(t *testing.T) {
+// Ensure index can open and retrieve a field.
+func TestIndex_CreateFieldIfNotExists(t *testing.T) {
 	index := test.MustOpenIndex()
 	defer index.Close()
 
-	// Create frame.
-	f, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{})
+	// Create field.
+	f, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{})
 	if err != nil {
 		t.Fatal(err)
 	} else if f == nil {
-		t.Fatal("expected frame")
+		t.Fatal("expected field")
 	}
 
-	// Retrieve existing frame.
-	other, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{})
+	// Retrieve existing field.
+	other, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{})
 	if err != nil {
 		t.Fatal(err)
-	} else if f.Frame != other.Frame {
-		t.Fatal("frame mismatch")
+	} else if f.Field != other.Field {
+		t.Fatal("field mismatch")
 	}
 
-	if f.Frame != index.Frame("f") {
-		t.Fatal("frame mismatch")
+	if f.Field != index.Field("f") {
+		t.Fatal("field mismatch")
 	}
 }
 
-func TestIndex_CreateFrame(t *testing.T) {
-	// Ensure time quantum can be set appropriately on a new frame.
+func TestIndex_CreateField(t *testing.T) {
+	// Ensure time quantum can be set appropriately on a new field.
 	t.Run("TimeQuantum", func(t *testing.T) {
 		t.Run("Explicit", func(t *testing.T) {
 			index := test.MustOpenIndex()
 			defer index.Close()
 
-			// Create frame with explicit quantum.
-			f, err := index.CreateFrame("f", pilosa.FrameOptions{
-				Type:        pilosa.FrameTypeTime,
+			// Create field with explicit quantum.
+			f, err := index.CreateField("f", pilosa.FieldOptions{
+				Type:        pilosa.FieldTypeTime,
 				TimeQuantum: pilosa.TimeQuantum("YMDH"),
 			})
 			if err != nil {
 				t.Fatal(err)
 			} else if q := f.TimeQuantum(); q != pilosa.TimeQuantum("YMDH") {
-				t.Fatalf("unexpected frame time quantum: %s", q)
+				t.Fatalf("unexpected field time quantum: %s", q)
 			}
 		})
 	})
 
-	// Ensure frame can include range columns.
+	// Ensure field can include range columns.
 	t.Run("BSIFields", func(t *testing.T) {
 		t.Run("OK", func(t *testing.T) {
 			index := test.MustOpenIndex()
 			defer index.Close()
 
-			// Create frame with schema and verify it exists.
-			if f, err := index.CreateFrame("f", pilosa.FrameOptions{
-				Type: pilosa.FrameTypeInt,
+			// Create field with schema and verify it exists.
+			if f, err := index.CreateField("f", pilosa.FieldOptions{
+				Type: pilosa.FieldTypeInt,
 				Min:  10,
 				Max:  20,
 			}); err != nil {
 				t.Fatal(err)
-			} else if !reflect.DeepEqual(f.Type(), pilosa.FrameTypeInt) {
+			} else if !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
 				t.Fatalf("unexpected type: %#v", f.Type())
 			}
 
 			// 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.FrameTypeInt) {
+			} else if f := index.Field("f"); !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
 				t.Fatalf("unexpected type after reopen: %#v", f.Type())
 			}
 		})
 
 		// TODO: These errors don't apply  here. Instead, we need these tests
-		// on frame creation FrameOptions validation.
+		// on field creation FieldOptions validation.
 		/*
 			t.Run("ErrRangeCacheAllowed", func(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
 
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					CacheType: pilosa.CacheTypeRanked,
 				}); err != nil {
 					t.Fatal(err)
@@ -111,7 +111,7 @@ func TestIndex_CreateFrame(t *testing.T) {
 			t.Run("BSIFieldsWithCacheTypeNone", func(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					CacheType: pilosa.CacheTypeNone,
 					CacheSize: uint32(5),
 				}); err != nil {
@@ -119,11 +119,11 @@ func TestIndex_CreateFrame(t *testing.T) {
 				}
 			})
 
-			t.Run("ErrFrameFieldsAllowed", func(t *testing.T) {
+			t.Run("ErrFieldFieldsAllowed", func(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
 
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					Fields: []*pilosa.Field{
 						{Name: "field0", Type: pilosa.FieldTypeInt},
 					},
@@ -136,7 +136,7 @@ func TestIndex_CreateFrame(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
 
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					Fields: []*pilosa.Field{
 						{Name: "", Type: pilosa.FieldTypeInt},
 					},
@@ -149,7 +149,7 @@ func TestIndex_CreateFrame(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
 
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					Fields: []*pilosa.Field{
 						{Name: "field0", Type: "bad_type"},
 					},
@@ -162,7 +162,7 @@ func TestIndex_CreateFrame(t *testing.T) {
 				index := test.MustOpenIndex()
 				defer index.Close()
 
-				if _, err := index.CreateFrame("f", pilosa.FrameOptions{
+				if _, err := index.CreateField("f", pilosa.FieldOptions{
 					Fields: []*pilosa.Field{
 						{Name: "field0", Type: pilosa.FieldTypeInt, Min: 100, Max: 50},
 					},
@@ -174,30 +174,30 @@ func TestIndex_CreateFrame(t *testing.T) {
 	})
 }
 
-// Ensure index can delete a frame.
-func TestIndex_DeleteFrame(t *testing.T) {
+// Ensure index can delete a field.
+func TestIndex_DeleteField(t *testing.T) {
 	index := test.MustOpenIndex()
 	defer index.Close()
 
-	// Create frame.
-	if _, err := index.CreateFrameIfNotExists("f", pilosa.FrameOptions{}); err != nil {
+	// Create field.
+	if _, err := index.CreateFieldIfNotExists("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	// Delete frame & verify it's gone.
-	if err := index.DeleteFrame("f"); err != nil {
+	// Delete field & verify it's gone.
+	if err := index.DeleteField("f"); err != nil {
 		t.Fatal(err)
-	} else if index.Frame("f") != nil {
-		t.Fatal("expected nil frame")
+	} else if index.Field("f") != nil {
+		t.Fatal("expected nil field")
 	}
 
 	// 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)
 	}
 }
 
-// Ensure index can delete a frame.
+// Ensure index can delete a field.
 func TestIndex_InvalidName(t *testing.T) {
 	path, err := ioutil.TempDir("", "pilosa-index-")
 	if err != nil {
diff --git a/internal/private.pb.go b/internal/private.pb.go
index a4f9e0431..1e2b34f38 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -10,7 +10,7 @@
 
 	It has these top-level messages:
 		IndexMeta
-		FrameMeta
+		FieldOptions
 		ImportResponse
 		BlockDataRequest
 		BlockDataResponse
@@ -19,9 +19,9 @@
 		CreateSliceMessage
 		DeleteIndexMessage
 		CreateIndexMessage
-		CreateFrameMessage
-		DeleteFrameMessage
-		Frame
+		CreateFieldMessage
+		DeleteFieldMessage
+		Field
 		Schema
 		Index
 		URI
@@ -68,7 +68,7 @@ func (m *IndexMeta) String() string            { return proto.CompactTextString(
 func (*IndexMeta) ProtoMessage()               {}
 func (*IndexMeta) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{0} }
 
-type FrameMeta struct {
+type FieldOptions struct {
 	Type        string `protobuf:"bytes,8,opt,name=Type,proto3" json:"Type,omitempty"`
 	CacheType   string `protobuf:"bytes,3,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
 	CacheSize   uint32 `protobuf:"varint,4,opt,name=CacheSize,proto3" json:"CacheSize,omitempty"`
@@ -77,47 +77,47 @@ type FrameMeta struct {
 	TimeQuantum string `protobuf:"bytes,5,opt,name=TimeQuantum,proto3" json:"TimeQuantum,omitempty"`
 }
 
-func (m *FrameMeta) Reset()                    { *m = FrameMeta{} }
-func (m *FrameMeta) String() string            { return proto.CompactTextString(m) }
-func (*FrameMeta) ProtoMessage()               {}
-func (*FrameMeta) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{1} }
+func (m *FieldOptions) Reset()                    { *m = FieldOptions{} }
+func (m *FieldOptions) String() string            { return proto.CompactTextString(m) }
+func (*FieldOptions) ProtoMessage()               {}
+func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{1} }
 
-func (m *FrameMeta) GetType() string {
+func (m *FieldOptions) GetType() string {
 	if m != nil {
 		return m.Type
 	}
 	return ""
 }
 
-func (m *FrameMeta) GetCacheType() string {
+func (m *FieldOptions) GetCacheType() string {
 	if m != nil {
 		return m.CacheType
 	}
 	return ""
 }
 
-func (m *FrameMeta) GetCacheSize() uint32 {
+func (m *FieldOptions) GetCacheSize() uint32 {
 	if m != nil {
 		return m.CacheSize
 	}
 	return 0
 }
 
-func (m *FrameMeta) GetMin() int64 {
+func (m *FieldOptions) GetMin() int64 {
 	if m != nil {
 		return m.Min
 	}
 	return 0
 }
 
-func (m *FrameMeta) GetMax() int64 {
+func (m *FieldOptions) GetMax() int64 {
 	if m != nil {
 		return m.Max
 	}
 	return 0
 }
 
-func (m *FrameMeta) GetTimeQuantum() string {
+func (m *FieldOptions) GetTimeQuantum() string {
 	if m != nil {
 		return m.TimeQuantum
 	}
@@ -142,7 +142,7 @@ func (m *ImportResponse) GetErr() string {
 
 type BlockDataRequest struct {
 	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	View  string `protobuf:"bytes,5,opt,name=View,proto3" json:"View,omitempty"`
 	Slice uint64 `protobuf:"varint,4,opt,name=Slice,proto3" json:"Slice,omitempty"`
 	Block uint64 `protobuf:"varint,3,opt,name=Block,proto3" json:"Block,omitempty"`
@@ -160,9 +160,9 @@ func (m *BlockDataRequest) GetIndex() string {
 	return ""
 }
 
-func (m *BlockDataRequest) GetFrame() string {
+func (m *BlockDataRequest) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -308,88 +308,88 @@ func (m *CreateIndexMessage) GetMeta() *IndexMeta {
 	return nil
 }
 
-type CreateFrameMessage struct {
-	Index string     `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string     `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
-	Meta  *FrameMeta `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
+type CreateFieldMessage struct {
+	Index string        `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field string        `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Meta  *FieldOptions `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
 }
 
-func (m *CreateFrameMessage) Reset()                    { *m = CreateFrameMessage{} }
-func (m *CreateFrameMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateFrameMessage) ProtoMessage()               {}
-func (*CreateFrameMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{10} }
+func (m *CreateFieldMessage) Reset()                    { *m = CreateFieldMessage{} }
+func (m *CreateFieldMessage) String() string            { return proto.CompactTextString(m) }
+func (*CreateFieldMessage) ProtoMessage()               {}
+func (*CreateFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{10} }
 
-func (m *CreateFrameMessage) GetIndex() string {
+func (m *CreateFieldMessage) GetIndex() string {
 	if m != nil {
 		return m.Index
 	}
 	return ""
 }
 
-func (m *CreateFrameMessage) GetFrame() string {
+func (m *CreateFieldMessage) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
 
-func (m *CreateFrameMessage) GetMeta() *FrameMeta {
+func (m *CreateFieldMessage) GetMeta() *FieldOptions {
 	if m != nil {
 		return m.Meta
 	}
 	return nil
 }
 
-type DeleteFrameMessage struct {
+type DeleteFieldMessage struct {
 	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 }
 
-func (m *DeleteFrameMessage) Reset()                    { *m = DeleteFrameMessage{} }
-func (m *DeleteFrameMessage) String() string            { return proto.CompactTextString(m) }
-func (*DeleteFrameMessage) ProtoMessage()               {}
-func (*DeleteFrameMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{11} }
+func (m *DeleteFieldMessage) Reset()                    { *m = DeleteFieldMessage{} }
+func (m *DeleteFieldMessage) String() string            { return proto.CompactTextString(m) }
+func (*DeleteFieldMessage) ProtoMessage()               {}
+func (*DeleteFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{11} }
 
-func (m *DeleteFrameMessage) GetIndex() string {
+func (m *DeleteFieldMessage) GetIndex() string {
 	if m != nil {
 		return m.Index
 	}
 	return ""
 }
 
-func (m *DeleteFrameMessage) GetFrame() string {
+func (m *DeleteFieldMessage) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
 
-type Frame struct {
-	Name  string     `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Meta  *FrameMeta `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
-	Views []string   `protobuf:"bytes,3,rep,name=Views" json:"Views,omitempty"`
+type Field struct {
+	Name  string        `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Meta  *FieldOptions `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
+	Views []string      `protobuf:"bytes,3,rep,name=Views" json:"Views,omitempty"`
 }
 
-func (m *Frame) Reset()                    { *m = Frame{} }
-func (m *Frame) String() string            { return proto.CompactTextString(m) }
-func (*Frame) ProtoMessage()               {}
-func (*Frame) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{12} }
+func (m *Field) Reset()                    { *m = Field{} }
+func (m *Field) String() string            { return proto.CompactTextString(m) }
+func (*Field) ProtoMessage()               {}
+func (*Field) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{12} }
 
-func (m *Frame) GetName() string {
+func (m *Field) GetName() string {
 	if m != nil {
 		return m.Name
 	}
 	return ""
 }
 
-func (m *Frame) GetMeta() *FrameMeta {
+func (m *Field) GetMeta() *FieldOptions {
 	if m != nil {
 		return m.Meta
 	}
 	return nil
 }
 
-func (m *Frame) GetViews() []string {
+func (m *Field) GetViews() []string {
 	if m != nil {
 		return m.Views
 	}
@@ -414,7 +414,7 @@ func (m *Schema) GetIndexes() []*Index {
 
 type Index struct {
 	Name   string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Frames []*Frame `protobuf:"bytes,4,rep,name=Frames" json:"Frames,omitempty"`
+	Fields []*Field `protobuf:"bytes,4,rep,name=Fields" json:"Fields,omitempty"`
 }
 
 func (m *Index) Reset()                    { *m = Index{} }
@@ -429,9 +429,9 @@ func (m *Index) GetName() string {
 	return ""
 }
 
-func (m *Index) GetFrames() []*Frame {
+func (m *Index) GetFields() []*Field {
 	if m != nil {
-		return m.Frames
+		return m.Fields
 	}
 	return nil
 }
@@ -654,7 +654,7 @@ func (m *BSIGroup) GetMax() int64 {
 
 type CreateViewMessage struct {
 	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	View  string `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
 }
 
@@ -670,9 +670,9 @@ func (m *CreateViewMessage) GetIndex() string {
 	return ""
 }
 
-func (m *CreateViewMessage) GetFrame() string {
+func (m *CreateViewMessage) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -686,7 +686,7 @@ func (m *CreateViewMessage) GetView() string {
 
 type DeleteViewMessage struct {
 	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	View  string `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
 }
 
@@ -702,9 +702,9 @@ func (m *DeleteViewMessage) GetIndex() string {
 	return ""
 }
 
-func (m *DeleteViewMessage) GetFrame() string {
+func (m *DeleteViewMessage) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -775,7 +775,7 @@ func (m *ResizeInstruction) GetClusterStatus() *ClusterStatus {
 type ResizeSource struct {
 	Node  *Node  `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
 	Index string `protobuf:"bytes,2,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,3,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field string `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
 	View  string `protobuf:"bytes,4,opt,name=View,proto3" json:"View,omitempty"`
 	Slice uint64 `protobuf:"varint,5,opt,name=Slice,proto3" json:"Slice,omitempty"`
 }
@@ -799,9 +799,9 @@ func (m *ResizeSource) GetIndex() string {
 	return ""
 }
 
-func (m *ResizeSource) GetFrame() string {
+func (m *ResizeSource) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -920,7 +920,7 @@ func (*RecalculateCaches) Descriptor() ([]byte, []int) { return fileDescriptorPr
 
 func init() {
 	proto.RegisterType((*IndexMeta)(nil), "internal.IndexMeta")
-	proto.RegisterType((*FrameMeta)(nil), "internal.FrameMeta")
+	proto.RegisterType((*FieldOptions)(nil), "internal.FieldOptions")
 	proto.RegisterType((*ImportResponse)(nil), "internal.ImportResponse")
 	proto.RegisterType((*BlockDataRequest)(nil), "internal.BlockDataRequest")
 	proto.RegisterType((*BlockDataResponse)(nil), "internal.BlockDataResponse")
@@ -929,9 +929,9 @@ func init() {
 	proto.RegisterType((*CreateSliceMessage)(nil), "internal.CreateSliceMessage")
 	proto.RegisterType((*DeleteIndexMessage)(nil), "internal.DeleteIndexMessage")
 	proto.RegisterType((*CreateIndexMessage)(nil), "internal.CreateIndexMessage")
-	proto.RegisterType((*CreateFrameMessage)(nil), "internal.CreateFrameMessage")
-	proto.RegisterType((*DeleteFrameMessage)(nil), "internal.DeleteFrameMessage")
-	proto.RegisterType((*Frame)(nil), "internal.Frame")
+	proto.RegisterType((*CreateFieldMessage)(nil), "internal.CreateFieldMessage")
+	proto.RegisterType((*DeleteFieldMessage)(nil), "internal.DeleteFieldMessage")
+	proto.RegisterType((*Field)(nil), "internal.Field")
 	proto.RegisterType((*Schema)(nil), "internal.Schema")
 	proto.RegisterType((*Index)(nil), "internal.Index")
 	proto.RegisterType((*URI)(nil), "internal.URI")
@@ -969,7 +969,7 @@ func (m *IndexMeta) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *FrameMeta) Marshal() (dAtA []byte, err error) {
+func (m *FieldOptions) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -979,7 +979,7 @@ func (m *FrameMeta) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *FrameMeta) MarshalTo(dAtA []byte) (int, error) {
+func (m *FieldOptions) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1065,11 +1065,11 @@ func (m *BlockDataRequest) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if m.Block != 0 {
 		dAtA[i] = 0x18
@@ -1298,7 +1298,7 @@ func (m *CreateIndexMessage) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *CreateFrameMessage) Marshal() (dAtA []byte, err error) {
+func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1308,7 +1308,7 @@ func (m *CreateFrameMessage) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *CreateFrameMessage) MarshalTo(dAtA []byte) (int, error) {
+func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1319,11 +1319,11 @@ func (m *CreateFrameMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if m.Meta != nil {
 		dAtA[i] = 0x1a
@@ -1338,7 +1338,7 @@ func (m *CreateFrameMessage) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *DeleteFrameMessage) Marshal() (dAtA []byte, err error) {
+func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1348,7 +1348,7 @@ func (m *DeleteFrameMessage) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DeleteFrameMessage) MarshalTo(dAtA []byte) (int, error) {
+func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1359,16 +1359,16 @@ func (m *DeleteFrameMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	return i, nil
 }
 
-func (m *Frame) Marshal() (dAtA []byte, err error) {
+func (m *Field) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1378,7 +1378,7 @@ func (m *Frame) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Frame) MarshalTo(dAtA []byte) (int, error) {
+func (m *Field) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1468,8 +1468,8 @@ func (m *Index) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
 		i += copy(dAtA[i:], m.Name)
 	}
-	if len(m.Frames) > 0 {
-		for _, msg := range m.Frames {
+	if len(m.Fields) > 0 {
+		for _, msg := range m.Fields {
 			dAtA[i] = 0x22
 			i++
 			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
@@ -1776,11 +1776,11 @@ func (m *CreateViewMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if len(m.View) > 0 {
 		dAtA[i] = 0x1a
@@ -1812,11 +1812,11 @@ func (m *DeleteViewMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if len(m.View) > 0 {
 		dAtA[i] = 0x1a
@@ -1933,11 +1933,11 @@ func (m *ResizeSource) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x1a
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if len(m.View) > 0 {
 		dAtA[i] = 0x22
@@ -2138,7 +2138,7 @@ func (m *IndexMeta) Size() (n int) {
 	return n
 }
 
-func (m *FrameMeta) Size() (n int) {
+func (m *FieldOptions) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.CacheType)
@@ -2182,7 +2182,7 @@ func (m *BlockDataRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2283,14 +2283,14 @@ func (m *CreateIndexMessage) Size() (n int) {
 	return n
 }
 
-func (m *CreateFrameMessage) Size() (n int) {
+func (m *CreateFieldMessage) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Index)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2301,21 +2301,21 @@ func (m *CreateFrameMessage) Size() (n int) {
 	return n
 }
 
-func (m *DeleteFrameMessage) Size() (n int) {
+func (m *DeleteFieldMessage) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Index)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
 	return n
 }
 
-func (m *Frame) Size() (n int) {
+func (m *Field) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2354,8 +2354,8 @@ func (m *Index) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	if len(m.Frames) > 0 {
-		for _, e := range m.Frames {
+	if len(m.Fields) > 0 {
+		for _, e := range m.Fields {
 			l = e.Size()
 			n += 1 + l + sovPrivate(uint64(l))
 		}
@@ -2489,7 +2489,7 @@ func (m *CreateViewMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2507,7 +2507,7 @@ func (m *DeleteViewMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2560,7 +2560,7 @@ func (m *ResizeSource) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2696,7 +2696,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *FrameMeta) Unmarshal(dAtA []byte) error {
+func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2719,10 +2719,10 @@ func (m *FrameMeta) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: FrameMeta: wiretype end group for non-group")
+			return fmt.Errorf("proto: FieldOptions: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FrameMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: FieldOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 3:
@@ -3029,7 +3029,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -3054,7 +3054,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 0 {
@@ -3875,7 +3875,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
+func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -3898,10 +3898,10 @@ func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CreateFrameMessage: wiretype end group for non-group")
+			return fmt.Errorf("proto: CreateFieldMessage: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CreateFrameMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CreateFieldMessage: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -3935,7 +3935,7 @@ func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -3960,7 +3960,7 @@ func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -3989,7 +3989,7 @@ func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Meta == nil {
-				m.Meta = &FrameMeta{}
+				m.Meta = &FieldOptions{}
 			}
 			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4016,7 +4016,7 @@ func (m *CreateFrameMessage) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
+func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -4039,10 +4039,10 @@ func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DeleteFrameMessage: wiretype end group for non-group")
+			return fmt.Errorf("proto: DeleteFieldMessage: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DeleteFrameMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DeleteFieldMessage: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -4076,7 +4076,7 @@ func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -4101,7 +4101,7 @@ func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -4124,7 +4124,7 @@ func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Frame) Unmarshal(dAtA []byte) error {
+func (m *Field) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -4147,10 +4147,10 @@ func (m *Frame) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Frame: wiretype end group for non-group")
+			return fmt.Errorf("proto: Field: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Frame: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -4209,7 +4209,7 @@ func (m *Frame) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Meta == nil {
-				m.Meta = &FrameMeta{}
+				m.Meta = &FieldOptions{}
 			}
 			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4406,7 +4406,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frames", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -4430,8 +4430,8 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frames = append(m.Frames, &Frame{})
-			if err := m.Frames[len(m.Frames)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Fields = append(m.Fields, &Field{})
+			if err := m.Fields[len(m.Fields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -5419,7 +5419,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -5444,7 +5444,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -5556,7 +5556,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -5581,7 +5581,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -5958,7 +5958,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -5983,7 +5983,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
@@ -6617,68 +6617,69 @@ var (
 func init() { proto.RegisterFile("private.proto", fileDescriptorPrivate) }
 
 var fileDescriptorPrivate = []byte{
-	// 1002 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6f, 0x1b, 0x45,
-	0x14, 0x67, 0xbd, 0x6b, 0xc7, 0x7e, 0xc1, 0xc1, 0x99, 0x42, 0xd8, 0x22, 0x14, 0xcc, 0xa8, 0x12,
-	0x86, 0x43, 0x54, 0xda, 0x0b, 0x5f, 0x95, 0xa2, 0xd8, 0x01, 0x16, 0x91, 0x08, 0x66, 0x93, 0x1e,
-	0x90, 0x38, 0x4c, 0xed, 0x51, 0xbb, 0xca, 0x7a, 0xc7, 0xec, 0xce, 0x26, 0x71, 0x0f, 0x5c, 0xe1,
-	0xc2, 0x1d, 0x71, 0xe3, 0xbf, 0xe1, 0xc8, 0x9f, 0x80, 0xc2, 0x3f, 0x82, 0xe6, 0xcd, 0xec, 0x47,
-	0xfc, 0xd1, 0x54, 0xa1, 0xb7, 0x79, 0xbf, 0xf7, 0xfd, 0xde, 0x6f, 0x76, 0x16, 0xba, 0xb3, 0x34,
-	0x3a, 0xe7, 0x4a, 0xec, 0xcd, 0x52, 0xa9, 0x24, 0x69, 0x47, 0x89, 0x12, 0x69, 0xc2, 0x63, 0xba,
-	0x09, 0x9d, 0x20, 0x99, 0x88, 0xcb, 0x23, 0xa1, 0x38, 0xfd, 0xd3, 0x81, 0xce, 0x97, 0x29, 0x9f,
-	0x0a, 0x2d, 0x91, 0x77, 0xa1, 0x33, 0xe4, 0xe3, 0x67, 0xe2, 0x64, 0x3e, 0x13, 0xbe, 0xdb, 0x77,
-	0x06, 0x1d, 0x56, 0x01, 0xa5, 0x36, 0x8c, 0x9e, 0x0b, 0xdf, 0xeb, 0x3b, 0x83, 0x2e, 0xab, 0x00,
-	0xd2, 0x87, 0xcd, 0x93, 0x68, 0x2a, 0xbe, 0xcf, 0x79, 0xa2, 0xf2, 0xa9, 0xdf, 0x44, 0xef, 0x3a,
-	0x44, 0x08, 0x78, 0x18, 0xb8, 0x8d, 0x2a, 0x3c, 0x93, 0x1e, 0xb8, 0x47, 0x51, 0xe2, 0x77, 0xfa,
-	0xce, 0xc0, 0x65, 0xfa, 0x88, 0x08, 0xbf, 0xf4, 0xc1, 0x22, 0xfc, 0x92, 0x52, 0xd8, 0x0a, 0xa6,
-	0x33, 0x99, 0x2a, 0x26, 0xb2, 0x99, 0x4c, 0x32, 0xf4, 0x3a, 0x4c, 0x53, 0xdf, 0xc1, 0x40, 0xfa,
-	0x48, 0x7f, 0x86, 0xde, 0x41, 0x2c, 0xc7, 0x67, 0x23, 0xae, 0x38, 0x13, 0x3f, 0xe5, 0x22, 0x53,
-	0xe4, 0x4d, 0x68, 0x62, 0xa3, 0xd6, 0xce, 0x08, 0x1a, 0xc5, 0x86, 0xfd, 0x86, 0x41, 0x51, 0xd0,
-	0x28, 0xfa, 0x63, 0xd7, 0x1e, 0x33, 0x82, 0x46, 0xc3, 0x38, 0x1a, 0x9b, 0x6e, 0x3d, 0x66, 0x04,
-	0xdd, 0xc7, 0xe3, 0x48, 0x5c, 0xd8, 0x16, 0xf1, 0x4c, 0x03, 0xd8, 0xae, 0xe5, 0xb7, 0x65, 0xee,
-	0x40, 0x8b, 0xc9, 0x8b, 0x60, 0x94, 0xf9, 0x4e, 0xdf, 0x1d, 0x78, 0xcc, 0x4a, 0x38, 0x48, 0x19,
-	0xe7, 0xd3, 0x44, 0xab, 0x1a, 0xa8, 0xaa, 0x00, 0x7a, 0x17, 0x9a, 0x38, 0x55, 0xdd, 0x65, 0xe5,
-	0xab, 0x8f, 0xf4, 0x17, 0x07, 0x3a, 0x47, 0xfc, 0x12, 0xcb, 0xc8, 0xc8, 0x23, 0x68, 0x87, 0x8a,
-	0x27, 0x13, 0x9e, 0x4e, 0xd0, 0x68, 0xf3, 0xc1, 0xfb, 0x7b, 0xc5, 0x96, 0xf7, 0x4a, 0xb3, 0xbd,
-	0xc2, 0xe6, 0x30, 0x51, 0xe9, 0x9c, 0x95, 0x2e, 0xef, 0x7c, 0x0e, 0xdd, 0x6b, 0x2a, 0x9d, 0xef,
-	0x4c, 0xcc, 0x8b, 0xa9, 0x9e, 0x89, 0xb9, 0xee, 0xff, 0x9c, 0xc7, 0xb9, 0x99, 0x95, 0xc7, 0x8c,
-	0xf0, 0x59, 0xe3, 0x13, 0x87, 0xee, 0x03, 0x19, 0xa6, 0x82, 0x2b, 0x81, 0x49, 0x8e, 0x44, 0x96,
-	0xf1, 0xa7, 0x62, 0xfd, 0xc4, 0xcd, 0x14, 0x1b, 0xb5, 0x29, 0xd2, 0x8f, 0x80, 0x8c, 0x44, 0x2c,
-	0x94, 0xb0, 0x64, 0x7c, 0x41, 0x04, 0x1a, 0x16, 0xd9, 0x6e, 0xb6, 0x25, 0x1f, 0x80, 0xa7, 0xb9,
-	0x8c, 0xc9, 0x36, 0x1f, 0xdc, 0xa9, 0x26, 0x52, 0x92, 0x9e, 0xa1, 0x01, 0x8d, 0x8a, 0xa0, 0x96,
-	0xff, 0x37, 0xb4, 0xb0, 0x82, 0x34, 0x45, 0x2a, 0x77, 0x31, 0x55, 0x79, 0xa3, 0x6c, 0xaa, 0xfd,
-	0xa2, 0xd7, 0xdb, 0xa6, 0xa2, 0x3f, 0x58, 0x54, 0x93, 0xef, 0x58, 0x6b, 0x8d, 0x0f, 0x9e, 0xd7,
-	0xb7, 0xbc, 0x50, 0x87, 0x8e, 0xad, 0xd9, 0x9a, 0xf9, 0x6e, 0xdf, 0xd5, 0xb1, 0x51, 0xa0, 0x0f,
-	0xa1, 0x15, 0x8e, 0x9f, 0x89, 0x29, 0x27, 0x1f, 0xc2, 0x06, 0x16, 0x21, 0x32, 0x4b, 0xa8, 0x37,
-	0x16, 0xc6, 0xc7, 0x0a, 0x3d, 0x1d, 0xd9, 0xe2, 0xd7, 0x14, 0xd4, 0xc2, 0xd4, 0x99, 0xef, 0x2d,
-	0x86, 0x41, 0x9c, 0x59, 0x35, 0x3d, 0x04, 0xf7, 0x94, 0x05, 0xfa, 0xa2, 0x60, 0x05, 0x45, 0x14,
-	0x2b, 0xe9, 0xd8, 0x5f, 0xcb, 0x4c, 0xd9, 0x51, 0xe0, 0x59, 0x63, 0xdf, 0xc9, 0x54, 0xe1, 0xd0,
-	0xbb, 0x0c, 0xcf, 0xf4, 0x47, 0xf0, 0x8e, 0xe5, 0x44, 0x90, 0x2d, 0x68, 0x04, 0x23, 0x1b, 0xa3,
-	0x11, 0x8c, 0xc8, 0x7b, 0x18, 0xde, 0xce, 0xa5, 0x5b, 0x15, 0x71, 0xca, 0x02, 0x86, 0x89, 0xef,
-	0x41, 0x37, 0xc8, 0x86, 0x52, 0xa6, 0x93, 0x28, 0xe1, 0x4a, 0xa6, 0x18, 0xb5, 0xcd, 0xae, 0x83,
-	0x74, 0x1f, 0x7a, 0x3a, 0x7c, 0xa8, 0xb8, 0x2a, 0x97, 0xb7, 0x03, 0x2d, 0x8d, 0x95, 0xe9, 0xac,
-	0x84, 0x64, 0xd7, 0x76, 0xc5, 0xfa, 0x50, 0xa0, 0xdf, 0x9a, 0x08, 0x87, 0xe7, 0x22, 0x51, 0xb5,
-	0xf5, 0xa3, 0x8c, 0x01, 0xba, 0xcc, 0x08, 0x84, 0x9a, 0x56, 0x6c, 0xcd, 0x5b, 0x55, 0xcd, 0x1a,
-	0x65, 0xa8, 0xa3, 0xbf, 0x39, 0x00, 0x45, 0x41, 0x79, 0x56, 0xba, 0x38, 0xeb, 0x5d, 0xc8, 0xc7,
-	0xb5, 0x0f, 0xc7, 0x32, 0x4f, 0x4a, 0x15, 0xab, 0x7d, 0x5e, 0x06, 0x05, 0x2d, 0x2c, 0xbf, 0x7b,
-	0x95, 0xbd, 0xc1, 0xed, 0x9a, 0xf4, 0x4d, 0xea, 0x0e, 0xe3, 0x3c, 0x53, 0x22, 0xb5, 0x15, 0xe9,
-	0x0f, 0x9c, 0x01, 0xca, 0xf9, 0x54, 0xc0, 0xea, 0x11, 0x91, 0x7b, 0xd0, 0xd4, 0x95, 0x1a, 0x6e,
-	0x2e, 0xb7, 0x61, 0x94, 0xf4, 0x31, 0xb4, 0x0f, 0xc2, 0xe0, 0xab, 0x54, 0xe6, 0xb3, 0x95, 0xcc,
-	0x2b, 0xde, 0x98, 0xc6, 0xf2, 0x1b, 0xe3, 0x2e, 0xbd, 0x31, 0x5e, 0xf5, 0xc6, 0x84, 0xb0, 0x6d,
-	0x3e, 0x06, 0xfa, 0x4a, 0xdc, 0xe6, 0x5b, 0x50, 0x3c, 0x0a, 0x6e, 0xed, 0x51, 0x08, 0x61, 0xdb,
-	0x5c, 0xfb, 0x57, 0x19, 0xf4, 0x8f, 0x06, 0x6c, 0x33, 0x91, 0x45, 0xcf, 0x45, 0x90, 0x64, 0x2a,
-	0xcd, 0xc7, 0x2a, 0x92, 0x89, 0xf6, 0xff, 0x46, 0x3e, 0xb1, 0xd3, 0x76, 0x99, 0x11, 0x5e, 0x86,
-	0x4c, 0xe4, 0x3e, 0x6c, 0x2e, 0x5e, 0x80, 0x65, 0xd3, 0xba, 0x09, 0xb9, 0x0f, 0x1b, 0xa1, 0xcc,
-	0xd3, 0x71, 0x79, 0xbd, 0x77, 0x2a, 0x6b, 0x53, 0x99, 0x51, 0xb3, 0xc2, 0xac, 0x46, 0xa5, 0xe6,
-	0x8b, 0xa9, 0x44, 0x1e, 0x2d, 0x50, 0xc9, 0x6f, 0xa1, 0xc3, 0xdb, 0x95, 0xc3, 0x35, 0x35, 0xbb,
-	0x6e, 0x4d, 0x7f, 0x75, 0xe0, 0xf5, 0x7a, 0x09, 0x2f, 0x75, 0x37, 0xca, 0x8d, 0x34, 0x56, 0x6e,
-	0xc4, 0x5d, 0xb5, 0x11, 0xaf, 0xda, 0x48, 0xf5, 0xbe, 0x35, 0xeb, 0xef, 0xdb, 0x19, 0xdc, 0x5d,
-	0x5a, 0xd3, 0x50, 0x4e, 0x67, 0x9a, 0x0f, 0xff, 0x63, 0x5d, 0xfa, 0xab, 0x91, 0xa6, 0x76, 0x51,
-	0x1d, 0x66, 0x04, 0xfa, 0x29, 0xbc, 0x15, 0x0a, 0x55, 0x5b, 0x52, 0xc1, 0xb6, 0x3e, 0xb8, 0xc7,
-	0xe2, 0x62, 0x4d, 0xfb, 0x5a, 0x45, 0xbf, 0x00, 0xff, 0x74, 0x36, 0xe1, 0x4a, 0xdc, 0xca, 0xfb,
-	0x00, 0xda, 0x27, 0x72, 0x26, 0x63, 0xf9, 0x74, 0x7e, 0xc3, 0xad, 0xf7, 0x61, 0xc3, 0x7c, 0x22,
-	0xcd, 0x2f, 0x4f, 0x87, 0x15, 0x22, 0xbd, 0xa3, 0x09, 0x3d, 0xe6, 0xf1, 0x38, 0x8f, 0x75, 0x19,
-	0xfa, 0xdf, 0x27, 0x3b, 0xe8, 0xfd, 0x75, 0xb5, 0xeb, 0xfc, 0x7d, 0xb5, 0xeb, 0xfc, 0x73, 0xb5,
-	0xeb, 0xfc, 0xfe, 0xef, 0xee, 0x6b, 0x4f, 0x5a, 0xf8, 0x23, 0xfb, 0xf0, 0xbf, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x93, 0x15, 0x15, 0x14, 0xd9, 0x0a, 0x00, 0x00,
+	// 1011 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcb, 0x6f, 0x1c, 0x35,
+	0x18, 0x67, 0x1e, 0xbb, 0xd9, 0xfd, 0xd2, 0x0d, 0x89, 0x0b, 0x61, 0x8a, 0x50, 0x58, 0xac, 0x4a,
+	0x0d, 0x3d, 0x44, 0xa5, 0xbd, 0xf0, 0xaa, 0x14, 0x25, 0x1b, 0x60, 0x10, 0x09, 0xe0, 0x49, 0x7a,
+	0xeb, 0xc1, 0xdd, 0xb5, 0xda, 0x51, 0x66, 0xc7, 0xc3, 0x8c, 0x27, 0xc9, 0xf6, 0xc0, 0x15, 0x2e,
+	0xdc, 0x11, 0x67, 0xfe, 0x18, 0x8e, 0xfc, 0x09, 0x28, 0xfc, 0x23, 0xc8, 0x9f, 0x3d, 0x8f, 0x64,
+	0x37, 0x4d, 0x15, 0x7a, 0xf3, 0xf7, 0x7e, 0xfd, 0x3e, 0xdb, 0x30, 0xc8, 0xf2, 0xf8, 0x84, 0x2b,
+	0xb1, 0x95, 0xe5, 0x52, 0x49, 0xd2, 0x8b, 0x53, 0x25, 0xf2, 0x94, 0x27, 0x74, 0x19, 0xfa, 0x61,
+	0x3a, 0x11, 0x67, 0xfb, 0x42, 0x71, 0xfa, 0xa7, 0x03, 0xb7, 0xbe, 0x8a, 0x45, 0x32, 0xf9, 0x3e,
+	0x53, 0xb1, 0x4c, 0x0b, 0xf2, 0x01, 0xf4, 0x77, 0xf9, 0xf8, 0x85, 0x38, 0x9c, 0x65, 0x22, 0xf0,
+	0x86, 0xce, 0x66, 0x9f, 0x35, 0x8c, 0x5a, 0x1a, 0xc5, 0x2f, 0x45, 0xe0, 0x0f, 0x9d, 0xcd, 0x01,
+	0x6b, 0x18, 0x64, 0x08, 0xcb, 0x87, 0xf1, 0x54, 0xfc, 0x58, 0xf2, 0x54, 0x95, 0xd3, 0xa0, 0x83,
+	0xd6, 0x6d, 0x16, 0x21, 0xe0, 0xa3, 0xe3, 0x1e, 0x8a, 0xf0, 0x4c, 0x56, 0xc1, 0xdb, 0x8f, 0xd3,
+	0xa0, 0x3f, 0x74, 0x36, 0x3d, 0xa6, 0x8f, 0xc8, 0xe1, 0x67, 0x01, 0x58, 0x0e, 0x3f, 0xa3, 0x14,
+	0x56, 0xc2, 0x69, 0x26, 0x73, 0xc5, 0x44, 0x91, 0xc9, 0xb4, 0x40, 0xab, 0xbd, 0x3c, 0x0f, 0x1c,
+	0x74, 0xa4, 0x8f, 0xf4, 0x67, 0x58, 0xdd, 0x49, 0xe4, 0xf8, 0x78, 0xc4, 0x15, 0x67, 0xe2, 0xa7,
+	0x52, 0x14, 0x8a, 0xbc, 0x03, 0x1d, 0xac, 0xd5, 0xea, 0x19, 0x42, 0x73, 0xb1, 0xe6, 0xc0, 0x35,
+	0x5c, 0x24, 0x34, 0x17, 0xed, 0xb1, 0x6a, 0x9f, 0x19, 0x42, 0x73, 0xa3, 0x24, 0x1e, 0x9b, 0x6a,
+	0x7d, 0x66, 0x08, 0x5d, 0xc7, 0x93, 0x58, 0x9c, 0xda, 0x12, 0xf1, 0x4c, 0x43, 0x58, 0x6b, 0xc5,
+	0xb7, 0x69, 0xae, 0x43, 0x97, 0xc9, 0xd3, 0x70, 0x54, 0x04, 0xce, 0xd0, 0xdb, 0xf4, 0x99, 0xa5,
+	0xb0, 0x91, 0x32, 0x29, 0xa7, 0xa9, 0x16, 0xb9, 0x28, 0x6a, 0x18, 0xf4, 0x0e, 0x74, 0xb0, 0xab,
+	0xba, 0xca, 0xc6, 0x56, 0x1f, 0xe9, 0x2f, 0x0e, 0xf4, 0xf7, 0xf9, 0x19, 0xa6, 0x51, 0x90, 0xc7,
+	0xd0, 0x8b, 0x14, 0x4f, 0x27, 0x3c, 0x9f, 0xa0, 0xd2, 0xf2, 0xc3, 0x8f, 0xb6, 0xaa, 0x41, 0x6f,
+	0xd5, 0x6a, 0x5b, 0x95, 0xce, 0x5e, 0xaa, 0xf2, 0x19, 0xab, 0x4d, 0xde, 0xff, 0x02, 0x06, 0x17,
+	0x44, 0x3a, 0xde, 0xb1, 0x98, 0x55, 0x5d, 0x3d, 0x16, 0x33, 0x5d, 0xff, 0x09, 0x4f, 0x4a, 0x81,
+	0xbd, 0xf2, 0x99, 0x21, 0x3e, 0x77, 0x3f, 0x75, 0xe8, 0x36, 0x90, 0xdd, 0x5c, 0x70, 0x25, 0x30,
+	0xc8, 0xbe, 0x28, 0x0a, 0xfe, 0x5c, 0x5c, 0xdd, 0x71, 0xd3, 0x45, 0xb7, 0xd5, 0x45, 0x7a, 0x1f,
+	0xc8, 0x48, 0x24, 0x42, 0x09, 0x8b, 0xc7, 0x57, 0x78, 0xa0, 0x51, 0x15, 0xed, 0x7a, 0x5d, 0x72,
+	0x0f, 0x7c, 0x0d, 0x6e, 0x0c, 0xb6, 0xfc, 0xf0, 0x76, 0xd3, 0x91, 0x1a, 0xf7, 0x0c, 0x15, 0x68,
+	0x52, 0x39, 0x45, 0x04, 0x5c, 0x5b, 0xc2, 0x02, 0xd0, 0xdc, 0xb7, 0xa1, 0x3c, 0x0c, 0xb5, 0xde,
+	0x84, 0x6a, 0x2f, 0x95, 0x8d, 0xb6, 0x5d, 0x95, 0x7b, 0xd3, 0x68, 0xf4, 0xa9, 0xe5, 0x6a, 0xfc,
+	0x1d, 0xf0, 0xa9, 0xb0, 0x36, 0x78, 0xae, 0x53, 0x71, 0xaf, 0x4f, 0x45, 0xbb, 0xd7, 0x98, 0x2d,
+	0x02, 0x6f, 0xe8, 0x69, 0xf7, 0x48, 0xd0, 0x47, 0xd0, 0x8d, 0xc6, 0x2f, 0xc4, 0x94, 0x93, 0x8f,
+	0x61, 0x09, 0xf3, 0x10, 0x85, 0x85, 0xd5, 0xdb, 0x97, 0x9a, 0xc8, 0x2a, 0x39, 0x1d, 0xd9, 0xfc,
+	0x17, 0xe6, 0x74, 0x0f, 0xba, 0x18, 0xbd, 0x08, 0xfc, 0xcb, 0x6e, 0x90, 0xcf, 0xac, 0x98, 0xee,
+	0x81, 0x77, 0xc4, 0x42, 0xbd, 0x2e, 0x98, 0x41, 0xe5, 0xc5, 0x52, 0xda, 0xf7, 0x37, 0xb2, 0x50,
+	0xb6, 0x1b, 0x78, 0xd6, 0xbc, 0x1f, 0x64, 0xae, 0xb0, 0xf5, 0x03, 0x86, 0x67, 0xfa, 0x14, 0xfc,
+	0x03, 0x39, 0x11, 0x64, 0x05, 0xdc, 0x70, 0x64, 0x7d, 0xb8, 0xe1, 0x88, 0x7c, 0x88, 0xee, 0x6d,
+	0x6b, 0x06, 0x4d, 0x12, 0x47, 0x2c, 0x64, 0x18, 0xf8, 0x2e, 0x0c, 0xc2, 0x62, 0x57, 0xca, 0x7c,
+	0x12, 0xa7, 0x5c, 0xc9, 0x1c, 0xbd, 0xf6, 0xd8, 0x45, 0x26, 0xdd, 0x86, 0x55, 0xed, 0x3e, 0x52,
+	0x5c, 0xd5, 0x80, 0x5f, 0x87, 0xae, 0xe6, 0xd5, 0xe1, 0x2c, 0x85, 0x90, 0xd7, 0x7a, 0xd5, 0x04,
+	0x91, 0xa0, 0xdf, 0x19, 0x0f, 0x7b, 0x27, 0x22, 0x55, 0x2d, 0x04, 0x20, 0x8d, 0x0e, 0x06, 0xcc,
+	0x10, 0x84, 0x9a, 0x52, 0x6c, 0xce, 0x2b, 0x4d, 0xce, 0x9a, 0xcb, 0x50, 0x46, 0x7f, 0x73, 0x00,
+	0xaa, 0x84, 0xca, 0xa2, 0x36, 0x71, 0xae, 0x36, 0x21, 0x9f, 0xb4, 0xae, 0x8f, 0xf9, 0x05, 0xa9,
+	0x45, 0xac, 0x75, 0xc9, 0x6c, 0x56, 0xb0, 0xb0, 0x28, 0x5f, 0x6d, 0xf4, 0x0d, 0xdf, 0x8e, 0x89,
+	0xd3, 0x18, 0x06, 0xbb, 0x49, 0x59, 0x28, 0x91, 0xdb, 0x8c, 0xf4, 0x35, 0x67, 0x18, 0x75, 0x7f,
+	0x1a, 0xc6, 0xe2, 0x16, 0x91, 0xbb, 0xd0, 0xd1, 0x99, 0x1a, 0x6c, 0xce, 0x97, 0x61, 0x84, 0xf4,
+	0x09, 0xf4, 0x76, 0xa2, 0xf0, 0xeb, 0x5c, 0x96, 0xd9, 0x42, 0xe4, 0x55, 0x2f, 0x8d, 0x3b, 0xff,
+	0xd2, 0x78, 0x73, 0x2f, 0x8d, 0xdf, 0xbc, 0x34, 0x11, 0xac, 0x99, 0x2b, 0x41, 0xaf, 0xc4, 0x4d,
+	0x6e, 0x84, 0xea, 0x69, 0xf0, 0x5a, 0x4f, 0x43, 0x04, 0x6b, 0x66, 0xf3, 0xdf, 0xa4, 0xd3, 0x3f,
+	0x5c, 0x58, 0x63, 0xa2, 0x88, 0x5f, 0x8a, 0x30, 0x2d, 0x54, 0x5e, 0x8e, 0xf5, 0x82, 0x6b, 0xfb,
+	0x6f, 0xe5, 0x33, 0xdb, 0x6d, 0x8f, 0x19, 0xe2, 0x75, 0xc0, 0x44, 0x1e, 0xc0, 0xf2, 0xe5, 0x05,
+	0x98, 0x57, 0x6d, 0xab, 0x90, 0x07, 0xb0, 0x14, 0xc9, 0x32, 0xd7, 0x48, 0x32, 0xeb, 0xdd, 0xba,
+	0x74, 0x4c, 0x66, 0x46, 0xcc, 0x2a, 0xb5, 0x16, 0x94, 0x3a, 0xaf, 0x86, 0x12, 0x79, 0x7c, 0x09,
+	0x4a, 0x41, 0x17, 0x0d, 0xde, 0x6b, 0x0c, 0x2e, 0x88, 0xd9, 0x45, 0x6d, 0xfa, 0xab, 0x03, 0xb7,
+	0xda, 0x29, 0xbc, 0xd6, 0x6e, 0xd4, 0x13, 0x71, 0x17, 0x4e, 0xc4, 0x5b, 0x34, 0x11, 0xbf, 0x99,
+	0x48, 0xf3, 0xca, 0x75, 0xda, 0xaf, 0xdc, 0x31, 0xdc, 0x99, 0x1b, 0xd3, 0xae, 0x9c, 0x66, 0x1a,
+	0x0f, 0xff, 0x63, 0x5c, 0xfa, 0xd6, 0xc8, 0x73, 0x3b, 0xa8, 0x3e, 0x33, 0x04, 0xfd, 0x0c, 0xde,
+	0x8d, 0x84, 0x6a, 0x0d, 0xa9, 0x42, 0xdb, 0x10, 0xbc, 0x03, 0x71, 0x7a, 0x45, 0xf9, 0x5a, 0x44,
+	0xbf, 0x84, 0xe0, 0x28, 0x9b, 0x70, 0x25, 0x6e, 0x64, 0xbd, 0x03, 0xbd, 0x43, 0x99, 0xc9, 0x44,
+	0x3e, 0x9f, 0x5d, 0xb3, 0xf5, 0x01, 0x2c, 0x99, 0x2b, 0xd2, 0x7c, 0x7c, 0xfa, 0xac, 0x22, 0xe9,
+	0x6d, 0x0d, 0xe8, 0x31, 0x4f, 0xc6, 0x65, 0xa2, 0xd3, 0xd0, 0x3f, 0xa0, 0x62, 0x67, 0xf5, 0xaf,
+	0xf3, 0x0d, 0xe7, 0xef, 0xf3, 0x0d, 0xe7, 0x9f, 0xf3, 0x0d, 0xe7, 0xf7, 0x7f, 0x37, 0xde, 0x7a,
+	0xd6, 0xc5, 0x1f, 0xed, 0xa3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x97, 0xf0, 0x12, 0xfd, 0xe2,
+	0x0a, 0x00, 0x00,
 }
diff --git a/internal/private.proto b/internal/private.proto
index d150b7802..9cab31828 100644
--- a/internal/private.proto
+++ b/internal/private.proto
@@ -5,7 +5,7 @@ package internal;
 message IndexMeta {
 }
 
-message FrameMeta {
+message FieldOptions {
     string Type = 8;
 	string CacheType = 3;
 	uint32 CacheSize = 4;
@@ -20,7 +20,7 @@ message ImportResponse {
 
 message BlockDataRequest {
 	string Index = 1;
-	string Frame = 2;
+	string Field = 2;
 	string View = 5;
 	uint64 Slice = 4;
 	uint64 Block = 3;
@@ -53,20 +53,20 @@ message CreateIndexMessage {
     IndexMeta Meta = 2;
 }
 
-message CreateFrameMessage {
+message CreateFieldMessage {
     string Index = 1;
-    string Frame = 2;
-    FrameMeta Meta = 3;
+    string Field = 2;
+    FieldOptions Meta = 3;
 }
 
-message DeleteFrameMessage {
+message DeleteFieldMessage {
     string Index = 1;
-    string Frame = 2;
+    string Field = 2;
 }
 
-message Frame {
+message Field {
     string Name = 1;
-    FrameMeta Meta = 2;
+    FieldOptions Meta = 2;
     repeated string Views = 3;
 }
 
@@ -76,7 +76,7 @@ message Schema {
 
 message Index {
     string Name = 1;
-    repeated Frame Frames = 4;
+    repeated Field Fields = 4;
 }
 
 message URI {
@@ -122,13 +122,13 @@ message BSIGroup {
 
 message CreateViewMessage {
     string Index = 1;
-    string Frame = 2;
+    string Field = 2;
     string View = 3;
 }
 
 message DeleteViewMessage {
     string Index = 1;
-    string Frame = 2;
+    string Field = 2;
     string View = 3;
 }
 
@@ -144,7 +144,7 @@ message ResizeInstruction {
 message ResizeSource {
     Node Node = 1;
     string Index = 2;
-    string Frame = 3;
+    string Field = 3;
     string View = 4;
     uint64 Slice = 5;
 }
diff --git a/internal/public.pb.go b/internal/public.pb.go
index 2fc4b3827..76266d2db 100644
--- a/internal/public.pb.go
+++ b/internal/public.pb.go
@@ -411,7 +411,7 @@ func (m *QueryResult) GetChanged() bool {
 
 type ImportRequest struct {
 	Index      string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame      string   `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field      string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	Slice      uint64   `protobuf:"varint,3,opt,name=Slice,proto3" json:"Slice,omitempty"`
 	RowIDs     []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
 	ColumnIDs  []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
@@ -432,9 +432,9 @@ func (m *ImportRequest) GetIndex() string {
 	return ""
 }
 
-func (m *ImportRequest) GetFrame() string {
+func (m *ImportRequest) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -483,7 +483,7 @@ func (m *ImportRequest) GetTimestamps() []int64 {
 
 type ImportValueRequest struct {
 	Index      string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame      string   `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	Field      string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	Slice      uint64   `protobuf:"varint,3,opt,name=Slice,proto3" json:"Slice,omitempty"`
 	ColumnIDs  []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
 	ColumnKeys []string `protobuf:"bytes,7,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
@@ -502,9 +502,9 @@ func (m *ImportValueRequest) GetIndex() string {
 	return ""
 }
 
-func (m *ImportValueRequest) GetFrame() string {
+func (m *ImportValueRequest) GetField() string {
 	if m != nil {
-		return m.Frame
+		return m.Field
 	}
 	return ""
 }
@@ -1054,11 +1054,11 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if m.Slice != 0 {
 		dAtA[i] = 0x18
@@ -1171,11 +1171,11 @@ func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.Frame) > 0 {
+	if len(m.Field) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Frame)))
-		i += copy(dAtA[i:], m.Frame)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if m.Slice != 0 {
 		dAtA[i] = 0x18
@@ -1474,7 +1474,7 @@ func (m *ImportRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
@@ -1524,7 +1524,7 @@ func (m *ImportValueRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
-	l = len(m.Frame)
+	l = len(m.Field)
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
@@ -3072,7 +3072,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -3097,7 +3097,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 0 {
@@ -3443,7 +3443,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Frame", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -3468,7 +3468,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Frame = string(dAtA[iNdEx:postIndex])
+			m.Field = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 0 {
@@ -3771,49 +3771,49 @@ var (
 func init() { proto.RegisterFile("public.proto", fileDescriptorPublic) }
 
 var fileDescriptorPublic = []byte{
-	// 701 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd4, 0x3c,
-	0x14, 0xfd, 0x3c, 0xc9, 0xfc, 0xdd, 0xe9, 0xcc, 0x57, 0x59, 0xdf, 0x57, 0x22, 0x84, 0x86, 0x28,
-	0x42, 0x28, 0xab, 0xa9, 0x34, 0xec, 0x41, 0xf4, 0x4f, 0x1a, 0x55, 0x54, 0x70, 0x5b, 0x8a, 0x58,
-	0xa6, 0xad, 0x55, 0x22, 0x65, 0xe2, 0x90, 0x38, 0x9a, 0xce, 0x73, 0xb0, 0xe1, 0x11, 0x58, 0xf0,
-	0x10, 0x2c, 0xbb, 0xe4, 0x11, 0xa0, 0xbc, 0x08, 0xf2, 0x75, 0x3c, 0x49, 0xa7, 0x52, 0xc5, 0x82,
-	0x9d, 0xcf, 0x39, 0xf6, 0xb5, 0x8f, 0x7d, 0x6e, 0x02, 0x1b, 0x59, 0x79, 0x96, 0xc4, 0xe7, 0x93,
-	0x2c, 0x97, 0x4a, 0xf2, 0x5e, 0x9c, 0x2a, 0x91, 0xa7, 0x51, 0x12, 0xbc, 0x07, 0x07, 0xe5, 0x82,
-	0x7b, 0xd0, 0xdd, 0x95, 0x49, 0x39, 0x4f, 0x0b, 0x8f, 0xf9, 0x4e, 0xe8, 0xa2, 0x85, 0xfc, 0x09,
-	0xb4, 0x5f, 0x2a, 0x95, 0x17, 0x5e, 0xcb, 0x77, 0xc2, 0xc1, 0x74, 0x34, 0xb1, 0x4b, 0x27, 0x9a,
-	0x46, 0x23, 0x72, 0x0e, 0xee, 0xa1, 0x58, 0x16, 0x9e, 0xe3, 0x3b, 0x61, 0x1f, 0x69, 0x1c, 0x3c,
-	0x07, 0xf7, 0x75, 0x14, 0xe7, 0x7c, 0x04, 0xad, 0xd9, 0x9e, 0xc7, 0x7c, 0x16, 0xba, 0xd8, 0x9a,
-	0xed, 0xf1, 0xff, 0xa0, 0xbd, 0x2b, 0xcb, 0x54, 0x79, 0x2d, 0xa2, 0x0c, 0xe0, 0x9b, 0xe0, 0x1c,
-	0x8a, 0xa5, 0xe7, 0xf8, 0x2c, 0xec, 0xa3, 0x1e, 0x06, 0x53, 0xe8, 0x9d, 0x46, 0xc9, 0x4a, 0x3d,
-	0x8d, 0x12, 0x2a, 0xe2, 0xa0, 0x1e, 0xde, 0xae, 0xe2, 0x54, 0x55, 0x82, 0xb7, 0xe0, 0xec, 0xc4,
-	0x4a, 0x8b, 0x28, 0x17, 0xab, 0x5d, 0x0d, 0xe0, 0x0f, 0xa1, 0x67, 0x5c, 0xcd, 0xf6, 0xaa, 0xbd,
-	0x57, 0x98, 0x3f, 0x82, 0xfe, 0x49, 0x3c, 0x17, 0x85, 0x8a, 0xe6, 0x19, 0x1d, 0xc2, 0xc1, 0x9a,
-	0x08, 0xde, 0xc1, 0xd0, 0xcc, 0xd4, 0x6e, 0x8f, 0x85, 0xba, 0xe3, 0xe9, 0xcf, 0x6e, 0xe9, 0xae,
-	0xc7, 0x2f, 0x0c, 0x5c, 0xad, 0x59, 0x89, 0xad, 0x24, 0x7d, 0xa5, 0x27, 0xcb, 0x4c, 0x54, 0x27,
-	0xa5, 0x31, 0xf7, 0x61, 0x70, 0xac, 0xf2, 0x38, 0xbd, 0x3c, 0x8d, 0x92, 0x52, 0x54, 0x85, 0x9a,
-	0x94, 0xf6, 0x38, 0x4b, 0x95, 0x91, 0x5d, 0xb2, 0xb1, 0xc2, 0xda, 0xe3, 0x8e, 0x94, 0x89, 0x11,
-	0xdb, 0x3e, 0x0b, 0x7b, 0x58, 0x13, 0x7c, 0x0c, 0x70, 0x90, 0xc8, 0xa8, 0x5a, 0xdb, 0xf1, 0x59,
-	0xc8, 0xb0, 0xc1, 0x04, 0xdb, 0xd0, 0xd5, 0x27, 0x7d, 0x15, 0x65, 0xb5, 0x5b, 0x76, 0x8f, 0xdb,
-	0xe0, 0x9a, 0xc1, 0xc6, 0x9b, 0x52, 0xe4, 0x4b, 0x14, 0x1f, 0x4b, 0x51, 0xd0, 0xab, 0x10, 0xae,
-	0x5c, 0x1a, 0xc0, 0xb7, 0xa0, 0x73, 0x9c, 0xc4, 0xe7, 0xc2, 0xdc, 0x9d, 0x8b, 0x15, 0xd2, 0x5e,
-	0xeb, 0x3b, 0x2f, 0xc8, 0x6b, 0x0f, 0x9b, 0x94, 0x5e, 0x89, 0x62, 0x2e, 0x95, 0x35, 0x53, 0x21,
-	0x1e, 0xc2, 0xbf, 0xfb, 0x57, 0xe7, 0x49, 0x79, 0x21, 0x50, 0x2e, 0xcc, 0xea, 0x0e, 0x4d, 0x58,
-	0xa7, 0xf9, 0x53, 0x18, 0x55, 0x94, 0x4d, 0x7f, 0x97, 0x26, 0xae, 0xb1, 0xc1, 0x27, 0x06, 0xc3,
-	0xca, 0x4a, 0x91, 0xc9, 0xb4, 0x10, 0xfa, 0xbd, 0xf6, 0xf3, 0xdc, 0xbe, 0xd7, 0x7e, 0x9e, 0xf3,
-	0x6d, 0xe8, 0xa2, 0x28, 0xca, 0x44, 0xd9, 0x10, 0xfc, 0x5f, 0x5f, 0x8b, 0x5d, 0x5b, 0x26, 0x0a,
-	0xed, 0x2c, 0xfe, 0x02, 0x46, 0xb7, 0x42, 0x65, 0xba, 0x67, 0x30, 0x7d, 0x50, 0xaf, 0xbb, 0xa5,
-	0xe3, 0xda, 0xf4, 0xe0, 0x1b, 0x83, 0x41, 0xa3, 0x32, 0x7f, 0x4c, 0xbd, 0x4c, 0x67, 0x1a, 0x4c,
-	0x87, 0x75, 0x15, 0x94, 0x0b, 0xa4, 0x2e, 0xdf, 0x00, 0x76, 0x54, 0xe5, 0x89, 0x1d, 0xe9, 0x57,
-	0xd4, 0xfd, 0x69, 0xb7, 0x6d, 0xbc, 0xa2, 0xa6, 0xd1, 0x88, 0xf4, 0x65, 0xf8, 0x10, 0xa5, 0x97,
-	0xe2, 0x82, 0xf2, 0xd4, 0x43, 0x0b, 0xf9, 0xa4, 0xee, 0x4f, 0x7a, 0x80, 0xc1, 0x94, 0xd7, 0x25,
-	0xac, 0x82, 0x75, 0x0f, 0xdb, 0x40, 0xeb, 0xb7, 0x18, 0x9a, 0x40, 0x07, 0x3f, 0x19, 0x0c, 0x67,
-	0xf3, 0x4c, 0xe6, 0xaa, 0x11, 0x92, 0x59, 0x7a, 0x21, 0xae, 0x6c, 0x48, 0x08, 0x68, 0xf6, 0x20,
-	0x8f, 0xe6, 0xa6, 0x1b, 0xfa, 0x68, 0x80, 0x66, 0x29, 0x2c, 0x14, 0x0e, 0x17, 0x0d, 0xa0, 0x58,
-	0xe8, 0x7e, 0x2f, 0x3c, 0xd7, 0x04, 0xca, 0x20, 0x1d, 0x7f, 0xdb, 0xee, 0x85, 0xd7, 0x26, 0xa9,
-	0x26, 0x74, 0xfc, 0x57, 0xfd, 0xae, 0xf3, 0xe2, 0x84, 0x0e, 0x36, 0x18, 0x7d, 0x0f, 0x28, 0x17,
-	0xf4, 0x91, 0xeb, 0xd2, 0x47, 0xce, 0x42, 0xbd, 0xd2, 0x94, 0x21, 0xb1, 0x47, 0x62, 0x83, 0x09,
-	0xbe, 0x32, 0xe0, 0xc6, 0x23, 0x35, 0xd2, 0xdf, 0x33, 0x7a, 0xbf, 0xa1, 0x2d, 0xe8, 0xd0, 0x7e,
-	0xd6, 0x4c, 0x85, 0xd6, 0x8e, 0xdb, 0x5d, 0x3f, 0xee, 0xce, 0xe6, 0xf5, 0xcd, 0x98, 0x7d, 0xbf,
-	0x19, 0xb3, 0x1f, 0x37, 0x63, 0xf6, 0xf9, 0xd7, 0xf8, 0x9f, 0xb3, 0x0e, 0xfd, 0x34, 0x9e, 0xfd,
-	0x0e, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x5d, 0x77, 0x8c, 0x44, 0x06, 0x00, 0x00,
+	// 699 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x6e, 0xd3, 0x40,
+	0x14, 0x65, 0x62, 0xe7, 0x75, 0xd3, 0x84, 0x6a, 0x04, 0xc5, 0x42, 0x28, 0x58, 0x16, 0x42, 0x5e,
+	0xa5, 0x52, 0xd8, 0x83, 0xe8, 0x4b, 0x8a, 0x2a, 0x2a, 0xb8, 0x2d, 0x45, 0x2c, 0xdd, 0x66, 0x54,
+	0x2c, 0x39, 0x9e, 0x60, 0x8f, 0x95, 0xe6, 0x3b, 0xd8, 0xf0, 0x09, 0x2c, 0xf8, 0x08, 0x96, 0x5d,
+	0xf2, 0x09, 0x50, 0x7e, 0x04, 0xcd, 0x1d, 0x4f, 0xec, 0xa6, 0x52, 0xc5, 0x82, 0xdd, 0x9c, 0x73,
+	0x66, 0xee, 0xcc, 0x99, 0x39, 0xd7, 0x86, 0x8d, 0x79, 0x71, 0x96, 0xc4, 0xe7, 0xa3, 0x79, 0x26,
+	0x95, 0xe4, 0x9d, 0x38, 0x55, 0x22, 0x4b, 0xa3, 0x24, 0xf8, 0x08, 0x0e, 0xca, 0x05, 0xf7, 0xa0,
+	0xbd, 0x2b, 0x93, 0x62, 0x96, 0xe6, 0x1e, 0xf3, 0x9d, 0xd0, 0x45, 0x0b, 0xf9, 0x33, 0x68, 0xbe,
+	0x56, 0x2a, 0xcb, 0xbd, 0x86, 0xef, 0x84, 0xbd, 0xf1, 0x60, 0x64, 0x97, 0x8e, 0x34, 0x8d, 0x46,
+	0xe4, 0x1c, 0xdc, 0x43, 0xb1, 0xcc, 0x3d, 0xc7, 0x77, 0xc2, 0x2e, 0xd2, 0x38, 0x78, 0x09, 0xee,
+	0xdb, 0x28, 0xce, 0xf8, 0x00, 0x1a, 0x93, 0x3d, 0x8f, 0xf9, 0x2c, 0x74, 0xb1, 0x31, 0xd9, 0xe3,
+	0x0f, 0xa0, 0xb9, 0x2b, 0x8b, 0x54, 0x79, 0x0d, 0xa2, 0x0c, 0xe0, 0x9b, 0xe0, 0x1c, 0x8a, 0xa5,
+	0xe7, 0xf8, 0x2c, 0xec, 0xa2, 0x1e, 0x06, 0x63, 0xe8, 0x9c, 0x46, 0xc9, 0x4a, 0x3d, 0x8d, 0x12,
+	0x2a, 0xe2, 0xa0, 0x1e, 0xde, 0xac, 0xe2, 0x94, 0x55, 0x82, 0xf7, 0xe0, 0xec, 0xc4, 0x4a, 0x8b,
+	0x28, 0x17, 0xab, 0x5d, 0x0d, 0xe0, 0x8f, 0xa1, 0x63, 0x5c, 0x4d, 0xf6, 0xca, 0xbd, 0x57, 0x98,
+	0x3f, 0x81, 0xee, 0x49, 0x3c, 0x13, 0xb9, 0x8a, 0x66, 0x73, 0x3a, 0x84, 0x83, 0x15, 0x11, 0x7c,
+	0x80, 0xbe, 0x99, 0xa9, 0xdd, 0x1e, 0x0b, 0x75, 0xcb, 0xd3, 0xbf, 0xdd, 0xd2, 0x6d, 0x8f, 0xdf,
+	0x18, 0xb8, 0x5a, 0xb3, 0x12, 0x5b, 0x49, 0xfa, 0x4a, 0x4f, 0x96, 0x73, 0x51, 0x9e, 0x94, 0xc6,
+	0xdc, 0x87, 0xde, 0xb1, 0xca, 0xe2, 0xf4, 0xe2, 0x34, 0x4a, 0x0a, 0x51, 0x16, 0xaa, 0x53, 0xda,
+	0xe3, 0x24, 0x55, 0x46, 0x76, 0xc9, 0xc6, 0x0a, 0x6b, 0x8f, 0x3b, 0x52, 0x26, 0x46, 0x6c, 0xfa,
+	0x2c, 0xec, 0x60, 0x45, 0xf0, 0x21, 0xc0, 0x41, 0x22, 0xa3, 0x72, 0x6d, 0xcb, 0x67, 0x21, 0xc3,
+	0x1a, 0x13, 0x6c, 0x43, 0x5b, 0x9f, 0xf4, 0x4d, 0x34, 0xaf, 0xdc, 0xb2, 0x3b, 0xdc, 0x06, 0x57,
+	0x0c, 0x36, 0xde, 0x15, 0x22, 0x5b, 0xa2, 0xf8, 0x5c, 0x88, 0x9c, 0x5e, 0x85, 0x70, 0xe9, 0xd2,
+	0x00, 0xbe, 0x05, 0xad, 0xe3, 0x24, 0x3e, 0x17, 0xe6, 0xee, 0x5c, 0x2c, 0x91, 0xf6, 0x5a, 0xdd,
+	0x79, 0x4e, 0x5e, 0x3b, 0x58, 0xa7, 0xf4, 0x4a, 0x14, 0x33, 0xa9, 0xac, 0x99, 0x12, 0xf1, 0x10,
+	0xee, 0xef, 0x5f, 0x9e, 0x27, 0xc5, 0x54, 0xa0, 0x5c, 0x98, 0xd5, 0x2d, 0x9a, 0xb0, 0x4e, 0xf3,
+	0xe7, 0x30, 0x28, 0x29, 0x9b, 0xfe, 0x36, 0x4d, 0x5c, 0x63, 0x83, 0x2f, 0x0c, 0xfa, 0xa5, 0x95,
+	0x7c, 0x2e, 0xd3, 0x5c, 0xe8, 0xf7, 0xda, 0xcf, 0x32, 0xfb, 0x5e, 0xfb, 0x59, 0xc6, 0xb7, 0xa1,
+	0x8d, 0x22, 0x2f, 0x12, 0x65, 0x43, 0xf0, 0xb0, 0xba, 0x16, 0xbb, 0xb6, 0x48, 0x14, 0xda, 0x59,
+	0xfc, 0x15, 0x0c, 0x6e, 0x84, 0xca, 0x74, 0x4f, 0x6f, 0xfc, 0xa8, 0x5a, 0x77, 0x43, 0xc7, 0xb5,
+	0xe9, 0xc1, 0x0f, 0x06, 0xbd, 0x5a, 0x65, 0xfe, 0x94, 0x7a, 0x99, 0xce, 0xd4, 0x1b, 0xf7, 0xab,
+	0x2a, 0x28, 0x17, 0x48, 0x5d, 0xbe, 0x01, 0xec, 0xa8, 0xcc, 0x13, 0x3b, 0xd2, 0xaf, 0xa8, 0xfb,
+	0xd3, 0x6e, 0x5b, 0x7b, 0x45, 0x4d, 0xa3, 0x11, 0xe9, 0xcb, 0xf0, 0x29, 0x4a, 0x2f, 0xc4, 0x94,
+	0xf2, 0xd4, 0x41, 0x0b, 0xf9, 0xa8, 0xea, 0x4f, 0x7a, 0x80, 0xde, 0x98, 0x57, 0x25, 0xac, 0x82,
+	0x55, 0x0f, 0xdb, 0x40, 0xeb, 0xb7, 0xe8, 0x9b, 0x40, 0x07, 0xbf, 0x19, 0xf4, 0x27, 0xb3, 0xb9,
+	0xcc, 0x54, 0x2d, 0x24, 0x93, 0x74, 0x2a, 0x2e, 0x6d, 0x48, 0x08, 0x68, 0xf6, 0x20, 0x16, 0xc9,
+	0x94, 0x4e, 0xdf, 0x45, 0x03, 0x34, 0x4b, 0x61, 0xa1, 0x70, 0xb8, 0x68, 0x00, 0xc5, 0x42, 0xf7,
+	0x7b, 0xee, 0xb9, 0x26, 0x50, 0x06, 0xe9, 0xf8, 0xdb, 0x76, 0xcf, 0xbd, 0x26, 0x49, 0x15, 0xa1,
+	0xe3, 0xbf, 0xea, 0x77, 0x9d, 0x17, 0x27, 0x74, 0xb0, 0xc6, 0xe8, 0x7b, 0x40, 0xb9, 0xa0, 0x8f,
+	0x5c, 0x9b, 0x3e, 0x72, 0x16, 0xea, 0x95, 0xa6, 0x0c, 0x89, 0x1d, 0x12, 0x6b, 0x4c, 0xf0, 0x9d,
+	0x01, 0x37, 0x1e, 0xa9, 0x91, 0xfe, 0x9f, 0xd1, 0xbb, 0x0d, 0x6d, 0x41, 0x8b, 0xf6, 0xb3, 0x66,
+	0x4a, 0xb4, 0x76, 0xdc, 0xf6, 0xfa, 0x71, 0x77, 0x36, 0xaf, 0xae, 0x87, 0xec, 0xe7, 0xf5, 0x90,
+	0xfd, 0xba, 0x1e, 0xb2, 0xaf, 0x7f, 0x86, 0xf7, 0xce, 0x5a, 0xf4, 0xd3, 0x78, 0xf1, 0x37, 0x00,
+	0x00, 0xff, 0xff, 0x71, 0x71, 0xa2, 0x0c, 0x44, 0x06, 0x00, 0x00,
 }
diff --git a/internal/public.proto b/internal/public.proto
index b37eea98c..cd34b88ff 100644
--- a/internal/public.proto
+++ b/internal/public.proto
@@ -70,7 +70,7 @@ message QueryResult {
 
 message ImportRequest {
 	string Index = 1;
-	string Frame = 2;
+	string Field = 2;
 	uint64 Slice = 3;
 	repeated uint64 RowIDs = 4;
 	repeated uint64 ColumnIDs = 5;
@@ -81,7 +81,7 @@ message ImportRequest {
 
 message ImportValueRequest {
 	string Index = 1;
-	string Frame = 2;
+	string Field = 2;
 	uint64 Slice = 3;
 	repeated uint64 ColumnIDs = 5;
 	repeated string ColumnKeys = 7;
diff --git a/pilosa.go b/pilosa.go
index 21bfdd822..6a7e74dfb 100644
--- a/pilosa.go
+++ b/pilosa.go
@@ -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")
@@ -50,7 +50,7 @@ var (
 	ErrInvalidView      = errors.New("invalid view")
 	ErrInvalidCacheType = errors.New("invalid cache type")
 
-	ErrName  = errors.New("invalid index or frame's name, must match [a-z0-9_-]")
+	ErrName  = errors.New("invalid index or field name, must match [a-z0-9_-]")
 	ErrLabel = errors.New("invalid row or column label, must match [A-Za-z0-9_-]")
 
 	// ErrFragmentNotFound is returned when a fragment does not exist.
@@ -78,7 +78,7 @@ type BadRequestError struct {
 	error
 }
 
-// Regular expression to validate index and frame names.
+// Regular expression to validate index and field names.
 var nameRegexp = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,63}$`)
 
 // ColumnAttrSet represents a set of attributes for a vertical column in an index.
diff --git a/pql/ast_test.go b/pql/ast_test.go
index f5d75e9de..4b130c610 100644
--- a/pql/ast_test.go
+++ b/pql/ast_test.go
@@ -33,11 +33,11 @@ func TestCall_String(t *testing.T) {
 		c := &pql.Call{
 			Name: "Range",
 			Args: map[string]interface{}{
-				"frame":  "f",
+				"other":  "f",
 				"field0": &pql.Condition{Op: pql.GTE, Value: 10},
 			},
 		}
-		if s := c.String(); s != `Range(field0 >= 10, frame="f")` {
+		if s := c.String(); s != `Range(field0 >= 10, other="f")` {
 			t.Fatalf("unexpected string: %s", s)
 		}
 	})
diff --git a/pql/parser_test.go b/pql/parser_test.go
index 0e2a5c17d..411406815 100644
--- a/pql/parser_test.go
+++ b/pql/parser_test.go
@@ -135,7 +135,7 @@ func TestParser_Parse(t *testing.T) {
 
 	// Parse with both child calls and arguments.
 	t.Run("ChildrenAndArguments", func(t *testing.T) {
-		q, err := pql.ParseString(`TopN(Bitmap(id=100, frame=other), frame=f, n=3)`)
+		q, err := pql.ParseString(`TopN(Bitmap(id=100, field=other), field=f, n=3)`)
 		if err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(q.Calls[0],
@@ -143,9 +143,9 @@ func TestParser_Parse(t *testing.T) {
 				Name: "TopN",
 				Children: []*pql.Call{{
 					Name: "Bitmap",
-					Args: map[string]interface{}{"id": int64(100), "frame": "other"},
+					Args: map[string]interface{}{"id": int64(100), "field": "other"},
 				}},
-				Args: map[string]interface{}{"n": int64(3), "frame": "f"},
+				Args: map[string]interface{}{"n": int64(3), "field": "f"},
 			},
 		) {
 			t.Fatalf("unexpected call: %#v", q.Calls[0])
@@ -154,14 +154,14 @@ func TestParser_Parse(t *testing.T) {
 
 	// Parse a list argument.
 	t.Run("ListArgument", func(t *testing.T) {
-		q, err := pql.ParseString(`TopN(frame="f", ids=[0,10,30])`)
+		q, err := pql.ParseString(`TopN(field="f", ids=[0,10,30])`)
 		if err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(q.Calls[0],
 			&pql.Call{
 				Name: "TopN",
 				Args: map[string]interface{}{
-					"frame": "f",
+					"field": "f",
 					"ids":   []interface{}{int64(0), int64(10), int64(30)},
 				},
 			},
diff --git a/server.go b/server.go
index 02e56e9b0..471319dd7 100644
--- a/server.go
+++ b/server.go
@@ -455,34 +455,34 @@ func (s *Server) ReceiveMessage(pb proto.Message) error {
 		if err := s.Holder.DeleteIndex(obj.Index); err != nil {
 			return err
 		}
-	case *internal.CreateFrameMessage:
+	case *internal.CreateFieldMessage:
 		idx := s.Holder.Index(obj.Index)
 		if idx == nil {
 			return fmt.Errorf("Local Index not found: %s", obj.Index)
 		}
-		opt := decodeFrameOptions(obj.Meta)
-		_, err := idx.CreateFrame(obj.Frame, *opt)
+		opt := decodeFieldOptions(obj.Meta)
+		_, err := idx.CreateField(obj.Field, *opt)
 		if err != nil {
 			return err
 		}
-	case *internal.DeleteFrameMessage:
+	case *internal.DeleteFieldMessage:
 		idx := s.Holder.Index(obj.Index)
-		if err := idx.DeleteFrame(obj.Frame); err != nil {
+		if err := idx.DeleteField(obj.Field); err != nil {
 			return err
 		}
 	case *internal.CreateViewMessage:
-		f := s.Holder.Frame(obj.Index, obj.Frame)
+		f := s.Holder.Field(obj.Index, obj.Field)
 		if f == nil {
-			return fmt.Errorf("Local Frame not found: %s", obj.Frame)
+			return fmt.Errorf("Local Field not found: %s", obj.Field)
 		}
 		_, _, err := f.createViewIfNotExistsBase(obj.View)
 		if err != nil {
 			return err
 		}
 	case *internal.DeleteViewMessage:
-		f := s.Holder.Frame(obj.Index, obj.Frame)
+		f := s.Holder.Field(obj.Index, obj.Field)
 		if f == nil {
-			return fmt.Errorf("Local Frame not found: %s", obj.Frame)
+			return fmt.Errorf("Local Field not found: %s", obj.Field)
 		}
 		err := f.DeleteView(obj.View)
 		if err != nil {
diff --git a/server/cluster_test.go b/server/cluster_test.go
index e6777d90c..3dfc6c4d9 100644
--- a/server/cluster_test.go
+++ b/server/cluster_test.go
@@ -42,7 +42,7 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	// Expected indexes and Frames
+	// Expected indexes and Fields
 	expected := map[string][]string{
 		"i": []string{"f"},
 	}
@@ -51,14 +51,14 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 	client0 := m0.Client()
 	client1 := m1.Client()
 
-	// Create indexes and frames on one node.
+	// Create indexes and fields on one node.
 	if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 		t.Fatal(err)
-	} else if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{}); err != nil {
+	} else if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	// Make sure node0 knows about the index and frame created.
+	// Make sure node0 knows about the index and field created.
 	schema0, err := client0.Schema(context.Background())
 	if err != nil {
 		t.Fatal(err)
@@ -66,15 +66,15 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 	received0 := map[string][]string{}
 	for _, idx := range schema0 {
 		received0[idx.Name] = []string{}
-		for _, frame := range idx.Frames {
-			received0[idx.Name] = append(received0[idx.Name], frame.Name)
+		for _, field := range idx.Fields {
+			received0[idx.Name] = append(received0[idx.Name], field.Name)
 		}
 	}
 	if !reflect.DeepEqual(received0, expected) {
 		t.Fatalf("unexpected schema on node0: %s", received0)
 	}
 
-	// Make sure node1 knows about the index and frame created.
+	// Make sure node1 knows about the index and field created.
 	schema1, err := client1.Schema(context.Background())
 	if err != nil {
 		t.Fatal(err)
@@ -82,8 +82,8 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 	received1 := map[string][]string{}
 	for _, idx := range schema1 {
 		received1[idx.Name] = []string{}
-		for _, frame := range idx.Frames {
-			received1[idx.Name] = append(received1[idx.Name], frame.Name)
+		for _, field := range idx.Fields {
+			received1[idx.Name] = append(received1[idx.Name], field.Name)
 		}
 	}
 	if !reflect.DeepEqual(received1, expected) {
@@ -92,8 +92,8 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 
 	// Write data on first node.
 	if _, err := m0.Query("i", "", `
-            SetBit(row=1, frame="f", col=1)
-            SetBit(row=1, frame="f", col=2400000)
+            SetBit(row=1, field="f", col=1)
+            SetBit(row=1, field="f", col=2400000)
         `); err != nil {
 		t.Fatal(err)
 	}
@@ -206,10 +206,10 @@ func TestClusterResize_AddNode(t *testing.T) {
 		// Create a client for each node.
 		client0 := m0.Client()
 
-		// Create indexes and frames on one node.
+		// Create indexes and fields on one node.
 		if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 			t.Fatal(err)
-		} else if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{}); err != nil {
+		} else if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
@@ -250,17 +250,17 @@ func TestClusterResize_AddNode(t *testing.T) {
 		client0 := m0.Client()
 		//client1 := m1.Client()
 
-		// Create indexes and frames on one node.
+		// Create indexes and fields on one node.
 		if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 			t.Fatal(err)
-		} else if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{}); err != nil {
+		} else if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
 		// Write data on first node.
 		if _, err := m0.Query("i", "", `
-				SetBit(row=1, frame="f", col=1)
-				SetBit(row=1, frame="f", col=1300000)
+				SetBit(row=1, field="f", col=1)
+				SetBit(row=1, field="f", col=1300000)
 			`); err != nil {
 			t.Fatal(err)
 		}
@@ -302,17 +302,17 @@ func TestClusterResize_AddNode(t *testing.T) {
 		client0 := m0.Client()
 		//client1 := m1.Client()
 
-		// Create indexes and frames on one node.
+		// Create indexes and fields on one node.
 		if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 			t.Fatal(err)
-		} else if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{}); err != nil {
+		} else if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
 		// Write data on first node. Note that no data is placed on slice 1.
 		if _, err := m0.Query("i", "", `
-				SetBit(row=1, frame="f", col=1)
-				SetBit(row=1, frame="f", col=2400000)
+				SetBit(row=1, field="f", col=1)
+				SetBit(row=1, field="f", col=2400000)
 			`); err != nil {
 			t.Fatal(err)
 		}
@@ -455,10 +455,10 @@ func TestClusterResize_RemoveNode(t *testing.T) {
 	t.Run("ErrorRemoveWithoutReplicas", func(t *testing.T) {
 		client0 := m0.Client()
 
-		// Create indexes and frames on one node.
+		// Create indexes and fields on one node.
 		if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 			t.Fatal(err)
-		} else if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{}); err != nil {
+		} else if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		}
 
@@ -466,7 +466,7 @@ func TestClusterResize_RemoveNode(t *testing.T) {
 		// TODO: Deterministic node IDs would ensure consistent results
 		setColumns := ""
 		for i := 0; i < 20; i++ {
-			setColumns += fmt.Sprintf("SetBit(row=1, frame=\"f\", col=%d) ", i*pilosa.SliceWidth)
+			setColumns += fmt.Sprintf("SetBit(row=1, field=\"f\", col=%d) ", i*pilosa.SliceWidth)
 		}
 
 		if _, err := m0.Query("i", "", setColumns); err != nil {
diff --git a/server/server_test.go b/server/server_test.go
index edac4b6fd..4356ad241 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -51,20 +51,20 @@ func TestMain_Set_Quick(t *testing.T) {
 
 		// Execute SetBit() commands.
 		for _, cmd := range cmds {
-			if err := client.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && !strings.Contains(err.Error(), "index already exists") {
+			if err := client.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 				t.Fatal(err)
 			}
-			if err := client.CreateFrame(context.Background(), "i", cmd.Frame, pilosa.FrameOptions{}); err != nil && !strings.Contains(err.Error(), "frame already exists") {
+			if err := client.CreateField(context.Background(), "i", cmd.Field, pilosa.FieldOptions{}); err != nil && err != pilosa.ErrFieldExists {
 				t.Fatal(err)
 			}
-			if _, err := m.Query("i", "", fmt.Sprintf(`SetBit(row=%d, frame=%q, col=%d)`, cmd.ID, cmd.Frame, cmd.ColumnID)); err != nil {
+			if _, err := m.Query("i", "", fmt.Sprintf(`SetBit(row=%d, field=%q, col=%d)`, cmd.ID, cmd.Field, cmd.ColumnID)); err != nil {
 				t.Fatal(err)
 			}
 		}
 
 		// Validate data.
-		for frame, frameSet := range SetCommands(cmds).Frames() {
-			for id, columnIDs := range frameSet {
+		for field, fieldSet := range SetCommands(cmds).Fields() {
+			for id, columnIDs := range fieldSet {
 				exp := MustMarshalJSON(map[string]interface{}{
 					"results": []interface{}{
 						map[string]interface{}{
@@ -73,7 +73,7 @@ func TestMain_Set_Quick(t *testing.T) {
 						},
 					},
 				}) + "\n"
-				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, frame=%q)`, id, frame)); err != nil {
+				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, field=%q)`, id, field)); err != nil {
 					t.Fatal(err)
 				} else if res != exp {
 					t.Fatalf("unexpected result:\n\ngot=%s\n\nexp=%s\n\n", res, exp)
@@ -86,8 +86,8 @@ func TestMain_Set_Quick(t *testing.T) {
 		}
 
 		// Validate data after reopening.
-		for frame, frameSet := range SetCommands(cmds).Frames() {
-			for id, columnIDs := range frameSet {
+		for field, fieldSet := range SetCommands(cmds).Fields() {
+			for id, columnIDs := range fieldSet {
 				exp := MustMarshalJSON(map[string]interface{}{
 					"results": []interface{}{
 						map[string]interface{}{
@@ -96,7 +96,7 @@ func TestMain_Set_Quick(t *testing.T) {
 						},
 					},
 				}) + "\n"
-				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, frame=%q)`, id, frame)); err != nil {
+				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, field=%q)`, id, field)); err != nil {
 					t.Fatal(err)
 				} else if res != exp {
 					t.Fatalf("unexpected result (reopen):\n\ngot=%s\n\nexp=%s\n\n", res, exp)
@@ -119,49 +119,49 @@ func TestMain_SetRowAttrs(t *testing.T) {
 	m := test.MustRunMain()
 	defer m.Close()
 
-	// Create frames.
+	// Create fields.
 	client := m.Client()
 	if err := client.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 		t.Fatal(err)
-	} else if err := client.CreateFrame(context.Background(), "i", "x", pilosa.FrameOptions{}); err != nil {
+	} else if err := client.CreateField(context.Background(), "i", "x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
-	} else if err := client.CreateFrame(context.Background(), "i", "z", pilosa.FrameOptions{}); err != nil {
+	} else if err := client.CreateField(context.Background(), "i", "z", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
-	} else if err := client.CreateFrame(context.Background(), "i", "neg", pilosa.FrameOptions{}); err != nil {
+	} else if err := client.CreateField(context.Background(), "i", "neg", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	// Set columns on different rows in different frames.
-	if _, err := m.Query("i", "", `SetBit(row=1, frame="x", col=100)`); err != nil {
+	// Set columns on different rows in different fields.
+	if _, err := m.Query("i", "", `SetBit(row=1, field="x", col=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(row=2, frame="x", col=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=2, field="x", col=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(row=2, frame="z", col=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=2, field="z", col=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(row=3, frame="neg", col=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=3, field="neg", col=100)`); err != nil {
 		t.Fatal(err)
 	}
 
 	// Set row attributes.
-	if _, err := m.Query("i", "", `SetRowAttrs(row=1, frame="x", x=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetRowAttrs(row=1, field="x", x=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, frame="x", x=-200)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, field="x", x=-200)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, frame="z", x=300)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, field="z", x=300)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(row=3, frame="neg", x=-0.44)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=3, field="neg", x=-0.44)`); err != nil {
 		t.Fatal(err)
 	}
 
 	// Query row x/1.
-	if res, err := m.Query("i", "", `Bitmap(row=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=1, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":100},"columns":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
 	}
 
 	// Query row x/2.
-	if res, err := m.Query("i", "", `Bitmap(row=2, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=2, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-200},"columns":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -172,19 +172,19 @@ func TestMain_SetRowAttrs(t *testing.T) {
 	}
 
 	// Query rows after reopening.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":100},"columns":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
 	}
 
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=3, frame="neg")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=3, field="neg")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-0.44},"columns":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
 	}
 	// Query row x/2.
-	if res, err := m.Query("i", "", `Bitmap(row=2, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=2, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-200},"columns":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -196,18 +196,18 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	m := test.MustRunMain()
 	defer m.Close()
 
-	// Create frames.
+	// Create fields.
 	client := m.Client()
 	if err := client.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 		t.Fatal(err)
-	} else if err := client.CreateFrame(context.Background(), "i", "x", pilosa.FrameOptions{}); err != nil {
+	} else if err := client.CreateField(context.Background(), "i", "x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
 	// Set columns on row.
-	if _, err := m.Query("i", "", `SetBit(row=1, frame="x", col=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetBit(row=1, field="x", col=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(row=1, frame="x", col=101)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=1, field="x", col=101)`); err != nil {
 		t.Fatal(err)
 	}
 
@@ -217,7 +217,7 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	}
 
 	// Query row.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{},"columns":[100,101]}],"columnAttrs":[{"id":100,"attrs":{"foo":"bar"}}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -228,7 +228,7 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	}
 
 	// Query row after reopening.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, field="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{},"columns":[100,101]}],"columnAttrs":[{"id":100,"attrs":{"foo":"bar"}}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
@@ -286,15 +286,15 @@ func TestMain_RecalculateHashes(t *testing.T) {
 	if err := client0.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
 		t.Fatal("create index:", err)
 	}
-	if err := client0.CreateFrame(context.Background(), "i", "f", pilosa.FrameOptions{CacheType: "ranked"}); err != nil {
-		t.Fatal("create frame:", err)
+	if err := client0.CreateField(context.Background(), "i", "f", pilosa.FieldOptions{CacheType: "ranked"}); err != nil {
+		t.Fatal("create field:", err)
 	}
 
 	// Set some columns
 	data := []string{}
 	for rowID := 1; rowID < 10; rowID++ {
 		for columnID := 1; columnID < 100; columnID++ {
-			data = append(data, fmt.Sprintf(`SetBit(row=%d, frame="f", col=%d)`, rowID, columnID))
+			data = append(data, fmt.Sprintf(`SetBit(row=%d, field="f", col=%d)`, rowID, columnID))
 		}
 	}
 	if _, err := cluster[0].Query("i", "", strings.Join(data, "")); err != nil {
@@ -311,7 +311,7 @@ func TestMain_RecalculateHashes(t *testing.T) {
 
 	// Run a TopN query on all nodes. The result should be the same as the target.
 	for _, m := range cluster {
-		res, err := m.Query("i", "", `TopN(frame="f")`)
+		res, err := m.Query("i", "", `TopN(field="f")`)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -325,37 +325,37 @@ func TestMain_RecalculateHashes(t *testing.T) {
 // SetCommand represents a command to set a column.
 type SetCommand struct {
 	ID       uint64
-	Frame    string
+	Field    string
 	ColumnID uint64
 }
 
 type SetCommands []SetCommand
 
-// Frames returns the set of column ids for each frame/row.
-func (a SetCommands) Frames() map[string]map[uint64][]uint64 {
+// Fields returns the set of column ids for each field/row.
+func (a SetCommands) Fields() map[string]map[uint64][]uint64 {
 	// Create a set of unique commands.
 	m := make(map[SetCommand]struct{})
 	for _, cmd := range a {
 		m[cmd] = struct{}{}
 	}
 
-	// Build unique ids for each frame & row.
-	frames := make(map[string]map[uint64][]uint64)
+	// Build unique ids for each field & row.
+	fields := make(map[string]map[uint64][]uint64)
 	for cmd := range m {
-		if frames[cmd.Frame] == nil {
-			frames[cmd.Frame] = make(map[uint64][]uint64)
+		if fields[cmd.Field] == nil {
+			fields[cmd.Field] = make(map[uint64][]uint64)
 		}
-		frames[cmd.Frame][cmd.ID] = append(frames[cmd.Frame][cmd.ID], cmd.ColumnID)
+		fields[cmd.Field][cmd.ID] = append(fields[cmd.Field][cmd.ID], cmd.ColumnID)
 	}
 
 	// Sort each set of column ids.
-	for _, frame := range frames {
-		for id := range frame {
-			sort.Sort(uint64Slice(frame[id]))
+	for _, field := range fields {
+		for id := range field {
+			sort.Sort(uint64Slice(field[id]))
 		}
 	}
 
-	return frames
+	return fields
 }
 
 // GenerateSetCommands generates random SetCommand objects.
@@ -364,7 +364,7 @@ func GenerateSetCommands(n int, rand *rand.Rand) []SetCommand {
 	for i := range cmds {
 		cmds[i] = SetCommand{
 			ID:       uint64(rand.Intn(1000)),
-			Frame:    "x",
+			Field:    "x",
 			ColumnID: uint64(rand.Intn(10)),
 		}
 	}
diff --git a/server_test.go b/server_test.go
index 9e10374d7..6cbbe191e 100644
--- a/server_test.go
+++ b/server_test.go
@@ -19,9 +19,9 @@ func TestMonitorAntiEntropy(t *testing.T) {
 	if err != nil {
 		t.Fatalf("creating index: %v", err)
 	}
-	err = client.CreateFrame(context.Background(), "balh", "fralh", pilosa.FrameOptions{})
+	err = client.CreateField(context.Background(), "balh", "fralh", pilosa.FieldOptions{})
 	if err != nil {
-		t.Fatalf("creating frame: %v", err)
+		t.Fatalf("creating field: %v", err)
 	}
 
 	time.Sleep(time.Millisecond * 2)
diff --git a/stats_test.go b/stats_test.go
index 611b7b2b6..55e90a741 100644
--- a/stats_test.go
+++ b/stats_test.go
@@ -42,39 +42,39 @@ func TestMultiStatClient_Expvar(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("d", "f", pilosa.ViewStandard, 1).SetBit(0, SliceWidth+2)
 	hldr.MustCreateFragmentIfNotExists("d", "f", pilosa.ViewStandard, 0).ClearBit(0, 1)
 
-	if pilosa.Expvar.String() != `{"index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
+	if pilosa.Expvar.String() != `{"index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
 	hldr.Stats.CountWithCustomTags("cc", 1, 1.0, []string{"foo:bar"})
-	if pilosa.Expvar.String() != `{"cc": 1, "index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
+	if pilosa.Expvar.String() != `{"cc": 1, "index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
 	// Gauge creates a unique key, subsequent Gauge calls will overwrite
 	hldr.Stats.Gauge("g", 5, 1.0)
 	hldr.Stats.Gauge("g", 8, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
+	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
 	// Set creates a unique key, subsequent sets will overwrite
 	hldr.Stats.Set("s", "4", 1.0)
 	hldr.Stats.Set("s", "7", 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7"}` {
+	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7"}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
 	// Record timing duration and a uniquely Set key/value
 	dur, _ := time.ParseDuration("123us")
 	hldr.Stats.Timing("tt", dur, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
+	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
 	// Expvar histogram is implemented as a gauge
 	hldr.Stats.Histogram("hh", 3, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "hh": 3, "index:d": {"frame:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
+	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "hh": 3, "index:d": {"field:f": {"view:standard": {"slice:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "slice:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
 		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
 	}
 
@@ -109,7 +109,7 @@ func TestStatsCount_TopN(t *testing.T) {
 			called = true
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`TopN(frame=f, n=2)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`TopN(field=f, n=2)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {
@@ -138,7 +138,7 @@ func TestStatsCount_Bitmap(t *testing.T) {
 			called = true
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`Bitmap(frame=f, row=0)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`Bitmap(field=f, row=0)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {
@@ -155,12 +155,12 @@ func TestStatsCount_SetColumnAttrs(t *testing.T) {
 
 	called := false
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	frame := e.Holder.Frame("d", "f")
-	if frame == nil {
-		t.Fatal("frame not found")
+	field := e.Holder.Field("d", "f")
+	if field == nil {
+		t.Fatal("field not found")
 	}
 
-	frame.Stats = &MockStats{
+	field.Stats = &MockStats{
 		mockCount: func(name string, value int64, rate float64) {
 			if name != "SetRowAttrs" {
 				t.Errorf("Expected SetRowAttrs, Results %s", name)
@@ -168,7 +168,7 @@ func TestStatsCount_SetColumnAttrs(t *testing.T) {
 			called = true
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetRowAttrs(row=10, frame=f, foo="bar")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetRowAttrs(row=10, field=f, foo="bar")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {
@@ -199,7 +199,7 @@ func TestStatsCount_SetProfileAttrs(t *testing.T) {
 			called = true
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetColumnAttrs(col=10, frame=f, foo="bar")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetColumnAttrs(col=10, field=f, foo="bar")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {
@@ -257,7 +257,7 @@ func TestStatsCount_DeleteIndex(t *testing.T) {
 	}
 }
 
-func TestStatsCount_CreateFrame(t *testing.T) {
+func TestStatsCount_CreateField(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 
@@ -272,8 +272,8 @@ func TestStatsCount_CreateFrame(t *testing.T) {
 	called := false
 	s.Handler.API.Holder.Stats = &MockStats{
 		mockCountWithTags: func(name string, value int64, rate float64, index []string) {
-			if name != "createFrame" {
-				t.Errorf("Expected createFrame, Results %s", name)
+			if name != "createField" {
+				t.Errorf("Expected createField, Results %s", name)
 			}
 			if index[0] != "index:i" {
 				t.Errorf("Expected index:i, Results %s", index)
@@ -282,13 +282,13 @@ func TestStatsCount_CreateFrame(t *testing.T) {
 			called = true
 		},
 	}
-	http.DefaultClient.Do(test.MustNewHTTPRequest("POST", s.URL+"/index/i/frame/f", nil))
+	http.DefaultClient.Do(test.MustNewHTTPRequest("POST", s.URL+"/index/i/field/f", nil))
 	if !called {
 		t.Error("Count isn't called")
 	}
 }
 
-func TestStatsCount_DeleteFrame(t *testing.T) {
+func TestStatsCount_DeleteField(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()
 
@@ -298,13 +298,13 @@ func TestStatsCount_DeleteFrame(t *testing.T) {
 	called := false
 	// Create index.
 	indx, _ := hldr.CreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	if _, err := indx.CreateFrameIfNotExists("test", pilosa.FrameOptions{}); err != nil {
+	if _, err := indx.CreateFieldIfNotExists("test", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 	s.Handler.API.Holder.Stats = &MockStats{
 		mockCountWithTags: func(name string, value int64, rate float64, index []string) {
-			if name != "deleteFrame" {
-				t.Errorf("Expected deleteFrame, Results %s", name)
+			if name != "deleteField" {
+				t.Errorf("Expected deleteField, Results %s", name)
 			}
 			if index[0] != "index:i" {
 				t.Errorf("Expected index:i, Results %s", index)
@@ -313,7 +313,7 @@ func TestStatsCount_DeleteFrame(t *testing.T) {
 			called = true
 		},
 	}
-	http.DefaultClient.Do(test.MustNewHTTPRequest("DELETE", s.URL+"/index/i/frame/f", strings.NewReader("")))
+	http.DefaultClient.Do(test.MustNewHTTPRequest("DELETE", s.URL+"/index/i/field/f", strings.NewReader("")))
 	if !called {
 		t.Error("Count isn't called")
 	}
diff --git a/test/cluster.go b/test/cluster.go
index bf6858e79..6b1efe665 100644
--- a/test/cluster.go
+++ b/test/cluster.go
@@ -114,19 +114,19 @@ func (t *TestCluster) CreateIndex(name string) error {
 	return nil
 }
 
-func (t *TestCluster) CreateFrame(index, frame string, opt pilosa.FrameOptions) error {
+func (t *TestCluster) CreateField(index, field string, opt pilosa.FieldOptions) error {
 	for _, c := range t.Clusters {
 		idx, err := c.Holder.CreateIndexIfNotExists(index, pilosa.IndexOptions{})
 		if err != nil {
 			return err
 		}
-		if _, err := idx.CreateFrame(frame, opt); err != nil {
+		if _, err := idx.CreateField(field, opt); err != nil {
 			return err
 		}
 	}
 	return nil
 }
-func (t *TestCluster) SetBit(index, frame, view string, rowID, colID uint64, x *time.Time) error {
+func (t *TestCluster) SetBit(index, field, view string, rowID, colID uint64, x *time.Time) error {
 	// Determine which node should receive the SetBit.
 	c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
 	slice := colID / pilosa.SliceWidth
@@ -137,9 +137,9 @@ func (t *TestCluster) SetBit(index, frame, view string, rowID, colID uint64, x *
 		if c == nil {
 			continue
 		}
-		f := c.Holder.Frame(index, frame)
+		f := c.Holder.Field(index, field)
 		if f == nil {
-			return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
+			return fmt.Errorf("index/field does not exist: %s/%s", index, field)
 		}
 		_, err := f.SetBit(view, rowID, colID, x)
 		if err != nil {
@@ -367,7 +367,7 @@ func (t *TestCluster) FollowResizeInstruction(instr *internal.ResizeInstruction)
 	if err := func() error {
 
 		// figure out which node it was meant for, then call the operation on that cluster
-		// basically need to mimic this: client.RetrieveSliceFromURI(context.Background(), src.Index, src.Frame, src.View, src.Slice, srcURI)
+		// basically need to mimic this: client.RetrieveSliceFromURI(context.Background(), src.Index, src.Field, src.View, src.Slice, srcURI)
 		instrNode := pilosa.DecodeNode(instr.Node)
 		destCluster := t.clusterByID(instrNode.ID)
 
@@ -380,11 +380,11 @@ func (t *TestCluster) FollowResizeInstruction(instr *internal.ResizeInstruction)
 			srcNode := pilosa.DecodeNode(src.Node)
 			srcCluster := t.clusterByID(srcNode.ID)
 
-			srcFragment := srcCluster.Holder.Fragment(src.Index, src.Frame, src.View, src.Slice)
-			destFragment := destCluster.Holder.Fragment(src.Index, src.Frame, src.View, src.Slice)
+			srcFragment := srcCluster.Holder.Fragment(src.Index, src.Field, src.View, src.Slice)
+			destFragment := destCluster.Holder.Fragment(src.Index, src.Field, src.View, src.Slice)
 			if destFragment == nil {
 				// Create fragment on destination if it doesn't exist.
-				f := destCluster.Holder.Frame(src.Index, src.Frame)
+				f := destCluster.Holder.Field(src.Index, src.Field)
 				v := f.View(src.View)
 				var err error
 				destFragment, err = v.CreateFragmentIfNotExists(src.Slice)
diff --git a/test/fragment.go b/test/fragment.go
index cd1111750..1280d3801 100644
--- a/test/fragment.go
+++ b/test/fragment.go
@@ -31,7 +31,7 @@ type Fragment struct {
 }
 
 // NewFragment returns a new instance of Fragment with a temporary path.
-func NewFragment(index, frame, view string, slice uint64, cacheType string) *Fragment {
+func NewFragment(index, field, view string, slice uint64, cacheType string) *Fragment {
 	file, err := ioutil.TempFile("", "pilosa-fragment-")
 	if err != nil {
 		panic(err)
@@ -39,7 +39,7 @@ func NewFragment(index, frame, view string, slice uint64, cacheType string) *Fra
 	file.Close()
 
 	f := &Fragment{
-		Fragment:     pilosa.NewFragment(file.Name(), index, frame, view, slice),
+		Fragment:     pilosa.NewFragment(file.Name(), index, field, view, slice),
 		RowAttrStore: MustOpenAttrStore(),
 	}
 	f.Fragment.CacheType = cacheType
@@ -48,11 +48,11 @@ func NewFragment(index, frame, view string, slice uint64, cacheType string) *Fra
 }
 
 // MustOpenFragment creates and opens an fragment at a temporary path. Panic on error.
-func MustOpenFragment(index, frame, view string, slice uint64, cacheType string) *Fragment {
+func MustOpenFragment(index, field, view string, slice uint64, cacheType string) *Fragment {
 	if cacheType == "" {
 		cacheType = pilosa.DefaultCacheType
 	}
-	f := NewFragment(index, frame, view, slice, cacheType)
+	f := NewFragment(index, field, view, slice, cacheType)
 
 	if err := f.Open(); err != nil {
 		panic(err)
@@ -76,7 +76,7 @@ func (f *Fragment) Reopen() error {
 		return err
 	}
 
-	f.Fragment = pilosa.NewFragment(path, f.Index(), f.Frame(), f.View(), f.Slice())
+	f.Fragment = pilosa.NewFragment(path, f.Index(), f.Field(), f.View(), f.Slice())
 	f.Fragment.CacheType = cacheType
 	f.Fragment.RowAttrStore = f.RowAttrStore
 	if err := f.Open(); err != nil {
diff --git a/test/frame.go b/test/frame.go
index 09503a3cf..75dc5800d 100644
--- a/test/frame.go
+++ b/test/frame.go
@@ -23,48 +23,48 @@ import (
 	"github.com/pilosa/pilosa"
 )
 
-// Frame represents a test wrapper for pilosa.Frame.
-type Frame struct {
-	*pilosa.Frame
+// Field represents a test wrapper for pilosa.Field.
+type Field struct {
+	*pilosa.Field
 }
 
-// NewFrame returns a new instance of Frame d/0.
-func NewFrame(opt ...pilosa.FrameOption) *Frame {
-	path, err := ioutil.TempDir("", "pilosa-frame-")
+// NewField returns a new instance of Field d/0.
+func NewField(opt ...pilosa.FieldOption) *Field {
+	path, err := ioutil.TempDir("", "pilosa-field-")
 	if err != nil {
 		panic(err)
 	}
-	frame, err := pilosa.NewFrame(path, "i", "f", opt...)
+	field, err := pilosa.NewField(path, "i", "f", opt...)
 	if err != nil {
 		panic(err)
 	}
-	return &Frame{Frame: frame}
+	return &Field{Field: field}
 }
 
-// MustOpenFrame returns a new, opened frame at a temporary path. Panic on error.
-func MustOpenFrame(opt ...pilosa.FrameOption) *Frame {
-	f := NewFrame(opt...)
+// MustOpenField returns a new, opened field at a temporary path. Panic on error.
+func MustOpenField(opt ...pilosa.FieldOption) *Field {
+	f := NewField(opt...)
 	if err := f.Open(); err != nil {
 		panic(err)
 	}
 	return f
 }
 
-// Close closes the frame and removes the underlying data.
-func (f *Frame) Close() error {
+// Close closes the field and removes the underlying data.
+func (f *Field) Close() error {
 	defer os.RemoveAll(f.Path())
-	return f.Frame.Close()
+	return f.Field.Close()
 }
 
 // Reopen closes the index and reopens it.
-func (f *Frame) Reopen() error {
+func (f *Field) Reopen() error {
 	var err error
-	if err := f.Frame.Close(); err != nil {
+	if err := f.Field.Close(); err != nil {
 		return err
 	}
 
 	path, index, name := f.Path(), f.Index(), f.Name()
-	f.Frame, err = pilosa.NewFrame(path, index, name)
+	f.Field, err = pilosa.NewField(path, index, name)
 	if err != nil {
 		return err
 	}
@@ -75,8 +75,8 @@ func (f *Frame) Reopen() error {
 	return nil
 }
 
-// MustSetBit sets a bit on the frame. Panic on error.
-func (f *Frame) MustSetBit(view string, rowID, columnID uint64, t *time.Time) (changed bool) {
+// MustSetBit sets a bit on the field. Panic on error.
+func (f *Field) MustSetBit(view string, rowID, columnID uint64, t *time.Time) (changed bool) {
 	changed, err := f.SetBit(view, rowID, columnID, t)
 	if err != nil {
 		panic(err)
@@ -84,23 +84,23 @@ func (f *Frame) MustSetBit(view string, rowID, columnID uint64, t *time.Time) (c
 	return changed
 }
 
-// Ensure frame can set its cache
-func TestFrame_SetCacheSize(t *testing.T) {
-	f := MustOpenFrame()
+// Ensure field can set its cache
+func TestField_SetCacheSize(t *testing.T) {
+	f := MustOpenField()
 	defer f.Close()
 	cacheSize := uint32(100)
 
-	// Set & retrieve frame cache size.
+	// Set & retrieve field cache size.
 	if err := f.SetCacheSize(cacheSize); err != nil {
 		t.Fatal(err)
 	} else if q := f.CacheSize(); q != cacheSize {
-		t.Fatalf("unexpected frame cache size: %d", q)
+		t.Fatalf("unexpected field cache size: %d", q)
 	}
 
-	// Reload frame and verify that it is persisted.
+	// Reload field and verify that it is persisted.
 	if err := f.Reopen(); err != nil {
 		t.Fatal(err)
 	} else if q := f.CacheSize(); q != cacheSize {
-		t.Fatalf("unexpected frame cache size (reopen): %d", q)
+		t.Fatalf("unexpected field cache size (reopen): %d", q)
 	}
 }
diff --git a/test/holder.go b/test/holder.go
index 97b399bea..3cb0a8791 100644
--- a/test/holder.go
+++ b/test/holder.go
@@ -80,9 +80,9 @@ func (h *Holder) MustCreateIndexIfNotExists(index string, opt pilosa.IndexOption
 	return &Index{Index: idx}
 }
 
-// MustCreateFrameIfNotExists returns a given frame. Panic on error.
-func (h *Holder) MustCreateFrameIfNotExists(index, frame string) *Frame {
-	f, err := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{}).CreateFrameIfNotExists(frame, pilosa.FrameOptions{})
+// MustCreateFieldIfNotExists returns a given field. Panic on error.
+func (h *Holder) MustCreateFieldIfNotExists(index, field string) *Field {
+	f, err := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{}).CreateFieldIfNotExists(field, pilosa.FieldOptions{})
 	if err != nil {
 		panic(err)
 	}
@@ -90,9 +90,9 @@ func (h *Holder) MustCreateFrameIfNotExists(index, frame string) *Frame {
 }
 
 // MustCreateFragmentIfNotExists returns a given fragment. Panic on error.
-func (h *Holder) MustCreateFragmentIfNotExists(index, frame, view string, slice uint64) *Fragment {
+func (h *Holder) MustCreateFragmentIfNotExists(index, field, view string, slice uint64) *Fragment {
 	idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
-	f, err := idx.CreateFrameIfNotExists(frame, pilosa.FrameOptions{})
+	f, err := idx.CreateFieldIfNotExists(field, pilosa.FieldOptions{})
 	if err != nil {
 		panic(err)
 	}
@@ -108,9 +108,9 @@ func (h *Holder) MustCreateFragmentIfNotExists(index, frame, view string, slice
 }
 
 // MustCreateRankedFragmentIfNotExists returns a given fragment with a ranked cache. Panic on error.
-func (h *Holder) MustCreateRankedFragmentIfNotExists(index, frame, view string, slice uint64) *Fragment {
+func (h *Holder) MustCreateRankedFragmentIfNotExists(index, field, view string, slice uint64) *Fragment {
 	idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
-	f, err := idx.CreateFrameIfNotExists(frame, pilosa.FrameOptions{CacheType: pilosa.CacheTypeRanked})
+	f, err := idx.CreateFieldIfNotExists(field, pilosa.FieldOptions{CacheType: pilosa.CacheTypeRanked})
 	if err != nil {
 		panic(err)
 	}
diff --git a/test/index.go b/test/index.go
index 5354c85f9..69c18682c 100644
--- a/test/index.go
+++ b/test/index.go
@@ -73,20 +73,20 @@ func (i *Index) Reopen() error {
 	return nil
 }
 
-// CreateFrame creates a frame with the given options.
-func (i *Index) CreateFrame(name string, opt pilosa.FrameOptions) (*Frame, error) {
-	f, err := i.Index.CreateFrame(name, opt)
+// CreateField creates a field with the given options.
+func (i *Index) CreateField(name string, opt pilosa.FieldOptions) (*Field, error) {
+	f, err := i.Index.CreateField(name, opt)
 	if err != nil {
 		return nil, err
 	}
-	return &Frame{Frame: f}, nil
+	return &Field{Field: f}, nil
 }
 
-// CreateFrameIfNotExists creates a frame with the given options if it doesn't exist.
-func (i *Index) CreateFrameIfNotExists(name string, opt pilosa.FrameOptions) (*Frame, error) {
-	f, err := i.Index.CreateFrameIfNotExists(name, opt)
+// CreateFieldIfNotExists creates a field with the given options if it doesn't exist.
+func (i *Index) CreateFieldIfNotExists(name string, opt pilosa.FieldOptions) (*Field, error) {
+	f, err := i.Index.CreateFieldIfNotExists(name, opt)
 	if err != nil {
 		return nil, err
 	}
-	return &Frame{Frame: f}, nil
+	return &Field{Field: f}, nil
 }
diff --git a/time_test.go b/time_test.go
index 233a2ae1a..3ab652455 100644
--- a/time_test.go
+++ b/time_test.go
@@ -65,7 +65,7 @@ func TestViewByTimeUnit(t *testing.T) {
 	})
 }
 
-// Ensure all applicable frame names can be generated when mutating a time bit.
+// Ensure all applicable field names can be generated when mutating a time bit.
 func TestViewsByTime(t *testing.T) {
 	ts := time.Date(2000, time.January, 2, 3, 4, 5, 6, time.UTC)
 
@@ -84,66 +84,66 @@ func TestViewsByTime(t *testing.T) {
 	})
 }
 
-// Ensure sets of frames can be returned for a given time range.
+// Ensure sets of fields can be returned for a given time range.
 func TestViewsByTimeRange(t *testing.T) {
 	t.Run("Y", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-01-01 00:00"), MustParseTime("2002-01-01 00:00"), MustParseTimeQuantum("Y"))
 		if !reflect.DeepEqual(a, []string{"F_2000", "F_2001"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("YM", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-11-01 00:00"), MustParseTime("2003-03-01 00:00"), MustParseTimeQuantum("YM"))
 		if !reflect.DeepEqual(a, []string{"F_200011", "F_200012", "F_2001", "F_2002", "F_200301", "F_200302"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("YMD", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-11-28 00:00"), MustParseTime("2003-03-02 00:00"), MustParseTimeQuantum("YMD"))
 		if !reflect.DeepEqual(a, []string{"F_20001128", "F_20001129", "F_20001130", "F_200012", "F_2001", "F_2002", "F_200301", "F_200302", "F_20030301"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("YMDH", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-11-28 22:00"), MustParseTime("2002-03-01 03:00"), MustParseTimeQuantum("YMDH"))
 		if !reflect.DeepEqual(a, []string{"F_2000112822", "F_2000112823", "F_20001129", "F_20001130", "F_200012", "F_2001", "F_200201", "F_200202", "F_2002030100", "F_2002030101", "F_2002030102"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("M", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-01-01 00:00"), MustParseTime("2000-03-01 00:00"), MustParseTimeQuantum("M"))
 		if !reflect.DeepEqual(a, []string{"F_200001", "F_200002"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("MD", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-11-29 00:00"), MustParseTime("2002-02-03 00:00"), MustParseTimeQuantum("MD"))
 		if !reflect.DeepEqual(a, []string{"F_20001129", "F_20001130", "F_200012", "F_200101", "F_200102", "F_200103", "F_200104", "F_200105", "F_200106", "F_200107", "F_200108", "F_200109", "F_200110", "F_200111", "F_200112", "F_200201", "F_20020201", "F_20020202"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("MDH", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-11-29 22:00"), MustParseTime("2002-03-02 03:00"), MustParseTimeQuantum("MDH"))
 		if !reflect.DeepEqual(a, []string{"F_2000112922", "F_2000112923", "F_20001130", "F_200012", "F_200101", "F_200102", "F_200103", "F_200104", "F_200105", "F_200106", "F_200107", "F_200108", "F_200109", "F_200110", "F_200111", "F_200112", "F_200201", "F_200202", "F_20020301", "F_2002030200", "F_2002030201", "F_2002030202"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("D", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-01-01 00:00"), MustParseTime("2000-01-04 00:00"), MustParseTimeQuantum("D"))
 		if !reflect.DeepEqual(a, []string{"F_20000101", "F_20000102", "F_20000103"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("DH", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-01-01 22:00"), MustParseTime("2000-03-01 02:00"), MustParseTimeQuantum("DH"))
 		if !reflect.DeepEqual(a, []string{"F_2000010122", "F_2000010123", "F_20000102", "F_20000103", "F_20000104", "F_20000105", "F_20000106", "F_20000107", "F_20000108", "F_20000109", "F_20000110", "F_20000111", "F_20000112", "F_20000113", "F_20000114", "F_20000115", "F_20000116", "F_20000117", "F_20000118", "F_20000119", "F_20000120", "F_20000121", "F_20000122", "F_20000123", "F_20000124", "F_20000125", "F_20000126", "F_20000127", "F_20000128", "F_20000129", "F_20000130", "F_20000131", "F_20000201", "F_20000202", "F_20000203", "F_20000204", "F_20000205", "F_20000206", "F_20000207", "F_20000208", "F_20000209", "F_20000210", "F_20000211", "F_20000212", "F_20000213", "F_20000214", "F_20000215", "F_20000216", "F_20000217", "F_20000218", "F_20000219", "F_20000220", "F_20000221", "F_20000222", "F_20000223", "F_20000224", "F_20000225", "F_20000226", "F_20000227", "F_20000228", "F_20000229", "F_2000030100", "F_2000030101"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 	t.Run("H", func(t *testing.T) {
 		a := pilosa.ViewsByTimeRange("F", MustParseTime("2000-01-01 00:00"), MustParseTime("2000-01-01 02:00"), MustParseTimeQuantum("H"))
 		if !reflect.DeepEqual(a, []string{"F_2000010100", "F_2000010101"}) {
-			t.Fatalf("unexpected frames: %#v", a)
+			t.Fatalf("unexpected fields: %#v", a)
 		}
 	})
 }
diff --git a/utils_test.go b/utils_test.go
index eb4170a19..6335d087f 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -104,20 +104,20 @@ func (t *ClusterCluster) CreateIndex(name string) error {
 	return nil
 }
 
-func (t *ClusterCluster) CreateFrame(index, frame string, opt FrameOptions) error {
+func (t *ClusterCluster) CreateField(index, field string, opt FieldOptions) error {
 	for _, c := range t.Clusters {
 		idx, err := c.Holder.CreateIndexIfNotExists(index, IndexOptions{})
 		if err != nil {
 			return err
 		}
-		if _, err := idx.CreateFrame(frame, opt); err != nil {
+		if _, err := idx.CreateField(field, opt); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (t *ClusterCluster) SetBit(index, frame, view string, rowID, colID uint64, x *time.Time) error {
+func (t *ClusterCluster) SetBit(index, field, view string, rowID, colID uint64, x *time.Time) error {
 	// Determine which node should receive the SetBit.
 	c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
 	slice := colID / SliceWidth
@@ -128,9 +128,9 @@ func (t *ClusterCluster) SetBit(index, frame, view string, rowID, colID uint64,
 		if c == nil {
 			continue
 		}
-		f := c.Holder.Frame(index, frame)
+		f := c.Holder.Field(index, field)
 		if f == nil {
-			return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
+			return fmt.Errorf("index/field does not exist: %s/%s", index, field)
 		}
 		_, err := f.SetBit(view, rowID, colID, x)
 		if err != nil {
@@ -356,7 +356,7 @@ func (t *ClusterCluster) FollowResizeInstruction(instr *internal.ResizeInstructi
 	if err := func() error {
 
 		// figure out which node it was meant for, then call the operation on that cluster
-		// basically need to mimic this: client.RetrieveSliceFromURI(context.Background(), src.Index, src.Frame, src.View, src.Slice, srcURI)
+		// basically need to mimic this: client.RetrieveSliceFromURI(context.Background(), src.Index, src.Field, src.View, src.Slice, srcURI)
 		instrNode := DecodeNode(instr.Node)
 		destCluster := t.clusterByID(instrNode.ID)
 
@@ -369,11 +369,11 @@ func (t *ClusterCluster) FollowResizeInstruction(instr *internal.ResizeInstructi
 			srcNode := DecodeNode(src.Node)
 			srcCluster := t.clusterByID(srcNode.ID)
 
-			srcFragment := srcCluster.Holder.Fragment(src.Index, src.Frame, src.View, src.Slice)
-			destFragment := destCluster.Holder.Fragment(src.Index, src.Frame, src.View, src.Slice)
+			srcFragment := srcCluster.Holder.Fragment(src.Index, src.Field, src.View, src.Slice)
+			destFragment := destCluster.Holder.Fragment(src.Index, src.Field, src.View, src.Slice)
 			if destFragment == nil {
 				// Create fragment on destination if it doesn't exist.
-				f := destCluster.Holder.Frame(src.Index, src.Frame)
+				f := destCluster.Holder.Field(src.Index, src.Field)
 				v := f.View(src.View)
 				var err error
 				destFragment, err = v.CreateFragmentIfNotExists(src.Slice)
diff --git a/view.go b/view.go
index 38c76a162..d76f33d59 100644
--- a/view.go
+++ b/view.go
@@ -39,18 +39,18 @@ func IsValidView(name string) bool {
 	return name == ViewStandard
 }
 
-// View represents a container for frame data.
+// View represents a container for field data.
 type View struct {
 	mu    sync.RWMutex
 	path  string
 	index string
-	frame string
+	field string
 	name  string
 
 	cacheSize uint32
 
 	// Fragments by slice.
-	cacheType string // passed in by frame
+	cacheType string // passed in by field
 	fragments map[uint64]*Fragment
 
 	// maxSlice maintains this view's max slice in order to
@@ -65,11 +65,11 @@ type View struct {
 }
 
 // NewView returns a new instance of View.
-func NewView(path, index, frame, name string, cacheSize uint32) *View {
+func NewView(path, index, field, name string, cacheSize uint32) *View {
 	return &View{
 		path:      path,
 		index:     index,
-		frame:     frame,
+		field:     field,
 		name:      name,
 		cacheSize: cacheSize,
 
@@ -88,8 +88,8 @@ func (v *View) Name() string { return v.name }
 // Index returns the index name the view was initialized with.
 func (v *View) Index() string { return v.index }
 
-// Frame returns the frame name the view was initialized with.
-func (v *View) Frame() string { return v.frame }
+// Field returns the field name the view was initialized with.
+func (v *View) Field() string { return v.field }
 
 // Path returns the path the view was initialized with.
 func (v *View) Path() string { return v.path }
@@ -265,7 +265,7 @@ func (v *View) createFragmentIfNotExists(slice uint64) (*Fragment, error) {
 }
 
 func (v *View) newFragment(path string, slice uint64) *Fragment {
-	frag := NewFragment(path, v.index, v.frame, v.name, slice)
+	frag := NewFragment(path, v.index, v.field, v.name, slice)
 	frag.CacheType = v.cacheType
 	frag.CacheSize = v.cacheSize
 	frag.Logger = v.Logger
@@ -281,7 +281,7 @@ func (v *View) DeleteFragment(slice uint64) error {
 		return ErrFragmentNotFound
 	}
 
-	v.Logger.Printf("delete fragment: (%s/%s/%s) %d", v.index, v.frame, v.name, slice)
+	v.Logger.Printf("delete fragment: (%s/%s/%s) %d", v.index, v.field, v.name, slice)
 
 	// Close data files before deletion.
 	if err := fragment.Close(); err != nil {
diff --git a/view_test.go b/view_test.go
index 21834113d..217c4bbb4 100644
--- a/view_test.go
+++ b/view_test.go
@@ -30,14 +30,14 @@ type View struct {
 }
 
 // NewView returns a new instance of View with a temporary path.
-func NewView(index, frame, name string) *View {
+func NewView(index, field, name string) *View {
 	path, err := ioutil.TempDir("", "pilosa-view-")
 	if err != nil {
 		panic(err)
 	}
 
 	v := &View{
-		View:         pilosa.NewView(path, index, frame, name, pilosa.DefaultCacheSize),
+		View:         pilosa.NewView(path, index, field, name, pilosa.DefaultCacheSize),
 		RowAttrStore: test.MustOpenAttrStore(),
 	}
 	v.View.RowAttrStore = v.RowAttrStore
@@ -45,8 +45,8 @@ func NewView(index, frame, name string) *View {
 }
 
 // MustOpenView creates and opens an view at a temporary path. Panic on error.
-func MustOpenView(index, frame, name string) *View {
-	v := NewView(index, frame, name)
+func MustOpenView(index, field, name string) *View {
+	v := NewView(index, field, name)
 	if err := v.Open(); err != nil {
 		panic(err)
 	}
@@ -67,7 +67,7 @@ func (v *View) Reopen() error {
 		return err
 	}
 
-	v.View = pilosa.NewView(path, v.Index(), v.Frame(), v.Name(), pilosa.DefaultCacheSize)
+	v.View = pilosa.NewView(path, v.Index(), v.Field(), v.Name(), pilosa.DefaultCacheSize)
 	v.View.RowAttrStore = v.RowAttrStore
 	return v.Open()
 }