Main Page   Modules   File List   Globals   Related Pages   Examples  

The advanced interface.

This functions offer more flexibility in terms of datatypes, but they need (much) more parameters. More...

Functions

int sqlo_prepare (sqlo_db_handle_t dbh, const char *stmt)
 Parse a statement.

int sqlo_bind_by_name (sqlo_stmt_handle_t sth, const char *name, int param_type, const void *param_addr, unsigned int param_size, short *ind_addr, int is_array)
 Bind a variable by name.

int sqlo_bind_ref_cursor (sqlo_stmt_handle_t sth, const char *cursor_name, int *sth2p)
 Bind a REF CURSOR.

int sqlo_bind_by_pos (sqlo_stmt_handle_t sth, int position, int param_type, const void *param_addr, unsigned int param_size, short *ind_addr, int is_array)
 Bind a variable by position.

int sqlo_bind_by_pos2 (sqlo_stmt_handle_t sth, int position, int param_type, const void *param_addr, unsigned int param_size, short *ind_addr, unsigned short *rcode_addr, unsigned int skip_size)
 Bind a variable by position.

int sqlo_define_by_pos (sqlo_stmt_handle_t sth, int value_pos, int value_type, const void *value_addr, unsigned int value_size, short *ind_addr, short *rlen_addr, int is_array)
 Define a output variable of the select list.

int sqlo_define_by_pos2 (sqlo_stmt_handle_t sth, int value_pos, int value_type, const void *value_addr, unsigned int value_size, short *ind_addr, unsigned short *rlen_addr, unsigned short *rcode_addr, unsigned int skip_size)
 Define a output variable of the select list.

int sqlo_define_ntable (sqlo_stmt_handle_t sth, unsigned int pos, int *sth2p)
 Define a nested table Please visit the example for details.

int sqlo_execute (sqlo_stmt_handle_t sth, unsigned int iterations)
 Execute a statement.


Detailed Description

This functions offer more flexibility in terms of datatypes, but they need (much) more parameters.

Use these functions if you want to execute PL/SQL or stored procedures.


Function Documentation

int sqlo_bind_by_name sqlo_stmt_handle_t    sth,
const char *    name,
int    param_type,
const void *    param_addr,
unsigned int    param_size,
short *    ind_addr,
int    is_array
 

Bind a variable by name.

Use this to bind a variable in a query or a stored procedure call.

If is_array is 1, the parameters param_addr and ind_addr must point to arrays. ind_addr is optional and can be passed a NULL. The param_size is still the size of one array element, not the whole array size!

Parameters:
sth  I - The statement handle.
name  I - The bind parameter name.
param_type  I - The datatype of the bind parameter (see Constants).
param_addr  I - The address of a variable or array.
param_size  I - The size of the object at param_addr in bytes.
ind_addr  I - The pointer to the NULL indicator variable (optional).
is_array  I - 1 means param_addr points to an array, 0 means a single variable.
Returns:
  • SQLO_SUCCESS
  • < 0 on error
