OrderBy:
  "ORDER" "BY" ByList
  {
    $$ = &ast.OrderByClause{Items: $3.([]*ast.ByItem)}
  }
ByList:
  ByItem
  {
    $$ = []*ast.ByItem{$1.(*ast.ByItem)}
  }
|  ByList ',' ByItem
  {
    $$ = append($1.([]*ast.ByItem), $3.(*ast.ByItem))
  }
  
ByItem:
  Expression Order
  {
    expr := $1
    valueExpr, ok := expr.(*ast.ValueExpr)
    if ok {
      position, isPosition := valueExpr.GetValue().(int64)
      if isPosition {
        expr = &ast.PositionExpr{N: int(position)}
      }
    }
    $$ = &ast.ByItem{Expr: expr, Desc: $2.(bool)}
  }
Order:
  /* EMPTY */
  {
    $$ = false // ASC by default
  }
|  "ASC"
  {
    $$ = false
  }
|  "DESC"
  {
    $$ = true
  }

// ByItem represents an item in order by or group by.
type ByItem struct {
  node
  Expr ExprNode
  Desc bool
}

func (b *planBuilder) buildSelect(sel *ast.SelectStmt) LogicalPlan {
  ...
  if sel.OrderBy != nil {
    p = b.buildSort(p, sel.OrderBy.Items, orderMap) // 这个 orderMap 会在下面解释.
    if b.err != nil {
      return nil
    }
  }
}

// Sort stands for the order by plan.
type Sort struct {
  *basePlan
  baseLogicalPlan
  basePhysicalPlan
  ByItems   []*ByItems
  ExecLimit *Limit // no longer be used by new plan
}

// resolveHavingAndOrderBy will process aggregate functions and resolve the columns that don't exist in select fields.
// If we found some columns that are not in select fields, we will append it to select fields and update the colMapper.
// When we rewrite the order by / having expression, we will find column in map at first.
func (b *planBuilder) resolveHavingAndOrderBy(sel *ast.SelectStmt, p LogicalPlan) (
  map[*ast.AggregateFuncExpr]int, map[*ast.AggregateFuncExpr]int) {
  extractor := &havingAndOrderbyExprResolver{
    p:            p,
    selectFields: sel.Fields.Fields,
    aggMapper:    make(map[*ast.AggregateFuncExpr]int),
    colMapper:    b.colMapper,
    outerSchemas: b.outerSchemas,
  }
  if sel.GroupBy != nil {
    extractor.gbyItems = sel.GroupBy.Items
  }
  // Extract agg funcs from having clause.
  if sel.Having != nil {
    extractor.curClause = havingClause
    n, ok := sel.Having.Expr.Accept(extractor)
    if !ok {
      b.err = errors.Trace(extractor.err)
      return nil, nil
    }
    sel.Having.Expr = n.(ast.ExprNode)
  }
  havingAggMapper := extractor.aggMapper
  extractor.aggMapper = make(map[*ast.AggregateFuncExpr]int)
  extractor.orderBy = true
  extractor.inExpr = false
  // Extract agg funcs from order by clause.
  if sel.OrderBy != nil {
    extractor.curClause = orderByClause
    for _, item := range sel.OrderBy.Items {
      n, ok := item.Expr.Accept(extractor)
      if !ok {
        b.err = errors.Trace(extractor.err)
        return nil, nil
      }
      item.Expr = n.(ast.ExprNode)
    }
  }
  sel.Fields.Fields = extractor.selectFields
  return havingAggMapper, extractor.aggMapper
}

// Accept implements Node Accept interface.
func (n *AggregateFuncExpr) Accept(v Visitor) (Node, bool) {
  newNode, skipChildren := v.Enter(n)
  if skipChildren {
    return v.Leave(newNode)
  }
  n = newNode.(*AggregateFuncExpr)
  for i, val := range n.Args {
    node, ok := val.Accept(v) 
    if !ok {
      return n, false
    }
    n.Args[i] = node.(ExprNode) // 在这里被改写.
  }
  return v.Leave(n)
}

