Skip to content

Go library designed to provide simple and efficient persistent key-value storage with support for in-memory caching and optional thread-safety.

License

Notifications You must be signed in to change notification settings

saenai255/pstore

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

4 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Persistent Storage (pstore)

pstore is a Go library designed to provide simple and efficient persistent key-value storage with support for in-memory caching and optional thread-safety. You can store, retrieve, and manage data with minimal boilerplate, with automatic support for saving and loading to disk.

Features

  • Persistent Storage: Stores key-value pairs in memory and optionally saves them to disk.
  • Configurable Caching: Control the number of items cached in memory or disable limits.
  • Thread-Safe Access: Optionally use thread-safe access for concurrent operations.
  • In-Memory Only Option: Create purely in-memory caches without persistence.
  • Flexible Storage Management: Save individual key-value pairs or all items in a single file.
  • Error Type Identification: Easily identify various error types like deletion, serialization, and disk read failures.

Installation

go get github.com/saenai255/pstore

Usage

Basic Initialization

Create a new persistent storage cache:

ps := pstore.New("/path/to/storage", "cache_name")

Or create an in-memory-only storage cache (no disk persistence):

ps := pstore.NewInMemory("memory_cache")

Configuring the Storage

Configure options after initialization to customize the behavior of PersistentStorage.

  • MaxMemItems: Set the maximum number of items to be stored in memory (default: 100). Use pstore.MEM_ITEMS_UNLIMITED for unlimited items.
  • ThreadSafe: Enable thread-safe access for concurrent operations.
  • SaveToDiskOnSet: Control whether data is automatically saved to disk when a key is set (default: true).
ps := pstore.New("/path/to/storage", "cache_name")

// Configure options
ps.MaxMemItems = pstore.MemoryItemsCount(200) // Store up to 200 items in memory
ps.ThreadSafe = true                          // Enable thread-safe access
ps.SaveToDiskOnSet = false                    // Save to disk manually

Storing and Retrieving Data

Set a key-value pair:

err := ps.Set("key1", "some_value")
if err != nil {
    fmt.Println("Error setting value:", err)
}

Get a key-value pair:

var value string
err := ps.Get("key1", &value)
if err != nil {
    fmt.Println("Error getting value:", err)
} else {
    fmt.Println("Value:", value)
}

Checking and Deleting Keys

Check if a key exists in the cache or on disk:

exists, err := ps.Has("key1")
if err != nil {
    fmt.Println("Error checking key:", err)
} else {
    fmt.Println("Key exists:", exists)
}

Delete a key from the cache and disk:

err := ps.Delete("key1")
if err != nil {
    fmt.Println("Error deleting key:", err)
}

Retrieving Cache Metadata

Get all keys in the cache (from both in-memory and disk):

keys, err := ps.Keys()
if err != nil {
    fmt.Println("Error getting keys:", err)
} else {
    fmt.Println("Cache keys:", keys)
}

Get the total number of items in the storage (including on disk):

count, err := ps.Len()
if err != nil {
    fmt.Println("Error getting length:", err)
} else {
    fmt.Println("Cache item count:", count)
}

Saving and Loading Data

Save the current state of the cache to disk. If SaveToDiskOnSet is set to true, this is done automatically when setting a key.

err := ps.SaveToDisk()
if err != nil {
    fmt.Println("Error saving to disk:", err)
}

Handling Errors

The library provides utility functions to identify different error types:

if pstore.IsDeleteFailed(err) {
    fmt.Println("Delete operation failed")
}

if pstore.IsSaveToDiskFailed(err) {
    fmt.Println("Failed to save to disk")
}

if pstore.IsKeyNotFound(err) {
    fmt.Println("Key not found")
}

Examples

Creating a Thread-Safe Persistent Storage with Unlimited Cache

ps := pstore.New("/path/to/storage", "cache_name")

ps.MaxMemItems = pstore.MEM_ITEMS_UNLIMITED
ps.ThreadSafe = true

Create an In-Memory Cache for Testing

Use the NewInMemory constructor for an in-memory cache, ideal for testing purposes. This cache does not persist data to disk.

ps := pstore.NewInMemory("test_cache")

// Set a value
ps.Set("key1", "some_value")

// Get a value
var value string
ps.Get("key1", &value)

Customizing Cache Behavior

Create a persistent storage with a maximum of 50 items in memory and custom disk-saving behavior:

ps := pstore.New("/path/to/storage", "my_cache")

ps.MaxMemItems = pstore.MemoryItemsCount(50) // Limit to 50 items in memory
ps.SaveToDiskOnSet = false                   // Save to disk manually

License

This library is licensed under the MIT License.


With pstore, you can easily create and manage key-value pairs, ensuring that your data is cached efficiently and safely persisted to disk when needed. Enjoy streamlined storage management for your Go applications!

About

Go library designed to provide simple and efficient persistent key-value storage with support for in-memory caching and optional thread-safety.

Topics

Resources

License

Stars

Watchers

Forks

Languages