An open-source graph database

Build Status Container Repository

Cayley is an open-source database for Linked Data. It is inspired by the graph database behind Google's Knowledge Graph (formerly Freebase).

Get it from the Snap Store

Documentation

Features

  • Built-in query editor, visualizer and REPL
  • Multiple query languages:
  • Modular: easy to connect to your favorite programming languages and back-end stores
  • Production ready: well tested and used by various companies for their production workloads
  • Fast: optimized specifically for usage in applications

Performance

Rough performance testing shows that, on 2014 consumer hardware and an average disk, 134m quads in LevelDB is no problem and a multi-hop intersection query -- films starring X and Y -- takes ~150ms.

Community

Owner
Cayley
An open-source graph database
Cayley
Comments
  • make cayley go-gettable

    make cayley go-gettable

    This set of changes reorganises the cayley codebase to conform to the normal Go project organisation. In addition to this it makes superficial changes to take code and files closer to Go convention.

  • Improve Frontend

    Improve Frontend

    Hi @barakmich

    Vision: Let's make Cayley more approachable for novices whilst also allowing "experts" to not feel "babied" in the environment.

    Some thoughts I wanted the team's buy-in on before submitting PRs:

    Front-end Architecture

    • [ ] Implement AngularJS, this will give the UI a front-end platform to expand on, allowing us to do a range of "snappy" things with the front end as features get rolled out.
    • [ ] Use Angular Material for the layout. The current responsive layout is somewhat broken.. Angular material will give us a nice look and feel out of the box as well as a powerful set of UI-features to work with.

    Proposed Frontend Overhaul Phases

    Phase 1: Migrate to Angular

    • [ ] Replicate existing functionality on the new AngularJS/Material setup.
    • [ ] Produce UX mockups for Phase 2.

    Phase 2: Create State Based Views

    • [ ] Implement UI-router to move from the current setup to a modular, state based front-end. (May be achievable in Phase 1)

    Phase 3: Produce Training Content

    • [ ] Tour of the UI for newbies.
    • [ ] Create "In line" documentation to introduce people to Gremlin/Graph Visualisation. It's the basics of query writing that help people "get over the line". I will need someone to help me put together a set of absolute beginner tutes and I'll happily weave these into the front-end. These will be woven directly into the front end as helpers.

    Phase 4: Integrate Training Content

    Basically: Integrate documentation produced in Phase 3 into the UI.

    • [ ] Implement "inline documentation" from Phase 3.
    • [ ] "Quickstart.." templates. Let users choose typical modelling scenarios (e.g. I want to select users of type X who visited Y that happen to be related to Z) to give users a headstart on scripting.
    • [ ] "Expert mode" that basically hides "distractions" and let's people focus on modelling their stup.

    Thoughts? I have availability over the next 3-4 weeks to make this happen (I am currently in between roles).

  • Add Err() and Close() methods to Iterators

    Add Err() and Close() methods to Iterators

    This PR does the following:

    • As mentioned in #208, add an Err() method to all Iterators.
    • Adds tests that the various iterators pass through the underlying Err value.
    • Makes the Close() method on Iterators return an error.
    • Remove a bunch of uses of glog.Fatal* calls, instead either propagating the errors, or calling panic (when it's a programming bug).
    • Try to handle errors in other locations that use Next().

    cc @kortschak

    Updates #157

  • Go API

    Go API

    First run at a Go-importable API for Cayley. This would be the first step into using Cayley as a library and tackling #64 to a degree.

    It's more or less a port of Gremlin into Go syntax with a little magic behind the scenes. Evaluation still remains unchanged (that'd be a nice followup PR -- get all top level nodes, get all tags, etc) but it's much, much easier to build iterator trees now.

    Needs a large amount of documentation before committing. Sending the PR for initial feedback.

    /cc @sdboyer @kortschak

  • Fix Sessions to properly manage worker routines

    Fix Sessions to properly manage worker routines

    I used the repl console to execute some queries, but after a while the application crashes. Below is the stack trace. Would you know what is the cause ?

    cayley> panic: runtime error: close of closed channel
    
    goroutine 50 [running]:
    runtime.panic(0xa46720, 0xf1f7d5)
        pkg/runtime/panic.c:279 +0xf5
    github.com/google/cayley/query/gremlin.func·011()
        github.com/google/cayley/query/gremlin/session.go:131 +0x4d
    created by github.com/google/cayley/query/gremlin.(*Session).runUnsafe
        github.com/google/cayley/query/gremlin/session.go:140 +0x136
    
    goroutine 16 [syscall]:
    syscall.Syscall(0x0, 0x0, 0xc208089000, 0x1000, 0x7f0b67402318, 0xc20803a008, 0x43c338)
        pkg/syscall/asm_linux_amd64.s:21 +0x5
    syscall.read(0x0, 0xc208089000, 0x1000, 0x1000, 0x4cb355, 0x0, 0x0)
        pkg/syscall/zsyscall_linux_amd64.go:838 +0x75
    syscall.Read(0x0, 0xc208089000, 0x1000, 0x1000, 0x8, 0x0, 0x0)
        pkg/syscall/syscall_unix.go:136 +0x5c
    os.(*File).read(0xc20803a000, 0xc208089000, 0x1000, 0x1000, 0x4, 0x0, 0x0)
        pkg/os/file_unix.go:190 +0x62
    os.(*File).Read(0xc20803a000, 0xc208089000, 0x1000, 0x1000, 0x0, 0x0, 0x0)
        pkg/os/file.go:95 +0x98
    bufio.(*Reader).fill(0xc208400de0)
        pkg/bufio/bufio.go:97 +0x1b3
    bufio.(*Reader).ReadSlice(0xc208400de0, 0xc20803a00a, 0x0, 0x0, 0x0, 0x0, 0x0)
        pkg/bufio/bufio.go:298 +0x22c
    bufio.(*Reader).ReadLine(0xc208400de0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
        pkg/bufio/bufio.go:326 +0x69
    github.com/google/cayley/db.Repl(0x7f0b67411048, 0xc20811e0f0, 0xad11c0, 0x7, 0xc208004540, 0x0, 0x0)
        github.com/google/cayley/db/repl.go:85 +0x266
    main.main()
        github.com/google/cayley/cayley.go:120 +0xbd6
    
    goroutine 19 [finalizer wait, 4 minutes]:
    runtime.park(0x414c00, 0xf27020, 0xf24a49)
        pkg/runtime/proc.c:1369 +0x89
    runtime.parkunlock(0xf27020, 0xf24a49)
        pkg/runtime/proc.c:1385 +0x3b
    runfinq()
        pkg/runtime/mgc0.c:2644 +0xcf
    runtime.goexit()
        pkg/runtime/proc.c:1445
    
    goroutine 20 [chan receive]:
    github.com/barakmich/glog.(*loggingT).flushDaemon(0xf29a80)
        github.com/barakmich/glog/glog.go:923 +0x75
    created by github.com/barakmich/glog.init·1
        github.com/barakmich/glog/glog.go:408 +0x37a
    
    goroutine 17 [syscall, 4 minutes]:
    runtime.goexit()
        pkg/runtime/proc.c:1445
    
    goroutine 21 [select, 1 minutes]:
    github.com/syndtr/goleveldb/leveldb.(*DB).compactionError(0xc2080246c0)
        github.com/syndtr/goleveldb/leveldb/db_compaction.go:113 +0x1fa
    created by github.com/syndtr/goleveldb/leveldb.openDB
        github.com/syndtr/goleveldb/leveldb/db.go:117 +0x4b2
    
    goroutine 22 [select, 1 minutes]:
    github.com/syndtr/goleveldb/leveldb.(*DB).tCompaction(0xc2080246c0)
        github.com/syndtr/goleveldb/leveldb/db_compaction.go:666 +0x777
    created by github.com/syndtr/goleveldb/leveldb.openDB
        github.com/syndtr/goleveldb/leveldb/db.go:120 +0x4f4
    
    goroutine 23 [select, 1 minutes]:
    github.com/syndtr/goleveldb/leveldb.(*DB).mCompaction(0xc2080246c0)
        github.com/syndtr/goleveldb/leveldb/db_compaction.go:615 +0x1b9
    created by github.com/syndtr/goleveldb/leveldb.openDB
        github.com/syndtr/goleveldb/leveldb/db.go:121 +0x50c
    
    goroutine 24 [select, 1 minutes]:
    github.com/syndtr/goleveldb/leveldb.(*DB).jWriter(0xc2080246c0)
        github.com/syndtr/goleveldb/leveldb/db_write.go:37 +0x143
    created by github.com/syndtr/goleveldb/leveldb.openDB
        github.com/syndtr/goleveldb/leveldb/db.go:122 +0x524
    
    goroutine 38 [sleep]:
    time.Sleep(0x6fc23ac00)
        pkg/runtime/time.goc:39 +0x31
    github.com/google/cayley/query/gremlin.func·011()
        github.com/google/cayley/query/gremlin/session.go:130 +0x35
    created by github.com/google/cayley/query/gremlin.(*Session).runUnsafe
        github.com/google/cayley/query/gremlin/session.go:140 +0x136
    
  • Revise parser to use generated code

    Revise parser to use generated code

    This approach brings us into conformity with the spec. It slows down parsing by a factor of 5, but we are being more careful so I think this is reasonable. There is some possibility that working in byte space instead of rune space would speed this up, but this would be at an increased complexity cost in the ragel grammar - at the moment we are leveraging the language to do that work for us with some allocation costs as a result.

    There is some risk that this change will break queries, but that should be addressable and the short term pain will IMO be worth the effort.

  • Postgres backend!

    Postgres backend!

    One of the things in TODO.md is supporting Postgres as a backend. As someone who loves Postgres when dealing with relational data, I'd like to hear more thoughts on this, because I'd be interested in implementing it. For example, would native data types be best or could every entry just make use of Postgres' awesome native support for JSON documents?

    As stated in the document, why not :smile:?

    - Jonathan

    Note: I've signed the CLA.

  • Add options to ignore duplicate or missing quad

    Add options to ignore duplicate or missing quad

    Add command line option to ignore duplicated quad when loading and ignore missing quads when deleting (two different options) as discussed in issue #201

    The command line options are:

    • -noerrdup to ignore duplicate
    • -noerrdel to ignore missing

    This is my first contribution to a go project so forgive me if some choice are not in line with the go coding style

    Also note that leveldb doesn't actually detect duplicated line in the same block because is loaded in the db with the same batch. I don't know the impact of such bug.

  • Transversing a tree in Cayley

    Transversing a tree in Cayley

    How do you walk an entire tree in cayley to generate json? Without looping and making multiple requests at each level? Especially for a tree that could go as far as 8 levels, with each node having one to 100 children? I'm using a remotely hosted mongodb database, so keeping requests down would be nice.

    I'm using cayley as a library, but converting a gremlin query to golang code shouldnt be an issue.

  • Higher-level Go API

    Higher-level Go API

    Tracking for this discussion that keeps happening -- now it's got a number.

    Basically, it'd be great to write queries (or, more explicitly, build iterator trees) without having to be so mechanistic in building the iterator trees. Exposing such an API makes it easier for people using Cayley as a library, makes it easier to write query languages (that have repeated patterns in a lot of places) and, perhaps, make it easier to talk about external API connections -- essentially, the wire format for building iterator trees. Which would allow interesting bindings for other languages without catting together Javascript.

    This may be directly related to the Gremlin API, in that one may influence the other and vice versa.

  • mongo empty result

    mongo empty result

    whatever query, cayley return empty result for me.

    eg: (1) g.V("Humphrey Bogart").All() return {"result": [ { "id": "" } ]}

    (2) g.V().GetLimit(2) { "result": [ { "id": "" }, { "id": "" } ]}

    this is my command 1, cayley_0.3.1_linux_amd64 2, config to mongodb 3, load data like : ./cayley load --config=cayley.cfg --triples=30kmoviedata.nq.gz 4, found 471705 document in mongo

  • Security issue with github.com/gogo/protobuf version < 1.3.2

    Security issue with github.com/gogo/protobuf version < 1.3.2

    github.com/gogo/protobuf versions lower that 1.3.2 there is security weakness.

    An issue was discovered in GoGo Protobuf before 1.3.2. plugin/unmarshal/unmarshal.go lacks certain index validation, aka the "skippy peanut butter" issue.
    
  • Relationships not displaying correctly in new cayley version

    Relationships not displaying correctly in new cayley version

    • Cayley Forum - https://discourse.cayley.io
    • Slack - cayleygraph.slack.com, invites: https://cayley-slackin.herokuapp.com

    Description

    Unable to display relationships correctly. We have a set of entity relations.

    When A -->B

    and when we query the relation. It would give relation between A and B when we query for A. This is not happening in the latest version of Cayley. When we give B , it would give the relation. In previous version that is 7.2 we are getting the results correctly. But in 7.7 we are unable to get this and customers have raised bug Steps to reproduce the issue: Create relation between A and B, A Query for A

    Received results:

    Getting empty results

    { "result": [ [] ] }

    Expected results:

    "result": [
    	[
    		"test-A",
    		"test-B"
    	],
    	{
    		"relation": "DependsOn",
    		"source": "test-A",
    		"target": "test-B"
    	},
    	{
    

    Backend database: (database and version)

    7,7

  • 'go build ./cmd/cayley' breaks: missing go.sum entry for module providing package github.com/golang/protobuf/proto

    'go build ./cmd/cayley' breaks: missing go.sum entry for module providing package github.com/golang/protobuf/proto

    Description While following build instructions https://cayley.gitbook.io/cayley/getting-involved/contributing the command go build ./cmd/cayley fails:

    $ go build ./cmd/cayley
    /home/yuri/go/pkg/mod/github.com/prometheus/[email protected]/prometheus/desc.go:22:2: missing go.sum entry for module providing package github.com/golang/protobuf/proto (imported by github.com/prometheus/client_golang/prometheus); to add:
    	go get github.com/prometheus/client_golang/[email protected]
    cmd/cayley/command/database.go:14:2: missing go.sum entry for module providing package github.com/spf13/viper (imported by github.com/cayleygraph/cayley/cmd/cayley); to add:
    	go get github.com/cayleygraph/cayley/cmd/cayley
    /home/yuri/go/pkg/mod/github.com/go-kivik/[email protected]/chttp/auth.go:10:2: missing go.sum entry for module providing package golang.org/x/net/publicsuffix (imported by github.com/go-kivik/couchdb/chttp); to add:
    	go get github.com/go-kivik/couchdb/[email protected]
    /home/yuri/go/pkg/mod/github.com/dgraph-io/[email protected]/y/watermark.go:23:2: missing go.sum entry for module providing package golang.org/x/net/trace (imported by github.com/dgraph-io/badger); to add:
    	go get github.com/dgraph-io/[email protected]
    /home/yuri/go/pkg/mod/github.com/dop251/[email protected]/string_unicode.go:7:2: missing go.sum entry for module providing package golang.org/x/text/cases (imported by github.com/dop251/goja); to add:
    	go get github.com/dop251/[email protected]
    /home/yuri/go/pkg/mod/github.com/dop251/[email protected]/builtin_string.go:6:2: missing go.sum entry for module providing package golang.org/x/text/collate (imported by github.com/dop251/goja); to add:
    	go get github.com/dop251/[email protected]
    /home/yuri/go/pkg/mod/github.com/dop251/[email protected]/builtin_string.go:7:2: missing go.sum entry for module providing package golang.org/x/text/language (imported by github.com/dop251/goja); to add:
    	go get github.com/dop251/[email protected]
    /home/yuri/go/pkg/mod/github.com/xdg/[email protected]/profile.go:4:2: missing go.sum entry for module providing package golang.org/x/text/unicode/norm (imported by github.com/dop251/goja); to add:
    	go get github.com/dop251/[email protected]
    internal/http/http-packr.go:8:8: package usr/ports/databases/cayley/cayley/packrd is not in GOROOT (/usr/local/go/src/usr/ports/databases/cayley/cayley/packrd)
    

    go-1.16.4,1 OS: FreeBSD 13

  • `LoadToDepth` from `schema` with property on depth 0 and depth 1 crashes

    `LoadToDepth` from `schema` with property on depth 0 and depth 1 crashes

    Description

    I am trying to build up an ontology of a service, its endpoint and a TLS configuration and trying to persist it into Cayley and then load it again. If I try to load it again into objects, there seems to be some kind of type confusion between objects on depth 0 and depth 1, resulting into the crash below.

    package main
    
    import (
    	"context"
    	"fmt"
    	"log"
    	"math/rand"
    
    	"github.com/cayleygraph/cayley"
    	"github.com/cayleygraph/cayley/graph"
    	"github.com/cayleygraph/cayley/schema"
    	"github.com/cayleygraph/quad"
    	"github.com/cayleygraph/quad/voc"
    )
    
    type TlsConfiguration struct {
    	rdfType struct{} `quad:"@type > ex:TlsConfig"`
    
    	Version string `quad:"ex:version"`
    }
    
    type HttpEndpoint struct {
    	rdfType struct{} `quad:"@type > ex:Http"`
    
    	URL       string           `quad:"ex:url"`
    	TlsConfig TlsConfiguration `quad:"ex:tls"`
    }
    
    type Category struct {
    	Name string `quad:"ex:name"`
    }
    
    type Service struct {
    	rdfType struct{} `quad:"@type > ex:Service"`
    
    	ID           quad.IRI     `json:"@id"`
    	HttpEndpoint HttpEndpoint `quad:"ex:http"`
    	Category     Category     `quad:"ex:category"`
    }
    
    func main() {
    	store, err := cayley.NewMemoryGraph()
    	if err != nil {
    		log.Fatalln(err)
    	}
    
    	voc.RegisterPrefix("ex:", "https://example.io")
    
    	sch := schema.NewConfig()
    	// Override a function to generate IDs. Can be changed to generate UUIDs, for example.
    	sch.GenerateID = func(_ interface{}) quad.Value {
    		return quad.BNode(fmt.Sprintf("node%d", rand.Intn(1000)))
    	}
    
    	qw := graph.NewWriter(store)
    
    	s1 := &Service{
    		ID: quad.IRI("s1"),
    		HttpEndpoint: HttpEndpoint{
    			URL: "https://example.io",
    			TlsConfig: TlsConfiguration{
    				Version: "1.2",
    			},
    		},
    		Category: Category{Name: "An example service"},
    	}
    
    	sch.WriteAsQuads(qw, s1)
    
    	s2 := &Service{
    		ID: quad.IRI("s2"),
    		HttpEndpoint: HttpEndpoint{
    			URL: "https://cayley.io",
    			TlsConfig: TlsConfiguration{
    				Version: "1.3",
    			},
    		},
    		Category: Category{Name: "A graph service"},
    	}
    
    	sch.WriteAsQuads(qw, s2)
    
    	qw.Close()
    
    	// Print quads
    	fmt.Println("\nquads:")
    	it := store.QuadsAllIterator().Iterate()
    	defer it.Close()
    
    	for it.Next(context.TODO()) {
    		fmt.Println(store.Quad(it.Result()))
    	}
    
    	var services []Service
    	sch.LoadToDepth(context.TODO(), store, &services, 1) // depth=0 will work, 1 will crash
    
    	for _, v := range services {
    		fmt.Printf("%+v\n", v)
    	}
    }
    

    Steps to reproduce the issue:

    1. Build up a schema with objects on depth 0 and depth 1
    2. Store it
    3. Load it

    Received results:

    <s1> -- <rdf:type> -> <ex:Actor>
    _:node81 -- <rdf:type> -> <ex:Http>
    _:node81 -- <ex:url> -> "https://example.io"
    _:node887 -- <rdf:type> -> <ex:TlsConfig>
    _:node887 -- <ex:version> -> "1.2"
    _:node81 -- <ex:tls> -> _:node887
    <s1> -- <ex:http> -> _:node81
    _:node847 -- <ex:name> -> "An example service"
    <s1> -- <ex:category> -> _:node847
    <s2> -- <rdf:type> -> <ex:Actor>
    _:node59 -- <rdf:type> -> <ex:Http>
    _:node59 -- <ex:url> -> "https://cayley.io"
    _:node81 -- <rdf:type> -> <ex:TlsConfig>
    _:node81 -- <ex:version> -> "1.3"
    _:node59 -- <ex:tls> -> _:node81
    <s2> -- <ex:http> -> _:node59
    _:node318 -- <ex:name> -> "A graph service"
    <s2> -- <ex:category> -> _:node318
    
    panic: reflect.Set: value of type main.HttpEndpoint is not assignable to type main.TlsConfiguration
    goroutine 1 [running]:
    
    reflect.Value.assignTo(0x100505fc0, 0x140001468a0, 0x199, 0x1004ce012, 0xb, 0x100500a60, 0x0, 0x0, 0x0, 0x0)
    	/opt/homebrew/Cellar/go/1.16.3/libexec/src/reflect/value.go:2451 +0x3f0
    reflect.Value.Set(0x100500a60, 0x140001055d0, 0x199, 0x100505fc0, 0x140001468a0, 0x199)
    	/opt/homebrew/Cellar/go/1.16.3/libexec/src/reflect/value.go:1564 +0xa4
    github.com/cayleygraph/cayley/schema.(*loader).loadIteratorToDepth(0x14000108a20, 0x100520230, 0x14000181b30, 0x100500a60, 0x140001055d0, 0x199, 0x0, 0x100520770, 0x140001217e8, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:470 +0x790
    github.com/cayleygraph/cayley/schema.(*loader).loadToValue(0x14000108a20, 0x100520230, 0x14000181800, 0x100505fc0, 0x14000147320, 0x199, 0x1, 0x1400018ac48, 0x0, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:372 +0xe08
    github.com/cayleygraph/cayley/schema.(*loader).loadIteratorToDepth(0x14000108a20, 0x100520230, 0x14000181800, 0x100505fc0, 0x14000147320, 0x199, 0x1, 0x100520770, 0x140001213f8, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:511 +0xd58
    github.com/cayleygraph/cayley/schema.(*loader).loadToValue(0x14000108a20, 0x100520230, 0x140001096e0, 0x10050b840, 0x14000182780, 0x199, 0x2, 0x1400018b848, 0x0, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:372 +0xe08
    github.com/cayleygraph/cayley/schema.(*loader).loadIteratorToDepth(0x14000108a20, 0x100520230, 0x140001096e0, 0x1004ef100, 0x140001203f0, 0x197, 0x2, 0x0, 0x0, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:511 +0xd58
    github.com/cayleygraph/cayley/schema.(*Config).LoadIteratorToDepth(0x1400012c0c0, 0x1005201f8, 0x1400010e008, 0x100521398, 0x14000146000, 0x1004ea340, 0x140001203f0, 0x16, 0x2, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:142 +0xa8
    github.com/cayleygraph/cayley/schema.(*Config).LoadToDepth(0x1400012c0c0, 0x1005201f8, 0x1400010e008, 0x100521398, 0x14000146000, 0x1004ea340, 0x140001203f0, 0x1, 0x0, 0x0, ...)
    	/Users/oxisto/go/pkg/mod/github.com/cayleygraph/[email protected]/schema/loader.go:116 +0x240
    main.main()
    	/Users/oxisto/Downloads/cayley-test/main.go:95 +0x750
    

    Expected results:

    I expect it to work - or at least give me a proper error message why it does not.

    Output of cayley version or commit hash:

    github.com/cayleygraph/cayley v0.7.7-0.20210518204410-08381efb7f81
    

    Environment details:

    Backend database: in-memory

Native GraphQL Database with graph backend
Native GraphQL Database with graph backend

The Only Native GraphQL Database With A Graph Backend. Dgraph is a horizontally scalable and distributed GraphQL database with a graph backend. It pro

Aug 4, 2022
EliasDB a graph-based database.
EliasDB a graph-based database.

EliasDB EliasDB is a graph-based database which aims to provide a lightweight solution for projects which want to store their data as a graph. Feature

Aug 2, 2022
CockroachDB - the open source, cloud-native distributed SQL database.
CockroachDB - the open source, cloud-native distributed SQL database.

CockroachDB is a cloud-native SQL database for building global, scalable cloud services that survive disasters. What is CockroachDB? Docs Quickstart C

Aug 7, 2022
TiDB is an open source distributed HTAP database compatible with the MySQL protocol
TiDB is an open source distributed HTAP database compatible with the MySQL protocol

Slack Channel Twitter: @PingCAP Reddit Mailing list: lists.tidb.io For support, please contact PingCAP What is TiDB? TiDB ("Ti" stands for Titanium) i

Aug 1, 2022
RadonDB is an open source, cloud-native MySQL database for building global, scalable cloud services

OverView RadonDB is an open source, Cloud-native MySQL database for unlimited scalability and performance. What is RadonDB? RadonDB is a cloud-native

Aug 5, 2022
LinDB is an open-source Time Series Database which provides high performance, high availability and horizontal scalability.
LinDB is an open-source Time Series Database which provides high performance, high availability and horizontal scalability.

LinDB is an open-source Time Series Database which provides high performance, high availability and horizontal scalability. LinDB stores all monitoring data of ELEME Inc, there is 88TB incremental writes per day and 2.7PB total raw data.

Jul 30, 2022
Set out to become the de facto open-source alternative to MongoDB

MangoDB MangoDB is set out to become the de facto open-source alternative to MongoDB. MangoDB is an open-source proxy, which converts MongoDB wire pro

Aug 6, 2022
Owl is a db manager platform,committed to standardizing the data, index in the database and operations to the database, to avoid risks and failures.

Owl is a db manager platform,committed to standardizing the data, index in the database and operations to the database, to avoid risks and failures. capabilities which owl provides include Process approval、sql Audit、sql execute and execute as crontab、data backup and recover .

Jun 17, 2022
Hard Disk Database based on a former database

Hard Disk Database based on a former database

Nov 1, 2021
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

Nov 13, 2021
Beerus-DB: a database operation framework, currently only supports Mysql, Use [go-sql-driver/mysql] to do database connection and basic operations

Beerus-DB · Beerus-DB is a database operation framework, currently only supports Mysql, Use [go-sql-driver/mysql] to do database connection and basic

Mar 5, 2022
An embedded key/value database for Go.

bbolt bbolt is a fork of Ben Johnson's Bolt key/value store. The purpose of this fork is to provide the Go community with an active maintenance and de

Aug 11, 2022
BuntDB is an embeddable, in-memory key/value database for Go with custom indexing and geospatial support
BuntDB is an embeddable, in-memory key/value database for Go with custom indexing and geospatial support

BuntDB is a low-level, in-memory, key/value store in pure Go. It persists to disk, is ACID compliant, and uses locking for multiple readers and a sing

Aug 7, 2022
ACID key-value database.

Coffer Simply ACID* key-value database. At the medium or even low latency it tries to provide greater throughput without losing the ACID properties of

Jul 3, 2022
A decentralized, trusted, high performance, SQL database with blockchain features
A decentralized, trusted, high performance, SQL database with blockchain features

中文简介 CovenantSQL(CQL) is a Byzantine Fault Tolerant relational database built on SQLite: ServerLess: Free, High Availabile, Auto Sync Database Service

Aug 2, 2022
LevelDB key/value database in Go.

This is an implementation of the LevelDB key/value database in the Go programming language. Installation go get github.com/syndtr/goleveldb/leveldb R

Jul 31, 2022
immudb - world’s fastest immutable database
immudb - world’s fastest immutable database

immudb Note: The master branch is the joint point for all ongoing development efforts. Thus it may be in an unstable state and should not be used in p

Aug 8, 2022
A high performance NoSQL Database Server powered by Go
A high performance NoSQL Database Server powered by Go

LedisDB Ledisdb is a high-performance NoSQL database library and server written in Go. It's similar to Redis but store data in disk. It supports many

Aug 6, 2022
Lightweight RESTful database engine based on stack data structures
Lightweight RESTful database engine based on stack data structures

piladb [pee-lah-dee-bee]. pila means stack or battery in Spanish. piladb is a lightweight RESTful database engine based on stack data structures. Crea

Jul 1, 2022