Feature/add mis endpoints in col

v2/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [master](https://github.com/arangodb/go-driver/tree/master) (N/A)
 - Add tasks endpoints to v2
+- Add missing endpoints from collections to v2
 
 ## [2.1.3](https://github.com/arangodb/go-driver/tree/v2.1.3) (2025-02-21)
 - Switch to Go 1.22.11

v2/arangodb/collection.go

@@ -51,6 +51,37 @@ type Collection interface {
 	// Count fetches the number of document in the collection.
 	Count(ctx context.Context) (int64, error)
 
+	// Statistics returns the number of documents and additional statistical information about the collection.
+	Statistics(ctx context.Context, details bool) (CollectionFigures, error)
+
+	// Revision fetches the revision ID of the collection.
+	// The revision ID is a server-generated string that clients can use to check whether data
+	// in a collection has changed since the last revision check.
+	Revision(ctx context.Context) (CollectionProperties, error)
+
+	// Checksum returns a checksum for the specified collection
+	// withRevisions - Whether to include document revision ids in the checksum calculation.
+	// withData - Whether to include document body data in the checksum calculation.
+	Checksum(ctx context.Context, withRevisions *bool, withData *bool) (CollectionChecksum, error)
+
+	// ResponsibleShard returns the shard responsible for the given options.
+	ResponsibleShard(ctx context.Context, options map[string]interface{}) (string, error)
+
+	// LoadIndexesIntoMemory loads all indexes of the collection into memory.
+	LoadIndexesIntoMemory(ctx context.Context) (bool, error)
+
+	// Renaming collections is not supported in cluster deployments.
+	// Renaming collections is only supported in single server deployments.
+	Rename(ctx context.Context, req RenameCollectionRequest) (CollectionInfo, error)
+
+	// RecalculateCount recalculates the count of documents in the collection.
+	RecalculateCount(ctx context.Context) (bool, *int64, error)
+
+	//Compacts the data of a collection in order to reclaim disk space.
+	// This operation is only supported in single server deployments.
+	// In cluster deployments, the compaction is done automatically by the server.
+	Compact(ctx context.Context) (CollectionInfo, error)
+
 	CollectionDocuments
 	CollectionIndexes
 }

v2/arangodb/collection_impl.go

@@ -216,6 +216,196 @@ func (c collection) Shards(ctx context.Context, details bool) (CollectionShards,
 	}
 }
 
