_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5700 | newDatabase | train | 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 | {
"resource": ""
} |
q5701 | Info | train | 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... | go | {
"resource": ""
} |
q5702 | Remove | train | 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 != n... | go | {
"resource": ""
} |
q5703 | Query | train | 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.applyCo... | go | {
"resource": ""
} |
q5704 | ValidateQuery | train | 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)
}
... | go | {
"resource": ""
} |
q5705 | Database | train | 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,... | go | {
"resource": ""
} |
q5706 | AccessibleDatabases | train | 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 | {
"resource": ""
} |
q5707 | listDatabases | train | 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 ... | go | {
"resource": ""
} |
q5708 | CreateDatabase | train | 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.J... | go | {
"resource": ""
} |
q5709 | Cluster | train | 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(newArangoErr... | go | {
"resource": ""
} |
q5710 | CreateBatch | train | 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... | go | {
"resource": ""
} |
q5711 | Extend | train | 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 Wit... | go | {
"resource": ""
} |
q5712 | Delete | train | 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)
}
... | go | {
"resource": ""
} |
q5713 | NewConnection | train | 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... | go | {
"resource": ""
} |
q5714 | newVSTConnection | train | 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) {
ca... | go | {
"resource": ""
} |
q5715 | closeResponseChan | train | func (m *Message) closeResponseChan() {
if atomic.CompareAndSwapInt32(&m.responseChanClosed, 0, 1) {
if ch := m.responseChan; ch != nil {
m.responseChan = nil
close(ch)
}
}
} | go | {
"resource": ""
} |
q5716 | addChunk | train | 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 | {
"resource": ""
} |
q5717 | assemble | train | 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
ret... | go | {
"resource": ""
} |
q5718 | IsReady | train | func (i DatabaseInventory) IsReady() bool {
for _, c := range i.Collections {
if !c.IsReady {
return false
}
}
return true
} | go | {
"resource": ""
} |
q5719 | PlanVersion | train | func (i DatabaseInventory) PlanVersion() int64 {
if len(i.Collections) == 0 {
return 0
}
return i.Collections[0].PlanVersion
} | go | {
"resource": ""
} |
q5720 | CollectionByName | train | 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 | {
"resource": ""
} |
q5721 | ViewByName | train | func (i DatabaseInventory) ViewByName(name string) (InventoryView, bool) {
for _, v := range i.Views {
if v.Name == name {
return v, true
}
}
return InventoryView{}, false
} | go | {
"resource": ""
} |
q5722 | IndexByFieldsAndType | train | 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 | {
"resource": ""
} |
q5723 | FieldsEqual | train | func (i InventoryIndex) FieldsEqual(fields []string) bool {
return stringSliceEqualsIgnoreOrder(i.Fields, fields)
} | go | {
"resource": ""
} |
q5724 | stringSliceEqualsIgnoreOrder | train | 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 | {
"resource": ""
} |
q5725 | Size | train | func (s *messageStore) Size() int {
s.mutex.RLock()
defer s.mutex.RUnlock()
return len(s.messages)
} | go | {
"resource": ""
} |
q5726 | Get | train | 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 | {
"resource": ""
} |
q5727 | Add | train | 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),
}
... | go | {
"resource": ""
} |
q5728 | Remove | train | func (s *messageStore) Remove(id uint64) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.messages, id)
} | go | {
"resource": ""
} |
q5729 | ForEach | train | func (s *messageStore) ForEach(cb func(*Message)) {
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, m := range s.messages {
cb(m)
}
} | go | {
"resource": ""
} |
q5730 | ReadDocument | train | 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 | {
"resource": ""
} |
q5731 | UpdateDocument | train | 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 | {
"resource": ""
} |
q5732 | getKeyFromDocument | train | 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()
f... | go | {
"resource": ""
} |
q5733 | newAuthenticatedConnection | train | 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"})
}
... | go | {
"resource": ""
} |
q5734 | prepare | train | 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
... | go | {
"resource": ""
} |
q5735 | NewTransport | train | 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: hos... | go | {
"resource": ""
} |
q5736 | CloseIdleConnections | train | 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], ... | go | {
"resource": ""
} |
q5737 | CloseAllConnections | train | func (c *Transport) CloseAllConnections() {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for _, conn := range c.connections {
// Close connection
go conn.Close()
}
} | go | {
"resource": ""
} |
q5738 | SetOnConnectionCreated | train | func (c *Transport) SetOnConnectionCreated(handler func(context.Context, *Connection) error) {
c.onConnectionCreated = handler
} | go | {
"resource": ""
} |
q5739 | getConnection | train | 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.WithStac... | go | {
"resource": ""
} |
q5740 | getAvailableConnection | train | 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++
... | go | {
"resource": ""
} |
q5741 | createConnection | train | 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.Unloc... | go | {
"resource": ""
} |
q5742 | cleanup | train | func (c *Transport) cleanup() {
for {
time.Sleep(c.IdleConnTimeout / 10)
_, remaining := c.CloseIdleConnections()
if remaining == 0 {
return
}
}
} | go | {
"resource": ""
} |
q5743 | Do | train | 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 = minA... | go | {
"resource": ""
} |
q5744 | agencyConnectionFailureBackoff | train | func agencyConnectionFailureBackoff(lastDelay time.Duration) time.Duration {
return increaseDelay(lastDelay, 1.5, time.Millisecond, time.Second*2)
} | go | {
"resource": ""
} |
q5745 | increaseDelay | train | 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 | {
"resource": ""
} |
q5746 | Properties | train | 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... | go | {
"resource": ""
} |
q5747 | SetProperties | train | 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)
}
applyContextSetti... | go | {
"resource": ""
} |
q5748 | NewConnection | train | 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.WithS... | go | {
"resource": ""
} |
q5749 | getCurrentServer | train | func (c *clusterConnection) getCurrentServer() driver.Connection {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.servers[c.current]
} | go | {
"resource": ""
} |
q5750 | getSpecificServer | train | 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 {
re... | go | {
"resource": ""
} |
q5751 | getNextServer | train | 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 | {
"resource": ""
} |
q5752 | newCollection | train | 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 | {
"resource": ""
} |
q5753 | Unload | train | 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 W... | go | {
"resource": ""
} |
q5754 | UnmarshalJSON | train | 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 | {
"resource": ""
} |
q5755 | UnmarshalJSON | train | 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 | {
"resource": ""
} |
q5756 | newHTTPConnection | train | 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 *... | go | {
"resource": ""
} |
q5757 | readBody | train | 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
... | go | {
"resource": ""
} |
q5758 | parseResponseArray | train | 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 := reflec... | go | {
"resource": ""
} |
q5759 | newGraph | train | 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 | {
"resource": ""
} |
q5760 | Remove | train | 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 | {
"resource": ""
} |
q5761 | readChunkVST1_1 | train | 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:])
messag... | go | {
"resource": ""
} |
q5762 | WriteToVST1_1 | train | 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.P... | go | {
"resource": ""
} |
q5763 | Collection | train | 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 {
retur... | go | {
"resource": ""
} |
q5764 | Collections | train | 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... | go | {
"resource": ""
} |
q5765 | CreateCollection | train | 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")... | go | {
"resource": ""
} |
q5766 | newResponse | train | 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.ValueLeng... | go | {
"resource": ""
} |
q5767 | ReplaceDocument | train | 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 | {
"resource": ""
} |
q5768 | ReplaceDocuments | train | 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(InvalidArgumentErro... | go | {
"resource": ""
} |
q5769 | RemoveDocument | train | 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 | {
"resource": ""
} |
q5770 | View | train | 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 !=... | go | {
"resource": ""
} |
q5771 | ViewExists | train | 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)
i... | go | {
"resource": ""
} |
q5772 | Views | train | 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.C... | go | {
"resource": ""
} |
q5773 | CreateArangoSearchView | train | 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:"properti... | go | {
"resource": ""
} |
q5774 | VertexCollection | train | 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... | go | {
"resource": ""
} |
q5775 | VertexCollectionExists | train | 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.CheckSt... | go | {
"resource": ""
} |
q5776 | VertexCollections | train | 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... | go | {
"resource": ""
} |
q5777 | Endpoint | train | func (r *httpVPackResponse) Endpoint() string {
u := *r.resp.Request.URL
u.Path = ""
return u.String()
} | go | {
"resource": ""
} |
q5778 | getSlice | train | 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 | {
"resource": ""
} |
q5779 | String | train | 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 = res... | go | {
"resource": ""
} |
q5780 | buildChunks | train | 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))
}
minC... | go | {
"resource": ""
} |
q5781 | NewClient | train | 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 != ni... | go | {
"resource": ""
} |
q5782 | SynchronizeEndpoints | train | func (c *client) SynchronizeEndpoints(ctx context.Context) error {
return c.SynchronizeEndpoints2(ctx, "")
} | go | {
"resource": ""
} |
q5783 | autoSynchronizeEndpoints | train | func (c *client) autoSynchronizeEndpoints(interval time.Duration) {
for {
// SynchronizeEndpoints endpoints
c.SynchronizeEndpoints(nil)
// Wait a bit
time.Sleep(interval)
}
} | go | {
"resource": ""
} |
q5784 | add | train | 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 | {
"resource": ""
} |
q5785 | toMap | train | func (c WriteCondition) toMap() map[string]interface{} {
result := make(map[string]interface{})
for k, v := range c.conditions {
result[k] = v
}
return result
} | go | {
"resource": ""
} |
q5786 | IfEmpty | train | func (c WriteCondition) IfEmpty(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.OldEmpty = &condTrue
})
} | go | {
"resource": ""
} |
q5787 | IfIsArray | train | func (c WriteCondition) IfIsArray(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.IsArray = &condTrue
})
} | go | {
"resource": ""
} |
q5788 | IfEqualTo | train | func (c WriteCondition) IfEqualTo(key []string, oldValue interface{}) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.Old = oldValue
})
} | go | {
"resource": ""
} |
q5789 | newVertexCollection | train | 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,
}... | go | {
"resource": ""
} |
q5790 | Revision | train | 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 | {
"resource": ""
} |
q5791 | BasicAuthentication | train | func BasicAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeBasic,
userName: userName,
password: password,
}
} | go | {
"resource": ""
} |
q5792 | JWTAuthentication | train | func JWTAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeJWT,
userName: userName,
password: password,
}
} | go | {
"resource": ""
} |
q5793 | Get | train | func (a *userNameAuthentication) Get(property string) string {
switch property {
case "username":
return a.userName
case "password":
return a.password
default:
return ""
}
} | go | {
"resource": ""
} |
q5794 | Major | train | func (v Version) Major() int {
parts := strings.Split(string(v), ".")
result, _ := strconv.Atoi(parts[0])
return result
} | go | {
"resource": ""
} |
q5795 | Minor | train | func (v Version) Minor() int {
parts := strings.Split(string(v), ".")
if len(parts) >= 2 {
result, _ := strconv.Atoi(parts[1])
return result
}
return 0
} | go | {
"resource": ""
} |
q5796 | Sub | train | func (v Version) Sub() string {
parts := strings.SplitN(string(v), ".", 3)
if len(parts) == 3 {
return parts[2]
}
return ""
} | go | {
"resource": ""
} |
q5797 | SubInt | train | func (v Version) SubInt() (int, bool) {
result, err := strconv.Atoi(v.Sub())
return result, err == nil
} | go | {
"resource": ""
} |
q5798 | Keys | train | func (l DocumentMetaSlice) Keys() []string {
keys := make([]string, len(l))
for i, m := range l {
keys[i] = m.Key
}
return keys
} | go | {
"resource": ""
} |
q5799 | Revs | train | func (l DocumentMetaSlice) Revs() []string {
revs := make([]string, len(l))
for i, m := range l {
revs[i] = m.Rev
}
return revs
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.