_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28400 | Configure | train | func Configure(options Options) (io.Closer, error) {
cfg := config.Configuration{
Disabled: options.Disabled,
Sampler: &config.SamplerConfig{
Type: jaeger.SamplerTypeProbabilistic,
Param: options.Probability,
},
}
return cfg.InitGlobalTracer(options.ServiceName)
} | go | {
"resource": ""
} |
q28401 | NewConfig | train | func NewConfig(cfgs ...*viper.Viper) *Config {
var cfg *viper.Viper
if len(cfgs) > 0 {
cfg = cfgs[0]
} else {
cfg = viper.New()
}
cfg.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
cfg.AutomaticEnv()
c := &Config{config: cfg}
c.fillDefaultValues()
return c
} | go | {
"resource": ""
} |
q28402 | GetDuration | train | func (c *Config) GetDuration(s string) time.Duration {
return c.config.GetDuration(s)
} | go | {
"resource": ""
} |
q28403 | GetString | train | func (c *Config) GetString(s string) string {
return c.config.GetString(s)
} | go | {
"resource": ""
} |
q28404 | GetInt | train | func (c *Config) GetInt(s string) int {
return c.config.GetInt(s)
} | go | {
"resource": ""
} |
q28405 | GetBool | train | func (c *Config) GetBool(s string) bool {
return c.config.GetBool(s)
} | go | {
"resource": ""
} |
q28406 | GetStringSlice | train | func (c *Config) GetStringSlice(s string) []string {
return c.config.GetStringSlice(s)
} | go | {
"resource": ""
} |
q28407 | GetStringMapString | train | func (c *Config) GetStringMapString(s string) map[string]string {
return c.config.GetStringMapString(s)
} | go | {
"resource": ""
} |
q28408 | UnmarshalKey | train | func (c *Config) UnmarshalKey(s string, v interface{}) error {
return c.config.UnmarshalKey(s, v)
} | go | {
"resource": ""
} |
q28409 | NewEtcdGroupService | train | func NewEtcdGroupService(conf *config.Config, clientOrNil *clientv3.Client) (*EtcdGroupService, error) {
err := initClientInstance(conf, clientOrNil)
if err != nil {
return nil, err
}
return &EtcdGroupService{}, err
} | go | {
"resource": ""
} |
q28410 | GroupCreate | train | func (c *EtcdGroupService) GroupCreate(ctx context.Context, groupName string) error {
return c.createGroup(ctx, groupName, 0)
} | go | {
"resource": ""
} |
q28411 | GroupCreateWithTTL | train | func (c *EtcdGroupService) GroupCreateWithTTL(ctx context.Context, groupName string, ttlTime time.Duration) error {
ctxT, cancel := context.WithTimeout(ctx, transactionTimeout)
defer cancel()
lease, err := clientInstance.Grant(ctxT, int64(ttlTime.Seconds()))
if err != nil {
return err
}
return c.createGroup(ctx... | go | {
"resource": ""
} |
q28412 | GroupContainsMember | train | func (c *EtcdGroupService) GroupContainsMember(ctx context.Context, groupName, uid string) (bool, error) {
ctxT, cancel := context.WithTimeout(ctx, transactionTimeout)
defer cancel()
etcdRes, err := clientInstance.Txn(ctxT).
If(clientv3.Compare(clientv3.CreateRevision(groupKey(groupName)), ">", 0)).
Then(clientv... | go | {
"resource": ""
} |
q28413 | GroupRemoveAll | train | func (c *EtcdGroupService) GroupRemoveAll(ctx context.Context, groupName string) error {
ctxT, cancel := context.WithTimeout(ctx, transactionTimeout)
defer cancel()
etcdRes, err := clientInstance.Txn(ctxT).
If(clientv3.Compare(clientv3.CreateRevision(groupKey(groupName)), ">", 0)).
Then(clientv3.OpDelete(memberK... | go | {
"resource": ""
} |
q28414 | GroupRenewTTL | train | func (c *EtcdGroupService) GroupRenewTTL(ctx context.Context, groupName string) error {
kv, err := getGroupKV(ctx, groupName)
if err != nil {
return err
}
if kv.Lease != 0 {
ctxT, cancel := context.WithTimeout(ctx, transactionTimeout)
defer cancel()
_, err = clientInstance.KeepAliveOnce(ctxT, clientv3.Lease... | go | {
"resource": ""
} |
q28415 | Report | train | func Report(reporters []metrics.Reporter, period time.Duration) {
for {
time.Sleep(period)
workerStats := workers.GetStats()
for _, r := range reporters {
reportJobsRetry(r, workerStats.Retries)
reportQueueSizes(r, workerStats.Enqueued)
reportJobsTotal(r, workerStats.Failed, workerStats.Processed)
}
... | go | {
"resource": ""
} |
q28416 | Pcall | train | func Pcall(method reflect.Method, args []reflect.Value) (rets interface{}, err error) {
defer func() {
if rec := recover(); rec != nil {
// Try to use logger from context here to help trace error cause
log := getLoggerFromArgs(args)
log.Errorf("panic - pitaya/dispatch: %s: %v", method.Name, rec)
log.Debu... | go | {
"resource": ""
} |
q28417 | SliceContainsString | train | func SliceContainsString(slice []string, str string) bool {
for _, value := range slice {
if value == str {
return true
}
}
return false
} | go | {
"resource": ""
} |
q28418 | SerializeOrRaw | train | func SerializeOrRaw(serializer serialize.Serializer, v interface{}) ([]byte, error) {
if data, ok := v.([]byte); ok {
return data, nil
}
data, err := serializer.Marshal(v)
if err != nil {
return nil, err
}
return data, nil
} | go | {
"resource": ""
} |
q28419 | GetErrorPayload | train | func GetErrorPayload(serializer serialize.Serializer, err error) ([]byte, error) {
code := e.ErrUnknownCode
msg := err.Error()
metadata := map[string]string{}
if val, ok := err.(*e.Error); ok {
code = val.Code
metadata = val.Metadata
}
errPayload := &protos.Error{
Code: code,
Msg: msg,
}
if len(metadat... | go | {
"resource": ""
} |
q28420 | ConvertProtoToMessageType | train | func ConvertProtoToMessageType(protoMsgType protos.MsgType) message.Type {
var msgType message.Type
switch protoMsgType {
case protos.MsgType_MsgRequest:
msgType = message.Request
case protos.MsgType_MsgNotify:
msgType = message.Notify
}
return msgType
} | go | {
"resource": ""
} |
q28421 | CtxWithDefaultLogger | train | func CtxWithDefaultLogger(ctx context.Context, route, userID string) context.Context {
var defaultLogger logger.Logger
logrusLogger, ok := logger.Log.(logrus.FieldLogger)
if ok {
requestID := pcontext.GetFromPropagateCtx(ctx, constants.RequestIDKey)
if rID, ok := requestID.(string); ok {
if rID == "" {
re... | go | {
"resource": ""
} |
q28422 | GetContextFromRequest | train | func GetContextFromRequest(req *protos.Request, serverID string) (context.Context, error) {
ctx, err := pcontext.Decode(req.GetMetadata())
if err != nil {
return nil, err
}
if ctx == nil {
return nil, constants.ErrNoContextFound
}
tags := opentracing.Tags{
"local.id": serverID,
"span.kind": "server... | go | {
"resource": ""
} |
q28423 | SetStatusFlag | train | func (s *SessionVars) SetStatusFlag(flag uint16, on bool) {
if on {
s.Status |= flag
return
}
s.Status &= (^flag)
} | go | {
"resource": ""
} |
q28424 | GetWarnings | train | func (sc *StatementContext) GetWarnings() []error {
sc.mu.Lock()
warns := make([]error, len(sc.mu.warnings))
copy(warns, sc.mu.warnings)
sc.mu.Unlock()
return warns
} | go | {
"resource": ""
} |
q28425 | AppendWarning | train | func (sc *StatementContext) AppendWarning(warn error) {
sc.mu.Lock()
sc.mu.warnings = append(sc.mu.warnings, warn)
sc.mu.Unlock()
} | go | {
"resource": ""
} |
q28426 | Clone | train | func (t *TableInfo) Clone() *TableInfo {
nt := *t
nt.Columns = make([]*ColumnInfo, len(t.Columns))
nt.Indices = make([]*IndexInfo, len(t.Indices))
for i := range t.Columns {
nt.Columns[i] = t.Columns[i].Clone()
}
for i := range t.Indices {
nt.Indices[i] = t.Indices[i].Clone()
}
return &nt
} | go | {
"resource": ""
} |
q28427 | Clone | train | func (index *IndexInfo) Clone() *IndexInfo {
ni := *index
ni.Columns = make([]*IndexColumn, len(index.Columns))
for i := range index.Columns {
ni.Columns[i] = index.Columns[i].Clone()
}
return &ni
} | go | {
"resource": ""
} |
q28428 | Clone | train | func (db *DBInfo) Clone() *DBInfo {
newInfo := *db
newInfo.Tables = make([]*TableInfo, len(db.Tables))
for i := range db.Tables {
newInfo.Tables[i] = db.Tables[i].Clone()
}
return &newInfo
} | go | {
"resource": ""
} |
q28429 | NewCIStr | train | func NewCIStr(s string) (cs CIStr) {
cs.O = s
cs.L = strings.ToLower(s)
return
} | go | {
"resource": ""
} |
q28430 | Output | train | func (d *Dataset) Output(f func(io.Reader) error) *Dataset {
step := d.Flow.AddAllToOneStep(d, nil)
step.IsOnDriverSide = true
step.Name = "Output"
step.Function = func(readers []io.Reader, writers []io.Writer, stat *pb.InstructionStat) error {
errChan := make(chan error, len(readers))
for i, reader := range re... | go | {
"resource": ""
} |
q28431 | Fprintf | train | func (d *Dataset) Fprintf(writer io.Writer, format string) *Dataset {
fn := func(r io.Reader) error {
w := bufio.NewWriter(writer)
defer w.Flush()
return util.Fprintf(w, r, format)
}
return d.Output(fn)
} | go | {
"resource": ""
} |
q28432 | Fprintlnf | train | func (d *Dataset) Fprintlnf(writer io.Writer, format string) *Dataset {
return d.Fprintf(writer, format+"\n")
} | go | {
"resource": ""
} |
q28433 | Printf | train | func (d *Dataset) Printf(format string) *Dataset {
return d.Fprintf(os.Stdout, format)
} | go | {
"resource": ""
} |
q28434 | Printlnf | train | func (d *Dataset) Printlnf(format string) *Dataset {
return d.Fprintf(os.Stdout, format+"\n")
} | go | {
"resource": ""
} |
q28435 | SaveFirstRowTo | train | func (d *Dataset) SaveFirstRowTo(decodedObjects ...interface{}) *Dataset {
fn := func(reader io.Reader) error {
return util.TakeMessage(reader, 1, func(encodedBytes []byte) error {
row, err := util.DecodeRow(encodedBytes)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to decode byte: %v\n", err)
return... | go | {
"resource": ""
} |
q28436 | runStmt | train | func runStmt(ctx context.Context, s ast.Statement) (ast.RecordSet, error) {
var err error
var rs ast.RecordSet
rs, err = s.Exec(ctx)
return rs, errors.Trace(err)
} | go | {
"resource": ""
} |
q28437 | CoGroupPartitionedSorted | train | func (this *Dataset) CoGroupPartitionedSorted(name string, that *Dataset, indexes []int) (ret *Dataset) {
ret = this.Flow.NewNextDataset(len(this.Shards))
ret.IsPartitionedBy = indexes
inputs := []*Dataset{this, that}
step := this.Flow.MergeDatasets1ShardTo1Step(inputs, ret)
step.SetInstruction(name, instruction.... | go | {
"resource": ""
} |
q28438 | NewAggFunction | train | func NewAggFunction(funcType string, funcArgs []Expression, distinct bool) AggregationFunction {
switch tp := strings.ToLower(funcType); tp {
case ast.AggFuncSum:
return &sumFunction{aggFunction: newAggFunc(tp, funcArgs, distinct)}
case ast.AggFuncCount:
return &countFunction{aggFunction: newAggFunc(tp, funcArgs... | go | {
"resource": ""
} |
q28439 | Equal | train | func (af *aggFunction) Equal(b AggregationFunction, ctx context.Context) bool {
if af.GetName() != b.GetName() {
return false
}
if af.Distinct != b.IsDistinct() {
return false
}
if len(af.GetArgs()) == len(b.GetArgs()) {
for i, argA := range af.GetArgs() {
if !argA.Equal(b.GetArgs()[i], ctx) {
return ... | go | {
"resource": ""
} |
q28440 | Clear | train | func (af *aggFunction) Clear() {
af.resultMapper = make(aggCtxMapper, 0)
af.streamCtx = nil
} | go | {
"resource": ""
} |
q28441 | Error | train | func (e *SQLError) Error() string {
return fmt.Sprintf("ERROR %d (%s): %s", e.Code, e.State, e.Message)
} | go | {
"resource": ""
} |
q28442 | NewErr | train | func NewErr(errCode uint16, args ...interface{}) *SQLError {
e := &SQLError{Code: errCode}
if s, ok := MySQLState[errCode]; ok {
e.State = s
} else {
e.State = DefaultMySQLState
}
if format, ok := MySQLErrName[errCode]; ok {
e.Message = fmt.Sprintf(format, args...)
} else {
e.Message = fmt.Sprint(args..... | go | {
"resource": ""
} |
q28443 | NewErrf | train | func NewErrf(errCode uint16, format string, args ...interface{}) *SQLError {
e := &SQLError{Code: errCode}
if s, ok := MySQLState[errCode]; ok {
e.State = s
} else {
e.State = DefaultMySQLState
}
e.Message = fmt.Sprintf(format, args...)
return e
} | go | {
"resource": ""
} |
q28444 | DoLocalLimit | train | func DoLocalLimit(reader io.Reader, writer io.Writer, n int, offset int, stats *pb.InstructionStat) error {
return util.ProcessRow(reader, nil, func(row *util.Row) error {
stats.InputCounter++
if offset > 0 {
offset--
} else {
if n > 0 {
row.WriteTo(writer)
stats.OutputCounter++
}
n--
}
... | go | {
"resource": ""
} |
q28445 | exprHasSetVar | train | func exprHasSetVar(expr expression.Expression) bool {
if fun, ok := expr.(*expression.ScalarFunction); ok {
canPrune := true
if fun.FuncName.L == ast.SetVar {
return false
}
for _, arg := range fun.GetArgs() {
canPrune = canPrune && exprHasSetVar(arg)
if !canPrune {
return false
}
}
}
retur... | go | {
"resource": ""
} |
q28446 | NewSegmentMap | train | func NewSegmentMap(size int64) (*SegmentMap, error) {
if size <= 0 {
return nil, errors.Errorf("Invalid size: %d", size)
}
sm := &SegmentMap{
maps: make([]map[string]interface{}, size),
size: size,
}
for i := int64(0); i < size; i++ {
sm.maps[i] = make(map[string]interface{})
}
sm.crcTable = crc32.Make... | go | {
"resource": ""
} |
q28447 | GetSegment | train | func (sm *SegmentMap) GetSegment(index int64) (map[string]interface{}, error) {
if index >= sm.size || index < 0 {
return nil, errors.Errorf("index out of bound: %d", index)
}
return sm.maps[index], nil
} | go | {
"resource": ""
} |
q28448 | Set | train | func (sm *SegmentMap) Set(key []byte, value interface{}, force bool) bool {
idx := int64(crc32.Checksum(key, sm.crcTable)) % sm.size
k := string(key)
_, exist := sm.maps[idx][k]
if exist && !force {
return exist
}
sm.maps[idx][k] = value
return exist
} | go | {
"resource": ""
} |
q28449 | GetStatusVars | train | func GetStatusVars() (map[string]*StatusVal, error) {
statusVars := make(map[string]*StatusVal)
for _, statistics := range statisticsList {
vals, err := statistics.Stats()
if err != nil {
return nil, errors.Trace(err)
}
for name, val := range vals {
scope := statistics.GetScope(name)
statusVars[nam... | go | {
"resource": ""
} |
q28450 | tryToGetJoinGroup | train | func tryToGetJoinGroup(j *Join) ([]LogicalPlan, bool) {
if j.reordered || !j.cartesianJoin {
return nil, false
}
lChild := j.GetChildByIndex(0).(LogicalPlan)
rChild := j.GetChildByIndex(1).(LogicalPlan)
if nj, ok := lChild.(*Join); ok {
plans, valid := tryToGetJoinGroup(nj)
return append(plans, rChild), vali... | go | {
"resource": ""
} |
q28451 | walkGraphAndComposeJoin | train | func (e *joinReOrderSolver) walkGraphAndComposeJoin(u int) {
e.visited[u] = true
for _, edge := range e.graph[u] {
v := edge.nodeID
if !e.visited[v] {
e.resultJoin = e.newJoin(e.resultJoin, e.group[v])
e.walkGraphAndComposeJoin(v)
}
}
} | go | {
"resource": ""
} |
q28452 | FindCols | train | func FindCols(cols []*Column, names []string) ([]*Column, error) {
var rcols []*Column
for _, name := range names {
col := FindCol(cols, name)
if col != nil {
rcols = append(rcols, col)
} else {
return nil, errUnknownColumn.Gen("unknown column %s", name)
}
}
return rcols, nil
} | go | {
"resource": ""
} |
q28453 | CheckOnce | train | func CheckOnce(cols []*Column) error {
m := map[string]struct{}{}
for _, col := range cols {
name := col.Name
_, ok := m[name.L]
if ok {
return errDuplicateColumn.Gen("column specified twice - %s", name)
}
m[name.L] = struct{}{}
}
return nil
} | go | {
"resource": ""
} |
q28454 | buildIndexRanges | train | func (r *rangeBuilder) buildIndexRanges(rangePoints []rangePoint, tp *types.FieldType) []*IndexRange {
indexRanges := make([]*IndexRange, 0, len(rangePoints)/2)
for i := 0; i < len(rangePoints); i += 2 {
startPoint := r.convertPoint(rangePoints[i], tp)
endPoint := r.convertPoint(rangePoints[i+1], tp)
less, err ... | go | {
"resource": ""
} |
q28455 | Less | train | func (fs *FileSorter) Less(i, j int) bool {
l := fs.buf[i].key
r := fs.buf[j].key
ret, err := lessThan(fs.sc, l, r, fs.byDesc)
if fs.err == nil {
fs.err = err
}
return ret
} | go | {
"resource": ""
} |
q28456 | flushToFile | train | func (fs *FileSorter) flushToFile() error {
var (
err error
outputFile *os.File
outputByte []byte
)
sort.Sort(fs)
if fs.err != nil {
return errors.Trace(fs.err)
}
fileName := fs.getUniqueFileName()
outputFile, err = os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil ... | go | {
"resource": ""
} |
q28457 | fetchNextRow | train | func (fs *FileSorter) fetchNextRow(index int) (*comparableRow, error) {
var (
err error
n int
head = make([]byte, 8)
dcod = make([]types.Datum, 0, fs.keySize+fs.valSize+1)
)
n, err = fs.fds[index].Read(head)
if err == io.EOF {
return nil, nil
}
if err != nil {
return nil, errors.Trace(err)
}
if ... | go | {
"resource": ""
} |
q28458 | externalSort | train | func (fs *FileSorter) externalSort() (*comparableRow, error) {
if !fs.fetched {
if len(fs.buf) > 0 {
err := fs.flushToFile()
if err != nil {
return nil, errors.Trace(err)
}
}
heap.Init(fs.rowHeap)
if fs.rowHeap.err != nil {
return nil, errors.Trace(fs.rowHeap.err)
}
err := fs.openAllFiles... | go | {
"resource": ""
} |
q28459 | ToString | train | func (h Hex) ToString() string {
s := fmt.Sprintf("%x", h.Value)
if len(s)%2 != 0 {
s = "0" + s
}
// should never error.
b, _ := hex.DecodeString(s)
return string(b)
} | go | {
"resource": ""
} |
q28460 | Exec | train | func (a *Statement) Exec(ctx context.Context) (*flow.Dataset, error) {
a.startTime = time.Now()
b := newExecutorBuilder(ctx, a.InfoSchema)
exe := b.build(a.Plan)
if b.err != nil {
return nil, errors.Trace(b.err)
}
if exe == nil {
return nil, fmt.Errorf("Failed to build execution plan %v", plan.ToString(a.P... | go | {
"resource": ""
} |
q28461 | Union | train | func (this *Dataset) Union(name string, others []*Dataset, isParallel bool) *Dataset {
ret := this.Flow.NewNextDataset(len(this.Shards))
inputs := []*Dataset{this}
inputs = append(inputs, others...)
step := this.Flow.MergeDatasets1ShardTo1Step(inputs, ret)
step.SetInstruction(name, instruction.NewUnion(isParallel)... | go | {
"resource": ""
} |
q28462 | Cleanup | train | func (as *AgentServer) Cleanup(ctx context.Context, cleanupRequest *pb.CleanupRequest) (*pb.CleanupResponse, error) {
log.Println("cleaning up", cleanupRequest.GetFlowHashCode())
dir := path.Join(*as.Option.Dir, fmt.Sprintf("%d", cleanupRequest.GetFlowHashCode()))
os.RemoveAll(dir)
return &pb.CleanupResponse{}, n... | go | {
"resource": ""
} |
q28463 | Execute | train | func (as *AgentServer) Execute(request *pb.ExecutionRequest, stream pb.GleamAgent_ExecuteServer) error {
dir := path.Join(*as.Option.Dir, fmt.Sprintf("%d", request.GetInstructionSet().GetFlowHashCode()), request.GetDir())
os.MkdirAll(dir, 0755)
allocated := *request.GetResource()
as.plusAllocated(allocated)
def... | go | {
"resource": ""
} |
q28464 | CollectExecutionStatistics | train | func (as *AgentServer) CollectExecutionStatistics(stream pb.GleamAgent_CollectExecutionStatisticsServer) error {
var statsChan chan *pb.ExecutionStat
for {
stats, err := stream.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if statsChan == nil {
statsChan = getStatsChan(stat... | go | {
"resource": ""
} |
q28465 | Delete | train | func (as *AgentServer) Delete(ctx context.Context, deleteRequest *pb.DeleteDatasetShardRequest) (*pb.DeleteDatasetShardResponse, error) {
log.Println("deleting", deleteRequest.Name)
as.storageBackend.DeleteNamedDatasetShard(deleteRequest.Name)
as.inMemoryChannels.Cleanup(deleteRequest.Name)
return &pb.DeleteDatas... | go | {
"resource": ""
} |
q28466 | collectStepOutputDatasetSize | train | func collectStepOutputDatasetSize(status *pb.FlowExecutionStatus, stepId int32) (counter int64) {
for _, tg := range status.TaskGroups {
for _, execution := range tg.Executions {
if execution.ExecutionStat == nil {
continue
}
for _, stat := range execution.ExecutionStat.Stats {
if stat.StepId == ste... | go | {
"resource": ""
} |
q28467 | DateDiff | train | func DateDiff(startTime, endTime TimeInternal) int {
return calcDaynr(startTime.Year(), startTime.Month(), startTime.Day()) - calcDaynr(endTime.Year(), endTime.Month(), endTime.Day())
} | go | {
"resource": ""
} |
q28468 | compilePattern | train | func compilePattern(pattern string, escape byte) (patChars, patTypes []byte) {
var lastAny bool
patChars = make([]byte, len(pattern))
patTypes = make([]byte, len(pattern))
patLen := 0
for i := 0; i < len(pattern); i++ {
var tp byte
var c = pattern[i]
switch c {
case escape:
lastAny = false
tp = patMa... | go | {
"resource": ""
} |
q28469 | peek | train | func peek(b []byte) (length int, err error) {
if len(b) < 1 {
return 0, errors.New("invalid encoded key")
}
flag := b[0]
length++
b = b[1:]
var l int
switch flag {
case NilFlag:
case intFlag, uintFlag, floatFlag, durationFlag:
// Those types are stored in 8 bytes.
l = 8
case bytesFlag:
l, err = peekBy... | go | {
"resource": ""
} |
q28470 | Hint | train | func (d *Dataset) Hint(options ...DasetsetHint) *Dataset {
for _, option := range options {
option(d)
}
return d
} | go | {
"resource": ""
} |
q28471 | TotalSize | train | func TotalSize(n int64) DasetsetHint {
return func(d *Dataset) {
d.Meta.TotalSize = n
}
} | go | {
"resource": ""
} |
q28472 | PartitionSize | train | func PartitionSize(n int64) DasetsetHint {
return func(d *Dataset) {
d.Meta.TotalSize = n * int64(len(d.GetShards()))
}
} | go | {
"resource": ""
} |
q28473 | OnDisk | train | func (d *Dataset) OnDisk(fn func(*Dataset) *Dataset) *Dataset {
ret := fn(d)
var parents, currents []*Dataset
currents = append(currents, ret)
for {
for _, t := range currents {
isFirstDataset, isLastDataset := false, false
if t == ret {
isLastDataset = true
} else if t.Step.OutputDataset != nil {
... | go | {
"resource": ""
} |
q28474 | Accept | train | func (n *AdminStmt) Accept(v Visitor) (Node, bool) {
newNode, skipChildren := v.Enter(n)
if skipChildren {
return v.Leave(newNode)
}
n = newNode.(*AdminStmt)
for i, val := range n.Tables {
node, ok := val.Accept(v)
if !ok {
return n, false
}
n.Tables[i] = node.(*TableName)
}
return v.Leave(n)
} | go | {
"resource": ""
} |
q28475 | Full | train | func (i Ident) Full(ctx context.Context) (full Ident) {
full.Name = i.Name
if i.Schema.O != "" {
full.Schema = i.Schema
} else {
full.Schema = model.NewCIStr(ctx.GetSessionVars().CurrentDB)
}
return
} | go | {
"resource": ""
} |
q28476 | String | train | func (i Ident) String() string {
if i.Schema.O == "" {
return i.Name.O
}
return fmt.Sprintf("%s.%s", i.Schema, i.Name)
} | go | {
"resource": ""
} |
q28477 | error | train | func (r *Reader) error(err error) error {
return &ParseError{
Line: r.line,
Column: r.column,
Err: err,
}
} | go | {
"resource": ""
} |
q28478 | ReadAll | train | func (r *Reader) ReadAll() (records [][]string, err error) {
for {
record, err := r.Read()
if err == io.EOF {
return records, nil
}
if err != nil {
return nil, err
}
records = append(records, record)
}
} | go | {
"resource": ""
} |
q28479 | readRune | train | func (r *Reader) readRune() (rune, error) {
r1, _, err := r.r.ReadRune()
// Handle \r\n here. We make the simplifying assumption that
// anytime \r is followed by \n that it 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 er... | go | {
"resource": ""
} |
q28480 | skip | train | func (r *Reader) skip(delim rune) error {
for {
r1, err := r.readRune()
if err != nil {
return err
}
if r1 == delim {
return nil
}
}
} | go | {
"resource": ""
} |
q28481 | parseRecord | train | func (r *Reader) parseRecord() (fields []string, err error) {
// Each record starts on a new line. We increment our line
// number (lines start at 1, not 0) and set column to -1
// so as we increment in readRune it points to the character we read.
r.line++
r.column = -1
// Peek at the first rune. If it is an e... | go | {
"resource": ""
} |
q28482 | NewFunction | train | func NewFunction(ctx context.Context, funcName string, retType *types.FieldType, args ...Expression) (Expression, error) {
fc, ok := funcs[funcName]
if !ok {
return nil, errFunctionNotExists.GenByArgs(funcName)
}
funcArgs := make([]Expression, len(args))
copy(funcArgs, args)
f, err := fc.getFunction(funcArgs, c... | go | {
"resource": ""
} |
q28483 | AddDemand | train | func (m *Market) AddDemand(r Requirement, bid float64, retChan chan Supply) {
m.Lock.Lock()
defer m.Lock.Unlock()
if len(m.Supplies) > 0 {
supply, matched := m.pickBestSupplyFor(r)
if matched {
retChan <- supply
close(retChan)
return
}
}
m.Demands = append(m.Demands, Demand{
Requirement: r,
Bid... | go | {
"resource": ""
} |
q28484 | TsvPrintf | train | func TsvPrintf(writer io.Writer, reader io.Reader, format string) error {
return TakeTsv(reader, -1, func(args []string) error {
var objects []interface{}
for _, arg := range args {
objects = append(objects, arg)
}
if len(objects) > 0 {
_, err := fmt.Fprintf(writer, format, objects...)
return err
}
... | go | {
"resource": ""
} |
q28485 | Fprintf | train | func Fprintf(writer io.Writer, reader io.Reader, format string) error {
return ProcessMessage(reader, func(encodedBytes []byte) error {
var decodedObjects []interface{}
var row *Row
var err error
// fmt.Printf("chan input encoded: %s\n", string(encodedBytes))
if row, err = DecodeRow(encodedBytes); err != ni... | go | {
"resource": ""
} |
q28486 | PrintDelimited | train | func PrintDelimited(stat *pb.InstructionStat, reader io.Reader, writer io.Writer, delimiter string, lineSperator string) error {
return ProcessMessage(reader, func(encodedBytes []byte) error {
var row *Row
var err error
// fmt.Printf("chan input encoded: %s\n", string(encodedBytes))
if row, err = DecodeRow(enc... | go | {
"resource": ""
} |
q28487 | matchPropColumn | train | func matchPropColumn(prop *requiredProperty, matchedIdx int, idxCol *model.IndexColumn) int {
if matchedIdx < prop.sortKeyLen {
// When walking through the first sorKeyLen column,
// we should make sure to match them as the columns order exactly.
// So we must check the column in position of matchedIdx.
propCo... | go | {
"resource": ""
} |
q28488 | SetRow | train | func (d *Datum) SetRow(ds []Datum) {
d.k = KindRow
d.x = ds
} | go | {
"resource": ""
} |
q28489 | GetMysqlBit | train | func (d *Datum) GetMysqlBit() Bit {
width := int(d.length)
value := uint64(d.i)
return Bit{Value: value, Width: width}
} | go | {
"resource": ""
} |
q28490 | SetMysqlBit | train | func (d *Datum) SetMysqlBit(b Bit) {
d.k = KindMysqlBit
d.length = uint32(b.Width)
d.i = int64(b.Value)
} | go | {
"resource": ""
} |
q28491 | GetMysqlEnum | train | func (d *Datum) GetMysqlEnum() Enum {
return Enum{Value: uint64(d.i), Name: hack.String(d.b)}
} | go | {
"resource": ""
} |
q28492 | SetMysqlHex | train | func (d *Datum) SetMysqlHex(b Hex) {
d.k = KindMysqlHex
d.i = b.Value
} | go | {
"resource": ""
} |
q28493 | Cast | train | func (d *Datum) Cast(sc *variable.StatementContext, target *FieldType) (ad Datum, err error) {
if !isCastType(target.Tp) {
return ad, errors.Errorf("unknown cast type - %v", target)
}
return d.ConvertTo(sc, target)
} | go | {
"resource": ""
} |
q28494 | ToString | train | func (d *Datum) ToString() (string, error) {
switch d.Kind() {
case KindInt64:
return strconv.FormatInt(d.GetInt64(), 10), nil
case KindUint64:
return strconv.FormatUint(d.GetUint64(), 10), nil
case KindFloat32:
return strconv.FormatFloat(float64(d.GetFloat32()), 'f', -1, 32), nil
case KindFloat64:
return ... | go | {
"resource": ""
} |
q28495 | CoerceDatum | train | func CoerceDatum(sc *variable.StatementContext, a, b Datum) (x, y Datum, err error) {
if a.IsNull() || b.IsNull() {
return x, y, nil
}
var (
hasUint bool
hasDecimal bool
hasFloat bool
)
x = a.convergeType(&hasUint, &hasDecimal, &hasFloat)
y = b.convergeType(&hasUint, &hasDecimal, &hasFloat)
if hasFl... | go | {
"resource": ""
} |
q28496 | DatumsToInterfaces | train | func DatumsToInterfaces(datums []Datum) []interface{} {
ins := make([]interface{}, len(datums))
for i, v := range datums {
ins[i] = v.GetValue()
}
return ins
} | go | {
"resource": ""
} |
q28497 | SortDatums | train | func SortDatums(sc *variable.StatementContext, datums []Datum) error {
sorter := datumsSorter{datums: datums, sc: sc}
sort.Sort(&sorter)
return sorter.err
} | go | {
"resource": ""
} |
q28498 | errorOrWarning | train | func errorOrWarning(err error, ctx context.Context) error {
sc := ctx.GetSessionVars().StmtCtx
// TODO: Use better name, such as sc.IsInsert instead of sc.IgnoreTruncate.
if ctx.GetSessionVars().StrictSQLMode && !sc.IgnoreTruncate {
return errors.Trace(types.ErrInvalidTimeFormat)
}
sc.AppendWarning(err)
return ... | go | {
"resource": ""
} |
q28499 | BuiltinValuesFactory | train | func BuiltinValuesFactory(offset int) BuiltinFunc {
return func(_ []types.Datum, ctx context.Context) (d types.Datum, err error) {
values := ctx.GetSessionVars().CurrInsertValues
if values == nil {
err = errors.New("Session current insert values is nil")
return
}
row := values.([]types.Datum)
if len(ro... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.