/********************************************************************8
**
** Program type: API
**
** Description: This program does an asynchronous event wait
** on a trigger set up in employee.sales.
** Somebody must add a new sales order to alert
** this program. That role can be accomplished
** by running programs stat12t or api16t at the
** same time.
**
** When the event is fired, this program selects
** back any new records and updates (current) those
** records to status "open". The entire program runs
** in a single read-committed (wait, no version)
** transaction, so transaction doesn't need to be started
** after an event.
* The contents of this file are subject to the Interbase Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy
* of the License at http://www.Inprise.com/IPL.html
*
* Software distributed under the License is distributed on an
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
* or implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
* Copyright (C) Inprise Corporation.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "example.h"
#include <ibase.h>
/* Sleep for Windows is a stupid loop with I/O */
#if defined _MSC_VER
#include <windows.h>
#define SLEEP(x) Sleep(x * 1000 )
#else
#define SLEEP(x) sleep(x)
#endif
short event_flag = 0;
void ast_routine (void *, ISC_USHORT, const ISC_UCHAR *);
int main(int argc, char** argv)
{
isc_db_handle DB = NULL; /* database handle */
isc_tr_handle trans = NULL; /* transaction handle */
isc_stmt_handle stmt = NULL; /* transaction handle */
ISC_STATUS_ARRAY status; /* status vector */
char * event_buffer;
char * result_buffer;
long event_id;
short length;
char dbname[128];
char po_number[9];
XSQLDA * sqlda;
short nullind = 0;
char query[128], update[128];
long count[2], i = 0;
ISC_STATUS_ARRAY Vector;
char ids[2][15];
int first = 1;
int ret = 0;
/* Transaction parameter block for read committed */
static char isc_tpb[5] = {isc_tpb_version1,
isc_tpb_write,
isc_tpb_read_committed,
isc_tpb_wait,
isc_tpb_no_rec_version};
if (argc > 1)
strcpy(dbname, argv[1]);
else
strcpy(dbname, "localhost:employee.fdb");
strcpy (ids[0], "new_order");
strcpy (ids[1], "change_order");
count[0] = 0;
count[1] = 0;
sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(1));
sqlda->sqln = 1;
sqlda->version = 1;
sqlda->sqlvar[0].sqldata = po_number;
sqlda->sqlvar[0].sqlind = &nullind;
if (isc_attach_database (status, 0, dbname, &DB, 0, NULL))
{ERREXIT(status, 1)}
/* SET TRANSACTION ISOLATION LEVEL READ COMMITTED */
if (isc_start_transaction (status, &trans, 1, &DB, 5, isc_tpb))
{ERREXIT(status, 1)}
/* Prepare the query to look at the result tables */
strcpy(query, " SELECT po_number FROM sales \
WHERE order_status = 'new' FOR UPDATE");
/* This is for the update where current of */
strcpy(update,
"UPDATE sales SET order_status = 'open' WHERE CURRENT OF C");
isc_dsql_allocate_statement(status, &DB, &stmt);
if (isc_dsql_prepare(status, &trans, &stmt, 0, query, 1, sqlda))
{ERREXIT(status, 1)};
/* Call the cursor "C" */
isc_dsql_set_cursor_name(status, &stmt, "C", 0);
/* Allocate an event block and initialize its values
** This will wait on two named events
*/
length = (short) isc_event_block((char **) &event_buffer,
(char **) &result_buffer,
2, ids[0], ids[1], 0);
/* Request the server to notify us of our events of interest.
** When one of the two named events is triggered, the ast_routine
** will be called with event_buffer, an updated buffer and length
** que_events returns ast_returns value
*/
if(isc_que_events(status, &DB, &event_id, length,
event_buffer, ast_routine, result_buffer))
{ERREXIT(status, 1)}
while (!ret)
{
i++;
/* If the event was triggered, reset the buffer and re-queue */
if (event_flag)
{
/* Check for first ast_call. isc_que_events fires
each event to get processing started */
if ( first )
{
first = 0;
event_flag = 0;
}
else
{
event_flag = 0;
/* event_counts will compare the various events
** listed in the two buffers and update the
** appropriate count_array elements with the difference
** in the counts in the two buffers.
*/
isc_event_counts(Vector, length, (char *) event_buffer,
(char *) result_buffer);
/* Look through the count array */
count[0] += Vector[0];
count[1] += Vector[1];
/* Select query to look at triggered events */
if (isc_dsql_execute(status, &trans, &stmt, 1, NULL))
{ERREXIT(status, 1)}
while (!isc_dsql_fetch(status, &stmt, 1, sqlda))
{
po_number[8] = 0;
printf("api16: %s\n", po_number);
/* exit on processing the last example record*/
if (!strncmp(po_number, "VNEW4", 5))
ret = 1;
/* Update current row */
if(isc_dsql_execute_immediate(status, &DB,
&trans, 0, update, 1, NULL))
{ERREXIT(status, 1)}
}
/* Close cursor */
isc_dsql_free_statement(status, &stmt, DSQL_close);
}
/* Re-queue for the next event */
if (isc_que_events(status, &DB, &event_id, length,
event_buffer, ast_routine, result_buffer))
{ERREXIT(status, 1)}
}
/* This does not block, but as a sample program there is nothing
** else for us to do, so we will take a nap
*/
SLEEP(1);
}
isc_commit_transaction(status, &trans);
isc_detach_database (status, &DB);
printf("Event complete, exiting\n");
free( sqlda);
return 0;
}
/*
** The called routine is always called with these three buffers. Any
** event will land us here . PLus we get called once when the
** program first starts.
*/
void ast_routine(void *result, ISC_USHORT length, const ISC_UCHAR *updated)
{
/* Set the global event flag */
event_flag++;
printf("ast routine was called\n");
/* Copy the updated buffer to the result buffer */
while (length--)
*(ISC_UCHAR*)result++ = *updated++;
}