tidesdb_go

package module
v0.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 3, 2025 License: MPL-2.0 Imports: 3 Imported by: 0

README

tidesdb-go

tidesdb-go is the official Go binding for TidesDB v1.

TidesDB is a fast and efficient key-value storage engine library written in C. The underlying data structure is based on a log-structured merge-tree (LSM-tree). This Go binding provides a safe, idiomatic Go interface to TidesDB with full support for all v1 features.

Features

  • ACID Transactions - Atomic, consistent, isolated, and durable transactions across column families
  • Optimized Concurrency - Multiple concurrent readers, writers don't block readers
  • Column Families - Isolated key-value stores with independent configuration
  • Bidirectional Iterators - Iterate forward and backward over sorted key-value pairs
  • TTL Support - Time-to-live for automatic key expiration
  • Compression - Snappy, LZ4, or ZSTD compression support
  • Bloom Filters - Reduce disk reads with configurable false positive rates
  • Background Compaction - Automatic or manual SSTable compaction with parallel execution
  • Sync Modes - Three durability levels: NONE, BACKGROUND, FULL
  • Custom Comparators - Register custom key comparison functions
  • Error Handling - Detailed error codes for production use

Getting Started

Prerequisites

You must have the TidesDB v1 shared C library installed on your system.

Building TidesDB

# Clone TidesDB repository
git clone https://github.com/tidesdb/tidesdb.git
cd tidesdb

# Build and install (compile with sanitizer and tests OFF for bindings)
rm -rf build && cmake -S . -B build -DTIDESDB_WITH_SANITIZER=OFF -DTIDESDB_BUILD_TESTS=OFF
cmake --build build
sudo cmake --install build

Dependencies

  • Snappy
  • LZ4
  • Zstandard
  • OpenSSL

On Ubuntu/Debian

sudo apt install libzstd-dev liblz4-dev libsnappy-dev libssl-dev

On macOS

brew install zstd lz4 snappy openssl
Installation
go get github.com/tidesdb/tidesdb-go
Custom Installation Paths

If you installed TidesDB to a non-standard location, you can specify custom paths using CGO environment variables:

# Set custom include and library paths
export CGO_CFLAGS="-I/custom/path/include"
export CGO_LDFLAGS="-L/custom/path/lib -ltidesdb"

# Then install/build
go get github.com/tidesdb/tidesdb-go

Example: Custom prefix installation

# Install TidesDB to custom location
cd tidesdb
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/opt/tidesdb
cmake --build build
sudo cmake --install build

# Configure Go to use custom location
export CGO_CFLAGS="-I/opt/tidesdb/include"
export CGO_LDFLAGS="-L/opt/tidesdb/lib -ltidesdb"
export LD_LIBRARY_PATH="/opt/tidesdb/lib:$LD_LIBRARY_PATH"  # Linux
# or
export DYLD_LIBRARY_PATH="/opt/tidesdb/lib:$DYLD_LIBRARY_PATH"  # macOS

go get github.com/tidesdb/tidesdb-go

Usage

Opening and Closing a Database
package main

import (
    "fmt"
    "log"
    
    tidesdb "github.com/tidesdb/tidesdb-go"
)

func main() {
    // Configure and open database
    config := tidesdb.Config{
        DBPath:             "./mydb",
        EnableDebugLogging: false,
    }
    
    db, err := tidesdb.Open(config)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    fmt.Println("Database opened successfully")
}
Creating and Dropping Column Families

Column families are isolated key-value stores with independent configuration.

// Create with default configuration
cfConfig := tidesdb.DefaultColumnFamilyConfig()
err := db.CreateColumnFamily("my_cf", cfConfig)
if err != nil {
    log.Fatal(err)
}

