Informix-ESQL/C Programmer's Manual

Informix-ESQL/C Programmer's Manual
Chapter 12: Working with the Database Server

Home Contents Index Master Index New Book

Using Database Server Control Functions

The following sections describe the ESQL/C library functions that you can use to control the database server sessions.


Function Name	Description
ifx_getcur_conn_name()	Returns the name of the current connection.
sqgetdbs()	Returns the names of databases that a database server can access.
sqlbreak()	Sends the database server a request to stop processing.
sqlbreakcallback()	Establishes a time-out interval and a callback function for interrupting an `SQL` request.
sqldetach()	Detaches a child process from a database server connection.
sqldone()	Determines whether the database server is currently processing an `SQL` request.
sqlexit()	Terminates a database server connection.
sqlsignal()	Performs signal handling and cleanup of child processes.
sqlstart()	Starts a database server connection.

ifx_getcur_conn_name()

The ifx_getcur_conn_name() function returns the name of the current connection.

Syntax

char *ifx_getcur_conn_name(void);

Usage

The current connection is the active database server connection that is currently sending SQL requests to the database server and possibly receiving data from the database server. In a callback function, the current connection is the current connection at the time when the callback was registered with a call to the sqlbreakcallback() function. The current connection name is the explicit name of the current connection. If the CONNECT statement that establishes a connection does not include the AS clause, the connection does not have an explicit name.

Return Codes

Name of current
connection

Successfully obtained current connection name

Null pointer

Unable to obtain current connection name or current connection does not have an explicit name

sqgetdbs()

The sqgetdbs() function returns the names of databases that a database server can access.

Syntax

int sqgetdbs(ret_fcnt,  dbnarray, dbnsize, dbnbuffer, dbnbufsz)

		int  *ret_fcnt;

		char  **dbnarray;

		int dbnsize;

		char *dbnbuffer;

		int dbnbufsz; 


ret_fcnt
is a pointer to the number of database names that the function returns.

dbnarray
is a user-defined array of character pointers. 

dbnsize
is the size of the dbnarray user-defined array.

dbnbuffer  
is a pointer to a user-defined buffer that contains the names of the databases that the function returns.

dbnbufsz
is the size of the dbnbuffer user-defined buffer.

Usage

You must provide the following user-defined data structures to the sqgetdbs() function:

The dbnbuffer buffer holds the names of the null-terminated database names that sqgetdbs() returns.
The dbnarray array holds pointers to the database names that the function stores in the dbnbuffer buffer. For example, dbnarray[0] points to the first character of the first database name (in dbnbuffer), dbnarray[1] points to the first character of the second database name, and so on.

If the application is connected to a database server, a call to the sqgetdbs() function returns the names of the databases that are available in the database server of the current connection. This includes the user-defined databases as well as the sysmaster database. Otherwise, it returns the database names that are available in the default database server (that the INFORMIXSERVER environment variable indicates). If you use the DBPATH environment variable to identify additional database servers that contain databases, sqgetdbs() also lists the databases that are available on these database servers. It first lists the databases that are available through DBPATH and then the databases that are available through the INFORMIXSERVER environment variable.

Return Codes

0

Successfully obtained database names

<0

Unable to obtain database names

Example

The sqgetdbs.ec file in the demo directory contains this sample program.

/*

   * sqgetdbs.ec *



   This program lists the available databases in the database server

   of the current connection.

*/



#include <stdio.h>



/* Defines used with exception-handling function: exp_chk() */

#define WARNNOTIFY     1

#define NOWARNNOTIFY   0



/* Defines used for user-defined data structures for sqgetdbs() */

#define BUFFSZ          256

#define NUM_DBNAMES      10



main()

