README
¶
Go client
This package provides helper function for interacting with the Dgraph server. You can use it to run mutations and queries. You can also use BatchMutation to upload data concurrently. It communicates with the server using gRPC.
Documentation
¶
Overview ¶
Package client is used to interact with a Dgraph server. Queries, mutations, and most other types of admin tasks can be run from the client.
Example (SetObject) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
type School struct {
Name string `json:"name,omitempty"`
}
type loc struct {
Type string `json:"type,omitempty"`
Coords []float64 `json:"coordinates,omitempty"`
}
// If omitempty is not set, then edges with empty values (0 for int/float, "" for string, false
// for bool) would be created for values not specified explicitly.
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Raw []byte `json:"raw_bytes",omitempty`
Friends []Person `json:"friend,omitempty"`
Location loc `json:"loc,omitempty"`
School []School `json:"school,omitempty"`
}
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
// While setting an object if a struct has a Uid then its properties in the graph are updated
// else a new node is created.
// In the example below new nodes for Alice and Charlie and school are created (since they dont
// have a Uid). Alice is also connected via the friend edge to an existing node with Uid
// 1000(Bob). We also set Name and Age values for this node with Uid 1000.
p := Person{
Name: "Alice",
Age: 26,
Married: true,
Location: loc{
Type: "Point",
Coords: []float64{1.1, 2},
},
Raw: []byte("raw_bytes"),
Friends: []Person{{
Uid: "1000",
Name: "Bob",
Age: 24,
}, {
Name: "Charlie",
Age: 29,
}},
School: []School{{
Name: "Crown Public School",
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
loc: geo .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
assigned, err := dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
// Assigned uids for nodes which were created would be returned in the resp.AssignedUids map.
puid := assigned.Uids["blank-0"]
q := fmt.Sprintf(`{
me(func: uid(%s)) {
uid
name
age
loc
raw_bytes
married
friend {
uid
name
age
}
school {
name
}
}
}`, puid)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Me: %+v\n", r.Me)
// R.Me would be same as the person that we set above.
}
Output:
Index ¶
- Variables
- type Dgraph
- type Txn
- func (txn *Txn) Commit(ctx context.Context) error
- func (txn *Txn) Discard(ctx context.Context) error
- func (txn *Txn) Mutate(ctx context.Context, mu *protos.Mutation) (*protos.Assigned, error)
- func (txn *Txn) Query(ctx context.Context, q string) (*protos.Response, error)
- func (txn *Txn) QueryWithVars(ctx context.Context, q string, vars map[string]string) (*protos.Response, error)
Examples ¶
Constants ¶
This section is empty.
Variables ¶
View Source
var ( ErrAborted = x.Errorf("Transaction has been aborted due to conflict") ErrFinished = x.Errorf("Transaction has already been committed or discarded") )
Functions ¶
This section is empty.
Types ¶
type Dgraph ¶
type Dgraph struct {
// contains filtered or unexported fields
}
Dgraph is a transaction aware client to a set of dgraph server instances.
func NewDgraphClient ¶
func NewDgraphClient(clients ...protos.DgraphClient) *Dgraph
NewDgraphClient creates a new Dgraph for interacting with the Dgraph store connected to in conns. The client can be backed by multiple connections (to the same server, or multiple servers in a cluster).
A single client is thread safe for sharing with multiple go routines.
func (*Dgraph) Alter ¶
By setting various fields of protos.Operation, Alter can be used to do the following:
1. Modify the schema.
2. Drop a predicate.
3. Drop the database.
Example (DropAll) ¶
package main
import (
"context"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
op := protos.Operation{
DropAll: true,
}
ctx := context.Background()
x.Check(dg.Alter(ctx, &op))
}
Output:
type Txn ¶
type Txn struct {
// contains filtered or unexported fields
}
Txn is a single atomic transaction.
A transaction lifecycle is as follows:
1. Created using NewTxn.
2. Various Query and Mutate calls made.
3. Commit or Discard used. If any mutations have been made, It's important that at least one of these methods is called to clean up resources. Discard is a no-op if Commit has already been called, so it's safe to defer a call to Discard immediately after NewTxn.
func (*Txn) Commit ¶
Commit commits any mutations that have been made in the transaction. Once Commit has been called, the lifespan of the transaction is complete.
Errors could be returned for various reasons. Notably, ErrAborted could be returned if transactions that modify the same data are being run concurrently. It's up to the user to decide if they wish to retry. In this case, the user should create a new transaction.
func (*Txn) Discard ¶
Discard cleans up the resources associated with an uncommitted transaction that contains mutations. It is a no-op on transactions that have already been committed or don't contain mutations. Therefore it is safe (and recommended) to call as a deferred function immediately after a new transaction is created.
In some cases, the transaction can't be discarded, e.g. the grpc connection is unavailable. In these cases, the server will eventually do the transaction clean up.
func (*Txn) Mutate ¶
Mutate allows data stored on dgraph instances to be modified. The fields in protos.Mutation come in pairs, set and delete. Mutations can either be encoded as JSON or as RDFs.
If CommitImmediately is set, then this call will result in the transaction being committed. In this case, an explicit call to Commit doesn't need to subsequently be made.
Example ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
type School struct {
Name string `json:"name,omitempty"`
}
type loc struct {
Type string `json:"type,omitempty"`
Coords []float64 `json:"coordinates,omitempty"`
}
// If omitempty is not set, then edges with empty values (0 for int/float, "" for string, false
// for bool) would be created for values not specified explicitly.
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Raw []byte `json:"raw_bytes,omitempty"`
Friends []Person `json:"friend,omitempty"`
Location loc `json:"loc,omitempty"`
School []School `json:"school,omitempty"`
}
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
// While setting an object if a struct has a Uid then its properties in the graph are updated
// else a new node is created.
// In the example below new nodes for Alice and Charlie and school are created (since they dont
// have a Uid). Alice is also connected via the friend edge to an existing node with Uid
// 1000(Bob). We also set Name and Age values for this node with Uid 1000.
p := Person{
Name: "Alice",
Age: 26,
Married: true,
Location: loc{
Type: "Point",
Coords: []float64{1.1, 2},
},
Raw: []byte("raw_bytes"),
Friends: []Person{{
Uid: "1000",
Name: "Bob",
Age: 24,
}, {
Name: "Charlie",
Age: 29,
}},
School: []School{{
Name: "Crown Public School",
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
assigned, err := dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
// Assigned uids for nodes which were created would be returned in the resp.AssignedUids map.
puid := assigned.Uids["blank-0"]
q := fmt.Sprintf(`{
me(func: uid(%s)) {
uid
name
age
loc
raw_bytes
married
friend {
uid
name
age
}
school {
name
}
}
}`, puid)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Me: %+v\n", r.Me)
// R.Me would be same as the person that we set above.
}
Output:
Example (Bytes) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Bytes []byte `json:"bytes,omitempty"`
}
op := &protos.Operation{}
op.Schema = `
name: string @index(exact) .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
p := Person{
Name: "Alice",
Bytes: []byte("raw_bytes"),
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
q := `{
q(func: eq(name, "Alice")) {
uid
name
bytes
}
}`
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"q"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Me: %+v\n", r.Me)
}
Output:
Example (Delete) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
type School struct {
Uid string `json:"uid"`
Name string `json:"name@en,omitempty"`
}
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Friends []Person `json:"friend,omitempty"`
Location string `json:"loc,omitempty"`
School []*School `json:"school,omitempty"`
}
// Lets add some data first.
p := Person{
Uid: "1000",
Name: "Alice",
Age: 26,
Married: true,
Location: "Riley Street",
Friends: []Person{{
Uid: "1001",
Name: "Bob",
Age: 24,
}, {
Uid: "1002",
Name: "Charlie",
Age: 29,
}},
School: []*School{&School{
Uid: "1003",
Name: "Crown Public School",
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
mu := &protos.Mutation{}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
mu.CommitImmediately = true
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
q := fmt.Sprintf(`{
me(func: uid(1000)) {
uid
name
age
loc
married
friend {
uid
name
age
}
school {
uid
name@en
}
}
me2(func: uid(1001)) {
uid
name
age
}
me3(func: uid(1003)) {
uid
name@en
}
me4(func: uid(1002)) {
uid
name
age
}
}`)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
// Now lets delete the edge between Alice and Bob.
// Also lets delete the location for Alice.
p2 := Person{
Uid: "1000",
Location: "",
Friends: []Person{Person{Uid: "1001"}},
}
mu = &protos.Mutation{}
pb, err = json.Marshal(p2)
if err != nil {
log.Fatal(err)
}
mu.DeleteJson = pb
mu.CommitImmediately = true
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
resp, err = dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
Me2 []Person `json:"me2"`
Me3 []School `json:"me3"`
Me4 []Person `json:"me4"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
fmt.Printf("Resp: %+v\n", r)
}
Output:
Example (DeleteNode) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
// In this test we check S * * deletion.
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Friends []*Person `json:"friend,omitempty"`
}
p := Person{
Uid: "1000",
Name: "Alice",
Age: 26,
Married: true,
Friends: []*Person{&Person{
Uid: "1001",
Name: "Bob",
Age: 24,
}, &Person{
Uid: "1002",
Name: "Charlie",
Age: 29,
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
q := fmt.Sprintf(`{
me(func: uid(1000)) {
uid
name
age
married
friend {
uid
name
age
}
}
me2(func: uid(1001)) {
uid
name
age
}
me3(func: uid(1002)) {
uid
name
age
}
}`)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
Me2 []Person `json:"me2"`
Me3 []Person `json:"me3"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
fmt.Printf("Resp after SetObject: %+v\n", r)
// Now lets try to delete Alice. This won't delete Bob and Charlie but just remove the
// connection between Alice and them.
p2 := Person{
Uid: "1000",
}
mu = &protos.Mutation{
CommitImmediately: true,
}
pb, err = json.Marshal(p2)
if err != nil {
log.Fatal(err)
}
mu.DeleteJson = pb
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
resp, err = dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Resp after deleting node: %+v\n", r)
}
Output:
Example (DeletePredicate) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Friends []Person `json:"friend,omitempty"`
}
p := Person{
Uid: "1000",
Name: "Alice",
Age: 26,
Married: true,
Friends: []Person{Person{
Uid: "1001",
Name: "Bob",
Age: 24,
}, Person{
Uid: "1002",
Name: "Charlie",
Age: 29,
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
q := fmt.Sprintf(`{
me(func: uid(1000)) {
uid
name
age
married
friend {
uid
name
age
}
}
}`)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Response after SetObject: %+v\n\n", r)
op = &protos.Operation{
DropAttr: "friend",
}
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
op.DropAttr = "married"
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
// Also lets run the query again to verify that predicate data was deleted.
resp, err = dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
// Alice should have no friends and only two attributes now.
fmt.Printf("Response after deletion: %+v\n", r)
}
Output:
func (*Txn) Query ¶
Query sends a query to one of the connected dgraph instances. If no mutations need to be made in the same transaction, it's convenient to chain the method, e.g. NewTxn().Query(ctx, "...").
Example (Unmarshal) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
type School struct {
Name string `json:"name,omitempty"`
}
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
Age int `json:"age,omitempty"`
Married bool `json:"married,omitempty"`
Raw []byte `json:"raw_bytes,omitempty"`
Friends []Person `json:"friend,omitempty"`
School []School `json:"school,omitempty"`
}
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
// While setting an object if a struct has a Uid then its properties in the graph are updated
// else a new node is created.
// In the example below new nodes for Alice and Charlie and school are created (since they dont
// have a Uid). Alice is also connected via the friend edge to an existing node with Uid
// 1000(Bob). We also set Name and Age values for this node with Uid 1000.
p := Person{
Name: "Alice",
Age: 26,
Married: true,
Raw: []byte("raw_bytes"),
Friends: []Person{{
Uid: "1000",
Name: "Bob",
Age: 24,
}, {
Name: "Charlie",
Age: 29,
}},
School: []School{{
Name: "Crown Public School",
}},
}
op := &protos.Operation{}
op.Schema = `
age: int .
married: bool .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
txn := dg.NewTxn()
mu := &protos.Mutation{}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
mu.CommitImmediately = true
assigned, err := txn.Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
// Assigned uids for nodes which were created would be returned in the resp.AssignedUids map.
puid := assigned.Uids["blank-0"]
q := fmt.Sprintf(`{
me(func: uid(%s)) {
uid
name
age
loc
raw_bytes
married
friend {
uid
name
age
}
school {
name
}
}
}`, puid)
resp, err := dg.NewTxn().Query(ctx, q)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Me: %+v\n", r.Me)
}
Output:
Example (Variables) ¶
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/dgraph-io/dgraph/client"
"github.com/dgraph-io/dgraph/protos"
"github.com/dgraph-io/dgraph/x"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("127.0.0.1:9080", grpc.WithInsecure())
x.Checkf(err, "While trying to dial gRPC")
defer conn.Close()
dc := protos.NewDgraphClient(conn)
dg := client.NewDgraphClient(dc)
type Person struct {
Uid string `json:"uid,omitempty"`
Name string `json:"name,omitempty"`
}
op := &protos.Operation{}
op.Schema = `
name: string @index(exact) .
`
ctx := context.Background()
err = dg.Alter(ctx, op)
if err != nil {
log.Fatal(err)
}
p := Person{
Name: "Alice",
}
mu := &protos.Mutation{
CommitImmediately: true,
}
pb, err := json.Marshal(p)
if err != nil {
log.Fatal(err)
}
mu.SetJson = pb
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
log.Fatal(err)
}
variables := make(map[string]string)
variables["$a"] = "Alice"
q := `{
me(func: eq(name, $a)) {
name
}
}`
resp, err := dg.NewTxn().QueryWithVars(ctx, q, variables)
if err != nil {
log.Fatal(err)
}
type Root struct {
Me []Person `json:"me"`
}
var r Root
err = json.Unmarshal(resp.Json, &r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Me: %+v\n", r.Me)
}
Output:
Source Files
Click to show internal directories.
Click to hide internal directories.