Example #1
0
// Main Entry point to take a Plan, and convert into Execution DAG
func (m *JobExecutor) WalkPlan(p plan.Task) (Task, error) {
	switch p := p.(type) {
	case *plan.PreparedStatement:
		return m.Executor.WalkPreparedStatement(p)
	case *plan.Select:
		if len(p.From) > 0 {
			//u.Debugf("walk select p:%p m.Executor: %p ChildDag?%v %v", p, m.Executor, p.ChildDag, p.Stmt.String())
		}
		if p.Ctx != nil && p.IsSchemaQuery() {
			//u.Debugf("is schema query. ctx nil? %v", p.Ctx == nil)
			if p.Ctx.Schema != nil && p.Ctx.Schema.InfoSchema != nil {
				p.Ctx.Schema = p.Ctx.Schema.InfoSchema
			}
			p.Stmt.SetSystemQry()
		}
		return m.Executor.WalkSelect(p)
	case *plan.Upsert:
		return m.Executor.WalkUpsert(p)
	case *plan.Insert:
		return m.Executor.WalkInsert(p)
	case *plan.Update:
		return m.Executor.WalkUpdate(p)
	case *plan.Delete:
		return m.Executor.WalkDelete(p)
	case *plan.Command:
		return m.Executor.WalkCommand(p)
	}
	panic(fmt.Sprintf("Not implemented for %T", p))
}
Example #2
0
func (m *JobExecutor) WalkPlanAll(p plan.Task) (Task, error) {
	root, err := m.WalkPlanTask(p)
	if err != nil {
		u.Errorf("all damn %v err=%v", p, err)
		return nil, err
	}
	if len(p.Children()) > 0 {
		dagRoot := m.NewTask(p)
		//u.Debugf("sequential?%v  parallel?%v", p.IsSequential(), p.IsParallel())
		err = dagRoot.Add(root)
		if err != nil {
			u.Errorf("Could not add root: %v", err)
			return nil, err
		}
		return dagRoot, m.WalkChildren(p, dagRoot)
	}
	//u.Debugf("got root? %T for %T", root, p)
	//u.Debugf("len=%d  for children:%v", len(p.Children()), p.Children())
	return root, m.WalkChildren(p, root)
}
Example #3
0
// WalkChildren walk dag of plan taasks creating execution tasks
func (m *JobExecutor) WalkChildren(p plan.Task, root Task) error {
	for _, t := range p.Children() {
		//u.Debugf("parent: %T  walk child %p %T  %#v", p, t, t, p.Children())
		et, err := m.WalkPlanTask(t)
		if err != nil {
			u.Errorf("could not create task %#v err=%v", t, err)
		}
		if len(t.Children()) == 0 {
			err = root.Add(et)
			if err != nil {
				return err
			}
		} else {
			childRoot := m.Executor.NewTask(t)
			err = root.Add(childRoot)
			if err != nil {
				return err
			}
			err = childRoot.Add(et)
			if err != nil {
				return err
			}
			//u.Warnf("has children but not handled %#v", t)
			for _, c := range t.Children() {
				//u.Warnf("\tchild task %#v", c)
				ct, err := m.WalkPlanTask(c)
				if err != nil {
					u.Errorf("could not create child task %#v err=%v", c, err)
					return err
				}
				if err = childRoot.Add(ct); err != nil {
					u.Errorf("Could not add task %v", err)
					return err
				}
			}
		}
	}
	return nil
}
Example #4
0
func (m *JobExecutor) NewTask(p plan.Task) Task {
	if p.IsParallel() {
		return NewTaskParallel(m.Ctx)
	}
	return NewTaskSequential(m.Ctx)
}