case *ast.AggregateFuncExpr:
    a.inAggFunc = false
    a.aggMapper[v] = len(a.selectFields)
    a.selectFields = append(a.selectFields, &ast.SelectField{
      Auxiliary: true,
      Expr:      v,
      AsName:    model.NewCIStr(fmt.Sprintf("sel_agg_%d", len(a.selectFields))),
    })

func (b *planBuilder) buildSort(p LogicalPlan, byItems []*ast.ByItem, aggMapper map[*ast.AggregateFuncExpr]int) LogicalPlan {
  b.curClause = orderByClause
  sort := Sort{}.init(b.ctx)
  exprs := make([]*ByItems, 0, len(byItems))
  for _, item := range byItems {
    it, np, err := b.rewrite(item.Expr, p, aggMapper, true) // 这里会对 byItems 做 rewrite, 方便后续的处理.
     if err != nil {
      b.err = err
      return nil
    }
    p = np
    exprs = append(exprs, &ByItems{Expr: it, Desc: item.Desc})
  }
  sort.ByItems = exprs
  setParentAndChildren(sort, p)
  sort.SetSchema(p.Schema().Clone())
  return sort
}

func (p *Sort) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
  t := p.getTask(prop)
  if t != nil {
    return t, nil
  }
  if prop.taskTp != rootTaskType {
    // TODO: This is a trick here, because an operator that can be pushed to Coprocessor can never be pushed across sort.
    // e.g. If an aggregation want to be pushed, the SQL is always like select count(*) from t order by ...
    // The Sort will on top of Aggregation. If the SQL is like select count(*) from (select * from s order by k).
    // The Aggregation will also be blocked by projection. In the future we will break this restriction.
    p.storeTask(prop, invalidTask)
    return invalidTask, nil
  }
  // enforce branch
  // 对于 select * from t order by a, sort plan 的第一个孩子是 Projection, 由于 Projection 没有实现convert2NewPhysicalPlan,
  // 所以调用的是 baseLogicalPlan.convert2NewPhysicalPlan
  t, err := p.children[0].(LogicalPlan).convert2NewPhysicalPlan(&requiredProp{taskTp: rootTaskType, expectedCnt: math.MaxFloat64}) 
  if err != nil {
    return nil, errors.Trace(err)
  }
  t = p.attach2Task(t)
  newProp, canPassProp := getPropByOrderByItems(p.ByItems)
  if canPassProp {
    newProp.expectedCnt = prop.expectedCnt
    orderedTask, err := p.children[0].(LogicalPlan).convert2NewPhysicalPlan(newProp)
    if err != nil {
      return nil, errors.Trace(err)
    }
    if orderedTask.cost() < t.cost() {
      t = orderedTask
    }
  }
  t = prop.enforceProperty(t, p.ctx)
  p.storeTask(prop, t)
  return t, nil
}

if !prop.isEmpty() {
    for i, col := range idx.Columns {
      // not matched
      if col.Name.L == prop.cols[0].ColName.L {
        matchProperty = matchIndicesProp(idx.Columns[i:], prop.cols)
        break
      } else if i >= len(is.AccessCondition) {
        break
      } else if sf, ok := is.AccessCondition[i].(*expression.ScalarFunction); !ok || sf.FuncName.L != ast.EQ {
        break
      }
    }
}

// task is a new version of `PhysicalPlanInfo`. It stores cost information for a task.
// A task may be CopTask, RootTask, MPPTask or a ParallelTask.
type task interface {
  count() float64
  addCost(cost float64)
  cost() float64
  copy() task
  plan() PhysicalPlan
  invalid() bool
}