// Create with custom configuration
cfConfig := tidesdb.DefaultColumnFamilyConfig()
cfConfig.MemtableFlushSize = 128 * 1024 * 1024  // 128MB
cfConfig.MaxSSTablesBeforeCompaction = 512       // Trigger compaction at 512 SSTables
cfConfig.CompactionThreads = 4                   // Use 4 threads for parallel compaction
cfConfig.Compressed = true
cfConfig.CompressAlgo = tidesdb.TDB_COMPRESS_LZ4
cfConfig.BloomFilterFPRate = 0.01               // 1% false positive rate
cfConfig.EnableBackgroundCompaction = true
cfConfig.SyncMode = tidesdb.TDB_SYNC_BACKGROUND
cfConfig.SyncInterval = 1000                     // Sync every 1 second

err = db.CreateColumnFamily("my_cf", cfConfig)
if err != nil {
    log.Fatal(err)
}

// Drop a column family
err = db.DropColumnFamily("my_cf")
if err != nil {
    log.Fatal(err)
}
CRUD Operations

All operations in TidesDB v1 are performed through transactions for ACID guarantees.

Writing Data
// Begin a write transaction
txn, err := db.BeginTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

// Put a key-value pair (TTL -1 means no expiration)
err = txn.Put("my_cf", []byte("key"), []byte("value"), -1)
if err != nil {
    log.Fatal(err)
}

// Commit the transaction
err = txn.Commit()
if err != nil {
    log.Fatal(err)
}
Writing with TTL
import "time"

txn, err := db.BeginTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

// Set expiration time (Unix timestamp)
ttl := time.Now().Add(10 * time.Second).Unix()

err = txn.Put("my_cf", []byte("temp_key"), []byte("temp_value"), ttl)
if err != nil {
    log.Fatal(err)
}

err = txn.Commit()
if err != nil {
    log.Fatal(err)
}

TTL Examples

// No expiration
ttl := int64(-1)

// Expire in 5 minutes
ttl := time.Now().Add(5 * time.Minute).Unix()

// Expire in 1 hour
ttl := time.Now().Add(1 * time.Hour).Unix()

// Expire at specific time
ttl := time.Date(2025, 12, 31, 23, 59, 59, 0, time.UTC).Unix()
Reading Data
// Begin a read-only transaction
txn, err := db.BeginReadTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

// Get a value
value, err := txn.Get("my_cf", []byte("key"))
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Value: %s\n", value)
Deleting Data
txn, err := db.BeginTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

err = txn.Delete("my_cf", []byte("key"))
if err != nil {
    log.Fatal(err)
}

err = txn.Commit()
if err != nil {
    log.Fatal(err)
}
Multi-Operation Transactions
txn, err := db.BeginTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

// Multiple operations in one transaction
err = txn.Put("my_cf", []byte("key1"), []byte("value1"), -1)
if err != nil {
    txn.Rollback()
    log.Fatal(err)
}

err = txn.Put("my_cf", []byte("key2"), []byte("value2"), -1)
if err != nil {
    txn.Rollback()
    log.Fatal(err)
}

err = txn.Delete("my_cf", []byte("old_key"))
if err != nil {
    txn.Rollback()
    log.Fatal(err)
}

// Commit atomically - all or nothing
err = txn.Commit()
if err != nil {
    log.Fatal(err)
}
Iterating Over Data

Iterators provide efficient bidirectional traversal over key-value pairs.

Forward Iteration
txn, err := db.BeginReadTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

iter, err := txn.NewIterator("my_cf")
if err != nil {
    log.Fatal(err)
}
defer iter.Free()

// Seek to first entry
iter.SeekToFirst()

for iter.Valid() {
    key, err := iter.Key()
    if err != nil {
        log.Fatal(err)
    }
    
    value, err := iter.Value()
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Key: %s, Value: %s\n", key, value)
    
    iter.Next()
}
Backward Iteration
txn, err := db.BeginReadTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

iter, err := txn.NewIterator("my_cf")
if err != nil {
    log.Fatal(err)
}
defer iter.Free()

// Seek to last entry
iter.SeekToLast()

