|
|
// Flags for field descriptor
/* note that these flags are stored persistantly in database
/* catalogs and cannot be changed without a database format change
/**/#define ffieldNotNull (1<<0) // NULL values not allowed
#define ffieldVersion (1<<2) // Version field
#define ffieldAutoInc (1<<3) // Auto increment field
#define ffieldMultivalue (1<<4) // Multi-valued column
#define ffieldDefault (1<<5) // Column has ISAM default value
#define FIELDSetNotNull( field ) ((field) |= ffieldNotNull)
#define FIELDResetNotNull( field ) ((field) &= ~ffieldNotNull)
#define FFIELDNotNull( field ) ((field) & ffieldNotNull)
#define FIELDSetVersion( field ) ((field) |= ffieldVersion)
#define FIELDResetVersion( field ) ((field) &= ~ffieldVersion)
#define FFIELDVersion( field ) ((field) & ffieldVersion)
#define FIELDSetAutoInc( field ) ((field) |= ffieldAutoInc)
#define FIELDResetAutoInc( field ) ((field) &= ~ffieldAutoInc)
#define FFIELDAutoInc( field ) ((field) & ffieldAutoInc)
#define FIELDSetMultivalue( field ) ((field) |= ffieldMultivalue)
#define FIELDResetMultivalue( field ) ((field) &= ~ffieldMultivalue)
#define FFIELDMultivalue( field ) ((field) & ffieldMultivalue)
#define FIELDSetDefault( field ) ((field) |= ffieldDefault)
#define FIELDResetDefault( field ) ((field) &= ~ffieldDefault)
#define FFIELDDefault( field ) ((field) & ffieldDefault)
#define FIELDSetFlag( field, flag ) ((field).ffield |= (flag))
#define FIELDResetFlag( field, flag ) ((field).ffield &= ~(flag))
#define FRECLongValue( coltyp ) \
( (coltyp) == JET_coltypLongText || (coltyp) == JET_coltypLongBinary )
#define FRECTextColumn( coltyp ) \
( (coltyp) == JET_coltypText || (coltyp) == JET_coltypLongText )
#define FRECBinaryColumn( coltyp ) \
( (coltyp) == JET_coltypBinary || (coltyp) == JET_coltypLongBinary )
#define cbAvgColName 10 // Average length of a column name
/* entry in field descriptor tables found in an FDB
/**/typedef struct _field { JET_COLTYP coltyp; // column data type
ULONG cbMaxLen; // maximum length
ULONG itagFieldName; // Offset into FDB's buffer
USHORT cp; // code page of language
BYTE ffield; // various flags
} FIELD;
typedef struct tagFIELDEX // Extended field info.
{ FIELD field; // Standard field info (see above)
FID fid; // field id
WORD ibRecordOffset; // Record offset (for fixed fields only)
} FIELDEX;
#define itagFDBFields 1 // Tag into FDB's buffer for field info
// (FIELD structures and fixed offsets table)
// The fixed offsets table is also the beginning of the field info (ie. the FIELD
// structures follow the fixed offsets table).
#define PibFDBFixedOffsets( pfdb ) ( (WORD *)PbMEMGet( (pfdb)->rgb, itagFDBFields ) )
// Get the appropriate FIELD structure based on the previous FIELD structure.
// NOTE: Be wary of the alignment fixup for the fixed offsets table.
#define PfieldFDBFixedFromOffsets( pfdb, pibFixedOffsets ) \
( (FIELD *)( Pb4ByteAlign( (BYTE *) ( pibFixedOffsets + (pfdb)->fidFixedLast + 1 ) ) ) )#define PfieldFDBVarFromFixed( pfdb, pfieldFixed ) \
( pfieldFixed + (pfdb)->fidFixedLast + 1 - fidFixedLeast )#define PfieldFDBTaggedFromVar( pfdb, pfieldVar ) \
( pfieldVar + (pfdb)->fidVarLast + 1 - fidVarLeast )
// Get the appropriate FIELD strcture, starting from the beginning of the field info.
#define PfieldFDBFixed( pfdb ) PfieldFDBFixedFromOffsets( pfdb, PibFDBFixedOffsets( pfdb ) )
#define PfieldFDBVar( pfdb ) PfieldFDBVarFromFixed( pfdb, PfieldFDBFixed( pfdb ) )
#define PfieldFDBTagged( pfdb ) PfieldFDBTaggedFromVar( pfdb, PfieldFDBVar( pfdb ) )
/* field descriptor block: information about all columns of a table
/**/struct _fdb { BYTE *rgb; // Buffer for FIELD structures, fixed
// offsets table, and column names
FID fidFixedLast; // Highest fixed field id in use
FID fidVarLast; // Highest variable field id in use
FID fidTaggedLast; // Highest tagged field id in use
USHORT ffdb; // FDB flags. NOTE: This field is currently
// no longer used, but keep it here anyways
// for alignment purposes.
FID fidVersion; // fid of version field
FID fidAutoInc; // fid of auto increment field
LINE lineDefaultRecord; // default record
};
typedef struct tagMEMBUFHDR { ULONG cbBufSize; // Length of buffer.
ULONG ibBufFree; // Beginning of free space in buffer
// (if ibBufFree==cbBufSize, then buffer is full)
ULONG cTotalTags; // Size of tag array
ULONG iTagUnused; // Next unused tag (never been used or freed)
ULONG iTagFreed; // Next freed tag (previously used, but since freed)
} MEMBUFHDR;
typedef struct tagMEMBUFTAG { ULONG ib; // UNDONE: Should these be SHORT's instead?
ULONG cb; } MEMBUFTAG;
typedef struct tagMEMBUF { MEMBUFHDR bufhdr; BYTE *pbuf; } MEMBUF;
ERR ErrMEMCreateMemBuf( BYTE **prgbBuffer, ULONG cbInitialSize, ULONG cInitialEntries );ERR ErrMEMCopyMemBuf( BYTE **prgbBufferDest, BYTE *rgbBufferSrc );VOID MEMFreeMemBuf( BYTE *rgbBuffer );ERR ErrMEMAdd( BYTE *rgbBuffer, BYTE *rgb, ULONG cb, ULONG *pitag );ERR ErrMEMReplace( BYTE *rgbBuffer, ULONG iTagEntry, BYTE *rgb, ULONG cb );VOID MEMDelete( BYTE *rgbBuffer, ULONG iTagEntry );
#ifdef DEBUG
BYTE *SzMEMGetString( BYTE *rgbBuffer, ULONG iTagEntry );VOID MEMAssertMemBuf( MEMBUF *pmembuf );VOID MEMAssertMemBufTag( MEMBUF *pmembuf, ULONG iTagEntry );#else
#define SzMEMGetString( rgbBuffer, iTagEntry ) PbMEMGet( rgbBuffer, iTagEntry )
#define MEMAssertMemBuf( pmembuf )
#define MEMAssertMemBufTag( pmembuf, iTagEntry )
#endif
// Retrieve a pointer to the desired entry in the buffer.
// WARNING: Pointers into the contents of the buffer are very
// volatile -- they may be invalidated the next time the buffer
// is reallocated. Ideally, we should never allow direct access via
// pointers -- we should only allow indirect access via itags which we
// will dereference for the user and copy to a user-provided buffer. However,
// there would be a size and speed hit with such a method.
INLINE STATIC BYTE *PbMEMGet( BYTE *rgbBuffer, ULONG iTagEntry ) { MEMBUF *pmembuf = (MEMBUF *)rgbBuffer; MEMBUFTAG *rgbTags;
MEMAssertMemBuf( pmembuf ); // Validate integrity of string buffer.
MEMAssertMemBufTag( pmembuf, iTagEntry ); // Validate integrity of itag.
rgbTags = (MEMBUFTAG *)pmembuf->pbuf;
return pmembuf->pbuf + rgbTags[iTagEntry].ib; }
INLINE STATIC ULONG CbMEMGet( BYTE *rgbBuffer, ULONG iTagEntry ) { MEMBUF *pmembuf = (MEMBUF *)rgbBuffer; MEMBUFTAG *rgbTags;
MEMAssertMemBuf( pmembuf ); // Validate integrity of string buffer.
MEMAssertMemBufTag( pmembuf, iTagEntry ); // Validate integrity of itag.
rgbTags = (MEMBUFTAG *)pmembuf->pbuf;
return rgbTags[iTagEntry].cb; }
|