// It will enumerate all the available indices and choose a plan with least cost.
func (p *DataSource) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
  if prop == nil {
    return nil, nil
  }
  t := p.getTask(prop)
  if t != nil {
    return t, nil
  }
  t, err := p.tryToGetDualTask()
  if err != nil {
    return nil, errors.Trace(err)
  }
  if t != nil {
    p.storeTask(prop, t)
    return t, nil
  }
  t, err = p.tryToGetMemTask(prop)
  if err != nil {
    return nil, errors.Trace(err)
  }
  if t != nil {
    p.storeTask(prop, t)
    return t, nil
  }
  // TODO: We have not checked if this table has a predicate. If not, we can only consider table scan.
  indices := p.availableIndices.indices
  includeTableScan := p.availableIndices.includeTableScan
  t = invalidTask
  
  // 它这里先会创建一个 PhysicalTableReader 的 copTask, 会在下面再创建一个 indexReader, 如果 idxTask 的代价小于 TableReader 的 copTask, 那么会选 indexReader
  if includeTableScan {
    t, err = p.convertToTableScan(prop)
    if err != nil {
      return nil, errors.Trace(err)
    }
  }
  if !includeTableScan || len(p.pushedDownConds) > 0 || len(prop.cols) > 0 {
    for _, idx := range indices {
      idxTask, err := p.convertToIndexScan(prop, idx)
      if err != nil {
        return nil, errors.Trace(err)
      }
      // 这里会选一个 cost 最小的 IndexScan, 具体这个 IndexScan 是怎么转换得来的, 
      // 可以看下面的 DataSource.convertToIndexScan 一节.
      if idxTask.cost() < t.cost() {
        t = idxTask
      }
    }
  }
  p.storeTask(prop, t)
  return t, nil
}

create table t1(
  a int, 
  b int, 
  primary key(a),
  key b_idx(b)
);

