featurebase/pb/private.proto
CLoZengineer daceee2ab6
merge: featurebase merge updates for 2022-10-28 (#2188)
* use t.Fatal(f) to abort tests, not panic

* make perf_able run at all, make it debug a bit better

switch perf-able to using same node type we use for other spot instances,
because otherwise it never finds any available capacity.

we switch the perf-able script to use the standard get_value function
instead of direct jq calls.

we try to grab server logs if the restore fails in the hopes of finding
out why the restore very occasionally fails.

* Fix some issues with running IDK tests in docker. (#2248)

*Stop running TestKafkaSourceIntegration with t.Parallel()

This test can't be run in parallel as it's currently written. Doing so
allows for interleaving of messages to the same kafka topic between
tests.

I didn't attempt to modify the test so it could be run in parallel. That
could be done, but left for someone more ambitious.

* Remove idk/testenv/certs which got accidentally committed.

also update .gitignore to include those.

* changes to add bool support in idk (#2240)

* initial changes to add bool support in idk

* modifying some default parameters for testing, will revert them later

* adding support for bool in making fragments function

* boolean values implementation without supporting empty or null values at this point

* Implement bool support in batch using a map (and a slice for nulls) (#2247)

* Implement bool support in batch using a map (and a slice for nulls)

* Keep the PackBools default for now

But set it explicity in the ingest tests which rely on it.

* Modify batch to construct bool update like mutex

The code in API.ImportRoaringShard has a switch statement which causes
bool fields to be handled like mutex fields. This means, that the
viewUpdate.Clear value should only contain data in the first "row" of
the fragment, which it will treat as records to clear for *all* rows.
This makes more sense for mutex fields; for bool fields, there's only
one other row to clear. But since the code is currently handling them
the same, we need to construct viewUpdate.Clear such that it conforms to
that pattern.

This commit also adds a test which covers this logic.

* Remove commented code; revert config for testing

This commit also removes the DELETE_SENTINEL case for non-packed bools,
since that isn't supported anyway.

* Revert default setting

* remove inconsistent type scope

* correcting the logic of string converstion to bool

* resolving an error in a test

* adding tests to cover code related to bool support in batch.go file and interface.go files

* modifying interfaces test

* added one more test case

Co-authored-by: Travis Turner <travis@pilosa.com>
Co-authored-by: Travis Turner <travis@molecula.com>

* resolving bool null field ingestion error (#2254)

* resolving bool null field ingestion error

* testing issues

* adding null support for bools

* updating the null bool field ingestion

* trying to resolve issue when ingesting null value for bool type

* adding a clearing support for bool type

* resolving issues with bool null value ingestion

* updating the jwt go package version and removing changes made in docker compose file

* reverting jwt go version

* removing v4 of jwt

* adding a comment in test file to see if sonar cloud accepts this file

* don't obtain stack traces on rbf.Tx creation

We thought stack traces were mildly expensive. We were very wrong.
Due to a complicated issue in the Go runtime, simultaneous requests
for stack traces end up contending on a lock even when they're not
actually contending on any resources. I've filed a ticket in the
Go issue tracker for this:

	https://github.com/golang/go/issues/56400

In the mean time: Under some workloads, we were seeing 85% of all
CPU time go into the stack backtraces, of which 81% went into the
contention on those locks. But even if you take away the contention,
that leaves us with 4/19 of all CPU time in our code going into
building those stack backtraces. That's a lot of overhead for a
feature we virtually never use.

We might consider adding a backtrace functionality here, possibly
using `runtime.Callers` which is much lower overhead, and allows us
to generate a backtrace on demand (no argument values available,
but then, we never read those because they're unformatted hex
values), but I don't think it's actually very informative to know
what the stack traces were of the Tx; they don't necessarily reflect
the current state of any ongoing use of the Tx, so we can't necessarily
correlate them to goroutine stack dumps, and so on.

* fb-1729 Enriched Table Metadata (#2255)

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

* tightened up is/is not null filter expressions (FB-1741) (#2260)

Covers tightening up handling filter expressions that contain is/is not null ops. These filters may have to be translated into PQL calls to be passed to the executor and even though sql3 language supports nullability for any data type, currently only BSI fields are nullable at the storage engine level (there is a ticket to add support for non-BSI field here FB-1689: IS SQL Argument returns incorrect error) so when these fields are used in filter conditions we need to handle BSI and non-BSI fields differently.

* added a test to cover the keyword replace as being synonymous with insert (#2261)

* update molecula references to featurebase (#2262)

Co-authored-by: Seebs <seebs@molecula.com>
Co-authored-by: Travis Turner <travis@pilosa.com>
Co-authored-by: Pranitha-malae <56414132+Pranitha-malae@users.noreply.github.com>
Co-authored-by: Travis Turner <travis@molecula.com>
Co-authored-by: pokeeffe-molecula <85502298+pokeeffe-molecula@users.noreply.github.com>
Co-authored-by: Stephanie Yang <stephanie@pilosa.com>
2022-10-28 13:08:23 -04:00

272 lines
4.2 KiB
Protocol Buffer

syntax = "proto3";
package pb;
import "public.proto";
message IndexMeta {
bool Keys = 3;
bool TrackExistence = 4;
string Description = 5;
}
message FieldOptions {
string Type = 8;
string CacheType = 3;
uint32 CacheSize = 4;
string TimeQuantum = 5;
int64 OldMin = 9;
int64 OldMax = 10;
bool Keys = 11;
bool NoStandardView = 12;
int64 Base = 13;
uint64 BitDepth = 14;
int64 Scale = 15;
string ForeignIndex = 16;
Decimal Min = 17;
Decimal Max = 18;
string TimeUnit = 19;
string TTL = 20;
}
message ImportResponse {
string Err = 1;
}
message BlockDataRequest {
string Index = 1;
string Field = 2;
string View = 5;
uint64 Shard = 4;
uint64 Block = 3;
}
message BlockDataResponse {
repeated uint64 RowIDs = 1;
repeated uint64 ColumnIDs = 2;
}
message Cache {
repeated uint64 IDs = 1;
}
message MaxShards {
map<string, uint64> Standard = 1;
}
message CreateShardMessage {
string Index = 1;
string Field = 3;
uint64 Shard = 2;
}
message DeleteIndexMessage {
string Index = 1;
}
message CreateIndexMessage {
string Index = 1;
IndexMeta Meta = 2;
int64 CreatedAt = 3;
string Owner = 5;
}
message CreateFieldMessage {
string Index = 1;
string Field = 2;
FieldOptions Meta = 3;
int64 CreatedAt = 4;
string Owner = 5;
}
message UpdateFieldMessage {
CreateFieldMessage CreateFieldMessage = 1;
FieldUpdate Update = 2;
}
message FieldUpdate {
string Option = 1;
string Value = 2;
}
message DeleteFieldMessage {
string Index = 1;
string Field = 2;
}
message DeleteAvailableShardMessage {
string Index = 1;
string Field = 2;
uint64 ShardID = 3;
}
message Field {
string Name = 1;
FieldOptions Meta = 2;
repeated string Views = 3;
int64 CreatedAt = 4;
}
message Schema {
repeated Index Indexes = 1;
}
message Index {
string Name = 1;
int64 CreatedAt = 2;
IndexMeta Options = 5;
repeated Field Fields = 4;
}
message URI {
string Scheme = 1;
string Host = 2;
uint32 Port = 3;
}
message Node {
string ID = 1;
URI URI = 2;
bool IsPrimary = 3;
string State = 4;
URI GRPCURI = 5;
}
message NodeStateMessage {
string NodeID = 1;
string State = 2;
}
message NodeEventMessage {
uint32 Event = 1;
Node Node = 2;
}
message NodeStatus {
Node Node = 1;
Schema Schema = 3;
repeated IndexStatus Indexes = 4;
}
message IndexStatus {
string Name = 1;
repeated FieldStatus Fields = 2;
int64 CreatedAt = 3;
}
message FieldStatus {
string Name = 1;
repeated uint64 AvailableShards = 2;
int64 CreatedAt = 3;
}
message ClusterStatus {
string ClusterID = 1;
string State = 2;
repeated Node Nodes = 3;
Schema Schema = 4;
}
message BSIGroup {
string Name = 1;
string Type = 2;
int64 Min = 3;
int64 Max = 4;
}
message CreateViewMessage {
string Index = 1;
string Field = 2;
string View = 3;
}
message DeleteViewMessage {
string Index = 1;
string Field = 2;
string View = 3;
}
message ResizeInstruction {
int64 JobID = 1;
Node Node = 2;
Node Primary = 3;
repeated ResizeSource Sources = 4;
repeated TranslationResizeSource TranslationSources = 8;
NodeStatus NodeStatus = 7;
ClusterStatus ClusterStatus = 6;
}
message ResizeSource {
Node Node = 1;
string Index = 2;
string Field = 3;
string View = 4;
uint64 Shard = 5;
}
message TranslationResizeSource {
Node Node = 1;
string Index = 2;
int32 PartitionID = 3;
}
message ResizeInstructionComplete {
int64 JobID = 1;
Node Node = 2;
string Error = 3;
}
message Topology {
string ClusterID = 1;
repeated string NodeIDs = 2;
}
message RecalculateCaches {}
message LoadSchemaMessage {}
message TransactionMessage {
string Action = 1;
Transaction Transaction = 2;
}
message Transaction {
string ID = 1;
bool Active = 2;
bool Exclusive = 3;
int64 Timeout = 4;
int64 Deadline = 5;
TransactionStats Stats = 6;
}
message TransactionStats {}
message ResizeAbortMessage {
}
message ResizeNodeMessage {
string NodeID = 1;
string Action = 2;
}
message FieldOperation {
repeated uint64 RecordIDs = 1;
repeated uint64 Values = 2;
repeated int64 Signed = 3;
}
message ShardIngestOperation {
string OpType = 1;
repeated uint64 ClearRecordIDs = 2;
repeated string ClearFields = 3;
map <string, FieldOperation> FieldOps = 4;
}
message ShardIngestOperations {
repeated ShardIngestOperation Ops = 1;
}
message ShardedIngestRequest {
map <uint64, ShardIngestOperations> Ops = 1;
}