Search code, repositories, users, issues, pull requests...

Lines 111 to 113 in bdcab67

    
           	} 
        
           	v.err = v.observer.leaveNode(name, plan) 
        
           }()

in pkg/sql.(*planVisitor).visitInternal.func1

Lines 296 to 298 in bdcab67

in pkg/sql.(*planVisitor).visitInternal

Lines 78 to 80 in bdcab67

    
           } 
        
           v.visitInternal(plan, name) 
        
           return plan

in pkg/sql.(*planVisitor).visit

cockroach/pkg/sql/plan.go

Lines 42 to 44 in bdcab67

    
           v := makePlanVisitor(ctx, observer) 
        
           v.visit(plan) 
        
           return v.err

in pkg/sql.walkPlan

Lines 518 to 520 in bdcab67

    
           	} 
        
           	return walkPlan(params.ctx, plan, o) 
        
           }

in pkg/sql.startExec

cockroach/pkg/sql/plan_node_to_row_source.go

Lines 145 to 147 in bdcab67

    
           // This starts all of the nodes below this node. 
        
           if err := startExec(p.params, p.node); err != nil { 
        
           	p.MoveToDraining(err)

in pkg/sql.(*planNodeToRowSource).Start

cockroach/pkg/sql/colflow/flow_coordinator.go

Lines 119 to 121 in bdcab67

    
           if err := colexecerror.CatchVectorizedRuntimeError(func() { 
        
           	f.input.Start(ctx) 
        
           }); err != nil {

in pkg/sql/colflow.(*FlowCoordinator).Start.func1

cockroach/pkg/sql/colexecerror/error.go

Lines 91 to 93 in bdcab67

    
           }() 
        
           operation() 
        
           return retErr

in pkg/sql/colexecerror.CatchVectorizedRuntimeError

cockroach/pkg/sql/colflow/flow_coordinator.go

Lines 118 to 120 in bdcab67

    
           ctx = f.StartInternalNoSpan(ctx) 
        
           if err := colexecerror.CatchVectorizedRuntimeError(func() { 
        
           	f.input.Start(ctx)

in pkg/sql/colflow.(*FlowCoordinator).Start

cockroach/pkg/sql/execinfra/processorsbase.go

Lines 752 to 754 in bdcab67

    
           } 
        
           pb.self.Start(ctx) 
        
           Run(pb.Ctx, pb.self, pb.Output)

in pkg/sql/execinfra.(*ProcessorBaseNoHelper).Run

cockroach/pkg/sql/flowinfra/flow.go

Lines 468 to 470 in bdcab67

    
           	log.VEventf(ctx, 1, "running %T in the flow's goroutine", headProc) 
        
           	headProc.Run(ctx) 
        
           }

in pkg/sql/flowinfra.(*FlowBase).Run

cockroach/pkg/sql/colflow/vectorized_flow.go

Lines 302 to 304 in bdcab67

    
           // as the root, so we run this flow with the default implementation. 
        
           f.FlowBase.Run(ctx, doneFn) 
        
           return

in pkg/sql/colflow.(*vectorizedFlow).Run

cockroach/pkg/sql/distsql_running.go

Lines 596 to 598 in bdcab67

    
           // TODO(radu): this should go through the flow scheduler. 
        
           flow.Run(ctx, func() {})

in pkg/sql.(*DistSQLPlanner).Run

cockroach/pkg/sql/distsql_running.go

Lines 1444 to 1446 in bdcab67

    
           recv.expectedRowsRead = int64(physPlan.TotalEstimatedScannedRows) 
        
           runCleanup := dsp.Run(ctx, planCtx, txn, physPlan, recv, evalCtx, nil /* finishedSetupFn */) 
        
           return func() {

in pkg/sql.(*DistSQLPlanner).PlanAndRun

Lines 1505 to 1507 in bdcab67

    
           // the planner whether or not to plan remote table readers. 
        
           cleanup := ex.server.cfg.DistSQLPlanner.PlanAndRun( 
        
           	ctx, evalCtx, planCtx, planner.txn, planner.curPlan.main, recv,

in pkg/sql.(*connExecutor).execWithDistSQLEngine

Lines 1162 to 1164 in bdcab67

    
           ex.sessionTracing.TraceExecStart(ctx, "distributed") 
        
           stats, err = ex.execWithDistSQLEngine( 
        
           	ctx, planner, stmt.AST.StatementReturnType(), res, distribute, progAtomic,

in pkg/sql.(*connExecutor).dispatchToExecutionEngine

Lines 698 to 700 in bdcab67

    
           if err := ex.dispatchToExecutionEngine(stmtCtx, p, res); err != nil { 
        
           	stmtThresholdSpan.Finish()

in pkg/sql.(*connExecutor).execStmtInOpenState

Lines 143 to 145 in bdcab67

    
           } else { 
        
           	ev, payload, err = ex.execStmtInOpenState(ctx, parserStmt, prepared, pinfo, res, canAutoCommit) 
        
           }

in pkg/sql.(*connExecutor).execStmt

Lines 231 to 233 in bdcab67

    
           } 
        
           ev, payload, err = ex.execStmt(ctx, portal.Stmt.Statement, portal.Stmt, pinfo, stmtRes, canAutoCommit) 
        
           // Portal suspension is supported via a "side" state machine

in pkg/sql.(*connExecutor).execPortal

Lines 1968 to 1970 in bdcab67

    
           canAutoCommit := ex.implicitTxn() && tcmd.FollowedBySync 
        
           ev, payload, err = ex.execPortal(ctx, portal, portalName, stmtRes, pinfo, canAutoCommit) 
        
           return err

in pkg/sql.(*connExecutor).execCmd.func2

Lines 1970 to 1972 in bdcab67

    
           	return err 
        
           }() 
        
           // Note: we write to ex.statsCollector.phaseTimes, instead of ex.phaseTimes,

in pkg/sql.(*connExecutor).execCmd

Lines 1816 to 1818 in bdcab67

    
           var err error 
        
           if err = ex.execCmd(); err != nil { 
        
           	if errors.IsAny(err, io.EOF, errDrainingComplete) {

in pkg/sql.(*connExecutor).run