// convertToTableScan converts the DataSource to table scan.
func (p *DataSource) convertToTableScan(prop *requiredProp) (task task, err error) {
  if prop.taskTp == copDoubleReadTaskType {
    return &copTask{cst: math.MaxFloat64}, nil
  }
  ts := PhysicalTableScan{
    Table:       p.tableInfo,
    Columns:     p.Columns,
    TableAsName: p.TableAsName,
    DBName:      p.DBName,
  }.init(p.ctx)
  ts.SetSchema(p.schema)
  sc := p.ctx.GetSessionVars().StmtCtx
  ts.Ranges = ranger.FullIntRange()
  var pkCol *expression.Column
  if ts.Table.PKIsHandle {
    if pkColInfo := ts.Table.GetPkColInfo(); pkColInfo != nil {
      pkCol = expression.ColInfo2Col(ts.schema.Columns, pkColInfo)
    }
  }
  if len(p.pushedDownConds) > 0 {
    conds := make([]expression.Expression, 0, len(p.pushedDownConds))
    for _, cond := range p.pushedDownConds {
      conds = append(conds, cond.Clone())
    }
    if pkCol != nil {
      var ranges []ranger.Range
      // ranger.DetachCondsForTableRange 是把过滤条件条件剔除出来, 
      // 如果是跟pkCol 相关的, 会放在ts.AccessCondition 数组, 
      // 如果是其他的列, 那么就放在 ts.filterCondition
      ts.AccessCondition, ts.filterCondition = ranger.DetachCondsForTableRange(p.ctx, conds, pkCol)
      // 这里的 range 包括: IntColumnRange(TableRange), ColumnRange, IndexRange. 当然这里是 ranger.IntRangeType (TableRange).
      // 对于 select * from t1 where b = 2 order by b; 这里的 ts.AccessCondition 为空, 所以得出的 range 就是 FullRange, 全表. 
      // 过滤是需要通过索引 b 来做的, pk 做不了什么.
      ranges, err = ranger.BuildRange(sc, ts.AccessCondition, ranger.IntRangeType, []*expression.Column{pkCol}, nil)
      ts.Ranges = ranger.Ranges2IntRanges(ranges)
      if err != nil {
        return nil, errors.Trace(err)
      }
    } else {
      // 如果 primary key 不是 Handle 的话(这个含义需要结合 TiDB 对于主键的处理来理解), 那么所有的条件都放在 ts.filterCondition
      ts.filterCondition = conds
    }
  }
  ts.profile = p.getStatsProfileByFilter(p.pushedDownConds)
  statsTbl := p.statisticTable
  rowCount := float64(statsTbl.Count)
  if pkCol != nil {
    // TODO: We can use p.getStatsProfileByFilter(accessConditions).
    rowCount, err = statsTbl.GetRowCountByIntColumnRanges(sc, pkCol.ID, ts.Ranges)
    if err != nil {
      return nil, errors.Trace(err)
    }
  }
  copTask := &copTask{
    tablePlan:         ts,
    indexPlanFinished: true,
  }
  task = copTask
  matchProperty := len(prop.cols) == 1 && pkCol != nil && prop.cols[0].Equal(pkCol, nil)
  if matchProperty && prop.expectedCnt < math.MaxFloat64 {
    selectivity, err := p.statisticTable.Selectivity(p.ctx, ts.filterCondition)
    if err != nil {
      log.Warnf("An error happened: %v, we have to use the default selectivity", err.Error())
      selectivity = selectionFactor
    }
    rowCount = math.Min(prop.expectedCnt/selectivity, rowCount)
  }
  ts.expectedCnt = rowCount
  copTask.cst = rowCount * scanFactor
  if matchProperty {
    if prop.desc {
      ts.Desc = true
      copTask.cst = rowCount * descScanFactor
    }
    ts.KeepOrder = true
    copTask.keepOrder = true
    ts.addPushedDownSelection(copTask, p.profile, prop.expectedCnt)
  } else {
    expectedCnt := math.MaxFloat64
    if prop.isEmpty() {
      expectedCnt = prop.expectedCnt
    } else {
      return invalidTask, nil
    }
    // 这里会把 filterCondition 转成 PhysicalSelection 
    ts.addPushedDownSelection(copTask, p.profile, expectedCnt)
  }
  if prop.taskTp == rootTaskType {
    task = finishCopTask(task, p.ctx)
  } else if _, ok := task.(*rootTask); ok {
    return invalidTask, nil
  }
  return task, nil
}

if !includeTableScan || len(p.pushedDownConds) > 0 || len(prop.cols) > 0 {
    for _, idx := range indices {
      idxTask, err := p.convertToIndexScan(prop, idx)
      if err != nil {
        return nil, errors.Trace(err)
      }
      if idxTask.cost() < t.cost() {
        t = idxTask
      }
    }
  }