{

    char db_buffer[ BUFFSZ ];     /* buffer for database names */

    char *dbnames[ NUM_DBNAMES ]; /* array of pointers to database

                                       names in `db_buffer' */

    int num_returned;             /* number of database names returned */

    int ret, i;



    printf("SQGETDBS Sample ESQL Program running.\n\n");



    EXEC SQL connect to default;

    exp_chk("CONNECT TO default server", NOWARNNOTIFY);

    printf("Connected to default server.\n");



    ret = sqgetdbs(&num_returned, dbnames, NUM_DBNAMES, 

        db_buffer, BUFFSZ);

    if(ret < 0)

        {

        printf("Unable to obtain names of databases.\n");

        exit(1);

        }



    printf("\nNumber of database names returned = %d\n", num_returned);



    printf("Databases currently available:\n");

    for (i = 0; i < num_returned; i++)

        printf("\t%s\n", dbnames[i]);

    printf("\nSQGETDBS Sample Program over.\n\n");

}

    

/*

 * The exp_chk() file contains the exception handling functions to

 * check the SQLSTATE status variable to see if an error has occurred 

 * following an SQL statement. If a warning or an error has

 * occurred, exp_chk() executes the GET DIAGNOSTICS statement and 

 * displays the detail for each exception that is returned.

 */

EXEC SQL include exp_chk.ec;

For a source listing of the exp_chk() exception-handling function, see Chapter 11, "Exception Handling," of this manual.

Example Output

The output you see from the sqgetdbs sample program depends on how you set your INFORMIXSERVER and DBPATH environment variables. The following sample output assumes that the INFORMIXSERVER environment variable is set to mainserver and that this database server contains three databases that are called stores7, sysmaster, and tpc. This output also assumes that the DBPATH environment is not set.

SQGETDBS Sample ESQL Program running.



Connected to default server.



Number of database names returned = 3

Databases currently available:

	stores7@mainserver

	sysmaster@mainserver

	tpc@mainserver



SQGETDBS Sample Program over.

sqlbreak()

The sqlbreak() function sends the database server a request to interrupt processing of the current SQL request. You generally call this function to interrupt long queries.

Syntax

int sqlbreak();

Usage

The sqlbreak() function sends the interrupt request to the database server of the current connection. When the database server receives this request, it must determine if the SQL request is interruptible. Some types of database operations are not interruptible and others cannot be interrupted at certain points. You can interrupt the following SQL statements.


`SELECT`	`OPEN`	`ALTER INDEX`
`UPDATE`	`CREATE TABLE`	`EXECUTE PROCEDURE`
`DELETE`	`CREATE INDEX`
`INSERT`	`ALTER TABLE`

If the SQL request can be interrupted, the database server takes the following actions:

1. Discontinues execution of the current SQL request

2. Sets SQLCODE (sqlca.sqlcode) to a negative value (-213)

3. Returns control to the application

When the application regains control after an interrupted SQL request, any resources that are allocated to the SQL statement remain allocated. Any open databases, cursors, and transactions remain open. Any system-descriptor areas or sqlda structures remain allocated. The application program is responsible for the graceful termination of the program; it must release resources and roll back the current transaction.

While the database server executes an SQL request, the application is blocked, waiting for results from the database server. To call sqlbreak(), you must first set up some mechanism to unblock the application process. Two possible methods follow:

Provide the application end user with the ability to interrupt an SQL request once it has begun execution.

When the user presses the Interrupt key, the application becomes unblocked and calls the SIGINT signal-handler function. This signal-handler function includes a call to sqlbreak() to interrupt the database server. For more information, see

page 12-35

Specify a time-out interval with the sqlbreakcallback() function.

After the time-out interval elapses, the application becomes unblocked and calls the callback function. This callback function includes a call to sqlbreak() to interrupt the database server. For more information, see

page 12-37

Before your program calls sqlbreak(), verify with the sqldone() function that the database server is currently processing an SQL request.

Return Codes

0
The call to sqlbreak() was successful. The database server connection exists and either a request to interrupt was sent successfully or the database server was idle.

!=0
No database server is running (no database connection exists) when you called sqlbreak().

sqlbreakcallback()

The sqlbreakcallback() function allows you to specify a time-out interval and to register a callback function. The callback function provides a method for the application to regain control when the database server is processing an SQL request.

