id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c12300 | defer p.mutex.Unlock()
p.dst = d
} | |
c12301 | the destination, working all the way
// up to the Source
var prevCh ChanOutput = ChanOutput(make(chan interface{}))
go p.dst.Accept(ctx, prevCh, nil)
for i := len(p.nodes) - 1; i >= 0; i-- {
cur := p.nodes[i]
ch := make(chan interface{}) //
go cur.Accept(ctx, ch, prevCh)
prevCh = ChanOutput(ch)
}
// An... | |
c12302 | s.mutex.Unlock()
s.tree.ReplaceOrInsert(l)
} | |
c12303 | s.mutex.Unlock()
s.tree.Delete(l)
} | |
c12304 |
return &AnchorSettings{
anchor: anchor,
anchorOffset: offset,
screen: screen,
}
} | |
c12305 | required because y is 0 base, but h is 1 base
default:
panic("Unknown anchor type!")
}
return pos
} | |
c12306 | "QUERY>"
}
promptLen := runewidth.StringWidth(prompt)
return &UserPrompt{
AnchorSettings: NewAnchorSettings(screen, anchor, anchorOffset),
prompt: prompt,
promptLen: int(promptLen),
styles: styles,
}
} | |
c12307 | {
return &StatusBar{
AnchorSettings: NewAnchorSettings(screen, anchor, anchorOffset),
clearTimer: nil,
styles: styles,
}
} | |
c12308 | []line.Line{},
dirty: false,
sortTopDown: sortTopDown,
styles: styles,
}
} | |
c12309 | the bottom, above the prompt
// It's displayed in bottom-to-top order
list: NewListArea(state.Screen(), AnchorBottom, 2+extraOffset, false, state.Styles()),
}
} | |
c12310 | loc.SetOffset((loc.Page() - 1) * perPage)
loc.SetPerPage(perPage)
loc.SetTotal(buf.Size())
if loc.Total() == 0 {
loc.SetMaxPage(1)
} else {
loc.SetMaxPage((loc.Total() + perPage - 1) / perPage)
}
if loc.MaxPage() < loc.Page() {
if buf.Size() == 0 {
// wait for targets
return errors.New("no targets ... | |
c12311 |
return
}
l.DrawPrompt(state)
l.list.Draw(state, l, perPage, options)
if err := l.screen.Flush(); err != nil {
return
}
} | |
c12312 | horizontalScroll(state, l, p)
default:
moved = verticalScroll(state, l, p)
}
return
} | |
c12313 | width/2)
if loc.Column() < 0 {
loc.SetColumn(0)
}
} else {
return false
}
l.list.SetDirty(true)
return true
} | |
c12314 |
return errors.Wrap(setStdHandle(syscall.STD_INPUT_HANDLE, syscall.Stdin), "failed to check for TtyReady")
} | |
c12315 |
setStdHandle(syscall.STD_INPUT_HANDLE, syscall.Stdin)
} | |
c12316 | false,
name: "Regexp",
outCh: pipeline.ChanOutput(make(chan interface{})),
}
} | |
c12317 | = regexpFlagFunc(func(q string) []string {
if util.ContainsUpper(q) {
return defaultFlags
}
return []string{"i"}
})
return rf
} | |
c12318 | -1,
displayString: "",
dirty: false,
}
if !enableSep {
return rl
}
if i := strings.IndexByte(rl.buf, '\000'); i != -1 {
rl.sepLoc = i
}
return rl
} | |
c12319 | rl.id < b.(Line).ID()
} | |
c12320 |
} else {
rl.displayString = util.StripANSISequence(rl.buf)
}
return rl.displayString
} | |
c12321 |
c.Prompt = "QUERY>"
c.Layout = LayoutTypeTopDown
return nil
} | |
c12322 | ok := c.CustomFilter[n]; ok {
return errors.Errorf("failed to create CustomFilter: '%s' already exists. Refusing to overwrite with deprecated CustomMatcher config", n)
}
c.CustomFilter[n] = CustomFilterConfig{
Cmd: cfg[0],
Args: cfg[1:],
BufferThreshold: filter.DefaultCust... | |
c12323 | "failed to unmarshal Style")
}
return stringsToStyle(s, raw)
} | |
c12324 | use it
if dirs := os.Getenv("XDG_CONFIG_DIRS"); dirs != "" {
for _, dir := range strings.Split(dirs, fmt.Sprintf("%c", filepath.ListSeparator)) {
if file, err := locater(filepath.Join(dir, "peco")); err == nil {
return file, nil
}
}
}
if uErr == nil { // silently ignore failure for homedir()
if fil... | |
c12325 | }
defer close(done)
defer out.SendEndMark("end of filter")
for {
select {
case <-ctx.Done():
return
case buf, ok := <-incoming:
if !ok {
return
}
pdebug.Printf("flusher: %#v", buf)
f.Apply(ctx, buf, out)
buffer.ReleaseLineListBuf(buf)
}
}
} | |
c12326 | if previous != nil {
if pdebug.Enabled {
pdebug.Printf("Canceling previous query")
}
previous()
}
previous = workcancel
mutex.Unlock()
f.state.Hub().SendStatusMsg("Running query...")
go f.Work(workctx, q)
}
}
} | |
c12327 | {
return NewFilteredBuffer(in, pf.currentPage, pf.perPage)
} | |
c12328 | int
if pdebug.Enabled {
defer func() { pdebug.Printf("Source scanned %d lines", scanned) }()
}
defer close(lines)
for scanner.Scan() {
lines <- scanner.Text()
scanned++
}
}()
state.Hub().SendStatusMsg("Waiting for input...")
readCount := 0
for loop := true; loop; {
select {
... | |
c12329 |
defer g.End()
}
s.ChanOutput = pipeline.ChanOutput(make(chan interface{}))
} | |
c12330 | scheduleTime != nil {
if scheduleTime.After(time.Now().Add(time.Minute)) {
return scheduleTime
}
}
return nil
} | |
c12331 | %d %d * cd %v; %v --qor-job %v\n", scheduleTime.Minute(), scheduleTime.Hour(), scheduleTime.Day(), scheduleTime.Month(), currentPath, binaryFile, job.GetJobID()),
})
} else {
cmd := exec.Command(binaryFile, "--qor-job", job.GetJobID())
if err = cmd.Start(); err == nil {
jobs = append(jobs, &cronJob{JobI... | |
c12332 | signal %s", i.String()))
qorJob.SetStatus(JobStatusKilled)
qorJob.StopReferesh()
os.Exit(int(reflect.ValueOf(i).Int()))
}()
qorJob.StartReferesh()
defer qorJob.StopReferesh()
err := job.Handler(qorJob.GetSerializableArgument(qorJob), qorJob)
if err == nil {
cron.parseJobs()
defer cron.write... | |
c12333 | if err = process.Kill(); err == nil {
cronJob.Delete = true
return nil
}
}
return err
}
}
return errors.New("failed to find job")
} | |
c12334 | {
if cronJob.Pid == 0 {
cronJob.Delete = true
return nil
}
return errors.New("failed to remove current job as it is running")
}
}
return errors.New("failed to find job")
} | |
c12335 | if cfg.Queue == nil {
cfg.Queue = NewCronQueue()
}
return &Worker{Config: cfg}
} | |
c12336 |
return db.Where("status = ?", status)
}})
}
// default scope
worker.JobResource.Scope(&admin.Scope{
Handler: func(db *gorm.DB, ctx *qor.Context) *gorm.DB {
if jobName := ctx.Request.URL.Query().Get("job"); jobName != "" {
return db.Where("kind = ?", jobName)
}
if groupName := ctx.Req... | |
c12337 | is registered after that", job.Name)
}
job.Worker = worker
worker.Jobs = append(worker.Jobs, job)
return nil
} | |
c12338 | job.Name == name {
return job
}
}
return nil
} | |
c12339 | nil, context.Context); err == nil {
for _, job := range worker.Jobs {
if job.Name == qorJob.GetJobName() {
qorJob.SetJob(job)
return qorJob, nil
}
}
return nil, fmt.Errorf("failed to load job: %v, unregistered job type: %v", jobID, qorJob.GetJobName())
}
return nil, fmt.Errorf("failed to find job... | |
c12340 | error {
return worker.Queue.Add(qorJob)
} | |
c12341 | err == nil {
if err = qorJob.GetJob().GetQueue().Run(qorJob); err == nil {
return qorJob.SetStatus(JobStatusDone)
}
qorJob.SetProgressText(err.Error())
qorJob.SetStatus(JobStatusException)
}
}
return err
} | |
c12342 | qorJob.SetStatus(JobStatusKilled)
return nil
}
return err
} else if qorJob.GetStatus() == JobStatusScheduled || qorJob.GetStatus() == JobStatusNew {
qorJob.SetStatus(JobStatusKilled)
return worker.RemoveJob(jobID)
} else {
return errors.New("invalid job status")
}
} else {
return err
}
... | |
c12343 | qorJob.GetJob().GetQueue().Remove(qorJob)
}
return err
} | |
c12344 |
qorJobInterface.SetJob(job)
return qorJobInterface
} | |
c12345 | return job.Queue
}
return job.Worker.Queue
} | |
c12346 | }
clientset, err := kubernetes.NewForConfig(config.ClusterConfig)
if err != nil {
return nil, err
}
return &Kubernetes{Clientset: clientset, Config: config}, nil
} | |
c12347 |
for _, item := range podlist.Items {
if item.Status.PodIP == localeIP {
return &item
}
}
}
return nil
} | |
c12348 |
if marshaledVolumes, err := json.Marshal(currentPod.Spec.Volumes); err == nil {
json.Unmarshal(marshaledVolumes, k8sJob.Spec.Template.Spec.Volumes)
}
}
if k8sJob.TypeMeta.Kind == "" {
k8sJob.TypeMeta.Kind = "Job"
}
if k8sJob.TypeMeta.APIVersion == "" {
k8sJob.TypeMeta.APIVersion = "batch/v1"
}
if k... | |
c12349 | container.Command = []string{binaryFile, "--qor-job", qorJob.GetJobID()}
}
if container.WorkingDir == "" || k8s.Config.JobTemplateMaker == nil {
container.WorkingDir = currentPath
}
k8sJob.Spec.Template.Spec.Containers[idx] = container
}
_, err = k8s.Clientset.Batch().Jobs(k8sJob.ObjectMeta.Get... | |
c12350 | return job.Handler(qorJob.GetSerializableArgument(qorJob), qorJob)
}
return errors.New("no handler found for job " + job.Name)
} | |
c12351 | nil {
return k8s.Clientset.Batch().Jobs(k8sJob.ObjectMeta.GetNamespace()).Delete(jobName, &metav1.DeleteOptions{})
}
return err
} | |
c12352 | json.Unmarshal(values, resultsTable)
case string:
return resultsTable.Scan([]byte(values))
default:
return errors.New("unsupported data type for Qor Job error table")
}
} | |
c12353 | err := json.Marshal(resultsTable)
return string(result), err
} | |
c12354 | job.Status = status
if status == JobStatusDone {
job.Progress = 100
}
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | |
c12355 | = j.Name
job.Job = j
} | |
c12356 | if job.Job != nil {
return job.Job
}
return nil
} | |
c12357 | {
if j := job.GetJob(); j != nil {
return j.Resource
}
return nil
} | |
c12358 |
if progress > 100 {
progress = 100
}
job.Progress = progress
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | |
c12359 | job.mutex.Unlock()
job.ProgressText = str
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | |
c12360 |
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | |
c12361 | append(job.ResultsTable.TableCells, cells)
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | |
c12362 | if ss[0] != "--channel_size" {
return 0, fmt.Errorf("Unknown flag %s", flag)
}
return strconv.Atoi(ss[1])
} | |
c12363 |
name += " "
}
usage = append(usage, fmt.Sprintf("\t%s\t- %s\n", name, c.Short))
}
sort.Strings(usage)
for _, u := range usage {
fmt.Fprint(os.Stderr, u)
}
fmt.Fprintln(os.Stderr, "")
return 0
}
fmt.Fprintf(os.Stderr, "help command %q not recognized. Usage:\n\n\t$ bw help\n\n", cmd)
return 2... | |
c12364 | ds = append(ds, k)
}
return nil, fmt.Errorf("unknown driver name %q; valid drivers [%q]", driverName, strings.Join(ds, ", "))
}
return f()
} | |
c12365 | benchmark.New(driver, chanSize, bulkTripleOpSize),
export.New(driver, bulkTripleOpSize),
load.New(driver, bulkTripleOpSize, builderSize),
run.New(driver, chanSize, bulkTripleOpSize),
repl.New(driver, chanSize, bulkTripleOpSize, builderSize, rl, done),
server.New(driver, chanSize, bulkTripleOpSize),
versio... | |
c12366 | }
}
// The command was not found.
if cmd != "" {
fmt.Fprintf(os.Stderr, "command %q not recognized. Usage:\n\n\t$ bw [command]\n\nPlease run\n\n\t$ bw help\n\n", cmd)
}
return 1
} | |
c12367 | }
return Eval(context.Background(), args, InitializeCommands(driver, chanSize, bulkTripleOpSize, builderSize, rl, make(chan bool)))
} | |
c12368 | {
return s.s.Name(ctx)
} | |
c12369 | context.Context) string {
return s.s.Version(ctx)
} | |
c12370 | memO: make(map[string][]*triple.Object),
memT: make(map[string][]*triple.Triple),
memE: make(map[string]bool),
}, nil
} | |
c12371 | string {
return g.g.ID(ctx)
} | |
c12372 | g.memT = make(map[string][]*triple.Triple)
g.memE = make(map[string]bool)
g.mu.Unlock()
return g.g.AddTriples(ctx, ts)
} | |
c12373 |
wg.Add(1)
go func() {
err = g.g.Objects(ctx, s, p, lo, c)
wg.Done()
}()
for o := range c {
select {
case <-ctx.Done():
return errors.New("context cancelled")
case objs <- o:
// memoize the object.
mobjs = append(mobjs, o)
}
}
wg.Wait()
g.mu.Lock()
g.memO[k] = mobjs
g.mu.Unlock()
return ... | |
c12374 |
wg.Add(1)
go func() {
err = g.g.Subjects(ctx, p, o, lo, c)
wg.Done()
}()
for s := range c {
select {
case <-ctx.Done():
return errors.New("context cancelled")
case subs <- s:
// memoize the object.
msubs = append(msubs, s)
}
}
wg.Wait()
g.mu.Lock()
g.memN[k] = msubs
g.mu.Unlock()
return... | |
c12375 |
)
wg.Add(1)
go func() {
err = g.g.PredicatesForSubjectAndObject(ctx, s, o, lo, c)
wg.Done()
}()
for p := range c {
select {
case <-ctx.Done():
return errors.New("context cancelled")
case prds <- p:
// memoize the object.
mpreds = append(mpreds, p)
}
}
wg.Wait()
g.mu.Lock()
g.memP[k] = mp... | |
c12376 | err = g.g.TriplesForSubject(ctx, s, lo, c)
wg.Done()
}()
for t := range c {
select {
case <-ctx.Done():
return errors.New("context cancelled")
case trpls <- t:
// memoize the object.
mts = append(mts, t)
}
}
wg.Wait()
g.mu.Lock()
g.memT[k] = mts
g.mu.Unlock()
return err
} | |
c12377 | "\""}
})
if _, err := p.store.NewGraph(ctx, g); err != nil {
errs = append(errs, err.Error())
}
}
if len(errs) > 0 {
return nil, errors.New(strings.Join(errs, "; "))
}
return t, nil
} | |
c12378 | tracer.Trace(p.tracer, func() []string {
return []string{"Inserting triples to graph \"" + g.ID(ctx) + "\""}
})
return g.AddTriples(ctx, d)
})
} | |
c12379 | store: store,
bndgs: bs,
grfsNames: stm.InputGraphNames(),
cls: stm.GraphPatternClauses(),
tbl: t,
chanSize: chanSize,
tracer: w,
}, nil
} | |
c12380 | // Data is new.
stmLimit := int64(0)
if len(p.stm.GraphPatternClauses()) == 1 && len(p.stm.GroupBy()) == 0 && len(p.stm.HavingExpression()) == 0 {
stmLimit = p.stm.Limit()
}
tbl, err := simpleFetch(ctx, p.grfs, cls, lo, stmLimit, p.chanSize, p.tracer)
if err != nil {
return false, err
}
if len(p.tb... | |
c12381 |
}
}
if len(cs) == 1 || len(cs) == 2 && reflect.DeepEqual(cs[0], cs[1]) {
return cs[0]
}
return nil
} | |
c12382 | table manipulations are now thread safe.
if err := p.addSpecifiedData(ctx, r, &tmpCls, lo); err != nil {
mu.Lock()
gErr = err
mu.Unlock()
}
}(tmpRow)
}
wg.Wait()
return gErr
} | |
c12383 | }
if c.S != nil {
l, err := literal.DefaultBuilder().Parse(fmt.Sprintf(`"%s"^^type:string`, *c.S))
if err != nil {
return nil, err
}
return triple.NewLiteralObject(l), nil
}
return nil, fmt.Errorf("invalid cell %v", c)
} | |
c12384 | // The current planner is based on naively executing clauses by
// specificity.
unresolvable, err := p.processClause(ctx, &cls, lo)
if err != nil {
return err
}
if unresolvable {
p.tbl.Truncate()
return nil
}
}
return nil
} | |
c12385 |
return []string{"Ordering by " + order.String()}
})
p.tbl.Sort(order)
} | |
c12386 |
b, err := eval.Evaluate(r)
if err != nil {
ok, eErr = false, err
}
return !b
})
if !ok {
return eErr
}
}
return nil
} | |
c12387 | " + strconv.Itoa(int(p.stm.Limit()))}
})
p.tbl.Limit(p.stm.Limit())
}
} | |
c12388 | err
}
if err := p.projectAndGroupBy(); err != nil {
return nil, err
}
p.orderBy()
err := p.having()
if err != nil {
return nil, err
}
p.limit()
if p.tbl.NumRows() == 0 {
// Correct the bindings.
t, err := table.New(p.stm.OutputBindings())
if err != nil {
return nil, err
}
p.tbl = t
}
return... | |
c12389 |
for name := range names {
id := name
t.AddRow(table.Row{
"?graph_id": &table.Cell{
S: &id,
},
})
}
if <-errs != nil {
return nil, err
}
return t, nil
} | |
c12390 | tracer: w,
bulkSize: bulkSize,
queryPlan: qp,
construct: true,
}, nil
case semantic.Deconstruct:
qp, _ := newQueryPlan(ctx, store, stm, chanSize, w)
return &constructPlan{
stm: stm,
store: store,
tracer: w,
bulkSize: bulkSize,
queryPlan: qp,
construct: false,
}, ... | |
c12391 | }
for i := 0; i < k+1; i++ {
appendNextToken(l)
}
return l
} | |
c12392 | l.tkns = append(l.tkns, lexer.Token{Type: lexer.ItemEOF})
} | |
c12393 | return nil, fmt.Errorf("grammar.LLk: invalid look ahead value %v", k)
}
return &l.tkns[k], nil
} | |
c12394 | bool {
return l.tkns[0].Type == tt
} | |
c12395 |
l.tkns = l.tkns[1:]
appendNextToken(l)
return true
} | |
c12396 |
d := timeNow().Sub(ts)
return d, err
} | |
c12397 | teardown(); err != nil {
return time.Duration(0), 0, err
}
}
mean := int64(0)
for _, d := range durations {
mean += int64(d)
}
mean /= int64(len(durations))
dev, expSquare := int64(0), mean*mean
for _, d := range durations {
dev = int64(d)*int64(d) - expSquare
}
dev = int64(math.Sqrt(math.Abs(float64... | |
c12398 | entry.F, entry.TearDown)
res = append(res, &BenchResult{
BatteryID: entry.BatteryID,
ID: entry.ID,
Triples: entry.Triples,
Err: err,
Mean: m,
StdDev: d,
})
}
return res
} | |
c12399 | wg.Done()
res = append(res, &BenchResult{
BatteryID: entry.BatteryID,
ID: entry.ID,
Triples: entry.Triples,
Err: err,
Mean: m,
StdDev: d,
})
}(entry)
}
wg.Wait()
return res
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.