_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12300 | SetDestination | train | func (p *Pipeline) SetDestination(d Destination) {
p.mutex.Lock()
defer p.mutex.Unlock()
p.dst = d
} | go | {
"resource": ""
} |
q12301 | Run | train | func (p *Pipeline) Run(ctx context.Context) (err error) {
if pdebug.Enabled {
g := pdebug.Marker("Pipeline.Run (%s)", ctx.Value("query")).BindError(&err)
defer g.End()
}
p.mutex.Lock()
defer p.mutex.Unlock()
defer close(p.done)
if p.src == nil {
return errors.New("source must be non-nil")
}
if p.dst == ... | go | {
"resource": ""
} |
q12302 | Add | train | func (s *Selection) Add(l line.Line) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.tree.ReplaceOrInsert(l)
} | go | {
"resource": ""
} |
q12303 | Remove | train | func (s *Selection) Remove(l line.Line) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.tree.Delete(l)
} | go | {
"resource": ""
} |
q12304 | NewAnchorSettings | train | func NewAnchorSettings(screen Screen, anchor VerticalAnchor, offset int) *AnchorSettings {
if !IsValidVerticalAnchor(anchor) {
panic("Invalid vertical anchor specified")
}
return &AnchorSettings{
anchor: anchor,
anchorOffset: offset,
screen: screen,
}
} | go | {
"resource": ""
} |
q12305 | AnchorPosition | train | func (as AnchorSettings) AnchorPosition() int {
var pos int
switch as.anchor {
case AnchorTop:
pos = as.anchorOffset
case AnchorBottom:
_, h := as.screen.Size()
pos = int(h) - as.anchorOffset - 1 // -1 is required because y is 0 base, but h is 1 base
default:
panic("Unknown anchor type!")
}
return pos
} | go | {
"resource": ""
} |
q12306 | NewUserPrompt | train | func NewUserPrompt(screen Screen, anchor VerticalAnchor, anchorOffset int, prompt string, styles *StyleSet) *UserPrompt {
if len(prompt) <= 0 { // default
prompt = "QUERY>"
}
promptLen := runewidth.StringWidth(prompt)
return &UserPrompt{
AnchorSettings: NewAnchorSettings(screen, anchor, anchorOffset),
prompt... | go | {
"resource": ""
} |
q12307 | NewStatusBar | train | func NewStatusBar(screen Screen, anchor VerticalAnchor, anchorOffset int, styles *StyleSet) *StatusBar {
return &StatusBar{
AnchorSettings: NewAnchorSettings(screen, anchor, anchorOffset),
clearTimer: nil,
styles: styles,
}
} | go | {
"resource": ""
} |
q12308 | NewListArea | train | func NewListArea(screen Screen, anchor VerticalAnchor, anchorOffset int, sortTopDown bool, styles *StyleSet) *ListArea {
return &ListArea{
AnchorSettings: NewAnchorSettings(screen, anchor, anchorOffset),
displayCache: []line.Line{},
dirty: false,
sortTopDown: sortTopDown,
styles: styles... | go | {
"resource": ""
} |
q12309 | NewBottomUpLayout | train | func NewBottomUpLayout(state *Peco) *BasicLayout {
return &BasicLayout{
StatusBar: NewStatusBar(state.Screen(), AnchorBottom, 0+extraOffset, state.Styles()),
// The prompt is at the bottom, above the status bar
prompt: NewUserPrompt(state.Screen(), AnchorBottom, 1+extraOffset, state.Prompt(), state.Styles()),
... | go | {
"resource": ""
} |
q12310 | CalculatePage | train | func (l *BasicLayout) CalculatePage(state *Peco, perPage int) error {
if pdebug.Enabled {
g := pdebug.Marker("BasicLayout.Calculate %d", perPage)
defer g.End()
}
buf := state.CurrentLineBuffer()
loc := state.Location()
loc.SetPage((loc.LineNumber() / perPage) + 1)
loc.SetOffset((loc.Page() - 1) * perPage)
lo... | go | {
"resource": ""
} |
q12311 | DrawScreen | train | func (l *BasicLayout) DrawScreen(state *Peco, options *DrawOptions) {
if pdebug.Enabled {
g := pdebug.Marker("BasicLayout.DrawScreen")
defer g.End()
}
perPage := l.linesPerPage()
if err := l.CalculatePage(state, perPage); err != nil {
return
}
l.DrawPrompt(state)
l.list.Draw(state, l, perPage, options)
... | go | {
"resource": ""
} |
q12312 | MovePage | train | func (l *BasicLayout) MovePage(state *Peco, p PagingRequest) (moved bool) {
switch p.Type() {
case ToScrollLeft, ToScrollRight:
moved = horizontalScroll(state, l, p)
default:
moved = verticalScroll(state, l, p)
}
return
} | go | {
"resource": ""
} |
q12313 | horizontalScroll | train | func horizontalScroll(state *Peco, l *BasicLayout, p PagingRequest) bool {
width, _ := state.screen.Size()
loc := state.Location()
if p.Type() == ToScrollRight {
loc.SetColumn(loc.Column() + width/2)
} else if loc.Column() > 0 {
loc.SetColumn(loc.Column() - width/2)
if loc.Column() < 0 {
loc.SetColumn(0)
... | go | {
"resource": ""
} |
q12314 | TtyReady | train | func TtyReady() error {
var err error
_stdin, err := os.Open("CONIN$")
if err != nil {
return err
}
stdin = os.Stdin
os.Stdin = _stdin
syscall.Stdin = syscall.Handle(os.Stdin.Fd())
return errors.Wrap(setStdHandle(syscall.STD_INPUT_HANDLE, syscall.Stdin), "failed to check for TtyReady")
} | go | {
"resource": ""
} |
q12315 | TtyTerm | train | func TtyTerm() {
os.Stdin = stdin
syscall.Stdin = syscall.Handle(os.Stdin.Fd())
setStdHandle(syscall.STD_INPUT_HANDLE, syscall.Stdin)
} | go | {
"resource": ""
} |
q12316 | NewRegexp | train | func NewRegexp() *Regexp {
return &Regexp{
factory: ®expQueryFactory{
compiled: make(map[string]regexpQuery),
threshold: time.Minute,
},
flags: regexpFlagList(defaultFlags),
quotemeta: false,
name: "Regexp",
outCh: pipeline.ChanOutput(make(chan interface{})),
}
} | go | {
"resource": ""
} |
q12317 | NewSmartCase | train | func NewSmartCase() *Regexp {
rf := NewRegexp()
rf.quotemeta = true
rf.name = "SmartCase"
rf.flags = regexpFlagFunc(func(q string) []string {
if util.ContainsUpper(q) {
return defaultFlags
}
return []string{"i"}
})
return rf
} | go | {
"resource": ""
} |
q12318 | NewRaw | train | func NewRaw(id uint64, v string, enableSep bool) *Raw {
rl := &Raw{
id: id,
buf: v,
sepLoc: -1,
displayString: "",
dirty: false,
}
if !enableSep {
return rl
}
if i := strings.IndexByte(rl.buf, '\000'); i != -1 {
rl.sepLoc = i
}
return rl
} | go | {
"resource": ""
} |
q12319 | Less | train | func (rl *Raw) Less(b btree.Item) bool {
return rl.id < b.(Line).ID()
} | go | {
"resource": ""
} |
q12320 | DisplayString | train | func (rl Raw) DisplayString() string {
if rl.displayString != "" {
return rl.displayString
}
if i := rl.sepLoc; i > -1 {
rl.displayString = util.StripANSISequence(rl.buf[:i])
} else {
rl.displayString = util.StripANSISequence(rl.buf)
}
return rl.displayString
} | go | {
"resource": ""
} |
q12321 | Init | train | func (c *Config) Init() error {
c.Keymap = make(map[string]string)
c.InitialMatcher = IgnoreCaseMatch
c.Style.Init()
c.Prompt = "QUERY>"
c.Layout = LayoutTypeTopDown
return nil
} | go | {
"resource": ""
} |
q12322 | ReadFilename | train | func (c *Config) ReadFilename(filename string) error {
f, err := os.Open(filename)
if err != nil {
return errors.Wrapf(err, "failed to open file %s", filename)
}
defer f.Close()
err = json.NewDecoder(f).Decode(c)
if err != nil {
return errors.Wrap(err, "failed to decode JSON")
}
if !IsValidLayoutType(Layo... | go | {
"resource": ""
} |
q12323 | UnmarshalJSON | train | func (s *Style) UnmarshalJSON(buf []byte) error {
raw := []string{}
if err := json.Unmarshal(buf, &raw); err != nil {
return errors.Wrapf(err, "failed to unmarshal Style")
}
return stringsToStyle(s, raw)
} | go | {
"resource": ""
} |
q12324 | LocateRcfile | train | func LocateRcfile(locater configLocateFunc) (string, error) {
// http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
//
// Try in this order:
// $XDG_CONFIG_HOME/peco/config.json
// $XDG_CONFIG_DIR/peco/config.json (where XDG_CONFIG_DIR is listed in $XDG_CONFIG_DIRS)
// ~/.peco/config.js... | go | {
"resource": ""
} |
q12325 | flusher | train | func flusher(ctx context.Context, f filter.Filter, incoming chan []line.Line, done chan struct{}, out pipeline.ChanOutput) {
if pdebug.Enabled {
g := pdebug.Marker("flusher goroutine")
defer g.End()
}
defer close(done)
defer out.SendEndMark("end of filter")
for {
select {
case <-ctx.Done():
return
c... | go | {
"resource": ""
} |
q12326 | Loop | train | func (f *Filter) Loop(ctx context.Context, cancel func()) error {
defer cancel()
// previous holds the function that can cancel the previous
// query. This is used when multiple queries come in succession
// and the previous query is discarded anyway
var mutex sync.Mutex
var previous func()
for {
select {
c... | go | {
"resource": ""
} |
q12327 | Crop | train | func (pf PageCrop) Crop(in Buffer) *FilteredBuffer {
return NewFilteredBuffer(in, pf.currentPage, pf.perPage)
} | go | {
"resource": ""
} |
q12328 | Setup | train | func (s *Source) Setup(ctx context.Context, state *Peco) {
s.setupOnce.Do(func() {
done := make(chan struct{})
refresh := make(chan struct{}, 1)
defer close(done)
defer close(refresh)
// And also, close the done channel so we can tell the consumers
// we have finished reading everything
defer close(s.set... | go | {
"resource": ""
} |
q12329 | Reset | train | func (s *Source) Reset() {
if pdebug.Enabled {
g := pdebug.Marker("Source.Reset")
defer g.End()
}
s.ChanOutput = pipeline.ChanOutput(make(chan interface{}))
} | go | {
"resource": ""
} |
q12330 | GetScheduleTime | train | func (schedule Schedule) GetScheduleTime() *time.Time {
if scheduleTime := schedule.ScheduleTime; scheduleTime != nil {
if scheduleTime.After(time.Now().Add(time.Minute)) {
return scheduleTime
}
}
return nil
} | go | {
"resource": ""
} |
q12331 | Add | train | func (cron *Cron) Add(job QorJobInterface) (err error) {
cron.parseJobs()
defer cron.writeCronJob()
var binaryFile string
if binaryFile, err = filepath.Abs(os.Args[0]); err == nil {
var jobs []*cronJob
for _, cronJob := range cron.Jobs {
if cronJob.JobID != job.GetJobID() {
jobs = append(jobs, cronJob)
... | go | {
"resource": ""
} |
q12332 | Run | train | func (cron *Cron) Run(qorJob QorJobInterface) error {
job := qorJob.GetJob()
if job.Handler != nil {
go func() {
sigint := make(chan os.Signal, 1)
// interrupt signal sent from terminal
signal.Notify(sigint, syscall.SIGINT)
// sigterm signal sent from kubernetes
signal.Notify(sigint, syscall.SIGTER... | go | {
"resource": ""
} |
q12333 | Kill | train | func (cron *Cron) Kill(job QorJobInterface) (err error) {
cron.parseJobs()
defer cron.writeCronJob()
for _, cronJob := range cron.Jobs {
if cronJob.JobID == job.GetJobID() {
if process, err := os.FindProcess(cronJob.Pid); err == nil {
if err = process.Kill(); err == nil {
cronJob.Delete = true
re... | go | {
"resource": ""
} |
q12334 | Remove | train | func (cron *Cron) Remove(job QorJobInterface) error {
cron.parseJobs()
defer cron.writeCronJob()
for _, cronJob := range cron.Jobs {
if cronJob.JobID == job.GetJobID() {
if cronJob.Pid == 0 {
cronJob.Delete = true
return nil
}
return errors.New("failed to remove current job as it is running")
}... | go | {
"resource": ""
} |
q12335 | New | train | func New(config ...*Config) *Worker {
var cfg = &Config{}
if len(config) > 0 {
cfg = config[0]
}
if cfg.Job == nil {
cfg.Job = &QorJob{}
}
if cfg.Queue == nil {
cfg.Queue = NewCronQueue()
}
return &Worker{Config: cfg}
} | go | {
"resource": ""
} |
q12336 | ConfigureQorResourceBeforeInitialize | train | func (worker *Worker) ConfigureQorResourceBeforeInitialize(res resource.Resourcer) {
if res, ok := res.(*admin.Resource); ok {
res.GetAdmin().RegisterViewPath("github.com/qor/worker/views")
res.UseTheme("worker")
worker.Admin = res.GetAdmin()
worker.JobResource = worker.Admin.NewResource(worker.Config.Job)
... | go | {
"resource": ""
} |
q12337 | RegisterJob | train | func (worker *Worker) RegisterJob(job *Job) error {
if worker.mounted {
debug.PrintStack()
fmt.Printf("Job should be registered before Worker mounted into admin, but %v is registered after that", job.Name)
}
job.Worker = worker
worker.Jobs = append(worker.Jobs, job)
return nil
} | go | {
"resource": ""
} |
q12338 | GetRegisteredJob | train | func (worker *Worker) GetRegisteredJob(name string) *Job {
for _, job := range worker.Jobs {
if job.Name == name {
return job
}
}
return nil
} | go | {
"resource": ""
} |
q12339 | GetJob | train | func (worker *Worker) GetJob(jobID string) (QorJobInterface, error) {
qorJob := worker.JobResource.NewStruct().(QorJobInterface)
context := worker.Admin.NewContext(nil, nil)
context.ResourceID = jobID
context.Resource = worker.JobResource
if err := worker.JobResource.FindOneHandler(qorJob, nil, context.Context);... | go | {
"resource": ""
} |
q12340 | AddJob | train | func (worker *Worker) AddJob(qorJob QorJobInterface) error {
return worker.Queue.Add(qorJob)
} | go | {
"resource": ""
} |
q12341 | RunJob | train | func (worker *Worker) RunJob(jobID string) error {
qorJob, err := worker.GetJob(jobID)
if qorJob != nil && err == nil {
defer func() {
if r := recover(); r != nil {
qorJob.AddLog(string(debug.Stack()))
qorJob.SetProgressText(fmt.Sprint(r))
qorJob.SetStatus(JobStatusException)
}
}()
if qorJob... | go | {
"resource": ""
} |
q12342 | KillJob | train | func (worker *Worker) KillJob(jobID string) error {
if qorJob, err := worker.GetJob(jobID); err == nil {
if qorJob.GetStatus() == JobStatusRunning {
if err = qorJob.GetJob().GetQueue().Kill(qorJob); err == nil {
qorJob.SetStatus(JobStatusKilled)
return nil
}
return err
} else if qorJob.GetStatus()... | go | {
"resource": ""
} |
q12343 | RemoveJob | train | func (worker *Worker) RemoveJob(jobID string) error {
qorJob, err := worker.GetJob(jobID)
if err == nil {
return qorJob.GetJob().GetQueue().Remove(qorJob)
}
return err
} | go | {
"resource": ""
} |
q12344 | NewStruct | train | func (job *Job) NewStruct() interface{} {
qorJobInterface := job.Worker.JobResource.NewStruct().(QorJobInterface)
qorJobInterface.SetJob(job)
return qorJobInterface
} | go | {
"resource": ""
} |
q12345 | GetQueue | train | func (job *Job) GetQueue() Queue {
if job.Queue != nil {
return job.Queue
}
return job.Worker.Queue
} | go | {
"resource": ""
} |
q12346 | New | train | func New(config *Config) (*Kubernetes, error) {
var err error
if config == nil {
config = &Config{}
}
if config.ClusterConfig == nil {
config.ClusterConfig, err = rest.InClusterConfig()
}
if err != nil {
return nil, err
}
clientset, err := kubernetes.NewForConfig(config.ClusterConfig)
if err != nil {... | go | {
"resource": ""
} |
q12347 | GetCurrentPod | train | func (k8s *Kubernetes) GetCurrentPod() *corev1.Pod {
var (
podlist, err = k8s.Clientset.Core().Pods("").List(metav1.ListOptions{})
localeIP = GetLocalIP()
)
if err == nil {
for _, item := range podlist.Items {
if item.Status.PodIP == localeIP {
return &item
}
}
}
return nil
} | go | {
"resource": ""
} |
q12348 | GetJobSpec | train | func (k8s *Kubernetes) GetJobSpec(qorJob worker.QorJobInterface) (*v1.Job, error) {
var (
k8sJob = &v1.Job{}
currentPod = k8s.GetCurrentPod()
namespace = currentPod.GetNamespace()
)
if k8s.Config.Namespace != "" {
namespace = k8s.Config.Namespace
}
if k8s.Config.JobTemplateMaker != nil {
if err :=... | go | {
"resource": ""
} |
q12349 | Add | train | func (k8s *Kubernetes) Add(qorJob worker.QorJobInterface) error {
var (
jobName = fmt.Sprintf("qor-job-%v", qorJob.GetJobID())
k8sJob, err = k8s.GetJobSpec(qorJob)
currentPath, _ = os.Getwd()
binaryFile, _ = filepath.Abs(os.Args[0])
)
if err == nil {
k8sJob.ObjectMeta.Name = jobName
k8sJob.Sp... | go | {
"resource": ""
} |
q12350 | Run | train | func (k8s *Kubernetes) Run(qorJob worker.QorJobInterface) error {
job := qorJob.GetJob()
if job.Handler != nil {
return job.Handler(qorJob.GetSerializableArgument(qorJob), qorJob)
}
return errors.New("no handler found for job " + job.Name)
} | go | {
"resource": ""
} |
q12351 | Kill | train | func (k8s *Kubernetes) Kill(qorJob worker.QorJobInterface) error {
var (
k8sJob, err = k8s.GetJobSpec(qorJob)
jobName = fmt.Sprintf("qor-job-%v", qorJob.GetJobID())
)
if err == nil {
return k8s.Clientset.Batch().Jobs(k8sJob.ObjectMeta.GetNamespace()).Delete(jobName, &metav1.DeleteOptions{})
}
return err... | go | {
"resource": ""
} |
q12352 | Scan | train | func (resultsTable *ResultsTable) Scan(data interface{}) error {
switch values := data.(type) {
case []byte:
return json.Unmarshal(values, resultsTable)
case string:
return resultsTable.Scan([]byte(values))
default:
return errors.New("unsupported data type for Qor Job error table")
}
} | go | {
"resource": ""
} |
q12353 | Value | train | func (resultsTable ResultsTable) Value() (driver.Value, error) {
result, err := json.Marshal(resultsTable)
return string(result), err
} | go | {
"resource": ""
} |
q12354 | SetStatus | train | func (job *QorJob) SetStatus(status string) error {
job.mutex.Lock()
defer job.mutex.Unlock()
job.Status = status
if status == JobStatusDone {
job.Progress = 100
}
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | go | {
"resource": ""
} |
q12355 | SetJob | train | func (job *QorJob) SetJob(j *Job) {
job.Kind = j.Name
job.Job = j
} | go | {
"resource": ""
} |
q12356 | GetJob | train | func (job *QorJob) GetJob() *Job {
if job.Job != nil {
return job.Job
}
return nil
} | go | {
"resource": ""
} |
q12357 | GetSerializableArgumentResource | train | func (job *QorJob) GetSerializableArgumentResource() *admin.Resource {
if j := job.GetJob(); j != nil {
return j.Resource
}
return nil
} | go | {
"resource": ""
} |
q12358 | SetProgress | train | func (job *QorJob) SetProgress(progress uint) error {
job.mutex.Lock()
defer job.mutex.Unlock()
if progress > 100 {
progress = 100
}
job.Progress = progress
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | go | {
"resource": ""
} |
q12359 | SetProgressText | train | func (job *QorJob) SetProgressText(str string) error {
job.mutex.Lock()
defer job.mutex.Unlock()
job.ProgressText = str
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | go | {
"resource": ""
} |
q12360 | AddLog | train | func (job *QorJob) AddLog(log string) error {
job.mutex.Lock()
defer job.mutex.Unlock()
fmt.Println(log)
job.Log += "\n" + log
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | go | {
"resource": ""
} |
q12361 | AddResultsRow | train | func (job *QorJob) AddResultsRow(cells ...TableCell) error {
job.mutex.Lock()
defer job.mutex.Unlock()
job.ResultsTable.TableCells = append(job.ResultsTable.TableCells, cells)
if job.shouldCallSave() {
return job.callSave()
}
return nil
} | go | {
"resource": ""
} |
q12362 | ParseChannelSizeFlag | train | func ParseChannelSizeFlag(flag string) (int, error) {
ss := strings.Split(flag, "=")
if len(ss) != 2 {
return 0, fmt.Errorf("Failed split flag %s", flag)
}
if ss[0] != "--channel_size" {
return 0, fmt.Errorf("Unknown flag %s", flag)
}
return strconv.Atoi(ss[1])
} | go | {
"resource": ""
} |
q12363 | Help | train | func Help(args []string, cmds []*command.Command) int {
var (
cmd string
)
if len(args) >= 3 {
cmd = args[2]
}
// Prints the help if the command exist.
for _, c := range cmds {
if c.Name() == cmd {
return c.Usage()
}
}
if cmd == "" {
fmt.Fprintf(os.Stderr, "missing help command. Usage:\n\n\t$ bw he... | go | {
"resource": ""
} |
q12364 | InitializeDriver | train | func InitializeDriver(driverName string, drivers map[string]StoreGenerator) (storage.Store, error) {
f, ok := drivers[driverName]
if !ok {
var ds []string
for k := range drivers {
ds = append(ds, k)
}
return nil, fmt.Errorf("unknown driver name %q; valid drivers [%q]", driverName, strings.Join(ds, ", "))
... | go | {
"resource": ""
} |
q12365 | InitializeCommands | train | func InitializeCommands(driver storage.Store, chanSize, bulkTripleOpSize, builderSize int, rl repl.ReadLiner, done chan bool) []*command.Command {
return []*command.Command{
assert.New(driver, literal.DefaultBuilder(), chanSize, bulkTripleOpSize),
benchmark.New(driver, chanSize, bulkTripleOpSize),
export.New(dri... | go | {
"resource": ""
} |
q12366 | Eval | train | func Eval(ctx context.Context, args []string, cmds []*command.Command) int {
// Retrieve the provided command.
if len(args) < 1 {
return Help(args, cmds)
}
cmd := args[0]
// Check for help request.
if cmd == "help" {
return Help(args, cmds)
}
// Run the requested command.
for _, c := range cmds {
if c.Na... | go | {
"resource": ""
} |
q12367 | Run | train | func Run(driverName string, args []string, drivers map[string]StoreGenerator, chanSize, bulkTripleOpSize, builderSize int, rl repl.ReadLiner) int {
driver, err := InitializeDriver(driverName, drivers)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 2
}
return Eval(context.Background(), args, InitializeComma... | go | {
"resource": ""
} |
q12368 | Name | train | func (s *storeMemoizer) Name(ctx context.Context) string {
return s.s.Name(ctx)
} | go | {
"resource": ""
} |
q12369 | Version | train | func (s *storeMemoizer) Version(ctx context.Context) string {
return s.s.Version(ctx)
} | go | {
"resource": ""
} |
q12370 | NewGraph | train | func (s *storeMemoizer) NewGraph(ctx context.Context, id string) (storage.Graph, error) {
g, err := s.s.NewGraph(ctx, id)
if err != nil {
return nil, err
}
return &graphMemoizer{
g: g,
memN: make(map[string][]*node.Node),
memP: make(map[string][]*predicate.Predicate),
memO: make(map[string][]*triple.Ob... | go | {
"resource": ""
} |
q12371 | ID | train | func (g *graphMemoizer) ID(ctx context.Context) string {
return g.g.ID(ctx)
} | go | {
"resource": ""
} |
q12372 | AddTriples | train | func (g *graphMemoizer) AddTriples(ctx context.Context, ts []*triple.Triple) error {
g.mu.Lock()
// Update operations reset the memoization.
g.memN = make(map[string][]*node.Node)
g.memP = make(map[string][]*predicate.Predicate)
g.memO = make(map[string][]*triple.Object)
g.memT = make(map[string][]*triple.Triple)... | go | {
"resource": ""
} |
q12373 | Objects | train | func (g *graphMemoizer) Objects(ctx context.Context, s *node.Node, p *predicate.Predicate, lo *storage.LookupOptions, objs chan<- *triple.Object) error {
k := combinedUUID("Objects", lo, s.UUID(), p.UUID())
g.mu.RLock()
v := g.memO[k]
g.mu.RUnlock()
if v != nil {
// Return the memoized results.
defer close(obj... | go | {
"resource": ""
} |
q12374 | Subjects | train | func (g *graphMemoizer) Subjects(ctx context.Context, p *predicate.Predicate, o *triple.Object, lo *storage.LookupOptions, subs chan<- *node.Node) error {
k := combinedUUID("Subjects", lo, p.UUID(), o.UUID())
g.mu.RLock()
v := g.memN[k]
g.mu.RUnlock()
if v != nil {
// Return the memoized results.
defer close(s... | go | {
"resource": ""
} |
q12375 | PredicatesForSubjectAndObject | train | func (g *graphMemoizer) PredicatesForSubjectAndObject(ctx context.Context, s *node.Node, o *triple.Object, lo *storage.LookupOptions, prds chan<- *predicate.Predicate) error {
k := combinedUUID("PredicatesForSubjectAndObject", lo, s.UUID(), o.UUID())
g.mu.RLock()
v := g.memP[k]
g.mu.RUnlock()
if v != nil {
// Re... | go | {
"resource": ""
} |
q12376 | TriplesForSubject | train | func (g *graphMemoizer) TriplesForSubject(ctx context.Context, s *node.Node, lo *storage.LookupOptions, trpls chan<- *triple.Triple) error {
k := combinedUUID("TriplesForSubject", lo, s.UUID())
g.mu.RLock()
v := g.memT[k]
g.mu.RUnlock()
if v != nil {
// Return the memoized results.
defer close(trpls)
for _, ... | go | {
"resource": ""
} |
q12377 | Execute | train | func (p *createPlan) Execute(ctx context.Context) (*table.Table, error) {
t, err := table.New([]string{})
if err != nil {
return nil, err
}
errs := []string{}
for _, g := range p.stm.GraphNames() {
tracer.Trace(p.tracer, func() []string {
return []string{"Creating new graph \"" + g + "\""}
})
if _, err ... | go | {
"resource": ""
} |
q12378 | Execute | train | func (p *insertPlan) Execute(ctx context.Context) (*table.Table, error) {
t, err := table.New([]string{})
if err != nil {
return nil, err
}
return t, update(ctx, p.stm.Data(), p.stm.OutputGraphNames(), p.store, func(g storage.Graph, d []*triple.Triple) error {
tracer.Trace(p.tracer, func() []string {
return ... | go | {
"resource": ""
} |
q12379 | newQueryPlan | train | func newQueryPlan(ctx context.Context, store storage.Store, stm *semantic.Statement, chanSize int, w io.Writer) (*queryPlan, error) {
bs := []string{}
for _, b := range stm.Bindings() {
bs = append(bs, b)
}
t, err := table.New([]string{})
if err != nil {
return nil, err
}
return &queryPlan{
stm: stm,... | go | {
"resource": ""
} |
q12380 | processClause | train | func (p *queryPlan) processClause(ctx context.Context, cls *semantic.GraphClause, lo *storage.LookupOptions) (bool, error) {
// This method decides how to process the clause based on the current
// list of bindings solved and data available.
if cls.Specificity() == 3 {
tracer.Trace(p.tracer, func() []string {
r... | go | {
"resource": ""
} |
q12381 | getBoundValueForComponent | train | func getBoundValueForComponent(r table.Row, bs []string) *table.Cell {
var cs []*table.Cell
for _, b := range bs {
if v, ok := r[b]; ok {
cs = append(cs, v)
}
}
if len(cs) == 1 || len(cs) == 2 && reflect.DeepEqual(cs[0], cs[1]) {
return cs[0]
}
return nil
} | go | {
"resource": ""
} |
q12382 | specifyClauseWithTable | train | func (p *queryPlan) specifyClauseWithTable(ctx context.Context, cls *semantic.GraphClause, lo *storage.LookupOptions) error {
rws := p.tbl.Rows()
p.tbl.Truncate()
var (
gErr error
mu sync.Mutex
wg sync.WaitGroup
)
for _, tmpRow := range rws {
wg.Add(1)
go func(r table.Row) {
defer wg.Done()
var... | go | {
"resource": ""
} |
q12383 | cellToObject | train | func cellToObject(c *table.Cell) (*triple.Object, error) {
if c == nil {
return nil, errors.New("cannot create an object out of and empty cell")
}
if c.N != nil {
return triple.NewNodeObject(c.N), nil
}
if c.P != nil {
return triple.NewPredicateObject(c.P), nil
}
if c.L != nil {
return triple.NewLiteralO... | go | {
"resource": ""
} |
q12384 | processGraphPattern | train | func (p *queryPlan) processGraphPattern(ctx context.Context, lo *storage.LookupOptions) error {
tracer.Trace(p.tracer, func() []string {
var res []string
for i, cls := range p.cls {
res = append(res, fmt.Sprintf("Clause %d to process: %v", i, cls))
}
return res
})
for i, c := range p.cls {
i, cls := i, ... | go | {
"resource": ""
} |
q12385 | orderBy | train | func (p *queryPlan) orderBy() {
order := p.stm.OrderByConfig()
if len(order) <= 0 {
return
}
tracer.Trace(p.tracer, func() []string {
return []string{"Ordering by " + order.String()}
})
p.tbl.Sort(order)
} | go | {
"resource": ""
} |
q12386 | having | train | func (p *queryPlan) having() error {
if p.stm.HasHavingClause() {
tracer.Trace(p.tracer, func() []string {
return []string{"Having filtering"}
})
eval := p.stm.HavingEvaluator()
ok := true
var eErr error
p.tbl.Filter(func(r table.Row) bool {
b, err := eval.Evaluate(r)
if err != nil {
ok, eErr ... | go | {
"resource": ""
} |
q12387 | limit | train | func (p *queryPlan) limit() {
if p.stm.IsLimitSet() {
tracer.Trace(p.tracer, func() []string {
return []string{"Limit results to " + strconv.Itoa(int(p.stm.Limit()))}
})
p.tbl.Limit(p.stm.Limit())
}
} | go | {
"resource": ""
} |
q12388 | Execute | train | func (p *queryPlan) Execute(ctx context.Context) (*table.Table, error) {
// Fetch and cache graph instances.
tracer.Trace(p.tracer, func() []string {
return []string{fmt.Sprintf("Caching graph instances for graphs %v", p.stm.InputGraphNames())}
})
if err := p.stm.Init(ctx, p.store); err != nil {
return nil, err... | go | {
"resource": ""
} |
q12389 | Execute | train | func (p *showPlan) Execute(ctx context.Context) (*table.Table, error) {
t, err := table.New([]string{"?graph_id"})
if err != nil {
return nil, err
}
errs := make(chan error)
names := make(chan string)
go func() {
errs <- p.store.GraphNames(ctx, names)
close(errs)
}()
for name := range names {
id := nam... | go | {
"resource": ""
} |
q12390 | New | train | func New(ctx context.Context, store storage.Store, stm *semantic.Statement, chanSize, bulkSize int, w io.Writer) (Executor, error) {
switch stm.Type() {
case semantic.Query:
return newQueryPlan(ctx, store, stm, chanSize, w)
case semantic.Insert:
return &insertPlan{
stm: stm,
store: store,
tracer: w,... | go | {
"resource": ""
} |
q12391 | NewLLk | train | func NewLLk(input string, k int) *LLk {
c := lexer.New(input, 2*k) // +2 to keep a bit of buffer available.
l := &LLk{
k: k,
c: c,
}
for i := 0; i < k+1; i++ {
appendNextToken(l)
}
return l
} | go | {
"resource": ""
} |
q12392 | appendNextToken | train | func appendNextToken(l *LLk) {
for t := range l.c {
l.tkns = append(l.tkns, t)
return
}
l.tkns = append(l.tkns, lexer.Token{Type: lexer.ItemEOF})
} | go | {
"resource": ""
} |
q12393 | Peek | train | func (l *LLk) Peek(k int) (*lexer.Token, error) {
if k > l.k {
return nil, fmt.Errorf("grammar.LLk: cannot look ahead %v beyond defined %v", k, l.k)
}
if k <= 0 {
return nil, fmt.Errorf("grammar.LLk: invalid look ahead value %v", k)
}
return &l.tkns[k], nil
} | go | {
"resource": ""
} |
q12394 | CanAccept | train | func (l *LLk) CanAccept(tt lexer.TokenType) bool {
return l.tkns[0].Type == tt
} | go | {
"resource": ""
} |
q12395 | Consume | train | func (l *LLk) Consume(tt lexer.TokenType) bool {
if l.tkns[0].Type != tt {
return false
}
l.tkns = l.tkns[1:]
appendNextToken(l)
return true
} | go | {
"resource": ""
} |
q12396 | TrackDuration | train | func TrackDuration(f func() error) (time.Duration, error) {
ts := timeNow()
err := f()
d := timeNow().Sub(ts)
return d, err
} | go | {
"resource": ""
} |
q12397 | RepetitionDurationStats | train | func RepetitionDurationStats(reps int, setup, f, teardown func() error) (time.Duration, time.Duration, error) {
if reps < 1 {
return time.Duration(0), 0, fmt.Errorf("repetions need to be %d >= 1", reps)
}
if setup == nil {
return time.Duration(0), 0, errors.New("setup function is required")
}
if f == nil {
r... | go | {
"resource": ""
} |
q12398 | RunBenchmarkBatterySequentially | train | func RunBenchmarkBatterySequentially(entries []*BenchEntry) []*BenchResult {
var res []*BenchResult
for _, entry := range entries {
m, d, err := RepetitionDurationStats(entry.Reps, entry.Setup, entry.F, entry.TearDown)
res = append(res, &BenchResult{
BatteryID: entry.BatteryID,
ID: entry.ID,
Tripl... | go | {
"resource": ""
} |
q12399 | RunBenchmarkBatteryConcurrently | train | func RunBenchmarkBatteryConcurrently(entries []*BenchEntry) []*BenchResult {
var (
mu sync.Mutex
wg sync.WaitGroup
res []*BenchResult
)
for _, entry := range entries {
wg.Add(1)
go func(entry *BenchEntry) {
m, d, err := RepetitionDurationStats(entry.Reps, entry.Setup, entry.F, entry.TearDown)
mu.Lo... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.