Warning: Do not use the sqlbreakcallback() function if your ESQL/C application uses shared memory (olipcshm) as the nettype to connect to an Universal Server database server. Shared memory is not a true network protocol and does not handle the nonblocking I/O that is needed to support a callback function. When you use sqlbreakcallback() with shared memory, the call appears to register the callback function successfully (it returns zero); however, during SQL requests, the application never calls the callback function.

Syntax

int sqlbreakcallback(timeout, callbackfunc_ptr);

			long timeout;

			void (* callbackfunc_ptr)(int status); 


timeout
is the interval of time to wait for an SQL request to execute before the application process regains control.


This value can be as follows:


 -1
clears the time-out value.


 0
immediately calls the function that callbackfunc_ptr indicates.


 >0  
sets the time-out interval to the number of milliseconds to elapse before the application calls the function that callbackfunc_ptr indicates.


The timeout parameter is a 4-byte variable. This parameter is operating-system dependent: it could be a variable with an int, long, or short data type.

callbackfunc_ptr  
is a pointer to the user-defined callback function.

Usage

Once you register a callback function with sqlbreakcallback(), the application calls this function at three different points in the execution of an SQL request. The value in the status argument of the callback function indicates the point at which the application calls the function. The following table summarizes the status values.


When Callback Function Is Called	Value of status Argument
When the database server begins processing an `SQL` request	status = 1
While the database server executes an `SQL` request, when the time-out interval has elapsed	status = 2
When the database server completes the processing of an `SQL` request	status = 0

When you call the callback function with a status value of 2, the callback function can determine whether the database server can continue processing with one of following actions:

It can call the sqlbreak() function to cancel the SQL request.
It can omit the call to sqlbreak() to continue the SQL request.

The callback function, and any of its subroutines, can contain only the following ESQL/C control functions: sqldone(), sqlbreak(), and sqlbreakcallback(). For more information about the callback function, see page 12-38.

If you call sqlbreakcallback() with a time-out value of zero (0), the callback function executes immediately. The callback function executes over and over again unless it contains a call to sqlbreakcallback() to redefine the callback function with one of the following actions:

It disassociates the callback function to discontinue the calling of the callback function, as follows: sqlbreakcallback(-1L, (void *)NULL);
It defines some other callback function or resets the time-out value to a nonzero value, as follows: sqlbreakcallback(timeout, callbackfunc_ptr);

Important: Small time-out values might adversely affect the performance of your application.

For more information about the time-out interval, see page 12-37.

You must establish a database server connection before you call the sqlbreakcallback() function. The callback function remains in effect for the duration of the connection or until the sqlbreakcallback() function redefines the callback function.

Return Codes

0
The call to sqlbreakcallback() was successful.

<0
The call to sqlbreakcallback() was not successful.

sqldetach()

The sqldetach() function detaches a process from the database server. You generally call this function when an application forks a new process to begin a new stream of execution.

Syntax

int sqldetach();

Usage

If an application spawns one or more processes after it initiates a connection to a database server, all the child processes inherit that database server connection from the parent process (the application process that spawned the child). However, the database server still assumes that this connection has only one process. If one database server connection tries to serve both the parent and child processes at the same time, problems can result. For example, if both processes send messages to do something, the database server has no way of knowing which messages belong to which process. The database server might not receive messages in an order that makes sense and might thereby generate an error (such as error -408).

In this situation, call the sqldetach() function from the child process. The sqldetach() function detaches the child process from the connection that the parent process establishes (which the child inherits). This action drops all database server connections in the child process. The child process can then establish its own connection to a database server.

Use the sqldetach() function with the fork() system call. When you spawn a child process from an application process with a database server connection, sequence the function calls as follows:

1. Call fork() from the parent process to create a copy of the parent process (the child process). Now both parent and child share the same connection to the database server.

2. Call sqldetach() from the child process to detach the child process from the database server. This call closes the connection in the child process.

Tip: You cannot use sqldetach() after a vfork() call because vfork() does not execute a true process fork until the exec() function is called. Do not use sqldetach() after the parent process uses an exec(); when exec() starts the child process, the child process does not inherit the connection that the parent process established.

