Simple DB using yaml. A project for managing the content of yaml files.

Overview

DB Yaml

Simple DB using yaml. A project for managing the content of yaml files.

Table of Contents

Features

The module can do

  • Create/Load yaml files
  • Update content
  • Get values from keys
  • Query for keys
  • Delete keys
  • Merge content

Usage

Simple examples for working with yaml files as db

Initiate a new DB

Create a new local DB

package main

import (
	"github.com/sirupsen/logrus"
	"github.com/ulfox/dby/db"
)

func main() {
	logger := logrus.New()

	state, err := db.NewStorageFactory("local/db.yaml")
	if err != nil {
		logger.Fatalf(err.Error())
	}
}

Write to DB

Insert a map to the local yaml file.

err = state.Upsert(
	"some.path",
	map[string]string{
		"key-1": "value-1",
		"key-2": "value-2",
	},
)

if err != nil {
	logger.Fatalf(err.Error())
}

Query DB

Get First Key

Get the value of the first key in the hierarchy (if any)

val, err := state.GetFirst("key-1")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(val)

For example if we have the following structure

key-1:
    key-2:
        key-3: "1"
    key-3: "2"

And we query for key-3, then we will get back "2" and not "1" since key-3 appears first on a higher layer with a value of 2

Search for keys

Get all they keys (if any). This returns the full path for the key, not the key values. To get the values check the next section GetPath

keys, err := state.FindKeys("key-1")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(keys)

From the previous example, this query would have returned

["key-1.key-2.key-3", "key-1.key-3"]

Query Path

Get the value from a given path (if any)

For example if we have in yaml file the following key-path

key-1:
    key-2:
        key-3: someValue

Then to get someValue, issue

keyPath, err := state.GetPath("key-1.key-2.key-3")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(keyPath)

Query Path with Arrays

We can also query paths that have arrays.

Without trailing array
key-1:
    key-2:
        - key-3: 
            key-4: value-1

To get the value of key-4, issue

keyPath, err := state.GetPath("key-1.key-2.[0].key-3.key-4")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(keyPath)
With trailing array
key-1:
    key-2:
        - value-1
        - value-2
        - value-3

To get the first index of key-2, issue

keyPath, err := state.GetPath("key-1.key-2.[0]")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(keyPath)

Delete Key By Path

To delete a single key for a given path, e.g. key-2 from the example above, issue

err = state.Delete("key-1.key-2")
if err != nil {
	logger.Fatalf(err.Error())
}

Convert Utils

Convert simply automate the need to explicitly do assertion each time we need to access an interface object.

Let us assume we have the following YAML structure

to:
  array-1:
    key-1:
    - key-2: 2
    - key-3: 3
    - key-4: 4
  array-2:
  - 1
  - 2
  - 3
  - 4
  - 5
  array-3:
  - key-1: 1
  - key-2: 2

Get map of strings from interface

We can do this in two ways, get object by giving a path and assert the interface to map[string]string, or work manually our way to the object

Get map directly from a GetPath object

To get map key-2: 2, first get object via GetPath

obj, err := state.GetPath("to.array-1.key-1.[0]")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(val)

Next, assert obj as map[string]string

assertData := db.NewConvertFactory()

assertData.Input(val)
if assertData.GetError() != nil {
	logger.Fatal(assertData.GetError())
}
vMap, err := assertData.GetMap()
if err != nil {
	logger.Fatal(err)
}
logger.Info(vMap["key-2"])
Get map manually

We can get the map manually by using only Convert operations

assertData := db.NewConvertFactory()

assertData.Input(state.Data).
	Key("to").
	Key("array-1").
	Key("key-1").Index(0)
if assertData.GetError() != nil {
	logger.Fatal(assertData.GetError())
}
vMap, err := assertData.GetMap()
if err != nil {
	logger.Fatal(err)
}
logger.Info(vMap["key-2"])

Get array of string from interface

Again here we can do it two ways as with the map example

Get array directly from a GetPath object

To get array-2 as []string, first get object via GetPath

obj, err = state.GetPath("to.array-2")
if err != nil {
	logger.Fatalf(err.Error())
}
logger.Info(obj)

Next, assert obj as []string

assertData := db.NewConvertFactory()

assertData.Input(obj)
if assertData.GetError() != nil {
	logger.Fatal(assertData.GetError())
}
vArray, err := assertData.GetArray()
if err != nil {
	logger.Fatal(err)
}
logger.Info(vArray)
Get array manually

