Added TTL index support. (#197)

Author: Lars Maier

collection_indexes.go

@@ -66,6 +66,10 @@ type CollectionIndexes interface {
 	// Fields is a slice of attribute paths.
 	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
 	EnsureSkipListIndex(ctx context.Context, fields []string, options *EnsureSkipListIndexOptions) (Index, bool, error)
+
+	// EnsureTTLIndex creates a TLL collection, if it does not already exist.
+	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
+	EnsureTTLIndex(ctx context.Context, field string, expireAfter int, options *EnsureTTLIndexOptions) (Index, bool, error)
 }
 
 // EnsureFullTextIndexOptions contains specific options for creating a full text index.
@@ -113,3 +117,7 @@ type EnsureSkipListIndexOptions struct {
 	// Note: this setting is only relevant for indexes with array fields (e.g. "fieldName[*]")
 	NoDeduplicate bool
 }
+
+// EnsureTTLIndexOptions provides specific options for creating a TTL index
+// Currently there are not options
+type EnsureTTLIndexOptions struct{}

collection_indexes_impl.go

@@ -36,6 +36,7 @@ type indexData struct {
 	Sparse      *bool    `json:"sparse,omitempty"`
 	GeoJSON     *bool    `json:"geoJson,omitempty"`
 	MinLength   int      `json:"minLength,omitempty"`
+	ExpireAfter int      `json:"expireAfter,omitempty"`
 }
 
 type genericIndexData struct {
@@ -229,6 +230,21 @@ func (c *collection) EnsureSkipListIndex(ctx context.Context, fields []string, o
 	return idx, created, nil
 }
 
+// EnsureTTLIndex creates a TLL collection, if it does not already exist.
+// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
+func (c *collection) EnsureTTLIndex(ctx context.Context, field string, expireAfter int, options *EnsureTTLIndexOptions) (Index, bool, error) {
+	input := indexData{
+		Type:        string(TTLIndex),
+		Fields:      []string{field},
+		ExpireAfter: expireAfter,
+	}
+	idx, created, err := c.ensureIndex(ctx, input)
+	if err != nil {
+		return nil, false, WithStack(err)
+	}
+	return idx, created, nil
+}
+
 // ensureIndex creates a persistent index in the collection, if it does not already exist.
 // Fields is a slice of attribute paths.
 // The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).

edge_collection_indexes_impl.go

@@ -114,3 +114,13 @@ func (c *edgeCollection) EnsureSkipListIndex(ctx context.Context, fields []strin
 	}
 	return result, created, nil
 }
+
+// EnsureTTLIndex creates a TLL collection, if it does not already exist.
+// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
+func (c *edgeCollection) EnsureTTLIndex(ctx context.Context, field string, expireAfter int, options *EnsureTTLIndexOptions) (Index, bool, error) {
+	result, created, err := c.rawCollection().EnsureTTLIndex(ctx, field, expireAfter, options)
+	if err != nil {
+		return nil, false, WithStack(err)
+	}
+	return result, created, nil
+}

index.go

@@ -36,6 +36,7 @@ const (
 	PersistentIndex = IndexType("persistent")
 	GeoIndex        = IndexType("geo")
 	EdgeIndex       = IndexType("edge")
+	TTLIndex        = IndexType("ttl")
 )
 
 // Index provides access to a single index in a single collection.

index_impl.go

@@ -45,7 +45,8 @@ func indexStringToType(indexTypeString string) (IndexType, error) {
 		return GeoIndex, nil
 	case string(EdgeIndex):
 		return EdgeIndex, nil
-
+	case string(TTLIndex):
+		return TTLIndex, nil
 	default:
 		return "", WithStack(InvalidArgumentError{Message: "unknown index type"})
 	}

test/index_ensure_test.go

@@ -309,3 +309,50 @@ func TestEnsureSkipListIndex(t *testing.T) {
 		}
 	}
 }
