id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c24700 | to read fixed body")
}
query.threadId = fixed.ThreadId
query.duration = fixed.Duration
query.errorCode = mysql_proto.ErrorCode_Type(fixed.ErrorCode)
data := raw.VariableLengthData()
dbNameEnd := int(fixed.StatusLength) + int(fixed.DatabaseNameLength)
if dbNameEnd+1 > len(data) {
return raw, errors.Newf("In... | |
c24701 |
if err != nil {
return raw, errors.Wrap(err, "Failed to read new log position")
}
return rotate, nil
} | |
c24702 |
eventType mysql_proto.LogEventType_Type) int {
return e.fixedLengthSizes[eventType]
} | |
c24703 | } else if len(data) == 40 { // mysql 5.6(.17)
// This is a relay log where the master is 5.5 and slave is 5.6
if data[int(mysql_proto.LogEventType_WRITE_ROWS_EVENT)-1] == 0 {
numEvents = 28
}
} else {
return raw, errors.Newf(
"Unable to parse FDE for mysql variant: %s",
fde.serverVersion)
}
// un... | |
c24704 | make(map[string]*_LockImp)
case ShardedGranularity:
lock.shardedLocks = make([]*sync.RWMutex, options.LockCount)
for i := range lock.shardedLocks {
lock.shardedLocks[i] = &sync.RWMutex{}
}
}
return &lock
} | |
c24705 | return &ShardedClient{
manager: manager,
builder: builder,
}
} | |
c24706 | []MutateResponse {
return shardClient.SetMulti(mapping.Items)
} | |
c24707 | []MutateResponse {
return shardClient.CasMulti(mapping.Items)
} | |
c24708 | []MutateResponse {
return shardClient.AddMulti(mapping.Items)
} | |
c24709 | shardClient.DeleteMulti(mapping.Keys)
} | |
c24710 | m.set(&TableMapEventParser{})
m.set(&XidEventParser{})
m.set(&RowsQueryEventParser{})
m.set(&GtidLogEventParser{})
m.set(&PreviousGtidsLogEventParser{})
m.set(newWriteRowsEventV1Parser())
m.set(newWriteRowsEventV2Parser())
m.set(newUpdateRowsEventV1Parser())
m.set(newUpdateRowsEventV2Parser())
m.set(newDelet... | |
c24711 | case error:
return e.Error()
default:
return "Passed a non-error to GetMessage"
}
} | |
c24712 | new(nil, fmt.Sprintf(format, args...))
} | |
c24713 | new(err, fmt.Sprintf(format, args...))
} | |
c24714 | := runtime.Callers(3, stack)
return &baseError{
msg: msg,
stack: stack[:stackLength],
inner: err,
}
} | |
c24715 | all inner errors.
// Add last message and exit loop.
errMsg.WriteString(innerErr.Error())
break
}
errMsg.WriteString("\n")
}
if includeStack {
errMsg.WriteString("\nORIGINAL STACK TRACE:\n")
errMsg.WriteString(lastDbxErr.GetStack())
}
return errMsg.String()
} | |
c24716 | a convention but paradoxically no
// interface. All of these panic on error.
errV := reflect.ValueOf(ierr).Elem()
errV = errV.FieldByName("Err")
return errV.Interface().(error)
} | |
c24717 | nerr = terr
}
return fmt.Errorf("too many iterations: %T", nerr)
} | |
c24718 | rootErrStr = rootErr.Error()
}
errConstStr := ""
if errConst != nil {
errConstStr = errConst.Error()
}
return rootErrStr == errConstStr
} | |
c24719 |
data := raw.VariableLengthData()
if len(data) < 1 {
return raw, errors.Newf("Invalid message length")
}
query.truncatedQuery = data[1:]
return query, nil
} | |
c24720 | options,
numActive: numActive,
activeHighWaterMark: activeHighWaterMark,
openTokens: tokens,
mutex: sync.Mutex{},
idleHandles: make([]*idleHandle, 0, 0),
isLameDuck: false,
}
} | |
c24721 | > 0 {
toClose = p.idleHandles[0:i]
}
if i < len(p.idleHandles) {
idle := p.idleHandles[i]
p.idleHandles = p.idleHandles[i+1:]
return NewManagedHandle(p.location, idle.handle, p, p.options)
}
if len(p.idleHandles) > 0 {
p.idleHandles = []*idleHandle{}
}
return nil
} | |
c24722 | := now.Add(*p.options.MaxIdleTime)
keepUntil = &x
}
p.mutex.Lock()
defer p.mutex.Unlock()
if p.isLameDuck {
toClose = []*idleHandle{
{handle: handle},
}
return
}
p.idleHandles = append(
p.idleHandles,
&idleHandle{
handle: handle,
keepUntil: keepUntil,
})
nIdleHandles := uint32(len(... | |
c24723 | {
for _, handle := range handles {
_ = p.options.Close(handle.handle)
}
} | |
c24724 | c.setTableName(name)
if err != nil {
panic(err)
}
t.columnLookup[c.Name()] = c
}
if len(columns) == 0 {
panic(fmt.Sprintf("Table %s has no columns", name))
}
return t
} | |
c24725 |
return nil, errors.Newf("No such column '%s' in table '%s'", name, t.name)
} | |
c24726 |
table: t,
colName: name,
}
} | |
c24727 | {
result = append(result, col)
}
return result
} | |
c24728 | *t
newTable.forcedIndex = index
return &newTable
} | |
c24729 |
return InnerJoinOn(t, table, onCondition)
} | |
c24730 |
return LeftJoinOn(t, table, onCondition)
} | |
c24731 |
return RightJoinOn(t, table, onCondition)
} | |
c24732 | return nil, errors.Newf("Not enough bytes for start/end: %v", data)
}
var start, end uint64
start, data = LittleEndian.Uint64(data[:8]), data[8:]
end, data = LittleEndian.Uint64(data[:8]), data[8:]
pgle.set[sid] = append(pgle.set[sid], GtidRange{start, end})
}
}
if len(data) > 0 {
return nil, ... | |
c24733 | []byte) {
for _, b := range data {
w.Write(hexMap[b])
}
} | |
c24734 | errors.New("Invalid pool")
}
}
if createPool == nil {
createPool = NewSimpleResourcePool
}
counter := new(int64)
atomic.StoreInt64(counter, 0)
shuffle(pools)
return &roundRobinResourcePool{
options: options,
createPool: createPool,
rwMutex: sync.RWMutex{},
isLameDuck: false,
pools: ... | |
c24735 | {
return mysql_proto.LogEventType_Type(e.header.EventType)
} | |
c24736 | end := len(e.data) - e.checksumSize
return e.data[begin:end]
} | |
c24737 | return errors.Newf(
"Invalid extra headers size (data size: %d basic header size: %d"+
"fixed length data size: %d checksum size: %d input: %d)",
len(e.data),
sizeOfBasicV4EventHeader,
e.fixedLengthDataSize,
e.checksumSize,
size)
}
e.extraHeadersSize = size
return nil
} | |
c24738 | Storage {
return &CacheOnStorage{
cache: cache,
storage: storage,
}
} | |
c24739 | {
if size%workSize != 0 {
rem := workSize - (size % workSize)
offset, err = io.ReadFull(socketRead, batch[size:size+rem])
size += offset
}
return
}
lastCheckedForNull = endCheck // need to check partial work items
} else {
return
}
}
}
return
} | |
c24740 | copyTo <- batch[:size]
}
if err != nil {
if err != io.EOF {
log.Print("Error encountered in readBatch:", err)
}
return
}
}
} | |
c24741 |
end := c.now.Add(delta)
c.advanceTo(end)
} | |
c24742 | defer c.mutex.Unlock()
c.advanceTo(t)
} | |
c24743 | c.mutex.Unlock()
return c.now
} | |
c24744 | conn.Do(req)
if err != nil {
if _, ok := err.(DialError); ok {
// do nothing. err is already wrapped.
} else if urlErr, ok := err.(*url.Error); ok {
if urlErr.Err == errFollowRedirectDisabled {
// This is not an actual error
return resp, nil
}
if _, ok := urlErr.Err.(DialError); ok {
err ... | |
c24745 | (resp *http.Response, err error) {
return pool.DoWithParams(req, DoParams{Timeout: timeout})
} | |
c24746 | (*http.Client, error) {
return pool.Get()
} | |
c24747 | defer pool.lock.Unlock()
pool.activeSetSize = size
} | |
c24748 | {
return pool.DoWithTimeout(req, 0)
} | |
c24749 |
return pool.DoWithParams(req, DoParams{Timeout: timeout})
} | |
c24750 | LBShuffledFixed:
// In ShuffledFixed strategy instances are also always traversed in
// same exact order.
idx = i
case LBConsistentHashing:
// In ConsistentHashing strategy instances are picked up randomly between
// start and start + numInstancesToTry. This is to load balance between
// the alive ... | |
c24751 | error) {
_, instance, _, err := pool.getInstance(nil, 1)
return instance, err
} | |
c24752 | pool.instanceList[idx] == instance {
pool.markDownUntil[idx] = downUntil
}
} | |
c24753 |
pool.markInstanceDown(idx, instance, 0)
} | |
c24754 | make(map[string]interface{}),
checkFunc: options.ValueCheckFunc,
}
} | |
c24755 | defer m.lock.RUnlock()
val, ok := m.data[key]
if ok && (m.checkFunc == nil || m.checkFunc(key, val)) {
return val, true
} else {
// No value or it failed to check
return nil, false
}
} | |
c24756 |
m.lock.Lock()
defer m.lock.Unlock()
delete(m.data, key)
} | |
c24757 |
return &managedConnImpl{
addr: addr,
handle: handle,
pool: pool,
options: options,
}
} | |
c24758 | := c.handle.Handle()
return h.(net.Conn)
} | |
c24759 | if err != nil {
return -1, err
}
lportInt, err := strconv.Atoi(lport)
if err != nil {
return -1, err
}
return lportInt, nil
} | |
c24760 |
src: rand.NewSource(seed),
}
} | |
c24761 | int64(now.Nanosecond()) + 12345*int64(os.Getpid())
} | |
c24762 | {
return time.Duration(Int63n(int64(max)))
} | |
c24763 | < k {
i := Intn(n)
picked.Add(i)
}
res = make([]int, k)
e := 0
for i := range picked.Iter() {
res[e] = i.(int)
e++
}
return
} | |
c24764 | = []interface{}{}
for _, idx := range idxs {
res = append(res, population[idx])
}
return
} | |
c24765 | := range population {
if len(idxs) > 0 && x == idxs[0] {
picked = append(picked, elem)
idxs = idxs[1:]
} else {
remaining = append(remaining, elem)
}
}
return
} | |
c24766 | 0; i-- {
collection.Swap(i, Intn(i+1))
}
} | |
c24767 | out of the two available channels.
// We should do one final immediate check below.
}
}
// Return true if we have a slot available immediately and false otherwise.
select {
case <-sem.slots:
return true
default:
return false
}
} | |
c24768 | "Invalid literal value"))
}
return &literalExpression{value: value}
} | |
c24769 | newBoolExpression(lhs, rhs, []byte(" IS "))
}
return newBoolExpression(lhs, rhs, []byte("="))
} | |
c24770 | {
return newBoolExpression(lhs, rhs, []byte("<"))
} | |
c24771 |
writer: bufio.NewWriter(channel),
reader: bufio.NewReader(channel),
}
} | |
c24772 | make(chan *rwwait, capacity),
control: &sync.Mutex{},
}
} | |
c24773 |
woken := me.WaitAtomic(deadline)
if !woken {
return errors.New("Waiter timeout")
}
} else {
rw.readers++
rw.control.Unlock()
}
return
} | |
c24774 |
}
woken := me.WaitAtomic(deadline)
if !woken {
return errors.New("Waiter timeout")
}
rw.control.Lock()
if rw.readers != 0 {
panic("readers??")
}
if rw.nextWriter != me {
panic("not me??")
}
} else {
rw.nextWriter = newWait(true)
}
rw.control.Unlock()
return
} | |
c24775 |
// They're gonna put it.
if !swapped {
<-wait.wake
return true
}
return false
} | |
c24776 | They've moved on.
return false
}
wait.wake <- true
return true
} | |
c24777 | platform.
_, err := readLittleEndian(raw.VariableLengthData(), &xe.xid)
if err != nil {
return raw, errors.Wrap(err, "Failed to read xid")
}
return xe, nil
} | |
c24778 | defer c.mutex.Unlock()
return c.getHelper(key)
} | |
c24779 | key := range keys {
res[key] = c.getHelper(key)
}
return res
} | |
c24780 | key,
StatusInternalError,
0)
}
_, ok := c.data[key]
if !ok {
return NewMutateResponse(
key,
StatusKeyNotFound,
0)
}
delete(c.data, key)
return NewMutateResponse(
key,
StatusNoError,
0)
} | |
c24781 | {
return NewMutateErrorResponse(key, errors.Newf("Append not implemented"))
} | |
c24782 |
// TODO(patrick): Use expiration argument
c.data = make(map[string]*Item)
return NewResponse(StatusNoError)
} | |
c24783 | {
return NewStatErrorResponse(errors.Newf("Stat not implemented"), nil)
} | |
c24784 | err != nil {
log.Fatal(err)
}
})
return myHostname
} | |
c24785 | true
}
if _, ok := err.(*FailedToOpenFileError); ok {
return true
}
return false
} | |
c24786 | _, _ = buf.WriteString(" WHERE ")
if err = q.where.SerializeSql(buf); err != nil {
return
}
}
if q.group != nil {
_, _ = buf.WriteString(" GROUP BY ")
if err = q.group.SerializeSql(buf); err != nil {
return
}
}
if q.order != nil {
_, _ = buf.WriteString(" ORDER BY ")
if err = q.order.Serializ... | |
c24787 | append(s.locks, tableLock{t: t, w: false})
return s
} | |
c24788 | append(s.locks, tableLock{t: t, w: true})
return s
} | |
c24789 | {
return >idNextStatementImpl{
sid: sid,
gno: gno,
}
} | |
c24790 | = true
} else {
return raw, errors.Newf("Commit data is not 0 or 1: %d", commitData)
}
data, err = readLittleEndian(data, &gle.sid)
if err != nil {
return raw, errors.Wrap(err, "Failed to read sid")
}
data, err = readLittleEndian(data, &gle.gno)
if err != nil {
return raw, errors.Wrap(err, "Failed to re... | |
c24791 | createPool: createPool,
rwMutex: sync.RWMutex{},
isLameDuck: false,
locationPools: make(map[string]ResourcePool),
}
} | |
c24792 |
return string(v.Inner.raw())
} | |
c24793 |
if _, err := b.Write(nullstr); err != nil {
panic(err)
}
} else {
v.Inner.encodeSql(b)
}
} | |
c24794 |
if _, err := b.Write(nullstr); err != nil {
panic(err)
}
} else {
v.Inner.encodeAscii(b)
}
} | |
c24795 | []byte{byte(NullType)}, nil
}
return v.Inner.MarshalBinary()
} | |
c24796 | }
switch typ {
case NumericType:
*v = Value{Numeric(raw)}
case FractionalType:
*v = Value{Fractional(raw)}
case StringType:
*v = Value{String{raw, false}}
case UTF8StringType:
*v = Value{String{raw, true}}
default:
return errors.Newf("Unknown type %d", int(typ))
}
return nil
} | |
c24797 | if row[i].IsNull() {
continue
}
err := ConvertAssign(row[i], dest[i])
if err != nil {
return err
}
}
return nil
} | |
c24798 | err != nil {
return err
}
return ConvertAssign(v, dest)
}
return ConvertAssign(src, dest)
} | |
c24799 | num uint64) {
numVal, _ := BuildValue(num)
numVal.EncodeSql(b)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.