gitson alternatives and similar packages
Based on the "Database" category.
Alternatively, view gitson alternatives based on common mentions on social networks and blogs.
-
erd
Translates a plain text description of a relational database schema to a graphical entity-relationship diagram. -
persistent-redis
Persistence interface for Haskell allowing multiple storage methods. -
acid-state
Add ACID guarantees to any serializable Haskell data structure -
postgresql-simple
Mid-level client library for accessing PostgreSQL from Haskell -
HDBC-session
This repository includes a joined query generator based on typefull relational algebra, and mapping tools between SQL values list and Haskell record type. -
esqueleto
Bare bones, type-safe EDSL for SQL queries on persistent backends. -
groundhog
This library maps datatypes to a relational model, in a way similar to what ORM libraries do in OOP. See the tutorial https://www.schoolofhaskell.com/user/lykahb/groundhog for introduction -
hw-kafka-client
Kafka client for Haskell, including auto-rebalancing consumers -
mysql-simple
A mid-level client library for the MySQL database, intended to be fast and easy to use. -
postgresql-simple-migration
PostgreSQL Schema Migrations for Haskell -
direct-sqlite
Low-level binding to SQLite3. Includes UTF8 and BLOB support. -
vcache-trie
large, persistent, memcached values and structure sharing for Haskell -
dbmigrations
A library for the creation, management, and installation of schema updates for relational databases. -
vcache
large, persistent, memcached values and structure sharing for Haskell -
postgresql-typed
Haskell PostgreSQL library with compile-time type inference -
ampersand
Build database applications faster than anyone else, and keep your data pollution free as a bonus. -
postgresql-orm
An Haskell ORM (Object Relational Mapping) and migrations DSL for PostgreSQL. -
persistent-database-url
Parse DATABASE_URL into configuration types for Persistent
InfluxDB - Power Real-Time Data Analytics at Scale
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of gitson or a related project?
README
gitson
A simple document store library for Git + JSON, based on Aeson. Uses command line git, at least for now. No fancy indexes and stuff, but it does what I need right now. Transactions use flock, so it's safe even across completely separate programs!
Usage
{-# LANGUAGE TemplateHaskell #-}
import Gitson
import Gitson.Util (insideDirectory)
import Data.Aeson.TH
import Control.Monad.IO.Class (liftIO)
data Thing = Thing { val :: Int } deriving (Eq, Show)
$(deriveJSON defaultOptions ''Thing) -- there are non-Template ways of doing this, see aeson docs
main :: IO ()
main = do
-- Creating a new "database," basically mkdir + git init
createRepo "./content"
-- Writing data to a "database" happens in transactions
-- A transaction is committed (write files & git commit)
-- after the block is executed, just like in SQL databases
-- Also, transactions are thread-safe
transaction "./content" $ do
-- order: (collection) (key ) (data)
saveDocument "things" "first-thing" Thing {val = 1}
-- Collections are created automatically, like in MongoDB
liftIO $ putStrLn "Written first-thing"
-- You have to use liftIO to do IO actions inside of a transaction!
-- Because a transaction is a monad transformer, WriterT actually
-- Reading data
-- (These are normal IO actions, so if you want
-- to read inside of a transaction, liftIO.
-- Note: transaction already includes insideDirectory!
-- Warning: you can't read what you've written in the current transaction!!!
-- You can only read what's been written before the transaction began.)
insideDirectory "./content" $ do
colls <- listCollections
-- ["things"]
keys <- listDocumentKeys "things"
-- ["first-thing"]
first-thing <- readDocument "things" "first-thing" :: IO (Maybe Thing)
-- Just Thing {val = 1}
things <- readEntries "things" :: IO [Thing]
-- [Thing {val = 1}]
-- Note: insideDirectory is just a function that changes
-- the current directory, executes an action and changes it back.
-- You can use reading actions without it, like this:
keys <- listDocumentKeys "./content/things"
-- And now, some bells and whistles:
-- Numeric id support
transaction "./content" $ do
saveNextDocument "things" "hello-world" Thing {val = 1}
-- will save to things/000001-hello-world.json
insideDirectory "./content" $ do
thing <- readDocumentById "things" 1
same-thing <- readDocumentByName "things" "hello-world"
-- both will read from things/000001-hello-world.json
i <- documentIdFromName "things" "hello-world"
-- 1
n <- documentNameFromId "things" 1
-- "hello-world"
Development
Use stack to build.
Use ghci to run tests quickly with :test
(see the .ghci
file).
``bash $ stack build
$ stack test && rm tests.tix
$ stack bench
$ stack ghci --ghc-options="-fno-hpc" ``
Contributing
Please feel free to submit pull requests! Bugfixes and simple non-breaking improvements will be accepted without any questions :-)
By participating in this project you agree to follow the Contributor Code of Conduct.
License
This is free and unencumbered software released into the public domain.
For more information, please refer to the UNLICENSE
file or unlicense.org.
*Note that all licence references and agreements mentioned in the gitson README section above
are relevant to that project's source code only.