Example:
/* $Id: ex9.c,v 1.5 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

static void create_sp __P((sqlo_db_handle_t dbh));

int call_plsql(sqlo_db_handle_t dbh)
{
  double ip1;
  int  ip2;
  char op[80];
  sqlo_stmt_handle_t sth = SQLO_STH_INIT;

  /* the stored procecdure call */
  char * stmt = 
    "BEGIN\n"
    "    EX9(:ip1, :ip2, :op);\n"
    "END;\n";


  create_sp(dbh);               /* create the test stored procedure */

  ip1 = 1.5;
  ip2 = 20;


  /* parse the statement */
  if ( 0 <= (sth = sqlo_prepare(dbh, stmt))) {
    /* bind all variables */
    if (SQLO_SUCCESS != 
        (sqlo_bind_by_name(sth, ":ip1", SQLOT_FLT, &ip1, sizeof(ip1), 0, 0) ||
         sqlo_bind_by_name(sth, ":ip2", SQLOT_INT, &ip2, sizeof(ip2), 0, 0) ||
         sqlo_bind_by_name(sth, ":op", SQLOT_STR, &op, sizeof(op), 0, 0)
         )) {

      error_exit(dbh, "sqlo_bind_by_name");
    } else {
      /* execute the call */
      if (SQLO_SUCCESS != sqlo_execute(sth, 1))
        error_exit(dbh, "sqlo_execute");
    }

    /* print the result */
    if (atof(op) != (ip1 + ip2))
      printf("Stored procudure returned wrong result %s, expected %6.2f\n",
             op, (ip1 + ip2));

    if (SQLO_SUCCESS != sqlo_close(sth))
      error_exit(dbh, "sqlo_execute");

  } else {
    error_exit(dbh, "sqlo_prepare");
  }

  if ( 0 > sqlo_exec(dbh, "DROP PROCEDURE EX9"))
    error_exit(dbh, "sqlo_exec");

  return 1;
}

/* creates the stored procedure used above */
static void
create_sp(sqlo_db_handle_t dbh)
{
  char * stmt =
    "CREATE OR REPLACE PROCEDURE EX9(ipNum1 IN NUMBER, ipNum2 IN NUMBER, opStr OUT VARCHAR)\n"
    "IS\n"
    "BEGIN\n"
    "  opStr := TO_CHAR(ipNum1 + ipNum2);\n"
    "END;\n";

  if (SQLO_SUCCESS != sqlo_exec(dbh, stmt))
    error_exit(dbh, stmt);

}

/* $Id: ex9.c,v 1.5 2002/08/24 12:54:47 kpoitschke Exp $ */
See also:
sqlo_prepare, sqlo_bind_by_pos, sqlo_define_by_pos
Examples:
ex17.c, ex18.c, ex19.c, and ex9.c.

int sqlo_bind_by_pos sqlo_stmt_handle_t    sth,
int    position,
int    param_type,
const void *    param_addr,
unsigned int    param_size,
short *    ind_addr,
int    is_array
 

Bind a variable by position.

If is_array is 1, the parameters param_addr and ind_addr must point to arrays. ind_addr is optional and can be passed a NULL. The param_size is still the size of one array element, not the whole array size!

Parameters:
sth  I - The statement handle
position  I - The bind parameter position in the string. Starts with 1 for the first.
param_type  I - The datatype of the bind parameter (see Constants).
param_addr  I - The pointer to the parameter data.
param_size  I - The size of the object at param_addr in bytes.
ind_addr  I - The pointer to the NULL indicator variable (optional).
is_array  I - 1 means param_addr points to an array, 0 means a single variable.
Returns:
  • SQLO_SUCCESS
  • < 0 on error
