id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c172300 |
in[2]<<7 |
in[3]<<10 |
in[4]<<13 |
in[5]<<16 |
in[6]<<19 |
in[7]<<22 |
in[8]<<25
} | |
c172301 |
in[3]<<12 |
in[4]<<16 |
in[5]<<20 |
in[6]<<24
} | |
c172302 | {
return 0, fmt.Errorf("invalid selector value: %b", sel)
}
selector[sel].unpack(v, (*[240]uint64)(unsafe.Pointer(&dst[j])))
j += selector[sel].n
}
return j, nil
} | |
c172303 | return nil
}
return c.out.Bytes()
} | |
c172304 | c.err = c.step2(in)
case 3:
c.err = c.step3(in)
}
return c.step > 2 || c.err != nil
} | |
c172305 |
return nil, err
}
info.Timeout = timeout
return DialWithInfo(info)
} | |
c172306 |
fallthrough
default:
return nil, errors.New("unsupported connection URL option: " + k + "=" + v)
}
}
info := DialInfo{
Addrs: uinfo.addrs,
Direct: direct,
Database: uinfo.db,
Username: uinfo.user,
Password: uinfo.pass,
Mechanism: mechanism,
Service: service,
Source: source,
PoolLimit: poolLimit,
ReplicaSetName: setName,
}
return &info, nil
} | |
c172307 | s.cluster().LiveServers()
s.m.RUnlock()
return addrs
} | |
c172308 | s.defaultdb
}
return &Database{s, name}
} | |
c172309 | {
return &Collection{db, name, db.Name + "." + name}
} | |
c172310 | *db
newdb.Session = s
return &newdb
} | |
c172311 | := *c.Database
newdb.Session = s
newc := *c
newc.Database = &newdb
return &newc
} | |
c172312 | session.creds = session.creds[:len(session.creds)-1]
found = true
break
}
}
if found {
if session.masterSocket != nil {
session.masterSocket.Logout(dbname)
}
if session.slaveSocket != nil {
session.slaveSocket.Logout(dbname)
}
}
session.m.Unlock()
} | |
c172313 | s.masterSocket.Logout(cred.Source)
}
if s.slaveSocket != nil {
s.slaveSocket.Logout(cred.Source)
}
}
s.creds = s.creds[0:0]
s.m.Unlock()
} | |
c172314 | return users.Remove(bson.M{"user": user})
}
if isNotFound(err) {
return ErrNotFound
}
return err
} | |
c172315 | s.m.Unlock()
scopy.Refresh()
return scopy
} | |
c172316 | s.m.Unlock()
scopy.Refresh()
return scopy
} | |
c172317 | true)
s.m.Unlock()
return scopy
} | |
c172318 | session %p", s)
s.unsetSocket()
s.cluster_.Release()
s.cluster_ = nil
}
s.m.Unlock()
} | |
c172319 | = s.consistency != Strong
s.unsetSocket()
s.m.Unlock()
} | |
c172320 | s.syncTimeout = d
s.m.Unlock()
} | |
c172321 |
if s.slaveSocket != nil {
s.slaveSocket.SetTimeout(d)
}
s.m.Unlock()
} | |
c172322 | |= flagNoCursorTimeout
} else {
panic("SetCursorTimeout: only 0 (disable timeout) supported for now")
}
s.m.Unlock()
} | |
c172323 |
s.poolLimit = limit
s.m.Unlock()
} | |
c172324 | cmd.J}
switch w := cmd.W.(type) {
case string:
safe.WMode = w
case int:
safe.W = w
}
}
return
} | |
c172325 | {
return s.Run(bson.D{{"fsync", 1}, {"async", async}}, nil)
} | |
c172326 | s.DB("admin").C("$cmd.sys.unlock").Find(nil).One(nil) // WTF?
} | |
c172327 | int64
}
}
cmd := repairCmd{
RepairCursor: c.Name,
Cursor: &repairCmdCursor{batchSize},
}
clonedc := c.With(cloned)
err := clonedc.Database.Run(cmd, &result)
return clonedc.NewIter(session, result.Cursor.FirstBatch, result.Cursor.Id, err)
} | |
c172328 | Cursor struct {
FirstBatch []bson.Raw "firstBatch"
Id int64
}
}
cmd := pipeCmd{
Aggregate: c.Name,
Pipeline: p.pipeline,
AllowDisk: p.allowDisk,
Cursor: &pipeCmdCursor{p.batchSize},
}
err := c.Database.Run(cmd, &result)
if e, ok := err.(*QueryError); ok && e.Message == `unrecognized field "cursor` {
cmd.Cursor = nil
cmd.AllowDisk = false
err = c.Database.Run(cmd, &result)
}
firstBatch := result.Result
if firstBatch == nil {
firstBatch = result.Cursor.FirstBatch
}
return c.NewIter(p.session, firstBatch, result.Cursor.Id, err)
} | |
c172329 | err := iter.Err(); err != nil {
return err
}
return ErrNotFound
} | |
c172330 | *Pipe {
p.batchSize = n
return p
} | |
c172331 | == 11001 || e.Code == 12582 || e.Code == 16460 && strings.Contains(e.Err, " E11000 ")
case *QueryError:
return e.Code == 11000 || e.Code == 11001 || e.Code == 12582
}
return false
} | |
c172332 | {
return c.Database.Run(bson.D{{"drop", c.Name}}, nil)
} | |
c172333 |
q.op.skip = int32(n)
q.m.Unlock()
return q
} | |
c172334 | 0:
q.limit = int32(-n)
q.op.limit = int32(n)
default:
q.limit = int32(n)
q.op.limit = int32(n)
}
q.m.Unlock()
return q
} | |
c172335 |
q.op.hasOptions = true
q.m.Unlock()
return q
} | |
c172336 |
q.op.flags |= flagLogReplay
q.m.Unlock()
return q
} | |
c172337 | for iter.Next(&coll) {
names = append(names, coll.Name)
}
if err := iter.Close(); err != nil {
return nil, err
}
sort.Strings(names)
return names, err
}
if err != nil && !isNoCmd(err) {
return nil, err
}
// Command not yet supported. Query the database instead.
nameIndex := len(db.Name) + 1
iter := db.C("system.namespaces").Find(nil).Iter()
var coll struct{ Name string }
for iter.Next(&coll) {
if strings.Index(coll.Name, "$") < 0 || strings.Index(coll.Name, ".oplog.$") >= 0 {
names = append(names, coll.Name[nameIndex:])
}
}
if err := iter.Close(); err != nil {
return nil, err
}
sort.Strings(names)
return names, nil
} | |
c172338 | range result.Databases {
if !db.Empty {
names = append(names, db.Name)
}
}
sort.Strings(names)
return names, nil
} | |
c172339 |
iter.m.Unlock()
return result
} | |
c172340 | := op.query
if query == nil {
query = bson.D{}
}
result := struct{ N int }{}
err = session.DB(dbname).Run(countCmd{cname, query, limit, op.skip}, &result)
return result.N, err
} | |
c172341 |
return c.Find(nil).Count()
} | |
c172342 | if i == len(bi.VersionArray) {
return false
}
if bi.VersionArray[i] < version[i] {
return false
}
}
return true
} | |
c172343 | i)
}
}
for len(info.VersionArray) < 4 {
info.VersionArray = append(info.VersionArray, 0)
}
if i := strings.IndexByte(info.GitVersion, ' '); i >= 0 {
// Strip off the " modules: enterprise" suffix. This is a _git version_.
// That information may be moved to another field if people need it.
info.GitVersion = info.GitVersion[:i]
}
return
} | |
c172344 | if s.slaveSocket != nil {
panic("setSocket(slave) with existing slave socket reserved")
}
s.slaveSocket = socket
}
} | |
c172345 | // Copy the data.
query.collection = dbname + ".$cmd"
query.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
replyData = docData
replyErr = err
mutex.Unlock()
}
err = socket.Query(op, &query)
if err != nil {
return nil, err
}
mutex.Lock() // Wait.
if replyErr != nil {
return nil, replyErr // XXX TESTME
}
if hasErrMsg(replyData) {
// Looks like getLastError itself failed.
err = checkQueryError(query.collection, replyData)
if err != nil {
return nil, err
}
}
result := &LastError{}
bson.Unmarshal(replyData, &result)
debugf("Result from writing query: %#v", result)
if result.Err != "" {
return result, result
}
return result, nil
} | |
c172346 | (refs=%d)", cluster, cluster.references)
cluster.Unlock()
} | |
c172347 | cluster.servers.Slice() {
server.Close()
}
// Wake up the sync loop so it can die.
cluster.syncServers()
stats.cluster(-1)
}
cluster.Unlock()
} | |
c172348 | restart := !direct && cluster.masters.Empty() || cluster.servers.Empty()
cluster.Unlock()
if restart {
log("SYNC No masters found. Will synchronize again.")
time.Sleep(syncShortDelay)
continue
}
debugf("SYNC Cluster %p waiting for next requested or scheduled sync.", cluster)
// Hold off until somebody explicitly requests a synchronization
// or it's time to check for a cluster topology change again.
select {
case <-cluster.sync:
case <-time.After(syncServersDelay):
}
}
debugf("SYNC Cluster %p is stopping its sync loop.", cluster)
} | |
c172349 | = nil
server.Unlock()
logf("Connections to %s closing (%d live sockets).", server.Addr, len(liveSockets))
for i, s := range liveSockets {
s.Close()
liveSockets[i] = nil
}
for i := range unusedSockets {
unusedSockets[i] = nil
}
} | |
c172350 |
if !server.closed {
server.unusedSockets = append(server.unusedSockets, socket)
}
server.Unlock()
} | |
c172351 | server.Unlock()
// Maybe just a timeout, but suggest a cluster sync up just in case.
select {
case server.sync <- true:
default:
}
} | |
c172352 | // Prefer nearest server.
swap = next.pingValue < best.pingValue
case len(next.liveSockets)-len(next.unusedSockets) < len(best.liveSockets)-len(best.unusedSockets):
// Prefer servers with less connections.
swap = true
}
if swap {
best.RUnlock()
best = next
} else {
next.RUnlock()
}
}
if best != nil {
best.RUnlock()
}
return best
} | |
c172353 | == 0 {
panic("template name cannot be empty")
}
r.Templates[name] = tmpl
} | |
c172354 | } else {
tpl = r.Templates[name]
}
return render.HTML{
Template: tpl,
Data: data,
}
} | |
c172355 | + " template name mismatch")
}
return template.Must(tpl, err)
} | |
c172356 | TemplatesDir: TemplatesDir,
Layout: Layout,
Ext: Ext,
Debug: Debug,
}
} | |
c172357 | `panic: template: redefinition of template "layout"`
name := r.getTemplateName(tpl)
if name == r.Layout {
continue
}
r.AddFromFiles(name, layout, tpl)
}
return r
} | |
c172358 | htmlRender.TemplatesDir = \"your-tpl-dir/\"")
}
// check for layout file
layoutFile := r.TemplatesDir + r.Layout + r.Ext
if ok, _ := exists(layoutFile); !ok {
panic(layoutFile + " layout file does not exist")
}
} | |
c172359 | = newNonce()
}
return token(t.Id.Hex() + "_" + nonce)
} | |
c172360 | tc.Database.C(tc.Name + ".stash"), nil}
} | |
c172361 |
Ops: ops,
State: tpreparing,
Info: info,
}
if err = r.tc.Insert(&t); err != nil {
return err
}
if err = flush(r, &t); err != nil {
return err
}
if t.State == taborted {
return ErrAborted
} else if t.State != tapplied {
panic(fmt.Errorf("invalid state for %s after flush: %q", &t, t.State))
}
return nil
} | |
c172362 | iter.Next(&t) {
if t.State == tapplied || t.State == taborted {
continue
}
debugf("Resuming %s from %q", t.Id, t.State)
if err := flush(r, &t); err != nil {
return err
}
if !t.done() {
panic(fmt.Errorf("invalid state for %s after flush: %q", &t, t.State))
}
}
return nil
} | |
c172363 |
if err := flush(r, t); err != nil {
return err
}
}
if t.State == taborted {
return ErrAborted
} else if t.State != tapplied {
panic(fmt.Errorf("invalid state for %s after flush: %q", t, t.State))
}
return nil
} | |
c172364 | c.KillChance > 0 || c.SlowdownChance > 0
} | |
c172365 |
c.Set("db", s.DB(db.Mongo.Database))
c.Next()
} | |
c172366 | c.HTML(http.StatusBadRequest, "400", gin.H{
"errors": c.Errors,
})
}
} | |
c172367 | }
// XXX Add tt to the query here, once we're sure it's all working.
// Not having it increases the chances of breaking on bad logic.
qdoc = append(qdoc, bson.DocElem{"txn-revno", revnoq})
if op.Assert != DocExists {
qdoc = append(qdoc, bson.DocElem{"$or", []interface{}{op.Assert}})
}
}
c := f.tc.Database.C(op.C)
if err := c.Find(qdoc).Select(bson.D{{"_id", 1}}).One(nil); err == mgo.ErrNotFound {
// Assertion failed or someone else started applying.
return f.abortOrReload(t, revnos, pull)
} else if err != nil {
return err
}
}
f.debugf("Asserting %s succeeded", t)
return nil
} | |
c172368 | := socket.server
socket.Unlock()
return server
} | |
c172369 | := socket.serverInfo
socket.Unlock()
return serverInfo
} | |
c172370 | socket.Unlock()
return dead
}
socket.references++
socket.serverInfo = serverInfo
socket.timeout = timeout
stats.socketsInUse(+1)
stats.socketRefs(+1)
socket.Unlock()
return nil
} | |
c172371 | still supposed to release the socket.
socket.references++
stats.socketRefs(+1)
serverInfo := socket.serverInfo
socket.Unlock()
return serverInfo
} | |
c172372 | socket.LogoutAll()
// If the socket is dead server is nil.
if server != nil {
server.RecycleSocket(socket)
}
} else {
socket.Unlock()
}
} | |
c172373 | socket.timeout = d
socket.Unlock()
} | |
c172374 | for key, err := range e.MapErrs {
buff.WriteString(fmt.Sprintf(mapErrMsg, e.Field, key, "\n"+err.Error()))
}
}
return strings.TrimSpace(buff.String())
}
return fmt.Sprintf(fieldErrMsg, e.Field, e.Tag)
} | |
c172375 | {
buff.WriteString(err.Error())
buff.WriteString("\n")
}
for _, err := range e.StructErrors {
buff.WriteString(err.Error())
}
return strings.TrimSpace(buff.String())
} | |
c172376 | &sync.Pool{New: newStructErrors}
return &Validate{
tagName: tagName,
validationFuncs: funcs,
}
} | |
c172377 | return v.FieldWithValue(nil, f, tag)
} | |
c172378 |
return v.fieldWithNameAndValue(nil, val, f, tag, "", true, nil)
} | |
c172379 | != nil {
c.Error(err)
return
}
err = db.C(models.CollectionArticle).Insert(article)
if err != nil {
c.Error(err)
}
c.Redirect(http.StatusMovedPermanently, "/articles")
} | |
c172380 | err := db.C(models.CollectionArticle).FindId(oID).One(&article)
if err != nil {
c.Error(err)
}
c.HTML(http.StatusOK, "articles/form", gin.H{
"title": "Edit article",
"article": article,
})
} | |
c172381 |
}
c.HTML(http.StatusOK, "articles/list", gin.H{
"title": "Articles",
"articles": articles,
})
} | |
c172382 | article.Body,
"updated_on": time.Now().UnixNano() / int64(time.Millisecond),
}
err = db.C(models.CollectionArticle).Update(query, doc)
if err != nil {
c.Error(err)
}
c.Redirect(http.StatusMovedPermanently, "/articles")
} | |
c172383 |
err := db.C(models.CollectionArticle).Remove(query)
if err != nil {
c.Error(err)
}
c.Redirect(http.StatusMovedPermanently, "/articles")
} | |
c172384 | panic(fmt.Sprintf("Invalid input to ObjectIdHex: %q", s))
}
return ObjectId(d)
} | |
c172385 | _, err := hex.DecodeString(s)
return err == nil
} | |
c172386 | = machineId[2]
// Pid, 2 bytes, specs don't specify endianness, but we use big endian.
pid := os.Getpid()
b[7] = byte(pid >> 8)
b[8] = byte(pid)
// Increment, 3 bytes, big endian
i := atomic.AddUint32(&objectIdCounter, 1)
b[9] = byte(i >> 16)
b[10] = byte(i >> 8)
b[11] = byte(i)
return ObjectId(b[:])
} | |
c172387 | uint32(t.Unix()))
return ObjectId(string(b[:]))
} | |
c172388 | {
return []byte(fmt.Sprintf(`"%x"`, string(id))), nil
} | |
c172389 | ObjectId: %q", string(id)))
}
return []byte(string(id)[start:end])
} | |
c172390 | secs := int64(binary.BigEndian.Uint32(id.byteSlice(0, 4)))
return time.Unix(secs, 0)
} | |
c172391 | is stored as big-endian 3-byte value
return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
} | |
c172392 | append(b.inserts, docs...)
} | |
c172393 |
op.flags = 1 // ContinueOnError
}
_, err := b.c.writeQuery(op)
if err != nil {
return nil, &bulkError{err}
}
return &BulkResult{}, nil
} | |
c172394 |
return int64(st.Len()) == p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() == p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() == p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() == p
}
panic(fmt.Sprintf("Bad field type %T", field))
} | |
c172395 | interface{}, param string) bool {
return isGte(top, current, field, param)
} | |
c172396 | interface{}, param string) bool {
return isLte(top, current, field, param)
} | |
c172397 | panic(err.Error())
}
s.SetSafe(&mgo.Safe{})
fmt.Println("Connected to", uri)
Session = s
Mongo = mongo
} | |
c172398 | globalMutex.Unlock()
}
globalDebug = debug
} | |
c172399 |
if e := gfs.RemoveId(doc.Id); e != nil {
err = e
}
}
if err == nil {
err = iter.Close()
}
return err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.