for iter.Valid() {
    key, err := iter.Key()
    if err != nil {
        log.Fatal(err)
    }
    
    value, err := iter.Value()
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Key: %s, Value: %s\n", key, value)
    
    iter.Prev()
}
Getting Column Family Statistics

Retrieve detailed statistics about a column family.

stats, err := db.GetColumnFamilyStats("my_cf")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Column Family: %s\n", stats.Name)
fmt.Printf("Comparator: %s\n", stats.ComparatorName)
fmt.Printf("Number of SSTables: %d\n", stats.NumSSTables)
fmt.Printf("Total SSTable Size: %d bytes\n", stats.TotalSSTableSize)
fmt.Printf("Memtable Size: %d bytes\n", stats.MemtableSize)
fmt.Printf("Memtable Entries: %d\n", stats.MemtableEntries)
fmt.Printf("Compression: %v\n", stats.Config.Compressed)
fmt.Printf("Bloom Filter FP Rate: %.4f\n", stats.Config.BloomFilterFPRate)
fmt.Printf("Sync Mode: %d\n", stats.Config.SyncMode)
Listing Column Families
cfList, err := db.ListColumnFamilies()
if err != nil {
    log.Fatal(err)
}

fmt.Println("Available column families:")
for _, name := range cfList {
    fmt.Printf("  - %s\n", name)
}
Compaction

Compaction merges SSTables, removes tombstones and expired keys.

Automatic Background Compaction
// Enable during column family creation
cfConfig := tidesdb.DefaultColumnFamilyConfig()
cfConfig.EnableBackgroundCompaction = true
cfConfig.MaxSSTablesBeforeCompaction = 128  // Trigger at 128 SSTables
cfConfig.CompactionThreads = 4              // Use 4 threads for parallel compaction

err := db.CreateColumnFamily("my_cf", cfConfig)
if err != nil {
    log.Fatal(err)
}

// Background compaction runs automatically when threshold is reached
Manual Compaction
// Get column family
cf, err := db.GetColumnFamily("my_cf")
if err != nil {
    log.Fatal(err)
}

// Manually trigger compaction (requires minimum 2 SSTables)
err = cf.Compact()
if err != nil {
    log.Printf("Compaction note: %v", err)
}

Benefits

  • Removes tombstones and expired TTL entries
  • Merges duplicate keys (keeps latest version)
  • Reduces SSTable count
  • Parallel compaction speeds up large compactions
  • Background compaction is non-blocking
Sync Modes

Control the durability vs performance tradeoff.

cfConfig := tidesdb.DefaultColumnFamilyConfig()

// TDB_SYNC_NONE - Fastest, least durable (OS handles flushing)
cfConfig.SyncMode = tidesdb.TDB_SYNC_NONE

// TDB_SYNC_BACKGROUND - Balanced (fsync every N milliseconds in background)
cfConfig.SyncMode = tidesdb.TDB_SYNC_BACKGROUND
cfConfig.SyncInterval = 1000  // Sync every 1000ms (1 second)

// TDB_SYNC_FULL - Most durable (fsync on every write)
cfConfig.SyncMode = tidesdb.TDB_SYNC_FULL

err := db.CreateColumnFamily("my_cf", cfConfig)
if err != nil {
    log.Fatal(err)
}
Compression Algorithms

TidesDB supports multiple compression algorithms:

cfConfig := tidesdb.DefaultColumnFamilyConfig()
cfConfig.Compressed = true

// Available compression algorithms
cfConfig.CompressAlgo = tidesdb.TDB_NO_COMPRESSION   // No compression
cfConfig.CompressAlgo = tidesdb.TDB_COMPRESS_SNAPPY  // Snappy (fast)
cfConfig.CompressAlgo = tidesdb.TDB_COMPRESS_LZ4     // LZ4 (very fast)
cfConfig.CompressAlgo = tidesdb.TDB_COMPRESS_ZSTD    // Zstandard (high compression)