+func (c collection) Statistics(ctx context.Context, details bool) (CollectionFigures, error) {
+	urlEndpoint := c.url("collection", "figures")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		CollectionFigures     `json:",inline"`
+	}
+
+	resp, err := connection.CallGet(
+		ctx, c.connection(), urlEndpoint, &response,
+		c.withModifiers(connection.WithQuery("details", boolToString(details)))...,
+	)
+	if err != nil {
+		return CollectionFigures{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.CollectionFigures, nil
+	default:
+		return CollectionFigures{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) Revision(ctx context.Context) (CollectionProperties, error) {
+	urlEndpoint := c.url("collection", "revision")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		CollectionProperties  `json:",inline"`
+	}
+
+	resp, err := connection.CallGet(
+		ctx, c.connection(), urlEndpoint, &response, c.withModifiers()...,
+	)
+
+	if err != nil {
+		return CollectionProperties{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.CollectionProperties, nil
+	default:
+		return CollectionProperties{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) Checksum(ctx context.Context, withRevisions *bool, withData *bool) (CollectionChecksum, error) {
+	urlEndpoint := c.url("collection", "checksum")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		CollectionChecksum    `json:",inline"`
+	}
+
+	// Prepare query modifiers
+	var modifiers []connection.RequestModifier
+	if withRevisions != nil && *withRevisions {
+		modifiers = append(modifiers, connection.WithQuery("withRevisions", boolToString(*withRevisions)))
+	}
+	if withData != nil && *withData {
+		modifiers = append(modifiers, connection.WithQuery("withData", boolToString(*withData)))
+	}
+
+	resp, err := connection.CallGet(
+		ctx, c.connection(), urlEndpoint, &response,
+		c.withModifiers(modifiers...)...,
+	)
+	if err != nil {
+		return CollectionChecksum{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.CollectionChecksum, nil
+	default:
+		return CollectionChecksum{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) ResponsibleShard(ctx context.Context, options map[string]interface{}) (string, error) {
+	urlEndpoint := c.url("collection", "responsibleShard")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		ShardId               string `json:"shardId,omitempty"`
+	}
+
+	resp, err := connection.CallPut(ctx, c.connection(), urlEndpoint, &response, options, c.withModifiers()...)
+	if err != nil {
+		return "", errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.ShardId, nil
+	default:
+		return "", response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) LoadIndexesIntoMemory(ctx context.Context) (bool, error) {
+	urlEndpoint := c.url("collection", "loadIndexesIntoMemory")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		Result                bool `json:"result"`
+	}
+
+	resp, err := connection.CallPut(ctx, c.connection(), urlEndpoint, &response, nil, c.withModifiers()...)
+	if err != nil {
+		return false, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.Result, nil
+	default:
+		return false, response.AsArangoErrorWithCode(code)
+	}
+}
+
+// Renaming collections is not supported in cluster deployments.
+func (c collection) Rename(ctx context.Context, req RenameCollectionRequest) (CollectionInfo, error) {
+	urlEndpoint := c.url("collection", "rename")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		CollectionInfo        `json:",inline"`
+	}
+
+	resp, err := connection.CallPut(ctx, c.connection(), urlEndpoint, &response, req, c.withModifiers()...)
+	if err != nil {
+		return CollectionInfo{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.CollectionInfo, nil
+	default:
+		return CollectionInfo{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) RecalculateCount(ctx context.Context) (bool, *int64, error) {
+	urlEndpoint := c.url("collection", "recalculateCount")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		Count                 *int64 `json:"count,omitempty"`
+		Result                bool   `json:"result"`
+	}
+
+	resp, err := connection.CallPut(ctx, c.connection(), urlEndpoint, &response, nil, c.withModifiers()...)
+	if err != nil {
+		zero := int64(0)
+		return false, &zero, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.Result, response.Count, nil
+	default:
+		zero := int64(0)
+		return false, &zero, response.AsArangoErrorWithCode(code)
+	}
+}
+
+func (c collection) Compact(ctx context.Context) (CollectionInfo, error) {
+	urlEndpoint := c.url("collection", "compact")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		CollectionInfo        `json:",inline"`
+	}
+
+	resp, err := connection.CallPut(ctx, c.connection(), urlEndpoint, &response, nil, c.withModifiers()...)
+	if err != nil {
+		return CollectionInfo{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.CollectionInfo, nil
+	default:
+		return CollectionInfo{}, response.AsArangoErrorWithCode(code)
+	}
+}
+
 type RemoveCollectionOptions struct {
 	// IsSystem when set to true allows to remove system collections.
 	// Use on your own risk!

v2/arangodb/collection_opts.go

@@ -73,6 +73,8 @@ type CollectionExtendedInfo struct {
 		// If set to false, then the key generator is solely responsible for generating keys and supplying own key values in
 		// the _key attribute of documents is considered an error.
 		AllowUserKeys bool `json:"allowUserKeys,omitempty"`
+		// The initial value for the key generator. This is only used for autoincrement key generators.
+		LastValue *uint64 `json:"lastValue,omitempty"`
 	} `json:"keyOptions,omitempty"`
 
 	// NumberOfShards is the number of shards of the collection.
@@ -149,6 +151,9 @@ type CollectionProperties struct {
 
 	// Schema for collection validation
 	Schema *CollectionSchemaOptions `json:"schema,omitempty"`
+
+	// The collection revision id as a string.
+	Revision string `json:"revision,omitempty"`
 }
 
 // IsSatellite returns true if the collection is a SatelliteCollection
@@ -322,6 +327,13 @@ type CollectionStatistics struct {
 			// The memory used for storing the revisions of this collection in the storage engine (in bytes). This figure does not include the document data but only mappings from document revision ids to storage engine datafile positions.
 			Size int64 `json:"size,omitempty"`
 		} `json:"revisions"`
+
+		DocumentsSize int64 `json:"documentsSize,omitempty"`
+
+		// RocksDB cache statistics
+		CacheInUse *bool  `json:"cacheInUse,omitempty"`
+		CacheSize  *int64 `json:"cacheSize,omitempty"`
+		CacheUsage *int64 `json:"cacheUsage,omitempty"`
 	} `json:"figures"`
 }
 
@@ -370,3 +382,25 @@ func (r *ReplicationFactor) UnmarshalJSON(d []byte) error {
 		Type:  reflect.TypeOf(r).Elem(),
 	}
 }
+
+type CollectionFigures struct {
+	CollectionProperties
+	CollectionStatistics
+}
+
+// CollectionChecksum contains information about a collection checksum response
+type CollectionChecksum struct {
+	CollectionInfo
+	// The collection revision id as a string.
+	Revision string `json:"revision,omitempty"`
+}
+
+type ResponsibleShardRequest struct {
+	// Fill with shard key fields expected
+	Key string `json:"_key,omitempty"`
+	// other shard key fields as required
+}
+
+type RenameCollectionRequest struct {
+	Name string `json:"name"`
+}

v2/arangodb/database.go

@@ -38,6 +38,9 @@ type Database interface {
 	// TransactionJS performs a javascript transaction. The result of the transaction function is returned.
 	TransactionJS(ctx context.Context, options TransactionJSOptions) (interface{}, error)
 
+	// Returns the available key generators for collections.
+	KeyGenerators(ctx context.Context) (KeyGeneratorsResponse, error)
+
 	DatabaseCollection
 	DatabaseTransaction
 	DatabaseQuery

v2/arangodb/database_impl.go

@@ -128,3 +128,24 @@ func (d database) TransactionJS(ctx context.Context, options TransactionJSOption
 		return nil, transactionResponse.AsArangoError()
 	}
 }
+
+func (d database) KeyGenerators(ctx context.Context) (KeyGeneratorsResponse, error) {
+	urlEndpoint := d.url("_api", "key-generators")
+
+	var response struct {
+		shared.ResponseStruct `json:",inline"`
+		KeyGeneratorsResponse `json:",inline"`
+	}
+
+	resp, err := connection.CallGet(ctx, d.client.connection, urlEndpoint, &response)
+	if err != nil {
+		return KeyGeneratorsResponse{}, errors.WithStack(err)
+	}
+
+	switch code := resp.Code(); code {
+	case http.StatusOK:
+		return response.KeyGeneratorsResponse, nil
+	default:
+		return KeyGeneratorsResponse{}, response.AsArangoError()
+	}
+}

v2/arangodb/database_opts.go

@@ -63,3 +63,7 @@ func (t EngineType) String() string {
 type EngineInfo struct {
 	Type EngineType `json:"name"`
 }
+
+type KeyGeneratorsResponse struct {
+	KeyGenerators []string `json:"keyGenerators"`
+}