A call to the sqldetach() function does not affect the database server sessions of the parent process. Therefore, after sqldetach() executes in the child process, the parent process retains any open cursors, transactions, or databases, and the child process has neither database server sessions nor database server connections.

When you call the sqlexit() function from the parent process, the function drops the connection in the parent process but does not affect the connections in the child process. Similarly, when you call sqlexit() from the child process, the function drops only the child connections; it does not affect the parent connections. The sqlexit() function rolls back any open transactions before it closes the connection.

If you execute the DISCONNECT statement from a child process, you disconnect the process from database server connections and terminate the database server sessions that correspond to those connections. The DISCONNECT fails if any transactions are open.

If the child process application has only one implicit connection before it calls sqldetach(), execution of the next SQL statement or of the sqlstart() library function reestablishes an implicit connection to the default database server. If the application has made one or more explicit connections, you must issue a CONNECT statement before you execute any other SQL statements.

The sqldetach demonstration program illustrates how to use the sqldetach() function.

Return Codes

0
The call to sqldetach() was successful.

<0
The call to sqldetach() was not successful.

Example

The sqldetach.ec file in the demo directory contains this sample program.

/*

   * sqldetach.ec *



   This program demonstrates how to detach a child process from a

   parent process using the ESQL/C sqldetach() library function.

*/



main()

{

    EXEC SQL BEGIN DECLARE SECTION;

        int pa;

    EXEC SQL END DECLARE SECTION;



    printf("SQLDETACH Sample ESQL Program running.\n\n");



    printf("Beginning execution of parent process.\n\n");

    printf("Connecting to default server...\n");

    EXEC SQL connect to default;

    chk("CONNECT");

    printf("\n");



    printf("Creating database 'aa'...\n");

    EXEC SQL create database aa;

    chk("CREATE DATABASE");

    printf("\n");



    printf("Creating table 'tab1'...\n");

    EXEC SQL create table tab1 (a integer);

    chk("CREATE TABLE");

    printf("\n");



    printf("Inserting 4 rows into 'tab1'...\n");

    EXEC SQL insert into tab1 values (1);

    chk("INSERT #1");

    EXEC SQL insert into tab1 values (2);

    chk("INSERT #2");

    EXEC SQL insert into tab1 values (3);

    chk("INSERT #3");

    EXEC SQL insert into tab1 values (4);

    chk("INSERT #4");

    printf("\n");



    printf("Selecting rows from 'tab1' table...\n");

    EXEC SQL declare c cursor for select * from tab1;

    chk("DECLARE");



EXEC SQL open c;

    chk("OPEN");



    printf("\nForking child process...\n");

    fork_child();



    printf("\nFetching row from cursor 'c'...\n"); 

    EXEC SQL fetch c into $pa;

    chk("Parent FETCH");

    if (sqlca.sqlcode == 0)

        printf("Value selected from 'c' = %d.\n", pa); 

    printf("\n");



    printf("Cleaning up...\n");

    EXEC SQL close database;

    chk("CLOSE DATABASE");

    EXEC SQL drop database aa;

    chk("DROP DATABASE");

    EXEC SQL disconnect all;

    chk("DISCONNECT");



    printf("\nEnding execution of parent process.\n");

    printf("\nSQLDETACH Sample Program over.\n\n");

}



fork_child()