+
+// TestEnsureTTLIndex creates a collection with a ttl index.
+func TestEnsureTTLIndex(t *testing.T) {
+	c := createClientFromEnv(t, true)
+	db := ensureDatabase(nil, c, "index_test", nil, t)
+	skipBelowVersion(c, "3.5", t)
+
+	col := ensureCollection(nil, db, "ttl_index_test", nil, t)
+	idx, created, err := col.EnsureTTLIndex(nil, "createdAt", 3600, nil)
+	if err != nil {
+		t.Fatalf("Failed to create new index: %s", describe(err))
+	}
+	if !created {
+		t.Error("Expected created to be true, got false")
+	}
+	if idxType := idx.Type(); idxType != driver.TTLIndex {
+		t.Errorf("Expected TTLIndex, found `%s`", idxType)
+	}
+
+	// Index must exists now
+	if found, err := col.IndexExists(nil, idx.Name()); err != nil {
+		t.Fatalf("Failed to check index '%s' exists: %s", idx.Name(), describe(err))
+	} else if !found {
+		t.Errorf("Index '%s' does not exist, expected it to exist", idx.Name())
+	}
+
+	// Ensure again, created must be false now
+	_, created, err = col.EnsureTTLIndex(nil, "createdAt", 3600, nil)
+	if err != nil {
+		t.Fatalf("Failed to re-create index: %s", describe(err))
+	}
+	if created {
+		t.Error("Expected created to be false, got true")
+	}
+
+	// Remove index
+	if err := idx.Remove(nil); err != nil {
+		t.Fatalf("Failed to remove index '%s': %s", idx.Name(), describe(err))
+	}
+
+	// Index must not exists now
+	if found, err := col.IndexExists(nil, idx.Name()); err != nil {
+		t.Fatalf("Failed to check index '%s' exists: %s", idx.Name(), describe(err))
+	} else if found {
+		t.Errorf("Index '%s' does exist, expected it not to exist", idx.Name())
+	}
+}

test/indexes_test.go

@@ -25,6 +25,7 @@ package test
 import (
 	"context"
 	"testing"
+	"time"
 
 	driver "github.com/arangodb/go-driver"
 )
@@ -282,3 +283,57 @@ func TestIndexesDeduplicateSkipList(t *testing.T) {
 		}
 	}
 }
+
+// TestIndexesTTL tests TTL index.
+func TestIndexesTTL(t *testing.T) {
+	c := createClientFromEnv(t, true)
+	skipBelowVersion(c, "3.5", t)
+
+	db := ensureDatabase(nil, c, "index_test", nil, t)
+
+	// Create some indexes with de-duplication off
+	col := ensureCollection(nil, db, "indexes_ttl_test", nil, t)
+	if _, _, err := col.EnsureTTLIndex(nil, "createdAt", 10, nil); err != nil {
+		t.Fatalf("Failed to create new index: %s", describe(err))
+	}
+
+	doc := struct {
+		CreatedAt int64 `json:"createdAt,omitempty"`
+	}{
+		CreatedAt: time.Now().Add(10 * time.Second).Unix(),
+	}
+	meta, err := col.CreateDocument(nil, doc)
+	if err != nil {
+		t.Errorf("Expected success, got %s", describe(err))
+	}
+
+	wasThere := false
+
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	for {
+		if found, err := col.DocumentExists(ctx, meta.Key); err != nil {
+			t.Fatalf("Failed to test if document exists: %s", describe(err))
+		} else {
+			if found {
+				if !wasThere {
+					t.Log("Found document")
+				}
+				wasThere = true
+			} else {
+				break
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			t.Fatalf("Timeout while waiting for document to be deleted: %s", ctx.Err())
+		case <-time.After(time.Second):
+			break
+		}
+	}
+
+	if !wasThere {
+		t.Fatalf("Document never existed")
+	}
+}

vertex_collection_indexes_impl.go

@@ -114,3 +114,13 @@ func (c *vertexCollection) EnsureSkipListIndex(ctx context.Context, fields []str
 	}
 	return result, created, nil
 }
+
+// EnsureTTLIndex creates a TLL collection, if it does not already exist.
+// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
+func (c *vertexCollection) EnsureTTLIndex(ctx context.Context, field string, expireAfter int, options *EnsureTTLIndexOptions) (Index, bool, error) {
+	result, created, err := c.rawCollection().EnsureTTLIndex(ctx, field, expireAfter, options)
+	if err != nil {
+		return nil, false, WithStack(err)
+	}
+	return result, created, nil
+}