// convertToIndexScan converts the DataSource to index scan with idx.
func (p *DataSource) convertToIndexScan(prop *requiredProp, idx *model.IndexInfo) (task task, err error) {
  is := PhysicalIndexScan{
    Table:            p.tableInfo,
    TableAsName:      p.TableAsName,
    DBName:           p.DBName,
    Columns:          p.Columns,
    Index:            idx,
    dataSourceSchema: p.schema,
  }.init(p.ctx)
  statsTbl := p.statisticTable
  rowCount := float64(statsTbl.Count)
  sc := p.ctx.GetSessionVars().StmtCtx
  idxCols, colLengths := expression.IndexInfo2Cols(p.Schema().Columns, idx)
  is.Ranges = ranger.FullIndexRange()
  if len(p.pushedDownConds) > 0 {
    conds := make([]expression.Expression, 0, len(p.pushedDownConds))
    for _, cond := range p.pushedDownConds {
      conds = append(conds, cond.Clone())
    }
    if len(idxCols) > 0 {
      var ranges []ranger.Range
      is.AccessCondition, is.filterCondition = ranger.DetachIndexConditions(conds, idxCols, colLengths)
      ranges, err = ranger.BuildRange(sc, is.AccessCondition, ranger.IndexRangeType, idxCols, colLengths)
      if err != nil {
        return nil, errors.Trace(err)
      }
      is.Ranges = ranger.Ranges2IndexRanges(ranges)
      rowCount, err = statsTbl.GetRowCountByIndexRanges(sc, is.Index.ID, is.Ranges)
      if err != nil {
        return nil, errors.Trace(err)
      }
    } else {
      is.filterCondition = conds
    }
  }
  is.profile = p.getStatsProfileByFilter(p.pushedDownConds)
  cop := &copTask{
    indexPlan: is,
  }
  if !isCoveringIndex(is.Columns, is.Index.Columns, is.Table.PKIsHandle) {
    // 如果索引里面没有全部的数据, 有一些列需要去拿 handle 绑定的value, 这个叫做
    // double read
    // On this way, it's double read case.
    cop.tablePlan = PhysicalTableScan{Columns: p.Columns, Table: is.Table}.init(p.ctx)
    cop.tablePlan.SetSchema(p.schema.Clone())
    // If it's parent requires single read task, return max cost.
    if prop.taskTp == copSingleReadTaskType {
      return &copTask{cst: math.MaxFloat64}, nil
    }
  } else if prop.taskTp == copDoubleReadTaskType {
    // If it's parent requires double read task, return max cost.
    return &copTask{cst: math.MaxFloat64}, nil
  }
  is.initSchema(p.id, idx, cop.tablePlan != nil)
  // Check if this plan matches the property.
  matchProperty := false
  if !prop.isEmpty() {
    for i, col := range idx.Columns {
      // not matched
      if col.Name.L == prop.cols[0].ColName.L {
        matchProperty = matchIndicesProp(idx.Columns[i:], prop.cols)
        break
      } else if i >= len(is.AccessCondition) {
        break
      } else if sf, ok := is.AccessCondition[i].(*expression.ScalarFunction); !ok || sf.FuncName.L != ast.EQ {
        break
      }
    }
  }
  if matchProperty && prop.expectedCnt < math.MaxFloat64 {
    selectivity, err := p.statisticTable.Selectivity(p.ctx, is.filterCondition)
    if err != nil {
      log.Warnf("An error happened: %v, we have to use the default selectivity", err.Error())
      selectivity = selectionFactor
    }
    rowCount = math.Min(prop.expectedCnt/selectivity, rowCount)
  }
  is.expectedCnt = rowCount
  cop.cst = rowCount * scanFactor
  task = cop
  if matchProperty {
    if prop.desc {
      is.Desc = true
      cop.cst = rowCount * descScanFactor
    }
    if cop.tablePlan != nil {
      cop.tablePlan.(*PhysicalTableScan).appendExtraHandleCol(p)
    }
    cop.keepOrder = true
    is.addPushedDownSelection(cop, p, prop.expectedCnt)
  } else {
    is.OutOfOrder = true
    expectedCnt := math.MaxFloat64
    if prop.isEmpty() {
      expectedCnt = prop.expectedCnt
    } else {
      return invalidTask, nil
    }
    // 这里把过滤条件转换为 PhysicalSelection
    is.addPushedDownSelection(cop, p, expectedCnt)
  }
  if prop.taskTp == rootTaskType {
    task = finishCopTask(task, p.ctx)
  } else if _, ok := task.(*rootTask); ok {
    return invalidTask, nil
  }
  return task, nil
}

func (p *baseLogicalPlan) getBestTask(bestTask task, prop *requiredProp, pp PhysicalPlan) (task, error) {
  newProps := pp.getChildrenPossibleProps(prop)
  for _, newProp := range newProps {
    tasks := make([]task, 0, len(p.basePlan.children))
    for i, child := range p.basePlan.children {
      childTask, err := child.(LogicalPlan).convert2NewPhysicalPlan(newProp[i])
      if err != nil {
        return nil, errors.Trace(err)
      }
      tasks = append(tasks, childTask)
    }
    // 这里是关键, 会计算 task 的代价, 如果当前resultTask 代价小于 bestTask,
    // 那么会替换当前的 bestTask. 最终选出最优的 task
    // attach2Task 是把 child 的 tasks attach 到当前的 Physical plan, 然后再计算总体代价
    resultTask := pp.attach2Task(tasks...)
    if resultTask.cost() < bestTask.cost() {
      bestTask = resultTask
    }
  }
  return bestTask, nil
}