err := db.CreateColumnFamily("my_cf", cfConfig)
if err != nil {
    log.Fatal(err)
}

Error Handling

TidesDB v1 provides detailed error codes for production use.

txn, err := db.BeginTxn()
if err != nil {
    log.Fatal(err)
}
defer txn.Free()

err = txn.Put("my_cf", []byte("key"), []byte("value"), -1)
if err != nil {
    // Errors include context and error codes
    fmt.Printf("Error: %v\n", err)
    
    // Example error message:
    // "failed to put key-value pair: memory allocation failed (code: -2)"
    
    txn.Rollback()
    return
}

err = txn.Commit()
if err != nil {
    log.Fatal(err)
}

Error Codes

  • TDB_SUCCESS (0) - Operation successful
  • TDB_ERR_MEMORY (-2) - Memory allocation failed
  • TDB_ERR_INVALID_ARGS (-3) - Invalid arguments
  • TDB_ERR_IO (-4) - I/O error
  • TDB_ERR_NOT_FOUND (-5) - Key not found
  • TDB_ERR_EXISTS (-6) - Resource already exists
  • TDB_ERR_CORRUPT (-7) - Data corruption
  • TDB_ERR_LOCK (-8) - Lock acquisition failed
  • TDB_ERR_TXN_COMMITTED (-9) - Transaction already committed
  • TDB_ERR_TXN_ABORTED (-10) - Transaction aborted
  • TDB_ERR_READONLY (-11) - Write on read-only transaction
  • TDB_ERR_FULL (-12) - Database full
  • TDB_ERR_INVALID_NAME (-13) - Invalid name
  • TDB_ERR_COMPARATOR_NOT_FOUND (-14) - Comparator not found
  • TDB_ERR_MAX_COMPARATORS (-15) - Max comparators reached
  • TDB_ERR_INVALID_CF (-16) - Invalid column family
  • TDB_ERR_THREAD (-17) - Thread operation failed
  • TDB_ERR_CHECKSUM (-18) - Checksum verification failed

Complete Example

package main

import (
    "fmt"
    "log"
    "time"
    
    tidesdb "github.com/tidesdb/tidesdb-go"
)

func main() {
    // Open database
    config := tidesdb.Config{
        DBPath:             "./example_db",
        EnableDebugLogging: false,
    }
    
    db, err := tidesdb.Open(config)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    // Create column family with custom configuration
    cfConfig := tidesdb.DefaultColumnFamilyConfig()
    cfConfig.MemtableFlushSize = 64 * 1024 * 1024
    cfConfig.Compressed = true
    cfConfig.CompressAlgo = tidesdb.TDB_COMPRESS_LZ4
    cfConfig.BloomFilterFPRate = 0.01
    cfConfig.EnableBackgroundCompaction = true
    cfConfig.SyncMode = tidesdb.TDB_SYNC_BACKGROUND
    cfConfig.SyncInterval = 1000
    
    err = db.CreateColumnFamily("users", cfConfig)
    if err != nil {
        log.Fatal(err)
    }
    defer db.DropColumnFamily("users")
    
    // Write data with transaction
    txn, err := db.BeginTxn()
    if err != nil {
        log.Fatal(err)
    }
    
    err = txn.Put("users", []byte("user:1"), []byte("Alice"), -1)
    if err != nil {
        txn.Rollback()
        log.Fatal(err)
    }
    
    err = txn.Put("users", []byte("user:2"), []byte("Bob"), -1)
    if err != nil {
        txn.Rollback()
        log.Fatal(err)
    }
    
    // Add temporary data with TTL
    ttl := time.Now().Add(30 * time.Second).Unix()
    err = txn.Put("users", []byte("session:abc"), []byte("temp_data"), ttl)
    if err != nil {
        txn.Rollback()
        log.Fatal(err)
    }
    
    err = txn.Commit()
    if err != nil {
        log.Fatal(err)
    }
    txn.Free()
    
    // Read data
    readTxn, err := db.BeginReadTxn()
    if err != nil {
        log.Fatal(err)
    }
    defer readTxn.Free()
    
    value, err := readTxn.Get("users", []byte("user:1"))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("user:1 = %s\n", value)
    
    // Iterate over all entries
    iter, err := readTxn.NewIterator("users")
    if err != nil {
        log.Fatal(err)
    }
    defer iter.Free()
    
    fmt.Println("\nAll entries:")
    iter.SeekToFirst()
    for iter.Valid() {
        key, _ := iter.Key()
        value, _ := iter.Value()
        fmt.Printf("  %s = %s\n", key, value)
        iter.Next()
    }
    
    // Get statistics
    stats, err := db.GetColumnFamilyStats("users")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("\nColumn Family Statistics:\n")
    fmt.Printf("  Name: %s\n", stats.Name)
    fmt.Printf("  Memtable Size: %d bytes\n", stats.MemtableSize)
    fmt.Printf("  Memtable Entries: %d\n", stats.MemtableEntries)
    fmt.Printf("  Number of SSTables: %d\n", stats.NumSSTables)
}