We can get the array manually by using only Convert operations

assertData.Input(state.Data).
	Key("to").
	Key("array-2")
if assertData.GetError() != nil {
	logger.Fatal(assertData.GetError())
}
vArray, err := assertData.GetArray()
if err != nil {
	logger.Fatal(err)
}
logger.Info(vArray)

Document Management

DBy creates by default an array of documents called library. That is in fact an array of interfaces

When initiating DBy, document 0 (index 0) is creatd by default and any action is done to that document, unless we switch to a new one

Add a new doc

To add a new doc, issue

err = state.AddDoc()
if err != nil {
  logger.Fatal(err)
}

Note: Adding a new doc also switches the pointer to that doc. Any action will write/read from the new doc by default

Switch Doc

To switch a different document, we can use Switch method that takes as an argument an index

For example to switch to doc 1 (second doc), issue

err = state.Switch(1)
if err != nil {
  logger.Fatal(err)
}

Document names

When we work with more than 1 document, we may want to set names in order to easily switch between docs

We have 2 ways to name our documents

  • Add a name to each document manually
  • Add a name providing a path that exists in all documents
Name documents manually

To name a document manually, we can use the SetName method which takes 2 arguments

  • name
  • doc index

For example to name document with index 0, as myDoc

err := state.SetName("myDoc", 0)
if err != nil {
  logger.Fatal(err)
}
Name all documents automatically

To name all documents automatically we need to ensure that the same path exists in all documents.

The method for updating all documents is called SetNames and takes 2 arguments

  • Prefix: A path in the documents that will be used for the first name
  • Suffix: A path in the documents that will be used for the last name

Note: Docs that do not have the paths that are queried will not get a name

This method best works with Kubernetes manifests, where all docs have a common set of fields.

For example

apiVersion: someApi-0
kind: someKind-0
metadata:
...
  name: someName-0
...
---
apiVersion: someApi-1
kind: someKind-1
metadata:
...
  name: someName-1
...
---

From above we could give a name for all our documents if we use kind + metadata.name for the name.

err := state.SetNames("kind", "metadata.name")
if err != nil {
  logger.Fatal(err)
}
List all doc names

To get the name of all named docs, issue

for i, j := range state.ListDocs() {
  fmt.Println(i, j)
}

Example output based on the previous SetNames example

0 service/listener-svc
1 poddisruptionbudget/listener-svc
2 horizontalpodautoscaler/caller-svc
3 deployment/caller-svc
4 service/caller-svc
5 poddisruptionbudget/caller-svc
6 horizontalpodautoscaler/listener-svc
7 deployment/listener-svc
Switch between docs by name

To switch to a doc by using the doc's name, issue

err = state.SwitchDoc("PodDisruptionBudget/caller-svc")
if err != nil {
  logger.Fatal(err)
}

Import Docs

We can import a set of docs with ImportDocs method. For example if we have the following yaml

apiVersion: someApi-0
kind: someKind-0
metadata:
...
  name: someName-0
...
---
apiVersion: someApi-1
kind: someKind-1
metadata:
...
  name: someName-1
...
---

We can import it by giving the path of the file

err = state.ImportDocs("file-name.yaml")
if err != nil {
  logger.Fatal(err)
}

Global Upsert

We can use upsert to update or create keys on all documents

err = state.UpsertGlobal(
  "some.path",
  "v0.3.0",
)
if err != nil {
  logger.Fatal(err)
}

Global Update

Global update works as GlobalUpsert but it skips documents that miss a path rather than creating the path on those docs.

