id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c28500 | }
break
}
newRow.UseKeys(indexes)
x := util.Compare(row.K, newRow.K)
if x == 0 {
row.V = append(row.V, newRow.V)
} else {
writer <- row
row.K = newRow.K
row.V = []interface{}{newRow.V}
}
row.T = max(row.T, newRow.T)
}
writer <- row
}()
return writer
} | |
c28501 | = append(value, getPrintDivLine(maxColLen)...)
value = append(value, getPrintRows(datas, maxColLen)...)
value = append(value, getPrintDivLine(maxColLen)...)
return string(value), true
} | |
c28502 |
if !ok {
return false
}
return x.FnName.L == currentTimestampL
} | |
c28503 |
// depends on the previous step group
// MAYBE IMPROVEMENT: depends on a subset of previus shards
tg.ParentStepGroup = stepGroup
stepGroup.TaskGroups = append(stepGroup.TaskGroups, tg)
tg.Id = len(ret)
ret = append(ret, tg)
}
}
return
} | |
c28504 | append(conditions, x)
}
case *ast.ParenthesesExpr:
conditions = append(conditions, splitWhere(x.Expr)...)
default:
conditions = append(conditions, where)
}
return conditions
} | |
c28505 | d, nil
}
d.SetMysqlDecimal(de)
return d, nil
case KindMysqlHex:
d.SetFloat64(a.GetMysqlHex().ToNumber())
return d, nil
case KindMysqlBit:
d.SetFloat64(a.GetMysqlBit().ToNumber())
return d, nil
case KindMysqlEnum:
d.SetFloat64(a.GetMysqlEnum().ToNumber())
return d, nil
case KindMysqlSet:
d.SetFl... | |
c28506 |
case KindFloat64:
switch b.Kind() {
case KindFloat64:
r := a.GetFloat64() + b.GetFloat64()
d.SetFloat64(r)
return d, nil
}
case KindMysqlDecimal:
switch b.Kind() {
case KindMysqlDecimal:
r := new(MyDecimal)
err = DecimalAdd(a.GetMysqlDecimal(), b.GetMysqlDecimal(), r)
d.SetMysqlDecimal(r)... | |
c28507 |
case KindFloat64:
switch b.Kind() {
case KindFloat64:
r := a.GetFloat64() - b.GetFloat64()
d.SetFloat64(r)
return d, nil
}
case KindMysqlDecimal:
switch b.Kind() {
case KindMysqlDecimal:
r := new(MyDecimal)
err = DecimalSub(a.GetMysqlDecimal(), b.GetMysqlDecimal(), r)
d.SetMysqlDecimal(r)... | |
c28508 | }
d.SetFloat64(math.Mod(x, y))
return d, nil
}
case KindMysqlDecimal:
x := a.GetMysqlDecimal()
switch b.Kind() {
case KindMysqlDecimal:
y := b.GetMysqlDecimal()
to := new(MyDecimal)
err = DecimalMod(x, y, to)
if err != ErrDivByZero {
d.SetMysqlDecimal(to)
} else {
// div by zero ... | |
c28509 |
if err != nil && err != ErrTruncated {
return 0, errors.Trace(err)
}
uintX = uint64(intX)
} else {
uintX, err = roundX.ToUint()
if err != nil && err != ErrTruncated {
return 0, errors.Trace(err)
}
}
return uintX, nil
} | |
c28510 | use uint64 to calculate.
x, err := convertNonInt2RoundUint64(sc, a)
if err != nil {
return d, errors.Trace(err)
}
d.SetUint64(^x)
return d, nil
} | |
c28511 |
return
}
// If either is not integer, we round the operands and then use uint64 to calculate.
x, err := convertNonInt2RoundUint64(sc, a)
if err != nil {
return d, errors.Trace(err)
}
y, err := convertNonInt2RoundUint64(sc, b)
if err != nil {
return d, errors.Trace(err)
}
d.SetUint64(x ^ y)
return d, ... | |
c28512 | decimal2RoundUint(decimalX)
if err != nil {
return d, errors.Trace(err)
}
return
} | |
c28513 | = v.ToDecimal(sc)
if err == nil {
data = types.NewDecimalDatum(d)
}
case types.KindMysqlDecimal:
data = v
default:
var f float64
f, err = v.ToFloat64(sc)
if err == nil {
data = types.NewFloat64Datum(f)
}
}
if err != nil {
return data, errors.Trace(err)
}
if data.IsNull() {
return sum, ni... | |
c28514 | fmt.Errorf("WriteMessage Error: %v", err)
break
}
atomic.AddInt64(&outCounter, 1)
}
}()
for range readers {
err := <-errChan
if err != nil && err != io.EOF {
return inCounter, outCounter, err
}
}
close(writerChan)
wg.Wait()
return inCounter, outCounter, nil
} | |
c28515 | true
step.Command = script.NewShellScript().Pipe(code).GetCommand()
return ret
} | |
c28516 | pq.Enqueue(row, 0)
}
} else {
pq.Enqueue(row, 0)
}
return nil
})
if err != nil {
fmt.Printf("Top>Failed to process input data:%v\n", err)
return err
}
// read data out of the priority queue
length := pq.Len()
itemsToReverse := make([]*util.Row, length)
for i := 0; i < length; i++ {
entry, _ ... | |
c28517 | ve := &ValueExpr{}
ve.SetValue(value)
types.DefaultTypeForValue(value, &ve.Type)
return ve
} | |
c28518 | o.IsProfiling = isProfiling
return o
} | |
c28519 |
if err != nil {
relativePath = relatedFile
}
o.RequiredFiles = append(o.RequiredFiles, resource.FileResource{relativePath, toFolder})
return o
} | |
c28520 | fmt.Errorf("WriteTo encoding error: %v", err)
}
return WriteMessage(writer, encoded)
} | |
c28521 | err = DecodeRow(encodedBytes); err != nil {
return row, fmt.Errorf("ReadRow failed to decode byte: %v", err)
}
return row, err
} | |
c28522 | return nil, fmt.Errorf("Failed to encode key: %v", err)
}
}
return buf.Bytes(), nil
} | |
c28523 | = fmt.Errorf("decode row error %v: %s\n", err, string(encodedBytes))
}
return row, err
} | |
c28524 | != nil {
return fmt.Errorf("DoLocalDistinct error %v: %+v", err, input)
}
row.UseKeys(indexes)
return f(row)
})
} | |
c28525 |
return 1000
}
if a.Rack != b.Rack {
return 100
}
if a.Server != b.Server {
return 10
}
return 1
} | |
c28526 |
resolver := nameResolver{Info: info, Ctx: ctx, DefaultSchema: model.NewCIStr(defaultSchema)}
node.Accept(&resolver)
return errors.Trace(resolver.Err)
} | |
c28527 | return nil
}
return nr.contextStack[stackLen-1]
} | |
c28528 | map[string]int{},
derivedTableMap: map[string]int{},
})
} | |
c28529 | = nr.contextStack[:len(nr.contextStack)-1]
} | |
c28530 | := nr.currentContext()
ctx.joinNodeStack = append(ctx.joinNodeStack, j)
} | |
c28531 |
ctx.joinNodeStack = ctx.joinNodeStack[:len(ctx.joinNodeStack)-1]
} | |
c28532 | return
}
tn.TableInfo = table.Meta()
dbInfo, _ := nr.Info.SchemaByName(tn.Schema)
tn.DBInfo = dbInfo
rfs := make([]*ast.ResultField, 0, len(tn.TableInfo.Columns))
tmp := make([]struct {
ast.ValueExpr
ast.ResultField
}, len(tn.TableInfo.Columns))
for i, v := range tn.TableInfo.Columns {
expr := &tmp[i].... | |
c28533 |
rightLen := len(j.Right.GetResultFields())
rfs := make([]*ast.ResultField, leftLen+rightLen)
copy(rfs, j.Left.GetResultFields())
copy(rfs[leftLen:], j.Right.GetResultFields())
j.SetResultFields(rfs)
} | |
c28534 |
if i < len(nr.contextStack)-1 {
// If in subselect, the query use outer query.
nr.currentContext().useOuterContext = true
}
return
}
}
nr.Err = errors.Errorf("unknown column %s", cn.Name.Name.L)
} | |
c28535 | = ErrIllegalReference.Gen("Reference '%s' not supported (reference to group function)", cn.Name.Name.O)
}
return true
}
return found
}
if ctx.inHaving {
// First group by, then field list.
if nr.resolveColumnInResultFields(ctx, cn, ctx.groupBy) {
return true
}
if ctx.inHavingAgg {
// If cn is... | |
c28536 |
tableSources := appendTableSources(nil, join)
if !nr.resolveColumnInTableSources(cn, tableSources) {
nr.Err = errors.Errorf("unknown column name %s", cn.Name.Name.O)
}
} | |
c28537 | resultFields = append(resultFields, nr.createResultFields(v)...)
}
nr.currentContext().fieldList = resultFields
} | |
c28538 | c.Name,
DefaultCollation: c.DefaultCollation.Name,
Desc: c.Desc,
Maxlen: c.Maxlen,
}
descs = append(descs, desc)
}
return descs
} | |
c28539 | return false
}
if co == "" {
return true
}
_, ok = c.Collations[co]
if !ok {
return false
}
return true
} | |
c28540 | return "", errors.Errorf("Unknown charset %s", charset)
}
return c.DefaultCollation.Name, nil
} | |
c28541 | errors.Errorf("Unknown charset %s", cs)
}
return c.Name, c.DefaultCollation.Name, nil
} | |
c28542 | types.NewDatum(0),
RetType: types.NewFieldType(mysql.TypeLong)}}
}
if (childIdx == 0 && join.JoinType == RightOuterJoin) || (childIdx == 1 && join.JoinType == LeftOuterJoin) {
var existsDefaultValues bool
join.DefaultValues, existsDefaultValues = a.getDefaultValues(agg)
if !existsDefaultValues {
return... | |
c28543 | _, stepGroupId := range noDependencyStepGroupIds {
for _, parentId := range status.StepGroups[stepGroupId].GetParentIds() {
dependencyCount[parentId]--
}
}
noDependencyStepGroupIds = checkAllDepencies(dependencyCount, isUsed)
}
return
} | |
c28544 | return newArgs, errors.Trace(err)
}
newArgs[i] = types.NewStringDatum(str)
} else {
// If error occurred when convert arg to float64, ignore it and set f as 0.
f, _ := arg.ToFloat64(sc)
newArgs[i] = types.NewFloat64Datum(f)
}
}
return
} | |
c28545 | current.StepId == stat.StepId && current.TaskId == stat.TaskId {
exe.stats[i] = stat
// fmt.Printf("executor received stat: %+v\n", stat)
break
}
}
}
}
} | |
c28546 | = strings.ToLower(strings.Trim(label, "\t\n\r\f "))
enc := encodings[label]
return enc.e, enc.name
} | |
c28547 | q.HasHeader = hasHeader
return q
} | |
c28548 | nil {
log.Printf("should not happen, precision %d, frac %d %v", precision, frac, err)
return b
}
b = append(b, bin...)
return b
} | |
c28549 |
addChild(ap, innerPlan)
ap.SetSchema(expression.MergeSchema(outerPlan.GetSchema(), innerPlan.GetSchema()))
for i := outerPlan.GetSchema().Len(); i < ap.GetSchema().Len(); i++ {
ap.schema.Columns[i].IsAggOrSubq = true
}
ap.SetCorrelated()
return ap
} | |
c28550 |
filterConditions = append(filterConditions, cond)
continue
}
accessConditions = append(accessConditions, cond)
// TODO: it will lead to repeated computation cost.
if checker.shouldReserve {
filterConditions = append(filterConditions, cond)
checker.shouldReserve = false
}
}
return accessConditi... | |
c28551 |
for i := byteSize - 1; i >= 0; i-- {
buf[byteSize-i-1] = byte(b.Value >> uint(i*8))
}
return string(buf)
} | |
c28552 |
inErr, ok := originErr.(*Error)
return ok && e.class == inErr.class && e.code == inErr.code
} | |
c28553 | return mysql.NewErrf(code, e.getMsg())
} | |
c28554 | := e1.(*Error)
te2, ok2 := e2.(*Error)
if ok1 && ok2 {
return te1.class == te2.class && te1.code == te2.code
}
return e1.Error() == e2.Error()
} | |
c28555 | input.GetShards() {
task := step.NewTask()
if output != nil && output.Shards != nil {
fromTaskToDatasetShard(task, output.GetShards()[i])
}
fromDatasetShardToTask(shard, task)
}
return
} | |
c28556 | {
fromTaskToDatasetShard(task, output.GetShards()[0])
}
for _, shard := range input.GetShards() {
fromDatasetShardToTask(shard, task)
}
return
} | |
c28557 | fromDatasetToStep(input, step)
}
// setup the network
if output != nil {
for shardId, outShard := range output.Shards {
task := step.NewTask()
for _, input := range inputs {
fromDatasetShardToTask(input.GetShards()[shardId], task)
}
fromTaskToDatasetShard(task, outShard)
}
}
return
} | |
c28558 | }
cmp, err := a.CompareDatum(sc, b)
if err != nil {
return false
}
if cmp != 0 {
return false
}
}
return !ir.LowExclude && !ir.HighExclude
} | |
c28559 | return s.Generate(fc)
} | |
c28560 | []string) error {
stats.InputCounter++
var row []interface{}
for _, m := range message {
row = append(row, m)
}
stats.OutputCounter++
return util.NewRow(util.Now(), row...).WriteTo(writer)
})
}
return fc.Source(address, fn)
} | |
c28561 | config FlowConfig
for _, option := range options {
option(&config)
}
} | |
c28562 |
currentDatasetTotalSize += ds.GetTotalSize()
}
d.Meta.TotalSize = currentDatasetTotalSize
return currentDatasetTotalSize
} | |
c28563 | {
return d.GetTotalSize() / int64(len(d.Shards))
} | |
c28564 | err != nil {
return 0, errors.Trace(err)
}
return t.Compare(o), nil
} | |
c28565 | {
return 0, errors.Trace(ErrInvalidYear)
}
return y, nil
} | |
c28566 |
if err != nil {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
microseconds, err := strconv.ParseInt(alignFrac(fields[1], MaxFsp), 10, 64)
if err != nil {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
return 0, 0, 0, gotime.Duration(seconds)*gotime.Second + ... | |
c28567 | time format - %s", format)
}
hours, err := strconv.ParseInt(fields[1], 10, 64)
if err != nil {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
return 0, 0, days, gotime.Duration(hours) * gotime.Hour, nil
} | |
c28568 | strconv.ParseInt(fields[1], 10, 64)
if err != nil {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
return years, months, 0, 0, nil
} | |
c28569 | {
// 12 is a special hour.
switch valueAMorPm {
case constForAM:
t.hour = 0
case constForPM:
t.hour = 12
}
return nil
}
if valueAMorPm == constForPM {
t.hour += 12
}
}
return nil
} | |
c28570 |
dateRemain, succ := matchDateWithToken(t, date, token, ctx)
if !succ {
return false
}
return strToDate(t, dateRemain, formatRemain, ctx)
} | |
c28571 | 0 {
t.month = uint8(month)
return remain, true
}
return input, false
} | |
c28572 | util.NewRow(ts, anyObject...).WriteTo(os.Stdout)
} | |
c28573 | yyLexer
parser.lexer.reset(sql)
l = &parser.lexer
yyParse(l, parser)
if len(l.Errors()) != 0 {
return nil, errors.Trace(l.Errors()[0])
}
for _, stmt := range parser.result {
ast.SetFlag(stmt)
}
return parser.result, nil
} | |
c28574 | collation)
if err != nil {
return nil, errors.Trace(err)
}
if len(stmts) != 1 {
return nil, ErrSyntax
}
ast.SetFlag(stmts[0])
return stmts[0], nil
} | |
c28575 | len(parser.src)-1 {
lastField.SetText(parser.src[lastField.Offset:lastEnd])
}
} | |
c28576 | default charset from ctx
inferrer.defaultCharset = "utf8"
node.Accept(&inferrer)
return inferrer.err
} | |
c28577 | *t
} else {
mtp := types.MergeFieldType(currType.Tp, t.Tp)
if mtp == t.Tp && mtp != currType.Tp {
currType.Charset = t.Charset
currType.Collate = t.Collate
}
currType.Tp = mtp
}
}
x.SetType(&currType)
// TODO: We need a better way to set charset/collation
x.Type.Charset, x.Type.Collate = ty... | |
c28578 |
x.Type.Charset = charset.CharsetBin
x.Type.Collate = charset.CollationBin
x.Expr = v.addCastToString(x.Expr)
x.Pattern = v.addCastToString(x.Pattern)
} | |
c28579 |
expr.SetDatum(newVal)
} else {
castFunc := &ast.FuncCastExpr{
Expr: expr,
Tp: castTp,
FunctionType: ast.CastFunction,
}
expr = castFunc
}
expr.SetType(castTp)
}
return expr
} | |
c28580 | v.err = errors.Trace(err)
}
cmp, err := newDatum.CompareDatum(v.sc, valueExpr.Datum)
if err != nil {
v.err = errors.Trace(err)
}
if cmp != 0 {
// The value will never match the column, do not set newDatum.
continue
}
valueExpr.SetDatum(newDatum)
}
}
if v.err != nil... | |
c28581 | MaxFraction)
return doDivMod(from1, from2, to, nil, fracIncr)
} | |
c28582 | new executors.", s.Master)
time.Sleep(time.Millisecond * time.Duration(2000+rand.Int63n(1000)))
} else {
if s.Option.DataCenter == "" {
s.Option.DataCenter = result.Allocations[0].Location.DataCenter
}
var allocatedMemory int64
for _, allocation := range result.Allocations {
s.Market.AddSupply... | |
c28583 | (ret *Dataset) {
sortOption := Field(1)
return d.ReduceBy(name, reducerId, sortOption)
} | |
c28584 | ret = ret.MergeTo(name, 1).LocalReduceBy(name+".LocalReduce2", reducerId, nil)
}
return ret
} | |
c28585 |
// Notice that no matter what kind of join is, it's always right.
newConds := make([]expression.Expression, 0, len(sel.Conditions))
for _, cond := range sel.Conditions {
newConds = append(newConds, cond.Decorrelate(outerPlan.GetSchema()))
}
apply.attachOnConds(newConds)
innerPlan = sel.children[0... | |
c28586 | = bufio.NewWriter(w)
bufWriters = append(bufWriters, bufWriter)
writers = append(writers, bufWriter)
}
}
function(writers)
for _, w := range bufWriters {
w.Flush()
}
} | |
c28587 | s.errs = s.errs[:0]
s.stmtStartPos = 0
} | |
c28588 | %d near \"%s\"%s (total length %d)", s.r.p.Line, s.r.p.Col, val, str, len(s.r.s))
s.errs = append(s.errs, err)
} | |
c28589 | case 'Z':
ch0 = 26
case 'r':
ch0 = '\r'
case 't':
ch0 = '\t'
case '%', '_':
s.buf.WriteByte('\\')
}
return ch0
} | |
c28590 | 0
}
r.p.Offset += r.w
r.p.Col++
} | |
c28591 | }
child.AddParent(parent)
parent.AddChild(child)
} | |
c28592 | return errors.Trace(err)
}
insert.AddChild(child)
insert.AddParent(parent)
return nil
} | |
c28593 |
if len(parents) == 0 {
child := children[0]
child.SetParents()
return nil
}
parent, child := parents[0], children[0]
err := parent.ReplaceChild(p, child)
if err != nil {
return errors.Trace(err)
}
err = child.ReplaceParent(p, parent)
return errors.Trace(err)
} | |
c28594 | = append(args, os.Args[1:]...)
args = append(args, "-gleam.mapper", string(mapperId))
step.Command = &script.Command{
Path: ex,
Args: args,
}
return ret
} | |
c28595 |
step.SetInstruction(name, instruction.NewSelect([]int{indexes[0]}, indexes[1:]))
step.Description = fmt.Sprintf("select %v", sortOption.Indexes())
return ret
} | |
c28596 | instruction.NewSelect(keys.Indexes(), values.Indexes()))
return ret
} | |
c28597 | d.IsLocalSorted
ret.IsPartitionedBy = d.IsPartitionedBy
step.SetInstruction(name, instruction.NewLocalLimit(n, offset))
step.Description = fmt.Sprintf("local limit %d", n)
return ret
} | |
c28598 | {
// no dataset inputs
break
}
if !isMergeableDataset(current.InputDatasets[0], taskCount) {
break
}
if (!current.IsOnDriverSide && current.InputDatasets[0].Step.IsOnDriverSide) ||
(current.IsOnDriverSide && !current.InputDatasets[0].Step.IsOnDriverSide) {
break
}
current = current.InputDat... | |
c28599 | {
// since we add steps following the same order as the code
log.Panic("parent StepGroup should already be in the map")
}
stepId2StepGroup[ancestorStepId].AddParent(parentSg)
}
}
stepId2StepGroup[ancestorStepId].AddStep(step)
}
// shrink
var ret []*StepGroup
for _, stepGroup := range stepI... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.