_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28500 | newChannelOfValuesWithSameKey | train | func newChannelOfValuesWithSameKey(name string, sortedChan io.Reader, indexes []int) chan util.Row {
writer := make(chan util.Row, 1024)
go func() {
defer close(writer)
firstRow, err := util.ReadRow(sortedChan)
if err != nil {
if err != io.EOF {
fmt.Fprintf(os.Stderr, "%s join read first row error: %v\... | go | {
"resource": ""
} |
q28501 | GetPrintResult | train | func GetPrintResult(cols []string, datas [][]string) (string, bool) {
if !checkValidity(cols, datas) {
return "", false
}
var value []byte
maxColLen := getMaxColLen(cols, datas)
value = append(value, getPrintDivLine(maxColLen)...)
value = append(value, getPrintCol(cols, maxColLen)...)
value = append(value, g... | go | {
"resource": ""
} |
q28502 | IsCurrentTimeExpr | train | func IsCurrentTimeExpr(e ast.ExprNode) bool {
x, ok := e.(*ast.FuncCallExpr)
if !ok {
return false
}
return x.FnName.L == currentTimestampL
} | go | {
"resource": ""
} |
q28503 | translateToTaskGroups | train | func translateToTaskGroups(stepId2StepGroup []*StepGroup) (ret []*TaskGroup) {
for _, stepGroup := range stepId2StepGroup {
assertSameNumberOfTasks(stepGroup.Steps)
count := len(stepGroup.Steps[0].Tasks)
// println("dealing with", stepGroup.Steps[0].Name, "tasks:", len(stepGroup.Steps[0].Tasks))
for i := 0; i ... | go | {
"resource": ""
} |
q28504 | splitWhere | train | func splitWhere(where ast.ExprNode) []ast.ExprNode {
var conditions []ast.ExprNode
switch x := where.(type) {
case nil:
case *ast.BinaryOperationExpr:
if x.Op == opcode.AndAnd {
conditions = append(conditions, splitWhere(x.L)...)
conditions = append(conditions, splitWhere(x.R)...)
} else {
conditions =... | go | {
"resource": ""
} |
q28505 | CoerceArithmetic | train | func CoerceArithmetic(sc *variable.StatementContext, a Datum) (d Datum, err error) {
switch a.Kind() {
case KindString, KindBytes:
// MySQL will convert string to float for arithmetic operation
f, err := StrToFloat(sc, a.GetString())
if err != nil {
return d, errors.Trace(err)
}
d.SetFloat64(f)
return ... | go | {
"resource": ""
} |
q28506 | ComputePlus | train | func ComputePlus(a, b Datum) (d Datum, err error) {
switch a.Kind() {
case KindInt64:
switch b.Kind() {
case KindInt64:
r, err1 := AddInt64(a.GetInt64(), b.GetInt64())
d.SetInt64(r)
return d, errors.Trace(err1)
case KindUint64:
r, err1 := AddInteger(b.GetUint64(), a.GetInt64())
d.SetUint64(r)
... | go | {
"resource": ""
} |
q28507 | ComputeMinus | train | func ComputeMinus(a, b Datum) (d Datum, err error) {
switch a.Kind() {
case KindInt64:
switch b.Kind() {
case KindInt64:
r, err1 := SubInt64(a.GetInt64(), b.GetInt64())
d.SetInt64(r)
return d, errors.Trace(err1)
case KindUint64:
r, err1 := SubIntWithUint(a.GetInt64(), b.GetUint64())
d.SetUint64(r... | go | {
"resource": ""
} |
q28508 | ComputeMod | train | func ComputeMod(sc *variable.StatementContext, a, b Datum) (d Datum, err error) {
switch a.Kind() {
case KindInt64:
x := a.GetInt64()
switch b.Kind() {
case KindInt64:
y := b.GetInt64()
if y == 0 {
return d, nil
}
d.SetInt64(x % y)
return d, nil
case KindUint64:
y := b.GetUint64()
if ... | go | {
"resource": ""
} |
q28509 | decimal2RoundUint | train | func decimal2RoundUint(x *MyDecimal) (uint64, error) {
roundX := new(MyDecimal)
x.Round(roundX, 0)
var (
uintX uint64
err error
)
if roundX.IsNegative() {
intX, err := roundX.ToInt()
if err != nil && err != ErrTruncated {
return 0, errors.Trace(err)
}
uintX = uint64(intX)
} else {
uintX, err = ... | go | {
"resource": ""
} |
q28510 | ComputeBitNeg | train | func ComputeBitNeg(sc *variable.StatementContext, a Datum) (d Datum, err error) {
aKind := a.Kind()
if aKind == KindInt64 || aKind == KindUint64 {
d.SetUint64(^a.GetUint64())
return
}
// If either is not integer, we round the operands and then use uint64 to calculate.
x, err := convertNonInt2RoundUint64(sc, a)... | go | {
"resource": ""
} |
q28511 | ComputeBitXor | train | func ComputeBitXor(sc *variable.StatementContext, a, b Datum) (d Datum, err error) {
aKind, bKind := a.Kind(), b.Kind()
if (aKind == KindInt64 || aKind == KindUint64) && (bKind == KindInt64 || bKind == KindUint64) {
d.SetUint64(a.GetUint64() ^ b.GetUint64())
return
}
// If either is not integer, we round the op... | go | {
"resource": ""
} |
q28512 | convertNonInt2RoundUint64 | train | func convertNonInt2RoundUint64(sc *variable.StatementContext, x Datum) (d uint64, err error) {
decimalX, err := x.ToDecimal(sc)
if err != nil {
return d, errors.Trace(err)
}
d, err = decimal2RoundUint(decimalX)
if err != nil {
return d, errors.Trace(err)
}
return
} | go | {
"resource": ""
} |
q28513 | calculateSum | train | func calculateSum(sc *variable.StatementContext, sum, v types.Datum) (data types.Datum, err error) {
// for avg and sum calculation
// avg and sum use decimal for integer and decimal type, use float for others
// see https://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html
switch v.Kind() {
case types.Kind... | go | {
"resource": ""
} |
q28514 | CopyMultipleReaders | train | func CopyMultipleReaders(readers []io.Reader, writer io.Writer) (inCounter int64, outCounter int64, e error) {
writerChan := make(chan []byte, 16*len(readers))
errChan := make(chan error, len(readers))
defer close(errChan)
var wg sync.WaitGroup
for _, reader := range readers {
wg.Add(1)
go func(reader io.Re... | go | {
"resource": ""
} |
q28515 | Pipe | train | func (d *Dataset) Pipe(name, code string) *Dataset {
ret, step := add1ShardTo1Step(d)
step.Name = name
step.Description = code
step.IsPipe = true
step.Command = script.NewShellScript().Pipe(code).GetCommand()
return ret
} | go | {
"resource": ""
} |
q28516 | DoLocalTop | train | func DoLocalTop(reader io.Reader, writer io.Writer, n int, orderBys []OrderBy, stats *pb.InstructionStat) error {
pq := newMinQueueOfPairs(orderBys)
err := util.ProcessRow(reader, nil, func(row *util.Row) error {
stats.InputCounter++
if pq.Len() >= n {
if lessThan(orderBys, pq.Top().(*util.Row), row) {
... | go | {
"resource": ""
} |
q28517 | NewValueExpr | train | func NewValueExpr(value interface{}) *ValueExpr {
if ve, ok := value.(*ValueExpr); ok {
return ve
}
ve := &ValueExpr{}
ve.SetValue(value)
types.DefaultTypeForValue(value, &ve.Type)
return ve
} | go | {
"resource": ""
} |
q28518 | SetProfiling | train | func (o *DistributedOption) SetProfiling(isProfiling bool) *DistributedOption {
o.IsProfiling = isProfiling
return o
} | go | {
"resource": ""
} |
q28519 | WithFile | train | func (o *DistributedOption) WithFile(relatedFile, toFolder string) *DistributedOption {
relativePath, err := filepath.Rel(".", relatedFile)
if err != nil {
relativePath = relatedFile
}
o.RequiredFiles = append(o.RequiredFiles, resource.FileResource{relativePath, toFolder})
return o
} | go | {
"resource": ""
} |
q28520 | WriteTo | train | func (row Row) WriteTo(writer io.Writer) (err error) {
encoded, err := encodeRow(row)
if err != nil {
return fmt.Errorf("WriteTo encoding error: %v", err)
}
return WriteMessage(writer, encoded)
} | go | {
"resource": ""
} |
q28521 | ReadRow | train | func ReadRow(reader io.Reader) (row *Row, err error) {
encodedBytes, hasErr := ReadMessage(reader)
if hasErr != nil {
if hasErr != io.EOF {
return row, fmt.Errorf("ReadRow ReadMessage: %v", hasErr)
}
return row, io.EOF
}
if row, err = DecodeRow(encodedBytes); err != nil {
return row, fmt.Errorf("ReadRow ... | go | {
"resource": ""
} |
q28522 | EncodeKeys | train | func EncodeKeys(anyObject ...interface{}) ([]byte, error) {
var buf bytes.Buffer
en := msgp.NewWriter(&buf)
for _, obj := range anyObject {
if err := en.WriteIntf(obj); err != nil {
return nil, fmt.Errorf("Failed to encode key: %v", err)
}
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q28523 | DecodeRow | train | func DecodeRow(encodedBytes []byte) (*Row, error) {
row := &Row{}
_, err := row.UnmarshalMsg(encodedBytes)
if err != nil {
err = fmt.Errorf("decode row error %v: %s\n", err, string(encodedBytes))
}
return row, err
} | go | {
"resource": ""
} |
q28524 | ProcessRow | train | func ProcessRow(reader io.Reader, indexes []int, f func(*Row) error) (err error) {
return ProcessMessage(reader, func(input []byte) error {
// read the row
row, err := DecodeRow(input)
if err != nil {
return fmt.Errorf("DoLocalDistinct error %v: %+v", err, input)
}
row.UseKeys(indexes)
return f(row)
})... | go | {
"resource": ""
} |
q28525 | Distance | train | func (a *Location) Distance(b *Location) float64 {
if a.DataCenter != b.DataCenter {
return 1000
}
if a.Rack != b.Rack {
return 100
}
if a.Server != b.Server {
return 10
}
return 1
} | go | {
"resource": ""
} |
q28526 | ResolveName | train | func ResolveName(node ast.Node, info infoschema.InfoSchema, ctx context.Context) error {
defaultSchema := ctx.GetSessionVars().CurrentDB
resolver := nameResolver{Info: info, Ctx: ctx, DefaultSchema: model.NewCIStr(defaultSchema)}
node.Accept(&resolver)
return errors.Trace(resolver.Err)
} | go | {
"resource": ""
} |
q28527 | currentContext | train | func (nr *nameResolver) currentContext() *resolverContext {
stackLen := len(nr.contextStack)
if stackLen == 0 {
return nil
}
return nr.contextStack[stackLen-1]
} | go | {
"resource": ""
} |
q28528 | pushContext | train | func (nr *nameResolver) pushContext() {
nr.contextStack = append(nr.contextStack, &resolverContext{
tableMap: map[string]int{},
derivedTableMap: map[string]int{},
})
} | go | {
"resource": ""
} |
q28529 | popContext | train | func (nr *nameResolver) popContext() {
nr.contextStack = nr.contextStack[:len(nr.contextStack)-1]
} | go | {
"resource": ""
} |
q28530 | pushJoin | train | func (nr *nameResolver) pushJoin(j *ast.Join) {
ctx := nr.currentContext()
ctx.joinNodeStack = append(ctx.joinNodeStack, j)
} | go | {
"resource": ""
} |
q28531 | popJoin | train | func (nr *nameResolver) popJoin() {
ctx := nr.currentContext()
ctx.joinNodeStack = ctx.joinNodeStack[:len(ctx.joinNodeStack)-1]
} | go | {
"resource": ""
} |
q28532 | handleTableName | train | func (nr *nameResolver) handleTableName(tn *ast.TableName) {
if tn.Schema.L == "" {
tn.Schema = nr.DefaultSchema
}
ctx := nr.currentContext()
if ctx.inCreateOrDropTable {
// The table may not exist in create table or drop table statement.
// Skip resolving the table to avoid error.
return
}
if ctx.inDelet... | go | {
"resource": ""
} |
q28533 | handleJoin | train | func (nr *nameResolver) handleJoin(j *ast.Join) {
if j.Right == nil {
j.SetResultFields(j.Left.GetResultFields())
return
}
leftLen := len(j.Left.GetResultFields())
rightLen := len(j.Right.GetResultFields())
rfs := make([]*ast.ResultField, leftLen+rightLen)
copy(rfs, j.Left.GetResultFields())
copy(rfs[leftLen... | go | {
"resource": ""
} |
q28534 | handleColumnName | train | func (nr *nameResolver) handleColumnName(cn *ast.ColumnNameExpr) {
ctx := nr.currentContext()
if ctx.inOnCondition {
// In on condition, only tables within current join is available.
nr.resolveColumnNameInOnCondition(cn)
return
}
// Try to resolve the column name form top to bottom in the context stack.
for... | go | {
"resource": ""
} |
q28535 | resolveColumnNameInContext | train | func (nr *nameResolver) resolveColumnNameInContext(ctx *resolverContext, cn *ast.ColumnNameExpr) bool {
if ctx.inTableRefs {
// In TableRefsClause, column reference only in join on condition which is handled before.
return false
}
if ctx.inFieldList {
// only resolve column using tables.
return nr.resolveCol... | go | {
"resource": ""
} |
q28536 | resolveColumnNameInOnCondition | train | func (nr *nameResolver) resolveColumnNameInOnCondition(cn *ast.ColumnNameExpr) {
ctx := nr.currentContext()
join := ctx.joinNodeStack[len(ctx.joinNodeStack)-1]
tableSources := appendTableSources(nil, join)
if !nr.resolveColumnInTableSources(cn, tableSources) {
nr.Err = errors.Errorf("unknown column name %s", cn.N... | go | {
"resource": ""
} |
q28537 | handleFieldList | train | func (nr *nameResolver) handleFieldList(fieldList *ast.FieldList) {
var resultFields []*ast.ResultField
for _, v := range fieldList.Fields {
resultFields = append(resultFields, nr.createResultFields(v)...)
}
nr.currentContext().fieldList = resultFields
} | go | {
"resource": ""
} |
q28538 | GetAllCharsets | train | func GetAllCharsets() []*Desc {
descs := make([]*Desc, 0, len(charsets))
// The charsetInfos is an array, so the iterate order will be stable.
for _, ci := range charsetInfos {
c, ok := charsets[ci.Name]
if !ok {
continue
}
desc := &Desc{
Name: c.Name,
DefaultCollation: c.DefaultCollatio... | go | {
"resource": ""
} |
q28539 | ValidCharsetAndCollation | train | func ValidCharsetAndCollation(cs string, co string) bool {
// We will use utf8 as a default charset.
if cs == "" {
cs = "utf8"
}
c, ok := charsets[cs]
if !ok {
return false
}
if co == "" {
return true
}
_, ok = c.Collations[co]
if !ok {
return false
}
return true
} | go | {
"resource": ""
} |
q28540 | GetDefaultCollation | train | func GetDefaultCollation(charset string) (string, error) {
charset = strings.ToLower(charset)
if charset == CharsetBin {
return CollationBin, nil
}
c, ok := charsets[charset]
if !ok {
return "", errors.Errorf("Unknown charset %s", charset)
}
return c.DefaultCollation.Name, nil
} | go | {
"resource": ""
} |
q28541 | GetCharsetInfo | train | func GetCharsetInfo(cs string) (string, string, error) {
c, ok := charsets[strings.ToLower(cs)]
if !ok {
return "", "", errors.Errorf("Unknown charset %s", cs)
}
return c.Name, c.DefaultCollation.Name, nil
} | go | {
"resource": ""
} |
q28542 | tryToPushDownAgg | train | func (a *aggPushDownSolver) tryToPushDownAgg(aggFuncs []expression.AggregationFunction, gbyCols []*expression.Column, join *Join, childIdx int) LogicalPlan {
child := join.GetChildByIndex(childIdx).(LogicalPlan)
if a.allFirstRow(aggFuncs) {
return child
}
agg := a.makeNewAgg(aggFuncs, gbyCols)
child.SetParents(a... | go | {
"resource": ""
} |
q28543 | toStepGroupLayers | train | func toStepGroupLayers(status *pb.FlowExecutionStatus) (layers [][]int) {
// how many step groups depenend on this step group
dependencyCount := make([]int, len(status.StepGroups))
isUsed := make([]bool, len(status.StepGroups))
for _, stepGroup := range status.StepGroups {
for _, parentId := range stepGroup.GetP... | go | {
"resource": ""
} |
q28544 | argsToSpecifiedType | train | func argsToSpecifiedType(args []types.Datum, allString bool, allNumber bool, ctx context.Context) (newArgs []types.Datum, err error) {
if allNumber { // If all arguments are numbers, they can be compared directly without type converting.
return args, nil
}
sc := ctx.GetSessionVars().StmtCtx
newArgs = make([]types... | go | {
"resource": ""
} |
q28545 | CollectExecutionStatistics | train | func (exe *Executor) CollectExecutionStatistics(stream pb.GleamExecutor_CollectExecutionStatisticsServer) error {
for {
stats, err := stream.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
for _, stat := range stats.Stats {
for i, current := range exe.stats {
if current.S... | go | {
"resource": ""
} |
q28546 | Lookup | train | func Lookup(label string) (e encoding.Encoding, name string) {
label = strings.ToLower(strings.Trim(label, "\t\n\r\f "))
enc := encodings[label]
return enc.e, enc.name
} | go | {
"resource": ""
} |
q28547 | SetHasHeader | train | func (q *FileSource) SetHasHeader(hasHeader bool) *FileSource {
q.HasHeader = hasHeader
return q
} | go | {
"resource": ""
} |
q28548 | EncodeDecimal | train | func EncodeDecimal(b []byte, d types.Datum) []byte {
dec := d.GetMysqlDecimal()
precision := d.Length()
frac := d.Frac()
if precision == 0 {
precision, frac = dec.PrecisionAndFrac()
}
b = append(b, byte(precision), byte(frac))
bin, err := dec.ToBin(precision, frac)
if err != nil {
log.Printf("should not hap... | go | {
"resource": ""
} |
q28549 | buildInnerApply | train | func (b *planBuilder) buildInnerApply(outerPlan, innerPlan LogicalPlan) LogicalPlan {
join := &Join{
JoinType: InnerJoin,
baseLogicalPlan: newBaseLogicalPlan(Jn, b.allocator),
}
ap := &Apply{Join: *join}
ap.initIDAndContext(b.ctx)
ap.self = ap
addChild(ap, outerPlan)
addChild(ap, innerPlan)
ap.SetSch... | go | {
"resource": ""
} |
q28550 | detachTableScanConditions | train | func detachTableScanConditions(conditions []expression.Expression, table *model.TableInfo) ([]expression.Expression, []expression.Expression) {
var pkName model.CIStr
for _, colInfo := range table.Columns {
if mysql.HasPriKeyFlag(colInfo.Flag) {
pkName = colInfo.Name
break
}
}
if pkName.L == "" {
return... | go | {
"resource": ""
} |
q28551 | ToString | train | func (b Bit) ToString() string {
byteSize := (b.Width + 7) / 8
buf := make([]byte, byteSize)
for i := byteSize - 1; i >= 0; i-- {
buf[byteSize-i-1] = byte(b.Value >> uint(i*8))
}
return string(buf)
} | go | {
"resource": ""
} |
q28552 | Equal | train | func (e *Error) Equal(err error) bool {
originErr := errors.Cause(err)
if originErr == nil {
return false
}
inErr, ok := originErr.(*Error)
return ok && e.class == inErr.class && e.code == inErr.code
} | go | {
"resource": ""
} |
q28553 | ToSQLError | train | func (e *Error) ToSQLError() *mysql.SQLError {
code := e.getMySQLErrorCode()
return mysql.NewErrf(code, e.getMsg())
} | go | {
"resource": ""
} |
q28554 | ErrorEqual | train | func ErrorEqual(err1, err2 error) bool {
e1 := errors.Cause(err1)
e2 := errors.Cause(err2)
if e1 == e2 {
return true
}
if e1 == nil || e2 == nil {
return e1 == e2
}
te1, ok1 := e1.(*Error)
te2, ok2 := e2.(*Error)
if ok1 && ok2 {
return te1.class == te2.class && te1.code == te2.code
}
return e1.Erro... | go | {
"resource": ""
} |
q28555 | AddOneToOneStep | train | func (f *Flow) AddOneToOneStep(input *Dataset, output *Dataset) (step *Step) {
step = f.NewStep()
step.NetworkType = OneShardToOneShard
fromStepToDataset(step, output)
fromDatasetToStep(input, step)
if input == nil {
task := step.NewTask()
if output != nil && output.Shards != nil {
fromTaskToDatasetShard(t... | go | {
"resource": ""
} |
q28556 | AddAllToOneStep | train | func (f *Flow) AddAllToOneStep(input *Dataset, output *Dataset) (step *Step) {
step = f.NewStep()
step.NetworkType = AllShardToOneShard
fromStepToDataset(step, output)
fromDatasetToStep(input, step)
// setup the network
task := step.NewTask()
if output != nil {
fromTaskToDatasetShard(task, output.GetShards()[... | go | {
"resource": ""
} |
q28557 | MergeDatasets1ShardTo1Step | train | func (f *Flow) MergeDatasets1ShardTo1Step(inputs []*Dataset, output *Dataset) (step *Step) {
step = f.NewStep()
step.NetworkType = MergeTwoShardToOneShard
fromStepToDataset(step, output)
for _, input := range inputs {
fromDatasetToStep(input, step)
}
// setup the network
if output != nil {
for shardId, outS... | go | {
"resource": ""
} |
q28558 | IsPoint | train | func (ir *IndexRange) IsPoint(sc *variable.StatementContext) bool {
if len(ir.LowVal) != len(ir.HighVal) {
return false
}
for i := range ir.LowVal {
a := ir.LowVal[i]
b := ir.HighVal[i]
if a.Kind() == types.KindMinNotNull || b.Kind() == types.KindMaxValue {
return false
}
cmp, err := a.CompareDatum(sc... | go | {
"resource": ""
} |
q28559 | Read | train | func (fc *Flow) Read(s Sourcer) (ret *Dataset) {
return s.Generate(fc)
} | go | {
"resource": ""
} |
q28560 | Listen | train | func (fc *Flow) Listen(network, address string) (ret *Dataset) {
fn := func(writer io.Writer, stats *pb.InstructionStat) error {
listener, err := net.Listen(network, address)
if err != nil {
return fmt.Errorf("Fail to listen on %s %s: %v", network, address, err)
}
conn, err := listener.Accept()
if err != ... | go | {
"resource": ""
} |
q28561 | Hint | train | func (d *Flow) Hint(options ...FlowHintOption) {
var config FlowConfig
for _, option := range options {
option(&config)
}
} | go | {
"resource": ""
} |
q28562 | GetTotalSize | train | func (d *Dataset) GetTotalSize() int64 {
if d.Meta.TotalSize >= 0 {
return d.Meta.TotalSize
}
var currentDatasetTotalSize int64
for _, ds := range d.Step.InputDatasets {
currentDatasetTotalSize += ds.GetTotalSize()
}
d.Meta.TotalSize = currentDatasetTotalSize
return currentDatasetTotalSize
} | go | {
"resource": ""
} |
q28563 | GetPartitionSize | train | func (d *Dataset) GetPartitionSize() int64 {
return d.GetTotalSize() / int64(len(d.Shards))
} | go | {
"resource": ""
} |
q28564 | CompareString | train | func (t Time) CompareString(str string) (int, error) {
// use MaxFsp to parse the string
o, err := ParseTime(str, t.Type, MaxFsp)
if err != nil {
return 0, errors.Trace(err)
}
return t.Compare(o), nil
} | go | {
"resource": ""
} |
q28565 | AdjustYear | train | func AdjustYear(y int64) (int64, error) {
y = int64(adjustYear(int(y)))
if y < int64(MinYear) || y > int64(MaxYear) {
return 0, errors.Trace(ErrInvalidYear)
}
return y, nil
} | go | {
"resource": ""
} |
q28566 | extractSecondMicrosecond | train | func extractSecondMicrosecond(format string) (int64, int64, int64, gotime.Duration, error) {
fields := strings.Split(format, ".")
if len(fields) != 2 {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
seconds, err := strconv.ParseInt(fields[0], 10, 64)
if err != nil {
return 0, 0, 0, 0, ... | go | {
"resource": ""
} |
q28567 | extractDayHour | train | func extractDayHour(format string) (int64, int64, int64, gotime.Duration, error) {
fields := strings.Split(format, " ")
if len(fields) != 2 {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
days, err := strconv.ParseInt(fields[0], 10, 64)
if err != nil {
return 0, 0, 0, 0, errors.Errorf... | go | {
"resource": ""
} |
q28568 | extractYearMonth | train | func extractYearMonth(format string) (int64, int64, int64, gotime.Duration, error) {
fields := strings.Split(format, "-")
if len(fields) != 2 {
return 0, 0, 0, 0, errors.Errorf("invalid time format - %s", format)
}
years, err := strconv.ParseInt(fields[0], 10, 64)
if err != nil {
return 0, 0, 0, 0, errors.Err... | go | {
"resource": ""
} |
q28569 | mysqlTimeFix | train | func mysqlTimeFix(t *mysqlTime, ctx map[string]int) error {
// Key of the ctx is the format char, such as `%j` `%p` and so on.
if yearOfDay, ok := ctx["%j"]; ok {
// TODO: Implement the function that converts day of year to yy:mm:dd.
_ = yearOfDay
}
if valueAMorPm, ok := ctx["%p"]; ok {
if t.hour == 0 {
re... | go | {
"resource": ""
} |
q28570 | strToDate | train | func strToDate(t *mysqlTime, date string, format string, ctx map[string]int) bool {
date = skipWhiteSpace(date)
format = skipWhiteSpace(format)
token, formatRemain, succ := getFormatToken(format)
if !succ {
return false
}
if token == "" {
// Extra characters at the end of date are ignored.
return true
}
... | go | {
"resource": ""
} |
q28571 | dayOfMonthWithSuffix | train | func dayOfMonthWithSuffix(t *mysqlTime, input string, ctx map[string]int) (string, bool) {
month, remain := parseOrdinalNumbers(input)
if month >= 0 {
t.month = uint8(month)
return remain, true
}
return input, false
} | go | {
"resource": ""
} |
q28572 | TsEmit | train | func TsEmit(ts int64, anyObject ...interface{}) error {
stat.Stats[0].OutputCounter++
return util.NewRow(ts, anyObject...).WriteTo(os.Stdout)
} | go | {
"resource": ""
} |
q28573 | Parse | train | func (parser *Parser) Parse(sql, charset, collation string) ([]ast.StmtNode, error) {
if charset == "" {
charset = mysql.DefaultCharset
}
if collation == "" {
collation = mysql.DefaultCollationName
}
parser.charset = charset
parser.collation = collation
parser.src = sql
parser.result = parser.result[:0]
v... | go | {
"resource": ""
} |
q28574 | ParseOneStmt | train | func (parser *Parser) ParseOneStmt(sql, charset, collation string) (ast.StmtNode, error) {
stmts, err := parser.Parse(sql, charset, collation)
if err != nil {
return nil, errors.Trace(err)
}
if len(stmts) != 1 {
return nil, ErrSyntax
}
ast.SetFlag(stmts[0])
return stmts[0], nil
} | go | {
"resource": ""
} |
q28575 | setLastSelectFieldText | train | func (parser *Parser) setLastSelectFieldText(st *ast.SelectStmt, lastEnd int) {
lastField := st.Fields.Fields[len(st.Fields.Fields)-1]
if lastField.Offset+len(lastField.Text()) >= len(parser.src)-1 {
lastField.SetText(parser.src[lastField.Offset:lastEnd])
}
} | go | {
"resource": ""
} |
q28576 | InferType | train | func InferType(sc *variable.StatementContext, node ast.Node) error {
var inferrer typeInferrer
inferrer.sc = sc
// TODO: get the default charset from ctx
inferrer.defaultCharset = "utf8"
node.Accept(&inferrer)
return inferrer.err
} | go | {
"resource": ""
} |
q28577 | handleCaseExpr | train | func (v *typeInferrer) handleCaseExpr(x *ast.CaseExpr) {
var currType types.FieldType
for _, w := range x.WhenClauses {
t := w.Result.GetType()
if currType.Tp == mysql.TypeUnspecified {
currType = *t
continue
}
mtp := types.MergeFieldType(currType.Tp, t.Tp)
if mtp == t.Tp && mtp != currType.Tp {
cu... | go | {
"resource": ""
} |
q28578 | handleLikeExpr | train | func (v *typeInferrer) handleLikeExpr(x *ast.PatternLikeExpr) {
x.SetType(types.NewFieldType(mysql.TypeLonglong))
x.Type.Charset = charset.CharsetBin
x.Type.Collate = charset.CollationBin
x.Expr = v.addCastToString(x.Expr)
x.Pattern = v.addCastToString(x.Pattern)
} | go | {
"resource": ""
} |
q28579 | addCastToString | train | func (v *typeInferrer) addCastToString(expr ast.ExprNode) ast.ExprNode {
if !mysql.IsUTF8Charset(expr.GetType().Charset) {
castTp := types.NewFieldType(mysql.TypeString)
castTp.Charset, castTp.Collate = types.DefaultCharsetForType(mysql.TypeString)
if val, ok := expr.(*ast.ValueExpr); ok {
newVal, err := val.... | go | {
"resource": ""
} |
q28580 | convertValueToColumnTypeIfNeeded | train | func (v *typeInferrer) convertValueToColumnTypeIfNeeded(x *ast.PatternInExpr) {
if cn, ok := x.Expr.(*ast.ColumnNameExpr); ok && cn.Refer != nil {
ft := cn.Refer.Column.FieldType
for _, expr := range x.List {
if valueExpr, ok := expr.(*ast.ValueExpr); ok {
newDatum, err := valueExpr.Datum.ConvertTo(v.sc, &f... | go | {
"resource": ""
} |
q28581 | DecimalDiv | train | func DecimalDiv(from1, from2, to *MyDecimal, fracIncr int) error {
to.resultFrac = myMinInt8(from1.resultFrac+int8(fracIncr), MaxFraction)
return doDivMod(from1, from2, to, nil, fracIncr)
} | go | {
"resource": ""
} |
q28582 | Fetch | train | func (s *Scheduler) Fetch(demands []market.Demand) {
var request pb.ComputeRequest
request.Username = s.Option.Username
request.Hostname = s.Option.Hostname
request.FlowHashCode = s.Option.FlowHashcode
request.DataCenter = s.Option.DataCenter
for _, d := range demands {
taskGroup := d.Requirement.(*plan.TaskGro... | go | {
"resource": ""
} |
q28583 | ReduceByKey | train | func (d *Dataset) ReduceByKey(name string, reducerId gio.ReducerId) (ret *Dataset) {
sortOption := Field(1)
return d.ReduceBy(name, reducerId, sortOption)
} | go | {
"resource": ""
} |
q28584 | Reduce | train | func (d *Dataset) Reduce(name string, reducerId gio.ReducerId) (ret *Dataset) {
name = name + ".Reduce"
ret = d.LocalReduceBy(name+".LocalReduce", reducerId, nil)
if len(d.Shards) > 1 {
ret = ret.MergeTo(name, 1).LocalReduceBy(name+".LocalReduce2", reducerId, nil)
}
return ret
} | go | {
"resource": ""
} |
q28585 | decorrelate | train | func decorrelate(p LogicalPlan) LogicalPlan {
if apply, ok := p.(*Apply); ok {
outerPlan := apply.children[0]
innerPlan := apply.children[1].(LogicalPlan)
apply.extractCorColumnsBySchema()
if len(apply.corCols) == 0 {
// If the inner plan is non-correlated, the apply will be simplified to join.
join := &... | go | {
"resource": ""
} |
q28586 | BufWrites | train | func BufWrites(rawWriters []io.Writer, function func([]io.Writer)) {
var writers []io.Writer
var bufWriters []*bufio.Writer
for _, w := range rawWriters {
if bufWriter, ok := w.(*bufio.Writer); ok {
writers = append(writers, bufWriter)
} else {
bufWriter = bufio.NewWriter(w)
bufWriters = append(bufWrite... | go | {
"resource": ""
} |
q28587 | reset | train | func (s *Scanner) reset(sql string) {
s.r = reader{s: sql}
s.buf.Reset()
s.errs = s.errs[:0]
s.stmtStartPos = 0
} | go | {
"resource": ""
} |
q28588 | Errorf | train | func (s *Scanner) Errorf(format string, a ...interface{}) {
str := fmt.Sprintf(format, a...)
val := s.r.s[s.r.pos().Offset:]
if len(val) > 2048 {
val = val[:2048]
}
err := fmt.Errorf("line %d column %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)
} | go | {
"resource": ""
} |
q28589 | handleEscape | train | func handleEscape(s *Scanner) rune {
s.r.inc()
ch0 := s.r.peek()
/*
\" \' \\ \n \0 \b \Z \r \t ==> escape to one char
\% \_ ==> preserve both char
other ==> remove \
*/
switch ch0 {
case 'n':
ch0 = '\n'
case '0':
ch0 = 0
case 'b':
ch0 = 8
case 'Z':
ch0 = 26
case 'r':
ch0 = '\r'
case 't':
ch... | go | {
"resource": ""
} |
q28590 | inc | train | func (r *reader) inc() {
if r.s[r.p.Offset] == '\n' {
r.p.Line++
r.p.Col = 0
}
r.p.Offset += r.w
r.p.Col++
} | go | {
"resource": ""
} |
q28591 | addChild | train | func addChild(parent Plan, child Plan) {
if child == nil || parent == nil {
return
}
child.AddParent(parent)
parent.AddChild(child)
} | go | {
"resource": ""
} |
q28592 | InsertPlan | train | func InsertPlan(parent Plan, child Plan, insert Plan) error {
err := child.ReplaceParent(parent, insert)
if err != nil {
return errors.Trace(err)
}
err = parent.ReplaceChild(child, insert)
if err != nil {
return errors.Trace(err)
}
insert.AddChild(child)
insert.AddParent(parent)
return nil
} | go | {
"resource": ""
} |
q28593 | RemovePlan | train | func RemovePlan(p Plan) error {
parents := p.GetParents()
children := p.GetChildren()
if len(parents) > 1 || len(children) != 1 {
return SystemInternalErrorType.Gen("can't remove this plan")
}
if len(parents) == 0 {
child := children[0]
child.SetParents()
return nil
}
parent, child := parents[0], childre... | go | {
"resource": ""
} |
q28594 | Map | train | func (d *Dataset) Map(name string, mapperId gio.MapperId) *Dataset {
ret, step := add1ShardTo1Step(d)
step.Name = name + ".Map"
step.IsPipe = false
step.IsGoCode = true
ex, _ := os.Executable()
mapper, _ := gio.GetMapper(mapperId)
step.Description = mapper.Name
var args []string
args = append(args, os.Args[... | go | {
"resource": ""
} |
q28595 | Select | train | func (d *Dataset) Select(name string, sortOption *SortOption) *Dataset {
ret, step := add1ShardTo1Step(d)
indexes := sortOption.Indexes()
step.SetInstruction(name, instruction.NewSelect([]int{indexes[0]}, indexes[1:]))
step.Description = fmt.Sprintf("select %v", sortOption.Indexes())
return ret
} | go | {
"resource": ""
} |
q28596 | SelectKV | train | func (d *Dataset) SelectKV(name string, keys, values *SortOption) *Dataset {
ret, step := add1ShardTo1Step(d)
step.SetInstruction(name, instruction.NewSelect(keys.Indexes(), values.Indexes()))
return ret
} | go | {
"resource": ""
} |
q28597 | LocalLimit | train | func (d *Dataset) LocalLimit(name string, n int, offset int) *Dataset {
ret, step := add1ShardTo1Step(d)
ret.IsLocalSorted = d.IsLocalSorted
ret.IsPartitionedBy = d.IsPartitionedBy
step.SetInstruction(name, instruction.NewLocalLimit(n, offset))
step.Description = fmt.Sprintf("local limit %d", n)
return ret
} | go | {
"resource": ""
} |
q28598 | findAncestorStepId | train | func findAncestorStepId(step *flow.Step) (int, bool) {
current := step
taskCount := len(current.Tasks)
// println("find step", step.Name)
for taskCount == len(current.Tasks) {
if len(current.InputDatasets) > 1 {
// more than 2 dataset inputs
break
}
if len(current.InputDatasets) == 0 {
// no datase... | go | {
"resource": ""
} |
q28599 | translateToStepGroups | train | func translateToStepGroups(fc *flow.Flow) []*StepGroup {
// use array instead of map to ensure consistent ordering
stepId2StepGroup := make([]*StepGroup, len(fc.Steps))
for _, step := range fc.Steps {
// println("step:", step.Name, step.Id, "starting...")
ancestorStepId, foundStepId := findAncestorStepId(step)
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.