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

fb-1729 Enriched Table Metadata (#2255)

Browse source 
enriched metadata for tables

added support for the concept of a table and field owners in metadata; mechanism to derive owner from http request metadata; metadata for table description
This commit is contained in:
pokeeffe-molecula 2022-10-26 11:23:40 -05:00 • committed by GitHub
parent 37ae0ce51a
commit fb40cdc2cb
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
35 changed files with 2307 additions and 1357 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
Makefile
View file

@ -206,12 +206,8 @@ generate-pql: require-peg
generate-proto-grpc: require-protoc require-protoc-gen-go
protoc -I proto proto/pilosa.proto --go_out=plugins=grpc:proto
protoc -I proto proto/vdsm/vdsm.proto --go_out=plugins=grpc:proto
# TODO: Modify above commands and remove the below mv if possible.
# See https://go-review.googlesource.com/c/protobuf/+/219298/ for info on --go-opt
# I couldn't get it to work during development - Cody
cp -r proto/github.com/molecula/featurebase/v3/proto/ proto/
rm -rf proto/github.com
# address re-generation here only if we need to
# protoc -I proto proto/vdsm.proto --go_out=plugins=grpc:proto
# `go generate` all needed packages
generate: generate-protoc generate-statik generate-stringer generate-pql

27
api.go
View file

@ -223,14 +223,23 @@ func (api *API) CreateIndex(ctx context.Context, indexName string, options Index
span, _ := tracing.StartSpanFromContext(ctx, "API.CreateIndex")
defer span.Finish()
// get the requestUserID from the context -- assumes the http handler has populated this from
// authN/Z info
requestUserID, ok := ctx.Value(ContextRequestUserIdKey).(string)
if !ok {
requestUserID = ""
}
if err := api.validate(apiCreateIndex); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
// Populate the create index message.
ts := timestamp()
cim := &CreateIndexMessage{
Index: indexName,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: options,
}
@ -306,6 +315,13 @@ func (api *API) CreateField(ctx context.Context, indexName string, fieldName str
return nil, errors.Wrap(err, "validating api method")
}
// get the requestUserID from the context -- assumes the http handler has populated this from
// authN/Z info
requestUserID, ok := ctx.Value(ContextRequestUserIdKey).(string)
if !ok {
requestUserID = ""
}
// Apply and validate functional options.
fo, err := newFieldOptions(opts...)
if err != nil {
@ -323,11 +339,12 @@ func (api *API) CreateField(ctx context.Context, indexName string, fieldName str
Index: indexName,
Field: fieldName,
CreatedAt: timestamp(),
Owner: requestUserID,
Meta: fo,
}
// Create field.
field, err := index.CreateField(fieldName, opts...)
field, err := index.CreateField(fieldName, requestUserID, opts...)
if err != nil {
return nil, errors.Wrap(err, "creating field")
}
@ -357,7 +374,11 @@ func (api *API) UpdateField(ctx context.Context, indexName, fieldName string, up
return newNotFoundError(ErrIndexNotFound, indexName)
}
cfm, err := index.UpdateField(ctx, fieldName, update)
// get the requestUserID from the context -- assumes the http handler has populated this from
// authN/Z info
requestUserID, _ := ctx.Value(ContextRequestUserIdKey).(string)
cfm, err := index.UpdateField(ctx, fieldName, requestUserID, update)
if err != nil {
return errors.Wrap(err, "updating field")
}

4
api_test.go
View file

@ -1387,11 +1387,11 @@ func TestVariousApiTranslateCalls(t *testing.T) {
// this should never actually get used because we're testing for errors here
r := strings.NewReader("")
// test index
idx, err := api.Holder().CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := api.Holder().CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatalf("%v: could not create test index", err)
}
if _, err = idx.CreateFieldIfNotExistsWithOptions("field", &pilosa.FieldOptions{Keys: false}); err != nil {
if _, err = idx.CreateFieldIfNotExistsWithOptions("field", "", &pilosa.FieldOptions{Keys: false}); err != nil {
t.Fatalf("creating field: %v", err)
}
t.Run("translateIndexDbOnNilIndex",

5
cluster.go
View file

@ -878,7 +878,9 @@ type CreateShardMessage struct {
type CreateIndexMessage struct {
Index string
CreatedAt int64
Meta IndexOptions
Owner string
Meta IndexOptions
}
// DeleteIndexMessage is an internal message indicating index deletion.
@ -891,6 +893,7 @@ type CreateFieldMessage struct {
Index string
Field string
CreatedAt int64
Owner string
Meta *FieldOptions
}

4
dbshard_internal_test.go
View file

@ -187,7 +187,7 @@ func makeSampleRoaringDir(t *testing.T, root, index, backend string, minBytes in
}
func helperCreateDBShard(h *Holder, index string, shard uint64) *Index {
idx, err := h.CreateIndexIfNotExists(index, IndexOptions{})
idx, err := h.CreateIndexIfNotExists(index, "", IndexOptions{})
PanicOn(err)
// TODO: It's not clear that this is actually doing anything.
dbs, err := h.txf.dbPerShard.GetDBShard(index, shard, idx)
@ -252,7 +252,7 @@ func Test_DBPerShard_GetFieldView2Shards_map_from_RBF(t *testing.T) {
index := "rick"
field := "f"
idx, err := holder.CreateIndex(index, IndexOptions{})
idx, err := holder.CreateIndex(index, "", IndexOptions{})
if err != nil {
t.Fatalf("creating index: %v", err)
}

26
disco/disco.go
View file

@ -100,8 +100,8 @@ type Schemator interface {
CreateIndex(ctx context.Context, name string, val []byte) error
DeleteIndex(ctx context.Context, name string) error
Field(ctx context.Context, index, field string) ([]byte, error)
CreateField(ctx context.Context, index, field string, val []byte) error
UpdateField(ctx context.Context, index, field string, val []byte) error
CreateField(ctx context.Context, index, field string, fieldVal []byte) error
UpdateField(ctx context.Context, index, field string, fieldVal []byte) error
DeleteField(ctx context.Context, index, field string) error
View(ctx context.Context, index, field, view string) (bool, error)
CreateView(ctx context.Context, index, field, view string) error
@ -185,23 +185,27 @@ func (*nopSchemator) Index(ctx context.Context, name string) ([]byte, error) { r
func (*nopSchemator) CreateIndex(ctx context.Context, name string, val []byte) error { return nil }
// DeleteIndex is a no-op implementation of the Schemator DeleteIndex method.
func (*nopSchemator) DeleteIndex(ctx context.Context, name string) error { return nil }
func (*nopSchemator) DeleteIndex(ctx context.Context, name string) error {
return nil
}
// Field is a no-op implementation of the Schemator Field method.
func (*nopSchemator) Field(ctx context.Context, index, field string) ([]byte, error) { return nil, nil }
// CreateField is a no-op implementation of the Schemator CreateField method.
func (*nopSchemator) CreateField(ctx context.Context, index, field string, val []byte) error {
func (*nopSchemator) CreateField(ctx context.Context, index, field string, fieldVal []byte) error {
return nil
}
// UpdateField is a no-op implementation of the Schemator UpdateField method.
func (*nopSchemator) UpdateField(ctx context.Context, index, field string, val []byte) error {
func (*nopSchemator) UpdateField(ctx context.Context, index, field string, fieldVal []byte) error {
return nil
}
// DeleteField is a no-op implementation of the Schemator DeleteField method.
func (*nopSchemator) DeleteField(ctx context.Context, index, field string) error { return nil }
func (*nopSchemator) DeleteField(ctx context.Context, index, field string) error {
return nil
}
// View is a no-op implementation of the Schemator View method.
func (*nopSchemator) View(ctx context.Context, index, field, view string) (bool, error) {
@ -295,7 +299,7 @@ func (s *inMemSchemator) Field(ctx context.Context, index, field string) ([]byte
}
// CreateField is an in-memory implementation of the Schemator CreateField method.
func (s *inMemSchemator) CreateField(ctx context.Context, index, field string, val []byte) error {
func (s *inMemSchemator) CreateField(ctx context.Context, index, field string, fieldVal []byte) error {
s.mu.Lock()
defer s.mu.Unlock()
idx, ok := s.schema[index]
@ -306,17 +310,17 @@ func (s *inMemSchemator) CreateField(ctx context.Context, index, field string, v
// The current logic in pilosa doesn't allow us to return ErrFieldExists
// here, so for now we just update the Data value if the field already
// exists.
fld.Data = val
fld.Data = fieldVal
return nil
}
idx.Fields[field] = &Field{
Data: val,
Data: fieldVal,
Views: make(map[string]struct{}),
}
return nil
}
func (s *inMemSchemator) UpdateField(ctx context.Context, index, field string, val []byte) error {
func (s *inMemSchemator) UpdateField(ctx context.Context, index, field string, fieldVal []byte) error {
s.mu.Lock()
defer s.mu.Unlock()
idx, ok := s.schema[index]
@ -327,7 +331,7 @@ func (s *inMemSchemator) UpdateField(ctx context.Context, index, field string, v
// The current logic in pilosa doesn't allow us to return ErrFieldExists
// here, so for now we just update the Data value if the field already
// exists.
fld.Data = val
fld.Data = fieldVal
return nil
} else {
return ErrFieldDoesNotExist

6
encoding/proto/proto.go
View file

@ -680,12 +680,14 @@ func (s Serializer) encodeCreateIndexMessage(m *pilosa.CreateIndexMessage) *pb.C
return &pb.CreateIndexMessage{
Index: m.Index,
CreatedAt: m.CreatedAt,
Owner: m.Owner,
Meta: s.encodeIndexMeta(&m.Meta),
}
}
func (s Serializer) encodeIndexMeta(m *pilosa.IndexOptions) *pb.IndexMeta {
return &pb.IndexMeta{
Description: m.Description,
Keys: m.Keys,
TrackExistence: m.TrackExistence,
}
@ -702,6 +704,7 @@ func (s Serializer) encodeCreateFieldMessage(m *pilosa.CreateFieldMessage) *pb.C
Index: m.Index,
Field: m.Field,
CreatedAt: m.CreatedAt,
Owner: m.Owner,
Meta: s.encodeFieldOptions(m.Meta),
}
}
@ -1056,12 +1059,14 @@ func (s Serializer) decodeCreateShardMessage(pb *pb.CreateShardMessage, m *pilos
func (s Serializer) decodeCreateIndexMessage(pb *pb.CreateIndexMessage, m *pilosa.CreateIndexMessage) {
m.Index = pb.Index
m.CreatedAt = pb.CreatedAt
m.Owner = pb.Owner
m.Meta = pilosa.IndexOptions{}
s.decodeIndexMeta(pb.Meta, &m.Meta)
}
func (s Serializer) decodeIndexMeta(pb *pb.IndexMeta, m *pilosa.IndexOptions) {
if pb != nil {
m.Description = pb.Description
m.Keys = pb.Keys
m.TrackExistence = pb.TrackExistence
}
@ -1075,6 +1080,7 @@ func (s Serializer) decodeCreateFieldMessage(pb *pb.CreateFieldMessage, m *pilos
m.Index = pb.Index
m.Field = pb.Field
m.CreatedAt = pb.CreatedAt
m.Owner = pb.Owner
m.Meta = &pilosa.FieldOptions{}
s.decodeFieldOptions(pb.Meta, m.Meta)
}

35
etcd/embed.go
View file

@ -868,19 +868,20 @@ func (e *Etcd) Field(ctx context.Context, indexName string, name string) ([]byte
return e.getKeyBytes(ctx, key)
}
func (e *Etcd) CreateField(ctx context.Context, indexName string, name string, val []byte) error {
func (e *Etcd) CreateField(ctx context.Context, indexName string, name string, fieldVal []byte) error {
key := schemaPrefix + indexName + "/" + name
// Set up Op to write field value as bytes.
op := clientv3.OpPut(key, "")
op.WithValueBytes(val)
op.WithValueBytes(fieldVal)
// Check for key existence, and execute Op within a transaction.
var resp *clientv3.TxnResponse
err := e.retryClient(func(cli *clientv3.Client) (err error) {
resp, err = cli.Txn(ctx).
If(clientv3util.KeyMissing(key)).
If(
clientv3util.KeyMissing(key)).
Then(op).
Commit()
return err
@ -896,19 +897,20 @@ func (e *Etcd) CreateField(ctx context.Context, indexName string, name string, v
return nil
}
func (e *Etcd) UpdateField(ctx context.Context, indexName string, name string, val []byte) error {
func (e *Etcd) UpdateField(ctx context.Context, indexName string, name string, fieldVal []byte) error {
key := schemaPrefix + indexName + "/" + name
// Set up Op to write field value as bytes.
op := clientv3.OpPut(key, "")
op.WithValueBytes(val)
op.WithValueBytes(fieldVal)
// Check for key existence, and execute Op within a transaction.
var resp *clientv3.TxnResponse
err := e.retryClient(func(cli *clientv3.Client) (err error) {
resp, err = cli.Txn(ctx).
If(clientv3util.KeyExists(key)).
If(
clientv3util.KeyExists(key)).
Then(op).
Commit()
return err
@ -923,20 +925,31 @@ func (e *Etcd) UpdateField(ctx context.Context, indexName string, name string, v
return nil
}
func (e *Etcd) DeleteField(ctx context.Context, indexname string, name string) (err error) {
key := schemaPrefix + indexname + "/" + name
func (e *Etcd) DeleteField(ctx context.Context, indexName string, name string) (err error) {
key := schemaPrefix + indexName + "/" + name
var resp *clientv3.TxnResponse
// Deleting field and views in one transaction.
err = e.retryClient(func(cli *clientv3.Client) (err error) {
_, err = cli.Txn(ctx).
If(clientv3.Compare(clientv3.Version(key), ">", -1)).
resp, err = cli.Txn(ctx).
If(
clientv3.Compare(clientv3.Version(key), ">", -1)).
Then(
clientv3.OpDelete(key+"/", clientv3.WithPrefix()), // deleting field views
clientv3.OpDelete(key), // deleting field
).Commit()
return err
})
if err != nil {
return errors.Wrap(err, "executing transaction")
}
return errors.Wrap(err, "DeleteField")
if !resp.Succeeded {
return errors.New("deleting field from etcd failed")
}
return nil
}
func (e *Etcd) View(ctx context.Context, indexName, fieldName, name string) (bool, error) {

2
executor.go
View file

@ -6546,7 +6546,7 @@ func (e *executor) collectCallKeys(dst *keyCollector, c *pql.Call, index string)
if keyed {
opts = append(opts, OptFieldKeys())
}
if _, err := idx.CreateField(field, opts...); err != nil {
if _, err := idx.CreateField(field, "", opts...); err != nil {
// We wrap these because we want to indicate that it wasn't found,
// but also the problem we encountered trying to create it.
return newNotFoundError(errors.Wrap(err, "creating field"), field)

10
executor_internal_test.go
View file

@ -46,7 +46,7 @@ func TestExecutor_TranslateRowsOnBool(t *testing.T) {
Cluster: NewTestCluster(t, 1),
}
idx, err := e.Holder.CreateIndex("i", IndexOptions{})
idx, err := e.Holder.CreateIndex("i", "", IndexOptions{})
if err != nil {
t.Fatalf("creating index: %v", err)
}
@ -54,8 +54,8 @@ func TestExecutor_TranslateRowsOnBool(t *testing.T) {
qcx := holder.Txf().NewWritableQcx()
defer qcx.Abort()
fb, errb := idx.CreateField("b", OptFieldTypeBool())
_, errbk := idx.CreateField("bk", OptFieldTypeBool(), OptFieldKeys())
fb, errb := idx.CreateField("b", "", OptFieldTypeBool())
_, errbk := idx.CreateField("bk", "", OptFieldTypeBool(), OptFieldKeys())
if errb != nil || errbk != nil {
t.Fatalf("creating fields %v, %v", errb, errbk)
}
@ -562,12 +562,12 @@ func TestDistinctTimestampUnion(t *testing.T) {
func TestExecutor_DeleteRows(t *testing.T) {
holder := newTestHolder(t)
idx, err := holder.CreateIndex("i", IndexOptions{TrackExistence: true})
idx, err := holder.CreateIndex("i", "", IndexOptions{TrackExistence: true})
if err != nil {
t.Fatalf("creating index: %v", err)
}
f, err := idx.CreateField("f")
f, err := idx.CreateField("f", "")
if err != nil {
t.Fatalf("creating field: %v", err)
}

196
executor_test.go
View file

@ -1154,11 +1154,11 @@ func runCallTest(c *test.Cluster, t *testing.T, writeQuery string, readQueries [
}
hldr := c.GetHolder(0)
index, err := hldr.CreateIndex(indexName, *indexOptions)
index, err := hldr.CreateIndex(indexName, "", *indexOptions)
if err != nil {
t.Fatal(err)
}
_, err = index.CreateField("f", fieldOption...)
_, err = index.CreateField("f", "", fieldOption...)
if err != nil {
t.Fatal(err)
}
@ -1444,7 +1444,7 @@ func TestExecutor_Execute_Set(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateField("f"); err != nil {
if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
}
@ -1461,7 +1461,7 @@ func TestExecutor_Execute_Set(t *testing.T) {
t.Run("ErrInvalidRowValueType", func(t *testing.T) {
idx := hldr.MustCreateIndexIfNotExists(c.Idx("inokey"), pilosa.IndexOptions{})
if _, err := idx.CreateField("f", pilosa.OptFieldKeys()); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
if _, err := cmd.API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx("inokey"), Query: `Set(2, f=1.2)`}); err == nil || !strings.Contains(err.Error(), "invalid value") {
@ -1487,7 +1487,7 @@ func TestExecutor_Execute_SetBool(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeBool()); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeBool()); err != nil {
t.Fatal(err)
}
@ -1533,7 +1533,7 @@ func TestExecutor_Execute_SetBool(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeBool()); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeBool()); err != nil {
t.Fatal(err)
}
@ -1559,7 +1559,7 @@ func TestExecutor_Execute_SetDecimal(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeDecimal(2)); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeDecimal(2)); err != nil {
t.Fatal(err)
}
@ -1596,7 +1596,7 @@ func TestExecutor_Execute_SetDecimal(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeDecimal(2)); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeDecimal(2)); err != nil {
t.Fatal(err)
}
@ -1630,9 +1630,9 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
} else if _, err := index.CreateFieldIfNotExists("xxx"); err != nil {
} else if _, err := index.CreateFieldIfNotExists("xxx", ""); err != nil {
t.Fatal(err)
}
@ -1671,7 +1671,7 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
@ -1701,9 +1701,9 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
// Create fields.
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{})
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, pilosa.TimeUnitSeconds)); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, pilosa.TimeUnitSeconds)); err != nil {
t.Fatal(err)
} else if _, err := index.CreateFieldIfNotExists("xxx"); err != nil {
} else if _, err := index.CreateFieldIfNotExists("xxx", ""); err != nil {
t.Fatal(err)
}
@ -1840,11 +1840,11 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Set columns for rows 0, 10, & 20 across two shards.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f"); err != nil {
} else if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("other"); err != nil {
} else if _, err := idx.CreateField("other", ""); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set(0, f=0)
@ -1884,11 +1884,11 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Set columns for rows 0, 10, & 20 across two shards.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{Keys: true}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{Keys: true}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f"); err != nil {
} else if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("other"); err != nil {
} else if _, err := idx.CreateField("other", ""); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set("zero", f=0)
@ -1928,11 +1928,11 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Set columns for rows 0, 10, & 20 across two shards.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{Keys: true}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{Keys: true}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f", pilosa.OptFieldKeys()); err != nil {
} else if _, err := idx.CreateField("f", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("other", pilosa.OptFieldKeys()); err != nil {
} else if _, err := idx.CreateField("other", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set("zero", f="zero")
@ -1974,11 +1974,11 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Set columns for rows 0, 10, & 20 across two shards.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{Keys: true}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{Keys: true}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f", pilosa.OptFieldKeys()); err != nil {
} else if _, err := idx.CreateField("f", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("other", pilosa.OptFieldKeys()); err != nil {
} else if _, err := idx.CreateField("other", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set("a", f="foo")
@ -2020,9 +2020,9 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Set data on the "f" field.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f"); err != nil {
} else if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set(0, f=0)
@ -2045,9 +2045,9 @@ func TestExecutor_Execute_TopN(t *testing.T) {
hldr := c.GetHolder(0)
// Create BSI "f" field.
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f", pilosa.OptFieldTypeInt(0, 100)); err != nil {
} else if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(0, 100)); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `TopN(f, n=2)`}); err == nil || !strings.Contains(err.Error(), `finding top results: mapping on primary node: cannot compute TopN() on integer, decimal, or timestamp field: "f"`) {
t.Fatalf("unexpected error: %v", err)
@ -2059,9 +2059,9 @@ func TestExecutor_Execute_TopN(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
if idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{}); err != nil {
if idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("f", pilosa.OptFieldTypeSet(pilosa.CacheTypeNone, 0)); err != nil {
} else if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeSet(pilosa.CacheTypeNone, 0)); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `
Set(0, f=0)
@ -2186,7 +2186,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
@ -2204,7 +2204,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
for i, test := range tests {
fld := fmt.Sprintf("f%d", i)
t.Run("MinMaxField_"+fld, func(t *testing.T) {
if _, err := idx.CreateField(fld, pilosa.OptFieldTypeInt(test.min, test.max)); err != nil {
if _, err := idx.CreateField(fld, "", pilosa.OptFieldTypeInt(test.min, test.max)); err != nil {
t.Fatal(err)
}
@ -2278,7 +2278,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
@ -2322,7 +2322,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
// This extra field exists to make there be shards which are present,
// but have no decimal values set, to make sure they don't break
// the results.
if _, err := idx.CreateFieldIfNotExists("z"); err != nil {
if _, err := idx.CreateFieldIfNotExists("z", ""); err != nil {
t.Fatal(err)
}
if res, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: `Set(1, z=0)`}); err != nil {
@ -2354,7 +2354,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
for i, test := range tests {
fld := fmt.Sprintf("f%d", i)
t.Run("MinMaxField_"+fld, func(t *testing.T) {
if _, err := idx.CreateField(fld, pilosa.OptFieldTypeDecimal(test.scale, test.min, test.max)); err != nil {
if _, err := idx.CreateField(fld, "", pilosa.OptFieldTypeDecimal(test.scale, test.min, test.max)); err != nil {
t.Fatal(err)
}
@ -2410,7 +2410,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
@ -2427,7 +2427,7 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
for i, test := range tests {
fld := fmt.Sprintf("f%d", i)
t.Run("MinMaxField_"+fld, func(t *testing.T) {
if _, err := idx.CreateField(fld, pilosa.OptFieldTypeTimestamp(test.epoch, pilosa.TimeUnitSeconds)); err != nil {
if _, err := idx.CreateField(fld, "", pilosa.OptFieldTypeTimestamp(test.epoch, pilosa.TimeUnitSeconds)); err != nil {
t.Fatal(err)
} else if _, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: c.Idx(), Query: fmt.Sprintf(`Set(10, %s="%s")`, fld, test.set.Format(time.RFC3339))}); err != nil {
t.Fatal(err)
@ -2498,16 +2498,16 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("x"); err != nil {
if _, err := idx.CreateField("x", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
t.Fatal(err)
}
@ -2562,16 +2562,16 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{Keys: true})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{Keys: true})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("x"); err != nil {
if _, err := idx.CreateField("x", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f", pilosa.OptFieldTypeInt(-1110, 1000)); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(-1110, 1000)); err != nil {
t.Fatal(err)
}
@ -2655,12 +2655,12 @@ func TestExecutor_Execute_MinMaxRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f"); err != nil {
if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
}
@ -2719,12 +2719,12 @@ func TestExecutor_Execute_MinMaxRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f", pilosa.OptFieldKeys()); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
@ -2775,28 +2775,28 @@ func TestExecutor_Execute_Sum(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("x"); err != nil {
if _, err := idx.CreateField("x", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("foo", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
if _, err := idx.CreateField("foo", "", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("other", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("other", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("dec", pilosa.OptFieldTypeDecimal(3)); err != nil {
if _, err := idx.CreateField("dec", "", pilosa.OptFieldTypeDecimal(3)); err != nil {
t.Fatal(err)
}
@ -2909,24 +2909,24 @@ func TestExecutor_Execute_Sum(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{Keys: true})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{Keys: true})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("x"); err != nil {
if _, err := idx.CreateField("x", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("foo", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
if _, err := idx.CreateField("foo", "", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("other", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("other", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
@ -2969,7 +2969,7 @@ func TestExecutor_DecimalArgs(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
@ -2983,7 +2983,7 @@ func TestExecutor_DecimalArgs(t *testing.T) {
t.Fatal(err)
}
if _, err := idx.CreateField("f", pilosa.OptFieldTypeDecimal(2, min, max)); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeDecimal(2, min, max)); err != nil {
t.Fatal(err)
}
@ -3000,28 +3000,28 @@ func TestExecutor_Execute_Row_BSIGroup(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f"); err != nil {
if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("foo", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
if _, err := idx.CreateField("foo", "", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("other", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("other", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("edge", pilosa.OptFieldTypeInt(-900, 1000)); err != nil {
if _, err := idx.CreateField("edge", "", pilosa.OptFieldTypeInt(-900, 1000)); err != nil {
t.Fatal(err)
}
@ -3213,13 +3213,13 @@ func TestExecutor_Execute_Row_BSIGroupEdge(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
t.Run("LT", func(t *testing.T) {
if _, err := idx.CreateField("f1", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
if _, err := idx.CreateField("f1", "", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
t.Fatal(err)
}
@ -3240,7 +3240,7 @@ func TestExecutor_Execute_Row_BSIGroupEdge(t *testing.T) {
})
t.Run("GT", func(t *testing.T) {
if _, err := idx.CreateField("f2", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
if _, err := idx.CreateField("f2", "", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
t.Fatal(err)
}
@ -3261,7 +3261,7 @@ func TestExecutor_Execute_Row_BSIGroupEdge(t *testing.T) {
})
t.Run("BTWN_LT_LT", func(t *testing.T) {
if _, err := idx.CreateField("f3", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
if _, err := idx.CreateField("f3", "", pilosa.OptFieldTypeInt(-2000, 2000)); err != nil {
t.Fatal(err)
}
@ -3300,28 +3300,28 @@ func TestExecutor_Execute_Range_BSIGroup_Deprecated(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f"); err != nil {
if _, err := idx.CreateField("f", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("foo", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
if _, err := idx.CreateField("foo", "", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("other", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
if _, err := idx.CreateField("other", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("edge", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
if _, err := idx.CreateField("edge", "", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
t.Fatal(err)
}
@ -3848,7 +3848,7 @@ func TestExecutor_Time_Clear_Quantums(t *testing.T) {
indexName := c.Idx(strings.ToLower(string(tt.quantum)))
index := hldr.MustCreateIndexIfNotExists(indexName, pilosa.IndexOptions{})
// Create field.
if _, err := index.CreateFieldIfNotExists("f", pilosa.OptFieldTypeTime(tt.quantum, "0")); err != nil {
if _, err := index.CreateFieldIfNotExists("f", "", pilosa.OptFieldTypeTime(tt.quantum, "0")); err != nil {
t.Fatal(err)
}
// Populate
@ -3932,7 +3932,7 @@ func TestExecutor_Execute_Existence(t *testing.T) {
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4334,7 +4334,7 @@ func TestExecutor_Execute_All(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
fld, err := index.CreateField("f")
fld, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4426,7 +4426,7 @@ func TestExecutor_Execute_All(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true, Keys: true})
fld, err := index.CreateField("f")
fld, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4491,7 +4491,7 @@ func TestExecutor_Execute_All(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4519,7 +4519,7 @@ func TestExecutor_Execute_ClearRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateField("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
_, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
t.Fatal(err)
}
@ -4535,7 +4535,7 @@ func TestExecutor_Execute_ClearRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4615,10 +4615,10 @@ func TestExecutor_Execute_SetRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
if _, err := index.CreateField("f"); err != nil {
if _, err := index.CreateField("f", ""); err != nil {
t.Fatal(err)
}
if _, err := index.CreateField("tmp"); err != nil {
if _, err := index.CreateField("tmp", ""); err != nil {
t.Fatal(err)
}
@ -4670,7 +4670,7 @@ func TestExecutor_Execute_SetRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := idx.CreateField("f")
_, err := idx.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4723,7 +4723,7 @@ func TestExecutor_Execute_SetRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -4764,7 +4764,7 @@ func TestExecutor_Execute_SetRow(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{TrackExistence: true})
if _, err := index.CreateField("f", pilosa.OptFieldKeys()); err != nil {
if _, err := index.CreateField("f", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
@ -4828,7 +4828,7 @@ func benchmarkExistence(nn bool, b *testing.B) {
index := hldr.MustCreateIndexIfNotExists(indexName, pilosa.IndexOptions{TrackExistence: nn})
// Create field.
if _, err := index.CreateFieldIfNotExists(fieldName); err != nil {
if _, err := index.CreateFieldIfNotExists(fieldName, ""); err != nil {
b.Fatal(err)
}
@ -6629,7 +6629,7 @@ func TestExecutor_Execute_IncludesColumn(t *testing.T) {
cmd := c.GetNode(0)
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), pilosa.IndexOptions{Keys: true})
if _, err := index.CreateField("general", pilosa.OptFieldKeys()); err != nil {
if _, err := index.CreateField("general", "", pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
@ -6695,20 +6695,20 @@ func TestExecutor_Execute_MinMaxCountEqual(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
idx, err := hldr.CreateIndex(c.Idx(), pilosa.IndexOptions{})
idx, err := hldr.CreateIndex(c.Idx(), "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("x"); err != nil {
if _, err := idx.CreateField("x", ""); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("f", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
if _, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(-1100, 1000)); err != nil {
t.Fatal(err)
}
if _, err := idx.CreateField("dec", pilosa.OptFieldTypeDecimal(3)); err != nil {
if _, err := idx.CreateField("dec", "", pilosa.OptFieldTypeDecimal(3)); err != nil {
t.Fatal(err)
}
@ -6868,7 +6868,7 @@ func TestExecutor_Execute_NoIndex(t *testing.T) {
defer c.Close()
hldr := c.GetHolder(0)
index := hldr.MustCreateIndexIfNotExists(c.Idx(), *indexOptions)
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal("should work")
}
@ -9683,11 +9683,11 @@ func TestExecutorTimeRange(t *testing.T) {
}
indexName := c.Idx(t.Name())
hldr := c.GetHolder(0)
index, err := hldr.CreateIndex(indexName, pilosa.IndexOptions{})
index, err := hldr.CreateIndex(indexName, "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
_, err = index.CreateField("f")
_, err = index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}

2
field.go
View file

@ -72,6 +72,7 @@ var availableShardFileFlushDuration = &protected{
type Field struct {
mu sync.RWMutex
createdAt int64
owner string
path string
index string
name string
@ -1971,6 +1972,7 @@ func (p fieldSlice) Less(i, j int) bool { return p[i].Name() < p[j].Name() }
type FieldInfo struct {
Name string `json:"name"`
CreatedAt int64 `json:"createdAt,omitempty"`
Owner string `json:"owner"`
Options FieldOptions `json:"options"`
Cardinality *uint64 `json:"cardinality,omitempty"`
Views []*ViewInfo `json:"views,omitempty"`

20
field_test.go
View file

@ -21,7 +21,7 @@ func TestField_SetValue(t *testing.T) {
t.Run("OK", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
t.Fatal(err)
}
@ -62,7 +62,7 @@ func TestField_SetValue(t *testing.T) {
t.Run("Overwrite", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
t.Fatal(err)
}
@ -97,7 +97,7 @@ func TestField_SetValue(t *testing.T) {
t.Run("ErrBSIGroupNotFound", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f")
f, err := idx.CreateField("f", "")
if err != nil {
t.Fatal(err)
}
@ -114,7 +114,7 @@ func TestField_SetValue(t *testing.T) {
t.Run("ErrBSIGroupValueTooLow", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f", pilosa.OptFieldTypeInt(20, 30))
f, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(20, 30))
if err != nil {
t.Fatal(err)
}
@ -129,7 +129,7 @@ func TestField_SetValue(t *testing.T) {
t.Run("ErrBSIGroupValueTooHigh", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f", pilosa.OptFieldTypeInt(20, 30))
f, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(20, 30))
if err != nil {
t.Fatal(err)
}
@ -169,13 +169,13 @@ func TestField_NameValidation(t *testing.T) {
_, idx := test.MustOpenIndex(t)
for _, name := range validFieldNames {
_, err := idx.CreateField(name)
_, err := idx.CreateField(name, "")
if err != nil {
t.Fatalf("unexpected field name: %s %s", name, err)
}
}
for _, name := range invalidFieldNames {
_, err := idx.CreateField(name)
_, err := idx.CreateField(name, "")
if err == nil {
t.Fatalf("expected error on field name: %s", name)
}
@ -188,7 +188,7 @@ const includeRemote = false // for calls to Index.AvailableShards(localOnly bool
func TestField_AvailableShards(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("fld-shards")
f, err := idx.CreateField("fld-shards", "")
if err != nil {
t.Fatal(err)
}
@ -229,7 +229,7 @@ func TestField_ClearValue(t *testing.T) {
t.Run("OK", func(t *testing.T) {
h, idx := test.MustOpenIndex(t)
f, err := idx.CreateField("f", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateField("f", "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
t.Fatal(err)
}
@ -290,7 +290,7 @@ func TestFieldInfoMarshal(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error marshalling index info, %v", err)
}
expected := []byte(`{"name":"timestamp","createdAt":1649270079233541000,"options":{"type":"timestamp","epoch":"1970-01-01T00:00:00Z","bitDepth":0,"min":-4294967296,"max":4294967296,"timeUnit":"s"}}`)
expected := []byte(`{"name":"timestamp","createdAt":1649270079233541000,"owner":"","options":{"type":"timestamp","epoch":"1970-01-01T00:00:00Z","bitDepth":0,"min":-4294967296,"max":4294967296,"timeUnit":"s"}}`)
if !bytes.Equal(a, expected) {
t.Fatalf("expected %s, got %s", expected, a)
}

6
fragment_internal_test.go
View file

@ -1330,7 +1330,7 @@ func TestFragment_TopN_CacheSize(t *testing.T) {
index := mustOpenIndex(t, IndexOptions{})
// Create field.
field, err := index.CreateFieldIfNotExists("f", OptFieldTypeSet(CacheTypeRanked, cacheSize))
field, err := index.CreateFieldIfNotExists("f", "", OptFieldTypeSet(CacheTypeRanked, cacheSize))
if err != nil {
t.Fatal(err)
}
@ -3086,11 +3086,11 @@ func newTestField(tb testing.TB, fieldOpts ...FieldOption) (*Holder, *Index, *Fi
fieldOpts = []FieldOption{OptFieldTypeDefault()}
}
h := newTestHolder(tb)
idx, err := h.CreateIndex("i", IndexOptions{})
idx, err := h.CreateIndex("i", "", IndexOptions{})
if err != nil {
tb.Fatalf("creating test index: %v", err)
}
fld, err := idx.CreateField("f", fieldOpts...)
fld, err := idx.CreateField("f", "", fieldOpts...)
if err != nil {
tb.Fatalf("creating test field: %v", err)
}

2
go.mod
View file

@ -82,6 +82,7 @@ require (
github.com/jaffee/commandeer v0.5.0
github.com/linkedin/goavro/v2 v2.11.1
google.golang.org/grpc v1.46.0
google.golang.org/protobuf v1.28.0
)
require (
@ -166,7 +167,6 @@ require (
golang.org/x/text v0.3.7 // indirect
google.golang.org/appengine v1.6.7 // indirect
google.golang.org/genproto v0.0.0-20220503193339-ba3ae3f07e29 // indirect
google.golang.org/protobuf v1.28.0 // indirect
gopkg.in/ini.v1 v1.62.0 // indirect
gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect

33
holder.go
View file

@ -435,14 +435,17 @@ func (h *Holder) Open() error {
return errors.Wrap(err, "opening index")
}
// Since we don't have createdAt stored on disk within the data
// Since we don't have createdAt and the other metadata stored on disk within the data
// directory, we need to populate it from the etcd schema data.
// TODO: we may no longer need the createdAt value stored in memory on
// the index struct; it may only be needed in the schema return value
// from the API, which already comes from etcd. In that case, this logic
// could be removed, and the createdAt on the index struct could be
// removed.
index.createdAt = cim.CreatedAt
index.owner = cim.Owner
index.description = cim.Meta.Description
err = index.OpenWithSchema(idx)
if err != nil {
@ -677,10 +680,13 @@ func (h *Holder) schema(ctx context.Context, includeViews bool) ([]*IndexInfo, e
di := &IndexInfo{
Name: cim.Index,
CreatedAt: cim.CreatedAt,
Owner: cim.Owner,
Options: cim.Meta,
ShardWidth: ShardWidth,
Fields: make([]*FieldInfo, 0, len(index.Fields)),
}
updatedAt := cim.CreatedAt
lastUpdateUser := cim.Owner
for fieldName, field := range index.Fields {
if fieldName == existenceFieldName {
continue
@ -689,9 +695,14 @@ func (h *Holder) schema(ctx context.Context, includeViews bool) ([]*IndexInfo, e
if err != nil {
return nil, errors.Wrap(err, "decoding CreateFieldMessage")
}
if cfm.CreatedAt > updatedAt {
updatedAt = cfm.CreatedAt
lastUpdateUser = cfm.Owner
}
fi := &FieldInfo{
Name: cfm.Field,
CreatedAt: cfm.CreatedAt,
Owner: cfm.Owner,
Options: *cfm.Meta,
}
if includeViews {
@ -702,6 +713,8 @@ func (h *Holder) schema(ctx context.Context, includeViews bool) ([]*IndexInfo, e
}
di.Fields = append(di.Fields, fi)
}
di.UpdatedAt = updatedAt
di.LastUpdateUser = lastUpdateUser
sort.Sort(fieldInfoSlice(di.Fields))
a = append(a, di)
}
@ -715,14 +728,14 @@ func (h *Holder) applySchema(schema *Schema) error {
// We use h.CreateIndex() instead of h.CreateIndexIfNotExists() because we
// want to limit the use of this method for now to only new indexes.
for _, i := range schema.Indexes {
idx, err := h.CreateIndex(i.Name, i.Options)
idx, err := h.CreateIndex(i.Name, i.Owner, i.Options)
if err != nil {
return errors.Wrap(err, "creating index")
}
// Create fields that don't exist.
for _, f := range i.Fields {
fld, err := idx.CreateFieldIfNotExistsWithOptions(f.Name, &f.Options)
fld, err := idx.CreateFieldIfNotExistsWithOptions(f.Name, "", &f.Options)
if err != nil {
return errors.Wrap(err, "creating field")
}
@ -774,7 +787,7 @@ func (h *Holder) Indexes() []*Index {
// CreateIndex creates an index.
// An error is returned if the index already exists.
func (h *Holder) CreateIndex(name string, opt IndexOptions) (*Index, error) {
func (h *Holder) CreateIndex(name string, requestUserID string, opt IndexOptions) (*Index, error) {
h.mu.Lock()
defer h.mu.Unlock()
@ -783,9 +796,11 @@ func (h *Holder) CreateIndex(name string, opt IndexOptions) (*Index, error) {
return nil, newConflictError(ErrIndexExists)
}
ts := timestamp()
cim := &CreateIndexMessage{
Index: name,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: opt,
}
@ -873,13 +888,15 @@ func (h *Holder) CreateIndexAndBroadcast(ctx context.Context, cim *CreateIndexMe
// CreateIndexIfNotExists returns an index by name.
// The index is created if it does not already exist.
func (h *Holder) CreateIndexIfNotExists(name string, opt IndexOptions) (*Index, error) {
func (h *Holder) CreateIndexIfNotExists(name string, requestUserID string, opt IndexOptions) (*Index, error) {
h.mu.Lock()
defer h.mu.Unlock()
ts := timestamp()
cim := &CreateIndexMessage{
Index: name,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: opt,
}
@ -930,6 +947,8 @@ func (h *Holder) createIndex(cim *CreateIndexMessage, broadcast bool) (*Index, e
index.keys = cim.Meta.Keys
index.trackExistence = cim.Meta.TrackExistence
index.createdAt = cim.CreatedAt
index.owner = cim.Owner
index.description = cim.Meta.Description
if err = index.Open(); err != nil {
return nil, errors.Wrap(err, "opening")

4
holder_internal_test.go
View file

@ -6,11 +6,11 @@ import (
)
func setupTest(t *testing.T, h *Holder, rowCol []rowCols, indexName string) (*Index, *Field) {
idx, err := h.CreateIndexIfNotExists(indexName, IndexOptions{TrackExistence: true})
idx, err := h.CreateIndexIfNotExists(indexName, "", IndexOptions{TrackExistence: true})
if err != nil {
t.Fatalf("failed to create index %v: %v", indexName, err)
}
f, err := idx.CreateFieldIfNotExists("f")
f, err := idx.CreateFieldIfNotExists("f", "")
if err != nil {
t.Fatalf("failed to create field in index %v: %v", indexName, err)
}

26
holder_test.go
View file

@ -31,7 +31,7 @@ func TestHolder_Open(t *testing.T) {
// no automatic close here, because we manually close this, and then
// *fail* to reopen it.
if _, err := h.CreateIndex("test", pilosa.IndexOptions{}); err != nil {
if _, err := h.CreateIndex("test", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if err := h.Close(); err != nil {
t.Fatal(err)
@ -50,10 +50,10 @@ func TestHolder_Open(t *testing.T) {
t.Run("ErrForeignIndexNotFound", func(t *testing.T) {
h := test.MustOpenHolder(t)
if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
if idx, err := h.CreateIndex("foo", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else {
_, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("nonexistent"))
_, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("nonexistent"))
if err == nil {
t.Fatalf("expected error: %s", pilosa.ErrForeignIndexNotFound)
} else if errors.Cause(err) != pilosa.ErrForeignIndexNotFound {
@ -66,11 +66,11 @@ func TestHolder_Open(t *testing.T) {
t.Run("ForeignIndexNotOpenYet", func(t *testing.T) {
h := test.MustOpenHolder(t)
if _, err := h.CreateIndex("zzz", pilosa.IndexOptions{}); err != nil {
if _, err := h.CreateIndex("zzz", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
} else if idx, err := h.CreateIndex("foo", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("zzz")); err != nil {
} else if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("zzz")); err != nil {
t.Fatal(err)
} else if err := h.Holder.Close(); err != nil {
t.Fatal(err)
@ -85,11 +85,11 @@ func TestHolder_Open(t *testing.T) {
t.Run("ForeignIndexIsOpen", func(t *testing.T) {
h := test.MustOpenHolder(t)
if _, err := h.CreateIndex("aaa", pilosa.IndexOptions{}); err != nil {
if _, err := h.CreateIndex("aaa", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
} else if idx, err := h.CreateIndex("foo", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
} else if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("aaa")); err != nil {
} else if _, err := idx.CreateField("bar", "", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("aaa")); err != nil {
t.Fatal(err)
} else if err := h.Holder.Close(); err != nil {
t.Fatal(err)
@ -104,18 +104,18 @@ func TestHolder_Open(t *testing.T) {
t.Run("CreateIndexIfNotExists", func(t *testing.T) {
h := test.MustOpenHolder(t)
idx1, err := h.CreateIndexIfNotExists("aaa", pilosa.IndexOptions{})
idx1, err := h.CreateIndexIfNotExists("aaa", "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
if _, err = h.CreateIndex("aaa", pilosa.IndexOptions{}); err == nil {
if _, err = h.CreateIndex("aaa", "", pilosa.IndexOptions{}); err == nil {
t.Fatalf("expected: ConflictError, got: nil")
} else if _, ok := err.(pilosa.ConflictError); !ok {
t.Fatalf("expected: ConflictError, got: %s", err)
}
idx2, err := h.CreateIndexIfNotExists("aaa", pilosa.IndexOptions{})
idx2, err := h.CreateIndexIfNotExists("aaa", "", pilosa.IndexOptions{})
if err != nil {
t.Fatal(err)
}
@ -135,7 +135,7 @@ func TestHolder_HasData(t *testing.T) {
t.Fatal("expected HasData to return false, no err, but", ok, err)
}
if _, err := h.CreateIndex("test", pilosa.IndexOptions{}); err != nil {
if _, err := h.CreateIndex("test", "", pilosa.IndexOptions{}); err != nil {
t.Fatal(err)
}

86
http_handler.go
View file

@ -48,6 +48,18 @@ import (
"github.com/zeebo/blake3"
)
type ContextRequestUserIdKeyType string
const (
// ContextRequestUserIdKey is request userid key for a request ctx
ContextRequestUserIdKey = ContextRequestUserIdKeyType("request-user-id")
)
const (
// HeaderRequestUserID is request userid header
HeaderRequestUserID = "X-Request-Userid"
)
// Handler represents an HTTP handler.
type Handler struct {
Handler http.Handler
@ -691,34 +703,52 @@ func (h *Handler) chkAllowedNetworks(r *http.Request) (bool, context.Context) {
func (h *Handler) chkAuthN(handler http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if h.auth != nil {
// if IP is in allowed networks, then serve the request
allowedNetwork, ctx := h.chkAllowedNetworks(r)
if allowedNetwork {
handler.ServeHTTP(w, r.WithContext(ctx))
return
}
access, refresh := getTokens(r)
uinfo, err := h.auth.Authenticate(access, refresh)
if err != nil {
http.Error(w, errors.Wrap(err, "authenticating").Error(), http.StatusUnauthorized)
return
}
// just in case it got refreshed
ctx = context.WithValue(ctx, authn.ContextValueAccessToken, "Bearer "+access)
ctx = context.WithValue(ctx, authn.ContextValueRefreshToken, refresh)
h.auth.SetCookie(w, uinfo.Token, uinfo.RefreshToken, uinfo.Expiry)
//if the request is unauthenticated and we have the appropriate header get the userid from the header
requestUserID := r.Header.Get(HeaderRequestUserID)
ctx = context.WithValue(ctx, ContextRequestUserIdKey, requestUserID)
if h.auth == nil {
handler.ServeHTTP(w, r.WithContext(ctx))
return
}
// if IP is in allowed networks, then serve the request
allowedNetwork, ctx := h.chkAllowedNetworks(r)
if allowedNetwork {
handler.ServeHTTP(w, r.WithContext(ctx))
return
}
access, refresh := getTokens(r)
uinfo, err := h.auth.Authenticate(access, refresh)
if err != nil {
http.Error(w, errors.Wrap(err, "authenticating").Error(), http.StatusUnauthorized)
return
}
// prefer the user id from an authenticated request over one in a header
ctx = context.WithValue(ctx, ContextRequestUserIdKey, uinfo.UserID)
// just in case it got refreshed
ctx = context.WithValue(ctx, authn.ContextValueAccessToken, "Bearer "+access)
ctx = context.WithValue(ctx, authn.ContextValueRefreshToken, refresh)
h.auth.SetCookie(w, uinfo.Token, uinfo.RefreshToken, uinfo.Expiry)
handler.ServeHTTP(w, r.WithContext(ctx))
}
}
func (h *Handler) chkAuthZ(handler http.HandlerFunc, perm authz.Permission) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// if auth isn't turned on, just serve the request
ctx := r.Context()
//if the request is unauthenticated and we have the appropriate header get the userid from the header
requestUserID := r.Header.Get(HeaderRequestUserID)
ctx = context.WithValue(ctx, ContextRequestUserIdKey, requestUserID)
// handle the case when auth is not turned on
if h.auth == nil {
handler.ServeHTTP(w, r)
handler.ServeHTTP(w, r.WithContext(ctx))
return
}
@ -737,19 +767,22 @@ func (h *Handler) chkAuthZ(handler http.HandlerFunc, perm authz.Permission) http
access, refresh := getTokens(r)
uinfo, err := h.auth.Authenticate(access, refresh)
ctx = context.WithValue(ctx, authn.ContextValueAccessToken, "Bearer "+access)
ctx = context.WithValue(ctx, authn.ContextValueRefreshToken, refresh)
if err != nil {
http.Error(w, errors.Wrap(err, "authenticating").Error(), http.StatusForbidden)
return
}
// prefer the user id from an authenticated request over one in a header
ctx = context.WithValue(ctx, ContextRequestUserIdKey, uinfo.UserID)
ctx = context.WithValue(ctx, authn.ContextValueAccessToken, "Bearer "+access)
ctx = context.WithValue(ctx, authn.ContextValueRefreshToken, refresh)
// just in case it got refreshed
h.auth.SetCookie(w, uinfo.Token, uinfo.RefreshToken, uinfo.Expiry)
// put the user's authN/Z info in the context
ctx = context.WithValue(r.Context(), contextKeyGroupMembership, uinfo.Groups)
ctx = context.WithValue(ctx, contextKeyGroupMembership, uinfo.Groups)
ctx = context.WithValue(ctx, authn.ContextValueAccessToken, "Bearer "+uinfo.Token)
ctx = context.WithValue(ctx, authn.ContextValueRefreshToken, uinfo.RefreshToken)
// unlikely h.permissions will be nil, but we'll check to be safe
@ -827,7 +860,6 @@ func (h *Handler) chkAuthZ(handler http.HandlerFunc, perm authz.Permission) http
}
}
handler.ServeHTTP(w, r.WithContext(ctx))
}
}
@ -879,7 +911,7 @@ func newStatikHandler(h *Handler) statikHandler {
func (s statikHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.UserAgent(), "curl") {
msg := "Welcome. FeatureBase v" + s.handler.api.Version() + " is running. Visit https://docs.molecula.cloud for more information."
msg := "Welcome. FeatureBase v" + s.handler.api.Version() + " is running. Visit https://docs.featurebase.com for more information."
if s.statikFS != nil {
msg += " Try the Web UI by visiting this URL in your browser."
}
@ -1702,6 +1734,7 @@ func (p *postIndexRequest) UnmarshalJSON(b []byte) error {
// Unmarshal expected values.
_p := _postIndexRequest{
Options: IndexOptions{
Description: "",
Keys: false,
TrackExistence: true,
},
@ -1787,6 +1820,7 @@ func (h *Handler) handlePostIndex(w http.ResponseWriter, r *http.Request) {
// Decode request.
req := postIndexRequest{
Options: IndexOptions{
Description: "",
Keys: false,
TrackExistence: true,
},

2
http_translator_test.go
View file

@ -25,7 +25,7 @@ func TestTranslateStore_EntryReader(t *testing.T) {
hldr := test.Holder{Holder: primary.Server.Holder()}
index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{Keys: true})
_, err := index.CreateField("f")
_, err := index.CreateField("f", "")
if err != nil {
t.Fatal(err)
}

57
index.go
View file

@ -23,8 +23,11 @@ import (
// Index represents a container for fields.
type Index struct {
mu sync.RWMutex
createdAt int64
mu sync.RWMutex
createdAt int64
owner string
description string
path string
name string
qualifiedName string
@ -147,6 +150,7 @@ func (i *Index) Options() IndexOptions {
func (i *Index) options() IndexOptions {
return IndexOptions{
Description: i.description,
Keys: i.keys,
TrackExistence: i.trackExistence,
}
@ -347,6 +351,7 @@ func (i *Index) openExistenceField() error {
cfm := &CreateFieldMessage{
Index: i.name,
Field: existenceFieldName,
Owner: "",
CreatedAt: 0,
Meta: &FieldOptions{Type: FieldTypeSet, CacheType: CacheTypeNone, CacheSize: 0},
}
@ -523,7 +528,7 @@ func (i *Index) recalculateCaches() {
}
// CreateField creates a field.
func (i *Index) CreateField(name string, opts ...FieldOption) (*Field, error) {
func (i *Index) CreateField(name string, requestUserID string, opts ...FieldOption) (*Field, error) {
err := ValidateName(name)
if err != nil {
return nil, errors.Wrap(err, "validating name")
@ -552,10 +557,12 @@ func (i *Index) CreateField(name string, opts ...FieldOption) (*Field, error) {
return nil, errors.Wrap(err, "applying option")
}
ts := timestamp()
cfm := &CreateFieldMessage{
Index: i.name,
Field: name,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: fo,
}
@ -584,7 +591,7 @@ func (i *Index) CreateField(name string, opts ...FieldOption) (*Field, error) {
}
// CreateFieldIfNotExists creates a field with the given options if it doesn't exist.
func (i *Index) CreateFieldIfNotExists(name string, opts ...FieldOption) (*Field, error) {
func (i *Index) CreateFieldIfNotExists(name string, requestUserID string, opts ...FieldOption) (*Field, error) {
err := ValidateName(name)
if err != nil {
return nil, errors.Wrap(err, "validating name")
@ -604,10 +611,12 @@ func (i *Index) CreateFieldIfNotExists(name string, opts ...FieldOption) (*Field
return nil, errors.Wrap(err, "applying option")
}
ts := timestamp()
cfm := &CreateFieldMessage{
Index: i.name,
Field: name,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: fo,
}
@ -628,7 +637,7 @@ func (i *Index) CreateFieldIfNotExists(name string, opts ...FieldOption) (*Field
// function options, taking a *FieldOptions struct. TODO: This should
// definintely be refactored so we don't have these virtually equivalent
// methods, but I'm puttin this here for now just to see if it works.
func (i *Index) CreateFieldIfNotExistsWithOptions(name string, opt *FieldOptions) (*Field, error) {
func (i *Index) CreateFieldIfNotExistsWithOptions(name string, requestUserID string, opt *FieldOptions) (*Field, error) {
err := ValidateName(name)
if err != nil {
return nil, errors.Wrap(err, "validating name")
@ -679,10 +688,12 @@ func (i *Index) CreateFieldIfNotExistsWithOptions(name string, opt *FieldOptions
}
}
ts := timestamp()
cfm := &CreateFieldMessage{
Index: i.name,
Field: name,
CreatedAt: timestamp(),
CreatedAt: ts,
Owner: requestUserID,
Meta: opt,
}
@ -711,7 +722,7 @@ func (i *Index) persistField(ctx context.Context, cfm *CreateFieldMessage) error
}
if b, err := i.serializer.Marshal(cfm); err != nil {
return errors.Wrap(err, "marshaling")
return errors.Wrap(err, "marshaling field")
} else if err := i.holder.Schemator.CreateField(ctx, cfm.Index, cfm.Field, b); errors.Cause(err) == disco.ErrFieldExists {
return ErrFieldExists
} else if err != nil {
@ -728,7 +739,7 @@ func (i *Index) persistUpdateField(ctx context.Context, cfm *CreateFieldMessage)
}
if b, err := i.serializer.Marshal(cfm); err != nil {
return errors.Wrap(err, "marshaling")
return errors.Wrap(err, "marshaling field")
} else if err := i.holder.Schemator.UpdateField(ctx, cfm.Index, cfm.Field, b); errors.Cause(err) == disco.ErrFieldDoesNotExist {
return ErrFieldNotFound
} else if err != nil {
@ -737,7 +748,7 @@ func (i *Index) persistUpdateField(ctx context.Context, cfm *CreateFieldMessage)
return nil
}
func (i *Index) UpdateField(ctx context.Context, name string, update FieldUpdate) (*CreateFieldMessage, error) {
func (i *Index) UpdateField(ctx context.Context, name string, requestUserID string, update FieldUpdate) (*CreateFieldMessage, error) {
// Get field from etcd
buf, err := i.holder.Schemator.Field(ctx, i.name, name)
if err != nil {
@ -782,6 +793,9 @@ func (i *Index) UpdateField(ctx context.Context, name string, update FieldUpdate
return nil, errors.Wrap(err, "persisting updated field")
}
i.mu.Lock()
defer i.mu.Unlock()
return cfm, nil
}
@ -842,6 +856,7 @@ func (i *Index) createField(cfm *CreateFieldMessage) (*Field, error) {
return nil, errors.Wrap(err, "initializing")
}
f.createdAt = cfm.CreatedAt
f.owner = cfm.Owner
// Pass holder through to the field for use in looking
// up a foreign index.
@ -927,11 +942,14 @@ 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"`
CreatedAt int64 `json:"createdAt,omitempty"`
Options IndexOptions `json:"options"`
Fields []*FieldInfo `json:"fields"`
ShardWidth uint64 `json:"shardWidth"`
Name string `json:"name"`
CreatedAt int64 `json:"createdAt,omitempty"`
UpdatedAt int64 `json:"updatedAt"`
Owner string `json:"owner"`
LastUpdateUser string `json:"lastUpdatedUser"`
Options IndexOptions `json:"options"`
Fields []*FieldInfo `json:"fields"`
ShardWidth uint64 `json:"shardWidth"`
}
// Field returns the FieldInfo the provided field name. If the field does not
@ -953,9 +971,10 @@ func (p indexInfoSlice) Less(i, j int) bool { return p[i].Name < p[j].Name }
// IndexOptions represents options to set when initializing an index.
type IndexOptions struct {
Keys bool `json:"keys"`
TrackExistence bool `json:"trackExistence"`
PartitionN int `json:"partitionN"`
Keys bool `json:"keys"`
TrackExistence bool `json:"trackExistence"`
PartitionN int `json:"partitionN"`
Description string `json:"description"`
}
type importData struct {

2
index_internal_test.go
View file

@ -8,7 +8,7 @@ import (
// mustOpenIndex returns a new, opened index at a temporary path. Panic on error.
func mustOpenIndex(tb testing.TB, opt IndexOptions) *Index {
h := newTestHolder(tb)
index, err := h.CreateIndex("i", opt)
index, err := h.CreateIndex("i", "", opt)
if err != nil {
panic(err)

20
index_test.go
View file

@ -25,7 +25,7 @@ func TestIndex_CreateFieldIfNotExists(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field.
f, err := index.CreateFieldIfNotExists("f")
f, err := index.CreateFieldIfNotExists("f", "")
if err != nil {
t.Fatal(err)
} else if f == nil {
@ -33,7 +33,7 @@ func TestIndex_CreateFieldIfNotExists(t *testing.T) {
}
// Retrieve existing field.
other, err := index.CreateFieldIfNotExists("f")
other, err := index.CreateFieldIfNotExists("f", "")
if err != nil {
t.Fatal(err)
} else if f.Field != other.Field {
@ -52,7 +52,7 @@ func TestIndex_CreateField(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field with explicit quantum.
f, err := index.CreateField("f", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0"))
f, err := index.CreateField("f", "", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0"))
if err != nil {
t.Fatal(err)
} else if q := f.TimeQuantum(); q != pilosa.TimeQuantum("YMDH") {
@ -67,7 +67,7 @@ func TestIndex_CreateField(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field with explicit quantum with no standard view
f, err := index.CreateField("f", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0", true))
f, err := index.CreateField("f", "", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0", true))
if err != nil {
t.Fatal(err)
} else if q := f.TimeQuantum(); q != pilosa.TimeQuantum("YMDH") {
@ -82,7 +82,7 @@ func TestIndex_CreateField(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field with schema and verify it exists.
if f, err := index.CreateField("f", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
if f, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(-990, 1000)); err != nil {
t.Fatal(err)
} else if !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
t.Fatalf("unexpected type: %#v", f.Type())
@ -100,7 +100,7 @@ func TestIndex_CreateField(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field with schema and verify it exists.
if f, err := index.CreateField("f", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, pilosa.TimeUnitSeconds)); err != nil {
if f, err := index.CreateField("f", "", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, pilosa.TimeUnitSeconds)); err != nil {
t.Fatal(err)
} else if !reflect.DeepEqual(f.Type(), pilosa.FieldTypeTimestamp) {
t.Fatalf("unexpected type: %#v", f.Type())
@ -192,7 +192,7 @@ func TestIndex_CreateField(t *testing.T) {
t.Run("IntField", func(t *testing.T) {
_, index := test.MustOpenIndex(t)
_, err := index.CreateField("f", pilosa.OptFieldTypeInt(-1, 1), pilosa.OptFieldKeys())
_, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(-1, 1), pilosa.OptFieldKeys())
if errors.Cause(err) != pilosa.ErrIntFieldWithKeys {
t.Fatal("int field cannot be created with keys=true")
}
@ -202,7 +202,7 @@ func TestIndex_CreateField(t *testing.T) {
t.Run("DecimalField", func(t *testing.T) {
_, index := test.MustOpenIndex(t)
_, err := index.CreateField("f", pilosa.OptFieldTypeDecimal(1, pql.NewDecimal(-1, 0), pql.NewDecimal(1, 0)), pilosa.OptFieldKeys())
_, err := index.CreateField("f", "", pilosa.OptFieldTypeDecimal(1, pql.NewDecimal(-1, 0), pql.NewDecimal(1, 0)), pilosa.OptFieldKeys())
if errors.Cause(err) != pilosa.ErrDecimalFieldWithKeys {
t.Fatal("decimal field cannot be created with keys=true")
}
@ -215,7 +215,7 @@ func TestIndex_DeleteField(t *testing.T) {
_, index := test.MustOpenIndex(t)
// Create field.
if _, err := index.CreateFieldIfNotExists("f"); err != nil {
if _, err := index.CreateFieldIfNotExists("f", ""); err != nil {
t.Fatal(err)
}
@ -262,7 +262,7 @@ func TestIndex_RecreateFieldOnRestart(t *testing.T) {
// create index
indexName := fmt.Sprintf("idx_%d", rand.Uint64())
holder := c.GetHolder(0)
_, err := holder.CreateIndex(indexName, pilosa.IndexOptions{
_, err := holder.CreateIndex(indexName, "", pilosa.IndexOptions{
Keys: false,
})
if err != nil {

10
internal_client_test.go
View file

@ -853,7 +853,7 @@ func TestClient_ImportKeys(t *testing.T) {
// Load bitmap into cache to ensure cache gets updated.
index := hldr.MustCreateIndexIfNotExists(cluster.Idx(), pilosa.IndexOptions{Keys: true})
_, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100))
_, err := index.CreateFieldIfNotExists(fldName, "", pilosa.OptFieldTypeInt(-100, 100))
if err != nil {
t.Fatal(err)
}
@ -932,7 +932,7 @@ func TestClient_ImportIDs(t *testing.T) {
// Load bitmap into cache to ensure cache gets updated.
index := hldr.MustCreateIndexIfNotExists(idxName, pilosa.IndexOptions{Keys: false})
_, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-10000, 10000))
_, err := index.CreateFieldIfNotExists(fldName, "", pilosa.OptFieldTypeInt(-10000, 10000))
if err != nil {
t.Fatal(err)
}
@ -1000,7 +1000,7 @@ func TestClient_ImportValue(t *testing.T) {
// Load bitmap into cache to ensure cache gets updated.
index := hldr.MustCreateIndexIfNotExists(cluster.Idx(), pilosa.IndexOptions{})
_, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100))
_, err := index.CreateFieldIfNotExists(fldName, "", pilosa.OptFieldTypeInt(-100, 100))
if err != nil {
t.Fatal(err)
}
@ -1111,7 +1111,7 @@ func TestClient_ImportExistence(t *testing.T) {
fldName := "fset"
index := hldr.MustCreateIndexIfNotExists(idxName, pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateFieldIfNotExists(fldName)
_, err := index.CreateFieldIfNotExists(fldName, "")
if err != nil {
t.Fatal(err)
}
@ -1147,7 +1147,7 @@ func TestClient_ImportExistence(t *testing.T) {
fldName := "fint"
index := hldr.MustCreateIndexIfNotExists(idxName, pilosa.IndexOptions{TrackExistence: true})
_, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100))
_, err := index.CreateFieldIfNotExists(fldName, "", pilosa.OptFieldTypeInt(-100, 100))
if err != nil {
t.Fatal(err)
}

370
pb/private.pb.go
View file

@ -25,6 +25,7 @@ const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type IndexMeta struct {
Keys bool `protobuf:"varint,3,opt,name=Keys,proto3" json:"Keys,omitempty"`
TrackExistence bool `protobuf:"varint,4,opt,name=TrackExistence,proto3" json:"TrackExistence,omitempty"`
Description string `protobuf:"bytes,5,opt,name=Description,proto3" json:"Description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -77,6 +78,13 @@ func (m *IndexMeta) GetTrackExistence() bool {
return false
}
func (m *IndexMeta) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
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"`
@ -633,6 +641,7 @@ type CreateIndexMessage struct {
Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
Meta *IndexMeta `protobuf:"bytes,2,opt,name=Meta,proto3" json:"Meta,omitempty"`
CreatedAt int64 `protobuf:"varint,3,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
Owner string `protobuf:"bytes,5,opt,name=Owner,proto3" json:"Owner,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -692,11 +701,19 @@ func (m *CreateIndexMessage) GetCreatedAt() int64 {
return 0
}
func (m *CreateIndexMessage) GetOwner() string {
if m != nil {
return m.Owner
}
return ""
}
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,proto3" json:"Meta,omitempty"`
CreatedAt int64 `protobuf:"varint,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
Owner string `protobuf:"bytes,5,opt,name=Owner,proto3" json:"Owner,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -763,6 +780,13 @@ func (m *CreateFieldMessage) GetCreatedAt() int64 {
return 0
}
func (m *CreateFieldMessage) GetOwner() string {
if m != nil {
return m.Owner
}
return ""
}
type UpdateFieldMessage struct {
CreateFieldMessage *CreateFieldMessage `protobuf:"bytes,1,opt,name=CreateFieldMessage,proto3" json:"CreateFieldMessage,omitempty"`
Update *FieldUpdate `protobuf:"bytes,2,opt,name=Update,proto3" json:"Update,omitempty"`
@ -2879,114 +2903,115 @@ func init() {
func init() { proto.RegisterFile("private.proto", fileDescriptor_d2a91b51c7bdc125) }
var fileDescriptor_d2a91b51c7bdc125 = []byte{
// 1701 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4b, 0x6f, 0x23, 0x4b,
0x15, 0xa6, 0x1f, 0xf1, 0xe3, 0x38, 0xce, 0x38, 0x75, 0xc3, 0xd0, 0x93, 0x3b, 0x44, 0x9e, 0x02,
0xcd, 0x98, 0x91, 0x08, 0x22, 0x77, 0x71, 0x11, 0x77, 0x73, 0x27, 0x76, 0x66, 0x30, 0xf7, 0xce,
0xe3, 0x56, 0x1e, 0x4b, 0x50, 0xa5, 0x5d, 0x4a, 0x5a, 0x69, 0x77, 0x9b, 0xee, 0x76, 0xc6, 0x9e,
0x05, 0x12, 0x08, 0x04, 0x1b, 0xf6, 0xac, 0xf8, 0x17, 0xfc, 0x01, 0x56, 0x6c, 0x90, 0xf8, 0x09,
0x68, 0xf8, 0x23, 0xa8, 0x4e, 0x55, 0x75, 0x97, 0x1d, 0x27, 0x86, 0x88, 0x5d, 0x9f, 0xef, 0x9c,
0x3a, 0xef, 0x3a, 0x75, 0x6c, 0x68, 0x4f, 0xb2, 0xe8, 0x9a, 0x17, 0x62, 0x7f, 0x92, 0xa5, 0x45,
0x4a, 0xdc, 0xc9, 0xf9, 0xee, 0xe6, 0x64, 0x7a, 0x1e, 0x47, 0xa1, 0x42, 0xe8, 0x2b, 0x68, 0x0e,
0x93, 0x91, 0x98, 0xbd, 0x16, 0x05, 0x27, 0x04, 0xfc, 0xaf, 0xc4, 0x3c, 0x0f, 0xbc, 0xae, 0xd3,
0x6b, 0x30, 0xfc, 0x26, 0x4f, 0x61, 0xeb, 0x24, 0xe3, 0xe1, 0xd5, 0xd1, 0x2c, 0xca, 0x0b, 0x91,
0x84, 0x22, 0xf0, 0x91, 0xbb, 0x84, 0xd2, 0xbf, 0x79, 0xb0, 0xf9, 0x32, 0x12, 0xf1, 0xe8, 0xed,
0xa4, 0x88, 0xd2, 0x24, 0x97, 0xca, 0x4e, 0xe6, 0x13, 0x11, 0x34, 0xba, 0x4e, 0xaf, 0xc9, 0xf0,
0x9b, 0x3c, 0x86, 0x66, 0x9f, 0x87, 0x97, 0x02, 0x19, 0x1e, 0x32, 0x2a, 0xa0, 0xe4, 0x1e, 0x47,
0x1f, 0x94, 0x95, 0x36, 0xab, 0x00, 0xd2, 0x85, 0xd6, 0x49, 0x34, 0x16, 0xdf, 0x4c, 0x79, 0x52,
0x4c, 0xc7, 0xc1, 0x06, 0x9e, 0xb6, 0x21, 0xf2, 0x10, 0x6a, 0x6f, 0xe3, 0xd1, 0xeb, 0x28, 0x09,
0x9a, 0x5d, 0xa7, 0xe7, 0x31, 0x4d, 0x19, 0x9c, 0xcf, 0x02, 0xa8, 0x70, 0x3e, 0x2b, 0xc3, 0x6d,
0x2d, 0x86, 0xfb, 0x26, 0x3d, 0x2e, 0x78, 0x32, 0xe2, 0xd9, 0xe8, 0x2c, 0x12, 0xef, 0x83, 0x4d,
0x15, 0xee, 0x22, 0x2a, 0xcf, 0x1e, 0xf2, 0x5c, 0x04, 0x6d, 0xd4, 0x88, 0xdf, 0x64, 0x17, 0x1a,
0x87, 0x51, 0x31, 0x10, 0x93, 0xe2, 0x32, 0xd8, 0xea, 0x3a, 0x3d, 0x9f, 0x95, 0x34, 0xd9, 0x81,
0x8d, 0xe3, 0x90, 0xc7, 0x22, 0x78, 0x80, 0x07, 0x14, 0x41, 0x28, 0x6c, 0xbe, 0x4c, 0x33, 0x11,
0x5d, 0x24, 0x58, 0x84, 0xa0, 0x83, 0x41, 0x2d, 0x60, 0xe4, 0xbb, 0xe0, 0xc9, 0x90, 0xb6, 0xbb,
0x4e, 0xaf, 0x75, 0xd0, 0xda, 0x9f, 0x9c, 0xef, 0x0f, 0x44, 0x18, 0x8d, 0x79, 0xcc, 0x24, 0x8e,
0x6c, 0x3e, 0x0b, 0xc8, 0x2a, 0x36, 0x9f, 0x49, 0x9f, 0x64, 0x8a, 0x4e, 0x93, 0xa8, 0x08, 0x3e,
0x41, 0xed, 0x25, 0x4d, 0x3a, 0xe0, 0x9d, 0x9c, 0x7c, 0x1d, 0xec, 0x20, 0x2c, 0x3f, 0x29, 0x85,
0xad, 0xe1, 0x78, 0x92, 0x66, 0x05, 0x13, 0xf9, 0x24, 0x4d, 0x72, 0x21, 0x65, 0x8e, 0xb2, 0x2c,
0x70, 0x94, 0xcc, 0x51, 0x96, 0xd1, 0x5f, 0x43, 0xe7, 0x30, 0x4e, 0xc3, 0xab, 0x01, 0x2f, 0x38,
0x13, 0xbf, 0x9a, 0x8a, 0xbc, 0x90, 0xd1, 0xa9, 0x00, 0x94, 0x9c, 0x22, 0x24, 0x8a, 0x1d, 0x11,
0xb8, 0x0a, 0x45, 0x42, 0x66, 0x0e, 0xf3, 0xaa, 0x0a, 0x88, 0xdf, 0x98, 0x9d, 0x4b, 0x9e, 0x8d,
0xb0, 0xea, 0x3e, 0x53, 0x84, 0x44, 0xd1, 0x12, 0x76, 0x8a, 0xcf, 0x14, 0x41, 0x87, 0xb0, 0x6d,
0xd9, 0xd7, 0x6e, 0x3e, 0x84, 0x1a, 0x4b, 0xdf, 0x0f, 0x07, 0x79, 0xe0, 0x74, 0xbd, 0x9e, 0xcf,
0x34, 0x85, 0x2d, 0x95, 0xc6, 0xd3, 0x71, 0x22, 0x59, 0x2e, 0xb2, 0x2a, 0x80, 0x3e, 0x82, 0x0d,
0xec, 0x2f, 0x19, 0x65, 0x75, 0x56, 0x7e, 0xd2, 0xdf, 0x38, 0xd0, 0x7c, 0xcd, 0x67, 0xe8, 0x48,
0x4e, 0x3e, 0x87, 0x86, 0xa9, 0x3e, 0x0a, 0xb5, 0x0e, 0x3e, 0x95, 0x99, 0x2e, 0x05, 0xf6, 0x0d,
0xf7, 0x28, 0x29, 0xb2, 0x39, 0x2b, 0x85, 0x77, 0xbf, 0x80, 0xf6, 0x02, 0x4b, 0x5a, 0xba, 0x12,
0x73, 0x93, 0xcf, 0x2b, 0x31, 0x97, 0x51, 0x5e, 0xf3, 0x78, 0x2a, 0x30, 0x4b, 0x3e, 0x53, 0xc4,
0x4f, 0xdd, 0x9f, 0x38, 0xf4, 0x0c, 0x48, 0x3f, 0x13, 0xbc, 0x10, 0x68, 0xe4, 0xb5, 0xc8, 0x73,
0x7e, 0x21, 0xd6, 0xe5, 0xda, 0xb3, 0x73, 0x5d, 0xe6, 0xd5, 0xb5, 0xf2, 0x4a, 0x9f, 0x03, 0x19,
0x88, 0x58, 0x14, 0x42, 0xdf, 0xfc, 0x3b, 0xf4, 0xd2, 0x2b, 0xe3, 0xc3, 0x7a, 0x59, 0xf2, 0x04,
0x7c, 0x39, 0x46, 0xd0, 0x58, 0xeb, 0xa0, 0x2d, 0x33, 0x54, 0xce, 0x16, 0x86, 0x2c, 0xac, 0x07,
0xaa, 0x1b, 0xbd, 0x28, 0xd0, 0x55, 0x8f, 0x55, 0x00, 0xfd, 0x9d, 0x63, 0xac, 0xa1, 0xfb, 0xff,
0x65, 0xc4, 0x0b, 0xdd, 0xf5, 0x7d, 0xed, 0x83, 0x87, 0x3e, 0x74, 0xa4, 0x0f, 0xf6, 0x54, 0x5a,
0xe5, 0x86, 0xbf, 0xec, 0xc6, 0xef, 0x1d, 0x20, 0xa7, 0x93, 0xd1, 0xb2, 0x1b, 0x2f, 0x57, 0x39,
0x87, 0x3e, 0xb5, 0x0e, 0x1e, 0x4a, 0x43, 0x37, 0xb9, 0x6c, 0x55, 0x38, 0xcf, 0xa0, 0xa6, 0xb4,
0xeb, 0x44, 0x3d, 0x28, 0x9d, 0x54, 0x30, 0xd3, 0x6c, 0xfa, 0x05, 0xb4, 0x2c, 0x18, 0xc7, 0x18,
0x46, 0xa1, 0xf3, 0xa0, 0x29, 0x99, 0x88, 0xb3, 0xb2, 0x81, 0x9a, 0x4c, 0x11, 0xf4, 0x4b, 0x53,
0xe4, 0xfb, 0xa6, 0x92, 0x86, 0xf0, 0xa9, 0xd2, 0xf0, 0xe2, 0x9a, 0x47, 0x31, 0x3f, 0x8f, 0xff,
0xa7, 0x3e, 0x5c, 0xa8, 0x4a, 0x00, 0x75, 0x3c, 0x3b, 0x1c, 0xe8, 0xbb, 0x6c, 0x48, 0x3a, 0x85,
0x6a, 0x2c, 0xbc, 0xe1, 0x63, 0xa1, 0xb5, 0xe1, 0x77, 0x59, 0x4c, 0xf7, 0xce, 0x62, 0xca, 0xf8,
0x23, 0xf1, 0x5e, 0x3e, 0x5b, 0x1e, 0xc6, 0x2f, 0x89, 0x35, 0x25, 0xfe, 0x21, 0xd4, 0x8e, 0xc3,
0x4b, 0x31, 0xe6, 0xe4, 0x7b, 0x50, 0x47, 0xcf, 0x45, 0xae, 0x6f, 0x76, 0xb3, 0xec, 0x5b, 0x66,
0x38, 0xb2, 0x23, 0x74, 0x7c, 0xab, 0xdc, 0x5c, 0x30, 0xe5, 0x2e, 0x99, 0x22, 0xcf, 0xa0, 0xae,
0xfd, 0xc5, 0x91, 0x77, 0xe3, 0x62, 0x18, 0x2e, 0x79, 0x02, 0x35, 0x8c, 0x2e, 0x0f, 0xfc, 0xca,
0x11, 0x44, 0x98, 0x66, 0xd0, 0x23, 0xf0, 0x4e, 0xd9, 0x50, 0x76, 0x02, 0x7a, 0x6f, 0xdc, 0xd0,
0x94, 0x74, 0xee, 0x67, 0x69, 0x5e, 0xe8, 0xdc, 0xe3, 0xb7, 0xc4, 0xde, 0xa5, 0x99, 0xba, 0x6c,
0x6d, 0x86, 0xdf, 0xf4, 0x8f, 0x0e, 0xf8, 0x6f, 0xd2, 0x91, 0x20, 0x5b, 0xe0, 0x0e, 0x07, 0x5a,
0x89, 0x3b, 0x1c, 0x90, 0x47, 0xa8, 0x5f, 0xe7, 0xbb, 0x2e, 0xed, 0x9f, 0xb2, 0x21, 0x43, 0x9b,
0x8f, 0xa1, 0x39, 0xcc, 0xdf, 0x65, 0xd1, 0x98, 0x67, 0x73, 0xbd, 0x20, 0x54, 0x00, 0x0e, 0x9a,
0x42, 0xb6, 0xb4, 0xaf, 0xca, 0x8e, 0x04, 0x79, 0x02, 0xf5, 0x57, 0xec, 0x5d, 0x5f, 0xaa, 0xdc,
0x58, 0x54, 0x69, 0x70, 0xfa, 0x25, 0x74, 0xa4, 0x27, 0x28, 0x6f, 0x3a, 0xeb, 0x21, 0xd4, 0x24,
0x56, 0x7a, 0xa6, 0xa9, 0xca, 0x88, 0x6b, 0x19, 0xa1, 0x2f, 0x95, 0x86, 0xa3, 0x6b, 0x91, 0x14,
0x56, 0x6f, 0x22, 0x8d, 0x0a, 0xda, 0x4c, 0x11, 0xe4, 0xb1, 0x8a, 0x5a, 0x87, 0xd7, 0x90, 0xbe,
0x48, 0x9a, 0x21, 0x4a, 0xe7, 0x00, 0xc6, 0x93, 0x69, 0x5e, 0xca, 0x3a, 0xab, 0x64, 0x09, 0x35,
0xed, 0xa3, 0xe7, 0x0c, 0x48, 0xbe, 0x42, 0x98, 0x69, 0xac, 0x1f, 0x54, 0x8d, 0xa5, 0xea, 0xf9,
0xa0, 0xac, 0xbb, 0xb2, 0x51, 0xb5, 0xd7, 0x25, 0xb4, 0x2c, 0x7c, 0x65, 0x8f, 0x3d, 0x2b, 0x9b,
0xc3, 0xad, 0x94, 0x21, 0xa2, 0x95, 0x69, 0xf6, 0x9a, 0x09, 0x1b, 0xe9, 0x91, 0x72, 0x87, 0xa5,
0x1e, 0x3c, 0x58, 0xbc, 0xf0, 0xe6, 0xe1, 0x5c, 0x86, 0xd7, 0x98, 0xfa, 0x83, 0x03, 0xed, 0x7e,
0x3c, 0xcd, 0x0b, 0x91, 0x95, 0x39, 0x6d, 0x6a, 0xa0, 0x2c, 0x6d, 0x05, 0xac, 0xae, 0x2e, 0xd9,
0x83, 0x0d, 0x99, 0x71, 0x75, 0xb9, 0xed, 0x42, 0x28, 0xd8, 0xaa, 0x84, 0x7f, 0x5b, 0x25, 0xe8,
0x19, 0x34, 0x0e, 0x8f, 0x87, 0xaf, 0xb2, 0x74, 0x3a, 0x59, 0x19, 0xb1, 0xd9, 0x54, 0x5d, 0x6b,
0x53, 0xed, 0xa8, 0xad, 0x4b, 0x45, 0x85, 0x8b, 0x56, 0x47, 0x2d, 0x5a, 0xbe, 0x46, 0xf8, 0x8c,
0x1e, 0xc3, 0xb6, 0x0a, 0x57, 0x4e, 0x9c, 0xfb, 0x8c, 0x45, 0xb3, 0x0a, 0x79, 0xd5, 0x2a, 0x24,
0x95, 0xaa, 0xa9, 0xfb, 0xff, 0x54, 0xfa, 0x0f, 0x17, 0xb6, 0x99, 0xc8, 0xa3, 0x0f, 0x62, 0x98,
0xe4, 0x45, 0x36, 0x0d, 0xcd, 0xc3, 0xf1, 0xf3, 0xf4, 0x5c, 0xd7, 0xc2, 0x63, 0x8a, 0xb8, 0xfb,
0x96, 0x10, 0x0a, 0x75, 0x7b, 0x08, 0xd8, 0x02, 0x86, 0x41, 0x9e, 0x43, 0xfd, 0x38, 0x9d, 0x66,
0x61, 0xd9, 0xf9, 0x38, 0xb9, 0x95, 0x7d, 0xc5, 0x60, 0x46, 0x80, 0x7c, 0x05, 0xe4, 0x24, 0xe3,
0x49, 0x1e, 0x73, 0xe9, 0x92, 0x39, 0xd6, 0xa8, 0x76, 0x2c, 0x8b, 0xbb, 0xa0, 0x61, 0xc5, 0x31,
0xb2, 0x6f, 0x5f, 0xe1, 0xa0, 0x8e, 0xfe, 0x6d, 0x19, 0xff, 0xf4, 0x3d, 0xb1, 0x2f, 0xf9, 0xe7,
0x4b, 0x1d, 0x1a, 0xd4, 0xf0, 0xc8, 0x36, 0x3e, 0xe6, 0x36, 0x83, 0x2d, 0xca, 0xd1, 0xdf, 0x3a,
0xb0, 0x69, 0x7b, 0xb3, 0x66, 0x5c, 0x94, 0xe5, 0x73, 0xd7, 0xaf, 0x6c, 0xa6, 0x7c, 0xfe, 0xaa,
0xf5, 0x78, 0xc3, 0x5e, 0xe3, 0x52, 0xf8, 0xce, 0x2d, 0xc9, 0xb9, 0x97, 0x3b, 0x5d, 0x68, 0xbd,
0xe3, 0x59, 0x11, 0x49, 0x65, 0xfa, 0x9d, 0xde, 0x60, 0x36, 0x44, 0x05, 0x3c, 0xba, 0xd1, 0x44,
0xfd, 0x74, 0x3c, 0x91, 0xdd, 0x7a, 0xaf, 0x66, 0x92, 0x63, 0x3a, 0xcb, 0xd2, 0xcc, 0x64, 0x00,
0x09, 0x7a, 0x08, 0x8d, 0x93, 0x74, 0x92, 0xc6, 0xe9, 0xc5, 0x7c, 0xcd, 0xc8, 0x08, 0xa0, 0xae,
0x9e, 0x06, 0x35, 0xa2, 0x9a, 0xcc, 0x90, 0xf4, 0x13, 0xd9, 0xef, 0x21, 0x8f, 0xc3, 0x69, 0xcc,
0x0b, 0x81, 0x4b, 0x3e, 0x82, 0x5f, 0xa7, 0x7c, 0xa4, 0xa6, 0x82, 0xbe, 0x5a, 0xf4, 0x97, 0xba,
0x01, 0x39, 0x86, 0x63, 0x3d, 0x41, 0x2f, 0x42, 0x7b, 0xd7, 0x52, 0x14, 0xf9, 0x31, 0xb4, 0x2c,
0x69, 0x7b, 0x81, 0xb3, 0x60, 0x66, 0xcb, 0xd0, 0xbf, 0x3a, 0x0b, 0x67, 0x6e, 0xbc, 0xb9, 0xda,
0xd4, 0xb5, 0x4a, 0x52, 0x83, 0x69, 0x4a, 0x86, 0x7e, 0x34, 0x0b, 0xe3, 0x69, 0x2e, 0x59, 0xfa,
0xc1, 0x2d, 0x01, 0x19, 0xba, 0xfc, 0x1d, 0x97, 0x4e, 0xcd, 0x72, 0x63, 0x48, 0xf9, 0x8b, 0x6f,
0x20, 0xf8, 0x28, 0x8e, 0x12, 0x81, 0xfd, 0xe2, 0xb1, 0x92, 0x26, 0xcf, 0xd5, 0x8c, 0x35, 0x8d,
0xbe, 0xb3, 0xe4, 0x38, 0xf2, 0xd4, 0xe4, 0xcd, 0x29, 0x81, 0xce, 0x32, 0x8b, 0xee, 0x00, 0x51,
0x1d, 0xf0, 0xe2, 0x3c, 0xcd, 0xcc, 0x6b, 0x4b, 0xfb, 0x66, 0xb8, 0xc8, 0xec, 0xaf, 0x7b, 0xc4,
0xab, 0xcc, 0xba, 0x76, 0x66, 0xe9, 0x2f, 0x60, 0x4b, 0xef, 0x76, 0x22, 0xc3, 0x86, 0x96, 0x09,
0x60, 0x22, 0x4c, 0xe5, 0x9a, 0x68, 0x7e, 0x9a, 0x55, 0x80, 0xd4, 0x83, 0x8b, 0xae, 0x79, 0x9d,
0x34, 0x85, 0xbb, 0x51, 0x74, 0x91, 0x88, 0x11, 0xbe, 0x18, 0x1e, 0xd3, 0x14, 0xfd, 0x93, 0x0b,
0x3b, 0x6a, 0xe9, 0x4c, 0x2e, 0x44, 0x5e, 0x54, 0x66, 0x70, 0xad, 0xc6, 0xf9, 0x5f, 0xae, 0xd5,
0xf8, 0x02, 0x3c, 0x85, 0xad, 0x7e, 0x2c, 0x78, 0x56, 0xf9, 0xa0, 0x0c, 0x2d, 0xa1, 0xf2, 0xde,
0x20, 0xa2, 0x9f, 0x67, 0xb5, 0x84, 0xda, 0x10, 0x39, 0x84, 0x86, 0x0e, 0xcd, 0x0c, 0xc4, 0xa7,
0xf8, 0x4a, 0xad, 0xf0, 0xc6, 0xec, 0xb7, 0xb9, 0xfe, 0x21, 0x69, 0xc8, 0xdd, 0xb7, 0xd0, 0x5e,
0x60, 0xad, 0xf8, 0x21, 0xd9, 0xb3, 0x7f, 0x48, 0xb6, 0x0e, 0x88, 0xb5, 0x2e, 0x6b, 0xed, 0xf6,
0x8f, 0xcb, 0x3e, 0x7c, 0x7b, 0x95, 0x03, 0x39, 0x79, 0x0e, 0x9e, 0x74, 0x54, 0x2d, 0xc3, 0xc1,
0x6d, 0x8e, 0x32, 0x29, 0x44, 0xff, 0xe2, 0xe8, 0xa4, 0x0a, 0xcd, 0x37, 0x7f, 0x08, 0x7c, 0x66,
0x2b, 0x79, 0x52, 0x2a, 0x59, 0x12, 0xdb, 0x2f, 0x03, 0x95, 0xd2, 0xbb, 0xdf, 0x40, 0x63, 0x55,
0x78, 0xbe, 0x0a, 0xef, 0x47, 0x8b, 0xe1, 0x3d, 0xba, 0xcd, 0xb3, 0xdc, 0x8a, 0xf2, 0xb0, 0xf3,
0xf7, 0x8f, 0x7b, 0xce, 0x3f, 0x3f, 0xee, 0x39, 0xff, 0xfa, 0xb8, 0xe7, 0xfc, 0xf9, 0xdf, 0x7b,
0xdf, 0x3a, 0xaf, 0xe1, 0xff, 0x5e, 0x9f, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0x76, 0x11, 0x06,
0x2f, 0x1a, 0x13, 0x00, 0x00,
// 1728 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0x23, 0x49,
0x15, 0xa7, 0xff, 0xc4, 0x7f, 0x9e, 0xe3, 0x8c, 0x53, 0x1b, 0x86, 0x9e, 0xec, 0x10, 0x79, 0x0a,
0x34, 0x63, 0x46, 0x22, 0x88, 0xec, 0x61, 0x11, 0x7b, 0xd9, 0x89, 0x9d, 0x59, 0xcc, 0xee, 0xcc,
0x64, 0x2b, 0x7f, 0x8e, 0xa0, 0x4a, 0xbb, 0x94, 0xb4, 0xd2, 0xee, 0x36, 0xdd, 0xed, 0xc4, 0xde,
0x03, 0x12, 0x48, 0x08, 0x2e, 0xdc, 0x11, 0x07, 0xbe, 0x05, 0x5f, 0x80, 0x13, 0x17, 0x24, 0x3e,
0x02, 0x1a, 0xbe, 0x08, 0xaa, 0x57, 0x55, 0xdd, 0x65, 0xc7, 0x49, 0x86, 0x68, 0x6f, 0xfd, 0x7e,
0xaf, 0xfa, 0xd5, 0xef, 0xfd, 0xa9, 0x57, 0xaf, 0x1b, 0xda, 0x93, 0x2c, 0xba, 0xe2, 0x85, 0xd8,
0x9d, 0x64, 0x69, 0x91, 0x12, 0x77, 0x72, 0xb6, 0xbd, 0x3e, 0x99, 0x9e, 0xc5, 0x51, 0xa8, 0x10,
0x1a, 0x41, 0x73, 0x98, 0x8c, 0xc4, 0xec, 0x8d, 0x28, 0x38, 0x21, 0xe0, 0x7f, 0x29, 0xe6, 0x79,
0xe0, 0x75, 0x9d, 0x5e, 0x83, 0xe1, 0x33, 0x79, 0x0e, 0x1b, 0xc7, 0x19, 0x0f, 0x2f, 0x0f, 0x66,
0x51, 0x5e, 0x88, 0x24, 0x14, 0x81, 0x8f, 0xda, 0x25, 0x94, 0x74, 0xa1, 0x35, 0x10, 0x79, 0x98,
0x45, 0x93, 0x22, 0x4a, 0x93, 0x60, 0xad, 0xeb, 0xf4, 0x9a, 0xcc, 0x86, 0xe8, 0x3f, 0x3c, 0x58,
0x7f, 0x1d, 0x89, 0x78, 0xf4, 0x0e, 0xe5, 0x5c, 0x6e, 0x77, 0x3c, 0x9f, 0x88, 0xa0, 0x81, 0x6b,
0xf1, 0x99, 0x3c, 0x85, 0x66, 0x9f, 0x87, 0x17, 0x02, 0x15, 0x1e, 0x2a, 0x2a, 0xa0, 0xd4, 0x1e,
0x45, 0xdf, 0x28, 0x1e, 0x6d, 0x56, 0x01, 0x92, 0xc2, 0x71, 0x34, 0x16, 0x5f, 0x4f, 0x79, 0x52,
0x4c, 0xc7, 0x86, 0x82, 0x05, 0x91, 0xc7, 0x50, 0x7b, 0x17, 0x8f, 0xde, 0x44, 0x49, 0xd0, 0xec,
0x3a, 0x3d, 0x8f, 0x69, 0xc9, 0xe0, 0x7c, 0x16, 0x40, 0x85, 0xf3, 0x59, 0x19, 0x90, 0xd6, 0x62,
0x40, 0xde, 0xa6, 0x47, 0x05, 0x4f, 0x46, 0x3c, 0x1b, 0x9d, 0x46, 0xe2, 0x3a, 0x58, 0x57, 0x01,
0x59, 0x44, 0xe5, 0xbb, 0xfb, 0x3c, 0x17, 0x41, 0x1b, 0x2d, 0xe2, 0x33, 0xd9, 0x86, 0xc6, 0x7e,
0x54, 0x0c, 0xc4, 0xa4, 0xb8, 0x08, 0x36, 0xba, 0x4e, 0xcf, 0x67, 0xa5, 0x4c, 0xb6, 0x60, 0xed,
0x28, 0xe4, 0xb1, 0x08, 0x1e, 0xe1, 0x0b, 0x4a, 0x20, 0x14, 0xd6, 0x5f, 0xa7, 0x99, 0x88, 0xce,
0x13, 0x4c, 0x53, 0xd0, 0x41, 0xa7, 0x16, 0x30, 0xf2, 0x7d, 0xf0, 0xa4, 0x4b, 0x9b, 0x5d, 0xa7,
0xd7, 0xda, 0x6b, 0xed, 0x4e, 0xce, 0x76, 0x07, 0x22, 0x8c, 0xc6, 0x3c, 0x66, 0x12, 0x47, 0x35,
0x9f, 0x05, 0x64, 0x95, 0x9a, 0xcf, 0x24, 0x27, 0x19, 0xa2, 0x93, 0x24, 0x2a, 0x82, 0x8f, 0xd0,
0x7a, 0x29, 0x93, 0x0e, 0x78, 0xc7, 0xc7, 0x5f, 0x05, 0x5b, 0x08, 0xcb, 0x47, 0x4a, 0x61, 0x63,
0x38, 0x9e, 0xa4, 0x59, 0xc1, 0x44, 0x3e, 0x49, 0x93, 0x5c, 0xc8, 0x35, 0x07, 0x59, 0x16, 0x38,
0x6a, 0xcd, 0x41, 0x96, 0xd1, 0xdf, 0x42, 0x67, 0x3f, 0x4e, 0xc3, 0xcb, 0x01, 0x2f, 0x38, 0x13,
0xbf, 0x99, 0x8a, 0xbc, 0x90, 0xde, 0x29, 0x07, 0xd4, 0x3a, 0x25, 0x48, 0x14, 0x2b, 0x22, 0x70,
0x15, 0x8a, 0x82, 0x8c, 0x1c, 0xc6, 0x55, 0x25, 0x10, 0x9f, 0x31, 0x3a, 0x17, 0x3c, 0x1b, 0x61,
0xd6, 0x7d, 0xa6, 0x04, 0x89, 0xe2, 0x4e, 0x58, 0x29, 0x3e, 0x53, 0x02, 0x1d, 0xc2, 0xa6, 0xb5,
0xbf, 0xa6, 0xf9, 0x18, 0x6a, 0x2c, 0xbd, 0x1e, 0x0e, 0xf2, 0xc0, 0xe9, 0x7a, 0x3d, 0x9f, 0x69,
0x09, 0x4b, 0x2a, 0x8d, 0xa7, 0xe3, 0x44, 0xaa, 0x5c, 0x54, 0x55, 0x00, 0x7d, 0x02, 0x6b, 0x58,
0x5f, 0xd2, 0xcb, 0xea, 0x5d, 0xf9, 0x48, 0x7f, 0xe7, 0x40, 0xf3, 0x0d, 0x9f, 0x21, 0x91, 0x9c,
0x7c, 0x0a, 0x0d, 0x93, 0x7d, 0x5c, 0xd4, 0xda, 0xfb, 0x58, 0x46, 0xba, 0x5c, 0xb0, 0x6b, 0xb4,
0x07, 0x49, 0x91, 0xcd, 0x59, 0xb9, 0x78, 0xfb, 0x33, 0x68, 0x2f, 0xa8, 0xe4, 0x4e, 0x97, 0x62,
0x6e, 0xe2, 0x79, 0x29, 0xe6, 0xd2, 0xcb, 0x2b, 0x1e, 0x4f, 0x05, 0x46, 0xc9, 0x67, 0x4a, 0xf8,
0xb9, 0xfb, 0x33, 0x87, 0x9e, 0x02, 0xe9, 0x67, 0x82, 0x17, 0x02, 0x37, 0x79, 0x23, 0xf2, 0x9c,
0x9f, 0x8b, 0xfb, 0x62, 0xed, 0xd9, 0xb1, 0x2e, 0xe3, 0xea, 0x5a, 0x71, 0xa5, 0x2f, 0x81, 0x0c,
0x44, 0x2c, 0x0a, 0xa1, 0x7b, 0xc3, 0x1d, 0x76, 0x65, 0x1c, 0x34, 0x89, 0xfb, 0x17, 0x93, 0x67,
0xe0, 0xcb, 0x4e, 0x83, 0xbb, 0xb5, 0xf6, 0xda, 0x32, 0x44, 0x65, 0xfb, 0x61, 0xa8, 0xc2, 0x84,
0xa0, 0xb9, 0xd1, 0xab, 0x02, 0xb9, 0x7a, 0xac, 0x02, 0xa4, 0xd9, 0x77, 0xd7, 0x89, 0xc8, 0x74,
0x71, 0x28, 0x81, 0xfe, 0xb5, 0xe4, 0x80, 0x5e, 0x7d, 0x60, 0x20, 0x16, 0x8a, 0xee, 0x87, 0x9a,
0x99, 0x87, 0xcc, 0x3a, 0x92, 0x99, 0xdd, 0xac, 0x56, 0x91, 0xf3, 0x3f, 0x8c, 0xdc, 0x1f, 0x1c,
0x20, 0x27, 0x93, 0xd1, 0x32, 0xb9, 0xd7, 0xab, 0x28, 0x23, 0xd3, 0xd6, 0xde, 0x63, 0xb9, 0xfd,
0x4d, 0x2d, 0x5b, 0xe5, 0xe4, 0x0b, 0xa8, 0x29, 0xeb, 0x3a, 0xa8, 0x8f, 0x4a, 0xea, 0x0a, 0x66,
0x5a, 0x4d, 0x3f, 0x83, 0x96, 0x05, 0x63, 0xcf, 0x53, 0xbd, 0x5a, 0x45, 0x47, 0x4b, 0xd2, 0x89,
0xd3, 0xb2, 0xda, 0x9a, 0x4c, 0x09, 0xf4, 0x73, 0x53, 0x11, 0x0f, 0x0d, 0x30, 0x0d, 0xe1, 0x63,
0x65, 0xe1, 0xd5, 0x15, 0x8f, 0x62, 0x7e, 0x16, 0xff, 0x5f, 0x45, 0xbb, 0x90, 0xab, 0x00, 0xea,
0xf8, 0xee, 0x70, 0xa0, 0x0f, 0xbe, 0x11, 0xe9, 0x14, 0xaa, 0x1e, 0xf2, 0x96, 0x8f, 0x85, 0xb6,
0x86, 0xcf, 0x65, 0x8a, 0xdd, 0x3b, 0x53, 0x2c, 0xfd, 0x8f, 0xc4, 0xb5, 0xbc, 0x05, 0x3d, 0xf4,
0x5f, 0x0a, 0x77, 0x27, 0x9e, 0xfe, 0x18, 0x6a, 0x47, 0xe1, 0x85, 0x18, 0x73, 0xf2, 0x03, 0xa8,
0x23, 0x73, 0x91, 0xeb, 0x36, 0xd0, 0x2c, 0x6b, 0x9c, 0x19, 0x8d, 0xac, 0x08, 0xed, 0xdf, 0x2a,
0x9a, 0x0b, 0x5b, 0xb9, 0xcb, 0x35, 0xf6, 0x02, 0xea, 0x9a, 0x2f, 0x56, 0xd9, 0x8d, 0x43, 0x64,
0xb4, 0xe4, 0x19, 0xd4, 0xd0, 0xbb, 0x3c, 0xf0, 0x2b, 0x22, 0x88, 0x30, 0xad, 0xa0, 0x07, 0xe0,
0x9d, 0xb0, 0xa1, 0xac, 0x04, 0x64, 0x6f, 0x68, 0x68, 0x49, 0x92, 0xfb, 0x45, 0x9a, 0x17, 0x3a,
0xf6, 0xf8, 0x2c, 0xb1, 0xc3, 0x34, 0x53, 0x07, 0xb3, 0xcd, 0xf0, 0x99, 0xfe, 0xc9, 0x01, 0xff,
0x6d, 0x3a, 0x12, 0x64, 0x03, 0xdc, 0xe1, 0x40, 0x1b, 0x71, 0x87, 0x03, 0xf2, 0x04, 0xed, 0xeb,
0x78, 0xd7, 0xe5, 0xfe, 0x27, 0x6c, 0xc8, 0x70, 0xcf, 0xa7, 0xd0, 0x1c, 0xe6, 0x87, 0x59, 0x34,
0xe6, 0xd9, 0x5c, 0xcf, 0x1b, 0x15, 0x80, 0x5d, 0xa9, 0x90, 0x25, 0xed, 0xab, 0xb4, 0xa3, 0x40,
0x9e, 0x41, 0xfd, 0x0b, 0x76, 0xd8, 0x97, 0x26, 0xd7, 0x16, 0x4d, 0x1a, 0x9c, 0x7e, 0x0e, 0x1d,
0xc9, 0x04, 0xd7, 0x9b, 0xca, 0x7a, 0x0c, 0x35, 0x89, 0x95, 0xcc, 0xb4, 0x54, 0x6d, 0xe2, 0x5a,
0x9b, 0xd0, 0xd7, 0xca, 0xc2, 0xc1, 0x95, 0x48, 0x0a, 0xab, 0x36, 0x51, 0x46, 0x03, 0x6d, 0xa6,
0x04, 0xf2, 0x54, 0x79, 0xad, 0xdd, 0x6b, 0x48, 0x2e, 0x52, 0x66, 0x88, 0xd2, 0x39, 0x80, 0x61,
0x32, 0xcd, 0xcb, 0xb5, 0xce, 0xaa, 0xb5, 0x84, 0x9a, 0xf2, 0xd1, 0xdd, 0x07, 0xa4, 0x5e, 0x21,
0xcc, 0x14, 0xd6, 0x8f, 0xaa, 0xc2, 0x52, 0xf9, 0x7c, 0x54, 0xe6, 0x5d, 0xed, 0x51, 0x95, 0xd7,
0x05, 0xb4, 0x2c, 0x7c, 0x65, 0x8d, 0xbd, 0x28, 0x8b, 0xc3, 0xad, 0x8c, 0x21, 0xa2, 0x8d, 0x69,
0xf5, 0xdd, 0xdd, 0x98, 0x46, 0xba, 0xa5, 0xdc, 0xb1, 0x53, 0x0f, 0x1e, 0x2d, 0x1e, 0x78, 0x73,
0xcb, 0x2e, 0xc3, 0xf7, 0x6c, 0xf5, 0x47, 0x07, 0xda, 0xfd, 0x78, 0x9a, 0x17, 0x22, 0x2b, 0x63,
0xda, 0xd4, 0x40, 0x99, 0xda, 0x0a, 0x58, 0x9d, 0x5d, 0xb2, 0x03, 0x6b, 0x32, 0xe2, 0xea, 0x70,
0xdb, 0x89, 0x50, 0xb0, 0x95, 0x09, 0xff, 0xb6, 0x4c, 0xd0, 0x53, 0x68, 0xec, 0x1f, 0x0d, 0xbf,
0xc8, 0xd2, 0xe9, 0x64, 0xa5, 0xc7, 0x66, 0xac, 0x75, 0xad, 0xb1, 0xb6, 0xa3, 0x46, 0x34, 0xe5,
0x15, 0x4e, 0x65, 0x1d, 0x35, 0x95, 0xf9, 0x1a, 0xe1, 0x33, 0x7a, 0x04, 0x9b, 0xca, 0x5d, 0xd9,
0x71, 0x1e, 0xd2, 0x16, 0xcd, 0xdc, 0xe4, 0x55, 0x73, 0x93, 0x34, 0xaa, 0xba, 0xee, 0xb7, 0x69,
0xf4, 0x5f, 0x2e, 0x6c, 0x32, 0x91, 0x47, 0xdf, 0x88, 0x61, 0x92, 0x17, 0xd9, 0x34, 0x34, 0x17,
0xc7, 0x2f, 0xd3, 0x33, 0x9d, 0x0b, 0x8f, 0x29, 0xe1, 0xee, 0x53, 0x42, 0x28, 0xd4, 0xed, 0x26,
0x60, 0x2f, 0x30, 0x0a, 0xf2, 0x12, 0xea, 0x47, 0xe9, 0x34, 0x0b, 0xcb, 0xca, 0xc7, 0xce, 0xad,
0xf6, 0x57, 0x0a, 0x66, 0x16, 0x90, 0x2f, 0x81, 0x1c, 0x67, 0x3c, 0xc9, 0x63, 0x2e, 0x29, 0x99,
0xd7, 0x1a, 0xd5, 0x40, 0x66, 0x69, 0x17, 0x2c, 0xac, 0x78, 0x8d, 0xec, 0xda, 0x47, 0x38, 0xa8,
0x23, 0xbf, 0x0d, 0xc3, 0x4f, 0x9f, 0x13, 0xfb, 0x90, 0x7f, 0xba, 0x54, 0xa1, 0x41, 0x0d, 0x5f,
0xd9, 0xc4, 0xcb, 0xdc, 0x56, 0xb0, 0xc5, 0x75, 0xf4, 0xf7, 0x0e, 0xac, 0xdb, 0x6c, 0xee, 0x69,
0x17, 0x65, 0xfa, 0xdc, 0xfb, 0xe7, 0x3b, 0x93, 0x3e, 0x7f, 0xd5, 0x2c, 0xbd, 0x66, 0xcf, 0x7c,
0x29, 0x7c, 0xef, 0x96, 0xe0, 0x3c, 0x88, 0x4e, 0x17, 0x5a, 0x87, 0x3c, 0x2b, 0x22, 0x69, 0x4c,
0xdf, 0xd3, 0x6b, 0xcc, 0x86, 0xa8, 0x80, 0x27, 0x37, 0x8a, 0xa8, 0x9f, 0x8e, 0x27, 0xb2, 0x5a,
0x1f, 0x54, 0x4c, 0xb2, 0x4d, 0x67, 0x59, 0x9a, 0x99, 0x08, 0xa0, 0x40, 0xf7, 0xa1, 0x71, 0x9c,
0x4e, 0xd2, 0x38, 0x3d, 0x9f, 0xdf, 0xd3, 0x32, 0x02, 0xa8, 0xab, 0xab, 0x41, 0xb5, 0xa8, 0x26,
0x33, 0x22, 0xfd, 0x48, 0xd6, 0x7b, 0xc8, 0xe3, 0x70, 0x1a, 0xf3, 0x42, 0xe0, 0x17, 0x01, 0x82,
0x5f, 0xa5, 0x7c, 0xa4, 0xba, 0x82, 0x3e, 0x5a, 0xf4, 0xd7, 0xba, 0x00, 0x39, 0xba, 0x63, 0x5d,
0x41, 0xaf, 0x42, 0x7b, 0xd6, 0x52, 0x12, 0xf9, 0x29, 0xb4, 0xac, 0xd5, 0xf6, 0x00, 0x67, 0xc1,
0xcc, 0x5e, 0x43, 0xff, 0xee, 0x2c, 0xbc, 0x73, 0xe3, 0xce, 0xd5, 0x5b, 0x5d, 0xa9, 0x20, 0x35,
0x98, 0x96, 0xa4, 0xeb, 0x07, 0xb3, 0x30, 0x9e, 0xe6, 0x52, 0xa5, 0x2f, 0xdc, 0x12, 0x90, 0xae,
0xcb, 0x8f, 0xbe, 0x74, 0x6a, 0x86, 0x1b, 0x23, 0xca, 0xcf, 0xc3, 0x81, 0xe0, 0xa3, 0x38, 0x4a,
0x04, 0xd6, 0x8b, 0xc7, 0x4a, 0x99, 0xbc, 0x54, 0x3d, 0xd6, 0x14, 0xfa, 0xd6, 0x12, 0x71, 0xd4,
0xa9, 0xce, 0x9b, 0x53, 0x02, 0x9d, 0x65, 0x15, 0xdd, 0x02, 0xa2, 0x2a, 0xe0, 0xd5, 0x59, 0x9a,
0x99, 0xdb, 0x96, 0xf6, 0x4d, 0x73, 0x91, 0xd1, 0xbf, 0xef, 0x12, 0xaf, 0x22, 0xeb, 0xda, 0x91,
0xa5, 0xbf, 0x82, 0x0d, 0x3d, 0xdb, 0x89, 0x0c, 0x0b, 0x5a, 0x06, 0x80, 0x89, 0x30, 0x95, 0x63,
0xa2, 0xf9, 0x8e, 0xab, 0x00, 0x69, 0x07, 0x07, 0x5d, 0x73, 0x3b, 0x69, 0x09, 0x67, 0xa3, 0xe8,
0x3c, 0x11, 0x23, 0xbc, 0x31, 0x3c, 0xa6, 0x25, 0xfa, 0x67, 0x17, 0xb6, 0xd4, 0xd0, 0x99, 0x9c,
0x8b, 0xbc, 0xa8, 0xb6, 0xc1, 0xb1, 0x1a, 0xfb, 0x7f, 0x39, 0x56, 0xe3, 0x0d, 0xf0, 0x1c, 0x36,
0xfa, 0xb1, 0xe0, 0x59, 0xc5, 0x41, 0x6d, 0xb4, 0x84, 0xca, 0x73, 0x83, 0x88, 0xbe, 0x9e, 0xd5,
0x10, 0x6a, 0x43, 0x64, 0x1f, 0x1a, 0xda, 0x35, 0xd3, 0x10, 0x9f, 0xe3, 0x2d, 0xb5, 0x82, 0x8d,
0x99, 0x6f, 0x73, 0xfd, 0xd5, 0x69, 0xc4, 0xed, 0x77, 0xd0, 0x5e, 0x50, 0xad, 0xf8, 0xea, 0xec,
0xd9, 0x5f, 0x9d, 0xad, 0x3d, 0x62, 0x8d, 0xcb, 0xda, 0xba, 0xfd, 0x25, 0xda, 0x87, 0xef, 0xae,
0x22, 0x90, 0x93, 0x97, 0xe0, 0x49, 0xa2, 0x6a, 0x18, 0x0e, 0x6e, 0x23, 0xca, 0xe4, 0x22, 0xfa,
0x37, 0x47, 0x07, 0x55, 0x68, 0xbd, 0xf9, 0x7b, 0xf0, 0x89, 0x6d, 0xe4, 0x59, 0x69, 0x64, 0x69,
0xd9, 0x6e, 0xe9, 0xa8, 0x5c, 0xbd, 0xfd, 0x35, 0x34, 0x56, 0xb9, 0xe7, 0x2b, 0xf7, 0x7e, 0xb2,
0xe8, 0xde, 0x93, 0xdb, 0x98, 0xe5, 0x96, 0x97, 0xfb, 0x9d, 0x7f, 0xbe, 0xdf, 0x71, 0xfe, 0xfd,
0x7e, 0xc7, 0xf9, 0xcf, 0xfb, 0x1d, 0xe7, 0x2f, 0xff, 0xdd, 0xf9, 0xce, 0x59, 0x0d, 0x7f, 0xa3,
0x7d, 0xf2, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa1, 0xcf, 0xef, 0xf0, 0x69, 0x13, 0x00, 0x00,
}
func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
@ -3013,6 +3038,13 @@ func (m *IndexMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Description) > 0 {
i -= len(m.Description)
copy(dAtA[i:], m.Description)
i = encodeVarintPrivate(dAtA, i, uint64(len(m.Description)))
i--
dAtA[i] = 0x2a
}
if m.TrackExistence {
i--
if m.TrackExistence {
@ -3537,6 +3569,13 @@ func (m *CreateIndexMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Owner) > 0 {
i -= len(m.Owner)
copy(dAtA[i:], m.Owner)
i = encodeVarintPrivate(dAtA, i, uint64(len(m.Owner)))
i--
dAtA[i] = 0x2a
}
if m.CreatedAt != 0 {
i = encodeVarintPrivate(dAtA, i, uint64(m.CreatedAt))
i--
@ -3588,6 +3627,13 @@ func (m *CreateFieldMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Owner) > 0 {
i -= len(m.Owner)
copy(dAtA[i:], m.Owner)
i = encodeVarintPrivate(dAtA, i, uint64(len(m.Owner)))
i--
dAtA[i] = 0x2a
}
if m.CreatedAt != 0 {
i = encodeVarintPrivate(dAtA, i, uint64(m.CreatedAt))
i--
@ -5435,6 +5481,10 @@ func (m *IndexMeta) Size() (n int) {
if m.TrackExistence {
n += 2
}
l = len(m.Description)
if l > 0 {
n += 1 + l + sovPrivate(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -5676,6 +5726,10 @@ func (m *CreateIndexMessage) Size() (n int) {
if m.CreatedAt != 0 {
n += 1 + sovPrivate(uint64(m.CreatedAt))
}
l = len(m.Owner)
if l > 0 {
n += 1 + l + sovPrivate(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -5703,6 +5757,10 @@ func (m *CreateFieldMessage) Size() (n int) {
if m.CreatedAt != 0 {
n += 1 + sovPrivate(uint64(m.CreatedAt))
}
l = len(m.Owner)
if l > 0 {
n += 1 + l + sovPrivate(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -6597,6 +6655,38 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
}
}
m.TrackExistence = bool(v != 0)
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPrivate
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthPrivate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPrivate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Description = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPrivate(dAtA[iNdEx:])
@ -8183,6 +8273,38 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPrivate
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthPrivate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPrivate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Owner = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPrivate(dAtA[iNdEx:])
@ -8353,6 +8475,38 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPrivate
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthPrivate
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthPrivate
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Owner = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPrivate(dAtA[iNdEx:])

3
pb/private.proto
View file

@ -7,6 +7,7 @@ import "public.proto";
message IndexMeta {
bool Keys = 3;
bool TrackExistence = 4;
string Description = 5;
}
message FieldOptions {
@ -67,6 +68,7 @@ message CreateIndexMessage {
string Index = 1;
IndexMeta Meta = 2;
int64 CreatedAt = 3;
string Owner = 5;
}
message CreateFieldMessage {
@ -74,6 +76,7 @@ message CreateFieldMessage {
string Field = 2;
FieldOptions Meta = 3;
int64 CreatedAt = 4;
string Owner = 5;
}
message UpdateFieldMessage {

2
pb/public.pb.go
View file

@ -465,6 +465,7 @@ func (m *KeyList) GetKeys() []string {
type ExtractedTableValue struct {
// Types that are valid to be assigned to Value:
//
// *ExtractedTableValue_IDs
// *ExtractedTableValue_Keys
// *ExtractedTableValue_BSIValue
@ -605,6 +606,7 @@ func (*ExtractedTableValue) XXX_OneofWrappers() []interface{} {
type ExtractedTableColumn struct {
// Types that are valid to be assigned to KeyOrID:
//
// *ExtractedTableColumn_Key
// *ExtractedTableColumn_ID
KeyOrID isExtractedTableColumn_KeyOrID `protobuf_oneof:"KeyOrID"`

2461
proto/pilosa.pb.go
View file

File diff suppressed because it is too large Load diff

7
proto/pilosa.proto
View file

@ -1,9 +1,7 @@
syntax = "proto3";
package pilosa;
package proto;
//import "public.proto";
option go_package = "github.com/pilosa/pilosa/v2/proto";
option go_package = "../proto";
message QueryPQLRequest {
string index = 1;
@ -93,6 +91,7 @@ message Index {
message CreateIndexRequest {
string name = 1;
bool keys = 2;
string description = 3;
}
message CreateIndexResponse {

1
server.go
View file

@ -1015,6 +1015,7 @@ func (s *Server) receiveMessage(m Message) error {
if err := idx.UpdateFieldLocal(&obj.CreateFieldMessage, obj.Update); err != nil {
return err
}
case *DeleteFieldMessage:
idx := s.holder.Index(obj.Index)
if err := idx.DeleteField(obj.Field); err != nil {

90
server/handler_test.go
View file

@ -179,12 +179,12 @@ func TestHandler_Endpoints(t *testing.T) {
const shard = 0
tx0 := holder.Txf().NewWritableQcx()
defer tx0.Abort()
if f, err := i0.CreateFieldIfNotExists("f1", pilosa.OptFieldTypeDefault()); err != nil {
if f, err := i0.CreateFieldIfNotExists("f1", "", pilosa.OptFieldTypeDefault()); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx0, 0, 0, nil); err != nil {
t.Fatal(err)
}
if _, err := i0.CreateFieldIfNotExists("f0", pilosa.OptFieldTypeDefault()); err != nil {
if _, err := i0.CreateFieldIfNotExists("f0", "", pilosa.OptFieldTypeDefault()); err != nil {
t.Fatal(err)
}
if err := tx0.Finish(); err != nil {
@ -194,7 +194,7 @@ func TestHandler_Endpoints(t *testing.T) {
i1 := hldr.MustCreateIndexIfNotExists("i1", pilosa.IndexOptions{})
tx1 := holder.Txf().NewWritableQcx()
defer tx1.Abort()
if f, err := i1.CreateFieldIfNotExists("f0", pilosa.OptFieldTypeDefault()); err != nil {
if f, err := i1.CreateFieldIfNotExists("f0", "", pilosa.OptFieldTypeDefault()); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx1, 0, 0, nil); err != nil {
t.Fatal(err)
@ -215,9 +215,10 @@ func TestHandler_Endpoints(t *testing.T) {
&bodySchema); err != nil {
t.Fatalf("unexpected unmarshalling error: %v", err)
}
// DO NOT COMPARE `CreatedAt` - reset to 0
// DO NOT COMPARE `CreatedAt` & 'UpdatedAt' - reset to 0
for _, i := range bodySchema.Indexes {
i.CreatedAt = 0
i.UpdatedAt = 0
for _, f := range i.Fields {
f.CreatedAt = 0
}
@ -225,8 +226,27 @@ func TestHandler_Endpoints(t *testing.T) {
//
var targetSchema pilosa.Schema
if err := json.Unmarshal([]byte(fmt.Sprintf(`{"indexes":[{"name":"i0","options":{"keys":false,"trackExistence":false},"fields":[{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}},{"name":"f1","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}}],"shardWidth":%d},{"name":"i1","options":{"keys":false,"trackExistence":false},"fields":[{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}}],"shardWidth":%[1]d}]}`, pilosa.ShardWidth)),
&targetSchema); err != nil {
if err := json.Unmarshal([]byte(fmt.Sprintf(`{"indexes":[
{
"name":"i0",
"options":{"keys":false,"trackExistence":false},
"updatedAt": 0,
"description": "this is a description",
"fields":[
{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}},
{"name":"f1","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}}
],
"shardWidth":%d
},
{
"name":"i1",
"options":{"keys":false,"trackExistence":false},
"updatedAt": 0,
"description": "this is a description",
"fields":[
{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}}],"shardWidth":%[1]d}
]
}`, pilosa.ShardWidth)), &targetSchema); err != nil {
t.Fatalf("unexpected unmarshalling error: %v", err)
}
@ -239,13 +259,13 @@ func TestHandler_Endpoints(t *testing.T) {
i2 := hldr.MustCreateIndexIfNotExists("i2", pilosa.IndexOptions{})
tx2 := holder.Txf().NewWritableQcx()
defer tx2.Abort()
if f, err := i2.CreateFieldIfNotExists("f0", pilosa.OptFieldTypeSet(pilosa.CacheTypeRanked, 1000)); err != nil {
if f, err := i2.CreateFieldIfNotExists("f0", "", pilosa.OptFieldTypeSet(pilosa.CacheTypeRanked, 1000)); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx2, 0, 0, nil); err != nil {
t.Fatal(err)
}
f, err := i2.CreateFieldIfNotExists("f1", pilosa.OptFieldTypeInt(-100, 100))
f, err := i2.CreateFieldIfNotExists("f1", "", pilosa.OptFieldTypeInt(-100, 100))
if err != nil {
t.Fatal(err)
}
@ -256,7 +276,7 @@ func TestHandler_Endpoints(t *testing.T) {
}
}
f, err = i2.CreateFieldIfNotExists("f2", pilosa.OptFieldTypeDecimal(1, pql.NewDecimal(-10, 0), pql.NewDecimal(10, 0)))
f, err = i2.CreateFieldIfNotExists("f2", "", pilosa.OptFieldTypeDecimal(1, pql.NewDecimal(-10, 0), pql.NewDecimal(10, 0)))
if err != nil {
t.Fatal(err)
}
@ -267,17 +287,17 @@ func TestHandler_Endpoints(t *testing.T) {
}
}
if f, err := i2.CreateFieldIfNotExists("f3", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0")); err != nil {
if f, err := i2.CreateFieldIfNotExists("f3", "", pilosa.OptFieldTypeTime(pilosa.TimeQuantum("YMDH"), "0")); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx2, 0, 0, nil); err != nil {
t.Fatal(err)
}
if f, err := i2.CreateFieldIfNotExists("f4", pilosa.OptFieldTypeMutex(pilosa.CacheTypeRanked, 5000)); err != nil {
if f, err := i2.CreateFieldIfNotExists("f4", "", pilosa.OptFieldTypeMutex(pilosa.CacheTypeRanked, 5000)); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx2, 0, 0, nil); err != nil {
t.Fatal(err)
}
if f, err := i2.CreateFieldIfNotExists("f5", pilosa.OptFieldTypeBool()); err != nil {
if f, err := i2.CreateFieldIfNotExists("f5", "", pilosa.OptFieldTypeBool()); err != nil {
t.Fatal(err)
} else if _, err := f.SetBit(tx2, 0, 0, nil); err != nil {
t.Fatal(err)
@ -298,9 +318,10 @@ func TestHandler_Endpoints(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &bodySchema); err != nil {
t.Fatalf("unexpected unmarshalling error: %v", err)
}
// DO NOT COMPARE `CreatedAt` - reset to 0
// DO NOT COMPARE `CreatedAt` & `UpdatedAt`` - reset to 0
for _, i := range bodySchema.Indexes {
i.CreatedAt = 0
i.UpdatedAt = 0
for _, f := range i.Fields {
f.CreatedAt = 0
}
@ -308,7 +329,44 @@ func TestHandler_Endpoints(t *testing.T) {
//
var targetSchema pilosa.Schema
target := fmt.Sprintf(`{"indexes":[{"name":"i0","options":{"keys":false,"trackExistence":false},"fields":[{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}},{"name":"f1","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false},"views":[{"name":"standard"}]}],"shardWidth":%[1]d},{"name":"i1","options":{"keys":false,"trackExistence":false},"fields":[{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false},"views":[{"name":"standard"}]}],"shardWidth":%[1]d},{"name":"i2","options":{"keys":false,"trackExistence":false},"fields":[{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":1000,"keys":false},"views":[{"name":"standard"}]},{"name":"f1","options":{"type":"int","base":0,"bitDepth":0,"min":-100,"max":100,"keys":false,"foreignIndex":""},"views":[{"name":"bsig_f1"}]},{"name":"f2","options":{"type":"decimal","base":0,"scale":1,"bitDepth":0,"min":-10,"max":10,"keys":false},"views":[{"name":"bsig_f2"}]},{"name":"f3","options":{"type":"time","timeQuantum":"YMDH","keys":false,"noStandardView":false},"views":[{"name":"standard"}]},{"name":"f4","options":{"type":"mutex","cacheType":"ranked","cacheSize":5000,"keys":false},"views":[{"name":"standard"}]},{"name":"f5","options":{"type":"bool"},"views":[{"name":"standard"}]}],"shardWidth":%[1]d}]}`, pilosa.ShardWidth)
target := fmt.Sprintf(`{"indexes":[
{
"name":"i0",
"options":{"keys":false,"trackExistence":false},
"updatedAt": 0,
"description": "this is a description",
"fields":[
{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false}},
{"name":"f1","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false},"views":[{"name":"standard"}]}
],
"shardWidth":%[1]d
},
{
"name":"i1",
"options":{"keys":false,"trackExistence":false},
"updatedAt": 0,
"description": "this is a description",
"fields":[
{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":50000,"keys":false},"views":[{"name":"standard"}]}
],
"shardWidth":%[1]d
},
{
"name":"i2",
"options":{"keys":false,"trackExistence":false},
"updatedAt": 0,
"description": "this is a description",
"fields":[
{"name":"f0","options":{"type":"set","cacheType":"ranked","cacheSize":1000,"keys":false},"views":[{"name":"standard"}]},
{"name":"f1","options":{"type":"int","base":0,"bitDepth":0,"min":-100,"max":100,"keys":false,"foreignIndex":""},"views":[{"name":"bsig_f1"}]},
{"name":"f2","options":{"type":"decimal","base":0,"scale":1,"bitDepth":0,"min":-10,"max":10,"keys":false},"views":[{"name":"bsig_f2"}]},
{"name":"f3","options":{"type":"time","timeQuantum":"YMDH","keys":false,"noStandardView":false},"views":[{"name":"standard"}]},
{"name":"f4","options":{"type":"mutex","cacheType":"ranked","cacheSize":5000,"keys":false},"views":[{"name":"standard"}]},
{"name":"f5","options":{"type":"bool"},"views":[{"name":"standard"}]}
],
"shardWidth":%[1]d}
]
}`, pilosa.ShardWidth)
if err := json.Unmarshal([]byte(target), &targetSchema); err != nil {
t.Fatalf("unexpected unmarshalling error: %v", err)
}
@ -416,7 +474,7 @@ func TestHandler_Endpoints(t *testing.T) {
})
t.Run("ImportRoaringOverwrite", func(t *testing.T) {
if _, err := i0.CreateFieldIfNotExists("int-field", pilosa.OptFieldTypeInt(0, 10)); err != nil {
if _, err := i0.CreateFieldIfNotExists("int-field", "", pilosa.OptFieldTypeInt(0, 10)); err != nil {
t.Fatal(err)
}
w := httptest.NewRecorder()
@ -957,7 +1015,7 @@ func TestHandler_Endpoints(t *testing.T) {
t.Run("Field delete", func(t *testing.T) {
i := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{})
if _, err := i.CreateFieldIfNotExists("f1", pilosa.OptFieldTypeDefault()); err != nil {
if _, err := i.CreateFieldIfNotExists("f1", "", pilosa.OptFieldTypeDefault()); err != nil {
t.Fatal(err)
}
w := httptest.NewRecorder()

110
sql3/planner/executionplanner_test.go
View file

@ -22,25 +22,25 @@ func TestPlanner_Show(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), pilosa.IndexOptions{TrackExistence: true})
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := index.CreateField("f", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := index.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := index.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
index2, err := c.GetHolder(0).CreateIndex(c.Idx("l"), pilosa.IndexOptions{TrackExistence: false})
index2, err := c.GetHolder(0).CreateIndex(c.Idx("l"), "", pilosa.IndexOptions{TrackExistence: false})
if err != nil {
t.Fatal(err)
}
if _, err := index2.CreateField("f", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := index2.CreateField("f", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := index2.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := index2.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -532,14 +532,14 @@ func TestPlanner_AlterTable(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), pilosa.IndexOptions{TrackExistence: true})
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := index.CreateField("f", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := index.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := index.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -594,14 +594,14 @@ func TestPlanner_DropTable(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), pilosa.IndexOptions{TrackExistence: true})
index, err := c.GetHolder(0).CreateIndex(c.Idx("i"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := index.CreateField("f", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := index.CreateField("f", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := index.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := index.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -617,25 +617,25 @@ func TestPlanner_ExpressionsInSelectListParen(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), pilosa.IndexOptions{TrackExistence: true})
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i1.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i1.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i1.CreateField("y", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i1.CreateField("y", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -698,20 +698,20 @@ func TestPlanner_ExpressionsInSelectListLiterals(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("d", pilosa.OptFieldTypeDecimal(2)); err != nil {
} else if _, err := i0.CreateField("d", "", pilosa.OptFieldTypeDecimal(2)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("ts", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, "s")); err != nil {
} else if _, err := i0.CreateField("ts", "", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, "s")); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("str", pilosa.OptFieldTypeMutex(pilosa.CacheTypeLRU, pilosa.DefaultCacheSize), pilosa.OptFieldKeys()); err != nil {
} else if _, err := i0.CreateField("str", "", pilosa.OptFieldTypeMutex(pilosa.CacheTypeLRU, pilosa.DefaultCacheSize), pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
@ -840,20 +840,20 @@ func TestPlanner_ExpressionsInSelectListCase(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("d", pilosa.OptFieldTypeDecimal(2)); err != nil {
} else if _, err := i0.CreateField("d", "", pilosa.OptFieldTypeDecimal(2)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("ts", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, "s")); err != nil {
} else if _, err := i0.CreateField("ts", "", pilosa.OptFieldTypeTimestamp(pilosa.DefaultEpoch, "s")); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("str", pilosa.OptFieldTypeMutex(pilosa.CacheTypeLRU, pilosa.DefaultCacheSize), pilosa.OptFieldKeys()); err != nil {
} else if _, err := i0.CreateField("str", "", pilosa.OptFieldTypeMutex(pilosa.CacheTypeLRU, pilosa.DefaultCacheSize), pilosa.OptFieldKeys()); err != nil {
t.Fatal(err)
}
@ -921,25 +921,25 @@ func TestPlanner_Select(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), pilosa.IndexOptions{TrackExistence: true})
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i1.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i1.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i1.CreateField("y", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i1.CreateField("y", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -1120,14 +1120,14 @@ func TestPlanner_SelectOrderBy(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -1170,14 +1170,14 @@ func TestPlanner_SelectSelectSource(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -1242,23 +1242,23 @@ func TestPlanner_In(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), pilosa.IndexOptions{TrackExistence: true})
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i1.CreateField("parentid", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i1.CreateField("parentid", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i1.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i1.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -1373,23 +1373,23 @@ func TestPlanner_Distinct(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), pilosa.IndexOptions{TrackExistence: true})
i1, err := c.GetHolder(0).CreateIndex(c.Idx("k"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i1.CreateField("parentid", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i1.CreateField("parentid", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
} else if _, err := i1.CreateField("x", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
} else if _, err := i1.CreateField("x", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
@ -1489,16 +1489,16 @@ func TestPlanner_SelectTop(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), pilosa.IndexOptions{TrackExistence: true})
i0, err := c.GetHolder(0).CreateIndex(c.Idx("j"), "", pilosa.IndexOptions{TrackExistence: true})
if err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("a", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("a", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}
if _, err := i0.CreateField("b", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
if _, err := i0.CreateField("b", "", pilosa.OptFieldTypeInt(0, 1000)); err != nil {
t.Fatal(err)
}

1
sql3/planner/opcreatetable.go
View file

@ -109,6 +109,7 @@ func (i *createTableRowIter) Next(ctx context.Context) (types.Row, error) {
}
}
// TODO (pok) add ability to add description here
if err := i.planner.schemaAPI.CreateIndexAndFields(ctx, i.tableName, options, fields); err != nil {
if _, ok := errors.Cause(err).(pilosa.ConflictError); ok {
if i.failIfExists {

16
test/holder.go
View file

@ -64,7 +64,7 @@ func (h *Holder) Reopen() error {
// MustCreateIndexIfNotExists returns a given index. Panic on error.
func (h *Holder) MustCreateIndexIfNotExists(index string, opt pilosa.IndexOptions) *Index {
idx, err := h.Holder.CreateIndexIfNotExists(index, opt)
idx, err := h.Holder.CreateIndexIfNotExists(index, "", opt)
if err != nil {
h.tb.Fatalf("creating index: %v", err)
}
@ -74,7 +74,7 @@ func (h *Holder) MustCreateIndexIfNotExists(index string, opt pilosa.IndexOption
// Row returns a Row for a given field.
func (h *Holder) Row(index, field string, rowID uint64) *pilosa.Row {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeDefault())
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeDefault())
if err != nil {
panic(err)
}
@ -116,7 +116,7 @@ func (h *Holder) ReadRow(index, field string, rowID uint64) *pilosa.Row {
func (h *Holder) RowTime(index, field string, rowID uint64, t time.Time, quantum string) *pilosa.Row {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeDefault())
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeDefault())
if err != nil {
panic(err)
}
@ -141,7 +141,7 @@ func (h *Holder) SetBit(index, field string, rowID, columnID uint64) {
// SetBitTime sets a bit with timestamp on the given field.
func (h *Holder) SetBitTime(index, field string, rowID, columnID uint64, t *time.Time) {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeDefault())
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeDefault())
if err != nil {
panic(err)
}
@ -162,7 +162,7 @@ func (h *Holder) SetBitTime(index, field string, rowID, columnID uint64, t *time
// ClearBit clears a bit on the given field.
func (h *Holder) ClearBit(index, field string, rowID, columnID uint64) {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeDefault())
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeDefault())
if err != nil {
panic(err)
}
@ -191,7 +191,7 @@ func (h *Holder) MustSetBits(index, field string, rowID uint64, columnIDs ...uin
// SetValue sets an integer value on the given field.
func (h *Holder) SetValue(index, field string, columnID uint64, value int64) *Index {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
panic(err)
}
@ -213,7 +213,7 @@ func (h *Holder) SetValue(index, field string, columnID uint64, value int64) *In
// Value returns the integer value for a given column.
func (h *Holder) Value(index, field string, columnID uint64) (int64, bool) {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
panic(err)
}
@ -232,7 +232,7 @@ func (h *Holder) Value(index, field string, columnID uint64) (int64, bool) {
// on the given range.
func (h *Holder) Range(index, field string, op pql.Token, predicate int64) *pilosa.Row {
idx := h.MustCreateIndexIfNotExists(index, pilosa.IndexOptions{})
f, err := idx.CreateFieldIfNotExists(field, pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
f, err := idx.CreateFieldIfNotExists(field, "", pilosa.OptFieldTypeInt(math.MinInt64, math.MaxInt64))
if err != nil {
panic(err)
}

10
test/index.go
View file

@ -20,7 +20,7 @@ func newIndex(tb testing.TB) (*Holder, *Index) {
testhook.Cleanup(tb, func() {
h.Close()
})
index, err := h.CreateIndex("i", pilosa.IndexOptions{})
index, err := h.CreateIndex("i", "", pilosa.IndexOptions{})
if err != nil {
panic(err)
}
@ -51,8 +51,8 @@ func (i *Index) Reopen() error {
}
// CreateField creates a field with the given options.
func (i *Index) CreateField(name string, opts ...pilosa.FieldOption) (*Field, error) {
f, err := i.Index.CreateField(name, opts...)
func (i *Index) CreateField(name string, requestUserID string, opts ...pilosa.FieldOption) (*Field, error) {
f, err := i.Index.CreateField(name, requestUserID, opts...)
if err != nil {
return nil, err
}
@ -60,8 +60,8 @@ func (i *Index) CreateField(name string, opts ...pilosa.FieldOption) (*Field, er
}
// CreateFieldIfNotExists creates a field with the given options if it doesn't exist.
func (i *Index) CreateFieldIfNotExists(name string, opts ...pilosa.FieldOption) (*Field, error) {
f, err := i.Index.CreateFieldIfNotExists(name, opts...)
func (i *Index) CreateFieldIfNotExists(name string, requestUserID string, opts ...pilosa.FieldOption) (*Field, error) {
f, err := i.Index.CreateFieldIfNotExists(name, requestUserID, opts...)
if err != nil {
return nil, err
}