Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/TobiEiss/aranGoDriver
ArangoDB-driver in golang
https://github.com/TobiEiss/aranGoDriver
aql arangodb database golang memory-database
Last synced: 26 days ago
JSON representation
ArangoDB-driver in golang
- Host: GitHub
- URL: https://github.com/TobiEiss/aranGoDriver
- Owner: TobiEiss
- License: mit
- Created: 2016-12-11T12:16:17.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2023-08-20T11:19:26.000Z (over 1 year ago)
- Last Synced: 2024-08-04T23:09:43.279Z (4 months ago)
- Topics: aql, arangodb, database, golang, memory-database
- Language: Go
- Homepage: https://github.com/TobiEiss/aranGoDriver
- Size: 72.3 KB
- Stars: 32
- Watchers: 4
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-arangodb - aranGoDriver
README
# aranGoDriver [![Build Status](https://travis-ci.org/TobiEiss/aranGoDriver.svg?branch=master)](https://travis-ci.org/TobiEiss/aranGoDriver)
This project is a golang-driver for [ArangoDB](https://www.arangodb.com/) writen in go.
There is also an embedded-in-memory-Database to run all your tests.Currently implemented:
* [version](#version)
* [users](#user): create, drop
* [databases](#database): connect, list, create, drop
* [collections](#collection): create, drop, truncate, update
* [documents](#document): create, getById
* [graphs](#graphs): create, drop, list
* [migrations](#migrations)
* [AQL](#aql): simple cursorIf you miss something, please contact me!
## Getting started
All you need is a running Arango-DB and a go-environment.Install aranGoDriver:
`go get github.com/TobiEiss/aranGoDriver`Write your first aranGoDriver-Programm:
```golang
func main() {
var session aranGoDriver.Session
// Initialize a arango-Session with the address to your arangoDB.
//
// If you write a test use:
// session = aranGoDriver.NewTestSession()
//
session = aranGoDriver.NewAranGoDriverSession("http://localhost:8529")// Connect to your arango-database:
session.Connect("usnername", "secretPassword")// Concrats, you are connected!
// Let's print out all your databases
list, err := session.ListDBs()
if err != nil {
log.Fatal("there was a problem: ", err)
}
log.Println(list)// Create a new database
err = session.CreateDB("myNewDatabase")
// TODO: handle err// Create a new collection
err = session.CreateCollection("myNewDatabase", "myNewCollection")
// TODO: handle err// Create Document
newDocument := make(map[string]interface{})
newDocument["foo"] = "bar"
arangoID, err = session.CreateDocument("myNewDatabase", "myNewCollection", newDocument)
}
```## Test
### Test against a fake-in-memory-database:
```
go test
```### Test with a real database
```
go test -dbhost http://localhost:8529 -dbusername root -dbpassword password123
```## Usage
### Connect to your ArangoDB
You need a new Session to your database with the hostname as parameter. Then connect with an existing username and a password.
```
session := aranGoDriver.NewAranGoDriverSession("http://localhost:8529")
session.Connect("username", "password")
```### Version
```golang
version, err := session.Version()
```### User
To use this methods you need a session as root user.
```golang
// create a new user
err := session.CreateUser("username", "password")// delete an existing user
err := session.DropUser("username")// grant permissions for a database
err := session.GrantDB("database", "username", "rw")
// Instead of "rw" you can also use "ro" or "none"// grant permissions for collections
err := session.GrantCollection("database", "collection", "username", "rw")
// Instead of "rw" you can also use "ro" or "none"
// and instead of a collection name, you can use "*" for all collections
```### Database
```golang
// list databases
list := session.ListDBs()
fmt.Println(list) // will print ([]string): [ _system test testDB]// create databases
err := session.CreateDB("myNewDatabase")// drop databases
err = session.DropDB("myNewDatabase")
```### Collection
```golang
// create a collection in a database
err = CreateCollection("myNewDatabase", "myNewCollection")// drop collection from database
err = DropCollection("myNewDatabase", "myNewCollection")// truncate database
err = TruncateCollection("myNewDatabase", "myNewCollection")
```EdgeCollection:
```golang
// create a collection in a database
err = CreateEdgeCollection("myNewDatabase", "myNewEdgeCollection")
```### Document
```golang
// create document
testDoc["foo"] = "bar"
arangoID, err := session.CreateDocument("myNewDatabase", "myNewCollection", testDoc)// get by id
resultAsMap, err := session.GetCollectionByID("myNewDatabase", idOfDocument)// update Document
testDoc["bar"] = "foo"
err = session.UpdateDocument("myNewDatabase", arangoID.ID, testDoc)
```EdgeDocument
```golang
arangoID, err := session.CreateDocument("myNewDatabase", "myNewCollection", testDoc)
```### Graphs
To create a graph, you need to define the edges and nodes for the graph.
This can be done with the `EdgeDefinition` model.
```golang
edgeDefinition := models.EdgeDefinition{
Collection: "myEdgeCollection",
From: []string{"myCollection1"},
To: []string{"myCollection2"}}
edgeDefinitions := []models.EdgeDefinition{edgeDefinition}err := session.CreateGraph("myDatabase", "myGraph", edgeDefinitions)
```If you want to get rid of an existing graph, you can use the `DropGraph` method.
```golang
err := session.DropGraph("myDatabase", "myGraph")
```For an overview of your existing graphs, you can use `ListGraphs`.
```golang
str, b, err := session.ListGraphs("myDatabase")
```### Migrations
In some cases you need 'migrations'. For example, you need default-user in your database in every environment.
For this case, you can use migrations. The aranGoDriver write his own memo in a `migrations`-Collection in the standard `-system`-Database of arango, and execute the migration only one time.
AranGoDriver will identificate the migration by name.
Take a look to the following example:
```golang
// check migrations
mig1 := aranGoDriver.Migration{
Name: "mig1", // name of migration to identificate
Handle: func(embeddedSession aranGoDriver.Session) {
testMap := make(map[string]interface{})
testMap["foo"] = "foo"
// you can do everything with the database
embeddedSession.CreateDocument("myDatabase", "myCollection", testMap)
},
}
// excute migration
// Run This line before you 'main-loop' of your program
session.Migrate(mig1)
```### aql
```golang
// create query
query := "FOR element in testColl FILTER element.foo == 'bar' RETURN element"
response, err := session.AqlQuery("myNewDatabase", query, true, 1)
```