NDB dbtux minor change

use strict;

use integer;

use Getopt::Long;

my $all = shift;

!defined($all) || ($all eq '--all' && !defined(shift))

  or die "only available option is --all";

my $opt_all = 0;

my $opt_cnt = 5;

GetOptions("all" => \$opt_all, "cnt=i" => \$opt_cnt)

  or die "options are:  --all --cnt=N";

my $table = 't';

  my($col, $key1, $key2, $val) = @_;

  my @a = ();

  my $p = mkdummy(@$val);

  push(@a, $p) if $all;

  my @ops1 = $all ? qw(< <= = >= >) : qw(= >= >);

  my @ops2 = $all ? qw(< <= = >= >) : qw(< <=);

  push(@a, $p) if $opt_all;

  my @ops = qw(< <= = >= >);

  for my $op (@ops) {

    my $p = mkone($col, $op, $key1, @$val);

    push(@a, $p) if $opt_all || $p->{cnt} != 0;

  }

  my @ops1 = $opt_all ? @ops : qw(= >= >);

  my @ops2 = $opt_all ? @ops : qw(<= <);

  for my $op1 (@ops1) {

    my $p = mkone($col, $op1, $key1, @$val);

    push(@a, $p) if $all || $p->{cnt} != 0;

    for my $op2 (@ops2) {

      my $p = mktwo($col, $op1, $key1, $op2, $key2, @$val);

      push(@a, $p) if $all || $p->{cnt} != 0;

      push(@a, $p) if $opt_all || $p->{cnt} != 0;

    }

  }

  return \@a;

  index (b, c, d)

) engine=ndb;

