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