func (b *executorBuilder) buildSort(v *plan.Sort) Executor {
  childExec := b.build(v.Children()[0]) // 先 build 孩子算子的执行器, 一层一层 build
  if b.err != nil {
    b.err = errors.Trace(b.err)
    return nil
  }
  sortExec := SortExec{
    baseExecutor: newBaseExecutor(v.Schema(), b.ctx, childExec),
    ByItems:      v.ByItems,
    schema:       v.Schema(),
  }
  sortExec.supportChk = true
  if v.ExecLimit != nil {
    return &TopNExec{
      SortExec: sortExec,
      limit:    v.ExecLimit,
    }
  }
  return &sortExec
}

func (e *SortExec) Next(goCtx goctx.Context) (Row, error) {
  if !e.fetched {
    for {
      srcRow, err := e.children[0].Next(goCtx)
      if err != nil {
        return nil, errors.Trace(err)
      }
      if srcRow == nil {
        break
      }
      orderRow := &orderByRow{
        row: srcRow,
        key: make([]*types.Datum, len(e.ByItems)),
      }
      for i, byItem := range e.ByItems {
        key, err := byItem.Expr.Eval(srcRow)
        if err != nil {
          return nil, errors.Trace(err)
        }
        orderRow.key[i] = &key
      }
      e.Rows = append(e.Rows, orderRow)
    }
    sort.Sort(e)
    e.fetched = true
  }
  if e.err != nil {
    return nil, errors.Trace(e.err)
  }
  if e.Idx >= len(e.Rows) {
    return nil, nil
  }
  row := e.Rows[e.Idx].row
  e.Idx++
  return row, nil
}