{

    int rc, status, pid;



    EXEC SQL BEGIN DECLARE SECTION;

        int cnt, ca;

    EXEC SQL END DECLARE SECTION;



    pid = fork();

    if (pid < 0)

        printf("can't fork child.\n");



    else if (pid == 0)

	{

        printf("\n**********************************************\n");

        printf("* Beginning execution of child process.\n");

        rc = sqldetach();

        printf("* sqldetach() call returns %d.\n", rc);



        /* Verify that the child is not longer using the parent's

         * connection and has not inherited the parent's connection

         * environment.

         */

        printf("* Trying to fetch row from cursor 'c'...\n"); 

        EXEC SQL fetch c into $ca;

        chk("* Child FETCH");

        if (sqlca.sqlcode == 0)

            printf("* Value from 'c' = %d.\n", ca); 



        /* startup a connection for the child, since

         * it doesn't have one.

         */

        printf("\n* Establish a connection, since child doesn't have one\n");

        printf("* Connecting to database 'aa'...\n");

        EXEC SQL connect to 'aa';

        chk("* CONNECT");

        printf("* \n");

		printf("* Determining number of rows in 'tab1'...\n");

        EXEC SQL select count(*) into $cnt from tab1;

        chk("* SELECT");

        if (sqlca.sqlcode == 0)

            printf("* Number of entries in 'tab1' =  %d.\n", cnt);

        printf("* \n");



        printf("* Disconnecting from 'aa' database...\n");

        EXEC SQL disconnect current;

        chk("* DISCONNECT");

        printf("* \n");

        printf("* Ending execution of child process.\n");

        printf("**********************************************\n");



        exit();

	}



    /* wait for child process to finish */

    while ((rc = wait(&status)) != pid && rc != -1);



}



chk(s)

char *s;

{

    int msglen;

    char buf1[200], buf2[200];



    if (SQLCODE == 0)

	{

        printf("%s was successful\n", s);

        return;

	}

    printf("\n%s:\n", s);

    if (SQLCODE)

	{

        printf("\tSQLCODE =  %6d: ", SQLCODE);

        rgetlmsg(SQLCODE, buf1, sizeof(buf1), &msglen);

        sprintf(buf2, buf1, sqlca.sqlerrm);

        printf(buf2);

        if (sqlca.sqlerrd[1])

	    {

            printf("\tISAM Error =  %6hd: ", sqlca.sqlerrd[1]);

            rgetlmsg(sqlca.sqlerrd[1], buf1, sizeof(buf1), &msglen);

            sprintf(buf2, buf1, sqlca.sqlerrm);

            printf(buf2);

	    }

	}

}

Example Output

SQLDETACH Sample ESQL Program running.



Beginning execution of parent process.



Connecting to default server...

CONNECT was successful



Creating database 'aa'...

CREATE DATABASE was successful



Creating table 'tab1'...

CREATE TABLE was successful



Inserting 4 rows into 'tab1'...

INSERT #1 was successful

INSERT #2 was successful

INSERT #3 was successful

INSERT #4 was successful



Selecting rows from 'tab1' table...

DECLARE was successful

OPEN was successful



Forking child process...



**********************************************

* Beginning execution of child process.

* sqldetach() call returns 0.

* Trying to fetch row from cursor 'c'...



* Child FETCH:

	SQLCODE =    -404: The cursor or statement is not available.



* Establish a connection, since child doesn't have one

* Connecting to database 'aa'...

* CONNECT was successful

* 

* Determining number of rows in 'tab1'...

* SELECT was successful

* Number of entries in 'tab1' =  4.

* 

* Disconnecting from 'aa' database...

* DISCONNECT was successful

* 

* Ending execution of child process.

**********************************************

SQLDETACH Sample ESQL Program running.



Beginning execution of parent process.



Connecting to default server...

CONNECT was successful



Creating database 'aa'...

CREATE DATABASE was successful



Creating table 'tab1'...



CREATE TABLE was successful



Inserting 4 rows into 'tab1'...

INSERT #1 was successful

INSERT #2 was successful

INSERT #3 was successful

INSERT #4 was successful



Selecting rows from 'tab1' table...

DECLARE was successful

OPEN was successful



Forking child process...



Fetching row from cursor 'c'...

Parent FETCH was successful

Value selected from 'c' = 1.



Cleaning up...

CLOSE DATABASE was successful

DROP DATABASE was successful

DISCONNECT was successful



Ending execution of parent process.



SQLDETACH Sample Program over.

sqldone()

The sqldone() function determines whether the database server is currently processing an SQL request.

Syntax

int sqldone();

Usage

Use sqldone() to test the status of the database server in the following situations:

Before a call to the sqlbreak() function to determine if the database server is processing an SQL request.
In a signal-handler function, before a call to the longjmp() system function. Only use longjmp() in a signal-handler function if sqldone() returns zero (the database server is idle).

When the sqldone() function determines that the database server is not currently processing an SQL request, you can assume that the database server does not begin any other processing until your application issues its next request.

You might want to create a defined constant for the -439 value to make your code more readable. For example, the following code fragment creates the SERVER_BUSY constant and then uses it to test the sqldone() return status:

#define SERVER_BUSY -439
...
if (sqldone() == SERVER_BUSY)

Return Codes

0
The database server is not currently processing an SQL request: it is idle.

-439
The database server is currently processing an SQL request.

sqlexit()

The sqlexit() function terminates all database server connections and frees resources. You can use sqlexit() to reduce database overhead in programs that refer to a database only briefly and after long intervals, or that access a database only during initialization.

Syntax

int sqlexit();

Usage

Only call the sqlexit() function when no databases are open. If an open database uses transactions, sqlexit() rolls back any open transactions before it closes the database. The behavior of this function is similar to that of the DISCONNECT ALL statement. However, the DISCONNECT ALL statement fails if any current transactions exist. Use the CLOSE DATABASE statement to close open databases before you call sqlexit().

If the application has only one implicit connection before it calls sqlexit(), execution of the next SQL statement or of the sqlstart() library function re-establishes an implicit connection to the default database server. If the application makes one or more explicit connections, you must issue a CONNECT statement before you execute any other SQL statements.

Return Codes

0
The call to sqlexit() was successful.

<0
The call to sqlexit() was not successful.

sqlsignal()

The sqlsignal() function enables, disables, or reenables signal handling of the signals that the ESQL/C library handles.

Syntax

void sqlsignal(sigvalue, sigfunc_ptr, mode)

			int sigvalue;

			void (*sigfunc_ptr) (void);

			short mode; 


sigvalue
is the integer value of the particular signal that needs to be trapped (as signal.h) defines). 


Currently, this parameter is a placeholder for future functionality. Initialize this argument to -1.

sigfunc_ptr  
is a pointer to the user-defined function, which takes no arguments, to call as a signal handler for the sigvalue signal.


Currently, this parameter is a placeholder for future functionality. Initialize this argument to a null pointer to a function that receives no arguments.

mode
is one of three possible modes:


 0
initializes signal handling.


 1
disables signal handling.


 2  
re-enables signal handling.

Usage

The sqlsignal() function currently provides handling only for the SIGCHLD signal. In some instances, defunct child processes remain after the application ends. If the application does not clean up these processes, they can cause needless use of process IDs and increase the risk that you run out of processes. This behavior is only apparent when the application uses pipes for client-server communication (that is, the nettype field of the sqlhosts file is ipcpip). You do not need to call sqlsignal() for other communication mechanisms (for example, a nettype of tlipcp).

The mode argument of sqlsignal() determines the task that sqlsignal() performs, as follows:

Set mode to 0 to initialize signal handling. sqlsignal(-1, (void (*)()), 0);

sqlsignal()

SIGCHLD

sqlsignal()

beginning

Enable and disable signal handling.

If you want to have the ESQL/C library perform signal handling for portions of the program and your own code perform signal handling for other portions, you can take the following actions:

To disable signal handling, call sqlsignal() with mode set to 1, at the point where you want your program to handle signals: sqlsignal(-1, (void (*)()), 1);
To re-enable signal handling, call sqlsignal() with mode set to 2, at the point where you want the INFORMIX-ESQL library to handle signals: sqlsignal(-1, (void (*)()), 2);

When you initialize SIGCHLD signal handling with sqlsignal(), you allow the ESQL/C library to process SIGCHLD cleanup. Otherwise, your application must perform the cleanup for these processes if defunct child processes are a problem.

sqlstart()

The sqlstart() function starts an implicit default connection. An implicit default connection can support one connection to the default database server (that the INFORMIXSERVER environment variable specifies).

