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

rename oField to bsiGroup

Browse source
This commit is contained in:
Travis Turner 2018-06-04 15:32:43 -05:00
parent ac3a0b1eca
commit 1f476c9078
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
3 changed files with 122 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
api.go
View file

@ -489,7 +489,7 @@ func (api *API) Schema(ctx context.Context) []*IndexInfo {
}
// CreateField creates a new BSI field in the given index and frame.
func (api *API) CreateField(ctx context.Context, indexName string, frameName string, field *oField) error {
func (api *API) CreateField(ctx context.Context, indexName string, frameName string, bsig *bsiGroup) error {
if err := api.validate(apiCreateField); err != nil {
return errors.Wrap(err, "validating api method")
}
@ -500,17 +500,17 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str
return ErrFrameNotFound
}
// Create new field.
if err := f.CreateField(field); err != nil {
return errors.Wrap(err, "creating field")
// Create new bsiGroup.
if err := f.CreateField(bsig); err != nil {
return errors.Wrap(err, "creating bsigroup")
}
// Send the create field message to all nodes.
// Send the create bsigroup message to all nodes.
err := api.Broadcaster.SendSync(
&internal.CreateFieldMessage{
Index: indexName,
Frame: frameName,
Field: encodeField(field),
Field: encodeField(bsig),
})
if err != nil {
api.Logger.Printf("problem sending CreateField message: %s", err)

113
frame.go
View file

@ -64,7 +64,7 @@ type Frame struct {
// Frame options.
options FrameOptions
fields []*oField
fields []*bsiGroup
Logger Logger
}
@ -325,19 +325,19 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
f.options.Max = opt.Max
f.options.TimeQuantum = ""
// Create new field.
field := &oField{
// Create new bsiGroup.
bsig := &bsiGroup{
Name: f.name,
Type: FieldTypeInt,
Min: opt.Min,
Max: opt.Max,
}
// Validate field.
if err := ValidateField(field); err != nil {
// Validate bsiGroup.
if err := ValidateField(bsig); err != nil {
return err
}
if err := f.CreateField(field); err != nil {
return errors.Wrap(err, "creating field")
if err := f.CreateField(bsig); err != nil {
return errors.Wrap(err, "creating bsigroup")
}
case FrameTypeTime:
f.options.Type = opt.Type
@ -379,7 +379,7 @@ func (f *Frame) Close() error {
}
// Field returns a field by name.
func (f *Frame) Field(name string) *oField {
func (f *Frame) Field(name string) *bsiGroup {
f.mu.RLock()
defer f.mu.RUnlock()
for _, field := range f.fields {
@ -401,12 +401,12 @@ func (f *Frame) hasField(name string) bool {
}
// CreateField creates a new field on the frame.
func (f *Frame) CreateField(field *oField) error {
func (f *Frame) CreateField(bsig *bsiGroup) error {
f.mu.Lock()
defer f.mu.Unlock()
// Append field.
if err := f.addField(field); err != nil {
// Append bsiGroup.
if err := f.addField(bsig); err != nil {
return err
}
f.saveMeta()
@ -414,15 +414,15 @@ func (f *Frame) CreateField(field *oField) error {
}
// addField adds a single field to fields.
func (f *Frame) addField(field *oField) error {
if err := ValidateField(field); err != nil {
return errors.Wrap(err, "validating field")
} else if f.hasField(field.Name) {
func (f *Frame) addField(bsig *bsiGroup) error {
if err := ValidateField(bsig); err != nil {
return errors.Wrap(err, "validating bsigroup")
} else if f.hasField(bsig.Name) {
return ErrFieldExists
}
// Add field to list.
f.fields = append(f.fields, field)
// Add bsiGroup to list.
f.fields = append(f.fields, bsig)
// Sort fields by name.
sort.Slice(f.fields, func(i, j int) bool {
@ -1084,9 +1084,8 @@ func IsValidFieldType(v string) bool {
}
}
// TODO: finish unexporting this. also, rename it.
// oField represents a range field on a frame.
type oField struct {
// bsiGroup represents a range field on a frame.
type bsiGroup struct {
Name string `json:"name,omitempty"`
Type string `json:"type,omitempty"`
Min int64 `json:"min,omitempty"`
@ -1094,9 +1093,9 @@ type oField struct {
}
// BitDepth returns the number of bits required to store a value between min & max.
func (f *oField) BitDepth() uint {
func (b *bsiGroup) BitDepth() uint {
for i := uint(0); i < 63; i++ {
if f.Max-f.Min < (1 << i) {
if b.Max-b.Min < (1 << i) {
return i
}
}
@ -1115,80 +1114,80 @@ func (f *oField) BitDepth() uint {
// In order to make this work, we effectively need to change the operator to LTE.
// Executor.executeFieldRangeSlice() takes this into account and returns
// `frag.FieldNotNull(field.BitDepth())` in such instances.
func (f *oField) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
func (b *bsiGroup) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
if op == pql.GT || op == pql.GTE {
if value > f.Max {
if value > b.Max {
return baseValue, true
} else if value > f.Min {
baseValue = uint64(value - f.Min)
} else if value > b.Min {
baseValue = uint64(value - b.Min)
}
} else if op == pql.LT || op == pql.LTE {
if value < f.Min {
if value < b.Min {
return baseValue, true
} else if value > f.Max {
baseValue = uint64(f.Max - f.Min)
} else if value > b.Max {
baseValue = uint64(b.Max - b.Min)
} else {
baseValue = uint64(value - f.Min)
baseValue = uint64(value - b.Min)
}
} else if op == pql.EQ || op == pql.NEQ {
if value < f.Min || value > f.Max {
if value < b.Min || value > b.Max {
return baseValue, true
}
baseValue = uint64(value - f.Min)
baseValue = uint64(value - b.Min)
}
return baseValue, false
}
// BaseValueBetween adjusts the min/max value to align with the range for Field.
func (f *oField) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
if max < f.Min || min > f.Max {
func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
if max < b.Min || min > b.Max {
return baseValueMin, baseValueMax, true
}
// Adjust min/max to range.
if min > f.Min {
baseValueMin = uint64(min - f.Min)
if min > b.Min {
baseValueMin = uint64(min - b.Min)
}
// Make sure the high value of the BETWEEN does not exceed BitDepth.
if max > f.Max {
baseValueMax = uint64(f.Max - f.Min)
} else if max > f.Min {
baseValueMax = uint64(max - f.Min)
if max > b.Max {
baseValueMax = uint64(b.Max - b.Min)
} else if max > b.Min {
baseValueMax = uint64(max - b.Min)
}
return baseValueMin, baseValueMax, false
}
func ValidateField(f *oField) error {
if f.Name == "" {
func ValidateField(b *bsiGroup) error {
if b.Name == "" {
return ErrFieldNameRequired
} else if !IsValidFieldType(f.Type) {
} else if !IsValidFieldType(b.Type) {
return ErrInvalidFieldType
} else if f.Min > f.Max {
} else if b.Min > b.Max {
return ErrInvalidFieldRange
}
return nil
}
func encodeField(f *oField) *internal.Field {
if f == nil {
func encodeField(b *bsiGroup) *internal.Field {
if b == nil {
return nil
}
return &internal.Field{
Name: f.Name,
Type: f.Type,
Min: int64(f.Min),
Max: int64(f.Max),
Name: b.Name,
Type: b.Type,
Min: int64(b.Min),
Max: int64(b.Max),
}
}
func decodeField(f *internal.Field) *oField {
if f == nil {
func decodeField(b *internal.Field) *bsiGroup {
if b == nil {
return nil
}
return &oField{
Name: f.Name,
Type: f.Type,
Min: f.Min,
Max: f.Max,
return &bsiGroup{
Name: b.Name,
Type: b.Type,
Min: b.Min,
Max: b.Max,
}
}

120
frame_internal_test.go
View file

@ -23,21 +23,21 @@ import (
// Ensure a field can adjust to its baseValue.
func TestField_BaseValue(t *testing.T) {
f0 := &oField{
Name: "f0",
b0 := &bsiGroup{
Name: "b0",
Type: FieldTypeInt,
Min: -100,
Max: 900,
}
f1 := &oField{
Name: "f1",
b1 := &bsiGroup{
Name: "b1",
Type: FieldTypeInt,
Min: 0,
Max: 1000,
}
f2 := &oField{
Name: "f2",
b2 := &bsiGroup{
Name: "b2",
Type: FieldTypeInt,
Min: 100,
Max: 1100,
@ -46,60 +46,60 @@ func TestField_BaseValue(t *testing.T) {
t.Run("Normal Condition", func(t *testing.T) {
for _, tt := range []struct {
f *oField
f *bsiGroup
op pql.Token
val int64
expBaseValue uint64
expOutOfRange bool
}{
// LT
{f0, pql.LT, 5, 105, false},
{f0, pql.LT, -8, 92, false},
{f0, pql.LT, -108, 0, true},
{f0, pql.LT, 1005, 1000, false},
{f0, pql.LT, 0, 100, false},
{b0, pql.LT, 5, 105, false},
{b0, pql.LT, -8, 92, false},
{b0, pql.LT, -108, 0, true},
{b0, pql.LT, 1005, 1000, false},
{b0, pql.LT, 0, 100, false},
{f1, pql.LT, 5, 5, false},
{f1, pql.LT, -8, 0, true},
{f1, pql.LT, 1005, 1000, false},
{f1, pql.LT, 0, 0, false},
{b1, pql.LT, 5, 5, false},
{b1, pql.LT, -8, 0, true},
{b1, pql.LT, 1005, 1000, false},
{b1, pql.LT, 0, 0, false},
{f2, pql.LT, 5, 0, true},
{f2, pql.LT, -8, 0, true},
{f2, pql.LT, 105, 5, false},
{f2, pql.LT, 1105, 1000, false},
{b2, pql.LT, 5, 0, true},
{b2, pql.LT, -8, 0, true},
{b2, pql.LT, 105, 5, false},
{b2, pql.LT, 1105, 1000, false},
// GT
{f0, pql.GT, -105, 0, false},
{f0, pql.GT, 5, 105, false},
{f0, pql.GT, 905, 0, true},
{f0, pql.GT, 0, 100, false},
{b0, pql.GT, -105, 0, false},
{b0, pql.GT, 5, 105, false},
{b0, pql.GT, 905, 0, true},
{b0, pql.GT, 0, 100, false},
{f1, pql.GT, 5, 5, false},
{f1, pql.GT, -8, 0, false},
{f1, pql.GT, 1005, 0, true},
{f1, pql.GT, 0, 0, false},
{b1, pql.GT, 5, 5, false},
{b1, pql.GT, -8, 0, false},
{b1, pql.GT, 1005, 0, true},
{b1, pql.GT, 0, 0, false},
{f2, pql.GT, 5, 0, false},
{f2, pql.GT, -8, 0, false},
{f2, pql.GT, 105, 5, false},
{f2, pql.GT, 1105, 0, true},
{b2, pql.GT, 5, 0, false},
{b2, pql.GT, -8, 0, false},
{b2, pql.GT, 105, 5, false},
{b2, pql.GT, 1105, 0, true},
// EQ
{f0, pql.EQ, -105, 0, true},
{f0, pql.EQ, 5, 105, false},
{f0, pql.EQ, 905, 0, true},
{f0, pql.EQ, 0, 100, false},
{b0, pql.EQ, -105, 0, true},
{b0, pql.EQ, 5, 105, false},
{b0, pql.EQ, 905, 0, true},
{b0, pql.EQ, 0, 100, false},
{f1, pql.EQ, 5, 5, false},
{f1, pql.EQ, -8, 0, true},
{f1, pql.EQ, 1005, 0, true},
{f1, pql.EQ, 0, 0, false},
{b1, pql.EQ, 5, 5, false},
{b1, pql.EQ, -8, 0, true},
{b1, pql.EQ, 1005, 0, true},
{b1, pql.EQ, 0, 0, false},
{f2, pql.EQ, 5, 0, true},
{f2, pql.EQ, -8, 0, true},
{f2, pql.EQ, 105, 5, false},
{f2, pql.EQ, 1105, 0, true},
{b2, pql.EQ, 5, 0, true},
{b2, pql.EQ, -8, 0, true},
{b2, pql.EQ, 105, 5, false},
{b2, pql.EQ, 1105, 0, true},
} {
bv, oor := tt.f.BaseValue(tt.op, tt.val)
if oor != tt.expOutOfRange {
@ -112,7 +112,7 @@ func TestField_BaseValue(t *testing.T) {
t.Run("Betwween Condition", func(t *testing.T) {
for _, tt := range []struct {
f *oField
f *bsiGroup
predMin int64
predMax int64
expBaseValueMin uint64
@ -120,23 +120,23 @@ func TestField_BaseValue(t *testing.T) {
expOutOfRange bool
}{
{f0, -205, -105, 0, 0, true},
{f0, -105, 80, 0, 180, false},
{f0, 5, 20, 105, 120, false},
{f0, 20, 1005, 120, 1000, false},
{f0, 1005, 2000, 0, 0, true},
{b0, -205, -105, 0, 0, true},
{b0, -105, 80, 0, 180, false},
{b0, 5, 20, 105, 120, false},
{b0, 20, 1005, 120, 1000, false},
{b0, 1005, 2000, 0, 0, true},
{f1, -105, -5, 0, 0, true},
{f1, -5, 20, 0, 20, false},
{f1, 5, 20, 5, 20, false},
{f1, 20, 1005, 20, 1000, false},
{f1, 1005, 2000, 0, 0, true},
{b1, -105, -5, 0, 0, true},
{b1, -5, 20, 0, 20, false},
{b1, 5, 20, 5, 20, false},
{b1, 20, 1005, 20, 1000, false},
{b1, 1005, 2000, 0, 0, true},
{f2, 5, 95, 0, 0, true},
{f2, 95, 120, 0, 20, false},
{f2, 105, 120, 5, 20, false},
{f2, 120, 1105, 20, 1000, false},
{f2, 1105, 2000, 0, 0, true},
{b2, 5, 95, 0, 0, true},
{b2, 95, 120, 0, 20, false},
{b2, 105, 120, 5, 20, false},
{b2, 120, 1105, 20, 1000, false},
{b2, 1105, 2000, 0, 0, true},
} {
min, max, oor := tt.f.BaseValueBetween(tt.predMin, tt.predMax)
if oor != tt.expOutOfRange {