Issues
  • fix: [findKeys: key depth] [DeleteGlobal]

    fix: [findKeys: key depth] [DeleteGlobal]

    Fixes

    • SQL/findKeys method would not proceed to paths that had a key already discovered

    • DeleteGlobal was deleting only active document. Now it will loop and delete the path (if any) for all docs

    • Nil input on upsert value is now translated to an empty map

    Changes

    • State.go: Buffer methods are no longer exported

    • Cache/V2: Results are saved to v2 cache. With v2 cache we will be able in the next releases to implement cache like features like key/object TTL

    • SQL: All methods now use pointers

    • State: Data array now uses pointers

    • GetData: Is a wrapper to getData method that returns a pointer from the data array.

    • GetAllData: Will return the actual data array (array values are pointers)

    • GetDataFromIndex: Returns a specific pointer from the data array

    • Makefile: Include new target for running multiple times the tests this is to ensure we get always the same result and reads order will not alter the results

    bug 
    opened by ulfox 1
  • path finding breaks on arrays with objects

    path finding breaks on arrays with objects

    Describe the bug GetFirst & Get return key not found on arrays with maps

    To Reproduce

    Example yaml that causes GetFirst, Get to exit with no key was found

    
    key-1:
        - key-2 : 
            - key-3: v3
        - key-4:
            - key-5: v5
    

    Expected behaviour

    Queries on key-{1,2,3,4,5} should return a value

    bug 
    opened by ulfox 1
  • Method GetFirst returns the first key found in a branch

    Method GetFirst returns the first key found in a branch

    Describe the bug Method GetFirst returns the first key that is found in the branch and not in the hierarchy. This appears to be the case when the a branch that has the key is processed first.

    Example:

    
    key-1:
        key-2:
            key-3: value-1
        key-3:  value-2
    

    Desired result for GetFirst("key-3") is value-2 but instead we get value-1

    To Reproduce Run GetFirst("someKey") with 2 keys

    Expected behaviour GetFirst should return value-1

    bug 
    opened by ulfox 1
  • improvement: [SQL] switch to pointers

    improvement: [SQL] switch to pointers

    In this commit we are switching input/return interfaces to pointer interfaces. For bigger volume of data, this change will be helpful to optimize the code to do as less copies as possible.

    For now we are not changing the logic of sql functions but only update them to handle pointers

    Breaking change:

    • SQL methods will return pointers. Only Storage.Wrappers will handle this change automatically
    opened by ulfox 0
  • deleteArrayItem is broken. Object is filtered as dict

    deleteArrayItem is broken. Object is filtered as dict

    Describe the bug deleteArrayItem returns an interface conversion error rather than deleting the specific index

    To Reproduce try to delete an index from an array by using storage.Delete("path.to.index") method.

    Expected behaviour Value for given index should be removed

    bug 
    opened by ulfox 0
  • fix: [storage/dbinit] map

    fix: [storage/dbinit] map

    The type that was getting created during dbinit method was a map[string]string

    The problem with the above is that we were not converting map[string]string to a map[interface{}]interface{} which was breaking the upsert method

    This was fine when we worked with files since when marshaling and unmarshaling an object, you get automatically a map of map[interface{}]interface{}

    bug 
    opened by ulfox 0
  • feat: [storage] support in memory only operations

    feat: [storage] support in memory only operations

    In this commit we included the InMem method which when run with true will configure the state manager method to encode / decode objects only in memory and never write to storage

    enhancement 
    opened by ulfox 0
  • feat: add Global GetPath and Delete

    feat: add Global GetPath and Delete

    In addition to the above wrappers we included

    • Storage.DeleteAll method for removing all docs
    • Deprecated bool from Storage.ImportDocs(string,bool) for now we keep this for compatibility
    • Included multiple tests for the multi-doc methods
    • Moved tests under tests directory
    • Removed returning an error from Global wrappers

    Fixes:

    • Ensure that AddDoc() and Switch will not return null pointer when the library is empty
    bug enhancement 
    opened by ulfox 0
  • fixes: [docs/convert] methods

    fixes: [docs/convert] methods

    Features

    • Cache.GetError: "Method for returning Cache.E"
    • Convert: "New methods GetString, GetInt, GetError"

    Fixes:

    • Storage.AddDoc: "Now switches to the correct index after adding a new doc"
    • Storage.Read: "No longer creates nil docs on read"
    • Storage.Write: "No longer skips empty maps"

    Tests:

    • MultiDoc: "Tests for checking doc switch & add"
    bug 
    opened by ulfox 0
  • [new] document-manager

    [new] document-manager

    In this commit we included document manager

    Document manager allows us to add multiple docs and switch between docs.

    Features:

    • Add new docs
    • Switch to new docs by index
    • Switch to new docs by name
    • Add name to doc
    • Add name to docs by using a path from their content
    • Import docs
    • Global doc upsert
    • Global doc update
    opened by ulfox 0
  • include convert-utils

    include convert-utils

    Convert utils for converting interfaces to

    • map[string]string
    • []string

    This is a helper util for quickly accessing the Memory Data

    Before: We could get with GetFirst, GetPath the objects with an interface type

    Now: We can use convert utils to either to get a map or array from interfaces quickly

    opened by ulfox 0
