]> git.saurik.com Git - wxWidgets.git/blob - src/common/dbtable.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
"char *" changed to "wxChar *" in several places
[wxWidgets.git] / src / common / dbtable.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: dbtable.cpp
3 // Purpose: Implementation of the wxDbTable class.
4 // Author: Doug Card
5 // Modified by: George Tasker
6 // Bart Jourquin
7 // Mark Johnson
8 // Created: 9.96
9 // RCS-ID: $Id$
10 // Copyright: (c) 1996 Remstar International, Inc.
11 // Licence: wxWindows licence, plus:
12 // Notice: This class library and its intellectual design are free of charge for use,
13 // modification, enhancement, debugging under the following conditions:
14 // 1) These classes may only be used as part of the implementation of a
15 // wxWindows-based application
16 // 2) All enhancements and bug fixes are to be submitted back to the wxWindows
17 // user groups free of all charges for use with the wxWindows library.
18 // 3) These classes may not be distributed as part of any other class library,
19 // DLL, text (written or electronic), other than a complete distribution of
20 // the wxWindows GUI development toolkit.
21 ///////////////////////////////////////////////////////////////////////////////
22
23 /*
24 // SYNOPSIS START
25 // SYNOPSIS STOP
26 */
27 #ifdef __GNUG__
28 #pragma implementation "dbtable.h"
29 #endif
30
31 #include "wx/wxprec.h"
32
33 #ifdef __BORLANDC__
34 #pragma hdrstop
35 #endif
36
37 #ifdef DBDEBUG_CONSOLE
38 #include "iostream.h"
39 #include "wx/ioswrap.h"
40 #endif
41
42 #ifndef WX_PRECOMP
43 #include "wx/string.h"
44 #include "wx/object.h"
45 #include "wx/list.h"
46 #include "wx/utils.h"
47 #if wxUSE_GUI
48 #include "wx/msgdlg.h"
49 #endif
50 #include "wx/log.h"
51 #endif
52 #include "wx/filefn.h"
53
54 #if wxUSE_ODBC
55
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 //#include <assert.h>
60
61 #include "wx/dbtable.h"
62
63 #ifdef __UNIX__
64 // The HPUX preprocessor lines below were commented out on 8/20/97
65 // because macros.h currently redefines DEBUG and is unneeded.
66 // # ifdef HPUX
67 // # include <macros.h>
68 // # endif
69 # ifdef LINUX
70 # include <sys/minmax.h>
71 # endif
72 #endif
73
74 ULONG lastTableID = 0;
75
76
77 #ifdef __WXDEBUG__
78 wxList TablesInUse;
79 #endif
80
81
82 /********** wxDbColDef::wxDbColDef() Constructor **********/
83 wxDbColDef::wxDbColDef()
84 {
85 Initialize();
86 } // Constructor
87
88
89 bool wxDbColDef::Initialize()
90 {
91 ColName[0] = 0;
92 DbDataType = DB_DATA_TYPE_INTEGER;
93 SqlCtype = SQL_C_LONG;
94 PtrDataObj = NULL;
95 SzDataObj = 0;
96 KeyField = FALSE;
97 Updateable = FALSE;
98 InsertAllowed = FALSE;
99 DerivedCol = FALSE;
100 CbValue = 0;
101 Null = FALSE;
102
103 return TRUE;
104 } // wxDbColDef::Initialize()
105
106
107 /********** wxDbTable::wxDbTable() Constructor **********/
108 wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
109 const wxString &qryTblName, bool qryOnly, const wxString &tblPath)
110 {
111 if (!initialize(pwxDb, tblName, numColumns, qryTblName, qryOnly, tblPath))
112 cleanup();
113 } // wxDbTable::wxDbTable()
114
115
116 /***** DEPRECATED: use wxDbTable::wxDbTable() format above *****/
117 wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
118 const wxChar *qryTblName, bool qryOnly, const wxString &tblPath)
119 {
120 wxString tempQryTblName;
121 tempQryTblName = qryTblName;
122 if (!initialize(pwxDb, tblName, numColumns, tempQryTblName, qryOnly, tblPath))
123 cleanup();
124 } // wxDbTable::wxDbTable()
125
126
127 /********** wxDbTable::~wxDbTable() **********/
128 wxDbTable::~wxDbTable()
129 {
130 this->cleanup();
131 } // wxDbTable::~wxDbTable()
132
133
134 bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
135 const wxString &qryTblName, bool qryOnly, const wxString &tblPath)
136 {
137 // Initializing member variables
138 pDb = pwxDb; // Pointer to the wxDb object
139 henv = 0;
140 hdbc = 0;
141 hstmt = 0;
142 m_hstmtGridQuery = 0;
143 hstmtDefault = 0; // Initialized below
144 hstmtCount = 0; // Initialized first time it is needed
145 hstmtInsert = 0;
146 hstmtDelete = 0;
147 hstmtUpdate = 0;
148 hstmtInternal = 0;
149 colDefs = 0;
150 tableID = 0;
151 noCols = numColumns; // Number of cols in the table
152 where.Empty(); // Where clause
153 orderBy.Empty(); // Order By clause
154 from.Empty(); // From clause
155 selectForUpdate = FALSE; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase
156 queryOnly = qryOnly;
157 insertable = TRUE;
158 tablePath.Empty();
159 tableName.Empty();
160 queryTableName.Empty();
161
162 wxASSERT(tblName.Length());
163 wxASSERT(pDb);
164
165 if (!pDb)
166 return FALSE;
167
168 tableName = tblName; // Table Name
169 if (tblPath.Length())
170 tablePath = tblPath; // Table Path - used for dBase files
171 else
172 tablePath.Empty();
173
174 if (qryTblName.Length()) // Name of the table/view to query
175 queryTableName = qryTblName;
176 else
177 queryTableName = tblName;
178
179 pDb->incrementTableCount();
180
181 wxString s;
182 tableID = ++lastTableID;
183 s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"), tblName.c_str(), tableID, pDb);
184
185 #ifdef __WXDEBUG__
186 wxTablesInUse *tableInUse;
187 tableInUse = new wxTablesInUse();
188 tableInUse->tableName = tblName;
189 tableInUse->tableID = tableID;
190 tableInUse->pDb = pDb;
191 TablesInUse.Append(tableInUse);
192 #endif
193
194 pDb->WriteSqlLog(s);
195
196 // Grab the HENV and HDBC from the wxDb object
197 henv = pDb->GetHENV();
198 hdbc = pDb->GetHDBC();
199
200 // Allocate space for column definitions
201 if (noCols)
202 colDefs = new wxDbColDef[noCols]; // Points to the first column definition
203
204 // Allocate statement handles for the table
205 if (!queryOnly)
206 {
207 // Allocate a separate statement handle for performing inserts
208 if (SQLAllocStmt(hdbc, &hstmtInsert) != SQL_SUCCESS)
209 pDb->DispAllErrors(henv, hdbc);
210 // Allocate a separate statement handle for performing deletes
211 if (SQLAllocStmt(hdbc, &hstmtDelete) != SQL_SUCCESS)
212 pDb->DispAllErrors(henv, hdbc);
213 // Allocate a separate statement handle for performing updates
214 if (SQLAllocStmt(hdbc, &hstmtUpdate) != SQL_SUCCESS)
215 pDb->DispAllErrors(henv, hdbc);
216 }
217 // Allocate a separate statement handle for internal use
218 if (SQLAllocStmt(hdbc, &hstmtInternal) != SQL_SUCCESS)
219 pDb->DispAllErrors(henv, hdbc);
220
221 // Set the cursor type for the statement handles
222 cursorType = SQL_CURSOR_STATIC;
223
224 if (SQLSetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS)
225 {
226 // Check to see if cursor type is supported
227 pDb->GetNextError(henv, hdbc, hstmtInternal);
228 if (! wxStrcmp(pDb->sqlState, wxT("01S02"))) // Option Value Changed
229 {
230 // Datasource does not support static cursors. Driver
231 // will substitute a cursor type. Call SQLGetStmtOption()
232 // to determine which cursor type was selected.
233 if (SQLGetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, &cursorType) != SQL_SUCCESS)
234 pDb->DispAllErrors(henv, hdbc, hstmtInternal);
235 #ifdef DBDEBUG_CONSOLE
236 cout << wxT("Static cursor changed to: ");
237 switch(cursorType)
238 {
239 case SQL_CURSOR_FORWARD_ONLY:
240 cout << wxT("Forward Only");
241 break;
242 case SQL_CURSOR_STATIC:
243 cout << wxT("Static");
244 break;
245 case SQL_CURSOR_KEYSET_DRIVEN:
246 cout << wxT("Keyset Driven");
247 break;
248 case SQL_CURSOR_DYNAMIC:
249 cout << wxT("Dynamic");
250 break;
251 }
252 cout << endl << endl;
253 #endif
254 // BJO20000425
255 if (pDb->FwdOnlyCursors() && cursorType != SQL_CURSOR_FORWARD_ONLY)
256 {
257 // Force the use of a forward only cursor...
258 cursorType = SQL_CURSOR_FORWARD_ONLY;
259 if (SQLSetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS)
260 {
261 // Should never happen
262 pDb->GetNextError(henv, hdbc, hstmtInternal);
263 return FALSE;
264 }
265 }
266 }
267 else
268 {
269 pDb->DispNextError();
270 pDb->DispAllErrors(henv, hdbc, hstmtInternal);
271 }
272 }
273 #ifdef DBDEBUG_CONSOLE
274 else
275 cout << wxT("Cursor Type set to STATIC") << endl << endl;
276 #endif
277
278 if (!queryOnly)
279 {
280 // Set the cursor type for the INSERT statement handle
281 if (SQLSetStmtOption(hstmtInsert, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS)
282 pDb->DispAllErrors(henv, hdbc, hstmtInsert);
283 // Set the cursor type for the DELETE statement handle
284 if (SQLSetStmtOption(hstmtDelete, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS)
285 pDb->DispAllErrors(henv, hdbc, hstmtDelete);
286 // Set the cursor type for the UPDATE statement handle
287 if (SQLSetStmtOption(hstmtUpdate, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS)
288 pDb->DispAllErrors(henv, hdbc, hstmtUpdate);
289 }
290
291 // Make the default cursor the active cursor
292 hstmtDefault = GetNewCursor(FALSE,FALSE);
293 wxASSERT(hstmtDefault);
294 hstmt = *hstmtDefault;
295
296 return TRUE;
297
298 } // wxDbTable::initialize()
299
300
301 void wxDbTable::cleanup()
302 {
303 wxString s;
304 if (pDb)
305 {
306 s.Printf(wxT("wxDbTable destructor (%-20s) tableID:[%6lu] pDb:[%p]"), tableName.c_str(), tableID, pDb);
307 pDb->WriteSqlLog(s);
308 }
309
310 #ifdef __WXDEBUG__
311 if (tableID)
312 {
313 TablesInUse.DeleteContents(TRUE);
314 bool found = FALSE;
315
316 wxNode *pNode;
317 pNode = TablesInUse.First();
318 while (pNode && !found)
319 {
320 if (((wxTablesInUse *)pNode->Data())->tableID == tableID)
321 {
322 found = TRUE;
323 if (!TablesInUse.DeleteNode(pNode))
324 wxLogDebug (s,wxT("Unable to delete node!"));
325 }
326 else
327 pNode = pNode->Next();
328 }
329 if (!found)
330 {
331 wxString msg;
332 msg.Printf(wxT("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s"),s.c_str());
333 wxLogDebug (msg,wxT("NOTICE..."));
334 }
335 }
336 #endif
337
338 // Decrement the wxDb table count
339 if (pDb)
340 pDb->decrementTableCount();
341
342 // Delete memory allocated for column definitions
343 if (colDefs)
344 delete [] colDefs;
345
346 // Free statement handles
347 if (!queryOnly)
348 {
349 if (hstmtInsert)
350 {
351 /*
352 ODBC 3.0 says to use this form
353 if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
354 */
355 if (SQLFreeStmt(hstmtInsert, SQL_DROP) != SQL_SUCCESS)
356 pDb->DispAllErrors(henv, hdbc);
357 }
358
359 if (hstmtDelete)
360 {
361 /*
362 ODBC 3.0 says to use this form
363 if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
364 */
365 if (SQLFreeStmt(hstmtDelete, SQL_DROP) != SQL_SUCCESS)
366 pDb->DispAllErrors(henv, hdbc);
367 }
368
369 if (hstmtUpdate)
370 {
371 /*
372 ODBC 3.0 says to use this form
373 if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
374 */
375 if (SQLFreeStmt(hstmtUpdate, SQL_DROP) != SQL_SUCCESS)
376 pDb->DispAllErrors(henv, hdbc);
377 }
378 }
379
380 if (hstmtInternal)
381 {
382 if (SQLFreeStmt(hstmtInternal, SQL_DROP) != SQL_SUCCESS)
383 pDb->DispAllErrors(henv, hdbc);
384 }
385
386 // Delete dynamically allocated cursors
387 if (hstmtDefault)
388 DeleteCursor(hstmtDefault);
389
390 if (hstmtCount)
391 DeleteCursor(hstmtCount);
392
393 if (m_hstmtGridQuery)
394 DeleteCursor(m_hstmtGridQuery);
395
396 } // wxDbTable::cleanup()
397
398
399 /***************************** PRIVATE FUNCTIONS *****************************/
400
401
402 /********** wxDbTable::bindParams() **********/
403 bool wxDbTable::bindParams(bool forUpdate)
404 {
405 wxASSERT(!queryOnly);
406 if (queryOnly)
407 return(FALSE);
408
409 SWORD fSqlType = 0;
410 UDWORD precision = 0;
411 SWORD scale = 0;
412
413 // Bind each column of the table that should be bound
414 // to a parameter marker
415 int i;
416 UWORD colNo;
417
418 for (i=0, colNo=1; i < noCols; i++)
419 {
420 if (forUpdate)
421 {
422 if (!colDefs[i].Updateable)
423 continue;
424 }
425 else
426 {
427 if (!colDefs[i].InsertAllowed)
428 continue;
429 }
430
431 switch(colDefs[i].DbDataType)
432 {
433 case DB_DATA_TYPE_VARCHAR:
434 fSqlType = pDb->GetTypeInfVarchar().FsqlType;
435 precision = colDefs[i].SzDataObj;
436 scale = 0;
437 if (colDefs[i].Null)
438 colDefs[i].CbValue = SQL_NULL_DATA;
439 else
440 colDefs[i].CbValue = SQL_NTS;
441 break;
442 case DB_DATA_TYPE_INTEGER:
443 fSqlType = pDb->GetTypeInfInteger().FsqlType;
444 precision = pDb->GetTypeInfInteger().Precision;
445 scale = 0;
446 if (colDefs[i].Null)
447 colDefs[i].CbValue = SQL_NULL_DATA;
448 else
449 colDefs[i].CbValue = 0;
450 break;
451 case DB_DATA_TYPE_FLOAT:
452 fSqlType = pDb->GetTypeInfFloat().FsqlType;
453 precision = pDb->GetTypeInfFloat().Precision;
454 scale = pDb->GetTypeInfFloat().MaximumScale;
455 // SQL Sybase Anywhere v5.5 returned a negative number for the
456 // MaxScale. This caused ODBC to kick out an error on ibscale.
457 // I check for this here and set the scale = precision.
458 //if (scale < 0)
459 // scale = (short) precision;
460 if (colDefs[i].Null)
461 colDefs[i].CbValue = SQL_NULL_DATA;
462 else
463 colDefs[i].CbValue = 0;
464 break;
465 case DB_DATA_TYPE_DATE:
466 fSqlType = pDb->GetTypeInfDate().FsqlType;
467 precision = pDb->GetTypeInfDate().Precision;
468 scale = 0;
469 if (colDefs[i].Null)
470 colDefs[i].CbValue = SQL_NULL_DATA;
471 else
472 colDefs[i].CbValue = 0;
473 break;
474 case DB_DATA_TYPE_BLOB:
475 fSqlType = pDb->GetTypeInfBlob().FsqlType;
476 precision = 50000;
477 scale = 0;
478 if (colDefs[i].Null)
479 colDefs[i].CbValue = SQL_NULL_DATA;
480 else
481 colDefs[i].CbValue = SQL_LEN_DATA_AT_EXEC(colDefs[i].SzDataObj);
482 break;
483 }
484 if (forUpdate)
485 {
486 if (SQLBindParameter(hstmtUpdate, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
487 fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
488 precision+1, &colDefs[i].CbValue) != SQL_SUCCESS)
489 {
490 return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
491 }
492 }
493 else
494 {
495 if (SQLBindParameter(hstmtInsert, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
496 fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
497 precision+1,&colDefs[i].CbValue) != SQL_SUCCESS)
498 {
499 return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
500 }
501 }
502 }
503
504 // Completed successfully
505 return(TRUE);
506
507 } // wxDbTable::bindParams()
508
509
510 /********** wxDbTable::bindInsertParams() **********/
511 bool wxDbTable::bindInsertParams(void)
512 {
513 return bindParams(FALSE);
514 } // wxDbTable::bindInsertParams()
515
516
517 /********** wxDbTable::bindUpdateParams() **********/
518 bool wxDbTable::bindUpdateParams(void)
519 {
520 return bindParams(TRUE);
521 } // wxDbTable::bindUpdateParams()
522
523
524 /********** wxDbTable::bindCols() **********/
525 bool wxDbTable::bindCols(HSTMT cursor)
526 {
527 // Bind each column of the table to a memory address for fetching data
528 UWORD i;
529 for (i = 0; i < noCols; i++)
530 {
531 if (SQLBindCol(cursor, (UWORD)(i+1), colDefs[i].SqlCtype, (UCHAR*) colDefs[i].PtrDataObj,
532 colDefs[i].SzDataObj, &colDefs[i].CbValue ) != SQL_SUCCESS)
533 {
534 return (pDb->DispAllErrors(henv, hdbc, cursor));
535 }
536 }
537
538 // Completed successfully
539 return(TRUE);
540
541 } // wxDbTable::bindCols()
542
543
544 /********** wxDbTable::getRec() **********/
545 bool wxDbTable::getRec(UWORD fetchType)
546 {
547 RETCODE retcode;
548
549 if (!pDb->FwdOnlyCursors())
550 {
551 // Fetch the NEXT, PREV, FIRST or LAST record, depending on fetchType
552 UDWORD cRowsFetched;
553 UWORD rowStatus;
554
555 retcode = SQLExtendedFetch(hstmt, fetchType, 0, &cRowsFetched, &rowStatus);
556 if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
557 {
558 if (retcode == SQL_NO_DATA_FOUND)
559 return(FALSE);
560 else
561 return(pDb->DispAllErrors(henv, hdbc, hstmt));
562 }
563 else
564 {
565 // Set the Null member variable to indicate the Null state
566 // of each column just read in.
567 int i;
568 for (i = 0; i < noCols; i++)
569 colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
570 }
571 }
572 else
573 {
574 // Fetch the next record from the record set
575 retcode = SQLFetch(hstmt);
576 if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
577 {
578 if (retcode == SQL_NO_DATA_FOUND)
579 return(FALSE);
580 else
581 return(pDb->DispAllErrors(henv, hdbc, hstmt));
582 }
583 else
584 {
585 // Set the Null member variable to indicate the Null state
586 // of each column just read in.
587 int i;
588 for (i = 0; i < noCols; i++)
589 colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
590 }
591 }
592
593 // Completed successfully
594 return(TRUE);
595
596 } // wxDbTable::getRec()
597
598
599 /********** wxDbTable::execDelete() **********/
600 bool wxDbTable::execDelete(const wxString &pSqlStmt)
601 {
602 RETCODE retcode;
603
604 // Execute the DELETE statement
605 retcode = SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
606
607 if (retcode == SQL_SUCCESS ||
608 retcode == SQL_NO_DATA_FOUND ||
609 retcode == SQL_SUCCESS_WITH_INFO)
610 {
611 // Record deleted successfully
612 return(TRUE);
613 }
614
615 // Problem deleting record
616 return(pDb->DispAllErrors(henv, hdbc, hstmtDelete));
617
618 } // wxDbTable::execDelete()
619
620
621 /********** wxDbTable::execUpdate() **********/
622 bool wxDbTable::execUpdate(const wxString &pSqlStmt)
623 {
624 RETCODE retcode;
625
626 // Execute the UPDATE statement
627 retcode = SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
628
629 if (retcode == SQL_SUCCESS ||
630 retcode == SQL_NO_DATA_FOUND ||
631 retcode == SQL_SUCCESS_WITH_INFO)
632 {
633 // Record updated successfully
634 return(TRUE);
635 }
636
637 // Problem updating record
638 return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
639
640 } // wxDbTable::execUpdate()
641
642
643 /********** wxDbTable::query() **********/
644 bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const wxString &pSqlStmt)
645 {
646 wxString sqlStmt;
647
648 if (forUpdate)
649 // The user may wish to select for update, but the DBMS may not be capable
650 selectForUpdate = CanSelectForUpdate();
651 else
652 selectForUpdate = FALSE;
653
654 // Set the SQL SELECT string
655 if (queryType != DB_SELECT_STATEMENT) // A select statement was not passed in,
656 { // so generate a select statement.
657 BuildSelectStmt(sqlStmt, queryType, distinct);
658 pDb->WriteSqlLog(sqlStmt);
659 }
660
661 // Make sure the cursor is closed first
662 if (!CloseCursor(hstmt))
663 return(FALSE);
664
665 // Execute the SQL SELECT statement
666 int retcode;
667 retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt.c_str() : sqlStmt.c_str()), SQL_NTS);
668 if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
669 return(pDb->DispAllErrors(henv, hdbc, hstmt));
670
671 // Completed successfully
672 return(TRUE);
673
674 } // wxDbTable::query()
675
676
677 /***************************** PUBLIC FUNCTIONS *****************************/
678
679
680 /********** wxDbTable::Open() **********/
681 bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
682 {
683 if (!pDb)
684 return FALSE;
685
686 int i;
687 wxString sqlStmt;
688 wxString s;
689 // int NumKeyCols=0;
690
691 // Calculate the maximum size of the concatenated
692 // keys for use with wxDbGrid
693 m_keysize = 0;
694 for (i=0; i < noCols; i++)
695 {
696 if (colDefs[i].KeyField)
697 {
698 // NumKeyCols++;
699 m_keysize += colDefs[i].SzDataObj;
700 }
701 }
702
703 s.Empty();
704 // Verify that the table exists in the database
705 if (checkTableExists && !pDb->TableExists(tableName, pDb->GetUsername(), tablePath))
706 {
707 s = wxT("Table/view does not exist in the database");
708 if ( *(pDb->dbInf.accessibleTables) == wxT('Y'))
709 s += wxT(", or you have no permissions.\n");
710 else
711 s += wxT(".\n");
712 }
713 else if (checkPrivileges)
714 {
715 // Verify the user has rights to access the table.
716 // Shortcut boolean evaluation to optimize out call to
717 // TablePrivileges
718 //
719 // Unfortunately this optimization doesn't seem to be
720 // reliable!
721 if (// *(pDb->dbInf.accessibleTables) == 'N' &&
722 !pDb->TablePrivileges(tableName,wxT("SELECT"), pDb->GetUsername(), pDb->GetUsername(), tablePath))
723 s = wxT("Current logged in user does not have sufficient privileges to access this table.\n");
724 }
725
726 if (!s.IsEmpty())
727 {
728 wxString p;
729
730 if (!tablePath.IsEmpty())
731 p.Printf(wxT("Error opening '%s/%s'.\n"),tablePath.c_str(),tableName.c_str());
732 else
733 p.Printf(wxT("Error opening '%s'.\n"), tableName.c_str());
734
735 p += s;
736 pDb->LogError(p.GetData());
737
738 return(FALSE);
739 }
740
741 // Bind the member variables for field exchange between
742 // the wxDbTable object and the ODBC record.
743 if (!queryOnly)
744 {
745 if (!bindInsertParams()) // Inserts
746 return(FALSE);
747
748 if (!bindUpdateParams()) // Updates
749 return(FALSE);
750 }
751
752 if (!bindCols(*hstmtDefault)) // Selects
753 return(FALSE);
754
755 if (!bindCols(hstmtInternal)) // Internal use only
756 return(FALSE);
757
758 /*
759 * Do NOT bind the hstmtCount cursor!!!
760 */
761
762 // Build an insert statement using parameter markers
763 if (!queryOnly && noCols > 0)
764 {
765 bool needComma = FALSE;
766 sqlStmt.Printf(wxT("INSERT INTO %s ("), pDb->SQLTableName(tableName.c_str()));
767 for (i = 0; i < noCols; i++)
768 {
769 if (! colDefs[i].InsertAllowed)
770 continue;
771 if (needComma)
772 sqlStmt += wxT(",");
773 sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
774 // sqlStmt += colDefs[i].ColName;
775 needComma = TRUE;
776 }
777 needComma = FALSE;
778 sqlStmt += wxT(") VALUES (");
779
780 int insertableCount = 0;
781
782 for (i = 0; i < noCols; i++)
783 {
784 if (! colDefs[i].InsertAllowed)
785 continue;
786 if (needComma)
787 sqlStmt += wxT(",");
788 sqlStmt += wxT("?");
789 needComma = TRUE;
790 insertableCount++;
791 }
792 sqlStmt += wxT(")");
793
794 // Prepare the insert statement for execution
795 if (insertableCount)
796 {
797 if (SQLPrepare(hstmtInsert, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
798 return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
799 }
800 else
801 insertable= FALSE;
802 }
803
804 // Completed successfully
805 return(TRUE);
806
807 } // wxDbTable::Open()
808
809
810 /********** wxDbTable::Query() **********/
811 bool wxDbTable::Query(bool forUpdate, bool distinct)
812 {
813
814 return(query(DB_SELECT_WHERE, forUpdate, distinct));
815
816 } // wxDbTable::Query()
817
818
819 /********** wxDbTable::QueryBySqlStmt() **********/
820 bool wxDbTable::QueryBySqlStmt(const wxString &pSqlStmt)
821 {
822 pDb->WriteSqlLog(pSqlStmt);
823
824 return(query(DB_SELECT_STATEMENT, FALSE, FALSE, pSqlStmt));
825
826 } // wxDbTable::QueryBySqlStmt()
827
828
829 /********** wxDbTable::QueryMatching() **********/
830 bool wxDbTable::QueryMatching(bool forUpdate, bool distinct)
831 {
832
833 return(query(DB_SELECT_MATCHING, forUpdate, distinct));
834
835 } // wxDbTable::QueryMatching()
836
837
838 /********** wxDbTable::QueryOnKeyFields() **********/
839 bool wxDbTable::QueryOnKeyFields(bool forUpdate, bool distinct)
840 {
841
842 return(query(DB_SELECT_KEYFIELDS, forUpdate, distinct));
843
844 } // wxDbTable::QueryOnKeyFields()
845
846
847 /********** wxDbTable::GetPrev() **********/
848 bool wxDbTable::GetPrev(void)
849 {
850 if (pDb->FwdOnlyCursors())
851 {
852 wxFAIL_MSG(wxT("GetPrev()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
853 return FALSE;
854 }
855 else
856 return(getRec(SQL_FETCH_PRIOR));
857
858 } // wxDbTable::GetPrev()
859
860
861 /********** wxDbTable::operator-- **********/
862 bool wxDbTable::operator--(int)
863 {
864 if (pDb->FwdOnlyCursors())
865 {
866 wxFAIL_MSG(wxT("operator--:Backward scrolling cursors are not enabled for this instance of wxDbTable"));
867 return FALSE;
868 }
869 else
870 return(getRec(SQL_FETCH_PRIOR));
871
872 } // wxDbTable::operator--
873
874
875 /********** wxDbTable::GetFirst() **********/
876 bool wxDbTable::GetFirst(void)
877 {
878 if (pDb->FwdOnlyCursors())
879 {
880 wxFAIL_MSG(wxT("GetFirst():Backward scrolling cursors are not enabled for this instance of wxDbTable"));
881 return FALSE;
882 }
883 else
884 return(getRec(SQL_FETCH_FIRST));
885
886 } // wxDbTable::GetFirst()
887
888
889 /********** wxDbTable::GetLast() **********/
890 bool wxDbTable::GetLast(void)
891 {
892 if (pDb->FwdOnlyCursors())
893 {
894 wxFAIL_MSG(wxT("GetLast()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
895 return FALSE;
896 }
897 else
898 return(getRec(SQL_FETCH_LAST));
899
900 } // wxDbTable::GetLast()
901
902
903 /********** wxDbTable::BuildDeleteStmt() **********/
904 void wxDbTable::BuildDeleteStmt(wxString &pSqlStmt, int typeOfDel, const wxString &pWhereClause)
905 {
906 wxASSERT(!queryOnly);
907 if (queryOnly)
908 return;
909
910 wxString whereClause;
911
912 whereClause.Empty();
913
914 // Handle the case of DeleteWhere() and the where clause is blank. It should
915 // delete all records from the database in this case.
916 if (typeOfDel == DB_DEL_WHERE && (pWhereClause.Length() == 0))
917 {
918 pSqlStmt.Printf(wxT("DELETE FROM %s"), pDb->SQLTableName(tableName.c_str()));
919 return;
920 }
921
922 pSqlStmt.Printf(wxT("DELETE FROM %s WHERE "), pDb->SQLTableName(tableName.c_str()));
923
924 // Append the WHERE clause to the SQL DELETE statement
925 switch(typeOfDel)
926 {
927 case DB_DEL_KEYFIELDS:
928 // If the datasource supports the ROWID column, build
929 // the where on ROWID for efficiency purposes.
930 // e.g. DELETE FROM PARTS WHERE ROWID = '111.222.333'
931 if (CanUpdByROWID())
932 {
933 SDWORD cb;
934 wxChar rowid[wxDB_ROWID_LEN+1];
935
936 // Get the ROWID value. If not successful retreiving the ROWID,
937 // simply fall down through the code and build the WHERE clause
938 // based on the key fields.
939 if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
940 {
941 pSqlStmt += wxT("ROWID = '");
942 pSqlStmt += rowid;
943 pSqlStmt += wxT("'");
944 break;
945 }
946 }
947 // Unable to delete by ROWID, so build a WHERE
948 // clause based on the keyfields.
949 BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
950 pSqlStmt += whereClause;
951 break;
952 case DB_DEL_WHERE:
953 pSqlStmt += pWhereClause;
954 break;
955 case DB_DEL_MATCHING:
956 BuildWhereClause(whereClause, DB_WHERE_MATCHING);
957 pSqlStmt += whereClause;
958 break;
959 }
960
961 } // BuildDeleteStmt()
962
963
964 /***** DEPRECATED: use wxDbTable::BuildDeleteStmt(wxString &....) form *****/
965 void wxDbTable::BuildDeleteStmt(wxChar *pSqlStmt, int typeOfDel, const wxString &pWhereClause)
966 {
967 wxString tempSqlStmt;
968 BuildDeleteStmt(tempSqlStmt, typeOfDel, pWhereClause);
969 wxStrcpy(pSqlStmt, tempSqlStmt);
970 } // wxDbTable::BuildDeleteStmt()
971
972
973 /********** wxDbTable::BuildSelectStmt() **********/
974 void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool distinct)
975 {
976 wxString whereClause;
977 whereClause.Empty();
978
979 // Build a select statement to query the database
980 pSqlStmt = wxT("SELECT ");
981
982 // SELECT DISTINCT values only?
983 if (distinct)
984 pSqlStmt += wxT("DISTINCT ");
985
986 // Was a FROM clause specified to join tables to the base table?
987 // Available for ::Query() only!!!
988 bool appendFromClause = FALSE;
989 #if wxODBC_BACKWARD_COMPATABILITY
990 if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from))
991 appendFromClause = TRUE;
992 #else
993 if (typeOfSelect == DB_SELECT_WHERE && from.Length())
994 appendFromClause = TRUE;
995 #endif
996
997 // Add the column list
998 int i;
999 for (i = 0; i < noCols; i++)
1000 {
1001 // If joining tables, the base table column names must be qualified to avoid ambiguity
1002 if (appendFromClause || pDb->Dbms() == dbmsACCESS)
1003 {
1004 pSqlStmt += pDb->SQLTableName(queryTableName.c_str());
1005 // pSqlStmt += queryTableName;
1006 pSqlStmt += wxT(".");
1007 }
1008 pSqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
1009 // pSqlStmt += colDefs[i].ColName;
1010 if (i + 1 < noCols)
1011 pSqlStmt += wxT(",");
1012 }
1013
1014 // If the datasource supports ROWID, get this column as well. Exception: Don't retrieve
1015 // the ROWID if querying distinct records. The rowid will always be unique.
1016 if (!distinct && CanUpdByROWID())
1017 {
1018 // If joining tables, the base table column names must be qualified to avoid ambiguity
1019 if (appendFromClause || pDb->Dbms() == dbmsACCESS)
1020 {
1021 pSqlStmt += wxT(",");
1022 pSqlStmt += pDb->SQLTableName(queryTableName);
1023 // pSqlStmt += queryTableName;
1024 pSqlStmt += wxT(".ROWID");
1025 }
1026 else
1027 pSqlStmt += wxT(",ROWID");
1028 }
1029
1030 // Append the FROM tablename portion
1031 pSqlStmt += wxT(" FROM ");
1032 pSqlStmt += pDb->SQLTableName(queryTableName);
1033 // pSqlStmt += queryTableName;
1034
1035 // Sybase uses the HOLDLOCK keyword to lock a record during query.
1036 // The HOLDLOCK keyword follows the table name in the from clause.
1037 // Each table in the from clause must specify HOLDLOCK or
1038 // NOHOLDLOCK (the default). Note: The "FOR UPDATE" clause
1039 // is parsed but ignored in SYBASE Transact-SQL.
1040 if (selectForUpdate && (pDb->Dbms() == dbmsSYBASE_ASA || pDb->Dbms() == dbmsSYBASE_ASE))
1041 pSqlStmt += wxT(" HOLDLOCK");
1042
1043 if (appendFromClause)
1044 pSqlStmt += from;
1045
1046 // Append the WHERE clause. Either append the where clause for the class
1047 // or build a where clause. The typeOfSelect determines this.
1048 switch(typeOfSelect)
1049 {
1050 case DB_SELECT_WHERE:
1051 #if wxODBC_BACKWARD_COMPATABILITY
1052 if (where && wxStrlen(where)) // May not want a where clause!!!
1053 #else
1054 if (where.Length()) // May not want a where clause!!!
1055 #endif
1056 {
1057 pSqlStmt += wxT(" WHERE ");
1058 pSqlStmt += where;
1059 }
1060 break;
1061 case DB_SELECT_KEYFIELDS:
1062 BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
1063 if (whereClause.Length())
1064 {
1065 pSqlStmt += wxT(" WHERE ");
1066 pSqlStmt += whereClause;
1067 }
1068 break;
1069 case DB_SELECT_MATCHING:
1070 BuildWhereClause(whereClause, DB_WHERE_MATCHING);
1071 if (whereClause.Length())
1072 {
1073 pSqlStmt += wxT(" WHERE ");
1074 pSqlStmt += whereClause;
1075 }
1076 break;
1077 }
1078
1079 // Append the ORDER BY clause
1080 #if wxODBC_BACKWARD_COMPATABILITY
1081 if (orderBy && wxStrlen(orderBy))
1082 #else
1083 if (orderBy.Length())
1084 #endif
1085 {
1086 pSqlStmt += wxT(" ORDER BY ");
1087 pSqlStmt += orderBy;
1088 }
1089
1090 // SELECT FOR UPDATE if told to do so and the datasource is capable. Sybase
1091 // parses the FOR UPDATE clause but ignores it. See the comment above on the
1092 // HOLDLOCK for Sybase.
1093 if (selectForUpdate && CanSelectForUpdate())
1094 pSqlStmt += wxT(" FOR UPDATE");
1095
1096 } // wxDbTable::BuildSelectStmt()
1097
1098
1099 /***** DEPRECATED: use wxDbTable::BuildSelectStmt(wxString &....) form *****/
1100 void wxDbTable::BuildSelectStmt(wxChar *pSqlStmt, int typeOfSelect, bool distinct)
1101 {
1102 wxString tempSqlStmt;
1103 BuildSelectStmt(tempSqlStmt, typeOfSelect, distinct);
1104 wxStrcpy(pSqlStmt, tempSqlStmt);
1105 } // wxDbTable::BuildSelectStmt()
1106
1107
1108 /********** wxDbTable::BuildUpdateStmt() **********/
1109 void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
1110 {
1111 wxASSERT(!queryOnly);
1112 if (queryOnly)
1113 return;
1114
1115 wxString whereClause;
1116 whereClause.Empty();
1117
1118 bool firstColumn = TRUE;
1119
1120 pSqlStmt.Printf(wxT("UPDATE %s SET "), pDb->SQLTableName(tableName.Upper().c_str()));
1121
1122 // Append a list of columns to be updated
1123 int i;
1124 for (i = 0; i < noCols; i++)
1125 {
1126 // Only append Updateable columns
1127 if (colDefs[i].Updateable)
1128 {
1129 if (!firstColumn)
1130 pSqlStmt += wxT(",");
1131 else
1132 firstColumn = FALSE;
1133
1134 pSqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
1135 // pSqlStmt += colDefs[i].ColName;
1136 pSqlStmt += wxT(" = ?");
1137 }
1138 }
1139
1140 // Append the WHERE clause to the SQL UPDATE statement
1141 pSqlStmt += wxT(" WHERE ");
1142 switch(typeOfUpd)
1143 {
1144 case DB_UPD_KEYFIELDS:
1145 // If the datasource supports the ROWID column, build
1146 // the where on ROWID for efficiency purposes.
1147 // e.g. UPDATE PARTS SET Col1 = ?, Col2 = ? WHERE ROWID = '111.222.333'
1148 if (CanUpdByROWID())
1149 {
1150 SDWORD cb;
1151 wxChar rowid[wxDB_ROWID_LEN+1];
1152
1153 // Get the ROWID value. If not successful retreiving the ROWID,
1154 // simply fall down through the code and build the WHERE clause
1155 // based on the key fields.
1156 if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
1157 {
1158 pSqlStmt += wxT("ROWID = '");
1159 pSqlStmt += rowid;
1160 pSqlStmt += wxT("'");
1161 break;
1162 }
1163 }
1164 // Unable to delete by ROWID, so build a WHERE
1165 // clause based on the keyfields.
1166 BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
1167 pSqlStmt += whereClause;
1168 break;
1169 case DB_UPD_WHERE:
1170 pSqlStmt += pWhereClause;
1171 break;
1172 }
1173 } // BuildUpdateStmt()
1174
1175
1176 /***** DEPRECATED: use wxDbTable::BuildUpdateStmt(wxString &....) form *****/
1177 void wxDbTable::BuildUpdateStmt(wxChar *pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
1178 {
1179 wxString tempSqlStmt;
1180 BuildUpdateStmt(tempSqlStmt, typeOfUpd, pWhereClause);
1181 wxStrcpy(pSqlStmt, tempSqlStmt);
1182 } // BuildUpdateStmt()
1183
1184
1185 /********** wxDbTable::BuildWhereClause() **********/
1186 void wxDbTable::BuildWhereClause(wxString &pWhereClause, int typeOfWhere,
1187 const wxString &qualTableName, bool useLikeComparison)
1188 /*
1189 * Note: BuildWhereClause() currently ignores timestamp columns.
1190 * They are not included as part of the where clause.
1191 */
1192 {
1193 bool moreThanOneColumn = FALSE;
1194 wxString colValue;
1195
1196 // Loop through the columns building a where clause as you go
1197 int i;
1198 for (i = 0; i < noCols; i++)
1199 {
1200 // Determine if this column should be included in the WHERE clause
1201 if ((typeOfWhere == DB_WHERE_KEYFIELDS && colDefs[i].KeyField) ||
1202 (typeOfWhere == DB_WHERE_MATCHING && (!IsColNull(i))))
1203 {
1204 // Skip over timestamp columns
1205 if (colDefs[i].SqlCtype == SQL_C_TIMESTAMP)
1206 continue;
1207 // If there is more than 1 column, join them with the keyword "AND"
1208 if (moreThanOneColumn)
1209 pWhereClause += wxT(" AND ");
1210 else
1211 moreThanOneColumn = TRUE;
1212 // Concatenate where phrase for the column
1213 if (qualTableName.Length())
1214 {
1215 pWhereClause += pDb->SQLTableName(qualTableName);
1216 // pWhereClause += qualTableName;
1217 pWhereClause += wxT(".");
1218 }
1219 pWhereClause += pDb->SQLColumnName(colDefs[i].ColName);
1220 // pWhereClause += colDefs[i].ColName;
1221 if (useLikeComparison && (colDefs[i].SqlCtype == SQL_C_CHAR))
1222 pWhereClause += wxT(" LIKE ");
1223 else
1224 pWhereClause += wxT(" = ");
1225 switch(colDefs[i].SqlCtype)
1226 {
1227 case SQL_C_CHAR:
1228 colValue.Printf(wxT("'%s'"), (UCHAR FAR *) colDefs[i].PtrDataObj);
1229 break;
1230 case SQL_C_SSHORT:
1231 colValue.Printf(wxT("%hi"), *((SWORD *) colDefs[i].PtrDataObj));
1232 break;
1233 case SQL_C_USHORT:
1234 colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[i].PtrDataObj));
1235 break;
1236 case SQL_C_SLONG:
1237 colValue.Printf(wxT("%li"), *((SDWORD *) colDefs[i].PtrDataObj));
1238 break;
1239 case SQL_C_ULONG:
1240 colValue.Printf(wxT("%lu"), *((UDWORD *) colDefs[i].PtrDataObj));
1241 break;
1242 case SQL_C_FLOAT:
1243 colValue.Printf(wxT("%.6f"), *((SFLOAT *) colDefs[i].PtrDataObj));
1244 break;
1245 case SQL_C_DOUBLE:
1246 colValue.Printf(wxT("%.6f"), *((SDOUBLE *) colDefs[i].PtrDataObj));
1247 break;
1248 }
1249 pWhereClause += colValue;
1250 }
1251 }
1252 } // wxDbTable::BuildWhereClause()
1253
1254
1255 /***** DEPRECATED: use wxDbTable::BuildWhereClause(wxString &....) form *****/
1256 void wxDbTable::BuildWhereClause(wxChar *pWhereClause, int typeOfWhere,
1257 const wxString &qualTableName, bool useLikeComparison)
1258 {
1259 wxString tempSqlStmt;
1260 BuildWhereClause(tempSqlStmt, typeOfWhere, qualTableName, useLikeComparison);
1261 wxStrcpy(pWhereClause, tempSqlStmt);
1262 } // wxDbTable::BuildWhereClause()
1263
1264
1265 /********** wxDbTable::GetRowNum() **********/
1266 UWORD wxDbTable::GetRowNum(void)
1267 {
1268 UDWORD rowNum;
1269
1270 if (SQLGetStmtOption(hstmt, SQL_ROW_NUMBER, (UCHAR*) &rowNum) != SQL_SUCCESS)
1271 {
1272 pDb->DispAllErrors(henv, hdbc, hstmt);
1273 return(0);
1274 }
1275
1276 // Completed successfully
1277 return((UWORD) rowNum);
1278
1279 } // wxDbTable::GetRowNum()
1280
1281
1282 /********** wxDbTable::CloseCursor() **********/
1283 bool wxDbTable::CloseCursor(HSTMT cursor)
1284 {
1285 if (SQLFreeStmt(cursor, SQL_CLOSE) != SQL_SUCCESS)
1286 return(pDb->DispAllErrors(henv, hdbc, cursor));
1287
1288 // Completed successfully
1289 return(TRUE);
1290
1291 } // wxDbTable::CloseCursor()
1292
1293
1294 /********** wxDbTable::CreateTable() **********/
1295 bool wxDbTable::CreateTable(bool attemptDrop)
1296 {
1297 if (!pDb)
1298 return FALSE;
1299
1300 int i, j;
1301 wxString sqlStmt;
1302
1303 #ifdef DBDEBUG_CONSOLE
1304 cout << wxT("Creating Table ") << tableName << wxT("...") << endl;
1305 #endif
1306
1307 // Drop table first
1308 if (attemptDrop && !DropTable())
1309 return FALSE;
1310
1311 // Create the table
1312 #ifdef DBDEBUG_CONSOLE
1313 for (i = 0; i < noCols; i++)
1314 {
1315 // Exclude derived columns since they are NOT part of the base table
1316 if (colDefs[i].DerivedCol)
1317 continue;
1318 cout << i + 1 << wxT(": ") << colDefs[i].ColName << wxT("; ");
1319 switch(colDefs[i].DbDataType)
1320 {
1321 case DB_DATA_TYPE_VARCHAR:
1322 cout << pDb->GetTypeInfVarchar().TypeName << wxT("(") << colDefs[i].SzDataObj << wxT(")");
1323 break;
1324 case DB_DATA_TYPE_INTEGER:
1325 cout << pDb->GetTypeInfInteger().TypeName;
1326 break;
1327 case DB_DATA_TYPE_FLOAT:
1328 cout << pDb->GetTypeInfFloat().TypeName;
1329 break;
1330 case DB_DATA_TYPE_DATE:
1331 cout << pDb->GetTypeInfDate().TypeName;
1332 break;
1333 case DB_DATA_TYPE_BLOB:
1334 cout << pDb->GetTypeInfBlob().TypeName;
1335 break;
1336 }
1337 cout << endl;
1338 }
1339 #endif
1340
1341 // Build a CREATE TABLE string from the colDefs structure.
1342 bool needComma = FALSE;
1343
1344 sqlStmt.Printf(wxT("CREATE TABLE %s ("), pDb->SQLTableName(tableName.c_str()));
1345
1346 for (i = 0; i < noCols; i++)
1347 {
1348 // Exclude derived columns since they are NOT part of the base table
1349 if (colDefs[i].DerivedCol)
1350 continue;
1351 // Comma Delimiter
1352 if (needComma)
1353 sqlStmt += wxT(",");
1354 // Column Name
1355 sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
1356 // sqlStmt += colDefs[i].ColName;
1357 sqlStmt += wxT(" ");
1358 // Column Type
1359 switch(colDefs[i].DbDataType)
1360 {
1361 case DB_DATA_TYPE_VARCHAR:
1362 sqlStmt += pDb->GetTypeInfVarchar().TypeName;
1363 break;
1364 case DB_DATA_TYPE_INTEGER:
1365 sqlStmt += pDb->GetTypeInfInteger().TypeName;
1366 break;
1367 case DB_DATA_TYPE_FLOAT:
1368 sqlStmt += pDb->GetTypeInfFloat().TypeName;
1369 break;
1370 case DB_DATA_TYPE_DATE:
1371 sqlStmt += pDb->GetTypeInfDate().TypeName;
1372 break;
1373 case DB_DATA_TYPE_BLOB:
1374 sqlStmt += pDb->GetTypeInfBlob().TypeName;
1375 break;
1376 }
1377 // For varchars, append the size of the string
1378 if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR)// ||
1379 // colDefs[i].DbDataType == DB_DATA_TYPE_BLOB)
1380 {
1381 wxString s;
1382 s.Printf(wxT("(%d)"), colDefs[i].SzDataObj);
1383 sqlStmt += s;
1384 }
1385
1386 if (pDb->Dbms() == dbmsDB2 ||
1387 pDb->Dbms() == dbmsMY_SQL ||
1388 pDb->Dbms() == dbmsSYBASE_ASE ||
1389 pDb->Dbms() == dbmsINTERBASE ||
1390 pDb->Dbms() == dbmsMS_SQL_SERVER)
1391 {
1392 if (colDefs[i].KeyField)
1393 {
1394 sqlStmt += wxT(" NOT NULL");
1395 }
1396 }
1397
1398 needComma = TRUE;
1399 }
1400 // If there is a primary key defined, include it in the create statement
1401 for (i = j = 0; i < noCols; i++)
1402 {
1403 if (colDefs[i].KeyField)
1404 {
1405 j++;
1406 break;
1407 }
1408 }
1409 if (j && pDb->Dbms() != dbmsDBASE) // Found a keyfield
1410 {
1411 switch (pDb->Dbms())
1412 {
1413 case dbmsACCESS:
1414 case dbmsINFORMIX:
1415 case dbmsSYBASE_ASA:
1416 case dbmsSYBASE_ASE:
1417 case dbmsMY_SQL:
1418 {
1419 // MySQL goes out on this one. We also declare the relevant key NON NULL above
1420 sqlStmt += wxT(",PRIMARY KEY (");
1421 break;
1422 }
1423 default:
1424 {
1425 sqlStmt += wxT(",CONSTRAINT ");
1426 // DB2 is limited to 18 characters for index names
1427 if (pDb->Dbms() == dbmsDB2)
1428 {
1429 wxASSERT_MSG((tableName && wxStrlen(tableName) <= 13), wxT("DB2 table/index names must be no longer than 13 characters in length.\n\nTruncating table name to 13 characters."));
1430 sqlStmt += pDb->SQLTableName(tableName.substr(0, 13).c_str());
1431 // sqlStmt += tableName.substr(0, 13);
1432 }
1433 else
1434 sqlStmt += pDb->SQLTableName(tableName.c_str());
1435 // sqlStmt += tableName;
1436
1437 sqlStmt += wxT("_PIDX PRIMARY KEY (");
1438 break;
1439 }
1440 }
1441
1442 // List column name(s) of column(s) comprising the primary key
1443 for (i = j = 0; i < noCols; i++)
1444 {
1445 if (colDefs[i].KeyField)
1446 {
1447 if (j++) // Multi part key, comma separate names
1448 sqlStmt += wxT(",");
1449 sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
1450 // sqlStmt += colDefs[i].ColName;
1451 }
1452 }
1453 sqlStmt += wxT(")");
1454
1455 if (pDb->Dbms() == dbmsINFORMIX ||
1456 pDb->Dbms() == dbmsSYBASE_ASA ||
1457 pDb->Dbms() == dbmsSYBASE_ASE)
1458 {
1459 sqlStmt += wxT(" CONSTRAINT ");
1460 sqlStmt += pDb->SQLTableName(tableName);
1461 // sqlStmt += tableName;
1462 sqlStmt += wxT("_PIDX");
1463 }
1464 }
1465 // Append the closing parentheses for the create table statement
1466 sqlStmt += wxT(")");
1467
1468 pDb->WriteSqlLog(sqlStmt);
1469
1470 #ifdef DBDEBUG_CONSOLE
1471 cout << endl << sqlStmt.c_str() << endl;
1472 #endif
1473
1474 // Execute the CREATE TABLE statement
1475 RETCODE retcode = SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
1476 if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
1477 {
1478 pDb->DispAllErrors(henv, hdbc, hstmt);
1479 pDb->RollbackTrans();
1480 CloseCursor(hstmt);
1481 return(FALSE);
1482 }
1483
1484 // Commit the transaction and close the cursor
1485 if (!pDb->CommitTrans())
1486 return(FALSE);
1487 if (!CloseCursor(hstmt))
1488 return(FALSE);
1489
1490 // Database table created successfully
1491 return(TRUE);
1492
1493 } // wxDbTable::CreateTable()
1494
1495
1496 /********** wxDbTable::DropTable() **********/
1497 bool wxDbTable::DropTable()
1498 {
1499 // NOTE: This function returns TRUE if the Table does not exist, but
1500 // only for identified databases. Code will need to be added
1501 // below for any other databases when those databases are defined
1502 // to handle this situation consistently
1503
1504 wxString sqlStmt;
1505
1506 sqlStmt.Printf(wxT("DROP TABLE %s"), pDb->SQLTableName(tableName.c_str()));
1507
1508 pDb->WriteSqlLog(sqlStmt);
1509
1510 #ifdef DBDEBUG_CONSOLE
1511 cout << endl << sqlStmt.c_str() << endl;
1512 #endif
1513
1514 RETCODE retcode = SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
1515 if (retcode != SQL_SUCCESS)
1516 {
1517 // Check for "Base table not found" error and ignore
1518 pDb->GetNextError(henv, hdbc, hstmt);
1519 if (wxStrcmp(pDb->sqlState, wxT("S0002")) /*&&
1520 wxStrcmp(pDb->sqlState, wxT("S1000"))*/) // "Base table not found"
1521 {
1522 // Check for product specific error codes
1523 if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // 5.x (and lower?)
1524 (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
1525 (pDb->Dbms() == dbmsPERVASIVE_SQL && !wxStrcmp(pDb->sqlState,wxT("S1000"))) || // Returns an S1000 then an S0002
1526 (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))))
1527 {
1528 pDb->DispNextError();
1529 pDb->DispAllErrors(henv, hdbc, hstmt);
1530 pDb->RollbackTrans();
1531 // CloseCursor(hstmt);
1532 return(FALSE);
1533 }
1534 }
1535 }
1536
1537 // Commit the transaction and close the cursor
1538 if (! pDb->CommitTrans())
1539 return(FALSE);
1540 if (! CloseCursor(hstmt))
1541 return(FALSE);
1542
1543 return(TRUE);
1544 } // wxDbTable::DropTable()
1545
1546
1547 /********** wxDbTable::CreateIndex() **********/
1548 bool wxDbTable::CreateIndex(const wxString &idxName, bool unique, UWORD noIdxCols,
1549 wxDbIdxDef *pIdxDefs, bool attemptDrop)
1550 {
1551 wxString sqlStmt;
1552
1553 // Drop the index first
1554 if (attemptDrop && !DropIndex(idxName))
1555 return (FALSE);
1556
1557 // MySQL (and possibly Sybase ASE?? - gt) require that any columns which are used as portions
1558 // of an index have the columns defined as "NOT NULL". During initial table creation though,
1559 // it may not be known which columns are necessarily going to be part of an index (e.g. the
1560 // table was created, then months later you determine that an additional index while
1561 // give better performance, so you want to add an index).
1562 //
1563 // The following block of code will modify the column definition to make the column be
1564 // defined with the "NOT NULL" qualifier.
1565 if (pDb->Dbms() == dbmsMY_SQL)
1566 {
1567 wxString sqlStmt;
1568 int i;
1569 bool ok = TRUE;
1570 for (i = 0; i < noIdxCols && ok; i++)
1571 {
1572 int j = 0;
1573 bool found = FALSE;
1574 // Find the column definition that has the ColName that matches the
1575 // index column name. We need to do this to get the DB_DATA_TYPE of
1576 // the index column, as MySQL's syntax for the ALTER column requires
1577 // this information
1578 while (!found && (j < this->noCols))
1579 {
1580 if (wxStrcmp(colDefs[j].ColName,pIdxDefs[i].ColName) == 0)
1581 found = TRUE;
1582 if (!found)
1583 j++;
1584 }
1585
1586 if (found)
1587 {
1588 ok = pDb->ModifyColumn(tableName, pIdxDefs[i].ColName,
1589 colDefs[j].DbDataType, colDefs[j].SzDataObj,
1590 wxT("NOT NULL"));
1591
1592 if (!ok)
1593 {
1594 wxODBC_ERRORS retcode;
1595 // Oracle returns a DB_ERR_GENERAL_ERROR if the column is already
1596 // defined to be NOT NULL, but reportedly MySQL doesn't mind.
1597 // This line is just here for debug checking of the value
1598 retcode = (wxODBC_ERRORS)pDb->DB_STATUS;
1599 }
1600 }
1601 else
1602 ok = FALSE;
1603 }
1604 if (ok)
1605 pDb->CommitTrans();
1606 else
1607 {
1608 pDb->RollbackTrans();
1609 return(FALSE);
1610 }
1611 }
1612
1613 // Build a CREATE INDEX statement
1614 sqlStmt = wxT("CREATE ");
1615 if (unique)
1616 sqlStmt += wxT("UNIQUE ");
1617
1618 sqlStmt += wxT("INDEX ");
1619 sqlStmt += pDb->SQLTableName(idxName);
1620 sqlStmt += wxT(" ON ");
1621
1622 sqlStmt += pDb->SQLTableName(tableName);
1623 // sqlStmt += tableName;
1624 sqlStmt += wxT(" (");
1625
1626 // Append list of columns making up index
1627 int i;
1628 for (i = 0; i < noIdxCols; i++)
1629 {
1630 sqlStmt += pDb->SQLColumnName(pIdxDefs[i].ColName);
1631 // sqlStmt += pIdxDefs[i].ColName;
1632
1633 // Postgres and SQL Server 7 do not support the ASC/DESC keywords for index columns
1634 if (!((pDb->Dbms() == dbmsMS_SQL_SERVER) && (strncmp(pDb->dbInf.dbmsVer,"07",2)==0)) &&
1635 !(pDb->Dbms() == dbmsPOSTGRES))
1636 {
1637 if (pIdxDefs[i].Ascending)
1638 sqlStmt += wxT(" ASC");
1639 else
1640 sqlStmt += wxT(" DESC");
1641 }
1642 else
1643 wxASSERT_MSG(pIdxDefs[i].Ascending, "Datasource does not support DESCending index columns");
1644
1645 if ((i + 1) < noIdxCols)
1646 sqlStmt += wxT(",");
1647 }
1648
1649 // Append closing parentheses
1650 sqlStmt += wxT(")");
1651
1652 pDb->WriteSqlLog(sqlStmt);
1653
1654 #ifdef DBDEBUG_CONSOLE
1655 cout << endl << sqlStmt.c_str() << endl << endl;
1656 #endif
1657
1658 // Execute the CREATE INDEX statement
1659 if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
1660 {
1661 pDb->DispAllErrors(henv, hdbc, hstmt);
1662 pDb->RollbackTrans();
1663 CloseCursor(hstmt);
1664 return(FALSE);
1665 }
1666
1667 // Commit the transaction and close the cursor
1668 if (! pDb->CommitTrans())
1669 return(FALSE);
1670 if (! CloseCursor(hstmt))
1671 return(FALSE);
1672
1673 // Index Created Successfully
1674 return(TRUE);
1675
1676 } // wxDbTable::CreateIndex()
1677
1678
1679 /********** wxDbTable::DropIndex() **********/
1680 bool wxDbTable::DropIndex(const wxString &idxName)
1681 {
1682 // NOTE: This function returns TRUE if the Index does not exist, but
1683 // only for identified databases. Code will need to be added
1684 // below for any other databases when those databases are defined
1685 // to handle this situation consistently
1686
1687 wxString sqlStmt;
1688
1689 if (pDb->Dbms() == dbmsACCESS || pDb->Dbms() == dbmsMY_SQL ||
1690 pDb->Dbms() == dbmsDBASE /*|| Paradox needs this syntax too when we add support*/)
1691 sqlStmt.Printf(wxT("DROP INDEX %s ON %s"),pDb->SQLTableName(idxName.c_str()), pDb->SQLTableName(tableName.c_str()));
1692 else if ((pDb->Dbms() == dbmsMS_SQL_SERVER) ||
1693 (pDb->Dbms() == dbmsSYBASE_ASE))
1694 sqlStmt.Printf(wxT("DROP INDEX %s.%s"), pDb->SQLTableName(tableName.c_str()), pDb->SQLTableName(idxName.c_str()));
1695 else
1696 sqlStmt.Printf(wxT("DROP INDEX %s"),pDb->SQLTableName(idxName.c_str()));
1697
1698 pDb->WriteSqlLog(sqlStmt);
1699
1700 #ifdef DBDEBUG_CONSOLE
1701 cout << endl << sqlStmt.c_str() << endl;
1702 #endif
1703
1704 if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
1705 {
1706 // Check for "Index not found" error and ignore
1707 pDb->GetNextError(henv, hdbc, hstmt);
1708 if (wxStrcmp(pDb->sqlState,wxT("S0012"))) // "Index not found"
1709 {
1710 // Check for product specific error codes
1711 if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // v5.x (and lower?)
1712 (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
1713 (pDb->Dbms() == dbmsMS_SQL_SERVER && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
1714 (pDb->Dbms() == dbmsINTERBASE && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
1715 (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("S0002"))) || // Base table not found
1716 (pDb->Dbms() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,wxT("42S12"))) || // tested by Christopher Ludwik Marino-Cebulski using v3.23.21beta
1717 (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))
1718 ))
1719 {
1720 pDb->DispNextError();
1721 pDb->DispAllErrors(henv, hdbc, hstmt);
1722 pDb->RollbackTrans();
1723 CloseCursor(hstmt);
1724 return(FALSE);
1725 }
1726 }
1727 }
1728
1729 // Commit the transaction and close the cursor
1730 if (! pDb->CommitTrans())
1731 return(FALSE);
1732 if (! CloseCursor(hstmt))
1733 return(FALSE);
1734
1735 return(TRUE);
1736 } // wxDbTable::DropIndex()
1737
1738
1739 /********** wxDbTable::SetOrderByColNums() **********/
1740 bool wxDbTable::SetOrderByColNums(UWORD first, ... )
1741 {
1742 int colNo = first; // using 'int' to be able to look for wxDB_NO_MORE_COLUN_NUMBERS
1743 va_list argptr;
1744
1745 bool abort = FALSE;
1746 wxString tempStr;
1747
1748 va_start(argptr, first); /* Initialize variable arguments. */
1749 while (!abort && (colNo != wxDB_NO_MORE_COLUMN_NUMBERS))
1750 {
1751 // Make sure the passed in column number
1752 // is within the valid range of columns
1753 //
1754 // Valid columns are 0 thru noCols-1
1755 if (colNo >= noCols || colNo < 0)
1756 {
1757 abort = TRUE;
1758 continue;
1759 }
1760
1761 if (colNo != first)
1762 tempStr += wxT(",");
1763
1764 tempStr += colDefs[colNo].ColName;
1765 colNo = va_arg (argptr, int);
1766 }
1767 va_end (argptr); /* Reset variable arguments. */
1768
1769 SetOrderByClause(tempStr);
1770
1771 return (!abort);
1772 } // wxDbTable::SetOrderByColNums()
1773
1774
1775 /********** wxDbTable::Insert() **********/
1776 int wxDbTable::Insert(void)
1777 {
1778 wxASSERT(!queryOnly);
1779 if (queryOnly || !insertable)
1780 return(DB_FAILURE);
1781
1782 bindInsertParams();
1783
1784 // Insert the record by executing the already prepared insert statement
1785 RETCODE retcode;
1786 retcode=SQLExecute(hstmtInsert);
1787 if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
1788 {
1789 // Check to see if integrity constraint was violated
1790 pDb->GetNextError(henv, hdbc, hstmtInsert);
1791 if (! wxStrcmp(pDb->sqlState, wxT("23000"))) // Integrity constraint violated
1792 return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL);
1793 else
1794 {
1795 pDb->DispNextError();
1796 pDb->DispAllErrors(henv, hdbc, hstmtInsert);
1797 return(DB_FAILURE);
1798 }
1799 }
1800
1801 // Record inserted into the datasource successfully
1802 return(DB_SUCCESS);
1803
1804 } // wxDbTable::Insert()
1805
1806
1807 /********** wxDbTable::Update() **********/
1808 bool wxDbTable::Update(void)
1809 {
1810 wxASSERT(!queryOnly);
1811 if (queryOnly)
1812 return(FALSE);
1813
1814 wxString sqlStmt;
1815
1816 // Build the SQL UPDATE statement
1817 BuildUpdateStmt(sqlStmt, DB_UPD_KEYFIELDS);
1818
1819 pDb->WriteSqlLog(sqlStmt);
1820
1821 #ifdef DBDEBUG_CONSOLE
1822 cout << endl << sqlStmt.c_str() << endl << endl;
1823 #endif
1824
1825 // Execute the SQL UPDATE statement
1826 return(execUpdate(sqlStmt));
1827
1828 } // wxDbTable::Update()
1829
1830
1831 /********** wxDbTable::Update(pSqlStmt) **********/
1832 bool wxDbTable::Update(const wxString &pSqlStmt)
1833 {
1834 wxASSERT(!queryOnly);
1835 if (queryOnly)
1836 return(FALSE);
1837
1838 pDb->WriteSqlLog(pSqlStmt);
1839
1840 return(execUpdate(pSqlStmt));
1841
1842 } // wxDbTable::Update(pSqlStmt)
1843
1844
1845 /********** wxDbTable::UpdateWhere() **********/
1846 bool wxDbTable::UpdateWhere(const wxString &pWhereClause)
1847 {
1848 wxASSERT(!queryOnly);
1849 if (queryOnly)
1850 return(FALSE);
1851
1852 wxString sqlStmt;
1853
1854 // Build the SQL UPDATE statement
1855 BuildUpdateStmt(sqlStmt, DB_UPD_WHERE, pWhereClause);
1856
1857 pDb->WriteSqlLog(sqlStmt);
1858
1859 #ifdef DBDEBUG_CONSOLE
1860 cout << endl << sqlStmt.c_str() << endl << endl;
1861 #endif
1862
1863 // Execute the SQL UPDATE statement
1864 return(execUpdate(sqlStmt));
1865
1866 } // wxDbTable::UpdateWhere()
1867
1868
1869 /********** wxDbTable::Delete() **********/
1870 bool wxDbTable::Delete(void)
1871 {
1872 wxASSERT(!queryOnly);
1873 if (queryOnly)
1874 return(FALSE);
1875
1876 wxString sqlStmt;
1877 sqlStmt.Empty();
1878
1879 // Build the SQL DELETE statement
1880 BuildDeleteStmt(sqlStmt, DB_DEL_KEYFIELDS);
1881
1882 pDb->WriteSqlLog(sqlStmt);
1883
1884 // Execute the SQL DELETE statement
1885 return(execDelete(sqlStmt));
1886
1887 } // wxDbTable::Delete()
1888
1889
1890 /********** wxDbTable::DeleteWhere() **********/
1891 bool wxDbTable::DeleteWhere(const wxString &pWhereClause)
1892 {
1893 wxASSERT(!queryOnly);
1894 if (queryOnly)
1895 return(FALSE);
1896
1897 wxString sqlStmt;
1898 sqlStmt.Empty();
1899
1900 // Build the SQL DELETE statement
1901 BuildDeleteStmt(sqlStmt, DB_DEL_WHERE, pWhereClause);
1902
1903 pDb->WriteSqlLog(sqlStmt);
1904
1905 // Execute the SQL DELETE statement
1906 return(execDelete(sqlStmt));
1907
1908 } // wxDbTable::DeleteWhere()
1909
1910
1911 /********** wxDbTable::DeleteMatching() **********/
1912 bool wxDbTable::DeleteMatching(void)
1913 {
1914 wxASSERT(!queryOnly);
1915 if (queryOnly)
1916 return(FALSE);
1917
1918 wxString sqlStmt;
1919 sqlStmt.Empty();
1920
1921 // Build the SQL DELETE statement
1922 BuildDeleteStmt(sqlStmt, DB_DEL_MATCHING);
1923
1924 pDb->WriteSqlLog(sqlStmt);
1925
1926 // Execute the SQL DELETE statement
1927 return(execDelete(sqlStmt));
1928
1929 } // wxDbTable::DeleteMatching()
1930
1931
1932 /********** wxDbTable::IsColNull() **********/
1933 bool wxDbTable::IsColNull(UWORD colNo) const
1934 {
1935 /*
1936 This logic is just not right. It would indicate TRUE
1937 if a numeric field were set to a value of 0.
1938
1939 switch(colDefs[colNo].SqlCtype)
1940 {
1941 case SQL_C_CHAR:
1942 return(((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] == 0);
1943 case SQL_C_SSHORT:
1944 return(( *((SWORD *) colDefs[colNo].PtrDataObj)) == 0);
1945 case SQL_C_USHORT:
1946 return(( *((UWORD*) colDefs[colNo].PtrDataObj)) == 0);
1947 case SQL_C_SLONG:
1948 return(( *((SDWORD *) colDefs[colNo].PtrDataObj)) == 0);
1949 case SQL_C_ULONG:
1950 return(( *((UDWORD *) colDefs[colNo].PtrDataObj)) == 0);
1951 case SQL_C_FLOAT:
1952 return(( *((SFLOAT *) colDefs[colNo].PtrDataObj)) == 0);
1953 case SQL_C_DOUBLE:
1954 return((*((SDOUBLE *) colDefs[colNo].PtrDataObj)) == 0);
1955 case SQL_C_TIMESTAMP:
1956 TIMESTAMP_STRUCT *pDt;
1957 pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj;
1958 if (pDt->year == 0 && pDt->month == 0 && pDt->day == 0)
1959 return(TRUE);
1960 else
1961 return(FALSE);
1962 default:
1963 return(TRUE);
1964 }
1965 */
1966 return (colDefs[colNo].Null);
1967 } // wxDbTable::IsColNull()
1968
1969
1970 /********** wxDbTable::CanSelectForUpdate() **********/
1971 bool wxDbTable::CanSelectForUpdate(void)
1972 {
1973 if (queryOnly)
1974 return FALSE;
1975
1976 if (pDb->Dbms() == dbmsMY_SQL)
1977 return FALSE;
1978
1979 if ((pDb->Dbms() == dbmsORACLE) ||
1980 (pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE))
1981 return(TRUE);
1982 else
1983 return(FALSE);
1984
1985 } // wxDbTable::CanSelectForUpdate()
1986
1987
1988 /********** wxDbTable::CanUpdByROWID() **********/
1989 bool wxDbTable::CanUpdByROWID(void)
1990 {
1991 /*
1992 * NOTE: Returning FALSE for now until this can be debugged,
1993 * as the ROWID is not getting updated correctly
1994 */
1995 return FALSE;
1996 /*
1997 if (pDb->Dbms() == dbmsORACLE)
1998 return(TRUE);
1999 else
2000 return(FALSE);
2001 */
2002 } // wxDbTable::CanUpdByROWID()
2003
2004
2005 /********** wxDbTable::IsCursorClosedOnCommit() **********/
2006 bool wxDbTable::IsCursorClosedOnCommit(void)
2007 {
2008 if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE)
2009 return(FALSE);
2010 else
2011 return(TRUE);
2012
2013 } // wxDbTable::IsCursorClosedOnCommit()
2014
2015
2016
2017 /********** wxDbTable::ClearMemberVar() **********/
2018 void wxDbTable::ClearMemberVar(UWORD colNo, bool setToNull)
2019 {
2020 wxASSERT(colNo < noCols);
2021
2022 switch(colDefs[colNo].SqlCtype)
2023 {
2024 case SQL_C_CHAR:
2025 ((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] = 0;
2026 break;
2027 case SQL_C_SSHORT:
2028 *((SWORD *) colDefs[colNo].PtrDataObj) = 0;
2029 break;
2030 case SQL_C_USHORT:
2031 *((UWORD*) colDefs[colNo].PtrDataObj) = 0;
2032 break;
2033 case SQL_C_SLONG:
2034 *((SDWORD *) colDefs[colNo].PtrDataObj) = 0;
2035 break;
2036 case SQL_C_ULONG:
2037 *((UDWORD *) colDefs[colNo].PtrDataObj) = 0;
2038 break;
2039 case SQL_C_FLOAT:
2040 *((SFLOAT *) colDefs[colNo].PtrDataObj) = 0.0f;
2041 break;
2042 case SQL_C_DOUBLE:
2043 *((SDOUBLE *) colDefs[colNo].PtrDataObj) = 0.0f;
2044 break;
2045 case SQL_C_TIMESTAMP:
2046 TIMESTAMP_STRUCT *pDt;
2047 pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj;
2048 pDt->year = 0;
2049 pDt->month = 0;
2050 pDt->day = 0;
2051 pDt->hour = 0;
2052 pDt->minute = 0;
2053 pDt->second = 0;
2054 pDt->fraction = 0;
2055 break;
2056 }
2057
2058 if (setToNull)
2059 SetColNull(colNo);
2060 } // wxDbTable::ClearMemberVar()
2061
2062
2063 /********** wxDbTable::ClearMemberVars() **********/
2064 void wxDbTable::ClearMemberVars(bool setToNull)
2065 {
2066 int i;
2067
2068 // Loop through the columns setting each member variable to zero
2069 for (i=0; i < noCols; i++)
2070 ClearMemberVar(i,setToNull);
2071
2072 } // wxDbTable::ClearMemberVars()
2073
2074
2075 /********** wxDbTable::SetQueryTimeout() **********/
2076 bool wxDbTable::SetQueryTimeout(UDWORD nSeconds)
2077 {
2078 if (SQLSetStmtOption(hstmtInsert, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS)
2079 return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
2080 if (SQLSetStmtOption(hstmtUpdate, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS)
2081 return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
2082 if (SQLSetStmtOption(hstmtDelete, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS)
2083 return(pDb->DispAllErrors(henv, hdbc, hstmtDelete));
2084 if (SQLSetStmtOption(hstmtInternal, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS)
2085 return(pDb->DispAllErrors(henv, hdbc, hstmtInternal));
2086
2087 // Completed Successfully
2088 return(TRUE);
2089
2090 } // wxDbTable::SetQueryTimeout()
2091
2092
2093 /********** wxDbTable::SetColDefs() **********/
2094 void wxDbTable::SetColDefs(UWORD index, const wxString &fieldName, int dataType, void *pData,
2095 SWORD cType, int size, bool keyField, bool upd,
2096 bool insAllow, bool derivedCol)
2097 {
2098 if (!colDefs) // May happen if the database connection fails
2099 return;
2100
2101 if (fieldName.Length() > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
2102 {
2103 wxStrncpy(colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN);
2104 colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0;
2105
2106 #ifdef __WXDEBUG__
2107 wxString tmpMsg;
2108 tmpMsg.Printf(_T("Column name '%s' is too long. Truncated to '%s'."),
2109 fieldName.c_str(),colDefs[index].ColName);
2110 wxFAIL_MSG(tmpMsg);
2111 #endif // __WXDEBUG__
2112 }
2113 else
2114 wxStrcpy(colDefs[index].ColName, fieldName);
2115
2116 colDefs[index].DbDataType = dataType;
2117 colDefs[index].PtrDataObj = pData;
2118 colDefs[index].SqlCtype = cType;
2119 colDefs[index].SzDataObj = size;
2120 colDefs[index].KeyField = keyField;
2121 colDefs[index].DerivedCol = derivedCol;
2122 // Derived columns by definition would NOT be "Insertable" or "Updateable"
2123 if (derivedCol)
2124 {
2125 colDefs[index].Updateable = FALSE;
2126 colDefs[index].InsertAllowed = FALSE;
2127 }
2128 else
2129 {
2130 colDefs[index].Updateable = upd;
2131 colDefs[index].InsertAllowed = insAllow;
2132 }
2133
2134 colDefs[index].Null = FALSE;
2135
2136 } // wxDbTable::SetColDefs()
2137
2138
2139 /********** wxDbTable::SetColDefs() **********/
2140 wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
2141 {
2142 wxASSERT(pColInfs);
2143 wxDbColDataPtr *pColDataPtrs = NULL;
2144
2145 if (pColInfs)
2146 {
2147 UWORD index;
2148
2149 pColDataPtrs = new wxDbColDataPtr[numCols+1];
2150
2151 for (index = 0; index < numCols; index++)
2152 {
2153 // Process the fields
2154 switch (pColInfs[index].dbDataType)
2155 {
2156 case DB_DATA_TYPE_VARCHAR:
2157 pColDataPtrs[index].PtrDataObj = new wxChar[pColInfs[index].bufferLength+1];
2158 pColDataPtrs[index].SzDataObj = pColInfs[index].columnSize;
2159 pColDataPtrs[index].SqlCtype = SQL_C_CHAR;
2160 break;
2161 case DB_DATA_TYPE_INTEGER:
2162 // Can be long or short
2163 if (pColInfs[index].bufferLength == sizeof(long))
2164 {
2165 pColDataPtrs[index].PtrDataObj = new long;
2166 pColDataPtrs[index].SzDataObj = sizeof(long);
2167 pColDataPtrs[index].SqlCtype = SQL_C_SLONG;
2168 }
2169 else
2170 {
2171 pColDataPtrs[index].PtrDataObj = new short;
2172 pColDataPtrs[index].SzDataObj = sizeof(short);
2173 pColDataPtrs[index].SqlCtype = SQL_C_SSHORT;
2174 }
2175 break;
2176 case DB_DATA_TYPE_FLOAT:
2177 // Can be float or double
2178 if (pColInfs[index].bufferLength == sizeof(float))
2179 {
2180 pColDataPtrs[index].PtrDataObj = new float;
2181 pColDataPtrs[index].SzDataObj = sizeof(float);
2182 pColDataPtrs[index].SqlCtype = SQL_C_FLOAT;
2183 }
2184 else
2185 {
2186 pColDataPtrs[index].PtrDataObj = new double;
2187 pColDataPtrs[index].SzDataObj = sizeof(double);
2188 pColDataPtrs[index].SqlCtype = SQL_C_DOUBLE;
2189 }
2190 break;
2191 case DB_DATA_TYPE_DATE:
2192 pColDataPtrs[index].PtrDataObj = new TIMESTAMP_STRUCT;
2193 pColDataPtrs[index].SzDataObj = sizeof(TIMESTAMP_STRUCT);
2194 pColDataPtrs[index].SqlCtype = SQL_C_TIMESTAMP;
2195 break;
2196 case DB_DATA_TYPE_BLOB:
2197 wxFAIL_MSG(wxT("This form of ::SetColDefs() cannot be used with BLOB columns"));
2198 pColDataPtrs[index].PtrDataObj = /*BLOB ADDITION NEEDED*/NULL;
2199 pColDataPtrs[index].SzDataObj = /*BLOB ADDITION NEEDED*/sizeof(void *);
2200 pColDataPtrs[index].SqlCtype = SQL_VARBINARY;
2201 break;
2202 }
2203 if (pColDataPtrs[index].PtrDataObj != NULL)
2204 SetColDefs (index,pColInfs[index].colName,pColInfs[index].dbDataType, pColDataPtrs[index].PtrDataObj, pColDataPtrs[index].SqlCtype, pColDataPtrs[index].SzDataObj);
2205 else
2206 {
2207 // Unable to build all the column definitions, as either one of
2208 // the calls to "new" failed above, or there was a BLOB field
2209 // to have a column definition for. If BLOBs are to be used,
2210 // the other form of ::SetColDefs() must be used, as it is impossible
2211 // to know the maximum size to create the PtrDataObj to be.
2212 delete [] pColDataPtrs;
2213 return NULL;
2214 }
2215 }
2216 }
2217
2218 return (pColDataPtrs);
2219
2220 } // wxDbTable::SetColDefs()
2221
2222
2223 /********** wxDbTable::SetCursor() **********/
2224 void wxDbTable::SetCursor(HSTMT *hstmtActivate)
2225 {
2226 if (hstmtActivate == wxDB_DEFAULT_CURSOR)
2227 hstmt = *hstmtDefault;
2228 else
2229 hstmt = *hstmtActivate;
2230
2231 } // wxDbTable::SetCursor()
2232
2233
2234 /********** wxDbTable::Count(const wxString &) **********/
2235 ULONG wxDbTable::Count(const wxString &args)
2236 {
2237 ULONG count;
2238 wxString sqlStmt;
2239 SDWORD cb;
2240
2241 // Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement
2242 sqlStmt = wxT("SELECT COUNT(");
2243 sqlStmt += args;
2244 sqlStmt += wxT(") FROM ");
2245 sqlStmt += pDb->SQLTableName(queryTableName);
2246 // sqlStmt += queryTableName;
2247 #if wxODBC_BACKWARD_COMPATABILITY
2248 if (from && wxStrlen(from))
2249 #else
2250 if (from.Length())
2251 #endif
2252 sqlStmt += from;
2253
2254 // Add the where clause if one is provided
2255 #if wxODBC_BACKWARD_COMPATABILITY
2256 if (where && wxStrlen(where))
2257 #else
2258 if (where.Length())
2259 #endif
2260 {
2261 sqlStmt += wxT(" WHERE ");
2262 sqlStmt += where;
2263 }
2264
2265 pDb->WriteSqlLog(sqlStmt);
2266
2267 // Initialize the Count cursor if it's not already initialized
2268 if (!hstmtCount)
2269 {
2270 hstmtCount = GetNewCursor(FALSE,FALSE);
2271 wxASSERT(hstmtCount);
2272 if (!hstmtCount)
2273 return(0);
2274 }
2275
2276 // Execute the SQL statement
2277 if (SQLExecDirect(*hstmtCount, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
2278 {
2279 pDb->DispAllErrors(henv, hdbc, *hstmtCount);
2280 return(0);
2281 }
2282
2283 // Fetch the record
2284 if (SQLFetch(*hstmtCount) != SQL_SUCCESS)
2285 {
2286 pDb->DispAllErrors(henv, hdbc, *hstmtCount);
2287 return(0);
2288 }
2289
2290 // Obtain the result
2291 if (SQLGetData(*hstmtCount, (UWORD)1, SQL_C_ULONG, &count, sizeof(count), &cb) != SQL_SUCCESS)
2292 {
2293 pDb->DispAllErrors(henv, hdbc, *hstmtCount);
2294 return(0);
2295 }
2296
2297 // Free the cursor
2298 if (SQLFreeStmt(*hstmtCount, SQL_CLOSE) != SQL_SUCCESS)
2299 pDb->DispAllErrors(henv, hdbc, *hstmtCount);
2300
2301 // Return the record count
2302 return(count);
2303
2304 } // wxDbTable::Count()
2305
2306
2307 /********** wxDbTable::Refresh() **********/
2308 bool wxDbTable::Refresh(void)
2309 {
2310 bool result = TRUE;
2311
2312 // Switch to the internal cursor so any active cursors are not corrupted
2313 HSTMT currCursor = GetCursor();
2314 hstmt = hstmtInternal;
2315 #if wxODBC_BACKWARD_COMPATABILITY
2316 // Save the where and order by clauses
2317 char *saveWhere = where;
2318 char *saveOrderBy = orderBy;
2319 #else
2320 wxString saveWhere = where;
2321 wxString saveOrderBy = orderBy;
2322 #endif
2323 // Build a where clause to refetch the record with. Try and use the
2324 // ROWID if it's available, ow use the key fields.
2325 wxString whereClause;
2326 whereClause.Empty();
2327
2328 if (CanUpdByROWID())
2329 {
2330 SDWORD cb;
2331 wxChar rowid[wxDB_ROWID_LEN+1];
2332
2333 // Get the ROWID value. If not successful retreiving the ROWID,
2334 // simply fall down through the code and build the WHERE clause
2335 // based on the key fields.
2336 if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
2337 {
2338 whereClause += pDb->SQLTableName(queryTableName);
2339 // whereClause += queryTableName;
2340 whereClause += wxT(".ROWID = '");
2341 whereClause += rowid;
2342 whereClause += wxT("'");
2343 }
2344 }
2345
2346 // If unable to use the ROWID, build a where clause from the keyfields
2347 if (wxStrlen(whereClause) == 0)
2348 BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS, queryTableName);
2349
2350 // Requery the record
2351 where = whereClause;
2352 orderBy.Empty();
2353 if (!Query())
2354 result = FALSE;
2355
2356 if (result && !GetNext())
2357 result = FALSE;
2358
2359 // Switch back to original cursor
2360 SetCursor(&currCursor);
2361
2362 // Free the internal cursor
2363 if (SQLFreeStmt(hstmtInternal, SQL_CLOSE) != SQL_SUCCESS)
2364 pDb->DispAllErrors(henv, hdbc, hstmtInternal);
2365
2366 // Restore the original where and order by clauses
2367 where = saveWhere;
2368 orderBy = saveOrderBy;
2369
2370 return(result);
2371
2372 } // wxDbTable::Refresh()
2373
2374
2375 /********** wxDbTable::SetColNull() **********/
2376 bool wxDbTable::SetColNull(UWORD colNo, bool set)
2377 {
2378 if (colNo < noCols)
2379 {
2380 colDefs[colNo].Null = set;
2381 if (set) // Blank out the values in the member variable
2382 ClearMemberVar(colNo,FALSE); // Must call with FALSE, or infinite recursion will happen
2383 return(TRUE);
2384 }
2385 else
2386 return(FALSE);
2387
2388 } // wxDbTable::SetColNull()
2389
2390
2391 /********** wxDbTable::SetColNull() **********/
2392 bool wxDbTable::SetColNull(const wxString &colName, bool set)
2393 {
2394 int i;
2395 for (i = 0; i < noCols; i++)
2396 {
2397 if (!wxStricmp(colName, colDefs[i].ColName))
2398 break;
2399 }
2400
2401 if (i < noCols)
2402 {
2403 colDefs[i].Null = set;
2404 if (set) // Blank out the values in the member variable
2405 ClearMemberVar(i,FALSE); // Must call with FALSE, or infinite recursion will happen
2406 return(TRUE);
2407 }
2408 else
2409 return(FALSE);
2410
2411 } // wxDbTable::SetColNull()
2412
2413
2414 /********** wxDbTable::GetNewCursor() **********/
2415 HSTMT *wxDbTable::GetNewCursor(bool setCursor, bool bindColumns)
2416 {
2417 HSTMT *newHSTMT = new HSTMT;
2418 wxASSERT(newHSTMT);
2419 if (!newHSTMT)
2420 return(0);
2421
2422 if (SQLAllocStmt(hdbc, newHSTMT) != SQL_SUCCESS)
2423 {
2424 pDb->DispAllErrors(henv, hdbc);
2425 delete newHSTMT;
2426 return(0);
2427 }
2428
2429 if (SQLSetStmtOption(*newHSTMT, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS)
2430 {
2431 pDb->DispAllErrors(henv, hdbc, *newHSTMT);
2432 delete newHSTMT;
2433 return(0);
2434 }
2435
2436 if (bindColumns)
2437 {
2438 if (!bindCols(*newHSTMT))
2439 {
2440 delete newHSTMT;
2441 return(0);
2442 }
2443 }
2444
2445 if (setCursor)
2446 SetCursor(newHSTMT);
2447
2448 return(newHSTMT);
2449
2450 } // wxDbTable::GetNewCursor()
2451
2452
2453 /********** wxDbTable::DeleteCursor() **********/
2454 bool wxDbTable::DeleteCursor(HSTMT *hstmtDel)
2455 {
2456 bool result = TRUE;
2457
2458 if (!hstmtDel) // Cursor already deleted
2459 return(result);
2460
2461 /*
2462 ODBC 3.0 says to use this form
2463 if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
2464
2465 */
2466 if (SQLFreeStmt(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
2467 {
2468 pDb->DispAllErrors(henv, hdbc);
2469 result = FALSE;
2470 }
2471
2472 delete hstmtDel;
2473
2474 return(result);
2475
2476 } // wxDbTable::DeleteCursor()
2477
2478 //////////////////////////////////////////////////////////////
2479 // wxDbGrid support functions
2480 //////////////////////////////////////////////////////////////
2481
2482 void wxDbTable::SetRowMode(const rowmode_t rowmode)
2483 {
2484 if (!m_hstmtGridQuery)
2485 {
2486 m_hstmtGridQuery = GetNewCursor(FALSE,FALSE);
2487 if (!bindCols(*m_hstmtGridQuery))
2488 return;
2489 }
2490
2491 m_rowmode = rowmode;
2492 switch (m_rowmode)
2493 {
2494 case WX_ROW_MODE_QUERY:
2495 SetCursor(m_hstmtGridQuery);
2496 break;
2497 case WX_ROW_MODE_INDIVIDUAL:
2498 SetCursor(hstmtDefault);
2499 break;
2500 default:
2501 assert(0);
2502 }
2503 } // wxDbTable::SetRowMode()
2504
2505
2506 wxVariant wxDbTable::GetCol(const int colNo) const
2507 {
2508 wxVariant val;
2509 if ((colNo < noCols) && (!IsColNull(colNo)))
2510 {
2511 switch (colDefs[colNo].SqlCtype)
2512 {
2513 case SQL_CHAR:
2514 case SQL_VARCHAR:
2515 val = (wxChar *)(colDefs[colNo].PtrDataObj);
2516 break;
2517 case SQL_C_LONG:
2518 case SQL_C_SLONG:
2519 val = *(long *)(colDefs[colNo].PtrDataObj);
2520 break;
2521 case SQL_C_SHORT:
2522 case SQL_C_SSHORT:
2523 val = (long int )(*(short *)(colDefs[colNo].PtrDataObj));
2524 break;
2525 case SQL_C_ULONG:
2526 val = (long)(*(unsigned long *)(colDefs[colNo].PtrDataObj));
2527 break;
2528 case SQL_C_TINYINT:
2529 val = (long)(*(char *)(colDefs[colNo].PtrDataObj));
2530 break;
2531 case SQL_C_UTINYINT:
2532 val = (long)(*(unsigned char *)(colDefs[colNo].PtrDataObj));
2533 break;
2534 case SQL_C_USHORT:
2535 val = (long)(*(UWORD *)(colDefs[colNo].PtrDataObj));
2536 break;
2537 case SQL_C_DATE:
2538 val = (DATE_STRUCT *)(colDefs[colNo].PtrDataObj);
2539 break;
2540 case SQL_C_TIME:
2541 val = (TIME_STRUCT *)(colDefs[colNo].PtrDataObj);
2542 break;
2543 case SQL_C_TIMESTAMP:
2544 val = (TIMESTAMP_STRUCT *)(colDefs[colNo].PtrDataObj);
2545 break;
2546 case SQL_C_DOUBLE:
2547 val = *(double *)(colDefs[colNo].PtrDataObj);
2548 break;
2549 default:
2550 assert(0);
2551 }
2552 }
2553 return val;
2554 } // wxDbTable::GetCol()
2555
2556
2557 void csstrncpyt(char *s, const char *t, int n)
2558 {
2559 while ((*s++ = *t++) && --n)
2560 {};
2561
2562 *s = '\0';
2563 }
2564
2565 void wxDbTable::SetCol(const int colNo, const wxVariant val)
2566 {
2567 //FIXME: Add proper wxDateTime support to wxVariant..
2568 wxDateTime dateval;
2569
2570 SetColNull(colNo, val.IsNull());
2571
2572 if (!val.IsNull())
2573 {
2574 if ((colDefs[colNo].SqlCtype == SQL_C_DATE)
2575 || (colDefs[colNo].SqlCtype == SQL_C_TIME)
2576 || (colDefs[colNo].SqlCtype == SQL_C_TIMESTAMP))
2577 {
2578 //Returns null if invalid!
2579 if (!dateval.ParseDate(val.GetString()))
2580 SetColNull(colNo, TRUE);
2581 }
2582
2583 switch (colDefs[colNo].SqlCtype)
2584 {
2585 case SQL_CHAR:
2586 case SQL_VARCHAR:
2587 csstrncpyt((char *)(colDefs[colNo].PtrDataObj),
2588 val.GetString().c_str(),
2589 colDefs[colNo].SzDataObj-1);
2590 break;
2591 case SQL_C_LONG:
2592 case SQL_C_SLONG:
2593 *(long *)(colDefs[colNo].PtrDataObj) = val;
2594 break;
2595 case SQL_C_SHORT:
2596 case SQL_C_SSHORT:
2597 *(short *)(colDefs[colNo].PtrDataObj) = val.GetLong();
2598 break;
2599 case SQL_C_ULONG:
2600 *(unsigned long *)(colDefs[colNo].PtrDataObj) = val.GetLong();
2601 break;
2602 case SQL_C_TINYINT:
2603 *(char *)(colDefs[colNo].PtrDataObj) = val.GetChar();
2604 break;
2605 case SQL_C_UTINYINT:
2606 *(unsigned char *)(colDefs[colNo].PtrDataObj) = val.GetChar();
2607 break;
2608 case SQL_C_USHORT:
2609 *(unsigned short *)(colDefs[colNo].PtrDataObj) = val.GetLong();
2610 break;
2611 //FIXME: Add proper wxDateTime support to wxVariant..
2612 case SQL_C_DATE:
2613 {
2614 DATE_STRUCT *dataptr =
2615 (DATE_STRUCT *)colDefs[colNo].PtrDataObj;
2616
2617 dataptr->year = dateval.GetYear();
2618 dataptr->month = dateval.GetMonth()+1;
2619 dataptr->day = dateval.GetDay();
2620 }
2621 break;
2622 case SQL_C_TIME:
2623 {
2624 TIME_STRUCT *dataptr =
2625 (TIME_STRUCT *)colDefs[colNo].PtrDataObj;
2626
2627 dataptr->hour = dateval.GetHour();
2628 dataptr->minute = dateval.GetMinute();
2629 dataptr->second = dateval.GetSecond();
2630 }
2631 break;
2632 case SQL_C_TIMESTAMP:
2633 {
2634 TIMESTAMP_STRUCT *dataptr =
2635 (TIMESTAMP_STRUCT *)colDefs[colNo].PtrDataObj;
2636 dataptr->year = dateval.GetYear();
2637 dataptr->month = dateval.GetMonth()+1;
2638 dataptr->day = dateval.GetDay();
2639
2640 dataptr->hour = dateval.GetHour();
2641 dataptr->minute = dateval.GetMinute();
2642 dataptr->second = dateval.GetSecond();
2643 }
2644 break;
2645 case SQL_C_DOUBLE:
2646 *(double *)(colDefs[colNo].PtrDataObj) = val;
2647 break;
2648 default:
2649 assert(0);
2650 } // switch
2651 } // if (!val.IsNull())
2652 } // wxDbTable::SetCol()
2653
2654
2655 GenericKey wxDbTable::GetKey()
2656 {
2657 void *blk;
2658 wxChar *blkptr;
2659
2660 blk = malloc(m_keysize);
2661 blkptr = (wxChar *) blk;
2662
2663 int i;
2664 for (i=0; i < noCols; i++)
2665 {
2666 if (colDefs[i].KeyField)
2667 {
2668 memcpy(blkptr,colDefs[i].PtrDataObj, colDefs[i].SzDataObj);
2669 blkptr += colDefs[i].SzDataObj;
2670 }
2671 }
2672
2673 GenericKey k = GenericKey(blk, m_keysize);
2674 free(blk);
2675
2676 return k;
2677 } // wxDbTable::GetKey()
2678
2679
2680 void wxDbTable::SetKey(const GenericKey& k)
2681 {
2682 void *blk;
2683 wxChar *blkptr;
2684
2685 blk = k.GetBlk();
2686 blkptr = (wxChar *)blk;
2687
2688 int i;
2689 for (i=0; i < noCols; i++)
2690 {
2691 if (colDefs[i].KeyField)
2692 {
2693 SetColNull(i, FALSE);
2694 memcpy(colDefs[i].PtrDataObj, blkptr, colDefs[i].SzDataObj);
2695 blkptr += colDefs[i].SzDataObj;
2696 }
2697 }
2698 } // wxDbTable::SetKey()
2699
2700
2701 #endif // wxUSE_ODBC
2702
wxWidgets (Impactor)