_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5600 | Error | train | func (ae ArangoError) Error() string {
if ae.ErrorMessage != "" {
return ae.ErrorMessage
}
return fmt.Sprintf("ArangoError: Code %d, ErrorNum %d", ae.Code, ae.ErrorNum)
} | go | {
"resource": ""
} |
q5601 | Timeout | train | func (ae ArangoError) Timeout() bool {
return ae.HasError && (ae.Code == http.StatusRequestTimeout || ae.Code == http.StatusGatewayTimeout)
} | go | {
"resource": ""
} |
q5602 | Temporary | train | func (ae ArangoError) Temporary() bool {
return ae.HasError && ae.Code == http.StatusServiceUnavailable
} | go | {
"resource": ""
} |
q5603 | newArangoError | train | func newArangoError(code, errorNum int, errorMessage string) error {
return ArangoError{
HasError: true,
Code: code,
ErrorNum: errorNum,
ErrorMessage: errorMessage,
}
} | go | {
"resource": ""
} |
q5604 | IsArangoError | train | func IsArangoError(err error) bool {
ae, ok := Cause(err).(ArangoError)
return ok && ae.HasError
} | go | {
"resource": ""
} |
q5605 | IsArangoErrorWithCode | train | func IsArangoErrorWithCode(err error, code int) bool {
ae, ok := Cause(err).(ArangoError)
return ok && ae.Code == code
} | go | {
"resource": ""
} |
q5606 | IsArangoErrorWithErrorNum | train | func IsArangoErrorWithErrorNum(err error, errorNum ...int) bool {
ae, ok := Cause(err).(ArangoError)
if !ok {
return false
}
for _, x := range errorNum {
if ae.ErrorNum == x {
return true
}
}
return false
} | go | {
"resource": ""
} |
q5607 | IsNoLeaderOrOngoing | train | func IsNoLeaderOrOngoing(err error) bool {
return IsArangoErrorWithCode(err, 503) && (IsArangoErrorWithErrorNum(err, 1495) || IsArangoErrorWithErrorNum(err, 1496))
} | go | {
"resource": ""
} |
q5608 | IsInvalidArgument | train | func IsInvalidArgument(err error) bool {
_, ok := Cause(err).(InvalidArgumentError)
return ok
} | go | {
"resource": ""
} |
q5609 | IsNoMoreDocuments | train | func IsNoMoreDocuments(err error) bool {
_, ok := Cause(err).(NoMoreDocumentsError)
return ok
} | go | {
"resource": ""
} |
q5610 | IsCanceled | train | func IsCanceled(err error) bool {
return isCausedBy(err, func(e error) bool { return e == context.Canceled })
} | go | {
"resource": ""
} |
q5611 | IsTimeout | train | func IsTimeout(err error) bool {
return isCausedBy(err, func(e error) bool { return e == context.DeadlineExceeded })
} | go | {
"resource": ""
} |
q5612 | isCausedBy | train | func isCausedBy(err error, p func(error) bool) bool {
if p(err) {
return true
}
err = Cause(err)
for {
if p(err) {
return true
} else if err == nil {
return false
}
if xerr, ok := err.(*ResponseError); ok {
err = xerr.Err
} else if xerr, ok := err.(*url.Error); ok {
err = xerr.Err
} else i... | go | {
"resource": ""
} |
q5613 | FirstNonNil | train | func (l ErrorSlice) FirstNonNil() error {
for _, e := range l {
if e != nil {
return e
}
}
return nil
} | go | {
"resource": ""
} |
q5614 | dial | train | func dial(version Version, addr string, tlsConfig *tls.Config) (*Connection, error) {
// Create TCP connection
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, driver.WithStack(err)
}
// Configure connection
if tcpConn, ok := conn.(*net.TCPConn); ok {
tcpConn.SetKeepAlive(true)
tcpConn.SetNoD... | go | {
"resource": ""
} |
q5615 | Close | train | func (c *Connection) Close() error {
if atomic.CompareAndSwapInt32(&c.closing, 0, 1) {
if err := c.conn.Close(); err != nil {
return driver.WithStack(err)
}
c.msgStore.ForEach(func(m *Message) {
m.closeResponseChan()
})
}
return nil
} | go | {
"resource": ""
} |
q5616 | sendChunk | train | func (c *Connection) sendChunk(deadline time.Time, chunk chunk) error {
c.writeMutex.Lock()
defer c.writeMutex.Unlock()
c.conn.SetWriteDeadline(deadline)
var err error
switch c.version {
case Version1_0:
_, err = chunk.WriteToVST1_0(c.conn)
case Version1_1:
_, err = chunk.WriteToVST1_1(c.conn)
default:
e... | go | {
"resource": ""
} |
q5617 | readChunkLoop | train | func (c *Connection) readChunkLoop() {
recentErrors := 0
goodChunks := 0
for {
if c.IsClosed() {
// Closing, we're done
return
}
var chunk chunk
var err error
switch c.version {
case Version1_0:
chunk, err = readChunkVST1_0(c.conn)
case Version1_1:
chunk, err = readChunkVST1_1(c.conn)
def... | go | {
"resource": ""
} |
q5618 | processChunk | train | func (c *Connection) processChunk(chunk chunk) {
m := c.msgStore.Get(chunk.MessageID)
if m == nil {
// Unexpected chunk, ignore it
return
}
// Add chunk to message
m.addChunk(chunk)
// Try to assembly
if m.assemble() {
// Message is complete
// Remove message from store
c.msgStore.Remove(m.ID)
//f... | go | {
"resource": ""
} |
q5619 | IsIdle | train | func (c *Connection) IsIdle(idleTimeout time.Duration) bool {
return time.Since(c.lastActivity) > idleTimeout && c.msgStore.Size() == 0
} | go | {
"resource": ""
} |
q5620 | indexStringToType | train | func indexStringToType(indexTypeString string) (IndexType, error) {
switch indexTypeString {
case string(FullTextIndex):
return FullTextIndex, nil
case string(HashIndex):
return HashIndex, nil
case string(SkipListIndex):
return SkipListIndex, nil
case string(PrimaryIndex):
return PrimaryIndex, nil
case st... | go | {
"resource": ""
} |
q5621 | newIndex | train | func newIndex(id string, indexTypeString string, col *collection) (Index, error) {
if id == "" {
return nil, WithStack(InvalidArgumentError{Message: "id is empty"})
}
parts := strings.Split(id, "/")
if len(parts) != 2 {
return nil, WithStack(InvalidArgumentError{Message: "id must be `collection/name`"})
}
if ... | go | {
"resource": ""
} |
q5622 | Name | train | func (i *index) Name() string {
parts := strings.Split(i.id, "/")
return parts[1]
} | go | {
"resource": ""
} |
q5623 | Remove | train | func (i *index) Remove(ctx context.Context) error {
req, err := i.conn.NewRequest("DELETE", path.Join(i.relPath(), i.id))
if err != nil {
return WithStack(err)
}
resp, err := i.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
... | go | {
"resource": ""
} |
q5624 | NewLock | train | func NewLock(log Logger, api Agency, key []string, id string, ttl time.Duration) (Lock, error) {
if ttl < minLockTTL {
ttl = minLockTTL
}
if id == "" {
randBytes := make([]byte, 16)
rand.Read(randBytes)
id = hex.EncodeToString(randBytes)
}
return &lock{
log: log,
api: api,
key: key,
id: id,
ttl:... | go | {
"resource": ""
} |
q5625 | Lock | train | func (l *lock) Lock(ctx context.Context) error {
l.mutex.Lock()
defer l.mutex.Unlock()
if l.locked {
return driver.WithStack(AlreadyLockedError)
}
// Try to claim lock
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := l.api.WriteKeyIfEmpty(ctx, l.key, l.id, l.ttl); err != nil ... | go | {
"resource": ""
} |
q5626 | Unlock | train | func (l *lock) Unlock(ctx context.Context) error {
l.mutex.Lock()
defer l.mutex.Unlock()
if !l.locked {
return driver.WithStack(NotLockedError)
}
// Release the lock
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := l.api.RemoveKeyIfEqualTo(ctx, l.key, l.id); err != nil {
re... | go | {
"resource": ""
} |
q5627 | IsLocked | train | func (l *lock) IsLocked() bool {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.locked
} | go | {
"resource": ""
} |
q5628 | renewLock | train | func (l *lock) renewLock(ctx context.Context) {
// op performs a renewal once.
// returns stop, error
op := func() (bool, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
if !l.locked {
return true, driver.WithStack(NotLockedError)
}
// Update key in agency
ctx, cancel := context.WithTimeout(ctx, time... | go | {
"resource": ""
} |
q5629 | User | train | func (c *client) User(ctx context.Context, name string) (User, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_api/user", escapedName))
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err ... | go | {
"resource": ""
} |
q5630 | UserExists | train | func (c *client) UserExists(ctx context.Context, name string) (bool, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_api", "user", escapedName))
if err != nil {
return false, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err... | go | {
"resource": ""
} |
q5631 | Users | train | func (c *client) Users(ctx context.Context) ([]User, error) {
req, err := c.conn.NewRequest("GET", "/_api/user")
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... | go | {
"resource": ""
} |
q5632 | CreateUser | train | func (c *client) CreateUser(ctx context.Context, name string, options *UserOptions) (User, error) {
input := struct {
UserOptions
Name string `json:"user"`
}{
Name: name,
}
if options != nil {
input.UserOptions = *options
}
req, err := c.conn.NewRequest("POST", path.Join("_api/user"))
if err != nil {
r... | go | {
"resource": ""
} |
q5633 | newEdgeCollection | train | func newEdgeCollection(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 &edgeCollection{
name: name,
g: g,
conn: g.db.conn,
}, ni... | go | {
"resource": ""
} |
q5634 | rawCollection | train | func (c *edgeCollection) rawCollection() Collection {
result, _ := newCollection(c.name, c.g.db)
return result
} | go | {
"resource": ""
} |
q5635 | Statistics | train | func (c *edgeCollection) Statistics(ctx context.Context) (CollectionStatistics, error) {
result, err := c.rawCollection().Statistics(ctx)
if err != nil {
return CollectionStatistics{}, WithStack(err)
}
return result, nil
} | go | {
"resource": ""
} |
q5636 | SetBody | train | func (r *vstRequest) SetBody(body ...interface{}) (driver.Request, error) {
switch len(body) {
case 0:
return r, driver.WithStack(fmt.Errorf("Must provide at least 1 body"))
case 1:
if data, err := velocypack.Marshal(body[0]); err != nil {
return r, driver.WithStack(err)
} else {
r.body = data
}
retu... | go | {
"resource": ""
} |
q5637 | requestType | train | func (r *vstRequest) requestType() int64 {
switch r.method {
case "DELETE":
return 0
case "GET":
return 1
case "POST":
return 2
case "PUT":
return 3
case "HEAD":
return 4
case "PATCH":
return 5
case "OPTIONS":
return 6
default:
panic(fmt.Errorf("Unknown method '%s'", r.method))
}
} | go | {
"resource": ""
} |
q5638 | newCursor | train | func newCursor(data cursorData, endpoint string, db *database, allowDirtyReads bool) (Cursor, error) {
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &cursor{
cursorData: data,
endpoint: endpoint,
db: db,
conn: db.conn,
allowD... | go | {
"resource": ""
} |
q5639 | HasMore | train | func (c *cursor) HasMore() bool {
return c.resultIndex < len(c.Result) || c.cursorData.HasMore
} | go | {
"resource": ""
} |
q5640 | Close | train | func (c *cursor) Close() error {
if c == nil {
// Avoid panics in the case that someone defer's a close before checking that the cursor is not nil.
return nil
}
if c := atomic.LoadInt32(&c.closed); c != 0 {
return nil
}
c.closeMutex.Lock()
defer c.closeMutex.Unlock()
if c.closed == 0 {
if c.cursorData.ID... | go | {
"resource": ""
} |
q5641 | ReadDocument | train | func (c *cursor) ReadDocument(ctx context.Context, result interface{}) (DocumentMeta, error) {
// Force use of initial endpoint
ctx = WithEndpoint(ctx, c.endpoint)
if c.resultIndex >= len(c.Result) && c.cursorData.HasMore {
// This is required since we are interested if this was a dirty read
// but we do not wa... | go | {
"resource": ""
} |
q5642 | SetQuery | train | func (r *httpJSONRequest) SetQuery(key, value string) driver.Request {
if r.q == nil {
r.q = url.Values{}
}
r.q.Set(key, value)
return r
} | go | {
"resource": ""
} |
q5643 | SetHeader | train | func (r *httpJSONRequest) SetHeader(key, value string) driver.Request {
if r.hdr == nil {
r.hdr = make(map[string]string)
}
r.hdr[key] = value
return r
} | go | {
"resource": ""
} |
q5644 | WithAllowNoLeader | train | func WithAllowNoLeader(parent context.Context) context.Context {
if parent == nil {
parent = context.Background()
}
return context.WithValue(parent, keyAllowNoLeader, true)
} | go | {
"resource": ""
} |
q5645 | hasAllowNoLeader | train | func hasAllowNoLeader(ctx context.Context) bool {
return ctx != nil && ctx.Value(keyAllowNoLeader) != nil
} | go | {
"resource": ""
} |
q5646 | AreAgentsHealthy | train | func AreAgentsHealthy(ctx context.Context, clients []driver.Connection) error {
wg := sync.WaitGroup{}
invalidKey := []string{"does-not-exist-70ddb948-59ea-52f3-9a19-baaca18de7ae"}
statuses := make([]agentStatus, len(clients))
for i, c := range clients {
wg.Add(1)
go func(i int, c driver.Connection) {
defer ... | go | {
"resource": ""
} |
q5647 | IsSameEndpoint | train | func IsSameEndpoint(a, b string) bool {
if a == b {
return true
}
ua, err := url.Parse(a)
if err != nil {
return false
}
ub, err := url.Parse(b)
if err != nil {
return false
}
return ua.Hostname() == ub.Hostname()
} | go | {
"resource": ""
} |
q5648 | Indexes | train | func (c *collection) Indexes(ctx context.Context) ([]Index, error) {
req, err := c.conn.NewRequest("GET", path.Join(c.db.relPath(), "_api", "index"))
if err != nil {
return nil, WithStack(err)
}
req.SetQuery("collection", c.name)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
... | go | {
"resource": ""
} |
q5649 | newUser | train | func newUser(data userData, conn Connection) (User, error) {
if data.Name == "" {
return nil, WithStack(InvalidArgumentError{Message: "data.Name is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &user{
data: data,
conn: conn,
}, nil
} | go | {
"resource": ""
} |
q5650 | Remove | train | func (u *user) Remove(ctx context.Context) error {
req, err := u.conn.NewRequest("DELETE", u.relPath())
if err != nil {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(202); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5651 | Update | train | func (u *user) Update(ctx context.Context, options UserOptions) error {
req, err := u.conn.NewRequest("PATCH", u.relPath())
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(options); err != nil {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
... | go | {
"resource": ""
} |
q5652 | AccessibleDatabases | train | func (u *user) AccessibleDatabases(ctx context.Context) ([]Database, error) {
req, err := u.conn.NewRequest("GET", path.Join(u.relPath(), "database"))
if err != nil {
return nil, WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); er... | go | {
"resource": ""
} |
q5653 | SetDatabaseAccess | train | func (u *user) SetDatabaseAccess(ctx context.Context, db Database, access Grant) error {
dbName, _, err := getDatabaseAndCollectionName(db)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
req, err := u.conn.NewRequest("PUT", path.Join(u.relPath(), "database", escapedDbName))
if err !... | go | {
"resource": ""
} |
q5654 | GetDatabaseAccess | train | func (u *user) GetDatabaseAccess(ctx context.Context, db Database) (Grant, error) {
dbName, _, err := getDatabaseAndCollectionName(db)
if err != nil {
return GrantNone, WithStack(err)
}
escapedDbName := pathEscape(dbName)
req, err := u.conn.NewRequest("GET", path.Join(u.relPath(), "database", escapedDbName))
if... | go | {
"resource": ""
} |
q5655 | SetCollectionAccess | train | func (u *user) SetCollectionAccess(ctx context.Context, col AccessTarget, access Grant) error {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("PUT", path.Jo... | go | {
"resource": ""
} |
q5656 | GetCollectionAccess | train | func (u *user) GetCollectionAccess(ctx context.Context, col AccessTarget) (Grant, error) {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return GrantNone, WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("GET", p... | go | {
"resource": ""
} |
q5657 | RemoveCollectionAccess | train | func (u *user) RemoveCollectionAccess(ctx context.Context, col AccessTarget) error {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("DELETE", path.Join(u.rel... | go | {
"resource": ""
} |
q5658 | getDatabaseAndCollectionName | train | func getDatabaseAndCollectionName(col AccessTarget) (string, string, error) {
if col == nil {
return "*", "*", nil
}
if x, ok := col.(Collection); ok {
return x.Database().Name(), x.Name(), nil
}
if x, ok := col.(Database); ok {
return x.Name(), "*", nil
}
return "", "", WithStack(InvalidArgumentError{"Nee... | go | {
"resource": ""
} |
q5659 | WithQueryCount | train | func WithQueryCount(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCount, v)
} | go | {
"resource": ""
} |
q5660 | WithQueryBatchSize | train | func WithQueryBatchSize(parent context.Context, value int) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryBatchSize, value)
} | go | {
"resource": ""
} |
q5661 | WithQueryCache | train | func WithQueryCache(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCache, v)
} | go | {
"resource": ""
} |
q5662 | WithQueryMemoryLimit | train | func WithQueryMemoryLimit(parent context.Context, value int64) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryMemoryLimit, value)
} | go | {
"resource": ""
} |
q5663 | WithQueryTTL | train | func WithQueryTTL(parent context.Context, value time.Duration) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryTTL, value)
} | go | {
"resource": ""
} |
q5664 | WithQuerySatelliteSyncWait | train | func WithQuerySatelliteSyncWait(parent context.Context, value time.Duration) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryOptSatSyncWait, value)
} | go | {
"resource": ""
} |
q5665 | WithQueryFullCount | train | func WithQueryFullCount(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryOptFullCount, v)
} | go | {
"resource": ""
} |
q5666 | applyContextSettings | train | func (q *queryRequest) applyContextSettings(ctx context.Context) {
if ctx == nil {
return
}
if rawValue := ctx.Value(keyQueryCount); rawValue != nil {
if value, ok := rawValue.(bool); ok {
q.Count = value
}
}
if rawValue := ctx.Value(keyQueryBatchSize); rawValue != nil {
if value, ok := rawValue.(int); ... | go | {
"resource": ""
} |
q5667 | Graph | train | func (d *database) Graph(ctx context.Context, name string) (Graph, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/gharial", escapedName))
if err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithSt... | go | {
"resource": ""
} |
q5668 | Graphs | train | func (d *database) Graphs(ctx context.Context) ([]Graph, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/gharial"))
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... | go | {
"resource": ""
} |
q5669 | CreateGraph | train | func (d *database) CreateGraph(ctx context.Context, name string, options *CreateGraphOptions) (Graph, error) {
input := createGraphOptions{
Name: name,
}
if options != nil {
input.OrphanVertexCollections = options.OrphanVertexCollections
input.EdgeDefinitions = options.EdgeDefinitions
input.IsSmart = options... | go | {
"resource": ""
} |
q5670 | Clone | train | func (r *httpVPackRequest) Clone() driver.Request {
clone := *r
clone.q = url.Values{}
for k, v := range r.q {
for _, x := range v {
clone.q.Add(k, x)
}
}
if clone.hdr != nil {
clone.hdr = make(map[string]string)
for k, v := range r.hdr {
clone.hdr[k] = v
}
}
return &clone
} | go | {
"resource": ""
} |
q5671 | SetBody | train | func (r *httpVPackRequest) SetBody(body ...interface{}) (driver.Request, error) {
switch len(body) {
case 0:
return r, driver.WithStack(fmt.Errorf("Must provide at least 1 body"))
case 1:
if data, err := velocypack.Marshal(body[0]); err != nil {
return r, driver.WithStack(err)
} else {
r.body = data
}
... | go | {
"resource": ""
} |
q5672 | Contains | train | func (ps ProtocolSet) Contains(p Protocol) bool {
for _, x := range ps {
if x == p {
return true
}
}
return false
} | go | {
"resource": ""
} |
q5673 | ContainsAny | train | func (ps ProtocolSet) ContainsAny(p ...Protocol) bool {
for _, x := range ps {
for _, y := range p {
if x == y {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q5674 | Shutdown | train | func (c *client) Shutdown(ctx context.Context, removeFromCluster bool) error {
req, err := c.conn.NewRequest("DELETE", "_admin/shutdown")
if err != nil {
return WithStack(err)
}
if removeFromCluster {
req.SetQuery("remove_from_cluster", "1")
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithSta... | go | {
"resource": ""
} |
q5675 | EdgeCollection | train | func (g *graph) EdgeCollection(ctx context.Context, name string) (Collection, VertexConstraints, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
if err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, VertexConstraints{}, WithSta... | go | {
"resource": ""
} |
q5676 | EdgeCollectionExists | train | func (g *graph) EdgeCollectionExists(ctx context.Context, name string) (bool, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
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 {... | go | {
"resource": ""
} |
q5677 | EdgeCollections | train | func (g *graph) EdgeCollections(ctx context.Context) ([]Collection, []VertexConstraints, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
if err != nil {
return nil, nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, nil, WithStack(err)
}
if err := resp.CheckStatus(2... | go | {
"resource": ""
} |
q5678 | newView | train | func newView(name string, viewType ViewType, db *database) (View, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if viewType == "" {
return nil, WithStack(InvalidArgumentError{Message: "viewType is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgume... | go | {
"resource": ""
} |
q5679 | ArangoSearchView | train | func (v *view) ArangoSearchView() (ArangoSearchView, error) {
if v.viewType != ViewTypeArangoSearch {
return nil, WithStack(newArangoError(http.StatusConflict, 0, fmt.Sprintf("Type must be '%s', got '%s'", ViewTypeArangoSearch, v.viewType)))
}
return &viewArangoSearch{view: *v}, nil
} | go | {
"resource": ""
} |
q5680 | Remove | train | func (v *view) Remove(ctx context.Context) error {
req, err := v.conn.NewRequest("DELETE", v.relPath())
if 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 WithS... | go | {
"resource": ""
} |
q5681 | newCluster | train | func newCluster(conn Connection) (Cluster, error) {
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &cluster{
conn: conn,
}, nil
} | go | {
"resource": ""
} |
q5682 | MoveShard | train | func (c *cluster) MoveShard(ctx context.Context, col Collection, shard ShardID, fromServer, toServer ServerID) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/moveShard")
if err != nil {
return WithStack(err)
}
input := moveShardRequest{
Database: col.Database().Name(),
Collection: col.Name(),... | go | {
"resource": ""
} |
q5683 | CleanOutServer | train | func (c *cluster) CleanOutServer(ctx context.Context, serverID string) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/cleanOutServer")
if err != nil {
return WithStack(err)
}
input := cleanOutServerRequest{
Server: serverID,
}
if _, err := req.SetBody(input); err != nil {
return WithStack(err... | go | {
"resource": ""
} |
q5684 | IsCleanedOut | train | func (c *cluster) IsCleanedOut(ctx context.Context, serverID string) (bool, error) {
r, err := c.NumberOfServers(ctx)
if err != nil {
return false, WithStack(err)
}
for _, id := range r.CleanedServerIDs {
if id == serverID {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q5685 | NumberOfServers | train | func (c *cluster) NumberOfServers(ctx context.Context) (NumberOfServersResponse, error) {
req, err := c.conn.NewRequest("GET", "_admin/cluster/numberOfServers")
if err != nil {
return NumberOfServersResponse{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
re... | go | {
"resource": ""
} |
q5686 | RemoveServer | train | func (c *cluster) RemoveServer(ctx context.Context, serverID ServerID) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/removeServer")
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(serverID); err != nil {
return WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.co... | go | {
"resource": ""
} |
q5687 | UnmarshalJSON | train | func (p *InventoryCollectionParameters) UnmarshalJSON(d []byte) error {
var internal inventoryCollectionParametersInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(internal)
return nil
} | go | {
"resource": ""
} |
q5688 | MarshalJSON | train | func (r replicationFactor) MarshalJSON() ([]byte, error) {
var replicationFactor interface{}
if int(r) == ReplicationFactorSatellite {
replicationFactor = replicationFactorSatelliteString
} else {
replicationFactor = int(r)
}
return json.Marshal(replicationFactor)
} | go | {
"resource": ""
} |
q5689 | UnmarshalJSON | train | func (r *replicationFactor) UnmarshalJSON(d []byte) error {
var internal interface{}
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
if i, ok := internal.(float64); ok {
*r = replicationFactor(i)
return nil
} else if str, ok := internal.(string); ok {
if ok && str == replicationFactorSa... | go | {
"resource": ""
} |
q5690 | NewAgency | train | func NewAgency(conn driver.Connection) (Agency, error) {
return &agency{
conn: conn,
}, nil
} | go | {
"resource": ""
} |
q5691 | ReadKey | train | func (c *agency) ReadKey(ctx context.Context, key []string, value interface{}) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/read")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
input := [][]string{{fullKey}}
req, err = req.SetBody(input)
if err != nil ... | go | {
"resource": ""
} |
q5692 | WriteKeyIfEmpty | train | func (c *agency) WriteKeyIfEmpty(ctx context.Context, key []string, value interface{}, ttl time.Duration) error {
var cond WriteCondition
cond = cond.IfEmpty(key)
if err := c.write(ctx, "set", key, value, cond, ttl); err != nil {
return driver.WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5693 | WriteKeyIfEqualTo | train | func (c *agency) WriteKeyIfEqualTo(ctx context.Context, key []string, newValue, oldValue interface{}, ttl time.Duration) error {
var cond WriteCondition
cond = cond.IfEqualTo(key, oldValue)
if err := c.write(ctx, "set", key, newValue, cond, ttl); err != nil {
return driver.WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5694 | write | train | func (c *agency) write(ctx context.Context, operation string, key []string, value interface{}, condition WriteCondition, ttl time.Duration) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/write")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
writeTxs := wr... | go | {
"resource": ""
} |
q5695 | RemoveKeyIfEqualTo | train | func (c *agency) RemoveKeyIfEqualTo(ctx context.Context, key []string, oldValue interface{}) error {
var cond WriteCondition
cond = cond.IfEqualTo(key, oldValue)
if err := c.write(ctx, "delete", key, nil, cond, 0); err != nil {
return driver.WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5696 | RegisterChangeCallback | train | func (c *agency) RegisterChangeCallback(ctx context.Context, key []string, cbURL string) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/write")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
writeTxs := writeTransactions{
writeTransaction{
// Update
... | go | {
"resource": ""
} |
q5697 | CreateArangodJwtAuthorizationHeader | train | func CreateArangodJwtAuthorizationHeader(jwtSecret, serverID string) (string, error) {
if jwtSecret == "" || serverID == "" {
return "", nil
}
// Create a new token object, specifying signing method and the claims
// you would like it to contain.
token := jg.NewWithClaims(jg.SigningMethodHS256, jg.MapClaims{
"... | go | {
"resource": ""
} |
q5698 | decodeObjectFields | train | func decodeObjectFields(objValue reflect.Value, body map[string]*json.RawMessage) error {
objValueType := objValue.Type()
for i := 0; i != objValue.NumField(); i++ {
f := objValueType.Field(i)
if f.Anonymous {
// Recurse into fields of anonymous field
if err := decodeObjectFields(objValue.Field(i), body); e... | go | {
"resource": ""
} |
q5699 | decodeMapFields | train | func decodeMapFields(val reflect.Value, body map[string]*json.RawMessage) error {
mapVal := val
if mapVal.IsNil() {
valType := val.Type()
mapType := reflect.MapOf(valType.Key(), valType.Elem())
mapVal = reflect.MakeMap(mapType)
}
for jsonName, raw := range body {
var value interface{}
if raw != nil {
i... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.