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