id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5700 | is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &database{
name: name,
conn: conn,
}, nil
} | |
c5701 | 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,... | |
c5702 |
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5703 |
}
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, ni... | |
c5704 |
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
} | |
c5705 | 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
} | |
c5706 | path.Join("/_db/_system/_api/database/user"))
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | |
c5707 | 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
} | |
c5708 | 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
} | |
c5709 | 0, "Cluster expected, found SINGLE server"))
}
cl, err := newCluster(c.conn)
if err != nil {
return nil, WithStack(err)
}
return cl, nil
} | |
c5710 |
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 &batc... | |
c5711 |
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
} | |
c5712 | 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
} | |
c5713 | return nil, driver.WithStack(err)
}
return conn, nil
}, config.Endpoints)
if err != nil {
return nil, driver.WithStack(err)
}
return c, nil
} | |
c5714 |
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 ... | |
c5715 | ch != nil {
m.responseChan = nil
close(ch)
}
}
} | |
c5716 |
m.chunks = append(m.chunks, c)
if c.IsFirst() {
m.numberOfChunks = c.NumberOfChunks()
}
} | |
c5717 |
// 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
} | |
c5718 | := range i.Collections {
if !c.IsReady {
return false
}
}
return true
} | |
c5719 | }
return i.Collections[0].PlanVersion
} | |
c5720 | if c.Parameters.Name == name {
return c, true
}
}
return InventoryCollection{}, false
} | |
c5721 | return v, true
}
}
return InventoryView{}, false
} | |
c5722 |
for _, idx := range i.Indexes {
if idx.Type == indexType && idx.FieldsEqual(fields) {
return idx, true
}
}
return InventoryIndex{}, false
} | |
c5723 | stringSliceEqualsIgnoreOrder(i.Fields, fields)
} | |
c5724 | x := range a {
if _, found := bMap[x]; !found {
return false
}
}
return true
} | |
c5725 | s.mutex.RUnlock()
return len(s.messages)
} | |
c5726 |
defer s.mutex.RUnlock()
m, ok := s.messages[id]
if ok {
return m
}
return nil
} | |
c5727 |
}
m := &Message{
ID: id,
responseChan: make(chan Message),
}
s.messages[id] = m
return m
} | |
c5728 | s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.messages, id)
} | |
c5729 |
for _, m := range s.messages {
cb(m)
}
} | |
c5730 | result)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | |
c5731 | update)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | |
c5732 | }
}
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
defa... | |
c5733 | is nil"})
}
if auth == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "auth is nil"})
}
return &authenticatedConnection{
conn: conn,
auth: auth,
}, nil
} | |
c5734 |
return driver.WithStack(err)
}
// We're now prepared
atomic.StoreInt32(&c.prepared, 1)
} else {
// We're already prepared, do nothing
}
return nil
} | |
c5735 | return &Transport{
TransportConfig: config,
hostAddr: hostAddr,
tlsConfig: tlsConfig,
}
} | |
c5736 | 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
} | |
c5737 | c.connMutex.Unlock()
for _, conn := range c.connections {
// Close connection
go conn.Close()
}
} | |
c5738 | *Connection) error) {
c.onConnectionCreated = handler
} | |
c5739 | != 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
} | |
c5740 | 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 >... | |
c5741 | }
// 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
} | |
c5742 | / 10)
_, remaining := c.CloseIdleConnections()
if remaining == 0 {
return
}
}
} | |
c5743 | 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 tempo... | |
c5744 | increaseDelay(lastDelay, 1.5, time.Millisecond, time.Second*2)
} | |
c5745 | delay < min {
delay = min
}
if delay > max {
delay = max
}
return delay
} | |
c5746 | 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 ArangoSearc... | |
c5747 | 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
} | |
c5748 | 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
} | |
c5749 | defer c.mutex.RUnlock()
return c.servers[c.current]
} | |
c5750 | }
}
if found {
return s, nil
}
}
return nil, driver.WithStack(driver.InvalidArgumentError{Message: fmt.Sprintf("unknown endpoint: %s", endpoint)})
} | |
c5751 | c.current = (c.current + 1) % len(c.servers)
return c.servers[c.current]
} | |
c5752 | is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &collection{
name: name,
db: db,
conn: db.conn,
}, nil
} | |
c5753 |
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5754 |
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | |
c5755 | json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | |
c5756 | 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 >... | |
c5757 | 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
} | |
c5758 | 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] = er... | |
c5759 | is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &graph{
name: name,
db: db,
conn: db.conn,
}, nil
} | |
c5760 | WithStack(err)
}
if err := resp.CheckStatus(201, 202); err != nil {
return WithStack(err)
}
return nil
} | |
c5761 |
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:... | |
c5762 | != 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
} | |
c5763 | resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
coll, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return coll, nil
} | |
c5764 | }
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
} | |
c5765 | 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
} | |
c5766 | 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() {
retu... | |
c5767 | document)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | |
c5768 | := 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.r... | |
c5769 |
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | |
c5770 |
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
} | |
c5771 |
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)
}
} | |
c5772 | 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
} | |
c5773 | 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)
}
re... | |
c5774 |
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"))
} | |
c5775 | 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 tr... | |
c5776 | 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
} | |
c5777 | *r.resp.Request.URL
u.Path = ""
return u.String()
} | |
c5778 | == nil {
r.slice = velocypack.Slice(r.rawResponse)
//fmt.Println(r.slice)
}
return r.slice, nil
} | |
c5779 | append(lines, fmt.Sprintf("%s: %v", k, v))
}
sort.Strings(lines)
result = result + "\n" + strings.Join(lines, "\n")
}
return result
} | |
c5780 | 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
} el... | |
c5781 | {
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
} | |
c5782 | c.SynchronizeEndpoints2(ctx, "")
} | |
c5783 |
// SynchronizeEndpoints endpoints
c.SynchronizeEndpoints(nil)
// Wait a bit
time.Sleep(interval)
}
} | |
c5784 | fullKey := createFullKey(key)
wc := c.conditions[fullKey]
updater(&wc)
c.conditions[fullKey] = wc
return c
} | |
c5785 | make(map[string]interface{})
for k, v := range c.conditions {
result[k] = v
}
return result
} | |
c5786 | func(wc *writeCondition) {
wc.OldEmpty = &condTrue
})
} | |
c5787 | func(wc *writeCondition) {
wc.IsArray = &condTrue
})
} | |
c5788 | c.add(key, func(wc *writeCondition) {
wc.Old = oldValue
})
} | |
c5789 | is empty"})
}
if g == nil {
return nil, WithStack(InvalidArgumentError{Message: "g is nil"})
}
return &vertexCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
} | |
c5790 | err := c.rawCollection().Revision(ctx)
if err != nil {
return "", WithStack(err)
}
return result, nil
} | |
c5791 | AuthenticationTypeBasic,
userName: userName,
password: password,
}
} | |
c5792 | AuthenticationTypeJWT,
userName: userName,
password: password,
}
} | |
c5793 | case "password":
return a.password
default:
return ""
}
} | |
c5794 | := strconv.Atoi(parts[0])
return result
} | |
c5795 | result, _ := strconv.Atoi(parts[1])
return result
}
return 0
} | |
c5796 | len(parts) == 3 {
return parts[2]
}
return ""
} | |
c5797 | strconv.Atoi(v.Sub())
return result, err == nil
} | |
c5798 | m := range l {
keys[i] = m.Key
}
return keys
} | |
c5799 | m := range l {
revs[i] = m.Rev
}
return revs
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.