Concurrency Model

TidesDB is designed for high concurrency:

  • Multiple readers can read concurrently - No blocking between readers
  • Writers don't block readers - Readers can access data during writes
  • Writers block other writers - Only one writer per column family at a time
  • Read transactions (BeginReadTxn) acquire read locks
  • Write transactions (BeginTxn) acquire write locks on commit
  • Different column families can be written concurrently

Optimal for

  • Read-heavy workloads
  • Mixed read/write workloads
  • Multi-column-family applications

Performance Tips

  1. Batch operations in transactions for better performance
  2. Use appropriate sync mode for your durability requirements
  3. Enable background compaction for automatic maintenance
  4. Adjust memtable flush size based on your workload
  5. Use compression to reduce disk usage and I/O
  6. Configure bloom filters to reduce unnecessary disk reads
  7. Set appropriate TTL to automatically expire old data
  8. Use parallel compaction for faster SSTable merging

Testing

# Run all tests
go test -v

# Run specific test
go test -v -run TestOpenClose

# Run with race detector
go test -race -v

License

Multiple licenses apply:

Mozilla Public License Version 2.0 (TidesDB)

-- AND --

BSD 3 Clause (Snappy)
BSD 2 (LZ4)
BSD 2 (xxHash - Yann Collet)
BSD (Zstandard)
Apache 2.0 (OpenSSL 3.0+) / OpenSSL License (OpenSSL 1.x)

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Support

For issues, questions, or discussions

Documentation

Overview

Package tidesdb_go Copyright (C) TidesDB

Original Author: Alex Gaetano Padula

Licensed under the Mozilla Public License, v. 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 

https://www.mozilla.org/en-US/MPL/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.

Index

Constants

View Source 
const (
	TDB_SUCCESS                  = C.TDB_SUCCESS
	TDB_ERROR                    = C.TDB_ERROR
	TDB_ERR_MEMORY               = C.TDB_ERR_MEMORY
	TDB_ERR_INVALID_ARGS         = C.TDB_ERR_INVALID_ARGS
	TDB_ERR_IO                   = C.TDB_ERR_IO
	TDB_ERR_NOT_FOUND            = C.TDB_ERR_NOT_FOUND
	TDB_ERR_EXISTS               = C.TDB_ERR_EXISTS
	TDB_ERR_CORRUPT              = C.TDB_ERR_CORRUPT
	TDB_ERR_LOCK                 = C.TDB_ERR_LOCK
	TDB_ERR_TXN_COMMITTED        = C.TDB_ERR_TXN_COMMITTED
	TDB_ERR_TXN_ABORTED          = C.TDB_ERR_TXN_ABORTED
	TDB_ERR_READONLY             = C.TDB_ERR_READONLY
	TDB_ERR_FULL                 = C.TDB_ERR_FULL
	TDB_ERR_INVALID_NAME         = C.TDB_ERR_INVALID_NAME
	TDB_ERR_COMPARATOR_NOT_FOUND = C.TDB_ERR_COMPARATOR_NOT_FOUND
	TDB_ERR_MAX_COMPARATORS      = C.TDB_ERR_MAX_COMPARATORS
	TDB_ERR_INVALID_CF           = C.TDB_ERR_INVALID_CF
	TDB_ERR_THREAD               = C.TDB_ERR_THREAD
	TDB_ERR_CHECKSUM             = C.TDB_ERR_CHECKSUM
)

