src/common/odbc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        odbc.cpp
   3 // Purpose:     ODBC implementation
   4 // Author:      Julian Smart, Olaf Klein (oklein@smallo.ruhr.de),
   5 //              Patrick Halke (patrick@zaphod.ruhr.de)
   6 // Modified by:
   7 // Created:     04/01/98
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) Julian Smart and Markus Holzem
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "odbc.h"
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #include "wx/defs.h"
  25
  26 #if wxUSE_ODBC
  27
  28 #ifdef __VISUALC__
  29     #pragma warning(disable:4706)   // assignment within conditional expression
  30 #endif // VC++
  31
  32 #ifndef WX_PRECOMP
  33 #include "wx/utils.h"
  34 #include "wx/dialog.h"
  35 #endif
  36
  37 #include "wx/string.h"
  38 #include "wx/odbc.h"
  39
  40 #include <math.h>
  41 #include <stdlib.h>
  42
  43 #if defined(__WXMSW__) && !defined(__WIN32__)
  44 #include <print.h>
  45 #endif
  46
  47 HENV wxDatabase::hEnv = 0;
  48 int wxDatabase::refCount = 0;
  49
  50 #if !USE_SHARED_LIBRARY
  51 IMPLEMENT_DYNAMIC_CLASS(wxDatabase, wxObject)
  52 IMPLEMENT_DYNAMIC_CLASS(wxQueryCol, wxObject)
  53 IMPLEMENT_DYNAMIC_CLASS(wxQueryField, wxObject)
  54 IMPLEMENT_DYNAMIC_CLASS(wxRecordSet, wxObject)
  55 #endif
  56
  57 wxDatabase::wxDatabase(void)
  58 {
  59   hDBC = 0;
  60   username = NULL;
  61   password = NULL;
  62   datasource = NULL;
  63   dbname = NULL;
  64   connectstring = NULL;
  65   isOpen = FALSE;
  66   refCount ++;
  67   retcode = 0;
  68   username = NULL;
  69   password = NULL;
  70   err_occured = FALSE;
  71
  72   memset(sqlstate, 0, sizeof sqlstate);
  73   memset(errmsg, 0, sizeof errmsg);
  74
  75   if (hEnv == 0)
  76   {
  77     retcode = SQLAllocEnv(&hEnv);
  78
  79     if (retcode != SQL_SUCCESS)
  80       hEnv = 0;
  81   }
  82 }
  83
  84 wxDatabase::~wxDatabase(void)
  85 {
  86   Close();
  87   DeleteRecordSets(); // Added JACS
  88
  89   if (connectstring)
  90     delete[] connectstring;
  91   if (datasource)
  92     delete[] datasource;
  93   if (username)
  94     delete[] username;
  95   if (password)
  96     delete[] password;
  97   if (dbname)
  98     delete[] dbname;
  99
 100   refCount --;
 101   if (!refCount && hEnv)
 102   {
 103     retcode = SQLFreeEnv(hEnv);
 104     hEnv = 0; // JACS 17/6
 105   }
 106 }
 107
 108 void wxDatabase::ErrorSnapshot(HSTMT hstmt)
 109 {
 110   SWORD len = 0; // JACS: sometimes doesn't get filled in by SQLError.
 111
 112   err_occured = TRUE;
 113   SQLError(hEnv, hDBC, hstmt, (unsigned char *)sqlstate, &nat_err, (unsigned char *)errmsg, SQL_MAX_MESSAGE_LENGTH-1, &len);
 114   errmsg[len] = '\0';
 115 }
 116
 117 bool wxDatabase::ErrorOccured(void)
 118 {
 119   return err_occured;
 120 }
 121
 122 char* wxDatabase::GetErrorMessage(void)
 123 {
 124   return errmsg;
 125 }
 126
 127 long wxDatabase::GetErrorNumber(void)
 128 {
 129   return nat_err;
 130 }
 131
 132 char* wxDatabase::GetErrorClass(void) {
 133   return sqlstate;
 134 }
 135
 136 bool wxDatabase::Open(char *thedatasource, bool WXUNUSED(exclusive),
 137   bool WXUNUSED(readOnly), char *username, char *password)
 138 {
 139   err_occured = FALSE;
 140
 141   if (isOpen)
 142     return FALSE;
 143
 144   SetUsername(username);
 145   SetPassword(password);
 146   SetDataSource(thedatasource);
 147
 148   if (!hEnv)
 149     return FALSE;
 150
 151   retcode = SQLAllocConnect(hEnv, &hDBC);
 152   if (retcode != SQL_SUCCESS) {
 153     hDBC = 0;
 154     return FALSE;
 155   }
 156
 157   retcode = SQLConnect(hDBC, (UCHAR FAR*)thedatasource, strlen(thedatasource), (UCHAR FAR*)username, strlen(username),
 158                        (UCHAR FAR*)password, strlen(password));
 159
 160   if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
 161     ErrorSnapshot();
 162     return FALSE;
 163   }
 164
 165   isOpen = TRUE;
 166
 167   return TRUE;
 168 }
 169
 170 bool wxDatabase::Close(void)
 171 {
 172   // JACS: make sure the record set statements are all released.
 173   ResetRecordSets();
 174
 175   err_occured = FALSE;
 176   if (hDBC != 0)
 177   {
 178     retcode = SQLDisconnect(hDBC);
 179
 180     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
 181       ErrorSnapshot();
 182       return FALSE;
 183     }
 184
 185     retcode = SQLFreeConnect(hDBC);
 186
 187     hDBC = 0;
 188     isOpen = FALSE;
 189
 190     return TRUE;
 191   }
 192
 193   return FALSE;
 194 }
 195
 196 // Database attributes
 197 char *wxDatabase::GetDatabaseName(void)
 198 {
 199   err_occured = FALSE;
 200   if (hDBC == 0)
 201     return NULL;
 202
 203   char nameBuf[400];
 204   int nameSize = 0;
 205
 206   retcode = SQLGetInfo(hDBC, SQL_DATABASE_NAME, (unsigned char*)nameBuf, sizeof(nameBuf), (short *)&nameSize);
 207
 208   if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
 209     return NULL;
 210
 211   delete[] dbname;
 212   dbname = NULL;
 213
 214   if (nameSize > 0)
 215   {
 216     dbname = copystring(nameBuf);
 217     return dbname;
 218   }
 219   else
 220     return NULL;
 221 }
 222
 223 bool wxDatabase::CanUpdate(void)
 224 {
 225   return FALSE;
 226 }
 227
 228 bool wxDatabase::CanTransact(void)
 229 {
 230   return FALSE;
 231 }
 232
 233 bool wxDatabase::InWaitForDataSource(void)
 234 {
 235   return FALSE;
 236 }
 237
 238 void wxDatabase::SetLoginTimeout(long WXUNUSED(seconds))
 239 {
 240 }
 241
 242 void wxDatabase::SetQueryTimeout(long WXUNUSED(seconds))
 243 {
 244 }
 245
 246 void wxDatabase::SetSynchronousMode(bool WXUNUSED(synchronous))
 247 {
 248 }
 249
 250 // Database operations
 251 bool wxDatabase::BeginTrans(void)
 252 {
 253   return FALSE;
 254 }
 255
 256 bool wxDatabase::CommitTrans(void)
 257 {
 258   return FALSE;
 259 }
 260
 261 bool wxDatabase::RollbackTrans(void)
 262 {
 263   return FALSE;
 264 }
 265
 266 void wxDatabase::Cancel(void)
 267 {
 268 }
 269
 270 // Overridables
 271 void wxDatabase::OnSetOptions(wxRecordSet *WXUNUSED(recordSet))
 272 {
 273 }
 274
 275 void wxDatabase::OnWaitForDataSource(bool WXUNUSED(stillExecuting))
 276 {
 277 }
 278
 279 void wxDatabase::SetPassword(char *s)
 280 {
 281   if (password)
 282     delete[] password;
 283   if (s)
 284   {
 285     password = copystring(s);
 286   }
 287   else
 288     password = NULL;
 289 }
 290
 291 void wxDatabase::SetUsername(char *s)
 292 {
 293   delete[] username;
 294
 295   if (s)
 296     username = copystring(s);
 297   else
 298     username = NULL;
 299 }
 300
 301 void wxDatabase::SetDataSource(char *s)
 302 {
 303   delete[] datasource;
 304
 305   if (s)
 306     datasource = copystring(s);
 307   else
 308     datasource = NULL;
 309 }
 310
 311 /*
 312  * Added by JACS
 313  */
 314
 315 void wxDatabase::DeleteRecordSets(void)
 316 {
 317   wxNode *node = recordSets.First();
 318   while (node)
 319   {
 320     wxNode *next = node->Next();
 321     wxRecordSet *rec = (wxRecordSet *)node->Data();
 322     delete rec;
 323     // The node is implicitly deleted by ~wxRecordSet
 324     node = next;
 325   }
 326 }
 327
 328 void wxDatabase::ResetRecordSets(void)
 329 {
 330   wxNode *node = recordSets.First();
 331   while (node)
 332   {
 333     wxRecordSet *rec = (wxRecordSet *)node->Data();
 334     rec->ReleaseHandle();
 335
 336     node = node->Next();
 337   }
 338 }
 339
 340 bool wxDatabase::GetInfo(long infoType, long *buf)
 341 {
 342   short sz = 0;
 343   retcode = SQLGetInfo(hDBC, (UWORD)infoType, (unsigned char*)buf, sizeof(buf), &sz);
 344
 345   if (retcode != SQL_ERROR)
 346     return TRUE;
 347   else
 348     return FALSE;
 349 }
 350
 351 bool wxDatabase::GetInfo(long infoType, char *buf, int bufSize)
 352 {
 353   if (bufSize == -1)
 354     bufSize = sizeof(buf);
 355
 356   short sz = 0;
 357   retcode = SQLGetInfo(hDBC, (UWORD)infoType, (unsigned char*)buf, bufSize, &sz);
 358
 359   if (retcode != SQL_ERROR)
 360     return TRUE;
 361   else
 362     return FALSE;
 363 }
 364
 365 wxString wxDatabase::GetODBCVersionString(bool implementation)
 366 {
 367   char buf[50];
 368   if (!implementation)
 369   {
 370 #ifdef SQL_SPEC_MAJOR
 371     sprintf(buf, "%d%d.%d", (int)(SQL_SPEC_MAJOR/10), (int)(SQL_SPEC_MAJOR - (((int)(SQL_SPEC_MAJOR/10))*10)),
 372              SQL_SPEC_MINOR);
 373     return wxString(buf);
 374 #else
 375     return wxString("00.00");
 376 #endif
 377   }
 378
 379   bool noDBC = FALSE;
 380   if (hDBC == 0)
 381   {
 382     noDBC = TRUE;
 383     retcode = SQLAllocConnect(hEnv, &hDBC);
 384     if (retcode != SQL_SUCCESS)
 385     {
 386       hDBC = 0;
 387       return wxString("00.00");
 388     }
 389   }
 390
 391   int bufSize = sizeof(buf);
 392
 393   short sz = 0;
 394   retcode = SQLGetInfo(hDBC, (UWORD)SQL_ODBC_VER, (unsigned char*)buf, bufSize, &sz);
 395
 396   if (hDBC != 0 && noDBC)
 397   {
 398     retcode = SQLFreeConnect(hDBC);
 399     hDBC = 0;
 400   }
 401
 402   if (retcode == SQL_ERROR)
 403     return wxString("");
 404   else
 405     return wxString(buf);
 406 }
 407
 408 float wxDatabase::GetODBCVersionFloat(bool implementation)
 409 {
 410   if (!implementation)
 411   {
 412 #ifdef SQL_SPEC_MAJOR
 413     return (float)(SQL_SPEC_MAJOR + (SQL_SPEC_MINOR/100.0));
 414 #else
 415     return 0.0;
 416 #endif
 417   }
 418
 419   bool noDBC = FALSE;
 420   if (hDBC == 0)
 421   {
 422     noDBC = TRUE;
 423     retcode = SQLAllocConnect(hEnv, &hDBC);
 424     if (retcode != SQL_SUCCESS)
 425     {
 426       hDBC = 0;
 427       return (float)0.0;
 428     }
 429   }
 430
 431   char buf[50];
 432   int bufSize = sizeof(buf);
 433
 434   short sz = 0;
 435   retcode = SQLGetInfo(hDBC, (UWORD)SQL_ODBC_VER, (unsigned char*)buf, bufSize, &sz);
 436
 437   if (hDBC != 0 && noDBC)
 438   {
 439     retcode = SQLFreeConnect(hDBC);
 440     hDBC = 0;
 441   }
 442
 443   if (retcode == SQL_ERROR)
 444     return 0.0;
 445   else
 446     return atof(buf);
 447 }
 448
 449 /*
 450  * wxRecordSet
 451  */
 452
 453 wxRecordSet::wxRecordSet(wxDatabase *db, int typ, int opt):
 454     cols(wxKEY_STRING)
 455 {
 456   parentdb = db;
 457   hStmt = 0;
 458   nFields = 0;
 459   nParams = 0;
 460   recordFilter = NULL;
 461   sortString = NULL;
 462   retcode = 0;
 463   cursor = 0;
 464   tablename = NULL;
 465   nCols = 0;
 466   nRecords = 0;
 467
 468   type = typ;
 469   options = opt;
 470
 471   // Added JACS
 472   if (parentdb)
 473     parentdb->GetRecordSets().Append(this);
 474 }
 475
 476 wxRecordSet::~wxRecordSet(void)
 477 {
 478   ReleaseHandle();
 479
 480   // JACS
 481   if (parentdb)
 482     parentdb->GetRecordSets().DeleteObject(this);
 483
 484   if (recordFilter)
 485     delete[] recordFilter;
 486   if (sortString)
 487     delete[] sortString;
 488   if (tablename)
 489     delete[] tablename;
 490 }
 491
 492 // If SQL is non-NULL, table and columns can be NULL.
 493 bool wxRecordSet::BeginQuery(int WXUNUSED(openType), char *WXUNUSED(sql), int WXUNUSED(options))
 494 {
 495   // Needs to construct an appropriate SQL statement. By default
 496   // (i.e. if table and columns are provided) then
 497   // SELECT <columns> FROM <table>
 498   // will be used.
 499   if (!parentdb)
 500     return FALSE;
 501   if (!parentdb->GetHDBC())
 502     return FALSE;
 503
 504   if (hStmt)
 505   {
 506     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 507     if (retcode == SQL_ERROR)
 508     {
 509       parentdb->ErrorSnapshot(hStmt);
 510       return FALSE;
 511     }
 512     hStmt = 0;
 513   }
 514
 515   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 516   if (retcode != SQL_SUCCESS)
 517     return FALSE;
 518
 519   return TRUE;
 520 }
 521
 522 bool wxRecordSet::Query(char *columns, char *table, char *filter)
 523 {
 524   // Needs to construct an appropriate SQL statement. By default
 525   // (i.e. if table and columns are provided) then
 526   // SELECT <columns> FROM <table>
 527   // will be used.
 528
 529   char* thetable = table ? table : tablename;
 530
 531   if (!thetable)
 532     return FALSE;
 533   if (!columns)
 534     return FALSE;
 535
 536   wxString query;
 537
 538   query += "SELECT ";
 539   query += columns;
 540   query += " FROM ";
 541   query += thetable;
 542
 543   if (filter)  {
 544     query += " WHERE ";
 545     query += filter;
 546   }
 547   retcode = SQLPrepare(hStmt, (UCHAR FAR *)query.GetData(), strlen(query.GetData()));
 548   if (retcode != SQL_SUCCESS) {
 549     parentdb->ErrorSnapshot(hStmt);
 550     return FALSE;
 551   }
 552
 553   retcode = SQLExecute(hStmt);
 554
 555   if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
 556     parentdb->ErrorSnapshot(hStmt);
 557     return FALSE;
 558   }
 559
 560   return TRUE;
 561 }
 562
 563 bool wxRecordSet::EndQuery(void)
 564 {
 565   return TRUE;
 566 }
 567
 568 void wxRecordSet::FillVars(int recnum) {
 569   wxNode* node = cols.First();
 570
 571   do {
 572     ((wxQueryCol*)node->Data())->FillVar(recnum);
 573   } while ((node = node->Next()));
 574 }
 575
 576 bool wxRecordSet::GetResultSet(void)
 577 {
 578 //  long trash = SQL_NULL_DATA; // value added by JACS
 579   long trash;
 580                // contains the number of bytes transferred by SQLFetch()
 581                // who needs this ?
 582   wxNode *currow, *fetch, *curcol;
 583
 584   retcode = SQLNumResultCols(hStmt, &nCols);
 585
 586   if (!nCols)
 587     return TRUE;
 588
 589   // delete old data first
 590   cols.DeleteContents(TRUE);
 591   cols.Clear();
 592   fetchbuf.DeleteContents(TRUE);
 593   fetchbuf.Clear();
 594
 595   nRecords = 0;
 596   cursor = 0;
 597
 598   int i;
 599   for (i=0; i<nCols; i++) {
 600     char name[512];
 601     short type, scale, nullable, namelen;
 602     unsigned long len;
 603
 604     retcode = SQLDescribeCol(hStmt, i+1, (unsigned char *)name, 511, &namelen, &type, &len, &scale, &nullable);
 605     if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 606       parentdb->ErrorSnapshot(hStmt);
 607       return FALSE;
 608     }
 609
 610     wxQueryCol *col1 = new wxQueryCol;
 611     curcol = cols.Append(name, col1);
 612     col1->SetName(name);
 613     col1->SetType(type);
 614     col1->SetNullable((nullable != 0));
 615
 616     wxQueryField *field1 = new wxQueryField;
 617     fetch = fetchbuf.Append(field1);
 618     field1->SetType(type);
 619     field1->SetSize(len);
 620
 621     SQLBindCol(hStmt, i+1, SQL_C_BINARY, (unsigned char*)field1->GetData(), field1->GetSize(), &trash);
 622   }
 623
 624   switch (type) {
 625     case wxOPEN_TYPE_SNAPSHOT:
 626     // get it all !
 627     // After we've done an SQLFetch, copy the data in the fetch buffer into
 628     // new fields, for each column.
 629     while (SQL_SUCCESS == (retcode = SQLFetch(hStmt)) || SQL_SUCCESS_WITH_INFO == retcode) {
 630       nRecords++;
 631
 632       curcol = cols.First();
 633       fetch = fetchbuf.First();
 634       for (i=0; i<nCols; i++) {
 635
 636         wxQueryField *fetchField = (wxQueryField *)fetch->Data();
 637         wxQueryCol *col = (wxQueryCol *)curcol->Data();
 638         wxQueryField *field = new wxQueryField;
 639
 640         currow = col->fields.Append(field);
 641
 642         field->SetType(fetchField->GetType());
 643         field->SetData(fetchField->GetData(), fetchField->GetSize());
 644         curcol = curcol->Next();
 645         fetchField->ClearData(); // Runs ok if this commented out and SetData commented out
 646         fetch = fetch->Next();
 647       }
 648     }
 649     // while loop should only be left, when no more data was found;
 650     // otherwise it seems, that there was an error
 651     if (SQL_NO_DATA_FOUND != retcode) {
 652       parentdb->ErrorSnapshot(hStmt);
 653       return FALSE;
 654     }
 655     break;
 656     case wxOPEN_TYPE_DYNASET:
 657     // get first record only
 658     if (SQL_SUCCESS == (retcode = SQLFetch(hStmt)) || retcode == SQL_SUCCESS_WITH_INFO) {
 659       nRecords = 1;  // TO DO! # of records in the ODBC result set should be set here.
 660
 661       curcol = cols.First();
 662       fetch = fetchbuf.First();
 663       for (i=0; i<nCols; i++) {
 664         currow = ((wxQueryCol*)curcol->Data())->fields.Append(new wxQueryField);
 665
 666         ((wxQueryField*)currow->Data())->SetType(((wxQueryField*)fetch->Data())->GetType());
 667         ((wxQueryField*)currow->Data())->SetData(((wxQueryField*)fetch->Data())->GetData(), ((wxQueryField*)fetch->Data())->GetSize());
 668         curcol = curcol->Next();
 669         ((wxQueryField*)fetch->Data())->ClearData();
 670         fetch = fetch->Next();
 671       }
 672     }
 673     if (SQL_NO_DATA_FOUND != retcode) {
 674       parentdb->ErrorSnapshot(hStmt);
 675       return FALSE;
 676     }
 677     break;
 678     default:
 679     return FALSE;
 680   }
 681
 682   FillVars(0);
 683
 684   return TRUE;
 685 }
 686
 687 bool wxRecordSet::ExecuteSQL(char *sql)
 688 {
 689   if (hStmt)
 690   {
 691     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 692     if (retcode == SQL_ERROR)
 693     {
 694       parentdb->ErrorSnapshot(hStmt);
 695       return FALSE;
 696     }
 697     hStmt = NULL;
 698   }
 699
 700   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 701
 702   if (SQL_SUCCESS != retcode) {
 703     parentdb->ErrorSnapshot(hStmt);
 704     return FALSE;
 705   }
 706
 707   retcode = SQLExecDirect(hStmt, (UCHAR FAR*)sql, SQL_NTS);
 708
 709   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 710     parentdb->ErrorSnapshot(hStmt);
 711     return FALSE;
 712   }
 713
 714   return GetResultSet();
 715 }
 716
 717 bool wxRecordSet::GetDataSources(void) {
 718
 719   char *dsname = "Name", *dsdesc = "Description";
 720   char namebuf[64];
 721   char descbuf[512];
 722   short namelen, desclen;
 723
 724   cursor = 0;
 725
 726   // delete old data first
 727   cols.DeleteContents(TRUE);
 728   cols.Clear();
 729   nRecords = 0;
 730
 731   // JACS This is a snapshot, not a dynaset.
 732   type = wxOPEN_TYPE_SNAPSHOT;
 733
 734   wxNode *namecol, *desccol;
 735
 736   namecol = cols.Append(dsname, new wxQueryCol);
 737   ((wxQueryCol*)namecol->Data())->SetName(dsname);
 738   ((wxQueryCol*)namecol->Data())->SetType(SQL_CHAR);
 739   desccol = cols.Append(dsdesc, new wxQueryCol);
 740   ((wxQueryCol*)desccol->Data())->SetName(dsdesc);
 741   ((wxQueryCol*)desccol->Data())->SetType(SQL_CHAR);
 742
 743   retcode = SQLDataSources(parentdb->GetHENV(), SQL_FETCH_FIRST, (unsigned char *)namebuf, 63, &namelen, (unsigned char *)descbuf, 511, &desclen);
 744   while (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
 745     nRecords++;
 746     ((wxQueryCol*)namecol->Data())->AppendField(namebuf, namelen);
 747     ((wxQueryCol*)desccol->Data())->AppendField(descbuf, desclen);
 748     retcode = SQLDataSources(parentdb->GetHENV(), SQL_FETCH_NEXT, (unsigned char *)namebuf, 63, &namelen, (unsigned char *)descbuf, 511, &desclen);
 749   }
 750
 751   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode && SQL_NO_DATA_FOUND != retcode)  {
 752     parentdb->ErrorSnapshot();
 753     return FALSE;
 754   }
 755
 756   cursor = 0;
 757
 758   return TRUE;
 759 }
 760
 761 // Attributes
 762 void wxRecordSet::SetTableName(char* name) {
 763   delete[] tablename;
 764   tablename = NULL;
 765
 766   if (name)
 767     tablename = copystring(name);
 768 }
 769
 770 bool wxRecordSet::GetTables(void)
 771 {
 772   if (hStmt)
 773   {
 774     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 775     if (retcode == SQL_ERROR)
 776     {
 777       parentdb->ErrorSnapshot(hStmt);
 778       return FALSE;
 779     }
 780
 781     hStmt = NULL;
 782   }
 783
 784   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 785
 786   if (SQL_SUCCESS != retcode) {
 787     parentdb->ErrorSnapshot();
 788     return FALSE;
 789   }
 790
 791   retcode = SQLTables(hStmt, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 792
 793   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 794     parentdb->ErrorSnapshot(hStmt);
 795     return FALSE;
 796   }
 797
 798   return GetResultSet();
 799 }
 800
 801 bool wxRecordSet::GetColumns(char* table)
 802 {
 803   char* name=NULL;
 804 //  char* wildcard = "%";
 805
 806   name = table ? table : tablename;
 807
 808   if (!name)
 809     return FALSE;
 810
 811   if (hStmt)
 812   {
 813     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 814     if (retcode == SQL_ERROR)
 815     {
 816       parentdb->ErrorSnapshot(hStmt);
 817       return FALSE;
 818     }
 819     hStmt = NULL;
 820   }
 821
 822   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 823
 824   if (SQL_SUCCESS != retcode) {
 825     parentdb->ErrorSnapshot();
 826     return FALSE;
 827   }
 828
 829   //retcode = SQLColumns(hstmt, (unsigned char*)parentdb->GetDataSource(), strlen(parentdb->GetDataSource()), wildcard, 1, name, strlen(name), wildcard, 1);
 830   retcode = SQLColumns(hStmt, NULL, 0, NULL, 0, (unsigned char *)name, strlen(name), NULL, 0);
 831
 832   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 833     parentdb->ErrorSnapshot(hStmt);
 834     return FALSE;
 835   }
 836
 837   return GetResultSet();
 838 }
 839
 840 // It is derived from previous GetColumns
 841 bool wxRecordSet::GetPrimaryKeys(char* table)
 842 {
 843   char* name=NULL;
 844 //  char* wildcard = "%";
 845
 846   name = table ? table : tablename;
 847
 848   if (!name)
 849     return FALSE;
 850
 851   if (hStmt)
 852   {
 853     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 854     if (retcode == SQL_ERROR)
 855     {
 856       parentdb->ErrorSnapshot(hStmt);
 857       return FALSE;
 858     }
 859     hStmt = NULL;
 860   }
 861
 862   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 863
 864   if (SQL_SUCCESS != retcode) {
 865     parentdb->ErrorSnapshot();
 866     return FALSE;
 867   }
 868
 869   retcode = SQLPrimaryKeys(hStmt, NULL, 0, NULL, 0, (unsigned char *)name, SQL_NTS);
 870
 871   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 872     parentdb->ErrorSnapshot(hStmt);
 873     return FALSE;
 874   }
 875
 876   return GetResultSet();
 877 }
 878
 879 bool wxRecordSet::GetForeignKeys(char* PkTableName, char * FkTableName)
 880 {
 881   char* Pkname=NULL;
 882   char* Fkname=NULL;
 883 //  char* wildcard = "%";
 884
 885 // Try to disable situation: both PkTableName and FkTableName are NULL
 886 //   set Pkname from tablename
 887   if( !PkTableName && !FkTableName ) {
 888      Pkname = PkTableName ? PkTableName : tablename;
 889      Fkname = FkTableName ;
 890      if (!Pkname )
 891        return FALSE;
 892   } else {
 893      Pkname = PkTableName ;
 894      Fkname = FkTableName ;
 895   }
 896
 897   if (hStmt)
 898   {
 899     retcode = SQLFreeStmt(hStmt, SQL_DROP);
 900     if (retcode == SQL_ERROR)
 901     {
 902       parentdb->ErrorSnapshot(hStmt);
 903       return FALSE;
 904     }
 905     hStmt = NULL;
 906   }
 907
 908   retcode = SQLAllocStmt(parentdb->GetHDBC(), &hStmt);
 909
 910   if (SQL_SUCCESS != retcode) {
 911     parentdb->ErrorSnapshot();
 912     return FALSE;
 913   }
 914
 915   retcode = SQLForeignKeys(hStmt, NULL, 0, NULL, 0, (unsigned char *)Pkname,
 916     (Pkname ? SQL_NTS : 0), NULL, 0, NULL, 0, (unsigned char *)Fkname ,(Fkname ?SQL_NTS : 0) );
 917
 918   if (SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode)  {
 919     parentdb->ErrorSnapshot(hStmt);
 920     return FALSE;
 921   }
 922
 923   return GetResultSet();
 924 }
 925
 926 long wxRecordSet::GetNumberRecords(void)
 927 {
 928   return nRecords;
 929 }
 930
 931 long wxRecordSet::GetNumberCols(void)
 932 {
 933   return nCols;
 934 }
 935
 936 char* wxRecordSet::GetColName(int col)
 937 {
 938   wxNode* node = cols.Nth(col);
 939
 940   if (!node)
 941     return NULL;
 942
 943   return ((wxQueryCol*)node->Data())->GetName();
 944 }
 945
 946 short wxRecordSet::GetColType(int col)
 947 {
 948   wxNode* node = cols.Nth(col);
 949
 950   if (!node)
 951     return SQL_TYPE_NULL;
 952
 953   return ((wxQueryCol*)node->Data())->GetType();
 954 }
 955
 956 short wxRecordSet::GetColType(const char *col)
 957 {
 958   wxNode* node = cols.Find(col);
 959
 960   if (!node)
 961     return SQL_TYPE_NULL;
 962
 963   return ((wxQueryCol*)node->Data())->GetType();
 964 }
 965
 966 bool wxRecordSet::GetFieldData(int col, int type, void* data)
 967 {
 968   wxNode* node = cols.Nth(col);
 969
 970   if (!node)
 971     return FALSE;
 972
 973   if (((wxQueryCol*)node->Data())->GetType() != type)
 974     return FALSE;
 975
 976   void* src = ((wxQueryCol*)node->Data())->GetData(cursor);
 977
 978   if (!src)
 979     return FALSE;
 980
 981   memcpy(data, src, ((wxQueryCol*)node->Data())->GetSize(cursor));
 982
 983   return TRUE;
 984 }
 985
 986 bool wxRecordSet::GetFieldData(const char* name, int type, void *data)
 987 {
 988   wxNode* node = cols.Find(name);
 989
 990   if (!node)
 991     return FALSE;
 992
 993   if (((wxQueryCol*)node->Data())->GetType() != type)
 994     return FALSE;
 995
 996   void* src = ((wxQueryCol*)node->Data())->GetData(cursor);
 997
 998   if (!src)
 999     return FALSE;
1000
1001   memcpy(data, src, ((wxQueryCol*)node->Data())->GetSize(cursor));
1002
1003   return TRUE;
1004 }
1005
1006 void* wxRecordSet::GetFieldDataPtr(int col, int type)
1007 {
1008   wxNode* node = cols.Nth(col);
1009
1010   if (!node)
1011     return NULL;
1012
1013   if (((wxQueryCol*)node->Data())->GetType() != type)
1014     return NULL;
1015
1016   return ((wxQueryCol*)node->Data())->GetData(cursor);
1017 }
1018
1019 void* wxRecordSet::GetFieldDataPtr(const char* name, int type)
1020 {
1021   wxNode* node = cols.Find(name);
1022
1023   if (!node)
1024     return NULL;
1025
1026   if (((wxQueryCol*)node->Data())->GetType() != type)
1027     return NULL;
1028
1029   return ((wxQueryCol*)node->Data())->GetData(cursor);
1030 }
1031
1032 void* wxRecordSet::BindVar(int col, void* var, long size) {
1033   wxNode* node = cols.Nth(col);
1034
1035   if (!node)
1036     return NULL;
1037
1038   return ((wxQueryCol*)node->Data())->BindVar(var, size);
1039 }
1040
1041 void* wxRecordSet::BindVar(const char* name, void* var, long size) {
1042   wxNode* node = cols.Find(name);
1043
1044   if (!node)
1045     return NULL;
1046
1047   return ((wxQueryCol*)node->Data())->BindVar(var, size);
1048 }
1049
1050 void wxRecordSet::SetType(int typ) {
1051   type = typ;
1052 }
1053
1054 int wxRecordSet::GetType(void) {
1055   return type;
1056 }
1057
1058 void wxRecordSet::SetOptions(int opts) {
1059   options = opts;
1060 }
1061
1062 int wxRecordSet::GetOptions(void) {
1063   return options;
1064 }
1065
1066 bool wxRecordSet::CanAppend(void)
1067 {
1068   return FALSE;
1069 }
1070
1071 bool wxRecordSet::CanRestart(void)
1072 {
1073   return FALSE;
1074 }
1075
1076 bool wxRecordSet::CanScroll(void)
1077 {
1078   return FALSE;
1079 }
1080
1081 bool wxRecordSet::CanTransact(void)
1082 {
1083   return FALSE;
1084 }
1085
1086 bool wxRecordSet::CanUpdate(void)
1087 {
1088   return FALSE;
1089 }
1090
1091 long wxRecordSet::GetCurrentRecord(void)
1092 {
1093   return -1L;
1094 }
1095
1096 bool wxRecordSet::RecordCountFinal(void)
1097 {
1098   return FALSE;
1099 }
1100
1101 char* wxRecordSet::GetTableName(void)
1102 {
1103   return tablename;
1104 }
1105
1106 char *wxRecordSet::GetSQL(void)
1107 {
1108   return NULL;
1109 }
1110
1111 bool wxRecordSet::IsOpen(void)
1112 {
1113   return parentdb->IsOpen();
1114 }
1115
1116 bool wxRecordSet::IsBOF(void)
1117 {
1118   return cursor < 0;
1119 }
1120
1121 bool wxRecordSet::IsEOF(void)
1122 {
1123   return cursor >= nRecords;
1124 }
1125
1126 bool wxRecordSet::IsDeleted(void)
1127 {
1128   return FALSE;
1129 }
1130
1131 // Update operations
1132 void wxRecordSet::AddNew(void)
1133 {
1134 }
1135
1136 bool wxRecordSet::Delete(void)
1137 {
1138   return FALSE;
1139 }
1140
1141 void wxRecordSet::Edit(void)
1142 {
1143 }
1144
1145 bool wxRecordSet::Update(void)
1146 {
1147   return FALSE;
1148 }
1149
1150 // Record navigation
1151 bool wxRecordSet::Move(long rows)
1152 {
1153   if (!nRecords) {
1154     cursor = -1;
1155     return FALSE;
1156   }
1157
1158   switch (type) {
1159     case wxOPEN_TYPE_SNAPSHOT:
1160     cursor += (int)rows;
1161     if (cursor < 0) {
1162       cursor = -1;
1163       return FALSE;
1164     }
1165     if (cursor > nRecords-1) {
1166       cursor = nRecords;
1167       return FALSE;
1168     }
1169     return TRUE;
1170
1171     case wxOPEN_TYPE_DYNASET:
1172     return FALSE;
1173     default:
1174     return FALSE;
1175   }
1176 }
1177
1178 bool wxRecordSet::GoTo(long row)
1179 {
1180   if (!nRecords) {
1181     cursor = -1;
1182     return FALSE;
1183   }
1184
1185   switch (type) {
1186     case wxOPEN_TYPE_SNAPSHOT:
1187     cursor = (int)row;
1188     if (cursor < 0) {
1189       cursor = -1;
1190       return FALSE;
1191     }
1192     if (cursor > nRecords-1) {
1193       cursor = nRecords;
1194       return FALSE;
1195     }
1196     return TRUE;
1197
1198     case wxOPEN_TYPE_DYNASET:
1199     return FALSE;
1200     default:
1201     return FALSE;
1202   }
1203 }
1204
1205 bool wxRecordSet::MoveFirst(void)
1206 {
1207   if (!nRecords) {
1208     cursor = -1;
1209     return FALSE;
1210   }
1211
1212   switch (type) {
1213     case wxOPEN_TYPE_SNAPSHOT:
1214     cursor = 0;
1215     return TRUE;
1216
1217     case wxOPEN_TYPE_DYNASET:
1218     return FALSE;
1219     default:
1220     return FALSE;
1221   }
1222 }
1223
1224 bool wxRecordSet::MoveLast(void)
1225 {
1226   if (!nRecords) {
1227     cursor = -1;
1228     return FALSE;
1229   }
1230
1231   switch (type) {
1232     case wxOPEN_TYPE_SNAPSHOT:
1233     cursor = nRecords-1;
1234     return TRUE;
1235
1236     case wxOPEN_TYPE_DYNASET:
1237     return FALSE;
1238     default:
1239     return FALSE;
1240   }
1241 }
1242
1243 bool wxRecordSet::MoveNext(void)
1244 {
1245   if (!nRecords) {
1246     cursor = -1;
1247     return FALSE;
1248   }
1249
1250   switch (type) {
1251     case wxOPEN_TYPE_SNAPSHOT:
1252     cursor++;
1253     if (cursor >= nRecords) {
1254       cursor = nRecords;
1255       return FALSE;
1256     }
1257     return TRUE;
1258
1259     case wxOPEN_TYPE_DYNASET:
1260     return FALSE;
1261     default:
1262     return FALSE;
1263   }
1264 }
1265
1266 bool wxRecordSet::MovePrev(void)
1267 {
1268   if (!nRecords) {
1269     cursor = -1;
1270     return FALSE;
1271   }
1272
1273   switch (type) {
1274     case wxOPEN_TYPE_SNAPSHOT:
1275     cursor--;
1276     if (cursor < 0) {
1277       cursor = 0;
1278       return FALSE;
1279     }
1280     return TRUE;
1281
1282     case wxOPEN_TYPE_DYNASET:
1283     return FALSE;
1284     default:
1285     return FALSE;
1286   }
1287 }
1288
1289 // Others
1290 void wxRecordSet::Cancel(void)
1291 {
1292 }
1293
1294 bool wxRecordSet::IsFieldDirty(int col)
1295 {
1296   wxNode* node = cols.Nth(col);
1297
1298   if (!node)
1299     return FALSE;
1300
1301   return ((wxQueryCol*)node->Data())->IsFieldDirty(cursor);
1302 }
1303
1304 bool wxRecordSet::IsFieldDirty(const char* name)
1305 {
1306   wxNode* node = cols.Find(name);
1307
1308   if (!node)
1309     return FALSE;
1310
1311   return ((wxQueryCol*)node->Data())->IsFieldDirty(cursor);
1312 }
1313
1314 bool wxRecordSet::IsFieldNull(int col)
1315 {
1316   wxNode* node = cols.Nth(col);
1317
1318   if (!node)
1319     return TRUE;
1320
1321   return NULL != ((wxQueryCol*)node->Data())->GetData(cursor);
1322 }
1323
1324 bool wxRecordSet::IsFieldNull(const char* name)
1325 {
1326   wxNode* node = cols.Find(name);
1327
1328   if (!node)
1329     return TRUE;
1330
1331   return NULL != ((wxQueryCol*)node->Data())->GetData(cursor);
1332 }
1333
1334 bool wxRecordSet::IsColNullable(int col)
1335 {
1336   wxNode* node = cols.Nth(col);
1337
1338   if (!node)
1339     return FALSE;
1340
1341   return ((wxQueryCol*)node->Data())->IsNullable();
1342 }
1343
1344 bool wxRecordSet::IsColNullable(const char* name)
1345 {
1346   wxNode* node = cols.Find(name);
1347
1348   if (!node)
1349     return FALSE;
1350
1351   return ((wxQueryCol*)node->Data())->IsNullable();
1352 }
1353
1354 bool wxRecordSet::Requery(void)
1355 {
1356   return FALSE;
1357 }
1358
1359 void wxRecordSet::SetFieldDirty(int col, bool dirty)
1360 {
1361   wxNode* node = cols.Nth(col);
1362
1363   if (!node)
1364     return;
1365
1366   ((wxQueryCol*)node->Data())->SetFieldDirty(cursor, dirty);
1367 }
1368
1369 void wxRecordSet::SetFieldDirty(const char* name, bool dirty)
1370 {
1371   wxNode* node = cols.Find(name);
1372
1373   if (!node)
1374     return;
1375
1376   ((wxQueryCol*)node->Data())->SetFieldDirty(cursor, dirty);
1377 }
1378
1379 void wxRecordSet::SetFieldNull(void *WXUNUSED(p), bool WXUNUSED(isNull))
1380 {
1381 }
1382
1383 // Overridables
1384 char *wxRecordSet::GetDefaultConnect(void)
1385 {
1386   return NULL;
1387 }
1388
1389 char *wxRecordSet::GetDefaultSQL(void)
1390 {
1391   return NULL;
1392 }
1393
1394 void wxRecordSet::SetDefaultSQL(char *s)
1395 {
1396   delete[] defaultSQL;
1397
1398   if (s)
1399     defaultSQL = copystring(s);
1400   else
1401     defaultSQL = NULL;
1402 }
1403
1404 // Build SQL query from column specification
1405 bool wxRecordSet::ConstructDefaultSQL(void)
1406 {
1407 //  if (queryCols.Number() == 0)
1408     return FALSE;
1409 }
1410
1411 bool wxRecordSet::ReleaseHandle(void)
1412 {
1413   if (hStmt)
1414   {
1415     retcode = SQLFreeStmt(hStmt, SQL_DROP);
1416     if (retcode == SQL_ERROR)
1417     {
1418       if (parentdb)
1419         parentdb->ErrorSnapshot(hStmt);
1420       return FALSE;
1421     }
1422     hStmt = 0;
1423   }
1424   return TRUE;
1425 }
1426
1427 wxQueryCol::wxQueryCol(void) {
1428 //  __type = wxTYPE_QUERYCOL;
1429   name = NULL;
1430   type = SQL_TYPE_NULL;
1431   nullable = FALSE;
1432   var = NULL;
1433   varsize = 0;
1434 }
1435
1436 wxQueryCol::~wxQueryCol(void) {
1437   // delete all data
1438   fields.DeleteContents(TRUE);
1439   fields.Clear();
1440
1441   if (name)
1442     delete[] name;
1443 }
1444
1445 void wxQueryCol::SetName(char* n) {
1446   name = new char[strlen(n)+1];
1447   strcpy(name, n);
1448 }
1449
1450 bool wxQueryCol::SetData(int row, void* buf, long len) {
1451   wxNode* node = fields.Nth(row);
1452
1453   if (!node)
1454     return FALSE;
1455
1456   return ((wxQueryField*)node->Data())->SetData(buf, len);
1457 }
1458
1459 void wxQueryCol::SetFieldDirty(int row, bool dirty) {
1460   wxNode* node = fields.Nth(row);
1461
1462   if (!node)
1463     return;
1464
1465   ((wxQueryField*)node->Data())->SetDirty(dirty);
1466 }
1467
1468 void wxQueryCol::AppendField(void* buf, long len) {
1469   wxNode* node = fields.Append(new wxQueryField);
1470   ((wxQueryField*)node->Data())->SetType(type);
1471   ((wxQueryField*)node->Data())->SetData(buf, len);
1472 }
1473
1474 void wxQueryCol::SetType(short t) {
1475   type = t;
1476 }
1477
1478 void* wxQueryCol::BindVar(void* v, long s) {
1479   void* oldvar = var;
1480
1481   var = v;
1482   varsize = s;
1483
1484   return oldvar;
1485 }
1486
1487 void wxQueryCol::FillVar(int recnum) {
1488   if (!var)
1489     return;
1490
1491   wxNode* node = fields.Nth(recnum);
1492
1493   if (!node)
1494     return;
1495
1496   long actsize = ((wxQueryField*)node->Data())->GetSize();
1497   if (actsize > varsize)
1498     actsize = varsize;
1499
1500   memcpy(var, ((wxQueryField*)node->Data())->GetData(), actsize);
1501 }
1502
1503 void wxQueryCol::SetNullable(bool n) {
1504   nullable = n;
1505 }
1506
1507 char* wxQueryCol::GetName(void) {
1508   return name;
1509 }
1510
1511 short wxQueryCol::GetType(void)  {
1512   return type;
1513 }
1514
1515 bool wxQueryCol::IsNullable(void) {
1516   return nullable;
1517 }
1518
1519
1520 bool wxQueryCol::IsFieldDirty(int row) {
1521   wxNode* node = fields.Nth(row);
1522
1523   if (!node)
1524     return FALSE;
1525
1526   return ((wxQueryField*)node->Data())->IsDirty();
1527 }
1528
1529 void* wxQueryCol::GetData(int row) {
1530   wxNode* node = fields.Nth(row);
1531
1532   if (!node)
1533     return NULL;
1534
1535   return ((wxQueryField*)node->Data())->GetData();
1536 }
1537
1538 long wxQueryCol::GetSize(int row) {
1539   wxNode* node = fields.Nth(row);
1540
1541   if (!node)
1542     return 0;
1543
1544   return ((wxQueryField*)node->Data())->GetSize();
1545 }
1546
1547 wxQueryField::wxQueryField(void) {
1548 //  __type = wxTYPE_QUERYROW;
1549   data = NULL;
1550   type = SQL_TYPE_NULL;
1551   size = 0;
1552   dirty = FALSE;
1553 }
1554
1555 wxQueryField::~wxQueryField(void) {
1556   switch (type)
1557   {
1558     case SQL_NUMERIC:
1559     case SQL_DECIMAL:
1560     case SQL_CHAR:
1561     case SQL_VARCHAR:
1562       if (data) // JACS
1563         delete[] (char*)data;
1564       break;
1565     case SQL_INTEGER:
1566       if (data) // JACS
1567         delete (long*)data;
1568       break;
1569     case SQL_SMALLINT:
1570       if (data)
1571         delete (short*)data;
1572       break;
1573     case SQL_FLOAT:
1574     case SQL_DOUBLE:
1575       if (data)
1576         delete (double*)data;
1577       break;
1578     case SQL_REAL:
1579       if (data)
1580         delete (float*)data;
1581       break;
1582     case SQL_TIME:
1583       if (data)
1584         delete (TIME_STRUCT *)data;
1585       break;
1586     case SQL_DATE:
1587       if (data)
1588         delete (DATE_STRUCT *)data;
1589       break;
1590     case SQL_TIMESTAMP:
1591       if (data)
1592         delete (TIMESTAMP_STRUCT *)data;
1593       break;
1594   }
1595 }
1596
1597 bool wxQueryField::AllocData(void) {
1598   switch (type)
1599   {
1600     case SQL_NUMERIC:
1601     case SQL_DECIMAL:
1602     case SQL_CHAR:
1603     case SQL_VARCHAR:
1604     {
1605       if (data) // JACS
1606         delete[] (char*)data;
1607       if ((data = new char[size+1]))
1608       {
1609         char *str = (char *)data;
1610         int i;
1611         for (i = 0; i < size; i++)
1612           str[i] = 0;
1613 //      memset(data, 0, size+1);
1614       }
1615       break;
1616     }
1617     case SQL_INTEGER:
1618     {
1619       if (data) // JACS
1620         delete (long*)data;
1621       if ((data = new long))
1622         *(long*)data = 0L;
1623       break;
1624     }
1625     case SQL_SMALLINT:
1626     {
1627       if (data)
1628         delete (short*)data;
1629       if ((data = new short))
1630         *(short*)data = 0;
1631       break;
1632     }
1633     case SQL_FLOAT:
1634     case SQL_DOUBLE:
1635     {
1636       if (data)
1637         delete (double*)data;
1638       if ((data = new double))
1639         *(double*)data = 0;
1640       break;
1641     }
1642     case SQL_REAL:
1643     {
1644       if (data)
1645         delete (float*)data;
1646       if ((data = new float))
1647         *(float*)data = (float)0;
1648       break;
1649     }
1650     case SQL_TIME:
1651     {
1652       if (data)
1653         delete (TIME_STRUCT *)data;
1654       data = new TIME_STRUCT;
1655       memset(data, 0, sizeof(TIME_STRUCT));
1656       break;
1657     }
1658     case SQL_DATE:
1659     {
1660       if (data)
1661         delete (DATE_STRUCT *)data;
1662       data = new DATE_STRUCT;
1663       memset(data, 0, sizeof(DATE_STRUCT));
1664       break;
1665     }
1666     case SQL_TIMESTAMP:
1667     {
1668       if (data)
1669         delete (TIMESTAMP_STRUCT *)data;
1670       data = new TIMESTAMP_STRUCT;
1671       memset(data, 0, sizeof(TIMESTAMP_STRUCT));
1672       break;
1673     }
1674     default:
1675       return FALSE;
1676   }
1677
1678   return TRUE;
1679 }
1680
1681 bool wxQueryField::SetData(void* d, long s) {
1682   size = s;
1683   if (AllocData() && d)
1684   {
1685 //    memcpy(data, d, s);
1686     switch (type)
1687     {
1688       case SQL_NUMERIC:
1689       case SQL_DECIMAL:
1690       case SQL_CHAR:
1691       case SQL_VARCHAR:
1692       {
1693         char *str = (char *)data;
1694         int i;
1695         for (i = 0; i < size; i++)
1696           str[i] = 0;
1697
1698         strncpy(str, (char *)d, (int)size);
1699         str[size] = 0;
1700         break;
1701       }
1702       case SQL_INTEGER:
1703       {
1704         *(long*)data = *((long *)d);
1705         break;
1706       }
1707       case SQL_SMALLINT:
1708       {
1709         *(short*)data = *((short*)d);
1710         break;
1711       }
1712       case SQL_FLOAT:
1713       case SQL_DOUBLE:
1714       {
1715         *(double*)data = *((double*)d);
1716         break;
1717       }
1718       case SQL_REAL:
1719       {
1720         *(float*)data = *((float*)d);
1721         break;
1722       }
1723       case SQL_TIME:
1724       {
1725         *(TIME_STRUCT *)data = *((TIME_STRUCT*)d);
1726         break;
1727       }
1728       case SQL_TIMESTAMP:
1729       {
1730         *(TIMESTAMP_STRUCT *)data = *((TIMESTAMP_STRUCT*)d);
1731         break;
1732       }
1733       case SQL_DATE:
1734       {
1735         *(DATE_STRUCT *)data = *((DATE_STRUCT*)d);
1736         break;
1737       }
1738       default:
1739         return FALSE;
1740     }
1741     return TRUE;
1742   }
1743   return FALSE;
1744 }
1745
1746 void wxQueryField::ClearData(void) {
1747   if (data)
1748   {
1749   //    memset(data, 0, size);
1750     switch (type)
1751     {
1752       case SQL_NUMERIC:
1753       case SQL_DECIMAL:
1754       case SQL_CHAR:
1755       case SQL_VARCHAR:
1756       {
1757         char *str = (char *)data;
1758         int i;
1759         for (i = 0; i < size; i++)
1760           str[i] = 0;
1761         break;
1762       }
1763       case SQL_INTEGER:
1764       {
1765         *(long*)data = 0L;
1766         break;
1767       }
1768       case SQL_SMALLINT:
1769       {
1770         *(short*)data = 0;
1771         break;
1772       }
1773       case SQL_FLOAT:
1774       case SQL_DOUBLE:
1775       {
1776         *(double*)data = (double)0.0;
1777         break;
1778       }
1779       case SQL_REAL:
1780       {
1781         *(float*)data = (float)0.0;
1782         break;
1783       }
1784       case SQL_TIME:
1785       {
1786         memset(data, 0, sizeof(TIME_STRUCT));
1787         break;
1788       }
1789       case SQL_DATE:
1790       {
1791         memset(data, 0, sizeof(DATE_STRUCT));
1792         break;
1793       }
1794       case SQL_TIMESTAMP:
1795       {
1796         memset(data, 0, sizeof(TIMESTAMP_STRUCT));
1797         break;
1798       }
1799       default:
1800         return;
1801     }
1802   }
1803 }
1804
1805 void wxQueryField::SetDirty(bool d) {
1806   dirty = d;
1807 }
1808
1809 void wxQueryField::SetType(short t) {
1810   type = t;
1811 }
1812
1813 void wxQueryField::SetSize(long s) {
1814   size = s;
1815   AllocData();
1816 }
1817
1818 void* wxQueryField::GetData(void) {
1819   return data;
1820 }
1821
1822 short wxQueryField::GetType(void)  {
1823   return type;
1824 }
1825
1826 long wxQueryField::GetSize(void) {
1827   return size;
1828 }
1829
1830 bool wxQueryField::IsDirty(void) {
1831   return dirty;
1832 }
1833
1834 #ifdef __VISUALC__
1835     #pragma warning(default:4706)   // assignment within conditional expression
1836 #endif // VC++
1837
1838 #endif // wxUSE_ODBC