EOF

  my @val = (0..4);

  my @val = (0..($opt_cnt-1));

  my $v0 = 0;

  for my $v1 (@val) {

    for my $v2 (@val) {

   * m_occup), and whether the position is at an existing entry or

   * before one (if any).  Position m_occup points past the node and is

   * also represented by position 0 of next node.  Includes direction

   * and copy of entry used by scan.

   * used by scan.

   */

  struct TreePos;

  friend struct TreePos;

    TupLoc m_loc;               // physical node address

    Uint16 m_pos;               // position 0 to m_occup

    Uint8 m_match;              // at an existing entry

    Uint8 m_dir;                // from link (0-2) or within node (3)

    TreeEnt m_ent;              // copy of current entry

    Uint8 m_dir;                // see scanNext()

    TreePos();

  };

   * a separate lock wait flag.  It may be for current entry or it may

   * be for an entry we were moved away from.  In any case nothing

   * happens with current entry before lock wait flag is cleared.

   *

   * An unfinished scan is always linked to some tree node, and has

   * current position and direction (see comments at scanNext).  There

   * is also a copy of latest entry found.

   */

  struct ScanOp;

  friend struct ScanOp;

    ScanBound* m_bound[2];      // pointers to above 2

    Uint16 m_boundCnt[2];       // number of bounds in each

    TreePos m_scanPos;          // position

    TreeEnt m_lastEnt;          // last entry returned

    TreeEnt m_scanEnt;          // latest entry found

    Uint32 m_nodeScan;          // next scan at node (single-linked)

    union {

    Uint32 nextPool;

  m_loc(),

  m_pos(ZNIL),

  m_match(false),

  m_dir(255),

  m_ent()

  m_dir(255)

{

}

  m_boundMin(scanBoundPool),

  m_boundMax(scanBoundPool),

  m_scanPos(),

  m_lastEnt(),

  m_scanEnt(),

  m_nodeScan(RNIL)

{

  m_bound[0] = &m_boundMin;

  out << " [pos " << dec << pos.m_pos << "]";

  out << " [match " << dec << pos.m_match << "]";

  out << " [dir " << dec << pos.m_dir << "]";

  out << " [ent " << pos.m_ent << "]";

  out << "]";

  return out;

}

  out << " [lockMode " << dec << scan.m_lockMode << "]";

  out << " [keyInfo " << dec << scan.m_keyInfo << "]";

  out << " [pos " << scan.m_scanPos << "]";

  out << " [ent " << scan.m_scanEnt << "]";

  for (unsigned i = 0; i <= 1; i++) {

    out << " [bound " << dec << i;

    Dbtux::ScanBound& bound = *scan.m_bound[i];

  if (scan.m_lockwait) {

    jam();

    // LQH asks if we are waiting for lock and we tell it to ask again

    const TreeEnt ent = scan.m_scanPos.m_ent;

    const TreeEnt ent = scan.m_scanEnt;

    NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();

    conf->scanPtr = scan.m_userPtr;

    conf->accOperationPtr = RNIL;       // no tuple returned

    ndbrequire(scan.m_accLockOp == RNIL);

    if (! scan.m_readCommitted) {

      jam();

      const TreeEnt ent = scan.m_scanPos.m_ent;

      const TreeEnt ent = scan.m_scanEnt;

      // read tuple key

      readTablePk(frag, ent, pkData, pkSize);

      // get read lock or exclusive lock

    // we have lock or do not need one

    jam();

    // read keys if not already done (uses signal)

    const TreeEnt ent = scan.m_scanPos.m_ent;

    const TreeEnt ent = scan.m_scanEnt;

    if (scan.m_keyInfo) {

      jam();

      if (pkSize == 0) {

        total += length;

      }

    }

    // remember last entry returned

    scan.m_lastEnt = ent;

    // next time look for next entry

    scan.m_state = ScanOp::Next;

    return;

/*

 * Move to next entry.  The scan is already linked to some node.  When

 * we leave, if any entry was found, it will be linked to a possibly

 * different node.  The scan has a direction, one of:

 * different node.  The scan has a position, and a direction which tells

 * from where we came to this position.  This is one of:

 *

 * 0 - coming up from left child

 * 1 - coming up from right child (proceed to parent immediately)

 * 2 - coming up from root (the scan ends)

 * 3 - left to right within node

 * 4 - coming down from parent to left or right child

 * 0 - up from left child (scan this node next)

 * 1 - up from right child (proceed to parent)

 * 2 - up from root (the scan ends)

 * 3 - left to right within node (at end proceed to right child)

 * 4 - down from parent (proceed to left child)

 */

void

Dbtux::scanNext(Signal* signal, ScanOpPtr scanPtr)

  ndbrequire(islinkScan(origNode, scanPtr));

  // current node in loop

  NodeHandle node = origNode;

  // copy of entry found

  TreeEnt ent;

  while (true) {

    jam();

    if (pos.m_dir == 2) {

      pos.m_dir = 0;

    }

    if (pos.m_dir == 0) {

      // coming from left child scan current node

      // coming up from left child scan current node

      jam();

      pos.m_pos = 0;

      pos.m_match = false;

        pos.m_pos++;

      if (pos.m_pos < occup) {

        jam();

        pos.m_ent = node.getEnt(pos.m_pos);

        ent = node.getEnt(pos.m_pos);

        pos.m_dir = 3;  // unchanged

        // read and compare all attributes

        readKeyAttrs(frag, pos.m_ent, 0, c_entryKey);

        readKeyAttrs(frag, ent, 0, c_entryKey);

        int ret = cmpScanBound(frag, 1, c_dataBuffer, scan.m_boundCnt[1], c_entryKey);

        ndbrequire(ret != NdbSqlUtil::CmpUnknown);

        if (ret < 0) {

          break;

        }

        // can we see it

        if (! scanVisible(signal, scanPtr, pos.m_ent)) {

        if (! scanVisible(signal, scanPtr, ent)) {

          jam();

          continue;

        }

      pos.m_dir = 1;

    }

    if (pos.m_dir == 1) {

      // coming from right child proceed to parent

      // coming up from right child proceed to parent

      jam();

      pos.m_loc = node.getLink(2);

      pos.m_dir = node.getSide();

      unlinkScan(origNode, scanPtr);

      linkScan(node, scanPtr);

    }

    // copy found entry

    scan.m_scanEnt = ent;

  } else if (scan.m_state == ScanOp::Last) {

    jam();

    ndbrequire(pos.m_loc == NullTupLoc);

/*

 * Check if an entry is visible to the scan.

 *

 * There is a special check to never return same tuple twice in a row.

 * There is a special check to never accept same tuple twice in a row.

 * This is faster than asking TUP.  It also fixes some special cases

 * which are not analyzed or handled yet.

 */

  Uint32 tupAddr = getTupAddr(frag, ent);

  Uint32 tupVersion = ent.m_tupVersion;

  // check for same tuple twice in row

  if (scan.m_lastEnt.m_tupLoc == ent.m_tupLoc &&

      scan.m_lastEnt.m_fragBit == fragBit) {

  if (scan.m_scanEnt.m_tupLoc == ent.m_tupLoc &&

      scan.m_scanEnt.m_fragBit == fragBit) {

    jam();

    return false;

  }