1 /************************************************************************************
2    Copyright (C) 2013,2016 MariaDB Corporation AB
3 
4    This library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8 
9    This library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13 
14    You should have received a copy of the GNU Library General Public
15    License along with this library; if not see <http://www.gnu.org/licenses>
16    or write to the Free Software Foundation, Inc.,
17    51 Franklin St., Fifth Floor, Boston, MA 02110, USA
18 *************************************************************************************/
19 #undef MA_ODBC_DEBUG_ALL
20 
21 #include <ma_odbc.h>
22 
23 extern Client_Charset utf8;
24 
25 /* {{{ SQLAllocHandle */
SQLAllocHandle(SQLSMALLINT HandleType,SQLHANDLE InputHandle,SQLHANDLE * OutputHandlePtr)26 SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT HandleType,
27     SQLHANDLE InputHandle,
28     SQLHANDLE *OutputHandlePtr)
29 {
30   SQLRETURN ret;
31   MDBUG_ENTER("SQLAllocHandle");
32   MDBUG_DUMP(HandleType, d);
33   MDBUG_DUMP(InputHandle, 0x);
34   MDBUG_DUMP(OutputHandlePtr, 0x);
35 
36   ret= MA_SQLAllocHandle(HandleType, InputHandle, OutputHandlePtr);
37 
38   MDBUG_DUMP(ret,d);
39   MDBUG_RETURN(ret);
40 }
41 /* }}} */
42 
43 
SQLAllocConnect(SQLHANDLE InputHandle,SQLHANDLE * OutputHandlePtr)44 SQLRETURN SQL_API SQLAllocConnect(SQLHANDLE InputHandle,
45                                   SQLHANDLE *OutputHandlePtr)
46 {
47   return MA_SQLAllocHandle(SQL_HANDLE_DBC, InputHandle, OutputHandlePtr);;
48 }
49 /* }}} */
50 
51 /* {{{ SQLAllocStmt */
SQLAllocStmt(SQLHANDLE InputHandle,SQLHANDLE * OutputHandlePtr)52 SQLRETURN SQL_API SQLAllocStmt(SQLHANDLE InputHandle,
53                                SQLHANDLE *OutputHandlePtr)
54 {
55   MDBUG_C_ENTER(InputHandle, "SQLAllocStmt");
56   MDBUG_C_DUMP(InputHandle, InputHandle, 0x);
57   MDBUG_C_DUMP(InputHandle, OutputHandlePtr, 0x);
58 
59   return MA_SQLAllocHandle(SQL_HANDLE_STMT, InputHandle, OutputHandlePtr);
60 }
61 /* }}} */
62 
63 /* {{{ SQLAllocEnv */
SQLAllocEnv(SQLHANDLE * OutputHandlePtr)64 SQLRETURN SQL_API SQLAllocEnv(SQLHANDLE *OutputHandlePtr)
65 {
66   return MA_SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, OutputHandlePtr);
67 }
68 /* }}} */
69 
70 /* {{{ SQLBindCol */
SQLBindCol(SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,SQLSMALLINT TargetType,SQLPOINTER TargetValuePtr,SQLLEN BufferLength,SQLLEN * StrLen_or_Ind)71 SQLRETURN SQL_API SQLBindCol(SQLHSTMT StatementHandle,
72     SQLUSMALLINT ColumnNumber,
73     SQLSMALLINT TargetType,
74     SQLPOINTER TargetValuePtr,
75     SQLLEN BufferLength,
76     SQLLEN *StrLen_or_Ind)
77 {
78   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
79   SQLRETURN ret;
80   MADB_CLEAR_ERROR(&Stmt->Error);
81   MADB_CHECK_STMT_HANDLE(Stmt,stmt);
82 
83   MDBUG_C_ENTER(Stmt->Connection, "SQLBindCol");
84   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
85   MDBUG_C_DUMP(Stmt->Connection, ColumnNumber, u);
86   MDBUG_C_DUMP(Stmt->Connection, TargetType, d);
87   MDBUG_C_DUMP(Stmt->Connection, BufferLength, d);
88   MDBUG_C_DUMP(Stmt->Connection, StrLen_or_Ind, 0x);
89 
90   ret= Stmt->Methods->BindColumn(Stmt, ColumnNumber, TargetType, TargetValuePtr, BufferLength, StrLen_or_Ind);
91 
92   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
93 }
94 /* }}} */
95 
96 /* {{{ SQLBindParameter */
SQLBindParameter(SQLHSTMT StatementHandle,SQLUSMALLINT ParameterNumber,SQLSMALLINT InputOutputType,SQLSMALLINT ValueType,SQLSMALLINT ParameterType,SQLULEN ColumnSize,SQLSMALLINT DecimalDigits,SQLPOINTER ParameterValuePtr,SQLLEN BufferLength,SQLLEN * StrLen_or_IndPtr)97 SQLRETURN SQL_API SQLBindParameter(SQLHSTMT StatementHandle,
98     SQLUSMALLINT ParameterNumber,
99     SQLSMALLINT InputOutputType,
100     SQLSMALLINT ValueType,
101     SQLSMALLINT ParameterType,
102     SQLULEN ColumnSize,
103     SQLSMALLINT DecimalDigits,
104     SQLPOINTER ParameterValuePtr,
105     SQLLEN BufferLength,
106     SQLLEN *StrLen_or_IndPtr)
107 {
108   if (!StatementHandle)
109     return SQL_INVALID_HANDLE;
110   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
111   return MA_SQLBindParameter(StatementHandle, ParameterNumber, InputOutputType, ValueType, ParameterType,
112                              ColumnSize, DecimalDigits, ParameterValuePtr, BufferLength, StrLen_or_IndPtr);
113 }
114 /* }}} */
115 
116 /* {{{ SQLBrowseConnect */
SQLBrowseConnect(SQLHDBC ConnectionHandle,SQLCHAR * InConnectionString,SQLSMALLINT StringLength1,SQLCHAR * OutConnectionString,SQLSMALLINT BufferLength,SQLSMALLINT * StringLength2Ptr)117 SQLRETURN SQL_API SQLBrowseConnect(SQLHDBC ConnectionHandle,
118     SQLCHAR *InConnectionString,
119     SQLSMALLINT StringLength1,
120     SQLCHAR *OutConnectionString,
121     SQLSMALLINT BufferLength,
122     SQLSMALLINT *StringLength2Ptr)
123 {
124   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
125   SQLRETURN ret;
126   MDBUG_C_ENTER(Dbc, "SQLBrowseConnect");
127   MADB_SetError(&Dbc->Error, MADB_ERR_IM001, NULL, 0);
128   ret= Dbc->Error.ReturnValue;
129 
130   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
131 }
132 /* }}} */
133 
134 /* {{{ SQLBrowseConnectW */
SQLBrowseConnectW(SQLHDBC ConnectionHandle,SQLWCHAR * InConnectionString,SQLSMALLINT StringLength1,SQLWCHAR * OutConnectionString,SQLSMALLINT BufferLength,SQLSMALLINT * StringLength2Ptr)135 SQLRETURN SQL_API SQLBrowseConnectW(SQLHDBC ConnectionHandle,
136     SQLWCHAR *InConnectionString,
137     SQLSMALLINT StringLength1,
138     SQLWCHAR *OutConnectionString,
139     SQLSMALLINT BufferLength,
140     SQLSMALLINT *StringLength2Ptr)
141 {
142   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
143   SQLRETURN ret;
144   MDBUG_C_ENTER(Dbc, SQLBrowseConnectW);
145   MADB_SetError(&Dbc->Error, MADB_ERR_IM001, NULL, 0);
146   ret= Dbc->Error.ReturnValue;
147 
148   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
149 }
150 /* }}} */
151 
152 /* {{{ SQLBulkOperations */
SQLBulkOperations(SQLHSTMT StatementHandle,SQLSMALLINT Operation)153 SQLRETURN SQL_API SQLBulkOperations(SQLHSTMT StatementHandle,
154     SQLSMALLINT Operation)
155 {
156   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
157   SQLRETURN ret;
158   if (!Stmt)
159     return SQL_INVALID_HANDLE;
160   MADB_CLEAR_ERROR(&Stmt->Error);
161 
162   MDBUG_C_ENTER(Stmt->Connection, "SQLBulkOperations");
163   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
164   MDBUG_C_DUMP(Stmt->Connection, Operation, d);
165 
166   ret= Stmt->Methods->BulkOperations(Stmt, Operation);
167 
168   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
169 }
170 /* }}} */
171 
172 /* {{{ SQLCancel */
SQLCancel(SQLHSTMT StatementHandle)173 SQLRETURN SQL_API SQLCancel(SQLHSTMT StatementHandle)
174 {
175   return MA_SQLCancel(StatementHandle);
176 }
177 /* }}} */
178 
179 /* {{{ SQLCancelHandle */
180 /* ODBC version 3.8 */
SQLCancelHandle(SQLSMALLINT HandleType,SQLHANDLE Handle)181 SQLRETURN SQL_API SQLCancelHandle(SQLSMALLINT HandleType,
182     SQLHANDLE Handle)
183 {
184   if (Handle)
185     return SQL_INVALID_HANDLE;
186 
187   switch(HandleType) {
188   case SQL_HANDLE_DBC:
189     {
190       MADB_Stmt Stmt;
191       Stmt.Connection= (MADB_Dbc *)Handle;
192       return MA_SQLCancel((SQLHSTMT)&Stmt);
193     }
194     break;
195   case SQL_HANDLE_STMT:
196     return MA_SQLCancel((SQLHSTMT)Handle);
197     break;
198   }
199   return SQL_INVALID_HANDLE;
200 }
201 /* }}} */
202 
203 /* {{{ SQLCloseCursor */
SQLCloseCursor(SQLHSTMT StatementHandle)204 SQLRETURN SQL_API SQLCloseCursor(SQLHSTMT StatementHandle)
205 {
206   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
207   SQLRETURN ret;
208   if (!Stmt)
209     return SQL_INVALID_HANDLE;
210 
211   MADB_CLEAR_ERROR(&Stmt->Error);
212 
213   MDBUG_C_ENTER(Stmt->Connection, "SQLCloseCursor");
214   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
215 
216   if (!Stmt->stmt ||
217      (!mysql_stmt_field_count(Stmt->stmt) &&
218        Stmt->Connection->Environment->OdbcVersion >= SQL_OV_ODBC3))
219   {
220     MADB_SetError(&Stmt->Error, MADB_ERR_24000, NULL, 0);
221     ret= Stmt->Error.ReturnValue;
222   }
223   else
224   {
225     ret = Stmt->Methods->StmtFree(Stmt, SQL_CLOSE);
226   }
227 
228   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
229 }
230 /* }}} */
231 
232 /* {{{ SQLColAttribute */
SQLColAttribute(SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,SQLUSMALLINT FieldIdentifier,SQLPOINTER CharacterAttributePtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr,SQLPOINTER NumericAttributePtr)233 SQLRETURN SQL_API SQLColAttribute (SQLHSTMT StatementHandle,
234     SQLUSMALLINT ColumnNumber,
235     SQLUSMALLINT FieldIdentifier,
236     SQLPOINTER CharacterAttributePtr,
237     SQLSMALLINT BufferLength,
238     SQLSMALLINT *StringLengthPtr,
239 #ifdef SQLCOLATTRIB_SQLPOINTER
240     SQLPOINTER NumericAttributePtr
241 #else
242     SQLLEN *NumericAttributePtr
243 #endif
244     )
245 {
246   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
247   SQLRETURN ret;
248   if (!Stmt)
249     return SQL_INVALID_HANDLE;
250 
251   MADB_CLEAR_ERROR(&Stmt->Error);
252 
253   MDBUG_C_ENTER(Stmt->Connection, "SQLColAttribute");
254   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
255   MDBUG_C_DUMP(Stmt->Connection, ColumnNumber, u);
256   MDBUG_C_DUMP(Stmt->Connection, FieldIdentifier, u);
257   MDBUG_C_DUMP(Stmt->Connection, CharacterAttributePtr, 0x);
258   MDBUG_C_DUMP(Stmt->Connection, BufferLength, d);
259   MDBUG_C_DUMP(Stmt->Connection, StringLengthPtr, 0x);
260   MDBUG_C_DUMP(Stmt->Connection, NumericAttributePtr, 0x);
261 
262   ret= Stmt->Methods->ColAttribute(Stmt, ColumnNumber, FieldIdentifier, CharacterAttributePtr,
263                                      BufferLength, StringLengthPtr, NumericAttributePtr, FALSE);
264 
265   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
266 }
267 /* }}} */
268 
269 /* {{{ SQLColAttributeW */
SQLColAttributeW(SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,SQLUSMALLINT FieldIdentifier,SQLPOINTER CharacterAttributePtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr,SQLPOINTER NumericAttributePtr)270 SQLRETURN SQL_API SQLColAttributeW (SQLHSTMT StatementHandle,
271     SQLUSMALLINT ColumnNumber,
272     SQLUSMALLINT FieldIdentifier,
273     SQLPOINTER CharacterAttributePtr,
274     SQLSMALLINT BufferLength,
275     SQLSMALLINT *StringLengthPtr,
276 #ifdef SQLCOLATTRIB_SQLPOINTER
277     SQLPOINTER NumericAttributePtr
278 #else
279     SQLLEN *NumericAttributePtr
280 #endif
281     )
282 {
283   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
284   SQLRETURN ret;
285   if (!Stmt)
286     return SQL_INVALID_HANDLE;
287 
288   MADB_CLEAR_ERROR(&Stmt->Error);
289 
290   MDBUG_C_ENTER(Stmt->Connection, "SQLColAttributeW");
291   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
292   MDBUG_C_DUMP(Stmt->Connection, ColumnNumber, u);
293   MDBUG_C_DUMP(Stmt->Connection, FieldIdentifier, u);
294   MDBUG_C_DUMP(Stmt->Connection, CharacterAttributePtr, 0x);
295   MDBUG_C_DUMP(Stmt->Connection, BufferLength, d);
296   MDBUG_C_DUMP(Stmt->Connection, StringLengthPtr, 0x);
297   MDBUG_C_DUMP(Stmt->Connection, NumericAttributePtr, 0x);
298 
299   ret= Stmt->Methods->ColAttribute(Stmt, ColumnNumber, FieldIdentifier, CharacterAttributePtr,
300                                      BufferLength, StringLengthPtr, NumericAttributePtr, TRUE);
301 
302   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
303 }
304 /* }}} */
305 
306 /* {{{ SQLColAttributes */
SQLColAttributes(SQLHSTMT hstmt,SQLUSMALLINT icol,SQLUSMALLINT fDescType,SQLPOINTER rgbDesc,SQLSMALLINT cbDescMax,SQLSMALLINT * pcbDesc,SQLLEN * pfDesc)307 SQLRETURN SQL_API SQLColAttributes(SQLHSTMT hstmt,
308 	SQLUSMALLINT icol,
309 	SQLUSMALLINT fDescType,
310 	SQLPOINTER rgbDesc,
311 	SQLSMALLINT cbDescMax,
312 	SQLSMALLINT * pcbDesc,
313 	SQLLEN * pfDesc)
314 {
315   MADB_Stmt *Stmt= (MADB_Stmt *)hstmt;
316   if (!Stmt)
317     return SQL_INVALID_HANDLE;
318 
319   MADB_CLEAR_ERROR(&Stmt->Error);
320 
321   return Stmt->Methods->ColAttribute(Stmt, icol, MapColAttributeDescType(fDescType), rgbDesc,
322                                      cbDescMax, pcbDesc, pfDesc, FALSE);
323 }
324 /* }}} */
325 
326 /* {{{ SQLColAttributesW */
SQLColAttributesW(SQLHSTMT hstmt,SQLUSMALLINT icol,SQLUSMALLINT fDescType,SQLPOINTER rgbDesc,SQLSMALLINT cbDescMax,SQLSMALLINT * pcbDesc,SQLLEN * pfDesc)327 SQLRETURN SQL_API SQLColAttributesW(SQLHSTMT hstmt,
328 	SQLUSMALLINT icol,
329 	SQLUSMALLINT fDescType,
330 	SQLPOINTER rgbDesc,
331 	SQLSMALLINT cbDescMax,
332 	SQLSMALLINT * pcbDesc,
333 	SQLLEN * pfDesc)
334 {
335   /* TODO: use internal function, not api */
336   return SQLColAttributeW(hstmt, icol, MapColAttributeDescType(fDescType), rgbDesc, cbDescMax, pcbDesc, pfDesc);
337 }
338 /* }}} */
339 
340 /* {{{ SQLColumnPrivileges */
SQLColumnPrivileges(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3,SQLCHAR * ColumnName,SQLSMALLINT NameLength4)341 SQLRETURN SQL_API SQLColumnPrivileges(SQLHSTMT StatementHandle,
342     SQLCHAR *CatalogName,
343     SQLSMALLINT NameLength1,
344     SQLCHAR *SchemaName,
345     SQLSMALLINT NameLength2,
346     SQLCHAR *TableName,
347     SQLSMALLINT NameLength3,
348     SQLCHAR *ColumnName,
349     SQLSMALLINT NameLength4)
350 {
351   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
352   SQLRETURN ret;
353 
354   if (!Stmt)
355     return SQL_INVALID_HANDLE;
356 
357   MADB_CLEAR_ERROR(&Stmt->Error);
358 
359   MDBUG_C_ENTER(Stmt->Connection, "SQLColumnPrivileges");
360   ret= Stmt->Methods->ColumnPrivileges(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName, NameLength2,
361                                          (char *)TableName, NameLength3, (char *)ColumnName, NameLength4);
362 
363   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
364  }
365 /* }}} */
366 
367 /* {{{ SQLColumnPrivilegesW */
SQLColumnPrivilegesW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3,SQLWCHAR * ColumnName,SQLSMALLINT NameLength4)368 SQLRETURN SQL_API SQLColumnPrivilegesW(SQLHSTMT StatementHandle,
369     SQLWCHAR *CatalogName,
370     SQLSMALLINT NameLength1,
371     SQLWCHAR *SchemaName,
372     SQLSMALLINT NameLength2,
373     SQLWCHAR *TableName,
374     SQLSMALLINT NameLength3,
375     SQLWCHAR *ColumnName,
376     SQLSMALLINT NameLength4)
377 {
378   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
379   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0, CpLength4= 0;
380   char *CpCatalog= NULL,
381        *CpSchema= NULL,
382        *CpTable= NULL,
383        *CpColumn= NULL;
384   SQLRETURN ret;
385 
386   if (!StatementHandle)
387     return SQL_INVALID_HANDLE;
388 
389   MADB_CLEAR_ERROR(&Stmt->Error);
390 
391   MDBUG_C_ENTER(Stmt->Connection, "SQLColumnPrivilegesW");
392 
393   if (CatalogName != NULL)
394   {
395     CpCatalog = MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
396   }
397   if (SchemaName != NULL)
398   {
399     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
400   }
401   if (TableName != NULL)
402   {
403     CpTable = MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
404   }
405   if (ColumnName != NULL)
406   {
407     CpColumn = MADB_ConvertFromWChar(ColumnName, NameLength4, &CpLength4, Stmt->Connection->ConnOrSrcCharset, NULL);
408   }
409 
410   ret= Stmt->Methods->ColumnPrivileges(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
411                                        CpTable, (SQLSMALLINT)CpLength3, CpColumn, (SQLSMALLINT)CpLength4);
412 
413   MADB_FREE(CpCatalog);
414   MADB_FREE(CpSchema);
415   MADB_FREE(CpTable);
416   MADB_FREE(CpColumn);
417 
418   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
419 }
420 /* }}} */
421 
422 /* {{{ SQLColumns */
SQLColumns(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3,SQLCHAR * ColumnName,SQLSMALLINT NameLength4)423 SQLRETURN SQL_API SQLColumns(SQLHSTMT StatementHandle,
424     SQLCHAR *CatalogName,
425     SQLSMALLINT NameLength1,
426     SQLCHAR *SchemaName,
427     SQLSMALLINT NameLength2,
428     SQLCHAR *TableName,
429     SQLSMALLINT NameLength3,
430     SQLCHAR *ColumnName,
431     SQLSMALLINT NameLength4)
432 {
433   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
434   SQLRETURN ret;
435   if (!Stmt)
436     return SQL_INVALID_HANDLE;
437 
438   MADB_CLEAR_ERROR(&Stmt->Error);
439 
440   MDBUG_C_ENTER(Stmt->Connection, "SQLColumns");
441 
442   ret= Stmt->Methods->Columns(Stmt, (char *)CatalogName,NameLength1, (char *)SchemaName, NameLength2,
443                                 (char *)TableName, NameLength3, (char *)ColumnName, NameLength4);
444 
445   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
446 }
447 /* }}} */
448 
449 /* {{{ SQLColumnsW */
SQLColumnsW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3,SQLWCHAR * ColumnName,SQLSMALLINT NameLength4)450 SQLRETURN SQL_API SQLColumnsW(SQLHSTMT StatementHandle,
451     SQLWCHAR *CatalogName,
452     SQLSMALLINT NameLength1,
453     SQLWCHAR *SchemaName,
454     SQLSMALLINT NameLength2,
455     SQLWCHAR *TableName,
456     SQLSMALLINT NameLength3,
457     SQLWCHAR *ColumnName,
458     SQLSMALLINT NameLength4)
459 {
460   char *CpCatalog= NULL,
461        *CpSchema= NULL,
462        *CpTable= NULL,
463        *CpColumn= NULL;
464   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0, CpLength4= 0;
465   SQLRETURN ret;
466   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
467 
468   if (!Stmt)
469     return SQL_INVALID_HANDLE;
470 
471   MADB_CLEAR_ERROR(&Stmt->Error);
472 
473   MDBUG_C_ENTER(Stmt->Connection, "SQLColumns");
474 
475   if (CatalogName != NULL)
476   {
477     CpCatalog= MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
478   }
479   if (SchemaName != NULL)
480   {
481     CpSchema=  MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
482   }
483   if (TableName != NULL)
484   {
485     CpTable=   MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
486   }
487   if (ColumnName != NULL)
488   {
489     CpColumn=  MADB_ConvertFromWChar(ColumnName, NameLength4, &CpLength4, Stmt->Connection->ConnOrSrcCharset, NULL);
490   }
491 
492   ret= Stmt->Methods->Columns(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
493                               CpTable, (SQLSMALLINT)CpLength3, CpColumn, (SQLSMALLINT)CpLength4);
494 
495   MADB_FREE(CpCatalog);
496   MADB_FREE(CpSchema);
497   MADB_FREE(CpTable);
498   MADB_FREE(CpColumn);
499 
500   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
501 }
502 /* }}} */
503 
504 /* {{{ SQLCompleteAsync */
505 /* ODBC 3.8 */
SQLCompleteAsync(SQLSMALLINT HandleType,SQLHANDLE Handle,RETCODE * AsyncRetCodePtr)506 SQLRETURN SQL_API SQLCompleteAsync(SQLSMALLINT HandleType,
507     SQLHANDLE Handle,
508     RETCODE *AsyncRetCodePtr)
509 {
510   SQLRETURN ret= SQL_ERROR;
511   return ret;
512 }
513 
514 /* }}} */
515 
516 /* {{{ SQLConnectCommon */
SQLConnectCommon(SQLHDBC ConnectionHandle,SQLCHAR * ServerName,SQLSMALLINT NameLength1,SQLCHAR * UserName,SQLSMALLINT NameLength2,SQLCHAR * Authentication,SQLSMALLINT NameLength3)517 SQLRETURN SQLConnectCommon(SQLHDBC ConnectionHandle,
518     SQLCHAR *ServerName,
519     SQLSMALLINT NameLength1,
520     SQLCHAR *UserName,
521     SQLSMALLINT NameLength2,
522     SQLCHAR *Authentication,
523     SQLSMALLINT NameLength3)
524 {
525   MADB_Dbc *Connection= (MADB_Dbc *)ConnectionHandle;
526   MADB_Dsn *Dsn;
527   SQLRETURN ret;
528   my_bool DsnFound;
529 
530   if (!Connection)
531     return SQL_INVALID_HANDLE;
532 
533   MADB_CLEAR_ERROR(&Connection->Error);
534 
535   MDBUG_C_ENTER(Connection, "SQLConnect");
536   MDBUG_C_DUMP(Connection, Connection, 0x);
537   MDBUG_C_DUMP(Connection, ServerName, s);
538   MDBUG_C_DUMP(Connection, NameLength1, d);
539   MDBUG_C_DUMP(Connection, UserName, s);
540   MDBUG_C_DUMP(Connection, NameLength2, d);
541   MDBUG_C_DUMP(Connection, Authentication, s);
542   MDBUG_C_DUMP(Connection, NameLength3, d);
543 
544   if (CheckConnection(Connection))
545   {
546     MADB_SetError(&Connection->Error, MADB_ERR_08002, NULL, 0);
547     return SQL_ERROR;
548   }
549 
550   if (!(Dsn= MADB_DSN_Init()))
551   {
552     MADB_SetError(&Connection->Error, MADB_ERR_HY001, NULL, 0);
553     return SQL_ERROR;
554   }
555 
556   if (ServerName && !ServerName[0])
557   {
558     MADB_SetError(&Connection->Error, MADB_ERR_HY000, "Invalid DSN", 0);
559     MADB_DSN_Free(Dsn);
560     return Connection->Error.ReturnValue;
561   }
562 
563   MADB_DSN_SET_STR(Dsn, DSNName, (char *)ServerName, NameLength1);
564   DsnFound= MADB_ReadDSN(Dsn, NULL, TRUE);
565 
566   MADB_DSN_SET_STR(Dsn, UserName, (char *)UserName, NameLength2);
567   MADB_DSN_SET_STR(Dsn, Password, (char *)Authentication, NameLength3);
568 
569   ret= Connection->Methods->ConnectDB(Connection, Dsn);
570 
571   if (SQL_SUCCEEDED(ret))
572   {
573     MADB_DSN_Free(Connection->Dsn);
574     Connection->Dsn= Dsn;
575   }
576   else
577   {
578     MADB_DSN_Free(Dsn);
579   }
580 
581   MDBUG_C_RETURN(Connection, ret, &Connection->Error);
582 }
583 /* }}} */
584 
585 /* {{{ SQLConnect */
SQLConnect(SQLHDBC ConnectionHandle,SQLCHAR * ServerName,SQLSMALLINT NameLength1,SQLCHAR * UserName,SQLSMALLINT NameLength2,SQLCHAR * Authentication,SQLSMALLINT NameLength3)586 SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,
587     SQLCHAR *ServerName,
588     SQLSMALLINT NameLength1,
589     SQLCHAR *UserName,
590     SQLSMALLINT NameLength2,
591     SQLCHAR *Authentication,
592     SQLSMALLINT NameLength3)
593 {
594   return SQLConnectCommon(ConnectionHandle, ServerName, NameLength1,
595                           UserName, NameLength2, Authentication, NameLength3);
596 }
597 /* }}} */
598 
599 /* {{{ SQLConnectW */
SQLConnectW(SQLHDBC ConnectionHandle,SQLWCHAR * ServerName,SQLSMALLINT NameLength1,SQLWCHAR * UserName,SQLSMALLINT NameLength2,SQLWCHAR * Authentication,SQLSMALLINT NameLength3)600 SQLRETURN SQL_API SQLConnectW(SQLHDBC ConnectionHandle,
601     SQLWCHAR *ServerName,
602     SQLSMALLINT NameLength1,
603     SQLWCHAR *UserName,
604     SQLSMALLINT NameLength2,
605     SQLWCHAR *Authentication,
606     SQLSMALLINT NameLength3)
607 {
608   char *MBServerName= NULL, *MBUserName= NULL, *MBAuthentication= NULL;
609   SQLRETURN ret;
610   MADB_Dbc *Dbc= (MADB_Dbc*)ConnectionHandle;
611 
612   if (!Dbc)
613     return SQL_INVALID_HANDLE;
614 
615   MADB_CLEAR_ERROR(&Dbc->Error);
616 
617    /* Convert parameters to Cp */
618   if (ServerName)
619     MBServerName= MADB_ConvertFromWChar(ServerName, NameLength1, 0, Dbc->IsAnsi ? Dbc->ConnOrSrcCharset : &utf8, NULL);
620   if (UserName)
621     MBUserName= MADB_ConvertFromWChar(UserName, NameLength2, 0, Dbc->IsAnsi ? Dbc->ConnOrSrcCharset : &utf8, NULL);
622   if (Authentication)
623     MBAuthentication= MADB_ConvertFromWChar(Authentication, NameLength3, 0, Dbc->IsAnsi ? Dbc->ConnOrSrcCharset : &utf8, NULL);
624 
625   ret= SQLConnectCommon(ConnectionHandle, (SQLCHAR *)MBServerName, SQL_NTS, (SQLCHAR *)MBUserName, SQL_NTS,
626                    (SQLCHAR *)MBAuthentication, SQL_NTS);
627   MADB_FREE(MBServerName);
628   MADB_FREE(MBUserName);
629   MADB_FREE(MBAuthentication);
630   return ret;
631 }
632 /* }}} */
633 
634 /* {{{ SQLCopyDesc */
SQLCopyDesc(SQLHDESC SourceDescHandle,SQLHDESC TargetDescHandle)635 SQLRETURN SQL_API SQLCopyDesc(SQLHDESC SourceDescHandle,
636     SQLHDESC TargetDescHandle)
637 {
638   /*TODO: clear error */
639   return MADB_DescCopyDesc((MADB_Desc *)SourceDescHandle, (MADB_Desc *)TargetDescHandle);
640 }
641 /* }}} */
642 
643 /* {{{ SQLDataSources */
SQLDataSources(SQLHENV EnvironmentHandle,SQLUSMALLINT Direction,SQLCHAR * ServerName,SQLSMALLINT BufferLength1,SQLSMALLINT * NameLength1Ptr,SQLCHAR * Description,SQLSMALLINT BufferLength2,SQLSMALLINT * NameLength2Ptr)644 SQLRETURN SQL_API SQLDataSources(SQLHENV EnvironmentHandle,
645     SQLUSMALLINT Direction,
646     SQLCHAR *ServerName,
647     SQLSMALLINT BufferLength1,
648     SQLSMALLINT *NameLength1Ptr,
649     SQLCHAR *Description,
650     SQLSMALLINT BufferLength2,
651     SQLSMALLINT *NameLength2Ptr)
652 {
653   SQLRETURN ret= SQL_ERROR;
654 
655   return ret;
656 }
657 /* }}} */
658 
659 /* {{{ SQLDataSourcesW */
SQLDataSourcesW(SQLHENV EnvironmentHandle,SQLUSMALLINT Direction,SQLWCHAR * ServerName,SQLSMALLINT BufferLength1,SQLSMALLINT * NameLength1Ptr,SQLWCHAR * Description,SQLSMALLINT BufferLength2,SQLSMALLINT * NameLength2Ptr)660 SQLRETURN SQL_API SQLDataSourcesW(SQLHENV EnvironmentHandle,
661     SQLUSMALLINT Direction,
662     SQLWCHAR *ServerName,
663     SQLSMALLINT BufferLength1,
664     SQLSMALLINT *NameLength1Ptr,
665     SQLWCHAR *Description,
666     SQLSMALLINT BufferLength2,
667     SQLSMALLINT *NameLength2Ptr)
668 {
669   SQLRETURN ret= SQL_ERROR;
670 
671   return ret;
672 }
673 /* }}} */
674 
675 /* {{{ SQLDescribeCol */
SQLDescribeCol(SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,SQLCHAR * ColumnName,SQLSMALLINT BufferLength,SQLSMALLINT * NameLengthPtr,SQLSMALLINT * DataTypePtr,SQLULEN * ColumnSizePtr,SQLSMALLINT * DecimalDigitsPtr,SQLSMALLINT * NullablePtr)676 SQLRETURN SQL_API SQLDescribeCol(SQLHSTMT StatementHandle,
677     SQLUSMALLINT ColumnNumber,
678     SQLCHAR *ColumnName,
679     SQLSMALLINT BufferLength,
680     SQLSMALLINT *NameLengthPtr,
681     SQLSMALLINT *DataTypePtr,
682     SQLULEN *ColumnSizePtr,
683     SQLSMALLINT *DecimalDigitsPtr,
684     SQLSMALLINT *NullablePtr)
685 {
686   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
687   SQLRETURN ret;
688   if (!Stmt)
689     return SQL_INVALID_HANDLE;
690 
691   MADB_CLEAR_ERROR(&Stmt->Error);
692 
693   MDBUG_C_ENTER(Stmt->Connection, "SQLDescribeCol");
694   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
695   MDBUG_C_DUMP(Stmt->Connection, ColumnNumber, u);
696 
697   ret= Stmt->Methods->DescribeCol(Stmt, ColumnNumber, (void *)ColumnName, BufferLength,
698                                     NameLengthPtr, DataTypePtr, ColumnSizePtr, DecimalDigitsPtr,
699                                     NullablePtr, FALSE);
700 
701   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
702 }
703 /* }}} */
704 
705 /* {{{ SQLDescribeColW */
SQLDescribeColW(SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,SQLWCHAR * ColumnName,SQLSMALLINT BufferLength,SQLSMALLINT * NameLengthPtr,SQLSMALLINT * DataTypePtr,SQLULEN * ColumnSizePtr,SQLSMALLINT * DecimalDigitsPtr,SQLSMALLINT * NullablePtr)706 SQLRETURN SQL_API SQLDescribeColW(SQLHSTMT StatementHandle,
707     SQLUSMALLINT ColumnNumber,
708     SQLWCHAR *ColumnName,
709     SQLSMALLINT BufferLength,
710     SQLSMALLINT *NameLengthPtr,
711     SQLSMALLINT *DataTypePtr,
712     SQLULEN *ColumnSizePtr,
713     SQLSMALLINT *DecimalDigitsPtr,
714     SQLSMALLINT *NullablePtr)
715 {
716   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
717   SQLRETURN ret;
718 
719   if (!Stmt)
720     return SQL_INVALID_HANDLE;
721 
722   MADB_CLEAR_ERROR(&Stmt->Error);
723 
724   MDBUG_C_ENTER(Stmt->Connection, "SQLDescribeColW");
725   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
726   MDBUG_C_DUMP(Stmt->Connection, ColumnNumber, u);
727 
728   ret= Stmt->Methods->DescribeCol(Stmt, ColumnNumber, (void *)ColumnName, BufferLength,
729                                     NameLengthPtr, DataTypePtr, ColumnSizePtr, DecimalDigitsPtr,
730                                     NullablePtr, TRUE);
731 
732   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
733 }
734 /* }}} */
735 
736 /* {{{ SQLDescribeParam */
SQLDescribeParam(SQLHSTMT StatementHandle,SQLUSMALLINT ParameterNumber,SQLSMALLINT * DataTypePtr,SQLULEN * ParameterSizePtr,SQLSMALLINT * DecimalDigitsPtr,SQLSMALLINT * NullablePtr)737 SQLRETURN SQL_API SQLDescribeParam(SQLHSTMT StatementHandle,
738     SQLUSMALLINT ParameterNumber,
739     SQLSMALLINT *DataTypePtr,
740     SQLULEN *ParameterSizePtr,
741     SQLSMALLINT *DecimalDigitsPtr,
742     SQLSMALLINT *NullablePtr)
743 {
744   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
745 
746   if (!Stmt)
747     return SQL_INVALID_HANDLE;
748 
749   MADB_CLEAR_ERROR(&Stmt->Error);
750 
751   /* MariaDB doesn't support metadata for parameters,
752      so we return default values */
753   if (DataTypePtr)
754     *DataTypePtr= SQL_VARCHAR;
755   if (ParameterSizePtr)
756     *ParameterSizePtr= 1024 * 1024 * 24;
757   if (NullablePtr)
758     *NullablePtr= SQL_NULLABLE_UNKNOWN;
759   return SQL_SUCCESS;
760 }
761 /* }}} */
762 
763 /* {{{ SQLDisconnect */
SQLDisconnect(SQLHDBC ConnectionHandle)764 SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle)
765 {
766   SQLRETURN ret= SQL_ERROR;
767   MADB_Dbc *Connection = (MADB_Dbc *)ConnectionHandle;
768   MADB_List *Element, *NextElement;
769 
770   if (!Connection)
771     return SQL_INVALID_HANDLE;
772 
773   MADB_CLEAR_ERROR(&Connection->Error);
774 
775   MDBUG_C_ENTER(Connection, "SQLDisconnect");
776   MDBUG_C_DUMP(Connection, ConnectionHandle, 0x);
777 
778   /* Close all statements */
779   for (Element= Connection->Stmts; Element; Element= NextElement)
780   {
781     MADB_Stmt *Stmt = (MADB_Stmt*)Element->data;
782     NextElement= Element->next;
783     Stmt->Methods->StmtFree(Stmt, SQL_DROP);
784   }
785 
786   /* Close all explicitly allocated descriptors */
787   for (Element= Connection->Descrs; Element; Element= NextElement)
788   {
789     NextElement= Element->next;
790     MADB_DescFree((MADB_Desc*)Element->data, FALSE);
791   }
792 
793   if (Connection->mariadb)
794   {
795     mysql_close(Connection->mariadb);
796     Connection->mariadb= NULL;
797     ret= SQL_SUCCESS;
798   }
799   else
800   {
801     MADB_SetError(&Connection->Error, MADB_ERR_08003, NULL, 0);
802     ret= Connection->Error.ReturnValue;
803   }
804   Connection->ConnOrSrcCharset= NULL;
805 
806   MDBUG_C_RETURN(Connection, ret, &Connection->Error);
807 }
808 /* }}} */
809 
810 /* {{{ SQLDriverConnect */
SQLDriverConnect(SQLHDBC ConnectionHandle,SQLHWND WindowHandle,SQLCHAR * InConnectionString,SQLSMALLINT StringLength1,SQLCHAR * OutConnectionString,SQLSMALLINT BufferLength,SQLSMALLINT * StringLength2Ptr,SQLUSMALLINT DriverCompletion)811 SQLRETURN SQL_API SQLDriverConnect(SQLHDBC ConnectionHandle,
812     SQLHWND WindowHandle,
813     SQLCHAR *InConnectionString,
814     SQLSMALLINT StringLength1,
815     SQLCHAR *OutConnectionString,
816     SQLSMALLINT BufferLength,
817     SQLSMALLINT *StringLength2Ptr,
818     SQLUSMALLINT DriverCompletion)
819 {
820   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
821   SQLRETURN ret;
822   if (!Dbc)
823     return SQL_INVALID_HANDLE;
824 
825   MADB_CLEAR_ERROR(&Dbc->Error);
826 
827   MDBUG_C_ENTER(Dbc, "SQLDriverConnect");
828   MDBUG_C_DUMP(Dbc, Dbc, 0x);
829   MDBUG_C_DUMP(Dbc, InConnectionString, s);
830   MDBUG_C_DUMP(Dbc, StringLength1, d);
831   MDBUG_C_DUMP(Dbc, OutConnectionString, 0x);
832   MDBUG_C_DUMP(Dbc, BufferLength, d);
833   MDBUG_C_DUMP(Dbc, StringLength2Ptr, 0x);
834   MDBUG_C_DUMP(Dbc, DriverCompletion, d);
835   ret= Dbc->Methods->DriverConnect(Dbc, WindowHandle, InConnectionString, StringLength1, OutConnectionString,
836                                      BufferLength, StringLength2Ptr, DriverCompletion);
837 
838   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
839 }
840 /* }}} */
841 
842 /* {{{ SQLDriverConnectW */
SQLDriverConnectW(SQLHDBC ConnectionHandle,SQLHWND WindowHandle,SQLWCHAR * InConnectionString,SQLSMALLINT StringLength1,SQLWCHAR * OutConnectionString,SQLSMALLINT BufferLength,SQLSMALLINT * StringLength2Ptr,SQLUSMALLINT DriverCompletion)843 SQLRETURN SQL_API SQLDriverConnectW(SQLHDBC      ConnectionHandle,
844                                     SQLHWND      WindowHandle,
845                                     SQLWCHAR    *InConnectionString,
846                                     SQLSMALLINT  StringLength1,
847                                     SQLWCHAR    *OutConnectionString,
848                                     SQLSMALLINT  BufferLength,
849                                     SQLSMALLINT *StringLength2Ptr,
850                                     SQLUSMALLINT DriverCompletion)
851 {
852   SQLRETURN   ret=          SQL_ERROR;
853   SQLULEN     Length=       0; /* Since we need bigger(in bytes) buffer for utf8 string, the length may be > max SQLSMALLINT */
854   char        *InConnStrA=  NULL;
855   SQLULEN     InStrAOctLen= 0;
856   char        *OutConnStrA= NULL;
857   MADB_Dbc    *Dbc=         (MADB_Dbc *)ConnectionHandle;
858 
859   if (!ConnectionHandle)
860   {
861     return SQL_INVALID_HANDLE;
862   }
863 
864   MDBUG_C_ENTER(Dbc, "SQLDriverConnectW");
865 
866   MADB_CLEAR_ERROR(&Dbc->Error);
867 
868   InConnStrA= MADB_ConvertFromWChar(InConnectionString, StringLength1, &InStrAOctLen, Dbc->IsAnsi ? Dbc->ConnOrSrcCharset : &utf8, NULL);
869   MDBUG_C_DUMP(Dbc, Dbc, 0x);
870   MDBUG_C_DUMP(Dbc, InConnStrA, s);
871   MDBUG_C_DUMP(Dbc, StringLength1, d);
872   MDBUG_C_DUMP(Dbc, OutConnectionString, 0x);
873   MDBUG_C_DUMP(Dbc, BufferLength, d);
874   MDBUG_C_DUMP(Dbc, StringLength2Ptr, 0x);
875   MDBUG_C_DUMP(Dbc, DriverCompletion, d);
876 
877   /* Allocate buffer for Asc OutConnectionString */
878   if (OutConnectionString && BufferLength)
879   {
880     Length= BufferLength*4 /*Max bytes per utf8 character */;
881     OutConnStrA= (char *)MADB_CALLOC(Length);
882 
883     if (OutConnStrA == NULL)
884     {
885       ret= MADB_SetError(&Dbc->Error, MADB_ERR_HY001, NULL, 0);
886       goto end;
887     }
888   }
889 
890   ret= Dbc->Methods->DriverConnect(Dbc, WindowHandle, (SQLCHAR *)InConnStrA, InStrAOctLen, (SQLCHAR *)OutConnStrA,
891                                      Length, StringLength2Ptr, DriverCompletion);
892   MDBUG_C_DUMP(Dbc, ret, d);
893   if (!SQL_SUCCEEDED(ret))
894     goto end;
895 
896   if (OutConnectionString)
897   {
898     Length= MADB_SetString(&utf8, OutConnectionString, BufferLength,
899                                         OutConnStrA, SQL_NTS, &((MADB_Dbc *)ConnectionHandle)->Error);
900     if (StringLength2Ptr)
901       *StringLength2Ptr= (SQLSMALLINT)Length;
902   }
903 
904 end:
905   MADB_FREE(OutConnStrA);
906   MADB_FREE(InConnStrA);
907   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
908 }
909 /* }}} */
910 
911 /* {{{ SQLDrivers */
SQLDrivers(SQLHENV EnvironmentHandle,SQLUSMALLINT Direction,SQLCHAR * DriverDescription,SQLSMALLINT BufferLength1,SQLSMALLINT * DescriptionLengthPtr,SQLCHAR * DriverAttributes,SQLSMALLINT BufferLength2,SQLSMALLINT * AttributesLengthPtr)912 SQLRETURN SQL_API SQLDrivers(SQLHENV EnvironmentHandle,
913     SQLUSMALLINT Direction,
914     SQLCHAR *DriverDescription,
915     SQLSMALLINT BufferLength1,
916     SQLSMALLINT *DescriptionLengthPtr,
917     SQLCHAR *DriverAttributes,
918     SQLSMALLINT BufferLength2,
919     SQLSMALLINT *AttributesLengthPtr)
920 {
921   SQLRETURN ret= SQL_ERROR;
922 
923   return ret;
924 }
925 /* }}} */
926 
927 /* {{{ SQLDriversW */
SQLDriversW(SQLHENV EnvironmentHandle,SQLUSMALLINT Direction,SQLWCHAR * DriverDescription,SQLSMALLINT BufferLength1,SQLSMALLINT * DescriptionLengthPtr,SQLWCHAR * DriverAttributes,SQLSMALLINT BufferLength2,SQLSMALLINT * AttributesLengthPtr)928 SQLRETURN SQL_API SQLDriversW(SQLHENV EnvironmentHandle,
929     SQLUSMALLINT Direction,
930     SQLWCHAR *DriverDescription,
931     SQLSMALLINT BufferLength1,
932     SQLSMALLINT *DescriptionLengthPtr,
933     SQLWCHAR *DriverAttributes,
934     SQLSMALLINT BufferLength2,
935     SQLSMALLINT *AttributesLengthPtr)
936 {
937   SQLRETURN ret= SQL_ERROR;
938 
939   return ret;
940 }
941 /* }}} */
942 
943 /* {{{ SQLEndTran */
SQLEndTran(SQLSMALLINT HandleType,SQLHANDLE Handle,SQLSMALLINT CompletionType)944 SQLRETURN SQL_API SQLEndTran(SQLSMALLINT HandleType,
945     SQLHANDLE Handle,
946     SQLSMALLINT CompletionType)
947 {
948   MADB_CHECK_HANDLE_CLEAR_ERROR(HandleType, Handle);
949   return MA_SQLEndTran(HandleType, Handle, CompletionType);
950 }
951 /* }}} */
952 
953 /* {{{ SQLError */
SQLError(SQLHENV Env,SQLHDBC Dbc,SQLHSTMT Stmt,SQLCHAR * Sqlstate,SQLINTEGER * NativeError,SQLCHAR * Message,SQLSMALLINT MessageMax,SQLSMALLINT * MessageLen)954 SQLRETURN SQL_API SQLError(SQLHENV Env, SQLHDBC Dbc, SQLHSTMT Stmt,
955                            SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
956                            SQLCHAR *Message, SQLSMALLINT MessageMax,
957                            SQLSMALLINT *MessageLen)
958 {
959   SQLSMALLINT HandleType= 0;
960   SQLHANDLE   Handle=     NULL;
961   MADB_Error *error;
962 
963   if (Stmt)
964   {
965     MDBUG_C_ENTER(((MADB_Stmt*)Stmt)->Connection, "SQLError->SQLGetDiagRec");
966 
967     MDBUG_C_DUMP(((MADB_Stmt*)Stmt)->Connection, Env, 0x);
968     MDBUG_C_DUMP(((MADB_Stmt*)Stmt)->Connection, Dbc, 0x);
969     MDBUG_C_DUMP(((MADB_Stmt*)Stmt)->Connection, Stmt, 0x);
970 
971     Handle= Stmt;
972     HandleType= SQL_HANDLE_STMT;
973     error= &((MADB_Stmt*)Stmt)->Error;
974   }
975   else if (Dbc)
976   {
977     MDBUG_C_ENTER((MADB_Dbc*)Dbc, "SQLError->SQLGetDiagRec");
978 
979     MDBUG_C_DUMP((MADB_Dbc*)Dbc, Env, 0x);
980     MDBUG_C_DUMP((MADB_Dbc*)Dbc, Dbc, 0x);
981     MDBUG_C_DUMP((MADB_Dbc*)Dbc, Stmt, 0x);
982 
983     Handle= Dbc;
984     HandleType= SQL_HANDLE_DBC;
985     error= &((MADB_Dbc*)Dbc)->Error;
986   }
987   else
988   {
989     MDBUG_ENTER("SQLError->SQLGetDiagRec");
990     MDBUG_DUMP(Env, 0x);
991     MDBUG_DUMP(Dbc, 0x);
992     MDBUG_DUMP(Stmt, 0x);
993 
994     Handle= Env;
995     HandleType= SQL_HANDLE_ENV;
996     error= &((MADB_Env*)Env)->Error;
997   }
998 
999   return MA_SQLGetDiagRec(HandleType, Handle, ++error->ErrorNum, Sqlstate, NativeError, Message, MessageMax, MessageLen);
1000 }
1001 /* }}} */
1002 
1003 /*{{{ SQLErrorW */
1004 SQLRETURN SQL_API
SQLErrorW(SQLHENV Env,SQLHDBC Dbc,SQLHSTMT Stmt,SQLWCHAR * Sqlstate,SQLINTEGER * NativeError,SQLWCHAR * Message,SQLSMALLINT MessageMax,SQLSMALLINT * MessageLen)1005 SQLErrorW(SQLHENV Env, SQLHDBC Dbc, SQLHSTMT Stmt, SQLWCHAR *Sqlstate,
1006           SQLINTEGER *NativeError, SQLWCHAR *Message, SQLSMALLINT MessageMax,
1007           SQLSMALLINT *MessageLen)
1008 
1009 {
1010   SQLSMALLINT HandleType= 0;
1011   SQLHANDLE   Handle=     NULL;
1012   MADB_Error *error;
1013 
1014     if (Stmt)
1015   {
1016     Handle= Stmt;
1017     HandleType= SQL_HANDLE_STMT;
1018     error= &((MADB_Stmt*)Stmt)->Error;
1019   }
1020   else if (Dbc)
1021   {
1022     Handle= Dbc;
1023     HandleType= SQL_HANDLE_DBC;
1024     error= &((MADB_Dbc*)Dbc)->Error;
1025   }
1026   else
1027   {
1028     Handle= Env;
1029     HandleType= SQL_HANDLE_ENV;
1030     error= &((MADB_Env*)Env)->Error;
1031   }
1032 
1033   return MA_SQLGetDiagRecW(HandleType, Handle, ++error->ErrorNum, Sqlstate, NativeError, Message, MessageMax, MessageLen);
1034 }
1035 /* }}} */
1036 
1037 /* {{{ SQLTransact */
SQLTransact(SQLHENV Env,SQLHDBC Dbc,SQLUSMALLINT CompletionType)1038 SQLRETURN SQL_API SQLTransact(SQLHENV Env, SQLHDBC Dbc, SQLUSMALLINT CompletionType)
1039 {
1040   if (Env != SQL_NULL_HENV)
1041   {
1042     MADB_CLEAR_ERROR(&((MADB_Env*)Env)->Error);
1043     return MA_SQLEndTran(SQL_HANDLE_ENV, Env, CompletionType);
1044   }
1045   else if (Dbc != SQL_NULL_HDBC)
1046   {
1047     MADB_CLEAR_ERROR(&((MADB_Dbc*)Dbc)->Error);
1048     return MA_SQLEndTran(SQL_HANDLE_DBC, Dbc, CompletionType);
1049   }
1050   else
1051     return SQL_INVALID_HANDLE;
1052 }
1053 /* }}} */
1054 
1055 /* {{{ SQLExecDirect */
SQLExecDirect(SQLHSTMT StatementHandle,SQLCHAR * StatementText,SQLINTEGER TextLength)1056 SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle,
1057     SQLCHAR *StatementText,
1058     SQLINTEGER TextLength)
1059 {
1060   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1061   SQLRETURN ret;
1062 
1063   if (!Stmt)
1064     ret= SQL_INVALID_HANDLE;
1065   else
1066     ret= Stmt->Methods->ExecDirect(Stmt, (char *)StatementText, TextLength);
1067 
1068   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
1069 }
1070 /* }}} */
1071 
1072 /* {{{ SQLExecDirectW */
SQLExecDirectW(SQLHSTMT StatementHandle,SQLWCHAR * StatementText,SQLINTEGER TextLength)1073 SQLRETURN SQL_API SQLExecDirectW(SQLHSTMT StatementHandle,
1074     SQLWCHAR *StatementText,
1075     SQLINTEGER TextLength)
1076 {
1077   char      *CpStmt;
1078   SQLULEN   StmtLength;
1079   SQLRETURN ret;
1080   BOOL      ConversionError;
1081 
1082   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1083 
1084   if (!Stmt)
1085     return SQL_INVALID_HANDLE;
1086 
1087   MADB_CLEAR_ERROR(&Stmt->Error);
1088 
1089   MDBUG_C_ENTER(Stmt->Connection, "SQLExecDirectW");
1090   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
1091 
1092   CpStmt= MADB_ConvertFromWChar(StatementText, TextLength, &StmtLength, Stmt->Connection->ConnOrSrcCharset, &ConversionError);
1093   MDBUG_C_DUMP(Stmt->Connection, CpStmt, s);
1094   if (ConversionError)
1095   {
1096     MADB_SetError(&Stmt->Error, MADB_ERR_22018, NULL, 0);
1097     ret= Stmt->Error.ReturnValue;
1098   }
1099   else
1100     ret= Stmt->Methods->ExecDirect(Stmt, CpStmt, (SQLINTEGER)StmtLength);
1101   MADB_FREE(CpStmt);
1102 
1103   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
1104 }
1105 /* }}} */
1106 
SQLExecute(SQLHSTMT StatementHandle)1107 SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle)
1108 {
1109   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1110 
1111   if (StatementHandle == SQL_NULL_HSTMT)
1112     return SQL_INVALID_HANDLE;
1113 
1114   MADB_CLEAR_ERROR(&Stmt->Error);
1115 
1116   MDBUG_C_ENTER(Stmt->Connection, "SQLExecute");
1117   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
1118 
1119   return Stmt->Methods->Execute(Stmt, FALSE);
1120 }
1121 /* }}} */
1122 
1123 /* {{{ SQLExtendedFetch */
SQLExtendedFetch(SQLHSTMT StatementHandle,SQLUSMALLINT FetchOrientation,SQLLEN FetchOffset,SQLULEN * RowCountPtr,SQLUSMALLINT * RowStatusArray)1124 SQLRETURN SQL_API SQLExtendedFetch(SQLHSTMT StatementHandle,
1125     SQLUSMALLINT FetchOrientation,
1126     SQLLEN FetchOffset,
1127     SQLULEN *RowCountPtr,
1128     SQLUSMALLINT *RowStatusArray)
1129 {
1130   SQLRETURN ret;
1131   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1132 
1133   SQLULEN *SaveRowsProcessedPtr= Stmt->Ird->Header.RowsProcessedPtr;
1134   SQLUSMALLINT *SaveArrayStatusPtr= Stmt->Ird->Header.ArrayStatusPtr;
1135 
1136   if (!Stmt)
1137     return SQL_INVALID_HANDLE;
1138   MADB_CLEAR_ERROR(&Stmt->Error);
1139 
1140   MDBUG_C_ENTER(Stmt->Connection, "SQLExtendedFetch");
1141   MDBUG_C_DUMP(Stmt->Connection, FetchOrientation, u);
1142   MDBUG_C_DUMP(Stmt->Connection, FetchOffset, d);
1143   MDBUG_C_DUMP(Stmt->Connection, RowCountPtr, 0x);
1144   MDBUG_C_DUMP(Stmt->Connection, RowStatusArray, 0x);
1145 
1146   Stmt->Ird->Header.RowsProcessedPtr= RowCountPtr;
1147   Stmt->Ird->Header.ArrayStatusPtr= RowStatusArray;
1148   ret=  Stmt->Methods->FetchScroll(Stmt, FetchOrientation, FetchOffset);
1149 
1150   if (RowStatusArray && SaveArrayStatusPtr)
1151   {
1152     SQLUINTEGER i;
1153     for (i=0; i < Stmt->Ard->Header.ArraySize; i++)
1154       SaveArrayStatusPtr[i]= RowStatusArray[i];
1155   }
1156 
1157   Stmt->Ird->Header.RowsProcessedPtr= SaveRowsProcessedPtr;
1158   Stmt->Ird->Header.ArrayStatusPtr= SaveArrayStatusPtr;
1159 
1160   if (ret == SQL_NO_DATA)
1161   {
1162     if (RowCountPtr)
1163       *RowCountPtr= 0;
1164   }
1165   if (ret == SQL_ERROR)
1166     if (strcmp(Stmt->Error.SqlState, "22002") == 0)
1167       ret= SQL_SUCCESS_WITH_INFO;
1168 
1169   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
1170 }
1171 /* }}} */
1172 
1173 /* {{{ SQLFetch */
SQLFetch(SQLHSTMT StatementHandle)1174 SQLRETURN SQL_API SQLFetch(SQLHSTMT StatementHandle)
1175 {
1176   MADB_Stmt *Stmt;
1177 
1178   if (StatementHandle == SQL_NULL_HSTMT)
1179     return SQL_INVALID_HANDLE;
1180 
1181   Stmt= (MADB_Stmt *)StatementHandle;
1182 
1183   MDBUG_C_ENTER(Stmt->Connection, "SQLFetch");
1184   MADB_CLEAR_ERROR(&Stmt->Error);
1185 
1186   /* SQLFetch is equivalent of SQLFetchScroll(SQL_FETCH_NEXT), 3rd parameter is ignored for SQL_FETCH_NEXT */
1187   MDBUG_C_RETURN(Stmt->Connection, Stmt->Methods->FetchScroll(Stmt, SQL_FETCH_NEXT, 1), &Stmt->Error);
1188 }
1189 /* }}} */
1190 
1191 /* {{{ SQLFetchScroll */
SQLFetchScroll(SQLHSTMT StatementHandle,SQLSMALLINT FetchOrientation,SQLLEN FetchOffset)1192 SQLRETURN SQL_API SQLFetchScroll(SQLHSTMT StatementHandle,
1193     SQLSMALLINT FetchOrientation,
1194     SQLLEN FetchOffset)
1195 {
1196   MADB_Stmt *Stmt;
1197 
1198   if (StatementHandle == SQL_NULL_HSTMT)
1199     return SQL_INVALID_HANDLE;
1200 
1201   Stmt= (MADB_Stmt *)StatementHandle;
1202 
1203   MDBUG_C_ENTER(Stmt->Connection, "SQLFetchScroll");
1204   MDBUG_C_DUMP(Stmt->Connection, FetchOrientation, d);
1205 
1206   MADB_CLEAR_ERROR(&Stmt->Error);
1207 
1208   MDBUG_C_RETURN(Stmt->Connection, Stmt->Methods->FetchScroll(Stmt, FetchOrientation, FetchOffset), &Stmt->Error);
1209 }
1210 /* }}} */
1211 
1212 /* {{{ SQLFreeHandle */
SQLFreeHandle(SQLSMALLINT HandleType,SQLHANDLE Handle)1213 SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT HandleType,
1214                                 SQLHANDLE Handle)
1215 {
1216   SQLRETURN ret= SQL_INVALID_HANDLE;
1217   MADB_CHECK_HANDLE_CLEAR_ERROR(HandleType, Handle);
1218 
1219   switch (HandleType)
1220   {
1221   case SQL_HANDLE_ENV:
1222       MDBUG_ENTER("SQLFreeHandle");
1223       MDBUG_DUMP(HandleType, d);
1224       MDBUG_DUMP(Handle, 0x);
1225 
1226       ret= MADB_EnvFree((MADB_Env *)Handle);
1227       break;
1228   case SQL_HANDLE_DBC:
1229     {
1230       MADB_Dbc *Dbc= (MADB_Dbc *)Handle;
1231 
1232       MDBUG_C_ENTER(Dbc, "SQLFreeHandle");
1233       MDBUG_C_DUMP(Dbc, HandleType, d);
1234       MDBUG_C_DUMP(Dbc, Handle, 0x);
1235 
1236       ret= MADB_DbcFree(Dbc);
1237       return ret;
1238       /*MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);*/
1239     }
1240   case SQL_HANDLE_DESC:
1241     {
1242       MADB_Desc *Desc= (MADB_Desc *)Handle;
1243       MADB_Dbc  *Dbc=  Desc->Dbc;
1244 
1245       MDBUG_C_ENTER(Dbc, "SQLFreeHandle");
1246       MDBUG_C_DUMP(Dbc, HandleType, d);
1247       MDBUG_C_DUMP(Dbc, Handle, 0x);
1248 
1249       /* Error if the descriptor does not belong to application(was automatically alliocated by the driver)
1250          Basically DM is supposed to take care of this. Keeping in mind direct linking */
1251       if (!Desc->AppType)
1252       {
1253         MADB_SetError(&Desc->Error, MADB_ERR_HY017, NULL, 0);
1254         MDBUG_C_RETURN(Dbc, Desc->Error.ReturnValue, &Desc->Error);
1255       }
1256       ret= MADB_DescFree(Desc, FALSE);
1257       MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
1258     }
1259   case SQL_HANDLE_STMT:
1260     {
1261       MADB_Stmt *Stmt= (MADB_Stmt *)Handle;
1262       MADB_Dbc  *Dbc=  Stmt->Connection;
1263 
1264       MDBUG_C_ENTER(Dbc, "SQLFreeHandle");
1265       MDBUG_C_DUMP(Dbc, HandleType, d);
1266       MDBUG_C_DUMP(Dbc, Handle, 0x);
1267 
1268       ret= Stmt->Methods->StmtFree(Stmt, SQL_DROP);
1269 
1270       MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
1271     }
1272   }
1273 
1274   MDBUG_RETURN(ret);
1275 }
1276 /* }}} */
1277 
1278 /* {{{ SQLFreeEnv */
SQLFreeEnv(SQLHANDLE henv)1279 SQLRETURN SQL_API SQLFreeEnv(SQLHANDLE henv)
1280 {
1281   if (henv == SQL_NULL_HENV)
1282     return SQL_INVALID_HANDLE;
1283   MADB_CLEAR_ERROR(&((MADB_Env*)henv)->Error);
1284 
1285   return MADB_EnvFree((MADB_Env *)henv);
1286 }
1287 /* }}} */
1288 
1289 /* {{{ SQLFreeConnect */
SQLFreeConnect(SQLHANDLE hdbc)1290 SQLRETURN SQL_API SQLFreeConnect(SQLHANDLE hdbc)
1291 {
1292   if (hdbc == SQL_NULL_HDBC)
1293     return SQL_INVALID_HANDLE;
1294   MADB_CLEAR_ERROR(&((MADB_Dbc*)hdbc)->Error);
1295 
1296   return MADB_DbcFree((MADB_Dbc*)hdbc);
1297 }
1298 /* }}} */
1299 
1300 /* {{{ SQLFreeStmt */
SQLFreeStmt(SQLHSTMT StatementHandle,SQLUSMALLINT Option)1301 SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle,
1302            SQLUSMALLINT Option)
1303 {
1304   MADB_Stmt* Stmt = (MADB_Stmt*)StatementHandle;
1305   if (StatementHandle== SQL_NULL_HSTMT)
1306     return SQL_INVALID_HANDLE;
1307   MDBUG_C_ENTER(((MADB_Stmt*)StatementHandle)->Connection, "SQLFreeStmt");
1308   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
1309   MDBUG_C_DUMP(Stmt->Connection, Option, d);
1310   MADB_CLEAR_ERROR(&Stmt->Error);
1311 
1312   return Stmt->Methods->StmtFree(Stmt, Option);
1313 }
1314 /* }}} */
1315 
1316 /* {{{ SQLForeignKeys */
SQLForeignKeys(SQLHSTMT StatementHandle,SQLCHAR * PKCatalogName,SQLSMALLINT NameLength1,SQLCHAR * PKSchemaName,SQLSMALLINT NameLength2,SQLCHAR * PKTableName,SQLSMALLINT NameLength3,SQLCHAR * FKCatalogName,SQLSMALLINT NameLength4,SQLCHAR * FKSchemaName,SQLSMALLINT NameLength5,SQLCHAR * FKTableName,SQLSMALLINT NameLength6)1317 SQLRETURN SQL_API SQLForeignKeys(SQLHSTMT StatementHandle,
1318     SQLCHAR *PKCatalogName,
1319     SQLSMALLINT NameLength1,
1320     SQLCHAR *PKSchemaName,
1321     SQLSMALLINT NameLength2,
1322     SQLCHAR *PKTableName,
1323     SQLSMALLINT NameLength3,
1324     SQLCHAR *FKCatalogName,
1325     SQLSMALLINT NameLength4,
1326     SQLCHAR *FKSchemaName,
1327     SQLSMALLINT NameLength5,
1328     SQLCHAR *FKTableName,
1329     SQLSMALLINT NameLength6)
1330 {
1331   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1332   SQLRETURN ret;
1333 
1334   if(!Stmt)
1335     return SQL_INVALID_HANDLE;
1336   MADB_CLEAR_ERROR(&Stmt->Error);
1337 
1338   MDBUG_C_ENTER(Stmt->Connection, "SQLForeignKeys");
1339 
1340   ret= Stmt->Methods->ForeignKeys(Stmt, (char *)PKCatalogName, NameLength1, (char *)PKSchemaName, NameLength2,
1341                                     (char *)PKTableName, NameLength3, (char *)FKCatalogName, NameLength4,
1342                                     (char *)FKSchemaName, NameLength4, (char *)FKTableName, NameLength6);
1343 
1344   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
1345 }
1346 /* }}} */
1347 
1348 /* {{{ SQLForeignKeysW */
SQLForeignKeysW(SQLHSTMT StatementHandle,SQLWCHAR * PKCatalogName,SQLSMALLINT NameLength1,SQLWCHAR * PKSchemaName,SQLSMALLINT NameLength2,SQLWCHAR * PKTableName,SQLSMALLINT NameLength3,SQLWCHAR * FKCatalogName,SQLSMALLINT NameLength4,SQLWCHAR * FKSchemaName,SQLSMALLINT NameLength5,SQLWCHAR * FKTableName,SQLSMALLINT NameLength6)1349 SQLRETURN SQL_API SQLForeignKeysW(SQLHSTMT StatementHandle,
1350     SQLWCHAR *PKCatalogName,
1351     SQLSMALLINT NameLength1,
1352     SQLWCHAR *PKSchemaName,
1353     SQLSMALLINT NameLength2,
1354     SQLWCHAR *PKTableName,
1355     SQLSMALLINT NameLength3,
1356     SQLWCHAR *FKCatalogName,
1357     SQLSMALLINT NameLength4,
1358     SQLWCHAR *FKSchemaName,
1359     SQLSMALLINT NameLength5,
1360     SQLWCHAR *FKTableName,
1361     SQLSMALLINT NameLength6)
1362 {
1363   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1364   char *CpPkCatalog= NULL,
1365        *CpPkSchema= NULL,
1366        *CpPkTable= NULL,
1367        *CpFkCatalog= NULL,
1368        *CpFkSchema= NULL,
1369        *CpFkTable= NULL;
1370   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0,
1371              CpLength4= 0, CpLength5= 0 , CpLength6= 0;
1372   SQLRETURN ret;
1373   if(!Stmt)
1374     return SQL_INVALID_HANDLE;
1375   MADB_CLEAR_ERROR(&Stmt->Error);
1376 
1377   MDBUG_C_ENTER(Stmt->Connection, "SQLForeignKeysW");
1378 
1379   if (PKCatalogName != NULL)
1380   {
1381     CpPkCatalog = MADB_ConvertFromWChar(PKCatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
1382   }
1383   if (PKSchemaName != NULL)
1384   {
1385     CpPkSchema = MADB_ConvertFromWChar(PKSchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
1386   }
1387   if (PKTableName != NULL)
1388   {
1389     CpPkTable = MADB_ConvertFromWChar(PKTableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
1390   }
1391   if (FKCatalogName != NULL)
1392   {
1393     CpFkCatalog = MADB_ConvertFromWChar(FKCatalogName, NameLength4, &CpLength4, Stmt->Connection->ConnOrSrcCharset, NULL);
1394   }
1395   if (FKSchemaName != NULL)
1396   {
1397     CpFkSchema = MADB_ConvertFromWChar(FKSchemaName, NameLength5, &CpLength5, Stmt->Connection->ConnOrSrcCharset, NULL);
1398   }
1399   if (FKTableName != NULL)
1400   {
1401     CpFkTable = MADB_ConvertFromWChar(FKTableName, NameLength6, &CpLength6, Stmt->Connection->ConnOrSrcCharset, NULL);
1402   }
1403 
1404   ret= Stmt->Methods->ForeignKeys(Stmt, CpPkCatalog, (SQLSMALLINT)CpLength1, CpPkSchema, (SQLSMALLINT)CpLength2,
1405                                   CpPkTable, (SQLSMALLINT)CpLength3, CpFkCatalog, (SQLSMALLINT)CpLength4,
1406                                   CpFkSchema, (SQLSMALLINT)CpLength5, CpFkTable, (SQLSMALLINT)CpLength6);
1407   MADB_FREE(CpPkCatalog);
1408   MADB_FREE(CpPkSchema);
1409   MADB_FREE(CpPkTable);
1410   MADB_FREE(CpFkCatalog);
1411   MADB_FREE(CpFkSchema);
1412   MADB_FREE(CpFkTable);
1413 
1414   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
1415 }
1416 /* }}} */
1417 
1418 /* {{{ SQLGetConnectAttr */
SQLGetConnectAttr(SQLHDBC ConnectionHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1419 SQLRETURN SQL_API SQLGetConnectAttr(SQLHDBC ConnectionHandle,
1420     SQLINTEGER Attribute,
1421     SQLPOINTER ValuePtr,
1422     SQLINTEGER BufferLength,
1423     SQLINTEGER *StringLengthPtr)
1424 {
1425   if (ConnectionHandle == SQL_NULL_HDBC)
1426     return SQL_INVALID_HANDLE;
1427   MADB_CLEAR_ERROR(&((MADB_Dbc *)ConnectionHandle)->Error);
1428 
1429   return MA_SQLGetConnectAttr(ConnectionHandle, Attribute, ValuePtr, BufferLength, StringLengthPtr);
1430 }
1431 /* }}} */
1432 
1433 /* {{{ SQLGetConnectAttrW */
SQLGetConnectAttrW(SQLHDBC ConnectionHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1434 SQLRETURN SQL_API SQLGetConnectAttrW(SQLHDBC ConnectionHandle,
1435     SQLINTEGER Attribute,
1436     SQLPOINTER ValuePtr,
1437     SQLINTEGER BufferLength,
1438     SQLINTEGER *StringLengthPtr)
1439 {
1440   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1441   SQLRETURN ret;
1442 
1443   if (!Dbc)
1444     return SQL_INVALID_HANDLE;
1445   MADB_CLEAR_ERROR(&Dbc->Error);
1446 
1447   MDBUG_C_ENTER(Dbc, "SQLGetConnectAttr");
1448   MDBUG_C_DUMP(Dbc, Attribute, d);
1449   MDBUG_C_DUMP(Dbc, ValuePtr, 0x);
1450   MDBUG_C_DUMP(Dbc, BufferLength, d);
1451   MDBUG_C_DUMP(Dbc, StringLengthPtr, 0x);
1452 
1453   ret= Dbc->Methods->GetAttr(Dbc, Attribute, ValuePtr, BufferLength, StringLengthPtr, TRUE);
1454 
1455   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
1456 }
1457 /* }}} */
1458 
1459 /* {{{ SQLGetConnectOption */
SQLGetConnectOption(SQLHDBC ConnectionHandle,SQLUSMALLINT Option,SQLPOINTER ValuePtr)1460 SQLRETURN SQL_API SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER ValuePtr)
1461 {
1462   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1463 
1464   if (!Dbc)
1465     return SQL_INVALID_HANDLE;
1466   MADB_CLEAR_ERROR(&Dbc->Error);
1467 
1468   return MA_SQLGetConnectAttr(ConnectionHandle, Option, ValuePtr,
1469                            Option == SQL_ATTR_CURRENT_CATALOG ? SQL_MAX_OPTION_STRING_LENGTH : 0, NULL);
1470 }
1471 /* }}} */
1472 
1473 /* {{{ SQLGetConnectOptionW */
SQLGetConnectOptionW(SQLHDBC ConnectionHandle,SQLUSMALLINT Option,SQLPOINTER ValuePtr)1474 SQLRETURN SQL_API SQLGetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER ValuePtr)
1475 {
1476   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1477   if (!Dbc)
1478     return SQL_INVALID_HANDLE;
1479   MADB_CLEAR_ERROR(&Dbc->Error);
1480   return SQLGetConnectAttrW(ConnectionHandle, Option, ValuePtr,
1481                            Option == SQL_ATTR_CURRENT_CATALOG ? SQL_MAX_OPTION_STRING_LENGTH : 0, NULL);
1482 }
1483 /* }}} */
1484 
1485 /* {{{ SQLGetCursorName */
SQLGetCursorName(SQLHSTMT StatementHandle,SQLCHAR * CursorName,SQLSMALLINT BufferLength,SQLSMALLINT * NameLengthPtr)1486 SQLRETURN SQL_API SQLGetCursorName(
1487      SQLHSTMT        StatementHandle,
1488      SQLCHAR *       CursorName,
1489      SQLSMALLINT     BufferLength,
1490      SQLSMALLINT *   NameLengthPtr)
1491 {
1492   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1493   if (!Stmt)
1494     return SQL_INVALID_HANDLE;
1495   MADB_CLEAR_ERROR(&Stmt->Error);
1496 
1497   return Stmt->Methods->GetCursorName(Stmt, CursorName, BufferLength, NameLengthPtr, FALSE);
1498 }
1499 /* }}} */
1500 
1501 /* {{{ SQLGetCursorNameW */
SQLGetCursorNameW(SQLHSTMT StatementHandle,SQLWCHAR * CursorName,SQLSMALLINT BufferLength,SQLSMALLINT * NameLengthPtr)1502 SQLRETURN SQL_API SQLGetCursorNameW(
1503      SQLHSTMT        StatementHandle,
1504      SQLWCHAR *      CursorName,
1505      SQLSMALLINT     BufferLength,
1506      SQLSMALLINT *   NameLengthPtr)
1507 {
1508   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1509   if (!Stmt)
1510     return SQL_INVALID_HANDLE;
1511   MADB_CLEAR_ERROR(&Stmt->Error);
1512 
1513   return Stmt->Methods->GetCursorName(Stmt, CursorName, BufferLength, NameLengthPtr, TRUE);
1514 }
1515 /* }}} */
1516 
1517 /* {{{ SQLGetData */
SQLGetData(SQLHSTMT StatementHandle,SQLUSMALLINT Col_or_Param_Num,SQLSMALLINT TargetType,SQLPOINTER TargetValuePtr,SQLLEN BufferLength,SQLLEN * StrLen_or_IndPtr)1518 SQLRETURN SQL_API SQLGetData(SQLHSTMT StatementHandle,
1519     SQLUSMALLINT Col_or_Param_Num,
1520     SQLSMALLINT TargetType,
1521     SQLPOINTER TargetValuePtr,
1522     SQLLEN BufferLength,
1523     SQLLEN *StrLen_or_IndPtr)
1524 {
1525   MADB_Stmt *Stmt= (MADB_Stmt*)StatementHandle;
1526   unsigned int i;
1527   MADB_DescRecord *IrdRec;
1528 
1529   if (StatementHandle== SQL_NULL_HSTMT)
1530     return SQL_INVALID_HANDLE;
1531   MADB_CLEAR_ERROR(&Stmt->Error);
1532 
1533   /* In case we don't have DM(it check for that) */
1534   if (TargetValuePtr == NULL)
1535   {
1536     return MADB_SetError(&Stmt->Error, MADB_ERR_HY009, NULL, 0);
1537   }
1538 
1539   /* Bookmark */
1540   if (Col_or_Param_Num == 0)
1541   {
1542     return MADB_GetBookmark(Stmt, TargetType, TargetValuePtr, BufferLength, StrLen_or_IndPtr);
1543   }
1544 
1545   /* We don't need this to be checked in case of "internal" use of the GetData, i.e. for internal needs we should always get the data */
1546   if ( Stmt->CharOffset[Col_or_Param_Num - 1] > 0
1547     && Stmt->CharOffset[Col_or_Param_Num - 1] >= Stmt->Lengths[Col_or_Param_Num - 1])
1548   {
1549     return SQL_NO_DATA;
1550   }
1551 
1552   if (BufferLength < 0)
1553   {
1554     return MADB_SetError(&Stmt->Error, MADB_ERR_HY090, NULL, 0);
1555   }
1556 
1557   /* reset offsets for other columns. Doing that here since "internal" calls should not do that */
1558   for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
1559   {
1560     if (i != Col_or_Param_Num - 1)
1561     {
1562       IrdRec= MADB_DescGetInternalRecord(Stmt->Ird, i, MADB_DESC_READ);
1563       if (IrdRec)
1564       {
1565         MADB_FREE(IrdRec->InternalBuffer);
1566       }
1567       Stmt->CharOffset[i]= 0;
1568     }
1569   }
1570 
1571   return Stmt->Methods->GetData(StatementHandle, Col_or_Param_Num, TargetType, TargetValuePtr, BufferLength, StrLen_or_IndPtr, FALSE);
1572 }
1573 /* }}} */
1574 
1575 /* {{{ SQLGetDescField */
SQLGetDescField(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT FieldIdentifier,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1576 SQLRETURN SQL_API SQLGetDescField(SQLHDESC DescriptorHandle,
1577     SQLSMALLINT RecNumber,
1578     SQLSMALLINT FieldIdentifier,
1579     SQLPOINTER ValuePtr,
1580     SQLINTEGER BufferLength,
1581     SQLINTEGER *StringLengthPtr)
1582 {
1583   if (!DescriptorHandle)
1584     return SQL_INVALID_HANDLE;
1585   MADB_CLEAR_ERROR(&((MADB_Desc*)DescriptorHandle)->Error);
1586 
1587   return MADB_DescGetField(DescriptorHandle, RecNumber, FieldIdentifier, ValuePtr, BufferLength, StringLengthPtr, FALSE);
1588 }
1589 /* }}} */
1590 
1591 /* {{{ SQLGetDescFieldW */
SQLGetDescFieldW(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT FieldIdentifier,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1592 SQLRETURN SQL_API SQLGetDescFieldW(SQLHDESC DescriptorHandle,
1593     SQLSMALLINT RecNumber,
1594     SQLSMALLINT FieldIdentifier,
1595     SQLPOINTER ValuePtr,
1596     SQLINTEGER BufferLength,
1597     SQLINTEGER *StringLengthPtr)
1598 {
1599   if (!DescriptorHandle)
1600     return SQL_INVALID_HANDLE;
1601   MADB_CLEAR_ERROR(&((MADB_Desc*)DescriptorHandle)->Error);
1602 
1603   return MADB_DescGetField(DescriptorHandle, RecNumber, FieldIdentifier, ValuePtr, BufferLength, StringLengthPtr, TRUE);
1604 }
1605 /* }}} */
1606 
1607 /* {{{ SQLGetDescRec */
SQLGetDescRec(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLCHAR * Name,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr,SQLSMALLINT * TypePtr,SQLSMALLINT * SubTypePtr,SQLLEN * LengthPtr,SQLSMALLINT * PrecisionPtr,SQLSMALLINT * ScalePtr,SQLSMALLINT * NullablePtr)1608 SQLRETURN SQL_API SQLGetDescRec(SQLHDESC DescriptorHandle,
1609     SQLSMALLINT RecNumber,
1610     SQLCHAR *Name,
1611     SQLSMALLINT BufferLength,
1612     SQLSMALLINT *StringLengthPtr,
1613     SQLSMALLINT *TypePtr,
1614     SQLSMALLINT *SubTypePtr,
1615     SQLLEN *LengthPtr,
1616     SQLSMALLINT *PrecisionPtr,
1617     SQLSMALLINT *ScalePtr,
1618     SQLSMALLINT *NullablePtr)
1619 {
1620   MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
1621   if (!Desc)
1622     return SQL_INVALID_HANDLE;
1623   MADB_CLEAR_ERROR(&Desc->Error);
1624 
1625   return MADB_DescGetRec(Desc, RecNumber, Name, BufferLength, StringLengthPtr, TypePtr, SubTypePtr,
1626                          LengthPtr, PrecisionPtr, ScalePtr, NullablePtr, FALSE);
1627 }
1628 /* }}} */
1629 
1630 /* {{{ SQLGetDescRecW */
SQLGetDescRecW(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLWCHAR * Name,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr,SQLSMALLINT * TypePtr,SQLSMALLINT * SubTypePtr,SQLLEN * LengthPtr,SQLSMALLINT * PrecisionPtr,SQLSMALLINT * ScalePtr,SQLSMALLINT * NullablePtr)1631 SQLRETURN SQL_API SQLGetDescRecW(SQLHDESC DescriptorHandle,
1632     SQLSMALLINT RecNumber,
1633     SQLWCHAR *Name,
1634     SQLSMALLINT BufferLength,
1635     SQLSMALLINT *StringLengthPtr,
1636     SQLSMALLINT *TypePtr,
1637     SQLSMALLINT *SubTypePtr,
1638     SQLLEN *LengthPtr,
1639     SQLSMALLINT *PrecisionPtr,
1640     SQLSMALLINT *ScalePtr,
1641     SQLSMALLINT *NullablePtr)
1642 {
1643  MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
1644   if (!Desc)
1645     return SQL_INVALID_HANDLE;
1646   MADB_CLEAR_ERROR(&Desc->Error);
1647 
1648   return MADB_DescGetRec(Desc, RecNumber, (SQLCHAR *)Name, BufferLength, StringLengthPtr, TypePtr, SubTypePtr,
1649                          LengthPtr, PrecisionPtr, ScalePtr, NullablePtr, TRUE);
1650 }
1651 /* }}} */
1652 
1653 /* {{{ SQLGetDiagField */
SQLGetDiagField(SQLSMALLINT HandleType,SQLHANDLE Handle,SQLSMALLINT RecNumber,SQLSMALLINT DiagIdentifier,SQLPOINTER DiagInfoPtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr)1654 SQLRETURN SQL_API SQLGetDiagField(SQLSMALLINT HandleType,
1655     SQLHANDLE Handle,
1656     SQLSMALLINT RecNumber,
1657     SQLSMALLINT DiagIdentifier,
1658     SQLPOINTER DiagInfoPtr,
1659     SQLSMALLINT BufferLength,
1660     SQLSMALLINT *StringLengthPtr)
1661 {
1662   if (!Handle)
1663     return SQL_INVALID_HANDLE;
1664   return MADB_GetDiagField(HandleType, Handle, RecNumber, DiagIdentifier, DiagInfoPtr, BufferLength, StringLengthPtr, FALSE);
1665 }
1666 /* }}} */
1667 
1668 /* {{{ SQLGetDiagFieldW */
SQLGetDiagFieldW(SQLSMALLINT HandleType,SQLHANDLE Handle,SQLSMALLINT RecNumber,SQLSMALLINT DiagIdentifier,SQLPOINTER DiagInfoPtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr)1669 SQLRETURN SQL_API SQLGetDiagFieldW(SQLSMALLINT HandleType,
1670     SQLHANDLE Handle,
1671     SQLSMALLINT RecNumber,
1672     SQLSMALLINT DiagIdentifier,
1673     SQLPOINTER DiagInfoPtr,
1674     SQLSMALLINT BufferLength,
1675     SQLSMALLINT *StringLengthPtr)
1676 {
1677   if (!Handle)
1678     return SQL_INVALID_HANDLE;
1679   return MADB_GetDiagField(HandleType, Handle, RecNumber, DiagIdentifier, DiagInfoPtr, BufferLength, StringLengthPtr, TRUE);
1680 }
1681 /* }}} */
1682 
1683 /* {{{ SQLGetDiagRec */
SQLGetDiagRec(SQLSMALLINT HandleType,SQLHANDLE Handle,SQLSMALLINT RecNumber,SQLCHAR * SQLState,SQLINTEGER * NativeErrorPtr,SQLCHAR * MessageText,SQLSMALLINT BufferLength,SQLSMALLINT * TextLengthPtr)1684 SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT HandleType,
1685     SQLHANDLE Handle,
1686     SQLSMALLINT RecNumber,
1687     SQLCHAR *SQLState,
1688     SQLINTEGER *NativeErrorPtr,
1689     SQLCHAR *MessageText,
1690     SQLSMALLINT BufferLength,
1691     SQLSMALLINT *TextLengthPtr)
1692 {
1693   return MA_SQLGetDiagRec(HandleType, Handle, RecNumber, SQLState, NativeErrorPtr,
1694                           MessageText, BufferLength, TextLengthPtr);
1695 }
1696 /* }}} */
1697 
1698 /* {{{ SQLGetDiagRecW */
SQLGetDiagRecW(SQLSMALLINT HandleType,SQLHANDLE Handle,SQLSMALLINT RecNumber,SQLWCHAR * SQLState,SQLINTEGER * NativeErrorPtr,SQLWCHAR * MessageText,SQLSMALLINT BufferLength,SQLSMALLINT * TextLengthPtr)1699 SQLRETURN SQL_API SQLGetDiagRecW(SQLSMALLINT HandleType,
1700     SQLHANDLE Handle,
1701     SQLSMALLINT RecNumber,
1702     SQLWCHAR *SQLState,
1703     SQLINTEGER *NativeErrorPtr,
1704     SQLWCHAR *MessageText,
1705     SQLSMALLINT BufferLength,
1706     SQLSMALLINT *TextLengthPtr)
1707 {
1708   return MA_SQLGetDiagRecW(HandleType, Handle, RecNumber, SQLState, NativeErrorPtr, MessageText,
1709                            BufferLength, TextLengthPtr);
1710 }
1711 /* }}} */
1712 
1713 /* {{{ SQLGetEnvAttr */
SQLGetEnvAttr(SQLHENV EnvironmentHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1714 SQLRETURN SQL_API SQLGetEnvAttr(SQLHENV EnvironmentHandle,
1715     SQLINTEGER Attribute,
1716     SQLPOINTER ValuePtr,
1717     SQLINTEGER BufferLength,
1718     SQLINTEGER *StringLengthPtr)
1719 {
1720   MADB_Env *Env= (MADB_Env *)EnvironmentHandle;
1721   SQLRETURN ret;
1722 
1723   MDBUG_ENTER("SQLGetEnvAttr");
1724   MDBUG_DUMP(Attribute, d);
1725   MDBUG_DUMP(ValuePtr, 0x);
1726   MDBUG_DUMP(BufferLength, d);
1727   MDBUG_DUMP(StringLengthPtr, 0x);
1728 
1729   if (!Env)
1730     ret= SQL_INVALID_HANDLE;
1731   else
1732   {
1733     MADB_CLEAR_ERROR(&Env->Error);
1734     ret= MADB_EnvGetAttr(Env, Attribute, ValuePtr, BufferLength, StringLengthPtr);
1735   }
1736 
1737   MDBUG_DUMP(ret, d);
1738   MDBUG_RETURN(ret);
1739 }
1740 /* {{{ SQLGetFunctions */
SQLGetFunctions(SQLHDBC ConnectionHandle,SQLUSMALLINT FunctionId,SQLUSMALLINT * SupportedPtr)1741 SQLRETURN SQL_API SQLGetFunctions(SQLHDBC ConnectionHandle,
1742     SQLUSMALLINT FunctionId,
1743     SQLUSMALLINT *SupportedPtr)
1744 {
1745   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1746   SQLRETURN ret;
1747 
1748   if (!Dbc)
1749     return SQL_INVALID_HANDLE;
1750   MADB_CLEAR_ERROR(&Dbc->Error);
1751 
1752   MDBUG_C_ENTER(Dbc, "SQLGetFunctions");
1753   MDBUG_C_DUMP(Dbc, FunctionId, d);
1754   MDBUG_C_DUMP(Dbc, SupportedPtr, 0x);
1755   ret= Dbc->Methods->GetFunctions(Dbc, FunctionId, SupportedPtr);
1756 
1757   MDBUG_C_RETURN(Dbc,ret, &Dbc->Error);
1758 }
1759 /* }}} */
1760 
1761 /* {{{ SQLGetInfo */
SQLGetInfo(SQLHDBC ConnectionHandle,SQLUSMALLINT InfoType,SQLPOINTER InfoValuePtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr)1762 SQLRETURN SQL_API SQLGetInfo(SQLHDBC ConnectionHandle,
1763     SQLUSMALLINT InfoType,
1764     SQLPOINTER InfoValuePtr,
1765     SQLSMALLINT BufferLength,
1766     SQLSMALLINT *StringLengthPtr)
1767 {
1768   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1769   SQLRETURN ret;
1770   if (!Dbc)
1771     return SQL_INVALID_HANDLE;
1772   MADB_CLEAR_ERROR(&Dbc->Error);
1773 
1774   MDBUG_C_ENTER(Dbc, "SQLGetInfo");
1775   MDBUG_C_DUMP(Dbc, InfoType, d);
1776   ret= Dbc->Methods->GetInfo(Dbc, InfoType, InfoValuePtr, BufferLength, StringLengthPtr, FALSE);
1777 
1778   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
1779 }
1780 /* }}} */
1781 
1782 /* {{{ SQLGetInfoW */
SQLGetInfoW(SQLHDBC ConnectionHandle,SQLUSMALLINT InfoType,SQLPOINTER InfoValuePtr,SQLSMALLINT BufferLength,SQLSMALLINT * StringLengthPtr)1783 SQLRETURN SQL_API SQLGetInfoW(SQLHDBC ConnectionHandle,
1784     SQLUSMALLINT InfoType,
1785     SQLPOINTER InfoValuePtr,
1786     SQLSMALLINT BufferLength,
1787     SQLSMALLINT *StringLengthPtr)
1788 {
1789   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1790   SQLRETURN ret;
1791   if (!Dbc)
1792     return SQL_INVALID_HANDLE;
1793   MADB_CLEAR_ERROR(&Dbc->Error);
1794 
1795   MDBUG_C_ENTER(Dbc, "SQLGetInfo");
1796   MDBUG_C_DUMP(Dbc, InfoType, d);
1797   MDBUG_C_DUMP(Dbc, InfoValuePtr, 0x);
1798   MDBUG_C_DUMP(Dbc, StringLengthPtr, 0x);
1799   ret= Dbc->Methods->GetInfo(Dbc, InfoType, InfoValuePtr, BufferLength, StringLengthPtr, TRUE);
1800 
1801   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
1802 }
1803 /* }}} */
1804 
1805 /* {{{ SQLGetStmtAttr */
SQLGetStmtAttr(SQLHSTMT StatementHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1806 SQLRETURN SQL_API SQLGetStmtAttr(SQLHSTMT StatementHandle,
1807     SQLINTEGER Attribute,
1808     SQLPOINTER ValuePtr,
1809     SQLINTEGER BufferLength,
1810     SQLINTEGER *StringLengthPtr)
1811 {
1812   if (StatementHandle == SQL_NULL_HSTMT)
1813   {
1814     return SQL_INVALID_HANDLE;
1815   }
1816   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
1817 
1818   return MA_SQLGetStmtAttr(StatementHandle, Attribute, ValuePtr, BufferLength, StringLengthPtr);
1819 }
1820 /* }}} */
1821 
1822 /* {{{ SQLGetStmtAttrW */
SQLGetStmtAttrW(SQLHSTMT StatementHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER BufferLength,SQLINTEGER * StringLengthPtr)1823 SQLRETURN SQL_API SQLGetStmtAttrW(SQLHSTMT StatementHandle,
1824     SQLINTEGER Attribute,
1825     SQLPOINTER ValuePtr,
1826     SQLINTEGER BufferLength,
1827     SQLINTEGER *StringLengthPtr)
1828 {
1829   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1830   if (!Stmt)
1831     return SQL_INVALID_HANDLE;
1832   MADB_CLEAR_ERROR(&Stmt->Error);
1833 
1834   return Stmt->Methods->GetAttr(Stmt, Attribute, ValuePtr, BufferLength, StringLengthPtr);
1835 }
1836 /* }}} */
1837 
1838 /* {{{ SQLGetStmtOption */
SQLGetStmtOption(SQLHSTMT StatementHandle,SQLUSMALLINT Option,SQLPOINTER Value)1839 SQLRETURN SQL_API SQLGetStmtOption(SQLHSTMT StatementHandle,
1840                                     SQLUSMALLINT Option, SQLPOINTER Value)
1841 {
1842   if (StatementHandle == SQL_NULL_HSTMT)
1843   {
1844     return SQL_INVALID_HANDLE;
1845   }
1846   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
1847 
1848   return MA_SQLGetStmtAttr(StatementHandle, Option, Value, SQL_NTS, (SQLINTEGER *)NULL);
1849 }
1850 
1851 /* }}} */
1852 
1853 /* {{{ SQLGetTypeInfo */
SQLGetTypeInfo(SQLHSTMT StatementHandle,SQLSMALLINT DataType)1854 SQLRETURN SQL_API SQLGetTypeInfo(SQLHSTMT StatementHandle,
1855     SQLSMALLINT DataType)
1856 {
1857   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1858   if (!Stmt)
1859     return SQL_INVALID_HANDLE;
1860   MADB_CLEAR_ERROR(&Stmt->Error);
1861 
1862   return MADB_GetTypeInfo(Stmt, DataType);
1863 }
1864 /* }}} */
1865 
1866 /* {{{ SQLGetTypeInfoW */
SQLGetTypeInfoW(SQLHSTMT StatementHandle,SQLSMALLINT DataType)1867 SQLRETURN SQL_API SQLGetTypeInfoW(SQLHSTMT StatementHandle,
1868     SQLSMALLINT DataType)
1869 {
1870   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1871   if (!Stmt)
1872     return SQL_INVALID_HANDLE;
1873   MADB_CLEAR_ERROR(&Stmt->Error);
1874 
1875   return MADB_GetTypeInfo(Stmt, DataType);}
1876 /* }}} */
1877 
1878 /* {{{ SQLMoreResults */
SQLMoreResults(SQLHSTMT StatementHandle)1879 SQLRETURN SQL_API SQLMoreResults(SQLHSTMT StatementHandle)
1880 {
1881   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1882   if (!Stmt)
1883     return SQL_INVALID_HANDLE;
1884   MADB_CLEAR_ERROR(&Stmt->Error);
1885 
1886   return MADB_StmtMoreResults(Stmt);
1887 }
1888 /* }}} */
1889 
1890 /* {{{ SQLNativeSql */
SQLNativeSql(SQLHDBC ConnectionHandle,SQLCHAR * InStatementText,SQLINTEGER TextLength1,SQLCHAR * OutStatementText,SQLINTEGER BufferLength,SQLINTEGER * TextLength2Ptr)1891 SQLRETURN SQL_API SQLNativeSql(SQLHDBC ConnectionHandle,
1892     SQLCHAR *InStatementText,
1893     SQLINTEGER TextLength1,
1894     SQLCHAR *OutStatementText,
1895     SQLINTEGER BufferLength,
1896     SQLINTEGER *TextLength2Ptr)
1897 {
1898   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
1899   SQLINTEGER Length;
1900   if (!Dbc)
1901     return SQL_INVALID_HANDLE;
1902   MADB_CLEAR_ERROR(&Dbc->Error);
1903 
1904   if (!TextLength2Ptr && (!OutStatementText || !BufferLength))
1905   {
1906     MADB_SetError(&Dbc->Error, MADB_ERR_01004, NULL, 0);
1907     return Dbc->Error.ReturnValue;
1908   }
1909   Length= (SQLINTEGER)MADB_SetString(0, OutStatementText, BufferLength, (char *)InStatementText, TextLength1, &Dbc->Error);
1910   if (TextLength2Ptr)
1911     *TextLength2Ptr= Length;
1912   return Dbc->Error.ReturnValue;
1913 }
1914 /* }}} */
1915 
1916 /* {{{ SQLNativeSqlW */
SQLNativeSqlW(SQLHDBC ConnectionHandle,SQLWCHAR * InStatementText,SQLINTEGER TextLength1,SQLWCHAR * OutStatementText,SQLINTEGER BufferLength,SQLINTEGER * TextLength2Ptr)1917 SQLRETURN SQL_API SQLNativeSqlW(SQLHDBC ConnectionHandle,
1918     SQLWCHAR *InStatementText,
1919     SQLINTEGER TextLength1,
1920     SQLWCHAR *OutStatementText,
1921     SQLINTEGER BufferLength,
1922     SQLINTEGER *TextLength2Ptr)
1923 {
1924   MADB_Dbc  *Conn=   (MADB_Dbc *)ConnectionHandle;
1925   SQLINTEGER Length= (TextLength1 == SQL_NTS) ? SqlwcsCharLen(InStatementText, (SQLLEN)-1) : TextLength1;
1926 
1927   if (!Conn)
1928     return SQL_INVALID_HANDLE;
1929   MADB_CLEAR_ERROR(&Conn->Error);
1930 
1931   if (TextLength2Ptr)
1932     *TextLength2Ptr= Length;
1933 
1934   if(OutStatementText && BufferLength < Length)
1935     MADB_SetError(&Conn->Error, MADB_ERR_01004, NULL, 0);
1936 
1937   if(OutStatementText && BufferLength < Length)
1938     MADB_SetError(&Conn->Error, MADB_ERR_01004, NULL, 0);
1939   Length= MIN(Length, BufferLength - 1);
1940 
1941   if (OutStatementText && BufferLength)
1942   {
1943     memcpy(OutStatementText, InStatementText, Length * sizeof(SQLWCHAR));
1944     OutStatementText[Length]= 0;
1945   }
1946   return Conn->Error.ReturnValue;
1947 }
1948 /* }}} */
1949 
1950 /* {{{ SQLNumParams */
SQLNumParams(SQLHSTMT StatementHandle,SQLSMALLINT * ParameterCountPtr)1951 SQLRETURN SQL_API SQLNumParams(SQLHSTMT StatementHandle,
1952     SQLSMALLINT *ParameterCountPtr)
1953 {
1954   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1955 
1956   MADB_CHECK_STMT_HANDLE(Stmt, stmt);
1957   MADB_CLEAR_ERROR(&Stmt->Error);
1958 
1959   return Stmt->Methods->ParamCount(Stmt, ParameterCountPtr);
1960 }
1961 /* }}} */
1962 
1963 /* {{{ SQLNumResultCols */
SQLNumResultCols(SQLHSTMT StatementHandle,SQLSMALLINT * ColumnCountPtr)1964 SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT StatementHandle,
1965     SQLSMALLINT *ColumnCountPtr)
1966 {
1967   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1968   MADB_CHECK_STMT_HANDLE(Stmt, stmt);
1969   MADB_CLEAR_ERROR(&Stmt->Error);
1970 
1971   return Stmt->Methods->ColumnCount(Stmt, ColumnCountPtr);
1972 }
1973 /* }}} */
1974 
1975 /* {{{ SQLParamData */
SQLParamData(SQLHSTMT StatementHandle,SQLPOINTER * ValuePtrPtr)1976 SQLRETURN SQL_API SQLParamData(SQLHSTMT StatementHandle,
1977     SQLPOINTER *ValuePtrPtr)
1978 {
1979   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1980   if (!Stmt)
1981     return SQL_INVALID_HANDLE;
1982   MADB_CLEAR_ERROR(&Stmt->Error);
1983 
1984   return Stmt->Methods->ParamData(Stmt, ValuePtrPtr);
1985 }
1986 /* }}} */
1987 
1988 
SQLPrepare(SQLHSTMT StatementHandle,SQLCHAR * StatementText,SQLINTEGER TextLength)1989 SQLRETURN SQL_API SQLPrepare(SQLHSTMT StatementHandle,
1990     SQLCHAR *StatementText,
1991     SQLINTEGER TextLength)
1992 {
1993   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
1994 
1995   if (StatementHandle == SQL_NULL_HSTMT)
1996   {
1997     return SQL_INVALID_HANDLE;
1998   }
1999 
2000   MDBUG_C_ENTER(Stmt->Connection, "SQLPrepare");
2001 
2002   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
2003   MDBUG_C_DUMP(Stmt->Connection, StatementText, s);
2004   MDBUG_C_DUMP(Stmt->Connection, TextLength, d);
2005 
2006   /* Prepare method clears error */
2007 
2008   return Stmt->Methods->Prepare(Stmt, (char *)StatementText, TextLength, FALSE);
2009 }
2010 /* }}} */
2011 
2012 /* {{{ SQLPrepareW */
SQLPrepareW(SQLHSTMT StatementHandle,SQLWCHAR * StatementText,SQLINTEGER TextLength)2013 SQLRETURN SQL_API SQLPrepareW(SQLHSTMT StatementHandle,
2014     SQLWCHAR *StatementText,
2015     SQLINTEGER TextLength)
2016 {
2017   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2018   char *StmtStr;
2019   SQLULEN StmtLength;
2020   SQLRETURN ret;
2021   BOOL ConversionError;
2022 
2023   if (!Stmt)
2024     return SQL_INVALID_HANDLE;
2025   MADB_CLEAR_ERROR(&Stmt->Error);
2026 
2027   MDBUG_C_ENTER(Stmt->Connection, "SQLPrepareW");
2028 
2029   StmtStr= MADB_ConvertFromWChar(StatementText, TextLength, &StmtLength, Stmt->Connection->ConnOrSrcCharset, &ConversionError);
2030 
2031   MDBUG_C_DUMP(Stmt->Connection, Stmt, 0x);
2032   MDBUG_C_DUMP(Stmt->Connection, StmtStr, s);
2033   MDBUG_C_DUMP(Stmt->Connection, TextLength, d);
2034 
2035   if (ConversionError)
2036   {
2037     MADB_SetError(&Stmt->Error, MADB_ERR_22018, NULL, 0);
2038     ret= Stmt->Error.ReturnValue;
2039   }
2040   else
2041     ret= Stmt->Methods->Prepare(Stmt, StmtStr, (SQLINTEGER)StmtLength, FALSE);
2042   MADB_FREE(StmtStr);
2043 
2044   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
2045 }
2046 /* }}} */
2047 
2048 /* {{{ SQLPrimaryKeys */
SQLPrimaryKeys(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3)2049 SQLRETURN SQL_API SQLPrimaryKeys(SQLHSTMT StatementHandle,
2050     SQLCHAR *CatalogName,
2051     SQLSMALLINT NameLength1,
2052     SQLCHAR *SchemaName,
2053     SQLSMALLINT NameLength2,
2054     SQLCHAR *TableName,
2055     SQLSMALLINT NameLength3)
2056 {
2057   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2058   SQLRETURN ret;
2059 
2060   MDBUG_C_ENTER(Stmt->Connection, "SQLPrimaryKeys");
2061   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
2062   MDBUG_C_DUMP(Stmt->Connection, CatalogName, s);
2063   MDBUG_C_DUMP(Stmt->Connection, NameLength1, d);
2064   MDBUG_C_DUMP(Stmt->Connection, SchemaName, s);
2065   MDBUG_C_DUMP(Stmt->Connection, NameLength2, d);
2066   MDBUG_C_DUMP(Stmt->Connection, TableName, s);
2067   MDBUG_C_DUMP(Stmt->Connection, NameLength3, d);
2068 
2069   if (!Stmt)
2070     ret= SQL_INVALID_HANDLE;
2071   else
2072   {
2073     MADB_CLEAR_ERROR(&Stmt->Error);
2074     ret= Stmt->Methods->PrimaryKeys(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName, NameLength2,
2075                                     (char *)TableName, NameLength3);
2076   }
2077 
2078   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
2079 }
2080 /* }}} */
2081 
2082 /* {{{ SQLPrimaryKeysW */
SQLPrimaryKeysW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3)2083 SQLRETURN SQL_API SQLPrimaryKeysW(SQLHSTMT StatementHandle,
2084     SQLWCHAR *CatalogName,
2085     SQLSMALLINT NameLength1,
2086     SQLWCHAR *SchemaName,
2087     SQLSMALLINT NameLength2,
2088     SQLWCHAR *TableName,
2089     SQLSMALLINT NameLength3)
2090 {
2091   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2092   char *CpCatalog= NULL,
2093        *CpSchema= NULL,
2094        *CpTable= NULL;
2095   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0;
2096   SQLRETURN ret;
2097 
2098   if (!Stmt)
2099     return SQL_INVALID_HANDLE;
2100   MADB_CLEAR_ERROR(&Stmt->Error);
2101 
2102   if (CatalogName != NULL)
2103   {
2104     CpCatalog = MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2105   }
2106   if (SchemaName != NULL)
2107   {
2108     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2109   }
2110   if (TableName != NULL)
2111   {
2112     CpTable = MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2113   }
2114 
2115   MDBUG_C_ENTER(Stmt->Connection, "SQLPrimaryKeysW");
2116   MDBUG_C_DUMP(Stmt->Connection, StatementHandle, 0x);
2117   MDBUG_C_DUMP(Stmt->Connection, CpCatalog, s);
2118   MDBUG_C_DUMP(Stmt->Connection, CpLength1, d);
2119   MDBUG_C_DUMP(Stmt->Connection, CpSchema, s);
2120   MDBUG_C_DUMP(Stmt->Connection, CpLength2, d);
2121   MDBUG_C_DUMP(Stmt->Connection, CpTable, s);
2122   MDBUG_C_DUMP(Stmt->Connection, CpLength3, d);
2123 
2124   ret= Stmt->Methods->PrimaryKeys(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
2125                                   CpTable, (SQLSMALLINT)CpLength3);
2126   MADB_FREE(CpCatalog);
2127   MADB_FREE(CpSchema);
2128   MADB_FREE(CpTable);
2129 
2130   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
2131 }
2132 /* }}} */
2133 
2134 /* {{{ SQLProcedureColumns */
SQLProcedureColumns(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * ProcName,SQLSMALLINT NameLength3,SQLCHAR * ColumnName,SQLSMALLINT NameLength4)2135 SQLRETURN SQL_API SQLProcedureColumns(SQLHSTMT StatementHandle,
2136     SQLCHAR *CatalogName,
2137     SQLSMALLINT NameLength1,
2138     SQLCHAR *SchemaName,
2139     SQLSMALLINT NameLength2,
2140     SQLCHAR *ProcName,
2141     SQLSMALLINT NameLength3,
2142     SQLCHAR *ColumnName,
2143     SQLSMALLINT NameLength4)
2144 {
2145   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2146 
2147   if (!Stmt)
2148     return SQL_INVALID_HANDLE;
2149   MADB_CLEAR_ERROR(&Stmt->Error);
2150 
2151   return Stmt->Methods->ProcedureColumns(Stmt, (char *)CatalogName,NameLength1, (char *)SchemaName, NameLength2,
2152                                          (char *)ProcName, NameLength3, (char *)ColumnName, NameLength4);
2153 
2154 }
2155 /* }}} */
2156 
2157 /* {{{ SQLProcedureColumnsW */
SQLProcedureColumnsW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * ProcName,SQLSMALLINT NameLength3,SQLWCHAR * ColumnName,SQLSMALLINT NameLength4)2158 SQLRETURN SQL_API SQLProcedureColumnsW(SQLHSTMT StatementHandle,
2159     SQLWCHAR *CatalogName,
2160     SQLSMALLINT NameLength1,
2161     SQLWCHAR *SchemaName,
2162     SQLSMALLINT NameLength2,
2163     SQLWCHAR *ProcName,
2164     SQLSMALLINT NameLength3,
2165     SQLWCHAR *ColumnName,
2166     SQLSMALLINT NameLength4)
2167 {
2168   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2169   SQLRETURN ret;
2170   char *CpCatalog= NULL,
2171        *CpSchema= NULL,
2172        *CpProc= NULL,
2173        *CpColumn= NULL;
2174   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0, CpLength4= 0;
2175 
2176   if (!Stmt)
2177     return SQL_INVALID_HANDLE;
2178   MADB_CLEAR_ERROR(&Stmt->Error);
2179 
2180   if (CatalogName != NULL)
2181   {
2182     CpCatalog= MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2183   }
2184   if (SchemaName != NULL)
2185   {
2186     CpSchema= MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2187   }
2188   if (ProcName != NULL)
2189   {
2190     CpProc= MADB_ConvertFromWChar(ProcName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2191   }
2192   if (ColumnName != NULL)
2193   {
2194     CpColumn= MADB_ConvertFromWChar(ColumnName, NameLength4, &CpLength4, Stmt->Connection->ConnOrSrcCharset, NULL);
2195   }
2196 
2197   ret= Stmt->Methods->ProcedureColumns(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
2198                                        CpProc, (SQLSMALLINT)CpLength3, CpColumn, (SQLSMALLINT)CpLength4);
2199   MADB_FREE(CpCatalog);
2200   MADB_FREE(CpSchema);
2201   MADB_FREE(CpProc);
2202   MADB_FREE(CpColumn);
2203 
2204   return ret;
2205 }
2206 /* }}} */
2207 
2208 /* {{{ SQLProcedures */
SQLProcedures(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * ProcName,SQLSMALLINT NameLength3)2209 SQLRETURN SQL_API SQLProcedures(SQLHSTMT StatementHandle,
2210     SQLCHAR *CatalogName,
2211     SQLSMALLINT NameLength1,
2212     SQLCHAR *SchemaName,
2213     SQLSMALLINT NameLength2,
2214     SQLCHAR *ProcName,
2215     SQLSMALLINT NameLength3)
2216 {
2217   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2218 
2219   if (!Stmt)
2220     return SQL_INVALID_HANDLE;
2221   MADB_CLEAR_ERROR(&Stmt->Error);
2222 
2223   return Stmt->Methods->Procedures(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName,
2224                                    NameLength2, (char *)ProcName, NameLength3);
2225 }
2226 /* }}} */
2227 
2228 /* {{{ SQLProceduresW */
SQLProceduresW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * ProcName,SQLSMALLINT NameLength3)2229 SQLRETURN SQL_API SQLProceduresW(SQLHSTMT StatementHandle,
2230     SQLWCHAR *CatalogName,
2231     SQLSMALLINT NameLength1,
2232     SQLWCHAR *SchemaName,
2233     SQLSMALLINT NameLength2,
2234     SQLWCHAR *ProcName,
2235     SQLSMALLINT NameLength3)
2236 {
2237   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2238   SQLRETURN ret;
2239   char *CpCatalog= NULL,
2240        *CpSchema= NULL,
2241        *CpProc= NULL;
2242   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0;
2243 
2244   if (!Stmt)
2245     return SQL_INVALID_HANDLE;
2246   MADB_CLEAR_ERROR(&Stmt->Error);
2247 
2248   if (CatalogName != NULL)
2249   {
2250     CpCatalog = MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2251   }
2252   if (SchemaName != NULL)
2253   {
2254     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2255   }
2256   if (ProcName != NULL)
2257   {
2258     CpProc = MADB_ConvertFromWChar(ProcName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2259   }
2260 
2261   ret= Stmt->Methods->Procedures(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
2262                                  CpProc, (SQLSMALLINT)CpLength3);
2263   MADB_FREE(CpCatalog);
2264   MADB_FREE(CpSchema);
2265   MADB_FREE(CpProc);
2266   return ret;
2267 }
2268 /* }}} */
2269 
2270 /* {{{ SQLPutData */
SQLPutData(SQLHSTMT StatementHandle,SQLPOINTER DataPtr,SQLLEN StrLen_or_Ind)2271 SQLRETURN SQL_API SQLPutData(SQLHSTMT StatementHandle,
2272     SQLPOINTER DataPtr,
2273     SQLLEN StrLen_or_Ind)
2274 {
2275   MADB_Stmt *Stmt=(MADB_Stmt *)StatementHandle;
2276   SQLRETURN ret;
2277 
2278   if (!Stmt)
2279     return SQL_INVALID_HANDLE;
2280   MADB_CLEAR_ERROR(&Stmt->Error);
2281 
2282   MDBUG_C_ENTER(Stmt->Connection, "SQLPutData");
2283   MDBUG_C_DUMP(Stmt->Connection, DataPtr, 0x);
2284   MDBUG_C_DUMP(Stmt->Connection, StrLen_or_Ind, d);
2285 
2286   ret= Stmt->Methods->PutData(Stmt, DataPtr, StrLen_or_Ind);
2287 
2288   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
2289 }
2290 /* }}} */
2291 
2292 /* {{{ SQLRowCount */
SQLRowCount(SQLHSTMT StatementHandle,SQLLEN * RowCountPtr)2293 SQLRETURN SQL_API SQLRowCount(SQLHSTMT StatementHandle,
2294     SQLLEN *RowCountPtr)
2295 {
2296   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2297 
2298   MADB_CHECK_STMT_HANDLE(Stmt, stmt);
2299   MADB_CLEAR_ERROR(&Stmt->Error);
2300 
2301   return Stmt->Methods->RowCount(Stmt, RowCountPtr);
2302 }
2303 /* }}} */
2304 
2305 /* {{{ SQLSetConnectAttr */
SQLSetConnectAttr(SQLHDBC ConnectionHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER StringLength)2306 SQLRETURN SQL_API SQLSetConnectAttr(SQLHDBC ConnectionHandle,
2307     SQLINTEGER Attribute,
2308     SQLPOINTER ValuePtr,
2309     SQLINTEGER StringLength)
2310 {
2311   if (ConnectionHandle == SQL_NULL_HDBC)
2312     return SQL_INVALID_HANDLE;
2313   MADB_CLEAR_ERROR(&((MADB_Dbc *)ConnectionHandle)->Error);
2314 
2315   return MA_SQLSetConnectAttr(ConnectionHandle, Attribute, ValuePtr, StringLength);
2316 }
2317 
2318 /* {{{ SQLSetConnectAttrW */
SQLSetConnectAttrW(SQLHDBC ConnectionHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER StringLength)2319 SQLRETURN SQL_API SQLSetConnectAttrW(SQLHDBC ConnectionHandle,
2320     SQLINTEGER Attribute,
2321     SQLPOINTER ValuePtr,
2322     SQLINTEGER StringLength)
2323 {
2324   MADB_Dbc *Dbc= (MADB_Dbc *)ConnectionHandle;
2325   SQLRETURN ret;
2326   if (!Dbc)
2327     return SQL_INVALID_HANDLE;
2328   MADB_CLEAR_ERROR(&Dbc->Error);
2329 
2330   MDBUG_C_ENTER(Dbc, "SetConnectAttrW");
2331   MDBUG_C_DUMP(Dbc, Dbc, 0x);
2332   MDBUG_C_DUMP(Dbc, Attribute, d);
2333   MDBUG_C_DUMP(Dbc, ValuePtr, 0x);
2334   MDBUG_C_DUMP(Dbc, StringLength, d);
2335   ret= Dbc->Methods->SetAttr(Dbc, Attribute, ValuePtr, StringLength, TRUE);
2336 
2337   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
2338 }
2339 /* }}} */
2340 
2341 /* {{{ SQLSetConnectOption */
SQLSetConnectOption(SQLHDBC Hdbc,SQLUSMALLINT Option,SQLULEN Param)2342 SQLRETURN SQL_API SQLSetConnectOption(SQLHDBC Hdbc, SQLUSMALLINT Option, SQLULEN Param)
2343 {
2344   SQLINTEGER StringLength= 0;
2345   SQLRETURN ret;
2346 
2347   if (!Hdbc)
2348     return SQL_INVALID_HANDLE;
2349   MADB_CLEAR_ERROR(&((MADB_Dbc*)Hdbc)->Error);
2350 
2351   /* todo: do we have more string options ? */
2352   if (Option == SQL_ATTR_CURRENT_CATALOG)
2353     StringLength= SQL_NTS;
2354   ret= MA_SQLSetConnectAttr(Hdbc, Option, (SQLPOINTER)Param, StringLength);
2355   return ret;
2356 }
2357 /* }}} */
2358 
2359 /* {{{ SQLSetConnectOptionW */
SQLSetConnectOptionW(SQLHDBC Hdbc,SQLUSMALLINT Option,SQLULEN Param)2360 SQLRETURN SQL_API SQLSetConnectOptionW(SQLHDBC Hdbc, SQLUSMALLINT Option, SQLULEN Param)
2361 {
2362   SQLINTEGER StringLength= 0;
2363   SQLRETURN ret;
2364   MADB_Dbc *Dbc= (MADB_Dbc *)Hdbc;
2365 
2366   if (!Dbc)
2367     return SQL_INVALID_HANDLE;
2368   MADB_CLEAR_ERROR(&Dbc->Error);
2369 
2370   MDBUG_C_ENTER(Dbc, "SetSetConnectOptionW");
2371   MDBUG_C_DUMP(Dbc, Option, d);
2372   MDBUG_C_DUMP(Dbc, Param, u);
2373   /* todo: do we have more string options ? */
2374   if (Option == SQL_ATTR_CURRENT_CATALOG)
2375     StringLength= SQL_NTS;
2376 
2377   ret= Dbc->Methods->SetAttr(Dbc, Option, (SQLPOINTER)Param, StringLength, TRUE);
2378 
2379   MDBUG_C_RETURN(Dbc, ret, &Dbc->Error);
2380 }
2381 /* }}} */
2382 
2383 /* {{{ SQLSetCursorName */
SQLSetCursorName(SQLHSTMT StatementHandle,SQLCHAR * CursorName,SQLSMALLINT NameLength)2384 SQLRETURN SQL_API SQLSetCursorName(SQLHSTMT StatementHandle,
2385     SQLCHAR *CursorName,
2386     SQLSMALLINT NameLength)
2387 {
2388   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2389   if (!Stmt)
2390     return SQL_INVALID_HANDLE;
2391   MADB_CLEAR_ERROR(&Stmt->Error);
2392 
2393   return Stmt->Methods->SetCursorName(Stmt, (char *)CursorName, NameLength);
2394 }
2395 /* }}} */
2396 
2397 /* {{{ SQLSetCursorNameW */
SQLSetCursorNameW(SQLHSTMT StatementHandle,SQLWCHAR * CursorName,SQLSMALLINT NameLength)2398 SQLRETURN SQL_API SQLSetCursorNameW(SQLHSTMT StatementHandle,
2399     SQLWCHAR *CursorName,
2400     SQLSMALLINT NameLength)
2401 {
2402   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2403   char *CpName= NULL;
2404   SQLULEN Length;
2405   SQLRETURN rc;
2406 
2407   if (!Stmt)
2408   {
2409     return SQL_INVALID_HANDLE;
2410   }
2411   MADB_CLEAR_ERROR(&Stmt->Error);
2412 
2413   CpName= MADB_ConvertFromWChar(CursorName, NameLength, &Length, Stmt->Connection->ConnOrSrcCharset, NULL);
2414   rc= Stmt->Methods->SetCursorName(Stmt, (char *)CpName, (SQLINTEGER)Length);
2415 
2416   MADB_FREE(CpName);
2417 
2418   return rc;
2419 }
2420 /* }}} */
2421 
2422 /* {{{ SQLSetDescField */
SQLSetDescField(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT FieldIdentifier,SQLPOINTER ValuePtr,SQLINTEGER BufferLength)2423 SQLRETURN SQL_API SQLSetDescField(SQLHDESC DescriptorHandle,
2424     SQLSMALLINT RecNumber,
2425     SQLSMALLINT FieldIdentifier,
2426     SQLPOINTER ValuePtr,
2427     SQLINTEGER BufferLength)
2428 {
2429   MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
2430   if (!Desc)
2431     return SQL_INVALID_HANDLE;
2432   MADB_CLEAR_ERROR(&Desc->Error);
2433 
2434   return MADB_DescSetField(DescriptorHandle, RecNumber, FieldIdentifier, ValuePtr, BufferLength, FALSE);
2435 }
2436 /* }}} */
2437 
2438 /* {{{ SQLSetDescFieldW */
SQLSetDescFieldW(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT FieldIdentifier,SQLPOINTER ValuePtr,SQLINTEGER BufferLength)2439 SQLRETURN SQL_API SQLSetDescFieldW(SQLHDESC DescriptorHandle,
2440     SQLSMALLINT RecNumber,
2441     SQLSMALLINT FieldIdentifier,
2442     SQLPOINTER ValuePtr,
2443     SQLINTEGER BufferLength)
2444 {
2445   MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
2446   if (!Desc)
2447     return SQL_INVALID_HANDLE;
2448   MADB_CLEAR_ERROR(&Desc->Error);
2449 
2450   return MADB_DescSetField(DescriptorHandle, RecNumber, FieldIdentifier, ValuePtr, BufferLength, TRUE);
2451 }
2452 /* }}} */
2453 
2454 /* {{{ SQLSetDescRec */
SQLSetDescRec(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT Type,SQLSMALLINT SubType,SQLLEN Length,SQLSMALLINT Precision,SQLSMALLINT Scale,SQLPOINTER DataPtr,SQLLEN * StringLengthPtr,SQLLEN * IndicatorPtr)2455 SQLRETURN SQL_API SQLSetDescRec(SQLHDESC DescriptorHandle,
2456     SQLSMALLINT RecNumber,
2457     SQLSMALLINT Type,
2458     SQLSMALLINT SubType,
2459     SQLLEN Length,
2460     SQLSMALLINT Precision,
2461     SQLSMALLINT Scale,
2462     SQLPOINTER DataPtr,
2463     SQLLEN *StringLengthPtr,
2464     SQLLEN *IndicatorPtr)
2465 {
2466   MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
2467   MADB_NOT_IMPLEMENTED(Desc);
2468 }
2469 /* }}} */
2470 
2471 /* {{{ SQLSetDescRecW */
SQLSetDescRecW(SQLHDESC DescriptorHandle,SQLSMALLINT RecNumber,SQLSMALLINT Type,SQLSMALLINT SubType,SQLLEN Length,SQLSMALLINT Precision,SQLSMALLINT Scale,SQLPOINTER DataPtr,SQLLEN * StringLengthPtr,SQLLEN * IndicatorPtr)2472 SQLRETURN SQL_API SQLSetDescRecW(SQLHDESC DescriptorHandle,
2473     SQLSMALLINT RecNumber,
2474     SQLSMALLINT Type,
2475     SQLSMALLINT SubType,
2476     SQLLEN Length,
2477     SQLSMALLINT Precision,
2478     SQLSMALLINT Scale,
2479     SQLPOINTER DataPtr,
2480     SQLLEN *StringLengthPtr,
2481     SQLLEN *IndicatorPtr)
2482 {
2483   MADB_Desc *Desc= (MADB_Desc *)DescriptorHandle;
2484   MADB_NOT_IMPLEMENTED(Desc);
2485 }
2486 /* }}} */
2487 
2488 /* {{{ SQLSetEnvAttr */
SQLSetEnvAttr(SQLHENV EnvironmentHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER StringLength)2489 SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV EnvironmentHandle,
2490     SQLINTEGER Attribute,
2491     SQLPOINTER ValuePtr,
2492     SQLINTEGER StringLength)
2493 {
2494   MADB_Env *Env= (MADB_Env *)EnvironmentHandle;
2495   SQLRETURN ret;
2496   MDBUG_ENTER("SQLSetEnvAttr");
2497   MDBUG_DUMP(Attribute, d);
2498   MDBUG_DUMP(ValuePtr, 0x);
2499   if (!Env)
2500     ret= SQL_INVALID_HANDLE;
2501   else
2502   {
2503     MADB_CLEAR_ERROR(&Env->Error);
2504     ret= MADB_EnvSetAttr(Env, Attribute, ValuePtr, StringLength);
2505   }
2506   MDBUG_DUMP(ret, d);
2507   MDBUG_RETURN(ret);
2508 }
2509 /* }}} */
2510 
2511 
2512 /* {{{ SQLSetPos */
SQLSetPos(SQLHSTMT StatementHandle,SQLSETPOSIROW RowNumber,SQLUSMALLINT Operation,SQLUSMALLINT LockType)2513 SQLRETURN SQL_API SQLSetPos(SQLHSTMT StatementHandle,
2514     SQLSETPOSIROW RowNumber,
2515     SQLUSMALLINT Operation,
2516     SQLUSMALLINT LockType)
2517 {
2518   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2519   SQLRETURN ret;
2520   if (!Stmt)
2521     return SQL_INVALID_HANDLE;
2522   MADB_CLEAR_ERROR(&Stmt->Error);
2523 
2524   MDBUG_C_ENTER(Stmt->Connection, "SQLSetPos");
2525   MDBUG_C_DUMP(Stmt->Connection, RowNumber, d);
2526   MDBUG_C_DUMP(Stmt->Connection, Operation, u);
2527   MDBUG_C_DUMP(Stmt->Connection, LockType, d);
2528 
2529   ret= Stmt->Methods->SetPos(Stmt, RowNumber, Operation, LockType, 0);
2530 
2531   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
2532 }
2533 /* }}} */
2534 
2535 /* {{{ SQLSetParam */
SQLSetParam(SQLHSTMT stmt,SQLUSMALLINT par,SQLSMALLINT type,SQLSMALLINT sqltype,SQLULEN coldef,SQLSMALLINT scale,SQLPOINTER val,SQLLEN * nval)2536 SQLRETURN SQL_API SQLSetParam(SQLHSTMT stmt,
2537 	                            SQLUSMALLINT par,
2538 	                            SQLSMALLINT type,
2539 	                            SQLSMALLINT sqltype,
2540 	                            SQLULEN coldef,
2541 	                            SQLSMALLINT scale,
2542 	                            SQLPOINTER val,
2543 	                            SQLLEN *nval)
2544 {
2545   if (!stmt)
2546     return SQL_INVALID_HANDLE;
2547   MADB_CLEAR_ERROR(&((MADB_Stmt*)stmt)->Error);
2548   return MA_SQLBindParameter(stmt, par, SQL_PARAM_INPUT_OUTPUT, type, sqltype, coldef,
2549                              scale, val, SQL_SETPARAM_VALUE_MAX, nval);
2550 }
2551 /* }}} */
2552 
2553 /* {{{ SQLBindParam - we need it for direct linking mainly */
SQLBindParam(SQLHSTMT StatementHandle,SQLUSMALLINT ParameterNumber,SQLSMALLINT ValueType,SQLSMALLINT ParameterType,SQLULEN LengthPrecision,SQLSMALLINT ParameterScale,SQLPOINTER ParameterValue,SQLLEN * StrLen_or_Ind)2554 SQLRETURN  SQL_API SQLBindParam(SQLHSTMT StatementHandle,
2555                                 SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
2556                                 SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
2557                                 SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
2558                                 SQLLEN *StrLen_or_Ind)
2559 {
2560   if (!StatementHandle)
2561     return SQL_INVALID_HANDLE;
2562   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
2563 
2564   return MA_SQLBindParameter(StatementHandle, ParameterNumber, SQL_PARAM_INPUT, ValueType, ParameterType, LengthPrecision, ParameterScale,
2565                       ParameterValue, SQL_SETPARAM_VALUE_MAX, StrLen_or_Ind);
2566 
2567 }
2568 /* }}} */
2569 
2570 /* {{{ SQLSetStmtAttr */
SQLSetStmtAttr(SQLHSTMT StatementHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER StringLength)2571 SQLRETURN SQL_API SQLSetStmtAttr(SQLHSTMT StatementHandle,
2572     SQLINTEGER Attribute,
2573     SQLPOINTER ValuePtr,
2574     SQLINTEGER StringLength)
2575 {
2576   if (StatementHandle == SQL_NULL_HSTMT)
2577   {
2578     return SQL_INVALID_HANDLE;
2579   }
2580   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
2581 
2582   return MA_SQLSetStmtAttr(StatementHandle, Attribute, ValuePtr, StringLength);
2583 }
2584 /* }}} */
2585 
2586 /* {{{ SQLSetStmtAttrW */
SQLSetStmtAttrW(SQLHSTMT StatementHandle,SQLINTEGER Attribute,SQLPOINTER ValuePtr,SQLINTEGER StringLength)2587 SQLRETURN SQL_API SQLSetStmtAttrW(SQLHSTMT StatementHandle,
2588     SQLINTEGER Attribute,
2589     SQLPOINTER ValuePtr,
2590     SQLINTEGER StringLength)
2591 {
2592   if (StatementHandle == SQL_NULL_HSTMT)
2593   {
2594     return SQL_INVALID_HANDLE;
2595   }
2596   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
2597 
2598   return MA_SQLSetStmtAttr(StatementHandle, Attribute, ValuePtr, StringLength);
2599 }
2600 /* }}} */
2601 
2602 /* {{{ SQLSetStmtOption */
SQLSetStmtOption(SQLHSTMT StatementHandle,SQLUSMALLINT Option,SQLULEN Value)2603 SQLRETURN SQL_API SQLSetStmtOption(SQLHSTMT StatementHandle,
2604                                     SQLUSMALLINT Option, SQLULEN Value)
2605 {
2606   if (StatementHandle == SQL_NULL_HSTMT)
2607   {
2608     return SQL_INVALID_HANDLE;
2609   }
2610   MADB_CLEAR_ERROR(&((MADB_Stmt*)StatementHandle)->Error);
2611   return MA_SQLSetStmtAttr(StatementHandle, Option, (SQLPOINTER)Value, SQL_NTS);
2612 }
2613 /* }}} */
2614 
2615 /* {{{ SQLSpecialColumns */
SQLSpecialColumns(SQLHSTMT StatementHandle,SQLUSMALLINT IdentifierType,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3,SQLUSMALLINT Scope,SQLUSMALLINT Nullable)2616 SQLRETURN SQL_API SQLSpecialColumns(SQLHSTMT StatementHandle,
2617     SQLUSMALLINT IdentifierType,
2618     SQLCHAR *CatalogName,
2619     SQLSMALLINT NameLength1,
2620     SQLCHAR *SchemaName,
2621     SQLSMALLINT NameLength2,
2622     SQLCHAR *TableName,
2623     SQLSMALLINT NameLength3,
2624     SQLUSMALLINT Scope,
2625     SQLUSMALLINT Nullable)
2626 {
2627   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2628   if (!Stmt)
2629     return SQL_INVALID_HANDLE;
2630   MADB_CLEAR_ERROR(&Stmt->Error);
2631 
2632   return Stmt->Methods->SpecialColumns(Stmt,IdentifierType, (char *)CatalogName, NameLength1,
2633                                        (char *)SchemaName, NameLength2,
2634                                        (char *)TableName, NameLength3, Scope, Nullable);
2635 }
2636 /* }}} */
2637 
2638 /* {{{ SQLSpecialColumnsW */
SQLSpecialColumnsW(SQLHSTMT StatementHandle,SQLUSMALLINT IdentifierType,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3,SQLUSMALLINT Scope,SQLUSMALLINT Nullable)2639 SQLRETURN SQL_API SQLSpecialColumnsW(SQLHSTMT StatementHandle,
2640     SQLUSMALLINT IdentifierType,
2641     SQLWCHAR *CatalogName,
2642     SQLSMALLINT NameLength1,
2643     SQLWCHAR *SchemaName,
2644     SQLSMALLINT NameLength2,
2645     SQLWCHAR *TableName,
2646     SQLSMALLINT NameLength3,
2647     SQLUSMALLINT Scope,
2648     SQLUSMALLINT Nullable)
2649 {
2650   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2651   SQLRETURN ret;
2652   char *CpCatalog= NULL,
2653        *CpSchema= NULL,
2654        *CpTable= NULL;
2655   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0;
2656 
2657   if (!Stmt)
2658     return SQL_INVALID_HANDLE;
2659   MADB_CLEAR_ERROR(&Stmt->Error);
2660 
2661   if (CatalogName!=NULL)
2662   {
2663     CpCatalog = MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2664   }
2665   if (SchemaName != NULL)
2666   {
2667     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2668   }
2669   if (TableName != NULL)
2670   {
2671     CpTable = MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2672   }
2673 
2674   ret= Stmt->Methods->SpecialColumns(Stmt,IdentifierType, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema,
2675                                      (SQLSMALLINT)CpLength2, CpTable, (SQLSMALLINT)CpLength3, Scope, Nullable);
2676   MADB_FREE(CpCatalog);
2677   MADB_FREE(CpSchema);
2678   MADB_FREE(CpTable);
2679   return ret;
2680 }
2681 /* }}} */
2682 
2683 /* {{{ SQLStatistics */
SQLStatistics(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3,SQLUSMALLINT Unique,SQLUSMALLINT Reserved)2684 SQLRETURN SQL_API SQLStatistics(SQLHSTMT StatementHandle,
2685     SQLCHAR *CatalogName,
2686     SQLSMALLINT NameLength1,
2687     SQLCHAR *SchemaName,
2688     SQLSMALLINT NameLength2,
2689     SQLCHAR *TableName,
2690     SQLSMALLINT NameLength3,
2691     SQLUSMALLINT Unique,
2692     SQLUSMALLINT Reserved)
2693 {
2694   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2695 
2696   if (!Stmt)
2697     return SQL_INVALID_HANDLE;
2698   MADB_CLEAR_ERROR(&Stmt->Error);
2699 
2700   return Stmt->Methods->Statistics(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName, NameLength2,
2701                                    (char *)TableName, NameLength3, Unique, Reserved);
2702 }
2703 /* }}} */
2704 
2705 /* {{{ SQLStatisticsW */
SQLStatisticsW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3,SQLUSMALLINT Unique,SQLUSMALLINT Reserved)2706 SQLRETURN SQL_API SQLStatisticsW(SQLHSTMT StatementHandle,
2707     SQLWCHAR *CatalogName,
2708     SQLSMALLINT NameLength1,
2709     SQLWCHAR *SchemaName,
2710     SQLSMALLINT NameLength2,
2711     SQLWCHAR *TableName,
2712     SQLSMALLINT NameLength3,
2713     SQLUSMALLINT Unique,
2714     SQLUSMALLINT Reserved)
2715 {
2716   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2717   SQLRETURN ret;
2718   char *CpCatalog= NULL,
2719        *CpSchema= NULL,
2720        *CpTable= NULL;
2721   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0;
2722 
2723   if (!Stmt)
2724     return SQL_INVALID_HANDLE;
2725   MADB_CLEAR_ERROR(&Stmt->Error);
2726 
2727   if (CatalogName != NULL)
2728   {
2729     CpCatalog = MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2730   }
2731   if (SchemaName != NULL)
2732   {
2733     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2734   }
2735   if (TableName != NULL)
2736   {
2737     CpTable = MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2738   }
2739 
2740   if (!Stmt)
2741     return SQL_INVALID_HANDLE;
2742   ret= Stmt->Methods->Statistics(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
2743                                  CpTable, (SQLSMALLINT)CpLength3, Unique, Reserved);
2744   MADB_FREE(CpCatalog);
2745   MADB_FREE(CpSchema);
2746   MADB_FREE(CpTable);
2747   return ret;
2748 }
2749 /* }}} */
2750 
2751 /* {{{ SQLTablePrivileges */
SQLTablePrivileges(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3)2752 SQLRETURN SQL_API SQLTablePrivileges(SQLHSTMT StatementHandle,
2753     SQLCHAR *CatalogName,
2754     SQLSMALLINT NameLength1,
2755     SQLCHAR *SchemaName,
2756     SQLSMALLINT NameLength2,
2757     SQLCHAR *TableName,
2758     SQLSMALLINT NameLength3)
2759 {
2760     MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2761 
2762   if (!Stmt)
2763     return SQL_INVALID_HANDLE;
2764   MADB_CLEAR_ERROR(&Stmt->Error);
2765 
2766   return Stmt->Methods->TablePrivileges(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName, NameLength2,
2767                                         (char *)TableName, NameLength3);
2768   }
2769 /* }}} */
2770 
2771 /* {{{ SQLTablePrivilegesW */
SQLTablePrivilegesW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3)2772 SQLRETURN SQL_API SQLTablePrivilegesW(SQLHSTMT StatementHandle,
2773     SQLWCHAR *CatalogName,
2774     SQLSMALLINT NameLength1,
2775     SQLWCHAR *SchemaName,
2776     SQLSMALLINT NameLength2,
2777     SQLWCHAR *TableName,
2778     SQLSMALLINT NameLength3)
2779 {
2780   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2781   SQLRETURN ret;
2782   char *CpCatalog= NULL,
2783        *CpTable= NULL, *CpSchema= NULL;
2784   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0;
2785 
2786   if (!Stmt)
2787     return SQL_INVALID_HANDLE;
2788   MADB_CLEAR_ERROR(&Stmt->Error);
2789 
2790   if (CatalogName != NULL)
2791   {
2792     CpCatalog= MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2793   }
2794   if (SchemaName != NULL)
2795   {
2796     CpSchema = MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2797   }
2798   if (TableName != NULL)
2799   {
2800     CpTable=   MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2801   }
2802 
2803   ret= Stmt->Methods->TablePrivileges(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2, CpTable, (SQLSMALLINT)CpLength3);
2804 
2805   MADB_FREE(CpCatalog);
2806   MADB_FREE(CpTable);
2807   return ret;
2808 }
2809 /* }}} */
2810 
2811 /* {{{ SQLTables */
SQLTables(SQLHSTMT StatementHandle,SQLCHAR * CatalogName,SQLSMALLINT NameLength1,SQLCHAR * SchemaName,SQLSMALLINT NameLength2,SQLCHAR * TableName,SQLSMALLINT NameLength3,SQLCHAR * TableType,SQLSMALLINT NameLength4)2812 SQLRETURN SQL_API SQLTables(SQLHSTMT StatementHandle,
2813     SQLCHAR *CatalogName,
2814     SQLSMALLINT NameLength1,
2815     SQLCHAR *SchemaName,
2816     SQLSMALLINT NameLength2,
2817     SQLCHAR *TableName,
2818     SQLSMALLINT NameLength3,
2819     SQLCHAR *TableType,
2820     SQLSMALLINT NameLength4)
2821 {
2822   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2823   if (!Stmt)
2824     return SQL_INVALID_HANDLE;
2825   MADB_CLEAR_ERROR(&Stmt->Error);
2826 
2827   return Stmt->Methods->Tables(Stmt, (char *)CatalogName, NameLength1, (char *)SchemaName, NameLength2,
2828                                (char *)TableName,NameLength3, (char *)TableType, NameLength4);
2829 }
2830 /* }}} */
2831 
2832 /* {{{ SQLTablesW */
SQLTablesW(SQLHSTMT StatementHandle,SQLWCHAR * CatalogName,SQLSMALLINT NameLength1,SQLWCHAR * SchemaName,SQLSMALLINT NameLength2,SQLWCHAR * TableName,SQLSMALLINT NameLength3,SQLWCHAR * TableType,SQLSMALLINT NameLength4)2833 SQLRETURN SQL_API SQLTablesW(SQLHSTMT StatementHandle,
2834     SQLWCHAR *CatalogName,
2835     SQLSMALLINT NameLength1,
2836     SQLWCHAR *SchemaName,
2837     SQLSMALLINT NameLength2,
2838     SQLWCHAR *TableName,
2839     SQLSMALLINT NameLength3,
2840     SQLWCHAR *TableType,
2841     SQLSMALLINT NameLength4)
2842 {
2843   MADB_Stmt *Stmt= (MADB_Stmt *)StatementHandle;
2844   char *CpCatalog= NULL,
2845        *CpSchema= NULL,
2846        *CpTable= NULL,
2847        *CpType= NULL;
2848   SQLULEN CpLength1= 0, CpLength2= 0, CpLength3= 0, CpLength4= 0;
2849   SQLRETURN ret;
2850 
2851   if (!Stmt)
2852     return SQL_INVALID_HANDLE;
2853   MADB_CLEAR_ERROR(&Stmt->Error);
2854 
2855   if (CatalogName)
2856   {
2857     CpCatalog= MADB_ConvertFromWChar(CatalogName, NameLength1, &CpLength1, Stmt->Connection->ConnOrSrcCharset, NULL);
2858   }
2859   if (SchemaName)
2860   {
2861     CpSchema= MADB_ConvertFromWChar(SchemaName, NameLength2, &CpLength2, Stmt->Connection->ConnOrSrcCharset, NULL);
2862   }
2863   if (TableName)
2864   {
2865     CpTable= MADB_ConvertFromWChar(TableName, NameLength3, &CpLength3, Stmt->Connection->ConnOrSrcCharset, NULL);
2866   }
2867   if (TableType)
2868   {
2869     CpType= MADB_ConvertFromWChar(TableType, NameLength4, &CpLength4, Stmt->Connection->ConnOrSrcCharset, NULL);
2870   }
2871 
2872   ret= Stmt->Methods->Tables(Stmt, CpCatalog, (SQLSMALLINT)CpLength1, CpSchema, (SQLSMALLINT)CpLength2,
2873                                CpTable, (SQLSMALLINT)CpLength3, CpType, (SQLSMALLINT)CpLength4);
2874   MADB_FREE(CpCatalog);
2875   MADB_FREE(CpSchema);
2876   MADB_FREE(CpTable);
2877   MADB_FREE(CpType);
2878   return ret;
2879 }
2880 /* }}} */
2881 
2882 /* {{{ SQLSetScrollOptions */
SQLSetScrollOptions(SQLHSTMT hstmt,SQLUSMALLINT Concurrency,SQLLEN crowKeySet,SQLUSMALLINT crowRowSet)2883 SQLRETURN SQL_API SQLSetScrollOptions(SQLHSTMT     hstmt,
2884                                       SQLUSMALLINT Concurrency,
2885                                       SQLLEN       crowKeySet,
2886                                       SQLUSMALLINT crowRowSet)
2887 {
2888   MADB_Stmt *Stmt= (MADB_Stmt *)hstmt;
2889   if (!Stmt)
2890     return SQL_INVALID_HANDLE;
2891   MADB_CLEAR_ERROR(&Stmt->Error);
2892 
2893   return MADB_DescSetField(Stmt->Ard, 0, SQL_DESC_ARRAY_SIZE, (SQLPOINTER)(SQLULEN)crowKeySet, SQL_IS_USMALLINT, 0);
2894 }
2895 /* }}} */
2896 
2897 /* {{{ SQLParamOptions */
SQLParamOptions(SQLHSTMT hstmt,SQLULEN crow,SQLULEN * pirow)2898 SQLRETURN SQL_API SQLParamOptions(
2899     SQLHSTMT hstmt,
2900     SQLULEN  crow,
2901     SQLULEN  *pirow)
2902 {
2903   MADB_Stmt *Stmt= (MADB_Stmt *)hstmt;
2904   SQLRETURN result;
2905   if (!Stmt)
2906     return SQL_INVALID_HANDLE;
2907   MADB_CLEAR_ERROR(&Stmt->Error);
2908 
2909   result= MADB_DescSetField(Stmt->Apd, 0, SQL_DESC_ARRAY_SIZE, (SQLPOINTER)crow, SQL_IS_UINTEGER, 0);
2910 
2911   if (SQL_SUCCEEDED(result))
2912   {
2913     result= MADB_DescSetField(Stmt->Ipd, 0, SQL_DESC_ROWS_PROCESSED_PTR, (SQLPOINTER)pirow, SQL_IS_POINTER, 0);
2914   }
2915 
2916   return result;
2917 }
2918 /* }}} */
2919