home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 May / PCWorld_1999-05_cd.bin / software / Vyzkuste / inprise / INTRBASE_55 / EXAMPLES / API / API16.C < prev    next >
C/C++ Source or Header  |  1998-10-18  |  6KB  |  224 lines
  1. /********************************************************************8
  2. **
  3. **    Program type:         API
  4. **
  5. **    Description:    This program does an asynchronous event wait
  6. **            on a trigger set up in employee.sales.  
  7. **            Somebody must add a new sales order to alert
  8. **            this program.  That role can be accomplished 
  9. **            by running programs stat12t or api16t at the
  10. **            same time.
  11. **    
  12. **            When the event is fired, this program selects
  13. **            back any new records and updates (current) those
  14. **            records to status "open".  The entire program runs
  15. **            in a single read-committed (wait, no version) 
  16. **            transaction, so transaction doesn't need to be started
  17. **            after an event.
  18. */
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include <stdio.h>
  22. #include "example.h"
  23. #include <ibase.h>
  24.  
  25.  
  26. /*  Sleep for Windows is a stupid loop with I/O */
  27. #if defined  __BORLANDC__ || defined _MSC_VER
  28. #include <windows.h>
  29. #define SLEEP(x)    Sleep(x * 1000 )
  30. #else
  31. #define SLEEP(x)     sleep(x)
  32. #endif
  33.  
  34. short             event_flag = 0;
  35. isc_callback     ast_routine PROTO((char ISC_FAR *, short, char ISC_FAR *));
  36.  
  37. int main(ARG(int, argc), ARG(char **, argv))
  38. ARGLIST(int argc)
  39. ARGLIST(char **argv)
  40.  
  41. {
  42.     isc_db_handle    DB = NULL;      /* database handle */
  43.     isc_tr_handle     trans = NULL;     /* transaction handle */
  44.     isc_stmt_handle stmt = NULL;     /* transaction handle */
  45.     long        status[20];    /* status vector */
  46.     char ISC_FAR *    event_buffer; 
  47.     char ISC_FAR *    result_buffer;
  48.     long        event_id;
  49.     short        length;
  50.     char        dbname[128];
  51.     char        po_number[9];
  52.     XSQLDA ISC_FAR * sqlda;
  53.     short        nullind = 0;
  54.     char        query[128], update[128];
  55.     long        count[2], i = 0;
  56.     unsigned long    Vector[20];
  57.     char        ids[2][15];
  58.         int             first = 1;
  59.     int         ret = 0;
  60.     /* Transaction parameter block for read committed */
  61.     static char      isc_tpb[5] = {isc_tpb_version1,
  62.                       isc_tpb_write,
  63.                       isc_tpb_read_committed,
  64.                       isc_tpb_wait,
  65.                       isc_tpb_no_rec_version};
  66.     if (argc > 1)
  67.                 strcpy(dbname, argv[1]);
  68.         else
  69.         strcpy(dbname, "employee.gdb");
  70.  
  71.  
  72.     strcpy (ids[0], "new_order");
  73.     strcpy (ids[1], "change_order");
  74.     count[0] = 0;
  75.     count[1] = 0;
  76.  
  77.     sqlda = (XSQLDA ISC_FAR *) malloc(XSQLDA_LENGTH(1));
  78.     sqlda->sqln = 1;
  79.     sqlda->version = 1;
  80.     sqlda->sqlvar[0].sqldata = po_number;
  81.     sqlda->sqlvar[0].sqlind = &nullind;
  82.  
  83.     if (isc_attach_database (status, 0, dbname, &DB, 0, NULL))
  84.         {ERREXIT(status, 1)};
  85.  
  86.     /* SET TRANSACTION ISOLATION LEVEL READ COMMITTED */
  87.     if (isc_start_transaction (status, &trans, 1, &DB, 5, isc_tpb))
  88.         {ERREXIT(status, 1)};
  89.  
  90.     /* Prepare the query to look at the result tables */
  91.     strcpy(query, " SELECT po_number FROM sales \
  92.         WHERE order_status = 'new'  FOR UPDATE");
  93.  
  94.     /* This is for the update where current of */
  95.     strcpy(update, 
  96.         "UPDATE sales SET order_status = 'open' WHERE CURRENT OF C");
  97.     isc_dsql_allocate_statement(status, &DB, &stmt);
  98.  
  99.     if (isc_dsql_prepare(status, &trans, &stmt, 0, query, 1, sqlda))
  100.         {ERREXIT(status, 1)};
  101.  
  102.     /* Call the cursor "C" */
  103.     isc_dsql_set_cursor_name(status, &stmt, "C", 0);
  104.  
  105.     /* Allocate an event block and initialize its values 
  106.     **  This will wait on two named events 
  107.     */
  108.     length = (short)  isc_event_block((char ISC_FAR * ISC_FAR *) &event_buffer,
  109.                 (char ISC_FAR * ISC_FAR *) &result_buffer,
  110.  
  111.                  2, ids[0], ids[1], 0);
  112.  
  113.     /* Request the server to notify us of our events of interest.
  114.     ** When one of the two named events is triggered, the ast_routine
  115.     ** will be called with event_buffer, an updated buffer and length
  116.     ** que_events returns ast_returns value
  117.     */
  118.     if(isc_que_events(status, &DB, &event_id, length,
  119.              event_buffer, (isc_callback) ast_routine, result_buffer))
  120.         {ERREXIT(status, 1)};
  121.  
  122.  
  123.     while (!ret)
  124.     {
  125.  
  126.         i++;
  127.         /* If the event was triggered, reset the buffer and re-queue */
  128.         if (event_flag)
  129.         {
  130.  
  131.  
  132.                  /* Check for first ast_call.  isc_que_events fires
  133.                     each event to get processing started */
  134.  
  135.                   if ( first )
  136.                      {
  137.                       first = 0;
  138.                       event_flag = 0;
  139.                      }
  140.                   else
  141.                      {
  142.                     
  143.             event_flag = 0; 
  144.             /* event_counts will compare the various events 
  145.             ** listed in the two buffers and update the 
  146.             ** appropriate count_array elements with the difference
  147.             ** in the counts in the two buffers.
  148.             */
  149.  
  150.             isc_event_counts(Vector, length, (char ISC_FAR *) event_buffer,
  151.                 (char ISC_FAR *) result_buffer);
  152.  
  153.             /* Look through the count array */
  154.             count[0] += Vector[0];
  155.             count[1] += Vector[1];
  156.  
  157.             /* Select query to look at triggered events */
  158.             if (isc_dsql_execute(status, &trans, &stmt, 1, NULL))
  159.                 {ERREXIT(status, 1)};
  160.  
  161.             while (!isc_dsql_fetch(status, &stmt, 1, sqlda))
  162.             {
  163.                 po_number[8] = 0;
  164.                 printf("api16: %s\n", po_number);
  165.  
  166.                 /* exit on processing the last example record*/
  167.                 if (!strncmp(po_number, "VNEW4", 5))
  168.                     ret = 1;
  169.  
  170.                 /* Update current row */
  171.                 if(isc_dsql_execute_immediate(status, &DB, 
  172.                     &trans, 0, update, 1, NULL))
  173.                     {ERREXIT(status, 1)};
  174.             }
  175.             /* Close cursor */
  176.             isc_dsql_free_statement(status, &stmt, DSQL_close);
  177.  
  178.                     }
  179.  
  180.            /* Re-queue for the next event */
  181.  
  182.          if (isc_que_events(status, &DB, &event_id, length, 
  183.             event_buffer, (isc_callback) ast_routine, result_buffer))
  184.                  {ERREXIT(status, 1)};
  185.         }
  186.  
  187.         /* This does not block, but as a sample program there is nothing
  188.         ** else for us to do, so we will take a nap
  189.         */
  190.     SLEEP(1);
  191.     }
  192.     isc_commit_transaction(status, &trans);
  193.  
  194.     isc_detach_database (status, &DB);
  195.  
  196.     printf("Event complete, exiting\n");
  197.     free( sqlda);
  198.     return 0;
  199.  
  200. }
  201.  
  202. /*
  203. ** The called routine is always called with these three buffers.  Any
  204. ** event will land us here .  PLus we get called once when the 
  205. ** program first starts.
  206. */
  207. isc_callback ast_routine(ARG(char ISC_FAR *, result), 
  208.         ARG(short, length), 
  209.         ARG(char ISC_FAR *, updated))
  210. ARGLIST(char  *result)
  211. ARGLIST(char  *updated)
  212. ARGLIST(short length)
  213. {
  214.     /* Set the global event flag */
  215.  
  216.  
  217.     event_flag++;
  218.     printf("ast routine was called\n");
  219.     /* Copy the updated buffer to the result buffer */
  220.     while (length--)
  221.         *result++ = *updated++;
  222.     return 0;
  223. }
  224.