func BootstrapSession(store kv.Storage) (*domain.Domain, error) {
ver := getStoreBootstrapVersion(store)
	if ver == notBootstrapped {
		runInBootstrapSession(store, bootstrap)
	} else if ver < currentBootstrapVersion {
		runInBootstrapSession(store, upgrade)
	}
	
	...

// bootstrap initiates system DB for a store.
func bootstrap(s Session) {
	b, err := checkBootstrapped(s)
	if err != nil {
		log.Fatal(err)
	}
	if b {
		upgrade(s)
		return
	}
	doDDLWorks(s)  // 创建一些系统表
	doDMLWorks(s)  // 插入一下元数据到系统表
}

func upgrade(s Session) {
	ver, err := getBootstrapVersion(s)
	if err != nil {
		log.Fatal(errors.Trace(err))
	}
	if ver >= currentBootstrapVersion {
		// It is already bootstrapped/upgraded by a higher version TiDB server.
		return
	}
	...
	if ver < version15 {
		upgradeToVer15(s) // 例如这里创建了mysql.gc_delete_range 
	}
	...
}

// LoadPrivilegeLoop create a goroutine loads privilege tables in a loop, it
// should be called only once in BootstrapSession.
func (do *Domain) LoadPrivilegeLoop(ctx context.Context) error {
	ctx.GetSessionVars().InRestrictedSQL = true
	do.privHandle = privileges.NewHandle()
	err := do.privHandle.Update(ctx) 
	if err != nil {
		return errors.Trace(err)
	}
	var watchCh clientv3.WatchChan
	duration := 5 * time.Minute
	if do.etcdClient != nil {
		watchCh = do.etcdClient.Watch(goctx.Background(), privilegeKey)
		duration = 10 * time.Minute
	}
	go func() {
		var count int
		for {
			ok := true
			select {
			case <-do.exit:
				return
			case _, ok = <-watchCh:
			case <-time.After(duration):
			}
			if !ok {
				log.Error("[domain] load privilege loop watch channel closed.")
				watchCh = do.etcdClient.Watch(goctx.Background(), privilegeKey)
				count++
				if count > 10 {
					time.Sleep(time.Duration(count) * time.Second)
				}
				continue
			}
			count = 0
			err := do.privHandle.Update(ctx)  // 这里会更新所有的 priv 到内存
			if err != nil {
				log.Error("[domain] load privilege fail:", errors.ErrorStack(err))
			} else {
				log.Info("[domain] reload privilege success.")
			}
		}
	}()
	return nil
}

// UpdateTableStatsLoop creates a goroutine loads stats info and updates stats info in a loop.
// It will also start a goroutine to analyze tables automatically.
// It should be called only once in BootstrapSession.
func (do *Domain) UpdateTableStatsLoop(ctx context.Context) error {
	ctx.GetSessionVars().InRestrictedSQL = true
	statsHandle := statistics.NewHandle(ctx, do.statsLease)
	atomic.StorePointer(&do.statsHandle, unsafe.Pointer(statsHandle))
	do.ddl.RegisterEventCh(statsHandle.DDLEventCh())
	err := statsHandle.Update(do.InfoSchema())
	if err != nil {
		return errors.Trace(err)
	}
	lease := do.statsLease
	if lease <= 0 {
		return nil
	}
	do.wg.Add(1)
	go do.updateStatsWorker(ctx, lease)
	if RunAutoAnalyze {
		do.wg.Add(1)
		go do.autoAnalyzeWorker(lease)
	}
	return nil
}

if raw, ok := store.(domain.EtcdBackend); ok {
	err = raw.StartGCWorker()
	if err != nil {
		return nil, errors.Trace(err)
	}
}

GOPATH=/home/user/gocode
/home/user/gocode/
    src/
        foo/
            bar/               (go code in package bar)
                x.go
            quux/              (go code in package main)
                y.go
    bin/
        quux                   (installed command)
    pkg/
        linux_amd64/
            foo/
                bar.a          (installed package object)

// +build

// +build linux,386 darwin,!cgo

(linux AND 386) OR (darwin AND (NOT cgo))

// +build linux darwin
// +build 386

(linux OR darwin) AND 386

- the target operating system, as spelled by runtime.GOOS
- the target architecture, as spelled by runtime.GOARCH
- the compiler being used, either "gc" or "gccgo"
- "cgo", if ctxt.CgoEnabled is true
- "go1.1", from Go version 1.1 onward
- "go1.2", from Go version 1.2 onward
- "go1.3", from Go version 1.3 onward
- "go1.4", from Go version 1.4 onward
- "go1.5", from Go version 1.5 onward
- "go1.6", from Go version 1.6 onward
- "go1.7", from Go version 1.7 onward
- "go1.8", from Go version 1.8 onward
- "go1.9", from Go version 1.9 onward
- any additional words listed in ctxt.BuildTags

*_GOOS
*_GOARCH
*_GOOS_GOARCH

// +build ignore

// +build linux,cgo darwin,cgo

// +build !linux,!darwin !cgo

//go:binary-only-package
package mypkg

LDFLAGS += -X "github.com/pingcap/tidb/util/printer.TiDBBuildTS=$(shell date -u '+%Y-%m-%d %I:%M:%S')"
LDFLAGS += -X "github.com/pingcap/tidb/util/printer.TiDBGitHash=$(shell git rev-parse HEAD)"
...
server:
ifeq ($(TARGET), "")
    @cd tidb-server && $(GO) build -ldflags '$(LDFLAGS)'
else
    @cd tidb-server && $(GO) build -ldflags '$(LDFLAGS)' -o '$(TARGET)'
endif