id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,700 | arangodb/go-driver | database_impl.go | newDatabase | func newDatabase(name string, conn Connection) (Database, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &database{
name: name,
conn: conn,
}, nil
} | go | func newDatabase(name string, conn Connection) (Database, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &database{
name: name,
conn: conn,
}, nil
} | [
"func",
"newDatabase",
"(",
"name",
"string",
",",
"conn",
"Connection",
")",
"(",
"Database",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
"\"",
... | // newDatabase creates a new Database implementation. | [
"newDatabase",
"creates",
"a",
"new",
"Database",
"implementation",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_impl.go#L32-L43 |
5,701 | arangodb/go-driver | database_impl.go | Info | func (d *database) Info(ctx context.Context) (DatabaseInfo, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/database/current"))
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return DatabaseInfo{}, WithStack(err)
}
var data DatabaseInfo
if err := resp.ParseBody("result", &data); err != nil {
return DatabaseInfo{}, WithStack(err)
}
return data, nil
} | go | func (d *database) Info(ctx context.Context) (DatabaseInfo, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/database/current"))
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return DatabaseInfo{}, WithStack(err)
}
var data DatabaseInfo
if err := resp.ParseBody("result", &data); err != nil {
return DatabaseInfo{}, WithStack(err)
}
return data, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Info",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"DatabaseInfo",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"d",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",... | // Info fetches information about the database. | [
"Info",
"fetches",
"information",
"about",
"the",
"database",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_impl.go#L63-L81 |
5,702 | arangodb/go-driver | database_impl.go | Remove | func (d *database) Remove(ctx context.Context) error {
req, err := d.conn.NewRequest("DELETE", path.Join("_db/_system/_api/database", pathEscape(d.name)))
if err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | func (d *database) Remove(ctx context.Context) error {
req, err := d.conn.NewRequest("DELETE", path.Join("_db/_system/_api/database", pathEscape(d.name)))
if err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Remove",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"req",
",",
"err",
":=",
"d",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"\"",
"\"",
",",
"pathEscape... | // Remove removes the entire database.
// If the database does not exist, a NotFoundError is returned. | [
"Remove",
"removes",
"the",
"entire",
"database",
".",
"If",
"the",
"database",
"does",
"not",
"exist",
"a",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_impl.go#L113-L126 |
5,703 | arangodb/go-driver | database_impl.go | Query | func (d *database) Query(ctx context.Context, query string, bindVars map[string]interface{}) (Cursor, error) {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/cursor"))
if err != nil {
return nil, WithStack(err)
}
input := queryRequest{
Query: query,
BindVars: bindVars,
}
input.applyContextSettings(ctx)
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
cs := applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
var data cursorData
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
col, err := newCursor(data, resp.Endpoint(), d, cs.AllowDirtyReads)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | go | func (d *database) Query(ctx context.Context, query string, bindVars map[string]interface{}) (Cursor, error) {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/cursor"))
if err != nil {
return nil, WithStack(err)
}
input := queryRequest{
Query: query,
BindVars: bindVars,
}
input.applyContextSettings(ctx)
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
cs := applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
var data cursorData
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
col, err := newCursor(data, resp.Endpoint(), d, cs.AllowDirtyReads)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Query",
"(",
"ctx",
"context",
".",
"Context",
",",
"query",
"string",
",",
"bindVars",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"Cursor",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
... | // Query performs an AQL query, returning a cursor used to iterate over the returned documents. | [
"Query",
"performs",
"an",
"AQL",
"query",
"returning",
"a",
"cursor",
"used",
"to",
"iterate",
"over",
"the",
"returned",
"documents",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_impl.go#L129-L159 |
5,704 | arangodb/go-driver | database_impl.go | ValidateQuery | func (d *database) ValidateQuery(ctx context.Context, query string) error {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/query"))
if err != nil {
return WithStack(err)
}
input := parseQueryRequest{
Query: query,
}
if _, err := req.SetBody(input); err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | func (d *database) ValidateQuery(ctx context.Context, query string) error {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/query"))
if err != nil {
return WithStack(err)
}
input := parseQueryRequest{
Query: query,
}
if _, err := req.SetBody(input); err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"ValidateQuery",
"(",
"ctx",
"context",
".",
"Context",
",",
"query",
"string",
")",
"error",
"{",
"req",
",",
"err",
":=",
"d",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",... | // ValidateQuery validates an AQL query.
// When the query is valid, nil returned, otherwise an error is returned.
// The query is not executed. | [
"ValidateQuery",
"validates",
"an",
"AQL",
"query",
".",
"When",
"the",
"query",
"is",
"valid",
"nil",
"returned",
"otherwise",
"an",
"error",
"is",
"returned",
".",
"The",
"query",
"is",
"not",
"executed",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_impl.go#L164-L183 |
5,705 | arangodb/go-driver | client_databases_impl.go | Database | func (c *client) Database(ctx context.Context, name string) (Database, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_db", escapedName, "_api/database/current"))
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | go | func (c *client) Database(ctx context.Context, name string) (Database, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_db", escapedName, "_api/database/current"))
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Database",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"Database",
",",
"error",
")",
"{",
"escapedName",
":=",
"pathEscape",
"(",
"name",
")",
"\n",
"req",
",",
"err",
":=",
"c",
"... | // Database opens a connection to an existing database.
// If no database with given name exists, an NotFoundError is returned. | [
"Database",
"opens",
"a",
"connection",
"to",
"an",
"existing",
"database",
".",
"If",
"no",
"database",
"with",
"given",
"name",
"exists",
"an",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_databases_impl.go#L32-L50 |
5,706 | arangodb/go-driver | client_databases_impl.go | AccessibleDatabases | func (c *client) AccessibleDatabases(ctx context.Context) ([]Database, error) {
result, err := listDatabases(ctx, c.conn, path.Join("/_db/_system/_api/database/user"))
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | go | func (c *client) AccessibleDatabases(ctx context.Context) ([]Database, error) {
result, err := listDatabases(ctx, c.conn, path.Join("/_db/_system/_api/database/user"))
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"AccessibleDatabases",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"Database",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"listDatabases",
"(",
"ctx",
",",
"c",
".",
"conn",
",",
"path",
... | // AccessibleDatabases returns a list of all databases that can be accessed by the authenticated user. | [
"AccessibleDatabases",
"returns",
"a",
"list",
"of",
"all",
"databases",
"that",
"can",
"be",
"accessed",
"by",
"the",
"authenticated",
"user",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_databases_impl.go#L86-L92 |
5,707 | arangodb/go-driver | client_databases_impl.go | listDatabases | func listDatabases(ctx context.Context, conn Connection, path string) ([]Database, error) {
req, err := conn.NewRequest("GET", path)
if err != nil {
return nil, WithStack(err)
}
resp, err := conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getDatabaseResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Database, 0, len(data.Result))
for _, name := range data.Result {
db, err := newDatabase(name, conn)
if err != nil {
return nil, WithStack(err)
}
result = append(result, db)
}
return result, nil
} | go | func listDatabases(ctx context.Context, conn Connection, path string) ([]Database, error) {
req, err := conn.NewRequest("GET", path)
if err != nil {
return nil, WithStack(err)
}
resp, err := conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getDatabaseResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Database, 0, len(data.Result))
for _, name := range data.Result {
db, err := newDatabase(name, conn)
if err != nil {
return nil, WithStack(err)
}
result = append(result, db)
}
return result, nil
} | [
"func",
"listDatabases",
"(",
"ctx",
"context",
".",
"Context",
",",
"conn",
"Connection",
",",
"path",
"string",
")",
"(",
"[",
"]",
"Database",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path"... | // listDatabases returns a list of databases using a GET to the given path. | [
"listDatabases",
"returns",
"a",
"list",
"of",
"databases",
"using",
"a",
"GET",
"to",
"the",
"given",
"path",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_databases_impl.go#L95-L120 |
5,708 | arangodb/go-driver | client_databases_impl.go | CreateDatabase | func (c *client) CreateDatabase(ctx context.Context, name string, options *CreateDatabaseOptions) (Database, error) {
input := struct {
CreateDatabaseOptions
Name string `json:"name"`
}{
Name: name,
}
if options != nil {
input.CreateDatabaseOptions = *options
}
req, err := c.conn.NewRequest("POST", path.Join("_db/_system/_api/database"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | go | func (c *client) CreateDatabase(ctx context.Context, name string, options *CreateDatabaseOptions) (Database, error) {
input := struct {
CreateDatabaseOptions
Name string `json:"name"`
}{
Name: name,
}
if options != nil {
input.CreateDatabaseOptions = *options
}
req, err := c.conn.NewRequest("POST", path.Join("_db/_system/_api/database"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"CreateDatabase",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"options",
"*",
"CreateDatabaseOptions",
")",
"(",
"Database",
",",
"error",
")",
"{",
"input",
":=",
"struct",
"{",
"CreateDatabaseO... | // CreateDatabase creates a new database with given name and opens a connection to it.
// If the a database with given name already exists, a DuplicateError is returned. | [
"CreateDatabase",
"creates",
"a",
"new",
"database",
"with",
"given",
"name",
"and",
"opens",
"a",
"connection",
"to",
"it",
".",
"If",
"the",
"a",
"database",
"with",
"given",
"name",
"already",
"exists",
"a",
"DuplicateError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_databases_impl.go#L124-L153 |
5,709 | arangodb/go-driver | client_cluster_impl.go | Cluster | func (c *client) Cluster(ctx context.Context) (Cluster, error) {
role, err := c.ServerRole(ctx)
if err != nil {
return nil, WithStack(err)
}
if role == ServerRoleSingle || role == ServerRoleSingleActive || role == ServerRoleSinglePassive {
// Standalone server, this is wrong
return nil, WithStack(newArangoError(412, 0, "Cluster expected, found SINGLE server"))
}
cl, err := newCluster(c.conn)
if err != nil {
return nil, WithStack(err)
}
return cl, nil
} | go | func (c *client) Cluster(ctx context.Context) (Cluster, error) {
role, err := c.ServerRole(ctx)
if err != nil {
return nil, WithStack(err)
}
if role == ServerRoleSingle || role == ServerRoleSingleActive || role == ServerRoleSinglePassive {
// Standalone server, this is wrong
return nil, WithStack(newArangoError(412, 0, "Cluster expected, found SINGLE server"))
}
cl, err := newCluster(c.conn)
if err != nil {
return nil, WithStack(err)
}
return cl, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Cluster",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"Cluster",
",",
"error",
")",
"{",
"role",
",",
"err",
":=",
"c",
".",
"ServerRole",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // Cluster provides access to cluster wide specific operations.
// To use this interface, an ArangoDB cluster is required.
// If this method is a called without a cluster, a PreconditionFailed error is returned. | [
"Cluster",
"provides",
"access",
"to",
"cluster",
"wide",
"specific",
"operations",
".",
"To",
"use",
"this",
"interface",
"an",
"ArangoDB",
"cluster",
"is",
"required",
".",
"If",
"this",
"method",
"is",
"a",
"called",
"without",
"a",
"cluster",
"a",
"Preco... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_cluster_impl.go#L32-L46 |
5,710 | arangodb/go-driver | replication_impl.go | CreateBatch | func (c *client) CreateBatch(ctx context.Context, db Database, serverID int64, ttl time.Duration) (Batch, error) {
req, err := c.conn.NewRequest("POST", path.Join("_db", db.Name(), "_api/replication/batch"))
if err != nil {
return nil, WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(serverID, 10))
params := struct {
TTL float64 `json:"ttl"`
}{TTL: ttl.Seconds()} // just use a default ttl value
req, err = req.SetBody(params)
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var batch batchMetadata
if err := resp.ParseBody("", &batch); err != nil {
return nil, WithStack(err)
}
batch.cl = c
batch.serverID = serverID
batch.database = db.Name()
return &batch, nil
} | go | func (c *client) CreateBatch(ctx context.Context, db Database, serverID int64, ttl time.Duration) (Batch, error) {
req, err := c.conn.NewRequest("POST", path.Join("_db", db.Name(), "_api/replication/batch"))
if err != nil {
return nil, WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(serverID, 10))
params := struct {
TTL float64 `json:"ttl"`
}{TTL: ttl.Seconds()} // just use a default ttl value
req, err = req.SetBody(params)
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var batch batchMetadata
if err := resp.ParseBody("", &batch); err != nil {
return nil, WithStack(err)
}
batch.cl = c
batch.serverID = serverID
batch.database = db.Name()
return &batch, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"CreateBatch",
"(",
"ctx",
"context",
".",
"Context",
",",
"db",
"Database",
",",
"serverID",
"int64",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"Batch",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"c... | // CreateBatch creates a "batch" to prevent WAL file removal and to take a snapshot | [
"CreateBatch",
"creates",
"a",
"batch",
"to",
"prevent",
"WAL",
"file",
"removal",
"and",
"to",
"take",
"a",
"snapshot"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/replication_impl.go#L48-L76 |
5,711 | arangodb/go-driver | replication_impl.go | Extend | func (b batchMetadata) Extend(ctx context.Context, ttl time.Duration) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 0) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("PUT", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(b.serverID, 10))
input := struct {
TTL int64 `json:"ttl"`
}{
TTL: int64(ttl.Seconds()),
}
req, err = req.SetBody(input)
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | go | func (b batchMetadata) Extend(ctx context.Context, ttl time.Duration) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 0) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("PUT", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(b.serverID, 10))
input := struct {
TTL int64 `json:"ttl"`
}{
TTL: int64(ttl.Seconds()),
}
req, err = req.SetBody(input)
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"b",
"batchMetadata",
")",
"Extend",
"(",
"ctx",
"context",
".",
"Context",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"!",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"b",
".",
"closed",
",",
"0",
",",
"0",
")",
... | // Extend the lifetime of an existing batch on the server | [
"Extend",
"the",
"lifetime",
"of",
"an",
"existing",
"batch",
"on",
"the",
"server"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/replication_impl.go#L110-L137 |
5,712 | arangodb/go-driver | replication_impl.go | Delete | func (b *batchMetadata) Delete(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 1) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("DELETE", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | go | func (b *batchMetadata) Delete(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 1) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("DELETE", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"b",
"*",
"batchMetadata",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"!",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"b",
".",
"closed",
",",
"0",
",",
"1",
")",
"{",
"return",
"WithStack",
"(",
... | // Delete an existing dump batch | [
"Delete",
"an",
"existing",
"dump",
"batch"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/replication_impl.go#L140-L157 |
5,713 | arangodb/go-driver | vst/connection.go | NewConnection | func NewConnection(config ConnectionConfig) (driver.Connection, error) {
c, err := cluster.NewConnection(config.ConnectionConfig, func(endpoint string) (driver.Connection, error) {
conn, err := newVSTConnection(endpoint, config)
if err != nil {
return nil, driver.WithStack(err)
}
return conn, nil
}, config.Endpoints)
if err != nil {
return nil, driver.WithStack(err)
}
return c, nil
} | go | func NewConnection(config ConnectionConfig) (driver.Connection, error) {
c, err := cluster.NewConnection(config.ConnectionConfig, func(endpoint string) (driver.Connection, error) {
conn, err := newVSTConnection(endpoint, config)
if err != nil {
return nil, driver.WithStack(err)
}
return conn, nil
}, config.Endpoints)
if err != nil {
return nil, driver.WithStack(err)
}
return c, nil
} | [
"func",
"NewConnection",
"(",
"config",
"ConnectionConfig",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"cluster",
".",
"NewConnection",
"(",
"config",
".",
"ConnectionConfig",
",",
"func",
"(",
"endpoint",
"string",... | // NewConnection creates a new Velocystream connection based on the given configuration settings. | [
"NewConnection",
"creates",
"a",
"new",
"Velocystream",
"connection",
"based",
"on",
"the",
"given",
"configuration",
"settings",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/connection.go#L70-L82 |
5,714 | arangodb/go-driver | vst/connection.go | newVSTConnection | func newVSTConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
hostAddr := u.Host
tlsConfig := config.TLSConfig
switch strings.ToLower(u.Scheme) {
case "http":
tlsConfig = nil
case "https":
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
}
c := &vstConnection{
endpoint: *u,
transport: protocol.NewTransport(hostAddr, tlsConfig, config.Transport),
}
return c, nil
} | go | func newVSTConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
hostAddr := u.Host
tlsConfig := config.TLSConfig
switch strings.ToLower(u.Scheme) {
case "http":
tlsConfig = nil
case "https":
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
}
c := &vstConnection{
endpoint: *u,
transport: protocol.NewTransport(hostAddr, tlsConfig, config.Transport),
}
return c, nil
} | [
"func",
"newVSTConnection",
"(",
"endpoint",
"string",
",",
"config",
"ConnectionConfig",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"endpoint",
"=",
"util",
".",
"FixupEndpointURLScheme",
"(",
"endpoint",
")",
"\n",
"u",
",",
"err",
":="... | // newVSTConnection creates a new Velocystream connection for a single endpoint and the remainder of the given configuration settings. | [
"newVSTConnection",
"creates",
"a",
"new",
"Velocystream",
"connection",
"for",
"a",
"single",
"endpoint",
"and",
"the",
"remainder",
"of",
"the",
"given",
"configuration",
"settings",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/connection.go#L85-L106 |
5,715 | arangodb/go-driver | vst/protocol/message.go | closeResponseChan | func (m *Message) closeResponseChan() {
if atomic.CompareAndSwapInt32(&m.responseChanClosed, 0, 1) {
if ch := m.responseChan; ch != nil {
m.responseChan = nil
close(ch)
}
}
} | go | func (m *Message) closeResponseChan() {
if atomic.CompareAndSwapInt32(&m.responseChanClosed, 0, 1) {
if ch := m.responseChan; ch != nil {
m.responseChan = nil
close(ch)
}
}
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"closeResponseChan",
"(",
")",
"{",
"if",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"m",
".",
"responseChanClosed",
",",
"0",
",",
"1",
")",
"{",
"if",
"ch",
":=",
"m",
".",
"responseChan",
";",
"ch",
"!="... | // closes the response channel if needed. | [
"closes",
"the",
"response",
"channel",
"if",
"needed",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message.go#L44-L51 |
5,716 | arangodb/go-driver | vst/protocol/message.go | addChunk | func (m *Message) addChunk(c chunk) {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
m.chunks = append(m.chunks, c)
if c.IsFirst() {
m.numberOfChunks = c.NumberOfChunks()
}
} | go | func (m *Message) addChunk(c chunk) {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
m.chunks = append(m.chunks, c)
if c.IsFirst() {
m.numberOfChunks = c.NumberOfChunks()
}
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"addChunk",
"(",
"c",
"chunk",
")",
"{",
"m",
".",
"chunksMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"chunksMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"m",
".",
"chunks",
"=",
"append",
"(",
"m",
... | // addChunk adds the given chunks to the list of chunks of the message.
// If the given chunk is the first chunk, the expected number of chunks is recorded. | [
"addChunk",
"adds",
"the",
"given",
"chunks",
"to",
"the",
"list",
"of",
"chunks",
"of",
"the",
"message",
".",
"If",
"the",
"given",
"chunk",
"is",
"the",
"first",
"chunk",
"the",
"expected",
"number",
"of",
"chunks",
"is",
"recorded",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message.go#L66-L74 |
5,717 | arangodb/go-driver | vst/protocol/message.go | assemble | func (m *Message) assemble() bool {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
if m.Data != nil {
// Already assembled
return true
}
if m.numberOfChunks == 0 {
// We don't have the first chunk yet
return false
}
if len(m.chunks) < int(m.numberOfChunks) {
// Not all chunks have arrived yet
return false
}
// Fast path, only 1 chunk
if m.numberOfChunks == 1 {
m.Data = m.chunks[0].Data
return true
}
// Sort chunks by index
sort.Sort(chunkByIndex(m.chunks))
// Build data buffer and copy chunks into it
data := make([]byte, m.chunks[0].MessageLength)
offset := 0
for _, c := range m.chunks {
copy(data[offset:], c.Data)
offset += len(c.Data)
}
m.Data = data
return true
} | go | func (m *Message) assemble() bool {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
if m.Data != nil {
// Already assembled
return true
}
if m.numberOfChunks == 0 {
// We don't have the first chunk yet
return false
}
if len(m.chunks) < int(m.numberOfChunks) {
// Not all chunks have arrived yet
return false
}
// Fast path, only 1 chunk
if m.numberOfChunks == 1 {
m.Data = m.chunks[0].Data
return true
}
// Sort chunks by index
sort.Sort(chunkByIndex(m.chunks))
// Build data buffer and copy chunks into it
data := make([]byte, m.chunks[0].MessageLength)
offset := 0
for _, c := range m.chunks {
copy(data[offset:], c.Data)
offset += len(c.Data)
}
m.Data = data
return true
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"assemble",
"(",
")",
"bool",
"{",
"m",
".",
"chunksMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"chunksMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"Data",
"!=",
"nil",
"{",
"// Alrea... | // assemble tries to assemble the message data from all chunks.
// If not all chunks are available yet, nothing is done and false
// is returned.
// If all chunks are available, the Data field is build and set and true is returned. | [
"assemble",
"tries",
"to",
"assemble",
"the",
"message",
"data",
"from",
"all",
"chunks",
".",
"If",
"not",
"all",
"chunks",
"are",
"available",
"yet",
"nothing",
"is",
"done",
"and",
"false",
"is",
"returned",
".",
"If",
"all",
"chunks",
"are",
"available... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message.go#L80-L115 |
5,718 | arangodb/go-driver | cluster.go | IsReady | func (i DatabaseInventory) IsReady() bool {
for _, c := range i.Collections {
if !c.IsReady {
return false
}
}
return true
} | go | func (i DatabaseInventory) IsReady() bool {
for _, c := range i.Collections {
if !c.IsReady {
return false
}
}
return true
} | [
"func",
"(",
"i",
"DatabaseInventory",
")",
"IsReady",
"(",
")",
"bool",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"i",
".",
"Collections",
"{",
"if",
"!",
"c",
".",
"IsReady",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
... | // IsReady returns true if the IsReady flag of all collections is set. | [
"IsReady",
"returns",
"true",
"if",
"the",
"IsReady",
"flag",
"of",
"all",
"collections",
"is",
"set",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L124-L131 |
5,719 | arangodb/go-driver | cluster.go | PlanVersion | func (i DatabaseInventory) PlanVersion() int64 {
if len(i.Collections) == 0 {
return 0
}
return i.Collections[0].PlanVersion
} | go | func (i DatabaseInventory) PlanVersion() int64 {
if len(i.Collections) == 0 {
return 0
}
return i.Collections[0].PlanVersion
} | [
"func",
"(",
"i",
"DatabaseInventory",
")",
"PlanVersion",
"(",
")",
"int64",
"{",
"if",
"len",
"(",
"i",
".",
"Collections",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"i",
".",
"Collections",
"[",
"0",
"]",
".",
"PlanVersion",
... | // PlanVersion returns the plan version of the first collection in the given inventory. | [
"PlanVersion",
"returns",
"the",
"plan",
"version",
"of",
"the",
"first",
"collection",
"in",
"the",
"given",
"inventory",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L134-L139 |
5,720 | arangodb/go-driver | cluster.go | CollectionByName | func (i DatabaseInventory) CollectionByName(name string) (InventoryCollection, bool) {
for _, c := range i.Collections {
if c.Parameters.Name == name {
return c, true
}
}
return InventoryCollection{}, false
} | go | func (i DatabaseInventory) CollectionByName(name string) (InventoryCollection, bool) {
for _, c := range i.Collections {
if c.Parameters.Name == name {
return c, true
}
}
return InventoryCollection{}, false
} | [
"func",
"(",
"i",
"DatabaseInventory",
")",
"CollectionByName",
"(",
"name",
"string",
")",
"(",
"InventoryCollection",
",",
"bool",
")",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"i",
".",
"Collections",
"{",
"if",
"c",
".",
"Parameters",
".",
"Name",
... | // CollectionByName returns the InventoryCollection with given name.
// Return false if not found. | [
"CollectionByName",
"returns",
"the",
"InventoryCollection",
"with",
"given",
"name",
".",
"Return",
"false",
"if",
"not",
"found",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L143-L150 |
5,721 | arangodb/go-driver | cluster.go | ViewByName | func (i DatabaseInventory) ViewByName(name string) (InventoryView, bool) {
for _, v := range i.Views {
if v.Name == name {
return v, true
}
}
return InventoryView{}, false
} | go | func (i DatabaseInventory) ViewByName(name string) (InventoryView, bool) {
for _, v := range i.Views {
if v.Name == name {
return v, true
}
}
return InventoryView{}, false
} | [
"func",
"(",
"i",
"DatabaseInventory",
")",
"ViewByName",
"(",
"name",
"string",
")",
"(",
"InventoryView",
",",
"bool",
")",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"i",
".",
"Views",
"{",
"if",
"v",
".",
"Name",
"==",
"name",
"{",
"return",
"v"... | // ViewByName returns the InventoryView with given name.
// Return false if not found. | [
"ViewByName",
"returns",
"the",
"InventoryView",
"with",
"given",
"name",
".",
"Return",
"false",
"if",
"not",
"found",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L154-L161 |
5,722 | arangodb/go-driver | cluster.go | IndexByFieldsAndType | func (i InventoryCollection) IndexByFieldsAndType(fields []string, indexType string) (InventoryIndex, bool) {
for _, idx := range i.Indexes {
if idx.Type == indexType && idx.FieldsEqual(fields) {
return idx, true
}
}
return InventoryIndex{}, false
} | go | func (i InventoryCollection) IndexByFieldsAndType(fields []string, indexType string) (InventoryIndex, bool) {
for _, idx := range i.Indexes {
if idx.Type == indexType && idx.FieldsEqual(fields) {
return idx, true
}
}
return InventoryIndex{}, false
} | [
"func",
"(",
"i",
"InventoryCollection",
")",
"IndexByFieldsAndType",
"(",
"fields",
"[",
"]",
"string",
",",
"indexType",
"string",
")",
"(",
"InventoryIndex",
",",
"bool",
")",
"{",
"for",
"_",
",",
"idx",
":=",
"range",
"i",
".",
"Indexes",
"{",
"if",... | // IndexByFieldsAndType returns the InventoryIndex with given fields & type.
// Return false if not found. | [
"IndexByFieldsAndType",
"returns",
"the",
"InventoryIndex",
"with",
"given",
"fields",
"&",
"type",
".",
"Return",
"false",
"if",
"not",
"found",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L175-L182 |
5,723 | arangodb/go-driver | cluster.go | FieldsEqual | func (i InventoryIndex) FieldsEqual(fields []string) bool {
return stringSliceEqualsIgnoreOrder(i.Fields, fields)
} | go | func (i InventoryIndex) FieldsEqual(fields []string) bool {
return stringSliceEqualsIgnoreOrder(i.Fields, fields)
} | [
"func",
"(",
"i",
"InventoryIndex",
")",
"FieldsEqual",
"(",
"fields",
"[",
"]",
"string",
")",
"bool",
"{",
"return",
"stringSliceEqualsIgnoreOrder",
"(",
"i",
".",
"Fields",
",",
"fields",
")",
"\n",
"}"
] | // FieldsEqual returns true when the given fields list equals the
// Fields list in the InventoryIndex.
// The order of fields is irrelevant. | [
"FieldsEqual",
"returns",
"true",
"when",
"the",
"given",
"fields",
"list",
"equals",
"the",
"Fields",
"list",
"in",
"the",
"InventoryIndex",
".",
"The",
"order",
"of",
"fields",
"is",
"irrelevant",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L239-L241 |
5,724 | arangodb/go-driver | cluster.go | stringSliceEqualsIgnoreOrder | func stringSliceEqualsIgnoreOrder(a, b []string) bool {
if len(a) != len(b) {
return false
}
bMap := make(map[string]struct{})
for _, x := range b {
bMap[x] = struct{}{}
}
for _, x := range a {
if _, found := bMap[x]; !found {
return false
}
}
return true
} | go | func stringSliceEqualsIgnoreOrder(a, b []string) bool {
if len(a) != len(b) {
return false
}
bMap := make(map[string]struct{})
for _, x := range b {
bMap[x] = struct{}{}
}
for _, x := range a {
if _, found := bMap[x]; !found {
return false
}
}
return true
} | [
"func",
"stringSliceEqualsIgnoreOrder",
"(",
"a",
",",
"b",
"[",
"]",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"a",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"bMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]... | // stringSliceEqualsIgnoreOrder returns true when the given lists contain the same elements.
// The order of elements is irrelevant. | [
"stringSliceEqualsIgnoreOrder",
"returns",
"true",
"when",
"the",
"given",
"lists",
"contain",
"the",
"same",
"elements",
".",
"The",
"order",
"of",
"elements",
"is",
"irrelevant",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster.go#L258-L272 |
5,725 | arangodb/go-driver | vst/protocol/message_store.go | Size | func (s *messageStore) Size() int {
s.mutex.RLock()
defer s.mutex.RUnlock()
return len(s.messages)
} | go | func (s *messageStore) Size() int {
s.mutex.RLock()
defer s.mutex.RUnlock()
return len(s.messages)
} | [
"func",
"(",
"s",
"*",
"messageStore",
")",
"Size",
"(",
")",
"int",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"len",
"(",
"s",
".",
"messages",
")",
"\n",
"}"
... | // Size returns the number of messages in this store. | [
"Size",
"returns",
"the",
"number",
"of",
"messages",
"in",
"this",
"store",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message_store.go#L36-L41 |
5,726 | arangodb/go-driver | vst/protocol/message_store.go | Get | func (s *messageStore) Get(id uint64) *Message {
s.mutex.RLock()
defer s.mutex.RUnlock()
m, ok := s.messages[id]
if ok {
return m
}
return nil
} | go | func (s *messageStore) Get(id uint64) *Message {
s.mutex.RLock()
defer s.mutex.RUnlock()
m, ok := s.messages[id]
if ok {
return m
}
return nil
} | [
"func",
"(",
"s",
"*",
"messageStore",
")",
"Get",
"(",
"id",
"uint64",
")",
"*",
"Message",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"m",
",",
"ok",
":=",
"s",
".",
"... | // Get returns the message with given id, or nil if not found | [
"Get",
"returns",
"the",
"message",
"with",
"given",
"id",
"or",
"nil",
"if",
"not",
"found"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message_store.go#L44-L53 |
5,727 | arangodb/go-driver | vst/protocol/message_store.go | Add | func (s *messageStore) Add(id uint64) *Message {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.messages == nil {
s.messages = make(map[uint64]*Message)
}
if _, ok := s.messages[id]; ok {
panic(fmt.Sprintf("ID %v is not unique", id))
}
m := &Message{
ID: id,
responseChan: make(chan Message),
}
s.messages[id] = m
return m
} | go | func (s *messageStore) Add(id uint64) *Message {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.messages == nil {
s.messages = make(map[uint64]*Message)
}
if _, ok := s.messages[id]; ok {
panic(fmt.Sprintf("ID %v is not unique", id))
}
m := &Message{
ID: id,
responseChan: make(chan Message),
}
s.messages[id] = m
return m
} | [
"func",
"(",
"s",
"*",
"messageStore",
")",
"Add",
"(",
"id",
"uint64",
")",
"*",
"Message",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"messages",
"==",
"ni... | // Add adds a new message to the store with given ID.
// If the ID is not unique this function will panic. | [
"Add",
"adds",
"a",
"new",
"message",
"to",
"the",
"store",
"with",
"given",
"ID",
".",
"If",
"the",
"ID",
"is",
"not",
"unique",
"this",
"function",
"will",
"panic",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message_store.go#L57-L74 |
5,728 | arangodb/go-driver | vst/protocol/message_store.go | Remove | func (s *messageStore) Remove(id uint64) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.messages, id)
} | go | func (s *messageStore) Remove(id uint64) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.messages, id)
} | [
"func",
"(",
"s",
"*",
"messageStore",
")",
"Remove",
"(",
"id",
"uint64",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"s",
".",
"messages",
",",
"id",
")... | // Remove removes the message with given ID from the store. | [
"Remove",
"removes",
"the",
"message",
"with",
"given",
"ID",
"from",
"the",
"store",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message_store.go#L77-L82 |
5,729 | arangodb/go-driver | vst/protocol/message_store.go | ForEach | func (s *messageStore) ForEach(cb func(*Message)) {
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, m := range s.messages {
cb(m)
}
} | go | func (s *messageStore) ForEach(cb func(*Message)) {
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, m := range s.messages {
cb(m)
}
} | [
"func",
"(",
"s",
"*",
"messageStore",
")",
"ForEach",
"(",
"cb",
"func",
"(",
"*",
"Message",
")",
")",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"m",
... | // ForEach calls the given function for each message in the store. | [
"ForEach",
"calls",
"the",
"given",
"function",
"for",
"each",
"message",
"in",
"the",
"store",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/message_store.go#L85-L92 |
5,730 | arangodb/go-driver | edge_collection_documents_impl.go | ReadDocument | func (c *edgeCollection) ReadDocument(ctx context.Context, key string, result interface{}) (DocumentMeta, error) {
meta, _, err := c.readDocument(ctx, key, result)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | func (c *edgeCollection) ReadDocument(ctx context.Context, key string, result interface{}) (DocumentMeta, error) {
meta, _, err := c.readDocument(ctx, key, result)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | [
"func",
"(",
"c",
"*",
"edgeCollection",
")",
"ReadDocument",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
",",
"result",
"interface",
"{",
"}",
")",
"(",
"DocumentMeta",
",",
"error",
")",
"{",
"meta",
",",
"_",
",",
"err",
":=",
"c"... | // ReadDocument reads a single document with given key from the collection.
// The document data is stored into result, the document meta data is returned.
// If no document exists with given key, a NotFoundError is returned. | [
"ReadDocument",
"reads",
"a",
"single",
"document",
"with",
"given",
"key",
"from",
"the",
"collection",
".",
"The",
"document",
"data",
"is",
"stored",
"into",
"result",
"the",
"document",
"meta",
"data",
"is",
"returned",
".",
"If",
"no",
"document",
"exis... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/edge_collection_documents_impl.go#L45-L51 |
5,731 | arangodb/go-driver | edge_collection_documents_impl.go | UpdateDocument | func (c *edgeCollection) UpdateDocument(ctx context.Context, key string, update interface{}) (DocumentMeta, error) {
meta, _, err := c.updateDocument(ctx, key, update)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | func (c *edgeCollection) UpdateDocument(ctx context.Context, key string, update interface{}) (DocumentMeta, error) {
meta, _, err := c.updateDocument(ctx, key, update)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | [
"func",
"(",
"c",
"*",
"edgeCollection",
")",
"UpdateDocument",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
",",
"update",
"interface",
"{",
"}",
")",
"(",
"DocumentMeta",
",",
"error",
")",
"{",
"meta",
",",
"_",
",",
"err",
":=",
"... | // UpdateDocument updates a single document with given key in the collection.
// The document meta data is returned.
// To return the NEW document, prepare a context with `WithReturnNew`.
// To return the OLD document, prepare a context with `WithReturnOld`.
// To wait until document has been synced to disk, prepare a context with `WithWaitForSync`.
// If no document exists with given key, a NotFoundError is returned. | [
"UpdateDocument",
"updates",
"a",
"single",
"document",
"with",
"given",
"key",
"in",
"the",
"collection",
".",
"The",
"document",
"meta",
"data",
"is",
"returned",
".",
"To",
"return",
"the",
"NEW",
"document",
"prepare",
"a",
"context",
"with",
"WithReturnNe... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/edge_collection_documents_impl.go#L233-L239 |
5,732 | arangodb/go-driver | edge_collection_documents_impl.go | getKeyFromDocument | func getKeyFromDocument(doc reflect.Value) (string, error) {
if doc.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document is nil"})
}
if doc.Kind() == reflect.Ptr {
doc = doc.Elem()
}
switch doc.Kind() {
case reflect.Struct:
structType := doc.Type()
fieldCount := structType.NumField()
for i := 0; i < fieldCount; i++ {
f := structType.Field(i)
tagParts := strings.Split(f.Tag.Get("json"), ",")
if tagParts[0] == "_key" {
// We found the _key field
keyVal := doc.Field(i)
return keyVal.String(), nil
}
}
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' field"})
case reflect.Map:
keyVal := doc.MapIndex(reflect.ValueOf("_key"))
if keyVal.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' entry"})
}
return keyVal.String(), nil
default:
return "", WithStack(InvalidArgumentError{Message: fmt.Sprintf("Document must be struct or map. Got %s", doc.Kind())})
}
} | go | func getKeyFromDocument(doc reflect.Value) (string, error) {
if doc.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document is nil"})
}
if doc.Kind() == reflect.Ptr {
doc = doc.Elem()
}
switch doc.Kind() {
case reflect.Struct:
structType := doc.Type()
fieldCount := structType.NumField()
for i := 0; i < fieldCount; i++ {
f := structType.Field(i)
tagParts := strings.Split(f.Tag.Get("json"), ",")
if tagParts[0] == "_key" {
// We found the _key field
keyVal := doc.Field(i)
return keyVal.String(), nil
}
}
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' field"})
case reflect.Map:
keyVal := doc.MapIndex(reflect.ValueOf("_key"))
if keyVal.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' entry"})
}
return keyVal.String(), nil
default:
return "", WithStack(InvalidArgumentError{Message: fmt.Sprintf("Document must be struct or map. Got %s", doc.Kind())})
}
} | [
"func",
"getKeyFromDocument",
"(",
"doc",
"reflect",
".",
"Value",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"doc",
".",
"IsNil",
"(",
")",
"{",
"return",
"\"",
"\"",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
"\"... | // getKeyFromDocument looks for a `_key` document in the given document and returns it. | [
"getKeyFromDocument",
"looks",
"for",
"a",
"_key",
"document",
"in",
"the",
"given",
"document",
"and",
"returns",
"it",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/edge_collection_documents_impl.go#L566-L596 |
5,733 | arangodb/go-driver | http/authentication.go | newAuthenticatedConnection | func newAuthenticatedConnection(conn driver.Connection, auth httpAuthentication) (driver.Connection, error) {
if conn == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "conn is nil"})
}
if auth == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "auth is nil"})
}
return &authenticatedConnection{
conn: conn,
auth: auth,
}, nil
} | go | func newAuthenticatedConnection(conn driver.Connection, auth httpAuthentication) (driver.Connection, error) {
if conn == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "conn is nil"})
}
if auth == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "auth is nil"})
}
return &authenticatedConnection{
conn: conn,
auth: auth,
}, nil
} | [
"func",
"newAuthenticatedConnection",
"(",
"conn",
"driver",
".",
"Connection",
",",
"auth",
"httpAuthentication",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"if",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"driver",
".",
"WithStack"... | // newAuthenticatedConnection creates a Connection that applies the given connection on the given underlying connection. | [
"newAuthenticatedConnection",
"creates",
"a",
"Connection",
"that",
"applies",
"the",
"given",
"connection",
"on",
"the",
"given",
"underlying",
"connection",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/authentication.go#L143-L154 |
5,734 | arangodb/go-driver | http/authentication.go | prepare | func (c *authenticatedConnection) prepare(ctx context.Context) error {
c.prepareMutex.Lock()
defer c.prepareMutex.Unlock()
if c.prepared == 0 {
// We need to prepare first
if err := c.auth.Prepare(ctx, c.conn); err != nil {
// Authentication failed
return driver.WithStack(err)
}
// We're now prepared
atomic.StoreInt32(&c.prepared, 1)
} else {
// We're already prepared, do nothing
}
return nil
} | go | func (c *authenticatedConnection) prepare(ctx context.Context) error {
c.prepareMutex.Lock()
defer c.prepareMutex.Unlock()
if c.prepared == 0 {
// We need to prepare first
if err := c.auth.Prepare(ctx, c.conn); err != nil {
// Authentication failed
return driver.WithStack(err)
}
// We're now prepared
atomic.StoreInt32(&c.prepared, 1)
} else {
// We're already prepared, do nothing
}
return nil
} | [
"func",
"(",
"c",
"*",
"authenticatedConnection",
")",
"prepare",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"c",
".",
"prepareMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"prepareMutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
... | // prepare calls Authentication.Prepare if needed. | [
"prepare",
"calls",
"Authentication",
".",
"Prepare",
"if",
"needed",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/authentication.go#L231-L246 |
5,735 | arangodb/go-driver | vst/protocol/transport.go | NewTransport | func NewTransport(hostAddr string, tlsConfig *tls.Config, config TransportConfig) *Transport {
if config.IdleConnTimeout == 0 {
config.IdleConnTimeout = DefaultIdleConnTimeout
}
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
return &Transport{
TransportConfig: config,
hostAddr: hostAddr,
tlsConfig: tlsConfig,
}
} | go | func NewTransport(hostAddr string, tlsConfig *tls.Config, config TransportConfig) *Transport {
if config.IdleConnTimeout == 0 {
config.IdleConnTimeout = DefaultIdleConnTimeout
}
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
return &Transport{
TransportConfig: config,
hostAddr: hostAddr,
tlsConfig: tlsConfig,
}
} | [
"func",
"NewTransport",
"(",
"hostAddr",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
",",
"config",
"TransportConfig",
")",
"*",
"Transport",
"{",
"if",
"config",
".",
"IdleConnTimeout",
"==",
"0",
"{",
"config",
".",
"IdleConnTimeout",
"=",
"Defa... | // NewTransport creates a new Transport for given address & tls settings. | [
"NewTransport",
"creates",
"a",
"new",
"Transport",
"for",
"given",
"address",
"&",
"tls",
"settings",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L69-L81 |
5,736 | arangodb/go-driver | vst/protocol/transport.go | CloseIdleConnections | func (c *Transport) CloseIdleConnections() (closed, remaining int) {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for i := 0; i < len(c.connections); {
conn := c.connections[i]
if conn.IsClosed() || conn.IsIdle(c.IdleConnTimeout) {
// Remove connection from list
c.connections = append(c.connections[:i], c.connections[i+1:]...)
// Close connection
go conn.Close()
closed++
} else {
i++
}
}
remaining = len(c.connections)
return closed, remaining
} | go | func (c *Transport) CloseIdleConnections() (closed, remaining int) {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for i := 0; i < len(c.connections); {
conn := c.connections[i]
if conn.IsClosed() || conn.IsIdle(c.IdleConnTimeout) {
// Remove connection from list
c.connections = append(c.connections[:i], c.connections[i+1:]...)
// Close connection
go conn.Close()
closed++
} else {
i++
}
}
remaining = len(c.connections)
return closed, remaining
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"CloseIdleConnections",
"(",
")",
"(",
"closed",
",",
"remaining",
"int",
")",
"{",
"c",
".",
"connMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"connMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
... | // CloseIdleConnections closes all connections which are closed or have been idle for more than the configured idle timeout. | [
"CloseIdleConnections",
"closes",
"all",
"connections",
"which",
"are",
"closed",
"or",
"have",
"been",
"idle",
"for",
"more",
"than",
"the",
"configured",
"idle",
"timeout",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L100-L119 |
5,737 | arangodb/go-driver | vst/protocol/transport.go | CloseAllConnections | func (c *Transport) CloseAllConnections() {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for _, conn := range c.connections {
// Close connection
go conn.Close()
}
} | go | func (c *Transport) CloseAllConnections() {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for _, conn := range c.connections {
// Close connection
go conn.Close()
}
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"CloseAllConnections",
"(",
")",
"{",
"c",
".",
"connMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"connMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"conn",
":=",
"range",
"c",
".",
... | // CloseAllConnections closes all connections. | [
"CloseAllConnections",
"closes",
"all",
"connections",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L122-L130 |
5,738 | arangodb/go-driver | vst/protocol/transport.go | SetOnConnectionCreated | func (c *Transport) SetOnConnectionCreated(handler func(context.Context, *Connection) error) {
c.onConnectionCreated = handler
} | go | func (c *Transport) SetOnConnectionCreated(handler func(context.Context, *Connection) error) {
c.onConnectionCreated = handler
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"SetOnConnectionCreated",
"(",
"handler",
"func",
"(",
"context",
".",
"Context",
",",
"*",
"Connection",
")",
"error",
")",
"{",
"c",
".",
"onConnectionCreated",
"=",
"handler",
"\n",
"}"
] | // SetOnConnectionCreated stores a callback function that is called every time a new connection has been created. | [
"SetOnConnectionCreated",
"stores",
"a",
"callback",
"function",
"that",
"is",
"called",
"every",
"time",
"a",
"new",
"connection",
"has",
"been",
"created",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L133-L135 |
5,739 | arangodb/go-driver | vst/protocol/transport.go | getConnection | func (c *Transport) getConnection(ctx context.Context) (*Connection, error) {
conn := c.getAvailableConnection()
if conn != nil {
return conn, nil
}
// No connections available, make a new one
conn, err := c.createConnection()
if err != nil {
if conn != nil {
conn.Close()
}
return nil, driver.WithStack(err)
}
// Invoke callback
if cb := c.onConnectionCreated; cb != nil {
if err := cb(ctx, conn); err != nil {
conn.Close()
return nil, driver.WithStack(err)
}
}
// Mark the connection as ready
atomic.StoreInt32(&conn.configured, 1)
return conn, nil
} | go | func (c *Transport) getConnection(ctx context.Context) (*Connection, error) {
conn := c.getAvailableConnection()
if conn != nil {
return conn, nil
}
// No connections available, make a new one
conn, err := c.createConnection()
if err != nil {
if conn != nil {
conn.Close()
}
return nil, driver.WithStack(err)
}
// Invoke callback
if cb := c.onConnectionCreated; cb != nil {
if err := cb(ctx, conn); err != nil {
conn.Close()
return nil, driver.WithStack(err)
}
}
// Mark the connection as ready
atomic.StoreInt32(&conn.configured, 1)
return conn, nil
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"getConnection",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"Connection",
",",
"error",
")",
"{",
"conn",
":=",
"c",
".",
"getAvailableConnection",
"(",
")",
"\n",
"if",
"conn",
"!=",
"nil",
"{",
"r... | // getConnection returns the first available connection, or when no such connection is available,
// is created a new connection. | [
"getConnection",
"returns",
"the",
"first",
"available",
"connection",
"or",
"when",
"no",
"such",
"connection",
"is",
"available",
"is",
"created",
"a",
"new",
"connection",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L139-L166 |
5,740 | arangodb/go-driver | vst/protocol/transport.go | getAvailableConnection | func (c *Transport) getAvailableConnection() *Connection {
c.connMutex.Lock()
defer c.connMutex.Unlock()
// Select the connection with the least amount of traffic
var bestConn *Connection
bestConnLoad := 0
activeConnCount := 0
for _, conn := range c.connections {
if !conn.IsClosed() {
activeConnCount++
if conn.IsConfigured() {
connLoad := conn.load()
if bestConn == nil || connLoad < bestConnLoad {
bestConn = conn
bestConnLoad = connLoad
}
}
}
}
if bestConn == nil {
// No connections available
return nil
}
// Is load is >0 AND the number of connections is below the limit, create a new one
if bestConnLoad > 0 && activeConnCount < c.ConnLimit {
return nil
}
// Use the best connection found
bestConn.updateLastActivity()
return bestConn
} | go | func (c *Transport) getAvailableConnection() *Connection {
c.connMutex.Lock()
defer c.connMutex.Unlock()
// Select the connection with the least amount of traffic
var bestConn *Connection
bestConnLoad := 0
activeConnCount := 0
for _, conn := range c.connections {
if !conn.IsClosed() {
activeConnCount++
if conn.IsConfigured() {
connLoad := conn.load()
if bestConn == nil || connLoad < bestConnLoad {
bestConn = conn
bestConnLoad = connLoad
}
}
}
}
if bestConn == nil {
// No connections available
return nil
}
// Is load is >0 AND the number of connections is below the limit, create a new one
if bestConnLoad > 0 && activeConnCount < c.ConnLimit {
return nil
}
// Use the best connection found
bestConn.updateLastActivity()
return bestConn
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"getAvailableConnection",
"(",
")",
"*",
"Connection",
"{",
"c",
".",
"connMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"connMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// Select the connection with the least... | // getAvailableConnection returns the first available connection.
// If no such connection is available, nil is returned. | [
"getAvailableConnection",
"returns",
"the",
"first",
"available",
"connection",
".",
"If",
"no",
"such",
"connection",
"is",
"available",
"nil",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L170-L204 |
5,741 | arangodb/go-driver | vst/protocol/transport.go | createConnection | func (c *Transport) createConnection() (*Connection, error) {
conn, err := dial(c.Version, c.hostAddr, c.tlsConfig)
if err != nil {
return nil, driver.WithStack(err)
}
// Record connection
c.connMutex.Lock()
c.connections = append(c.connections, conn)
startCleanup := len(c.connections) == 1
c.connMutex.Unlock()
if startCleanup {
// TODO enable cleanup
go c.cleanup()
}
return conn, nil
} | go | func (c *Transport) createConnection() (*Connection, error) {
conn, err := dial(c.Version, c.hostAddr, c.tlsConfig)
if err != nil {
return nil, driver.WithStack(err)
}
// Record connection
c.connMutex.Lock()
c.connections = append(c.connections, conn)
startCleanup := len(c.connections) == 1
c.connMutex.Unlock()
if startCleanup {
// TODO enable cleanup
go c.cleanup()
}
return conn, nil
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"createConnection",
"(",
")",
"(",
"*",
"Connection",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"dial",
"(",
"c",
".",
"Version",
",",
"c",
".",
"hostAddr",
",",
"c",
".",
"tlsConfig",
")",
"\n",
"... | // createConnection creates a new connection. | [
"createConnection",
"creates",
"a",
"new",
"connection",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L207-L225 |
5,742 | arangodb/go-driver | vst/protocol/transport.go | cleanup | func (c *Transport) cleanup() {
for {
time.Sleep(c.IdleConnTimeout / 10)
_, remaining := c.CloseIdleConnections()
if remaining == 0 {
return
}
}
} | go | func (c *Transport) cleanup() {
for {
time.Sleep(c.IdleConnTimeout / 10)
_, remaining := c.CloseIdleConnections()
if remaining == 0 {
return
}
}
} | [
"func",
"(",
"c",
"*",
"Transport",
")",
"cleanup",
"(",
")",
"{",
"for",
"{",
"time",
".",
"Sleep",
"(",
"c",
".",
"IdleConnTimeout",
"/",
"10",
")",
"\n",
"_",
",",
"remaining",
":=",
"c",
".",
"CloseIdleConnections",
"(",
")",
"\n",
"if",
"remai... | // cleanup keeps removing idle connections | [
"cleanup",
"keeps",
"removing",
"idle",
"connections"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/transport.go#L228-L236 |
5,743 | arangodb/go-driver | agency/agency_connection.go | Do | func (c *agencyConnection) Do(ctx context.Context, req driver.Request) (driver.Response, error) {
if ctx == nil {
ctx = context.Background()
}
deadline, ok := ctx.Deadline()
if !ok {
deadline = time.Now().Add(time.Second * 30)
}
timeout := time.Until(deadline)
if timeout < minAgencyTimeout {
timeout = minAgencyTimeout
}
attempt := 1
delay := agencyConnectionFailureBackoff(0)
for {
lctx, cancel := context.WithTimeout(ctx, timeout/3)
resp, isPerm, err := c.doOnce(lctx, req)
cancel()
if err == nil {
// Success
return resp, nil
} else if isPerm {
// Permanent error
return nil, driver.WithStack(err)
}
// Is deadline exceeded?
if time.Now().After(deadline) {
return nil, driver.WithStack(fmt.Errorf("All %d attemps resulted in temporary failure", attempt))
}
// Just retry
attempt++
delay = agencyConnectionFailureBackoff(delay)
// Wait a bit so we don't hammer the agency
select {
case <-time.After(delay):
// Continue
case <-ctx.Done():
// Context canceled
return nil, driver.WithStack(ctx.Err())
}
}
} | go | func (c *agencyConnection) Do(ctx context.Context, req driver.Request) (driver.Response, error) {
if ctx == nil {
ctx = context.Background()
}
deadline, ok := ctx.Deadline()
if !ok {
deadline = time.Now().Add(time.Second * 30)
}
timeout := time.Until(deadline)
if timeout < minAgencyTimeout {
timeout = minAgencyTimeout
}
attempt := 1
delay := agencyConnectionFailureBackoff(0)
for {
lctx, cancel := context.WithTimeout(ctx, timeout/3)
resp, isPerm, err := c.doOnce(lctx, req)
cancel()
if err == nil {
// Success
return resp, nil
} else if isPerm {
// Permanent error
return nil, driver.WithStack(err)
}
// Is deadline exceeded?
if time.Now().After(deadline) {
return nil, driver.WithStack(fmt.Errorf("All %d attemps resulted in temporary failure", attempt))
}
// Just retry
attempt++
delay = agencyConnectionFailureBackoff(delay)
// Wait a bit so we don't hammer the agency
select {
case <-time.After(delay):
// Continue
case <-ctx.Done():
// Context canceled
return nil, driver.WithStack(ctx.Err())
}
}
} | [
"func",
"(",
"c",
"*",
"agencyConnection",
")",
"Do",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"driver",
".",
"Request",
")",
"(",
"driver",
".",
"Response",
",",
"error",
")",
"{",
"if",
"ctx",
"==",
"nil",
"{",
"ctx",
"=",
"context",
".... | // Do performs a given request, returning its response.
// In case of a termporary failure, the request is retried until
// the deadline is exceeded. | [
"Do",
"performs",
"a",
"given",
"request",
"returning",
"its",
"response",
".",
"In",
"case",
"of",
"a",
"termporary",
"failure",
"the",
"request",
"is",
"retried",
"until",
"the",
"deadline",
"is",
"exceeded",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency_connection.go#L81-L122 |
5,744 | arangodb/go-driver | agency/agency_connection.go | agencyConnectionFailureBackoff | func agencyConnectionFailureBackoff(lastDelay time.Duration) time.Duration {
return increaseDelay(lastDelay, 1.5, time.Millisecond, time.Second*2)
} | go | func agencyConnectionFailureBackoff(lastDelay time.Duration) time.Duration {
return increaseDelay(lastDelay, 1.5, time.Millisecond, time.Second*2)
} | [
"func",
"agencyConnectionFailureBackoff",
"(",
"lastDelay",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"return",
"increaseDelay",
"(",
"lastDelay",
",",
"1.5",
",",
"time",
".",
"Millisecond",
",",
"time",
".",
"Second",
"*",
"2",
")",
"\n",... | // agencyConnectionFailureBackoff returns a backoff delay for cases where all
// agents responded with a non-fatal error. | [
"agencyConnectionFailureBackoff",
"returns",
"a",
"backoff",
"delay",
"for",
"cases",
"where",
"all",
"agents",
"responded",
"with",
"a",
"non",
"-",
"fatal",
"error",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency_connection.go#L300-L302 |
5,745 | arangodb/go-driver | agency/agency_connection.go | increaseDelay | func increaseDelay(oldDelay time.Duration, factor float64, min, max time.Duration) time.Duration {
delay := time.Duration(float64(oldDelay) * factor)
if delay < min {
delay = min
}
if delay > max {
delay = max
}
return delay
} | go | func increaseDelay(oldDelay time.Duration, factor float64, min, max time.Duration) time.Duration {
delay := time.Duration(float64(oldDelay) * factor)
if delay < min {
delay = min
}
if delay > max {
delay = max
}
return delay
} | [
"func",
"increaseDelay",
"(",
"oldDelay",
"time",
".",
"Duration",
",",
"factor",
"float64",
",",
"min",
",",
"max",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"delay",
":=",
"time",
".",
"Duration",
"(",
"float64",
"(",
"oldDelay",
")",... | // increaseDelay returns an delay, increased from an old delay with a given
// factor, limited to given min & max. | [
"increaseDelay",
"returns",
"an",
"delay",
"increased",
"from",
"an",
"old",
"delay",
"with",
"a",
"given",
"factor",
"limited",
"to",
"given",
"min",
"&",
"max",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency_connection.go#L306-L315 |
5,746 | arangodb/go-driver | view_arangosearch_impl.go | Properties | func (v *viewArangoSearch) Properties(ctx context.Context) (ArangoSearchViewProperties, error) {
req, err := v.conn.NewRequest("GET", path.Join(v.relPath(), "properties"))
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
var data ArangoSearchViewProperties
if err := resp.ParseBody("", &data); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
return data, nil
} | go | func (v *viewArangoSearch) Properties(ctx context.Context) (ArangoSearchViewProperties, error) {
req, err := v.conn.NewRequest("GET", path.Join(v.relPath(), "properties"))
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
var data ArangoSearchViewProperties
if err := resp.ParseBody("", &data); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
return data, nil
} | [
"func",
"(",
"v",
"*",
"viewArangoSearch",
")",
"Properties",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"ArangoSearchViewProperties",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"v",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"pa... | // Properties fetches extended information about the view. | [
"Properties",
"fetches",
"extended",
"information",
"about",
"the",
"view",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/view_arangosearch_impl.go#L36-L54 |
5,747 | arangodb/go-driver | view_arangosearch_impl.go | SetProperties | func (v *viewArangoSearch) SetProperties(ctx context.Context, options ArangoSearchViewProperties) error {
req, err := v.conn.NewRequest("PUT", path.Join(v.relPath(), "properties"))
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(options); err != nil {
return WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | func (v *viewArangoSearch) SetProperties(ctx context.Context, options ArangoSearchViewProperties) error {
req, err := v.conn.NewRequest("PUT", path.Join(v.relPath(), "properties"))
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(options); err != nil {
return WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"v",
"*",
"viewArangoSearch",
")",
"SetProperties",
"(",
"ctx",
"context",
".",
"Context",
",",
"options",
"ArangoSearchViewProperties",
")",
"error",
"{",
"req",
",",
"err",
":=",
"v",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"... | // SetProperties changes properties of the view. | [
"SetProperties",
"changes",
"properties",
"of",
"the",
"view",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/view_arangosearch_impl.go#L57-L74 |
5,748 | arangodb/go-driver | cluster/cluster.go | NewConnection | func NewConnection(config ConnectionConfig, connectionBuilder ServerConnectionBuilder, endpoints []string) (driver.Connection, error) {
if connectionBuilder == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must a connection builder"})
}
if len(endpoints) == 0 {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must provide at least 1 endpoint"})
}
if config.DefaultTimeout == 0 {
config.DefaultTimeout = defaultTimeout
}
cConn := &clusterConnection{
connectionBuilder: connectionBuilder,
defaultTimeout: config.DefaultTimeout,
}
// Initialize endpoints
if err := cConn.UpdateEndpoints(endpoints); err != nil {
return nil, driver.WithStack(err)
}
return cConn, nil
} | go | func NewConnection(config ConnectionConfig, connectionBuilder ServerConnectionBuilder, endpoints []string) (driver.Connection, error) {
if connectionBuilder == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must a connection builder"})
}
if len(endpoints) == 0 {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must provide at least 1 endpoint"})
}
if config.DefaultTimeout == 0 {
config.DefaultTimeout = defaultTimeout
}
cConn := &clusterConnection{
connectionBuilder: connectionBuilder,
defaultTimeout: config.DefaultTimeout,
}
// Initialize endpoints
if err := cConn.UpdateEndpoints(endpoints); err != nil {
return nil, driver.WithStack(err)
}
return cConn, nil
} | [
"func",
"NewConnection",
"(",
"config",
"ConnectionConfig",
",",
"connectionBuilder",
"ServerConnectionBuilder",
",",
"endpoints",
"[",
"]",
"string",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"if",
"connectionBuilder",
"==",
"nil",
"{",
"re... | // NewConnection creates a new cluster connection to a cluster of servers.
// The given connections are existing connections to each of the servers. | [
"NewConnection",
"creates",
"a",
"new",
"cluster",
"connection",
"to",
"a",
"cluster",
"of",
"servers",
".",
"The",
"given",
"connections",
"are",
"existing",
"connections",
"to",
"each",
"of",
"the",
"servers",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster/cluster.go#L54-L73 |
5,749 | arangodb/go-driver | cluster/cluster.go | getCurrentServer | func (c *clusterConnection) getCurrentServer() driver.Connection {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.servers[c.current]
} | go | func (c *clusterConnection) getCurrentServer() driver.Connection {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.servers[c.current]
} | [
"func",
"(",
"c",
"*",
"clusterConnection",
")",
"getCurrentServer",
"(",
")",
"driver",
".",
"Connection",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"servers... | // getCurrentServer returns the currently used server. | [
"getCurrentServer",
"returns",
"the",
"currently",
"used",
"server",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster/cluster.go#L328-L332 |
5,750 | arangodb/go-driver | cluster/cluster.go | getSpecificServer | func (c *clusterConnection) getSpecificServer(endpoint string) (driver.Connection, error) {
c.mutex.RLock()
defer c.mutex.RUnlock()
for _, s := range c.servers {
endpoints := s.Endpoints()
found := false
for _, x := range endpoints {
if x == endpoint {
found = true
break
}
}
if found {
return s, nil
}
}
return nil, driver.WithStack(driver.InvalidArgumentError{Message: fmt.Sprintf("unknown endpoint: %s", endpoint)})
} | go | func (c *clusterConnection) getSpecificServer(endpoint string) (driver.Connection, error) {
c.mutex.RLock()
defer c.mutex.RUnlock()
for _, s := range c.servers {
endpoints := s.Endpoints()
found := false
for _, x := range endpoints {
if x == endpoint {
found = true
break
}
}
if found {
return s, nil
}
}
return nil, driver.WithStack(driver.InvalidArgumentError{Message: fmt.Sprintf("unknown endpoint: %s", endpoint)})
} | [
"func",
"(",
"c",
"*",
"clusterConnection",
")",
"getSpecificServer",
"(",
"endpoint",
"string",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"c",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"RUnlock",... | // getSpecificServer returns the server with the given endpoint. | [
"getSpecificServer",
"returns",
"the",
"server",
"with",
"the",
"given",
"endpoint",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster/cluster.go#L335-L354 |
5,751 | arangodb/go-driver | cluster/cluster.go | getNextServer | func (c *clusterConnection) getNextServer() driver.Connection {
c.mutex.Lock()
defer c.mutex.Unlock()
c.current = (c.current + 1) % len(c.servers)
return c.servers[c.current]
} | go | func (c *clusterConnection) getNextServer() driver.Connection {
c.mutex.Lock()
defer c.mutex.Unlock()
c.current = (c.current + 1) % len(c.servers)
return c.servers[c.current]
} | [
"func",
"(",
"c",
"*",
"clusterConnection",
")",
"getNextServer",
"(",
")",
"driver",
".",
"Connection",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"current",
"=",
"(",
... | // getNextServer changes the currently used server and returns the new server. | [
"getNextServer",
"changes",
"the",
"currently",
"used",
"server",
"and",
"returns",
"the",
"new",
"server",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/cluster/cluster.go#L357-L362 |
5,752 | arangodb/go-driver | collection_impl.go | newCollection | func newCollection(name string, db *database) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &collection{
name: name,
db: db,
conn: db.conn,
}, nil
} | go | func newCollection(name string, db *database) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &collection{
name: name,
db: db,
conn: db.conn,
}, nil
} | [
"func",
"newCollection",
"(",
"name",
"string",
",",
"db",
"*",
"database",
")",
"(",
"Collection",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
... | // newCollection creates a new Collection implementation. | [
"newCollection",
"creates",
"a",
"new",
"Collection",
"implementation",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/collection_impl.go#L32-L44 |
5,753 | arangodb/go-driver | collection_impl.go | Unload | func (c *collection) Unload(ctx context.Context) error {
req, err := c.conn.NewRequest("PUT", path.Join(c.relPath("collection"), "unload"))
if err != nil {
return WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | func (c *collection) Unload(ctx context.Context) error {
req, err := c.conn.NewRequest("PUT", path.Join(c.relPath("collection"), "unload"))
if err != nil {
return WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"collection",
")",
"Unload",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"req",
",",
"err",
":=",
"c",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",
"(",
"c",
".",
"relPath",
"(",
... | // UnLoad the collection from memory. | [
"UnLoad",
"the",
"collection",
"from",
"memory",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/collection_impl.go#L218-L232 |
5,754 | arangodb/go-driver | collection_impl.go | UnmarshalJSON | func (p *CollectionProperties) UnmarshalJSON(d []byte) error {
var internal collectionPropertiesInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | go | func (p *CollectionProperties) UnmarshalJSON(d []byte) error {
var internal collectionPropertiesInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | [
"func",
"(",
"p",
"*",
"CollectionProperties",
")",
"UnmarshalJSON",
"(",
"d",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"internal",
"collectionPropertiesInternal",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"d",
",",
"&",
"internal",
")",
... | // UnmarshalJSON loads CollectionProperties from json | [
"UnmarshalJSON",
"loads",
"CollectionProperties",
"from",
"json"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/collection_impl.go#L333-L341 |
5,755 | arangodb/go-driver | collection_impl.go | UnmarshalJSON | func (p *SetCollectionPropertiesOptions) UnmarshalJSON(d []byte) error {
var internal setCollectionPropertiesOptionsInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | go | func (p *SetCollectionPropertiesOptions) UnmarshalJSON(d []byte) error {
var internal setCollectionPropertiesOptionsInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | [
"func",
"(",
"p",
"*",
"SetCollectionPropertiesOptions",
")",
"UnmarshalJSON",
"(",
"d",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"internal",
"setCollectionPropertiesOptionsInternal",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"d",
",",
"&",
... | // UnmarshalJSON loads SetCollectionPropertiesOptions from json | [
"UnmarshalJSON",
"loads",
"SetCollectionPropertiesOptions",
"from",
"json"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/collection_impl.go#L369-L377 |
5,756 | arangodb/go-driver | http/connection.go | newHTTPConnection | func newHTTPConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
var httpTransport *http.Transport
if config.Transport != nil {
httpTransport, _ = config.Transport.(*http.Transport)
} else {
httpTransport = &http.Transport{
// Copy default values from http.DefaultTransport
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
config.Transport = httpTransport
}
if httpTransport != nil {
if httpTransport.MaxIdleConnsPerHost == 0 {
// Raise the default number of idle connections per host since in a database application
// it is very likely that you want more than 2 concurrent connections to a host.
// We raise it to avoid the extra concurrent connections being closed directly
// after use, resulting in a lot of connection in `TIME_WAIT` state.
httpTransport.MaxIdleConnsPerHost = DefaultMaxIdleConnsPerHost
}
defaultMaxIdleConns := 3 * DefaultMaxIdleConnsPerHost
if httpTransport.MaxIdleConns > 0 && httpTransport.MaxIdleConns < defaultMaxIdleConns {
// For a cluster scenario we assume the use of 3 coordinators (don't know the exact number here)
// and derive the maximum total number of idle connections from that.
httpTransport.MaxIdleConns = defaultMaxIdleConns
}
if config.TLSConfig != nil {
httpTransport.TLSClientConfig = config.TLSConfig
}
}
httpClient := &http.Client{
Transport: config.Transport,
}
if config.DontFollowRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse // Do not wrap, standard library will not understand
}
} else if config.FailOnRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return driver.ArangoError{
HasError: true,
Code: http.StatusFound,
ErrorNum: 0,
ErrorMessage: "Redirect not allowed",
}
}
}
var connPool chan int
if config.ConnLimit > 0 {
connPool = make(chan int, config.ConnLimit)
// Fill with available tokens
for i := 0; i < config.ConnLimit; i++ {
connPool <- i
}
}
c := &httpConnection{
endpoint: *u,
contentType: config.ContentType,
client: httpClient,
connPool: connPool,
}
return c, nil
} | go | func newHTTPConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
var httpTransport *http.Transport
if config.Transport != nil {
httpTransport, _ = config.Transport.(*http.Transport)
} else {
httpTransport = &http.Transport{
// Copy default values from http.DefaultTransport
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
config.Transport = httpTransport
}
if httpTransport != nil {
if httpTransport.MaxIdleConnsPerHost == 0 {
// Raise the default number of idle connections per host since in a database application
// it is very likely that you want more than 2 concurrent connections to a host.
// We raise it to avoid the extra concurrent connections being closed directly
// after use, resulting in a lot of connection in `TIME_WAIT` state.
httpTransport.MaxIdleConnsPerHost = DefaultMaxIdleConnsPerHost
}
defaultMaxIdleConns := 3 * DefaultMaxIdleConnsPerHost
if httpTransport.MaxIdleConns > 0 && httpTransport.MaxIdleConns < defaultMaxIdleConns {
// For a cluster scenario we assume the use of 3 coordinators (don't know the exact number here)
// and derive the maximum total number of idle connections from that.
httpTransport.MaxIdleConns = defaultMaxIdleConns
}
if config.TLSConfig != nil {
httpTransport.TLSClientConfig = config.TLSConfig
}
}
httpClient := &http.Client{
Transport: config.Transport,
}
if config.DontFollowRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse // Do not wrap, standard library will not understand
}
} else if config.FailOnRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return driver.ArangoError{
HasError: true,
Code: http.StatusFound,
ErrorNum: 0,
ErrorMessage: "Redirect not allowed",
}
}
}
var connPool chan int
if config.ConnLimit > 0 {
connPool = make(chan int, config.ConnLimit)
// Fill with available tokens
for i := 0; i < config.ConnLimit; i++ {
connPool <- i
}
}
c := &httpConnection{
endpoint: *u,
contentType: config.ContentType,
client: httpClient,
connPool: connPool,
}
return c, nil
} | [
"func",
"newHTTPConnection",
"(",
"endpoint",
"string",
",",
"config",
"ConnectionConfig",
")",
"(",
"driver",
".",
"Connection",
",",
"error",
")",
"{",
"if",
"config",
".",
"ConnLimit",
"==",
"0",
"{",
"config",
".",
"ConnLimit",
"=",
"DefaultConnLimit",
"... | // newHTTPConnection creates a new HTTP connection for a single endpoint and the remainder of the given configuration settings. | [
"newHTTPConnection",
"creates",
"a",
"new",
"HTTP",
"connection",
"for",
"a",
"single",
"endpoint",
"and",
"the",
"remainder",
"of",
"the",
"given",
"configuration",
"settings",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/connection.go#L103-L181 |
5,757 | arangodb/go-driver | http/connection.go | readBody | func readBody(resp *http.Response) ([]byte, error) {
defer resp.Body.Close()
contentLength := resp.ContentLength
if contentLength < 0 {
// Don't know the content length, do it the slowest way
result, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, driver.WithStack(err)
}
return result, nil
}
buf := &bytes.Buffer{}
if int64(int(contentLength)) == contentLength {
// contentLength is an int64. If we can safely cast to int, use Grow.
buf.Grow(int(contentLength))
}
if _, err := buf.ReadFrom(resp.Body); err != nil {
return nil, driver.WithStack(err)
}
return buf.Bytes(), nil
} | go | func readBody(resp *http.Response) ([]byte, error) {
defer resp.Body.Close()
contentLength := resp.ContentLength
if contentLength < 0 {
// Don't know the content length, do it the slowest way
result, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, driver.WithStack(err)
}
return result, nil
}
buf := &bytes.Buffer{}
if int64(int(contentLength)) == contentLength {
// contentLength is an int64. If we can safely cast to int, use Grow.
buf.Grow(int(contentLength))
}
if _, err := buf.ReadFrom(resp.Body); err != nil {
return nil, driver.WithStack(err)
}
return buf.Bytes(), nil
} | [
"func",
"readBody",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"contentLength",
":=",
"resp",
".",
"ContentLength",
"\n",
"if",
"contentLe... | // readBody reads the body of the given response into a byte slice. | [
"readBody",
"reads",
"the",
"body",
"of",
"the",
"given",
"response",
"into",
"a",
"byte",
"slice",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/connection.go#L323-L343 |
5,758 | arangodb/go-driver | collection_document_impl.go | parseResponseArray | func parseResponseArray(resp Response, count int, cs contextSettings, results interface{}) (DocumentMetaSlice, ErrorSlice, error) {
resps, err := resp.ParseArrayBody()
if err != nil {
return nil, nil, WithStack(err)
}
metas := make(DocumentMetaSlice, count)
errs := make(ErrorSlice, count)
returnOldVal := reflect.ValueOf(cs.ReturnOld)
returnNewVal := reflect.ValueOf(cs.ReturnNew)
resultsVal := reflect.ValueOf(results)
for i := 0; i < count; i++ {
resp := resps[i]
var meta DocumentMeta
if err := resp.CheckStatus(200, 201, 202); err != nil {
errs[i] = err
} else {
if err := resp.ParseBody("", &meta); err != nil {
errs[i] = err
} else {
metas[i] = meta
// Parse returnOld (if needed)
if cs.ReturnOld != nil {
returnOldEntryVal := returnOldVal.Index(i).Addr()
if err := resp.ParseBody("old", returnOldEntryVal.Interface()); err != nil {
errs[i] = err
}
}
// Parse returnNew (if needed)
if cs.ReturnNew != nil {
returnNewEntryVal := returnNewVal.Index(i).Addr()
if err := resp.ParseBody("new", returnNewEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
if results != nil {
// Parse compare result document
resultsEntryVal := resultsVal.Index(i).Addr()
if err := resp.ParseBody("", resultsEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
}
return metas, errs, nil
} | go | func parseResponseArray(resp Response, count int, cs contextSettings, results interface{}) (DocumentMetaSlice, ErrorSlice, error) {
resps, err := resp.ParseArrayBody()
if err != nil {
return nil, nil, WithStack(err)
}
metas := make(DocumentMetaSlice, count)
errs := make(ErrorSlice, count)
returnOldVal := reflect.ValueOf(cs.ReturnOld)
returnNewVal := reflect.ValueOf(cs.ReturnNew)
resultsVal := reflect.ValueOf(results)
for i := 0; i < count; i++ {
resp := resps[i]
var meta DocumentMeta
if err := resp.CheckStatus(200, 201, 202); err != nil {
errs[i] = err
} else {
if err := resp.ParseBody("", &meta); err != nil {
errs[i] = err
} else {
metas[i] = meta
// Parse returnOld (if needed)
if cs.ReturnOld != nil {
returnOldEntryVal := returnOldVal.Index(i).Addr()
if err := resp.ParseBody("old", returnOldEntryVal.Interface()); err != nil {
errs[i] = err
}
}
// Parse returnNew (if needed)
if cs.ReturnNew != nil {
returnNewEntryVal := returnNewVal.Index(i).Addr()
if err := resp.ParseBody("new", returnNewEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
if results != nil {
// Parse compare result document
resultsEntryVal := resultsVal.Index(i).Addr()
if err := resp.ParseBody("", resultsEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
}
return metas, errs, nil
} | [
"func",
"parseResponseArray",
"(",
"resp",
"Response",
",",
"count",
"int",
",",
"cs",
"contextSettings",
",",
"results",
"interface",
"{",
"}",
")",
"(",
"DocumentMetaSlice",
",",
"ErrorSlice",
",",
"error",
")",
"{",
"resps",
",",
"err",
":=",
"resp",
".... | // parseResponseArray parses an array response in the given response | [
"parseResponseArray",
"parses",
"an",
"array",
"response",
"in",
"the",
"given",
"response"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/collection_document_impl.go#L631-L676 |
5,759 | arangodb/go-driver | graph_impl.go | newGraph | func newGraph(name string, db *database) (Graph, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &graph{
name: name,
db: db,
conn: db.conn,
}, nil
} | go | func newGraph(name string, db *database) (Graph, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &graph{
name: name,
db: db,
conn: db.conn,
}, nil
} | [
"func",
"newGraph",
"(",
"name",
"string",
",",
"db",
"*",
"database",
")",
"(",
"Graph",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
"\"",
"}... | // newGraph creates a new Graph implementation. | [
"newGraph",
"creates",
"a",
"new",
"Graph",
"implementation",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/graph_impl.go#L31-L43 |
5,760 | arangodb/go-driver | graph_impl.go | Remove | func (g *graph) Remove(ctx context.Context) error {
req, err := g.conn.NewRequest("DELETE", g.relPath())
if err != nil {
return WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(201, 202); err != nil {
return WithStack(err)
}
return nil
} | go | func (g *graph) Remove(ctx context.Context) error {
req, err := g.conn.NewRequest("DELETE", g.relPath())
if err != nil {
return WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(201, 202); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"g",
"*",
"graph",
")",
"Remove",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"req",
",",
"err",
":=",
"g",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"g",
".",
"relPath",
"(",
")",
")",
"\n",
"if",
"err",
... | // Remove removes the entire graph.
// If the graph does not exist, a NotFoundError is returned. | [
"Remove",
"removes",
"the",
"entire",
"graph",
".",
"If",
"the",
"graph",
"does",
"not",
"exist",
"a",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/graph_impl.go#L64-L77 |
5,761 | arangodb/go-driver | vst/protocol/chunk_1_1.go | readChunkVST1_1 | func readChunkVST1_1(r io.Reader) (chunk, error) {
hdr := [maxChunkHeaderSize]byte{}
if err := readBytes(hdr[:maxChunkHeaderSize], r); err != nil {
return chunk{}, driver.WithStack(err)
}
le := binary.LittleEndian
length := le.Uint32(hdr[0:])
chunkX := le.Uint32(hdr[4:])
messageID := le.Uint64(hdr[8:])
messageLength := le.Uint64(hdr[16:])
contentLength := length - maxChunkHeaderSize
data := make([]byte, contentLength)
if err := readBytes(data, r); err != nil {
return chunk{}, driver.WithStack(err)
}
//fmt.Printf("data: " + hex.EncodeToString(data) + "\n")
return chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: data,
}, nil
} | go | func readChunkVST1_1(r io.Reader) (chunk, error) {
hdr := [maxChunkHeaderSize]byte{}
if err := readBytes(hdr[:maxChunkHeaderSize], r); err != nil {
return chunk{}, driver.WithStack(err)
}
le := binary.LittleEndian
length := le.Uint32(hdr[0:])
chunkX := le.Uint32(hdr[4:])
messageID := le.Uint64(hdr[8:])
messageLength := le.Uint64(hdr[16:])
contentLength := length - maxChunkHeaderSize
data := make([]byte, contentLength)
if err := readBytes(data, r); err != nil {
return chunk{}, driver.WithStack(err)
}
//fmt.Printf("data: " + hex.EncodeToString(data) + "\n")
return chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: data,
}, nil
} | [
"func",
"readChunkVST1_1",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"chunk",
",",
"error",
")",
"{",
"hdr",
":=",
"[",
"maxChunkHeaderSize",
"]",
"byte",
"{",
"}",
"\n",
"if",
"err",
":=",
"readBytes",
"(",
"hdr",
"[",
":",
"maxChunkHeaderSize",
"]",
... | // readChunkVST1_1 reads an entire chunk from the given reader in VST 1.1 format. | [
"readChunkVST1_1",
"reads",
"an",
"entire",
"chunk",
"from",
"the",
"given",
"reader",
"in",
"VST",
"1",
".",
"1",
"format",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/chunk_1_1.go#L33-L56 |
5,762 | arangodb/go-driver | vst/protocol/chunk_1_1.go | WriteToVST1_1 | func (c chunk) WriteToVST1_1(w io.Writer) (int64, error) {
le := binary.LittleEndian
hdr := [maxChunkHeaderSize]byte{}
le.PutUint32(hdr[0:], uint32(len(c.Data)+len(hdr))) // length
le.PutUint32(hdr[4:], c.chunkX) // chunkX
le.PutUint64(hdr[8:], c.MessageID) // message ID
le.PutUint64(hdr[16:], c.MessageLength) // message length
// Write header
//fmt.Printf("Writing hdr: %s\n", hex.EncodeToString(hdr))
if n, err := w.Write(hdr[:]); err != nil {
return int64(n), driver.WithStack(err)
}
// Write data
//fmt.Printf("Writing data: %s\n", hex.EncodeToString(c.Data))
n, err := w.Write(c.Data)
result := int64(n) + int64(len(hdr))
if err != nil {
return result, driver.WithStack(err)
}
return result, nil
} | go | func (c chunk) WriteToVST1_1(w io.Writer) (int64, error) {
le := binary.LittleEndian
hdr := [maxChunkHeaderSize]byte{}
le.PutUint32(hdr[0:], uint32(len(c.Data)+len(hdr))) // length
le.PutUint32(hdr[4:], c.chunkX) // chunkX
le.PutUint64(hdr[8:], c.MessageID) // message ID
le.PutUint64(hdr[16:], c.MessageLength) // message length
// Write header
//fmt.Printf("Writing hdr: %s\n", hex.EncodeToString(hdr))
if n, err := w.Write(hdr[:]); err != nil {
return int64(n), driver.WithStack(err)
}
// Write data
//fmt.Printf("Writing data: %s\n", hex.EncodeToString(c.Data))
n, err := w.Write(c.Data)
result := int64(n) + int64(len(hdr))
if err != nil {
return result, driver.WithStack(err)
}
return result, nil
} | [
"func",
"(",
"c",
"chunk",
")",
"WriteToVST1_1",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"int64",
",",
"error",
")",
"{",
"le",
":=",
"binary",
".",
"LittleEndian",
"\n",
"hdr",
":=",
"[",
"maxChunkHeaderSize",
"]",
"byte",
"{",
"}",
"\n\n",
"le",
... | // WriteToVST1_1 write the chunk to the given writer in VST 1.0 format.
// An error is returned when less than the entire chunk was written. | [
"WriteToVST1_1",
"write",
"the",
"chunk",
"to",
"the",
"given",
"writer",
"in",
"VST",
"1",
".",
"0",
"format",
".",
"An",
"error",
"is",
"returned",
"when",
"less",
"than",
"the",
"entire",
"chunk",
"was",
"written",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/chunk_1_1.go#L60-L83 |
5,763 | arangodb/go-driver | database_collections_impl.go | Collection | func (d *database) Collection(ctx context.Context, name string) (Collection, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection", escapedName))
if err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
coll, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return coll, nil
} | go | func (d *database) Collection(ctx context.Context, name string) (Collection, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection", escapedName))
if err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
coll, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return coll, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Collection",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"Collection",
",",
"error",
")",
"{",
"escapedName",
":=",
"pathEscape",
"(",
"name",
")",
"\n",
"req",
",",
"err",
":=",
"d... | // Collection opens a connection to an existing collection within the database.
// If no collection with given name exists, an NotFoundError is returned. | [
"Collection",
"opens",
"a",
"connection",
"to",
"an",
"existing",
"collection",
"within",
"the",
"database",
".",
"If",
"no",
"collection",
"with",
"given",
"name",
"exists",
"an",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_collections_impl.go#L32-L50 |
5,764 | arangodb/go-driver | database_collections_impl.go | Collections | func (d *database) Collections(ctx context.Context) ([]Collection, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection"))
if err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Result))
for _, info := range data.Result {
col, err := newCollection(info.Name, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, col)
}
return result, nil
} | go | func (d *database) Collections(ctx context.Context) ([]Collection, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection"))
if err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Result))
for _, info := range data.Result {
col, err := newCollection(info.Name, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, col)
}
return result, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Collections",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"Collection",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"d",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".... | // Collections returns a list of all collections in the database. | [
"Collections",
"returns",
"a",
"list",
"of",
"all",
"collections",
"in",
"the",
"database",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_collections_impl.go#L77-L102 |
5,765 | arangodb/go-driver | database_collections_impl.go | CreateCollection | func (d *database) CreateCollection(ctx context.Context, name string, options *CreateCollectionOptions) (Collection, error) {
input := createCollectionOptionsInternal{
Name: name,
}
if options != nil {
input.fromExternal(options)
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/collection"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
col, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | go | func (d *database) CreateCollection(ctx context.Context, name string, options *CreateCollectionOptions) (Collection, error) {
input := createCollectionOptionsInternal{
Name: name,
}
if options != nil {
input.fromExternal(options)
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/collection"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
col, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"CreateCollection",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"options",
"*",
"CreateCollectionOptions",
")",
"(",
"Collection",
",",
"error",
")",
"{",
"input",
":=",
"createCollectionOptionsInt... | // CreateCollection creates a new collection with given name and options, and opens a connection to it.
// If a collection with given name already exists within the database, a DuplicateError is returned. | [
"CreateCollection",
"creates",
"a",
"new",
"collection",
"with",
"given",
"name",
"and",
"options",
"and",
"opens",
"a",
"connection",
"to",
"it",
".",
"If",
"a",
"collection",
"with",
"given",
"name",
"already",
"exists",
"within",
"the",
"database",
"a",
"... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_collections_impl.go#L126-L153 |
5,766 | arangodb/go-driver | vst/response.go | newResponse | func newResponse(msgData []byte, endpoint string, rawResponse *[]byte) (*vstResponse, error) {
// Decode header
hdr := velocypack.Slice(msgData)
if err := hdr.AssertType(velocypack.Array); err != nil {
return nil, driver.WithStack(err)
}
//panic("hdr: " + hex.EncodeToString(hdr))
var hdrLen velocypack.ValueLength
if l, err := hdr.Length(); err != nil {
return nil, driver.WithStack(err)
} else if l < 3 {
return nil, driver.WithStack(fmt.Errorf("Expected a header of 3 elements, got %d", l))
} else {
hdrLen = l
}
resp := &vstResponse{
endpoint: endpoint,
}
// Decode version
if elem, err := hdr.At(0); err != nil {
return nil, driver.WithStack(err)
} else if version, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Version = int(version)
}
// Decode type
if elem, err := hdr.At(1); err != nil {
return nil, driver.WithStack(err)
} else if tp, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Type = int(tp)
}
// Decode responseCode
if elem, err := hdr.At(2); err != nil {
return nil, driver.WithStack(err)
} else if code, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.ResponseCode = int(code)
}
// Decode meta
if hdrLen >= 4 {
if elem, err := hdr.At(3); err != nil {
return nil, driver.WithStack(err)
} else if !elem.IsObject() {
return nil, driver.WithStack(fmt.Errorf("Expected meta field to be of type Object, got %s", elem.Type()))
} else {
resp.meta = elem
}
}
// Fetch body directly after hdr
if body, err := hdr.Next(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.slice = body
if rawResponse != nil {
*rawResponse = body
}
}
//fmt.Printf("got response: code=%d, body=%s\n", resp.ResponseCode, hex.EncodeToString(resp.slice))
return resp, nil
} | go | func newResponse(msgData []byte, endpoint string, rawResponse *[]byte) (*vstResponse, error) {
// Decode header
hdr := velocypack.Slice(msgData)
if err := hdr.AssertType(velocypack.Array); err != nil {
return nil, driver.WithStack(err)
}
//panic("hdr: " + hex.EncodeToString(hdr))
var hdrLen velocypack.ValueLength
if l, err := hdr.Length(); err != nil {
return nil, driver.WithStack(err)
} else if l < 3 {
return nil, driver.WithStack(fmt.Errorf("Expected a header of 3 elements, got %d", l))
} else {
hdrLen = l
}
resp := &vstResponse{
endpoint: endpoint,
}
// Decode version
if elem, err := hdr.At(0); err != nil {
return nil, driver.WithStack(err)
} else if version, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Version = int(version)
}
// Decode type
if elem, err := hdr.At(1); err != nil {
return nil, driver.WithStack(err)
} else if tp, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Type = int(tp)
}
// Decode responseCode
if elem, err := hdr.At(2); err != nil {
return nil, driver.WithStack(err)
} else if code, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.ResponseCode = int(code)
}
// Decode meta
if hdrLen >= 4 {
if elem, err := hdr.At(3); err != nil {
return nil, driver.WithStack(err)
} else if !elem.IsObject() {
return nil, driver.WithStack(fmt.Errorf("Expected meta field to be of type Object, got %s", elem.Type()))
} else {
resp.meta = elem
}
}
// Fetch body directly after hdr
if body, err := hdr.Next(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.slice = body
if rawResponse != nil {
*rawResponse = body
}
}
//fmt.Printf("got response: code=%d, body=%s\n", resp.ResponseCode, hex.EncodeToString(resp.slice))
return resp, nil
} | [
"func",
"newResponse",
"(",
"msgData",
"[",
"]",
"byte",
",",
"endpoint",
"string",
",",
"rawResponse",
"*",
"[",
"]",
"byte",
")",
"(",
"*",
"vstResponse",
",",
"error",
")",
"{",
"// Decode header",
"hdr",
":=",
"velocypack",
".",
"Slice",
"(",
"msgDat... | // newResponse builds a vstResponse from given message. | [
"newResponse",
"builds",
"a",
"vstResponse",
"from",
"given",
"message",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/response.go#L48-L113 |
5,767 | arangodb/go-driver | vertex_collection_documents_impl.go | ReplaceDocument | func (c *vertexCollection) ReplaceDocument(ctx context.Context, key string, document interface{}) (DocumentMeta, error) {
meta, _, err := c.replaceDocument(ctx, key, document)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | func (c *vertexCollection) ReplaceDocument(ctx context.Context, key string, document interface{}) (DocumentMeta, error) {
meta, _, err := c.replaceDocument(ctx, key, document)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | [
"func",
"(",
"c",
"*",
"vertexCollection",
")",
"ReplaceDocument",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
",",
"document",
"interface",
"{",
"}",
")",
"(",
"DocumentMeta",
",",
"error",
")",
"{",
"meta",
",",
"_",
",",
"err",
":="... | // ReplaceDocument replaces a single document with given key in the collection with the document given in the document argument.
// The document meta data is returned.
// To return the NEW document, prepare a context with `WithReturnNew`.
// To return the OLD document, prepare a context with `WithReturnOld`.
// To wait until document has been synced to disk, prepare a context with `WithWaitForSync`.
// If no document exists with given key, a NotFoundError is returned. | [
"ReplaceDocument",
"replaces",
"a",
"single",
"document",
"with",
"given",
"key",
"in",
"the",
"collection",
"with",
"the",
"document",
"given",
"in",
"the",
"document",
"argument",
".",
"The",
"document",
"meta",
"data",
"is",
"returned",
".",
"To",
"return",... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vertex_collection_documents_impl.go#L351-L357 |
5,768 | arangodb/go-driver | vertex_collection_documents_impl.go | ReplaceDocuments | func (c *vertexCollection) ReplaceDocuments(ctx context.Context, keys []string, documents interface{}) (DocumentMetaSlice, ErrorSlice, error) {
documentsVal := reflect.ValueOf(documents)
switch documentsVal.Kind() {
case reflect.Array, reflect.Slice:
// OK
default:
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("documents data must be of kind Array, got %s", documentsVal.Kind())})
}
documentCount := documentsVal.Len()
if keys != nil {
if len(keys) != documentCount {
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("expected %d keys, got %d", documentCount, len(keys))})
}
for _, key := range keys {
if err := validateKey(key); err != nil {
return nil, nil, WithStack(err)
}
}
}
metas := make(DocumentMetaSlice, documentCount)
errs := make(ErrorSlice, documentCount)
silent := false
for i := 0; i < documentCount; i++ {
doc := documentsVal.Index(i)
ctx, err := withDocumentAt(ctx, i)
if err != nil {
return nil, nil, WithStack(err)
}
var key string
if keys != nil {
key = keys[i]
} else {
var err error
key, err = getKeyFromDocument(doc)
if err != nil {
errs[i] = err
continue
}
}
meta, cs, err := c.replaceDocument(ctx, key, doc.Interface())
if cs.Silent {
silent = true
} else {
metas[i], errs[i] = meta, err
}
}
if silent {
return nil, nil, nil
}
return metas, errs, nil
} | go | func (c *vertexCollection) ReplaceDocuments(ctx context.Context, keys []string, documents interface{}) (DocumentMetaSlice, ErrorSlice, error) {
documentsVal := reflect.ValueOf(documents)
switch documentsVal.Kind() {
case reflect.Array, reflect.Slice:
// OK
default:
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("documents data must be of kind Array, got %s", documentsVal.Kind())})
}
documentCount := documentsVal.Len()
if keys != nil {
if len(keys) != documentCount {
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("expected %d keys, got %d", documentCount, len(keys))})
}
for _, key := range keys {
if err := validateKey(key); err != nil {
return nil, nil, WithStack(err)
}
}
}
metas := make(DocumentMetaSlice, documentCount)
errs := make(ErrorSlice, documentCount)
silent := false
for i := 0; i < documentCount; i++ {
doc := documentsVal.Index(i)
ctx, err := withDocumentAt(ctx, i)
if err != nil {
return nil, nil, WithStack(err)
}
var key string
if keys != nil {
key = keys[i]
} else {
var err error
key, err = getKeyFromDocument(doc)
if err != nil {
errs[i] = err
continue
}
}
meta, cs, err := c.replaceDocument(ctx, key, doc.Interface())
if cs.Silent {
silent = true
} else {
metas[i], errs[i] = meta, err
}
}
if silent {
return nil, nil, nil
}
return metas, errs, nil
} | [
"func",
"(",
"c",
"*",
"vertexCollection",
")",
"ReplaceDocuments",
"(",
"ctx",
"context",
".",
"Context",
",",
"keys",
"[",
"]",
"string",
",",
"documents",
"interface",
"{",
"}",
")",
"(",
"DocumentMetaSlice",
",",
"ErrorSlice",
",",
"error",
")",
"{",
... | // ReplaceDocuments replaces multiple documents with given keys in the collection with the documents given in the documents argument.
// The replacements are loaded from the given documents slice, the documents meta data are returned.
// To return the NEW documents, prepare a context with `WithReturnNew` with a slice of documents.
// To return the OLD documents, prepare a context with `WithReturnOld` with a slice of documents.
// To wait until documents has been synced to disk, prepare a context with `WithWaitForSync`.
// If no document exists with a given key, a NotFoundError is returned at its errors index. | [
"ReplaceDocuments",
"replaces",
"multiple",
"documents",
"with",
"given",
"keys",
"in",
"the",
"collection",
"with",
"the",
"documents",
"given",
"in",
"the",
"documents",
"argument",
".",
"The",
"replacements",
"are",
"loaded",
"from",
"the",
"given",
"documents"... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vertex_collection_documents_impl.go#L412-L462 |
5,769 | arangodb/go-driver | vertex_collection_documents_impl.go | RemoveDocument | func (c *vertexCollection) RemoveDocument(ctx context.Context, key string) (DocumentMeta, error) {
meta, _, err := c.removeDocument(ctx, key)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | func (c *vertexCollection) RemoveDocument(ctx context.Context, key string) (DocumentMeta, error) {
meta, _, err := c.removeDocument(ctx, key)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | [
"func",
"(",
"c",
"*",
"vertexCollection",
")",
"RemoveDocument",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
")",
"(",
"DocumentMeta",
",",
"error",
")",
"{",
"meta",
",",
"_",
",",
"err",
":=",
"c",
".",
"removeDocument",
"(",
"ctx",... | // RemoveDocument removes a single document with given key from the collection.
// The document meta data is returned.
// To return the OLD document, prepare a context with `WithReturnOld`.
// To wait until removal has been synced to disk, prepare a context with `WithWaitForSync`.
// If no document exists with given key, a NotFoundError is returned. | [
"RemoveDocument",
"removes",
"a",
"single",
"document",
"with",
"given",
"key",
"from",
"the",
"collection",
".",
"The",
"document",
"meta",
"data",
"is",
"returned",
".",
"To",
"return",
"the",
"OLD",
"document",
"prepare",
"a",
"context",
"with",
"WithReturn... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vertex_collection_documents_impl.go#L469-L475 |
5,770 | arangodb/go-driver | database_views_impl.go | View | func (d *database) View(ctx context.Context, name string) (View, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data viewInfo
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, data.Type, d)
if err != nil {
return nil, WithStack(err)
}
return view, nil
} | go | func (d *database) View(ctx context.Context, name string) (View, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data viewInfo
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, data.Type, d)
if err != nil {
return nil, WithStack(err)
}
return view, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"View",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"View",
",",
"error",
")",
"{",
"escapedName",
":=",
"pathEscape",
"(",
"name",
")",
"\n",
"req",
",",
"err",
":=",
"d",
".",
... | // View opens a connection to an existing view within the database.
// If no collection with given name exists, an NotFoundError is returned. | [
"View",
"opens",
"a",
"connection",
"to",
"an",
"existing",
"view",
"within",
"the",
"database",
".",
"If",
"no",
"collection",
"with",
"given",
"name",
"exists",
"an",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_views_impl.go#L42-L65 |
5,771 | arangodb/go-driver | database_views_impl.go | ViewExists | func (d *database) ViewExists(ctx context.Context, name string) (bool, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return false, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err)
}
if err := resp.CheckStatus(200); err == nil {
return true, nil
} else if IsNotFound(err) {
return false, nil
} else {
return false, WithStack(err)
}
} | go | func (d *database) ViewExists(ctx context.Context, name string) (bool, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return false, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err)
}
if err := resp.CheckStatus(200); err == nil {
return true, nil
} else if IsNotFound(err) {
return false, nil
} else {
return false, WithStack(err)
}
} | [
"func",
"(",
"d",
"*",
"database",
")",
"ViewExists",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"escapedName",
":=",
"pathEscape",
"(",
"name",
")",
"\n",
"req",
",",
"err",
":=",
"d",
"... | // ViewExists returns true if a view with given name exists within the database. | [
"ViewExists",
"returns",
"true",
"if",
"a",
"view",
"with",
"given",
"name",
"exists",
"within",
"the",
"database",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_views_impl.go#L68-L86 |
5,772 | arangodb/go-driver | database_views_impl.go | Views | func (d *database) Views(ctx context.Context) ([]View, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getViewResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]View, 0, len(data.Result))
for _, info := range data.Result {
view, err := newView(info.Name, info.Type, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, view)
}
return result, nil
} | go | func (d *database) Views(ctx context.Context) ([]View, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getViewResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]View, 0, len(data.Result))
for _, info := range data.Result {
view, err := newView(info.Name, info.Type, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, view)
}
return result, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"Views",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"View",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"d",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
".",
"Join",... | // Views returns a list of all views in the database. | [
"Views",
"returns",
"a",
"list",
"of",
"all",
"views",
"in",
"the",
"database",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_views_impl.go#L89-L115 |
5,773 | arangodb/go-driver | database_views_impl.go | CreateArangoSearchView | func (d *database) CreateArangoSearchView(ctx context.Context, name string, options *ArangoSearchViewProperties) (ArangoSearchView, error) {
input := struct {
Name string `json:"name"`
Type ViewType `json:"type"`
ArangoSearchViewProperties // `json:"properties"`
}{
Name: name,
Type: ViewTypeArangoSearch,
}
if options != nil {
input.ArangoSearchViewProperties = *options
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, input.Type, d)
if err != nil {
return nil, WithStack(err)
}
result, err := view.ArangoSearchView()
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | go | func (d *database) CreateArangoSearchView(ctx context.Context, name string, options *ArangoSearchViewProperties) (ArangoSearchView, error) {
input := struct {
Name string `json:"name"`
Type ViewType `json:"type"`
ArangoSearchViewProperties // `json:"properties"`
}{
Name: name,
Type: ViewTypeArangoSearch,
}
if options != nil {
input.ArangoSearchViewProperties = *options
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, input.Type, d)
if err != nil {
return nil, WithStack(err)
}
result, err := view.ArangoSearchView()
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | [
"func",
"(",
"d",
"*",
"database",
")",
"CreateArangoSearchView",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"options",
"*",
"ArangoSearchViewProperties",
")",
"(",
"ArangoSearchView",
",",
"error",
")",
"{",
"input",
":=",
"struct",
... | // CreateArangoSearchView creates a new view of type ArangoSearch,
// with given name and options, and opens a connection to it.
// If a view with given name already exists within the database, a ConflictError is returned. | [
"CreateArangoSearchView",
"creates",
"a",
"new",
"view",
"of",
"type",
"ArangoSearch",
"with",
"given",
"name",
"and",
"options",
"and",
"opens",
"a",
"connection",
"to",
"it",
".",
"If",
"a",
"view",
"with",
"given",
"name",
"already",
"exists",
"within",
"... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/database_views_impl.go#L120-L157 |
5,774 | arangodb/go-driver | graph_vertex_collections_impl.go | VertexCollection | func (g *graph) VertexCollection(ctx context.Context, name string) (Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
return ec, nil
}
}
return nil, WithStack(newArangoError(404, 0, "not found"))
} | go | func (g *graph) VertexCollection(ctx context.Context, name string) (Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
return ec, nil
}
}
return nil, WithStack(newArangoError(404, 0, "not found"))
} | [
"func",
"(",
"g",
"*",
"graph",
")",
"VertexCollection",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"Collection",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"g",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",... | // VertexCollection opens a connection to an existing edge-collection within the graph.
// If no edge-collection with given name exists, an NotFoundError is returned. | [
"VertexCollection",
"opens",
"a",
"connection",
"to",
"an",
"existing",
"edge",
"-",
"collection",
"within",
"the",
"graph",
".",
"If",
"no",
"edge",
"-",
"collection",
"with",
"given",
"name",
"exists",
"an",
"NotFoundError",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/graph_vertex_collections_impl.go#L36-L62 |
5,775 | arangodb/go-driver | graph_vertex_collections_impl.go | VertexCollectionExists | func (g *graph) VertexCollectionExists(ctx context.Context, name string) (bool, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return false, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return false, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return false, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
return true, nil
}
}
return false, nil
} | go | func (g *graph) VertexCollectionExists(ctx context.Context, name string) (bool, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return false, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return false, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return false, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
return true, nil
}
}
return false, nil
} | [
"func",
"(",
"g",
"*",
"graph",
")",
"VertexCollectionExists",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"g",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",... | // VertexCollectionExists returns true if an edge-collection with given name exists within the graph. | [
"VertexCollectionExists",
"returns",
"true",
"if",
"an",
"edge",
"-",
"collection",
"with",
"given",
"name",
"exists",
"within",
"the",
"graph",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/graph_vertex_collections_impl.go#L65-L87 |
5,776 | arangodb/go-driver | graph_vertex_collections_impl.go | VertexCollections | func (g *graph) VertexCollections(ctx context.Context) ([]Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Collections))
for _, name := range data.Collections {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
result = append(result, ec)
}
return result, nil
} | go | func (g *graph) VertexCollections(ctx context.Context) ([]Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Collections))
for _, name := range data.Collections {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
result = append(result, ec)
}
return result, nil
} | [
"func",
"(",
"g",
"*",
"graph",
")",
"VertexCollections",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"Collection",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"g",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"path",
... | // VertexCollections returns all edge collections of this graph | [
"VertexCollections",
"returns",
"all",
"edge",
"collections",
"of",
"this",
"graph"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/graph_vertex_collections_impl.go#L90-L115 |
5,777 | arangodb/go-driver | http/response_vpack.go | Endpoint | func (r *httpVPackResponse) Endpoint() string {
u := *r.resp.Request.URL
u.Path = ""
return u.String()
} | go | func (r *httpVPackResponse) Endpoint() string {
u := *r.resp.Request.URL
u.Path = ""
return u.String()
} | [
"func",
"(",
"r",
"*",
"httpVPackResponse",
")",
"Endpoint",
"(",
")",
"string",
"{",
"u",
":=",
"*",
"r",
".",
"resp",
".",
"Request",
".",
"URL",
"\n",
"u",
".",
"Path",
"=",
"\"",
"\"",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}"... | // Endpoint returns the endpoint that handled the request. | [
"Endpoint",
"returns",
"the",
"endpoint",
"that",
"handled",
"the",
"request",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/response_vpack.go#L47-L51 |
5,778 | arangodb/go-driver | http/response_vpack.go | getSlice | func (r *httpVPackResponse) getSlice() (velocypack.Slice, error) {
if r.slice == nil {
r.slice = velocypack.Slice(r.rawResponse)
//fmt.Println(r.slice)
}
return r.slice, nil
} | go | func (r *httpVPackResponse) getSlice() (velocypack.Slice, error) {
if r.slice == nil {
r.slice = velocypack.Slice(r.rawResponse)
//fmt.Println(r.slice)
}
return r.slice, nil
} | [
"func",
"(",
"r",
"*",
"httpVPackResponse",
")",
"getSlice",
"(",
")",
"(",
"velocypack",
".",
"Slice",
",",
"error",
")",
"{",
"if",
"r",
".",
"slice",
"==",
"nil",
"{",
"r",
".",
"slice",
"=",
"velocypack",
".",
"Slice",
"(",
"r",
".",
"rawRespon... | // getSlice reads the slice from the response if needed. | [
"getSlice",
"reads",
"the",
"slice",
"from",
"the",
"response",
"if",
"needed",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/http/response_vpack.go#L143-L149 |
5,779 | arangodb/go-driver | client.go | String | func (v VersionInfo) String() string {
result := fmt.Sprintf("%s, version %s, license %s", v.Server, v.Version, v.License)
if len(v.Details) > 0 {
lines := make([]string, 0, len(v.Details))
for k, v := range v.Details {
lines = append(lines, fmt.Sprintf("%s: %v", k, v))
}
sort.Strings(lines)
result = result + "\n" + strings.Join(lines, "\n")
}
return result
} | go | func (v VersionInfo) String() string {
result := fmt.Sprintf("%s, version %s, license %s", v.Server, v.Version, v.License)
if len(v.Details) > 0 {
lines := make([]string, 0, len(v.Details))
for k, v := range v.Details {
lines = append(lines, fmt.Sprintf("%s: %v", k, v))
}
sort.Strings(lines)
result = result + "\n" + strings.Join(lines, "\n")
}
return result
} | [
"func",
"(",
"v",
"VersionInfo",
")",
"String",
"(",
")",
"string",
"{",
"result",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
".",
"Server",
",",
"v",
".",
"Version",
",",
"v",
".",
"License",
")",
"\n",
"if",
"len",
"(",
"v",
".",... | // String creates a string representation of the given VersionInfo. | [
"String",
"creates",
"a",
"string",
"representation",
"of",
"the",
"given",
"VersionInfo",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client.go#L108-L119 |
5,780 | arangodb/go-driver | vst/protocol/chunk.go | buildChunks | func buildChunks(messageID uint64, maxChunkSize uint32, messageParts ...[]byte) ([]chunk, error) {
if maxChunkSize <= maxChunkHeaderSize {
return nil, fmt.Errorf("maxChunkSize is too small (%d)", maxChunkSize)
}
messageLength := uint64(0)
for _, m := range messageParts {
messageLength += uint64(len(m))
}
minChunkCount := int(messageLength / uint64(maxChunkSize))
maxDataLength := int(maxChunkSize - maxChunkHeaderSize)
chunks := make([]chunk, 0, minChunkCount+len(messageParts))
chunkIndex := uint32(0)
for _, m := range messageParts {
offset := 0
remaining := len(m)
for remaining > 0 {
dataLength := remaining
if dataLength > maxDataLength {
dataLength = maxDataLength
}
chunkX := chunkIndex << 1
c := chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: m[offset : offset+dataLength],
}
chunks = append(chunks, c)
remaining -= dataLength
offset += dataLength
chunkIndex++
}
}
// Set chunkX of first chunk
if len(chunks) == 1 {
chunks[0].chunkX = 3
} else {
chunks[0].chunkX = uint32((len(chunks) << 1) + 1)
}
return chunks, nil
} | go | func buildChunks(messageID uint64, maxChunkSize uint32, messageParts ...[]byte) ([]chunk, error) {
if maxChunkSize <= maxChunkHeaderSize {
return nil, fmt.Errorf("maxChunkSize is too small (%d)", maxChunkSize)
}
messageLength := uint64(0)
for _, m := range messageParts {
messageLength += uint64(len(m))
}
minChunkCount := int(messageLength / uint64(maxChunkSize))
maxDataLength := int(maxChunkSize - maxChunkHeaderSize)
chunks := make([]chunk, 0, minChunkCount+len(messageParts))
chunkIndex := uint32(0)
for _, m := range messageParts {
offset := 0
remaining := len(m)
for remaining > 0 {
dataLength := remaining
if dataLength > maxDataLength {
dataLength = maxDataLength
}
chunkX := chunkIndex << 1
c := chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: m[offset : offset+dataLength],
}
chunks = append(chunks, c)
remaining -= dataLength
offset += dataLength
chunkIndex++
}
}
// Set chunkX of first chunk
if len(chunks) == 1 {
chunks[0].chunkX = 3
} else {
chunks[0].chunkX = uint32((len(chunks) << 1) + 1)
}
return chunks, nil
} | [
"func",
"buildChunks",
"(",
"messageID",
"uint64",
",",
"maxChunkSize",
"uint32",
",",
"messageParts",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"chunk",
",",
"error",
")",
"{",
"if",
"maxChunkSize",
"<=",
"maxChunkHeaderSize",
"{",
"return",
"nil",
","... | // buildChunks splits a message consisting of 1 or more parts into chunks. | [
"buildChunks",
"splits",
"a",
"message",
"consisting",
"of",
"1",
"or",
"more",
"parts",
"into",
"chunks",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vst/protocol/chunk.go#L44-L84 |
5,781 | arangodb/go-driver | client_impl.go | NewClient | func NewClient(config ClientConfig) (Client, error) {
if config.Connection == nil {
return nil, WithStack(InvalidArgumentError{Message: "Connection is not set"})
}
conn := config.Connection
if config.Authentication != nil {
var err error
conn, err = conn.SetAuthentication(config.Authentication)
if err != nil {
return nil, WithStack(err)
}
}
c := &client{
conn: conn,
}
if config.SynchronizeEndpointsInterval > 0 {
go c.autoSynchronizeEndpoints(config.SynchronizeEndpointsInterval)
}
return c, nil
} | go | func NewClient(config ClientConfig) (Client, error) {
if config.Connection == nil {
return nil, WithStack(InvalidArgumentError{Message: "Connection is not set"})
}
conn := config.Connection
if config.Authentication != nil {
var err error
conn, err = conn.SetAuthentication(config.Authentication)
if err != nil {
return nil, WithStack(err)
}
}
c := &client{
conn: conn,
}
if config.SynchronizeEndpointsInterval > 0 {
go c.autoSynchronizeEndpoints(config.SynchronizeEndpointsInterval)
}
return c, nil
} | [
"func",
"NewClient",
"(",
"config",
"ClientConfig",
")",
"(",
"Client",
",",
"error",
")",
"{",
"if",
"config",
".",
"Connection",
"==",
"nil",
"{",
"return",
"nil",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
"\"",
"}",
")"... | // NewClient creates a new Client based on the given config setting. | [
"NewClient",
"creates",
"a",
"new",
"Client",
"based",
"on",
"the",
"given",
"config",
"setting",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_impl.go#L34-L53 |
5,782 | arangodb/go-driver | client_impl.go | SynchronizeEndpoints | func (c *client) SynchronizeEndpoints(ctx context.Context) error {
return c.SynchronizeEndpoints2(ctx, "")
} | go | func (c *client) SynchronizeEndpoints(ctx context.Context) error {
return c.SynchronizeEndpoints2(ctx, "")
} | [
"func",
"(",
"c",
"*",
"client",
")",
"SynchronizeEndpoints",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"c",
".",
"SynchronizeEndpoints2",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // SynchronizeEndpoints fetches all endpoints from an ArangoDB cluster and updates the
// connection to use those endpoints.
// When this client is connected to a single server, nothing happens.
// When this client is connected to a cluster of servers, the connection will be updated to reflect
// the layout of the cluster. | [
"SynchronizeEndpoints",
"fetches",
"all",
"endpoints",
"from",
"an",
"ArangoDB",
"cluster",
"and",
"updates",
"the",
"connection",
"to",
"use",
"those",
"endpoints",
".",
"When",
"this",
"client",
"is",
"connected",
"to",
"a",
"single",
"server",
"nothing",
"hap... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_impl.go#L70-L72 |
5,783 | arangodb/go-driver | client_impl.go | autoSynchronizeEndpoints | func (c *client) autoSynchronizeEndpoints(interval time.Duration) {
for {
// SynchronizeEndpoints endpoints
c.SynchronizeEndpoints(nil)
// Wait a bit
time.Sleep(interval)
}
} | go | func (c *client) autoSynchronizeEndpoints(interval time.Duration) {
for {
// SynchronizeEndpoints endpoints
c.SynchronizeEndpoints(nil)
// Wait a bit
time.Sleep(interval)
}
} | [
"func",
"(",
"c",
"*",
"client",
")",
"autoSynchronizeEndpoints",
"(",
"interval",
"time",
".",
"Duration",
")",
"{",
"for",
"{",
"// SynchronizeEndpoints endpoints",
"c",
".",
"SynchronizeEndpoints",
"(",
"nil",
")",
"\n\n",
"// Wait a bit",
"time",
".",
"Sleep... | // autoSynchronizeEndpoints performs automatic endpoint synchronization. | [
"autoSynchronizeEndpoints",
"performs",
"automatic",
"endpoint",
"synchronization",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_impl.go#L108-L116 |
5,784 | arangodb/go-driver | agency/agency.go | add | func (c WriteCondition) add(key []string, updater func(wc *writeCondition)) WriteCondition {
if c.conditions == nil {
c.conditions = make(map[string]writeCondition)
}
fullKey := createFullKey(key)
wc := c.conditions[fullKey]
updater(&wc)
c.conditions[fullKey] = wc
return c
} | go | func (c WriteCondition) add(key []string, updater func(wc *writeCondition)) WriteCondition {
if c.conditions == nil {
c.conditions = make(map[string]writeCondition)
}
fullKey := createFullKey(key)
wc := c.conditions[fullKey]
updater(&wc)
c.conditions[fullKey] = wc
return c
} | [
"func",
"(",
"c",
"WriteCondition",
")",
"add",
"(",
"key",
"[",
"]",
"string",
",",
"updater",
"func",
"(",
"wc",
"*",
"writeCondition",
")",
")",
"WriteCondition",
"{",
"if",
"c",
".",
"conditions",
"==",
"nil",
"{",
"c",
".",
"conditions",
"=",
"m... | // IfEmpty adds an empty check on the given key to the given condition
// and returns the updated condition. | [
"IfEmpty",
"adds",
"an",
"empty",
"check",
"on",
"the",
"given",
"key",
"to",
"the",
"given",
"condition",
"and",
"returns",
"the",
"updated",
"condition",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency.go#L74-L83 |
5,785 | arangodb/go-driver | agency/agency.go | toMap | func (c WriteCondition) toMap() map[string]interface{} {
result := make(map[string]interface{})
for k, v := range c.conditions {
result[k] = v
}
return result
} | go | func (c WriteCondition) toMap() map[string]interface{} {
result := make(map[string]interface{})
for k, v := range c.conditions {
result[k] = v
}
return result
} | [
"func",
"(",
"c",
"WriteCondition",
")",
"toMap",
"(",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"c",... | // toMap convert the given condition to a map suitable for writeTransaction. | [
"toMap",
"convert",
"the",
"given",
"condition",
"to",
"a",
"map",
"suitable",
"for",
"writeTransaction",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency.go#L86-L92 |
5,786 | arangodb/go-driver | agency/agency.go | IfEmpty | func (c WriteCondition) IfEmpty(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.OldEmpty = &condTrue
})
} | go | func (c WriteCondition) IfEmpty(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.OldEmpty = &condTrue
})
} | [
"func",
"(",
"c",
"WriteCondition",
")",
"IfEmpty",
"(",
"key",
"[",
"]",
"string",
")",
"WriteCondition",
"{",
"return",
"c",
".",
"add",
"(",
"key",
",",
"func",
"(",
"wc",
"*",
"writeCondition",
")",
"{",
"wc",
".",
"OldEmpty",
"=",
"&",
"condTrue... | // IfEmpty adds an "is empty" check on the given key to the given condition
// and returns the updated condition. | [
"IfEmpty",
"adds",
"an",
"is",
"empty",
"check",
"on",
"the",
"given",
"key",
"to",
"the",
"given",
"condition",
"and",
"returns",
"the",
"updated",
"condition",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency.go#L96-L100 |
5,787 | arangodb/go-driver | agency/agency.go | IfIsArray | func (c WriteCondition) IfIsArray(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.IsArray = &condTrue
})
} | go | func (c WriteCondition) IfIsArray(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.IsArray = &condTrue
})
} | [
"func",
"(",
"c",
"WriteCondition",
")",
"IfIsArray",
"(",
"key",
"[",
"]",
"string",
")",
"WriteCondition",
"{",
"return",
"c",
".",
"add",
"(",
"key",
",",
"func",
"(",
"wc",
"*",
"writeCondition",
")",
"{",
"wc",
".",
"IsArray",
"=",
"&",
"condTru... | // IfIsArray adds an "is-array" check on the given key to the given condition
// and returns the updated condition. | [
"IfIsArray",
"adds",
"an",
"is",
"-",
"array",
"check",
"on",
"the",
"given",
"key",
"to",
"the",
"given",
"condition",
"and",
"returns",
"the",
"updated",
"condition",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency.go#L104-L108 |
5,788 | arangodb/go-driver | agency/agency.go | IfEqualTo | func (c WriteCondition) IfEqualTo(key []string, oldValue interface{}) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.Old = oldValue
})
} | go | func (c WriteCondition) IfEqualTo(key []string, oldValue interface{}) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.Old = oldValue
})
} | [
"func",
"(",
"c",
"WriteCondition",
")",
"IfEqualTo",
"(",
"key",
"[",
"]",
"string",
",",
"oldValue",
"interface",
"{",
"}",
")",
"WriteCondition",
"{",
"return",
"c",
".",
"add",
"(",
"key",
",",
"func",
"(",
"wc",
"*",
"writeCondition",
")",
"{",
... | // IfEqualTo adds an "value equals oldValue" check to given old value on the
// given key to the given condition and returns the updated condition. | [
"IfEqualTo",
"adds",
"an",
"value",
"equals",
"oldValue",
"check",
"to",
"given",
"old",
"value",
"on",
"the",
"given",
"key",
"to",
"the",
"given",
"condition",
"and",
"returns",
"the",
"updated",
"condition",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/agency.go#L112-L116 |
5,789 | arangodb/go-driver | vertex_collection_impl.go | newVertexCollection | func newVertexCollection(name string, g *graph) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if g == nil {
return nil, WithStack(InvalidArgumentError{Message: "g is nil"})
}
return &vertexCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
} | go | func newVertexCollection(name string, g *graph) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if g == nil {
return nil, WithStack(InvalidArgumentError{Message: "g is nil"})
}
return &vertexCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
} | [
"func",
"newVertexCollection",
"(",
"name",
"string",
",",
"g",
"*",
"graph",
")",
"(",
"Collection",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"WithStack",
"(",
"InvalidArgumentError",
"{",
"Message",
":",
"\"",
... | // newVertexCollection creates a new Vertex Collection implementation. | [
"newVertexCollection",
"creates",
"a",
"new",
"Vertex",
"Collection",
"implementation",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vertex_collection_impl.go#L31-L43 |
5,790 | arangodb/go-driver | vertex_collection_impl.go | Revision | func (c *vertexCollection) Revision(ctx context.Context) (string, error) {
result, err := c.rawCollection().Revision(ctx)
if err != nil {
return "", WithStack(err)
}
return result, nil
} | go | func (c *vertexCollection) Revision(ctx context.Context) (string, error) {
result, err := c.rawCollection().Revision(ctx)
if err != nil {
return "", WithStack(err)
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"vertexCollection",
")",
"Revision",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"string",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"c",
".",
"rawCollection",
"(",
")",
".",
"Revision",
"(",
"ctx",
")",
"\n",
... | // Revision fetches the revision ID of the collection.
// The revision ID is a server-generated string that clients can use to check whether data
// in a collection has changed since the last revision check. | [
"Revision",
"fetches",
"the",
"revision",
"ID",
"of",
"the",
"collection",
".",
"The",
"revision",
"ID",
"is",
"a",
"server",
"-",
"generated",
"string",
"that",
"clients",
"can",
"use",
"to",
"check",
"whether",
"data",
"in",
"a",
"collection",
"has",
"ch... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/vertex_collection_impl.go#L104-L110 |
5,791 | arangodb/go-driver | authentication.go | BasicAuthentication | func BasicAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeBasic,
userName: userName,
password: password,
}
} | go | func BasicAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeBasic,
userName: userName,
password: password,
}
} | [
"func",
"BasicAuthentication",
"(",
"userName",
",",
"password",
"string",
")",
"Authentication",
"{",
"return",
"&",
"userNameAuthentication",
"{",
"authType",
":",
"AuthenticationTypeBasic",
",",
"userName",
":",
"userName",
",",
"password",
":",
"password",
",",
... | // BasicAuthentication creates an authentication implementation based on the given username & password. | [
"BasicAuthentication",
"creates",
"an",
"authentication",
"implementation",
"based",
"on",
"the",
"given",
"username",
"&",
"password",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/authentication.go#L46-L52 |
5,792 | arangodb/go-driver | authentication.go | JWTAuthentication | func JWTAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeJWT,
userName: userName,
password: password,
}
} | go | func JWTAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeJWT,
userName: userName,
password: password,
}
} | [
"func",
"JWTAuthentication",
"(",
"userName",
",",
"password",
"string",
")",
"Authentication",
"{",
"return",
"&",
"userNameAuthentication",
"{",
"authType",
":",
"AuthenticationTypeJWT",
",",
"userName",
":",
"userName",
",",
"password",
":",
"password",
",",
"}... | // JWTAuthentication creates a JWT token authentication implementation based on the given username & password. | [
"JWTAuthentication",
"creates",
"a",
"JWT",
"token",
"authentication",
"implementation",
"based",
"on",
"the",
"given",
"username",
"&",
"password",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/authentication.go#L55-L61 |
5,793 | arangodb/go-driver | authentication.go | Get | func (a *userNameAuthentication) Get(property string) string {
switch property {
case "username":
return a.userName
case "password":
return a.password
default:
return ""
}
} | go | func (a *userNameAuthentication) Get(property string) string {
switch property {
case "username":
return a.userName
case "password":
return a.password
default:
return ""
}
} | [
"func",
"(",
"a",
"*",
"userNameAuthentication",
")",
"Get",
"(",
"property",
"string",
")",
"string",
"{",
"switch",
"property",
"{",
"case",
"\"",
"\"",
":",
"return",
"a",
".",
"userName",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
".",
"password... | // Get returns a configuration property of the authentication.
// Supported properties depend on type of authentication. | [
"Get",
"returns",
"a",
"configuration",
"property",
"of",
"the",
"authentication",
".",
"Supported",
"properties",
"depend",
"on",
"type",
"of",
"authentication",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/authentication.go#L77-L86 |
5,794 | arangodb/go-driver | version.go | Major | func (v Version) Major() int {
parts := strings.Split(string(v), ".")
result, _ := strconv.Atoi(parts[0])
return result
} | go | func (v Version) Major() int {
parts := strings.Split(string(v), ".")
result, _ := strconv.Atoi(parts[0])
return result
} | [
"func",
"(",
"v",
"Version",
")",
"Major",
"(",
")",
"int",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"v",
")",
",",
"\"",
"\"",
")",
"\n",
"result",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"0",
"]",
... | // Major returns the major part of the version
// E.g. "3.1.7" -> 3 | [
"Major",
"returns",
"the",
"major",
"part",
"of",
"the",
"version",
"E",
".",
"g",
".",
"3",
".",
"1",
".",
"7",
"-",
">",
"3"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/version.go#L36-L40 |
5,795 | arangodb/go-driver | version.go | Minor | func (v Version) Minor() int {
parts := strings.Split(string(v), ".")
if len(parts) >= 2 {
result, _ := strconv.Atoi(parts[1])
return result
}
return 0
} | go | func (v Version) Minor() int {
parts := strings.Split(string(v), ".")
if len(parts) >= 2 {
result, _ := strconv.Atoi(parts[1])
return result
}
return 0
} | [
"func",
"(",
"v",
"Version",
")",
"Minor",
"(",
")",
"int",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"v",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
">=",
"2",
"{",
"result",
",",
"_",
":=",
"strc... | // Minor returns the minor part of the version.
// E.g. "3.1.7" -> 1 | [
"Minor",
"returns",
"the",
"minor",
"part",
"of",
"the",
"version",
".",
"E",
".",
"g",
".",
"3",
".",
"1",
".",
"7",
"-",
">",
"1"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/version.go#L44-L51 |
5,796 | arangodb/go-driver | version.go | Sub | func (v Version) Sub() string {
parts := strings.SplitN(string(v), ".", 3)
if len(parts) == 3 {
return parts[2]
}
return ""
} | go | func (v Version) Sub() string {
parts := strings.SplitN(string(v), ".", 3)
if len(parts) == 3 {
return parts[2]
}
return ""
} | [
"func",
"(",
"v",
"Version",
")",
"Sub",
"(",
")",
"string",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"string",
"(",
"v",
")",
",",
"\"",
"\"",
",",
"3",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"==",
"3",
"{",
"return",
"parts",
... | // Sub returns the sub part of the version.
// E.g. "3.1.7" -> "7" | [
"Sub",
"returns",
"the",
"sub",
"part",
"of",
"the",
"version",
".",
"E",
".",
"g",
".",
"3",
".",
"1",
".",
"7",
"-",
">",
"7"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/version.go#L55-L61 |
5,797 | arangodb/go-driver | version.go | SubInt | func (v Version) SubInt() (int, bool) {
result, err := strconv.Atoi(v.Sub())
return result, err == nil
} | go | func (v Version) SubInt() (int, bool) {
result, err := strconv.Atoi(v.Sub())
return result, err == nil
} | [
"func",
"(",
"v",
"Version",
")",
"SubInt",
"(",
")",
"(",
"int",
",",
"bool",
")",
"{",
"result",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"v",
".",
"Sub",
"(",
")",
")",
"\n",
"return",
"result",
",",
"err",
"==",
"nil",
"\n",
"}"
] | // SubInt returns the sub part of the version as integer.
// The bool return value indicates if the sub part is indeed a number.
// E.g. "3.1.7" -> 7, true
// E.g. "3.1.foo" -> 0, false | [
"SubInt",
"returns",
"the",
"sub",
"part",
"of",
"the",
"version",
"as",
"integer",
".",
"The",
"bool",
"return",
"value",
"indicates",
"if",
"the",
"sub",
"part",
"is",
"indeed",
"a",
"number",
".",
"E",
".",
"g",
".",
"3",
".",
"1",
".",
"7",
"-"... | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/version.go#L67-L70 |
5,798 | arangodb/go-driver | meta.go | Keys | func (l DocumentMetaSlice) Keys() []string {
keys := make([]string, len(l))
for i, m := range l {
keys[i] = m.Key
}
return keys
} | go | func (l DocumentMetaSlice) Keys() []string {
keys := make([]string, len(l))
for i, m := range l {
keys[i] = m.Key
}
return keys
} | [
"func",
"(",
"l",
"DocumentMetaSlice",
")",
"Keys",
"(",
")",
"[",
"]",
"string",
"{",
"keys",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"l",
"{",
"keys",
"[",
"i",
"]",
... | // Keys returns the keys of all elements. | [
"Keys",
"returns",
"the",
"keys",
"of",
"all",
"elements",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/meta.go#L44-L50 |
5,799 | arangodb/go-driver | meta.go | Revs | func (l DocumentMetaSlice) Revs() []string {
revs := make([]string, len(l))
for i, m := range l {
revs[i] = m.Rev
}
return revs
} | go | func (l DocumentMetaSlice) Revs() []string {
revs := make([]string, len(l))
for i, m := range l {
revs[i] = m.Rev
}
return revs
} | [
"func",
"(",
"l",
"DocumentMetaSlice",
")",
"Revs",
"(",
")",
"[",
"]",
"string",
"{",
"revs",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"l",
"{",
"revs",
"[",
"i",
"]",
... | // Revs returns the revisions of all elements. | [
"Revs",
"returns",
"the",
"revisions",
"of",
"all",
"elements",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/meta.go#L53-L59 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.