Error codes from TidesDB

Variables

This section is empty.

Functions

This section is empty.

Types

type ColumnFamily added in v0.5.0 

type ColumnFamily struct {
	// contains filtered or unexported fields
}

ColumnFamily represents a TidesDB column family.

func (*ColumnFamily) Compact added in v0.5.0 

func (cf *ColumnFamily) Compact() error

Compact manually triggers compaction for a column family.

type ColumnFamilyConfig added in v0.3.0 

type ColumnFamilyConfig struct {
	MemtableFlushSize            int
	MaxSSTablesBeforeCompaction  int
	CompactionThreads            int
	MaxLevel                     int
	Probability                  float32
	Compressed                   bool
	CompressAlgo                 TidesDBCompressionAlgo
	BloomFilterFPRate            float64
	EnableBackgroundCompaction   bool
	BackgroundCompactionInterval int
	UseSBHA                      bool
	SyncMode                     TidesDBSyncMode
	SyncInterval                 int
	ComparatorName               *string
}

ColumnFamilyConfig represents the configuration for a column family.

func DefaultColumnFamilyConfig added in v0.5.0 

func DefaultColumnFamilyConfig() ColumnFamilyConfig

DefaultColumnFamilyConfig returns a default column family configuration.

type ColumnFamilySSTableStat added in v0.3.0 

type ColumnFamilySSTableStat struct {
	Path      string
	Size      int64
	NumBlocks int64
}

ColumnFamilySSTableStat represents statistics about an SSTable in a column family.

type ColumnFamilyStat added in v0.3.0 

type ColumnFamilyStat struct {
	Name             string
	ComparatorName   string
	NumSSTables      int
	TotalSSTableSize int64
	MemtableSize     int64
	MemtableEntries  int
	Config           ColumnFamilyConfig
}

ColumnFamilyStat represents statistics about a column family.

type Config added in v0.5.0 

type Config struct {
	DBPath             string
	EnableDebugLogging bool
}

Config represents the configuration for opening a TidesDB instance.

type Iterator added in v0.5.0 

type Iterator struct {
	// contains filtered or unexported fields
}

Iterator represents a TidesDB iterator.

func (*Iterator) Free added in v0.5.0 

func (iter *Iterator) Free()

Free frees the iterator resources.

func (*Iterator) Key added in v0.5.0 

func (iter *Iterator) Key() ([]byte, error)

Key retrieves the current key from the iterator.

func (*Iterator) Next added in v0.5.0 

func (iter *Iterator) Next()

Next moves the iterator to the next entry.

func (*Iterator) Prev added in v0.5.0 

func (iter *Iterator) Prev()

Prev moves the iterator to the previous entry.

func (*Iterator) SeekToFirst added in v0.5.0 

func (iter *Iterator) SeekToFirst() error

SeekToFirst positions the iterator at the first key. Note: This automatically advances to the first valid entry.

func (*Iterator) SeekToLast added in v0.5.0 

func (iter *Iterator) SeekToLast() error

SeekToLast positions the iterator at the last key. Note: This automatically moves to the last valid entry.

func (*Iterator) Valid added in v0.5.0 

func (iter *Iterator) Valid() bool

Valid returns true if the iterator is positioned at a valid entry.