Releases(v0.3.3)
  • v0.3.3(Sep 15, 2021)

  • v0.3.2(Sep 12, 2021)

    Commits:

    • 1b121d803a8be8d0026dea1bed67e2c7f63ebd65
    • 7c5211bbae88f79c1622f54a0993109d46ca4952
    • 9b05be538915e99122fbae5d04f8edf602cfe5ec
    • 764cd8d8bdc15f524e76a3a42fb8cc0304563be1
    • bb2047ddbaf96bd9c769a55a2a03621ed042d885

    Commit 1b121d803a8be8d0026dea1bed67e2c7f63ebd65

    New
    • Storage tests
    Changes
    • sql_tests.go was split to multiple files test

    Commit 7c5211bbae88f79c1622f54a0993109d46ca4952

    [todo] update

    Commit 9b05be538915e99122fbae5d04f8edf602cfe5ec

    [cache/v1/v2] make fields private

    Commit 764cd8d8bdc15f524e76a3a42fb8cc0304563be1

    The following fields of Storage have been moved to a new struct

    • Data array
    • Library map
    • Active Document index

    Commit bb2047ddbaf96bd9c769a55a2a03621ed042d885

    We now use buffer for reads to make sure that if an import/read operation fails, we wont be left with an empty data array

    Before we would dump the data array and then read the file into it. If the file was corrupt, the operation would fail and leave as with an empty data array

    Now we keep the current data array and dump only if the import/read operation has finished successfully

    Source code(tar.gz)
    Source code(zip)
  • v0.3.1(Sep 11, 2021)

    Commits:

    • d892bd9419308938a519d294fb420c1b179db27b
    • 93b2d0fe1881c40e7e69499514459d232b5f0efb
    • 8443f2c4b179977f71de8a7c6f48b97b3e104c27
    • 5e12bf2ab720b47df5cad7a1b66d84898004e7f5

    In this commit we included the InMem method which when run with true will configure the state manager method to encode / decode objects only in memory and never write to storage

    This was original v0.3.0 but we removed it since it was missing commits

    • 8443f2c4b179977f71de8a7c6f48b97b3e104c27
    • 8443f2c4b179977f71de8a7c6f48b97b3e104c27
    Source code(tar.gz)
    Source code(zip)
  • v0.3.0(Sep 11, 2021)

  • v0.2.1(Sep 8, 2021)

    Commit: c700f6137968b24c6d512d0148c3d883428d539a

    New

    • Storage.DeleteAll method for removing all docs
    • Deprecated bool from Storage.ImportDocs(string,bool) for now we keep this for compatibility
    • Included multiple tests for the multi-doc methods
    • Moved tests under tests directory
    • Removed returning an error from Global wrappers

    Fixes

    • Ensure that AddDoc() and Switch will not return null pointer when the library is empty

    Commit: 89e98dafc6de8dfc2a69ecc9472f8dee9900b4bc

    In this commit we consolidated the getFn and wrapErr functions into a new function called WrapErr

    In addition to the above change WrapErr handles the error creation automatically.

    Before we were creating the error from in the caller and then passed it into the wrapErr function together with the result of getFn

    Now we are only passing the error/string + additional arguments if required and call create the error withing WrapErr

    Commit: 23fc4f7267540d4a531330d7c52f70ae9147eb48

    Add emptyMap function

    Source code(tar.gz)
    Source code(zip)
  • v0.2.0(Sep 6, 2021)

    Commits:

    • 802b43700832ce641f51f0b551d6ca524932c009
    • 8215258c5ed2f9a5f15f16a69f56e83aa74a4dd7

    Include Global Method for GetFirst and FindKeys [storage] include delete doc method

    Source code(tar.gz)
    Source code(zip)
  • v0.1.1(Sep 6, 2021)

    Commits:

    • 53d2e411e1e24843bb100d97eb0a03452f9dc6d9

    Features

    • Cache.GetError: "Method for returning Cache.E"
    • Convert: "New methods GetString, GetInt, GetError"

    Fixes:

    • Storage.AddDoc: "Now switches to the correct index after adding a new doc"
    • Storage.Read: "No longer creates nil docs on read"
    • Storage.Write: "No longer skips empty maps"

    Tests:

    • MultiDoc: "Tests for checking doc switch & add"
    Source code(tar.gz)
    Source code(zip)
  • v0.1.0(Sep 6, 2021)

    Commits:

    • 23e20012a7785b655014589c0d670bdd3e9e7954

    In this commit we included document manager

    Document manager allows us to add multiple docs and switch between docs.

    Features:

    • Add new docs
    • Switch to new docs by index
    • Switch to new docs by name
    • Add name to doc
    • Add name to docs by using a path from their content
    • Import docs
    • Global doc upsert
    • Global doc update
    Source code(tar.gz)
    Source code(zip)
  • v0.0.10(Sep 5, 2021)

  • v0.0.9(Sep 5, 2021)

    Commits:

    • 54e93c2c20145c94a23e7c7cb5ab30c993d96287
    • 1f0eb6026d3e490e6722878ad25637fc7a5b4371
    • fd8e5117882df066eff31c26e618ebea36ca9f79
    • cea373e3a3b1c232fc4f3f9d10d48dd2eb236d50

    Bug fixes:

    • getPath method would fail on paths that had an array. That is because getPath expected explicitly an index. This was fixed by creating a new method for handling getPath when no index has been given
    • Empty keys were not blocked. We could create a map with key "".
    Source code(tar.gz)
    Source code(zip)
  • v0.0.8(Sep 3, 2021)

    Changes 535cda2d47e7a40b7349451df1746511ac4d1721

    fix: [getFirst] condition was using wrong indexes

    The issue was due to a miss-configured test. The expected value from 2 different scenarios was the same.

    That lead assert to pass both scenarios while it should have failed on the second

    Now tests have been updated and the wrong condition that was returning a wrong value fixed

    Source code(tar.gz)
    Source code(zip)
  • v0.0.7(Sep 3, 2021)

    Commit: b8feaad7c14b62d4d4a339cf8d476435f89f7d1e

    Before we were wrapping errors by adding manually the callers name

    Now we wrap errors by getting automatically the callers name and line of code

    Source code(tar.gz)
    Source code(zip)
  • v0.0.6(Sep 2, 2021)

    Commits:

    • 5ddb5bf9c06e98f76374ce8b749bbbe1868551e5

    In this commit we moved to a storage.Write safer approach by including an intermediate write to a different file to ensure that the db will not get corrupted on non-graceful program exits

    Co-Author: reddit:user:jakewins

    Source code(tar.gz)
    Source code(zip)
  • v0.0.5(Sep 2, 2021)

    Changes 664c4dab5a5e79cf789d6507124e5cba28bb4022

    In this commit we fixed the GetFirst Method which was exporting a different value when a branch with the queried key in lower hierarchy was processed first

    In addition to that change, we made the following changes:

    • Updated Upsert wrapper to use directly upsertRecursive
    • Exported Cache content
    • SQL Now is a Pointer to Storage struct
    • Minor changes e.g. remove redundant error function
    Source code(tar.gz)
    Source code(zip)
  • v0.0.4(Aug 26, 2021)

  • v0.0.3(Aug 24, 2021)

    Improvements 44816b9061a34a7b0149d91d103b8b65b65898be

    Tests

    • Remove test-dbs at the end
    • Include additional test cases
    TestUpsert
    • Add arrays
    • Add arrays of maps
    • Add map with arrays
    • Add map with integers
    TestGetSingle
    • Get key with map values
    TestGetPath
    • Test array out of range errors
    TestDelete
    • Test delete missing key errors
    • Add arrays of maps
    • Add map with arrays
    • Add map with integers
    TestGetSingle
    • Get key with map values
    TestGetPath
    • Test array out of range errors
    TestDelete
    • Test delete missing key errors
    TestGet
    • Include additional match that has a map as value rather than a string

    cache

    Export SQL.Cache Before we had Cache struct exported but SQL.cache unreported. Now we have both objects exported

    Error Wrap errors

    We included error.wrap during checks. Now among with the initial error message it is also propagated the caller name.

    Source code(tar.gz)
    Source code(zip)
  • v0.0.2(Aug 23, 2021)

  • v0.0.1(Aug 23, 2021)