Example:
/* $Id: ex10.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

sqlo_stmt_handle_t prepare_cursor(sqlo_db_handle_t dbh, double * min_salary)
{
  sqlo_stmt_handle_t sth;                      /* statement handle */

  if (0 > (sth = sqlo_prepare(dbh, 
                            "SELECT ENAME, SAL FROM EMP WHERE SAL >= :salary ORDER BY 2,1")))
    error_exit(dbh, "sqlo_prepare");

  if (SQLO_SUCCESS != 
      sqlo_bind_by_pos(sth, 1, SQLOT_FLT, min_salary, sizeof(double), 0, 0))
    error_exit(dbh, "sqlo_bind_by_pos");

  return sth;
}
/* $Id: ex10.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
See also:
sqlo_prepare, sqlo_bind_by_name, sqlo_define_by_pos
Examples:
ex10.c, ex13.c, ex14.c, ex15.c, and ex16.c.

int sqlo_bind_by_pos2 sqlo_stmt_handle_t    sth,
int    position,
int    param_type,
const void *    param_addr,
unsigned int    param_size,
short *    ind_addr,
unsigned short *    rcode_addr,
unsigned int    skip_size
 

Bind a variable by position.

Bind the input variables. This new version supports arrays of structures. Set the skip_size to the size of the structure. rcode and ind must be part of the structure.

Parameters:
sth  I - The statement handle
position  I - The bind parameter position in the string. Starts with 1 for the first.
param_type  I - The datatype of the bind parameter (Constants).
param_addr  I - The pointer to the parameter data.
param_size  I - The size of the object at param_addr in bytes.
ind_addr  I - The pointer to the NULL indicator variable (optional).
rcode_addr  I - The pointer to the variable that should return the column level
skip_size  I - In case into an array of structures, set to sizeof(your_struct), otherwise set it to 0.
Returns:
  • SQLO_SUCCESS
  • < 0 on error
See also:
sqlo_prepare, sqlo_bind_by_name, sqlo_define_by_pos
Since:
Version 2.2

int sqlo_bind_ref_cursor sqlo_stmt_handle_t    sth,
const char *    cursor_name,
int *    sth2p
 

Bind a REF CURSOR.

Binds a ref cursor and returns a new sth, which you can use to retrieve the data.

Note:
You can also use The advanced interface. and supply as SQLOT_RSET as type and the address of the new statement handle as param_addr. All other parameters are ignored.
Parameters:
sth  I - The statement handle
cursor_name  I - The bind name of the cursor
sth2p  O - The new statement handle for the ref cursor.
Example:
Example using sqlo_values to get the result:
/* $Id: ex17.c,v 1.3 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

int select_refcursor(sqlo_db_handle_t dbh, double min_salary)
{
  sqlo_stmt_handle_t sth = SQLO_STH_INIT;
  sqlo_stmt_handle_t st2h;                     /* handle of the ref cursor */
  double sal = min_salary;
  CONST char **v;
  int status;

  CONST char * stmt = 
    "BEGIN\n"
    "    OPEN :c1 FOR SELECT ENAME, SAL FROM EMP WHERE SAL >= :min_sal ORDER BY 2,1;\n"
    "END;\n";


  /* parse the statement */
  if ( 0 <= (sth = sqlo_prepare(dbh, stmt))) {
    /* bind all variables */
    if (SQLO_SUCCESS != 
        ( sqlo_bind_ref_cursor(sth, ":c1", &st2h)) ||
        (sqlo_bind_by_name(sth, ":min_sal", SQLOT_FLT, &sal, sizeof(sal), 0, 0) ) ) {
      error_exit(dbh, "sqlo_bind_by_name");
    } else {

      /* execute the PL/SQL block */
      if (SQLO_SUCCESS != sqlo_execute(sth, 1))
        error_exit(dbh, "sqlo_execute");
    }
    /* execute the refcursor */
    if (SQLO_SUCCESS != sqlo_execute(st2h, 1)) {
      error_exit(dbh, "sqlo_execute(ref)");
    }

    while (SQLO_SUCCESS == (status = sqlo_fetch(st2h, 1))) {
      v = sqlo_values(st2h, NULL, 1);

      printf("Name=%-8s Salary= %-6s\n", v[0], v[1]);
    }
    
    if (status != SQLO_NO_DATA)
      error_exit(dbh, "sqlo_fetch(st2)");

    if (SQLO_SUCCESS != sqlo_close(sth))
      error_exit(dbh, "sqlo_close(1)");

    if (SQLO_SUCCESS != sqlo_close(st2h))
      error_exit(dbh, "sqlo_close(2)");

  } else {
    error_exit(dbh, "sqlo_prepare");
  }

  return 1;
}