Tip: Restrict use of sqlstart() to pre-Version 6.0 applications that only use one connection. ESQL/C continues to support this function for backward compatibility with these applications. For applications of Version 6.0 and later, use the CONNECT statement to establish explicit connections to a default database server.

Syntax

int sqlstart();

Usage

ESQL/C provides the sqlstart() function for pre-Version 6.0 applications that can only support single connections. In this context, possible uses of sqlstart() are as follows:

You only need to verify that the default database server is available but you do not intend to open a database. If the call to sqlstart() fails, you can check the return status to verify that the default database server is not available.
You need to speed up the execution of the DATABASE statement when the application runs over a network. When you put the call to sqlstart() in an initialization routine, the application establishes a connection before the user begins interaction with the application. The DATABASE statement can then open the specified database.
You do not know the name of the actual database to access, or your application plans to create a database. The call to sqlstart() can establish the implicit default connection and the application can later determine the name of the database to access or create.

If you have a pre-Version 6.0 application that needs an implicit default connection for any other reason, use the DATABASE statement instead of sqlstart(). For applications of Version 6.0 and later, use the CONNECT statement to establish database server connections.

When you call the sqlstart() function, make sure that the application has not yet established any connections, implicit or explicit. When the application has established an explicit connection, sqlstart() returns error -1811. If an implicit connection has been established, sqlstart() returns error -1802.

You can call this function several times before you establish an explicit connection, as long as each implicit connection is disconnected before the next call to sqlstart(). For information on disconnecting, see "Terminating a Connection". For more information on explicit and implicit connections, see "Establishing a Connection".

Informix-ESQL/C Programmer's ManualChapter 12: Working with the Database Server Home Contents Index Master Index New Book

Using Database Server Control Functions

Usage

Return Codes Name of current connection Successfully obtained current connection name Null pointer Unable to obtain current connection name or current connection does not have an explicit name

sqgetdbs()

Usage

Return Codes 0 Successfully obtained database names <0 Unable to obtain database names

Example

sqlbreak()

Usage

Return Codes 0 The call to sqlbreak() was successful. The database server connection exists and either a request to interrupt was sent successfully or the database server was idle. !=0 No database server is running (no database connection exists) when you called sqlbreak().

sqlbreakcallback()

Usage

Return Codes 0 The call to sqlbreakcallback() was successful. <0 The call to sqlbreakcallback() was not successful.

sqldetach()

Usage

Return Codes 0 The call to sqldetach() was successful. <0 The call to sqldetach() was not successful.

Example

Example Output

sqldone()

Usage

Return Codes 0 The database server is not currently processing an SQL request: it is idle. -439 The database server is currently processing an SQL request.

sqlexit()

Usage

Return Codes 0 The call to sqlexit() was successful. <0 The call to sqlexit() was not successful.

sqlsignal()

Usage

Usage

Return Codes 0 The call to sqlstart() was successful. <0 The call to sqlstart() was not successful.

Informix-ESQL/C Programmer's Manual
Chapter 12: Working with the Database Server

Home Contents Index Master Index New Book

Return Codes

Name of current
connection

Successfully obtained current connection name

Null pointer

Unable to obtain current connection name or current connection does not have an explicit name

Return Codes

0

Successfully obtained database names

<0

Unable to obtain database names

Return Codes

0
The call to sqlbreak() was successful. The database server connection exists and either a request to interrupt was sent successfully or the database server was idle.

!=0
No database server is running (no database connection exists) when you called sqlbreak().

Return Codes

0
The call to sqlbreakcallback() was successful.

<0
The call to sqlbreakcallback() was not successful.

Return Codes

0
The call to sqldetach() was successful.

<0
The call to sqldetach() was not successful.

Return Codes

0
The database server is not currently processing an SQL request: it is idle.

-439
The database server is currently processing an SQL request.

Return Codes

0
The call to sqlexit() was successful.

<0
The call to sqlexit() was not successful.

Return Codes

0
The call to sqlstart() was successful.

<0
The call to sqlstart() was not successful.