forked from arangodb/go-driver
-
Notifications
You must be signed in to change notification settings - Fork 0
/
database_collections.go
150 lines (136 loc) · 9.39 KB
/
database_collections.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//
// DISCLAIMER
//
// Copyright 2017 ArangoDB GmbH, Cologne, Germany
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Copyright holder is ArangoDB GmbH, Cologne, Germany
//
// Author Ewout Prangsma
//
package driver
import "context"
// DatabaseCollections provides access to all collections in a single database.
type DatabaseCollections interface {
// Collection opens a connection to an existing collection within the database.
// If no collection with given name exists, an NotFoundError is returned.
Collection(ctx context.Context, name string) (Collection, error)
// CollectionExists returns true if a collection with given name exists within the database.
CollectionExists(ctx context.Context, name string) (bool, error)
// Collections returns a list of all collections in the database.
Collections(ctx context.Context) ([]Collection, error)
// CreateCollection creates a new collection with given name and options, and opens a connection to it.
// If a collection with given name already exists within the database, a DuplicateError is returned.
CreateCollection(ctx context.Context, name string, options *CreateCollectionOptions) (Collection, error)
}
// CreateCollectionOptions contains options that customize the creating of a collection.
type CreateCollectionOptions struct {
// The maximal size of a journal or datafile in bytes. The value must be at least 1048576 (1 MiB). (The default is a configuration parameter)
JournalSize int `arango:"journalSize,omitempty" json:"journalSize,omitempty"`
// ReplicationFactor in a cluster (default is 1), this attribute determines how many copies of each shard are kept on different DBServers.
// The value 1 means that only one copy (no synchronous replication) is kept.
// A value of k means that k-1 replicas are kept. Any two copies reside on different DBServers.
// Replication between them is synchronous, that is, every write operation to the "leader" copy will be replicated to all "follower" replicas,
// before the write operation is reported successful. If a server fails, this is detected automatically
// and one of the servers holding copies take over, usually without an error being reported.
ReplicationFactor int `arango:"replicationFactor,omitempty" json:"replicationFactor,omitempty"`
// If true then the data is synchronized to disk before returning from a document create, update, replace or removal operation. (default: false)
WaitForSync bool `arango:"waitForSync,omitempty" json:"waitForSync,omitempty"`
// Whether or not the collection will be compacted (default is true)
DoCompact *bool `arango:"doCompact,omitempty" json:"doCompact,omitempty"`
// If true then the collection data is kept in-memory only and not made persistent.
// Unloading the collection will cause the collection data to be discarded. Stopping or re-starting the server will also
// cause full loss of data in the collection. Setting this option will make the resulting collection be slightly faster
// than regular collections because ArangoDB does not enforce any synchronization to disk and does not calculate any
// CRC checksums for datafiles (as there are no datafiles). This option should therefore be used for cache-type collections only,
// and not for data that cannot be re-created otherwise. (The default is false)
IsVolatile bool `arango:"isVolatile,omitempty" json:"isVolatile,omitempty"`
// In a cluster, this attribute determines which document attributes are used to
// determine the target shard for documents. Documents are sent to shards based on the values of their shard key attributes.
// The values of all shard key attributes in a document are hashed, and the hash value is used to determine the target shard.
// Note: Values of shard key attributes cannot be changed once set. This option is meaningless in a single server setup.
// The default is []string{"_key"}.
ShardKeys []string `arango:"shardKeys,omitempty" json:"shardKeys,omitempty"`
// In a cluster, this value determines the number of shards to create for the collection. In a single server setup, this option is meaningless. (default is 1)
NumberOfShards int `arango:"numberOfShards,omitempty" json:"numberOfShards,omitempty"`
// If true, create a system collection. In this case collection-name should start with an underscore.
// End users should normally create non-system collections only. API implementors may be required to create system
// collections in very special occasions, but normally a regular collection will do. (The default is false)
IsSystem bool `arango:"isSystem,omitempty" json:"isSystem,omitempty"`
// The type of the collection to create. (default is CollectionTypeDocument)
Type CollectionType `arango:"type,omitempty" json:"type,omitempty"`
// The number of buckets into which indexes using a hash table are split. The default is 16 and this number has to be a power
// of 2 and less than or equal to 1024. For very large collections one should increase this to avoid long pauses when the hash
// table has to be initially built or resized, since buckets are resized individually and can be initially built in parallel.
// For example, 64 might be a sensible value for a collection with 100 000 000 documents.
// Currently, only the edge index respects this value, but other index types might follow in future ArangoDB versions.
// Changes are applied when the collection is loaded the next time.
IndexBuckets int `arango:"indexBuckets,omitempty" json:"indexBuckets,omitempty"`
// Specifies how keys in the collection are created.
KeyOptions *CollectionKeyOptions `arango:"keyOptions,omitempty" json:"keyOptions,omitempty"`
// This field is used for internal purposes only. DO NOT USE.
DistributeShardsLike string `arango:"distributeShardsLike,omitempty" json:"distributeShardsLike,omitempty"`
// Set to create a smart edge or vertex collection.
// This requires ArangoDB Enterprise Edition.
IsSmart bool `arango:"isSmart,omitempty" json:"isSmart,omitempty"`
// This field must be set to the attribute that will be used for sharding or smart graphs.
// All vertices are required to have this attribute set. Edges derive the attribute from their connected vertices.
// This requires ArangoDB Enterprise Edition.
SmartGraphAttribute string `arango:"smartGraphAttribute,omitempty" json:"smartGraphAttribute,omitempty"`
// SmartJoinAttribute
// In the specific case that the two collections have the same number of shards, the data of the two collections can
// be co-located on the same server for the same shard key values. In this case the extra hop via the coordinator will not be necessary.
// See documentation for smart joins.
// This requires ArangoDB Enterprise Edition.
SmartJoinAttribute string `arango:"smartJoinAttribute,omitempty" json:"smartJoinAttribute,omitempty"`
// This attribute specifies the name of the sharding strategy to use for the collection.
// Must be one of ShardingStrategy* values.
ShardingStrategy ShardingStrategy `arango:"shardingStrategy,omitempty" json:"shardingStrategy,omitempty"`
}
// CollectionType is the type of a collection.
type CollectionType int
const (
// CollectionTypeDocument specifies a document collection
CollectionTypeDocument = CollectionType(2)
// CollectionTypeEdge specifies an edges collection
CollectionTypeEdge = CollectionType(3)
)
// CollectionKeyOptions specifies ways for creating keys of a collection.
type CollectionKeyOptions struct {
// If set to true, then it is allowed to supply own key values in the _key attribute of a document.
// If set to false, then the key generator will solely be responsible for generating keys and supplying own
// key values in the _key attribute of documents is considered an error.
AllowUserKeys bool `arango:"allowUserKeys,omitempty" json:"allowUserKeys,omitempty"`
// Specifies the type of the key generator. The currently available generators are traditional and autoincrement.
Type KeyGeneratorType `arango:"type,omitempty" json:"type,omitempty"`
// increment value for autoincrement key generator. Not used for other key generator types.
Increment int `arango:"increment,omitempty" json:"increment,omitempty"`
// Initial offset value for autoincrement key generator. Not used for other key generator types.
Offset int `arango:"offset,omitempty" json:"offset,omitempty"`
}
// KeyGeneratorType is a type of key generated, used in `CollectionKeyOptions`.
type KeyGeneratorType string
const (
KeyGeneratorTraditional = KeyGeneratorType("traditional")
KeyGeneratorAutoIncrement = KeyGeneratorType("autoincrement")
)
// ShardingStrategy describes the sharding strategy of a collection
type ShardingStrategy string
const (
ShardingStrategyCommunityCompat ShardingStrategy = "community-compat"
ShardingStrategyEnterpriseCompat ShardingStrategy = "enterprise-compat"
ShardingStrategyEnterpriseSmartEdgeCompat ShardingStrategy = "enterprise-smart-edge-compat"
ShardingStrategyHash ShardingStrategy = "hash"
ShardingStrategyEnterpriseHashSmartEdge ShardingStrategy = "enterprise-hash-smart-edge"
)