home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / 32snipit.pak / FILTCOMP.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  9KB  |  227 lines
  1. // BDE32 3.x - (C) Copyright 1996 by Borland International
  2.  
  3. // FiltComp.c
  4. #include "snipit.h"
  5.  
  6. static const char szTblName[] = "customer";
  7. static const char szTblType[] = szPARADOX;
  8. static const CHAR szField[] = "NAME";
  9. static const CHAR szConst[] = "OCEAN";
  10.  
  11. //==============================================================
  12. //  Function:
  13. //          FiltComp();
  14. //
  15. //  Description:
  16. //          This example shows how to use filters to limit the
  17. //          result set of a table. Specifically, this example
  18. //          does a comparison of the first N digits of a character
  19. //          field. Filters perform a function similar to that of
  20. //          ranges, but more powerful operations are supported.
  21. //==============================================================
  22. void
  23. FiltComp (void)
  24. {
  25.     hDBIDb          hDb = 0;            // Handle to the database.
  26.     hDBICur         hCur = 0;           // Handle to the table.
  27.     DBIResult       rslt;               // Value returned from IDAPI functions
  28.     pBYTE           pcanExpr;           // Structure containing
  29.                                         //   filter info.
  30.     hDBIFilter      hFilter;            // Filter handle.
  31.     UINT16          uSizeNodes;         // Size of the nodes in the
  32.                                         //   tree.
  33.     UINT16          uSizeCanExpr;       // Size of the header
  34.                                         //   information.
  35.     UINT32          uSizeLiterals;      // Size of the literals.
  36.     UINT32          uTotalSize;         // Total size of the filter
  37.                                         //   expression.
  38.     UINT32          uNumRecs  = 10;     // Number of records to
  39.                                         //   display.
  40.     CANExpr         canExp;             // Contains the header
  41.                                         //   information.
  42.     struct {
  43.        CANCompare CompareNode;
  44.        CANField  FieldNode;
  45.        CANConst  ConstantNode;
  46.     } Nodes = {                         // Nodes of the filter tree.
  47.     {
  48.         // Offset 0
  49.         nodeCOMPARE,    // canCompare.nodeClass
  50.         canEQ,          // canCompare.canOp
  51.         1,              // canCompare.bCaseInsensitive
  52.         5,              // canCompare.iParialLen (0 if
  53.                         //   full length)
  54.         sizeof(Nodes.CompareNode),             // canBinary.iOperand1
  55.         sizeof(Nodes.CompareNode) + sizeof(Nodes.FieldNode),
  56.                                 // canBinary.iOperand2
  57.     },               //   Offsets in the Nodes array
  58.     {
  59.         // Offset sizeof(Nodes.CompareNode)
  60.         nodeFIELD,      // canField.nodeClass
  61.         canFIELD,       // canField.canOp
  62.         2,              // canField.iFieldNum
  63.         0,              // canField.iNameOffset: szField
  64.     },               //   is the literal at offset 0
  65.     {
  66.         // Offset sizeof(Nodes.CompareNode) + sizeof(Nodes.FieldNode)
  67.         nodeCONST,      // canConst.nodeClass
  68.         canCONST,       // canConst.canOp
  69.         fldZSTRING,     // canConst.iType
  70.         6,              // canConst.iSize strlen("OCEAN") + 1
  71.         5               // canConst.iOffset: szConst is
  72.                                //   the literal at offset
  73.     }};                //   strlen(szField) + 1
  74.  
  75.     Screen("*** Compare Filter Example ***\r\n");
  76.  
  77.     BREAK_IN_DEBUGGER();
  78.  
  79.     Screen("    Initializing IDAPI...");
  80.     if (InitAndConnect(&hDb) != DBIERR_NONE)
  81.     {
  82.         Screen("\r\n*** End of Example ***");
  83.         return;
  84.     }
  85.  
  86.     Screen("    Setting the database directory...");
  87.     rslt = DbiSetDirectory(hDb, (pCHAR)szTblDirectory);
  88.     ChkRslt(rslt, "SetDirectory");
  89.  
  90.     Screen("    Open the %s table...", szTblName);
  91.     rslt = DbiOpenTable(hDb, (pCHAR)szTblName, (pCHAR)szTblType, NULL, NULL, 0,
  92.                         dbiREADWRITE, dbiOPENSHARED, xltFIELD, FALSE, NULL,
  93.                         &hCur);
  94.     if (ChkRslt(rslt, "OpenTable") != DBIERR_NONE)
  95.     {
  96.         CloseDbAndExit(&hDb);
  97.         Screen("\r\n*** End of Example ***");
  98.         return;
  99.     }
  100.  
  101.     // Go to the beginning of the table
  102.     rslt = DbiSetToBegin(hCur);
  103.     ChkRslt(rslt, "SetToBegin");
  104.  
  105.     Screen("\r\n    Display the %s table...", szTblName);
  106.     DisplayTable(hCur, uNumRecs);
  107.  
  108.     uSizeNodes      = sizeof(Nodes);   // Size of the nodes.
  109.     // Size of the literals.
  110.     uSizeLiterals   = strlen(szField) + 1 + strlen(szConst) + 1;
  111.  
  112.     // Size of the header information.
  113.     uSizeCanExpr    = sizeof(CANExpr);
  114.     // Total size of the filter.
  115.     uTotalSize      = uSizeCanExpr + uSizeNodes + uSizeLiterals;
  116.  
  117.     // Initialize the header information
  118.     canExp.iVer = 1;                         // Version.
  119.     canExp.iTotalSize = (UINT16)uTotalSize;  // Total size of the filter.
  120.     canExp.iNodes = 3;                       // Number of nodes.
  121.     canExp.iNodeStart = uSizeCanExpr;        // The offset in the
  122.                                              //   buffer where the
  123.                                              //   expression nodes
  124.                                              //   start.
  125.  
  126.     // The offset in the buffer where the literals start.
  127.     //    uSizeCanExprNodes = uSizeCanExpr + uSizeNodes;
  128.     //    canExp.iLiteralStart = (UINT16)uSizeCanExprNodes;
  129.     canExp.iLiteralStart = (UINT16)(uSizeCanExpr + uSizeNodes);
  130.  
  131.     // Allocate contiguous memory space to hold
  132.     // 1) Header information  i.e. the CANExpr structure
  133.     // 2) Compare, field and constant nodes  i.e. the Nodes structure
  134.     // 3) Literal and constant pool  i.e. field names and constant values
  135.     pcanExpr = (pBYTE)malloc(uTotalSize * sizeof(BYTE));
  136.     if (pcanExpr == NULL)
  137.     {
  138.         Screen("    Could not allocate memory...");
  139.         DbiCloseCursor(&hCur);
  140.         CloseDbAndExit(&hDb);
  141.         Screen("\r\n*** End of Example ***");
  142.         return;
  143.     }
  144.  
  145.     // Initialize the filter expression by placing header, nodes and
  146.     // pool into pcanexpr
  147.  
  148.     // Move header information into pcanexpr. pcanExpr will now look as follows:
  149.     // **canExp**|                 |                        |
  150.     // | CANExpr |    All Nodes    | Literal, Constant Pool |
  151.     // |----------------------------------------------------|
  152.     // 0                                                    sizeof(uTotalSize)
  153.     memmove(pcanExpr, &canExp, uSizeCanExpr);
  154.  
  155.     // Move node structure into pcanexpr.  pcanExpr will now look as follows:
  156.     // |**canExp*|**Node Structure*|                        |
  157.     // | CANExpr |    All Nodes    | Literal, Constant Pool |
  158.     // |----------------------------------------------------|
  159.     // 0                                                    sizeof(uTotalSize)
  160.     memmove(&pcanExpr[uSizeCanExpr], &Nodes, uSizeNodes);
  161.  
  162.     // Move the literal into pcanexpr.  pcanExpr will now look as follows:
  163.     // |**canExp*|**Node Structure*|***szField              |
  164.     // | CANExpr |    All Nodes    | Literal, Constant Pool |
  165.     // |----------------------------------------------------|
  166.     // 0                                                    sizeof(uTotalSize)
  167.     memmove(&pcanExpr[uSizeCanExpr + uSizeNodes],
  168.             szField, strlen(szField) + 1); // First literal "NAME"
  169.  
  170.     // Move the literal into pcanexpr.  pcanExpr will now look as follows:
  171.     // |**canExp*|**Node Structure*|***szField*****fConst***|
  172.     // | CANExpr |    All Nodes    | Literal, Constant Pool |
  173.     // |----------------------------------------------------|
  174.     // 0                                                    sizeof(uTotalSize)
  175.     memmove(&pcanExpr[uSizeCanExpr + uSizeNodes + strlen(szField) + 1],
  176.             szConst, strlen(szConst) + 1); // Second literal "OCEAN"
  177.  
  178.     rslt = DbiSetToBegin(hCur);
  179.     ChkRslt(rslt, "SetToBegin");
  180.  
  181.     Screen("\r\n    Add a filter to the %s table which will"
  182.            " limit the records\r\n        which are displayed"
  183.            " to those whose %s field starts with '%s'...",
  184.            szTblName, szField, szConst);
  185.     rslt = DbiAddFilter(hCur, 0L, 1, FALSE, (pCANExpr)pcanExpr, NULL, &hFilter);
  186.     if (ChkRslt(rslt, "AddFilter") != DBIERR_NONE)
  187.     {
  188.         rslt = DbiCloseCursor(&hCur);
  189.         ChkRslt(rslt, "CloseCursor");
  190.         free(pcanExpr);
  191.         CloseDbAndExit(&hDb);
  192.         Screen("\r\n*** End of Example ***");
  193.         return;
  194.     }
  195.  
  196.     // Activate the filter.
  197.     Screen("    Activate the filter on the %s table...",
  198.            szTblName);
  199.     rslt = DbiActivateFilter(hCur, hFilter);
  200.     ChkRslt(rslt, "ActivateFilter");
  201.  
  202.     rslt = DbiSetToBegin(hCur);
  203.     ChkRslt(rslt, "SetToBegin");
  204.  
  205.     Screen("\r\n    Display the %s table with the filter"
  206.            " set...", szTblName);
  207.     DisplayTable(hCur, uNumRecs);
  208.  
  209.     Screen("\r\n    Deactivate the filter...");
  210.     rslt = DbiDeactivateFilter(hCur, hFilter);
  211.     ChkRslt(rslt, "DeactivateFilter");
  212.  
  213.     Screen("\r\n    Drop the filter...");
  214.     rslt = DbiDropFilter(hCur, hFilter);
  215.     ChkRslt(rslt, "DropFilter");
  216.  
  217.     rslt = DbiCloseCursor(&hCur);
  218.     ChkRslt(rslt, "CloseCursor");
  219.  
  220.     free(pcanExpr);
  221.  
  222.     Screen("    Close the database and exit IDAPI...");
  223.     CloseDbAndExit(&hDb);
  224.  
  225.     Screen("\r\n*** End of Example ***");
  226. }
  227.