_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24700 | Parse | train | func (p *QueryEventParser) Parse(raw *RawV4Event) (Event, error) {
query := &QueryEvent{
Event: raw,
}
type fixedBodyStruct struct {
ThreadId uint32
Duration uint32
DatabaseNameLength uint8
ErrorCode uint16
StatusLength uint16
}
fixed := fixedBodyStruct{}
_, err :... | go | {
"resource": ""
} |
q24701 | Parse | train | func (p *RotateEventParser) Parse(raw *RawV4Event) (Event, error) {
rotate := &RotateEvent{
Event: raw,
newLogName: raw.VariableLengthData(),
}
_, err := readLittleEndian(raw.FixedLengthData(), &rotate.newPosition)
if err != nil {
return raw, errors.Wrap(err, "Failed to read new log position")
}
retu... | go | {
"resource": ""
} |
q24702 | FixedLengthDataSizeForType | train | func (e *FormatDescriptionEvent) FixedLengthDataSizeForType(
eventType mysql_proto.LogEventType_Type) int {
return e.fixedLengthSizes[eventType]
} | go | {
"resource": ""
} |
q24703 | Parse | train | func (p *FormatDescriptionEventParser) Parse(raw *RawV4Event) (Event, error) {
fde := &FormatDescriptionEvent{
Event: raw,
fixedLengthSizes: make(map[mysql_proto.LogEventType_Type]int),
}
data := raw.VariableLengthData()
data, err := readLittleEndian(data, &fde.binlogVersion)
if err != nil {
ret... | go | {
"resource": ""
} |
q24704 | New | train | func New(options LockStoreOptions) LockStore {
testTryLockCallback := options.testTryLockCallback
if testTryLockCallback == nil {
testTryLockCallback = func() {}
}
lock := _LockStoreImp{
granularity: options.Granularity,
testTryLockCallback: testTryLockCallback,
}
switch options.Granularity {
cas... | go | {
"resource": ""
} |
q24705 | NewShardedClient | train | func NewShardedClient(
manager ShardManager,
builder ClientShardBuilder) Client {
return &ShardedClient{
manager: manager,
builder: builder,
}
} | go | {
"resource": ""
} |
q24706 | setMultiMutator | train | func setMultiMutator(shardClient Client, mapping *ShardMapping) []MutateResponse {
return shardClient.SetMulti(mapping.Items)
} | go | {
"resource": ""
} |
q24707 | casMultiMutator | train | func casMultiMutator(shardClient Client, mapping *ShardMapping) []MutateResponse {
return shardClient.CasMulti(mapping.Items)
} | go | {
"resource": ""
} |
q24708 | addMultiMutator | train | func addMultiMutator(shardClient Client, mapping *ShardMapping) []MutateResponse {
return shardClient.AddMulti(mapping.Items)
} | go | {
"resource": ""
} |
q24709 | deleteMultiMutator | train | func deleteMultiMutator(shardClient Client, mapping *ShardMapping) []MutateResponse {
return shardClient.DeleteMulti(mapping.Keys)
} | go | {
"resource": ""
} |
q24710 | NewV4EventParserMap | train | func NewV4EventParserMap() V4EventParserMap {
m := &v4EventParserMap{
extraHeadersSize: nonFDEExtraHeadersSize,
checksumSize: 0,
parsers: make(map[mysql_proto.LogEventType_Type]V4EventParser),
}
// TODO(patrick): implement parsers
m.set(&FormatDescriptionEventParser{})
m.set(&QueryEventParser{}... | go | {
"resource": ""
} |
q24711 | GetMessage | train | func GetMessage(err interface{}) string {
switch e := err.(type) {
case DropboxError:
return extractFullErrorMessage(e, false)
case runtime.Error:
return runtime.Error(e).Error()
case error:
return e.Error()
default:
return "Passed a non-error to GetMessage"
}
} | go | {
"resource": ""
} |
q24712 | Newf | train | func Newf(format string, args ...interface{}) DropboxError {
return new(nil, fmt.Sprintf(format, args...))
} | go | {
"resource": ""
} |
q24713 | Wrapf | train | func Wrapf(err error, format string, args ...interface{}) DropboxError {
return new(err, fmt.Sprintf(format, args...))
} | go | {
"resource": ""
} |
q24714 | new | train | func new(err error, msg string) *baseError {
stack := make([]uintptr, 200)
stackLength := runtime.Callers(3, stack)
return &baseError{
msg: msg,
stack: stack[:stackLength],
inner: err,
}
} | go | {
"resource": ""
} |
q24715 | extractFullErrorMessage | train | func extractFullErrorMessage(e DropboxError, includeStack bool) string {
var ok bool
var lastDbxErr DropboxError
errMsg := bytes.NewBuffer(make([]byte, 0, 1024))
dbxErr := e
for {
lastDbxErr = dbxErr
errMsg.WriteString(dbxErr.GetMessage())
innerErr := dbxErr.GetInner()
if innerErr == nil {
break
}
... | go | {
"resource": ""
} |
q24716 | unwrapError | train | func unwrapError(ierr error) (nerr error) {
// Internal errors have a well defined bit of context.
if dbxErr, ok := ierr.(DropboxError); ok {
return dbxErr.GetInner()
}
// At this point, if anything goes wrong, just return nil.
defer func() {
if x := recover(); x != nil {
nerr = nil
}
}()
// Go system... | go | {
"resource": ""
} |
q24717 | RootError | train | func RootError(ierr error) (nerr error) {
nerr = ierr
for i := 0; i < 20; i++ {
terr := unwrapError(nerr)
if terr == nil {
return nerr
}
nerr = terr
}
return fmt.Errorf("too many iterations: %T", nerr)
} | go | {
"resource": ""
} |
q24718 | IsError | train | func IsError(err, errConst error) bool {
if err == errConst {
return true
}
// Must rely on string equivalence, otherwise a value is not equal
// to its pointer value.
rootErrStr := ""
rootErr := RootError(err)
if rootErr != nil {
rootErrStr = rootErr.Error()
}
errConstStr := ""
if errConst != nil {
err... | go | {
"resource": ""
} |
q24719 | Parse | train | func (p *RowsQueryEventParser) Parse(raw *RawV4Event) (Event, error) {
query := &RowsQueryEvent{
Event: raw,
}
data := raw.VariableLengthData()
if len(data) < 1 {
return raw, errors.Newf("Invalid message length")
}
query.truncatedQuery = data[1:]
return query, nil
} | go | {
"resource": ""
} |
q24720 | NewSimpleResourcePool | train | func NewSimpleResourcePool(options Options) ResourcePool {
numActive := new(int32)
atomic.StoreInt32(numActive, 0)
activeHighWaterMark := new(int32)
atomic.StoreInt32(activeHighWaterMark, 0)
var tokens sync2.Semaphore
if options.OpenMaxConcurrency > 0 {
tokens = sync2.NewBoundedSemaphore(uint(options.OpenMaxC... | go | {
"resource": ""
} |
q24721 | getIdleHandle | train | func (p *simpleResourcePool) getIdleHandle() ManagedHandle {
var toClose []*idleHandle
defer func() {
// NOTE: Must keep the closure around to late bind the toClose slice.
p.closeHandles(toClose)
}()
now := p.options.getCurrentTime()
p.mutex.Lock()
defer p.mutex.Unlock()
var i int
for i = 0; i < len(p.id... | go | {
"resource": ""
} |
q24722 | queueIdleHandles | train | func (p *simpleResourcePool) queueIdleHandles(handle interface{}) {
var toClose []*idleHandle
defer func() {
// NOTE: Must keep the closure around to late bind the toClose slice.
p.closeHandles(toClose)
}()
now := p.options.getCurrentTime()
var keepUntil *time.Time
if p.options.MaxIdleTime != nil {
// NOTE... | go | {
"resource": ""
} |
q24723 | closeHandles | train | func (p *simpleResourcePool) closeHandles(handles []*idleHandle) {
for _, handle := range handles {
_ = p.options.Close(handle.handle)
}
} | go | {
"resource": ""
} |
q24724 | NewTable | train | func NewTable(name string, columns ...NonAliasColumn) *Table {
if !validIdentifierName(name) {
panic("Invalid table name")
}
t := &Table{
name: name,
columns: columns,
columnLookup: make(map[string]NonAliasColumn),
}
for _, c := range columns {
err := c.setTableName(name)
if err != nil {
... | go | {
"resource": ""
} |
q24725 | getColumn | train | func (t *Table) getColumn(name string) (NonAliasColumn, error) {
if c, ok := t.columnLookup[name]; ok {
return c, nil
}
return nil, errors.Newf("No such column '%s' in table '%s'", name, t.name)
} | go | {
"resource": ""
} |
q24726 | C | train | func (t *Table) C(name string) NonAliasColumn {
return &deferredLookupColumn{
table: t,
colName: name,
}
} | go | {
"resource": ""
} |
q24727 | Projections | train | func (t *Table) Projections() []Projection {
result := make([]Projection, 0)
for _, col := range t.columns {
result = append(result, col)
}
return result
} | go | {
"resource": ""
} |
q24728 | ForceIndex | train | func (t *Table) ForceIndex(index string) *Table {
newTable := *t
newTable.forcedIndex = index
return &newTable
} | go | {
"resource": ""
} |
q24729 | InnerJoinOn | train | func (t *Table) InnerJoinOn(
table ReadableTable,
onCondition BoolExpression) ReadableTable {
return InnerJoinOn(t, table, onCondition)
} | go | {
"resource": ""
} |
q24730 | LeftJoinOn | train | func (t *Table) LeftJoinOn(
table ReadableTable,
onCondition BoolExpression) ReadableTable {
return LeftJoinOn(t, table, onCondition)
} | go | {
"resource": ""
} |
q24731 | RightJoinOn | train | func (t *Table) RightJoinOn(
table ReadableTable,
onCondition BoolExpression) ReadableTable {
return RightJoinOn(t, table, onCondition)
} | go | {
"resource": ""
} |
q24732 | Parse | train | func (p *PreviousGtidsLogEventParser) Parse(raw *RawV4Event) (Event, error) {
pgle := &PreviousGtidsLogEvent{
Event: raw,
set: make(map[string][]GtidRange),
}
data := raw.VariableLengthData()
if len(data) < 8 {
return nil, errors.Newf("Not enough bytes for n_sids: %v", data)
}
nSids, data := LittleEndia... | go | {
"resource": ""
} |
q24733 | HexEncodeToWriter | train | func HexEncodeToWriter(w BinaryWriter, data []byte) {
for _, b := range data {
w.Write(hexMap[b])
}
} | go | {
"resource": ""
} |
q24734 | NewRoundRobinResourcePool | train | func NewRoundRobinResourcePool(
options Options,
createPool func(Options) ResourcePool,
pools ...*ResourceLocationPool) (ResourcePool, error) {
locations := make(map[string]bool)
for _, pool := range pools {
if pool.ResourceLocation == "" {
return nil, errors.New("Invalid resource location")
}
if locat... | go | {
"resource": ""
} |
q24735 | EventType | train | func (e *RawV4Event) EventType() mysql_proto.LogEventType_Type {
return mysql_proto.LogEventType_Type(e.header.EventType)
} | go | {
"resource": ""
} |
q24736 | VariableLengthData | train | func (e *RawV4Event) VariableLengthData() []byte {
begin := (sizeOfBasicV4EventHeader +
e.extraHeadersSize +
e.fixedLengthDataSize)
end := len(e.data) - e.checksumSize
return e.data[begin:end]
} | go | {
"resource": ""
} |
q24737 | SetExtraHeadersSize | train | func (e *RawV4Event) SetExtraHeadersSize(size int) error {
newFixedSize := (size +
sizeOfBasicV4EventHeader +
e.fixedLengthDataSize +
e.checksumSize)
if size < 0 || newFixedSize > len(e.data) {
return errors.Newf(
"Invalid extra headers size (data size: %d basic header size: %d"+
"fixed length data siz... | go | {
"resource": ""
} |
q24738 | NewCacheOnStorage | train | func NewCacheOnStorage(
cache Storage,
storage Storage) Storage {
return &CacheOnStorage{
cache: cache,
storage: storage,
}
} | go | {
"resource": ""
} |
q24739 | readUntilNullWorkSizeBatch | train | func readUntilNullWorkSizeBatch(socketRead io.ReadCloser,
batch []byte, workSize int) (size int, err error) {
err = nil
size = 0
if workSize == 0 {
size, err = io.ReadFull(socketRead, batch)
} else {
lastCheckedForNull := 0
for err == nil {
var offset int
offset, err = socketRead.Read(batch[size:])
... | go | {
"resource": ""
} |
q24740 | readBatch | train | func readBatch(copyTo chan<- []byte, socketRead io.ReadCloser, batchSize int, workSize int) {
defer close(copyTo)
for {
batch := make([]byte, batchSize)
size, err := readUntilNullWorkSizeBatch(socketRead, batch, workSize)
if size > 0 {
if err != nil && workSize != 0 {
size -= (size % workSize)
}
co... | go | {
"resource": ""
} |
q24741 | Advance | train | func (c *MockClock) Advance(delta time.Duration) {
c.mutex.Lock()
defer c.mutex.Unlock()
end := c.now.Add(delta)
c.advanceTo(end)
} | go | {
"resource": ""
} |
q24742 | AdvanceTo | train | func (c *MockClock) AdvanceTo(t time.Time) {
c.mutex.Lock()
defer c.mutex.Unlock()
c.advanceTo(t)
} | go | {
"resource": ""
} |
q24743 | Now | train | func (c *MockClock) Now() time.Time {
c.mutex.Lock()
defer c.mutex.Unlock()
return c.now
} | go | {
"resource": ""
} |
q24744 | Do | train | func (pool *SimplePool) Do(req *http.Request) (resp *http.Response, err error) {
conn, err := pool.Get()
if err != nil {
return nil, errors.Wrap(err, err.Error())
}
if pool.params.UseSSL {
req.URL.Scheme = "https"
} else {
req.URL.Scheme = "http"
}
if pool.params.UseRequestHost && req.Host != "" {
req.... | go | {
"resource": ""
} |
q24745 | DoWithTimeout | train | func (pool *SimplePool) DoWithTimeout(req *http.Request,
timeout time.Duration) (resp *http.Response, err error) {
return pool.DoWithParams(req, DoParams{Timeout: timeout})
} | go | {
"resource": ""
} |
q24746 | GetWithKey | train | func (pool *SimplePool) GetWithKey(key []byte, limit int) (*http.Client, error) {
return pool.Get()
} | go | {
"resource": ""
} |
q24747 | SetActiveSetSize | train | func (pool *LoadBalancedPool) SetActiveSetSize(size uint64) {
pool.lock.Lock()
defer pool.lock.Unlock()
pool.activeSetSize = size
} | go | {
"resource": ""
} |
q24748 | Do | train | func (pool *LoadBalancedPool) Do(req *http.Request) (resp *http.Response, err error) {
return pool.DoWithTimeout(req, 0)
} | go | {
"resource": ""
} |
q24749 | DoWithTimeout | train | func (pool *LoadBalancedPool) DoWithTimeout(req *http.Request,
timeout time.Duration) (*http.Response, error) {
return pool.DoWithParams(req, DoParams{Timeout: timeout})
} | go | {
"resource": ""
} |
q24750 | getInstance | train | func (pool *LoadBalancedPool) getInstance(key []byte, maxInstances int) (
idx int,
instance *instancePool,
isDown bool,
err error) {
pool.lock.RLock()
defer pool.lock.RUnlock()
if len(pool.instanceList) == 0 {
return 0, nil, false, errors.Newf("no available instances")
}
now := time.Now().Unix()
numInstanc... | go | {
"resource": ""
} |
q24751 | GetSingleInstance | train | func (pool *LoadBalancedPool) GetSingleInstance() (Pool, error) {
_, instance, _, err := pool.getInstance(nil, 1)
return instance, err
} | go | {
"resource": ""
} |
q24752 | markInstanceDown | train | func (pool *LoadBalancedPool) markInstanceDown(
idx int, instance *instancePool, downUntil int64) {
pool.lock.Lock()
defer pool.lock.Unlock()
if idx < len(pool.instanceList) && pool.instanceList[idx] == instance {
pool.markDownUntil[idx] = downUntil
}
} | go | {
"resource": ""
} |
q24753 | markInstanceUp | train | func (pool *LoadBalancedPool) markInstanceUp(
idx int, instance *instancePool) {
pool.markInstanceDown(idx, instance, 0)
} | go | {
"resource": ""
} |
q24754 | NewLockingMap | train | func NewLockingMap(options LockingMapOptions) LockingMap {
return &lockingMap{
lock: &sync.RWMutex{},
keyLocker: New(options.LockStoreOptions),
data: make(map[string]interface{}),
checkFunc: options.ValueCheckFunc,
}
} | go | {
"resource": ""
} |
q24755 | Get | train | func (m *lockingMap) Get(key string) (interface{}, bool) {
m.keyLocker.RLock(key)
defer m.keyLocker.RUnlock(key)
m.lock.RLock()
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, fa... | go | {
"resource": ""
} |
q24756 | Delete | train | func (m *lockingMap) Delete(key string) {
m.keyLocker.Lock(key)
defer m.keyLocker.Unlock(key)
m.lock.Lock()
defer m.lock.Unlock()
delete(m.data, key)
} | go | {
"resource": ""
} |
q24757 | NewManagedConn | train | func NewManagedConn(
network string,
address string,
handle resource_pool.ManagedHandle,
pool ConnectionPool,
options ConnectionOptions) ManagedConn {
addr := NetworkAddress{
Network: network,
Address: address,
}
return &managedConnImpl{
addr: addr,
handle: handle,
pool: pool,
options: opti... | go | {
"resource": ""
} |
q24758 | RawConn | train | func (c *managedConnImpl) RawConn() net.Conn {
h, _ := c.handle.Handle()
return h.(net.Conn)
} | go | {
"resource": ""
} |
q24759 | GetPort | train | func GetPort(addr net.Addr) (int, error) {
_, lport, err := net.SplitHostPort(addr.String())
if err != nil {
return -1, err
}
lportInt, err := strconv.Atoi(lport)
if err != nil {
return -1, err
}
return lportInt, nil
} | go | {
"resource": ""
} |
q24760 | NewSource | train | func NewSource(seed int64) rand.Source {
return &lockedSource{
src: rand.NewSource(seed),
}
} | go | {
"resource": ""
} |
q24761 | GetSeed | train | func GetSeed() int64 {
now := time.Now()
return now.Unix() + int64(now.Nanosecond()) + 12345*int64(os.Getpid())
} | go | {
"resource": ""
} |
q24762 | Dur | train | func Dur(max time.Duration) time.Duration {
return time.Duration(Int63n(int64(max)))
} | go | {
"resource": ""
} |
q24763 | SampleInts | train | func SampleInts(n int, k int) (res []int, err error) {
if k < 0 {
err = errors.Newf("invalid sample size k")
return
}
if n < k {
err = errors.Newf("sample size k larger than n")
return
}
picked := set.NewSet()
for picked.Len() < k {
i := Intn(n)
picked.Add(i)
}
res = make([]int, k)
e := 0
for i... | go | {
"resource": ""
} |
q24764 | Sample | train | func Sample(population []interface{}, k int) (res []interface{}, err error) {
n := len(population)
idxs, err := SampleInts(n, k)
if err != nil {
return
}
res = []interface{}{}
for _, idx := range idxs {
res = append(res, population[idx])
}
return
} | go | {
"resource": ""
} |
q24765 | PickN | train | func PickN(population []interface{}, n int) (
picked []interface{}, remaining []interface{}, err error) {
total := len(population)
idxs, err := SampleInts(total, n)
if err != nil {
return
}
sort.Ints(idxs)
picked, remaining = []interface{}{}, []interface{}{}
for x, elem := range population {
if len(idxs) ... | go | {
"resource": ""
} |
q24766 | Shuffle | train | func Shuffle(collection Swapper) {
// Fisher-Yates shuffle.
for i := collection.Len() - 1; i >= 0; i-- {
collection.Swap(i, Intn(i+1))
}
} | go | {
"resource": ""
} |
q24767 | TryAcquire | train | func (sem *boundedSemaphore) TryAcquire(timeout time.Duration) bool {
if timeout > 0 {
// Wait until we get a slot or timeout expires.
tm := time.NewTimer(timeout)
defer tm.Stop()
select {
case <-sem.slots:
return true
case <-tm.C:
// Timeout expired. In very rare cases this might happen even if
/... | go | {
"resource": ""
} |
q24768 | Literal | train | func Literal(v interface{}) Expression {
value, err := sqltypes.BuildValue(v)
if err != nil {
panic(errors.Wrap(err, "Invalid literal value"))
}
return &literalExpression{value: value}
} | go | {
"resource": ""
} |
q24769 | Eq | train | func Eq(lhs, rhs Expression) BoolExpression {
lit, ok := rhs.(*literalExpression)
if ok && sqltypes.Value(lit.value).IsNull() {
return newBoolExpression(lhs, rhs, []byte(" IS "))
}
return newBoolExpression(lhs, rhs, []byte("="))
} | go | {
"resource": ""
} |
q24770 | Lt | train | func Lt(lhs Expression, rhs Expression) BoolExpression {
return newBoolExpression(lhs, rhs, []byte("<"))
} | go | {
"resource": ""
} |
q24771 | NewRawAsciiClient | train | func NewRawAsciiClient(shard int, channel io.ReadWriter) ClientShard {
return &RawAsciiClient{
shard: shard,
channel: channel,
validState: true,
writer: bufio.NewWriter(channel),
reader: bufio.NewReader(channel),
}
} | go | {
"resource": ""
} |
q24772 | NewBoundedRWLock | train | func NewBoundedRWLock(capacity int) *BoundedRWLock {
return &BoundedRWLock{
waiters: make(chan *rwwait, capacity),
control: &sync.Mutex{},
}
} | go | {
"resource": ""
} |
q24773 | RLock | train | func (rw *BoundedRWLock) RLock(timeout time.Duration) (err error) {
deadline := time.After(timeout)
rw.control.Lock()
if rw.nextWriter != nil {
me := newWait(false)
select {
case rw.waiters <- me:
default:
err = errors.New("Waiter capacity reached in RLock")
}
rw.control.Unlock()
if err != nil {
... | go | {
"resource": ""
} |
q24774 | WLock | train | func (rw *BoundedRWLock) WLock(timeout time.Duration) (err error) {
deadline := time.After(timeout)
rw.control.Lock()
if rw.readers != 0 || rw.nextWriter != nil {
me := newWait(true)
if rw.nextWriter == nil {
rw.nextWriter = me
} else {
select {
case rw.waiters <- me:
default:
err = errors.New(... | go | {
"resource": ""
} |
q24775 | WaitAtomic | train | func (wait *rwwait) WaitAtomic(after <-chan time.Time) bool {
select {
case <-wait.wake:
return true
case <-after:
}
swapped := atomic.CompareAndSwapInt32(&wait.alive, 1, 0)
// They're gonna put it.
if !swapped {
<-wait.wake
return true
}
return false
} | go | {
"resource": ""
} |
q24776 | WakeAtomic | train | func (wait *rwwait) WakeAtomic() bool {
swapped := atomic.CompareAndSwapInt32(&wait.alive, 1, 0)
if !swapped {
// They've moved on.
return false
}
wait.wake <- true
return true
} | go | {
"resource": ""
} |
q24777 | Parse | train | func (p *XidEventParser) Parse(raw *RawV4Event) (Event, error) {
xe := &XidEvent{
Event: raw,
}
// For convenience, we'll interpret the bytes as little endian, our
// dominate computing (intel) platform.
_, err := readLittleEndian(raw.VariableLengthData(), &xe.xid)
if err != nil {
return raw, errors.Wrap(err... | go | {
"resource": ""
} |
q24778 | Get | train | func (c *MockClient) Get(key string) GetResponse {
c.mutex.Lock()
defer c.mutex.Unlock()
return c.getHelper(key)
} | go | {
"resource": ""
} |
q24779 | GetMulti | train | func (c *MockClient) GetMulti(keys []string) map[string]GetResponse {
c.mutex.Lock()
defer c.mutex.Unlock()
res := make(map[string]GetResponse)
for _, key := range keys {
res[key] = c.getHelper(key)
}
return res
} | go | {
"resource": ""
} |
q24780 | Delete | train | func (c *MockClient) Delete(key string) MutateResponse {
c.mutex.Lock()
defer c.mutex.Unlock()
if c.forceFailEverything {
return NewMutateResponse(
key,
StatusInternalError,
0)
}
_, ok := c.data[key]
if !ok {
return NewMutateResponse(
key,
StatusKeyNotFound,
0)
}
delete(c.data, key)
r... | go | {
"resource": ""
} |
q24781 | Append | train | func (c *MockClient) Append(key string, value []byte) MutateResponse {
return NewMutateErrorResponse(key, errors.Newf("Append not implemented"))
} | go | {
"resource": ""
} |
q24782 | Flush | train | func (c *MockClient) Flush(expiration uint32) Response {
c.mutex.Lock()
defer c.mutex.Unlock()
// TODO(patrick): Use expiration argument
c.data = make(map[string]*Item)
return NewResponse(StatusNoError)
} | go | {
"resource": ""
} |
q24783 | Stat | train | func (c *MockClient) Stat(statsKey string) StatResponse {
return NewStatErrorResponse(errors.Newf("Stat not implemented"), nil)
} | go | {
"resource": ""
} |
q24784 | MyHostname | train | func MyHostname() string {
myHostnameOnce.Do(func() {
var err error
myHostname, err = os.Hostname()
if err != nil {
log.Fatal(err)
}
})
return myHostname
} | go | {
"resource": ""
} |
q24785 | IsRetryableError | train | func IsRetryableError(err error) bool {
if err == io.EOF {
return true
}
if _, ok := err.(*FailedToOpenFileError); ok {
return true
}
return false
} | go | {
"resource": ""
} |
q24786 | String | train | func (q *selectStatementImpl) String(database string) (sql string, err error) {
if !validIdentifierName(database) {
return "", errors.New("Invalid database name specified")
}
buf := new(bytes.Buffer)
_, _ = buf.WriteString("SELECT ")
if err = writeComment(q.comment, buf); err != nil {
return
}
if q.distin... | go | {
"resource": ""
} |
q24787 | AddReadLock | train | func (s *lockStatementImpl) AddReadLock(t *Table) LockStatement {
s.locks = append(s.locks, tableLock{t: t, w: false})
return s
} | go | {
"resource": ""
} |
q24788 | AddWriteLock | train | func (s *lockStatementImpl) AddWriteLock(t *Table) LockStatement {
s.locks = append(s.locks, tableLock{t: t, w: true})
return s
} | go | {
"resource": ""
} |
q24789 | NewGtidNextStatement | train | func NewGtidNextStatement(sid []byte, gno uint64) GtidNextStatement {
return >idNextStatementImpl{
sid: sid,
gno: gno,
}
} | go | {
"resource": ""
} |
q24790 | Parse | train | func (p *GtidLogEventParser) Parse(raw *RawV4Event) (Event, error) {
gle := &GtidLogEvent{
Event: raw,
}
if len(raw.VariableLengthData()) > 0 {
return raw, errors.New("GTID binlog event larger than expected size")
}
data := raw.FixedLengthData()
var commitData uint8
data, err := readLittleEndian(data, &co... | go | {
"resource": ""
} |
q24791 | NewMultiResourcePool | train | func NewMultiResourcePool(
options Options,
createPool func(Options) ResourcePool) ResourcePool {
if createPool == nil {
createPool = NewSimpleResourcePool
}
return &multiResourcePool{
options: options,
createPool: createPool,
rwMutex: sync.RWMutex{},
isLameDuck: false,
locationPool... | go | {
"resource": ""
} |
q24792 | String | train | func (v Value) String() string {
if v.Inner == nil {
return ""
}
return string(v.Inner.raw())
} | go | {
"resource": ""
} |
q24793 | EncodeSql | train | func (v Value) EncodeSql(b encoding2.BinaryWriter) {
if v.Inner == nil {
if _, err := b.Write(nullstr); err != nil {
panic(err)
}
} else {
v.Inner.encodeSql(b)
}
} | go | {
"resource": ""
} |
q24794 | EncodeAscii | train | func (v Value) EncodeAscii(b encoding2.BinaryWriter) {
if v.Inner == nil {
if _, err := b.Write(nullstr); err != nil {
panic(err)
}
} else {
v.Inner.encodeAscii(b)
}
} | go | {
"resource": ""
} |
q24795 | MarshalBinary | train | func (v Value) MarshalBinary() ([]byte, error) {
if v.IsNull() {
return []byte{byte(NullType)}, nil
}
return v.Inner.MarshalBinary()
} | go | {
"resource": ""
} |
q24796 | UnmarshalBinary | train | func (v *Value) UnmarshalBinary(data []byte) error {
reader := bytes.NewReader(data)
b, err := reader.ReadByte()
if err != nil {
return err
}
typ := ValueType(b)
if typ == NullType {
*v = Value{}
return nil
}
length, err := binary.ReadUvarint(reader)
if err != nil {
return err
}
raw := make([]byt... | go | {
"resource": ""
} |
q24797 | ConvertAssignRowNullable | train | func ConvertAssignRowNullable(row []Value, dest ...interface{}) error {
if len(row) != len(dest) {
return errors.Newf(
"# of row entries %d does not match # of destinations %d",
len(row),
len(dest))
}
if row == nil {
return nil
}
for i := 0; i < len(row); i++ {
if row[i].IsNull() {
continue
}... | go | {
"resource": ""
} |
q24798 | ConvertAssignDefault | train | func ConvertAssignDefault(src Value, dest interface{}, defaultValue interface{}) error {
if src.IsNull() {
// This is not the most efficient way of doing things, but it's certainly cleaner
v, err := BuildValue(defaultValue)
if err != nil {
return err
}
return ConvertAssign(v, dest)
}
return ConvertAssig... | go | {
"resource": ""
} |
q24799 | Uint64EncodeSql | train | func Uint64EncodeSql(b encoding2.BinaryWriter, num uint64) {
numVal, _ := BuildValue(num)
numVal.EncodeSql(b)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.