home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / 32SNIPIT.PAK / OPTPARAM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  11.1 KB  |  305 lines
  1. // BDE32 3.x - (C) Copyright 1996 by Borland International
  2.  
  3. // optparam.c
  4. #include "snipit.h"
  5.  
  6. static const char szTblName[] = "OPTPARAM";
  7. static const char szTblType[] = szPARADOX;
  8.  
  9. #define NAMELEN  10 // Length of the name field
  10.  
  11. // Field descriptor used in creating a table.
  12. static SNIPFAR FLDDesc fldDesc[] = {
  13.               { // Field 1 - AUTOINC
  14.                 1,            // Field number
  15.                 "NUMBER",     // Field name
  16.                 fldFLOAT,     // Field type
  17.                 fldUNKNOWN,   // Field subtype
  18.                 0,            // Field size ( 1 or 0, except
  19.                               //     BLOb or CHAR field )
  20.                 0,            // Decimal places ( 0 )
  21.                               //     computed
  22.                 0,            // Offset in record ( 0 )
  23.                 0,            // Length in bytes  ( 0 )
  24.                 0,            // For Null bits    ( 0 )
  25.                 fldvNOCHECKS, // Validity checks   ( 0 )
  26.                 fldrREADWRITE // Rights
  27.               },
  28.               { // Field 2 - ALPHA
  29.                 2, "ALPHA", fldZSTRING, fldUNKNOWN,
  30.                 NAMELEN, 0, 0, 0, 0,
  31.                 fldvNOCHECKS, fldrREADWRITE
  32.               }
  33.             }; // Array of field descriptors
  34.  
  35. // The number of fields in the table.
  36. static const UINT16 uNumFields = sizeof(fldDesc) / sizeof (fldDesc[0]);
  37.  
  38. static DBIResult GetOptionalParams(pCHAR szDriver, UINT16 *iFields,
  39.                                    pFLDDesc pfldDesc, pCHAR szData);
  40.  
  41. //=====================================================================
  42. //  Function:
  43. //          OptParam();
  44. //
  45. //  Description:
  46. //          This function shows how to use the optional parameters
  47. //          on some of the BDE functions.
  48. //=====================================================================
  49. void
  50. OptParam (void)   
  51. {
  52.     hDBIDb      hDb;                // Handle to the database
  53.     hDBICur     hCur;               // Handle to the table
  54.     CRTblDesc   TblDesc;            // Create table descriptor
  55.     UINT16      uDispNumRecs = 10 ; // Number of records to add and
  56.                                     // display.
  57.     CURProps    curProps;           // Cursor Properties
  58.   
  59.     pFLDDesc    pfldDesc;           // Field Descriptor for Opt Params
  60.     UINT16      iFields;            // Number of fields (Opt params)
  61.     UINT16      i;                  // Loop counter
  62.     UINT16      iOffset;            // Offset in the default values buffer
  63.     CHAR        szFieldName[DBIMAXSCRECSIZE];   // Field name
  64.     CHAR        szDefault[DBIMAXSCRECSIZE];     // Default values for Opt
  65.                                                 // params
  66.     pCHAR       szTemp;                         // Temporary Buffer
  67.     pCHAR       szData;                         // Data to display
  68.     DBIResult   rslt;                           // Return value from IDAPI
  69.                                                 //   functions
  70.  
  71.     Screen("*** Using Optional Parameters ***\r\n");
  72.  
  73.     BREAK_IN_DEBUGGER();
  74.  
  75.     Screen("    Initializing IDAPI...");
  76.     if (InitAndConnect(&hDb) != DBIERR_NONE)
  77.     {
  78.         Screen("\r\n*** End of Example ***");
  79.         return;
  80.     }
  81.  
  82.     Screen("    Setting the database directory...");
  83.     rslt = DbiSetDirectory(hDb, (pCHAR) szTblDirectory);
  84.     ChkRslt(rslt, "SetDirectory");
  85.  
  86.     // Initialize the TblDesc variable to all zeroes
  87.     memset((void *) &TblDesc , 0, sizeof(CRTblDesc));
  88.  
  89.     szTemp = (pCHAR) malloc(DBIMAXSCFLDLEN);
  90.     szData = (pCHAR) malloc(DBIMAXSCRECSIZE);
  91.     pfldDesc = (pFLDDesc) malloc(DBIMAXSCFIELDS * sizeof(FLDDesc));
  92.  
  93.     // Initialize the TblDesc variable to all zeroes
  94.     memset((void*) pfldDesc , 0, sizeof(FLDDesc) * DBIMAXSCFIELDS);
  95.  
  96.     // Get the field types and default values of the optional
  97.     // parameters available when creating a Paradox table
  98.     GetOptionalParams("PARADOX", &iFields, pfldDesc, szData);
  99.  
  100.     Screen("\r\n    Default values for optional parameters...\r\n");
  101.     strcpy(szFieldName, "    ");
  102.     strcpy(szDefault, "    ");
  103.     iOffset = 0;
  104.     for (i = 0; i < iFields; i++)
  105.     {
  106.         // Note: Fields are formatted to be 20 characters wide
  107.         // in order to better fit on the screen (Field widths
  108.         // default to 128).
  109.         sprintf(szTemp, "%-*s\t", 20, pfldDesc[i].szName);
  110.         strcat(szFieldName, szTemp);
  111.         sprintf(szTemp, " %-*s\t", 20, &szData[iOffset]);
  112.         strcat(szDefault, szTemp);
  113.  
  114.         // Create the table as a 3.5 table.
  115.         if (! strcmp(pfldDesc[i].szName, "LEVEL"))
  116.         {
  117.             strcpy(&szData[iOffset], "3");
  118.         }
  119.  
  120.         // Set the maximum size of the table to 256MB
  121.         if (! strcmp(pfldDesc[i].szName, "BLOCK SIZE"))
  122.         {
  123.             strcpy(&szData[iOffset], "4096");
  124.         }
  125.  
  126.         // Increment to point to the next field within the
  127.         // array of default values.
  128.         iOffset += pfldDesc[i].iLen;
  129.     }
  130.  
  131.     Screen(szFieldName);
  132.     Screen(szDefault);
  133.  
  134.     Screen("\r\n    Change optional parameters to...\r\n");
  135.     strcpy(szFieldName, "    ");
  136.     strcpy(szDefault, "    ");
  137.     iOffset = 0;
  138.     for (i = 0; i < iFields; i++)
  139.     {
  140.         // Note: Fields are formatted to be 20 characters wide
  141.         // in order to better fit on the screen (field widths
  142.         // default to 128).
  143.         sprintf(szTemp, "%-*s\t", 20, pfldDesc[i].szName);
  144.         strcat(szFieldName, szTemp);
  145.         sprintf(szTemp, " %-*s\t", 20, &szData[iOffset]);
  146.         strcat(szDefault, szTemp);
  147.  
  148.         // Increment to point to the next field within the
  149.         // array of default values.
  150.         iOffset += pfldDesc[i].iLen;
  151.     }
  152.  
  153.     Screen(szFieldName);
  154.     Screen(szDefault);
  155.  
  156.     Screen("\r\n    Initializing the table descriptor...");
  157.     lstrcpy(TblDesc.szTblName, szTblName);
  158.     lstrcpy(TblDesc.szTblType, szTblType);
  159.  
  160.     TblDesc.iFldCount = (UINT16)uNumFields;
  161.     TblDesc.pfldDesc = fldDesc;
  162.  
  163.     TblDesc.iOptParams = iFields;
  164.     TblDesc.pfldOptParams = pfldDesc;
  165.     TblDesc.pOptData = (pBYTE) szData;
  166.  
  167.     Screen("\r\n    Creating the Paradox table...");
  168.     rslt = DbiCreateTable(hDb, TRUE, &TblDesc);
  169.     if (ChkRslt(rslt, "CreateTable") != DBIERR_NONE)
  170.     {
  171.         free(szTemp);
  172.         free(szData);
  173.         free(pfldDesc);
  174.         CloseDbAndExit(&hDb);
  175.         Screen("\r\n*** End of Example ***");
  176.         return;
  177.     }
  178.  
  179.     free(pfldDesc);
  180.  
  181.     Screen("    Fill the table with random data...");
  182.     FillTable(hDb, (pCHAR) szTblName, (pCHAR) szTblType, uDispNumRecs);
  183.  
  184.     Screen("    Open the %s table...", szTblName);
  185.     rslt = DbiOpenTable(hDb, (pCHAR) szTblName, (pCHAR) szTblType,
  186.                         NULL, NULL, 0, dbiREADWRITE, dbiOPENSHARED,
  187.                         xltFIELD, FALSE, NULL, &hCur);
  188.     if (ChkRslt(rslt, "OpenTable") != DBIERR_NONE)
  189.     {
  190.         rslt = DbiDeleteTable(hDb, (pCHAR) szTblName, (pCHAR) szTblType);
  191.         ChkRslt(rslt, "DeleteTable");
  192.         CloseDbAndExit(&hDb);
  193.         Screen("\r\n*** End of Example ***");
  194.         return;
  195.     }
  196.  
  197.     Screen("\r\n    Determine the properties of the table:");
  198.     rslt = DbiGetCursorProps(hCur, &curProps);
  199.     ChkRslt(rslt, "GetCursorProps");
  200.  
  201.     Screen("        Table Level:      %d", curProps.iTblLevel);
  202.     Screen("        Table block size: %d", (curProps.iBlockSize * 1024));
  203.  
  204.     Screen("\r\n    Display the %s table which we just created...", szTblName);
  205.     DisplayTable(hCur, uDispNumRecs);
  206.                                  
  207.     Screen("\r\n    Close the table...");
  208.     rslt = DbiCloseCursor(&hCur);
  209.     ChkRslt(rslt, "CloseCursor");
  210.  
  211.     Screen("    Deleting the table...");
  212.     rslt = DbiDeleteTable(hDb, (pCHAR) szTblName, (pCHAR) szTblType);
  213.     ChkRslt(rslt, "DeleteTable");
  214.  
  215.     Screen("\r\n    Close the database and exit IDAPI...");
  216.     CloseDbAndExit(&hDb);
  217.  
  218.     free(szTemp);
  219.     free(szData);
  220.     Screen("\r\n*** End of Example ***");
  221. }
  222.  
  223. //=====================================================================
  224. //  Function:
  225. //          GetOptionalParams(pCHAR szDriver, UINT16 *iFields,
  226. //                            pFLDDesc pfldDesc, pCHAR szData);
  227. //
  228. //  Input:  szDriver    - Name of the driver
  229. //          iFields     - Used to return the number of fields
  230. //          pfldDesc    - Returns the descriptors of the fields.
  231. //                          Memory for this variable must be allocated by
  232. //                          the calling function.
  233. //          szData      - Contains the values of the fields.  Memory for
  234. //                          this variable must be allocated by the calling
  235. //                          function.
  236. //
  237. //  Return: DBIResult - success of the function
  238. //
  239. //  Description:
  240. //          This function is used to return the available optional
  241. //          parameters when creating a table of the given type. This
  242. //          information includes the number of optional parameters
  243. //          (iFields), an array of field descriptors describing those
  244. //          parameters, and the default values for the parameters.
  245. //          Optional parameters are available only for dBASE and
  246. //          Paradox tables.
  247. //=====================================================================
  248. DBIResult                         
  249. GetOptionalParams(pCHAR szDriver, UINT16 *iFields,
  250.                   pFLDDesc pfldDesc, pCHAR szData)
  251. {
  252.     DBIResult   rslt;       // Return value from IDAPI functions
  253.     hDBICur     hCur;       // Handle to the cursor
  254.     pCHAR       szNode;     // String which contains the name of the node
  255.     pCFGDesc    CfgDesc;    // Configuration descriptor
  256.     DBIPATH     szCfgPath;  // Maximum length of the path
  257.                             // in the configuration file.
  258.     UINT16      iOffset = 0;
  259.  
  260.     *iFields = 0;
  261.  
  262.     // Set up the option to get from the configuration file
  263.     strcpy(szCfgPath, "\\DRIVERS\\");
  264.     strcat(szCfgPath, szDriver);
  265.     strcat(szCfgPath, "\\TABLE CREATE");
  266.  
  267.     rslt = DbiOpenCfgInfoList(NULL, dbiREADONLY, cfgPersistent, szCfgPath,
  268.                               &hCur);
  269.     if (ChkRslt(rslt, "OpenCfgInfoList") != DBIERR_NONE)
  270.     {
  271.         return rslt;
  272.     }
  273.  
  274.     // Allocate resources
  275.     szNode = (pCHAR) malloc((DBIMAXPATHLEN * sizeof(CHAR)) + 1);
  276.     CfgDesc = (pCFGDesc) malloc(sizeof(CFGDesc));
  277.  
  278.     // Process all nodes
  279.     // Get the next record in the table - contains the next option
  280.     // of the given level in the tree.
  281.     while (DbiGetNextRecord(hCur, dbiNOLOCK, (pBYTE)CfgDesc, NULL)
  282.            == DBIERR_NONE)
  283.     {
  284.         pfldDesc[*iFields].iFldNum = (UINT16)(*iFields + 1);
  285.         pfldDesc[*iFields].iFldType = CfgDesc->iDataType;
  286.         pfldDesc[*iFields].iUnits1 = DBIMAXSCFLDLEN - 1;
  287.         pfldDesc[*iFields].iLen = DBIMAXSCFLDLEN;
  288.         strcpy(pfldDesc[*iFields].szName, CfgDesc->szNodeName);
  289.  
  290.         sprintf(szNode, "%s", CfgDesc->szValue);
  291.         strcpy(&szData[iOffset], szNode);
  292.         iOffset += pfldDesc[*iFields].iLen;
  293.         (*iFields)++;
  294.     }
  295.  
  296.     // Clean up
  297.     free(szNode);
  298.     free((pCHAR) CfgDesc);
  299.     rslt = DbiCloseCursor(&hCur);
  300.     ChkRslt(rslt, "CloseCursor");
  301.  
  302.     return rslt;
  303. }
  304.  
  305.