开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbScanFilter.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：18k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbScanFilter.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <NdbScanFilter.hpp>
  18. #include <NdbOperation.hpp>
  19. #include "NdbDictionaryImpl.hpp"
  20. #include <Vector.hpp>
  21. #include <NdbOut.hpp>
  22. #include <Interpreter.hpp>
  24. #ifdef VM_TRACE
  25. #include <NdbEnv.h>
  26. #define INT_DEBUG(x) 
  27.   { const char* tmp = NdbEnv_GetEnv("INT_DEBUG", (char*)0, 0); 
  28.   if (tmp != 0 && strlen(tmp) != 0) { ndbout << "INT:"; ndbout_c x; } }
  29. #else
  30. #define INT_DEBUG(x)
  31. #endif
  33. class NdbScanFilterImpl {
  34. public:
  35.   struct State {
  36.     NdbScanFilter::Group m_group;
  37.     Uint32 m_popCount;
  38.     Uint32 m_ownLabel;
  39.     Uint32 m_trueLabel;
  40.     Uint32 m_falseLabel;
  41.   };
  43.   int m_label;
  44.   State m_current;
  45.   Vector<State> m_stack;
  46.   NdbOperation * m_operation;
  47.   Uint32 m_latestAttrib;
  49.   int cond_col(Interpreter::UnaryCondition, Uint32 attrId);
  50.   
  51.   template<typename T>
  52.   int cond_col_const(Interpreter::BinaryCondition, Uint32 attrId, T value);
  54.   int cond_col_const(Interpreter::BinaryCondition, Uint32 attrId, 
  55.      const char * value, Uint32 len, bool nopad);
  56. };
  58. const Uint32 LabelExit = ~0;
  61. NdbScanFilter::NdbScanFilter(class NdbOperation * op)
  62.   : m_impl(* new NdbScanFilterImpl())
  63. {
  64.   m_impl.m_current.m_group = (NdbScanFilter::Group)0;
  65.   m_impl.m_current.m_popCount = 0;
  66.   m_impl.m_current.m_ownLabel = 0;
  67.   m_impl.m_current.m_trueLabel = ~0;
  68.   m_impl.m_current.m_falseLabel = ~0;
  69.   m_impl.m_label = 0;
  70.   m_impl.m_latestAttrib = ~0;
  71.   m_impl.m_operation = op;
  72. }
  74. NdbScanFilter::~NdbScanFilter(){
  75.   delete &m_impl;
  76. }
  77.  
  78. int
  79. NdbScanFilter::begin(Group group){
  81.   switch(group){
  82.   case NdbScanFilter::AND:
  83.     INT_DEBUG(("Begin(AND)"));
  84.     break;
  85.   case NdbScanFilter::OR:
  86.     INT_DEBUG(("Begin(OR)"));
  87.     break;
  88.   case NdbScanFilter::NAND:
  89.     INT_DEBUG(("Begin(NAND)"));
  90.     break;
  91.   case NdbScanFilter::NOR:
  92.     INT_DEBUG(("Begin(NOR)"));
  93.     break;
  94.   }
  96.   if(group == m_impl.m_current.m_group){
  97.     switch(group){
  98.     case NdbScanFilter::AND:
  99.     case NdbScanFilter::OR:
  100.       m_impl.m_current.m_popCount++;
  101.       return 0;
  102.     case NdbScanFilter::NOR:
  103.     case NdbScanFilter::NAND:
  104.       break;
  105.     }
  106.   }
  108.   NdbScanFilterImpl::State tmp = m_impl.m_current;
  109.   m_impl.m_stack.push_back(m_impl.m_current);
  110.   m_impl.m_current.m_group = group;
  111.   m_impl.m_current.m_ownLabel = m_impl.m_label++;
  112.   m_impl.m_current.m_popCount = 0;
  113.   
  114.   switch(group){
  115.   case NdbScanFilter::AND:
  116.   case NdbScanFilter::NAND:
  117.     m_impl.m_current.m_falseLabel = m_impl.m_current.m_ownLabel;
  118.     m_impl.m_current.m_trueLabel = tmp.m_trueLabel;
  119.     break;
  120.   case NdbScanFilter::OR:
  121.   case NdbScanFilter::NOR:
  122.     m_impl.m_current.m_falseLabel = tmp.m_falseLabel;
  123.     m_impl.m_current.m_trueLabel = m_impl.m_current.m_ownLabel;
  124.     break;
  125.   default: 
  126.     m_impl.m_operation->setErrorCodeAbort(4260);
  127.     return -1;
  128.   }
  129.   
  130.   return 0;
  131. }
  133. int
  134. NdbScanFilter::end(){
  136.   switch(m_impl.m_current.m_group){
  137.   case NdbScanFilter::AND:
  138.     INT_DEBUG(("End(AND pc=%d)", m_impl.m_current.m_popCount));
  139.     break;
  140.   case NdbScanFilter::OR:
  141.     INT_DEBUG(("End(OR pc=%d)", m_impl.m_current.m_popCount));
  142.     break;
  143.   case NdbScanFilter::NAND:
  144.     INT_DEBUG(("End(NAND pc=%d)", m_impl.m_current.m_popCount));
  145.     break;
  146.   case NdbScanFilter::NOR:
  147.     INT_DEBUG(("End(NOR pc=%d)", m_impl.m_current.m_popCount));
  148.     break;
  149.   }
  151.   if(m_impl.m_current.m_popCount > 0){
  152.     m_impl.m_current.m_popCount--;
  153.     return 0;
  154.   }
  155.   
  156.   NdbScanFilterImpl::State tmp = m_impl.m_current;  
  157.   m_impl.m_current = m_impl.m_stack.back();
  158.   m_impl.m_stack.erase(m_impl.m_stack.size() - 1);
  159.   
  160.   switch(tmp.m_group){
  161.   case NdbScanFilter::AND:
  162.     if(tmp.m_trueLabel == (Uint32)~0){
  163.       m_impl.m_operation->interpret_exit_ok();
  164.     } else {
  165.       m_impl.m_operation->branch_label(tmp.m_trueLabel);
  166.     }
  167.     break;
  168.   case NdbScanFilter::NAND:
  169.     if(tmp.m_trueLabel == (Uint32)~0){
  170.       m_impl.m_operation->interpret_exit_nok();
  171.     } else {
  172.       m_impl.m_operation->branch_label(tmp.m_falseLabel);
  173.     }
  174.     break;
  175.   case NdbScanFilter::OR:
  176.     if(tmp.m_falseLabel == (Uint32)~0){
  177.       m_impl.m_operation->interpret_exit_nok();
  178.     } else {
  179.       m_impl.m_operation->branch_label(tmp.m_falseLabel);
  180.     }
  181.     break;
  182.   case NdbScanFilter::NOR:
  183.     if(tmp.m_falseLabel == (Uint32)~0){
  184.       m_impl.m_operation->interpret_exit_ok();
  185.     } else {
  186.       m_impl.m_operation->branch_label(tmp.m_trueLabel);
  187.     }
  188.     break;
  189.   default:
  190.     m_impl.m_operation->setErrorCodeAbort(4260);
  191.     return -1;
  192.   }
  194.   m_impl.m_operation->def_label(tmp.m_ownLabel);
  196.   if(m_impl.m_stack.size() == 0){
  197.     switch(tmp.m_group){
  198.     case NdbScanFilter::AND:
  199.     case NdbScanFilter::NOR:
  200.       m_impl.m_operation->interpret_exit_nok();
  201.       break;
  202.     case NdbScanFilter::OR:
  203.     case NdbScanFilter::NAND:
  204.       m_impl.m_operation->interpret_exit_ok();
  205.       break;
  206.     default:
  207.       m_impl.m_operation->setErrorCodeAbort(4260);
  208.       return -1;
  209.     }
  210.   }
  211.   
  212.   return 0;
  213. }
  215. int
  216. NdbScanFilter::istrue(){
  217.   if(m_impl.m_current.m_group < NdbScanFilter::AND || 
  218.      m_impl.m_current.m_group > NdbScanFilter::NOR){
  219.     m_impl.m_operation->setErrorCodeAbort(4260);
  220.     return -1;
  221.   }
  223.   if(m_impl.m_current.m_trueLabel == (Uint32)~0){
  224.     return m_impl.m_operation->interpret_exit_ok();
  225.   } else {
  226.     return m_impl.m_operation->branch_label(m_impl.m_current.m_trueLabel);
  227.   }
  228. }
  230. int
  231. NdbScanFilter::isfalse(){
  232.   if(m_impl.m_current.m_group < NdbScanFilter::AND || 
  233.      m_impl.m_current.m_group > NdbScanFilter::NOR){
  234.     m_impl.m_operation->setErrorCodeAbort(4260);
  235.     return -1;
  236.   }
  237.   
  238.   if(m_impl.m_current.m_falseLabel == (Uint32)~0){
  239.     return m_impl.m_operation->interpret_exit_nok();
  240.   } else {
  241.     return m_impl.m_operation->branch_label(m_impl.m_current.m_falseLabel);
  242.   }
  243. }
  246. #define action(x, y, z)
  249. typedef int (NdbOperation:: * Branch1)(Uint32, Uint32 label);
  250. typedef int (NdbOperation:: * Branch2)(Uint32, Uint32, Uint32 label);
  251. typedef int (NdbOperation:: * StrBranch2)(Uint32, const char*,Uint32,bool,Uint32);
  253. struct tab {
  254.   Branch2 m_branches[5];
  255. };
  257. static const tab table[] = {
  258.   /**
  259.    * EQ (AND, OR, NAND, NOR)
  260.    */
  261.   { { 0, 
  262.       &NdbOperation::branch_ne, 
  263.       &NdbOperation::branch_eq, 
  264.       &NdbOperation::branch_eq,  
  265.       &NdbOperation::branch_ne } }
  266.   
  267.   /**
  268.    * NEQ
  269.    */
  270.   ,{ { 0, 
  271.        &NdbOperation::branch_eq, 
  272.        &NdbOperation::branch_ne, 
  273.        &NdbOperation::branch_ne, 
  274.        &NdbOperation::branch_eq } }
  275.   
  276.   /**
  277.    * LT
  278.    */
  279.   ,{ { 0, 
  280.        &NdbOperation::branch_le, 
  281.        &NdbOperation::branch_gt, 
  282.        &NdbOperation::branch_gt,
  283.        &NdbOperation::branch_le } }
  284.   
  285.   /**
  286.    * LE
  287.    */
  288.   ,{ { 0, 
  289.        &NdbOperation::branch_lt, 
  290.        &NdbOperation::branch_ge, 
  291.        &NdbOperation::branch_ge, 
  292.        &NdbOperation::branch_lt } }
  293.   
  294.   /**
  295.    * GT
  296.    */
  297.   ,{ { 0, 
  298.        &NdbOperation::branch_ge, 
  299.        &NdbOperation::branch_lt, 
  300.        &NdbOperation::branch_lt, 
  301.        &NdbOperation::branch_ge } }
  303.   /**
  304.    * GE
  305.    */
  306.   ,{ { 0, 
  307.        &NdbOperation::branch_gt, 
  308.        &NdbOperation::branch_le, 
  309.        &NdbOperation::branch_le, 
  310.        &NdbOperation::branch_gt } }
  311. };
  313. struct tab2 {
  314.   Branch1 m_branches[5];
  315. };
  317. static const tab2 table2[] = {
  318.   /**
  319.    * IS NULL
  320.    */
  321.   { { 0, 
  322.       &NdbOperation::branch_col_ne_null, 
  323.       &NdbOperation::branch_col_eq_null, 
  324.       &NdbOperation::branch_col_eq_null,  
  325.       &NdbOperation::branch_col_ne_null } }
  326.   
  327.   /**
  328.    * IS NOT NULL
  329.    */
  330.   ,{ { 0, 
  331.        &NdbOperation::branch_col_eq_null, 
  332.        &NdbOperation::branch_col_ne_null, 
  333.        &NdbOperation::branch_col_ne_null,  
  334.        &NdbOperation::branch_col_eq_null } }
  335. };
  337. const int tab_sz = sizeof(table)/sizeof(table[0]);
  338. const int tab2_sz = sizeof(table2)/sizeof(table2[0]);
  340. int
  341. matchType(const NdbDictionary::Column * col){
  342.   return 1;
  343. }
  345. template<typename T> int load_const(NdbOperation* op, T value, Uint32 reg);
  347. template<>
  348. int
  349. load_const(NdbOperation* op, Uint32 value, Uint32 reg){
  350.   return op->load_const_u32(reg, value);
  351. }
  353. template<>
  354. int
  355. load_const(NdbOperation* op, Uint64 value, Uint32 reg){
  356.   return op->load_const_u64(reg, value);
  357. }
  359. template<typename T>
  360. int
  361. NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition op, 
  362.   Uint32 AttrId, T value){
  363.   
  364.   if(op < 0 || op >= tab_sz){
  365.     m_operation->setErrorCodeAbort(4262);
  366.     return -1;
  367.   }
  369.   if(m_current.m_group < NdbScanFilter::AND || 
  370.      m_current.m_group > NdbScanFilter::NOR){
  371.     m_operation->setErrorCodeAbort(4260);
  372.     return -1;
  373.   }
  375.   Branch2 branch = table[op].m_branches[m_current.m_group];
  376.   const NdbDictionary::Column * col = 
  377.     m_operation->m_currentTable->getColumn(AttrId);
  378.   
  379.   if(col == 0){
  380.     m_operation->setErrorCodeAbort(4261);
  381.     return -1;
  382.   }
  383.   
  384.   if(!matchType(col)){
  385.     /**
  386.      * Code not reached
  387.      */
  388.     return -1;
  389.   }
  391.   if(m_latestAttrib != AttrId){
  392.     m_operation->read_attr(&NdbColumnImpl::getImpl(* col), 4);
  393.     m_latestAttrib = AttrId;
  394.   }
  395.   
  396.   load_const<T>(m_operation, value, 5);
  397.   (m_operation->* branch)(4, 5, m_current.m_ownLabel);
  399.   return 0;
  400. }
  402. int
  403. NdbScanFilter::eq(int AttrId, Uint32 value){
  404.   return m_impl.cond_col_const(Interpreter::EQ, AttrId, value);
  405. }
  407. int
  408. NdbScanFilter::ne(int AttrId, Uint32 value){
  409.   return m_impl.cond_col_const(Interpreter::NE, AttrId, value);
  410. }
  412. int
  413. NdbScanFilter::lt(int AttrId, Uint32 value){
  414.   return m_impl.cond_col_const(Interpreter::LT, AttrId, value);
  415. }
  417. int
  418. NdbScanFilter::le(int AttrId, Uint32 value){
  419.   return m_impl.cond_col_const(Interpreter::LE, AttrId, value);
  420. }
  422. int
  423. NdbScanFilter::gt(int AttrId, Uint32 value){
  424.   return m_impl.cond_col_const(Interpreter::GT, AttrId, value);
  425. }
  427. int
  428. NdbScanFilter::ge(int AttrId, Uint32 value){
  429.   return m_impl.cond_col_const(Interpreter::GE, AttrId, value);
  430. }
  433. int
  434. NdbScanFilter::eq(int AttrId, Uint64 value){
  435.   return m_impl.cond_col_const(Interpreter::EQ, AttrId, value);
  436. }
  438. int
  439. NdbScanFilter::ne(int AttrId, Uint64 value){
  440.   return m_impl.cond_col_const(Interpreter::NE, AttrId, value);
  441. }
  443. int
  444. NdbScanFilter::lt(int AttrId, Uint64 value){
  445.   return m_impl.cond_col_const(Interpreter::LT, AttrId, value);
  446. }
  448. int
  449. NdbScanFilter::le(int AttrId, Uint64 value){
  450.   return m_impl.cond_col_const(Interpreter::LE, AttrId, value);
  451. }
  453. int
  454. NdbScanFilter::gt(int AttrId, Uint64 value){
  455.   return m_impl.cond_col_const(Interpreter::GT, AttrId, value);
  456. }
  458. int
  459. NdbScanFilter::ge(int AttrId, Uint64 value){
  460.   return m_impl.cond_col_const(Interpreter::GE, AttrId, value);
  461. }
  464. int
  465. NdbScanFilterImpl::cond_col(Interpreter::UnaryCondition op, Uint32 AttrId){
  466.   
  467.   if(op < 0 || op >= tab2_sz){
  468.     m_operation->setErrorCodeAbort(4262);
  469.     return -1;
  470.   }
  471.   
  472.   if(m_current.m_group < NdbScanFilter::AND || 
  473.      m_current.m_group > NdbScanFilter::NOR){
  474.     m_operation->setErrorCodeAbort(4260);
  475.     return -1;
  476.   }
  477.   
  478.   Branch1 branch = table2[op].m_branches[m_current.m_group];
  479.   (m_operation->* branch)(AttrId, m_current.m_ownLabel);
  480.   return 0;
  481. }
  483. int
  484. NdbScanFilter::isnull(int AttrId){
  485.   return m_impl.cond_col(Interpreter::IS_NULL, AttrId);
  486. }
  488. int
  489. NdbScanFilter::isnotnull(int AttrId){
  490.   return m_impl.cond_col(Interpreter::IS_NOT_NULL, AttrId);
  491. }
  493. struct tab3 {
  494.   StrBranch2 m_branches[5];
  495. };
  497. static const tab3 table3[] = {
  498.   /**
  499.    * EQ (AND, OR, NAND, NOR)
  500.    */
  501.   { { 0, 
  502.       &NdbOperation::branch_col_ne, 
  503.       &NdbOperation::branch_col_eq, 
  504.       &NdbOperation::branch_col_ne,  
  505.       &NdbOperation::branch_col_eq } }
  506.   
  507.   /**
  508.    * NEQ
  509.    */
  510.   ,{ { 0, 
  511.        &NdbOperation::branch_col_eq, 
  512.        &NdbOperation::branch_col_ne, 
  513.        &NdbOperation::branch_col_eq, 
  514.        &NdbOperation::branch_col_ne } }
  515.   
  516.   /**
  517.    * LT
  518.    */
  519.   ,{ { 0, 
  520.        &NdbOperation::branch_col_le, 
  521.        &NdbOperation::branch_col_gt, 
  522.        &NdbOperation::branch_col_le,
  523.        &NdbOperation::branch_col_gt } }
  524.   
  525.   /**
  526.    * LE
  527.    */
  528.   ,{ { 0, 
  529.        &NdbOperation::branch_col_lt, 
  530.        &NdbOperation::branch_col_ge, 
  531.        &NdbOperation::branch_col_lt, 
  532.        &NdbOperation::branch_col_ge } }
  533.   
  534.   /**
  535.    * GT
  536.    */
  537.   ,{ { 0, 
  538.        &NdbOperation::branch_col_ge, 
  539.        &NdbOperation::branch_col_lt, 
  540.        &NdbOperation::branch_col_ge, 
  541.        &NdbOperation::branch_col_lt } }
  543.   /**
  544.    * GE
  545.    */
  546.   ,{ { 0, 
  547.        &NdbOperation::branch_col_gt, 
  548.        &NdbOperation::branch_col_le, 
  549.        &NdbOperation::branch_col_gt, 
  550.        &NdbOperation::branch_col_le } }
  552.   /**
  553.    * LIKE
  554.    */
  555.   ,{ { 0, 
  556.        &NdbOperation::branch_col_notlike, 
  557.        &NdbOperation::branch_col_like, 
  558.        &NdbOperation::branch_col_notlike, 
  559.        &NdbOperation::branch_col_like } }
  561.   /**
  562.    * NOT LIKE
  563.    */
  564.   ,{ { 0, 
  565.        &NdbOperation::branch_col_like, 
  566.        &NdbOperation::branch_col_notlike, 
  567.        &NdbOperation::branch_col_like, 
  568.        &NdbOperation::branch_col_notlike } }
  569. };
  571. const int tab3_sz = sizeof(table3)/sizeof(table3[0]);
  574. int
  575. NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition op, 
  576.   Uint32 AttrId, 
  577.   const char * value, Uint32 len, bool nopad){
  578.   if(op < 0 || op >= tab3_sz){
  579.     m_operation->setErrorCodeAbort(4260);
  580.     return -1;
  581.   }
  582.   
  583.   if(m_current.m_group < NdbScanFilter::AND || 
  584.      m_current.m_group > NdbScanFilter::NOR){
  585.     m_operation->setErrorCodeAbort(4260);
  586.     return -1;
  587.   }
  588.   
  589.   StrBranch2 branch = table3[op].m_branches[m_current.m_group];
  590.   const NdbDictionary::Column * col = 
  591.     m_operation->m_currentTable->getColumn(AttrId);
  592.   
  593.   if(col == 0){
  594.     m_operation->setErrorCodeAbort(4261);
  595.     return -1;
  596.   }
  597.   
  598.   (m_operation->* branch)(AttrId, value, len, nopad, m_current.m_ownLabel);
  599.   return 0;
  600. }
  602. int
  603. NdbScanFilter::eq(int ColId, const char * val, Uint32 len, bool nopad){
  604.   return m_impl.cond_col_const(Interpreter::EQ, ColId, val, len, nopad);
  605. }
  607. int
  608. NdbScanFilter::ne(int ColId, const char * val, Uint32 len, bool nopad){
  609.   return m_impl.cond_col_const(Interpreter::NE, ColId, val, len, nopad);
  610. }
  612. int
  613. NdbScanFilter::lt(int ColId, const char * val, Uint32 len, bool nopad){
  614.   return m_impl.cond_col_const(Interpreter::LT, ColId, val, len, nopad);
  615. }
  617. int
  618. NdbScanFilter::le(int ColId, const char * val, Uint32 len, bool nopad){
  619.   return m_impl.cond_col_const(Interpreter::LE, ColId, val, len, nopad);
  620. }
  622. int
  623. NdbScanFilter::gt(int ColId, const char * val, Uint32 len, bool nopad){
  624.   return m_impl.cond_col_const(Interpreter::GT, ColId, val, len, nopad);
  625. }
  627. int
  628. NdbScanFilter::ge(int ColId, const char * val, Uint32 len, bool nopad){
  629.   return m_impl.cond_col_const(Interpreter::GE, ColId, val, len, nopad);
  630. }
  632. int
  633. NdbScanFilter::like(int ColId, const char * val, Uint32 len, bool nopad){
  634.   return m_impl.cond_col_const(Interpreter::LIKE, ColId, val, len, nopad);
  635. }
  637. int
  638. NdbScanFilter::notlike(int ColId, const char * val, Uint32 len, bool nopad){
  639.   return m_impl.cond_col_const(Interpreter::NOT_LIKE, ColId, val, len, nopad);
  640. }
  642. #if 0
  643. int
  644. main(void){
  645.   if(0)
  646.   {
  647.     ndbout << "a > 7 AND b < 9 AND c = 4" << endl;
  648.     NdbScanFilter f(0);
  649.     f.begin(NdbScanFilter::AND);
  650.     f.gt(0, 7);
  651.     f.lt(1, 9);
  652.     f.eq(2, 4);
  653.     f.end();
  654.     ndbout << endl;
  655.   }
  657.   if(0)
  658.   {
  659.     ndbout << "a > 7 OR b < 9 OR c = 4" << endl;
  660.     NdbScanFilter f(0);
  661.     f.begin(NdbScanFilter::OR);
  662.     f.gt(0, 7);
  663.     f.lt(1, 9);
  664.     f.eq(2, 4);
  665.     f.end();
  666.     ndbout << endl;
  667.   }
  669.   if(0)
  670.   {
  671.     ndbout << "a > 7 AND (b < 9 OR c = 4)" << endl;
  672.     NdbScanFilter f(0);
  673.     f.begin(NdbScanFilter::AND);
  674.     f.gt(0, 7);
  675.     f.begin(NdbScanFilter::OR);
  676.     f.lt(1, 9);
  677.     f.eq(2, 4);
  678.     f.end();
  679.     f.end();
  680.     ndbout << endl;
  681.   }
  683.   if(0)
  684.   {
  685.     ndbout << "a > 7 AND (b < 9 AND c = 4)" << endl;
  686.     NdbScanFilter f(0);
  687.     f.begin(NdbScanFilter::AND);
  688.     f.gt(0, 7);
  689.     f.begin(NdbScanFilter::AND);
  690.     f.lt(1, 9);
  691.     f.eq(2, 4);
  692.     f.end();
  693.     f.end();
  694.     ndbout << endl;
  695.   }
  697.   if(0)
  698.   {
  699.     ndbout << "(a > 7 AND b < 9) AND c = 4" << endl;
  700.     NdbScanFilter f(0);
  701.     f.begin(NdbScanFilter::AND);
  702.     f.begin(NdbScanFilter::AND);
  703.     f.gt(0, 7);
  704.     f.lt(1, 9);
  705.     f.end();
  706.     f.eq(2, 4);
  707.     f.end();
  708.     ndbout << endl;
  709.   }
  711.   if(1)
  712.   {
  713.     ndbout << "(a > 7 OR b < 9) AND (c = 4 OR c = 5)" << endl;
  714.     NdbScanFilter f(0);
  715.     f.begin(NdbScanFilter::AND);
  716.     f.begin(NdbScanFilter::OR);
  717.     f.gt(0, 7);
  718.     f.lt(1, 9);
  719.     f.end();
  720.     f.begin(NdbScanFilter::OR);    
  721.     f.eq(2, 4);
  722.     f.eq(2, 5);
  723.     f.end();
  724.     f.end();
  725.     ndbout << endl;
  726.   }
  728.   if(1)
  729.   {
  730.     ndbout << "(a > 7 AND b < 9) OR (c = 4 AND c = 5)" << endl;
  731.     NdbScanFilter f(0);
  732.     f.begin(NdbScanFilter::OR);
  733.     f.begin(NdbScanFilter::AND);
  734.     f.gt(0, 7);
  735.     f.lt(1, 9);
  736.     f.end();
  737.     f.begin(NdbScanFilter::AND);    
  738.     f.eq(2, 4);
  739.     f.eq(2, 5);
  740.     f.end();
  741.     f.end();
  742.     ndbout << endl;
  743.   }
  745.   if(1)
  746.   {
  747.     ndbout << 
  748.       "((a > 7 AND b < 9) OR (c = 4 AND d = 5)) AND " 
  749.       "((e > 6 AND f < 8) OR (g = 2 AND h = 3)) "  << endl;
  750.     NdbScanFilter f(0);
  751.     f.begin(NdbScanFilter::AND);
  752.     f.begin(NdbScanFilter::OR);
  753.     f.begin(NdbScanFilter::AND);
  754.     f.gt(0, 7);
  755.     f.lt(1, 9);
  756.     f.end();
  757.     f.begin(NdbScanFilter::AND);    
  758.     f.eq(2, 4);
  759.     f.eq(3, 5);
  760.     f.end();
  761.     f.end();
  763.     f.begin(NdbScanFilter::OR);
  764.     f.begin(NdbScanFilter::AND);
  765.     f.gt(4, 6);
  766.     f.lt(5, 8);
  767.     f.end();
  768.     f.begin(NdbScanFilter::AND);    
  769.     f.eq(6, 2);
  770.     f.eq(7, 3);
  771.     f.end();
  772.     f.end();
  773.     f.end();
  774.   }
  775.   
  776.   return 0;
  777. }
  778. #endif
  780. template class Vector<NdbScanFilterImpl::State>;
  781. #if __SUNPRO_CC != 0x560
  782. #ifndef _FORTEC_
  783. template int NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition, Uint32 attrId, Uint32);
  784. template int NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition, Uint32 attrId, Uint64);
  785. #endif
  786. #endif