Owner
Christos Kotsis
Christos Kotsis
Toy project to test golang toolset, using as pretext the "cyclic number" problem (famous 142857 number)

go-cyclic-number Toy project to test golang toolset, using as pretext the "cyclic number" problem (famous 142857 number) First version: https://github

A. M. Cajal 0 Feb 12, 2022
Rk-db - Enterprise level database bootstrapper with YAML based on rk-entry in Golang

rk-db Enterprise level database bootstrapper with YAML in golang. This belongs to rk-boot family. We suggest use this lib from rk-boot. Database Statu

PointGoal 3 Mar 7, 2022
Simple key value database that use json files to store the database

KValDB Simple key value database that use json files to store the database, the key and the respective value. This simple database have two gRPC metho

Francisco Santos 0 Nov 13, 2021
NoSql DB using fileSystems using golang

No SQL DB using Go Prerequisite go 1.15 Run test go test -v ./... Env Var Variable Description Default Value Possible Values DB_DATA dir location to s

Neeraj 0 Nov 8, 2021
Fast and simple key/value store written using Go's standard library

Table of Contents Description Usage Cookbook Disadvantages Motivation Benchmarks Test 1 Test 4 Description Package pudge is a fast and simple key/valu

Vadim Kulibaba 327 Aug 2, 2022
The stats collector for CSC demo files

