id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c28400 | jaeger.SamplerTypeProbabilistic,
Param: options.Probability,
},
}
return cfg.InitGlobalTracer(options.ServiceName)
} | |
c28401 |
cfg.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
cfg.AutomaticEnv()
c := &Config{config: cfg}
c.fillDefaultValues()
return c
} | |
c28402 | time.Duration {
return c.config.GetDuration(s)
} | |
c28403 | c.config.GetString(s)
} | |
c28404 | c.config.GetInt(s)
} | |
c28405 | c.config.GetBool(s)
} | |
c28406 | c.config.GetStringSlice(s)
} | |
c28407 | c.config.GetStringMapString(s)
} | |
c28408 | return c.config.UnmarshalKey(s, v)
} | |
c28409 | err != nil {
return nil, err
}
return &EtcdGroupService{}, err
} | |
c28410 |
return c.createGroup(ctx, groupName, 0)
} | |
c28411 | int64(ttlTime.Seconds()))
if err != nil {
return err
}
return c.createGroup(ctx, groupName, lease.ID)
} | |
c28412 | Commit()
if err != nil {
return false, err
}
if !etcdRes.Succeeded {
return false, constants.ErrGroupNotFound
}
return etcdRes.Responses[0].GetResponseRange().GetCount() > 0, nil
} | |
c28413 | clientv3.WithPrefix())).
Commit()
if err != nil {
return err
}
if !etcdRes.Succeeded {
return constants.ErrGroupNotFound
}
return nil
} | |
c28414 | cancel()
_, err = clientInstance.KeepAliveOnce(ctxT, clientv3.LeaseID(kv.Lease))
return err
}
return constants.ErrEtcdLeaseNotFound
} | |
c28415 | for _, r := range reporters {
reportJobsRetry(r, workerStats.Retries)
reportQueueSizes(r, workerStats.Enqueued)
reportJobsTotal(r, workerStats.Failed, workerStats.Processed)
}
}
} | |
c28416 | s, ok := rec.(string); ok {
err = errors.New(s)
} else {
err = fmt.Errorf("rpc call internal error - %s: %v", method.Name, rec)
}
}
}()
r := method.Func.Call(args)
// r can have 0 length in case of notify handlers
// otherwise it will have 2 outputs: an interface and an error
if len(r) == 2 {
i... | |
c28417 | if value == str {
return true
}
}
return false
} | |
c28418 | := v.([]byte); ok {
return data, nil
}
data, err := serializer.Marshal(v)
if err != nil {
return nil, err
}
return data, nil
} | |
c28419 |
errPayload := &protos.Error{
Code: code,
Msg: msg,
}
if len(metadata) > 0 {
errPayload.Metadata = metadata
}
return SerializeOrRaw(serializer, errPayload)
} | |
c28420 | message.Request
case protos.MsgType_MsgNotify:
msgType = message.Notify
}
return msgType
} | |
c28421 |
}
defaultLogger = logrusLogger.WithFields(
logrus.Fields{
"route": route,
"requestId": requestID,
"userId": userID,
})
} else {
defaultLogger = logger.Log
}
return context.WithValue(ctx, constants.LoggerCtxKey, defaultLogger)
} | |
c28422 | constants.RequestIDKey),
}
parent, err := tracing.ExtractSpan(ctx)
if err != nil {
logger.Log.Warnf("failed to retrieve parent span: %s", err.Error())
}
ctx = tracing.StartSpan(ctx, req.GetMsg().GetRoute(), tags, parent)
ctx = CtxWithDefaultLogger(ctx, req.GetMsg().GetRoute(), "")
return ctx, nil
} | |
c28423 | s.Status |= flag
return
}
s.Status &= (^flag)
} | |
c28424 | copy(warns, sc.mu.warnings)
sc.mu.Unlock()
return warns
} | |
c28425 | sc.mu.warnings = append(sc.mu.warnings, warn)
sc.mu.Unlock()
} | |
c28426 |
nt.Columns[i] = t.Columns[i].Clone()
}
for i := range t.Indices {
nt.Indices[i] = t.Indices[i].Clone()
}
return &nt
} | |
c28427 | len(index.Columns))
for i := range index.Columns {
ni.Columns[i] = index.Columns[i].Clone()
}
return &ni
} | |
c28428 | newInfo.Tables[i] = db.Tables[i].Clone()
}
return &newInfo
} | |
c28429 | {
cs.O = s
cs.L = strings.ToLower(s)
return
} | |
c28430 | }(i, reader)
}
for range readers {
err := <-errChan
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to process output: %v\n", err)
return err
}
}
return nil
}
return d
} | |
c28431 | defer w.Flush()
return util.Fprintf(w, r, format)
}
return d.Output(fn)
} | |
c28432 |
return d.Fprintf(writer, format+"\n")
} | |
c28433 | d.Fprintf(os.Stdout, format)
} | |
c28434 | d.Fprintf(os.Stdout, format+"\n")
} | |
c28435 | if err := setValueTo(v, decodedObjects[counter]); err != nil {
return err
}
counter++
}
for _, v := range row.V {
if err := setValueTo(v, decodedObjects[counter]); err != nil {
return err
}
counter++
}
return nil
})
}
return d.Output(fn)
} | |
c28436 | ast.RecordSet
rs, err = s.Exec(ctx)
return rs, errors.Trace(err)
} | |
c28437 | that}
step := this.Flow.MergeDatasets1ShardTo1Step(inputs, ret)
step.SetInstruction(name, instruction.NewCoGroupPartitionedSorted(indexes))
return ret
} | |
c28438 | case ast.AggFuncMax:
return &maxMinFunction{aggFunction: newAggFunc(tp, funcArgs, distinct), isMax: true}
case ast.AggFuncMin:
return &maxMinFunction{aggFunction: newAggFunc(tp, funcArgs, distinct), isMax: false}
case ast.AggFuncFirstRow:
return &firstRowFunction{aggFunction: newAggFunc(tp, funcArgs, distinct)... | |
c28439 | i, argA := range af.GetArgs() {
if !argA.Equal(b.GetArgs()[i], ctx) {
return false
}
}
}
return true
} | |
c28440 | = make(aggCtxMapper, 0)
af.streamCtx = nil
} | |
c28441 | fmt.Sprintf("ERROR %d (%s): %s", e.Code, e.State, e.Message)
} | |
c28442 | := MySQLErrName[errCode]; ok {
e.Message = fmt.Sprintf(format, args...)
} else {
e.Message = fmt.Sprint(args...)
}
return e
} | |
c28443 |
e.State = DefaultMySQLState
}
e.Message = fmt.Sprintf(format, args...)
return e
} | |
c28444 | offset--
} else {
if n > 0 {
row.WriteTo(writer)
stats.OutputCounter++
}
n--
}
return nil
})
} | |
c28445 | range fun.GetArgs() {
canPrune = canPrune && exprHasSetVar(arg)
if !canPrune {
return false
}
}
}
return true
} | |
c28446 | size; i++ {
sm.maps[i] = make(map[string]interface{})
}
sm.crcTable = crc32.MakeTable(crc32.Castagnoli)
return sm, nil
} | |
c28447 | return nil, errors.Errorf("index out of bound: %d", index)
}
return sm.maps[index], nil
} | |
c28448 | exist := sm.maps[idx][k]
if exist && !force {
return exist
}
sm.maps[idx][k] = value
return exist
} | |
c28449 | if err != nil {
return nil, errors.Trace(err)
}
for name, val := range vals {
scope := statistics.GetScope(name)
statusVars[name] = &StatusVal{Value: val, Scope: scope}
}
}
return statusVars, nil
} | |
c28450 | rChild := j.GetChildByIndex(1).(LogicalPlan)
if nj, ok := lChild.(*Join); ok {
plans, valid := tryToGetJoinGroup(nj)
return append(plans, rChild), valid
}
return []LogicalPlan{lChild, rChild}, true
} | |
c28451 | {
v := edge.nodeID
if !e.visited[v] {
e.resultJoin = e.newJoin(e.resultJoin, e.group[v])
e.walkGraphAndComposeJoin(v)
}
}
} | |
c28452 | col)
} else {
return nil, errUnknownColumn.Gen("unknown column %s", name)
}
}
return rcols, nil
} | |
c28453 |
_, ok := m[name.L]
if ok {
return errDuplicateColumn.Gen("column specified twice - %s", name)
}
m[name.L] = struct{}{}
}
return nil
} | |
c28454 | }
ir := &IndexRange{
LowVal: []types.Datum{startPoint.value},
LowExclude: startPoint.excl,
HighVal: []types.Datum{endPoint.value},
HighExclude: endPoint.excl,
}
indexRanges = append(indexRanges, ir)
}
return indexRanges
} | |
c28455 |
ret, err := lessThan(fs.sc, l, r, fs.byDesc)
if fs.err == nil {
fs.err = err
}
return ret
} | |
c28456 |
body, err = codec.EncodeKey(body, row.key...)
if err != nil {
return errors.Trace(err)
}
body, err = codec.EncodeKey(body, row.val...)
if err != nil {
return errors.Trace(err)
}
body, err = codec.EncodeKey(body, types.NewIntDatum(row.handle))
if err != nil {
return errors.Trace(err)
}
bi... | |
c28457 | rowSize {
return nil, errors.New("incorrect row")
}
dcod, err = codec.Decode(rowBytes, fs.keySize+fs.valSize+1)
if err != nil {
return nil, errors.Trace(err)
}
return &comparableRow{
key: dcod[:fs.keySize],
val: dcod[fs.keySize : fs.keySize+fs.valSize],
handle: dcod[fs.keySize+fs.valSize:][0].Ge... | |
c28458 |
}
fs.fetched = true
}
if fs.rowHeap.Len() > 0 {
im := heap.Pop(fs.rowHeap).(*item)
if fs.rowHeap.err != nil {
return nil, errors.Trace(fs.rowHeap.err)
}
row, err := fs.fetchNextRow(im.index)
if err != nil {
return nil, errors.Trace(err)
}
if row != nil {
im := &item{
index: im.index... | |
c28459 | 0 {
s = "0" + s
}
// should never error.
b, _ := hex.DecodeString(s)
return string(b)
} | |
c28460 |
if exe == nil {
return nil, fmt.Errorf("Failed to build execution plan %v", plan.ToString(a.Plan))
}
return exe.Exec(), nil
} | |
c28461 |
step := this.Flow.MergeDatasets1ShardTo1Step(inputs, ret)
step.SetInstruction(name, instruction.NewUnion(isParallel))
return ret
} | |
c28462 | := path.Join(*as.Option.Dir, fmt.Sprintf("%d", cleanupRequest.GetFlowHashCode()))
os.RemoveAll(dir)
return &pb.CleanupResponse{}, nil
} | |
c28463 | *request.GetResource()
as.plusAllocated(allocated)
defer as.minusAllocated(allocated)
request.InstructionSet.AgentAddress = fmt.Sprintf("%s:%d", *as.Option.Host, *as.Option.Port)
statsChan := createStatsChanByInstructionSet(request.InstructionSet)
defer deleteStatsChanByInstructionSet(request.InstructionSet)
... | |
c28464 | {
statsChan = getStatsChan(stats.FlowHashCode, stats.Stats[0].GetStepId(), stats.Stats[0].GetTaskId())
}
statsChan <- stats
// fmt.Printf("received stats: %+v\n", stats)
}
} | |
c28465 |
as.storageBackend.DeleteNamedDatasetShard(deleteRequest.Name)
as.inMemoryChannels.Cleanup(deleteRequest.Name)
return &pb.DeleteDatasetShardResponse{}, nil
} | |
c28466 | }
for _, stat := range execution.ExecutionStat.Stats {
if stat.StepId == stepId {
counter += stat.OutputCounter
}
}
}
}
return counter
} | |
c28467 | startTime.Month(), startTime.Day()) - calcDaynr(endTime.Year(), endTime.Month(), endTime.Day())
} | |
c28468 | for other escapes.
i--
c = escape
}
}
case '_':
lastAny = false
tp = patOne
case '%':
if lastAny {
continue
}
lastAny = true
tp = patAny
default:
lastAny = false
tp = patMatch
}
patChars[patLen] = c
patTypes[patLen] = tp
patLen++
}
for i := 0; i < patLen-1; ... | |
c28469 | varintFlag:
l, err = peekVarint(b)
case uvarintFlag:
l, err = peekUvarint(b)
default:
return 0, errors.Errorf("invalid encoded key flag %v", flag)
}
if err != nil {
return 0, errors.Trace(err)
}
length += l
return
} | |
c28470 | *Dataset {
for _, option := range options {
option(d)
}
return d
} | |
c28471 | {
d.Meta.TotalSize = n
}
} | |
c28472 | d.Meta.TotalSize = n * int64(len(d.GetShards()))
}
} | |
c28473 |
parents = append(parents, p)
} else {
isFirstDataset = true
}
}
if !isFirstDataset && !isLastDataset {
t.Step.Meta.IsRestartable = true
}
}
if len(parents) == 0 {
break
}
currents = parents
parents = nil
}
return ret
} | |
c28474 | ok := val.Accept(v)
if !ok {
return n, false
}
n.Tables[i] = node.(*TableName)
}
return v.Leave(n)
} | |
c28475 | } else {
full.Schema = model.NewCIStr(ctx.GetSessionVars().CurrentDB)
}
return
} | |
c28476 | return fmt.Sprintf("%s.%s", i.Schema, i.Name)
} | |
c28477 | Column: r.column,
Err: err,
}
} | |
c28478 | if err != nil {
return nil, err
}
records = append(records, record)
}
} | |
c28479 | can be folded to \n.
// We will not detect files which contain both \r\n and bare \n.
if r1 == '\r' {
r1, _, err = r.r.ReadRune()
if err == nil {
if r1 != '\n' {
r.r.UnreadRune()
r1 = '\r'
}
}
}
r.column++
return r1, err
} | |
c28480 | return err
}
if r1 == delim {
return nil
}
}
} | |
c28481 | it is the comment character
// then skip to the end of line.
r1, _, err := r.r.ReadRune()
if err != nil {
return nil, err
}
if r.Comment != 0 && r1 == r.Comment {
return nil, r.skip('\n')
}
r.r.UnreadRune()
// At this point we have at least one field.
for {
haveField, delim, err := r.parseField()
i... | |
c28482 | err != nil {
return nil, errors.Trace(err)
}
return &ScalarFunction{
FuncName: model.NewCIStr(funcName),
RetType: retType,
Function: f,
}, nil
} | |
c28483 | return
}
}
m.Demands = append(m.Demands, Demand{
Requirement: r,
Bid: bid,
ReturnChan: retChan,
})
m.hasDemands.Signal()
} | |
c28484 |
}
if len(objects) > 0 {
_, err := fmt.Fprintf(writer, format, objects...)
return err
}
return nil
})
} | |
c28485 | %s\n", string(encodedBytes))
if row, err = DecodeRow(encodedBytes); err != nil {
return fmt.Errorf("Failed to decode byte: %v\n", err)
}
decodedObjects = append(decodedObjects, row.K...)
decodedObjects = append(decodedObjects, row.V...)
fmt.Fprintf(writer, format, decodedObjects...)
return nil
})
} | |
c28486 | != nil {
return fmt.Errorf("Failed to write row: %v", err)
}
if _, err := fprintRow(writer, written, delimiter, row.V...); err != nil {
return fmt.Errorf("Failed to write row: %v", err)
}
if _, err := writer.Write([]byte("\n")); err != nil {
return fmt.Errorf("Failed to write line separator: %v", err... | |
c28487 | When walking outside the first sorKeyLen column, we can match the columns as any order.
for j, propCol := range prop.props {
if idxCol.Name.L == propCol.col.ColName.L {
return j
}
}
}
return -1
} | |
c28488 | = KindRow
d.x = ds
} | |
c28489 |
return Bit{Value: value, Width: width}
} | |
c28490 | uint32(b.Width)
d.i = int64(b.Value)
} | |
c28491 | uint64(d.i), Name: hack.String(d.b)}
} | |
c28492 | = KindMysqlHex
d.i = b.Value
} | |
c28493 | errors.Errorf("unknown cast type - %v", target)
}
return d.ConvertTo(sc, target)
} | |
c28494 | KindMysqlHex:
return d.GetMysqlHex().ToString(), nil
case KindMysqlBit:
return d.GetMysqlBit().ToString(), nil
case KindMysqlEnum:
return d.GetMysqlEnum().String(), nil
case KindMysqlSet:
return d.GetMysqlSet().String(), nil
default:
return "", errors.Errorf("cannot convert %v(type %T) to string", d.GetV... | |
c28495 | y.SetFloat64(y.GetMysqlBit().ToNumber())
case KindMysqlEnum:
y.SetFloat64(y.GetMysqlEnum().ToNumber())
case KindMysqlSet:
y.SetFloat64(y.GetMysqlSet().ToNumber())
case KindMysqlDecimal:
fval, err := y.ToFloat64(sc)
if err != nil {
return x, y, errors.Trace(err)
}
y.SetFloat64(fval)
}
} ... | |
c28496 | len(datums))
for i, v := range datums {
ins[i] = v.GetValue()
}
return ins
} | |
c28497 | datumsSorter{datums: datums, sc: sc}
sort.Sort(&sorter)
return sorter.err
} | |
c28498 | sc.IsInsert instead of sc.IgnoreTruncate.
if ctx.GetSessionVars().StrictSQLMode && !sc.IgnoreTruncate {
return errors.Trace(types.ErrInvalidTimeFormat)
}
sc.AppendWarning(err)
return nil
} | |
c28499 | err = errors.New("Session current insert values is nil")
return
}
row := values.([]types.Datum)
if len(row) > offset {
return row[offset], nil
}
err = errors.Errorf("Session current insert values len %d and column's offset %v don't match", len(row), offset)
return
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.