/* $Id: ex17.c,v 1.3 2002/08/24 12:54:47 kpoitschke Exp $ */
Example using bind variables:
/* $Id: ex18.c,v 1.3 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

int select_refcursor2(sqlo_db_handle_t dbh, double min_salary)
{
  sqlo_stmt_handle_t sth = SQLO_STH_INIT;
  sqlo_stmt_handle_t st2h;                     /* handle of the ref cursor */
  double sal = min_salary;
  int status;
  char name[30];
  double salary;
  short nind, sind;

  CONST char * stmt = 
    "BEGIN\n"
    "    OPEN :c1 FOR SELECT ENAME, SAL FROM EMP WHERE SAL >= :min_sal ORDER BY 2,1;\n"
    "END;\n";


  /* parse the statement */
  if ( 0 <= (sth = sqlo_prepare(dbh, stmt))) {

    /* bind all variables */
    if (SQLO_SUCCESS != 
        (sqlo_bind_by_name(sth, ":c1", SQLOT_RSET, &st2h, 0, 0, 0)) ||
        (sqlo_bind_by_name(sth, ":min_sal", SQLOT_FLT, &sal, sizeof(sal), 0, 0) ) ) {
      error_exit(dbh, "sqlo_bind_by_name");
    } else {

      /* execute the PL/SQL block */
      if (SQLO_SUCCESS != sqlo_execute(sth, 1))
        error_exit(dbh, "sqlo_execute");
    }

    /* execute the second cursor */
    if(SQLO_SUCCESS != sqlo_execute(st2h, 1))
      error_exit(dbh, "sqlo_execute");

    if (SQLO_SUCCESS != 
        ( sqlo_define_by_pos(st2h, 1, SQLOT_STR, name, sizeof(name), &nind, 0, 0) ) ||
        ( sqlo_define_by_pos(st2h, 2, SQLOT_FLT, &salary, sizeof(salary), &sind, 0, 0) ) )
      {
        error_exit(dbh, "sqlo_define_by_pos");
      }

    while (SQLO_SUCCESS == (status = sqlo_fetch(st2h, 1))) {
      printf("Name=%-8s Salary= %6.2f\n", name, salary);
    }
    
    if (status != SQLO_NO_DATA)
      error_exit(dbh, "sqlo_fetch(st2)");

    if (SQLO_SUCCESS != sqlo_close(sth))
      error_exit(dbh, "sqlo_close(1)");

    if (SQLO_SUCCESS != sqlo_close(st2h))
      error_exit(dbh, "sqlo_close(2)");

  } else {
    error_exit(dbh, "sqlo_prepare");
  }

  return 1;
}

/* $Id: ex18.c,v 1.3 2002/08/24 12:54:47 kpoitschke Exp $ */
Examples:
ex17.c.

int sqlo_define_by_pos sqlo_stmt_handle_t    sth,
int    value_pos,
int    value_type,
const void *    value_addr,
unsigned int    value_size,
short *    ind_addr,
short *    rlen_addr,
int    is_array
 

Define a output variable of the select list.

Use this to define the output variables.

If is_array is 1, the parameters value_addr, rlen_addr and ind_addr must point to arrays. ind_addr is optional and can be passed a NULL. Passing NULL is only usefull for NOT NULL columns. If you ommit the indicator and a NULL is fetched, The advanced interface. will fail with an Oracle error (FETCHED COLUMN VALUE IS NULL).

The value_size is still the size of one array element, not the whole array size!

Parameters:
sth  I - The statement handle
value_pos  I - The bind parameter position in the string. Starts with 1 for the first.
value_type  I - The datatype of the bind parameter (Constants).
value_addr  I - The pointer to the parameter data.
value_size  I - The size of the object at param_addr in bytes.
ind_addr  I - The pointer to the NULL indicator variable (optional).
rlen_addr  I - The pointer where The advanced interface. writes the actual returned length.
is_array  I - 1 means param_addr points to an array, 0 means a single variable.
Returns:
  • SQLO_SUCCESS
  • < 0 on error