demoScrape2 The stats collector for CSC demo files. Join the CSC discord

null 1 Jan 8, 2022
The Monogon Project Monorepo. May contain traces of peanuts and a pure Go Linux userland.

This is the main repository containing the source code for the Monogon Project.

null 39 Jul 15, 2022
🤔 A minimize Time Series Database, written from scratch as a learning project.

mandodb ?? A minimize Time Series Database, written from scratch as a learning project. 时序数据库(TSDB: Time Series Database)大多数时候都是为了满足监控场景的需求,这里先介绍两个概念:

dongdong 486 Aug 11, 2022
Multi producer and multi-reader lockless ring buffer in go using generics from the go 1.18beta release

LocklessGenericRingBuffer This is an implementation of a multi producer, multi r

Gavin Clarke 134 Jul 27, 2022
moss - a simple, fast, ordered, persistable, key-val storage library for golang

moss moss provides a simple, fast, persistable, ordered key-val collection implementation as a 100% golang library. moss stands for "memory-oriented s

null 879 Aug 5, 2022
A simple, fast, embeddable, persistent key/value store written in pure Go. It supports fully serializable transactions and many data structures such as list, set, sorted set.

NutsDB English | 简体中文 NutsDB is a simple, fast, embeddable and persistent key/value store written in pure Go. It supports fully serializable transacti

徐佳军 2.3k Aug 8, 2022
Simple Shamir's Secret Sharing (s4) - A go package giving a easy to use interface for the shamir's secret sharing algorithm

Simple Shamir's Secret Sharing (s4) With Simple Shamir's Secret Sharing (s4) I want to provide you an easy to use interface for this beautiful little

Simon Frey 124 Jul 18, 2022
Simple implementation of a sharded mutex in Go

Sharded Mutex in Go This package contains a sharded mutex which should do better than a traditional sync.RWMutex in certain cases where you want to pr

Roman Atachiants 8 May 7, 2022
A simple Git Notes Key Value store

Gino Keva - Git Notes Key Values Gino Keva works as a simple Key Value store built on top of Git Notes, using an event sourcing architecture. Events a

Philips Software 23 Jan 19, 2022
This is a simple graph database in SQLite, inspired by "SQLite as a document database".

About This is a simple graph database in SQLite, inspired by "SQLite as a document database". Structure The schema consists of just two structures: No

Denis Papathanasiou 1.1k Aug 11, 2022
A simple memory database. It's nothing but a homework to learn primary datastruct of golang.

A simple memory database. It's nothing but a homework to learn primary datastruct of golang.

常乐村喵蕉君 0 Nov 8, 2021
Go reproduction of Bustub--a simple relational database system.

Bustub in Golang Bustub is the course project of CMU15-445 Database System, which is a simple relational database system. This repo is a golang reprod

Zhang Each 1 Dec 18, 2021
A simple wrapper around badgerDB that can be used across multiple projects

mstore Mstore is a simple wrapper around badgerDB for platform applications that require a quick persistent cache close to the consumer. It's intended

null 0 Dec 14, 2021
Simple Go program to prevent AFK timeouts during FFXIV Endwalker launch.

Idler Just a super simple keyboard idler written in Go, to assist in hands-free queueing/preventing AFK timeouts during the FFXIV Endwalker expansion

Chris Marquart 0 Dec 22, 2021