SQL relay的C接口

  1<sqlrelay sqlrclientwrapper.h="">
  2&gt;     
  3
  4You'll also need to link against the sqlrclientwrapper, sqlrclient and rudiments libraries. The include file is usually found in /usr/local/firstworks/include and the libraries are usually found in /usr/local/firstworks/lib. 
  5
  6The command to compile your .c file to object code will look something like this (assuming you're using the GNU C compiler): 
  7
  8&gt; gcc -I/usr/local/firstworks/include -c myprogram.c 
  9
 10The command to compile your .o file to an executable will look something like this (assuming you're using the GNU C++ compiler): 
 11
 12&gt; g++ -o myprogram myprogram.o -L/usr/local/firstworks/lib -lsqlrclientwrapper -lsqlrclient -lrudiments 
 13
 14Note that g++ was used to link, not gcc. You could alternatively link using gcc like this: 
 15
 16&gt; gcc -o myprogram myprogram.o -L/usr/local/firstworks/lib -lsqlrclientwrapper -lsqlrclient -lrudiments -lstdc++ 
 17
 18When using the C API, it is important to compile the .c files to object code using the C compiler before linking them using the C++ compiler. Compiling/Linking in one step using the C++ compiler the will most likely fail as it will generate C++ style symbols for function calls which will not be resolved in the sqlrclientwrapper library since it contains C style function symbols. Compiling to object code using the C compiler as a seperate step ensures that C style symbols will be generated for function calls. 
 19
 20Establishing a Session    
 21  
 22
 23
 24To use SQL Relay, you have to identify the connection that you intend to use. 
 25
 26&gt; 
 27&gt;     #include <sqlrelay sqlrclientwrapper.h="">
 28&gt;     #include <stdio.h>
 29&gt;     
 30&gt;     main() {
 31&gt;     
 32&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
 33&gt;     
 34&gt;             ... execute some queries ...
 35&gt;     
 36&gt;             sqlrcon_free(con);
 37&gt;     }
 38&gt;     
 39
 40After calling the constructor, a session is established when the first query, sqlrcur_ping() or sqlrcur_identify() is run. 
 41
 42For the duration of the session, the client stays connected to a database connection daemon. While one client is connected, no other client can connect. Care should be taken to minimize the length of a session. 
 43
 44If you're using a transactional database, ending a session has a catch. Database connection daemons can be configured to send either a commit or rollback at the end of a session if DML queries were executed during the session with no commit or rollback. Program accordingly. 
 45
 46Executing Queries    
 47  
 48
 49
 50Call sqlrcur_sendQuery() or sqlrcur_sendFileQuery() to run a query. 
 51
 52&gt; 
 53&gt;     #include <sqlrelay sqlrclientwrapper.h="">
 54&gt;     #include <stdio.h>
 55&gt;     
 56&gt;     main() {
 57&gt;     
 58&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
 59&gt;             sqlrcur      cur=sqlrcur_alloc(con);
 60&gt;     
 61&gt;             sqlrcur_sendQuery(cur,"select * from my_table");
 62&gt;     
 63&gt;             ... do some stuff that takes a **short** time ...
 64&gt;     
 65&gt;             sqlrcur_sendFileQuery(cur,"/usr/local/myprogram/sql","myquery.sql");
 66&gt;             sqlrcon_endSession(con);
 67&gt;     
 68&gt;             ... do some stuff that takes a **long** time ...
 69&gt;     
 70&gt;             sqlrcur_sendQuery(cur,"select * from my_other_table");
 71&gt;             sqlrcon_endSession(con);
 72&gt;     
 73&gt;             ... process the result set ...
 74&gt;     
 75&gt;             sqlrcur_free(cur);
 76&gt;             sqlrcon_free(con);
 77&gt;     }
 78&gt;     
 79
 80Note the call to sqlrcon_endSession() after the call to sqlrcur_sendFileQuery(). Since the program does some stuff that takes a long time between that query and the next, ending the session there allows another client an opportunity to use that database connection while your client is busy. The next call to sqlrcur_sendQuery() establishes another session. Since the program does some stuff that takes a short time between the first two queries, it's OK to leave the session open between them. 
 81
 82Commits and Rollbacks    
 83  
 84
 85
 86If you need to execute a commit or rollback, you should use the sqlrcon_commit() and sqlrcon_rollback() functions rather than sending a "commit" or "rollback" query. There are two reasons for this. First, it's much more efficient to call the methods. Second, if you're writing code that can run on transactional or non-transactional databases, some non-transactional databases will throw errors if they receive a "commit" or "rollback" query, but by calling the sqlrcon_commit() and sqlrcon_rollback() functions you instruct the database connection daemon to call the commit and rollback API methods for that database rather than issuing them as queries. If the API's have no commit or rollback methods, the calls do nothing and the database throws no error. This is especially important when using SQL Relay with ODBC. 
 87
 88You can also turn Autocommit on or off with the sqlrcon_autoCommitOn() and sqlrcon_autoCommitOff() functions. When Autocommit is on, the database performs a commit after each successful DML or DDL query. When Autocommit is off, the database commits when the client instructs it to, or (by default) when a client disconnects. For databases that don't support Autocommit, sqlrcon_autoCommitOn() and sqlrcon_autoCommitOff() have no effect. 
 89
 90Temporary Tables    
 91  
 92
 93
 94Some databases support temporary tables. That is, tables which are automatically dropped or truncated when an application closes it's connection to the database or when a transaction is committed or rolled back. 
 95
 96For databases which drop or truncate tables when a transaction is committed or rolled back, temporary tables work naturally. 
 97
 98However, for databases which drop or truncate tables when an application closes it's connection to the database, there is an issue. Since SQL Relay maintains persistent database connections, when an application disconnects from SQL Relay, the connection between SQL Relay and the database remains, so the database does not know to drop or truncate the table. To remedy this situation, SQL Relay parses each query to see if it created a temporary table, keeps a list of temporary tables and drops (or truncates them) when the application disconnects from SQL Relay. Since each database has slightly different syntax for creating a temporary table, SQL Relay parses each query according to the rules for that database. 
 99
100In effect, temporary tables should work when an application connects to SQL Relay in the same manner that they would work if the application connected directly to the database. 
101
102Catching Errors    
103  
104
105
106If your call to sqlrcur_sendQuery() or sqlrcur_sendFileQuery() returns a 0, the query failed. You can find out why by calling sqlrcur_errorMessage(). 
107
108&gt; 
109&gt;     #include <sqlrelay sqlrclientwrapper.h="">
110&gt;     #include <stdio.h>
111&gt;     
112&gt;     main() {
113&gt;     
114&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
115&gt;             sqlrcur      cur=sqlrcur_alloc(con);
116&gt;     
117&gt;             **if** (!sqlrcur_sendQuery(cur,"select * from my_nonexistant_table")) {
118&gt;                     printf("%s\n",sqlrcur_errorMessage(cur));
119&gt;             }
120&gt;     
121&gt;             sqlrcur_free(cur);
122&gt;             sqlrcon_free(con);
123&gt;     }
124&gt;     
125
126Substitution and Bind Variables    
127  
128
129
130Programs rarely execute fixed queries. More often than not, some part of the query is dynamically generated. It's convenient to store queries in files so they can be changed by a non-C programmer. The SQL Relay API provides functions for making substitutions and binds in those queries. 
131
132For a detailed discussion of substitutions and binds, see  this document  . 
133
134Rather than just calling sqlrcur_sendFileQuery() you call sqlrcur_prepareFileQuery(), one or more of sqlrcur_subString(), sqlrcur_subLong() or sqlrcur_subDouble, one or more of sqlrcur_inputBindString(), sqlrcur_inputBindLong() or sqlr_inputBindDouble() and sqlrcur_executeQuery(). 
135
136&gt; 
137&gt;     /usr/local/myprogram/sql/myquery.sql:
138&gt;     
139&gt;     	select * from mytable $(whereclause)
140&gt;     
141&gt;     Program code:  
142&gt;     &gt; 
143&gt;     #include <sqlrelay sqlrclientwrapper.h="">
144&gt;     #include <stdio.h>
145&gt;     
146&gt;     main() {
147&gt;     
148&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
149&gt;             sqlrcur      cur=sqlrcur_alloc(con);
150&gt;     
151&gt;             sqlrcur_prepareFileQuery(cur,"/usr/local/myprogram/sql","myquery.sql");
152&gt;             sqlrcur_subString(cur,"whereclause","where col1=:value1");
153&gt;             sqlrcur_inputBindString(cur,"value1","true");
154&gt;             sqlrcur_executeQuery(cur);
155&gt;     
156&gt;             ... process the result set ...
157&gt;     
158&gt;             sqlrcur_free(cur);
159&gt;             sqlrcon_free(con);
160&gt;     }
161&gt;     
162
163If you're using a database with an embedded procedural language, you may want to retrieve data from a call to one of it's functions. To facilitate this, SQL Relay provides the sqlrcur_defineOutputBind() and sqlrcur_getOutputBind() methods. 
164
165&gt; PL/SQL Procedure:   
166&gt; 
167&gt;     
168&gt;     
169&gt;     FUNCTION sp_mytable RETURN types.cursorType
170&gt;     l_cursor types.cursorType;
171&gt;     BEGIN
172&gt;             OPEN l_cursor FOR **SELECT** * FROM mytable;
173&gt;             RETURN l_cursor;
174&gt;     END;
175&gt;     
176&gt; 
177&gt;   
178&gt;  Program code: 
179&gt;     
180&gt;     
181&gt;     #include <sqlrelay sqlrclientwrapper.h="">
182&gt;     #include <stdio.h>
183&gt;     
184&gt;     main() {
185&gt;     
186&gt;             **int**        result;
187&gt;     
188&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
189&gt;             sqlrcur      cur=sqlrcur_alloc(con);
190&gt;     
191&gt;             sqlrcur_prepareQuery(cur,"begin  :result:=addTwoNumbers(:num1,:num2);  end;");
192&gt;             sqlrcur_inputBindLong(cur,"num1",10);
193&gt;             sqlrcur_inputBindLong(cur,"num2",20);
194&gt;             sqlrcur_defineOutputBind(cur,"result",100);
195&gt;             sqlrcur_executeQuery(cur);
196&gt;             result=atoi(sqlrcur_getOutputBind(cur,"result"));
197&gt;             sqlrcon_endSession(con);
198&gt;     
199&gt;             ... do something with the result ...
200&gt;     
201&gt;             sqlrcur_free(cur);
202&gt;             sqlrcon_free(con);
203&gt;     }
204&gt;     
205
206The sqlrcur_getOutputBind() function returns a NULL value as an empty string. If you would it to come back as a NULL instead, you can call the sqlrcur_getNullsAsNulls() method. To revert to the default behavior, you can call sqlrcur_getNullsAsEmptyStrings(). 
207
208The sqlrcur_getOutputBind() function returns a string, if you would like to get the value as a long or double, you can use sqlrcur_getOutputBindAsLong() or sqlrcur_getOutputBindAsDouble(). 
209
210If you are using Oracle 8i or higher, you can insert data into BLOB and CLOB columns using the inputBindBlob(), inputBindClob() methods. 
211
212If you are curious how many bind variables have been declared in a query, you can call sqlrcur_countBindVariables() after preparing the query. 
213
214&gt; 
215&gt;     #include <sqlrelay sqlrclientwrapper.h="">
216&gt;     
217&gt;     main() {
218&gt;     
219&gt;             sqlrcon         con=sqlrcon_alloc("host",9000,"","user","password",0,1);
220&gt;             sqlrcur         cur=sqlrcur_alloc(con);
221&gt;     
222&gt;             sqlrcur_executeQuery(cur,"create table images (image blob, description clob)");
223&gt;     
224&gt;             **unsigned** **char**   imagedata[40000];
225&gt;             **unsigned** **long**   imagelength;
226&gt;     
227&gt;             ... read an image from a file into imagedata and the length of the
228&gt;                     file into imagelength ...
229&gt;     
230&gt;             **unsigned** **char**   description[40000];
231&gt;             **unsigned** **long**   desclength;
232&gt;     
233&gt;             ... read a description from a file into description and the length of
234&gt;                     the file into desclength ...
235&gt;     
236&gt;             sqlrcur_prepareQuery(cur,"insert into images values (:image,:desc)");
237&gt;             sqlrcur_inputBindBlob(cur,"image",imagedata,imagelength);
238&gt;             sqlrcur_inputBindClob(cur,"desc",description,desclength);
239&gt;             sqlrcur_executeQuery(cur);
240&gt;     
241&gt;             sqlrcur_free(cur);
242&gt;             sqlrcur_free(con);
243&gt;     }
244&gt;     
245
246Likewise, with Oracle 8i, you can retreive BLOB or CLOB data using defineOutputBindBlob(), defineOutputBindClob(), getOutputBind() and getOutputBindLength(). 
247
248&gt; 
249&gt;     #include <sqlrelay sqlrclientwrapper.h="">
250&gt;     
251&gt;     main() {
252&gt;     
253&gt;             sqlrcon         con=sqlrcon_alloc("host",9000,"","user","password",0,1);
254&gt;             sqlrcur         cur=sqlrcur_alloc(con);
255&gt;     
256&gt;             sqlrcur_prepareQuery(cur,"begin  select image into :image from images;  select description into :desc from images;  end;");
257&gt;             sqlrcur_defineOutputBindBlob(cur,"image");
258&gt;             sqlrcur_defineOutputBindClob(cur,"desc");
259&gt;             sqlrcur_executeQuery(cur);
260&gt;     
261&gt;             **char**    *image=sqlrcur_getOutputBind(cur,"image");
262&gt;             **long**    imagelength=sqlrcur_getOutputBindLength(cur,"image");
263&gt;     
264&gt;             **char**    *desc=sqlrcur_getOutputBind(cur,"desc");
265&gt;             **char**    *desclength=sqlrcur_getOutputBindLength(cur,"desc");
266&gt;     
267&gt;             sqlrcon_endSession(con);
268&gt;     
269&gt;             ... do something with image and desc ...
270&gt;     
271&gt;             sqlrcur_free(cur);
272&gt;             sqlrcon_free(con);
273&gt;     }
274&gt;     
275
276Sometimes it's convenient to bind a bunch of variables that may or may not actually be in the query. For example, if you are building a web based application, it may be easy to just bind all the form variables/values from the previous page, even though some of them don't appear in the query. Databases usually generate errors in this case. Calling validateBinds() just prior to calling executeQuery() causes the API to check the query for each bind variable before actually binding it, preventing those kinds of errors. There is a performance cost associated with calling validateBinds(). 
277
278Re-Binding and Re-Execution    
279  
280
281
282Another feature of the prepare/bind/execute paradigm is the ability to prepare, bind and execute a query once, then re-bind and re-execute the query over and over without re-preparing it. If your backend database natively supports this paradigm, you can reap a substantial performance improvement. 
283
284&gt; 
285&gt;     #include <sqlrelay sqlrclientwrapper.h="">
286&gt;     #include <stdio.h>
287&gt;     
288&gt;     main() {
289&gt;     
290&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
291&gt;             sqlrcur      cur=sqlrcur_alloc(con);
292&gt;     
293&gt;             sqlrcur_prepareQuery(cur,"select * from mytable where mycolumn&gt;:value");
294&gt;             sqlrcur_inputBindLong(cur,"value",1);
295&gt;             sqlrcur_executeQuery(cur);
296&gt;     
297&gt;             ... process the result set ...
298&gt;     
299&gt;             sqlrcur_clearBinds(cur);
300&gt;             sqlrcur_inputBindLong(cur,"value",5);
301&gt;             sqlrcur_executeQuery(cur);
302&gt;     
303&gt;             ... process the result set ...
304&gt;     
305&gt;             sqlrcur_clearBinds(cur);
306&gt;             sqlrcur_inputBindLong(cur,"value",10);
307&gt;             sqlrcur_executeQuery(cur);
308&gt;     
309&gt;             ... process the result set ...
310&gt;     
311&gt;             sqlrcur_free(cur);
312&gt;             sqlrcon_free(con);
313&gt;     }
314&gt;     
315
316Accessing Fields in the Result Set    
317  
318
319
320The sqlrcur_rowCount(), sqlrcur_colCount(), sqlrcur_getFieldByName() and sqlrcur_getFieldByIndex() functions are useful for processing result sets. 
321
322&gt; 
323&gt;     #include <sqlrelay sqlrclientwrapper.h="">
324&gt;     #include <stdio.h>
325&gt;     
326&gt;     main() {
327&gt;     
328&gt;             **int**        row,col;
329&gt;     
330&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
331&gt;             sqlrcur      cur=sqlrcur_alloc(con);
332&gt;     
333&gt;             sqlrcur_sendQuery(cur,"select * from my_table");
334&gt;             sqlrcon_endSession(con);
335&gt;     
336&gt;             **for** (row=0; row<sqlrcur_rowcount(cur); row++)="" {="">                     **for** (col=0; col<sqlrcur_colcount(cur); col++)="" {="">                             printf("%s,",sqlrcur_getFieldByIndex(cur,row,col));
337&gt;                     }
338&gt;                     printf("\n");
339&gt;             }
340&gt;     
341&gt;             sqlrcur_free(cur);
342&gt;             sqlrcon_free(con);
343&gt;     }
344&gt;     
345
346The sqlrcur_getFieldByName() and sqlrcur_getFieldByIndex() functions return strings. If you would like to get a field as a long or double, you can use sqlrcur_getFieldAsLongByName()/sqlrcur_getFieldAsLongByIndex() and sqlrcur_getFieldAsDoubleByName()/sqlrcur_getFieldAsDoubleByIndex(). 
347
348You can also use sqlrcur_getRow() which returns a NULL-terminated array of the fields in the row. 
349
350&gt; 
351&gt;     #include <sqlrelay sqlrclientwrapper.h="">
352&gt;     #include <stdio.h>
353&gt;     
354&gt;     main() {
355&gt;     
356&gt;             **int**        row,col;
357&gt;     
358&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
359&gt;             sqlrcur      cur=sqlrcur_alloc(con);
360&gt;     
361&gt;             sqlrcur_sendQuery(cur,"select * from my_table");
362&gt;             sqlrcon_endSession(con);
363&gt;     
364&gt;             **for** (row=0; row<sqlrcur_rowcount(cur); row++)="" {="">                     **char**    **rowarray=sqlrcur_getRow(cur,row);
365&gt;                     **for** (col=0; col<sqlrcur_colcount(cur); col++)="" {="">                             printf("%s,",rowarray[col]);
366&gt;                     }
367&gt;                     printf("\n");
368&gt;             }
369&gt;     
370&gt;             sqlrcur_free(cur);
371&gt;             sqlrcon_free(con);
372&gt;     }
373&gt;     
374
375The sqlrcur_getFieldByIndex(), sqlrcur_getFieldByName() and sqlrcur_getRow() functions return NULL fields as empty strings. If you would like them to come back as NULL's instead, you can call the sqlrcur_getNullsAsNulls() method. To revert to the default behavior, you can call sqlrcur_getNullsAsEmptyStrings(). 
376
377If you want to access the result set, but don't care about the column information (column names, types or sizes) and don't mind getting fields by their numeric index instead of by name, you can call the sqlrcur_dontGetColumnInfo() method prior to executing your query. This can result in a performance improvement, especially when many queries with small result sets are executed in rapid succession. You can call sqlrcur_getColumnInfo() again later to turn off this feature. 
378
379Dealing With Large Result Sets    
380  
381
382
383SQL Relay normally buffers the entire result set. This can speed things up at the cost of memory. With large enough result sets, it makes sense to buffer the result set in chunks instead of all at once. 
384
385Use sqlrcur_setResultSetBufferSize() to set the number of rows to buffer at a time. Calls to sqlrcur_getRow(), sqlrcur_getFieldByIndex() and sqlrcur_getFieldByName() cause the chunk containing the requested field to be fetched. Rows in that chunk are accessible but rows before it are not. 
386
387For example, if you setResultSetBufferSize(5) and execute a query that returns 20 rows, rows 0-4 are available at once, then rows 5-9, then 10-14, then 15-19. When rows 5-9 are available, getFieldByIndex(0,0) will return NULL and getFieldByIndex(11,0) will cause rows 10-14 to be fetched and return the requested value. 
388
389When buffering the result set in chunks, don't end the session until after you're done with the result set. 
390
391If you call sqlrcur_setResultSetBufferSize() and forget what you set it to, you can always call sqlrcur_getResultSetBufferSize(). 
392
393When buffering a result set in chunks, the sqlrcur_rowCount() method returns the number of rows returned so far. The sqlrcur_firstRowIndex() method returns the index of the first row of the currently buffered chunk. 
394
395&gt; 
396&gt;     #include <sqlrelay sqlrclientwrapper.h="">
397&gt;     #include <stdio.h>
398&gt;     
399&gt;     main() {
400&gt;     
401&gt;             **int**     done=0;
402&gt;             **int**     row=0;
403&gt;             **int**     col;
404&gt;             **char**    *field;
405&gt;     
406&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
407&gt;             sqlrcur      cur=sqlrcur_alloc(con);
408&gt;     
409&gt;             sqlrcur_setResultSetBufferSize(cur,5);
410&gt;     
411&gt;             sqlrcur_sendQuery(cur,"select * from my_table");
412&gt;     
413&gt;             **while** (!done) {
414&gt;                     **for** (col=0; col<sqlrcur_colcount(cur); col++)="" {="">                             **if** (field=sqlrcur_getFieldByIndex(cur,row,col)) {
415&gt;                                     printf("%s,",field);
416&gt;                             } **else** {
417&gt;                                     done=1;
418&gt;                             }
419&gt;                     }
420&gt;                     printf("\n");
421&gt;                     row++;
422&gt;             }
423&gt;     
424&gt;             sqlrcur_sendQuery(cur,"select * from my_other_table");
425&gt;     
426&gt;             ... process this query's result set in chunks also ...
427&gt;     
428&gt;             sqlrcur_setResultSetBufferSize(cur,0);
429&gt;     
430&gt;             sqlrcur_sendQuery(cur,"select * from my_third_table");
431&gt;     
432&gt;             ... process this query's result set all at once ...
433&gt;     
434&gt;             sqlrcon_endSession(con);
435&gt;     
436&gt;             sqlrcur_free(cur);
437&gt;             sqlrcon_free(con);
438&gt;     }
439&gt;     
440
441Cursors    
442  
443
444
445Cursors make it possible to execute queries while processing the result set of another query. You can select rows from a table in one query, then iterate through it's result set, inserting rows into another table, using only 1 database connection for both operations. 
446
447For example: 
448    
449    
450    #include <sqlrelay sqlrclientwrapper.h="">
451    
452    main() {
453    
454            sqlrcon      con;
455            sqlrcur      cursor1;
456            sqlrcur      cursor2;
457            **int**          index;
458    
459            con=new sqlrcon_alloc("host",9000,"","user","password",0,1);
460            cursor1=new sqlrcur_alloc(con);
461            cursor2=new sqlrcur_alloc(con);
462    
463            sqlrcur_setResultSetBufferSize(cursor1,10);
464            sqlrcur_sendQuery(cursor1,"select * from my_huge_table");
465    
466            index=0;
467            **while** (!sqlrcur_endOfResultSet(cursor1)) {
468                    sqlrcur_prepareQuery(cursor2,"insert into my_other_table values (:1,:2,:3)");
469                    sqlrcur_inputBindString(cursor2,"1",sqlrcur_getFieldByIndex(cursor1,index,1));
470                    sqlrcur_inputBindString(cursor2,"2",sqlrcur_getFieldByIndex(cursor1,index,2));
471                    sqlrcur_inputBindString(cursor2,"3",sqlrcur_getFieldByIndex(cursor1,index,3));
472                    sqlrcur_executeQuery(cursor2);
473            }
474    
475            sqlrcur_free(cursor2);
476            sqlrcur_free(cursor1);
477            sqlrcon_free(con);
478    }
479    
480
481Prior to SQL Relay version 0.25, you would have had to buffer the first result set or use 2 database connections instead of just 1. 
482
483If you are using stored procedures with Oracle 8i or higher, a stored procedure can execute a query and return a cursor. A cursor bind variable can then retrieve that cursor. Your program can retrieve the result set from the cursor. All of this can be accomplished using defineOutputBindCursor(), getOutputBindCursor() and fetchFromOutputBindCursor(). 
484
485&gt; 
486&gt;     #include <sqlrelay sqlrclientwrapper.h="">
487&gt;     #include <stdio.h>
488&gt;     
489&gt;     main() {
490&gt;     
491&gt;             **int**        i,j;
492&gt;     
493&gt;             sqlrcon         con=sqlrcon_alloc("host",9000,"","user","password",0,1);
494&gt;             sqlrcur         cur=sqlrcur_alloc(con);
495&gt;     
496&gt;             sqlrcur_prepareQuery(cur,"begin  :curs:=sp_mytable; end;");
497&gt;             sqlrcur_defineOutputBindCursor(cur,"curs");
498&gt;             sqlrcur_executeQuery(cur);
499&gt;     
500&gt;             sqlrcur         bindcur=sqlrcur_getOutputBindCursor(cur,"curs");
501&gt;             sqlrcur_fetchFromBindCursor(bindcur);
502&gt;     
503&gt;             // print fields from table
504&gt;             **for** (i=0; i<sqlrcur_rowcount(bindcur); i++)="" {="">                     **for** (j=0; j<sqlrcur_colcount(bindcur); j++)="" {="">                             printf("%s,",sqlrcur_getFieldByIndex(bindcur,i,j));
505&gt;                     }
506&gt;                     printf("\n");
507&gt;             }
508&gt;     
509&gt;             sqlrcur_free(bindcur);
510&gt;     
511&gt;             sqlrcur_free(cur);
512&gt;             sqlrcon_free(con);
513&gt;     }
514&gt;     
515
516The number of cursors simultaneously available per-connection is set at compile time and defaults to 5. 
517
518Getting Column Information    
519  
520
521
522For each column, the API supports getting the name, type and length of each field. All databases support these attributes. The API also supports getting the precision, scale, length of the longest field, and whether the column is nullable, the primary key, unique, part of a key, unsigned, zero-filled, binary, or an auto-incrementing field. However, not all databases support these attributes. If a database doesn't support an attribute, it is always returned as false. 
523
524&gt; 
525&gt;     #include <sqlrelay sqlrclientwrapper.h="">
526&gt;     #include <stdio.h>
527&gt;     
528&gt;     main() {
529&gt;     
530&gt;             **int**        i;
531&gt;     
532&gt;             sqlrcon      con=sqlrcon_alloc("host",9000,"","user","password",0,1);
533&gt;             sqlrcur      cur=sqlrcur_alloc(con);
534&gt;     
535&gt;             sqlrcur_sendQuery(cur,"select * from my_table");
536&gt;             sqlrcon_endSession(con);
537&gt;     
538&gt;             **for** (i=0; i<sqlrcur_colcount(cur); i++)="" {="">                     printf("Name:          %s\n",sqlrcur_getColumnName(cur,i));
539&gt;                     printf("Type:          %s\n",sqlrcur_getColumnType(cur,i));
540&gt;                     printf("Length:        %d\n",sqlrcur_getColumnLength(cur,i));
541&gt;                     printf("Precision:     %d\n",sqlrcur_getColumnPrecision(cur,i));
542&gt;                     printf("Scale:         %d\n",sqlrcur_getColumnScale(cur,i));
543&gt;                     printf("Longest Field: %d\n",sqlrcur_getLongest(cur,i));
544&gt;                     printf("Nullable:      %d\n",sqlrcur_getColumnIsNullable(cur,i));
545&gt;                     printf("Primary Key:   %d\n",sqlrcur_getColumnIsPrimaryKey(cur,i));
546&gt;                     printf("Unique:        %d\n",sqlrcur_getColumnIsUnique(cur,i));
547&gt;                     printf("Part of Key:   %d\n",sqlrcur_getColumnIsPartOfKey(cur,i));
548&gt;                     printf("Unsigned:      %d\n",sqlrcur_getColumnIsUnsigned(cur,i));
549&gt;                     printf("Zero Filled:   %d\n",sqlrcur_getColumnIsZeroFilled(cur,i));
550&gt;                     printf("Binary:        %d\n",sqlrcur_getColumnIsBinary(cur,i));
551&gt;                     printf("Auth Increment:%d\n",sqlrcur_getColumnIsAutoIncrement(cur,i));
552&gt;                     printf("\n");
553&gt;             }
554&gt;     
555&gt;             sqlrcur_free(cur);
556&gt;             sqlrcon_free(con);
557&gt;     }
558&gt;     
559
560Some databases force column names to upper case, others force column names to lower case, and others still support mixed-case column names. Sometimes, when migrating between databases, you can run into trouble. You can use upperCaseColumnNames() and lowerCaseColumnNames() to cause column names to be converted to upper or lower case, or you can use mixedCaseColumnNames() to cause column names to be returned in the same case as they are defined in the database. 
561
562&gt; 
563&gt;     #include <sqlrelay sqlrclientwrapper.h="">
564&gt;     #include <stdio.h>
565&gt;     
566&gt;     main() {
567&gt;     
568&gt;             **int**        i;
569&gt;     
570&gt;             sqlrcon         con=sqlrcon_alloc("host",9000,"","user","password",0,1);
571&gt;             sqlrcur         cur=sqlrcur_alloc(con);
572&gt;     
573&gt;             // column names will be forced to upper case
574&gt;             sqlrcur_upperCaseColumnNames(cur);
575&gt;             sqlrcur_endQuery(cur,"select * from my_table");
576&gt;             sqlrcon_endSession(con);
577&gt;     
578&gt;             **for** (i=0; i<sqlrcur_colcount(cur); i++)="" {="">                     printf("Name:   %s\n",sqlrcur_getColumnName(cur,i));
579&gt;             }
580&gt;     
581&gt;             // column names will be forced to lower case
582&gt;             sqlrcur_lowerCaseColumnNames(cur);
583&gt;             sqlrcur_endQuery(cur,"select * from my_table");
584&gt;             sqlrcon_endSession(con);
585&gt;     
586&gt;             **for** (i=0; i<sqlrcur_colcount(cur); i++)="" {="">                     printf("Name:   %s\n",sqlrcur_getColumnName(cur,i));
587&gt;             }
588&gt;     
589&gt;             // column names will be the same as they are in the database
590&gt;             sqlrcur_mixedCaseColumnNames(cur);
591&gt;             sqlrcur_endQuery(cur,"select * from my_table");
592&gt;             sqlrcon_endSession(con);
593&gt;     
594&gt;             **for** (i=0; i<sqlrcur_colcount(cur); i++)="" {="">                     printf("Name:   %s\n",sqlrcur_getColumnName(cur,i));
595&gt;             }
596&gt;     
597&gt;             sqlrcur_free(cur);
598&gt;             sqlrcon_free(con);
599&gt;     }
600&gt;     
601
602Stored Procedures    
603  
604
605
606Many databases support stored procedures. Stored procedures are sets of queries and procedural code that are executed inside of the database itself. For example, a stored procedure may select rows from one table, iterate through the result set and, based on the values in each row, insert, update or delete rows in other tables. A client program could do this as well, but a stored procedure is generally more efficient because queries and result sets don't have to be sent back and forth between the client and database. Also, stored procedures are generally stored in the database in a compiled state, while queries may have to be re-parsed and re-compiled each time they are sent. 
607
608While many databases support stored procedures. The syntax for creating and executing stored procedures varies greatly between databases. 
609
610SQL Relay supports stored procedures for most databases, but there are some caveats. Stored procedures are not currently supported when using FreeTDS against Sybase or Microsoft SQL Server. Blob/Clob bind variables are only supported in Oracle 8i or higher. Sybase stored procedures must use varchar output parameters. 
611
612Stored procedures typically take input paramters from client programs through input bind variables and return values back to client programs either through bind variables or result sets. Stored procedures can be broken down into several categories, based on the values that they return. Some stored procedures don't return any values, some return a single value, some return multiple values and some return entire result sets. 
613
614No Values    
615
616
617Some stored procedures don't return any values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports. 
618
619Oracle    
620
621
622To create the stored procedure, run a query like the following. 
623
624&gt; 
625&gt;     **create** procedure testproc(in1 **in** **number** , in2 **in** **number** , in3 **in** **varchar2** ) is
626&gt;     begin
627&gt;             **insert** into mytable values (in1,in2,in3);
628&gt;     end;
629&gt;     
630
631To execute the stored procedure from an SQL Relay program, use code like the following. 
632
633&gt; 
634&gt;     sqlrcur_prepareQuery(cur,"begin testproc(:in1,:in2,:in3); end;");
635&gt;     sqlrcur_inputBindLong(cur,"in1",1);
636&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
637&gt;     sqlrcur_inputBindString(cur,"in3","hello");
638&gt;     sqlrcur_executeQuery(cur);
639&gt;     
640
641To drop the stored procedure, run a query like the following. 
642
643&gt; 
644&gt;     **drop** procedure testproc
645&gt;     
646
647Sybase and Microsoft SQL Server    
648
649
650To create the stored procedure, run a query like the following. 
651
652&gt; 
653&gt;     **create** procedure testproc @in1 int, @in2 **float** , @in3 **varchar** (20) as
654&gt;             **insert** into mytable values (@in1,@in2,@in3)
655&gt;     
656
657To execute the stored procedure from an SQL Relay program, use code like the following. 
658
659&gt; 
660&gt;     sqlrcur_prepareQuery(cur,"exec testproc");
661&gt;     sqlrcur_inputBindLong(cur,"in1",1);
662&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
663&gt;     sqlrcur_inputBindString(cur,"in3","hello");
664&gt;     sqlrcur_executeQuery(cur);
665&gt;     
666
667To drop the stored procedure, run a query like the following. 
668
669&gt; 
670&gt;     **drop** procedure testproc
671&gt;     
672
673Interbase and Firebird    
674
675
676To create the stored procedure, run a query like the following. 
677
678&gt; 
679&gt;     **create** procedure testproc(in1 **integer** , in2 **float** , in3 **varchar** (20)) as
680&gt;     begin
681&gt;             **insert** into mytable values (in1,in2,in3);
682&gt;             suspend;
683&gt;     end;
684&gt;     
685
686To execute the stored procedure from an SQL Relay program, use code like the following. 
687
688&gt; 
689&gt;     sqlrcur_prepareQuery(cur,"execute procedure testproc ?, ?, ?");
690&gt;     sqlrcur_inputBindLong(cur,"1",1);
691&gt;     sqlrcur_inputBindDouble(cur,"2",1.1,2,1);
692&gt;     sqlrcur_inputBindString(cur,"3","hello");
693&gt;     sqlrcur_executeQuery(cur);
694&gt;     
695
696To drop the stored procedure, run a query like the following. 
697
698&gt; 
699&gt;     **drop** procedure testproc
700&gt;     
701
702DB2    
703
704
705To create the stored procedure, run a query like the following. 
706
707&gt; 
708&gt;     **create** procedure testproc( **in** in1 int, **in** in2 double, **in** in3 **varchar** (20)) language sql
709&gt;     begin
710&gt;             **insert** into mytable values (in1,in2,in3);
711&gt;     end;
712&gt;     
713
714To execute the stored procedure from an SQL Relay program, use code like the following. 
715
716&gt; 
717&gt;     sqlrcur_prepareQuery(cur,"call testproc(?,?,?)");
718&gt;     sqlrcur_inputBindLong(cur,"1",1);
719&gt;     sqlrcur_inputBindDouble(cur,"2",1.1,2,1);
720&gt;     sqlrcur_inputBindString(cur,"3","hello");
721&gt;     sqlrcur_executeQuery(cur);
722&gt;     
723
724To drop the stored procedure, run a query like the following. 
725
726&gt; 
727&gt;     **drop** procedure testproc
728&gt;     
729
730Postgresql    
731
732
733To create the stored procedure, run a query like the following. 
734
735&gt; 
736&gt;     **create** function testproc(int, **float** , **varchar** (20)) returns void as '
737&gt;     begin
738&gt;             **insert** into mytable values ($1,$2,$3);
739&gt;             return;
740&gt;     end;' language plpgsql
741&gt;     
742
743To execute the stored procedure from an SQL Relay program, use code like the following. 
744
745&gt; 
746&gt;     sqlrcur_prepareQuery(cur,"select testproc(:in1,:in2,:in3)");
747&gt;     sqlrcur_inputBindLong(cur,"in1",1);
748&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
749&gt;     sqlrcur_inputBindString(cur,"in3","hello");
750&gt;     sqlrcur_executeQuery(cur);
751&gt;     
752
753To drop the stored procedure, run a query like the following. 
754
755&gt; 
756&gt;     **drop** procedure testproc
757&gt;     
758
759  
760Single Values    
761
762
763Some stored procedures return single values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports. 
764
765Oracle    
766
767
768In Oracle, stored procedures can return values through output parameters or as return values of the procedure itself. 
769
770Here is an example where the procedure itself returns a value. Note that Oracle calls these functions. 
771
772To create the stored procedure, run a query like the following. 
773
774&gt; 
775&gt;     **create** function testproc(in1 **in** **number** , in2 **in** **number** , in3 **in** **varchar2** ) returns **number** is
776&gt;     begin
777&gt;             return in1;
778&gt;     end;
779&gt;     
780
781To execute the stored procedure from an SQL Relay program, use code like the following. 
782
783&gt; 
784&gt;     sqlrcur_prepareQuery(cur,"select testproc(:in1,:in2,:in3) from dual");
785&gt;     sqlrcur_inputBindLong(cur,"in1",1);
786&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
787&gt;     sqlrcur_inputBindString(cur,"in3","hello");
788&gt;     sqlrcur_executeQuery(cur);
789&gt;     **char**    *result=sqlrcur_getFieldByIndex(cur,0,0);
790&gt;     
791
792To drop the stored procedure, run a query like the following. 
793
794&gt; 
795&gt;     **drop** function testproc
796&gt;     
797
798Here is an example where the value is returned through an output parameter. 
799
800To create the stored procedure, run a query like the following. 
801
802&gt; 
803&gt;     **create** procedure testproc(in1 **in** **number** , in2 **in** **number** , in3 **in** **varchar2** , out1 **out** **number** ) as
804&gt;     begin
805&gt;             out1:=in1;
806&gt;     end;
807&gt;     
808
809To execute the stored procedure from an SQL Relay program, use code like the following. 
810
811&gt; 
812&gt;     sqlrcur_prepareQuery(cur,"begin testproc(:in1,:in2,:in3,:out1); end;");
813&gt;     sqlrcur_inputBindLong(cur,"in1",1);
814&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
815&gt;     sqlrcur_inputBindString(cur,"in3","hello");
816&gt;     sqlrcur_defineOutputBind(cur,"out1",20);
817&gt;     sqlrcur_executeQuery(cur);
818&gt;     **char**    *result=sqlrcur_getOutputBind(cur,"out1");
819&gt;     
820
821To drop the stored procedure, run a query like the following. 
822
823&gt; 
824&gt;     **drop** procedure testproc
825&gt;     
826
827Sybase and Microsoft SQL Server    
828
829
830In Sybase and Microsoft SQL Server, stored procedures return values through output parameters rather than as return values of the procedure itself. 
831
832To create the stored procedure, run a query like the following. 
833
834&gt; 
835&gt;     **create** procedure testproc @in1 int, @in2 **float** , @in3 **varchar** (20), @out1 int output as
836&gt;             **select** @out1=convert( **varchar** (20),@in1)
837&gt;     
838
839To execute the stored procedure from an SQL Relay program, use code like the following. 
840
841&gt; 
842&gt;     sqlrcur_prepareQuery(cur,"exec testproc");
843&gt;     sqlrcur_inputBindLong(cur,"in1",1);
844&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,2,1);
845&gt;     sqlrcur_inputBindString(cur,"in3","hello");
846&gt;     sqlrcur_defineOutputBind(cur,"out1",20);
847&gt;     sqlrcur_executeQuery(cur);
848&gt;     **char**    *result=sqlrcur_getOutputBind(cur,"out1");
849&gt;     
850
851To drop the stored procedure, run a query like the following. 
852
853&gt; 
854&gt;     **drop** procedure testproc
855&gt;     
856
857Interbase and Firebird    
858
859
860To create the stored procedure, run a query like the following. 
861
862&gt; 
863&gt;     **create** procedure testproc(in1 **integer** , in2 **float** , in3 **varchar** (20)) returns (out1 **integer** ) as
864&gt;     begin
865&gt;             out1=in1;
866&gt;             suspend;
867&gt;     end;
868&gt;     
869
870To execute the stored procedure from an SQL Relay program, use code like the following. 
871
872&gt; 
873&gt;     sqlrcur_prepareQuery(cur,"select * from testproc(?,?,?)");
874&gt;     sqlrcur_inputBindLong(cur,"1",1);
875&gt;     sqlrcur_inputBindDouble(cur,"2",1.1,2,1);
876&gt;     sqlrcur_inputBindString(cur,"3","hello");
877&gt;     sqlrcur_executeQuery(cur);
878&gt;     **char**    *result=sqlrcur_getFieldByIndex(cur,0,0);
879&gt;     
880
881Alternatively, you can run a query like the following and receive the result using an output bind variable. Note that in Interbase/Firebird, input and output bind variable indices are distict from one another. The index of the output bind variable is 1 rather than 4, even though there were 3 input bind variables. 
882
883&gt; 
884&gt;     sqlrcur_prepareQuery(cur,"execute procedure testproc ?, ?, ?");
885&gt;     sqlrcur_inputBindLong(cur,"1",1);
886&gt;     sqlrcur_inputBindDouble(cur,"2",1.1,2,1);
887&gt;     sqlrcur_inputBindString(cur,"3","hello");
888&gt;     sqlrcur_defineOutputBind(cur,"1",20);
889&gt;     sqlrcur_executeQuery(cur);
890&gt;     **char**    *result=sqlrcur_getOutputBind(cur,"1");
891&gt;     
892
893To drop the stored procedure, run a query like the following. 
894
895&gt; 
896&gt;     **drop** procedure testproc
897&gt;     
898
899DB2    
900
901
902In DB2, stored procedures return values through output parameters rather than as return values of the procedure itself. 
903
904To create the stored procedure, run a query like the following. 
905
906&gt; 
907&gt;     **create** procedure testproc( **in** in1 int, **in** in2 double, **in** in3 **varchar** (20), **out** out1 int) language sql
908&gt;     begin
909&gt;             **set** out1 = in1;
910&gt;     end
911&gt;     
912
913To execute the stored procedure from an SQL Relay program, use code like the following. 
914
915&gt; 
916&gt;     sqlrcur_prepareQuery(cur,"call testproc(?,?,?,?)");
917&gt;     sqlrcur_inputBindLong(cur,"1",1);
918&gt;     sqlrcur_inputBindDouble(cur,"2",1.1,2,1);
919&gt;     sqlrcur_inputBindString(cur,"3","hello");
920&gt;     sqlrcur_defineOutputBind(cur,"4",25);
921&gt;     sqlrcur_executeQuery(cur);
922&gt;     **char**    *result=sqlrcur_getOutputBind(cur,"4");
923&gt;     
924
925To drop the stored procedure, run a query like the following. 
926
927&gt; 
928&gt;     **drop** procedure testproc
929&gt;     
930
931Postgresql    
932
933
934To create the stored procedure, run a query like the following. 
935
936&gt; 
937&gt;     **create** function testfunc(int, **float** , **char** (20)) returns int as '
938&gt;     declare
939&gt;             in1 int;
940&gt;             in2 **float** ;
941&gt;             in3 **char** (20);
942&gt;     begin
943&gt;             in1:=$1;
944&gt;             return;
945&gt;     end;
946&gt;     ' language plpgsql
947&gt;     
948
949To execute the stored procedure from an SQL Relay program, use code like the following. 
950
951&gt; 
952&gt;     sqlrcur_prepareQuery(cur,"select * from testfunc(:in1,:in2,:in3)");
953&gt;     sqlrcur_inputBindLong(cur,"in1",1);
954&gt;     sqlrcur_inputBindDouble(cur,"in2",1.1,4,2);
955&gt;     sqlrcur_inputBindString(cur,"in3","hello");
956&gt;     sqlrcur_executeQuery(cur);
957&gt;     **char**    *result=sqlrcur_getFieldByIndex(cur,0,0);
958&gt;     
959
960To drop the stored procedure, run a query like the following. 
961
962&gt; 
963&gt;     **drop** function testfunc(int, **float** , **char** (20))
964&gt;     
965
966  
967Multiple Values    
968
969
970Some stored procedures return multiple values. Below are examples, illustrating how to create, execute and drop this kind of stored procedure for each database that SQL Relay supports. 
971
972Oracle    
973
974
975In Oracle, stored procedures can return values through output parameters or as return values of the procedure itself. If a procedure needs to return multiple values, it can return one of them as the return value of the procedure itself, but the rest must be returned through output parameters. 
976
977To create the stored procedure, run a query like the following. 
978
979&gt; 
980&gt;     **create** procedure testproc(in1 &lt;fo</sqlrcur_colcount(cur);></sqlrcur_colcount(cur);></sqlrcur_colcount(cur);></stdio.h></sqlrelay></sqlrcur_colcount(cur);></stdio.h></sqlrelay></sqlrcur_colcount(bindcur);></sqlrcur_rowcount(bindcur);></stdio.h></sqlrelay></sqlrelay></sqlrcur_colcount(cur);></stdio.h></sqlrelay></sqlrcur_colcount(cur);></sqlrcur_rowcount(cur);></stdio.h></sqlrelay></sqlrcur_colcount(cur);></sqlrcur_rowcount(cur);></stdio.h></sqlrelay></stdio.h></sqlrelay></sqlrelay></sqlrelay></stdio.h></sqlrelay></stdio.h></sqlrelay></stdio.h></sqlrelay></stdio.h></sqlrelay></stdio.h></sqlrelay></sqlrelay>