Example:
/* $Id: ex11.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

sqlo_stmt_handle_t do_select2(sqlo_db_handle_t dbh, double min_salary)
{
  sqlo_stmt_handle_t sth;       /* statement handle */
  int status;                   /* return code of sqlo_... */
  char name[64];                /* output variable for NAME */
  short name_rlen;              /* returned length of NAME */
  short name_ind;               /* NULL indicator for NAME */
  short sal_ind;                /* NULL indicator for SALARY */
  double salary = min_salary;   /* input variable for SALARY */

  sth = prepare_cursor(dbh, &salary); /* see ex10.c */

  /* define output */
  if (SQLO_SUCCESS != 
      (sqlo_define_by_pos(sth, 1, SQLOT_STR, name, sizeof(name), &name_ind, &name_rlen, 0)) ||
      (sqlo_define_by_pos(sth, 2, SQLOT_FLT, &salary, sizeof(salary), &sal_ind, 0, 0))) {
    error_exit(dbh, "sqlo_define_by_pos");
  }

  status = sqlo_execute(sth, 0);
  if ( 0 > status)
    error_exit(dbh, "sqlo_execute");

  while ( SQLO_SUCCESS == (status = sqlo_fetch(sth, 1))) {
    printf("Name=%-8s Salary=%6.2f\n", name, salary);
  }

  if (status != SQLO_NO_DATA)
    error_exit(dbh, "sqlo_fetch");

  return sth;
}
/* $Id: ex11.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
See also:
sqlo_prepare, sqlo_bind_by_name, sqlo_define_by_pos
Examples:
ex11.c, ex15.c, ex16.c, ex18.c, and ex19.c.

int sqlo_define_by_pos2 sqlo_stmt_handle_t    sth,
int    value_pos,
int    value_type,
const void *    value_addr,
unsigned int    value_size,
short *    ind_addr,
unsigned short *    rlen_addr,
unsigned short *    rcode_addr,
unsigned int    skip_size
 

Define a output variable of the select list.

Use this to define where the result of the query should go. This new version supports filling arrays of structures. If skip_size is not 0, the parameter value_addr must point to an array of structures. If used, the structure must contain variables for ind, rlen and rcode.

The value_size is still the size of one array element, not the whole array size!

Parameters:
sth  I - The statement handle
value_pos  I - The bind parameter position in the string. Starts with 1 for the first.
value_type  I - The datatype of the bind parameter (Constants).
value_addr  I - The pointer to the parameter data.
value_size  I - The size of the object at param_addr in bytes.
ind_addr  I - The pointer to the NULL indicator variable (optional).
rlen_addr  I - The pointer where library puts the actual return length.
rcode_addr  I - The address where the library puts the return code for the column
skip_size  I - In case into an array of structures, set to sizeof(your_struct), otherwise set it to 0.
Returns:
  • SQLO_SUCCESS
  • < 0 on error
Example:
This is an example of a fetch into an array of structure.
/* $Id: ex12.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

enum {
  MAX_NAME_LEN = 64,
  MAX_ARRAY_SIZE = 4            /* Note: usually this should be 100 or so. 
                                 * Used a smaller one to do test all paths in the code
                                 */
};

typedef struct _result_t {
  char name[MAX_NAME_LEN+1];    /* output ENAME */
  double salary;                /* output SAL */
  short name_ind;               /* indicator variable of ENAME */
  short sal_ind;                /* indicator variable of SAL */
  unsigned short name_rlen;     /* the actual length of ENAME */
  unsigned short name_rcode;    /* the return code of ENAME */
} result_t;

void print_record __P((result_t * r));


