Secondo Sortby分析

函数代码

/*
3.2 Operator ~sortby~

这个操作符类型由给定的属性列表流元组。
对于每个属性可以指定清单应按升序（ASC）或降序（DESC）对属性的顺序。

3.2.1 Type mapping function of operator ~sortby~

类型映射~sortby~ is

---- ((stream (tuple ((x1 t1)...(xn tn)))) ((xi1 asc/desc) ... (xij asc/desc)))
             -> ((stream (tuple ((x1 t1)...(xn tn))))
                 APPEND (j i1 true/false i2 true/false ... ij true/false))
----

类型映射函数确定给定属性列表的属性索引，并生成相应的排序顺序规范。
属性的数量，属性索引和布尔标志，表示一个提升（真）或降排序顺序
（假），被添加到值映射函数的参数列表中

*/

ListExpr SortByTypeMap( ListExpr args )//类型映射
{
  NList type(args);

  // 检查表的长度
  if ( !type.hasLength(2) )
  {
    return NList::typeError(
        "Operator sortby expects a list of "
        "length two.");
  }

  NList streamDesc = type.first();
  NList attrDesc = type.second();

  // 检查第一个参数是否是一个元组流
  NList attr;
  if ( !streamDesc.checkStreamTuple(attr) )
  {
    return NList::typeError(
        "Operator sortby: first argument is not a tuple stream!"
        "Operator received: " + streamDesc.convertToString() );
  }

  // 检查是否有一个有效的元组描述
  if ( !IsTupleDescription(attr.listExpr()) )
  {
    return NList::typeError(
        "Operator sortby: first argument does not "
        "contain a tuple description!"
        "Operator received: " + attr.convertToString() );
  }

  int numberOfSortAttrs = attrDesc.length();

  // 检查属性规范的长度
  if ( numberOfSortAttrs <= 0 )
  {
    return NList::typeError(
        "Operator sortby: sort order specification "
        "list may not be empty!");
  }

  NList sortDesc;
  sortDesc.append(NList(numberOfSortAttrs));
  NList rest = attrDesc;

  // 过程属性描述
  while( !rest.isEmpty() )
  {
    // 提取属性规范的第一个元素
    NList attrElem = rest.first();

    //切断第一个元素
    rest.rest();

    // attrelem可能是一个原子（不可选升序/降序说明符）
    // 或两个元素的表 (with asc/desc specifier)
    if ( !(attrElem.isAtom() || attrElem.length() == 2) )
    {
      return NList::typeError(
          "Operator sortby expects as second argument "
          "a list of (attrname [asc, desc])|attrname.");
    }

    string attrName;

    // 处理两种不同的情况
    if ( attrElem.length() == 2 )
    {
      // 检查类型attrelem
      if ( !(attrElem.first().isAtom() &&
             attrElem.first().isSymbol() &&
             attrElem.second().isAtom() &&
             attrElem.second().isSymbol() ) )
      {
        return NList::typeError(
            "Operator sortby expects as second argument a list"
            " of (attrname [asc, desc])|attrname .\n"
            "Operator sortby gets a list '"
            + attrDesc.convertToString() + "'.");
      }
      attrName = attrElem.first().str();
    }
    else
    {
      // 检查attrelem型原子
      if ( !(attrElem.isSymbol()) )
      {
        return NList::typeError(
            "Operator sortby expects as second argument a list"
            " of (attrname [asc, desc])|attrname .\n"
            "Operator sortby gets a list '"
            + attrDesc.convertToString() + "'.");
      }
      attrName = attrElem.str();
    }

    // 确定属性指标(1-based)
    ListExpr attrType;
    int j = FindAttribute(attr.listExpr(), attrName, attrType);

    // 确定升序/降序说明符
    if (j > 0)
    {
      bool isAscending = true;

      if( attrElem.length() == 2 )
      {
         if ( !( attrElem.second().str() == "asc" ||
                 attrElem.second().str() == "desc" ) )
         {
           return NList::typeError(
               "Operator sortby sorting criteria must "
               "be asc or desc, not '"
               + attrElem.second().convertToString() + "'!");
         }
         isAscending = attrElem.second().str() == "asc" ? true : false;
      }

      sortDesc.append(NList(j));
      sortDesc.append(NList(isAscending, isAscending));
    }
    else
    {
      return NList::typeError(
          "Operator sortby: attribute name '" + attrName +
          "' is not known.\nKnown Attribute(s): "
          + attr.convertToString());
    }
  }

  return NList(NList(Symbol::APPEND()), sortDesc, streamDesc).listExpr();
}
/*

3.2.2 规范操作 ~sortby~

*/
const string SortBySpec  = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
                           "\"Example\" ) "
                           "( <text>((stream (tuple([a1:d1, ... ,an:dn])))"
                           " ((xi1 asc/desc) ... (xij [asc/desc]))) -> "
                           "(stream (tuple([a1:d1, ... ,an:dn])))</text--->"
                           "<text>_ sortby [list]</text--->"
                           "<text>Sorts an input stream according to a list "
                           "of attributes ai1 ... aij. For each attribute one "
                           "may specify the sorting order (asc/desc). If no "
                           "order is specified, ascending is assumed."
                           "</text--->"
                           "<text>query employee feed sortby[DeptNo asc] "
                           "consume</text--->"
                              ") )";