func (*Iterator) Value added in v0.5.0 

func (iter *Iterator) Value() ([]byte, error)

Value retrieves the current value from the iterator.

type TidesDB 

type TidesDB struct {
	// contains filtered or unexported fields
}

TidesDB represents a TidesDB instance.

func Open 

func Open(config Config) (*TidesDB, error)

Open opens a TidesDB instance with the given configuration.

func (*TidesDB) BeginReadTxn added in v0.5.0 

func (db *TidesDB) BeginReadTxn() (*Transaction, error)

BeginReadTxn begins a new read-only transaction.

func (*TidesDB) BeginTxn 

func (db *TidesDB) BeginTxn() (*Transaction, error)

BeginTxn begins a new write transaction.

func (*TidesDB) Close 

func (db *TidesDB) Close() error

Close closes a TidesDB instance.

func (*TidesDB) CreateColumnFamily 

func (db *TidesDB) CreateColumnFamily(name string, config ColumnFamilyConfig) error

CreateColumnFamily creates a new column family with the given configuration.

func (*TidesDB) DropColumnFamily 

func (db *TidesDB) DropColumnFamily(name string) error

DropColumnFamily drops a column family and all associated data.

func (*TidesDB) GetColumnFamily added in v0.5.0 

func (db *TidesDB) GetColumnFamily(name string) (*ColumnFamily, error)

GetColumnFamily retrieves a column family by name.

func (*TidesDB) GetColumnFamilyStats added in v0.5.0 

func (db *TidesDB) GetColumnFamilyStats(name string) (*ColumnFamilyStat, error)

GetColumnFamilyStats retrieves statistics about a column family.

func (*TidesDB) ListColumnFamilies 

func (db *TidesDB) ListColumnFamilies() ([]string, error)

ListColumnFamilies lists all column families in the database.

type TidesDBCompressionAlgo 

type TidesDBCompressionAlgo int

TidesDBCompressionAlgo represents the compression algorithm type. 

const (
	TDB_COMPRESS_SNAPPY TidesDBCompressionAlgo = C.COMPRESS_SNAPPY
	TDB_COMPRESS_LZ4    TidesDBCompressionAlgo = C.COMPRESS_LZ4
	TDB_COMPRESS_ZSTD   TidesDBCompressionAlgo = C.COMPRESS_ZSTD
)

type TidesDBSyncMode added in v0.5.0 

type TidesDBSyncMode int

TidesDBSyncMode represents the sync mode for durability. 

const (
	TDB_SYNC_NONE       TidesDBSyncMode = C.TDB_SYNC_NONE
	TDB_SYNC_BACKGROUND TidesDBSyncMode = C.TDB_SYNC_BACKGROUND
	TDB_SYNC_FULL       TidesDBSyncMode = C.TDB_SYNC_FULL
)

type Transaction 

type Transaction struct {
	// contains filtered or unexported fields
}

Transaction represents a TidesDB transaction.

func (*Transaction) Commit 

func (txn *Transaction) Commit() error

Commit commits the transaction.

func (*Transaction) Delete 

func (txn *Transaction) Delete(columnFamily string, key []byte) error

Delete removes a key-value pair from the transaction.

func (*Transaction) Free 

func (txn *Transaction) Free()

Free frees the transaction resources.

func (*Transaction) Get 

func (txn *Transaction) Get(columnFamily string, key []byte) ([]byte, error)

Get retrieves a value from the transaction.

func (*Transaction) NewIterator added in v0.5.0 

func (txn *Transaction) NewIterator(columnFamily string) (*Iterator, error)

NewIterator creates a new iterator for a column family within a transaction.

func (*Transaction) Put 

func (txn *Transaction) Put(columnFamily string, key, value []byte, ttl int64) error

Put adds a key-value pair to the transaction.

func (*Transaction) Rollback 

func (txn *Transaction) Rollback() error

Rollback rolls back the transaction.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.