1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
|
// Microsoft Foundation Classes C++ library.
// Copyright (C) 1993 Microsoft Corporation,
// All rights reserved.
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and Microsoft
// QuickHelp and/or WinHelp documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.
#ifndef __AFXDB_H__
#define __AFXDB_H__
#ifdef _AFX_NO_DB_SUPPORT
#error Database classes not supported in this library variant.
#endif
#ifndef __AFXEXT_H__
#include <afxext.h>
#endif
// include standard SQL/ODBC "C" APIs
#include <sql.h> // core
#include <sqlext.h> // extensions
#ifndef _AFX_NOFORCE_LIBS
#ifndef _MAC
/////////////////////////////////////////////////////////////////////////////
// Win32 libraries
#ifdef _AFXDLL
#ifdef _AFXCTL
#ifdef _DEBUG
#pragma comment(lib, "ocd30d.lib")
#else
#pragma comment(lib, "ocd30.lib")
#endif
#else
#ifdef _DEBUG
#pragma comment(lib, "mfcd30d.lib")
#else
#pragma comment(lib, "mfcd30.lib")
#endif
#endif
#endif
#pragma comment(lib, "odbc32.lib")
#pragma comment(lib, "odbccp32.lib")
#else //!_MAC
/////////////////////////////////////////////////////////////////////////////
// Macintosh libraries
#endif //_MAC
#endif //!_AFX_NOFORCE_LIBS
/////////////////////////////////////////////////////////////////////////////
#ifdef _AFX_PACKING
#pragma pack(push, _AFX_PACKING)
#endif
/////////////////////////////////////////////////////////////////////////////
// AFXDB - MFC SQL/ODBC/Database support
// Classes declared in this file
//CException
class CDBException; // abnormal return value
//CFieldExchange
class CFieldExchange; // Recordset Field Exchange
//CObject
class CDatabase; // Connecting to databases
class CRecordset; // Data result sets
//CObject
//CCmdTarget;
//CWnd
//CView
//CScrollView
//CFormView
class CRecordView; // view records with a form
// Non CObject classes
struct CRecordsetStatus;
struct CFieldInfo;
/////////////////////////////////////////////////////////////////////////////
// ODBC helpers
// return code left in 'nRetCode'
#define AFX_SQL_ASYNC(prs, SQLFunc) \
do \
{ \
ASSERT(!CDatabase::InWaitForDataSource()); \
while ((nRetCode = (SQLFunc)) == SQL_STILL_EXECUTING) \
prs->OnWaitForDataSource(TRUE); \
prs->OnWaitForDataSource(FALSE); \
} while (0)
#define AFX_SQL_SYNC(SQLFunc) \
do \
{ \
ASSERT(!CDatabase::InWaitForDataSource()); \
nRetCode = SQLFunc; \
} while (0)
// Max display length in chars of timestamp (date & time) value
#define TIMESTAMP_PRECISION 23
// AFXDLL support
#undef AFX_DATA
#define AFX_DATA AFX_DB_DATA
// Miscellaneous sizing info
#define MAX_CURRENCY 30 // Max size of Currency($) string
#define MAX_TNAME_LEN 64 // Max size of table names
#define MAX_FNAME_LEN 64 // Max size of field names
#define MAX_DBNAME_LEN 32 // Max size of a database name
#define MAX_DNAME_LEN 256 // Max size of Recordset names
#define MAX_CONNECT_LEN 512 // Max size of Connect string
#define MAX_CURSOR_NAME 18 // Max size of a cursor name
// Timeout and net wait defaults
#define DEFAULT_LOGIN_TIMEOUT 15 // seconds to before fail on connect
#define DEFAULT_QUERY_TIMEOUT 15 // seconds to before fail waiting for results
#define DEFAULT_MAX_WAIT_FOR_DATASOURCE 250 // milliseconds. Give DATASOURCE 1/4 second to respond
#define DEFAULT_MIN_WAIT_FOR_DATASOURCE 50 // milliseconds. Start value for min wait heuristic
// Field Flags, used to indicate status of fields
#define AFX_SQL_FIELD_FLAG_DIRTY 0x1
#define AFX_SQL_FIELD_FLAG_NULL 0x2
/////////////////////////////////////////////////////////////////////////////
// CDBException - something gone wrong
// Dbkit extended error codes
#define AFX_SQL_ERROR 1000
#define AFX_SQL_ERROR_CONNECT_FAIL AFX_SQL_ERROR+1
#define AFX_SQL_ERROR_RECORDSET_FORWARD_ONLY AFX_SQL_ERROR+2
#define AFX_SQL_ERROR_EMPTY_COLUMN_LIST AFX_SQL_ERROR+3
#define AFX_SQL_ERROR_FIELD_SCHEMA_MISMATCH AFX_SQL_ERROR+4
#define AFX_SQL_ERROR_ILLEGAL_MODE AFX_SQL_ERROR+5
#define AFX_SQL_ERROR_MULTIPLE_ROWS_AFFECTED AFX_SQL_ERROR+6
#define AFX_SQL_ERROR_NO_CURRENT_RECORD AFX_SQL_ERROR+7
#define AFX_SQL_ERROR_NO_ROWS_AFFECTED AFX_SQL_ERROR+8
#define AFX_SQL_ERROR_RECORDSET_READONLY AFX_SQL_ERROR+9
#define AFX_SQL_ERROR_SQL_NO_TOTAL AFX_SQL_ERROR+10
#define AFX_SQL_ERROR_ODBC_LOAD_FAILED AFX_SQL_ERROR+11
#define AFX_SQL_ERROR_DYNASET_NOT_SUPPORTED AFX_SQL_ERROR+12
#define AFX_SQL_ERROR_SNAPSHOT_NOT_SUPPORTED AFX_SQL_ERROR+13
#define AFX_SQL_ERROR_API_CONFORMANCE AFX_SQL_ERROR+14
#define AFX_SQL_ERROR_SQL_CONFORMANCE AFX_SQL_ERROR+15
#define AFX_SQL_ERROR_NO_DATA_FOUND AFX_SQL_ERROR+16
#define AFX_SQL_ERROR_ROW_UPDATE_NOT_SUPPORTED AFX_SQL_ERROR+17
#define AFX_SQL_ERROR_ODBC_V2_REQUIRED AFX_SQL_ERROR+18
#define AFX_SQL_ERROR_NO_POSITIONED_UPDATES AFX_SQL_ERROR+19
#define AFX_SQL_ERROR_LOCK_MODE_NOT_SUPPORTED AFX_SQL_ERROR+20
#define AFX_SQL_ERROR_DATA_TRUNCATED AFX_SQL_ERROR+21
#define AFX_SQL_ERROR_ROW_FETCH AFX_SQL_ERROR+22
#define AFX_SQL_ERROR_INCORRECT_ODBC AFX_SQL_ERROR+23
#define AFX_SQL_ERROR_UPDATE_DELETE_FAILED AFX_SQL_ERROR+24
#define AFX_SQL_ERROR_MAX AFX_SQL_ERROR+25
class CDBException : public CException
{
DECLARE_DYNAMIC(CDBException)
// Attributes
public:
RETCODE m_nRetCode;
CString m_strError;
CString m_strStateNativeOrigin;
// Implementation (use AfxThrowDBException to create)
public:
CDBException(RETCODE nRetCode = SQL_SUCCESS);
void BuildErrorString(CDatabase* pdb, HSTMT hstmt, BOOL bTrace = TRUE);
void Empty();
virtual ~CDBException();
#ifdef _DEBUG
void TraceErrorMessage(LPCTSTR szTrace) const;
#endif // DEBUG
};
void AFXAPI AfxThrowDBException(RETCODE nRetCode, CDatabase* pdb, HSTMT hstmt);
//////////////////////////////////////////////////////////////////////////////
// CLongBinary - a Long (generally > 32k in length) Binary object
#define AFX_SQL_DEFAULT_LONGBINARY_SIZE 1024
class CLongBinary : public CObject
{
DECLARE_DYNAMIC(CLongBinary)
// Constructors
public:
CLongBinary();
// Attributes
HGLOBAL m_hData;
DWORD m_dwDataLength;
// Implementation
public:
virtual ~CLongBinary();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif //_DEBUG
};
//////////////////////////////////////////////////////////////////////////////
// CDatabase - a SQL Database
class CDatabase : public CObject
{
DECLARE_DYNAMIC(CDatabase)
// Constructors
public:
CDatabase();
virtual BOOL Open(LPCSTR lpszDSN, BOOL bExclusive = FALSE,
BOOL bReadonly = FALSE, LPCSTR lpszConnect = "ODBC;",
BOOL bUseCursorLib = TRUE);
virtual void Close();
// Attributes
public:
HDBC m_hdbc;
BOOL IsOpen() const; // Database successfully opened?
BOOL CanUpdate() const;
BOOL CanTransact() const; // Are Transactions supported?
CString GetDatabaseName() const;
const CString& GetConnect() const;
// global state - if waiting for datasource => not normal operations
static BOOL PASCAL InWaitForDataSource();
// Operations
public:
void SetLoginTimeout(DWORD dwSeconds);
void SetQueryTimeout(DWORD dwSeconds);
void SetSynchronousMode(BOOL bSynchronous);
// transaction control
BOOL BeginTrans();
BOOL CommitTrans();
BOOL Rollback();
// direct sql execution
void ExecuteSQL(LPCSTR lpszSQL);
// Cancel asynchronous operation
void Cancel();
// Overridables
public:
// set special options
virtual void OnSetOptions(HSTMT hstmt);
// Give user chance to cancel long operation
virtual void OnWaitForDataSource(BOOL bStillExecuting);
// Implementation
public:
virtual ~CDatabase();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
BOOL m_bTransactionPending;
#endif //_DEBUG
// general error check
virtual BOOL Check(RETCODE nRetCode) const;
void ReplaceBrackets(LPTSTR lpchSQL);
BOOL m_bStripTrailingSpaces;
BOOL m_bIncRecordCountOnAdd;
protected:
CString m_strConnect;
CPtrList m_listRecordsets; // maintain list to ensure CRecordsets all closed
int nRefCount;
BOOL m_bUpdatable;
BOOL m_bTransactions;
SWORD m_nTransactionCapable;
SWORD m_nCursorCommitBehavior;
SWORD m_nCursorRollbackBehavior;
UDWORD m_dwGetDataExtensions;
DWORD m_dwLoginTimeout;
HSTMT m_hstmt;
DWORD m_dwWait;
DWORD m_dwQueryTimeout;
DWORD m_dwMinWaitForDataSource;
DWORD m_dwMaxWaitForDataSource;
BOOL m_bAsync;
char m_chIDQuoteChar;
char m_reserved1[3]; // pad to even 4 bytes
void ThrowDBException(RETCODE nRetCode);
void AllocConnect();
void Free();
// friend classes that call protected CDatabase overridables
friend class CRecordset;
friend class CFieldExchange;
friend class CDBException;
};
//////////////////////////////////////////////////////////////////////////////
// Recordset Field exchanged (RFX_)
#define AFX_RFX_INT_PSEUDO_NULL (0x7EE4)
#define AFX_RFX_LONG_PSEUDO_NULL (0x4a4d4120L)
#define AFX_RFX_BYTE_PSEUDO_NULL 255
#define AFX_RFX_SINGLE_PSEUDO_NULL (-9.123e19f)
#define AFX_RFX_DOUBLE_PSEUDO_NULL (-9.123e19)
#define AFX_RFX_BOOL_PSEUDO_NULL 2
#define AFX_RFX_DATE_PSEUDO_NULL CTime(0)
#define AFX_RFX_TIMESTAMP_PSEUDO_NULL 99
#define AFX_RFX_BOOL 1
#define AFX_RFX_BYTE 2
#define AFX_RFX_INT 3
#define AFX_RFX_LONG 4
#define AFX_RFX_SINGLE 6
#define AFX_RFX_DOUBLE 7
#define AFX_RFX_DATE 8
#define AFX_RFX_BINARY 9
#define AFX_RFX_TEXT 10
#define AFX_RFX_LONGBINARY 11
// CFieldExchange - for field exchange
class CFieldExchange
{
// Attributes
public:
enum RFX_Operation
{
BindParam, // register users parameters with ODBC SQLBindParameter
RebindDateParam, // migrate date param values to proxy array before Requery
BindFieldToColumn, // register users fields with ODBC SQLBindCol
BindFieldForUpdate, // temporarily bind columns before update (via SQLSetPos)
UnbindFieldForUpdate, // unbind columns after update (via SQLSetPos)
Fixup, // Set string lengths, clear status bits
MarkForAddNew,
MarkForUpdate, // Prepare fields and flags for update operation
Name, // append dirty field name
NameValue, // append dirty name=value
Value, // append dirty value or parameter marker
SetFieldDirty, // Set status bit for changed status
SetFieldNull, // Set status bit for null value
IsFieldDirty,// return TRUE if field is dirty
IsFieldNull,// return TRUE if field is marked NULL
IsFieldNullable,// return TRUE if field can hold NULL values
StoreField, // archive values of current record
LoadField, // reload archived values into current record
GetFieldInfoValue, // general info on a field via pv for field
GetFieldInfoOrdinal, // general info on a field via field ordinal
#ifdef _DEBUG
DumpField, // dump bound field name and value
#endif
};
UINT m_nOperation; // Type of exchange operation
CRecordset* m_prs; // recordset handle
// Operations
enum FieldType
{
noFieldType,
outputColumn,
param,
};
// Operations (for implementors of RFX procs)
BOOL IsFieldType(UINT* pnField);
// Indicate purpose of subsequent RFX calls
void SetFieldType(UINT nFieldType);
// Implementation
CFieldExchange(UINT nOperation, CRecordset* prs, void* pvField = NULL);
void Default(const char* szName,
void* pv, LONG* plLength, int nCType, UINT cbValue, UINT cbPrecision);
int GetColumnType(int nColumn, UINT* pcbLength = NULL,
int* pnScale = NULL, int* pnNullable = NULL);
// Current type of field
UINT m_nFieldType;
// For GetFieldInfo
CFieldInfo* m_pfi; // GetFieldInfo return struct
BOOL m_bFieldFound; // GetFieldInfo search successful
// For returning status info for a field
BOOL m_bNull; // return result of IsFieldNull(able)/Dirty operation
BOOL m_bDirty; // return result of IsFieldNull(able)/Dirty operation
CString* m_pstr; // Field name or destination for building various SQL clauses
BOOL m_bField; // Value to set for SetField operation
void* m_pvField; // For indicating an operation on a specific field
CArchive* m_par; // For storing/loading copy buffer
LPCSTR m_lpszSeparator; // append after field names
UINT m_nFields; // count of fields for various operations
UINT m_nParams; // count of fields for various operations
UINT m_nParamFields; // count of fields for various operations
HSTMT m_hstmt; // For SQLBindParameter on update statement
#ifdef _DEBUG
CDumpContext* m_pdcDump;
#endif //_DEBUG
};
/////////////////////////////////////////////////////////////////////////////
// Standard RecordSet Field Exchange routines
// text data
void AFXAPI RFX_Text(CFieldExchange* pFX, const char* szName, CString& value,
// Default max length for char and varchar, default datasource type
int nMaxLength = 255, int nColumnType = SQL_VARCHAR);
// boolean data
void AFXAPI RFX_Bool(CFieldExchange* pFX, const char* szName, BOOL& value);
// integer data
void AFXAPI RFX_Long(CFieldExchange* pFX, const char* szName, long& value);
void AFXAPI RFX_Int(CFieldExchange* pFX, const char* szName, int& value);
void AFXAPI RFX_Single(CFieldExchange* pFX, const char* szName, float& value);
void AFXAPI RFX_Double(CFieldExchange* pFX, const char* szName, double& value);
// date and time
void AFXAPI RFX_Date(CFieldExchange* pFX, const char* szName, CTime& value);
void AFXAPI RFX_Date(CFieldExchange* pFX, const char* szName, TIMESTAMP_STRUCT& value);
// Binary data
void AFXAPI RFX_Binary(CFieldExchange* pFX, const char* szName, CByteArray& value,
// Default max length is for binary and varbinary
int nMaxLength = 255);
void AFXAPI RFX_Byte(CFieldExchange* pFX, const char* szName, BYTE& value);
void AFXAPI RFX_LongBinary(CFieldExchange* pFX, const char* szName, CLongBinary& value);
/////////////////////////////////////////////////////////////////////////////
// Database Dialog Data Exchange cover routines
// Cover routines provide database semantics on top of DDX routines
// simple text operations
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, BYTE& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, int& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, UINT& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, long& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, DWORD& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, CString& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, double& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldText(CDataExchange* pDX, int nIDC, float& value, CRecordset* pRecordset);
// special control types
void AFXAPI DDX_FieldCheck(CDataExchange* pDX, int nIDC, int& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldRadio(CDataExchange* pDX, int nIDC, int& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldLBString(CDataExchange* pDX, int nIDC, CString& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldCBString(CDataExchange* pDX, int nIDC, CString& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldLBStringExact(CDataExchange* pDX, int nIDC, CString& value, CRecordset* pRecordset);
void AFXAPI DDX_FieldCBStringExact(CDataExchange* pDX, int nIDC, CString& value, CRecordset* pRecordset);
//////////////////////////////////////////////////////////////////////////////
// CRecordset - the result of a SQL Statement
#define AFX_MOVE_FIRST 0x80000000L
#define AFX_MOVE_PREVIOUS (-1L)
#define AFX_MOVE_REFRESH 0L
#define AFX_MOVE_NEXT (+1L)
#define AFX_MOVE_LAST 0x7fffffffL
#define AFX_RECORDSET_STATUS_OPEN (+1L)
#define AFX_RECORDSET_STATUS_CLOSED 0L
#define AFX_RECORDSET_STATUS_UNKNOWN (-1L)
class CRecordset : public CObject
{
DECLARE_DYNAMIC(CRecordset)
// Constructor
protected:
CRecordset(CDatabase* pDatabase = NULL);
public:
virtual ~CRecordset();
enum OpenType
{
dynaset,
snapshot,
forwardOnly
};
enum OpenOptions
{
none = 0x0,
readOnly = 0x0004,
appendOnly = 0x0008,
optimizeBulkAdd = 0x4000, // Use prepared HSTMT for multiple AddNews, dirty fields must not change.
firstBulkAdd = 0x8000, // INTERNAL to MFC, don't specify on Open.
};
virtual BOOL Open(UINT nOpenType = snapshot, LPCSTR lpszSQL = NULL, DWORD dwOptions = none);
virtual void Close();
// Attributes
public:
HSTMT m_hstmt; // Source statement for this resultset
CDatabase* m_pDatabase; // Source database for this resultset
CString m_strFilter; // Where clause
CString m_strSort; // Order By Clause
BOOL CanAppend() const; // Can AddNew be called?
BOOL CanRestart() const; // Can Requery be called to restart a query?
BOOL CanScroll() const; // Can MovePrev and MoveFirst be called?
BOOL CanTransact() const; // Are Transactions supported?
BOOL CanUpdate() const; // Can Edit/AddNew/Delete be called?
const CString& GetSQL() const; // SQL executed for this recordset
const CString& GetTableName() const; // Table name
BOOL IsOpen() const; // Recordset successfully opened?
BOOL IsBOF() const; // Beginning Of File
BOOL IsEOF() const; // End Of File
BOOL IsDeleted() const; // On a deleted record
BOOL IsFieldDirty(void *pv); // has field been updated?
BOOL IsFieldNull(void *pv); // is field NULL valued?
BOOL IsFieldNullable(void *pv); // can field be set to a NULL value
long GetRecordCount() const; // Records seen so far or -1 if unknown
void GetStatus(CRecordsetStatus& rStatus) const;
// Operations
public:
// cursor operations
void MoveNext();
void MovePrev();
void MoveFirst();
void MoveLast();
virtual void Move(long lRows);
// edit buffer operations
virtual void AddNew(); // add new record at the end
virtual void Edit(); // start editing
virtual BOOL Update(); // update it
virtual void Delete(); // delete the current record
// field operations
void SetFieldDirty(void *pv, BOOL bDirty = TRUE);
void SetFieldNull(void *pv, BOOL bNull = TRUE);
// locking control during Edit
enum LockMode
{
optimistic,
pessimistic,
};
void SetLockingMode(UINT nMode);
// Recordset operations
virtual BOOL Requery(); // Re-execute query based on new params
// Cancel asynchronous operation
void Cancel();
// Overridables
public:
// Get default connect string
virtual CString GetDefaultConnect();
// Get SQL to execute
virtual CString GetDefaultSQL() = 0;
// set special options
virtual void OnSetOptions(HSTMT hstmt);
// Give user chance to cancel long operation
virtual void OnWaitForDataSource(BOOL bStillExecuting);
// for recordset field exchange
virtual void DoFieldExchange(CFieldExchange* pFX) = 0;
// Implementation
public:
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif //_DEBUG
virtual BOOL Check(RETCODE nRetCode) const; // general error check
void InitRecord();
virtual void PreBindFields(); // called before data fields are bound
UINT m_nFields; // number of RFX fields
UINT m_nParams; // number of RFX params
BOOL m_bDateParams; // date parameter existence flag
BOOL m_bLongBinaryColumns; // long binary column existence flag
BOOL m_bUseUpdateSQL; // uses SQL-based updates (or SQLSetPos)
UDWORD m_dwDriverPositionedStatements;
BOOL IsSQLUpdatable(LPCTSTR lpszSQL);
BOOL IsSelectQueryUpdatable(LPCTSTR lpszSQL);
static BOOL PASCAL IsJoin(LPCTSTR lpszJoinClause);
static LPCTSTR PASCAL FindSQLToken(LPCTSTR lpszSQL, LPCTSTR lpszSQLToken);
// RFX Operations on fields of CRecordset
UINT BindParams(HSTMT hstmt);
void RebindDateParams(HSTMT hstmt);
UINT BindFieldsToColumns();
void BindFieldsForUpdate();
void UnbindFieldsForUpdate();
void Fixups();
UINT AppendNames(CString* pstr, LPCSTR szSeparator);
UINT AppendValues(HSTMT hstmt, CString* pstr, LPCSTR szSeparator);
UINT AppendNamesValues(HSTMT hstmt, CString* pstr, LPCSTR szSeparator);
void StoreFields();
void LoadFields();
void MarkForAddNew();
void MarkForUpdate();
BOOL GetFieldInfo(void* pv, CFieldInfo* pfi);
BOOL GetFieldInfo(UINT nField, CFieldInfo* pfi);
#ifdef _DEBUG
void DumpFields(CDumpContext& dc) const;
#endif //_DEBUG
// RFX operation helper functions
BOOL UnboundFieldInfo(UINT nField, CFieldInfo* pfi);
void ThrowDBException(RETCODE nRetCode, HSTMT hstmt = SQL_NULL_HSTMT);
CMemFile* m_pmemfile; // For saving copy buffer
CArchive* m_par; // For saving copy buffer
void AllocFlags();
BYTE GetFieldFlags(UINT nField, UINT nFieldType = CFieldExchange::outputColumn);
void SetFieldFlags(UINT nField, BYTE bFlags, UINT nFieldType = CFieldExchange::outputColumn);
void ClearFieldFlags(UINT nField, BYTE bFlags, UINT nFieldType = CFieldExchange::outputColumn);
LONG* GetFieldLength(CFieldExchange* pFX);
BOOL IsFieldFlagNull(UINT nField, UINT nFieldType);
BOOL IsFieldFlagDirty(UINT nField, UINT nFieldType);
void** m_pvFieldProxy;
void** m_pvParamProxy;
UINT m_nProxyFields;
UINT m_nProxyParams;
protected:
UINT m_nOpenType;
enum EditMode
{
noMode,
edit,
addnew
};
long m_lOpen;
UINT m_nEditMode;
BOOL m_bEOFSeen;
long m_lRecordCount;
long m_lCurrentRecord;
CString m_strCursorName;
// Perform operation based on m_nEditMode
BOOL UpdateInsertDelete();
void ReleaseCopyBuffer();
BOOL m_nLockMode; // Control concurrency for Edit()
UDWORD m_dwDriverConcurrency; // driver supported concurrency types
UDWORD m_dwConcurrency; // requested concurrency type
UWORD m_wRowStatus; // row status used by SQLExtendedFetch and SQLSetPos
HSTMT m_hstmtUpdate;
BOOL m_bRecordsetDb;
BOOL m_bBOF;
BOOL m_bEOF;
BOOL m_bUpdatable; // Is recordset updatable?
BOOL m_bAppendable;
CString m_strSQL; // SQL statement for recordset
CString m_strUpdateSQL; // SQL statement for updates
CString m_strTableName; // source table of recordset
BOOL m_bScrollable; // supports MovePrev
BOOL m_bDeleted;
DWORD m_dwWait;
UINT m_nFieldsBound;
BYTE* m_pbFieldFlags;
LONG* m_plFieldLength; // Pointer to field length bound in SQLBindCol
BYTE* m_pbParamFlags;
LONG* m_plParamLength;
BOOL m_bExtendedFetch;
public:
DWORD m_dwOptions; // archive dwOptions on Open
protected:
CString m_strRequerySQL; // archive SQL string for use in Requery()
CString m_strRequeryFilter; // archive filter string for use in Requery()
CString m_strRequerySort; // archive sort string for use in Requery()
void BuildSelectSQL();
void AppendFilterAndSortSQL();
BOOL IsRecordsetUpdatable();
void ExecuteSetPosUpdate();
void PrepareUpdateHstmt();
void BuildUpdateSQL();
void ExecuteUpdateSQL();
void SendLongBinaryData(HSTMT hstmt);
friend class CFieldExchange;
friend class CRecordView;
};
#define AFX_CURRENT_RECORD_UNDEFINED (-2)
#define AFX_CURRENT_RECORD_BOF (-1)
// For returning status for a recordset
struct CRecordsetStatus
{
long m_lCurrentRecord; // -2=Unknown,-1=BOF,0=1st record. . .
BOOL m_bRecordCountFinal;// Have we counted all records?
};
// For returning field info on RFX fields
struct CFieldInfo
{
// For ID'ing field
UINT nField; // Field number
CString strName; // Field name
void* pv; // Address of value for field
// Return info GetFieldInfo
UINT nDataType; // data type of field (BOOL, BYTE, etc)
DWORD dwSize; // Max size for field data
};
/////////////////////////////////////////////////////////////////////////////
// CRecordView - form for viewing data records
class CRecordView : public CFormView
{
DECLARE_DYNAMIC(CRecordView)
// Construction
protected: // must derive your own class
CRecordView(LPCSTR lpszTemplateName);
CRecordView(UINT nIDTemplate);
// Attributes
public:
virtual CRecordset* OnGetRecordset() = 0;
BOOL IsOnLastRecord();
BOOL IsOnFirstRecord();
// Operations
public:
virtual BOOL OnMove(UINT nIDMoveCommand);
// Implementation
public:
virtual ~CRecordView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
virtual void OnInitialUpdate();
protected:
BOOL m_bOnFirstRecord;
BOOL m_bOnLastRecord;
//{{AFX_MSG(CRecordView)
afx_msg void OnUpdateRecordFirst(CCmdUI* pCmdUI);
afx_msg void OnUpdateRecordPrev(CCmdUI* pCmdUI);
afx_msg void OnUpdateRecordNext(CCmdUI* pCmdUI);
afx_msg void OnUpdateRecordLast(CCmdUI* pCmdUI);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
// Inline function declarations
#ifdef _AFX_PACKING
#pragma pack(pop)
#endif
#ifdef _AFX_ENABLE_INLINES
#define _AFXDBCORE_INLINE inline
#define _AFXDBRFX_INLINE inline
#define _AFXDBVIEW_INLINE inline
#include <afxdb.inl>
#undef _AFXDBVIEW_INLINE
#undef _AFXDBCORE_INLINE
#undef _AFXDBRFX_INLINE
#endif
#undef AFX_DATA
#define AFX_DATA
#endif //__AFXDB_H__
/////////////////////////////////////////////////////////////////////////////
|