/*
3.2.3 定义的算子~sortby~

*/
Operator extrelsortby (
         "sortby",               // name
         SortBySpec,              // specification
         SortValueMap<2, false>,  // value mapping - first argument
                                  // of sort order spec is 2
         Operator::SimpleSelect,  // trivial selection function
         SortByTypeMap            // type mapping
);

 

 

sortby的具体实现

template<int firstArg, bool param>
int SortValueMap(Word* args, Word& result, int message, Word& local, Supplier s)
{
  bool traceProgress = false;

  // Operator sort2 (firstArg = 1, param = false)
  // args[0] : stream
  // args[1] : the number of sort attributes
  // args[3] : the index of the first sort attribute
  // args[4] : a boolean which indicates if sortorder should
  //           be asc (true) or desc (false)
  // args[5] : Same as 3 but for the second sort attribute
  // args[6] : Same as 4 but for the second sort attribute
  // ....

  // Operator sort2Param (firstArg = 4, param = true)
  // args[0] : stream
  // args[1] : operator's main memory in bytes
  // args[2] : maximum fan-in of merge phase
  // args[3] : I/O buffer size in bytes
  // args[4] : the number of sort attributes
  // args[5] : the index of the first sort attribute
  // args[6] : a boolean which indicates if sortorder should
  //           be asc (true) or desc (false)
  // args[7] : Same as 3 but for the second sort attribute
  // args[8] : Same as 4 but for the second sort attribute
  // ....

  // Operator sortby2 (firstArg = 2, param = false)
  // args[0] : stream
  // args[1] : sort attributes specification as list (ignored)
  // args[2] : the number of sort attributes
  // args[3] : the index of the first sort attribute
  // args[4] : a boolean which indicates if sortorder should
  //           be asc (true) or desc (false)
  // args[5] : Same as 3 but for the second sort attribute
  // args[6] : Same as 4 but for the second sort attribute
  // ....

  // Operator sortby2Param (firstArg = 5, param = true)
  // args[0] : stream
  // args[1] : sort attributes specification as list (ignored)
  // args[2] : operator's main memory in bytes
  // args[3] : maximum fan-in of merge phase
  // args[4] : I/O buffer size in bytes
  // args[5] : the number of sort attributes
  // args[6] : the index of the first sort attribute
  // args[7] : a boolean which indicates if sortorder should
  //           be asc (true) or desc (false)
  // args[8] : Same as 3 but for the second sort attribute
  // args[9] : Same as 4 but for the second sort attribute
  // ....

  SortLocalInfo* li;
  li = static_cast<SortLocalInfo*>( local.addr );

  switch(message)
  {
    case OPEN:
    {
      if (li)
      {
        delete li;
      }

      li = new SortLocalInfo();
      local.addr = li;

      // at this point the local value is well defined
      // afterwards progress request calls are
      // allowed.

      li->ptr = 0;

      qp->Open(args[0].addr);

      return 0;
    }

    case REQUEST:
    {
      if ( li->ptr == 0 )
      {
        SortOrderSpecification spec;
        int nAttrCount = StdTypes::GetInt( args[firstArg] );
        for(int i = 1; i <= nAttrCount; i++)
        {
          int j = firstArg + (2*i - 1);
          int attrIndex = StdTypes::GetInt( args[j] );
          bool isAsc = StdTypes::GetBool( args[j+1] );
          spec.push_back(pair<int, bool>(attrIndex, isAsc));
        };

        //Sorting is done in the following constructor. It was moved from
        //OPEN to REQUEST to avoid long delays in the OPEN method, which are
        //a problem for progress estimation
        if ( param )
        {
          int idx = firstArg - 3;
          int maxMemSize = StdTypes::GetInt( args[idx] );
          int maxFanIn = StdTypes::GetInt( args[idx+1] );
          int ioBufferSize = StdTypes::GetInt( args[idx+2] );

          size_t fan = maxFanIn < 0 ? UINT_MAX : (size_t)maxFanIn;
          size_t mem = maxMemSize < 0 ? UINT_MAX : (size_t)maxMemSize;
          size_t buf = ioBufferSize < 0 ? UINT_MAX : (size_t)ioBufferSize;

          li->ptr = new SortAlgorithm(args[0], spec, li, s, fan, mem, buf);
        }
        else
        {
          li->ptr = new SortAlgorithm(args[0], spec, li, s);
        }
      }

      SortAlgorithm* sa = li->ptr;

      result.setAddr( sa->NextResultTuple() );
      li->returned++;
      return result.addr != 0 ? YIELD : CANCEL;
    }

    case CLOSE:
    {
      // Note: object deletion is handled in OPEN and CLOSEPROGRESS
      qp->Close(args[0].addr);
      return 0;
    }


    case CLOSEPROGRESS:
    {
      if (li)
      {
        delete li;
        local.addr = 0;
      }
      return 0;
    }

    case REQUESTPROGRESS:
    {
      ProgressInfo p1;
      ProgressInfo *pRes;
      const double uSortBy = 0.0000873; //millisecs per byte input and sort
    // old constant 0.000396;   
      const double vSortBy = 0.0000243;  //millisecs per byte output
        // old constant 0.000194;  
      const double oSortBy = 0.00004;   //offset due to writing to disk
            //not yet measurable

      // constants determined in file ExtRelation-C++/ConstantsExtendStream



      pRes = (ProgressInfo*) result.addr;

      if( !li )
      {
        return CANCEL;
      }
      else
      {
        if (qp->RequestProgress(args[0].addr, &p1))
        {
          // -------------------------------------------
          // Result cardinality
          // -------------------------------------------

          pRes->Card = li->returned == 0 ? p1.Card : li->read;
          pRes->CopySizes(p1);

          // -------------------------------------------
          // Total time
          // -------------------------------------------

          pRes->Time = p1.Time
            + pRes->Card * p1.SizeExt * (uSortBy + oSortBy * li->state)
            + pRes->Card * p1.SizeExt * vSortBy
            + li->intTuplesTotal * p1.Size * (2 * vSortBy);

          // -------------------------------------------
          // Total progress
          // -------------------------------------------

          pRes->Progress =
            (p1.Progress * p1.Time
             + li->read * p1.SizeExt * (uSortBy + oSortBy * li->state)
             + li->returned * p1.SizeExt * vSortBy
             + li->intTuplesProc * p1.SizeExt * (2 * vSortBy) )
            / pRes->Time;

          // -------------------------------------------
          // Blocking time
          // -------------------------------------------

          // Estimated time until first result tuple is ready
          pRes->BTime = p1.Time
            + pRes->Card * p1.SizeExt * (uSortBy + oSortBy * li->state)
            + li->intTuplesTotal * p1.SizeExt * (2 * vSortBy);

          // -------------------------------------------
          // Blocking progress
          // -------------------------------------------

          pRes->BProgress =
            (p1.Progress * p1.Time
                + li->read * p1.SizeExt * (uSortBy + oSortBy * li->state)
                + li->intTuplesProc * p1.SizeExt * (2 * vSortBy))
                / pRes->BTime;

          if ( traceProgress )
          {
            cmsg.info() << "p1->Card: " << p1.Card
                        << ", p1.Time: " << p1.Time
                        << ", p1.Progress: " << p1.Progress
                        << endl
                        << "pRes->Time: " << pRes->Time
                        << ", pRes->Progress: " << pRes->Progress
                        << endl
                        << ", intTuples: " << li->intTuplesProc
                        << "/" << li->intTuplesTotal
                        << endl;
            cmsg.send();
          }

          return YIELD;
        }
        else
        {
          return CANCEL;
        }
      }
    }
  }
  return 0;
}