int do_array_select(sqlo_db_handle_t dbh, double min_salary)
{
  sqlo_stmt_handle_t sth;       /* statement handle */
  int i;                        /* loop variable */
  int status;                   /* return code of sqlo_... */
  result_t result[MAX_ARRAY_SIZE];
  int rows_fetched;             /* number of rows fetched per execute */
  int rows_fetched_total = 0;   /* total number of rows */
  int done_fetching = 0;        /* flag indicating end of fetch */
  double salary = min_salary;   /* input variable for SAL */
  int skip_size = sizeof(result[0]); /* The skip size */

  sth = prepare_cursor(dbh, &salary); /* see ex10.c */

  /* define output */
  if (SQLO_SUCCESS != 
      (sqlo_define_by_pos2(sth, 1, SQLOT_STR, result[0].name, sizeof(result[0].name), 
                           &result[0].name_ind, &result[0].name_rlen, 
                           &result[0].name_rcode, skip_size)) ||
      (sqlo_define_by_pos2(sth, 2, SQLOT_FLT, &result[0].salary, sizeof(result[0].salary),
                           &result[0].sal_ind, 0, 0, skip_size))) {
    error_exit(dbh, "sqlo_define_by_pos");
  }

  /* execute and fetch  the result */
  status = sqlo_execute(sth, 0);

  while (!done_fetching) {

    rows_fetched = MAX_ARRAY_SIZE;

    /* get the next set */
    status = sqlo_fetch(sth, MAX_ARRAY_SIZE);

    if (0 > status)
      error_exit(dbh, "sqlo_execute(NEXT)");
    else if (SQLO_NO_DATA == status) {
      
      rows_fetched = sqlo_prows(sth);
          
      /* sqlo_prows returns now the total number of fetched rows
       * the difference to the previous total fechted rows is
       * the number of rows fetched in this last call to sqlo_execute
       */
      rows_fetched = rows_fetched - rows_fetched_total;
      done_fetching = 1;

    }
    
    /* print the records */
    for (i = 0; i < rows_fetched; ++i)
      print_record(&result[i]);

    rows_fetched_total += rows_fetched;

  }
  printf("Selected %d employees\n", rows_fetched_total);
  /* finished. */
  sqlo_close(sth);

  return 1;
}

/* print record */
void print_record(result_t * r /* I - The record */ )
{
  printf("Name=%-8s Salary= %6.2f\n",
         (r->name_ind == SQLO_NULL_IND ? "NULL" : r->name),
         (r->sal_ind == SQLO_NULL_IND ? -1.0 : r->salary));
}

/* $Id: ex12.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
See also:
sqlo_prepare, sqlo_bind_by_name, sqlo_define_by_pos, sqlo_execute
Since:
Version 2.2
Examples:
ex12.c.

int sqlo_define_ntable sqlo_stmt_handle_t    sth,
unsigned int    pos,
int *    sth2p
 

Define a nested table Please visit the example for details.

Note:
You can also use The advanced interface. with type == SQLOT_RSET and passing the address of the new sth as value_addr and set all other parameters to 0.
Parameters:
sth  I - The statement handle
pos  I - The define position of the nested table
sth2p  O - The new statement handle for the nested table.
Examples:
/* $Id: ex19.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
#include <stdio.h>
#include <stdlib.h>
#include "examples.h"

int select_ntable(sqlo_db_handle_t dbh)
{
  sqlo_stmt_handle_t sth = SQLO_STH_INIT;
  sqlo_stmt_handle_t st2h;                     /* handle of the ref cursor */
  int status;
  char ename[11];
  char dname[15];
  char loc[14];
  short eind, dind, lind;
  int deptno = 10;

               /* don't know why the bind variable for deptno causes a crash */
  CONST char * stmt = 
    "SELECT ENAME, CURSOR(SELECT DNAME, LOC FROM DEPT)\n"
    "  FROM EMP WHERE DEPTNO = :deptno";


  /* parse the statement */
  if ( 0 <= (sth = sqlo_prepare(dbh, stmt))) {

    /* bind all variables */
    if (SQLO_SUCCESS != 
        (sqlo_bind_by_name(sth, ":deptno", SQLOT_INT, &deptno, sizeof(deptno), 0, 0) ) ) {
      error_exit(dbh, "sqlo_bind_by_name");
    } 

    /* Do the defines */
    /* You could also do: sqlo_define_by_pos(sth, 2, SQLOT_RSET, &st2h, 0, 0, 0, 0) */
    if (SQLO_SUCCESS != 
        ( sqlo_define_by_pos(sth, 1, SQLOT_STR, ename, sizeof(ename), &eind, 0, 0) ) ||
        ( sqlo_define_ntable(sth, 2, &st2h)))
      error_exit(dbh, "sqlo_define_ntable");
    
    /* execute the main statement */
    if (SQLO_SUCCESS != sqlo_execute(sth, 1))
      error_exit(dbh, "sqlo_execute");
    

    /* fetch from the main statement */
    while (SQLO_SUCCESS == (status = sqlo_fetch(sth, 1))) {
      printf("ENAME=%11s\n", ename);


      /* define the output of the second cursor */
      if (SQLO_SUCCESS != 
          ( sqlo_define_by_pos(st2h, 1, SQLOT_STR, dname, sizeof(dname), &dind, 0, 0) ) ||
          ( sqlo_define_by_pos(st2h, 2, SQLOT_STR, loc, sizeof(loc), &lind, 0, 0) ) )  {
          error_exit(dbh, "sqlo_define_by_pos");
        }

      /* execute the cursor */
      if(SQLO_SUCCESS != sqlo_execute(st2h, 1))
        error_exit(dbh, "sqlo_execute");

      /* fetch from the second cursor */
      while (SQLO_SUCCESS == (status = sqlo_fetch(st2h, 1))) {
        printf("    DNAME=%15s LOC=%15s\n", dname, loc);

      }
      if (status != SQLO_NO_DATA)
        error_exit(dbh, "sqlo_fetch(st2)");

    }
    
    if (SQLO_SUCCESS != sqlo_close(sth))
      error_exit(dbh, "sqlo_close(1)");
    
    if (SQLO_SUCCESS != sqlo_close(st2h))
      error_exit(dbh, "sqlo_close(2)");
    
  } else {
    error_exit(dbh, "sqlo_prepare");
  }

  return 1;
}

