home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bde / snipit.pak / DRVCAPS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-24  |  11.2 KB  |  301 lines
  1. // BDE - (C) Copyright 1995 by Borland International
  2.  
  3. // drvcaps.c
  4. #include "snipit.h"
  5.  
  6. static DBIResult DisplayOptionalParams(pCHAR szDriver);
  7.  
  8. //=====================================================================
  9. //  Function:
  10. //          DriverCaps();
  11. //
  12. //  Description:
  13. //          This example shows how to determine the capabilities of
  14. //          available IDAPI drivers. This includes the table types
  15. //          supported and the fields which those table types support.
  16. //=====================================================================
  17. void
  18. DriverCaps (void)
  19. {
  20.     hDBIDb      hDb;            // Handle to the database
  21.     hDBICur     hDrvCur;        // Handle to the in-memory table
  22.                                 //   containing the driver list
  23.     hDBICur     hTblTypeCur;    // Handle to the in-memory table
  24.                                 //   containing the table-type list
  25.     hDBICur     hFldTypeCur;    // Handle to the in-memory table
  26.                                 //   containing the field-type list
  27.     hDBICur     hIdxTypeCur;    // Handle to the in-memory table
  28.                                 //   containing the index-type list
  29.     DBIResult   rslt;           // Return value from IDAPI functions
  30.     CURProps    TblProps;       // Table properties
  31.     pBYTE       pRecBuf;        // Record buffer
  32.     DBINAME     szDriver;       // String to contain the driver name
  33.     DBIMSG      szTempBuf;      // Temporary buffer for displaying
  34.                                 //   information
  35.     BOOL        bIsBlank;       // Is the field blank?
  36.     DRVType     drvType;        // Driver type information
  37.  
  38.     Screen("*** Driver Capabilities Example ***\r\n");
  39.  
  40.     BREAK_IN_DEBUGGER();
  41.  
  42.     Screen("    Initializing IDAPI...");
  43.     if (InitAndConnect(&hDb) != DBIERR_NONE)
  44.     {                                        
  45.         Screen("\r\n*** End of Example ***");
  46.         return;
  47.     }
  48.  
  49.     Screen("    Setting the database directory...");
  50.     rslt = DbiSetDirectory(hDb, (pCHAR) szTblDirectory);
  51.     ChkRslt(rslt, "SetDirectory");
  52.  
  53.     // Get a list of the drivers which are available to the system
  54.     //   (drivers which are defined in the configuration file).
  55.     rslt = DbiOpenDriverList(&hDrvCur);
  56.     if (ChkRslt(rslt, "OpenDriverList") != DBIERR_NONE)
  57.     {
  58.         CloseDbAndExit(&hDb);
  59.         Screen("\r\n*** End of example ***");
  60.         return;
  61.     }
  62.  
  63.     // Get the size of the record buffer.
  64.     rslt = DbiGetCursorProps(hDrvCur, &TblProps);
  65.     ChkRslt(rslt, "GetProps");
  66.  
  67.     // Allocate space for the record buffer.
  68.     pRecBuf = (pBYTE) malloc(TblProps.iRecBufSize * sizeof(BYTE));
  69.     if (pRecBuf == NULL)
  70.     {
  71.         Screen("    Error - Could not allocate memory");
  72.         rslt = DbiCloseCursor(&hDrvCur);
  73.         ChkRslt(rslt, "CloseCursor");
  74.         CloseDbAndExit(&hDb);
  75.         Screen("\r\n*** End of example ***");
  76.         return;
  77.     }
  78.  
  79.     Screen("    Go to the beginning of the table...");
  80.     rslt = DbiSetToBegin(hDrvCur);
  81.     ChkRslt(rslt, "SetToBegin");
  82.  
  83.     // Iterate through all available drivers in the configuration file.
  84.     while (DbiGetNextRecord(hDrvCur, dbiNOLOCK, pRecBuf, NULL)
  85.            == DBIERR_NONE)
  86.     {
  87.         // Get the name of the driver.
  88.         rslt = DbiGetField(hDrvCur, 1, pRecBuf, (pBYTE) szDriver,
  89.                            &bIsBlank);
  90.         ChkRslt(rslt, "GetField");
  91.  
  92.         // Get the description of the driver.
  93.         rslt = DbiGetDriverDesc(szDriver, &drvType);
  94.         if (ChkRslt(rslt, "GetDriverDesc") != DBIERR_NONE)
  95.         {
  96.             continue;
  97.         }
  98.  
  99.         // Limit driver information to local tables (the edit control
  100.         //   can only hold so much....)
  101.         if (drvType.edrvCat == drvFILE)
  102.         {
  103.             // Skip a line.
  104.             Screen("");
  105.  
  106.             // Display the information about the driver.
  107.             Screen("        Driver Name:                     %s",
  108.                    drvType.szType);
  109.             Screen("        Description:                     %s",
  110.                    drvType.szText);
  111.  
  112.             // Create a string to display depending on the driver category.
  113.             switch(drvType.edrvCat)
  114.             {
  115.                 case drvFILE:
  116.                     strcpy(szTempBuf, "File-based (PDox, dBASE, Text)");
  117.                     break;
  118.                 case drvOTHERSERVER:
  119.                     strcpy(szTempBuf, "Other type of server???");
  120.                     break;
  121.                 case drvSQLBASEDSERVER:
  122.                     strcpy(szTempBuf, "SQL-based server");
  123.                     break;
  124.             }
  125.             Screen("        Category:                        %s", szTempBuf);
  126.             Screen("        Supports true database concepts: %s",
  127.                    drvType.bTrueDb ? "Yes" : "No");
  128.             Screen("        Database type to use:            %s",
  129.                    drvType.szDbType);
  130.             Screen("        Supports multi-user:             %s",
  131.                    drvType.bMultiUser ? "Yes" : "No");
  132.             Screen("        Read only?:                      %s",
  133.                    drvType.bReadWrite ? "No" : "Yes");
  134.             Screen("        Transaction support:             %s",
  135.                    drvType.bTrans ? "Yes" : "No");
  136.             Screen("        Supports pass-through SQL:       %s",
  137.                    drvType.bPassThruSQL ? "Yes" : "No");
  138.             Screen("        Requires explicit login:         %s",
  139.                    drvType.bLogIn ? "Yes" : "No");
  140.             Screen("        Can create a database:           %s",
  141.                    drvType.bCreateDb ? "Yes" : "No");
  142.             Screen("        Can drop a database:             %s",
  143.                    drvType.bDeleteDb ? "Yes" : "No");
  144.             Screen("        Can create a table:              %s",
  145.                    drvType.bCreateTable ? "Yes" : "No");
  146.             Screen("        Can delete a table:              %s",
  147.                   drvType.bDeleteTable ? "Yes" : "No");
  148.             Screen("        Multiple passwords:              %s",
  149.                    drvType.bMultiplePWs ? "Yes" : "No");
  150.  
  151.             // Determine table types that the driver can use.
  152.             rslt = DbiOpenTableTypesList(szDriver, &hTblTypeCur);
  153.             if (ChkRslt(rslt, "OpenTableTypesList") != DBIERR_NONE)
  154.             {
  155.                 continue;
  156.             }
  157.  
  158.             Screen("\r\n    Table types supported by the driver...");
  159.             DisplayInMemoryTable(hTblTypeCur, 0);
  160.  
  161.             rslt = DbiCloseCursor(&hTblTypeCur);
  162.             ChkRslt(rslt, "CloseCursor");
  163.  
  164.             // Determine field types that the driver can use.
  165.             rslt = DbiOpenFieldTypesList(szDriver, NULL, &hFldTypeCur);
  166.             if (ChkRslt(rslt, "OpenFieldTypesList") != DBIERR_NONE)
  167.             {
  168.                 continue;
  169.             }
  170.  
  171.             Screen("\r\n    Field types supported by the driver...");
  172.             DisplayInMemoryTable(hFldTypeCur, 0);
  173.  
  174.             rslt = DbiCloseCursor(&hFldTypeCur);
  175.             ChkRslt(rslt, "CloseCursor");
  176.  
  177.             // Determine index types that the driver can use.
  178.             rslt = DbiOpenIndexTypesList(szDriver, &hIdxTypeCur);
  179.             if (ChkRslt(rslt, "OpenTableTypesList") != DBIERR_NONE)
  180.             {
  181.                 continue;
  182.             }
  183.  
  184.             Screen("\r\n    Display the index types that the driver"
  185.                    " supports...");
  186.             DisplayInMemoryTable(hIdxTypeCur, 0);
  187.  
  188.             rslt = DbiCloseCursor(&hIdxTypeCur);
  189.             ChkRslt(rslt, "CloseCursor");
  190.  
  191.             Screen("\r\n    Optional parameters....\r\n");
  192.             DisplayOptionalParams (drvType.szType);
  193.         }
  194.     }
  195.  
  196.     free(pRecBuf);
  197.  
  198.     rslt = DbiCloseCursor(&hDrvCur);
  199.     ChkRslt(rslt, "CloseCursor");
  200.  
  201.     Screen("\r\n    Close the database and exit IDAPI...");
  202.     CloseDbAndExit(&hDb);
  203.  
  204.     Screen("\r\n*** End of Example ***");
  205. }
  206.  
  207. //=====================================================================
  208. //  Function:
  209. //          DisplayOptionalParams (pCHAR szDriver)
  210. //
  211. //  Input:  szDriver    - Name of the driver
  212. //
  213. //  Return: DBIResult   - Result of the operation
  214. //
  215. //  Description:
  216. //          This function is used to display the optional parameters
  217. //          for a given driver. 
  218. //=====================================================================
  219. DBIResult
  220. DisplayOptionalParams (pCHAR szDriver)
  221. {
  222.     DBIResult   rslt;           // Return value from IDAPI functions
  223.     hDBICur     hCur;           // Handle to the cursor
  224.     pCHAR       szNode;         // String which contains the name of the
  225.                                 //   node
  226.     pCFGDesc    CfgDesc;        // Configuration descriptor
  227.     DBIPATH     szCfgPath;      // Maximum length of the path in the
  228.                                 //   configuration file
  229.     pCHAR       szFieldNames;   // String to contain the field names
  230.     pCHAR       szFieldValues;  // String to contain the field values
  231.  
  232.     // Set up the option to get from the configuration file.
  233.     strcpy(szCfgPath, "\\");
  234.     strcat(szCfgPath, szCFGDRIVER);
  235.     strcat(szCfgPath, "\\");
  236.     strcat(szCfgPath, szDriver);
  237.     strcat(szCfgPath, "\\");
  238.     strcat(szCfgPath, szCFGTBLCREATE);
  239.     strcat(szCfgPath, "\\");
  240.  
  241.     // Open the configuration file - returns the configuration options
  242.     //   for the current level in a schema table referenced by hCur.
  243.     rslt = DbiOpenCfgInfoList(NULL, dbiREADONLY, cfgPersistent,
  244.                               szCfgPath, &hCur);
  245.     if (ChkRslt(rslt, "OpenCfgInfoList") != DBIERR_NONE)
  246.     {
  247.         return rslt;
  248.     }
  249.  
  250.     // Allocate resources.
  251.     szNode = (pCHAR) malloc(DBIMAXPATHLEN * sizeof(CHAR) + 1);
  252.     szFieldNames = (pCHAR) malloc(DBIMAXSCRECSIZE * sizeof(CHAR) + 1);
  253.     szFieldValues = (pCHAR) malloc(DBIMAXSCRECSIZE * sizeof(CHAR) + 1);
  254.     CfgDesc = (pCFGDesc) malloc(sizeof(CFGDesc));
  255.     if ((szNode == NULL) || (szFieldNames == NULL) || (szFieldValues == NULL)
  256.         || (CfgDesc == NULL))
  257.     {
  258.         if (szNode) free(szNode);
  259.         if (szFieldNames) free(szFieldNames);
  260.         if (szFieldValues) free(szFieldValues);
  261.         if (CfgDesc) free((pCHAR)CfgDesc);
  262.         rslt = DbiCloseCursor(&hCur);
  263.         ChkRslt(rslt, "CloseCursor");
  264.         return DBIERR_NOMEMORY;
  265.     }                      
  266.  
  267.     // Set the spacing.
  268.     strcpy(szFieldNames, "    ");
  269.     strcpy(szFieldValues, "    ");
  270.  
  271.     // Process all nodes.
  272.     //   Get the next record in the table - contains the next option
  273.     //   of the given level in the tree.
  274.     while (DbiGetNextRecord(hCur, dbiNOLOCK, (pBYTE)CfgDesc, NULL)
  275.            == DBIERR_NONE)
  276.     {
  277.         // Output this node, copying the name of the node to the
  278.         //   szNode variable.
  279.         sprintf(szNode, "%-16s\t", CfgDesc->szNodeName);
  280.         strcat(szFieldNames, szNode);
  281.  
  282.         sprintf(szNode, " %-16s\t", CfgDesc->szValue);
  283.         strcat(szFieldValues, szNode);
  284.     }
  285.  
  286.     // Display the field names and values.
  287.     Screen(szFieldNames);
  288.     Screen(szFieldValues);
  289.  
  290.     // Clean up.
  291.     free(szNode);
  292.     free(szFieldNames);
  293.     free(szFieldValues);
  294.     free((pCHAR) CfgDesc);
  295.     rslt = DbiCloseCursor(&hCur);
  296.     ChkRslt(rslt, "CloseCursor");
  297.  
  298.     return rslt;
  299. }
  300.  
  301.