/* $Id: ex19.c,v 1.4 2002/08/24 12:54:47 kpoitschke Exp $ */
Examples:
ex19.c.

int sqlo_execute sqlo_stmt_handle_t    sth,
unsigned int    iterations
 

Execute a statement.

Execute a PL/SQL block or a statement after you prepared it with sqlo_prepare and bound input and output variables. If you are fetching into arrays, you can set iterations to the actual array size. For PL/SQL blocks it must be set to 1.

Parameters:
sth  I - A parsed statement handle
iterations  I - How many times the statement should be exectuted. Must be 1 if you execute a PL/SQL block
Returns:
  • SQLO_SUCCESS
  • SQLO_NO_DATA
  • SQLO_STILL_EXECUTING (non-blocking)
  • < 0 on error
See also:
sqlo_prepare, sqlo_define_by_pos, sqlo_define_by_pos2, sqlo_bind_by_name
Examples:
ex11.c, ex12.c, ex13.c, ex14.c, ex15.c, ex16.c, ex17.c, ex18.c, ex19.c, and ex9.c.

int sqlo_prepare sqlo_db_handle_t    dbh,
const char *    stmt
 

Parse a statement.

This functions must be used to parse a statement if you want to bind manually the parameters. By doing this you can use native datatypes. This is the more complex form of The easy interface.

If the stmt is a SELECT statement, the function sets the attribute OCI_ATTR_PREFETCH rows to the max arraysize parameter of the library. This is a kind of internal array fetch Oracle provides to speed up the fetching.

Parameters:
dbh  I - A database handle
stmt  I - sql statement.
Returns:
  • A new statement handle
  • < 0 on error.
See also:
sqlo_bind_by_name, sqlo_bind_by_pos, sqlo_define_by_pos, sqlo_open2.
Examples:
ex10.c, ex13.c, ex14.c, ex15.c, ex16.c, ex17.c, ex18.c, ex19.c, and ex9.c.


Generated on Thu Aug 14 18:02:53 2003 for libsqlora8 by doxygen1.2.18