From VisualWorks®, 7.6 of February 1, 2008 on February 1, 2008 at 1:13:31 pm (Dialog confirm: 'You are filing-in a Parcel source file!\\While this is possible it will not have\the same effect as loading the parcel.\None of the Parcel''s prerequisites will\be loaded and none of its load actions\will be performed.\\Are you sure you want to file-in?' withCRs) ifFalse: [self error: 'Parcel file-in abandoned. Choose terminate or close.'] <class> <name>DB2APIInterface</name> <environment>Database</environment> <super>External.ExternalInterface</super> <private>false</private> none <imports> Database.DB2APIInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles><item>db2apidf.h</item></includeFiles> <includeDirectories><item>d:\sqllib\include</item></includeDirectories> <libraryFiles><item>db2sys.dll</item> <item>db2app.dll</item> <item>db2util.dll</item></libraryFiles> <libraryDirectories></libraryDirectories> true full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2APIInterface
DB2APIInterface defines calling conventions for DB2 Administrative API.
</comment> <class> <name>DB2Connection</name> <environment>Database</environment> <super>Database.ExternalDatabaseConnection</super> <private>false</private> none hdbcHolder supportedFunctions generalInformationCache blobHstmt apiXif apiXifMap <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Connection
DB2Connection is the concrete class implementation of connection services using the DB2 CLI library. Instance Variables: blobHstmt <(CPointer | nil)> A pointer to the statement handle for LOB handling. generalInformationCache <IdentityDictionary> A dictionary containing the information associated with information type symbols. hdbcHolder <ValueHolder on: (CPointer | nil)> A private value holder which remembers the pointer for the connection handle. supportedFunctions <IdentityDictionary> A dictionary indicating whether a specific function is supported. Class instance variables: apiXif <IdentityDictionary> Maps a set of error codes to their corresponding signals. apiXifMap <IdentityDictionary> A boolean indicating whether the Oracle OCI library is initialized.
</comment> <class> <name>DB2CLIInterface</name> <environment>Database</environment> <super>External.ExternalInterface</super> <private>false</private> none encoding getSelectorMap fSqlTypeToConversionMap fetchBufferSizeBlocks putSelectorMap fCTypeFromConversionMap fSqlTypeFromConversionMap valueSizeBlocks valuePrecisionBlocks dataChunkSize conversionBufferMap <imports> Database.DB2CLIInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles></includeFiles> <includeDirectories></includeDirectories> <libraryFiles></libraryFiles> <libraryDirectories></libraryDirectories> true full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2CLIInterface
DB2CLIInterface defines calling conventions for DB2 CLI. Instance Variables: encoding <Symbol> A symbol remembers the encoding selection. Class instance variables: getSelectorMap <IdentityDictionary> Map of selectors to get values out of the buffer for different data types. putSelectorMap <IdentityDictionary> Map of selectors to put value into the buffer for different data types. fetchBufferSizeBlocks <IdentityDictionary> Map of buffer size for different data types. fSqlTypeToConversionMap <IdentityDictionary> Map of converting Sql types to Smalltalk types. fCTypeFromConversionMap <IdentityDictionary> Map of converting Smalltalk types to Sql types. fSqlTypeFromConversionMap <IdentityDictionary> Map of converting Smalltalk types to Sql types. valueSizeBlocks <IdentityDictionary> Map of value sizes for different data type. valuePrecisionBlocks <IdentityDictionary> Map of precision sizes for different data type. dataChunkSize <Integer> Size of the chunks for LOB data types. conversionBufferMap <IdentityDictionary> Map of buffer type for different data types.
</comment> <class> <name>DB2CLIWinInterface</name> <environment>Database</environment> <super>Database.DB2CLIInterface</super> <private>false</private> none <imports> Database.DB2CLIWinInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles></includeFiles> <includeDirectories></includeDirectories> <libraryFiles><item>db2cli.dll</item></libraryFiles> <libraryDirectories></libraryDirectories> false full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2CLIWinInterface
DB2CLIWinInterface defines calling conventions for DB2 CLI on the Windows platform.
</comment> <class> <name>DB2CLILinuxInterface</name> <environment>Database</environment> <super>Database.DB2CLIInterface</super> <private>false</private> none <imports> Database.DB2CLILinuxInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles></includeFiles> <includeDirectories></includeDirectories> <libraryFiles><item>libdb2.so</item></libraryFiles> <libraryDirectories></libraryDirectories> false full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2CLILinuxInterface
DB2CLILinuxInterface defines calling conventions for DB2 CLI on the Linux platform.
</comment> <class> <name>DB2Buffer</name> <environment>Database</environment> <super>Database.ExternalDatabaseBuffer</super> <private>false</private> none conversionBuffer bufferValue bufferIndex hstmt connection fParamType cbColDef ibScale pcbValue getSelector putSelector <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Buffer
DB2Buffer is a private subclass, it extends ExternalDatabaseBuffer to deal with DB2. Instance Variables: bufferIndex <SmallInteger> An Integer storing the external bind index. bufferValue <Object | nil> The object to store a bind value. cbColDef <SmallInteger> The precision of the buffer value. connection <DB2Connection> The connection the buffer is used for. conversionBuffer <Object | nil> The buffer type used to store or get the value from. fParamType <SmallInteger> The type of the parameter. (e.g., SQL_PARAM_INPUT) getSelector <nil | Symbol> Selector to perform to get values out of the buffer. hstmt <CPointer> The statement handle. ibScale <SmallInteger> The scale of the parameter. pcbValue <CPointer> The buffer's count (length) in bytes. putSelector <nil | Symbol> Selector to perform to put values into the buffer.
</comment> <class> <name>DB2FileRefBuffer</name> <environment>Database</environment> <super>Database.DB2Buffer</super> <private>false</private> none bufferLengthPointer fileOptionsPointer <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2FileRefBuffer
DB2FileRefBuffer is a private subclass, it extends DB2Buffer to deal with file reference. Instance Variables: bufferLengthPointer <CPointer> Stores the buffer length. fileOptionsPointer <CPointer> Stores the file options.
</comment> <class> <name>DB2DataType</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2DataType
DB2DataType is the super class of the classes dealing with special DB2 data types.
</comment> <class> <name>DB2LOBType</name> <environment>Database</environment> <super>Database.DB2DataType</super> <private>false</private> none <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2LOBType
DB2LOBType is the super class of the classes dealing with LOB types in DB2.
</comment> <class> <name>DB2LOBFileReference</name> <environment>Database</environment> <super>Database.DB2LOBType</super> <private>false</private> none fileName fileOptions dataType computeBlock <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2LOBFileReference
DB2LOBFileReference is used to handle LOB file references in DB2. Instance Variables: computeBlock <BlockClosure> Used to compute the file name. dataType <ByteSymbol> Data types used (#LargeString or #LargeByteArray). fileName <String> The file name. fileOptions <ByteSymbol> File options
</comment> <class> <name>DB2DataSource</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none name description <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2DataSource
DB2DataSource is used to represent the DB2 data sources. Instance Variables: description <String> Description of the data source. name <String> Name of the data source.
</comment> <class> <name>DB2LOBLocator</name> <environment>Database</environment> <super>Database.DB2LOBType</super> <private>false</private> none locator <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2LOBLocator
DB2LOBLocator is the super class of the classes dealing with BlobLocator and ClobLocator types in DB2. Instance Variables: locator <CPointer> Pointer to the LOB locator..
</comment> <class> <name>DB2CLOBLocator</name> <environment>Database</environment> <super>Database.DB2LOBLocator</super> <private>false</private> none <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2CLOBLocator
DB2CLOBLocator is the class which handles DB2 data type ClobLocator.
</comment> <class> <name>DB2Manager</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none singleton <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Manager
DB2Manager is used to make DB2 Administrative API calls. Class instance variables: singleton <DB2Manager> The only instance of the class used to make the calls.
</comment> <class> <name>DB2APIWinInterface</name> <environment>Database</environment> <super>Database.DB2APIInterface</super> <private>false</private> none <imports> Database.DB2APIWinInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles></includeFiles> <includeDirectories></includeDirectories> <libraryFiles><item>db2sys.dll</item> <item>db2app.dll</item> <item>db2util.dll</item></libraryFiles> <libraryDirectories></libraryDirectories> false full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2APIWinInterface
DB2APIWinInterface defines calling conventions for DB2 Administrative API on the Windows platform.
</comment> <class> <name>DB2DataLinkBuffer</name> <environment>Database</environment> <super>Database.DB2Buffer</super> <private>false</private> none valuePointer linkTypePointer commentPointer stringLengthPointer <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2DataLinkBuffer
DB2DataLinkBuffer extends DB2Buffer to deal with DB2 DATALINK types. Instance Variables: commentPointer <CPointer> Buffer to store DataLink comment. linkTypePointer <CPointer> Buffer to store DataLink type. stringLengthPointer <CPointer> Buffer to store the length of a DataLink attribute. valuePointer <CPointer> Buffer to store DataLink data location.
</comment> <class> <name>DB2DataLink</name> <environment>Database</environment> <super>Database.DB2DataType</super> <private>false</private> none dlValue comment complete path pathOnly scheme server needBuild <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2DataLink
DB2DataLink is the class which handles DB2 data type DATALINK. Instance Variables: comment <String> The DATALINK comment. complete <String> Complete URL to access a file. dlValue <String> DATALINK value (file reference),. needBuild <Boolean> Indicates whether the dlValue needs to be build. path <String> Path to access a file within a file server. pathOnly <String> File path only. scheme <String> Scheme of the DATALINK ('HTTP', 'FILE', 'UNC', 'DFS'). server <String> Server name where the file resides.
</comment> <class> <name>DB2Error</name> <environment>Database</environment> <super>Database.ExternalDatabaseError</super> <private>false</private> none sqlState <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Error
DB2Error adds information about the error returned from the CLI interface. Refer to the DB2 documentation for further details. Instance Variables: sqlState <String> Part of DB2's diagnostic information.
</comment> <class> <name>DB2Session</name> <environment>Database</environment> <super>Database.ExternalDatabaseSession</super> <private>false</private> none hstmtHolder resultsCache bindValuePointersHolder mustResendQueryHolder maxLongData currentRowIndex rowsInBlock totalRows pRowsFetchedHolder sqlStatementAttributeCache paramSetSize queryIsCALL mustCloseCursorHolder deferCursorClosing answerBlob rowStatus <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Session
DB2Session is the concrete implementation of session services using the DB2 CLI library. Instance Variables: answerBlob <Boolean> Indicates whether LOB locators or LOB values should be returned. bindValuePointersHolder <ValueHolder on: ((IdentityDictionary of: OracleBuffer) | nil)> Holds the DB2Buffers used to reference externally bound parameter values currentRowIndex <SmallInteger> Part of the support for utilizing the array interface for fetching rows. deferCursorClosing <Boolean> Indicates whether the cursor's closing should be defered until the session is reused. hstmtHolder <ValueHolder on: (CPointer | nil)> A private value holder which remembers the pointer for the current CLI statement handle, if any. The value holder is shared with the executor object. maxLongData <Integer> The maximum amount of data to be copied from BLOB or CLOB columns. mustCloseCursorHolder <Boolean> Indicates whether the cursor should be closed immediately. mustResendQueryHolder <ValueHolder on: Boolean> A private value holder which remembers whether the query text need to be sent to the server again. paramSetSize <SmallInteger> Indicates number of the parameters. pRowsFetchedHolder <ValueHolder on: (CPointer | nil)> Used to remember number of rows fetched from the server. queryIsCALL <Boolean> Indicates that whether the prepared query is a stored procedure call. resultsCache <Collection | nil> Stores a collection of DB2Error(s) associated with the statement handle. Used to tell resultsExternal the outcome of the operation. rowsInBlock <SmallInteger> Part of the support for utilizing the array interface for fetching rows. rowStatus <CPointer> Used to indicate the status of each row in the rowset. sqlStatementAttributeCache <IdentityDictionary> Used to cache statement attributes. totalRows <SmallInteger> Part of the support for utilizing the array interface for fetching rows.
</comment> <class> <name>DB2ColumnDescription</name> <environment>Database</environment> <super>Database.ExternalDatabaseColumnDescription</super> <private>false</private> none fSqlType fileRef <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2ColumnDescription
DB2ColumnDescription extends ExternalDatabaseColumnDescription to deal with DB2. Instance Variables: fileRef <DB2LOBFileReference> Remembers the DB2LOBFileReference instance used. fSqlType <SmallInteger | nil> SQL datatype code.
</comment> <class> <name>DB2DatabaseException</name> <environment>Database</environment> <super>Database.ExternalDatabaseException</super> <private>false</private> none <imports></imports> <category>DB2EXDI</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2DatabaseException
DB2DatabaseException is raised in case of DB2 database errors.
</comment> <class> <name>DB2APILinuxInterface</name> <environment>Database</environment> <super>Database.DB2APIInterface</super> <private>false</private> none <imports> Database.DB2APILinuxInterfaceDictionary.* </imports> <category>Database-DB2</category> <attributes> <includeFiles></includeFiles> <includeDirectories></includeDirectories> <libraryFiles><item>libdb2.so</item></libraryFiles> <libraryDirectories></libraryDirectories> false full <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2APILinuxInterface
DB2APILinuxInterface defines calling conventions for DB2 Administrative API on the Linux platform.
</comment> <class> <name>DB2BLOBLocator</name> <environment>Database</environment> <super>Database.DB2LOBLocator</super> <private>false</private> none <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2BLOBLocator
DB2BLOBLocator is the class which handles DB2 data type BlobLocator.
</comment> <class> <name>DB2Transaction</name> <environment>Database</environment> <super>Database.ExternalDatabaseTransaction</super> <private>false</private> none <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2Transaction
DB2Transaction is the concrete implementation of the transaction concept for DB2.
</comment> <class> <name>DB2LargeObjectBuffer</name> <environment>Database</environment> <super>Database.DB2Buffer</super> <private>false</private> none blobBuffer blobBufferSize maxLongData <imports></imports> <category>Database-DB2</category> <attributes> <package>DB2EXDI</package> </attributes> </class> <comment> Database.DB2LargeObjectBuffer
DB2LargeObjectBuffer extends DB2Buffer to deal with LOB data types in DB2. Instance Variables: blobBuffer <nil | CPointer> The buffer to hold piece of (or all) of LOB value. blobBufferSize <Integer> Size of the blobBuffer. maxLongData <Integer> The maximum amount of data to be copied from LOB columns.
</comment> <name>SupportedIsolationLevels</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>SQLInfoTypeConversionMap</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>RegisteredDB2Connections</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>HenvReferencesCount</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>HenvLock</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>Henv</name> <environment>Database.DB2Connection</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>ValueSizeBlocks</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>FetchBufferSizeBlocks</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>PutSelectorMap</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>ValuePrecisionBlocks</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>SQLTypeFromConversionMap</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>GetSelectorMap</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>ConversionBufferMap</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>CTypeFromConversionMap</name> <environment>Database.DB2Buffer</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>DefaultMaxLongData</name> <environment>Database.DB2Session</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>SQLStatementAttributeConversionMap</name> <environment>Database.DB2Session</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <name>RegisteredDB2Sessions</name> <environment>Database.DB2Session</environment> <private>false</private> <constant>false</constant> <category>As yet unclassified</category> <attributes> <package>DB2EXDI</package> </attributes> <methods> Database.DB2APIInterface <category>types</category>
db2int32 <C: typedef sqlint32 db2int32>
db2RestartDbStruct <C: typedef struct __db2RestartDbStruct db2RestartDbStruct>
db2Uint32 <C: typedef sqluint32 db2Uint32>
sqlint32 <C: typedef long sqlint32>
sqluint32 <C: typedef unsigned long sqluint32>
SQL_PDB_NODE_TYPE <C: typedef short SQL_PDB_NODE_TYPE>
SQL_PDB_PORT_TYPE <C: typedef int SQL_PDB_PORT_TYPE>
</methods> <methods> Database.DB2APIInterface <category>structs</category>
sqlca <C: struct sqlca { char sqlcaid[8]; sqlint32 sqlcabc, sqlcode; short sqlerrml; char sqlerrmc[70]; char sqlerrp[8]; sqlint32 sqlerrd[6]; char sqlwarn[11]; char sqlstate[5]; }>
sqledbstopopt <C: struct sqledbstopopt { sqluint32 isprofile; char profile[236]; sqluint32 isnodenum; SQL_PDB_NODE_TYPE nodenum; sqluint32 option, callerac; }>
sqledinfo <C: struct sqledinfo { char alias[8]; char dbname[8]; char drive[215]; char intname[8]; char nodename[8]; char dbtype[20]; char comment[30]; short com_codepage; char type; unsigned short authentication; char glbdbname[255]; char dceprincipal[1024]; short cat_nodenum, nodenum; }>
sqle_start_options <C: struct sqle_start_options { char sqloptid[8]; sqluint32 isprofile; char profile[236]; sqluint32 isnodenum; SQL_PDB_NODE_TYPE nodenum; sqluint32 option, ishostname; char hostname[256]; sqluint32 isport; SQL_PDB_PORT_TYPE port; sqluint32 isnetname; char netname[256]; sqluint32 tblspace_type; SQL_PDB_NODE_TYPE tblspace_node; sqluint32 iscomputer; char computer[16]; char * pUserName; char * pPassword; }>
__db2RestartDbStruct <C: struct __db2RestartDbStruct { char * piDatabaseName; char * piUserId; char * piPassword; char * piTablespaceNames; db2int32 iOption; }>
</methods> <methods> Database.DB2APIInterface <category>procedures</category>
sqlaintp: msgbuf with: bufsize with: linesize with: sqlcaptr | pMoFile rc | [ pMoFile := 'db2sql.mo' copyToHeap. rc:=self sqlaintp_api: msgbuf with: bufsize with: linesize with: pMoFile with: sqlcaptr] ensure: [pMoFile notNil ifTrue: [pMoFile free ]]. ^rc
</methods> <methods> Database.DB2APIInterface <category>accessing</category>
db2Version ^self db2Version710
mallocSelector ^#malloc:
</methods> <methods> Database.DB2APIInterface <category>defines</category>
db2Version710 <C: #define db2Version710 SQL_REL7100 >
SQL_ALL_USERS <C: #define SQL_ALL_USERS -1 >
SQL_ASYNCH <C: #define SQL_ASYNCH 0 >
SQL_STATS_ALL <C: #define SQL_STATS_ALL 65 >
SQL_STATS_BOTH <C: #define SQL_STATS_BOTH 66 >
SQL_STATS_CHG <C: #define SQL_STATS_CHG 67 >
SQL_STATS_EXTINDEX_ONLY <C: #define SQL_STATS_EXTINDEX_ONLY 88 >
SQL_STATS_EXTINDEX_TABLE <C: #define SQL_STATS_EXTINDEX_TABLE 89 >
SQL_STATS_EXTTABLE_INDEX <C: #define SQL_STATS_EXTTABLE_INDEX 69 >
SQL_STATS_EXTTABLE_ONLY <C: #define SQL_STATS_EXTTABLE_ONLY 68 >
SQL_STATS_INDEX <C: #define SQL_STATS_INDEX 73 >
SQL_STATS_REF <C: #define SQL_STATS_REF 82 >
SQL_STATS_TABLE <C: #define SQL_STATS_TABLE 84 >
</methods> <methods> Database.DB2APIInterface class <category>initialize</category>
initialize self initializeDefineCaches
initializeDefineCaches "This should only be done if the DLLCC development environment is present in the image." "self fillDefineCaches. self fillDefineCaches" "Do twice in case there are longer reference chains."
</methods> <methods> Database.DB2Connection <category>private-execution</category>
acquireExternal: aPassword " username and password on local instance of DB2 may be empty string, in this case current account is used" | xif rc name pw env szDSN szUID szAuthStr env1 nm1 pw1 | xif := self class xif. name := self username. [name isString] whileFalse: [name := self class requiredUsernameSignal raiseRequest]. pw := aPassword. [pw isString] whileFalse: [pw := self class requiredPasswordSignal raiseRequest]. (env := self environment) isNil ifTrue: [env := self class defaultEnvironment]. [env isString] whileFalse: [env := self class requiredEnvironmentSignal raiseRequest]. env := self class mapLogical: env. "Get required handles." HenvLock critical: [self unprotectedAllocConnect]. ["Begin unwind protection (level 1) -- ensure release of connection handle on failure." ["Begin unwind protection (level 2) -- ensure release of pointers on success or failure." szDSN := (env1 := env asByteArrayEncoding: self encoding) perform: xif copyToHeapSelector. szUID := (nm1 := name asByteArrayEncoding: self encoding) perform: xif copyToHeapSelector. szAuthStr := (pw1 := pw asByteArrayEncoding: self encoding) perform: xif copyToHeapSelector. rc := xif SQLConnect: self hdbc with: szDSN with: env1 size with: szUID with: nm1 size with: szAuthStr with: pw1 size. traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLConnect( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', szDSN = '; nextPutAll: env; nextPutAll: ', szUID = '; nextPutAll: name; nextPutAll: ', szAuthStr = ******* )'. self class trace: self emitTrace] "End unwind protection (level 2)"] ensure: [szAuthStr notNil ifTrue: [szAuthStr freePointer]. szUID notNil ifTrue: [szUID freePointer]. szDSN notNil ifTrue: [szDSN freePointer]]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getConnectionErrors. ^self class unableToConnectToSQLserverSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection (level 1)"] ifCurtailed: ["Some failure is causing unwind, don't keep the handles." HenvLock critical: [self unprotectedFreeConnect]]. "Enter autocommit mode on the transaction." self singleStatementTransactions "Set the correct isolation level for this connect" "self setIsolationLevel: (SupportedIsolationLevels at: isolationLevel)."
beginExternal super beginExternal. self multiStatementTransactions
commitExternal super commitExternal ifFalse: [ ^self ]. self transactExternal: #SQL_COMMIT. self singleStatementTransactions
cursorsAreClosed "Notify each participating session that the cursor was closed by some event (like commit or rollback)." self participantsDo: [ :each | each cursorIsClosed ]
cursorsAreDeleted "Notify each participating session that the cursor was deleted by some event (like commit or rollback)." self participantsDo: [ :each | each cursorIsDeleted ]
dismissExternal "Note: blobHstmt will be automatically dropped on SQLDisconnect() call" | xif rc | xif := self class xif. ["Begin unwind protection." self hdbc isNil ifTrue: [^self]. rc := xif SQLDisconnect: self hdbc. traceLevel >= 2 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLDisconnect( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. ^self class unableToDisconnectSignal raiseRequestWith: errs] "End unwind protection."] ensure: ["Whether or not there was a failure, there's no point in hanging onto the handles." HenvLock critical: [self unprotectedFreeConnect]. self supportedFunctions: IdentityDictionary new. self generalInformationCache: IdentityDictionary new]
getDataSourceExternal: fDirection "Return the next piece of error or status information, or NULL if none." | xif cbDSNMax cbDescriptionMax szDSN pcbDSN szDescription pcbDescription rc ds | xif := self class xif. cbDSNMax := xif SQL_MAX_DSN_LENGTH + 1. cbDescriptionMax := 254 + 1. [ "Begin unwind protection." szDSN := xif SQLCHAR perform: xif mallocSelector with: cbDSNMax. pcbDSN := xif SQLSMALLINT perform: xif mallocSelector with: 1. szDescription := xif SQLCHAR perform: xif mallocSelector with: cbDescriptionMax. pcbDescription := xif SQLSMALLINT perform: xif mallocSelector with: 1. HenvLock critical: [ "Begin critical section." rc := xif SQLDataSources: self class henv with: fDirection with: szDSN with: cbDSNMax with: pcbDSN with: szDescription with: cbDescriptionMax with: pcbDescription. (( rc == xif SQL_SUCCESS ) or: [ rc == xif SQL_SUCCESS_WITH_INFO ] ) ifTrue: [ ds := self class dataSourceClass new. ds name: szDSN copyCStringFromHeap. ds description: szDescription copyCStringFromHeap.] "End critical section." ] "End unwind protection." ] ensure: [ szDSN notNil ifTrue: [ szDSN freePointer ]. pcbDSN notNil ifTrue: [ pcbDSN freePointer ]. szDescription notNil ifTrue: [ szDescription freePointer ]. pcbDescription notNil ifTrue: [ pcbDescription freePointer ] ]. ^ds
getErrorsExternal: handleType handle: aHandle recNumber: aRecNumber "Return the next piece of error or status information, or nil if none." | xif szSqlState pfNativeError szErrorMsg cbErrorMsgMax pcbErrorMsg rc error | xif := self class xif. [ "Begin unwind protection." szSqlState := xif SQLCHAR perform: xif mallocSelector with: xif SQL_SQLSTATE_SIZE + 1. pfNativeError := xif SQLINTEGER perform: xif mallocSelector with: 1. szErrorMsg := xif SQLCHAR perform: xif mallocSelector with: (cbErrorMsgMax := xif SQL_MAX_MESSAGE_LENGTH + 1). pcbErrorMsg := xif SQLSMALLINT perform: xif mallocSelector with: 1. rc := xif SQLGetDiagRec: handleType with: aHandle with: aRecNumber with: szSqlState with: pfNativeError with: szErrorMsg with: cbErrorMsgMax with: pcbErrorMsg. rc == xif SQL_SUCCESS ifTrue: [ error := self class errorClass new. error dbmsErrorCode: pfNativeError contents. error dbmsErrorString: szErrorMsg copyCStringFromHeap. error sqlState: szSqlState copyCStringFromHeap. ( traceLevel >= 2 ) ifTrue: [ (self traceStream) print: rc; nextPutAll: ' = SQLGetDiagRec( handleType = *, handle = *, szSqlState = '; nextPutAll: error sqlState; nextPutAll: ', pfNativeError = '; print: error dbmsErrorCode; nextPutAll: ', szErrorMsg = '; nextPutAll: error dbmsErrorString; nextPutAll: ', cbErrorMsgMax = '; print: cbErrorMsgMax; nextPutAll: ', pcbErrorMsg = '; print: pcbErrorMsg contents; nextPutAll: ' )'; crtab. self class trace: self emitTrace ] ]. "End unwind protection." ] ensure: [ szSqlState notNil ifTrue: [ szSqlState freePointer ]. pfNativeError notNil ifTrue: [ pfNativeError freePointer ]. szErrorMsg notNil ifTrue: [ szErrorMsg freePointer ]. pcbErrorMsg notNil ifTrue: [ pcbErrorMsg freePointer ] ]. ^error
getInformationTypeExternal: fInfoTypeSymbol "Answer the information associated with fInfoTypeSymbol. This information is defined only after connecting." | xif cbInfoValueMax rgbInfoValue pcbInfoValue rc ub infoValue | xif := self class xif. cbInfoValueMax := 256. "Arbitrary number for a max." ["Begin unwind protection." rgbInfoValue := xif UCHAR perform: xif mallocSelector with: cbInfoValueMax. pcbInfoValue := xif SWORD perform: xif mallocSelector with: 1. rc := xif SQLGetInfo: self hdbc with: (xif perform: fInfoTypeSymbol) with: rgbInfoValue with: cbInfoValueMax with: pcbInfoValue. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getConnectionErrors. errs first sqlState = '40003' ifTrue: [^self]. ^self class unableToQueryDriverInformationSignal raiseWith: errs errorString: errs first dbmsErrorString]. ub := UninterpretedBytes new: pcbInfoValue contents. rgbInfoValue copyAt: 0 to: ub size: ub sizeInBytes startingAt: 1. infoValue := ub perform: (SQLInfoTypeConversionMap at: fInfoTypeSymbol) with: 1 "End unwind protection."] ensure: [rgbInfoValue notNil ifTrue: [rgbInfoValue freePointer]. pcbInfoValue notNil ifTrue: [pcbInfoValue freePointer]]. ^infoValue
getSupportedFunctionExternal: fFunctionSymbol "Answer a boolean indicating whether the function corresponding to the fFunctionSymbol is supported by the driver. This information is defined only after connecting as the specific driver to use is not defined yet." | xif rc pfSupportedPointer supported | xif := self class xif. ["Begin unwind protection." pfSupportedPointer := xif SQLUSMALLINT perform: xif mallocSelector with: 1. rc := xif SQLGetFunctions: self hdbc with: (xif perform: fFunctionSymbol) with: pfSupportedPointer. traceLevel >= 4 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetFunctions( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', fFunction = '; nextPutAll: fFunctionSymbol; nextPutAll: ', pfSupported ='; print: pfSupportedPointer contents; nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class unableToQueryDriverInformationSignal raiseWith: errs errorString: errs first dbmsErrorString]. supported := pfSupportedPointer contents == 1 "End unwind protection."] ensure: [pfSupportedPointer notNil ifTrue: [pfSupportedPointer freePointer]]. ^supported
installExternal super installExternal. self hdbc: nil. self supportedFunctions: IdentityDictionary new. self generalInformationCache: IdentityDictionary new.
multiStatementTransactions "Take the receiver's connection out of auto-commit mode for transaction behavior." "If receiver is connected to a driver which supports control over the autocommit behavior then this is the preferred mechanism for implementing the transaction behavior defined for the EXDI." | xif rc | xif := self class xif. rc := xif SQLSetConnectAttr: self hdbc with: xif SQL_ATTR_AUTOCOMMIT with: xif SQL_AUTOCOMMIT_OFF with: 0. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLSetConnectAttr( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF)'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class transactionExceptionSignal raiseWith: errs errorString: errs first dbmsErrorString]
rollbackExternal super rollbackExternal ifFalse: [ ^self ]. self transactExternal: #SQL_ROLLBACK. self singleStatementTransactions
setIsolationLevel: anIsolationLevel "Take the receiver's connection out of auto-commit mode for transaction behavior." | xif rc | xif := self class xif. rc := xif SQLSetConnectAttr: self hdbc with: xif SQL_ATTR_TXN_ISOLATION with: (xif perform: anIsolationLevel) with: 0. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLSetConnectAttr( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', SQL_ATTR_TXN_ISOLATION, '; nextPutAll: isolationLevel; nextPutAll: ')'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class transactionExceptionSignal raiseWith: errs errorString: errs first dbmsErrorString]
singleStatementTransactions "Put the receiver's connection into auto-commit mode for transaction behavior." | xif rc | xif := self class xif. rc := xif SQLSetConnectAttr: self hdbc with: xif SQL_ATTR_AUTOCOMMIT with: xif SQL_AUTOCOMMIT_ON with: 0. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLSetConnectAttr( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_ON)'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class transactionExceptionSignal raiseWith: errs errorString: errs first dbmsErrorString]
transactExternal: fTypeSymbol | xif rc behavior | xif := self class xif. rc := xif SQLEndTran: xif SQL_HANDLE_DBC with: self hdbc with: (xif perform: fTypeSymbol). traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLEndTran( handleType = SQL_HANDLE_DBC, hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', fType = '; nextPutAll: fTypeSymbol; nextPutAll: ')'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class transactionExceptionSignal raiseWith: errs errorString: errs first dbmsErrorString]. "What are the side effects of the end of the transaction." fTypeSymbol == #SQL_COMMIT ifTrue: [behavior := self getInformationType: #SQL_CURSOR_COMMIT_BEHAVIOR]. fTypeSymbol == #SQL_ROLLBACK ifTrue: [behavior := self getInformationType: #SQL_CURSOR_ROLLBACK_BEHAVIOR]. behavior == xif SQL_CB_DELETE ifTrue: [self cursorsAreDeleted]. behavior == xif SQL_CB_CLOSE ifTrue: [self cursorsAreClosed]
</methods> <methods> Database.DB2Connection <category>private-accessing</category>
blobHstmt blobHstmt isNil ifTrue: [self getBlobHstmt]. ^blobHstmt
generalInformationCache ^generalInformationCache
generalInformationCache: anIdentityDictionary generalInformationCache := anIdentityDictionary
getBlobHstmt "Acquire statement handle for LOB handling." | xif phstmt rc | xif := self class xif. ["Begin unwind protection." phstmt := xif SQLHSTMT perform: xif mallocSelector with: 1. rc := xif SQLAllocHandle: xif SQL_HANDLE_STMT with: self hdbc with: phstmt. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLAllocStmt( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ', hstmt = '; nextPutAll: (phstmt contents printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getConnectionErrors. self class connectionClass unableToAllocateHandleSignal raiseWith: errs errorString: errs first dbmsErrorString]. blobHstmt := phstmt contents "End unwind protection."] ensure: [phstmt notNil ifTrue: [phstmt freePointer]]
getConnectionErrors "Return a collection of DB2Error(s) associated with the connection handle." | xif errors err num | xif := self class xif. errors := OrderedCollection new. num:=0. [ (err := self getErrorsExternal: xif SQL_HANDLE_DBC handle: self hdbc recNumber: (num:=num+1)) notNil ] whileTrue: [ errors add: err ]. ^errors
getEnvironmentErrors "Answer a collection of DB2Error(s) associated with the environment handle." | xif errors err num | xif := self class xif. errors := OrderedCollection new. num:=0. HenvLock critical: [ "Begin critical section." [ (err := self getErrorsExternal: xif SQL_HANDLE_ENV handle: self class henv recNumber: (num:=num+1)) notNil ] whileTrue: [ errors add: err ]. "End critical section." ]. ^errors
getInformationType: anInfoTypeSymbol "Answer driver sql type information" | gic | ^(gic := self generalInformationCache) at: anInfoTypeSymbol ifAbsent: [ | infoType | infoType := self getInformationTypeExternal: anInfoTypeSymbol. gic at: anInfoTypeSymbol put: infoType. infoType ].
getStatementErrors: hstmt "Return a collection of DB2Error(s) associated with the statement handle. This message send by DB2Buffer " | xif errors err num | xif := self class xif. errors := OrderedCollection new. num:=0. [ (err := self getErrorsExternal: xif SQL_HANDLE_STMT handle: hstmt recNumber: (num:=num+1)) notNil ] whileTrue: [ errors add: err ]. ^errors
hdbc ^self hdbcHolder value
hdbc: aCPointerOrNil "Now hdbc is Integer" self hdbcHolder value: aCPointerOrNil
hdbcHolder ^hdbcHolder
hdbcHolder: aValueHolder hdbcHolder := aValueHolder
isolationLevel: newIsolationLevel "Set the current isolation level." | externalIsolationLevel | externalIsolationLevel := SupportedIsolationLevels at: newIsolationLevel ifAbsent: [ExternalDatabaseConnection unsupportedIsolationLevelSignal raise]. self isConnected ifTrue: [self setIsolationLevel: externalIsolationLevel]. isolationLevel := newIsolationLevel
supportedFunctions ^supportedFunctions
supportedFunctions: anIdentityDictionary supportedFunctions := anIdentityDictionary
supportsFunction: fFunctionSymbol "Answer if the attached driver supports the given function" | sf | ^(sf := self supportedFunctions) at: fFunctionSymbol ifAbsent: [ | supported | supported := self getSupportedFunctionExternal: fFunctionSymbol. sf at: fFunctionSymbol put: supported. supported ]
traceLevel ^traceLevel
</methods> <methods> Database.DB2Connection <category>accessing</category>
dataSources "Return a List of accessible DB2DataSource instances. The receiver does not need to be connected." | xif dataSources fDirection ds | xif := self class xif. "If we don't have an environment handle allocated, get one now." HenvLock critical: [ self unprotectedAddHenvReference ]. [ "Begin unwind protection." dataSources := List new. fDirection := xif SQL_FETCH_FIRST. [ (ds := self getDataSourceExternal: fDirection) notNil ] whileTrue: [ fDirection := xif SQL_FETCH_NEXT. dataSources add: ds ]. "End unwind protection." ] ensure: [ HenvLock critical: [ self unprotectedDropHenvReference ] ]. ^dataSources
dbmsName "Answer the name of the DBMS product being accessed" ^self getInformationType: #SQL_DBMS_NAME.
dbmsVersion "Answer the version of the DBMS product being accessed" ^self getInformationType: #SQL_DBMS_VER.
delimitedIdentifierCharacter "Answer the delimiter of the DBMS product being accessed a space indicates no delimited identifiers supported" ^self getInformationType: #SQL_IDENTIFIER_QUOTE_CHAR.
encoding ^self class xif encoding
</methods> <methods> Database.DB2Connection <category>private-finalization</category>
executor | ex | ex := super executor. ex hdbcHolder: self hdbcHolder. ex supportedFunctions: IdentityDictionary new. ex generalInformationCache: IdentityDictionary new. ^ex
finalizeExternal self hdbc isNil ifTrue: [ ^self ]. ( traceLevel >= 1 ) ifTrue: [ self class trace: nil ]. super finalizeExternal
key "The hdbcHolder is unique to the connection and is constant across pause/resume." ^self hdbcHolder
</methods> <methods> Database.DB2Connection <category>datalink-functions</category>
getDLAttribute: attributeName for: aDataLink "attributeName from: #SQL_ATTR_DATALINK_COMMENT #SQL_ATTR_DATALINK_LINKTYPE #SQL_ATTR_DATALINK_URLCOMPLETE (complete URL to access a file) #SQL_ATTR_DATALINK_URLPATH (to access a file within a file server) #SQL_ATTR_DATALINK_URLPATHONLY (file path only) #SQL_ATTR_DATALINK_URLSCHEME #SQL_ATTR_DATALINK_URLSERVER" | xif attr rc bytes attrString pDataLink pValue pLength | xif := self class xif. attr := xif perform: attributeName. [pDataLink := aDataLink dlValue copyToHeap. pValue := CIntegerType char malloc: 256. "max attr size" pLength := xif SQLINTEGER malloc: 1. rc := xif SQLGetDataLinkAttr: self blobHstmt with: attr with: pDataLink with: aDataLink dlValue size with: pValue with: 256 with: pLength. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors: self blobHstmt. ^self class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. pLength isNull ifTrue: [^nil]. bytes := pLength contents. attrString := ByteString new: bytes. pValue copyAt: 0 to: attrString size: bytes startingAt: 1] ensure: [pDataLink notNil ifTrue: [pDataLink freePointer]. pValue notNil ifTrue: [pValue freePointer]. pLength notNil ifTrue: [pLength freePointer]]. ^attrString
</methods> <methods> Database.DB2Connection <category>blob-functions</category>
getLOBLength: aLocator "Retrieve length of a string/blob value" | xif pStringLength pIndicatorValue rc result | xif := self class xif. ["Begin unwind protection." pStringLength := xif SQLINTEGER perform: xif mallocSelector with: 1. pIndicatorValue := xif SQLINTEGER perform: xif mallocSelector with: 1. rc := xif SQLGetLength: self blobHstmt with: aLocator locatorCType with: aLocator locator with: pStringLength with: pIndicatorValue. traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetLength:( hstmt = '; nextPutAll: (self blobHstmt printStringRadix: 16); nextPutAll: ', locatorCType = '; nextPutAll: aLocator locatorCType printString; nextPutAll: ', aLocator = '; nextPutAll: (aLocator locator printStringRadix: 16); nextPutAll: ', StringLength = ' , pStringLength contents printString. self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifTrue: [result := pStringLength contents] ifFalse: [| errs | errs := self getStatementErrors: self blobHstmt. "self resultsCache: errs." self class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [pStringLength notNil ifTrue: [pStringLength freePointer]. pIndicatorValue notNil ifTrue: [pIndicatorValue freePointer]]. ^result
getLOBPosition: aLocator search: aStringOrLocator from: aPosition "Retrieve position of a sub-string/blob value" | xif pLocatedAt pIndicatorValue rc result searchLocator searchLiteralLength searchLiteral | xif := self class xif. ["Begin unwind protection." pLocatedAt := xif SQLINTEGER perform: xif mallocSelector with: 1. pIndicatorValue := xif SQLINTEGER perform: xif mallocSelector with: 1. aStringOrLocator class == DB2LOBLocator ifTrue: [searchLocator := aStringOrLocator locator. searchLiteralLength := 0. searchLiteral := nil] ifFalse: [searchLocator := 0. "ignored" searchLiteralLength := aStringOrLocator size. searchLiteral := aStringOrLocator copyToHeap]. rc := xif SQLGetPosition: self blobHstmt with: aLocator locatorCType with: aLocator locator with: searchLocator with: searchLiteral with: searchLiteralLength with: aPosition with: pLocatedAt with: pIndicatorValue. traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetPosition ( hstmt = '; nextPutAll: (self blobHstmt printStringRadix: 16); nextPutAll: ', locatorCType = '; nextPutAll: aLocator locatorCType printString; nextPutAll: ', aLocator = '; nextPutAll: (aLocator locator printStringRadix: 16); nextPutAll: ', LocatedAt = ' , pLocatedAt contents printString. self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifTrue: [result := pLocatedAt contents] ifFalse: [| errs | errs := self getStatementErrors: self blobHstmt. "self resultsCache: errs." self class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [pLocatedAt notNil ifTrue: [pLocatedAt freePointer]. pIndicatorValue notNil ifTrue: [pIndicatorValue freePointer]. searchLiteral notNil ifTrue: [searchLiteral freePointer]]. ^result
getLOBSubString: aLocator from: aPosition length: aLength asLocator: aBoolean "Retrieve substring of a string/blob value " | xif pIndicatorValue rc result targetCType dataPtr bufferLength | xif := self class xif. ["Begin unwind protection." pIndicatorValue := xif SQLINTEGER perform: xif mallocSelector with: 1. aBoolean ifTrue: [targetCType := aLocator locatorCType. dataPtr := xif SQLINTEGER perform: xif mallocSelector with: 1. "LOB locator " bufferLength := 4] ifFalse: [targetCType := aLocator targetCType. bufferLength := aLength + 1. "(targetCType == xif SQL_C_CHAR ifTrue: [1] ifFalse: [0])" dataPtr := xif SQLCHAR perform: xif mallocSelector with: bufferLength " string/bytearray value"]. rc := xif SQLGetSubString: self blobHstmt with: aLocator locatorCType with: aLocator locator with: aPosition with: aLength with: targetCType with: dataPtr with: bufferLength with: nil with: pIndicatorValue. "pStringLength" traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetSubString ( hstmt = '; nextPutAll: (self blobHstmt printStringRadix: 16); nextPutAll: ', locatorCType = '; nextPutAll: aLocator locatorCType printString; nextPutAll: ', targetCType = '; nextPutAll: aLocator targetCType printString; nextPutAll: ', aLocator = '; nextPutAll: (aLocator locator printStringRadix: 16); nextPutAll: ', dataPtr = ' , (dataPtr referentAddress printStringRadix: 16). self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifTrue: [aBoolean ifTrue: [result := (DB2LOBLocator asType: aLocator db2Conversion) locator: dataPtr contents] ifFalse: [result := ByteArray new: aLength. dataPtr copyAt: 0 to: result size: aLength startingAt: 1. targetCType == xif SQL_C_CHAR ifTrue: [result := result asStringEncoding: self encoding]]] ifFalse: [| errs | errs := self getStatementErrors: self blobHstmt. "self resultsCache: errs." self class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [dataPtr notNil ifTrue: [dataPtr freePointer]. pIndicatorValue notNil ifTrue: [pIndicatorValue freePointer]]. ^result
</methods> <methods> Database.DB2Connection <category>blob-private</category>
getLOBLength: aLocator buffer: aBuffer "Retrieve length of a string/blob value" ^self getLOBLength: aLocator
getLOBSubString: aLocator from: aPosition length: aLength buffer: aBuffer "Retrieve substring of a string/blob value Private: for DB2LargeBuffer only" | xif pIndicatorValue rc | xif := self class xif. ["Begin unwind protection." pIndicatorValue := xif SQLINTEGER perform: xif mallocSelector with: 1. rc := xif SQLGetSubString: self blobHstmt with: aLocator locatorCType with: aLocator locator with: aPosition with: aLength with: aLocator targetCType with: aBuffer blobBuffer with: aBuffer blobBufferSize with: nil with: pIndicatorValue. "dataPtr" "pStringLength" traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetSubString ( hstmt = '; nextPutAll: (self blobHstmt printStringRadix: 16); nextPutAll: ', locatorCType = '; nextPutAll: aLocator locatorCType printString; nextPutAll: ', targetCType = '; nextPutAll: aLocator targetCType printString; nextPutAll: ', aLocator = '; nextPutAll: (aLocator locator printStringRadix: 16); nextPutAll: ', dataPtr = ' , (aBuffer blobBuffer referentAddress printStringRadix: 16). self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors: self blobHstmt. "self resultsCache: errs." self class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [pIndicatorValue notNil ifTrue: [pIndicatorValue freePointer]]. ^self
</methods> <methods> Database.DB2Connection <category>initialize-release</category>
initialize "Establish initial value for instance variables." super initialize. self hdbcHolder: nil asValue. supportedFunctions := IdentityDictionary new. generalInformationCache := IdentityDictionary new. "self isolationLevel: #RR"
</methods> <methods> Database.DB2Connection <category>private-testing</category>
isDbmsVersion6 "Answer the version of the DBMS product being accessed" ^(self dbmsVersion at: 2) >= $6
</methods> <methods> Database.DB2Connection <category>printing</category>
printOn: aStream | hdbc | super printOn: aStream. (hdbc := self hdbc) isNil ifFalse: [aStream nextPutAll: '( hdbc = '; nextPutAll: (hdbc printStringRadix: 16); nextPutAll: ' )']
</methods> <methods> Database.DB2Connection <category>private-handles</category>
unprotectedAddHenvReference "Acquire an environment handle if needed and record a reference. Senders must ensure protection using HenvLock. If this method completes normally, resources are held that should be released explicitly using #unprotectedDropHenvReference." | xif phenv rc | xif := self class xif. "Not too much to do if environment handle already allocated." Henv notNil ifTrue: ["One more reference to the Henv." HenvReferencesCount := HenvReferencesCount + 1. ^self]. "Get the environment handle." [ ["Begin unwind protection" phenv := xif SQLHENV perform: xif mallocSelector with: 1. rc := xif SQLAllocHandle: xif SQL_HANDLE_ENV with: xif SQL_NULL_HANDLE with: phenv. traceLevel >= 3 ifTrue: [self traceStream print: rc; nextPutAll: ' = SQLAllocHandle(), henv = '; nextPutAll: (phenv contents printStringRadix: 16). self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [^self class unableToAllocateHandleSignal raise]. "Save environment handle" Henv := phenv contents. HenvReferencesCount := 1 "End unwind protection."] ensure: [phenv notNil ifTrue: [phenv freePointer]]] on: Object errorSignal do: [:ex | self class externalDatabaseLibraryInaccessibleSignal raise]
unprotectedAllocConnect "Acquire reference to environment handle and then allocate a connection handle. Senders must ensure protection using HenvLock. If this method completes normally, resources are held that should be released explicitly using #unprotectedFreeConnect." | xif phdbc rc | xif := self class xif. "Make sure we have a reference to the environment handle." self unprotectedAddHenvReference. ["Begin unwind protection (level 1) -- ensure release of environment handle on failure." ["Begin unwind protection (level 2) -- ensure release of pointers on success or failure." phdbc := xif SQLHDBC perform: xif mallocSelector with: 1. rc := xif SQLAllocHandle: xif SQL_HANDLE_DBC with: self class henv with: phdbc. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLAllocConnect( henv = '; nextPutAll: (self class henv printStringRadix: 16); nextPutAll: ', *phdbc = '; nextPutAll: (phdbc contents printStringRadix: 16); nextPutAll: ')'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getEnvironmentErrors. ^self class unableToAllocateHandleSignal raiseWith: errs errorString: errs first dbmsErrorString]. self hdbc: phdbc contents "End unwind protection (level 2)"] ensure: [phdbc notNil ifTrue: [phdbc freePointer]] "End unwind protection (level 1)"] ifCurtailed: ["Some failure is causing unwind, don't keep the environment handle reference." self unprotectedDropHenvReference]
unprotectedDropHenvReference "Remove a reference to the environment handle. If no references left, release the handle. Senders must ensure protection using HenvLock." | xif rc | xif := self class xif. "Reduce the reference count." (HenvReferencesCount := HenvReferencesCount - 1) > 0 ifTrue: ["Little to do if other references still remain." ^self]. ["Begin unwind protection." Henv isNil ifTrue: [^self]. rc := xif SQLFreeHandle: xif SQL_HANDLE_ENV with: Henv. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLFreeEnv( henv = '; nextPutAll: (Henv printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getEnvironmentErrors. ^self class unableToFreeResourceSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [Henv := nil]
unprotectedFreeConnect "Free the connection handle and then release reference to environment handle. Senders must ensure protection using HenvLock." | xif rc | xif := self class xif. ["Begin unwind protection" self hdbc isNil ifTrue: [^self]. rc := xif SQLFreeHandle: xif SQL_HANDLE_DBC with: self hdbc. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLFreeConnect( hdbc = '; nextPutAll: (self hdbc printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getEnvironmentErrors. errs isEmpty ifTrue: [^self]. ^self class unableToFreeResourceSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: ["Whether or not there was a failure, there's no point in hanging onto these." self hdbc: nil. self unprotectedDropHenvReference]
</methods> <methods> Database.DB2Connection class <category>accessing</category>
apiInterfaceClass "Answer the correct interface class" | interfaceClassName | apiXifMap isNil ifTrue: [self initializeInterfaceMapping]. interfaceClassName := apiXifMap at: self platformType ifAbsent: [nil]. ^interfaceClassName notNil ifTrue: [ self environment at: interfaceClassName ifAbsent: [nil] ] ifFalse: [nil]
apiXif "Answer the ExternalInterface subclass instance to use." apiXif isNil ifTrue: [ self initializeExternalInterface ]. ^apiXif
apiXif: anExternalInterface apiXif := anExternalInterface
bufferClass "Answer the buffer class for sessions" ^DB2Buffer
columnDescriptionClass "Answer the class to use for column description objects associated with receiver." ^DB2ColumnDescription
dataSourceClass "Answer the error class for the receiver." ^DB2DataSource
errorClass "Answer the error class for the receiver." ^DB2Error
henv ^Henv
interfaceClass "Answer the correct interface class" | interfaceClassName | xifMap isNil ifTrue: [self initializeInterfaceMapping]. interfaceClassName := xifMap at: self platformType ifAbsent: [nil]. ^interfaceClassName notNil ifTrue: [ self environment at: interfaceClassName ifAbsent: [nil] ] ifFalse: [nil]
kind "Answer a symbol representing the type of DMBS the receiver provides services for." ^#'DB2/UDB'
sessionClass "Answer the class to use for session objects associated with receiver." ^DB2Session
storeBroker "Answer a broker class for Store" ^Store.DB2Broker
transactionClass "Answer the class to use for transaction objects associated with receiver." ^DB2Transaction
version ^'DB2/UDB Connect - Release 1.4 '
xif "Answer the ExternalInterface subclass instance to use." xif isNil ifTrue: [ self initializeExternalInterface ]. ^xif
</methods> <methods> Database.DB2Connection class <category>class initialization</category>
determinePlatformType "Answer a symbol representing the current platform type." "ExternalInterface must complete its #returnFromSnapshot processing before this method can be safely invoked." | platformArray platformSymbol osNameString | platformArray := ExternalInterface currentPlatform. platformSymbol := platformArray at: 1. osNameString := platformArray at: 2. #unix == platformSymbol ifTrue: [^self determineUnixPlatformFrom: osNameString]. #win32 == platformSymbol ifTrue: [^#nt]. ^#unknown.
determineUnixPlatformFrom: unixOSNameString "Answer a symbol representing the current platform type." "ExternalInterface must complete its #returnFromSnapshot processing before this method can be safely invoked." "Digital Unix ^#alpha_unix HP Unix ^#hp_unix IBM Aix ^#aix_unix Sun Solaris ^#sun5_unix Sun SunOS ^#sun4_unix i386 Linux ^#linux_i386_unix" | tokens | tokens := unixOSNameString tokensBasedOn: Character space. "(tokens includes: 'osf1') ifTrue: [^#alpha_unix]. (tokens includes: 'hp-ux') ifTrue: [^#hp_unix]. (tokens includes: 'aix') ifTrue: [^#aix_unix]. (tokens includes: 'solaris') ifTrue: [^#sun5_unix]. ((tokens includes: 'bsd') and: [tokens includes: 'sun']) ifTrue: [^#sun4_unix]." ((tokens includes: 'I386') and: [tokens includes: 'linux']) ifTrue:[^#linux_i386_unix]. ^#unknown
initialize "DB2Connection initialize" Henv := nil. PlatformType:=nil. "!" HenvLock := RecursionLock new. HenvReferencesCount := 0. self initializeInterfaceMapping. self xif: nil. self apiXif: nil. self initRegistry. SupportedIsolationLevels := IdentityDictionary new. SupportedIsolationLevels at: #RR put: #SQL_TXN_SERIALIZABLE. " Repeatable Read " SupportedIsolationLevels at: #RS put: #SQL_TXN_REPEATABLE_READ. "Read Stability" SupportedIsolationLevels at: #RC put: #SQL_TXN_READ_COMMITTED. "Read Commited" SupportedIsolationLevels at: #CS put: #SQL_TXN_READ_COMMITTED. "Cursor Stability alias" SupportedIsolationLevels at: #RU put: #SQL_TXN_READ_UNCOMMITED. "Uncommitted Read " SupportedIsolationLevels at: #NC put: #SQL_TXN_NOCOMMIT. "No Commit" SupportedIsolationLevels at: #serializable put: #SQL_TXN_SERIALIZABLE. "SupportedIsolationLevels at: #versioning put: #SQL_TXN_VERSIONING." self sessionClass initialize.
initializeExternalInterface "Reset xif call with the right interface class based on the current platform." | xifClass | xifClass := self interfaceClass. self xif: (xifClass notNil ifTrue: [xifClass new] ifFalse: [nil]). self xif isNil ifTrue: [^Dialog warn: 'The DB2 CLI Driver is not correctly installed.' withCRs]. xifClass := self apiInterfaceClass. self apiXif: (xifClass notNil ifTrue: [xifClass new] ifFalse: [nil]). self initializeInformationTypeConversionMap.
initializeInformationTypeConversionMap "DB2Connection initializeInformationTypeConversionMap" (SQLInfoTypeConversionMap := IdentityDictionary new) add: #SQL_MAX_DRIVER_CONNECTIONS->#stringAt:; add: #SQL_MAX_CONCURRENT_ACTIVITIES->#shortAt:; add: #SQL_DATA_SOURCE_NAME->#stringAt:; add: #SQL_DRIVER_HDBC->#longAt:; add: #SQL_DRIVER_HENV->#longAt:; add: #SQL_DRIVER_HSTMT->#longAt:; add: #SQL_DRIVER_NAME->#stringAt:; add: #SQL_DRIVER_VER->#stringAt:; add: #SQL_FETCH_DIRECTION->#longAt:; add: #SQL_ODBC_API_CONFORMANCE->#shortAt:; add: #SQL_ODBC_VER->#stringAt:; add: #SQL_ROW_UPDATES->#stringAt:; add: #SQL_ODBC_SAG_CLI_CONFORMANCE->#shortAt:; add: #SQL_SERVER_NAME->#stringAt:; add: #SQL_SEARCH_PATTERN_ESCAPE->#stringAt:; add: #SQL_ODBC_SQL_CONFORMANCE->#shortAt:; add: #SQL_DATABASE_NAME->#stringAt:; add: #SQL_DBMS_NAME->#stringAt:; add: #SQL_DBMS_VER->#stringAt:; add: #SQL_ACCESSIBLE_TABLES->#stringAt:; add: #SQL_ACCESSIBLE_PROCEDURES->#stringAt:; add: #SQL_PROCEDURES->#stringAt:; add: #SQL_CONCAT_NULL_BEHAVIOR->#shortAt:; add: #SQL_CURSOR_COMMIT_BEHAVIOR->#shortAt:; add: #SQL_CURSOR_ROLLBACK_BEHAVIOR->#shortAt:; add: #SQL_DATA_SOURCE_READ_ONLY->#stringAt:; add: #SQL_DEFAULT_TXN_ISOLATION->#longAt:; add: #SQL_EXPRESSIONS_IN_ORDERBY->#stringAt:; add: #SQL_IDENTIFIER_CASE->#shortAt:; add: #SQL_IDENTIFIER_QUOTE_CHAR->#stringAt:; add: #SQL_MAX_COLUMN_NAME_LEN->#shortAt:; add: #SQL_MAX_CURSOR_NAME_LEN->#shortAt:; add: #SQL_MAX_SCHEMA_NAME_LEN ->#shortAt:; add: #SQL_MAX_PROCEDURE_NAME_LEN->#shortAt:; add: #SQL_MAX_CATALOG_NAME_LEN ->#shortAt:; add: #SQL_MAX_TABLE_NAME_LEN->#shortAt:; add: #SQL_MULT_RESULT_SETS->#stringAt:; add: #SQL_MULTIPLE_ACTIVE_TXN->#stringAt:; add: #SQL_OUTER_JOINS->#stringAt:; add: #SQL_OWNER_TERM->#stringAt:; add: #SQL_PROCEDURE_TERM->#stringAt:; add: #SQL_QUALIFIER_NAME_SEPARATOR->#stringAt:; add: #SQL_QUALIFIER_TERM->#stringAt:; add: #SQL_SCROLL_CONCURRENCY->#longAt:; add: #SQL_SCROLL_OPTIONS->#longAt:; add: #SQL_TABLE_TERM->#stringAt:; add: #SQL_TXN_CAPABLE->#shortAt:; add: #SQL_USER_NAME->#stringAt:; add: #SQL_CONVERT_FUNCTIONS->#longAt:; add: #SQL_NUMERIC_FUNCTIONS->#longAt:; add: #SQL_STRING_FUNCTIONS->#longAt:; add: #SQL_SYSTEM_FUNCTIONS->#longAt:; add: #SQL_TIMEDATE_FUNCTIONS->#longAt:; add: #SQL_TXN_ISOLATION_OPTION->#longAt:; add: #SQL_INTEGRITY->#stringAt:; add: #SQL_GETDATA_EXTENSIONS->#longAt:.
initializeInterfaceMapping "only once interface" xifMap := IdentityDictionary new. xifMap at: #nt put: #DB2CLIWinInterface. xifMap at: #win95 put: #DB2CLIWinInterface. xifMap at: #linux_i386_unix put: #DB2CLILinuxInterface. xifMap at: #unknown put: #DB2CLILinuxInterface. apiXifMap := IdentityDictionary new. apiXifMap at: #nt put: #DB2APIWinInterface. apiXifMap at: #win95 put: #DB2APIWinInterface. apiXifMap at: #linux_i386_unix put: #DB2APILinuxInterface. apiXifMap at: #unknown put: #DB2APILinuxInterface
postLoadActionFor: aParcel "If there is no default Database Connect, make this the default." ExternalDatabaseConnection defaultConnection isNil ifTrue: [ExternalDatabaseConnection defaultConnection: #DB2Connection ].
</methods> <methods> Database.DB2Connection class <category>private-activation</category>
install ( TraceLevel >= 1 ) ifTrue: [ self trace: nil ]. Henv := nil. HenvReferencesCount := 0. self xif: nil. self apiXif: nil. self sessionClass install. self returnFromSnapshot
</methods> <methods> Database.DB2Connection class <category>activation</category>
pause ^self quiesce
resume ^self activate
</methods> <methods> Database.DB2Connection class <category>private-registry</category>
registry ^RegisteredDB2Connections
registry: aCollection RegisteredDB2Connections := aCollection
</methods> <methods> Database.DB2Connection class <category>signal constants</category>
unableToQueryStatementAttributesSignal ^DB2DatabaseException notifierString: 'Unable to query statement attributes'
</methods> <methods> Database.DB2CLIInterface <category>structs</category>
sqlca <C: struct sqlca { char sqlcaid[8]; sqlint32 sqlcabc, sqlcode; short sqlerrml; char sqlerrmc[70]; char sqlerrp[8]; sqlint32 sqlerrd[6]; char sqlwarn[11]; char sqlstate[5]; }>
tagSQL_DAY_SECOND <C: struct tagSQL_DAY_SECOND { SQLUINTEGER day, hour, minute, second, fraction; }>
tagSQL_INTERVAL_STRUCT <C: struct tagSQL_INTERVAL_STRUCT { SQLINTERVAL interval_type; SQLSMALLINT interval_sign; union { SQL_YEAR_MONTH_STRUCT year_month; SQL_DAY_SECOND_STRUCT day_second; } intval; }>
tagSQL_NUMERIC_STRUCT <C: struct tagSQL_NUMERIC_STRUCT { SQLCHAR precision; SQLSCHAR scale; SQLCHAR sign; SQLCHAR val[16]; }>
tagSQL_YEAR_MONTH <C: struct tagSQL_YEAR_MONTH { SQLUINTEGER year, month; }>
__DATE_STRUCT <C: struct __DATE_STRUCT { SQLSMALLINT year; SQLUSMALLINT month, day; }>
__TIMESTAMP_STRUCT <C: struct __TIMESTAMP_STRUCT { SQLSMALLINT year; SQLUSMALLINT month, day, hour, minute, second; SQLUINTEGER fraction; }>
__TIME_STRUCT <C: struct __TIME_STRUCT { SQLUSMALLINT hour, minute, second; }>
</methods> <methods> Database.DB2CLIInterface <category>types</category>
DATE_STRUCT <C: typedef struct __DATE_STRUCT DATE_STRUCT>
DWORD <C: typedef sqlint32 DWORD>
HDBC <C: typedef void * HDBC>
HENV <C: typedef void * HENV>
HSTMT <C: typedef void * HSTMT>
HWND <C: typedef void * HWND>
LDOUBLE <C: typedef double LDOUBLE>
LPWSTR <C: typedef char * LPWSTR>
PSDWORD <C: typedef SDWORD * PSDWORD>
PTR <C: typedef void * PTR>
RETCODE <C: typedef short RETCODE>
SCHAR <C: typedef char SCHAR>
SDOUBLE <C: typedef double SDOUBLE>
SDWORD <C: typedef sqlint32 SDWORD>
SFLOAT <C: typedef float SFLOAT>
SLONG <C: typedef sqlint32 SLONG>
SQLBIGINT <C: typedef long long SQLBIGINT>
SQLCHAR <C: typedef UCHAR SQLCHAR>
SQLDATE <C: typedef unsigned char SQLDATE>
SQLDBCHAR <C: typedef unsigned short SQLDBCHAR>
SQLDECIMAL <C: typedef unsigned char SQLDECIMAL>
SQLDOUBLE <C: typedef SDOUBLE SQLDOUBLE>
SQLFLOAT <C: typedef SDOUBLE SQLFLOAT>
SQLHANDLE <C: typedef SQLINTEGER SQLHANDLE>
SQLHDBC <C: typedef SQLINTEGER SQLHDBC>
SQLHDESC <C: typedef SQLHANDLE SQLHDESC>
SQLHENV <C: typedef SQLINTEGER SQLHENV>
SQLHSTMT <C: typedef SQLINTEGER SQLHSTMT>
SQLHWND <C: typedef HWND SQLHWND>
sqlint16 <C: typedef short sqlint16>
sqlint32 <C: typedef long sqlint32>
sqlint64 <C: typedef long long sqlint64>
sqlint8 <C: typedef char sqlint8>
SQLINTEGER <C: typedef SDWORD SQLINTEGER>
SQLINTERVAL <C: typedef enum { SQL_IS_YEAR = 1, SQL_IS_MONTH, SQL_IS_DAY, SQL_IS_HOUR, SQL_IS_MINUTE, SQL_IS_SECOND, SQL_IS_YEAR_TO_MONTH, SQL_IS_DAY_TO_HOUR, SQL_IS_DAY_TO_MINUTE, SQL_IS_DAY_TO_SECOND, SQL_IS_HOUR_TO_MINUTE, SQL_IS_HOUR_TO_SECOND, SQL_IS_MINUTE_TO_SECOND } SQLINTERVAL>
sqlintptr <C: typedef sqlint32 sqlintptr>
SQLNUMERIC <C: typedef unsigned char SQLNUMERIC>
SQLPOINTER <C: typedef PTR SQLPOINTER>
SQLREAL <C: typedef SFLOAT SQLREAL>
SQLRETURN <C: typedef SQLSMALLINT SQLRETURN>
SQLSCHAR <C: typedef SCHAR SQLSCHAR>
SQLSMALLINT <C: typedef SWORD SQLSMALLINT>
SQLTCHAR <C: typedef SQLCHAR SQLTCHAR>
SQLTIME <C: typedef unsigned char SQLTIME>
SQLTIMESTAMP <C: typedef unsigned char SQLTIMESTAMP>
SQLUBIGINT <C: typedef unsigned long long SQLUBIGINT>
sqluint16 <C: typedef unsigned short sqluint16>
sqluint32 <C: typedef unsigned long sqluint32>
sqluint64 <C: typedef unsigned long long sqluint64>
sqluint8 <C: typedef unsigned char sqluint8>
SQLUINTEGER <C: typedef UDWORD SQLUINTEGER>
sqluintptr <C: typedef sqluint32 sqluintptr>
SQLUSMALLINT <C: typedef UWORD SQLUSMALLINT>
SQLVARCHAR <C: typedef UCHAR SQLVARCHAR>
SQLWCHAR <C: typedef unsigned short SQLWCHAR>
SQL_DATE_STRUCT <C: typedef DATE_STRUCT SQL_DATE_STRUCT>
SQL_DAY_SECOND_STRUCT <C: typedef struct tagSQL_DAY_SECOND SQL_DAY_SECOND_STRUCT>
SQL_INTERVAL_STRUCT <C: typedef struct tagSQL_INTERVAL_STRUCT SQL_INTERVAL_STRUCT>
SQL_NUMERIC_STRUCT <C: typedef struct tagSQL_NUMERIC_STRUCT SQL_NUMERIC_STRUCT>
SQL_TIMESTAMP_STRUCT <C: typedef TIMESTAMP_STRUCT SQL_TIMESTAMP_STRUCT>
SQL_TIME_STRUCT <C: typedef TIME_STRUCT SQL_TIME_STRUCT>
SQL_YEAR_MONTH_STRUCT <C: typedef struct tagSQL_YEAR_MONTH SQL_YEAR_MONTH_STRUCT>
SSHORT <C: typedef short SSHORT>
SWORD <C: typedef short SWORD>
TIMESTAMP_STRUCT <C: typedef struct __TIMESTAMP_STRUCT TIMESTAMP_STRUCT>
TIME_STRUCT <C: typedef struct __TIME_STRUCT TIME_STRUCT>
UCHAR <C: typedef unsigned char UCHAR>
UDWORD <C: typedef sqluint32 UDWORD>
ULONG <C: typedef sqluint32 ULONG>
USHORT <C: typedef unsigned short USHORT>
UWORD <C: typedef unsigned short UWORD>
</methods> <methods> Database.DB2CLIInterface <category>defines</category>
CLI_MAX_CHAR <C: #define CLI_MAX_CHAR 1252 >
CLI_MAX_GRAPHIC <C: #define CLI_MAX_GRAPHIC 1255 >
CLI_MAX_LONGVARCHAR <C: #define CLI_MAX_LONGVARCHAR 1250 >
CLI_MAX_LONGVARGRAPHIC <C: #define CLI_MAX_LONGVARGRAPHIC 1253 >
CLI_MAX_VARCHAR <C: #define CLI_MAX_VARCHAR 1251 >
CLI_MAX_VARGRAPHIC <C: #define CLI_MAX_VARGRAPHIC 1254 >
DB2CLI_VER <C: #define DB2CLI_VER 784 >
DB2NT <C: #define DB2NT 1 >
FAR <C: #define FAR >
ODBCVER <C: #define ODBCVER 768 >
PSQL_API_FN <C: #define PSQL_API_FN __stdcall* >
SQLCODE <C: #define SQLCODE sqlca.sqlcode >
SQLConnectW <C: #define SQLConnectW SQLConnectWInt >
SQLWARN0 <C: #define SQLWARN0 sqlca.sqlwarn[0] >
SQLWARN1 <C: #define SQLWARN1 sqlca.sqlwarn[1] >
SQLWARN2 <C: #define SQLWARN2 sqlca.sqlwarn[2] >
SQLWARN3 <C: #define SQLWARN3 sqlca.sqlwarn[3] >
SQLWARN4 <C: #define SQLWARN4 sqlca.sqlwarn[4] >
SQLWARN5 <C: #define SQLWARN5 sqlca.sqlwarn[5] >
SQLWARN6 <C: #define SQLWARN6 sqlca.sqlwarn[6] >
SQLWARN7 <C: #define SQLWARN7 sqlca.sqlwarn[7] >
SQLWARN8 <C: #define SQLWARN8 sqlca.sqlwarn[8] >
SQLWARN9 <C: #define SQLWARN9 sqlca.sqlwarn[9] >
SQLWARNA <C: #define SQLWARNA sqlca.sqlwarn[10] >
SQL_ACCESSIBLE_PROCEDURES <C: #define SQL_ACCESSIBLE_PROCEDURES 20 >
SQL_ACCESSIBLE_TABLES <C: #define SQL_ACCESSIBLE_TABLES 19 >
SQL_ACCESS_MODE <C: #define SQL_ACCESS_MODE 101 >
SQL_ACTIVE_CONNECTIONS <C: #define SQL_ACTIVE_CONNECTIONS 0 >
SQL_ACTIVE_ENVIRONMENTS <C: #define SQL_ACTIVE_ENVIRONMENTS 116 >
SQL_ACTIVE_STATEMENTS <C: #define SQL_ACTIVE_STATEMENTS 1 >
SQL_ADD <C: #define SQL_ADD 4 >
SQL_AD_ADD_CONSTRAINT_DEFERRABLE <C: #define SQL_AD_ADD_CONSTRAINT_DEFERRABLE 0x00000080 >
SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED <C: #define SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED 0x00000020 >
SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE <C: #define SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE 0x00000040 >
SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE <C: #define SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE 0x00000100 >
SQL_AD_ADD_DOMAIN_CONSTRAINT <C: #define SQL_AD_ADD_DOMAIN_CONSTRAINT 0x00000002 >
SQL_AD_ADD_DOMAIN_DEFAULT <C: #define SQL_AD_ADD_DOMAIN_DEFAULT 0x00000008 >
SQL_AD_CONSTRAINT_NAME_DEFINITION <C: #define SQL_AD_CONSTRAINT_NAME_DEFINITION 0x00000001 >
SQL_AD_DROP_DOMAIN_CONSTRAINT <C: #define SQL_AD_DROP_DOMAIN_CONSTRAINT 0x00000004 >
SQL_AD_DROP_DOMAIN_DEFAULT <C: #define SQL_AD_DROP_DOMAIN_DEFAULT 0x00000010 >
SQL_AF_ALL <C: #define SQL_AF_ALL 0x00000040 >
SQL_AF_AVG <C: #define SQL_AF_AVG 0x00000001 >
SQL_AF_COUNT <C: #define SQL_AF_COUNT 0x00000002 >
SQL_AF_DISTINCT <C: #define SQL_AF_DISTINCT 0x00000020 >
SQL_AF_MAX <C: #define SQL_AF_MAX 0x00000004 >
SQL_AF_MIN <C: #define SQL_AF_MIN 0x00000008 >
SQL_AF_SUM <C: #define SQL_AF_SUM 0x00000010 >
SQL_AGGREGATE_FUNCTIONS <C: #define SQL_AGGREGATE_FUNCTIONS 169 >
SQL_ALL_CATALOGS <C: #define SQL_ALL_CATALOGS "%" >
SQL_ALL_EXCEPT_LIKE <C: #define SQL_ALL_EXCEPT_LIKE 2 >
SQL_ALL_SCHEMAS <C: #define SQL_ALL_SCHEMAS "%" >
SQL_ALL_TABLE_TYPES <C: #define SQL_ALL_TABLE_TYPES "%" >
SQL_ALL_TYPES <C: #define SQL_ALL_TYPES 0 >
SQL_ALTER_DOMAIN <C: #define SQL_ALTER_DOMAIN 117 >
SQL_ALTER_TABLE <C: #define SQL_ALTER_TABLE 86 >
SQL_AM_CONNECTION <C: #define SQL_AM_CONNECTION 1 >
SQL_AM_NONE <C: #define SQL_AM_NONE 0 >
SQL_AM_STATEMENT <C: #define SQL_AM_STATEMENT 2 >
SQL_API <C: #define SQL_API SQL_API_FN >
SQL_API_ALL_FUNCTIONS <C: #define SQL_API_ALL_FUNCTIONS 0 >
SQL_API_FN <C: #define SQL_API_FN __stdcall >
SQL_API_INTR <C: #define SQL_API_INTR __stdcall >
SQL_API_LOADBYORDINAL <C: #define SQL_API_LOADBYORDINAL 199 >
SQL_API_ODBC3_ALL_FUNCTIONS <C: #define SQL_API_ODBC3_ALL_FUNCTIONS 999 >
SQL_API_ODBC3_ALL_FUNCTIONS_SIZE <C: #define SQL_API_ODBC3_ALL_FUNCTIONS_SIZE 250 >
SQL_API_RC <C: #define SQL_API_RC int >
SQL_API_SQLALLOCCONNECT <C: #define SQL_API_SQLALLOCCONNECT 1 >
SQL_API_SQLALLOCENV <C: #define SQL_API_SQLALLOCENV 2 >
SQL_API_SQLALLOCHANDLE <C: #define SQL_API_SQLALLOCHANDLE 1001 >
SQL_API_SQLALLOCHANDLESTD <C: #define SQL_API_SQLALLOCHANDLESTD 73 >
SQL_API_SQLALLOCSTMT <C: #define SQL_API_SQLALLOCSTMT 3 >
SQL_API_SQLBINDCOL <C: #define SQL_API_SQLBINDCOL 4 >
SQL_API_SQLBINDFILETOCOL <C: #define SQL_API_SQLBINDFILETOCOL 1250 >
SQL_API_SQLBINDFILETOPARAM <C: #define SQL_API_SQLBINDFILETOPARAM 1251 >
SQL_API_SQLBINDPARAM <C: #define SQL_API_SQLBINDPARAM 1002 >
SQL_API_SQLBINDPARAMETER <C: #define SQL_API_SQLBINDPARAMETER 72 >
SQL_API_SQLBROWSECONNECT <C: #define SQL_API_SQLBROWSECONNECT 55 >
SQL_API_SQLBUILDDATALINK <C: #define SQL_API_SQLBUILDDATALINK 1256 >
SQL_API_SQLBULKOPERATIONS <C: #define SQL_API_SQLBULKOPERATIONS 24 >
SQL_API_SQLCANCEL <C: #define SQL_API_SQLCANCEL 5 >
SQL_API_SQLCLOSECURSOR <C: #define SQL_API_SQLCLOSECURSOR 1003 >
SQL_API_SQLCOLATTRIBUTE <C: #define SQL_API_SQLCOLATTRIBUTE 6 >
SQL_API_SQLCOLATTRIBUTES <C: #define SQL_API_SQLCOLATTRIBUTES 6 >
SQL_API_SQLCOLUMNPRIVILEGES <C: #define SQL_API_SQLCOLUMNPRIVILEGES 56 >
SQL_API_SQLCOLUMNS <C: #define SQL_API_SQLCOLUMNS 40 >
SQL_API_SQLCONNECT <C: #define SQL_API_SQLCONNECT 7 >
SQL_API_SQLCOPYDESC <C: #define SQL_API_SQLCOPYDESC 1004 >
SQL_API_SQLDATASOURCES <C: #define SQL_API_SQLDATASOURCES 57 >
SQL_API_SQLDESCRIBECOL <C: #define SQL_API_SQLDESCRIBECOL 8 >
SQL_API_SQLDESCRIBEPARAM <C: #define SQL_API_SQLDESCRIBEPARAM 58 >
SQL_API_SQLDISCONNECT <C: #define SQL_API_SQLDISCONNECT 9 >
SQL_API_SQLDRIVERCONNECT <C: #define SQL_API_SQLDRIVERCONNECT 41 >
SQL_API_SQLDRIVERS <C: #define SQL_API_SQLDRIVERS 71 >
SQL_API_SQLENDTRAN <C: #define SQL_API_SQLENDTRAN 1005 >
SQL_API_SQLERROR <C: #define SQL_API_SQLERROR 10 >
SQL_API_SQLEXECDIRECT <C: #define SQL_API_SQLEXECDIRECT 11 >
SQL_API_SQLEXECUTE <C: #define SQL_API_SQLEXECUTE 12 >
SQL_API_SQLEXTENDEDBIND <C: #define SQL_API_SQLEXTENDEDBIND 1297 >
SQL_API_SQLEXTENDEDFETCH <C: #define SQL_API_SQLEXTENDEDFETCH 59 >
SQL_API_SQLEXTENDEDPREPARE <C: #define SQL_API_SQLEXTENDEDPREPARE 1296 >
SQL_API_SQLFETCH <C: #define SQL_API_SQLFETCH 13 >
SQL_API_SQLFETCHSCROLL <C: #define SQL_API_SQLFETCHSCROLL 1021 >
SQL_API_SQLFOREIGNKEYS <C: #define SQL_API_SQLFOREIGNKEYS 60 >
SQL_API_SQLFREECONNECT <C: #define SQL_API_SQLFREECONNECT 14 >
SQL_API_SQLFREEENV <C: #define SQL_API_SQLFREEENV 15 >
SQL_API_SQLFREEHANDLE <C: #define SQL_API_SQLFREEHANDLE 1006 >
SQL_API_SQLFREESTMT <C: #define SQL_API_SQLFREESTMT 16 >
SQL_API_SQLGETCONNECTATTR <C: #define SQL_API_SQLGETCONNECTATTR 1007 >
SQL_API_SQLGETCONNECTOPTION <C: #define SQL_API_SQLGETCONNECTOPTION 42 >
SQL_API_SQLGETCURSORNAME <C: #define SQL_API_SQLGETCURSORNAME 17 >
SQL_API_SQLGETDATA <C: #define SQL_API_SQLGETDATA 43 >
SQL_API_SQLGETDATALINKATTR <C: #define SQL_API_SQLGETDATALINKATTR 1255 >
SQL_API_SQLGETDESCFIELD <C: #define SQL_API_SQLGETDESCFIELD 1008 >
SQL_API_SQLGETDESCREC <C: #define SQL_API_SQLGETDESCREC 1009 >
SQL_API_SQLGETDIAGFIELD <C: #define SQL_API_SQLGETDIAGFIELD 1010 >
SQL_API_SQLGETDIAGREC <C: #define SQL_API_SQLGETDIAGREC 1011 >
SQL_API_SQLGETENVATTR <C: #define SQL_API_SQLGETENVATTR 1012 >
SQL_API_SQLGETFUNCTIONS <C: #define SQL_API_SQLGETFUNCTIONS 44 >
SQL_API_SQLGETINFO <C: #define SQL_API_SQLGETINFO 45 >
SQL_API_SQLGETLENGTH <C: #define SQL_API_SQLGETLENGTH 1022 >
SQL_API_SQLGETPOSITION <C: #define SQL_API_SQLGETPOSITION 1023 >
SQL_API_SQLGETSQLCA <C: #define SQL_API_SQLGETSQLCA 1253 >
SQL_API_SQLGETSTMTATTR <C: #define SQL_API_SQLGETSTMTATTR 1014 >
SQL_API_SQLGETSTMTOPTION <C: #define SQL_API_SQLGETSTMTOPTION 46 >
SQL_API_SQLGETSUBSTRING <C: #define SQL_API_SQLGETSUBSTRING 1024 >
SQL_API_SQLGETTYPEINFO <C: #define SQL_API_SQLGETTYPEINFO 47 >
SQL_API_SQLMORERESULTS <C: #define SQL_API_SQLMORERESULTS 61 >
SQL_API_SQLNATIVESQL <C: #define SQL_API_SQLNATIVESQL 62 >
SQL_API_SQLNUMPARAMS <C: #define SQL_API_SQLNUMPARAMS 63 >
SQL_API_SQLNUMRESULTCOLS <C: #define SQL_API_SQLNUMRESULTCOLS 18 >
SQL_API_SQLPARAMDATA <C: #define SQL_API_SQLPARAMDATA 48 >
SQL_API_SQLPARAMOPTIONS <C: #define SQL_API_SQLPARAMOPTIONS 64 >
SQL_API_SQLPREPARE <C: #define SQL_API_SQLPREPARE 19 >
SQL_API_SQLPRIMARYKEYS <C: #define SQL_API_SQLPRIMARYKEYS 65 >
SQL_API_SQLPROCEDURECOLUMNS <C: #define SQL_API_SQLPROCEDURECOLUMNS 66 >
SQL_API_SQLPROCEDURES <C: #define SQL_API_SQLPROCEDURES 67 >
SQL_API_SQLPUTDATA <C: #define SQL_API_SQLPUTDATA 49 >
SQL_API_SQLROWCOUNT <C: #define SQL_API_SQLROWCOUNT 20 >
SQL_API_SQLSETCOLATTRIBUTES <C: #define SQL_API_SQLSETCOLATTRIBUTES 1252 >
SQL_API_SQLSETCONNECTATTR <C: #define SQL_API_SQLSETCONNECTATTR 1016 >
SQL_API_SQLSETCONNECTION <C: #define SQL_API_SQLSETCONNECTION 1254 >
SQL_API_SQLSETCONNECTOPTION <C: #define SQL_API_SQLSETCONNECTOPTION 50 >
SQL_API_SQLSETCURSORNAME <C: #define SQL_API_SQLSETCURSORNAME 21 >
SQL_API_SQLSETDESCFIELD <C: #define SQL_API_SQLSETDESCFIELD 1017 >
SQL_API_SQLSETDESCREC <C: #define SQL_API_SQLSETDESCREC 1018 >
SQL_API_SQLSETENVATTR <C: #define SQL_API_SQLSETENVATTR 1019 >
SQL_API_SQLSETPARAM <C: #define SQL_API_SQLSETPARAM 22 >
SQL_API_SQLSETPOS <C: #define SQL_API_SQLSETPOS 68 >
SQL_API_SQLSETSCROLLOPTIONS <C: #define SQL_API_SQLSETSCROLLOPTIONS 69 >
SQL_API_SQLSETSTMTATTR <C: #define SQL_API_SQLSETSTMTATTR 1020 >
SQL_API_SQLSETSTMTOPTION <C: #define SQL_API_SQLSETSTMTOPTION 51 >
SQL_API_SQLSPECIALCOLUMNS <C: #define SQL_API_SQLSPECIALCOLUMNS 52 >
SQL_API_SQLSTATISTICS <C: #define SQL_API_SQLSTATISTICS 53 >
SQL_API_SQLTABLEPRIVILEGES <C: #define SQL_API_SQLTABLEPRIVILEGES 70 >
SQL_API_SQLTABLES <C: #define SQL_API_SQLTABLES 54 >
SQL_API_SQLTRANSACT <C: #define SQL_API_SQLTRANSACT 23 >
SQL_APP_TYPE_DEFAULT <C: #define SQL_APP_TYPE_DEFAULT SQL_APP_TYPE_ODBC >
SQL_APP_TYPE_JDBC <C: #define SQL_APP_TYPE_JDBC 3 >
SQL_APP_TYPE_ODBC <C: #define SQL_APP_TYPE_ODBC 1 >
SQL_APP_TYPE_OLEDB <C: #define SQL_APP_TYPE_OLEDB 2 >
SQL_ARD_TYPE <C: #define SQL_ARD_TYPE (-99) >
SQL_ASYNC_ENABLE <C: #define SQL_ASYNC_ENABLE 4 >
SQL_ASYNC_ENABLE_DEFAULT <C: #define SQL_ASYNC_ENABLE_DEFAULT SQL_ASYNC_ENABLE_OFF >
SQL_ASYNC_ENABLE_OFF <C: #define SQL_ASYNC_ENABLE_OFF 0 >
SQL_ASYNC_ENABLE_ON <C: #define SQL_ASYNC_ENABLE_ON 1 >
SQL_ASYNC_MODE <C: #define SQL_ASYNC_MODE 10021 >
SQL_ATOMIC_DEFAULT <C: #define SQL_ATOMIC_DEFAULT SQL_ATOMIC_YES >
SQL_ATOMIC_NO <C: #define SQL_ATOMIC_NO 0 >
SQL_ATOMIC_YES <C: #define SQL_ATOMIC_YES 1 >
SQL_ATTR_ACCESS_MODE <C: #define SQL_ATTR_ACCESS_MODE SQL_ACCESS_MODE >
SQL_ATTR_APP_PARAM_DESC <C: #define SQL_ATTR_APP_PARAM_DESC 10011 >
SQL_ATTR_APP_ROW_DESC <C: #define SQL_ATTR_APP_ROW_DESC 10010 >
SQL_ATTR_APP_TYPE <C: #define SQL_ATTR_APP_TYPE 2473 >
SQL_ATTR_ASYNC_ENABLE <C: #define SQL_ATTR_ASYNC_ENABLE 4 >
SQL_ATTR_AUTOCOMMIT <C: #define SQL_ATTR_AUTOCOMMIT SQL_AUTOCOMMIT >
SQL_ATTR_AUTOCOMMIT_NOCOMMIT <C: #define SQL_ATTR_AUTOCOMMIT_NOCOMMIT 2462 >
SQL_ATTR_AUTO_IPD <C: #define SQL_ATTR_AUTO_IPD 10001 >
SQL_ATTR_BLOCK_FOR_NROWS <C: #define SQL_ATTR_BLOCK_FOR_NROWS 2459 >
SQL_ATTR_CALL_RETURN <C: #define SQL_ATTR_CALL_RETURN 2470 >
SQL_ATTR_CALL_RETVAL_AS_PARM <C: #define SQL_ATTR_CALL_RETVAL_AS_PARM 2469 >
SQL_ATTR_CHAINING_BEGIN <C: #define SQL_ATTR_CHAINING_BEGIN 2464 >
SQL_ATTR_CHAINING_END <C: #define SQL_ATTR_CHAINING_END 2465 >
SQL_ATTR_CLISCHEMA <C: #define SQL_ATTR_CLISCHEMA 1280 >
SQL_ATTR_CLOSEOPEN <C: #define SQL_ATTR_CLOSEOPEN 1265 >
SQL_ATTR_CLOSE_BEHAVIOR <C: #define SQL_ATTR_CLOSE_BEHAVIOR 1257 >
SQL_ATTR_CONCURRENCY <C: #define SQL_ATTR_CONCURRENCY SQL_CONCURRENCY >
SQL_ATTR_CONNECTION_DEAD <C: #define SQL_ATTR_CONNECTION_DEAD 1209 >
SQL_ATTR_CONNECTION_POOLING <C: #define SQL_ATTR_CONNECTION_POOLING 201 >
SQL_ATTR_CONNECTION_TIMEOUT <C: #define SQL_ATTR_CONNECTION_TIMEOUT 113 >
SQL_ATTR_CONNECTTYPE <C: #define SQL_ATTR_CONNECTTYPE SQL_CONNECTTYPE >
SQL_ATTR_CONNECT_NODE <C: #define SQL_ATTR_CONNECT_NODE 1290 >
SQL_ATTR_CONNECT_WITH_XA <C: #define SQL_ATTR_CONNECT_WITH_XA 1291 >
SQL_ATTR_CONN_CONTEXT <C: #define SQL_ATTR_CONN_CONTEXT SQL_CONN_CONTEXT >
SQL_ATTR_CP_MATCH <C: #define SQL_ATTR_CP_MATCH 202 >
SQL_ATTR_CURRENT_CATALOG <C: #define SQL_ATTR_CURRENT_CATALOG SQL_CURRENT_QUALIFIER >
SQL_ATTR_CURRENT_PACKAGE_SET <C: #define SQL_ATTR_CURRENT_PACKAGE_SET 1276 >
SQL_ATTR_CURRENT_SCHEMA <C: #define SQL_ATTR_CURRENT_SCHEMA SQL_CURRENT_SCHEMA >
SQL_ATTR_CURSOR_BLOCK_EARLY_CLOSE <C: #define SQL_ATTR_CURSOR_BLOCK_EARLY_CLOSE 2454 >
SQL_ATTR_CURSOR_BLOCK_NUM_ROWS <C: #define SQL_ATTR_CURSOR_BLOCK_NUM_ROWS 2453 >
SQL_ATTR_CURSOR_HOLD <C: #define SQL_ATTR_CURSOR_HOLD 1250 >
SQL_ATTR_CURSOR_SCROLLABLE <C: #define SQL_ATTR_CURSOR_SCROLLABLE (-1) >
SQL_ATTR_CURSOR_SENSITIVITY <C: #define SQL_ATTR_CURSOR_SENSITIVITY (-2) >
SQL_ATTR_CURSOR_TYPE <C: #define SQL_ATTR_CURSOR_TYPE SQL_CURSOR_TYPE >
SQL_ATTR_DATALINK_COMMENT <C: #define SQL_ATTR_DATALINK_COMMENT 1 >
SQL_ATTR_DATALINK_LINKTYPE <C: #define SQL_ATTR_DATALINK_LINKTYPE 2 >
SQL_ATTR_DATALINK_URLCOMPLETE <C: #define SQL_ATTR_DATALINK_URLCOMPLETE 3 >
SQL_ATTR_DATALINK_URLPATH <C: #define SQL_ATTR_DATALINK_URLPATH 4 >
SQL_ATTR_DATALINK_URLPATHONLY <C: #define SQL_ATTR_DATALINK_URLPATHONLY 5 >
SQL_ATTR_DATALINK_URLSCHEME <C: #define SQL_ATTR_DATALINK_URLSCHEME 6 >
SQL_ATTR_DATALINK_URLSERVER <C: #define SQL_ATTR_DATALINK_URLSERVER 7 >
SQL_ATTR_DB2ESTIMATE <C: #define SQL_ATTR_DB2ESTIMATE SQL_DB2ESTIMATE >
SQL_ATTR_DB2EXPLAIN <C: #define SQL_ATTR_DB2EXPLAIN SQL_DB2EXPLAIN >
SQL_ATTR_DB2_MESSAGE_PREFIX <C: #define SQL_ATTR_DB2_MESSAGE_PREFIX 2468 >
SQL_ATTR_DB2_MESSAGE_PREFIX_DEFAULT <C: #define SQL_ATTR_DB2_MESSAGE_PREFIX_DEFAULT SQL_ATTR_DB2_MESSAGE_PREFIX_ON >
SQL_ATTR_DB2_MESSAGE_PREFIX_OFF <C: #define SQL_ATTR_DB2_MESSAGE_PREFIX_OFF 0 >
SQL_ATTR_DB2_MESSAGE_PREFIX_ON <C: #define SQL_ATTR_DB2_MESSAGE_PREFIX_ON 1 >
SQL_ATTR_DB2_SQLERRP <C: #define SQL_ATTR_DB2_SQLERRP 2451 >
SQL_ATTR_DEFERRED_PREPARE <C: #define SQL_ATTR_DEFERRED_PREPARE 1277 >
SQL_ATTR_DISCONNECT_BEHAVIOR <C: #define SQL_ATTR_DISCONNECT_BEHAVIOR 114 >
SQL_ATTR_EARLYCLOSE <C: #define SQL_ATTR_EARLYCLOSE 1268 >
SQL_ATTR_ENABLE_AUTO_IPD <C: #define SQL_ATTR_ENABLE_AUTO_IPD 15 >
SQL_ATTR_ENABLE_EXTENDED_PARAMDATA <C: #define SQL_ATTR_ENABLE_EXTENDED_PARAMDATA 2472 >
SQL_ATTR_ENABLE_IPD_SETTING <C: #define SQL_ATTR_ENABLE_IPD_SETTING 1286 >
SQL_ATTR_ENLIST_IN_DTC <C: #define SQL_ATTR_ENLIST_IN_DTC 1207 >
SQL_ATTR_ENLIST_IN_XA <C: #define SQL_ATTR_ENLIST_IN_XA 1208 >
SQL_ATTR_FETCH_BOOKMARK_PTR <C: #define SQL_ATTR_FETCH_BOOKMARK_PTR 16 >
SQL_ATTR_FORCE_CONVERSION_ON_CLIENT <C: #define SQL_ATTR_FORCE_CONVERSION_ON_CLIENT 1275 >
SQL_ATTR_GET_XA_RESOURCE <C: #define SQL_ATTR_GET_XA_RESOURCE 1292 >
SQL_ATTR_IMP_PARAM_DESC <C: #define SQL_ATTR_IMP_PARAM_DESC 10013 >
SQL_ATTR_IMP_ROW_DESC <C: #define SQL_ATTR_IMP_ROW_DESC 10012 >
SQL_ATTR_INFO_ACCTSTR <C: #define SQL_ATTR_INFO_ACCTSTR 1284 >
SQL_ATTR_INFO_APPLNAME <C: #define SQL_ATTR_INFO_APPLNAME 1283 >
SQL_ATTR_INFO_USERID <C: #define SQL_ATTR_INFO_USERID 1281 >
SQL_ATTR_INFO_WRKSTNNAME <C: #define SQL_ATTR_INFO_WRKSTNNAME 1282 >
SQL_ATTR_INHERIT_NULL_CONNECT <C: #define SQL_ATTR_INHERIT_NULL_CONNECT 1270 >
SQL_ATTR_KEYSET_SIZE <C: #define SQL_ATTR_KEYSET_SIZE SQL_KEYSET_SIZE >
SQL_ATTR_LITTLE_ENDIAN_UNICODE <C: #define SQL_ATTR_LITTLE_ENDIAN_UNICODE 2457 >
SQL_ATTR_LOGIN_TIMEOUT <C: #define SQL_ATTR_LOGIN_TIMEOUT SQL_LOGIN_TIMEOUT >
SQL_ATTR_LONGDATA_COMPAT <C: #define SQL_ATTR_LONGDATA_COMPAT SQL_LONGDATA_COMPAT >
SQL_ATTR_MAXCONN <C: #define SQL_ATTR_MAXCONN SQL_MAXCONN >
SQL_ATTR_MAX_LENGTH <C: #define SQL_ATTR_MAX_LENGTH SQL_MAX_LENGTH >
SQL_ATTR_MAX_ROWS <C: #define SQL_ATTR_MAX_ROWS SQL_MAX_ROWS >
SQL_ATTR_MEM_DEBUG_DUMP <C: #define SQL_ATTR_MEM_DEBUG_DUMP 1289 >
SQL_ATTR_METADATA_ID <C: #define SQL_ATTR_METADATA_ID 10014 >
SQL_ATTR_MINMEMORY_USAGE <C: #define SQL_ATTR_MINMEMORY_USAGE SQL_MINMEMORY_USAGE >
SQL_ATTR_NODESCRIBE <C: #define SQL_ATTR_NODESCRIBE SQL_NODESCRIBE_OUTPUT >
SQL_ATTR_NODESCRIBE_INPUT <C: #define SQL_ATTR_NODESCRIBE_INPUT 1264 >
SQL_ATTR_NODESCRIBE_OUTPUT <C: #define SQL_ATTR_NODESCRIBE_OUTPUT 1251 >
SQL_ATTR_NOSCAN <C: #define SQL_ATTR_NOSCAN SQL_NOSCAN >
SQL_ATTR_ODBC_CURSORS <C: #define SQL_ATTR_ODBC_CURSORS SQL_ODBC_CURSORS >
SQL_ATTR_ODBC_VERSION <C: #define SQL_ATTR_ODBC_VERSION 200 >
SQL_ATTR_OPTIMIZE_FOR_NROWS <C: #define SQL_ATTR_OPTIMIZE_FOR_NROWS 2450 >
SQL_ATTR_OPTIMIZE_ROWS_FOR_BLOCKING <C: #define SQL_ATTR_OPTIMIZE_ROWS_FOR_BLOCKING 2460 >
SQL_ATTR_OPTIMIZE_SQLCOLUMNS <C: #define SQL_ATTR_OPTIMIZE_SQLCOLUMNS 1288 >
SQL_ATTR_OUTPUT_NTS <C: #define SQL_ATTR_OUTPUT_NTS 10001 >
SQL_ATTR_PACKET_SIZE <C: #define SQL_ATTR_PACKET_SIZE SQL_PACKET_SIZE >
SQL_ATTR_PARAMOPT_ATOMIC <C: #define SQL_ATTR_PARAMOPT_ATOMIC SQL_PARAMOPT_ATOMIC >
SQL_ATTR_PARAMSET_SIZE <C: #define SQL_ATTR_PARAMSET_SIZE 22 >
SQL_ATTR_PARAMS_PROCESSED_PTR <C: #define SQL_ATTR_PARAMS_PROCESSED_PTR 21 >
SQL_ATTR_PARAM_BIND_OFFSET_PTR <C: #define SQL_ATTR_PARAM_BIND_OFFSET_PTR 17 >
SQL_ATTR_PARAM_BIND_TYPE <C: #define SQL_ATTR_PARAM_BIND_TYPE 18 >
SQL_ATTR_PARAM_OPERATION_PTR <C: #define SQL_ATTR_PARAM_OPERATION_PTR 19 >
SQL_ATTR_PARAM_STATUS_PTR <C: #define SQL_ATTR_PARAM_STATUS_PTR 20 >
SQL_ATTR_PREFETCH <C: #define SQL_ATTR_PREFETCH 1285 >
SQL_ATTR_PROCESSCTL <C: #define SQL_ATTR_PROCESSCTL 1278 >
SQL_ATTR_QUERY_OPTIMIZATION_LEVEL <C: #define SQL_ATTR_QUERY_OPTIMIZATION_LEVEL 1293 >
SQL_ATTR_QUERY_PATROLLER <C: #define SQL_ATTR_QUERY_PATROLLER 2466 >
SQL_ATTR_QUERY_PATROLLER_BYPASS <C: #define SQL_ATTR_QUERY_PATROLLER_BYPASS 3 >
SQL_ATTR_QUERY_PATROLLER_DISABLE <C: #define SQL_ATTR_QUERY_PATROLLER_DISABLE 1 >
SQL_ATTR_QUERY_PATROLLER_ENABLE <C: #define SQL_ATTR_QUERY_PATROLLER_ENABLE 2 >
SQL_ATTR_QUERY_TIMEOUT <C: #define SQL_ATTR_QUERY_TIMEOUT SQL_QUERY_TIMEOUT >
SQL_ATTR_QUIET_MODE <C: #define SQL_ATTR_QUIET_MODE SQL_QUIET_MODE >
SQL_ATTR_READONLY <C: #define SQL_ATTR_READONLY 0 >
SQL_ATTR_READWRITE_UNKNOWN <C: #define SQL_ATTR_READWRITE_UNKNOWN 2 >
SQL_ATTR_RETRIEVE_DATA <C: #define SQL_ATTR_RETRIEVE_DATA SQL_RETRIEVE_DATA >
SQL_ATTR_RETURN_USER_DEFINED_TYPES <C: #define SQL_ATTR_RETURN_USER_DEFINED_TYPES 2471 >
SQL_ATTR_ROWS_FETCHED_PTR <C: #define SQL_ATTR_ROWS_FETCHED_PTR 26 >
SQL_ATTR_ROW_ARRAY_SIZE <C: #define SQL_ATTR_ROW_ARRAY_SIZE 27 >
SQL_ATTR_ROW_BIND_OFFSET_PTR <C: #define SQL_ATTR_ROW_BIND_OFFSET_PTR 23 >
SQL_ATTR_ROW_BIND_TYPE <C: #define SQL_ATTR_ROW_BIND_TYPE SQL_BIND_TYPE >
SQL_ATTR_ROW_NUMBER <C: #define SQL_ATTR_ROW_NUMBER SQL_ROW_NUMBER >
SQL_ATTR_ROW_OPERATION_PTR <C: #define SQL_ATTR_ROW_OPERATION_PTR 24 >
SQL_ATTR_ROW_STATUS_PTR <C: #define SQL_ATTR_ROW_STATUS_PTR 25 >
SQL_ATTR_SERVER_MSGTXT_MASK <C: #define SQL_ATTR_SERVER_MSGTXT_MASK 2455 >
SQL_ATTR_SERVER_MSGTXT_MASK_ALL <C: #define SQL_ATTR_SERVER_MSGTXT_MASK_ALL 4294967295 >
SQL_ATTR_SERVER_MSGTXT_MASK_DEFAULT <C: #define SQL_ATTR_SERVER_MSGTXT_MASK_DEFAULT SQL_ATTR_SERVER_MSGTXT_MASK_LOCAL_FIRST >
SQL_ATTR_SERVER_MSGTXT_MASK_ERRORS <C: #define SQL_ATTR_SERVER_MSGTXT_MASK_ERRORS 4294967294 >
SQL_ATTR_SERVER_MSGTXT_MASK_LOCAL_FIRST <C: #define SQL_ATTR_SERVER_MSGTXT_MASK_LOCAL_FIRST 0x00000000 >
SQL_ATTR_SERVER_MSGTXT_MASK_WARNINGS <C: #define SQL_ATTR_SERVER_MSGTXT_MASK_WARNINGS 0x00000001 >
SQL_ATTR_SERVER_MSGTXT_SP <C: #define SQL_ATTR_SERVER_MSGTXT_SP 2452 >
SQL_ATTR_SIMULATE_CURSOR <C: #define SQL_ATTR_SIMULATE_CURSOR SQL_SIMULATE_CURSOR >
SQL_ATTR_STATICMODE <C: #define SQL_ATTR_STATICMODE 2467 >
SQL_ATTR_STMTTXN_ISOLATION <C: #define SQL_ATTR_STMTTXN_ISOLATION SQL_STMTTXN_ISOLATION >
SQL_ATTR_SYNC_POINT <C: #define SQL_ATTR_SYNC_POINT SQL_SYNC_POINT >
SQL_ATTR_TRACE <C: #define SQL_ATTR_TRACE SQL_OPT_TRACE >
SQL_ATTR_TRACEFILE <C: #define SQL_ATTR_TRACEFILE SQL_OPT_TRACEFILE >
SQL_ATTR_TRANSFORM_GROUP <C: #define SQL_ATTR_TRANSFORM_GROUP 2474 >
SQL_ATTR_TRANSLATE_LIB <C: #define SQL_ATTR_TRANSLATE_LIB SQL_TRANSLATE_DLL >
SQL_ATTR_TRANSLATE_OPTION <C: #define SQL_ATTR_TRANSLATE_OPTION SQL_TRANSLATE_OPTION >
SQL_ATTR_TXN_ISOLATION <C: #define SQL_ATTR_TXN_ISOLATION SQL_TXN_ISOLATION >
SQL_ATTR_USE_2BYTES_OCTET_LENGTH <C: #define SQL_ATTR_USE_2BYTES_OCTET_LENGTH 1299 >
SQL_ATTR_USE_BOOKMARKS <C: #define SQL_ATTR_USE_BOOKMARKS SQL_USE_BOOKMARKS >
SQL_ATTR_USE_LIGHT_INPUT_SQLDA <C: #define SQL_ATTR_USE_LIGHT_INPUT_SQLDA 2458 >
SQL_ATTR_USE_LIGHT_OUTPUT_SQLDA <C: #define SQL_ATTR_USE_LIGHT_OUTPUT_SQLDA 1298 >
SQL_ATTR_WCHARTYPE <C: #define SQL_ATTR_WCHARTYPE SQL_WCHARTYPE >
SQL_ATTR_WRITE <C: #define SQL_ATTR_WRITE 1 >
SQL_AT_ADD_COLUMN <C: #define SQL_AT_ADD_COLUMN 0x00000001 >
SQL_AT_ADD_COLUMN_COLLATION <C: #define SQL_AT_ADD_COLUMN_COLLATION 0x00000080 >
SQL_AT_ADD_COLUMN_DEFAULT <C: #define SQL_AT_ADD_COLUMN_DEFAULT 0x00000040 >
SQL_AT_ADD_COLUMN_SINGLE <C: #define SQL_AT_ADD_COLUMN_SINGLE 0x00000020 >
SQL_AT_ADD_CONSTRAINT <C: #define SQL_AT_ADD_CONSTRAINT 0x00000008 >
SQL_AT_ADD_TABLE_CONSTRAINT <C: #define SQL_AT_ADD_TABLE_CONSTRAINT 0x00001000 >
SQL_AT_CONSTRAINT_DEFERRABLE <C: #define SQL_AT_CONSTRAINT_DEFERRABLE 0x00040000 >
SQL_AT_CONSTRAINT_INITIALLY_DEFERRED <C: #define SQL_AT_CONSTRAINT_INITIALLY_DEFERRED 0x00010000 >
SQL_AT_CONSTRAINT_INITIALLY_IMMEDIATE <C: #define SQL_AT_CONSTRAINT_INITIALLY_IMMEDIATE 0x00020000 >
SQL_AT_CONSTRAINT_NAME_DEFINITION <C: #define SQL_AT_CONSTRAINT_NAME_DEFINITION 0x00008000 >
SQL_AT_CONSTRAINT_NON_DEFERRABLE <C: #define SQL_AT_CONSTRAINT_NON_DEFERRABLE 0x00080000 >
SQL_AT_DROP_COLUMN <C: #define SQL_AT_DROP_COLUMN 0x00000002 >
SQL_AT_DROP_COLUMN_CASCADE <C: #define SQL_AT_DROP_COLUMN_CASCADE 0x00000400 >
SQL_AT_DROP_COLUMN_DEFAULT <C: #define SQL_AT_DROP_COLUMN_DEFAULT 0x00000200 >
SQL_AT_DROP_COLUMN_RESTRICT <C: #define SQL_AT_DROP_COLUMN_RESTRICT 0x00000800 >
SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE <C: #define SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE 0x00002000 >
SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT <C: #define SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT 0x00004000 >
SQL_AT_SET_COLUMN_DEFAULT <C: #define SQL_AT_SET_COLUMN_DEFAULT 0x00000100 >
SQL_AUTOCOMMIT <C: #define SQL_AUTOCOMMIT 102 >
SQL_AUTOCOMMIT_DEFAULT <C: #define SQL_AUTOCOMMIT_DEFAULT SQL_AUTOCOMMIT_ON >
SQL_AUTOCOMMIT_OFF <C: #define SQL_AUTOCOMMIT_OFF 0 >
SQL_AUTOCOMMIT_ON <C: #define SQL_AUTOCOMMIT_ON 1 >
SQL_BATCH_ROW_COUNT <C: #define SQL_BATCH_ROW_COUNT 120 >
SQL_BATCH_SUPPORT <C: #define SQL_BATCH_SUPPORT 121 >
SQL_BEST_ROWID <C: #define SQL_BEST_ROWID 1 >
SQL_BIGINT <C: #define SQL_BIGINT (-5) >
SQL_BIGINT_TYPE <C: #define SQL_BIGINT_TYPE long long >
SQL_BIGUINT_TYPE <C: #define SQL_BIGUINT_TYPE unsigned long long >
SQL_BINARY <C: #define SQL_BINARY (-2) >
SQL_BIND_BY_COLUMN <C: #define SQL_BIND_BY_COLUMN 0 >
SQL_BIND_TYPE <C: #define SQL_BIND_TYPE 5 >
SQL_BIND_TYPE_DEFAULT <C: #define SQL_BIND_TYPE_DEFAULT SQL_BIND_BY_COLUMN >
SQL_BIT <C: #define SQL_BIT (-7) >
SQL_BLOB <C: #define SQL_BLOB -98 >
SQL_BLOB_LOCATOR <C: #define SQL_BLOB_LOCATOR 31 >
SQL_BOOKMARK_PERSISTENCE <C: #define SQL_BOOKMARK_PERSISTENCE 82 >
SQL_BP_CLOSE <C: #define SQL_BP_CLOSE 0x00000001 >
SQL_BP_DELETE <C: #define SQL_BP_DELETE 0x00000002 >
SQL_BP_DROP <C: #define SQL_BP_DROP 0x00000004 >
SQL_BP_OTHER_HSTMT <C: #define SQL_BP_OTHER_HSTMT 0x00000020 >
SQL_BP_SCROLL <C: #define SQL_BP_SCROLL 0x00000040 >
SQL_BP_TRANSACTION <C: #define SQL_BP_TRANSACTION 0x00000008 >
SQL_BP_UPDATE <C: #define SQL_BP_UPDATE 0x00000010 >
SQL_BRC_EXPLICIT <C: #define SQL_BRC_EXPLICIT 0x00000002 >
SQL_BRC_PROCEDURES <C: #define SQL_BRC_PROCEDURES 0x00000001 >
SQL_BRC_ROLLED_UP <C: #define SQL_BRC_ROLLED_UP 0x00000004 >
SQL_BS_ROW_COUNT_EXPLICIT <C: #define SQL_BS_ROW_COUNT_EXPLICIT 0x00000002 >
SQL_BS_ROW_COUNT_PROC <C: #define SQL_BS_ROW_COUNT_PROC 0x00000008 >
SQL_BS_SELECT_EXPLICIT <C: #define SQL_BS_SELECT_EXPLICIT 0x00000001 >
SQL_BS_SELECT_PROC <C: #define SQL_BS_SELECT_PROC 0x00000004 >
SQL_CA1_ABSOLUTE <C: #define SQL_CA1_ABSOLUTE 0x00000002 >
SQL_CA1_BOOKMARK <C: #define SQL_CA1_BOOKMARK 0x00000008 >
SQL_CA1_BULK_ADD <C: #define SQL_CA1_BULK_ADD 0x00010000 >
SQL_CA1_BULK_DELETE_BY_BOOKMARK <C: #define SQL_CA1_BULK_DELETE_BY_BOOKMARK 0x00040000 >
SQL_CA1_BULK_FETCH_BY_BOOKMARK <C: #define SQL_CA1_BULK_FETCH_BY_BOOKMARK 0x00080000 >
SQL_CA1_BULK_UPDATE_BY_BOOKMARK <C: #define SQL_CA1_BULK_UPDATE_BY_BOOKMARK 0x00020000 >
SQL_CA1_LOCK_EXCLUSIVE <C: #define SQL_CA1_LOCK_EXCLUSIVE 0x00000080 >
SQL_CA1_LOCK_NO_CHANGE <C: #define SQL_CA1_LOCK_NO_CHANGE 0x00000040 >
SQL_CA1_LOCK_UNLOCK <C: #define SQL_CA1_LOCK_UNLOCK 0x00000100 >
SQL_CA1_NEXT <C: #define SQL_CA1_NEXT 0x00000001 >
SQL_CA1_POSITIONED_DELETE <C: #define SQL_CA1_POSITIONED_DELETE 0x00004000 >
SQL_CA1_POSITIONED_UPDATE <C: #define SQL_CA1_POSITIONED_UPDATE 0x00002000 >
SQL_CA1_POS_DELETE <C: #define SQL_CA1_POS_DELETE 0x00000800 >
SQL_CA1_POS_POSITION <C: #define SQL_CA1_POS_POSITION 0x00000200 >
SQL_CA1_POS_REFRESH <C: #define SQL_CA1_POS_REFRESH 0x00001000 >
SQL_CA1_POS_UPDATE <C: #define SQL_CA1_POS_UPDATE 0x00000400 >
SQL_CA1_RELATIVE <C: #define SQL_CA1_RELATIVE 0x00000004 >
SQL_CA1_SELECT_FOR_UPDATE <C: #define SQL_CA1_SELECT_FOR_UPDATE 0x00008000 >
SQL_CA2_CRC_APPROXIMATE <C: #define SQL_CA2_CRC_APPROXIMATE 0x00002000 >
SQL_CA2_CRC_EXACT <C: #define SQL_CA2_CRC_EXACT 0x00001000 >
SQL_CA2_LOCK_CONCURRENCY <C: #define SQL_CA2_LOCK_CONCURRENCY 0x00000002 >
SQL_CA2_MAX_ROWS_AFFECTS_ALL <C: #define SQL_CA2_MAX_ROWS_AFFECTS_ALL (SQL_CA2_MAX_ROWS_SELECT | SQL_CA2_MAX_ROWS_INSERT | SQL_CA2_MAX_ROWS_DELETE | SQL_CA2_MAX_ROWS_UPDATE | SQL_CA2_MAX_ROWS_CATALOG) >
SQL_CA2_MAX_ROWS_CATALOG <C: #define SQL_CA2_MAX_ROWS_CATALOG 0x00000800 >
SQL_CA2_MAX_ROWS_DELETE <C: #define SQL_CA2_MAX_ROWS_DELETE 0x00000200 >
SQL_CA2_MAX_ROWS_INSERT <C: #define SQL_CA2_MAX_ROWS_INSERT 0x00000100 >
SQL_CA2_MAX_ROWS_SELECT <C: #define SQL_CA2_MAX_ROWS_SELECT 0x00000080 >
SQL_CA2_MAX_ROWS_UPDATE <C: #define SQL_CA2_MAX_ROWS_UPDATE 0x00000400 >
SQL_CA2_OPT_ROWVER_CONCURRENCY <C: #define SQL_CA2_OPT_ROWVER_CONCURRENCY 0x00000004 >
SQL_CA2_OPT_VALUES_CONCURRENCY <C: #define SQL_CA2_OPT_VALUES_CONCURRENCY 0x00000008 >
SQL_CA2_READ_ONLY_CONCURRENCY <C: #define SQL_CA2_READ_ONLY_CONCURRENCY 0x00000001 >
SQL_CA2_SENSITIVITY_ADDITIONS <C: #define SQL_CA2_SENSITIVITY_ADDITIONS 0x00000010 >
SQL_CA2_SENSITIVITY_DELETIONS <C: #define SQL_CA2_SENSITIVITY_DELETIONS 0x00000020 >
SQL_CA2_SENSITIVITY_UPDATES <C: #define SQL_CA2_SENSITIVITY_UPDATES 0x00000040 >
SQL_CA2_SIMULATE_NON_UNIQUE <C: #define SQL_CA2_SIMULATE_NON_UNIQUE 0x00004000 >
SQL_CA2_SIMULATE_TRY_UNIQUE <C: #define SQL_CA2_SIMULATE_TRY_UNIQUE 0x00008000 >
SQL_CA2_SIMULATE_UNIQUE <C: #define SQL_CA2_SIMULATE_UNIQUE 0x00010000 >
SQL_CASCADE <C: #define SQL_CASCADE 0 >
SQL_CATALOG_LOCATION <C: #define SQL_CATALOG_LOCATION SQL_QUALIFIER_LOCATION >
SQL_CATALOG_NAME <C: #define SQL_CATALOG_NAME 10003 >
SQL_CATALOG_NAME_SEPARATOR <C: #define SQL_CATALOG_NAME_SEPARATOR SQL_QUALIFIER_NAME_SEPARATOR >
SQL_CATALOG_TERM <C: #define SQL_CATALOG_TERM SQL_QUALIFIER_TERM >
SQL_CATALOG_USAGE <C: #define SQL_CATALOG_USAGE SQL_QUALIFIER_USAGE >
SQL_CA_CONSTRAINT_DEFERRABLE <C: #define SQL_CA_CONSTRAINT_DEFERRABLE 0x00000040 >
SQL_CA_CONSTRAINT_INITIALLY_DEFERRED <C: #define SQL_CA_CONSTRAINT_INITIALLY_DEFERRED 0x00000010 >
SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE <C: #define SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE 0x00000020 >
SQL_CA_CONSTRAINT_NON_DEFERRABLE <C: #define SQL_CA_CONSTRAINT_NON_DEFERRABLE 0x00000080 >
SQL_CA_CREATE_ASSERTION <C: #define SQL_CA_CREATE_ASSERTION 0x00000001 >
SQL_CB_CLOSE <C: #define SQL_CB_CLOSE 0x0001 >
SQL_CB_DELETE <C: #define SQL_CB_DELETE 0x0000 >
SQL_CB_NON_NULL <C: #define SQL_CB_NON_NULL 0x0001 >
SQL_CB_NULL <C: #define SQL_CB_NULL 0x0000 >
SQL_CB_PRESERVE <C: #define SQL_CB_PRESERVE 0x0002 >
SQL_CCOL_CREATE_COLLATION <C: #define SQL_CCOL_CREATE_COLLATION 0x00000001 >
SQL_CCS_COLLATE_CLAUSE <C: #define SQL_CCS_COLLATE_CLAUSE 0x00000002 >
SQL_CCS_CREATE_CHARACTER_SET <C: #define SQL_CCS_CREATE_CHARACTER_SET 0x00000001 >
SQL_CCS_LIMITED_COLLATION <C: #define SQL_CCS_LIMITED_COLLATION 0x00000004 >
SQL_CC_CLOSE <C: #define SQL_CC_CLOSE SQL_CB_CLOSE >
SQL_CC_DEFAULT <C: #define SQL_CC_DEFAULT SQL_CC_NO_RELEASE >
SQL_CC_DELETE <C: #define SQL_CC_DELETE SQL_CB_DELETE >
SQL_CC_NO_RELEASE <C: #define SQL_CC_NO_RELEASE 0 >
SQL_CC_PRESERVE <C: #define SQL_CC_PRESERVE SQL_CB_PRESERVE >
SQL_CC_RELEASE <C: #define SQL_CC_RELEASE 1 >
SQL_CDO_COLLATION <C: #define SQL_CDO_COLLATION 0x00000008 >
SQL_CDO_CONSTRAINT <C: #define SQL_CDO_CONSTRAINT 0x00000004 >
SQL_CDO_CONSTRAINT_DEFERRABLE <C: #define SQL_CDO_CONSTRAINT_DEFERRABLE 0x00000080 >
SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED <C: #define SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED 0x00000020 >
SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE <C: #define SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE 0x00000040 >
SQL_CDO_CONSTRAINT_NAME_DEFINITION <C: #define SQL_CDO_CONSTRAINT_NAME_DEFINITION 0x00000010 >
SQL_CDO_CONSTRAINT_NON_DEFERRABLE <C: #define SQL_CDO_CONSTRAINT_NON_DEFERRABLE 0x00000100 >
SQL_CDO_CREATE_DOMAIN <C: #define SQL_CDO_CREATE_DOMAIN 0x00000001 >
SQL_CDO_DEFAULT <C: #define SQL_CDO_DEFAULT 0x00000002 >
SQL_CD_FALSE <C: #define SQL_CD_FALSE 0 >
SQL_CD_TRUE <C: #define SQL_CD_TRUE 1 >
SQL_CHAR <C: #define SQL_CHAR 1 >
SQL_CLI_STMT_ALTER_TABLE <C: #define SQL_CLI_STMT_ALTER_TABLE 1 >
SQL_CLI_STMT_CALL <C: #define SQL_CLI_STMT_CALL 24 >
SQL_CLI_STMT_CREATE_FUNCTION <C: #define SQL_CLI_STMT_CREATE_FUNCTION 42 >
SQL_CLI_STMT_CREATE_INDEX <C: #define SQL_CLI_STMT_CREATE_INDEX 5 >
SQL_CLI_STMT_CREATE_PROCEDURE <C: #define SQL_CLI_STMT_CREATE_PROCEDURE 41 >
SQL_CLI_STMT_CREATE_TABLE <C: #define SQL_CLI_STMT_CREATE_TABLE 6 >
SQL_CLI_STMT_CREATE_TRIGGER <C: #define SQL_CLI_STMT_CREATE_TRIGGER 34 >
SQL_CLI_STMT_CREATE_VIEW <C: #define SQL_CLI_STMT_CREATE_VIEW 7 >
SQL_CLI_STMT_DELETE_POSITIONED <C: #define SQL_CLI_STMT_DELETE_POSITIONED 9 >
SQL_CLI_STMT_DELETE_SEARCHED <C: #define SQL_CLI_STMT_DELETE_SEARCHED 8 >
SQL_CLI_STMT_DROP_INDEX <C: #define SQL_CLI_STMT_DROP_INDEX 11 >
SQL_CLI_STMT_DROP_PACKAGE <C: #define SQL_CLI_STMT_DROP_PACKAGE 10 >
SQL_CLI_STMT_DROP_TABLE <C: #define SQL_CLI_STMT_DROP_TABLE 12 >
SQL_CLI_STMT_DROP_VIEW <C: #define SQL_CLI_STMT_DROP_VIEW 13 >
SQL_CLI_STMT_GRANT <C: #define SQL_CLI_STMT_GRANT 14 >
SQL_CLI_STMT_INSERT <C: #define SQL_CLI_STMT_INSERT 15 >
SQL_CLI_STMT_REVOKE <C: #define SQL_CLI_STMT_REVOKE 16 >
SQL_CLI_STMT_SELECT <C: #define SQL_CLI_STMT_SELECT 18 >
SQL_CLI_STMT_SELECT_FOR_FETCH <C: #define SQL_CLI_STMT_SELECT_FOR_FETCH 31 >
SQL_CLI_STMT_SELECT_FOR_UPDATE <C: #define SQL_CLI_STMT_SELECT_FOR_UPDATE 29 >
SQL_CLI_STMT_SELECT_INTO <C: #define SQL_CLI_STMT_SELECT_INTO 40 >
SQL_CLI_STMT_SELECT_OPTIMIZE_FOR_NROWS <C: #define SQL_CLI_STMT_SELECT_OPTIMIZE_FOR_NROWS 39 >
SQL_CLI_STMT_SET_CURRENT_QUERY_OPT <C: #define SQL_CLI_STMT_SET_CURRENT_QUERY_OPT 46 >
SQL_CLI_STMT_UNDEFINED <C: #define SQL_CLI_STMT_UNDEFINED 0 >
SQL_CLI_STMT_UPDATE_POSITIONED <C: #define SQL_CLI_STMT_UPDATE_POSITIONED 20 >
SQL_CLI_STMT_UPDATE_SEARCHED <C: #define SQL_CLI_STMT_UPDATE_SEARCHED 19 >
SQL_CLI_STMT_VALUES <C: #define SQL_CLI_STMT_VALUES 32 >
SQL_CLI_STMT_WITH <C: #define SQL_CLI_STMT_WITH 30 >
SQL_CLOB <C: #define SQL_CLOB -99 >
SQL_CLOB_LOCATOR <C: #define SQL_CLOB_LOCATOR 41 >
SQL_CLOSE <C: #define SQL_CLOSE 0 >
SQL_CLOSE_BEHAVIOR <C: #define SQL_CLOSE_BEHAVIOR 1257 >
SQL_CL_END <C: #define SQL_CL_END SQL_QL_END >
SQL_CL_START <C: #define SQL_CL_START SQL_QL_START >
SQL_CMP_NA_ERRORS <C: #define SQL_CMP_NA_ERRORS 1 >
SQL_CMP_REF_INT_ROWS <C: #define SQL_CMP_REF_INT_ROWS 4 >
SQL_CMP_ROWS_AFFECTED <C: #define SQL_CMP_ROWS_AFFECTED 2 >
SQL_CMP_STMTS_COMPLETED <C: #define SQL_CMP_STMTS_COMPLETED 3 >
SQL_CN_ANY <C: #define SQL_CN_ANY 0x0002 >
SQL_CN_DIFFERENT <C: #define SQL_CN_DIFFERENT 0x0001 >
SQL_CN_NONE <C: #define SQL_CN_NONE 0x0000 >
SQL_CODE_DATE <C: #define SQL_CODE_DATE 1 >
SQL_CODE_DAY <C: #define SQL_CODE_DAY 3 >
SQL_CODE_DAY_TO_HOUR <C: #define SQL_CODE_DAY_TO_HOUR 8 >
SQL_CODE_DAY_TO_MINUTE <C: #define SQL_CODE_DAY_TO_MINUTE 9 >
SQL_CODE_DAY_TO_SECOND <C: #define SQL_CODE_DAY_TO_SECOND 10 >
SQL_CODE_HOUR <C: #define SQL_CODE_HOUR 4 >
SQL_CODE_HOUR_TO_MINUTE <C: #define SQL_CODE_HOUR_TO_MINUTE 11 >
SQL_CODE_HOUR_TO_SECOND <C: #define SQL_CODE_HOUR_TO_SECOND 12 >
SQL_CODE_MINUTE <C: #define SQL_CODE_MINUTE 5 >
SQL_CODE_MINUTE_TO_SECOND <C: #define SQL_CODE_MINUTE_TO_SECOND 13 >
SQL_CODE_MONTH <C: #define SQL_CODE_MONTH 2 >
SQL_CODE_SECOND <C: #define SQL_CODE_SECOND 6 >
SQL_CODE_TIME <C: #define SQL_CODE_TIME 2 >
SQL_CODE_TIMESTAMP <C: #define SQL_CODE_TIMESTAMP 3 >
SQL_CODE_YEAR <C: #define SQL_CODE_YEAR 1 >
SQL_CODE_YEAR_TO_MONTH <C: #define SQL_CODE_YEAR_TO_MONTH 7 >
SQL_COLATT_OPT_MAX <C: #define SQL_COLATT_OPT_MAX SQL_COLUMN_LABEL >
SQL_COLATT_OPT_MIN <C: #define SQL_COLATT_OPT_MIN SQL_COLUMN_COUNT >
SQL_COLLATION_SEQ <C: #define SQL_COLLATION_SEQ 10004 >
SQL_COLUMN_ALIAS <C: #define SQL_COLUMN_ALIAS 87 >
SQL_COLUMN_AUTO_INCREMENT <C: #define SQL_COLUMN_AUTO_INCREMENT 11 >
SQL_COLUMN_CASE_SENSITIVE <C: #define SQL_COLUMN_CASE_SENSITIVE 12 >
SQL_COLUMN_CATALOG_NAME <C: #define SQL_COLUMN_CATALOG_NAME 17 >
SQL_COLUMN_COUNT <C: #define SQL_COLUMN_COUNT 0 >
SQL_COLUMN_DISPLAY_SIZE <C: #define SQL_COLUMN_DISPLAY_SIZE 6 >
SQL_COLUMN_DISTINCT_TYPE <C: #define SQL_COLUMN_DISTINCT_TYPE 1250 >
SQL_COLUMN_IGNORE <C: #define SQL_COLUMN_IGNORE SQL_IGNORE >
SQL_COLUMN_LABEL <C: #define SQL_COLUMN_LABEL 18 >
SQL_COLUMN_LENGTH <C: #define SQL_COLUMN_LENGTH 3 >
SQL_COLUMN_MONEY <C: #define SQL_COLUMN_MONEY 9 >
SQL_COLUMN_NAME <C: #define SQL_COLUMN_NAME 1 >
SQL_COLUMN_NO_COLUMN_NUMBER <C: #define SQL_COLUMN_NO_COLUMN_NUMBER (-1) >
SQL_COLUMN_NULLABLE <C: #define SQL_COLUMN_NULLABLE 7 >
SQL_COLUMN_NUMBER_UNKNOWN <C: #define SQL_COLUMN_NUMBER_UNKNOWN (-2) >
SQL_COLUMN_OWNER_NAME <C: #define SQL_COLUMN_OWNER_NAME 16 >
SQL_COLUMN_PRECISION <C: #define SQL_COLUMN_PRECISION 4 >
SQL_COLUMN_QUALIFIER_NAME <C: #define SQL_COLUMN_QUALIFIER_NAME 17 >
SQL_COLUMN_REFERENCE_TYPE <C: #define SQL_COLUMN_REFERENCE_TYPE 1251 >
SQL_COLUMN_SCALE <C: #define SQL_COLUMN_SCALE 5 >
SQL_COLUMN_SCHEMA_NAME <C: #define SQL_COLUMN_SCHEMA_NAME 16 >
SQL_COLUMN_SEARCHABLE <C: #define SQL_COLUMN_SEARCHABLE 13 >
SQL_COLUMN_TABLE_NAME <C: #define SQL_COLUMN_TABLE_NAME 15 >
SQL_COLUMN_TYPE <C: #define SQL_COLUMN_TYPE 2 >
SQL_COLUMN_TYPE_NAME <C: #define SQL_COLUMN_TYPE_NAME 14 >
SQL_COLUMN_UNSIGNED <C: #define SQL_COLUMN_UNSIGNED 8 >
SQL_COLUMN_UPDATABLE <C: #define SQL_COLUMN_UPDATABLE 10 >
SQL_COL_PRED_BASIC <C: #define SQL_COL_PRED_BASIC SQL_ALL_EXCEPT_LIKE >
SQL_COL_PRED_CHAR <C: #define SQL_COL_PRED_CHAR SQL_LIKE_ONLY >
SQL_COMMIT <C: #define SQL_COMMIT 0 >
SQL_CONCAT_NULL_BEHAVIOR <C: #define SQL_CONCAT_NULL_BEHAVIOR 22 >
SQL_CONCURRENCY <C: #define SQL_CONCURRENCY 7 >
SQL_CONCURRENT_TRANS <C: #define SQL_CONCURRENT_TRANS 1 >
SQL_CONCUR_DEFAULT <C: #define SQL_CONCUR_DEFAULT SQL_CONCUR_READ_ONLY >
SQL_CONCUR_LOCK <C: #define SQL_CONCUR_LOCK 2 >
SQL_CONCUR_READ_ONLY <C: #define SQL_CONCUR_READ_ONLY 1 >
SQL_CONCUR_ROWVER <C: #define SQL_CONCUR_ROWVER 3 >
SQL_CONCUR_TIMESTAMP <C: #define SQL_CONCUR_TIMESTAMP SQL_CONCUR_ROWVER >
SQL_CONCUR_VALUES <C: #define SQL_CONCUR_VALUES 4 >
SQL_CONNECTTYPE <C: #define SQL_CONNECTTYPE 1255 >
SQL_CONNECTTYPE_DEFAULT <C: #define SQL_CONNECTTYPE_DEFAULT SQL_CONCURRENT_TRANS >
SQL_CONNECT_DB_APP2DB_CONVFACTOR <C: #define SQL_CONNECT_DB_APP2DB_CONVFACTOR 0 >
SQL_CONNECT_DB_COMMIT_TYPE <C: #define SQL_CONNECT_DB_COMMIT_TYPE 3 >
SQL_CONNECT_DB_DB2APP_CONVFACTOR <C: #define SQL_CONNECT_DB_DB2APP_CONVFACTOR 1 >
SQL_CONNECT_DB_UPDATEABILITY_IN_UOW <C: #define SQL_CONNECT_DB_UPDATEABILITY_IN_UOW 2 >
SQL_CONNECT_WITH_XA_DEFAULT <C: #define SQL_CONNECT_WITH_XA_DEFAULT SQL_CONNECT_WITH_XA_OFF >
SQL_CONNECT_WITH_XA_OFF <C: #define SQL_CONNECT_WITH_XA_OFF 0 >
SQL_CONNECT_WITH_XA_ON <C: #define SQL_CONNECT_WITH_XA_ON 1 >
SQL_CONN_CONTEXT <C: #define SQL_CONN_CONTEXT 1269 >
SQL_CONVERT_BIGINT <C: #define SQL_CONVERT_BIGINT 53 >
SQL_CONVERT_BINARY <C: #define SQL_CONVERT_BINARY 54 >
SQL_CONVERT_BIT <C: #define SQL_CONVERT_BIT 55 >
SQL_CONVERT_CHAR <C: #define SQL_CONVERT_CHAR 56 >
SQL_CONVERT_DATE <C: #define SQL_CONVERT_DATE 57 >
SQL_CONVERT_DECIMAL <C: #define SQL_CONVERT_DECIMAL 58 >
SQL_CONVERT_DOUBLE <C: #define SQL_CONVERT_DOUBLE 59 >
SQL_CONVERT_FLOAT <C: #define SQL_CONVERT_FLOAT 60 >
SQL_CONVERT_FUNCTIONS <C: #define SQL_CONVERT_FUNCTIONS 48 >
SQL_CONVERT_INTEGER <C: #define SQL_CONVERT_INTEGER 61 >
SQL_CONVERT_INTERVAL_DAY_TIME <C: #define SQL_CONVERT_INTERVAL_DAY_TIME 123 >
SQL_CONVERT_INTERVAL_YEAR_MONTH <C: #define SQL_CONVERT_INTERVAL_YEAR_MONTH 124 >
SQL_CONVERT_LONGVARBINARY <C: #define SQL_CONVERT_LONGVARBINARY 71 >
SQL_CONVERT_LONGVARCHAR <C: #define SQL_CONVERT_LONGVARCHAR 62 >
SQL_CONVERT_NUMERIC <C: #define SQL_CONVERT_NUMERIC 63 >
SQL_CONVERT_REAL <C: #define SQL_CONVERT_REAL 64 >
SQL_CONVERT_SMALLINT <C: #define SQL_CONVERT_SMALLINT 65 >
SQL_CONVERT_TIME <C: #define SQL_CONVERT_TIME 66 >
SQL_CONVERT_TIMESTAMP <C: #define SQL_CONVERT_TIMESTAMP 67 >
SQL_CONVERT_TINYINT <C: #define SQL_CONVERT_TINYINT 68 >
SQL_CONVERT_VARBINARY <C: #define SQL_CONVERT_VARBINARY 69 >
SQL_CONVERT_VARCHAR <C: #define SQL_CONVERT_VARCHAR 70 >
SQL_CONVERT_WCHAR <C: #define SQL_CONVERT_WCHAR 122 >
SQL_CONVERT_WLONGVARCHAR <C: #define SQL_CONVERT_WLONGVARCHAR 125 >
SQL_CONVERT_WVARCHAR <C: #define SQL_CONVERT_WVARCHAR 126 >
SQL_COORDINATED_TRANS <C: #define SQL_COORDINATED_TRANS 2 >
SQL_CORRELATION_NAME <C: #define SQL_CORRELATION_NAME 74 >
SQL_CP_DEFAULT <C: #define SQL_CP_DEFAULT SQL_CP_OFF >
SQL_CP_MATCH_DEFAULT <C: #define SQL_CP_MATCH_DEFAULT SQL_CP_STRICT_MATCH >
SQL_CP_OFF <C: #define SQL_CP_OFF 0 >
SQL_CP_ONE_PER_DRIVER <C: #define SQL_CP_ONE_PER_DRIVER 1 >
SQL_CP_ONE_PER_HENV <C: #define SQL_CP_ONE_PER_HENV 2 >
SQL_CP_RELAXED_MATCH <C: #define SQL_CP_RELAXED_MATCH 1 >
SQL_CP_STRICT_MATCH <C: #define SQL_CP_STRICT_MATCH 0 >
SQL_CREATE_ASSERTION <C: #define SQL_CREATE_ASSERTION 127 >
SQL_CREATE_CHARACTER_SET <C: #define SQL_CREATE_CHARACTER_SET 128 >
SQL_CREATE_COLLATION <C: #define SQL_CREATE_COLLATION 129 >
SQL_CREATE_DOMAIN <C: #define SQL_CREATE_DOMAIN 130 >
SQL_CREATE_SCHEMA <C: #define SQL_CREATE_SCHEMA 131 >
SQL_CREATE_TABLE <C: #define SQL_CREATE_TABLE 132 >
SQL_CREATE_TRANSLATION <C: #define SQL_CREATE_TRANSLATION 133 >
SQL_CREATE_VIEW <C: #define SQL_CREATE_VIEW 134 >
SQL_CR_CLOSE <C: #define SQL_CR_CLOSE SQL_CB_CLOSE >
SQL_CR_DELETE <C: #define SQL_CR_DELETE SQL_CB_DELETE >
SQL_CR_PRESERVE <C: #define SQL_CR_PRESERVE SQL_CB_PRESERVE >
SQL_CS_AUTHORIZATION <C: #define SQL_CS_AUTHORIZATION 0x00000002 >
SQL_CS_CREATE_SCHEMA <C: #define SQL_CS_CREATE_SCHEMA 0x00000001 >
SQL_CS_DEFAULT_CHARACTER_SET <C: #define SQL_CS_DEFAULT_CHARACTER_SET 0x00000004 >
SQL_CTR_CREATE_TRANSLATION <C: #define SQL_CTR_CREATE_TRANSLATION 0x00000001 >
SQL_CT_COLUMN_COLLATION <C: #define SQL_CT_COLUMN_COLLATION 0x00000800 >
SQL_CT_COLUMN_CONSTRAINT <C: #define SQL_CT_COLUMN_CONSTRAINT 0x00000200 >
SQL_CT_COLUMN_DEFAULT <C: #define SQL_CT_COLUMN_DEFAULT 0x00000400 >
SQL_CT_COMMIT_DELETE <C: #define SQL_CT_COMMIT_DELETE 0x00000004 >
SQL_CT_COMMIT_PRESERVE <C: #define SQL_CT_COMMIT_PRESERVE 0x00000002 >
SQL_CT_CONSTRAINT_DEFERRABLE <C: #define SQL_CT_CONSTRAINT_DEFERRABLE 0x00000080 >
SQL_CT_CONSTRAINT_INITIALLY_DEFERRED <C: #define SQL_CT_CONSTRAINT_INITIALLY_DEFERRED 0x00000020 >
SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE <C: #define SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE 0x00000040 >
SQL_CT_CONSTRAINT_NAME_DEFINITION <C: #define SQL_CT_CONSTRAINT_NAME_DEFINITION 0x00002000 >
SQL_CT_CONSTRAINT_NON_DEFERRABLE <C: #define SQL_CT_CONSTRAINT_NON_DEFERRABLE 0x00000100 >
SQL_CT_CREATE_TABLE <C: #define SQL_CT_CREATE_TABLE 0x00000001 >
SQL_CT_GLOBAL_TEMPORARY <C: #define SQL_CT_GLOBAL_TEMPORARY 0x00000008 >
SQL_CT_LOCAL_TEMPORARY <C: #define SQL_CT_LOCAL_TEMPORARY 0x00000010 >
SQL_CT_TABLE_CONSTRAINT <C: #define SQL_CT_TABLE_CONSTRAINT 0x00001000 >
SQL_CURRENT_QUALIFIER <C: #define SQL_CURRENT_QUALIFIER 109 >
SQL_CURRENT_SCHEMA <C: #define SQL_CURRENT_SCHEMA 1254 >
SQL_CURSOR_COMMIT_BEHAVIOR <C: #define SQL_CURSOR_COMMIT_BEHAVIOR 23 >
SQL_CURSOR_DYNAMIC <C: #define SQL_CURSOR_DYNAMIC 2 >
SQL_CURSOR_FORWARD_ONLY <C: #define SQL_CURSOR_FORWARD_ONLY 0 >
SQL_CURSOR_HOLD <C: #define SQL_CURSOR_HOLD 1250 >
SQL_CURSOR_HOLD_DEFAULT <C: #define SQL_CURSOR_HOLD_DEFAULT SQL_CURSOR_HOLD_ON >
SQL_CURSOR_HOLD_OFF <C: #define SQL_CURSOR_HOLD_OFF 0 >
SQL_CURSOR_HOLD_ON <C: #define SQL_CURSOR_HOLD_ON 1 >
SQL_CURSOR_KEYSET_DRIVEN <C: #define SQL_CURSOR_KEYSET_DRIVEN 1 >
SQL_CURSOR_ROLLBACK_BEHAVIOR <C: #define SQL_CURSOR_ROLLBACK_BEHAVIOR 24 >
SQL_CURSOR_SENSITIVITY <C: #define SQL_CURSOR_SENSITIVITY 10001 >
SQL_CURSOR_STATIC <C: #define SQL_CURSOR_STATIC 3 >
SQL_CURSOR_TYPE <C: #define SQL_CURSOR_TYPE 6 >
SQL_CURSOR_TYPE_DEFAULT <C: #define SQL_CURSOR_TYPE_DEFAULT SQL_CURSOR_FORWARD_ONLY >
SQL_CUR_DEFAULT <C: #define SQL_CUR_DEFAULT SQL_CUR_USE_DRIVER >
SQL_CUR_USE_DRIVER <C: #define SQL_CUR_USE_DRIVER 2 >
SQL_CUR_USE_IF_NEEDED <C: #define SQL_CUR_USE_IF_NEEDED 0 >
SQL_CUR_USE_ODBC <C: #define SQL_CUR_USE_ODBC 1 >
SQL_CU_DML_STATEMENTS <C: #define SQL_CU_DML_STATEMENTS SQL_QU_DML_STATEMENTS >
SQL_CU_INDEX_DEFINITION <C: #define SQL_CU_INDEX_DEFINITION SQL_QU_INDEX_DEFINITION >
SQL_CU_PRIVILEGE_DEFINITION <C: #define SQL_CU_PRIVILEGE_DEFINITION SQL_QU_PRIVILEGE_DEFINITION >
SQL_CU_PROCEDURE_INVOCATION <C: #define SQL_CU_PROCEDURE_INVOCATION SQL_QU_PROCEDURE_INVOCATION >
SQL_CU_TABLE_DEFINITION <C: #define SQL_CU_TABLE_DEFINITION SQL_QU_TABLE_DEFINITION >
SQL_CVT_BIGINT <C: #define SQL_CVT_BIGINT 0x00004000 >
SQL_CVT_BINARY <C: #define SQL_CVT_BINARY 0x00000400 >
SQL_CVT_BIT <C: #define SQL_CVT_BIT 0x00001000 >
SQL_CVT_CHAR <C: #define SQL_CVT_CHAR 0x00000001 >
SQL_CVT_DATE <C: #define SQL_CVT_DATE 0x00008000 >
SQL_CVT_DECIMAL <C: #define SQL_CVT_DECIMAL 0x00000004 >
SQL_CVT_DOUBLE <C: #define SQL_CVT_DOUBLE 0x00000080 >
SQL_CVT_FLOAT <C: #define SQL_CVT_FLOAT 0x00000020 >
SQL_CVT_INTEGER <C: #define SQL_CVT_INTEGER 0x00000008 >
SQL_CVT_INTERVAL_DAY_TIME <C: #define SQL_CVT_INTERVAL_DAY_TIME 0x00100000 >
SQL_CVT_INTERVAL_YEAR_MONTH <C: #define SQL_CVT_INTERVAL_YEAR_MONTH 0x00080000 >
SQL_CVT_LONGVARBINARY <C: #define SQL_CVT_LONGVARBINARY 0x00040000 >
SQL_CVT_LONGVARCHAR <C: #define SQL_CVT_LONGVARCHAR 0x00000200 >
SQL_CVT_NUMERIC <C: #define SQL_CVT_NUMERIC 0x00000002 >
SQL_CVT_REAL <C: #define SQL_CVT_REAL 0x00000040 >
SQL_CVT_SMALLINT <C: #define SQL_CVT_SMALLINT 0x00000010 >
SQL_CVT_TIME <C: #define SQL_CVT_TIME 0x00010000 >
SQL_CVT_TIMESTAMP <C: #define SQL_CVT_TIMESTAMP 0x00020000 >
SQL_CVT_TINYINT <C: #define SQL_CVT_TINYINT 0x00002000 >
SQL_CVT_VARBINARY <C: #define SQL_CVT_VARBINARY 0x00000800 >
SQL_CVT_VARCHAR <C: #define SQL_CVT_VARCHAR 0x00000100 >
SQL_CVT_WCHAR <C: #define SQL_CVT_WCHAR 0x00200000 >
SQL_CVT_WLONGVARCHAR <C: #define SQL_CVT_WLONGVARCHAR 0x00400000 >
SQL_CVT_WVARCHAR <C: #define SQL_CVT_WVARCHAR 0x00800000 >
SQL_CV_CASCADED <C: #define SQL_CV_CASCADED 0x00000004 >
SQL_CV_CHECK_OPTION <C: #define SQL_CV_CHECK_OPTION 0x00000002 >
SQL_CV_CREATE_VIEW <C: #define SQL_CV_CREATE_VIEW 0x00000001 >
SQL_CV_LOCAL <C: #define SQL_CV_LOCAL 0x00000008 >
SQL_C_BINARY <C: #define SQL_C_BINARY SQL_BINARY >
SQL_C_BIT <C: #define SQL_C_BIT SQL_BIT >
SQL_C_BLOB_LOCATOR <C: #define SQL_C_BLOB_LOCATOR SQL_BLOB_LOCATOR >
SQL_C_BOOKMARK <C: #define SQL_C_BOOKMARK SQL_C_ULONG >
SQL_C_CHAR <C: #define SQL_C_CHAR SQL_CHAR >
SQL_C_CLOB_LOCATOR <C: #define SQL_C_CLOB_LOCATOR SQL_CLOB_LOCATOR >
SQL_C_DATALINK <C: #define SQL_C_DATALINK SQL_C_CHAR >
SQL_C_DATE <C: #define SQL_C_DATE SQL_DATE >
SQL_C_DBCHAR <C: #define SQL_C_DBCHAR SQL_DBCLOB >
SQL_C_DBCLOB_LOCATOR <C: #define SQL_C_DBCLOB_LOCATOR SQL_DBCLOB_LOCATOR >
SQL_C_DECIMAL_IBM <C: #define SQL_C_DECIMAL_IBM SQL_DECIMAL >
SQL_C_DEFAULT <C: #define SQL_C_DEFAULT 99 >
SQL_C_DOUBLE <C: #define SQL_C_DOUBLE SQL_DOUBLE >
SQL_C_FLOAT <C: #define SQL_C_FLOAT SQL_REAL >
SQL_C_INTERVAL_DAY <C: #define SQL_C_INTERVAL_DAY SQL_INTERVAL_DAY >
SQL_C_INTERVAL_DAY_TO_HOUR <C: #define SQL_C_INTERVAL_DAY_TO_HOUR SQL_INTERVAL_DAY_TO_HOUR >
SQL_C_INTERVAL_DAY_TO_MINUTE <C: #define SQL_C_INTERVAL_DAY_TO_MINUTE SQL_INTERVAL_DAY_TO_MINUTE >
SQL_C_INTERVAL_DAY_TO_SECOND <C: #define SQL_C_INTERVAL_DAY_TO_SECOND SQL_INTERVAL_DAY_TO_SECOND >
SQL_C_INTERVAL_HOUR <C: #define SQL_C_INTERVAL_HOUR SQL_INTERVAL_HOUR >
SQL_C_INTERVAL_HOUR_TO_MINUTE <C: #define SQL_C_INTERVAL_HOUR_TO_MINUTE SQL_INTERVAL_HOUR_TO_MINUTE >
SQL_C_INTERVAL_HOUR_TO_SECOND <C: #define SQL_C_INTERVAL_HOUR_TO_SECOND SQL_INTERVAL_HOUR_TO_SECOND >
SQL_C_INTERVAL_MINUTE <C: #define SQL_C_INTERVAL_MINUTE SQL_INTERVAL_MINUTE >
SQL_C_INTERVAL_MINUTE_TO_SECOND <C: #define SQL_C_INTERVAL_MINUTE_TO_SECOND SQL_INTERVAL_MINUTE_TO_SECOND >
SQL_C_INTERVAL_MONTH <C: #define SQL_C_INTERVAL_MONTH SQL_INTERVAL_MONTH >
SQL_C_INTERVAL_SECOND <C: #define SQL_C_INTERVAL_SECOND SQL_INTERVAL_SECOND >
SQL_C_INTERVAL_YEAR <C: #define SQL_C_INTERVAL_YEAR SQL_INTERVAL_YEAR >
SQL_C_INTERVAL_YEAR_TO_MONTH <C: #define SQL_C_INTERVAL_YEAR_TO_MONTH SQL_INTERVAL_YEAR_TO_MONTH >
SQL_C_LONG <C: #define SQL_C_LONG SQL_INTEGER >
SQL_C_NUMERIC <C: #define SQL_C_NUMERIC SQL_NUMERIC >
SQL_C_PTR <C: #define SQL_C_PTR 2463 >
SQL_C_SBIGINT <C: #define SQL_C_SBIGINT (SQL_BIGINT+SQL_SIGNED_OFFSET) >
SQL_C_SHORT <C: #define SQL_C_SHORT SQL_SMALLINT >
SQL_C_SLONG <C: #define SQL_C_SLONG (SQL_C_LONG+SQL_SIGNED_OFFSET) >
SQL_C_SSHORT <C: #define SQL_C_SSHORT (SQL_C_SHORT+SQL_SIGNED_OFFSET) >
SQL_C_STINYINT <C: #define SQL_C_STINYINT (SQL_TINYINT+SQL_SIGNED_OFFSET) >
SQL_C_TCHAR <C: #define SQL_C_TCHAR SQL_C_CHAR >
SQL_C_TIME <C: #define SQL_C_TIME SQL_TIME >
SQL_C_TIMESTAMP <C: #define SQL_C_TIMESTAMP SQL_TIMESTAMP >
SQL_C_TINYINT <C: #define SQL_C_TINYINT SQL_TINYINT >
SQL_C_TYPE_DATE <C: #define SQL_C_TYPE_DATE SQL_TYPE_DATE >
SQL_C_TYPE_TIME <C: #define SQL_C_TYPE_TIME SQL_TYPE_TIME >
SQL_C_TYPE_TIMESTAMP <C: #define SQL_C_TYPE_TIMESTAMP SQL_TYPE_TIMESTAMP >
SQL_C_UBIGINT <C: #define SQL_C_UBIGINT (SQL_BIGINT+SQL_UNSIGNED_OFFSET) >
SQL_C_ULONG <C: #define SQL_C_ULONG (SQL_C_LONG+SQL_UNSIGNED_OFFSET) >
SQL_C_USHORT <C: #define SQL_C_USHORT (SQL_C_SHORT+SQL_UNSIGNED_OFFSET) >
SQL_C_UTINYINT <C: #define SQL_C_UTINYINT (SQL_TINYINT+SQL_UNSIGNED_OFFSET) >
SQL_C_VARBOOKMARK <C: #define SQL_C_VARBOOKMARK SQL_C_BINARY >
SQL_C_WCHAR <C: #define SQL_C_WCHAR SQL_WCHAR >
SQL_DATABASE_NAME <C: #define SQL_DATABASE_NAME 16 >
SQL_DATALINK <C: #define SQL_DATALINK -400 >
SQL_DATALINK_URL <C: #define SQL_DATALINK_URL "URL" >
SQL_DATA_AT_EXEC <C: #define SQL_DATA_AT_EXEC -2 >
SQL_DATA_SOURCE_NAME <C: #define SQL_DATA_SOURCE_NAME 2 >
SQL_DATA_SOURCE_READ_ONLY <C: #define SQL_DATA_SOURCE_READ_ONLY 25 >
SQL_DATE <C: #define SQL_DATE 9 >
SQL_DATETIME <C: #define SQL_DATETIME 9 >
SQL_DATETIME_LITERALS <C: #define SQL_DATETIME_LITERALS 119 >
SQL_DATE_LEN <C: #define SQL_DATE_LEN 10 >
SQL_DA_DROP_ASSERTION <C: #define SQL_DA_DROP_ASSERTION 0x00000001 >
SQL_DB2ESTIMATE <C: #define SQL_DB2ESTIMATE 1259 >
SQL_DB2ESTIMATE_DEFAULT <C: #define SQL_DB2ESTIMATE_DEFAULT SQL_DB2ESTIMATE_OFF >
SQL_DB2ESTIMATE_OFF <C: #define SQL_DB2ESTIMATE_OFF 0 >
SQL_DB2ESTIMATE_ON <C: #define SQL_DB2ESTIMATE_ON 1 >
SQL_DB2EXPLAIN <C: #define SQL_DB2EXPLAIN 1258 >
SQL_DB2EXPLAIN_DEFAULT <C: #define SQL_DB2EXPLAIN_DEFAULT SQL_DB2EXPLAIN_OFF >
SQL_DB2EXPLAIN_MODE_ON <C: #define SQL_DB2EXPLAIN_MODE_ON 0x00000002 >
SQL_DB2EXPLAIN_OFF <C: #define SQL_DB2EXPLAIN_OFF 0x00000000 >
SQL_DB2EXPLAIN_ON <C: #define SQL_DB2EXPLAIN_ON SQL_DB2EXPLAIN_SNAPSHOT_ON >
SQL_DB2EXPLAIN_SNAPSHOT_MODE_ON <C: #define SQL_DB2EXPLAIN_SNAPSHOT_MODE_ON SQL_DB2EXPLAIN_SNAPSHOT_ON+SQL_DB2EXPLAIN_MODE_ON >
SQL_DB2EXPLAIN_SNAPSHOT_ON <C: #define SQL_DB2EXPLAIN_SNAPSHOT_ON 0x00000001 >
SQL_DBCLOB <C: #define SQL_DBCLOB -350 >
SQL_DBCLOB_LOCATOR <C: #define SQL_DBCLOB_LOCATOR -351 >
SQL_DBMS_NAME <C: #define SQL_DBMS_NAME 17 >
SQL_DBMS_VER <C: #define SQL_DBMS_VER 18 >
SQL_DB_DEFAULT <C: #define SQL_DB_DEFAULT SQL_DB_RETURN_TO_POOL >
SQL_DB_DISCONNECT <C: #define SQL_DB_DISCONNECT 1 >
SQL_DB_ONE_PHASE_COMMIT <C: #define SQL_DB_ONE_PHASE_COMMIT 1 >
SQL_DB_ONE_PHASE_READ_ONLY <C: #define SQL_DB_ONE_PHASE_READ_ONLY 2 >
SQL_DB_READ_ONLY <C: #define SQL_DB_READ_ONLY 2 >
SQL_DB_RETURN_TO_POOL <C: #define SQL_DB_RETURN_TO_POOL 0 >
SQL_DB_TWO_PHASE_COMMIT <C: #define SQL_DB_TWO_PHASE_COMMIT 3 >
SQL_DB_UPDATEABLE <C: #define SQL_DB_UPDATEABLE 1 >
SQL_DCS_DROP_CHARACTER_SET <C: #define SQL_DCS_DROP_CHARACTER_SET 0x00000001 >
SQL_DC_DROP_COLLATION <C: #define SQL_DC_DROP_COLLATION 0x00000001 >
SQL_DDL_INDEX <C: #define SQL_DDL_INDEX 170 >
SQL_DD_CASCADE <C: #define SQL_DD_CASCADE 0x00000004 >
SQL_DD_DROP_DOMAIN <C: #define SQL_DD_DROP_DOMAIN 0x00000001 >
SQL_DD_RESTRICT <C: #define SQL_DD_RESTRICT 0x00000002 >
SQL_DECIMAL <C: #define SQL_DECIMAL 3 >
SQL_DEFAULT <C: #define SQL_DEFAULT 99 >
SQL_DEFAULT_PARAM <C: #define SQL_DEFAULT_PARAM (-5) >
SQL_DEFAULT_TXN_ISOLATION <C: #define SQL_DEFAULT_TXN_ISOLATION 26 >
SQL_DEFERRED_PREPARE_DEFAULT <C: #define SQL_DEFERRED_PREPARE_DEFAULT SQL_DEFERRED_PREPARE_ON >
SQL_DEFERRED_PREPARE_OFF <C: #define SQL_DEFERRED_PREPARE_OFF 0 >
SQL_DEFERRED_PREPARE_ON <C: #define SQL_DEFERRED_PREPARE_ON 1 >
SQL_DELETE <C: #define SQL_DELETE 3 >
SQL_DELETE_BY_BOOKMARK <C: #define SQL_DELETE_BY_BOOKMARK 6 >
SQL_DESCRIBE_PARAMETER <C: #define SQL_DESCRIBE_PARAMETER 10002 >
SQL_DESC_ALLOC_AUTO <C: #define SQL_DESC_ALLOC_AUTO 1 >
SQL_DESC_ALLOC_TYPE <C: #define SQL_DESC_ALLOC_TYPE 1099 >
SQL_DESC_ALLOC_USER <C: #define SQL_DESC_ALLOC_USER 2 >
SQL_DESC_ARRAY_SIZE <C: #define SQL_DESC_ARRAY_SIZE 20 >
SQL_DESC_ARRAY_STATUS_PTR <C: #define SQL_DESC_ARRAY_STATUS_PTR 21 >
SQL_DESC_AUTO_UNIQUE_VALUE <C: #define SQL_DESC_AUTO_UNIQUE_VALUE SQL_COLUMN_AUTO_INCREMENT >
SQL_DESC_BASE_COLUMN_NAME <C: #define SQL_DESC_BASE_COLUMN_NAME 22 >
SQL_DESC_BASE_TABLE_NAME <C: #define SQL_DESC_BASE_TABLE_NAME 23 >
SQL_DESC_BASE_TYPE <C: #define SQL_DESC_BASE_TYPE 1254 >
SQL_DESC_BIND_OFFSET_PTR <C: #define SQL_DESC_BIND_OFFSET_PTR 24 >
SQL_DESC_BIND_TYPE <C: #define SQL_DESC_BIND_TYPE 25 >
SQL_DESC_CASE_SENSITIVE <C: #define SQL_DESC_CASE_SENSITIVE SQL_COLUMN_CASE_SENSITIVE >
SQL_DESC_CATALOG_NAME <C: #define SQL_DESC_CATALOG_NAME SQL_COLUMN_QUALIFIER_NAME >
SQL_DESC_CONCISE_TYPE <C: #define SQL_DESC_CONCISE_TYPE SQL_COLUMN_TYPE >
SQL_DESC_COUNT <C: #define SQL_DESC_COUNT 1001 >
SQL_DESC_DATA_PTR <C: #define SQL_DESC_DATA_PTR 1010 >
SQL_DESC_DATETIME_INTERVAL_CODE <C: #define SQL_DESC_DATETIME_INTERVAL_CODE 1007 >
SQL_DESC_DATETIME_INTERVAL_PRECISION <C: #define SQL_DESC_DATETIME_INTERVAL_PRECISION 26 >
SQL_DESC_DESCRIPTOR_TYPE <C: #define SQL_DESC_DESCRIPTOR_TYPE 1287 >
SQL_DESC_DISPLAY_SIZE <C: #define SQL_DESC_DISPLAY_SIZE SQL_COLUMN_DISPLAY_SIZE >
SQL_DESC_DISTINCT_TYPE <C: #define SQL_DESC_DISTINCT_TYPE SQL_COLUMN_DISTINCT_TYPE >
SQL_DESC_FIXED_PREC_SCALE <C: #define SQL_DESC_FIXED_PREC_SCALE SQL_COLUMN_MONEY >
SQL_DESC_INDICATOR_PTR <C: #define SQL_DESC_INDICATOR_PTR 1009 >
SQL_DESC_LABEL <C: #define SQL_DESC_LABEL SQL_COLUMN_LABEL >
SQL_DESC_LENGTH <C: #define SQL_DESC_LENGTH 1003 >
SQL_DESC_LITERAL_PREFIX <C: #define SQL_DESC_LITERAL_PREFIX 27 >
SQL_DESC_LITERAL_SUFFIX <C: #define SQL_DESC_LITERAL_SUFFIX 28 >
SQL_DESC_LOCAL_TYPE_NAME <C: #define SQL_DESC_LOCAL_TYPE_NAME 29 >
SQL_DESC_MAXIMUM_SCALE <C: #define SQL_DESC_MAXIMUM_SCALE 30 >
SQL_DESC_MINIMUM_SCALE <C: #define SQL_DESC_MINIMUM_SCALE 31 >
SQL_DESC_NAME <C: #define SQL_DESC_NAME 1011 >
SQL_DESC_NULLABLE <C: #define SQL_DESC_NULLABLE 1008 >
SQL_DESC_NUM_PREC_RADIX <C: #define SQL_DESC_NUM_PREC_RADIX 32 >
SQL_DESC_OCTET_LENGTH <C: #define SQL_DESC_OCTET_LENGTH 1013 >
SQL_DESC_OCTET_LENGTH_PTR <C: #define SQL_DESC_OCTET_LENGTH_PTR 1004 >
SQL_DESC_PARAMETER_TYPE <C: #define SQL_DESC_PARAMETER_TYPE 33 >
SQL_DESC_PRECISION <C: #define SQL_DESC_PRECISION 1005 >
SQL_DESC_REFERENCE_TYPE <C: #define SQL_DESC_REFERENCE_TYPE SQL_COLUMN_REFERENCE_TYPE >
SQL_DESC_ROWS_PROCESSED_PTR <C: #define SQL_DESC_ROWS_PROCESSED_PTR 34 >
SQL_DESC_SCALE <C: #define SQL_DESC_SCALE 1006 >
SQL_DESC_SCHEMA_NAME <C: #define SQL_DESC_SCHEMA_NAME SQL_COLUMN_OWNER_NAME >
SQL_DESC_SEARCHABLE <C: #define SQL_DESC_SEARCHABLE SQL_COLUMN_SEARCHABLE >
SQL_DESC_STRUCTURED_TYPE <C: #define SQL_DESC_STRUCTURED_TYPE 1252 >
SQL_DESC_TABLE_NAME <C: #define SQL_DESC_TABLE_NAME SQL_COLUMN_TABLE_NAME >
SQL_DESC_TYPE <C: #define SQL_DESC_TYPE 1002 >
SQL_DESC_TYPE_NAME <C: #define SQL_DESC_TYPE_NAME SQL_COLUMN_TYPE_NAME >
SQL_DESC_UNNAMED <C: #define SQL_DESC_UNNAMED 1012 >
SQL_DESC_UNSIGNED <C: #define SQL_DESC_UNSIGNED SQL_COLUMN_UNSIGNED >
SQL_DESC_UPDATABLE <C: #define SQL_DESC_UPDATABLE SQL_COLUMN_UPDATABLE >
SQL_DESC_USER_DEFINED_TYPE_CODE <C: #define SQL_DESC_USER_DEFINED_TYPE_CODE 1098 >
SQL_DESC_USER_TYPE <C: #define SQL_DESC_USER_TYPE 1253 >
SQL_DIAG_ALTER_TABLE <C: #define SQL_DIAG_ALTER_TABLE 4 >
SQL_DIAG_CALL <C: #define SQL_DIAG_CALL 7 >
SQL_DIAG_CLASS_ORIGIN <C: #define SQL_DIAG_CLASS_ORIGIN 8 >
SQL_DIAG_COLUMN_NUMBER <C: #define SQL_DIAG_COLUMN_NUMBER (-1247) >
SQL_DIAG_CONNECTION_NAME <C: #define SQL_DIAG_CONNECTION_NAME 10 >
SQL_DIAG_CREATE_INDEX <C: #define SQL_DIAG_CREATE_INDEX (-1) >
SQL_DIAG_CREATE_TABLE <C: #define SQL_DIAG_CREATE_TABLE 77 >
SQL_DIAG_CREATE_VIEW <C: #define SQL_DIAG_CREATE_VIEW 84 >
SQL_DIAG_CURSOR_ROW_COUNT <C: #define SQL_DIAG_CURSOR_ROW_COUNT (-1249) >
SQL_DIAG_DEFERRED_PREPARE_ERROR <C: #define SQL_DIAG_DEFERRED_PREPARE_ERROR 1279 >
SQL_DIAG_DELETE_WHERE <C: #define SQL_DIAG_DELETE_WHERE 19 >
SQL_DIAG_DROP_INDEX <C: #define SQL_DIAG_DROP_INDEX (-2) >
SQL_DIAG_DROP_TABLE <C: #define SQL_DIAG_DROP_TABLE 32 >
SQL_DIAG_DROP_VIEW <C: #define SQL_DIAG_DROP_VIEW 36 >
SQL_DIAG_DYNAMIC_DELETE_CURSOR <C: #define SQL_DIAG_DYNAMIC_DELETE_CURSOR 38 >
SQL_DIAG_DYNAMIC_FUNCTION <C: #define SQL_DIAG_DYNAMIC_FUNCTION 7 >
SQL_DIAG_DYNAMIC_FUNCTION_CODE <C: #define SQL_DIAG_DYNAMIC_FUNCTION_CODE 12 >
SQL_DIAG_DYNAMIC_UPDATE_CURSOR <C: #define SQL_DIAG_DYNAMIC_UPDATE_CURSOR 81 >
SQL_DIAG_ERRMC <C: #define SQL_DIAG_ERRMC 2467 >
SQL_DIAG_GRANT <C: #define SQL_DIAG_GRANT 48 >
SQL_DIAG_INSERT <C: #define SQL_DIAG_INSERT 50 >
SQL_DIAG_LINE_NUMBER <C: #define SQL_DIAG_LINE_NUMBER 2461 >
SQL_DIAG_MESSAGE_TEXT <C: #define SQL_DIAG_MESSAGE_TEXT 6 >
SQL_DIAG_MESSAGE_TEXT_PTR <C: #define SQL_DIAG_MESSAGE_TEXT_PTR 2456 >
SQL_DIAG_NATIVE <C: #define SQL_DIAG_NATIVE 5 >
SQL_DIAG_NUMBER <C: #define SQL_DIAG_NUMBER 2 >
SQL_DIAG_RETURNCODE <C: #define SQL_DIAG_RETURNCODE 1 >
SQL_DIAG_REVOKE <C: #define SQL_DIAG_REVOKE 59 >
SQL_DIAG_ROW_COUNT <C: #define SQL_DIAG_ROW_COUNT 3 >
SQL_DIAG_ROW_NUMBER <C: #define SQL_DIAG_ROW_NUMBER (-1248) >
SQL_DIAG_SELECT_CURSOR <C: #define SQL_DIAG_SELECT_CURSOR 85 >
SQL_DIAG_SERVER_NAME <C: #define SQL_DIAG_SERVER_NAME 11 >
SQL_DIAG_SQLSTATE <C: #define SQL_DIAG_SQLSTATE 4 >
SQL_DIAG_SUBCLASS_ORIGIN <C: #define SQL_DIAG_SUBCLASS_ORIGIN 9 >
SQL_DIAG_UNKNOWN_STATEMENT <C: #define SQL_DIAG_UNKNOWN_STATEMENT 0 >
SQL_DIAG_UPDATE_WHERE <C: #define SQL_DIAG_UPDATE_WHERE 82 >
SQL_DI_CREATE_INDEX <C: #define SQL_DI_CREATE_INDEX 0x00000001 >
SQL_DI_DROP_INDEX <C: #define SQL_DI_DROP_INDEX 0x00000002 >
SQL_DL_SQL92_DATE <C: #define SQL_DL_SQL92_DATE 0x00000001 >
SQL_DL_SQL92_INTERVAL_DAY <C: #define SQL_DL_SQL92_INTERVAL_DAY 0x00000020 >
SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR <C: #define SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR 0x00000400 >
SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE <C: #define SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE 0x00000800 >
SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND <C: #define SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND 0x00001000 >
SQL_DL_SQL92_INTERVAL_HOUR <C: #define SQL_DL_SQL92_INTERVAL_HOUR 0x00000040 >
SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE <C: #define SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE 0x00002000 >
SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND <C: #define SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND 0x00004000 >
SQL_DL_SQL92_INTERVAL_MINUTE <C: #define SQL_DL_SQL92_INTERVAL_MINUTE 0x00000080 >
SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND <C: #define SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND 0x00008000 >
SQL_DL_SQL92_INTERVAL_MONTH <C: #define SQL_DL_SQL92_INTERVAL_MONTH 0x00000010 >
SQL_DL_SQL92_INTERVAL_SECOND <C: #define SQL_DL_SQL92_INTERVAL_SECOND 0x00000100 >
SQL_DL_SQL92_INTERVAL_YEAR <C: #define SQL_DL_SQL92_INTERVAL_YEAR 0x00000008 >
SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH <C: #define SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH 0x00000200 >
SQL_DL_SQL92_TIME <C: #define SQL_DL_SQL92_TIME 0x00000002 >
SQL_DL_SQL92_TIMESTAMP <C: #define SQL_DL_SQL92_TIMESTAMP 0x00000004 >
SQL_DM_VER <C: #define SQL_DM_VER 171 >
SQL_DOUBLE <C: #define SQL_DOUBLE 8 >
SQL_DRIVER_COMPLETE <C: #define SQL_DRIVER_COMPLETE 1 >
SQL_DRIVER_COMPLETE_REQUIRED <C: #define SQL_DRIVER_COMPLETE_REQUIRED 3 >
SQL_DRIVER_HDBC <C: #define SQL_DRIVER_HDBC 3 >
SQL_DRIVER_HDESC <C: #define SQL_DRIVER_HDESC 135 >
SQL_DRIVER_HENV <C: #define SQL_DRIVER_HENV 4 >
SQL_DRIVER_HLIB <C: #define SQL_DRIVER_HLIB 76 >
SQL_DRIVER_HSTMT <C: #define SQL_DRIVER_HSTMT 5 >
SQL_DRIVER_NAME <C: #define SQL_DRIVER_NAME 6 >
SQL_DRIVER_NOPROMPT <C: #define SQL_DRIVER_NOPROMPT 0 >
SQL_DRIVER_ODBC_VER <C: #define SQL_DRIVER_ODBC_VER 77 >
SQL_DRIVER_PROMPT <C: #define SQL_DRIVER_PROMPT 2 >
SQL_DRIVER_VER <C: #define SQL_DRIVER_VER 7 >
SQL_DROP <C: #define SQL_DROP 1 >
SQL_DROP_ASSERTION <C: #define SQL_DROP_ASSERTION 136 >
SQL_DROP_CHARACTER_SET <C: #define SQL_DROP_CHARACTER_SET 137 >
SQL_DROP_COLLATION <C: #define SQL_DROP_COLLATION 138 >
SQL_DROP_DOMAIN <C: #define SQL_DROP_DOMAIN 139 >
SQL_DROP_SCHEMA <C: #define SQL_DROP_SCHEMA 140 >
SQL_DROP_TABLE <C: #define SQL_DROP_TABLE 141 >
SQL_DROP_TRANSLATION <C: #define SQL_DROP_TRANSLATION 142 >
SQL_DROP_VIEW <C: #define SQL_DROP_VIEW 143 >
SQL_DS_CASCADE <C: #define SQL_DS_CASCADE 0x00000004 >
SQL_DS_DROP_SCHEMA <C: #define SQL_DS_DROP_SCHEMA 0x00000001 >
SQL_DS_RESTRICT <C: #define SQL_DS_RESTRICT 0x00000002 >
SQL_DTC_DONE <C: #define SQL_DTC_DONE 0 >
SQL_DTC_ENLIST_EXPENSIVE <C: #define SQL_DTC_ENLIST_EXPENSIVE 0x00000001 >
SQL_DTC_TRANSITION_COST <C: #define SQL_DTC_TRANSITION_COST 1750 >
SQL_DTC_UNENLIST_EXPENSIVE <C: #define SQL_DTC_UNENLIST_EXPENSIVE 0x00000002 >
SQL_DTR_DROP_TRANSLATION <C: #define SQL_DTR_DROP_TRANSLATION 0x00000001 >
SQL_DT_CASCADE <C: #define SQL_DT_CASCADE 0x00000004 >
SQL_DT_DROP_TABLE <C: #define SQL_DT_DROP_TABLE 0x00000001 >
SQL_DT_RESTRICT <C: #define SQL_DT_RESTRICT 0x00000002 >
SQL_DV_CASCADE <C: #define SQL_DV_CASCADE 0x00000004 >
SQL_DV_DROP_VIEW <C: #define SQL_DV_DROP_VIEW 0x00000001 >
SQL_DV_RESTRICT <C: #define SQL_DV_RESTRICT 0x00000002 >
SQL_DYNAMIC_CURSOR_ATTRIBUTES1 <C: #define SQL_DYNAMIC_CURSOR_ATTRIBUTES1 144 >
SQL_DYNAMIC_CURSOR_ATTRIBUTES2 <C: #define SQL_DYNAMIC_CURSOR_ATTRIBUTES2 145 >
SQL_EARLYCLOSE_DEFAULT <C: #define SQL_EARLYCLOSE_DEFAULT SQL_EARLYCLOSE_ON >
SQL_EARLYCLOSE_OFF <C: #define SQL_EARLYCLOSE_OFF 0 >
SQL_EARLYCLOSE_ON <C: #define SQL_EARLYCLOSE_ON 1 >
SQL_ENSURE <C: #define SQL_ENSURE 1 >
SQL_ENTIRE_ROWSET <C: #define SQL_ENTIRE_ROWSET 0 >
SQL_ERROR <C: #define SQL_ERROR -1 >
SQL_EXPRESSIONS_IN_ORDERBY <C: #define SQL_EXPRESSIONS_IN_ORDERBY 27 >
SQL_EXT_API_LAST <C: #define SQL_EXT_API_LAST 72 >
SQL_FALSE <C: #define SQL_FALSE 0 >
SQL_FD_FETCH_ABSOLUTE <C: #define SQL_FD_FETCH_ABSOLUTE 0x00000010 >
SQL_FD_FETCH_BOOKMARK <C: #define SQL_FD_FETCH_BOOKMARK 0x00000080 >
SQL_FD_FETCH_FIRST <C: #define SQL_FD_FETCH_FIRST 0x00000002 >
SQL_FD_FETCH_LAST <C: #define SQL_FD_FETCH_LAST 0x00000004 >
SQL_FD_FETCH_NEXT <C: #define SQL_FD_FETCH_NEXT 0x00000001 >
SQL_FD_FETCH_PREV <C: #define SQL_FD_FETCH_PREV SQL_FD_FETCH_PRIOR >
SQL_FD_FETCH_PRIOR <C: #define SQL_FD_FETCH_PRIOR 0x00000008 >
SQL_FD_FETCH_RELATIVE <C: #define SQL_FD_FETCH_RELATIVE 0x00000020 >
SQL_FD_FETCH_RESUME <C: #define SQL_FD_FETCH_RESUME 0x00000040 >
SQL_FETCH_ABSOLUTE <C: #define SQL_FETCH_ABSOLUTE 5 >
SQL_FETCH_BOOKMARK <C: #define SQL_FETCH_BOOKMARK 8 >
SQL_FETCH_BY_BOOKMARK <C: #define SQL_FETCH_BY_BOOKMARK 7 >
SQL_FETCH_DIRECTION <C: #define SQL_FETCH_DIRECTION 8 >
SQL_FETCH_FIRST <C: #define SQL_FETCH_FIRST 2 >
SQL_FETCH_FIRST_SYSTEM <C: #define SQL_FETCH_FIRST_SYSTEM 32 >
SQL_FETCH_FIRST_USER <C: #define SQL_FETCH_FIRST_USER 31 >
SQL_FETCH_LAST <C: #define SQL_FETCH_LAST 3 >
SQL_FETCH_NEXT <C: #define SQL_FETCH_NEXT 1 >
SQL_FETCH_PREV <C: #define SQL_FETCH_PREV SQL_FETCH_PRIOR >
SQL_FETCH_PRIOR <C: #define SQL_FETCH_PRIOR 4 >
SQL_FETCH_RELATIVE <C: #define SQL_FETCH_RELATIVE 6 >
SQL_FILE_APPEND <C: #define SQL_FILE_APPEND 32 >
SQL_FILE_CATALOG <C: #define SQL_FILE_CATALOG SQL_FILE_QUALIFIER >
SQL_FILE_CREATE <C: #define SQL_FILE_CREATE 8 >
SQL_FILE_NOT_SUPPORTED <C: #define SQL_FILE_NOT_SUPPORTED 0x0000 >
SQL_FILE_OVERWRITE <C: #define SQL_FILE_OVERWRITE 16 >
SQL_FILE_QUALIFIER <C: #define SQL_FILE_QUALIFIER 0x0002 >
SQL_FILE_READ <C: #define SQL_FILE_READ 2 >
SQL_FILE_TABLE <C: #define SQL_FILE_TABLE 0x0001 >
SQL_FILE_USAGE <C: #define SQL_FILE_USAGE 84 >
SQL_FLOAT <C: #define SQL_FLOAT 6 >
SQL_FN_CVT_CAST <C: #define SQL_FN_CVT_CAST 0x00000002 >
SQL_FN_CVT_CONVERT <C: #define SQL_FN_CVT_CONVERT 0x00000001 >
SQL_FN_NUM_ABS <C: #define SQL_FN_NUM_ABS 0x00000001 >
SQL_FN_NUM_ACOS <C: #define SQL_FN_NUM_ACOS 0x00000002 >
SQL_FN_NUM_ASIN <C: #define SQL_FN_NUM_ASIN 0x00000004 >
SQL_FN_NUM_ATAN <C: #define SQL_FN_NUM_ATAN 0x00000008 >
SQL_FN_NUM_ATAN2 <C: #define SQL_FN_NUM_ATAN2 0x00000010 >
SQL_FN_NUM_CEILING <C: #define SQL_FN_NUM_CEILING 0x00000020 >
SQL_FN_NUM_COS <C: #define SQL_FN_NUM_COS 0x00000040 >
SQL_FN_NUM_COT <C: #define SQL_FN_NUM_COT 0x00000080 >
SQL_FN_NUM_DEGREES <C: #define SQL_FN_NUM_DEGREES 0x00040000 >
SQL_FN_NUM_EXP <C: #define SQL_FN_NUM_EXP 0x00000100 >
SQL_FN_NUM_FLOOR <C: #define SQL_FN_NUM_FLOOR 0x00000200 >
SQL_FN_NUM_LOG <C: #define SQL_FN_NUM_LOG 0x00000400 >
SQL_FN_NUM_LOG10 <C: #define SQL_FN_NUM_LOG10 0x00080000 >
SQL_FN_NUM_MOD <C: #define SQL_FN_NUM_MOD 0x00000800 >
SQL_FN_NUM_PI <C: #define SQL_FN_NUM_PI 0x00010000 >
SQL_FN_NUM_POWER <C: #define SQL_FN_NUM_POWER 0x00100000 >
SQL_FN_NUM_RADIANS <C: #define SQL_FN_NUM_RADIANS 0x00200000 >
SQL_FN_NUM_RAND <C: #define SQL_FN_NUM_RAND 0x00020000 >
SQL_FN_NUM_ROUND <C: #define SQL_FN_NUM_ROUND 0x00400000 >
SQL_FN_NUM_SIGN <C: #define SQL_FN_NUM_SIGN 0x00001000 >
SQL_FN_NUM_SIN <C: #define SQL_FN_NUM_SIN 0x00002000 >
SQL_FN_NUM_SQRT <C: #define SQL_FN_NUM_SQRT 0x00004000 >
SQL_FN_NUM_TAN <C: #define SQL_FN_NUM_TAN 0x00008000 >
SQL_FN_NUM_TRUNCATE <C: #define SQL_FN_NUM_TRUNCATE 0x00800000 >
SQL_FN_STR_ASCII <C: #define SQL_FN_STR_ASCII 0x00002000 >
SQL_FN_STR_BIT_LENGTH <C: #define SQL_FN_STR_BIT_LENGTH 0x00080000 >
SQL_FN_STR_CHAR <C: #define SQL_FN_STR_CHAR 0x00004000 >
SQL_FN_STR_CHARACTER_LENGTH <C: #define SQL_FN_STR_CHARACTER_LENGTH 0x00200000 >
SQL_FN_STR_CHAR_LENGTH <C: #define SQL_FN_STR_CHAR_LENGTH 0x00100000 >
SQL_FN_STR_CONCAT <C: #define SQL_FN_STR_CONCAT 0x00000001 >
SQL_FN_STR_DIFFERENCE <C: #define SQL_FN_STR_DIFFERENCE 0x00008000 >
SQL_FN_STR_INSERT <C: #define SQL_FN_STR_INSERT 0x00000002 >
SQL_FN_STR_LCASE <C: #define SQL_FN_STR_LCASE 0x00000040 >
SQL_FN_STR_LEFT <C: #define SQL_FN_STR_LEFT 0x00000004 >
SQL_FN_STR_LENGTH <C: #define SQL_FN_STR_LENGTH 0x00000010 >
SQL_FN_STR_LOCATE <C: #define SQL_FN_STR_LOCATE 0x00000020 >
SQL_FN_STR_LOCATE_2 <C: #define SQL_FN_STR_LOCATE_2 0x00010000 >
SQL_FN_STR_LTRIM <C: #define SQL_FN_STR_LTRIM 0x00000008 >
SQL_FN_STR_OCTET_LENGTH <C: #define SQL_FN_STR_OCTET_LENGTH 0x00400000 >
SQL_FN_STR_POSITION <C: #define SQL_FN_STR_POSITION 0x00800000 >
SQL_FN_STR_REPEAT <C: #define SQL_FN_STR_REPEAT 0x00000080 >
SQL_FN_STR_REPLACE <C: #define SQL_FN_STR_REPLACE 0x00000100 >
SQL_FN_STR_RIGHT <C: #define SQL_FN_STR_RIGHT 0x00000200 >
SQL_FN_STR_RTRIM <C: #define SQL_FN_STR_RTRIM 0x00000400 >
SQL_FN_STR_SOUNDEX <C: #define SQL_FN_STR_SOUNDEX 0x00020000 >
SQL_FN_STR_SPACE <C: #define SQL_FN_STR_SPACE 0x00040000 >
SQL_FN_STR_SUBSTRING <C: #define SQL_FN_STR_SUBSTRING 0x00000800 >
SQL_FN_STR_UCASE <C: #define SQL_FN_STR_UCASE 0x00001000 >
SQL_FN_SYS_DBNAME <C: #define SQL_FN_SYS_DBNAME 0x00000002 >
SQL_FN_SYS_IFNULL <C: #define SQL_FN_SYS_IFNULL 0x00000004 >
SQL_FN_SYS_USERNAME <C: #define SQL_FN_SYS_USERNAME 0x00000001 >
SQL_FN_TD_CURDATE <C: #define SQL_FN_TD_CURDATE 0x00000002 >
SQL_FN_TD_CURRENT_DATE <C: #define SQL_FN_TD_CURRENT_DATE 0x00020000 >
SQL_FN_TD_CURRENT_TIME <C: #define SQL_FN_TD_CURRENT_TIME 0x00040000 >
SQL_FN_TD_CURRENT_TIMESTAMP <C: #define SQL_FN_TD_CURRENT_TIMESTAMP 0x00080000 >
SQL_FN_TD_CURTIME <C: #define SQL_FN_TD_CURTIME 0x00000200 >
SQL_FN_TD_DAYNAME <C: #define SQL_FN_TD_DAYNAME 0x00008000 >
SQL_FN_TD_DAYOFMONTH <C: #define SQL_FN_TD_DAYOFMONTH 0x00000004 >
SQL_FN_TD_DAYOFWEEK <C: #define SQL_FN_TD_DAYOFWEEK 0x00000008 >
SQL_FN_TD_DAYOFYEAR <C: #define SQL_FN_TD_DAYOFYEAR 0x00000010 >
SQL_FN_TD_EXTRACT <C: #define SQL_FN_TD_EXTRACT 0x00100000 >
SQL_FN_TD_HOUR <C: #define SQL_FN_TD_HOUR 0x00000400 >
SQL_FN_TD_MINUTE <C: #define SQL_FN_TD_MINUTE 0x00000800 >
SQL_FN_TD_MONTH <C: #define SQL_FN_TD_MONTH 0x00000020 >
SQL_FN_TD_MONTHNAME <C: #define SQL_FN_TD_MONTHNAME 0x00010000 >
SQL_FN_TD_NOW <C: #define SQL_FN_TD_NOW 0x00000001 >
SQL_FN_TD_QUARTER <C: #define SQL_FN_TD_QUARTER 0x00000040 >
SQL_FN_TD_SECOND <C: #define SQL_FN_TD_SECOND 0x00001000 >
SQL_FN_TD_TIMESTAMPADD <C: #define SQL_FN_TD_TIMESTAMPADD 0x00002000 >
SQL_FN_TD_TIMESTAMPDIFF <C: #define SQL_FN_TD_TIMESTAMPDIFF 0x00004000 >
SQL_FN_TD_WEEK <C: #define SQL_FN_TD_WEEK 0x00000080 >
SQL_FN_TD_YEAR <C: #define SQL_FN_TD_YEAR 0x00000100 >
SQL_FN_TSI_DAY <C: #define SQL_FN_TSI_DAY 0x00000010 >
SQL_FN_TSI_FRAC_SECOND <C: #define SQL_FN_TSI_FRAC_SECOND 0x00000001 >
SQL_FN_TSI_HOUR <C: #define SQL_FN_TSI_HOUR 0x00000008 >
SQL_FN_TSI_MINUTE <C: #define SQL_FN_TSI_MINUTE 0x00000004 >
SQL_FN_TSI_MONTH <C: #define SQL_FN_TSI_MONTH 0x00000040 >
SQL_FN_TSI_QUARTER <C: #define SQL_FN_TSI_QUARTER 0x00000080 >
SQL_FN_TSI_SECOND <C: #define SQL_FN_TSI_SECOND 0x00000002 >
SQL_FN_TSI_WEEK <C: #define SQL_FN_TSI_WEEK 0x00000020 >
SQL_FN_TSI_YEAR <C: #define SQL_FN_TSI_YEAR 0x00000100 >
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 <C: #define SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 146 >
SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2 <C: #define SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2 147 >
SQL_FROM_LITERAL <C: #define SQL_FROM_LITERAL 3 >
SQL_FROM_LOCATOR <C: #define SQL_FROM_LOCATOR 2 >
SQL_GB_COLLATE <C: #define SQL_GB_COLLATE 0x0004 >
SQL_GB_GROUP_BY_CONTAINS_SELECT <C: #define SQL_GB_GROUP_BY_CONTAINS_SELECT 0x0002 >
SQL_GB_GROUP_BY_EQUALS_SELECT <C: #define SQL_GB_GROUP_BY_EQUALS_SELECT 0x0001 >
SQL_GB_NOT_SUPPORTED <C: #define SQL_GB_NOT_SUPPORTED 0x0000 >
SQL_GB_NO_RELATION <C: #define SQL_GB_NO_RELATION 0x0003 >
SQL_GD_ANY_COLUMN <C: #define SQL_GD_ANY_COLUMN 0x00000001 >
SQL_GD_ANY_ORDER <C: #define SQL_GD_ANY_ORDER 0x00000002 >
SQL_GD_BLOCK <C: #define SQL_GD_BLOCK 0x00000004 >
SQL_GD_BOUND <C: #define SQL_GD_BOUND 0x00000008 >
SQL_GETDATA_EXTENSIONS <C: #define SQL_GETDATA_EXTENSIONS 81 >
SQL_GET_BOOKMARK <C: #define SQL_GET_BOOKMARK 13 >
SQL_GRAPHIC <C: #define SQL_GRAPHIC -95 >
SQL_GROUP_BY <C: #define SQL_GROUP_BY 88 >
SQL_HANDLE_DBC <C: #define SQL_HANDLE_DBC 2 >
SQL_HANDLE_DESC <C: #define SQL_HANDLE_DESC 4 >
SQL_HANDLE_ENV <C: #define SQL_HANDLE_ENV 1 >
SQL_HANDLE_SENV <C: #define SQL_HANDLE_SENV 5 >
SQL_HANDLE_STMT <C: #define SQL_HANDLE_STMT 3 >
SQL_H_SQLCLI <C: #define SQL_H_SQLCLI >
SQL_H_SQLCLI1 <C: #define SQL_H_SQLCLI1 >
SQL_H_SQLSYSTM <C: #define SQL_H_SQLSYSTM >
SQL_IBM_ALTERTABLEVARCHAR <C: #define SQL_IBM_ALTERTABLEVARCHAR 1000 >
SQL_IC_LOWER <C: #define SQL_IC_LOWER 0x0002 >
SQL_IC_MIXED <C: #define SQL_IC_MIXED 0x0004 >
SQL_IC_SENSITIVE <C: #define SQL_IC_SENSITIVE 0x0003 >
SQL_IC_UPPER <C: #define SQL_IC_UPPER 0x0001 >
SQL_IDENTIFIER_CASE <C: #define SQL_IDENTIFIER_CASE 28 >
SQL_IDENTIFIER_QUOTE_CHAR <C: #define SQL_IDENTIFIER_QUOTE_CHAR 29 >
SQL_IGNORE <C: #define SQL_IGNORE (-6) >
SQL_IK_ALL <C: #define SQL_IK_ALL (SQL_IK_ASC | SQL_IK_DESC) >
SQL_IK_ASC <C: #define SQL_IK_ASC 0x00000001 >
SQL_IK_DESC <C: #define SQL_IK_DESC 0x00000002 >
SQL_IK_NONE <C: #define SQL_IK_NONE 0x00000000 >
SQL_INDEX_ALL <C: #define SQL_INDEX_ALL 1 >
SQL_INDEX_CLUSTERED <C: #define SQL_INDEX_CLUSTERED 1 >
SQL_INDEX_HASHED <C: #define SQL_INDEX_HASHED 2 >
SQL_INDEX_KEYWORDS <C: #define SQL_INDEX_KEYWORDS 148 >
SQL_INDEX_OTHER <C: #define SQL_INDEX_OTHER 3 >
SQL_INDEX_UNIQUE <C: #define SQL_INDEX_UNIQUE 0 >
SQL_INFO_DRIVER_START <C: #define SQL_INFO_DRIVER_START 1000 >
SQL_INFO_FIRST <C: #define SQL_INFO_FIRST 0 >
SQL_INFO_LAST <C: #define SQL_INFO_LAST 114 >
SQL_INFO_SCHEMA_VIEWS <C: #define SQL_INFO_SCHEMA_VIEWS 149 >
SQL_INITIALLY_DEFERRED <C: #define SQL_INITIALLY_DEFERRED 5 >
SQL_INITIALLY_IMMEDIATE <C: #define SQL_INITIALLY_IMMEDIATE 6 >
SQL_INSENSITIVE <C: #define SQL_INSENSITIVE 1 >
SQL_INSERT_STATEMENT <C: #define SQL_INSERT_STATEMENT 172 >
SQL_INTEGER <C: #define SQL_INTEGER 4 >
SQL_INTEGRITY <C: #define SQL_INTEGRITY 73 >
SQL_INTERVAL <C: #define SQL_INTERVAL 10 >
SQL_INTERVAL_DAY <C: #define SQL_INTERVAL_DAY (100+SQL_CODE_DAY) >
SQL_INTERVAL_DAY_TO_HOUR <C: #define SQL_INTERVAL_DAY_TO_HOUR (100+SQL_CODE_DAY_TO_HOUR) >
SQL_INTERVAL_DAY_TO_MINUTE <C: #define SQL_INTERVAL_DAY_TO_MINUTE (100+SQL_CODE_DAY_TO_MINUTE) >
SQL_INTERVAL_DAY_TO_SECOND <C: #define SQL_INTERVAL_DAY_TO_SECOND (100+SQL_CODE_DAY_TO_SECOND) >
SQL_INTERVAL_HOUR <C: #define SQL_INTERVAL_HOUR (100+SQL_CODE_HOUR) >
SQL_INTERVAL_HOUR_TO_MINUTE <C: #define SQL_INTERVAL_HOUR_TO_MINUTE (100+SQL_CODE_HOUR_TO_MINUTE) >
SQL_INTERVAL_HOUR_TO_SECOND <C: #define SQL_INTERVAL_HOUR_TO_SECOND (100+SQL_CODE_HOUR_TO_SECOND) >
SQL_INTERVAL_MINUTE <C: #define SQL_INTERVAL_MINUTE (100+SQL_CODE_MINUTE) >
SQL_INTERVAL_MINUTE_TO_SECOND <C: #define SQL_INTERVAL_MINUTE_TO_SECOND (100+SQL_CODE_MINUTE_TO_SECOND) >
SQL_INTERVAL_MONTH <C: #define SQL_INTERVAL_MONTH (100+SQL_CODE_MONTH) >
SQL_INTERVAL_SECOND <C: #define SQL_INTERVAL_SECOND (100+SQL_CODE_SECOND) >
SQL_INTERVAL_YEAR <C: #define SQL_INTERVAL_YEAR (100+SQL_CODE_YEAR) >
SQL_INTERVAL_YEAR_TO_MONTH <C: #define SQL_INTERVAL_YEAR_TO_MONTH (100+SQL_CODE_YEAR_TO_MONTH) >
SQL_INVALID_HANDLE <C: #define SQL_INVALID_HANDLE -2 >
SQL_ISV_ASSERTIONS <C: #define SQL_ISV_ASSERTIONS 0x00000001 >
SQL_ISV_CHARACTER_SETS <C: #define SQL_ISV_CHARACTER_SETS 0x00000002 >
SQL_ISV_CHECK_CONSTRAINTS <C: #define SQL_ISV_CHECK_CONSTRAINTS 0x00000004 >
SQL_ISV_COLLATIONS <C: #define SQL_ISV_COLLATIONS 0x00000008 >
SQL_ISV_COLUMNS <C: #define SQL_ISV_COLUMNS 0x00000040 >
SQL_ISV_COLUMN_DOMAIN_USAGE <C: #define SQL_ISV_COLUMN_DOMAIN_USAGE 0x00000010 >
SQL_ISV_COLUMN_PRIVILEGES <C: #define SQL_ISV_COLUMN_PRIVILEGES 0x00000020 >
SQL_ISV_CONSTRAINT_COLUMN_USAGE <C: #define SQL_ISV_CONSTRAINT_COLUMN_USAGE 0x00000080 >
SQL_ISV_CONSTRAINT_TABLE_USAGE <C: #define SQL_ISV_CONSTRAINT_TABLE_USAGE 0x00000100 >
SQL_ISV_DOMAINS <C: #define SQL_ISV_DOMAINS 0x00000400 >
SQL_ISV_DOMAIN_CONSTRAINTS <C: #define SQL_ISV_DOMAIN_CONSTRAINTS 0x00000200 >
SQL_ISV_KEY_COLUMN_USAGE <C: #define SQL_ISV_KEY_COLUMN_USAGE 0x00000800 >
SQL_ISV_REFERENTIAL_CONSTRAINTS <C: #define SQL_ISV_REFERENTIAL_CONSTRAINTS 0x00001000 >
SQL_ISV_SCHEMATA <C: #define SQL_ISV_SCHEMATA 0x00002000 >
SQL_ISV_SQL_LANGUAGES <C: #define SQL_ISV_SQL_LANGUAGES 0x00004000 >
SQL_ISV_TABLES <C: #define SQL_ISV_TABLES 0x00020000 >
SQL_ISV_TABLE_CONSTRAINTS <C: #define SQL_ISV_TABLE_CONSTRAINTS 0x00008000 >
SQL_ISV_TABLE_PRIVILEGES <C: #define SQL_ISV_TABLE_PRIVILEGES 0x00010000 >
SQL_ISV_TRANSLATIONS <C: #define SQL_ISV_TRANSLATIONS 0x00040000 >
SQL_ISV_USAGE_PRIVILEGES <C: #define SQL_ISV_USAGE_PRIVILEGES 0x00080000 >
SQL_ISV_VIEWS <C: #define SQL_ISV_VIEWS 0x00400000 >
SQL_ISV_VIEW_COLUMN_USAGE <C: #define SQL_ISV_VIEW_COLUMN_USAGE 0x00100000 >
SQL_ISV_VIEW_TABLE_USAGE <C: #define SQL_ISV_VIEW_TABLE_USAGE 0x00200000 >
SQL_IS_INSERT_LITERALS <C: #define SQL_IS_INSERT_LITERALS 0x00000001 >
SQL_IS_INSERT_SEARCHED <C: #define SQL_IS_INSERT_SEARCHED 0x00000002 >
SQL_IS_INTEGER <C: #define SQL_IS_INTEGER (-6) >
SQL_IS_POINTER <C: #define SQL_IS_POINTER (-4) >
SQL_IS_SELECT_INTO <C: #define SQL_IS_SELECT_INTO 0x00000004 >
SQL_IS_SMALLINT <C: #define SQL_IS_SMALLINT (-8) >
SQL_IS_UINTEGER <C: #define SQL_IS_UINTEGER (-5) >
SQL_IS_USMALLINT <C: #define SQL_IS_USMALLINT (-7) >
SQL_KEYSET_CURSOR_ATTRIBUTES1 <C: #define SQL_KEYSET_CURSOR_ATTRIBUTES1 150 >
SQL_KEYSET_CURSOR_ATTRIBUTES2 <C: #define SQL_KEYSET_CURSOR_ATTRIBUTES2 151 >
SQL_KEYSET_SIZE <C: #define SQL_KEYSET_SIZE 8 >
SQL_KEYSET_SIZE_DEFAULT <C: #define SQL_KEYSET_SIZE_DEFAULT 0 >
SQL_KEYWORDS <C: #define SQL_KEYWORDS 89 >
SQL_LCK_EXCLUSIVE <C: #define SQL_LCK_EXCLUSIVE 0x00000002 >
SQL_LCK_NO_CHANGE <C: #define SQL_LCK_NO_CHANGE 0x00000001 >
SQL_LCK_UNLOCK <C: #define SQL_LCK_UNLOCK 0x00000004 >
SQL_LD_COMPAT_DEFAULT <C: #define SQL_LD_COMPAT_DEFAULT SQL_LD_COMPAT_NO >
SQL_LD_COMPAT_NO <C: #define SQL_LD_COMPAT_NO 0 >
SQL_LD_COMPAT_YES <C: #define SQL_LD_COMPAT_YES 1 >
SQL_LEN_BINARY_ATTR_OFFSET <C: #define SQL_LEN_BINARY_ATTR_OFFSET (-100) >
SQL_LEN_DATA_AT_EXEC_OFFSET <C: #define SQL_LEN_DATA_AT_EXEC_OFFSET (-100) >
SQL_LIKE_ESCAPE_CLAUSE <C: #define SQL_LIKE_ESCAPE_CLAUSE 113 >
SQL_LIKE_ONLY <C: #define SQL_LIKE_ONLY 1 >
SQL_LOCK_EXCLUSIVE <C: #define SQL_LOCK_EXCLUSIVE 1 >
SQL_LOCK_NO_CHANGE <C: #define SQL_LOCK_NO_CHANGE 0 >
SQL_LOCK_TYPES <C: #define SQL_LOCK_TYPES 78 >
SQL_LOCK_UNLOCK <C: #define SQL_LOCK_UNLOCK 2 >
SQL_LOGIN_TIMEOUT <C: #define SQL_LOGIN_TIMEOUT 103 >
SQL_LOGIN_TIMEOUT_DEFAULT <C: #define SQL_LOGIN_TIMEOUT_DEFAULT 15 >
SQL_LONGDATA_COMPAT <C: #define SQL_LONGDATA_COMPAT 1253 >
SQL_LONGVARBINARY <C: #define SQL_LONGVARBINARY (-4) >
SQL_LONGVARCHAR <C: #define SQL_LONGVARCHAR (-1) >
SQL_LONGVARGRAPHIC <C: #define SQL_LONGVARGRAPHIC -97 >
SQL_MAXCONN <C: #define SQL_MAXCONN 1262 >
SQL_MAXIMUM_CATALOG_NAME_LENGTH <C: #define SQL_MAXIMUM_CATALOG_NAME_LENGTH SQL_MAX_CATALOG_NAME_LEN >
SQL_MAXIMUM_COLUMNS_IN_GROUP_BY <C: #define SQL_MAXIMUM_COLUMNS_IN_GROUP_BY SQL_MAX_COLUMNS_IN_GROUP_BY >
SQL_MAXIMUM_COLUMNS_IN_INDEX <C: #define SQL_MAXIMUM_COLUMNS_IN_INDEX SQL_MAX_COLUMNS_IN_INDEX >
SQL_MAXIMUM_COLUMNS_IN_ORDER_BY <C: #define SQL_MAXIMUM_COLUMNS_IN_ORDER_BY SQL_MAX_COLUMNS_IN_ORDER_BY >
SQL_MAXIMUM_COLUMNS_IN_SELECT <C: #define SQL_MAXIMUM_COLUMNS_IN_SELECT SQL_MAX_COLUMNS_IN_SELECT >
SQL_MAXIMUM_COLUMN_NAME_LENGTH <C: #define SQL_MAXIMUM_COLUMN_NAME_LENGTH SQL_MAX_COLUMN_NAME_LEN >
SQL_MAXIMUM_CONCURRENT_ACTIVITIES <C: #define SQL_MAXIMUM_CONCURRENT_ACTIVITIES SQL_MAX_CONCURRENT_ACTIVITIES >
SQL_MAXIMUM_CURSOR_NAME_LENGTH <C: #define SQL_MAXIMUM_CURSOR_NAME_LENGTH SQL_MAX_CURSOR_NAME_LEN >
SQL_MAXIMUM_DRIVER_CONNECTIONS <C: #define SQL_MAXIMUM_DRIVER_CONNECTIONS SQL_MAX_DRIVER_CONNECTIONS >
SQL_MAXIMUM_IDENTIFIER_LENGTH <C: #define SQL_MAXIMUM_IDENTIFIER_LENGTH SQL_MAX_IDENTIFIER_LEN >
SQL_MAXIMUM_INDEX_SIZE <C: #define SQL_MAXIMUM_INDEX_SIZE SQL_MAX_INDEX_SIZE >
SQL_MAXIMUM_ROW_SIZE <C: #define SQL_MAXIMUM_ROW_SIZE SQL_MAX_ROW_SIZE >
SQL_MAXIMUM_SCHEMA_NAME_LENGTH <C: #define SQL_MAXIMUM_SCHEMA_NAME_LENGTH SQL_MAX_SCHEMA_NAME_LEN >
SQL_MAXIMUM_STATEMENT_LENGTH <C: #define SQL_MAXIMUM_STATEMENT_LENGTH SQL_MAX_STATEMENT_LEN >
SQL_MAXIMUM_TABLES_IN_SELECT <C: #define SQL_MAXIMUM_TABLES_IN_SELECT SQL_MAX_TABLES_IN_SELECT >
SQL_MAXIMUM_USER_NAME_LENGTH <C: #define SQL_MAXIMUM_USER_NAME_LENGTH SQL_MAX_USER_NAME_LEN >
SQL_MAX_ASYNC_CONCURRENT_STATEMENTS <C: #define SQL_MAX_ASYNC_CONCURRENT_STATEMENTS 10022 >
SQL_MAX_BINARY_LITERAL_LEN <C: #define SQL_MAX_BINARY_LITERAL_LEN 112 >
SQL_MAX_CATALOG_NAME_LEN <C: #define SQL_MAX_CATALOG_NAME_LEN SQL_MAX_QUALIFIER_NAME_LEN >
SQL_MAX_CHAR_LITERAL_LEN <C: #define SQL_MAX_CHAR_LITERAL_LEN 108 >
SQL_MAX_COLUMNS_IN_GROUP_BY <C: #define SQL_MAX_COLUMNS_IN_GROUP_BY 97 >
SQL_MAX_COLUMNS_IN_INDEX <C: #define SQL_MAX_COLUMNS_IN_INDEX 98 >
SQL_MAX_COLUMNS_IN_ORDER_BY <C: #define SQL_MAX_COLUMNS_IN_ORDER_BY 99 >
SQL_MAX_COLUMNS_IN_SELECT <C: #define SQL_MAX_COLUMNS_IN_SELECT 100 >
SQL_MAX_COLUMNS_IN_TABLE <C: #define SQL_MAX_COLUMNS_IN_TABLE 101 >
SQL_MAX_COLUMN_NAME_LEN <C: #define SQL_MAX_COLUMN_NAME_LEN 30 >
SQL_MAX_CONCURRENT_ACTIVITIES <C: #define SQL_MAX_CONCURRENT_ACTIVITIES 1 >
SQL_MAX_CURSOR_NAME_LEN <C: #define SQL_MAX_CURSOR_NAME_LEN 31 >
SQL_MAX_C_NUMERIC_PRECISION <C: #define SQL_MAX_C_NUMERIC_PRECISION 38 >
SQL_MAX_DRIVER_CONNECTIONS <C: #define SQL_MAX_DRIVER_CONNECTIONS 0 >
SQL_MAX_DSN_LENGTH <C: #define SQL_MAX_DSN_LENGTH 32 >
SQL_MAX_IDENTIFIER_LEN <C: #define SQL_MAX_IDENTIFIER_LEN 10005 >
SQL_MAX_ID_LENGTH <C: #define SQL_MAX_ID_LENGTH 128 >
SQL_MAX_INDEX_SIZE <C: #define SQL_MAX_INDEX_SIZE 102 >
SQL_MAX_LENGTH <C: #define SQL_MAX_LENGTH 3 >
SQL_MAX_LENGTH_DEFAULT <C: #define SQL_MAX_LENGTH_DEFAULT 0 >
SQL_MAX_MESSAGE_LENGTH <C: #define SQL_MAX_MESSAGE_LENGTH 1024 >
SQL_MAX_NUMERIC_LEN <C: #define SQL_MAX_NUMERIC_LEN 16 >
SQL_MAX_OPTION_STRING_LENGTH <C: #define SQL_MAX_OPTION_STRING_LENGTH 256 >
SQL_MAX_OWNER_NAME_LEN <C: #define SQL_MAX_OWNER_NAME_LEN 32 >
SQL_MAX_PROCEDURE_NAME_LEN <C: #define SQL_MAX_PROCEDURE_NAME_LEN 33 >
SQL_MAX_QUALIFIER_NAME_LEN <C: #define SQL_MAX_QUALIFIER_NAME_LEN 34 >
SQL_MAX_ROWS <C: #define SQL_MAX_ROWS 1 >
SQL_MAX_ROWS_DEFAULT <C: #define SQL_MAX_ROWS_DEFAULT 0 >
SQL_MAX_ROW_SIZE <C: #define SQL_MAX_ROW_SIZE 104 >
SQL_MAX_ROW_SIZE_INCLUDES_LONG <C: #define SQL_MAX_ROW_SIZE_INCLUDES_LONG 103 >
SQL_MAX_SCHEMA_NAME_LEN <C: #define SQL_MAX_SCHEMA_NAME_LEN SQL_MAX_OWNER_NAME_LEN >
SQL_MAX_STATEMENT_LEN <C: #define SQL_MAX_STATEMENT_LEN 105 >
SQL_MAX_TABLES_IN_SELECT <C: #define SQL_MAX_TABLES_IN_SELECT 106 >
SQL_MAX_TABLE_NAME_LEN <C: #define SQL_MAX_TABLE_NAME_LEN 35 >
SQL_MAX_USER_NAME_LEN <C: #define SQL_MAX_USER_NAME_LEN 107 >
SQL_MINMEMORY_USAGE <C: #define SQL_MINMEMORY_USAGE 1263 >
SQL_MODE_DEFAULT <C: #define SQL_MODE_DEFAULT SQL_MODE_READ_WRITE >
SQL_MODE_READ_ONLY <C: #define SQL_MODE_READ_ONLY 1 >
SQL_MODE_READ_WRITE <C: #define SQL_MODE_READ_WRITE 0 >
SQL_MULTIPLE_ACTIVE_TXN <C: #define SQL_MULTIPLE_ACTIVE_TXN 37 >
SQL_MULT_RESULT_SETS <C: #define SQL_MULT_RESULT_SETS 36 >
SQL_NAMED <C: #define SQL_NAMED 0 >
SQL_NC_END <C: #define SQL_NC_END 0x0004 >
SQL_NC_HIGH <C: #define SQL_NC_HIGH 0 >
SQL_NC_LOW <C: #define SQL_NC_LOW 1 >
SQL_NC_START <C: #define SQL_NC_START 0x0002 >
SQL_NEED_DATA <C: #define SQL_NEED_DATA 99 >
SQL_NEED_LONG_DATA_LEN <C: #define SQL_NEED_LONG_DATA_LEN 111 >
SQL_NNC_NON_NULL <C: #define SQL_NNC_NON_NULL 0x0001 >
SQL_NNC_NULL <C: #define SQL_NNC_NULL 0x0000 >
SQL_NODESCRIBE <C: #define SQL_NODESCRIBE SQL_NODESCRIBE_OUTPUT >
SQL_NODESCRIBE_DEFAULT <C: #define SQL_NODESCRIBE_DEFAULT SQL_NODESCRIBE_OFF >
SQL_NODESCRIBE_INPUT <C: #define SQL_NODESCRIBE_INPUT 1264 >
SQL_NODESCRIBE_OFF <C: #define SQL_NODESCRIBE_OFF 0 >
SQL_NODESCRIBE_ON <C: #define SQL_NODESCRIBE_ON 1 >
SQL_NODESCRIBE_OUTPUT <C: #define SQL_NODESCRIBE_OUTPUT 1251 >
SQL_NONSCROLLABLE <C: #define SQL_NONSCROLLABLE 0 >
SQL_NON_NULLABLE_COLUMNS <C: #define SQL_NON_NULLABLE_COLUMNS 75 >
SQL_NOSCAN <C: #define SQL_NOSCAN 2 >
SQL_NOSCAN_DEFAULT <C: #define SQL_NOSCAN_DEFAULT SQL_NOSCAN_OFF >
SQL_NOSCAN_OFF <C: #define SQL_NOSCAN_OFF 0 >
SQL_NOSCAN_ON <C: #define SQL_NOSCAN_ON 1 >
SQL_NOT_DEFERRABLE <C: #define SQL_NOT_DEFERRABLE 7 >
SQL_NO_ACTION <C: #define SQL_NO_ACTION 3 >
SQL_NO_COLUMN_NUMBER <C: #define SQL_NO_COLUMN_NUMBER (-1) >
SQL_NO_DATA <C: #define SQL_NO_DATA 100 >
SQL_NO_DATA_FOUND <C: #define SQL_NO_DATA_FOUND SQL_NO_DATA >
SQL_NO_NULLS <C: #define SQL_NO_NULLS 0 >
SQL_NO_ROW_NUMBER <C: #define SQL_NO_ROW_NUMBER (-1) >
SQL_NO_TOTAL <C: #define SQL_NO_TOTAL (-4) >
SQL_NTS <C: #define SQL_NTS -3 >
SQL_NTSL <C: #define SQL_NTSL -3 >
SQL_NULLABLE <C: #define SQL_NULLABLE 1 >
SQL_NULLABLE_UNKNOWN <C: #define SQL_NULLABLE_UNKNOWN 2 >
SQL_NULL_COLLATION <C: #define SQL_NULL_COLLATION 85 >
SQL_NULL_DATA <C: #define SQL_NULL_DATA -1 >
SQL_NULL_HANDLE <C: #define SQL_NULL_HANDLE 0 >
SQL_NULL_HDBC <C: #define SQL_NULL_HDBC 0 >
SQL_NULL_HDESC <C: #define SQL_NULL_HDESC 0 >
SQL_NULL_HENV <C: #define SQL_NULL_HENV 0 >
SQL_NULL_HSTMT <C: #define SQL_NULL_HSTMT 0 >
SQL_NUMERIC <C: #define SQL_NUMERIC 2 >
SQL_NUMERIC_FUNCTIONS <C: #define SQL_NUMERIC_FUNCTIONS 49 >
SQL_OAC_LEVEL1 <C: #define SQL_OAC_LEVEL1 0x0001 >
SQL_OAC_LEVEL2 <C: #define SQL_OAC_LEVEL2 0x0002 >
SQL_OAC_NONE <C: #define SQL_OAC_NONE 0x0000 >
SQL_ODBC_API_CONFORMANCE <C: #define SQL_ODBC_API_CONFORMANCE 9 >
SQL_ODBC_CURSORS <C: #define SQL_ODBC_CURSORS 110 >
SQL_ODBC_INTERFACE_CONFORMANCE <C: #define SQL_ODBC_INTERFACE_CONFORMANCE 152 >
SQL_ODBC_KEYWORDS <C: #define SQL_ODBC_KEYWORDS "ABSOLUTE,ACTION,ADA,ADD,ALL,ALLOCATE,ALTER,AND,ANY,ARE,AS,ASC,ASSERTION,AT,AUTHORIZATION,AVG,BEGIN,BETWEEN,BIT,BIT_LENGTH,BOTH,BY,CASCADE,CASCADED,CASE,CAST,CATALOG,CHAR,CHAR_LENGTH,CHARACTER,CHARACTER_LENGTH,CHECK,CLOSE,COALESCE,COLLATE,COLLATION,COLUMN,COMMIT,CONNECT,CONNECTION,CONSTRAINT,CONSTRAINTS,CONTINUE,CONVERT,CORRESPONDING,COUNT,CREATE,CROSS,CURRENT,CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP,CURRENT_USER,CURSOR,DATE,DAY,DEALLOCATE,DEC,DECIMAL,DECLARE,DEFAULT,DEFERRABLE,DEFERRED,DELETE,DESC,DESCRIBE,DESCRIPTOR,DIAGNOSTICS,DISCONNECT,DISTINCT,DOMAIN,DOUBLE,DROP,ELSE,END,END-EXEC,ESCAPE,EXCEPT,EXCEPTION,EXEC,EXECUTE,EXISTS,EXTERNAL,EXTRACT,FALSE,FETCH,FIRST,FLOAT,FOR,FOREIGN,FORTRAN,FOUND,FROM,FULL,GET,GLOBAL,GO,GOTO,GRANT,GROUP,HAVING,HOUR,IDENTITY,IMMEDIATE,IN,INCLUDE,INDEX,INDICATOR,INITIALLY,INNER,INPUT,INSENSITIVE,INSERT,INT,INTEGER,INTERSECT,INTERVAL,INTO,IS,ISOLATION,JOIN,KEY,LANGUAGE,LAST,LEADING,LEFT,LEVEL,LIKE,LOCAL,LOWER,MATCH,MAX,MIN,MINUTE,MODULE,MONTH,NAMES,NATIONAL,NATURAL,NCHAR,NEXT,NO,NONE,NOT,NULL,NULLIF,NUMERIC,OCTET_LENGTH,OF,ON,ONLY,OPEN,OPTION,OR,ORDER,OUTER,OUTPUT,OVERLAPS,PAD,PARTIAL,PASCAL,PLI,POSITION,PRECISION,PREPARE,PRESERVE,PRIMARY,PRIOR,PRIVILEGES,PROCEDURE,PUBLIC,READ,REAL,REFERENCES,RELATIVE,RESTRICT,REVOKE,RIGHT,ROLLBACK,ROWSSCHEMA,SCROLL,SECOND,SECTION,SELECT,SESSION,SESSION_USER,SET,SIZE,SMALLINT,SOME,SPACE,SQL,SQLCA,SQLCODE,SQLERROR,SQLSTATE,SQLWARNING,SUBSTRING,SUM,SYSTEM_USER,TABLE,TEMPORARY,THEN,TIME,TIMESTAMP,TIMEZONE_HOUR,TIMEZONE_MINUTE,TO,TRAILING,TRANSACTION,TRANSLATE,TRANSLATION,TRIM,TRUE,UNION,UNIQUE,UNKNOWN,UPDATE,UPPER,USAGE,USER,USING,VALUE,VALUES,VARCHAR,VARYING,VIEW,WHEN,WHENEVER,WHERE,WITH,WORK,WRITE,YEAR,ZONE" SQLRETURN SQL_API SQLBrowseC >
SQL_ODBC_SAG_CLI_CONFORMANCE <C: #define SQL_ODBC_SAG_CLI_CONFORMANCE 12 >
SQL_ODBC_SQL_CONFORMANCE <C: #define SQL_ODBC_SQL_CONFORMANCE 15 >
SQL_ODBC_SQL_OPT_IEF <C: #define SQL_ODBC_SQL_OPT_IEF 73 >
SQL_ODBC_VER <C: #define SQL_ODBC_VER 10 >
SQL_OIC_CORE <C: #define SQL_OIC_CORE 1 >
SQL_OIC_LEVEL1 <C: #define SQL_OIC_LEVEL1 2 >
SQL_OIC_LEVEL2 <C: #define SQL_OIC_LEVEL2 3 >
SQL_OJ_ALL_COMPARISON_OPS <C: #define SQL_OJ_ALL_COMPARISON_OPS 0x00000040 >
SQL_OJ_CAPABILITIES <C: #define SQL_OJ_CAPABILITIES 115 >
SQL_OJ_FULL <C: #define SQL_OJ_FULL 0x00000004 >
SQL_OJ_INNER <C: #define SQL_OJ_INNER 0x00000020 >
SQL_OJ_LEFT <C: #define SQL_OJ_LEFT 0x00000001 >
SQL_OJ_NESTED <C: #define SQL_OJ_NESTED 0x00000008 >
SQL_OJ_NOT_ORDERED <C: #define SQL_OJ_NOT_ORDERED 0x00000010 >
SQL_OJ_RIGHT <C: #define SQL_OJ_RIGHT 0x00000002 >
SQL_ONEPHASE <C: #define SQL_ONEPHASE 1 >
SQL_OPTIMIZE_SQLCOLUMNS_DEFAULT <C: #define SQL_OPTIMIZE_SQLCOLUMNS_DEFAULT SQL_OPTIMIZE_SQLCOLUMNS_OFF >
SQL_OPTIMIZE_SQLCOLUMNS_OFF <C: #define SQL_OPTIMIZE_SQLCOLUMNS_OFF 0 >
SQL_OPTIMIZE_SQLCOLUMNS_ON <C: #define SQL_OPTIMIZE_SQLCOLUMNS_ON 1 >
SQL_OPT_TRACE <C: #define SQL_OPT_TRACE 104 >
SQL_OPT_TRACEFILE <C: #define SQL_OPT_TRACEFILE 105 >
SQL_OPT_TRACE_DEFAULT <C: #define SQL_OPT_TRACE_DEFAULT SQL_OPT_TRACE_OFF >
SQL_OPT_TRACE_FILE_DEFAULT <C: #define SQL_OPT_TRACE_FILE_DEFAULT "\\SQL.LOG" >
SQL_OPT_TRACE_OFF <C: #define SQL_OPT_TRACE_OFF 0 >
SQL_OPT_TRACE_ON <C: #define SQL_OPT_TRACE_ON 1 >
SQL_ORDER_BY_COLUMNS_IN_SELECT <C: #define SQL_ORDER_BY_COLUMNS_IN_SELECT 90 >
SQL_OSCC_COMPLIANT <C: #define SQL_OSCC_COMPLIANT 0x0001 >
SQL_OSCC_NOT_COMPLIANT <C: #define SQL_OSCC_NOT_COMPLIANT 0x0000 >
SQL_OSC_CORE <C: #define SQL_OSC_CORE 0x0001 >
SQL_OSC_EXTENDED <C: #define SQL_OSC_EXTENDED 0x0002 >
SQL_OSC_MINIMUM <C: #define SQL_OSC_MINIMUM 0x0000 >
SQL_OUTER_JOINS <C: #define SQL_OUTER_JOINS 38 >
SQL_OUTER_JOIN_CAPABILITIES <C: #define SQL_OUTER_JOIN_CAPABILITIES SQL_OJ_CAPABILITIES >
SQL_OU_DML_STATEMENTS <C: #define SQL_OU_DML_STATEMENTS 0x00000001 >
SQL_OU_INDEX_DEFINITION <C: #define SQL_OU_INDEX_DEFINITION 0x00000008 >
SQL_OU_PRIVILEGE_DEFINITION <C: #define SQL_OU_PRIVILEGE_DEFINITION 0x00000010 >
SQL_OU_PROCEDURE_INVOCATION <C: #define SQL_OU_PROCEDURE_INVOCATION 0x00000002 >
SQL_OU_TABLE_DEFINITION <C: #define SQL_OU_TABLE_DEFINITION 0x00000004 >
SQL_OV_ODBC2 <C: #define SQL_OV_ODBC2 2 >
SQL_OV_ODBC3 <C: #define SQL_OV_ODBC3 3 >
SQL_OWNER_TERM <C: #define SQL_OWNER_TERM 39 >
SQL_OWNER_USAGE <C: #define SQL_OWNER_USAGE 91 >
SQL_PACKET_SIZE <C: #define SQL_PACKET_SIZE 112 >
SQL_PARAMOPT_ATOMIC <C: #define SQL_PARAMOPT_ATOMIC 1260 >
SQL_PARAM_ARRAY_ROW_COUNTS <C: #define SQL_PARAM_ARRAY_ROW_COUNTS 153 >
SQL_PARAM_ARRAY_SELECTS <C: #define SQL_PARAM_ARRAY_SELECTS 154 >
SQL_PARAM_BIND_BY_COLUMN <C: #define SQL_PARAM_BIND_BY_COLUMN 0 >
SQL_PARAM_BIND_TYPE_DEFAULT <C: #define SQL_PARAM_BIND_TYPE_DEFAULT SQL_PARAM_BIND_BY_COLUMN >
SQL_PARAM_DIAG_UNAVAILABLE <C: #define SQL_PARAM_DIAG_UNAVAILABLE 1 >
SQL_PARAM_ERROR <C: #define SQL_PARAM_ERROR 5 >
SQL_PARAM_IGNORE <C: #define SQL_PARAM_IGNORE 1 >
SQL_PARAM_INPUT <C: #define SQL_PARAM_INPUT 1 >
SQL_PARAM_INPUT_OUTPUT <C: #define SQL_PARAM_INPUT_OUTPUT 2 >
SQL_PARAM_OUTPUT <C: #define SQL_PARAM_OUTPUT 4 >
SQL_PARAM_PROCEED <C: #define SQL_PARAM_PROCEED 0 >
SQL_PARAM_SUCCESS <C: #define SQL_PARAM_SUCCESS 0 >
SQL_PARAM_SUCCESS_WITH_INFO <C: #define SQL_PARAM_SUCCESS_WITH_INFO 6 >
SQL_PARAM_TYPE_DEFAULT <C: #define SQL_PARAM_TYPE_DEFAULT SQL_PARAM_INPUT_OUTPUT >
SQL_PARAM_TYPE_UNKNOWN <C: #define SQL_PARAM_TYPE_UNKNOWN 0 >
SQL_PARAM_UNUSED <C: #define SQL_PARAM_UNUSED 7 >
SQL_PARC_BATCH <C: #define SQL_PARC_BATCH 1 >
SQL_PARC_NO_BATCH <C: #define SQL_PARC_NO_BATCH 2 >
SQL_PAS_BATCH <C: #define SQL_PAS_BATCH 1 >
SQL_PAS_NO_BATCH <C: #define SQL_PAS_NO_BATCH 2 >
SQL_PAS_NO_SELECT <C: #define SQL_PAS_NO_SELECT 3 >
SQL_PC_NON_PSEUDO <C: #define SQL_PC_NON_PSEUDO 1 >
SQL_PC_NOT_PSEUDO <C: #define SQL_PC_NOT_PSEUDO 1 >
SQL_PC_PSEUDO <C: #define SQL_PC_PSEUDO 2 >
SQL_PC_UNKNOWN <C: #define SQL_PC_UNKNOWN 0 >
SQL_POINTER <C: #define SQL_POINTER >
SQL_POSITION <C: #define SQL_POSITION 0 >
SQL_POSITIONED_STATEMENTS <C: #define SQL_POSITIONED_STATEMENTS 80 >
SQL_POS_ADD <C: #define SQL_POS_ADD 0x00000010 >
SQL_POS_DELETE <C: #define SQL_POS_DELETE 0x00000008 >
SQL_POS_OPERATIONS <C: #define SQL_POS_OPERATIONS 79 >
SQL_POS_POSITION <C: #define SQL_POS_POSITION 0x00000001 >
SQL_POS_REFRESH <C: #define SQL_POS_REFRESH 0x00000002 >
SQL_POS_UPDATE <C: #define SQL_POS_UPDATE 0x00000004 >
SQL_PRED_BASIC <C: #define SQL_PRED_BASIC 2 >
SQL_PRED_CHAR <C: #define SQL_PRED_CHAR 1 >
SQL_PRED_NONE <C: #define SQL_PRED_NONE 0 >
SQL_PRED_SEARCHABLE <C: #define SQL_PRED_SEARCHABLE SQL_SEARCHABLE >
SQL_PREFETCH_DEFAULT <C: #define SQL_PREFETCH_DEFAULT SQL_PREFETCH_OFF >
SQL_PREFETCH_OFF <C: #define SQL_PREFETCH_OFF 0 >
SQL_PREFETCH_ON <C: #define SQL_PREFETCH_ON 1 >
SQL_PROCEDURES <C: #define SQL_PROCEDURES 21 >
SQL_PROCEDURE_TERM <C: #define SQL_PROCEDURE_TERM 40 >
SQL_PROCESSCTL_NOFORK <C: #define SQL_PROCESSCTL_NOFORK 0x00000002 >
SQL_PROCESSCTL_NOTHREAD <C: #define SQL_PROCESSCTL_NOTHREAD 0x00000001 >
SQL_PROCESSCTL_SHARESTMTDESC <C: #define SQL_PROCESSCTL_SHARESTMTDESC 0x00000004 >
SQL_PS_POSITIONED_DELETE <C: #define SQL_PS_POSITIONED_DELETE 0x00000001 >
SQL_PS_POSITIONED_UPDATE <C: #define SQL_PS_POSITIONED_UPDATE 0x00000002 >
SQL_PS_SELECT_FOR_UPDATE <C: #define SQL_PS_SELECT_FOR_UPDATE 0x00000004 >
SQL_PT_FUNCTION <C: #define SQL_PT_FUNCTION 2 >
SQL_PT_PROCEDURE <C: #define SQL_PT_PROCEDURE 1 >
SQL_PT_UNKNOWN <C: #define SQL_PT_UNKNOWN 0 >
SQL_QL_END <C: #define SQL_QL_END 0x0002 >
SQL_QL_START <C: #define SQL_QL_START 0x0001 >
SQL_QUALIFIER_LOCATION <C: #define SQL_QUALIFIER_LOCATION 114 >
SQL_QUALIFIER_NAME_SEPARATOR <C: #define SQL_QUALIFIER_NAME_SEPARATOR 41 >
SQL_QUALIFIER_TERM <C: #define SQL_QUALIFIER_TERM 42 >
SQL_QUALIFIER_USAGE <C: #define SQL_QUALIFIER_USAGE 92 >
SQL_QUERY_TIMEOUT <C: #define SQL_QUERY_TIMEOUT 0 >
SQL_QUERY_TIMEOUT_DEFAULT <C: #define SQL_QUERY_TIMEOUT_DEFAULT 0 >
SQL_QUICK <C: #define SQL_QUICK 0 >
SQL_QUIET_MODE <C: #define SQL_QUIET_MODE 111 >
SQL_QUOTED_IDENTIFIER_CASE <C: #define SQL_QUOTED_IDENTIFIER_CASE 93 >
SQL_QU_DML_STATEMENTS <C: #define SQL_QU_DML_STATEMENTS 0x00000001 >
SQL_QU_INDEX_DEFINITION <C: #define SQL_QU_INDEX_DEFINITION 0x00000008 >
SQL_QU_PRIVILEGE_DEFINITION <C: #define SQL_QU_PRIVILEGE_DEFINITION 0x00000010 >
SQL_QU_PROCEDURE_INVOCATION <C: #define SQL_QU_PROCEDURE_INVOCATION 0x00000002 >
SQL_QU_TABLE_DEFINITION <C: #define SQL_QU_TABLE_DEFINITION 0x00000004 >
SQL_RD_DEFAULT <C: #define SQL_RD_DEFAULT SQL_RD_ON >
SQL_RD_OFF <C: #define SQL_RD_OFF 0 >
SQL_RD_ON <C: #define SQL_RD_ON 1 >
SQL_REAL <C: #define SQL_REAL 7 >
SQL_REFRESH <C: #define SQL_REFRESH 1 >
SQL_RESET_PARAMS <C: #define SQL_RESET_PARAMS 3 >
SQL_RESTRICT <C: #define SQL_RESTRICT 1 >
SQL_RESULT_COL <C: #define SQL_RESULT_COL 3 >
SQL_RETRIEVE_DATA <C: #define SQL_RETRIEVE_DATA 11 >
SQL_RETURN_VALUE <C: #define SQL_RETURN_VALUE 5 >
SQL_ROLLBACK <C: #define SQL_ROLLBACK 1 >
SQL_ROWSET_SIZE <C: #define SQL_ROWSET_SIZE 9 >
SQL_ROWSET_SIZE_DEFAULT <C: #define SQL_ROWSET_SIZE_DEFAULT 1 >
SQL_ROWVER <C: #define SQL_ROWVER 2 >
SQL_ROW_ADDED <C: #define SQL_ROW_ADDED 4 >
SQL_ROW_DELETED <C: #define SQL_ROW_DELETED 1 >
SQL_ROW_ERROR <C: #define SQL_ROW_ERROR 5 >
SQL_ROW_IDENTIFIER <C: #define SQL_ROW_IDENTIFIER 1 >
SQL_ROW_IGNORE <C: #define SQL_ROW_IGNORE 1 >
SQL_ROW_NOROW <C: #define SQL_ROW_NOROW 3 >
SQL_ROW_NO_ROW_NUMBER <C: #define SQL_ROW_NO_ROW_NUMBER (-1) >
SQL_ROW_NUMBER <C: #define SQL_ROW_NUMBER 14 >
SQL_ROW_NUMBER_UNKNOWN <C: #define SQL_ROW_NUMBER_UNKNOWN (-2) >
SQL_ROW_PROCEED <C: #define SQL_ROW_PROCEED 0 >
SQL_ROW_SUCCESS <C: #define SQL_ROW_SUCCESS 0 >
SQL_ROW_SUCCESS_WITH_INFO <C: #define SQL_ROW_SUCCESS_WITH_INFO 6 >
SQL_ROW_UPDATED <C: #define SQL_ROW_UPDATED 2 >
SQL_ROW_UPDATES <C: #define SQL_ROW_UPDATES 11 >
SQL_SCCO_LOCK <C: #define SQL_SCCO_LOCK 0x00000002 >
SQL_SCCO_OPT_ROWVER <C: #define SQL_SCCO_OPT_ROWVER 0x00000004 >
SQL_SCCO_OPT_TIMESTAMP <C: #define SQL_SCCO_OPT_TIMESTAMP SQL_SCCO_OPT_ROWVER >
SQL_SCCO_OPT_VALUES <C: #define SQL_SCCO_OPT_VALUES 0x00000008 >
SQL_SCCO_READ_ONLY <C: #define SQL_SCCO_READ_ONLY 0x00000001 >
SQL_SCC_ISO92_CLI <C: #define SQL_SCC_ISO92_CLI 0x00000002 >
SQL_SCC_XOPEN_CLI_VERSION1 <C: #define SQL_SCC_XOPEN_CLI_VERSION1 0x00000001 >
SQL_SCHEMA_TERM <C: #define SQL_SCHEMA_TERM SQL_OWNER_TERM >
SQL_SCHEMA_USAGE <C: #define SQL_SCHEMA_USAGE SQL_OWNER_USAGE >
SQL_SCOPE_CURROW <C: #define SQL_SCOPE_CURROW 0 >
SQL_SCOPE_SESSION <C: #define SQL_SCOPE_SESSION 2 >
SQL_SCOPE_TRANSACTION <C: #define SQL_SCOPE_TRANSACTION 1 >
SQL_SCROLLABLE <C: #define SQL_SCROLLABLE 1 >
SQL_SCROLL_CONCURRENCY <C: #define SQL_SCROLL_CONCURRENCY 43 >
SQL_SCROLL_DYNAMIC <C: #define SQL_SCROLL_DYNAMIC (-2) >
SQL_SCROLL_FORWARD_ONLY <C: #define SQL_SCROLL_FORWARD_ONLY 0 >
SQL_SCROLL_KEYSET_DRIVEN <C: #define SQL_SCROLL_KEYSET_DRIVEN (-1) >
SQL_SCROLL_OPTIONS <C: #define SQL_SCROLL_OPTIONS 44 >
SQL_SCROLL_STATIC <C: #define SQL_SCROLL_STATIC (-3) >
SQL_SC_FIPS127_2_TRANSITIONAL <C: #define SQL_SC_FIPS127_2_TRANSITIONAL 0x00000002 >
SQL_SC_NON_UNIQUE <C: #define SQL_SC_NON_UNIQUE 0 >
SQL_SC_SQL92_ENTRY <C: #define SQL_SC_SQL92_ENTRY 0x00000001 >
SQL_SC_SQL92_FULL <C: #define SQL_SC_SQL92_FULL 0x00000008 >
SQL_SC_SQL92_INTERMEDIATE <C: #define SQL_SC_SQL92_INTERMEDIATE 0x00000004 >
SQL_SC_TRY_UNIQUE <C: #define SQL_SC_TRY_UNIQUE 1 >
SQL_SC_UNIQUE <C: #define SQL_SC_UNIQUE 2 >
SQL_SDF_CURRENT_DATE <C: #define SQL_SDF_CURRENT_DATE 0x00000001 >
SQL_SDF_CURRENT_TIME <C: #define SQL_SDF_CURRENT_TIME 0x00000002 >
SQL_SDF_CURRENT_TIMESTAMP <C: #define SQL_SDF_CURRENT_TIMESTAMP 0x00000004 >
SQL_SEARCHABLE <C: #define SQL_SEARCHABLE 3 >
SQL_SEARCH_PATTERN_ESCAPE <C: #define SQL_SEARCH_PATTERN_ESCAPE 14 >
SQL_SENSITIVE <C: #define SQL_SENSITIVE 2 >
SQL_SERVER_NAME <C: #define SQL_SERVER_NAME 13 >
SQL_SETPARAM_VALUE_MAX <C: #define SQL_SETPARAM_VALUE_MAX (-1) >
SQL_SETPOS_MAX_LOCK_VALUE <C: #define SQL_SETPOS_MAX_LOCK_VALUE SQL_LOCK_UNLOCK >
SQL_SETPOS_MAX_OPTION_VALUE <C: #define SQL_SETPOS_MAX_OPTION_VALUE SQL_ADD >
SQL_SET_DEFAULT <C: #define SQL_SET_DEFAULT 4 >
SQL_SET_NULL <C: #define SQL_SET_NULL 2 >
SQL_SFKD_CASCADE <C: #define SQL_SFKD_CASCADE 0x00000001 >
SQL_SFKD_NO_ACTION <C: #define SQL_SFKD_NO_ACTION 0x00000002 >
SQL_SFKD_SET_DEFAULT <C: #define SQL_SFKD_SET_DEFAULT 0x00000004 >
SQL_SFKD_SET_NULL <C: #define SQL_SFKD_SET_NULL 0x00000008 >
SQL_SFKU_CASCADE <C: #define SQL_SFKU_CASCADE 0x00000001 >
SQL_SFKU_NO_ACTION <C: #define SQL_SFKU_NO_ACTION 0x00000002 >
SQL_SFKU_SET_DEFAULT <C: #define SQL_SFKU_SET_DEFAULT 0x00000004 >
SQL_SFKU_SET_NULL <C: #define SQL_SFKU_SET_NULL 0x00000008 >
SQL_SG_DELETE_TABLE <C: #define SQL_SG_DELETE_TABLE 0x00000020 >
SQL_SG_INSERT_COLUMN <C: #define SQL_SG_INSERT_COLUMN 0x00000080 >
SQL_SG_INSERT_TABLE <C: #define SQL_SG_INSERT_TABLE 0x00000040 >
SQL_SG_REFERENCES_COLUMN <C: #define SQL_SG_REFERENCES_COLUMN 0x00000200 >
SQL_SG_REFERENCES_TABLE <C: #define SQL_SG_REFERENCES_TABLE 0x00000100 >
SQL_SG_SELECT_TABLE <C: #define SQL_SG_SELECT_TABLE 0x00000400 >
SQL_SG_UPDATE_COLUMN <C: #define SQL_SG_UPDATE_COLUMN 0x00001000 >
SQL_SG_UPDATE_TABLE <C: #define SQL_SG_UPDATE_TABLE 0x00000800 >
SQL_SG_USAGE_ON_CHARACTER_SET <C: #define SQL_SG_USAGE_ON_CHARACTER_SET 0x00000002 >
SQL_SG_USAGE_ON_COLLATION <C: #define SQL_SG_USAGE_ON_COLLATION 0x00000004 >
SQL_SG_USAGE_ON_DOMAIN <C: #define SQL_SG_USAGE_ON_DOMAIN 0x00000001 >
SQL_SG_USAGE_ON_TRANSLATION <C: #define SQL_SG_USAGE_ON_TRANSLATION 0x00000008 >
SQL_SG_WITH_GRANT_OPTION <C: #define SQL_SG_WITH_GRANT_OPTION 0x00000010 >
SQL_SIGNED_OFFSET <C: #define SQL_SIGNED_OFFSET (-20) >
SQL_SIMULATE_CURSOR <C: #define SQL_SIMULATE_CURSOR 10 >
SQL_SMALLINT <C: #define SQL_SMALLINT 5 >
SQL_SNVF_BIT_LENGTH <C: #define SQL_SNVF_BIT_LENGTH 0x00000001 >
SQL_SNVF_CHARACTER_LENGTH <C: #define SQL_SNVF_CHARACTER_LENGTH 0x00000004 >
SQL_SNVF_CHAR_LENGTH <C: #define SQL_SNVF_CHAR_LENGTH 0x00000002 >
SQL_SNVF_EXTRACT <C: #define SQL_SNVF_EXTRACT 0x00000008 >
SQL_SNVF_OCTET_LENGTH <C: #define SQL_SNVF_OCTET_LENGTH 0x00000010 >
SQL_SNVF_POSITION <C: #define SQL_SNVF_POSITION 0x00000020 >
SQL_SO_DYNAMIC <C: #define SQL_SO_DYNAMIC 0x00000004 >
SQL_SO_FORWARD_ONLY <C: #define SQL_SO_FORWARD_ONLY 0x00000001 >
SQL_SO_KEYSET_DRIVEN <C: #define SQL_SO_KEYSET_DRIVEN 0x00000002 >
SQL_SO_MIXED <C: #define SQL_SO_MIXED 0x00000008 >
SQL_SO_STATIC <C: #define SQL_SO_STATIC 0x00000010 >
SQL_SPECIAL_CHARACTERS <C: #define SQL_SPECIAL_CHARACTERS 94 >
SQL_SPEC_MAJOR <C: #define SQL_SPEC_MAJOR 3 >
SQL_SPEC_MINOR <C: #define SQL_SPEC_MINOR 51 >
SQL_SPEC_STRING <C: #define SQL_SPEC_STRING "03.51" >
SQL_SP_BETWEEN <C: #define SQL_SP_BETWEEN 0x00000800 >
SQL_SP_COMPARISON <C: #define SQL_SP_COMPARISON 0x00001000 >
SQL_SP_EXISTS <C: #define SQL_SP_EXISTS 0x00000001 >
SQL_SP_IN <C: #define SQL_SP_IN 0x00000400 >
SQL_SP_ISNOTNULL <C: #define SQL_SP_ISNOTNULL 0x00000002 >
SQL_SP_ISNULL <C: #define SQL_SP_ISNULL 0x00000004 >
SQL_SP_LIKE <C: #define SQL_SP_LIKE 0x00000200 >
SQL_SP_MATCH_FULL <C: #define SQL_SP_MATCH_FULL 0x00000008 >
SQL_SP_MATCH_PARTIAL <C: #define SQL_SP_MATCH_PARTIAL 0x00000010 >
SQL_SP_MATCH_UNIQUE_FULL <C: #define SQL_SP_MATCH_UNIQUE_FULL 0x00000020 >
SQL_SP_MATCH_UNIQUE_PARTIAL <C: #define SQL_SP_MATCH_UNIQUE_PARTIAL 0x00000040 >
SQL_SP_OVERLAPS <C: #define SQL_SP_OVERLAPS 0x00000080 >
SQL_SP_QUANTIFIED_COMPARISON <C: #define SQL_SP_QUANTIFIED_COMPARISON 0x00002000 >
SQL_SP_UNIQUE <C: #define SQL_SP_UNIQUE 0x00000100 >
SQL_SQL92_DATETIME_FUNCTIONS <C: #define SQL_SQL92_DATETIME_FUNCTIONS 155 >
SQL_SQL92_FOREIGN_KEY_DELETE_RULE <C: #define SQL_SQL92_FOREIGN_KEY_DELETE_RULE 156 >
SQL_SQL92_FOREIGN_KEY_UPDATE_RULE <C: #define SQL_SQL92_FOREIGN_KEY_UPDATE_RULE 157 >
SQL_SQL92_GRANT <C: #define SQL_SQL92_GRANT 158 >
SQL_SQL92_NUMERIC_VALUE_FUNCTIONS <C: #define SQL_SQL92_NUMERIC_VALUE_FUNCTIONS 159 >
SQL_SQL92_PREDICATES <C: #define SQL_SQL92_PREDICATES 160 >
SQL_SQL92_RELATIONAL_JOIN_OPERATORS <C: #define SQL_SQL92_RELATIONAL_JOIN_OPERATORS 161 >
SQL_SQL92_REVOKE <C: #define SQL_SQL92_REVOKE 162 >
SQL_SQL92_ROW_VALUE_CONSTRUCTOR <C: #define SQL_SQL92_ROW_VALUE_CONSTRUCTOR 163 >
SQL_SQL92_STRING_FUNCTIONS <C: #define SQL_SQL92_STRING_FUNCTIONS 164 >
SQL_SQL92_VALUE_EXPRESSIONS <C: #define SQL_SQL92_VALUE_EXPRESSIONS 165 >
SQL_SQLSTATE_SIZE <C: #define SQL_SQLSTATE_SIZE 5 >
SQL_SQL_CONFORMANCE <C: #define SQL_SQL_CONFORMANCE 118 >
SQL_SQ_COMPARISON <C: #define SQL_SQ_COMPARISON 0x00000001 >
SQL_SQ_CORRELATED_SUBQUERIES <C: #define SQL_SQ_CORRELATED_SUBQUERIES 0x00000010 >
SQL_SQ_EXISTS <C: #define SQL_SQ_EXISTS 0x00000002 >
SQL_SQ_IN <C: #define SQL_SQ_IN 0x00000004 >
SQL_SQ_QUANTIFIED <C: #define SQL_SQ_QUANTIFIED 0x00000008 >
SQL_SRJO_CORRESPONDING_CLAUSE <C: #define SQL_SRJO_CORRESPONDING_CLAUSE 0x00000001 >
SQL_SRJO_CROSS_JOIN <C: #define SQL_SRJO_CROSS_JOIN 0x00000002 >
SQL_SRJO_EXCEPT_JOIN <C: #define SQL_SRJO_EXCEPT_JOIN 0x00000004 >
SQL_SRJO_FULL_OUTER_JOIN <C: #define SQL_SRJO_FULL_OUTER_JOIN 0x00000008 >
SQL_SRJO_INNER_JOIN <C: #define SQL_SRJO_INNER_JOIN 0x00000010 >
SQL_SRJO_INTERSECT_JOIN <C: #define SQL_SRJO_INTERSECT_JOIN 0x00000020 >
SQL_SRJO_LEFT_OUTER_JOIN <C: #define SQL_SRJO_LEFT_OUTER_JOIN 0x00000040 >
SQL_SRJO_NATURAL_JOIN <C: #define SQL_SRJO_NATURAL_JOIN 0x00000080 >
SQL_SRJO_RIGHT_OUTER_JOIN <C: #define SQL_SRJO_RIGHT_OUTER_JOIN 0x00000100 >
SQL_SRJO_UNION_JOIN <C: #define SQL_SRJO_UNION_JOIN 0x00000200 >
SQL_SRVC_DEFAULT <C: #define SQL_SRVC_DEFAULT 0x00000004 >
SQL_SRVC_NULL <C: #define SQL_SRVC_NULL 0x00000002 >
SQL_SRVC_ROW_SUBQUERY <C: #define SQL_SRVC_ROW_SUBQUERY 0x00000008 >
SQL_SRVC_VALUE_EXPRESSION <C: #define SQL_SRVC_VALUE_EXPRESSION 0x00000001 >
SQL_SR_CASCADE <C: #define SQL_SR_CASCADE 0x00000020 >
SQL_SR_DELETE_TABLE <C: #define SQL_SR_DELETE_TABLE 0x00000080 >
SQL_SR_GRANT_OPTION_FOR <C: #define SQL_SR_GRANT_OPTION_FOR 0x00000010 >
SQL_SR_INSERT_COLUMN <C: #define SQL_SR_INSERT_COLUMN 0x00000200 >
SQL_SR_INSERT_TABLE <C: #define SQL_SR_INSERT_TABLE 0x00000100 >
SQL_SR_REFERENCES_COLUMN <C: #define SQL_SR_REFERENCES_COLUMN 0x00000800 >
SQL_SR_REFERENCES_TABLE <C: #define SQL_SR_REFERENCES_TABLE 0x00000400 >
SQL_SR_RESTRICT <C: #define SQL_SR_RESTRICT 0x00000040 >
SQL_SR_SELECT_TABLE <C: #define SQL_SR_SELECT_TABLE 0x00001000 >
SQL_SR_UPDATE_COLUMN <C: #define SQL_SR_UPDATE_COLUMN 0x00004000 >
SQL_SR_UPDATE_TABLE <C: #define SQL_SR_UPDATE_TABLE 0x00002000 >
SQL_SR_USAGE_ON_CHARACTER_SET <C: #define SQL_SR_USAGE_ON_CHARACTER_SET 0x00000002 >
SQL_SR_USAGE_ON_COLLATION <C: #define SQL_SR_USAGE_ON_COLLATION 0x00000004 >
SQL_SR_USAGE_ON_DOMAIN <C: #define SQL_SR_USAGE_ON_DOMAIN 0x00000001 >
SQL_SR_USAGE_ON_TRANSLATION <C: #define SQL_SR_USAGE_ON_TRANSLATION 0x00000008 >
SQL_SSF_CONVERT <C: #define SQL_SSF_CONVERT 0x00000001 >
SQL_SSF_LOWER <C: #define SQL_SSF_LOWER 0x00000002 >
SQL_SSF_SUBSTRING <C: #define SQL_SSF_SUBSTRING 0x00000008 >
SQL_SSF_TRANSLATE <C: #define SQL_SSF_TRANSLATE 0x00000010 >
SQL_SSF_TRIM_BOTH <C: #define SQL_SSF_TRIM_BOTH 0x00000020 >
SQL_SSF_TRIM_LEADING <C: #define SQL_SSF_TRIM_LEADING 0x00000040 >
SQL_SSF_TRIM_TRAILING <C: #define SQL_SSF_TRIM_TRAILING 0x00000080 >
SQL_SSF_UPPER <C: #define SQL_SSF_UPPER 0x00000004 >
SQL_SS_ADDITIONS <C: #define SQL_SS_ADDITIONS 0x00000001 >
SQL_SS_DELETIONS <C: #define SQL_SS_DELETIONS 0x00000002 >
SQL_SS_UPDATES <C: #define SQL_SS_UPDATES 0x00000004 >
SQL_STANDARD_CLI_CONFORMANCE <C: #define SQL_STANDARD_CLI_CONFORMANCE 166 >
SQL_STATICMODE_CAPTURE <C: #define SQL_STATICMODE_CAPTURE CLI_CAP_STATICMODE_CAPTURE >
SQL_STATICMODE_DISABLED <C: #define SQL_STATICMODE_DISABLED CLI_CAP_STATICMODE_DISABLED >
SQL_STATICMODE_MATCH <C: #define SQL_STATICMODE_MATCH CLI_CAP_STATICMODE_MATCH >
SQL_STATIC_CURSOR_ATTRIBUTES1 <C: #define SQL_STATIC_CURSOR_ATTRIBUTES1 167 >
SQL_STATIC_CURSOR_ATTRIBUTES2 <C: #define SQL_STATIC_CURSOR_ATTRIBUTES2 168 >
SQL_STATIC_SENSITIVITY <C: #define SQL_STATIC_SENSITIVITY 83 >
SQL_STILL_EXECUTING <C: #define SQL_STILL_EXECUTING 2 >
SQL_STMTTXN_ISOLATION <C: #define SQL_STMTTXN_ISOLATION 1261 >
SQL_STRING_FUNCTIONS <C: #define SQL_STRING_FUNCTIONS 50 >
SQL_STRUCTURE <C: #define SQL_STRUCTURE struct >
SQL_SUBQUERIES <C: #define SQL_SUBQUERIES 95 >
SQL_SUCCESS <C: #define SQL_SUCCESS 0 >
SQL_SUCCESS_WITH_INFO <C: #define SQL_SUCCESS_WITH_INFO 1 >
SQL_SU_DML_STATEMENTS <C: #define SQL_SU_DML_STATEMENTS SQL_OU_DML_STATEMENTS >
SQL_SU_INDEX_DEFINITION <C: #define SQL_SU_INDEX_DEFINITION SQL_OU_INDEX_DEFINITION >
SQL_SU_PRIVILEGE_DEFINITION <C: #define SQL_SU_PRIVILEGE_DEFINITION SQL_OU_PRIVILEGE_DEFINITION >
SQL_SU_PROCEDURE_INVOCATION <C: #define SQL_SU_PROCEDURE_INVOCATION SQL_OU_PROCEDURE_INVOCATION >
SQL_SU_TABLE_DEFINITION <C: #define SQL_SU_TABLE_DEFINITION SQL_OU_TABLE_DEFINITION >
SQL_SVE_CASE <C: #define SQL_SVE_CASE 0x00000001 >
SQL_SVE_CAST <C: #define SQL_SVE_CAST 0x00000002 >
SQL_SVE_COALESCE <C: #define SQL_SVE_COALESCE 0x00000004 >
SQL_SVE_NULLIF <C: #define SQL_SVE_NULLIF 0x00000008 >
SQL_SYNCPOINT_DEFAULT <C: #define SQL_SYNCPOINT_DEFAULT SQL_ONEPHASE >
SQL_SYNC_POINT <C: #define SQL_SYNC_POINT 1256 >
SQL_SYSTEM_FUNCTIONS <C: #define SQL_SYSTEM_FUNCTIONS 51 >
SQL_TABLE_STAT <C: #define SQL_TABLE_STAT 0 >
SQL_TABLE_TERM <C: #define SQL_TABLE_TERM 45 >
SQL_TC_ALL <C: #define SQL_TC_ALL 0x0002 >
SQL_TC_DDL_COMMIT <C: #define SQL_TC_DDL_COMMIT 0x0003 >
SQL_TC_DDL_IGNORE <C: #define SQL_TC_DDL_IGNORE 0x0004 >
SQL_TC_DML <C: #define SQL_TC_DML 0x0001 >
SQL_TC_NONE <C: #define SQL_TC_NONE 0x0000 >
SQL_TIME <C: #define SQL_TIME 10 >
SQL_TIMEDATE_ADD_INTERVALS <C: #define SQL_TIMEDATE_ADD_INTERVALS 109 >
SQL_TIMEDATE_DIFF_INTERVALS <C: #define SQL_TIMEDATE_DIFF_INTERVALS 110 >
SQL_TIMEDATE_FUNCTIONS <C: #define SQL_TIMEDATE_FUNCTIONS 52 >
SQL_TIMESTAMP <C: #define SQL_TIMESTAMP 11 >
SQL_TIMESTAMP_LEN <C: #define SQL_TIMESTAMP_LEN 19 >
SQL_TIME_LEN <C: #define SQL_TIME_LEN 8 >
SQL_TINYINT <C: #define SQL_TINYINT (-6) >
SQL_TRANSACTION_CAPABLE <C: #define SQL_TRANSACTION_CAPABLE SQL_TXN_CAPABLE >
SQL_TRANSACTION_ISOLATION_OPTION <C: #define SQL_TRANSACTION_ISOLATION_OPTION SQL_TXN_ISOLATION_OPTION >
SQL_TRANSACTION_NOCOMMIT <C: #define SQL_TRANSACTION_NOCOMMIT SQL_TXN_NOCOMMIT >
SQL_TRANSACTION_READ_COMMITTED <C: #define SQL_TRANSACTION_READ_COMMITTED SQL_TXN_READ_COMMITTED >
SQL_TRANSACTION_READ_UNCOMMITTED <C: #define SQL_TRANSACTION_READ_UNCOMMITTED SQL_TXN_READ_UNCOMMITTED >
SQL_TRANSACTION_REPEATABLE_READ <C: #define SQL_TRANSACTION_REPEATABLE_READ SQL_TXN_REPEATABLE_READ >
SQL_TRANSACTION_SERIALIZABLE <C: #define SQL_TRANSACTION_SERIALIZABLE SQL_TXN_SERIALIZABLE >
SQL_TRANSLATE_DLL <C: #define SQL_TRANSLATE_DLL 106 >
SQL_TRANSLATE_OPTION <C: #define SQL_TRANSLATE_OPTION 107 >
SQL_TRUE <C: #define SQL_TRUE 1 >
SQL_TWOPHASE <C: #define SQL_TWOPHASE 2 >
SQL_TXN_CAPABLE <C: #define SQL_TXN_CAPABLE 46 >
SQL_TXN_ISOLATION <C: #define SQL_TXN_ISOLATION 108 >
SQL_TXN_ISOLATION_OPTION <C: #define SQL_TXN_ISOLATION_OPTION 72 >
SQL_TXN_NOCOMMIT <C: #define SQL_TXN_NOCOMMIT 0x00000020 >
SQL_TXN_READ_COMMITTED <C: #define SQL_TXN_READ_COMMITTED 0x00000002 >
SQL_TXN_READ_UNCOMMITTED <C: #define SQL_TXN_READ_UNCOMMITTED 0x00000001 >
SQL_TXN_REPEATABLE_READ <C: #define SQL_TXN_REPEATABLE_READ 0x00000004 >
SQL_TXN_SERIALIZABLE <C: #define SQL_TXN_SERIALIZABLE 0x00000008 >
SQL_TYPE_BASE <C: #define SQL_TYPE_BASE 0 >
SQL_TYPE_DATE <C: #define SQL_TYPE_DATE 91 >
SQL_TYPE_DISTINCT <C: #define SQL_TYPE_DISTINCT 1 >
SQL_TYPE_NULL <C: #define SQL_TYPE_NULL 0 >
SQL_TYPE_REFERENCE <C: #define SQL_TYPE_REFERENCE 3 >
SQL_TYPE_STRUCTURED <C: #define SQL_TYPE_STRUCTURED 2 >
SQL_TYPE_TIME <C: #define SQL_TYPE_TIME 92 >
SQL_TYPE_TIMESTAMP <C: #define SQL_TYPE_TIMESTAMP 93 >
SQL_UB_DEFAULT <C: #define SQL_UB_DEFAULT SQL_UB_OFF >
SQL_UB_FIXED <C: #define SQL_UB_FIXED SQL_UB_ON >
SQL_UB_OFF <C: #define SQL_UB_OFF 0 >
SQL_UB_ON <C: #define SQL_UB_ON 1 >
SQL_UB_VARIABLE <C: #define SQL_UB_VARIABLE 2 >
SQL_UNBIND <C: #define SQL_UNBIND 2 >
SQL_UNICODE <C: #define SQL_UNICODE (-95) >
SQL_UNICODE_CHAR <C: #define SQL_UNICODE_CHAR SQL_UNICODE >
SQL_UNICODE_LONGVARCHAR <C: #define SQL_UNICODE_LONGVARCHAR (-97) >
SQL_UNICODE_VARCHAR <C: #define SQL_UNICODE_VARCHAR (-96) >
SQL_UNION <C: #define SQL_UNION 96 >
SQL_UNION_STATEMENT <C: #define SQL_UNION_STATEMENT SQL_UNION >
SQL_UNKNOWN_TYPE <C: #define SQL_UNKNOWN_TYPE 0 >
SQL_UNNAMED <C: #define SQL_UNNAMED 1 >
SQL_UNSEARCHABLE <C: #define SQL_UNSEARCHABLE 0 >
SQL_UNSIGNED_OFFSET <C: #define SQL_UNSIGNED_OFFSET (-22) >
SQL_UNSPECIFIED <C: #define SQL_UNSPECIFIED 0 >
SQL_UPDATE <C: #define SQL_UPDATE 2 >
SQL_UPDATE_BY_BOOKMARK <C: #define SQL_UPDATE_BY_BOOKMARK 5 >
SQL_UPDT_READONLY <C: #define SQL_UPDT_READONLY 0 >
SQL_UPDT_READWRITE_UNKNOWN <C: #define SQL_UPDT_READWRITE_UNKNOWN 2 >
SQL_UPDT_WRITE <C: #define SQL_UPDT_WRITE 1 >
SQL_USER_DEFINED_TYPE <C: #define SQL_USER_DEFINED_TYPE -450 >
SQL_USER_NAME <C: #define SQL_USER_NAME 47 >
SQL_USE_BOOKMARKS <C: #define SQL_USE_BOOKMARKS 12 >
SQL_US_UNION <C: #define SQL_US_UNION SQL_U_UNION >
SQL_US_UNION_ALL <C: #define SQL_US_UNION_ALL SQL_U_UNION_ALL >
SQL_U_UNION <C: #define SQL_U_UNION 0x00000001 >
SQL_U_UNION_ALL <C: #define SQL_U_UNION_ALL 0x00000002 >
SQL_VARBINARY <C: #define SQL_VARBINARY (-3) >
SQL_VARCHAR <C: #define SQL_VARCHAR 12 >
SQL_VARGRAPHIC <C: #define SQL_VARGRAPHIC -96 >
SQL_WCHAR <C: #define SQL_WCHAR (-8) >
SQL_WCHARTYPE <C: #define SQL_WCHARTYPE 1252 >
SQL_WCHARTYPE_DEFAULT <C: #define SQL_WCHARTYPE_DEFAULT SQL_WCHARTYPE_NOCONVERT >
SQL_WCHARTYPE_NOCONVERT <C: #define SQL_WCHARTYPE_NOCONVERT 0 >
SQL_WLONGVARCHAR <C: #define SQL_WLONGVARCHAR (-10) >
SQL_WVARCHAR <C: #define SQL_WVARCHAR (-9) >
SQL_XOPEN_CLI_YEAR <C: #define SQL_XOPEN_CLI_YEAR 10000 >
_SQLOLDCHAR <C: #define _SQLOLDCHAR char >
__DATE__ <C: #define __DATE__ "June 5, 2000" >
__FILE__ <C: #define __FILE__ >
__LINE__ <C: #define __LINE__ 0 >
__SQL <C: #define __SQL >
__SQLEXT <C: #define __SQLEXT >
__STDC__ <C: #define __STDC__ 1 >
__TIME__ <C: #define __TIME__ "4:53:53 pm" >
</methods> <methods> Database.DB2CLIInterface <category>accessing</category>
copyToHeapSelector ^#copyToHeap
encoding encoding == nil ifTrue: [encoding := self getEncoding]. ^encoding
getDataChunkSize ^self class getDataChunkSize
getEncoding ^#default
mallocSelector ^#malloc:
setDataChunkSize: anInteger self class setDataChunkSize: anInteger
</methods> <methods> Database.DB2CLIInterface <category>macros</category>
SQL_ADD_RECORD: hstmt with: irow "<C: #define SQL_ADD_RECORD(hstmt, irow) SQLSetPos(hstmt ,irow ,SQL_ADD,SQL_LOCK_NO_CHANGE) >" ^self SQLSetPos: hstmt with: irow with: self SQL_ADD with: self SQL_LOCK_NO_CHANGE
SQL_DELETE_RECORD: hstmt with: irow "<C: #define SQL_DELETE_RECORD(hstmt, irow) SQLSetPos(hstmt ,irow ,SQL_DELETE,SQL_LOCK_NO_CHANGE) >" ^self SQLSetPos: hstmt with: irow with: self SQL_DELETE with: self SQL_LOCK_NO_CHANGE
SQL_FUNC_EXISTS: pfExists with: uwAPI <C: #define SQL_FUNC_EXISTS(pfExists, uwAPI) ((*(((UWORD*)(pfExists ))+((uwAPI )>>4))&(1<<((uwAPI )&0x000F)))?SQL_TRUE:SQL_FALSE) > ^self error: 'Macro evaluation is not supported'
SQL_LEN_BINARY_ATTR: length "<C: #define SQL_LEN_BINARY_ATTR(length) (-(length )+SQL_LEN_BINARY_ATTR_OFFSET) >" ^length negated + self SQL_LEN_BINARY_ATTR_OFFSET
SQL_LEN_DATA_AT_EXEC: length "<C: #define SQL_LEN_DATA_AT_EXEC(length) (-(length )+SQL_LEN_DATA_AT_EXEC_OFFSET) >" ^length negated + self SQL_LEN_DATA_AT_EXEC_OFFSET
SQL_LOCK_RECORD: hstmt with: irow with: fLock "<C: #define SQL_LOCK_RECORD(hstmt, irow, fLock) SQLSetPos(hstmt ,irow ,SQL_POSITION,fLock ) >" ^self SQLSetPos: hstmt with: irow with: self SQL_POSITION with: fLock
SQL_POSITION_TO: hstmt with: irow "<C: #define SQL_POSITION_TO(hstmt, irow) SQLSetPos(hstmt ,irow ,SQL_POSITION,SQL_LOCK_NO_CHANGE) >" ^self SQLSetPos: hstmt with: irow with: self SQL_POSITION with: self SQL_LOCK_NO_CHANGE
SQL_REFRESH_RECORD: hstmt with: irow with: fLock "<C: #define SQL_REFRESH_RECORD(hstmt, irow, fLock) SQLSetPos(hstmt ,irow ,SQL_REFRESH,fLock ) >" ^self SQLSetPos: hstmt with: irow with: self SQL_REFRESH with: fLock
SQL_SUCCEEDED: rc "<C: #define SQL_SUCCEEDED(rc) (((rc )&(~1))==0) >" ^( rc bitAnd: 1 bitInvert ) == 0
SQL_UPDATE_RECORD: hstmt with: irow "<C: #define SQL_UPDATE_RECORD(hstmt, irow) SQLSetPos(hstmt ,irow ,SQL_UPDATE,SQL_LOCK_NO_CHANGE) >" ^self SQLSetPos: hstmt with: irow with: self SQL_UPDATE with: self SQL_LOCK_NO_CHANGE
</methods> <methods> Database.DB2CLIInterface class <category>fileIn/Out</category>
binaryInitializationMessagesFor: sourceMode "Answer a list of message sends used to initialize the receiver." | list | list := super binaryInitializationMessagesFor: sourceMode. list add: ( MessageSend receiver: self selector: #deferredInitialize). ^list
</methods> <methods> Database.DB2CLIInterface class <category>private-accessing</category>
conversionBufferMap ^conversionBufferMap
fCTypeFromConversionMap ^fCTypeFromConversionMap
fetchBufferSizeBlocks ^fetchBufferSizeBlocks
fSqlTypeFromConversionMap ^fSqlTypeFromConversionMap
fSqlTypeToConversionMap ^fSqlTypeToConversionMap
getSelectorMap ^getSelectorMap
putSelectorMap ^putSelectorMap
valuePrecisionBlocks ^valuePrecisionBlocks
valueSizeBlocks ^valueSizeBlocks
</methods> <methods> Database.DB2CLIInterface class <category>class initialization</category>
deferredInitialize "Used to initialize the class after file-in or BOSS-in." | db2BufferClass | self initializeMaps. (db2BufferClass := self environment at: #DB2Buffer ifAbsent: [nil]) notNil ifTrue: [db2BufferClass install]
initialize "DB2CLIInterface withAllSubclasses do: [:class | class initialize]. DB2Buffer install" self initializeDefineCaches. self initializeMaps.
initializeDefineCaches "This should only be done if the DLLCC development environment is present in the image." "self fillDefineCaches. self fillDefineCaches" "Do twice in case there are longer reference chains."
initializeMaps "self initializeMapsOld" self initializeMapsNew.
initializeMapsNew | xif | dataChunkSize := 1048576. "Set the default chunk size." "NEED MORE WORK" xif := self new. "==========================================================" self privateInitializeMaps. self initializeDateConversions: xif. self initializeTimeConversions: xif. self initializeTimestampConversions: xif. self initializeStringConversions: xif. "self initializeLongStringConversions: xif." self initializeClobConversions: xif. self initializeClobLocatorConversions: xif. self initializeFileReferenceConversions: xif. self initializeByteArrayConversions: xif. "self initializeLongByteArrayConversions: xif." self initializeBlobConversions: xif. self initializeBlobLocatorConversions: xif. self initializeBigIntConversions: xif. self initializeFloatConversions: xif. self initializeDoubleConversions: xif. self initializeIntegerConversions: xif. self initializeFixedPointConversions: xif. self initializeDataLinkConversions: xif
</methods> <methods> Database.DB2CLIInterface class <category>accessing</category>
getDataChunkSize ^dataChunkSize
setDataChunkSize: anInteger dataChunkSize := anInteger
</methods> <methods> Database.DB2CLIInterface class <category>private class initialization</category>
initializeBigIntConversions: xif "Conversion to/from buffer for BIGINT" conversionBufferMap add: (#LargeInteger -> UninterpretedBytes). fSqlTypeToConversionMap add: ( xif SQL_BIGINT -> #LargeInteger ). getSelectorMap add: ( #LargeInteger -> #getLargeIntegerAt: ). putSelectorMap add: ( #LargeInteger -> #at:putLargeInteger: ). fSqlTypeFromConversionMap add: ( #LargeInteger -> xif SQL_BIGINT ). fCTypeFromConversionMap add: ( #LargeInteger -> xif SQL_C_SBIGINT ). "add mapping for UBIGINT ?" fetchBufferSizeBlocks add: ( #LargeInteger -> [ :size | 8 ] ). valueSizeBlocks add: ( #LargeInteger -> [ :ignoredValue | 8 ] ). valuePrecisionBlocks add: ( #LargeInteger -> [ :ignoredValue | 0 ] ).
initializeBlobConversions: xif "Conversion to/from BLOB" | binVPB | conversionBufferMap add: (#LargeByteArray -> nil). getSelectorMap add: ( #LargeByteArray -> #getByteArrayAt: ). putSelectorMap add: ( #LargeByteArray -> #at:putByteArray: ). fSqlTypeToConversionMap add: ( xif SQL_BLOB -> #LargeByteArray ). fSqlTypeFromConversionMap add: ( #LargeByteArray -> xif SQL_BLOB ). fCTypeFromConversionMap add: ( #LargeByteArray -> xif SQL_C_BINARY ). binVPB := [ :ba | | sz | (sz := ba size) <= 256 ifTrue: [ 256 ] ifFalse: [ "65536" dataChunkSize min: (2 raisedTo: ( (sz floorLog: 2) + 1)) ] ]. fetchBufferSizeBlocks add: ( #LargeByteArray -> [ :size | (self getDataChunkSize min: size) ] ). valueSizeBlocks add: ( #LargeByteArray -> binVPB ). valuePrecisionBlocks add: ( #LargeByteArray -> binVPB ).
initializeBlobLocatorConversions: xif "Conversion to/from BLOB Locator" conversionBufferMap add: (#BlobLocator -> UninterpretedBytes). getSelectorMap add: ( #BlobLocator -> #getBlobLocatorAt: ). putSelectorMap add: ( #BlobLocator -> #at:putBlobLocator: ). fSqlTypeToConversionMap add: ( xif SQL_BLOB_LOCATOR -> #BlobLocator ). fSqlTypeFromConversionMap add: ( #BlobLocator -> xif SQL_BLOB_LOCATOR ). fCTypeFromConversionMap add: ( #BlobLocator -> xif SQL_C_BLOB_LOCATOR ). fetchBufferSizeBlocks add: ( #BlobLocator -> [ :ignored | 4 ] ). valueSizeBlocks add: ( #BlobLocator -> [ :ignoredValue | 4 ] ). valuePrecisionBlocks add: ( #BlobLocator -> [ :ignoredValue | 0 ] ).
initializeByteArrayConversions: xif "Conversion to/from buffer for ByteArray." | binVPB | conversionBufferMap add: (#ByteArray -> nil). getSelectorMap add: ( #ByteArray -> #getByteArrayAt: ). putSelectorMap add: ( #ByteArray -> #at:putByteArray: ). fSqlTypeToConversionMap add: ( xif SQL_BINARY -> #ByteArray ). fSqlTypeToConversionMap add: ( xif SQL_VARBINARY -> #ByteArray ). fSqlTypeToConversionMap add: ( xif SQL_LONGVARBINARY -> #ByteArray ). fSqlTypeFromConversionMap add: ( #ByteArray -> xif SQL_VARBINARY ). fCTypeFromConversionMap add: ( #ByteArray -> xif SQL_C_BINARY ). binVPB := [ :ba | | sz | (sz := ba size) <= 256 ifTrue: [ 256 ] ifFalse: [32700 min: (2 raisedTo: ( (sz floorLog: 2) + 1)) ] ]. fetchBufferSizeBlocks add: ( #ByteArray -> [ :size | size ] ). valueSizeBlocks add: ( #ByteArray -> binVPB ). valuePrecisionBlocks add: ( #ByteArray -> binVPB ).
initializeClobConversions: xif "Conversion to/from CLOB" | binVPB | conversionBufferMap add: (#LargeString -> nil). getSelectorMap add: ( #LargeString -> #getStringAt: ). putSelectorMap add: ( #LargeString -> #at:putString: ). fSqlTypeToConversionMap add: ( xif SQL_CLOB -> #LargeString ). fSqlTypeFromConversionMap add: ( #LargeString -> xif SQL_CLOB ). fCTypeFromConversionMap add: ( #LargeString -> xif SQL_C_CHAR ). binVPB := [ :ba | | sz | (sz := ba size) <= 256 ifTrue: [ 256 ] ifFalse: [ dataChunkSize min: (2 raisedTo: ( (sz floorLog: 2) + 1)) ] ]. fetchBufferSizeBlocks add: ( #LargeString -> [ :size | (self getDataChunkSize min: size) + 1 ] ). valueSizeBlocks add: ( #LargeString -> binVPB ). valuePrecisionBlocks add: ( #LargeString -> binVPB ).
initializeClobLocatorConversions: xif "Conversion to/from CLOB Locator" conversionBufferMap add: (#ClobLocator -> UninterpretedBytes). getSelectorMap add: ( #ClobLocator -> #getBlobLocatorAt: ). putSelectorMap add: ( #ClobLocator -> #at:putBlobLocator: ). fSqlTypeToConversionMap add: ( xif SQL_CLOB_LOCATOR -> #ClobLocator ). fSqlTypeFromConversionMap add: ( #ClobLocator -> xif SQL_CLOB_LOCATOR ). fCTypeFromConversionMap add: ( #ClobLocator -> xif SQL_C_CLOB_LOCATOR ). fetchBufferSizeBlocks add: ( #ClobLocator -> [ :ignored | 4 ] ). valueSizeBlocks add: ( #ClobLocator -> [ :ignoredValue | 4 ] ). valuePrecisionBlocks add: ( #ClobLocator -> [ :ignoredValue | 0 ] ).
initializeDataLinkConversions: xif "Conversion to/from buffer for DataLink." conversionBufferMap add: (#DataLink -> ByteString). fSqlTypeToConversionMap add: ( xif SQL_DATALINK -> #DataLink ). getSelectorMap add: ( #DataLink -> #getDataLinkAt: ). putSelectorMap add: ( #DataLink -> #at:putDataLink: ). fSqlTypeFromConversionMap add: ( #DataLink -> xif SQL_DATALINK ). fCTypeFromConversionMap add: ( #DataLink -> xif SQL_C_DATALINK ). fetchBufferSizeBlocks add: ( #DataLink -> [ :size | 255 ] ). valueSizeBlocks add: ( #DataLink -> [ :ignoredValue | 255 ] ). valuePrecisionBlocks add: ( #DataLink -> [ :ignoredValue | 255 ] ).
initializeDateConversions: xif "Conversions to/from buffer for #Date." conversionBufferMap add: (#Date -> UninterpretedBytes). getSelectorMap add: ( #Date -> #getDateAt: ). putSelectorMap add: ( #Date -> #at:putDate: ). fSqlTypeToConversionMap add: ( xif SQL_DATE -> #Date ). fSqlTypeToConversionMap add: ( xif SQL_TYPE_DATE -> #Date ). fSqlTypeFromConversionMap add: ( #Date -> xif SQL_TYPE_DATE ). fCTypeFromConversionMap add: ( #Date -> xif SQL_C_TYPE_DATE ). fetchBufferSizeBlocks add: ( #Date -> [ :ignored | 6] ). valueSizeBlocks add: ( #Date -> [ :ignoredValue | 6 ] ). valuePrecisionBlocks add: ( #Date -> [ :ignoredValue | 0 ] ). "Not used by SQLSetParam"
initializeDBClobLocatorConversions: xif
initializeDoubleConversions: xif "Conversion to/from buffer for Double." conversionBufferMap add: (#Double -> UninterpretedBytes). getSelectorMap add: ( #Double -> #getDoubleAt: ). putSelectorMap add: ( #Double -> #at:putDouble: ). fSqlTypeToConversionMap add: ( xif SQL_DOUBLE -> #Double ). fSqlTypeToConversionMap add: ( xif SQL_FLOAT -> #Double ). fSqlTypeFromConversionMap add: ( #Double -> xif SQL_DOUBLE ). fCTypeFromConversionMap add: ( #Double -> xif SQL_C_DOUBLE ). fetchBufferSizeBlocks add: ( #Double -> [ :ignored | 8 ] ). valueSizeBlocks add: ( #Double -> [ :ignoredValue | 8 ] ). valuePrecisionBlocks add: ( #Double -> [ :ignoredValue | 0 ] ).
initializeFileReferenceConversions: xif "Conversion to/from LOB Reference" "conversionBufferMap add: (#FileRef -> nil)." getSelectorMap add: ( #FileRef -> #getFileRefAt: ). putSelectorMap add: ( #FileRef -> #at:putFileRef: ). "fSqlTypeToConversionMap add: ( xif SQL_BLOB_LOCATOR -> #BlobLocator ). fSqlTypeFromConversionMap add: ( #BlobLocator -> xif SQL_BLOB_LOCATOR ). fCTypeFromConversionMap add: ( #BlobLocator -> xif SQL_C_BLOB_LOCATOR )." "fetchBufferSizeBlocks add: ( #BlobLocator -> [ :ignored | 4 ] ). valueSizeBlocks add: ( #BlobLocator -> [ :ignoredValue | 4 ] ). valuePrecisionBlocks add: ( #BlobLocator -> [ :ignoredValue | 0 ] )."
initializeFixedPointConversions: xif "Conversion to/from buffer for FixedPoint." conversionBufferMap add: (#FixedPoint -> ByteString). fSqlTypeToConversionMap add: ( xif SQL_DECIMAL -> #FixedPoint ). fSqlTypeToConversionMap add: ( xif SQL_NUMERIC -> #FixedPoint ). getSelectorMap add: ( #FixedPoint -> #getFixedPointAt: ). putSelectorMap add: ( #FixedPoint -> #at:putFixedPoint: ). fSqlTypeFromConversionMap add: ( #FixedPoint -> xif SQL_DECIMAL ). fCTypeFromConversionMap add: ( #FixedPoint -> xif SQL_C_CHAR ). fetchBufferSizeBlocks add: ( #FixedPoint -> [ :size | size + 3 ] ). "Add room for sign, decimal point, and null byte" valueSizeBlocks add: ( #FixedPoint -> [ :ignoredValue | 34 ] ). "Leave room for sign, decimal point, and null byte" valuePrecisionBlocks add: ( #FixedPoint -> [ :ignoredValue | 31 ] ). "This be the max."
initializeFloatConversions: xif "Conversion from buffer for Float." conversionBufferMap add: (#Float -> UninterpretedBytes). getSelectorMap add: ( #Float -> #getFloatAt: ). putSelectorMap add: ( #Float -> #at:putFloat: ). fSqlTypeToConversionMap add: ( xif SQL_REAL -> #Float ). fSqlTypeFromConversionMap add: ( #Float -> xif SQL_REAL ). fCTypeFromConversionMap add: ( #Float -> xif SQL_C_FLOAT ). fetchBufferSizeBlocks add: ( #Float -> [ :ignored | 4 ] ). valueSizeBlocks add: ( #Float -> [ :ignoredValue | 4 ] ). valuePrecisionBlocks add: ( #Float -> [ :ignoredValue | 0 ] ).
initializeIntegerConversions: xif "Conversion from buffer for Integer." conversionBufferMap add: (#Integer -> UninterpretedBytes). getSelectorMap add: ( #Integer -> #getIntegerAt: ). putSelectorMap add: ( #Integer -> #at:putInteger: ). fSqlTypeToConversionMap add: ( xif SQL_SMALLINT -> #Integer ). fSqlTypeToConversionMap add: ( xif SQL_INTEGER -> #Integer ). fSqlTypeFromConversionMap add: ( #Integer -> xif SQL_INTEGER ). fCTypeFromConversionMap add: ( #Integer -> xif SQL_C_LONG ). fetchBufferSizeBlocks add: ( #Integer -> [ :ignored | 4 ] ). valueSizeBlocks add: ( #Integer -> [ :ignoredValue | 4 ] ). valuePrecisionBlocks add: ( #Integer -> [ :ignoredValue | 0 ] )
initializeStringConversions: xif "Conversion from buffer for String." | charVPB | conversionBufferMap add: (#String -> nil). getSelectorMap add: ( #String -> #getStringAt: ). putSelectorMap add: ( #String -> #at:putString: ). fSqlTypeToConversionMap add: ( xif SQL_CHAR -> #String ). fSqlTypeToConversionMap add: ( xif SQL_VARCHAR -> #String ). fSqlTypeToConversionMap add: ( xif SQL_LONGVARCHAR -> #String ). fSqlTypeFromConversionMap add: ( #String -> xif SQL_VARCHAR ). fCTypeFromConversionMap add: ( #String -> xif SQL_C_CHAR ). charVPB := [ :str | | sz | (sz := str size) <= 256 ifTrue: [ 256 ] ifFalse: [ 32700 min: (2 raisedTo: ( (sz floorLog: 2) + 1) ) ] ]. fetchBufferSizeBlocks add: ( #String -> [ :size | size + 1 ] ). "Leave room for a null." valueSizeBlocks add: ( #String -> charVPB ). valuePrecisionBlocks add: ( #String -> charVPB ).
initializeTimeConversions: xif "Conversion from buffer for Time." conversionBufferMap add: (#Time -> UninterpretedBytes). getSelectorMap add: ( #Time -> #getTimeAt: ). putSelectorMap add: ( #Time -> #at:putTime: ). fSqlTypeToConversionMap add: ( xif SQL_TIME -> #Time ). fSqlTypeToConversionMap add: ( xif SQL_TYPE_TIME -> #Time ). fSqlTypeFromConversionMap add: ( #Time -> xif SQL_TYPE_TIME ). fCTypeFromConversionMap add: ( #Time -> xif SQL_C_TYPE_TIME ). fetchBufferSizeBlocks add: ( #Time -> [ :ignored | 6 ] ). valueSizeBlocks add: ( #Time -> [ :ignoredValue | 6 ] ). valuePrecisionBlocks add: ( #Time -> [ :ignoredValue | 0 ] ).
initializeTimestampConversions: xif "Conversion from buffer for Timestamp." conversionBufferMap add: (#Timestamp -> UninterpretedBytes). getSelectorMap add: ( #Timestamp -> #getTimestampAt: ). putSelectorMap add: ( #Timestamp -> #at:putTimestamp: ). fSqlTypeToConversionMap add: ( xif SQL_TIMESTAMP -> #Timestamp ). fSqlTypeToConversionMap add: ( xif SQL_TYPE_TIMESTAMP -> #Timestamp ). fSqlTypeFromConversionMap add: ( #Timestamp -> xif SQL_TYPE_TIMESTAMP ). fCTypeFromConversionMap add: ( #Timestamp -> xif SQL_C_TYPE_TIMESTAMP ). fetchBufferSizeBlocks add: ( #Timestamp -> [ :ignored | 16 ] ). valueSizeBlocks add: ( #Timestamp -> [ :ignoredValue | 16 ] ). valuePrecisionBlocks add: ( #Timestamp -> [ :ignoredValue | 0 ] ).
privateInitializeMaps "initSelectorMap := IdentityDictionary new. freeSelectorMap := IdentityDictionary new." getSelectorMap := IdentityDictionary new. putSelectorMap := IdentityDictionary new. fSqlTypeToConversionMap := IdentityDictionary new. fSqlTypeFromConversionMap := IdentityDictionary new. fCTypeFromConversionMap := IdentityDictionary new. fetchBufferSizeBlocks := IdentityDictionary new. valueSizeBlocks := IdentityDictionary new. valuePrecisionBlocks := IdentityDictionary new. conversionBufferMap := IdentityDictionary new.
</methods> <methods> Database.DB2CLIWinInterface class <category>class initialization</category>
initialize super initialize
initializeDefineCaches "This should only be done if the DLLCC development environment is present in the image." "self fillDefineCaches. self fillDefineCaches" "Do twice in case there are longer reference chains."
</methods> <methods> Database.DB2CLILinuxInterface class <category>class initialization</category>
initialize super initialize
</methods> <methods> Database.DB2Buffer <category>private-accessing</category>
at: anIndex "Answer the object in the buffer at anIndex." ^((pcbValue at: (anIndex-1)) == -1 "self xif SQL_NULL_DATA") ifTrue: [ nil ] ifFalse: [ self perform: getSelector with: anIndex ]
at: anIndex put: anObject "Store anObject into the buffer at anIndex." anObject isNil ifTrue: [ pcbValue at: (anIndex-1) put: -1 "self xif SQL_NULL_DATA" ] ifFalse:[ self perform: putSelector with: anIndex with: anObject ]. ^anObject
connection ^connection
connection: aValue connection := aValue
connectionClass ^connection class
hstmt ^hstmt
hstmt: aValue hstmt := aValue
traceLevel ^self connection traceLevel
traceStream ^self connection traceStream
xif ^self connectionClass xif
</methods> <methods> Database.DB2Buffer <category>private-data conversion {put}</category>
at: index putBlobLocator: aBlobLocator "Put anInteger into the buffer" conversionBuffer longAt: 1 put: aBlobLocator locator. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 4 startingAt: 1. pcbValue at: (index-1) put: 4. ^aBlobLocator
at: index putByteArray: aByteArray "Put aByteArray into the buffer." | bytes | (bytes := aByteArray size) > cbColDef ifTrue: [ self rebind: aByteArray. bytes > cbColDef ifTrue: [self connectionClass unableToBindSignal raise] ]. bufferPointer copyAt: ((index-1) * elementSize) from: aByteArray size: bytes startingAt: 1. pcbValue at: (index-1) put: bytes. ^aByteArray
at: index putDate: aDate "Put aDate into the buffer." conversionBuffer shortAt: 1 put: aDate year. conversionBuffer unsignedShortAt: 3 put: aDate monthIndex. conversionBuffer unsignedShortAt: 5 put: aDate dayOfMonth. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 6 startingAt: 1. pcbValue at: (index-1) put: 6. ^aDate
at: index putDouble: aDouble "Put aDouble into the buffer" conversionBuffer doubleAt: 1 put: aDouble. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 8 startingAt: 1. pcbValue at: (index-1) put: 8. ^aDouble
at: index putFixedPoint: aFixedPoint "Put aFixedPoint into the buffer." | strm str bytes | strm := (String new: 40) writeStream. aFixedPoint printOn: strm. strm skip: -1. str := strm contents. "Stick the result into the buffer." bufferPointer copyAt: ((index-1) * elementSize) from: str size: (bytes := str size) startingAt: 1. pcbValue at: (index-1) put: bytes. ibScale := aFixedPoint scale. ^aFixedPoint
at: index putFloat: aFloat "Put aFloat into the buffer" conversionBuffer floatAt: 1 put: aFloat. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 4 startingAt: 1. pcbValue at: (index-1) put: 4. ^aFloat
at: index putInteger: anInteger "Put anInteger into the buffer" conversionBuffer longAt: 1 put: anInteger. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 4 startingAt: 1. pcbValue at: (index-1) put: 4. ^anInteger
at: index putLargeInteger: anInteger "Put anInteger into the buffer" conversionBuffer longLongAt: 1 put: anInteger "bigEndian: UninterpretedBytes isBigEndian". bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 8 startingAt: 1. pcbValue at: (index-1) put: 8. ^anInteger
at: index putString: aString "Put aString into the buffer." | bytes ba str | aString class == Text ifTrue: [str := aString string] ifFalse: [aString class == GapString ifTrue: [str := aString compress string] ifFalse: [str := aString]]. aString size > cbColDef ifTrue: [self rebind: aString. aString size > cbColDef ifTrue: [self connectionClass unableToBindSignal raise]]. ba := ByteArray fromString: str encoding: self encoding. bufferPointer copyAt: (index - 1) * elementSize from: ba size: (bytes := ba size) startingAt: 1. pcbValue at: index - 1 put: bytes. ^aString
at: index putTime: aTime "Put aTime into the buffer" conversionBuffer unsignedShortAt: 1 put: aTime hours. conversionBuffer unsignedShortAt: 3 put: aTime minutes. conversionBuffer unsignedShortAt: 5 put: aTime seconds. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 6 startingAt: 1. pcbValue at: (index-1) put: 6. ^aTime
at: index putTimestamp: aTimestamp "Put aTimestamp into the buffer" conversionBuffer shortAt: 1 put: (aTimestamp year max: 1). conversionBuffer unsignedShortAt: 3 put: aTimestamp month. conversionBuffer unsignedShortAt: 5 put: aTimestamp day. conversionBuffer unsignedShortAt: 7 put: aTimestamp hour. conversionBuffer unsignedShortAt: 9 put: aTimestamp minute. conversionBuffer unsignedShortAt: 11 put: aTimestamp second. conversionBuffer unsignedLongAt: 13 put: aTimestamp millisecond * 1000000. bufferPointer copyAt: ((index-1) * elementSize) from: conversionBuffer size: 16 startingAt: 1. pcbValue at: (index-1) put: 16. ^aTimestamp
at: index putWordArray: aWordArray "Put aWordArray into the buffer." "Currently not yet supported" | octets | aWordArray size > cbColDef ifTrue: [ self connectionClass unableToBindSignal raise ]. bufferPointer copyAt: (index -1 ) from: aWordArray size: (octets := aWordArray basicSize) startingAt: 1. pcbValue at: (index-1) put: octets. ^aWordArray
</methods> <methods> Database.DB2Buffer <category>binding</category>
bindFor: paramType "Binding contents of the receiver to the server." fParamType := self xif perform: paramType. "We won't re-use pointers." (bufferPointer isNil) ifFalse: [ self free ]. "Like bindForInput" self mallocUsingSelector: self xif mallocSelector. self value: bufferValue. self bindInputExternal
bindForInput "Binding contents of the receiver to the server." fParamType := self xif SQL_PARAM_INPUT. "We won't re-use pointers." (bufferPointer isNil) ifFalse: [ self free ]. self mallocUsingSelector: self xif mallocSelector. self value: bufferValue. self bindInputExternal
bindForInputOutput "Binding contents of the receiver to the server." fParamType := self xif SQL_PARAM_INPUT_OUTPUT. "We won't re-use pointers." (bufferPointer isNil) ifFalse: [ self free ]. "Like bindForInput" self mallocUsingSelector: self xif mallocSelector. self value: bufferValue. self bindInputExternal
bindForOutput "Setup the receiver to hold the contents of a single column." fParamType := self xif SQL_PARAM_OUTPUT. "We won't re-use pointers." (bufferPointer isNil) ifFalse: [ self free ]. "Allocate external CPointers." self mallocUsingSelector: self xif mallocSelector. self bindOutputExternal
</methods> <methods> Database.DB2Buffer <category>private-binding</category>
bindInputExternal "Bind the contents of the receiver to the server." | rc xif | xif := self xif. rc := xif SQLBindParameter: self hstmt with: bufferIndex with: fParamType with: self fCType with: self fSqlType with: cbColDef with: self ibScale with: bufferPointer with: elementSize with: pcbValue. self traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLBindParameter( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', ipar='; print: bufferIndex; nextPutAll: ', fParamType='; print: fParamType; nextPutAll: ', fCType='; print: self fCType; nextPutAll: ', fSqlType='; print: self fSqlType; nextPutAll: ', cbParamDef= '; print: cbColDef; nextPutAll: ', ibScale= '; print: ibScale; nextPutAll: ', *rgbValue='; print: bufferValue; nextPutAll: ', cbValueMax='; print: elementSize; nextPutAll: ', *pcbValue='; print: pcbValue contents; nextPutAll: ' )'. self connection class trace: self connection emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: self hstmt. ^self connectionClass unableToBindSignal raiseWith: errs errorString: errs first dbmsErrorString]
bindOutputExternal "Prepare the receiver to automatically receive it's data from the server." | rc xif | xif := self xif. rc := xif SQLBindCol: self hstmt with: bufferIndex with: self fCType with: bufferPointer with: elementSize with: pcbValue. self traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLBindCol( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', icol ='; print: bufferIndex; nextPutAll: ', fCType = '; print: self fCType; nextPutAll: ', rgbValue = '; nextPutAll: (bufferPointer referentAddress printStringRadix: 16); nextPutAll: ', cbValueMax = '; print: elementSize; nextPutAll: ', pcbValue = '; print: (pcbValue referentAddress printStringRadix: 16); nextPutAll: ' )'. self connection class trace: self connection emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: self hstmt. ^self connectionClass unableToBindSignal raiseWith: errs errorString: errs first dbmsErrorString]
rebind: aValue "rebind for a new size" self traceLevel>=3 ifTrue: [ (self traceStream) nextPutAll: ' Rebind parameter from: '; nextPutAll: databaseType printString; nextPutAll: ' to '; nextPutAll: (databaseType:=aValue db2Conversion) printString; nextPutAll: ' size from: ', elementSize printString; nextPutAll: ' to: ', ((ValueSizeBlocks at: databaseType) value: aValue) printString. self connection class trace: self connection emitTrace ]. bufferPointer notNil ifTrue: [bufferPointer freePointer. bufferPointer:=nil]. databaseType:= aValue db2Conversion. elementSize := (ValueSizeBlocks at: databaseType) value: aValue. cbColDef := (ValuePrecisionBlocks at: databaseType) value: aValue. bufferPointer := self pointerType perform: self xif mallocSelector with: (count max: 1). getSelector := GetSelectorMap at: databaseType ifAbsent: [nil]. putSelector := PutSelectorMap at: databaseType ifAbsent: [nil]. conversionBuffer := (ConversionBufferMap at: databaseType) notNil ifTrue: [(ConversionBufferMap at: databaseType) new: elementSize]. self bindInputExternal
</methods> <methods> Database.DB2Buffer <category>accessing</category>
bufferValue ^bufferValue
cbColDef "Answer the precision of the buffer value" ^cbColDef
cbValueMax "Answer the receiver's maximum count (length) in bytes." ^elementSize
fCType "Answer the C data type for the data in this buffer." ^CTypeFromConversionMap at: databaseType
fParamType ^fParamType
fSqlType "Answer the DB2 SQL data type for the data in this buffer." ^SQLTypeFromConversionMap at: databaseType
ibScale ^ibScale
iCol "Answer the receiver external bind index." ^bufferIndex
iCol: anInteger "Set the receiver external bind index." bufferIndex := anInteger.
pcbValue "Answer the receiver's count (length) in bytes pointer." ^pcbValue
rebindOrRaiseFor: aValueOrArray | type | ((type := aValueOrArray db2Conversion) ~~ databaseType and: [aValueOrArray notNil]) ifTrue: [(type == #FileRef or: [type == #DataLink]) ifFalse: [self rebind: aValueOrArray] ifTrue: [DB2Connection unableToBindSignal raise]]
rgbValue "Answer the receiver's buffer pointer." ^bufferPointer
value: aValueOrArray "Store aValueOrArray into the receiver." | size val | (aValueOrArray class name ~= #Array and: [count > 0]) ifTrue: [^DB2Connection unableToBindSignal raise]. count == 0 ifTrue: [self rebindOrRaiseFor: aValueOrArray. ^self at: 1 put: aValueOrArray]. size := aValueOrArray size. size > count ifTrue: [^DB2Connection unableToBindSignal raise]. val := aValueOrArray detect: [:x | x notNil] ifNone: [nil]. self rebindOrRaiseFor: val. 1 to: size do: [:index | self at: index put: (aValueOrArray at: index)]
</methods> <methods> Database.DB2Buffer <category>initialize-release</category>
descriptor: aColDesc position: position session: session "Initialize an instance of receiver which is set up to hold values as described." count := session blockFactor. databaseType := aColDesc type. elementSize := (FetchBufferSizeBlocks at: aColDesc type) value: aColDesc precision . conversionBuffer := (ConversionBufferMap at: databaseType) notNil ifTrue: [(ConversionBufferMap at: databaseType) new: elementSize]. cbColDef := aColDesc precision. bufferIndex := position. connection:= session connection. hstmt := session hstmt. self encoding: session connection encoding. getSelector := GetSelectorMap at: databaseType ifAbsent: [nil]. putSelector := PutSelectorMap at: databaseType ifAbsent: [nil].
on: aValue position: position session: session type: type | maxValue | count := session paramSetSize. ibScale := 0. type isNil ifTrue: [databaseType := session conversionFor: aValue at: position. elementSize := 0. cbColDef := 0 ] ifFalse: [ maxValue:= aValue. databaseType := type "(count > 1 ifTrue: [aValue detect: [ :v | v notNil] ifNone: [nil]] ifFalse: [aValue]) db2Conversion". maxValue:= (count > 0 and: [databaseType == #String or: [databaseType == #ByteArray or: [databaseType == #LargeString or: [databaseType == #LargeByteArray]]]]) ifTrue: [ aValue inject: '' into: [ :currentMax :nextValue | nextValue size > currentMax size ifTrue: [ nextValue ] ifFalse: [ currentMax ] ] ] ifFalse: [aValue]. elementSize := (ValueSizeBlocks at: databaseType) value: maxValue. cbColDef := (ValuePrecisionBlocks at: databaseType) value: maxValue ]. bufferIndex := position. connection:= session connection. hstmt := session hstmt. bufferValue := aValue. self encoding: session connection encoding. getSelector := GetSelectorMap at: databaseType ifAbsent: [nil]. putSelector := PutSelectorMap at: databaseType ifAbsent: [nil]. conversionBuffer := (ConversionBufferMap at: databaseType) notNil ifTrue: [(ConversionBufferMap at: databaseType) new: elementSize].
</methods> <methods> Database.DB2Buffer <category>allocation</category>
free "Free the receiver." pcbValue notNil ifTrue: [ pcbValue freePointer. pcbValue := nil ]. super free.
mallocUsingSelector: mallocSelector "Allocate a physical buffer for the receiver. Use mallocSelector to perform the allocation." [ "Begin unwind protection." super mallocUsingSelector: mallocSelector. pcbValue := CIntegerType long perform: mallocSelector with: (count max: 1). "End unwind protection." ] ifCurtailed: [ self free ]
</methods> <methods> Database.DB2Buffer <category>private-data conversion {get}</category>
getBlobLocatorAt: index "Answer an BlobLocator populated from the buffer." bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 4 startingAt: 1. ^(DB2LOBLocator asType: self databaseType) locator: (conversionBuffer longAt: 1).
getByteArrayAt: index "Answer a ByteArray populated from the buffer." | bytes byteArray | bytes := pcbValue at: (index -1). byteArray := ByteArray new: bytes. bufferPointer copyAt: ((index-1) * elementSize) to: byteArray size: bytes startingAt: 1. ^byteArray
getDateAt: index "Answer a Date populated from the buffer." | year month day | bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 6 startingAt: 1. year := conversionBuffer shortAt: 1. month := conversionBuffer unsignedShortAt: 3. day := conversionBuffer unsignedShortAt: 5. ^Date newDay: day monthNumber: month year: year
getDoubleAt: index "Answer a Double populated from the buffer" bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 8 startingAt: 1. ^conversionBuffer doubleAt: 1
getFixedPointAt: index "Answer a FixedPoint number populated from the buffer" | bytes | bytes := pcbValue at: (index -1). conversionBuffer:=ByteString new: bytes. bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: bytes startingAt: 1. ^FixedPoint "readFrom:" readDB2DecimalFrom: conversionBuffer readStream
getFloatAt: index "Answer a Float populated from the buffer" "Assume: bufferPointer points to at least 4 bytes in the heap." bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 4 startingAt: 1. ^conversionBuffer floatAt: 1
getIntegerAt: index "Answer an Integer populated from the buffer." bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 4 startingAt: 1. ^conversionBuffer longAt: 1
getLargeIntegerAt: index "Answer an Integer populated from the buffer." bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 8 startingAt: 1. ^conversionBuffer longLongAt: 1
getStringAt: index "Answer a String populated from the buffer" "Restore encoding ?" | bytes byteArray | bytes := pcbValue at: (index -1). byteArray := ByteArray new: bytes. bufferPointer copyAt: ((index-1) * elementSize) to: byteArray size: bytes startingAt: 1. ^byteArray asStringEncoding: self encoding
getTimeAt: index "Answer a Time populated from the buffer" | hours minutes seconds | bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 6 startingAt: 1. hours := conversionBuffer unsignedShortAt: 1. minutes := conversionBuffer unsignedShortAt: 3. seconds := conversionBuffer unsignedShortAt: 5. ^Time new hours: hours minutes: minutes seconds: seconds
getTimestampAt: index "Answer a Timestamp populated from the buffer" | year month day hours minutes seconds millisecond ts | bufferPointer copyAt: ((index-1) * elementSize) to: conversionBuffer size: 16 startingAt: 1. year := conversionBuffer shortAt: 1. month := conversionBuffer unsignedShortAt: 3. day := conversionBuffer unsignedShortAt: 5. hours := conversionBuffer unsignedShortAt: 7. minutes := conversionBuffer unsignedShortAt: 9. seconds := conversionBuffer unsignedShortAt: 11. millisecond := ((conversionBuffer unsignedLongAt: 13) / 1000000) rounded. (ts := Timestamp new) year: year; month: month; day: day; hour: hours; minute: minutes; second: seconds; millisecond: millisecond. ^ts
getWordArrayAt: index "Answer a WordArray populated from the buffer." "Currently not yet supported" | bytes wa | bytes := pcbValue at: (index -1). wa := WordArray new: (bytes / 2). bufferPointer copyAt: ((index-1) * elementSize) to: wa size: bytes startingAt: 1. ^wa
</methods> <methods> Database.DB2Buffer <category>private</category>
getSelector ^getSelector
pointerType "Answer the pointer type to use for buffer allocation." | refType | databaseType == #WordArray ifTrue: [ refType := CIntegerType unsignedShort ] ifFalse: [ refType := CIntegerType char ]. ^CArrayType defaultPointer referentType: refType; numElements: elementSize.
putSelector ^putSelector
</methods> <methods> Database.DB2Buffer <category>testing</category>
isFileRefObject ^false
isLargeObject ^false
</methods> <methods> Database.DB2Buffer class <category>accessing</category>
connectionClass ^DB2Connection
datalinkBufferClass ^DB2DataLinkBuffer
fileRefBufferClass ^DB2FileRefBuffer
largeObjectBufferClass ^DB2LargeObjectBuffer
</methods> <methods> Database.DB2Buffer class <category>private-instance creation</category>
descriptor: aColDesc position: position session: session "Create an appropriate instance of an DB2Buffer which is set up to hold values as described." ^(aColDesc isLong) ifTrue: [self largeObjectBufferClass basicNew descriptor: aColDesc position: position session: session] ifFalse: [aColDesc fileRef notNil ifTrue: [DB2FileRefBuffer basicNew descriptor: aColDesc position: position session: session] ifFalse: [aColDesc type == #DataLink ifTrue: [DB2DataLinkBuffer basicNew descriptor: aColDesc position: position session: session] ifFalse: [self basicNew descriptor: aColDesc position: position session: session ]]].
on: aValue position: position session: session "Create an appropriate instance of an DB2Buffer which is set up to hold values as described." | db2Conversion bufferClass | "db2Conversion := (aValue class == Array ifTrue: [aValue detect: [ :v | v notNil] ifNone: [nil]] ifFalse: [aValue]) db2Conversion." db2Conversion := session conversionFor: aValue at: position. bufferClass := ( db2Conversion == #LargeByteArray or: [ db2Conversion == #LargeString ] ) ifTrue: [self largeObjectBufferClass] ifFalse: [db2Conversion == #FileRef ifTrue: [self fileRefBufferClass ] ifFalse: [ db2Conversion == #DataLink ifTrue: [self datalinkBufferClass] ifFalse: [self ]]]. ^bufferClass basicNew on: aValue position: position session: session type: db2Conversion
</methods> <methods> Database.DB2Buffer class <category>class initialization</category>
initialize "DB2Buffer initialize" self install
</methods> <methods> Database.DB2Buffer class <category>private-activation</category>
install | ifcClass | (ifcClass := self connectionClass interfaceClass) notNil ifTrue: [ConversionBufferMap := ifcClass conversionBufferMap. GetSelectorMap := ifcClass getSelectorMap. PutSelectorMap := ifcClass putSelectorMap. SQLTypeFromConversionMap := ifcClass fSqlTypeFromConversionMap. CTypeFromConversionMap := ifcClass fCTypeFromConversionMap. FetchBufferSizeBlocks := ifcClass fetchBufferSizeBlocks. ValueSizeBlocks := ifcClass valueSizeBlocks. ValuePrecisionBlocks := ifcClass valuePrecisionBlocks ].
</methods> <methods> Database.DB2Buffer class <category>instance creation</category>
new ^self error: 'An DB2Buffer is created and privately used by an instance of DB2Session.'
</methods> <methods> Database.DB2Buffer class <category>filein/fileout</category>
prerequisitesForLoading "The receiver requires DB2Connection to have initialized its interface mapping before it initializes." ^super prerequisitesForLoading addLast: DB2Connection; addAll: DB2CLIInterface withAllSubclasses; yourself
</methods> <methods> Database.DB2FileRefBuffer <category>private-accessing</category>
at: anIndex put: anObject "Store anObject into the buffer at anIndex." anObject isNil ifTrue: [ pcbValue contents: self xif SQL_NULL_DATA ] ifFalse:[pcbValue contents: 0. "not null data " self perform: putSelector with: anIndex with: anObject ]. ^anObject
fileReadOption ^self xif SQL_FILE_READ
fSqlType "Answer the DB2 SQL data type for the data in this buffer." "Assume: all DB2LOBFileRef's instances same dataType " count == 0 ifTrue: [^SQLTypeFromConversionMap at: bufferValue dataType]. ^SQLTypeFromConversionMap at: (bufferValue first ) dataType
</methods> <methods> Database.DB2FileRefBuffer <category>private-data conversion {put}</category>
at: index putFileRef: aFileRef "Put aString into the buffer." | str bytes aString | aString:=aFileRef fileName. str := aString asByteArrayEncoding: self encoding. bufferPointer copyAt: (index -1)*elementSize from: str size: (bytes := str size) startingAt: 1. bufferLengthPointer at: (index-1) put: bytes. fileOptionsPointer at: (index-1) put: self fileReadOption. ^aFileRef
</methods> <methods> Database.DB2FileRefBuffer <category>private-binding</category>
bindInputExternal "Bind the contents of the receiver to the server." | rc xif | xif := self xif. rc := xif SQLBindFileToParam: self hstmt with: bufferIndex with: self fSqlType with: bufferPointer with: bufferLengthPointer with: fileOptionsPointer with: elementSize with: pcbValue. "dataType" self traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLBindFileToParam( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', ipar='; print: bufferIndex; nextPutAll: ', dataType='; print: self fCType; nextPutAll: ', bufferLength='; print: bufferLengthPointer contents; nextPutAll: ', fileOptions= '; print: fileOptionsPointer contents; nextPutAll: ', *rgbValue='; print: bufferValue; nextPutAll: ', cbValueMax='; print: elementSize; nextPutAll: ', *pcbValue='; print: pcbValue contents; nextPutAll: ' )'. self connection class trace: self connection emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: self hstmt. ^self connectionClass unableToBindSignal raiseWith: errs errorString: errs first dbmsErrorString]
bindOutputExternal "Prepare the receiver to automatically receive it's data from the server." | rc xif | xif := self xif. rc := xif SQLBindFileToCol: self hstmt with: bufferIndex with: bufferPointer with: bufferLengthPointer with: fileOptionsPointer with: elementSize with: nil with: pcbValue. self traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLBindFileToCol( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', icol ='; print: bufferIndex; nextPutAll: ', rgbValue = '; nextPutAll: (bufferPointer referentAddress printStringRadix: 16); nextPutAll: ', elementSize = '; print: elementSize; nextPutAll: ', pcbValue = '; print: (pcbValue referentAddress printStringRadix: 16); nextPutAll: ' )'. self connection class trace: self connection emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: self hstmt. ^self connectionClass unableToBindSignal raiseWith: errs errorString: errs first dbmsErrorString]
updateFileNameInfo: index | str bytes | bufferValue computeFileName. str := bufferValue fileName asByteArrayEncoding: self encoding. bufferPointer copyAt: ((index -1)*elementSize) from: str size: (bytes := str size) startingAt: 1. bufferLengthPointer at: (index -1) put: bytes. fileOptionsPointer at: (index -1) put: (self xif perform: bufferValue fileOptions).
updateFileRefInfo 1 to: count do: [ :index | self updateFileNameInfo: index ].
</methods> <methods> Database.DB2FileRefBuffer <category>initialize-release</category>
descriptor: aColDesc position: position session: session "Initialize an instance of receiver which is set up to hold values as described." count := session blockFactor. "databaseType := aColDesc dataType." "i.e. #Blob or #Clob" elementSize := 256. "max file name length" bufferIndex := position. connection:= session connection. hstmt := session hstmt. bufferValue := aColDesc fileRef. self encoding: session connection encoding. getSelector := GetSelectorMap at: #FileRef ifAbsent: [nil]. putSelector := PutSelectorMap at: #FileRef ifAbsent: [nil].
on: aValue position: position session: session type: type "Initialize an instance of receiver which is set up to hold aValue." count := session paramSetSize. ibScale := 0. databaseType := type. "aValue dataType" "i.e. #Blob or #Clob" elementSize := 256. "max file name length" bufferIndex := position. connection:= session connection. hstmt := session hstmt. bufferValue := aValue. self encoding: session connection encoding. getSelector := GetSelectorMap at: #FileRef ifAbsent: [nil]. putSelector := PutSelectorMap at: #FileRef ifAbsent: [nil].
</methods> <methods> Database.DB2FileRefBuffer <category>allocation</category>
free "Free the receiver." fileOptionsPointer notNil ifTrue: [fileOptionsPointer freePointer. fileOptionsPointer := nil]. bufferLengthPointer notNil ifTrue: [bufferLengthPointer freePointer. bufferLengthPointer := nil]. super free
mallocUsingSelector: mallocSelector "Allocate a physical buffer for the receiver. Use mallocSelector to perform the allocation." [ "Begin unwind protection." super mallocUsingSelector: mallocSelector. bufferLengthPointer := CIntegerType short "SQLSMALLINT" perform: mallocSelector with: (count max: 1). fileOptionsPointer := CIntegerType unsignedLong "SQLUINTEGER" perform: mallocSelector with: (count max: 1). "End unwind protection." ] ifCurtailed: [ self free ]
</methods> <methods> Database.DB2FileRefBuffer <category>private-data conversion {get}</category>
getFileRefAt: index ^#FileRef
</methods> <methods> Database.DB2FileRefBuffer <category>testing</category>
isFileRefObject ^true
</methods> <methods> Database.DB2LOBFileReference <category>accessing</category>
appendToFile fileOptions:=#SQL_FILE_APPEND
compute: aBlock computeBlock:=aBlock
computeFileName computeBlock notNil ifTrue: [fileName:=computeBlock value: fileName]. ^fileName
createFile fileOptions:=#SQL_FILE_CREATE
dataType ^dataType
dataType: aDb2Conversion dataType:=aDb2Conversion
fileName ^fileName
fileName: aString fileName:=aString
fileOptions ^fileOptions
forBLOB self dataType: #LargeByteArray
forCLOB self dataType: #LargeString
overwriteFile fileOptions:=#SQL_FILE_OVERWRITE
value ^self
</methods> <methods> Database.DB2LOBFileReference <category>private-db2</category>
db2Conversion ^#FileRef
</methods> <methods> Database.DB2LOBFileReference <category>initialize</category>
initialize fileName:='lobfile.bin'. self createFile
</methods> <methods> Database.DB2LOBFileReference class <category>instance creation</category>
for: aFileName ^self new fileName: aFileName
forBLOB: aFileName ^self new fileName: aFileName; dataType: #LargeByteArray
forCLOB: aFileName ^self new fileName: aFileName; dataType: #LargeString
new ^super new initialize
</methods> <methods> Database.DB2DataSource <category>accessing</category>
description ^description
description: aString description := aString
name ^name
name: aString name := aString
</methods> <methods> Database.DB2DataSource <category>printing</category>
printOn: aStream super printOn: aStream. aStream nextPutAll: '( DSN ='; print: self name; nextPutAll: ', Description = '; print: self description; nextPutAll: ' )'
</methods> <methods> Database.DB2LOBLocator <category>private-db2</category>
db2Conversion self subclassResponsibility
locatorCType self subclassResponsibility
printOn: aStream super printOn: aStream. aStream nextPut: $(. locator notNil ifTrue: [aStream nextPutAll: locator printString]. aStream nextPut: $).
targetCType "need for SQLGetSubString " self subclassResponsibility
</methods> <methods> Database.DB2LOBLocator <category>accessing</category>
locator ^locator
locator: aValue locator := aValue
</methods> <methods> Database.DB2LOBLocator class <category>instance creation</category>
asBLOBLocator ^DB2BLOBLocator new
asCLOBLocator ^DB2CLOBLocator new
asType: type ^type == #BlobLocator ifTrue: [DB2BLOBLocator new] ifFalse: [type == #ClobLocator ifTrue: [DB2CLOBLocator new] ifFalse: [^self halt: 'Bad locator type' ] ]
recordTemplate ^self new
</methods> <methods> Database.DB2LOBLocator class <category>private</category>
locatorTypeFor: type ^type == #LargeByteArray ifTrue: [#BlobLocator ] ifFalse: [type == #LargeString ifTrue: [#ClobLocator ] ifFalse: [self error: 'bad LOB type']]
</methods> <methods> Database.DB2CLOBLocator <category>private-db2</category>
db2Conversion ^#ClobLocator
locatorCType ^41 "SQL_C_CLOB_LOCATOR"
targetCType "need for SQLGetSubString " ^1 "SQL_C_CHAR"
</methods> <methods> Database.DB2Manager <category>api-calls</category>
attachTo: aNode username: aUsername password: aPassword "self attachTo: 'NTSERV00' username: 'avb2' password: 'anton' " | xif rc pSqlca szUser szPassword szNode | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. szUser:=aUsername copyToHeap. szPassword:=aPassword copyToHeap. szNode:=aNode copyToHeap. rc := xif sqleatin_api: szNode with: szUser with: szPassword with: pSqlca. self sqlInfoPrint: 'attach to ', aNode, ' user ', aUsername sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]. szUser notNil ifTrue: [szUser free]. szPassword notNil ifTrue: [szPassword free]. szNode notNil ifTrue: [szNode free]]
closeDDS: aHandle "" | xif rc pSqlca | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. rc := xif sqledcls_api: aHandle with: pSqlca. self sqlInfoPrint: 'close database directory scan ', aHandle printString sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]]
databaseEntryOf: anAlias "self databaseEntryOf: 'SAMPLE' " | r handle count i a | r:=self openDDS: ''. [ handle := r first. count:=r last. i:= 0. a:=''. [i < count and: [anAlias~= a ] ] whileTrue: [a:=((r:=self getNextDBDirectoryEntry: handle) at: #alias) copyWithout: $ . i:=i+1. ]. anAlias~= a ifTrue: [^nil]. "Alias not found" ^r ] ensure: [ self closeDDS: handle ]
detach "self detach" | xif rc pSqlca | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. rc := xif sqledtin_api: pSqlca. self sqlInfoPrint: 'detach ' sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ] ]
errorClass ^DB2Error
forceApplicationAll "self forceApplicationAll" | xif pSqlca rc | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. rc := xif sqlefrce_api: xif SQL_ALL_USERS with: nil with: xif SQL_ASYNCH with: pSqlca. self sqlInfoPrint: 'force application all' sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]]
getNextDBDirectoryEntry: aHandle "" | xif rc pSqlca resultArray ppDbDirEntry t | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. ppDbDirEntry:=(CPointerType defaultPointer referentType: xif sqledinfo) malloc: 1. rc := xif sqledgne_api: aHandle with: ppDbDirEntry with: pSqlca. self sqlInfoPrint: 'get next database directory entry' sqlca: pSqlca. resultArray := Dictionary new: 14. t:=ppDbDirEntry contents contents. #(alias dbname drive intname nodename dbtype comment ) do: [:x | resultArray at: x put: ((t memberAt: x) datum stringAt: 1)]. " ugly " #(authentication cat_nodenum nodenum type) do: [:x | resultArray at: x put: (t memberAt: x) ]. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]. ppDbDirEntry notNil ifTrue: [ppDbDirEntry freePointer]]. ^resultArray
instanceNameOf: anAlias "self instanceNameOf: 'SAMPLE' " | e | ((e:=self databaseEntryOf: anAlias asUppercase) at: #type) == 48 ifTrue: [^nil]. "local instance" ^e at: #nodename
openDDS: aPath "" | xif rc pSqlca szPath pHandle pNumEntries resultArray | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. szPath:=aPath copyToHeap. pHandle:=CIntegerType short malloc: 1. pNumEntries:=CIntegerType short malloc: 1. rc := xif sqledosd_api: szPath with: pHandle with: pNumEntries with: pSqlca. self sqlInfoPrint: 'open database directory scan ' sqlca: pSqlca. resultArray := Array with: pHandle contents with: pNumEntries contents. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]. szPath notNil ifTrue: [ szPath freePointer ]. pHandle notNil ifTrue: [ pHandle freePointer ]. pNumEntries notNil ifTrue: [pNumEntries freePointer]]. ^resultArray
restartDatabase: aDatabase username: aUsername password: aPassword "self restartDatabase: 'sample' username: 'avb2' password: 'anton' " | xif rc pSqlca pParamStruct szUser szPassword szDatabase | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. pParamStruct:= xif db2RestartDbStruct perform: xif mallocSelector with: 1. szUser:=aUsername copyToHeap. szPassword:=aPassword copyToHeap. szDatabase:=aDatabase copyToHeap. pParamStruct memberAt: #piDatabaseName put: szDatabase; memberAt: #piUserId put: szUser; memberAt: #piPassword put: szPassword; memberAt: #piTablespaceNames put: nil. rc := xif db2DatabaseRestart: xif db2Version with: pParamStruct with: pSqlca. self sqlInfoPrint: 'restart database ' sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]. szUser notNil ifTrue: [szUser free]. szPassword notNil ifTrue: [szPassword free]. szDatabase notNil ifTrue: [szDatabase free]. pParamStruct notNil ifTrue: [pParamStruct free]]
runStats: aTable statsOption: anOption shared: aBoolean indexes: anIndexes "self runStats: 'AVB.EMPLOYEE' statsOption: #SQL_STATS_ALL shared: true indexes: nil" | xif pSqlca pTableName shareLevel rc | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. pTableName:= aTable copyToHeap. shareLevel:= aBoolean ifTrue: [xif SQL_STATS_CHG] ifFalse: [xif SQL_STATS_REF]. rc := xif sqlustat_api: pTableName with: 0 "numIndexes - ALL" with: nil with: (xif perform: anOption) with: shareLevel with: pSqlca. self sqlInfoPrint: 'runstats on ', aTable sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]. pTableName notNil ifTrue: [pTableName free]]
startDatabaseManager "self startDatabaseManager" | xif rc pSqlca | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. rc := xif sqlepstart_api: nil with: pSqlca. self sqlInfoPrint: 'start database manager' sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]]
stopDatabaseManager "self stopDatabaseManager" | xif rc pSqlca | xif := self xif. [ "Begin unwind protection." pSqlca := xif sqlca perform: xif mallocSelector with: 1. rc := xif sqlepstp_api: nil with: pSqlca. self sqlInfoPrint: 'stop database manager' sqlca: pSqlca. "End unwind protection." ] ensure: [ pSqlca notNil ifTrue: [ pSqlca freePointer ]]
</methods> <methods> Database.DB2Manager <category>private</category>
sqlInfoPrint: aMessage sqlca: pSqlca "Converted from util.c" | rc sqlInfo errorMsg sqlCode sqlstateMsg error xif | ["Begin unwind protection" xif := self xif. sqlstateMsg := CIntegerType char perform: xif mallocSelector with: 1024. errorMsg := CIntegerType char perform: xif mallocSelector with: 1024. ((sqlCode:=pSqlca memberAt: #sqlcode) ~= 0 and: [sqlCode~= 100]) ifTrue: [ sqlInfo := ReadWriteStream on: (String new: 600). sqlInfo nextPutAll: ' app. message = '; nextPutAll: aMessage; cr. sqlInfo nextPutAll: (sqlCode < 0 ifTrue: ['\-- error report --\'] ifFalse: ['\---- warning report ----\']) withCRs . sqlInfo nextPutAll: 'SQLCODE = '; nextPutAll: sqlCode printString; cr. " get error message " rc := xif sqlaintp: errorMsg with: 1024 with: 255 with: pSqlca. "return code is the length of the errorMsg string " rc > 0 ifTrue: [sqlInfo nextPutAll: (errorMsg copyCStringFromHeap)]. "get SQLSTATE message " rc := xif sqlogstt: sqlstateMsg with: 1024 with: 255 with: (pSqlca memberAt: #sqlstate). rc > 0 ifTrue: [sqlInfo nextPutAll: (sqlstateMsg copyCStringFromHeap)]. sqlInfo nextPutAll: (sqlCode < 0 ifTrue: ['-- end error report --'] ifFalse: ['---- end warning report ----']) ]. sqlInfo notNil ifTrue: [error := self class errorClass new. error dbmsErrorCode: sqlCode. error dbmsErrorString: sqlInfo contents. error sqlState: (pSqlca memberAt: #sqlstate) copyCStringFromHeap. Transcript show: sqlInfo contents; cr.]. "End unwind protection"] ensure: [ sqlstateMsg notNil ifTrue: [ sqlstateMsg freePointer ]. errorMsg notNil ifTrue: [ errorMsg freePointer ] ]. ^error
xif ^self class xif
</methods> <methods> Database.DB2Manager class <category>private-accessing</category>
connectionClass ^DB2Connection
errorClass ^DB2Error
xif "Answer the ExternalInterface subclass instance to use." ^self connectionClass apiXif
</methods> <methods> Database.DB2Manager class <category>instance-creation</category>
new singleton isNil ifTrue: [singleton:=self basicNew]. ^singleton
</methods> <methods> Database.DB2APIWinInterface <category>structs</category>
sqledinfo "NT version drive[12]" <C: struct sqledinfo { char alias[8]; char dbname[8]; char drive[12]; char intname[8]; char nodename[8]; char dbtype[20]; char comment[30]; short com_codepage; char type; unsigned short authentication; char glbdbname[255]; char dceprincipal[1024]; short cat_nodenum, nodenum; }>
</methods> <methods> Database.DB2DataLinkBuffer <category>private-data conversion {put}</category>
at: index putDataLink: aDataLink | str bytes | self makeDataLink: aDataLink at: index. "Now we have bufferPointer & pcbValue already " "str := aDataLink asByteArrayEncoding: self encoding. bufferPointer copyAt: (index -1) from: str size: (bytes := str size) startingAt: 1. pcbValue contents: bytes." ^aDataLink
</methods> <methods> Database.DB2DataLinkBuffer <category>initialize-release</category>
descriptorOLD: aColDesc position: position session: session "Initialize an instance of receiver which is set up to hold values as described." super descriptor: aColDesc position: position session: session. true ifTrue: [^self]. count := session blockFactor. databaseType := aColDesc type. elementSize := 256. "max file name length" bufferIndex := position. connection:= session connection. hstmt := session hstmt. self encoding: session connection encoding. getSelector := GetSelectorMap at: #DataLink ifAbsent: [nil]. putSelector := PutSelectorMap at: #DataLink ifAbsent: [nil].
</methods> <methods> Database.DB2DataLinkBuffer <category>allocation</category>
free "Free the receiver." valuePointer notNil ifTrue: [ valuePointer freePointer. valuePointer := nil ]. linkTypePointer notNil ifTrue: [ linkTypePointer freePointer. linkTypePointer := nil ]. commentPointer notNil ifTrue: [ commentPointer freePointer. commentPointer := nil ]. stringLengthPointer notNil ifTrue: [ stringLengthPointer freePointer. stringLengthPointer := nil ]. super free.
mallocUsingSelector: mallocSelector "Allocate a physical buffer for the receiver. Use mallocSelector to perform the allocation." | xif | [ "Begin unwind protection." xif := self xif. super mallocUsingSelector: mallocSelector. valuePointer := xif SQLCHAR perform: mallocSelector with: elementSize. stringLengthPointer := xif SQLINTEGER perform: mallocSelector with: 1. commentPointer := xif SQLCHAR perform: mallocSelector with: elementSize. linkTypePointer := 'URL' copyToHeap. "End unwind protection." ] ifCurtailed: [ self free ]
</methods> <methods> Database.DB2DataLinkBuffer <category>private-data conversion {get}</category>
getDataLinkAt: index "Answer a DataLink populated from the buffer" | bytes byteArray dl | bytes := pcbValue at: (index -1). byteArray := ByteString new: bytes. bufferPointer copyAt: ((index-1) * elementSize) to: byteArray size: bytes startingAt: 1. (dl:=DB2DataLink new) dlValue: byteArray. "asStringEncoding: self encoding" self getDLAttributes: dl at: index. ^dl
</methods> <methods> Database.DB2DataLinkBuffer <category>private</category>
getDLAttribute: attributeName for: aDataLink at: index | xif attr rc bytes attrString | xif := self xif. attr := xif perform: attributeName. rc := xif SQLGetDataLinkAttr: connection blobHstmt with: attr with: (bufferPointer refAt: (index - 1) * elementSize) with: aDataLink dlValue size with: valuePointer with: elementSize with: stringLengthPointer. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: connection blobHstmt. ^self connectionClass unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. stringLengthPointer isNull ifTrue: [^nil]. bytes := stringLengthPointer contents. attrString := ByteString new: bytes. valuePointer copyAt: 0 to: attrString size: bytes startingAt: 1. ^attrString
getDLAttributes: aDataLink at: index "Note: SQL_ATTR_DATALINK_LINKTYPE answer always 'URL' , may be add SQL_ATTR_DATALINK_URLPATH ?" aDataLink comment: (self getDLAttribute: #SQL_ATTR_DATALINK_COMMENT for: aDataLink at: index); complete: (self getDLAttribute: #SQL_ATTR_DATALINK_URLCOMPLETE for: aDataLink at: index); pathOnly: (self getDLAttribute: #SQL_ATTR_DATALINK_URLPATHONLY for: aDataLink at: index); server: (self getDLAttribute: #SQL_ATTR_DATALINK_URLSERVER for: aDataLink at: index); scheme: (self getDLAttribute: #SQL_ATTR_DATALINK_URLSCHEME for: aDataLink at: index).
makeDataLink: aDataLink at: index | xif rc bytes dlString | xif := self xif. valuePointer copyAt: 0 from: aDataLink dataLocation size: aDataLink dataLocation size startingAt: 1. aDataLink comment notNil ifTrue: [commentPointer copyAt: 0 from: aDataLink comment size: aDataLink comment size startingAt: 1] ifFalse: [commentPointer contents: nil]. rc := xif SQLBuildDataLink: connection blobHstmt with: linkTypePointer with: 3 with: valuePointer with: aDataLink dataLocation size with: commentPointer with: aDataLink comment size with: (bufferPointer refAt: (index - 1) * elementSize) with: elementSize with: (pcbValue refAt: index - 1). " 'URL' size" "DataLinkBuffer" "stringLengthPointer" rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getStatementErrors: connection blobHstmt. ^self connectionClass unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. stringLengthPointer isNull ifTrue: [self halt]. "now set dlValue" bytes := pcbValue at: index - 1. dlString := ByteString new: bytes. bufferPointer copyAt: (index - 1) * elementSize to: dlString size: bytes startingAt: 1. aDataLink dlValue: dlString
</methods> <methods> Database.DB2DataLink <category>comparing</category>
= aDatalink ^self class = aDatalink class and: [self pathOnly = aDatalink pathOnly and: [(self scheme sameAs: aDatalink scheme) and: [self comment = aDatalink comment and: [(self server sameAs: aDatalink server)]]]]
hash "Modify the hash method to be based on the path and comment combined." ^(((self pathOnly hash bitShift: 3) bitXor: self comment hash) bitXor: self server hash) bitXor: self scheme hash
</methods> <methods> Database.DB2DataLink <category>accessing</category>
comment ^comment notNil ifTrue: [comment] ifFalse: [comment:=String new]
comment: aString comment:= aString
complete ^complete
complete: aString complete:= aString
dataLocation ^(String new: dlValue size) writeStream nextPutAll: self schemeAsUrl; nextPutAll: (server notNil ifTrue: [server] ifFalse: ['']); nextPutAll: (pathOnly notNil ifTrue: [pathOnly] ifFalse: ['']); contents
dlValue ^dlValue
dlValue: aDataLink dlValue:= aDataLink
path ^path
path: aString path:= aString
pathOnly ^pathOnly
pathOnly: aString pathOnly:= aString
scheme ^scheme
scheme: aString scheme:=aString
schemeAsUrl ^scheme notNil ifTrue: [scheme, '://' ] ifFalse: ['']
server ^server
server: aString server:= aString
</methods> <methods> Database.DB2DataLink <category>private-db2</category>
db2Conversion ^#DataLink
</methods> <methods> Database.DB2DataLink <category>private</category>
getDLAttributes: aConnection "Note: SQL_ATTR_DATALINK_LINKTYPE answer always 'URL' , may be add SQL_ATTR_DATALINK_URLPATH ?" self comment: (aConnection getDLAttribute: #SQL_ATTR_DATALINK_COMMENT for: self); complete: (aConnection getDLAttribute: #SQL_ATTR_DATALINK_URLCOMPLETE for: self); pathOnly: (aConnection getDLAttribute: #SQL_ATTR_DATALINK_URLPATHONLY for: self); server: (aConnection getDLAttribute: #SQL_ATTR_DATALINK_URLSERVER for: self); scheme: (aConnection getDLAttribute: #SQL_ATTR_DATALINK_URLSCHEME for: self).
initialize needBuild := true
printOn: aStream aStream nextPutAll: 'DL('; nextPutAll: self dataLocation. comment notNil ifTrue: [ aStream nextPutAll: ' Comment: '; nextPutAll: comment]. aStream nextPut: $)
</methods> <methods> Database.DB2DataLink class <category>instance creation</category>
recordTemplate ^self new
</methods> <methods> Database.DB2Error <category>accessing</category>
sqlState ^sqlState
sqlState: anInteger sqlState := anInteger
</methods> <methods> Database.DB2Session <category>private-answer set</category>
aboutToAnswer "Do last-minute work before fetching data from an answer set" totalRows := 0. rowsInBlock := self blockFactor. currentRowIndex := self blockFactor. self checkRowSetSize.
advanceExternal "Advance to the next row in the block buffer. If the buffer is exhausted, refill it and continue." self currentRowIndex: (self currentRowIndex + 1). self currentRowIndex > self rowsInBlock ifTrue: [ self rowsInBlock < self blockFactor ifTrue: [ ^nil "No more rows will be found" ]. self updateFileRefs. self getBlockOfRowsExternal. self rowsInBlock <= 0 ifTrue: [ ^nil "No more rows will be found" ]. self currentRowIndex: 1 ]. ^self
advanceExternal: fetchOrientation offset: fetchOffset "Advance to the next row in the block buffer. If the buffer is exhausted, refill it and continue." fetchOrientation == self fetchNextMode ifTrue: [ self currentRowIndex: (self currentRowIndex + 1). ] ifFalse: [ fetchOrientation == self fetchPriorMode ifTrue: [ self currentRowIndex: (self currentRowIndex - 1). ] ifFalse: [ fetchOrientation == self fetchAbsoluteMode ifTrue: [ self currentRowIndex: (self blockFactor + 2). self rowsInBlock: (self blockFactor + 1). ] ifFalse: [ fetchOrientation == self fetchRelativeMode ifTrue: [ self currentRowIndex: (self currentRowIndex + fetchOffset). ]. ]. ]. ]. ((self currentRowIndex > self rowsInBlock) or: [ self currentRowIndex <= 0 ]) ifTrue: [ self updateFileRefs. self getBlockOfRowsExternal: fetchOrientation offset: fetchOffset. self rowsInBlock <= 0 ifTrue: [ ^nil "No more rows will be found" ]. fetchOrientation == self fetchPriorMode ifTrue: [ self currentRowIndex: self rowsInBlock . ] ifFalse: [ self currentRowIndex: 1. ]. ]. ^self
allocateFetchedPointer | xif p | ["Begin unwind protection." xif := self class xif. self pRowsFetched: (p := xif SQLUINTEGER perform: xif mallocSelector with: 1). self setStatementAttribute: #SQL_ATTR_ROWS_FETCHED_PTR value: p. rowStatus := xif SQLUINTEGER perform: xif mallocSelector with: blockFactor. self setStatementAttribute: #SQL_ATTR_ROW_STATUS_PTR value: rowStatus. ] ifCurtailed: [p notNil ifTrue: [p freePointer]. rowStatus notNil ifTrue: [rowStatus freePointer]. ]
allocateRowBufferExternal: aColumn "Answer a DB2Buffer allocated for holding one column's worth of information as returned by the DB2 CLI." | aColDescription buffer | aColDescription := columnDescriptions at: aColumn. "An appropriate buffer class for the result column will be choosen automatically." buffer := self class bufferClass descriptor: aColDescription position: aColumn session: self. buffer bindForOutput. ^buffer
answerOfClass: anAnswerStreamClass "Answer an instance of the given subclass of ExternalDatabaseAnswerStream" "Assert: anAnswerStreamClass isKindOf: ExternalDatabaseAnswerStream" | initialAnswer | initialAnswer := ( self state == #ready ). self state: #validResults. initialAnswer ifTrue: [ "Verify that the query executed without error." self resultsExternal ] ifFalse: [ "If we're still holding on to a prior answer stream, dismiss it." answerStream notNil ifTrue: [ answerStream close ]. "Temporary ! Cursor must be closed in 'moreResultsExternal' " "Assert: self state == #validResults" self moreResultsExternal ifFalse: [ self state: #prepared. ^#noMoreAnswers ] ]. self hasAnswerSetExternal ifTrue: [ | answer | initialAnswer ifFalse: [ "Previous descriptions/buffers are no longer valid" self releaseBuffers. self releaseAdaptors. self columnDescriptions: nil ]. self getColumnDescriptions. self acquireBuffers. self setupAdaptors. self aboutToAnswer. answer := anAnswerStreamClass newForSession: self. self answerStream: answer. self state: #fetchingData. ^answer ]. ^#noAnswerStream.
answerStreamDismissed "Close the cursor and discard pending results." "self freeStatementExternal: #SQL_CLOSE." " We must defer closing of cursor up to next execute call " deferCursorClosing ifFalse: [self closeCursor] ifTrue: [ self mustCloseCursor: true]. super answerStreamDismissed. "self handleAutoCommit"
cancelAnswerSetExternal "Nothing more to do here." ^self "self xif SQLCancel: self hstmt"
checkRowSetSize "Check and set row set size" | old | old:=self sqlStatementAttributeCache at: #SQL_ATTR_ROW_ARRAY_SIZE ifAbsent: [1]. old = blockFactor ifTrue: [^true] ifFalse: [self setStatementAttribute: #SQL_ATTR_ROW_ARRAY_SIZE value: blockFactor].
describeAnswerColumns "Fill in the columnDescriptions array." | xif descrs cbColNameMax columnDescriptionClass szColName pcbColName pfSqlType pcbColDef pibScale pfNullable rc precision colDesc dt | xif := self class xif. descrs := Array new: self numColumns. cbColNameMax := self connection getInformationType: #SQL_MAX_COLUMN_NAME_LEN. columnDescriptionClass := self connection class columnDescriptionClass. ["Begin unwind protection." szColName := xif SQLCHAR perform: xif mallocSelector with: cbColNameMax. pcbColName := xif SQLSMALLINT perform: xif mallocSelector with: 1. pfSqlType := xif SQLSMALLINT perform: xif mallocSelector with: 1. pcbColDef := xif SQLUINTEGER perform: xif mallocSelector with: 1. pibScale := xif SQLSMALLINT perform: xif mallocSelector with: 1. pfNullable := xif SQLSMALLINT perform: xif mallocSelector with: 1. 1 to: self numColumns do: [:aColumn | rc := xif SQLDescribeCol: self hstmt with: aColumn with: szColName with: cbColNameMax with: pcbColName with: pfSqlType with: pcbColDef with: pibScale with: pfNullable. precision := pcbColDef contents. traceLevel >= 2 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLDescribeCol( hstmt='; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', icol ='; print: aColumn; nextPutAll: ', szColName: '; print: szColName copyCStringFromHeap; nextPutAll: ', cbColName: '; print: pcbColName contents; nextPutAll: ', fSQLType: '; print: pfSqlType contents; nextPutAll: ', cbColDef: '; print: precision; nextPutAll: ', ibScale: '; print: pibScale contents; nextPutAll: ', fNullable: '; print: pfNullable contents; nextPutAll: ' )'. self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. ^self class connectionClass unableToDescribeSignal raiseWith: errs errorString: errs first dbmsErrorString]. (colDesc := columnDescriptionClass new) index: aColumn; name: szColName copyCStringFromHeap; fSqlType: pfSqlType contents; nullable: pfNullable contents == xif SQL_NULLABLE. dt := xif class fSqlTypeToConversionMap at: colDesc fSqlType. (self answerLOBValues not and: [dt == #LargeByteArray or: [dt == #LargeString]]) ifTrue: [self answerLocators ifTrue: [colDesc fSqlType: (xif class fSqlTypeFromConversionMap at: (dt := DB2LOBLocator locatorTypeFor: dt)); type: dt; maxColumnConstraint: 4; precision: 4; scale: 0] ifFalse: ["answer FileRef" colDesc fSqlType: nil; type: #FileRef; fileRef: answerBlob; maxColumnConstraint: precision; precision: precision; scale: 0 "pfSqlType contents"]] ifFalse: [colDesc type: dt; maxColumnConstraint: precision; precision: precision; scale: pibScale contents]. descrs at: aColumn put: colDesc] "End unwind protection."] ensure: [szColName notNil ifTrue: [szColName freePointer]. pcbColName notNil ifTrue: [pcbColName freePointer]. pfSqlType notNil ifTrue: [pfSqlType freePointer]. pcbColDef notNil ifTrue: [pcbColDef freePointer]. pibScale notNil ifTrue: [pibScale freePointer]. pfNullable notNil ifTrue: [pfNullable freePointer]]. self columnDescriptions: descrs
getBlockOfRowsExternal "Fetch the next block of rows into the memory allocated for this purpose." | xif rc p | xif := self class xif. "workaround for DB2 v7 client bug" rc := blockFactor = 1 ifFalse: [pRowsFetchedHolder value isNil ifTrue: [self allocateFetchedPointer]. (p := pRowsFetchedHolder value) contents: 0. xif SQLFetchScroll: self hstmt with: xif SQL_FETCH_NEXT with: 0] ifTrue: [xif SQLFetch: self hstmt]. traceLevel >= 3 ifTrue: [blockFactor > 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLFetchScroll( hstmt='; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', rows_read='; print: p contents; nextPutAll: ' )'] ifFalse: [(self traceStream) print: rc; nextPutAll: ' = SQLFetch( hstmt='; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ' )']. self class trace: self emitTrace]. rc == xif SQL_NO_DATA_FOUND ifTrue: [rowsInBlock := 0. ^nil]. "workaround DB2 v7 client bug" blockFactor = 1 ifTrue: [rowsInBlock := 1] ifFalse: [rowsInBlock := p contents]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self class connectionClass unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. totalRows := totalRows + rowsInBlock
getBlockOfRowsExternal: fetchOrientation offset: fetchOffset "Fetch the next block of rows into the memory allocated for this purpose." | xif rc p newFetchMode newOffset | xif := self class xif. "workaround for DB2 v7 client bug" pRowsFetchedHolder value isNil ifTrue: [self allocateFetchedPointer]. (p := pRowsFetchedHolder value) contents: 0. fetchOrientation == self fetchPriorMode ifTrue: [ newFetchMode := self fetchRelativeMode. newOffset := 0 - (self blockFactor). ] ifFalse: [ fetchOrientation == self fetchRelativeMode ifTrue: [ newFetchMode := fetchOrientation. self currentRowIndex: (self currentRowIndex - fetchOffset). newOffset := fetchOffset + self currentRowIndex - 1. ] ifFalse: [ newFetchMode := fetchOrientation. newOffset := fetchOffset. ]. ]. rc := xif SQLFetchScroll: self hstmt with: newFetchMode with: newOffset. traceLevel >= 3 ifTrue: [ (self traceStream) print: rc; nextPutAll: ' = SQLFetchScroll( hstmt='; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', fetchOrientation='; print: newFetchMode; nextPutAll: ', fetchOffset='; print: fetchOffset; nextPutAll: ' )'. self class trace: self emitTrace ]. rc == xif SQL_NO_DATA_FOUND ifTrue: [rowsInBlock := 0. ^nil]. "workaround DB2 v7 client bug" blockFactor = 1 ifTrue: [rowsInBlock := 1] ifFalse: [rowsInBlock := p contents]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self class connectionClass unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. totalRows := totalRows + rowsInBlock
getColumnDescriptionExternal: aColumn "Folded into describeAnswerColumns for efficiency." ^self shouldNotImplement
getFieldExternal: aColumn "Answer the data for the aColumn-th column in the current row." | buffer | buffer := (self rowBuffers) at: aColumn. ^buffer at: ((self currentRowIndex - 1) \\ self blockFactor) + 1
handleAutoCommit "The behavior of the EXDI as regards transactions is that each statement executed is a separate transaction unless the connection is sent begin." | conn xif | conn := self connection. xif := self class xif. conn inTransactionMode ifFalse: [ "We have an autocommit if connection wasn't sent begin" | behavior | behavior := conn getInformationType: #SQL_CURSOR_COMMIT_BEHAVIOR. behavior == xif SQL_CB_CLOSE ifTrue: [conn cursorsAreClosed]]
hasAnswerSetExternal | xif rc pccol | xif := self class xif. self numColumns: 0. "default to none" ["Begin unwind protection." pccol := xif SQLSMALLINT perform: xif mallocSelector with: 1. rc := xif SQLNumResultCols: self hstmt with: pccol. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLNumResultCols( hstmt='; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', *pccol ='; print: pccol contents; nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. ^self class connectionClass unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString]. self numColumns: pccol contents "End unwind protection."] ensure: [pccol notNil ifTrue: [pccol freePointer]]. self numColumns > 0 ifTrue: [^true]. "Simulate auto-commit transaction behavior?" self handleAutoCommit. ^false
releaseBuffers "Release buffers and their associated resources." | rbs | (rbs := self rowBuffers) notNil ifTrue: [self hstmt isNil ifFalse: [ self freeStatementExternal: #SQL_UNBIND ]. "may be remove, in ODBCEXDI never send :) " 1 to: rbs size do: [ :i | (rbs at: i) free ] ]. super releaseBuffers
updateFileRefs self rowBuffers do: [:buf | (buf isFileRefObject ) ifTrue: [ buf updateFileRefInfo]]
</methods> <methods> Database.DB2Session <category>data processing</category>
answerLOBAsFileRef: aFileRefOrDictionary "currently only DB2LOBFileReference instance supported" answerBlob := aFileRefOrDictionary
answerLOBAsLocators answerBlob := false
answerLOBAsValues answerBlob := true
answerLOBValues ^answerBlob == true
answerLocators ^answerBlob == false
bindInputArray: anArray "Transform 'row-wise' array to 'column-wise' presentation" | columns new columnSize t | columnSize := anArray size. anArray first class isVariable ifTrue: [ columns := anArray first size. new := Array new: columns. 1 to: columns do: [:i | new at: i put: (t:=Array new: columnSize). 1 to: columnSize do: [:x | t at: x put: ((anArray at: x) at: i)]]] ifFalse: [columns := anArray first class instSize. new := Array new: columns. 1 to: columns do: [:i | new at: i put: (t:=Array new: columnSize). 1 to: columnSize do: [:x | t at: x put: ((anArray at: x) instVarAt: i)]]]. self bindInputArrayByColumns: new.
bindInputArrayByColumns: anArray "check size" anArray inject: anArray first size into: [:last :x| last ~= x size ifTrue: [self connection class unableToBindSignal raise] ifFalse: [last]]. paramSetSize:= anArray first size. bindInput:=anArray
bindVariable: name "Answer the value of a bind variable." | buffer | buffer := self bindValuePointers at: name ifAbsent: [ nil ]. buffer isNil ifTrue: [ self error: 'unbound variable' ]. ^buffer value
bindVariable: name value: value "Set the value of a bind variable." self bindVariable: name value: value kind: #in
bindVariable: name value: aValue kind: kind "Set the value of a bind variable." | buffer paramType pos | pos := name isInteger ifTrue: [ name] ifFalse: [(queryFragments indexOf: name ifAbsent: [self connection class unableToBindSignal ] ) // 2 ]. paramType := (kind == #in) ifTrue: [#SQL_PARAM_INPUT] ifFalse: [kind == #out ifTrue: [ #SQL_PARAM_OUTPUT] ifFalse: [#SQL_PARAM_INPUT_OUTPUT]]. buffer := self bindValuePointers at: name ifAbsent: [ nil ]. buffer notNil ifTrue: [ [buffer value: aValue] on: self connection class unableToBindSignal do: [:ex | self bindValuePointers removeKey: name. buffer free. buffer := nil. ex return]]. buffer isNil ifTrue: [ buffer := self class bufferClass on: aValue position: pos session: self "type: type size: nil". buffer bindFor: paramType. self bindValuePointers at: name put: buffer]. ^self
closeCursor "Really cursor closing" self freeStatementExternal: #SQL_CLOSE. self mustCloseCursor: false. "self immediateCursorClosing." "don't change defered/immediate closing behavior" self handleAutoCommit
cursorName "Answer the cursor name associated with receiver." | xif szCursor pcbCursor rc cursorName cbCursorMax | xif := self class xif. self hstmt isNil ifTrue: [^nil]. ["Begin unwind protection." cbCursorMax := self connection getInformationType: #SQL_MAX_CURSOR_NAME_LEN. szCursor := xif SQLCHAR perform: xif mallocSelector with: cbCursorMax. pcbCursor := xif SQLINTEGER perform: xif mallocSelector with: 1. rc := xif SQLGetCursorName: self hstmt with: szCursor with: cbCursorMax with: pcbCursor. traceLevel >= 2 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLGetCursorName( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', szCursor = '; print: szCursor copyCStringFromHeap; nextPutAll: ', cbCursorMax = '; print: cbCursorMax; nextPutAll: ', *pcbCursor = '; print: pcbCursor contents; nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. (rc == xif SQL_ERROR and: [errs first sqlState = 'S1015']) ifTrue: [^nil]. ^self class connectionClass externalDatabaseErrorSignal raiseWith: errs errorString: errs first dbmsErrorString]. cursorName := szCursor copyCStringFromHeap "End unwind protection"] ensure: [szCursor notNil ifTrue: [szCursor freePointer]. pcbCursor notNil ifTrue: [pcbCursor freePointer]]. ^cursorName
cursorName: aString "Sets the cursor name associated with receiver." | xif rc | xif := self class xif. ((self hstmt isNil or: [ aString isString not ]) or: [ aString size <= 0 ]) ifTrue: [^nil]. rc := xif SQLSetCursorName: self hstmt with: aString with: aString size. traceLevel >= 2 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLSetCursorName( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', szCursor = '; print: aString; nextPutAll: ', cbCursor = '; print: aString size; nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. (rc == xif SQL_ERROR and: [errs first sqlState = 'S1015']) ifTrue: [^nil]. ^self class connectionClass externalDatabaseErrorSignal raiseWith: errs errorString: errs first dbmsErrorString].
deferCursorClosing deferCursorClosing:=true
deleteAtCursorPosition: anInteger | rc xif | xif := self class xif. rc := xif SQL_DELETE_RECORD: self hstmt with: anInteger. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. errs isEmpty ifTrue: [^self]. "errs first sqlState = '40003' ifTrue: [^self]." self class connectionClass invalidSessionStateSignal raiseWith: errs errorString: errs first dbmsErrorString]
getDataChunkSize "Answer the data transfer size for LOB columns." ^self class xif getDataChunkSize
getMaxLongData "Answer the maximum amount of data to be copied from BLOB or CLOB columns." ^maxLongData
immediateCursorClosing deferCursorClosing:=false
prepare: aString queryIsCALL := false. super prepare: aString
prepareCall: aString queryIsCALL := true. super prepare: aString
rowCount "Answer an Integer representing the number of rows affected by the previous query. Valid only after the query has been answered." | xif pcrow rc rowCount | xif := self class xif. self hstmt isNil ifTrue: [^nil]. ["Begin unwind protection." pcrow := xif SQLINTEGER perform: xif mallocSelector with: 1. pcrow contents: 0. rc := xif SQLRowCount: self hstmt with: pcrow. rowCount := pcrow contents. traceLevel >= 2 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLRowCount( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', pcrow = '; nextPutAll: (pcrow referentAddress printStringRadix: 16); nextPutAll: ') = '; print: rowCount; nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. ^self class connectionClass externalDatabaseErrorSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [pcrow notNil ifTrue: [pcrow freePointer]]. ^rowCount
setCursorPositionTo: anInteger | rc xif | xif := self class xif. rc := xif SQL_POSITION_TO: self hstmt with: anInteger. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. errs isEmpty ifTrue: [^self]. "errs first sqlState = '40003' ifTrue: [^self]." self class connectionClass invalidSessionStateSignal raiseWith: errs errorString: errs first dbmsErrorString]
setDataChunkSize: anInteger "Specify the data transfer size for BLOB or CLOB columns." self class xif setDataChunkSize: anInteger.
setMaxLongData: anInteger "Specify the maximum amount of data to be copied from CLOB or BLOB columns." maxLongData := (self class defaultMaxLongData min: anInteger).
updateAtCursorPosition: anInteger | rc xif | xif := self class xif. rc := xif SQL_UPDATE_RECORD: self hstmt with: anInteger. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. errs isEmpty ifTrue: [^self]. "errs first sqlState = '40003' ifTrue: [^self]." self class connectionClass invalidSessionStateSignal raiseWith: errs errorString: errs first dbmsErrorString]
</methods> <methods> Database.DB2Session <category>private-binding</category>
bindExternal queryIsCALL ifTrue: [ self bindSPCall ] ifFalse: [ self bindValuesExternal ]
bindInput: aBindObject "Supply aBindObject as the object from which input values should be obtained for host variable references in the SQL text. Host variables may be specified using either a positional or a named notation. The driver may limit to only one form. When using the positional form (a ?), all host variable references (including the named ones) are implicitly ordered by their position in the SQL-text. The n-th variable of aBindObject is used for the n-th host variable reference. If aBindObject has both instance variables and indexed variables, only the indexed variables will be used. When using the named form, the leading colon is removed and the name is expected to be an accessing method on aBindObject (i.e. aBindObject is sent perform: with the name converted to a symbol as the argument)." bindInput := aBindObject. paramSetSize := (aBindObject isSequenceable and: [aBindObject notEmpty and: [aBindObject first class = Array]]) ifTrue: [aBindObject first size] ifFalse: [0]
bindParamArray "Check and set parameter array size" | old bvp | old:=self sqlStatementAttributeCache at: #SQL_ATTR_PARAMSET_SIZE ifAbsent: [1]. old = (paramSetSize max: 1) ifTrue: [^true] ifFalse: [self setStatementAttribute: #SQL_ATTR_PARAMSET_SIZE value: (paramSetSize max: 1). (old < paramSetSize or: [paramSetSize==0] ) ifTrue: [ (bvp:=self bindValuePointersHolder value) notNil ifTrue: [bvp values do: [:b | b notNil ifTrue: [ b free ] ]]. self bindValuePointers: nil]].
bindSPCall "Bind values for a SP CALL query." | bound position | position := 0. bound := IdentitySet new: self bindValuePointers capacity. 2 to: queryFragments size by: 2 do: [ :index | | bindMarker buffer | position := position + 1. bindMarker := queryFragments at: index. ( bound includes: bindMarker ) ifFalse: [ buffer := self bindValuePointers at: bindMarker ifAbsent: [ nil ]. buffer isNil ifTrue: [ ^self connection class missingBindVariableSignal raise ]. "buffer bindForInputOutput." bound add: bindMarker ] ]
bindValue: aValue at: position "Bind a value to a parameter position in the query" | buffer val | val := (aValue isKindOf: Stream) ifTrue: [aValue contents] ifFalse: [aValue]. (aValue class == Array and: [aValue first isKindOf: Stream ]) ifTrue: [val := aValue collect: [:x | x contents]]. buffer := self bindValuePointers at: position ifAbsent: [ nil ]. buffer notNil ifTrue: [ [buffer value: val ] on: self connection class unableToBindSignal do: [ :ex | self bindValuePointers removeKey: position. buffer free. buffer := nil. ex return ]]. buffer isNil ifTrue: [ buffer := self class bufferClass on: val position: position session: self "type: type size: nil". buffer bindForInput. self bindValuePointers at: position put: buffer]. ^self
bindValuePointers "Answer with the receiver's dictionary of bound rgbValue pointers (input parameters)." | t | (t:=bindValuePointersHolder value) isNil ifTrue: [ bindValuePointersHolder value: (t:=IdentityDictionary new) ]. ^t
bindValuePointers: aDictionary bindValuePointersHolder value: aDictionary.
bindValuePointersHolder ^bindValuePointersHolder
bindValuePointersHolder: aValueModel bindValuePointersHolder:= aValueModel
bindValuesExternal "Bind values to parameters in the query, avoiding unnecessary rebinding where possible." "For each bind marker in the query fragments, get the corresponding value from the bindInput object. If the value isn't already bound, bind and remember it." | leftToRightOrder | self bindParamArray. leftToRightOrder := 0. 2 to: queryFragments size by: 2 do: [ :index | | bindMarker value | bindMarker := queryFragments at: index. leftToRightOrder := leftToRightOrder + 1. value := self inBindInputAt: bindMarker. self bindValue: value at: leftToRightOrder. ( self boundValueAt: bindMarker is: value ) ifFalse: [ self bindValues at: bindMarker put: value. ] ].
conversionFor: aValue at: aPosition aValue isNil ifFalse: [aValue class == Array ifTrue: [(aValue detect: [:v | v notNil] ifNone: [nil]) db2Conversion ifNotNil: [:v | ^v]] ifFalse: [^aValue db2Conversion]]. "Not a very good answer, but what we did before" bindTemplate isNil ifTrue: [^#String]. "workaround for GlorpReadingDifferentCollectionsThroughMappingsTest>>testReadManyToManyWithOrder, DatabaseCommand>>parameterTypeSignature make bad work on arrays and null's" ^bindTemplate size >= aPosition ifTrue: [bindTemplate at: aPosition] ifFalse: [#String]
prepareExternal "Prepare the server to execute a query." | xif sql sqlBa rc | self mustCloseCursor ifTrue: [self closeCursor]. xif := self class xif. "Assemble the query, substituting the correct parameter markers." queryFragments size == 1 ifTrue: [sql := queryFragments at: 1] ifFalse: [| sqlStream | sqlStream := (String new: query size) writeStream. sqlStream nextPutAll: (queryFragments at: 1). 2 to: queryFragments size by: 2 do: [:index | sqlStream nextPut: $?; nextPutAll: (queryFragments at: index + 1)]. sql := sqlStream contents]. sqlBa := sql asByteArrayEncoding: self connection encoding. ["Begin unwind protection." rc := xif SQLPrepare: self hstmt with: sqlBa with: sqlBa size. traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLPrepare( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', szSqlStr = '''; print: sql asString; nextPutAll: ''', cbSqlStr = '; print: sql size; nextPutAll: ' )'. self class trace: self emitTrace]. ((rc == xif SQL_SUCCESS) or: [ rc == xif SQL_SUCCESS_WITH_INFO ]) ifFalse: [| errs | errs := self getStatementErrors. self class connectionClass unableToPrepareSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection"] ifCurtailed: [self connection inTransactionMode ifFalse: [self connection transactExternal: #SQL_ROLLBACK]]
releaseBindings | bvp bvps | "self mustCloseCursor ifTrue: [self closeCursor]." (bvp:=self bindValuePointersHolder value) notNil ifTrue: [ self hstmt isNil ifFalse: [ self freeStatementExternal: #SQL_RESET_PARAMS ]. bvps := bvp values. 1 to: bvps size do: [ :i | | buffer | (buffer := bvps at: i) notNil ifTrue: [ buffer free ] ]. self bindValuePointers: nil ]. super releaseBindings
</methods> <methods> Database.DB2Session <category>private-ObjectLens</category>
bindInput: object template: template to: bindStream "Recursively flatten a template onto a bindStream" | class | ( template isInteger ) ifTrue: [ ^bindStream nextPut: object ]. class := template class. ( class == Object ) ifTrue: [ ^self ]. ( class == Float or: [ class == Double or: [ class == FixedPoint or: [ class == Timestamp or: [class == Date or: [class == Time or: [class == ByteFieldDescriptor or: [class == DB2DataLink or: [class == DB2CLOBLocator or: [class == DB2BLOBLocator or: [ object == true or: [ object == false or: [ object == nil or: [ (object isKindOf: CharacterArray) or: [ object isKindOf: ByteArray ] ] ] ] ] ] ] ] ] ] ] ] ] ]) ifTrue: [ ^bindStream nextPut: object ]. "turn symbols into strings" "(object isKindOf: ByteSymbol) ifTrue: [ ^bindStream nextPut: object asString ]." ( ( template isKindOf: Array ) or: [ template isKindOf: OrderedCollection ] ) ifTrue: [ 1 to: (object size) do: [ : index | self bindInput: (object at: index) template: (template at: index) to: bindStream ] ] ifFalse: [ "All others are treated as instances" 1 to: (object class instSize) do: [ : index | self bindInput: (object instVarAt: index) template: (template instVarAt: index) to: bindStream ] ].
flattenResultTemplate: template onto: descStream "Recursively flatten an ObjectLens result template." | class desc | class := template class. "Instances of object in the template denote slots to ignore." ( class == Object ) ifTrue: [ ^self ]. ( template isInteger ) ifTrue: [(desc := DB2ColumnDescription new) type: template db2Conversion; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: template db2Conversion ); maxColumnConstraint: 4. ^descStream nextPut: desc ]. class == Float ifTrue: [ (desc := DB2ColumnDescription new) type: #Float; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #Float); maxColumnConstraint: 4. ^descStream nextPut: desc ]. class == Double ifTrue: [ (desc := DB2ColumnDescription new) type: #Double; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #Double); maxColumnConstraint: 8. ^descStream nextPut: desc ]. (class == DB2BLOBLocator or: [class == DB2CLOBLocator ]) ifTrue: [ (desc := DB2ColumnDescription new) type: template db2Conversion ; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: template db2Conversion); maxColumnConstraint: 4. ^descStream nextPut: desc ]. (class == DB2DataLink) ifTrue: [ (desc := DB2ColumnDescription new) type: template db2Conversion ; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: template db2Conversion); maxColumnConstraint: 254. ^descStream nextPut: desc ]. (class == DB2LOBFileReference) ifTrue: [ (desc := DB2ColumnDescription new) type: template db2Conversion ; fileRef: template. ^descStream nextPut: desc ]. class == FixedPoint ifTrue: [ (desc := DB2ColumnDescription new) type: #FixedPoint; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #FixedPoint); maxColumnConstraint: 34; precision: 34. ^descStream nextPut: desc ]. ( class == Timestamp ) ifTrue: [ (desc := DB2ColumnDescription new) type: #Timestamp; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #Timestamp); maxColumnConstraint: 16. ^descStream nextPut: desc ]. ( class == Date ) ifTrue: [ (desc := DB2ColumnDescription new) type: #Date; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #Date); maxColumnConstraint: 6. ^descStream nextPut: desc ]. ( class == Time ) ifTrue: [ (desc := DB2ColumnDescription new) type: #Time; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #Time); maxColumnConstraint: 6. ^descStream nextPut: desc ]. ( class == ByteFieldDescriptor ) ifTrue: [ | temp | (desc := DB2ColumnDescription new) maxColumnConstraint: template MaxColumnConstraint; precision: template MaxColumnConstraint. temp := template Template. desc type: temp db2Conversion. desc fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: temp db2Conversion). ^descStream nextPut: desc ]. ( template isString ) ifTrue: [ (desc := DB2ColumnDescription new) type: #String; fSqlType: (DB2CLIInterface fSqlTypeFromConversionMap at: #String); precision: ((DB2Buffer.ValuePrecisionBlocks at: #String) value: template); maxColumnConstraint: ((DB2Buffer.ValueSizeBlocks at: #String) value: template). ^descStream nextPut: desc ]. "Decompose Arrays and Collections." ( ( template isKindOf: Array ) or: [ template isKindOf: OrderedCollection ] ) ifTrue: [ 1 to: template size do: [ :index | self flattenResultTemplate: (template at: index) onto: descStream ]. ^self ]. "All others are treated as instances of some entity" 1 to: template class instSize do: [ :index | self flattenResultTemplate: (template instVarAt: index) onto: descStream ].
getColumnsOfTable: aTableName owner: anOwner | answer | self class traceLevel >= 1 ifTrue: [self class trace: 'Looking up columns for table "', aTableName, '" ...']. self getSQLColumns: nil tableOwner: anOwner tableName: aTableName columnName: nil. answer := OrderedCollection new. self answer do: [:t | (answer add: Dictionary new) add: #table -> (t at: 3); add: #name -> (t at: 4); add: #type -> (t at: 5); add: #nativeType -> (t at: 6); add: #maxLength -> (t at: 8); add: #columnSize -> (t at: 7); add: #scale -> (t at: 9); add: #nullable -> (t at: 11)]. ^answer
getForeignKeysFor: aTable owner: anOwner | answer | self class traceLevel >= 1 ifTrue: [self class trace: 'Looking up foreign keys for table "' , anOwner, '.', aTable , '" ...']. answer := OrderedCollection new. self getSQLForeignKeys: nil tableOwner: nil tableName: nil fkQualifier: nil fkOwner: anOwner fkTableName: aTable. self answer do: [:x | answer add: x ]. ^answer
getPrimaryKeysFor: aTableName owner: anOwner | answer | self class traceLevel >= 1 ifTrue: [self class trace: 'Looking up columns for table "', aTableName, '" ...']. answer := OrderedCollection new. self getSQLPrimaryKeys: nil tableOwner: anOwner tableName: aTableName. self answer do: [:x | answer add: (x at: 4)]. "column name" ^answer
listTablesLike: aString "Answer a collection of tables available in the receiver's database." | pattern i owner tableType answer | owner := ''. ((pattern := aString) isNil or: [aString isEmpty]) ifTrue: [pattern := '%'] ifFalse: [(i := pattern indexOf: $.) > 0 ifTrue: [owner := pattern copyFrom: 1 to: i - 1. pattern := pattern copyFrom: i + 1 to: pattern size]]. owner isEmpty ifTrue: [owner := nil]. tableType := aString first == $+ ifTrue: [pattern:=pattern copyWithout: $+. 'SYSTEM TABLE'] ifFalse: ['TABLE,VIEW']. answer := OrderedCollection new. self getSQLTables: nil tableOwner: owner tableName: pattern tableType: tableType. self answer do: [:t | (answer add: IdentityDictionary new) add: #name -> (t at: 3); add: #owner -> (t at: 2); add: #tableType -> (t at: 4)]. ^answer
nextViaTemplate: template "Answer the object formed by reifying the template using a fetched row" | class object | ( template isInteger ) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object asInteger ] ]. class := template class. ( class == Float ) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object asFloat ] ]. ( class == Double ) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object asDouble] ]. ( class == DB2CLOBLocator or: [class == DB2BLOBLocator or: [class == DB2LOBFileReference]]) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object ]]. ( class == DB2DataLink) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object ]]. ( class == FixedPoint ) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object isNil ifTrue: [ nil ] ifFalse: [ object isInteger ifTrue: [ object asFixedPoint: 2 ] ifFalse: [ object ] ] ]. ( class == Timestamp or: [class == Date or: [class == Time or: [ template == true or: [ template == false ] ] ] ]) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object ]. ( class == ByteFieldDescriptor or: [template isString and: [template isSymbol not]] ) ifTrue: [ object := self getFieldExternal: bufferIndex. bufferIndex := bufferIndex + 1. ^object ]. ( template isKindOf: Collection ) ifTrue: [ ( template isKindOf: Array ) ifTrue: [ ^self nextViaArrayTemplate: template ] ifFalse: [ ^self nextViaCollectionTemplate: template ] ]. ( class == Object ) ifTrue: [ ^nil ]. ^self nextViaEntityTemplate: template
</methods> <methods> Database.DB2Session <category>accessing</category>
blockFactor: aSmallInteger "Specify the blocking factor to use when fetching of row data. This may improve application performance at the expense of memory. The blocking factor is optional and will be ignored if the driver does not support fetching multiple rows at a time. The application still uses next to obtain a single row at a time. However, the use of WHERE CURRENT OF may not be allowed as the database system cannot be sure of which row the application is referring to." blockFactor := aSmallInteger
</methods> <methods> Database.DB2Session <category>private-execution</category>
acquireExternal "Acquire external resources." | xif phstmt rc | xif := self class xif. ["Begin unwind protection." phstmt := xif SQLHSTMT perform: xif mallocSelector with: 1. rc := xif SQLAllocHandle: xif SQL_HANDLE_STMT with: self connection hdbc with: phstmt. traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLAllocStmt( hdbc = '; nextPutAll: (self connection hdbc printStringRadix: 16); nextPutAll: ', hstmt = '; nextPutAll: (phstmt contents printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self connection getConnectionErrors. self class connectionClass unableToAllocateHandleSignal raiseWith: errs errorString: errs first dbmsErrorString]. self hstmt: phstmt contents. self sqlStatementAttributeCache: IdentityDictionary new. self setStatementAttributeExternal: #SQL_ATTR_CLOSEOPEN value: 1. "Chain the close and open statements (DB2 v6)" self scrollable ifTrue: [ self setStatementAttribute: #SQL_ATTR_CURSOR_TYPE value: xif SQL_CURSOR_KEYSET_DRIVEN. ]. "End unwind protection."] ensure: [phstmt notNil ifTrue: [phstmt freePointer]]
cancelExternal "Handle cleanup when current query is cancelled." ^self
cursorIsClosed "Receiver's cursor was closed and can no longer be used to access rows from the previous query. Prepared statements can be executed without preparing them again." "If receiver isn't in an executing state, nothing to do." self isExecuting ifFalse: [ ^self ]. "If there is an extant answer stream, it's dead so mark it as such." answerStream notNil ifTrue: [ answerStream session: nil. answerStream := nil ]. "We're now back in the prepared state and can execute again without preparing." self state: #prepared. ( traceLevel >= 3 ) ifTrue: [ (self traceStream) nextPutAll: 'hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); cr; tab; nextPutAll: 'self mustResendQuery: false. self state: #prepared'. self class trace: self emitTrace ]
cursorIsDeleted "Receiver's cursor was deleted and can no longer be used to access rows from the previous query. Any prepared statements must be prepared again. Parameters and bound buffers are still valid." "If receiver isn't in an executing state, nothing to do." self isExecuting ifFalse: [ ^self ]. "If there is an extant answer stream, it's dead so mark it as such." answerStream notNil ifTrue: [ answerStream session: nil. answerStream := nil ]. "The SQL text must be sent to the server again." self mustResendQuery: true. self mustCloseCursor: false. "We're now back in the prepared state and can execute again without preparing." self state: #prepared. ( traceLevel >= 3 ) ifTrue: [ (self traceStream) nextPutAll: 'hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); cr; tab; nextPutAll: 'self mustResendQuery: true. self state: #prepared'. self class trace: self emitTrace ]
dismissExternal pRowsFetchedHolder value == nil ifFalse: [pRowsFetchedHolder value freePointer. pRowsFetchedHolder value: nil ]. self rowStatus isNil ifFalse: [rowStatus freePointer. self rowStatus: nil ]. self freeStatementExternal: #SQL_DROP. self hstmt: nil
executeExternal "Execute the prepared SQL text." | xif rc | xif := self class xif. "Does the query text need to be sent to the server again?" self mustResendQuery ifTrue: [ self prepareExternal. self mustResendQuery: false ]. rc := xif SQLExecute: self hstmt. ( traceLevel >= 1 ) ifTrue: [ (self traceStream) print: rc; nextPutAll: ' = SQLExecute( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace ]. (rc == xif SQL_ERROR) ifTrue: [self resultsCache: self getStatementErrors ]. "Are there any data-at-execution parameters to bind?" (rc == xif SQL_NEED_DATA) ifTrue: [self halt. "never send now" ]
freeStatementExternal: releaseOption "Release resources associated with a session." | xif rc | self hstmt isNil ifTrue: [^self]. xif := self class xif. rc := xif SQLFreeStmt: self hstmt with: (xif perform: releaseOption). traceLevel >= 3 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLFreeStmt( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ', '; print: releaseOption; nextPutAll: ')'. self class trace: self emitTrace]. rc == xif SQL_SUCCESS ifFalse: [| errs | errs := self getStatementErrors. errs isEmpty ifTrue: [^self]. "errs first sqlState = '40003' ifTrue: [^self]." self class connectionClass unableToFreeResourceSignal raiseWith: errs errorString: errs first dbmsErrorString]
getStatementAttributeExternal: fOptionSymbol "Answer the information associated with fInfoTypeSymbol. This information is defined only after connecting." | xif rc ub pvParam vParam | xif := self class xif. ["Begin unwind protection." pvParam := xif SQLPOINTER perform: xif mallocSelector with: 1. rc := xif SQLGetStmtAttr: self hstmt with: (xif perform: fOptionSymbol) with: pvParam with: 0 with: nil. "only integer attributes supported" (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. ^self connection class unableToQueryStatementAttributesSignal raiseWith: errs errorString: errs first dbmsErrorString]. ub := UninterpretedBytes new: pvParam contents. vParam := ub perform: (SQLStatementAttributeConversionMap at: fOptionSymbol) with: 1 "End unwind protection."] ensure: [pvParam notNil ifTrue: [pvParam freePointer]]. ^vParam
installExternal super installExternal. self hstmt: nil. self mustResendQuery: false. self mustCloseCursor: false. self sqlStatementAttributeCache: IdentityDictionary new. self setMaxLongData: DefaultMaxLongData.
moreResultsExternal "^false" | xif rc | (deferCursorClosing or: [self paramSetSize > 1]) ifFalse: [^false]. "FP2 trouble w/a ?" xif := self class xif. rc := xif SQLMoreResults: self hstmt. traceLevel >= 1 ifTrue: [(self traceStream) print: rc; nextPutAll: ' = SQLMoreResults( hstmt = '; nextPutAll: (self hstmt printStringRadix: 16); nextPutAll: ' )'. self class trace: self emitTrace]. (rc == xif SQL_SUCCESS or: [rc == xif SQL_NO_DATA_FOUND]) ifFalse: [| errs | errs := self getStatementErrors. self class connectionClass externalDatabaseErrorSignal raiseWith: errs errorString: errs first dbmsErrorString]. "Are there any result sets?" ^(rc == xif SQL_NO_DATA_FOUND) not
readyExternal ^true
resultsExternal "extracted from ODBCEXDI: proper handling for multiple results" | errs sqlState | (errs := self resultsCache) notNil ifTrue: [1 to: errs size do: [:position | ((sqlState := (errs at: position) sqlState asSymbol) == #'01000' or: [sqlState == #S1000]) ifFalse: [^self class connectionClass unableToExecuteSQLSignal raiseWith: errs errorString: (errs at: position) dbmsErrorString]]. self class connectionClass externalDatabaseInformationSignal raiseRequestWith: errs]. ^true
setStatementAttributeExternal: fOptionSymbol value: vOption "Set the information associated with fInfoTypeSymbol. This information is defined only after connecting." | xif rc valuePtr | ["Begin unwind protection." xif := self class xif. rc := xif SQLSetStmtAttr: self hstmt with: (xif perform: fOptionSymbol) with: (vOption isString ifTrue: [valuePtr := vOption copyToHeap] ifFalse: [vOption]) with: (vOption isString ifTrue: [vOption size] ifFalse: [0]). (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. ^self class externalDatabaseErrorSignal raiseWith: errs errorString: errs first dbmsErrorString]] ensure: [valuePtr notNil ifTrue: [valuePtr freePointer]]. ^vOption
</methods> <methods> Database.DB2Session <category>private-accessing</category>
currentRowIndex ^currentRowIndex
currentRowIndex: aValue currentRowIndex := aValue
fetchAbsoluteMode ^self class xif SQL_FETCH_ABSOLUTE
fetchNextMode ^self class xif SQL_FETCH_NEXT
fetchPriorMode ^self class xif SQL_FETCH_PRIOR
fetchRelativeMode ^self class xif SQL_FETCH_RELATIVE
getStatementAttribute: fOptionTypeSymbol | ssoc | ^(ssoc := self sqlStatementAttributeCache) at: fOptionTypeSymbol ifAbsent: [ | vOption | vOption := self getStatementAttributeExternal: fOptionTypeSymbol. ssoc at: fOptionTypeSymbol put: vOption. vOption ].
getStatementErrors "Return a collection of DB2Error(s) associated with the statement handle." | xif errors err num | xif := self class xif. errors := OrderedCollection new. num:=0. [ (err := self connection getErrorsExternal: xif SQL_HANDLE_STMT handle: self hstmt recNumber: (num:=num+1)) notNil ] whileTrue: [ errors add: err ]. ^errors
hstmt ^hstmtHolder value
hstmt: aCPointerOrNil hstmtHolder value: aCPointerOrNil
hstmtHolder ^hstmtHolder
hstmtHolder: aValueHolder hstmtHolder := aValueHolder
mustCloseCursor ^self mustCloseCursorHolder value
mustCloseCursor: aBoolean self mustCloseCursorHolder value: aBoolean
mustCloseCursorHolder ^mustCloseCursorHolder
mustCloseCursorHolder: aValueHolder mustCloseCursorHolder:= aValueHolder
mustResendQuery ^self mustResendQueryHolder value
mustResendQuery: aBoolean self mustResendQueryHolder value: aBoolean
mustResendQueryHolder ^mustResendQueryHolder
mustResendQueryHolder: aValueHolder mustResendQueryHolder := aValueHolder
paramSetSize ^paramSetSize
pRowsFetched ^pRowsFetchedHolder value
pRowsFetched: aPointer pRowsFetchedHolder value: aPointer
pRowsFetchedHolder ^pRowsFetchedHolder
pRowsFetchedHolder: aHolder pRowsFetchedHolder := aHolder
resultsCache "Answer the contents of the result cache. Clear the cache." | results | results := resultsCache. resultsCache := nil. ^results
resultsCache: results "Cache results." resultsCache := results
rowsInBlock ^rowsInBlock
rowsInBlock: aValue rowsInBlock := aValue
rowStatus ^rowStatus
rowStatus: aPointer rowStatus := aPointer
setStatementAttribute: fOptionTypeSymbol value: vOption self setStatementAttributeExternal: fOptionTypeSymbol value: vOption. "don't save pointer's in cache" vOption class == CPointer ifFalse: [ self sqlStatementAttributeCache at: fOptionTypeSymbol put: vOption]. ^vOption
sqlStatementAttributeCache ^sqlStatementAttributeCache
sqlStatementAttributeCache: anIdentityDictionary sqlStatementAttributeCache := anIdentityDictionary
state: aSymbol super state: aSymbol. "traceLevel > 1 ifTrue: [Transcript nextPutAll: 'Current State: '; nextPutAll: aSymbol; cr; flush]"
totalRows ^totalRows
totalRows: aValue totalRows := aValue
</methods> <methods> Database.DB2Session <category>private-finalization</category>
executor "Answer with an executor for the receiver." | ex | ex := super executor. ex hstmtHolder: self hstmtHolder. "ex mustResendQueryHolder: self mustResendQueryHolder." ex bindValuePointersHolder: self bindValuePointersHolder. ex pRowsFetchedHolder: self pRowsFetchedHolder. ex rowStatus: self rowStatus. "ex mustCloseCursorHolder: self mustCloseCursorHolder." ^ex
finalizeExternal "Release all external resources" self releaseBuffersAndAdaptors. self releaseBindings. (self hstmt isNil ) ifTrue: [ ^self ]. ( traceLevel >= 1 ) ifTrue: [ self class trace: nil ]. super finalizeExternal
key "The hstmtHolder is unique to the session and is constant across pause/resume." ^self hstmtHolder
</methods> <methods> Database.DB2Session <category>blob-functions</category>
freeLocator: aLocator "Free LOB locator " self connection inTransactionMode ifFalse: [^self connection class invalidTransactionStateSignal raise]. self prepare: 'FREE LOCATOR ?'. self bindInput: (Array with: aLocator ); execute; answer.
</methods> <methods> Database.DB2Session <category>catalog functions</category>
getSQLColumns: tableQualifier tableOwner: tableOwner tableName: tableName columnName: columnName "If supported on the current platform, call the ODBC function SQLColumns to obtain a list of names of tables stored in the current data source. Sending the message callSQLColumns:tableOwner:tableName:columnName: is equivalent to preparing and executing a query using the receiver. After the call completes, the table information is obtained as an answer stream in the normal way (i.e. send the message answer and then use the answer stream to fetch the rows). Each row is an Array with one element for each column. The arguments tableQualifier, tableOwner, tableName, and columnName are directly passed to the function and take their definitions from the function definition. From DB2/CLI documentation: Column 1 TABLE_CAT (VARCHAR(128)) Column 2 TABLE_SCHEM (VARCHAR(128)) Column 3 TABLE_NAME (VARCHAR(128) not NULL) Column 4 COLUMN_NAME (VARCHAR(128) not NULL) Column 5 DATA_TYPE (SMALLINT not NULL) Column 6 TYPE_NAME (VARCHAR(128) not NULL) Column 7 COLUMN_SIZE (INTEGER) Column 8 BUFFER_LENGTH (INTEGER) Column 9 DECIMAL_DIGITS (SMALLINT) Column 10 NUM_PREC_RADIX (SMALLINT) Column 11 NULLABLE (SMALLINT not NULL) Column 12 REMARKS (VARCHAR(254)) Column 13 COLUMN_DEF (VARCHAR(254)) Column 14 SQL_DATA_TYPE (SMALLINT not NULL) Column 15 SQL_DATETIME_SUB (SMALLINT) Column 16 CHAR_OCTET_LENGTH (INTEGER) Column 17 ORDINAL_POSITION (INTEGER not NULL) Column 18 IS_NULLABLE (VARCHAR(254)) " | xif szTableQualfier szTableOwner szTableName szColumnName rc | xif := self class xif. self startPrepare. self state: #executing. ["Begin unwind protection." | tqByteArray toByteArray tnByteArray cnByteArray | szTableQualfier := szTableOwner := szTableName := szColumnName := nil. tableQualifier isNil ifFalse: [tqByteArray := tableQualifier asByteArrayEncoding: self connection encoding. szTableQualfier := tqByteArray perform: xif copyToHeapSelector]. tableOwner isNil ifFalse: [toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector]. tableName isNil ifFalse: [tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector]. columnName isNil ifFalse: [cnByteArray := columnName asByteArrayEncoding: self connection encoding. szColumnName := cnByteArray perform: xif copyToHeapSelector]. rc := xif SQLColumns: self hstmt with: szTableQualfier with: tqByteArray size with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size with: szColumnName with: cnByteArray size. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self resultsCache: errs. self connection class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [szTableQualfier notNil ifTrue: [szTableQualfier freePointer]. szTableOwner notNil ifTrue: [szTableOwner freePointer]. szTableName notNil ifTrue: [szTableName freePointer]. szColumnName notNil ifTrue: [szColumnName freePointer]]
getSQLForeignKeys: tableQualifier tableOwner: tableOwner tableName: tableName fkQualifier: fkTableQualifier fkOwner: fkTableOwner fkTableName: fkTableName "The arguments tableQualifier, tableOwner, tableName and fkTableQualifier, fkTableOwner, fkTableName are directly passed to the function and take their definitions from the function definition. If the foreign keys associated with a primary key are requested, the result set is ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and ORDINAL_POSITION. If the primary keys associated with a foreign key are requested, the result set is ordered by PKTABLE_CAT, PKTABLE_SCHEM, PKTABLE_NAME, and ORDINAL_POSITION. " | xif szTableOwner szTableName szFkTableOwner szFkTableName rc | xif := self class xif. self startPrepare. self state: #executing. ["Begin unwind protection." | toByteArray tnByteArray ftoByteArray ftnByteArray | szTableOwner := szTableName := szFkTableOwner := szFkTableName := nil. tableOwner isNil ifFalse: [toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector]. tableName isNil ifFalse: [tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector]. fkTableOwner isNil ifFalse: [ftoByteArray := fkTableOwner asByteArrayEncoding: self connection encoding. szFkTableOwner := ftoByteArray perform: xif copyToHeapSelector]. fkTableName isNil ifFalse: [ftnByteArray := fkTableName asByteArrayEncoding: self connection encoding. szFkTableName := ftnByteArray perform: xif copyToHeapSelector]. rc := xif SQLForeignKeys: self hstmt with: nil with: 0 with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size with: nil with: 0 with: szFkTableOwner with: ftoByteArray size with: szFkTableName with: ftnByteArray size. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self resultsCache: errs. self connection class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [szTableOwner notNil ifTrue: [szTableOwner freePointer]. szTableName notNil ifTrue: [szTableName freePointer]. szFkTableOwner notNil ifTrue: [szFkTableOwner freePointer]. szFkTableName notNil ifTrue: [szFkTableName freePointer]]
getSQLPrimaryKeys: tableQualifier tableOwner: tableOwner tableName: tableName "The arguments tableQualifier, tableOwner, tableName are directly passed to the function and take their definitions from the function definition. Answer: TABLE_CAT (VARCHAR(128)) This is always null. TABLE_SCHEM (VARCHAR(128)) TABLE_NAME (VARCHAR(128) not NULL) COLUMN_NAME (VARCHAR(128) not NULL) ORDINAL_POSITION (SMALLINT not NULL) PK_NAME (VARCHAR(128)) Columns ordered by TABLE_CAT, TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION." | xif szTableQualfier szTableOwner szTableName rc | xif := self class xif. self startPrepare. self state: #executing. ["Begin unwind protection." | tqByteArray toByteArray tnByteArray | szTableQualfier := szTableOwner := szTableName := nil. tableQualifier isNil ifFalse: [tqByteArray := tableQualifier asByteArrayEncoding: self connection encoding. szTableQualfier := tqByteArray perform: xif copyToHeapSelector]. tableOwner isNil ifFalse: [toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector]. tableName isNil ifFalse: [tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector]. rc := xif SQLPrimaryKeys: self hstmt with: szTableQualfier with: tqByteArray size with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self resultsCache: errs. self connection class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [szTableQualfier notNil ifTrue: [szTableQualfier freePointer]. szTableOwner notNil ifTrue: [szTableOwner freePointer]. szTableName notNil ifTrue: [szTableName freePointer]]
getSQLSpecialColumns: colTypeSymbol tableQualifier: tableQualifier tableOwner: tableOwner tableName: tableName scope: scopeSymbol nullable: nullableSymbol "If supported on the current platform, call the ODBC function SQLSpecialColumns to obtain a list of statistics about a single table and the indexes associated with the table. Sending the message callSQLSpecialColumns:tableQualifier:tableOwner:tableName:scope:nullable: is equivalent to preparing and executing a query using the receiver. After the call completes, the table information is obtained as an answer stream in the normal way (i.e. send the message answer and then use the answer stream to fetch the rows). Each row is an Array with one element for each column. The columns of the answer set are defined in the ODBC documentation as: SCOPE, COLUMN_NAME, DATA_TYPE, PRECISION, LENGTH, SCALE, and PSEUDO_COLUMN. Refer to the Informix CLI or ODBC documentation for more details. The arguments tableQualifier, tableOwner, and tableName are directly passed to the function and take their definitions from the function definition. The argument colTypeSymbol must be either #SQL_BEST_ROWID or #SQL_ROWVER. The argument scopeSymbol must be one of #SQL_SCOPE_CURROW, #SQL_SCOPE_TRANSACTION, #SQL_SCOPE_SESSION. The argument nullableSymbol must be either #SQL_NO_NULLS or #SQL_NULLABLE." | xif fColType szTableQualfier szTableOwner szTableName fScope fNullable rc | xif := self class xif. self startPrepare. self state: #executing. "Set up the fColType parameter. colTypeSymbol must be one of #SQL_BEST_ROWID or #SQL_ROWVER." fColType := xif perform: colTypeSymbol. "Set up the fScope parameter. scopeSymbol must be one of #SQL_SCOPE_CURROW, #SQL_SCOPE_TRANSACTION, #SQL_SCOPE_SESSION" fScope := xif perform: scopeSymbol. "Set up the fNullable parameter. nullableSymbol must be one of #SQL_NO_NULLS or #SQL_NULLABLE." fNullable := xif perform: nullableSymbol. [ "Begin unwind protection." | tqByteArray toByteArray tnByteArray | szTableQualfier := szTableOwner := szTableName := nil. tableQualifier isNil ifFalse: [ tqByteArray := tableQualifier asByteArrayEncoding: self connection encoding. szTableQualfier := tqByteArray perform: xif copyToHeapSelector ]. tableOwner isNil ifFalse: [ toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector ]. tableName isNil ifFalse: [ tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector ]. rc := xif SQLSpecialColumns: self hstmt with: fColType with: szTableQualfier with: tqByteArray size with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size with: fScope with: fNullable. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [ | errs | errs := self getStatementErrors. self resultsCache: errs ]. "End unwind protection." ] ensure: [ szTableQualfier notNil ifTrue: [ szTableQualfier freePointer ]. szTableOwner notNil ifTrue: [ szTableOwner freePointer ]. szTableName notNil ifTrue: [ szTableName freePointer ] ]
getSQLStatistics: tableQualifier tableOwner: tableOwner tableName: tableName unique: uniqueSymbol accuracy: accuracySymbol "If supported on the current platform, call the ODBC function SQLStatistics to obtain a list of statistics about a single table and the indexes associated with the table. Sending the message callSQLStatistics:tableOwner:tableName:unique:accuracy: is equivalent to preparing and executing a query using the receiver. After the call completes, the table information is obtained as an answer stream in the normal way (i.e. send the message answer and then use the answer stream to fetch the rows). Each row is an Array with one element for each column. The columns of the answer set are defined in the ODBC documentation as: TABLE_QUALIFIER, TABLE_OWNER, TABLE_NAME, NON_UNIQUE, INDEX_QUALIFIER, INDEX_NAME, and TYPE. Refer to the Informix CLI or ODBC documentation for more details. The arguments tableQualifier, tableOwner, and tableName are directly passed to the function and take their definitions from the function definition. The argument uniqueSymbol must be either #SQL_INDEX_UNIQUE or #SQL_INDEX_ALL. The argument accuracySymbol must be either #SQL_ENSURE or #SQL_QUICK." | xif szTableQualfier szTableOwner szTableName fUnique fAccuracy rc | xif := self class xif. self startPrepare. self state: #executing. "Set up the fUnique parameter. uniqueSymbol must be one of #SQL_INDEX_UNIQUE or #SQL_INDEX_ALL." fUnique := xif perform: uniqueSymbol. "Set up the fAccuracy parameter. accuracySymbol must be one of #SQL_ENSURE or #SQL_QUICK." fAccuracy := xif perform: accuracySymbol. [ "Begin unwind protection." | tqByteArray toByteArray tnByteArray | szTableQualfier := szTableOwner := szTableName := nil. tableQualifier isNil ifFalse: [ tqByteArray := tableQualifier asByteArrayEncoding: self connection encoding. szTableQualfier := tqByteArray perform: xif copyToHeapSelector ]. tableOwner isNil ifFalse: [ toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector ]. tableName isNil ifFalse: [ tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector ]. rc := xif SQLStatistics: self hstmt with: szTableQualfier with: tqByteArray size with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size with: fUnique with: fAccuracy. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [ | errs | errs := self getStatementErrors. self resultsCache: errs ]. "End unwind protection." ] ensure: [ szTableQualfier notNil ifTrue: [ szTableQualfier freePointer ]. szTableOwner notNil ifTrue: [ szTableOwner freePointer ]. szTableName notNil ifTrue: [ szTableName freePointer ] ]
getSQLTables: tableQualifier tableOwner: tableOwner tableName: tableName tableType: tableType "Answer list of names of tables stored in the current data source. Sending the message callSQLTables:tableOwner:tableName:tableType: is equivalent to preparing and executing a query using the receiver. After the call completes, the table information is obtained as an answer stream in the normal way (i.e. send the message answer and then use the answer stream to fetch the rows). Each row is an Array with one element for each column. The columns of the answer set are defined in the CLI documentation as: TABLE_QUALIFIER, TABLE_OWNER, TABLE_NAME, TABLE_TYPE, and REMARKS. Refer to the DB2 CLI or ODBC documentation for more details. The arguments tableQualifier, tableOwner, tableName, and tableType are directly passed to the function and take their definitions from the function definition." | xif szTableQualfier szTableOwner szTableName szTableType rc | xif := self class xif. self startPrepare. self state: #executing. ["Begin unwind protection." | tqByteArray toByteArray tnByteArray ttByteArray | szTableQualfier := szTableOwner := szTableName := szTableType := nil. tableQualifier isNil ifFalse: [tqByteArray := tableQualifier asByteArrayEncoding: self connection encoding. szTableQualfier := tqByteArray perform: xif copyToHeapSelector]. tableOwner isNil ifFalse: [toByteArray := tableOwner asByteArrayEncoding: self connection encoding. szTableOwner := toByteArray perform: xif copyToHeapSelector]. tableName isNil ifFalse: [tnByteArray := tableName asByteArrayEncoding: self connection encoding. szTableName := tnByteArray perform: xif copyToHeapSelector]. tableType isNil ifFalse: [ttByteArray := tableType asByteArrayEncoding: self connection encoding. szTableType := ttByteArray perform: xif copyToHeapSelector]. rc := xif SQLTables: self hstmt with: szTableQualfier with: tqByteArray size with: szTableOwner with: toByteArray size with: szTableName with: tnByteArray size with: szTableType with: ttByteArray size. (rc == xif SQL_SUCCESS or: [rc == xif SQL_SUCCESS_WITH_INFO]) ifFalse: [| errs | errs := self getStatementErrors. self resultsCache: errs. self connection class unableToFetchDataSignal raiseWith: errs errorString: errs first dbmsErrorString] "End unwind protection."] ensure: [szTableQualfier notNil ifTrue: [szTableQualfier freePointer]. szTableOwner notNil ifTrue: [szTableOwner freePointer]. szTableName notNil ifTrue: [szTableName freePointer]. szTableType notNil ifTrue: [szTableType freePointer]]
</methods> <methods> Database.DB2Session <category>printing</category>
printOn: aStream | hstmt | super printOn: aStream. (hstmt := self hstmt) isNil ifFalse: [ aStream nextPutAll: '( hstmt = '; nextPutAll: (hstmt printStringRadix: 16); nextPutAll: ' )' ]
</methods> <methods> Database.DB2Session <category>private-tracing</category>
traceLevel ^traceLevel
</methods> <methods> Database.DB2Session <category>initialize-release</category>
initialize paramSetSize:=0. bindValuePointersHolder:=nil asValue. pRowsFetchedHolder:=nil asValue. hstmtHolder := nil asValue. mustResendQueryHolder := false asValue. mustCloseCursorHolder := false asValue. deferCursorClosing := false. sqlStatementAttributeCache := IdentityDictionary new. self setMaxLongData: DefaultMaxLongData. answerBlob:=true. self rowStatus: nil. super initialize.
</methods> <methods> Database.DB2Session class <category>accessing</category>
bufferClass "Answer the class to use for bindInput/Output objects associated with receiver." ^DB2Buffer
connectionClass "Answer the class to use for connection objects associated with receiver." ^DB2Connection
defaultMaxLongData ^DefaultMaxLongData
defaultMaxLongData: anInteger DefaultMaxLongData := anInteger
largeObjectBufferClass "Answer the class to use for bindInput/Output objects associated with receiver." ^DB2LargeObjectBuffer
</methods> <methods> Database.DB2Session class <category>class initialization</category>
initialize "DB2Session initialize" self initRegistry. DefaultMaxLongData := 16777216. "Default to 16 megs of long data" self initializeSQLStatementAttributeConversionMap. self install.
initializeSQLStatementAttributeConversionMap "DB2Session initializeSQLStatementAttributeConversionMap" (SQLStatementAttributeConversionMap := IdentityDictionary new) add: #SQL_ATTR_ASYNC_ENABLE->#longAt:; add: #SQL_ATTR_ROW_BIND_TYPE->#longAt:; add: #SQL_ATTR_CURSOR_TYPE->#longAt:; add: #SQL_ATTR_MAX_LENGTH->#longAt:; add: #SQL_ATTR_MAX_ROWS->#longAt:; add: #SQL_ATTR_NOSCAN->#longAt:; add: #SQL_ATTR_ROWS_FETCHED_PTR->#longAt:; add: #SQL_ATTR_ROW_ARRAY_SIZE->#longAt:; add: #SQL_ATTR_CLOSEOPEN->#longAt:
</methods> <methods> Database.DB2Session class <category>private-activation</category>
install self bufferClass install.
</methods> <methods> Database.DB2Session class <category>private-registry</category>
registry ^RegisteredDB2Sessions
registry: aCollection RegisteredDB2Sessions := aCollection
</methods> <methods> Database.DB2ColumnDescription <category>accessing</category>
fileRef "Return the DB2LOBFileReference instance" ^fileRef
fileRef: aFileRef fileRef := aFileRef
fSqlType "Return the receiver's SQL type" ^fSqlType
</methods> <methods> Database.DB2ColumnDescription <category>private-accessing</category>
fSqlType: aSmallInteger "Set the receiver's SQL type." fSqlType := aSmallInteger
</methods> <methods> Database.DB2ColumnDescription <category>testing</category>
isLong "Answer true if the receiver represents a long result column." | xif | xif := self class connectionClass xif. ^(fSqlType == xif SQL_CLOB or: [fSqlType == xif SQL_BLOB ]) and: [self maxColumnConstraint > xif getDataChunkSize ]
</methods> <methods> Database.DB2ColumnDescription class <category>accessing</category>
connectionClass ^DB2Connection
</methods> <methods> Database.DB2BLOBLocator <category>private-db2</category>
db2Conversion ^#BlobLocator
locatorCType ^31 "SQL_C_BLOB_LOCATOR"
targetCType "need for SQLGetSubString " ^-2 "SQL_C_BINARY"
</methods> <methods> Database.DB2Transaction <category>private-finalization</category>
acquireExternal ^self
beginExternal ^self
commitExternal ^self
dismissExternal ^self
rollbackExternal ^self
</methods> <methods> Database.DB2Transaction <category>private-execution</category>
executor ^self shouldNotImplement
finalizeExternal ^self shouldNotImplement
key ^self shouldNotImplement
</methods> <methods> Database.DB2Transaction class <category>accessing</category>
connectionClass "Answer the class to use for connection objects associated with receiver." ^DB2Connection
</methods> <methods> Database.DB2Transaction class <category>private-registry</category>
registry: aCollection ^self shouldNotImplement
</methods> <methods> Database.DB2LargeObjectBuffer <category>private-data conversion {put}</category>
at: index putByteArray: aByteArray "Put aByteArray into the buffer." | bytes | (bytes := aByteArray size) > cbColDef ifTrue: [ self rebind: aByteArray. bytes > cbColDef ifTrue: [self connectionClass unableToBindSignal raise] ]. bufferPointer copyAt: ((index-1) * elementSize) from: aByteArray "contents" size: bytes startingAt: 1. pcbValue at: (index-1) put: bytes. ^aByteArray
at: index putString: aString "Put aString into the buffer." | str bytes | aString size > cbColDef ifTrue: [ self rebind: aString. aString size > cbColDef ifTrue: [self connectionClass unableToBindSignal raise] ]. str := aString "contents" asByteArrayEncoding: self encoding. bufferPointer copyAt: ((index-1) * elementSize) from: str size: (bytes := str size) startingAt: 1. pcbValue at: (index-1) put: bytes. ^aString
</methods> <methods> Database.DB2LargeObjectBuffer <category>accessing</category>
blobBuffer ^blobBuffer
blobBufferSize ^blobBufferSize
</methods> <methods> Database.DB2LargeObjectBuffer <category>initialize-release</category>
descriptor: aColDesc position: position session: session "Initialize an instance of receiver for LOB handling with locator" | valueType | valueType:=aColDesc type. count:= session blockFactor. maxLongData := session getMaxLongData. databaseType := (valueType == #LargeString) ifTrue: [#ClobLocator] ifFalse: [#BlobLocator]. "locator type" cbColDef := 0. "0 for locator" bufferIndex := position. hstmt := session hstmt. connection:= session connection. elementSize := 4. "4 for locator" blobBufferSize:= (FetchBufferSizeBlocks at: aColDesc type) value: aColDesc precision. self encoding: session connection encoding. getSelector := GetSelectorMap at: valueType ifAbsent: [nil]. putSelector := PutSelectorMap at: valueType ifAbsent: [nil]. conversionBuffer := (ConversionBufferMap at: databaseType) notNil ifTrue: [(ConversionBufferMap at: databaseType) new: elementSize].
</methods> <methods> Database.DB2LargeObjectBuffer <category>allocation</category>
free "Free the receiver." blobBuffer notNil ifTrue: [ blobBuffer freePointer. blobBuffer := nil ]. super free.
mallocUsingSelector: mallocSelector "Allocate a physical buffer for the receiver. Use mallocSelector to perform the allocation." [ "Begin unwind protection." super mallocUsingSelector: mallocSelector. blobBufferSize notNil ifTrue: [ blobBuffer := CIntegerType char perform: mallocSelector with: blobBufferSize]. "End unwind protection." ] ifCurtailed: [ self free ]
</methods> <methods> Database.DB2LargeObjectBuffer <category>private-data conversion {get}</category>
getByteArrayAt: index "Answer a ByteArray populated from the buffer." | loc len result copyIndex maxBytesToCopy | loc:=self getBlobLocatorAt: index. len:=self connection getLOBLength: loc buffer: self. copyIndex:=1. maxBytesToCopy:= maxLongData min: len. result := ByteArray new: maxBytesToCopy. [copyIndex >= maxBytesToCopy ] whileFalse: [len := ((maxBytesToCopy - copyIndex)+1 min: blobBufferSize). self connection getLOBSubString: loc from: copyIndex length: len buffer: self. blobBuffer copyAt: 0 to: result size: len startingAt: copyIndex. copyIndex:=copyIndex+len]. ^result
getStringAt: index "Answer a String populated from the buffer." | loc len result copyIndex maxBytesToCopy | loc:=self getBlobLocatorAt: index. len:=(self connection getLOBLength: loc buffer: self). copyIndex:=1. maxBytesToCopy:= maxLongData min: len. result := ByteArray new: maxBytesToCopy. [copyIndex >= maxBytesToCopy ] whileFalse: [len := ((maxBytesToCopy - copyIndex)+1 min: blobBufferSize - 1). "need for null terminator" self connection getLOBSubString: loc from: copyIndex length: len buffer: self. blobBuffer copyAt: 0 to: result size: len startingAt: copyIndex. copyIndex:=copyIndex+len]. ^result asStringEncoding: self encoding
</methods> <methods> Database.DB2LargeObjectBuffer <category>testing</category>
isLargeObject ^true
</methods> <methods> Core.Integer <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Integer
</methods> <methods> Core.String <category>private-db2</category>
asBooleanForDB2 "Try to interpret the string as a Boolean using a common Cobol paradigm. Treat the value as null if it doesn't match the encoded value for true or false." self size == 1 ifTrue: [ self = 'Y' ifTrue: [ ^true ]. self = 'N' ifTrue: [ ^false ] ]. ^nil
</methods> <methods> Core.Object <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses. The default is no conversion is defined" ^nil
</methods> <methods> Core.FixedPoint class <category>private-db2</category>
readDB2DecimalFrom: aStream "Answer an instance of me as described on the stream, aStream." | value neg precision num den digit | (aStream atEnd or: [aStream peek isLetter]) ifTrue: [^0]. neg := aStream peekFor: $-. value := self readIntegerFrom: aStream radix: 10. precision := 0. num := 0. den := 1. ((aStream peekFor: $.) or: [aStream peekFor: $,]) ifTrue: ["<integer>.<fraction>" (aStream atEnd not and: [aStream peek isDigit]) ifTrue: [ [aStream atEnd or: [(digit := aStream next) isDigit not]] whileFalse: [num := num * 10 + digit digitValue. precision := precision + 1]. den := 10 ** precision]]. value := value + (num / den). value := self basicNew setNumerator: value numerator denominator: value denominator scale: precision. ^neg ifTrue: [value negated] ifFalse: [value]
</methods> <methods> Core.FixedPoint <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#FixedPoint
</methods> <methods> Core.ByteArray <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^self size > 32700 ifTrue: [#LargeByteArray] ifFalse: [#ByteArray]
</methods> <methods> OS.BufferedExternalStream <category>private-db2</category>
db2Conversion ^self isBinary ifTrue: [^#LargeByteArray ] ifFalse: [^#LargeString ]
</methods> <methods> Core.LargeInteger class <category>type semantics</category>
recordTemplate ^self new: 8 neg: false
</methods> <methods> Core.LargeInteger <category>private-db2</category>
db2Conversion ^#LargeInteger
</methods> <methods> Core.Double <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Double
</methods> <methods> Core.Timestamp <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Timestamp
</methods> <methods> Core.UndefinedObject <category>private-db2</category>
printStringForDB2 ^' '
</methods> <methods> Core.Boolean <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Boolean
printStringForDB2 "Encode receiver in one character ." ^self ifTrue: [ 'Y' ] ifFalse: [ 'N' ]
</methods> <methods> Core.Time class <category>instance creation</category>
recordTemplate ^self fromSeconds: 0
zero ^self fromSeconds: 0
</methods> <methods> Core.Time <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Time
</methods> <methods> Core.Float <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Float
</methods> <methods> Core.PositionableStream <category>private-db2</category>
db2Conversion (collection isKindOf: ByteArray ) ifTrue: [^#LargeByteArray ]. (collection isKindOf: CharacterArray ) ifTrue: [^#LargeString ]. self error: 'The receiver does not have an appropriate DB2 conversion type.'
</methods> <methods> Core.Date class <category>instance creation</category>
recordTemplate ^self newDay: 1 year: 1
</methods> <methods> Core.Date <category>private-db2</category>
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^#Date
</methods> <methods> Core.CharacterArray <category>private-db2</category>
avbTrimBlanks "Answer a String containing the receiver string with leading and trailing blanks removed. Sample: ' asdasd sdfsdf sdfdsf ' trimBlanks 'asdasd sdfsdf sdfdsf' " | start end done | (end := self size) == 0 ifTrue: [^self]. start := 1. done := false. [(self at: start) ~~ Character space or: [done := start == end]] whileFalse: [start := start + 1]. done ifTrue: [^'']. [(self at: end) ~~ Character space or: [done := start == end]] whileFalse: [end := end - 1]. ^done ifTrue: [''] ifFalse: [self copyFrom: start to: end]
db2Conversion "Answer the symbolic conversion name for instances of this class or subclasses." ^self size > 32700 ifTrue: [#LargeString] ifFalse: [#String]
</methods> <methods> Database.DB2APIInterface <category>procedures</category>
db2DatabaseRestart: versionNumber with: pParmStruct with: pSqlca <C: int __stdcall db2DatabaseRestart(db2Uint32 versionNumber, void * pParmStruct, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqlaintp_api: pBuffer with: BufferSize with: LineWidth with: pMsgFileName with: pSqlca <C: int __stdcall sqlaintp_api(char * pBuffer, short BufferSize, short LineWidth, char * pMsgFileName, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqleatin_api: pNodeName with: pUserName with: pPassword with: pSqlca "sqleatin - Attach" <C: int __stdcall sqleatin_api(char * pNodeName, char * pUserName, char * pPassword, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqledcls_api: Handle with: pSqlca "sqledcls - Close Database Directory Scan" <C: int __stdcall sqledcls_api(unsigned short Handle, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqledgne_api: Handle with: ppDbDirEntry with: pSqlca "sqledgne - Get Next Database Directory Entry" <C: int __stdcall sqledgne_api(unsigned short Handle, struct sqledinfo * * ppDbDirEntry, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqledosd_api: pPath with: pHandle with: pNumEntries with: pSqlca "sqledosd - Open Database Directory Scan" <C: int __stdcall sqledosd_api(char * pPath, unsigned short * pHandle, unsigned short * pNumEntries, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqledtin_api: pSqlca "sqledtin - Detach" <C: int __stdcall sqledtin_api(struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqlefrce_api: NumAgentIds with: pAgentIds with: ForceMode with: pSqlca <C: int __stdcall sqlefrce_api(sqlint32 NumAgentIds, sqluint32 * pAgentIds, unsigned short ForceMode, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqlepstart_api: pStartOptions with: pSqlca <C: int __stdcall sqlepstart_api(struct sqle_start_options * pStartOptions, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqlepstp_api: pStopOptions with: pSqlca <C: int __stdcall sqlepstp_api(struct sqledbstopopt * pStopOptions, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
sqlogstt: pBuffer with: BufferSize with: LineWidth with: pSqlstate <C: int __stdcall sqlogstt(char * pBuffer, short BufferSize, short LineWidth, char * pSqlstate)> ^self externalAccessFailedWith: _errorCode
sqlustat_api: pTableName with: NumIndexes with: ppIndexList with: StatsOption with: ShareLevel with: pSqlca <C: int __stdcall sqlustat_api(char * pTableName, unsigned short NumIndexes, char * * ppIndexList, unsigned char StatsOption, unsigned char ShareLevel, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
</methods> <methods> Database.DB2CLIInterface <category>procedures</category>
SQLAllocConnect: henv with: phdbc <C: SQLRETURN __stdcall SQLAllocConnect(SQLHENV henv, SQLHDBC * phdbc)> ^self externalAccessFailedWith: _errorCode
SQLAllocEnv: phenv <C: SQLRETURN __stdcall SQLAllocEnv(SQLHENV * phenv)> ^self externalAccessFailedWith: _errorCode
SQLAllocHandle: fHandleType with: hInput with: phOutput <C: SQLRETURN __stdcall SQLAllocHandle(SQLSMALLINT fHandleType, SQLHANDLE hInput, SQLHANDLE * phOutput)> ^self externalAccessFailedWith: _errorCode
SQLAllocHandleStd: fHandleType with: hInput with: phOutput <C: SQLRETURN __stdcall SQLAllocHandleStd(SQLSMALLINT fHandleType, SQLHANDLE hInput, SQLHANDLE * phOutput)> ^self externalAccessFailedWith: _errorCode
SQLAllocStmt: hdbc with: phstmt <C: SQLRETURN __stdcall SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT * phstmt)> ^self externalAccessFailedWith: _errorCode
SQLBindCol: hstmt with: icol with: fCType with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLBindCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLBindFileToCol: hstmt with: icol with: FileName with: FileNameLength with: FileOptions with: MaxFileNameLength with: StringLength with: IndicatorValue <C: SQLRETURN __stdcall SQLBindFileToCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLCHAR * FileName, SQLSMALLINT * FileNameLength, SQLUINTEGER * FileOptions, SQLSMALLINT MaxFileNameLength, SQLINTEGER * StringLength, SQLINTEGER * IndicatorValue)> ^self externalAccessFailedWith: _errorCode
SQLBindFileToParam: hstmt with: ipar with: fSqlType with: FileName with: FileNameLength with: FileOptions with: MaxFileNameLength with: IndicatorValue <C: SQLRETURN __stdcall SQLBindFileToParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fSqlType, SQLCHAR * FileName, SQLSMALLINT * FileNameLength, SQLUINTEGER * FileOptions, SQLSMALLINT MaxFileNameLength, SQLINTEGER * IndicatorValue)> ^self externalAccessFailedWith: _errorCode
SQLBindParam: StatementHandle with: ParameterNumber with: ValueType with: ParameterType with: LengthPrecision with: ParameterScale with: ParameterValue with: StrLen_or_Ind <C: SQLRETURN __stdcall SQLBindParam(SQLHSTMT StatementHandle, SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType, SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision, SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue, SQLINTEGER * StrLen_or_Ind)> ^self externalAccessFailedWith: _errorCode
SQLBindParameter: hstmt with: ipar with: fParamType with: fCType with: fSqlType with: cbColDef with: ibScale with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLBrowseConnect: hdbc with: szConnStrIn with: cbConnStrIn with: szConnStrOut with: cbConnStrOutMax with: pcbConnStrOut <C: SQLRETURN __stdcall SQLBrowseConnect(SQLHDBC hdbc, SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOut)> ^self externalAccessFailedWith: _errorCode
SQLBrowseConnectW: hdbc with: szConnStrIn with: cbConnStrIn with: szConnStrOut with: cbConnStrOutMax with: pcbConnStrOut <C: SQLRETURN __stdcall SQLBrowseConnectW(SQLHDBC hdbc, SQLWCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLWCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOut)> ^self externalAccessFailedWith: _errorCode
SQLBuildDataLink: hStmt with: pszLinkType with: cbLinkType with: pszDataLocation with: cbDataLocation with: pszComment with: cbComment with: pDataLink with: cbDataLinkMax with: pcbDataLink <C: SQLRETURN __stdcall SQLBuildDataLink(SQLHSTMT hStmt, SQLCHAR * pszLinkType, SQLINTEGER cbLinkType, SQLCHAR * pszDataLocation, SQLINTEGER cbDataLocation, SQLCHAR * pszComment, SQLINTEGER cbComment, SQLCHAR * pDataLink, SQLINTEGER cbDataLinkMax, SQLINTEGER * pcbDataLink)> ^self externalAccessFailedWith: _errorCode
SQLBulkOperations: StatementHandle with: Operation <C: SQLRETURN __stdcall SQLBulkOperations(SQLHSTMT StatementHandle, SQLSMALLINT Operation)> ^self externalAccessFailedWith: _errorCode
SQLCancel: hstmt <C: SQLRETURN __stdcall SQLCancel(SQLHSTMT hstmt)> ^self externalAccessFailedWith: _errorCode
SQLCloseCursor: hStmt <C: SQLRETURN __stdcall SQLCloseCursor(SQLHSTMT hStmt)> ^self externalAccessFailedWith: _errorCode
SQLColAttribute: hstmt with: icol with: fDescType with: rgbDesc with: cbDescMax with: pcbDesc with: pfDesc <C: SQLRETURN __stdcall SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT * pcbDesc, SQLPOINTER pfDesc)> ^self externalAccessFailedWith: _errorCode
SQLColAttributes: hstmt with: icol with: fDescType with: rgbDesc with: cbDescMax with: pcbDesc with: pfDesc <C: SQLRETURN __stdcall SQLColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT * pcbDesc, SQLINTEGER * pfDesc)> ^self externalAccessFailedWith: _errorCode
SQLColAttributesW: hstmt with: icol with: fDescType with: rgbDesc with: cbDescMax with: pcbDesc with: pfDesc <C: SQLRETURN __stdcall SQLColAttributesW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT * pcbDesc, SQLINTEGER * pfDesc)> ^self externalAccessFailedWith: _errorCode
SQLColAttributeW: hstmt with: iCol with: iField with: pCharAttr with: cbCharAttrMax with: pcbCharAttr with: pNumAttr <C: SQLRETURN __stdcall SQLColAttributeW(SQLHSTMT hstmt, SQLUSMALLINT iCol, SQLUSMALLINT iField, SQLPOINTER pCharAttr, SQLSMALLINT cbCharAttrMax, SQLSMALLINT * pcbCharAttr, SQLPOINTER pNumAttr)> ^self externalAccessFailedWith: _errorCode
SQLColumnPrivileges: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLColumnPrivileges(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLColumnPrivilegesW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLColumnPrivilegesW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName, SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLColumns: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLColumns(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLColumnsW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLColumnsW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName, SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLConnect: hdbc with: szDSN with: cbDSN with: szUID with: cbUID with: szAuthStr with: cbAuthStr <C: SQLRETURN __stdcall SQLConnect(SQLHDBC hdbc, SQLCHAR * szDSN, SQLSMALLINT cbDSN, SQLCHAR * szUID, SQLSMALLINT cbUID, SQLCHAR * szAuthStr, SQLSMALLINT cbAuthStr)> ^self externalAccessFailedWith: _errorCode
SQLConnectWInt: hdbc with: szDSN with: cbDSN with: szUID with: cbUID with: szAuthStr with: cbAuthStr <C: SQLRETURN __stdcall SQLConnectWInt(SQLHDBC hdbc, SQLWCHAR * szDSN, SQLSMALLINT cbDSN, SQLWCHAR * szUID, SQLSMALLINT cbUID, SQLWCHAR * szAuthStr, SQLSMALLINT cbAuthStr)> ^self externalAccessFailedWith: _errorCode
SQLCopyDesc: hDescSource with: hDescTarget <C: SQLRETURN __stdcall SQLCopyDesc(SQLHDESC hDescSource, SQLHDESC hDescTarget)> ^self externalAccessFailedWith: _errorCode
SQLDataSources: henv with: fDirection with: szDSN with: cbDSNMax with: pcbDSN with: szDescription with: cbDescriptionMax with: pcbDescription <C: SQLRETURN __stdcall SQLDataSources(SQLHENV henv, SQLUSMALLINT fDirection, SQLCHAR * szDSN, SQLSMALLINT cbDSNMax, SQLSMALLINT * pcbDSN, SQLCHAR * szDescription, SQLSMALLINT cbDescriptionMax, SQLSMALLINT * pcbDescription)> ^self externalAccessFailedWith: _errorCode
SQLDataSourcesW: henv with: fDirection with: szDSN with: cbDSNMax with: pcbDSN with: szDescription with: cbDescriptionMax with: pcbDescription <C: SQLRETURN __stdcall SQLDataSourcesW(SQLHENV henv, SQLUSMALLINT fDirection, SQLWCHAR * szDSN, SQLSMALLINT cbDSNMax, SQLSMALLINT * pcbDSN, SQLWCHAR * szDescription, SQLSMALLINT cbDescriptionMax, SQLSMALLINT * pcbDescription)> ^self externalAccessFailedWith: _errorCode
SQLDescribeCol: hstmt with: icol with: szColName with: cbColNameMax with: pcbColName with: pfSqlType with: pcbColDef with: pibScale with: pfNullable <C: SQLRETURN __stdcall SQLDescribeCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT * pcbColName, SQLSMALLINT * pfSqlType, SQLUINTEGER * pcbColDef, SQLSMALLINT * pibScale, SQLSMALLINT * pfNullable)> ^self externalAccessFailedWith: _errorCode
SQLDescribeColW: hstmt with: icol with: szColName with: cbColNameMax with: pcbColName with: pfSqlType with: pcbColDef with: pibScale with: pfNullable <C: SQLRETURN __stdcall SQLDescribeColW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLWCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT * pcbColName, SQLSMALLINT * pfSqlType, SQLUINTEGER * pcbColDef, SQLSMALLINT * pibScale, SQLSMALLINT * pfNullable)> ^self externalAccessFailedWith: _errorCode
SQLDescribeParam: hstmt with: ipar with: pfSqlType with: pcbParamDef with: pibScale with: pfNullable <C: SQLRETURN __stdcall SQLDescribeParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT * pfSqlType, SQLUINTEGER * pcbParamDef, SQLSMALLINT * pibScale, SQLSMALLINT * pfNullable)> ^self externalAccessFailedWith: _errorCode
SQLDisconnect: hdbc <C: SQLRETURN __stdcall SQLDisconnect(SQLHDBC hdbc)> ^self externalAccessFailedWith: _errorCode
SQLDriverConnect: hdbc with: hwnd with: szConnStrIn with: cbConnStrIn with: szConnStrOut with: cbConnStrOutMax with: pcbConnStrOut with: fDriverCompletion <C: SQLRETURN __stdcall SQLDriverConnect(SQLHDBC hdbc, SQLHWND hwnd, SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOut, SQLUSMALLINT fDriverCompletion)> ^self externalAccessFailedWith: _errorCode
SQLDriverConnectW: hdbc with: hwnd with: szConnStrIn with: cbConnStrIn with: szConnStrOut with: cbConnStrOutMax with: pcbConnStrOut with: fDriverCompletion <C: SQLRETURN __stdcall SQLDriverConnectW(SQLHDBC hdbc, SQLHWND hwnd, SQLWCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLWCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOut, SQLUSMALLINT fDriverCompletion)> ^self externalAccessFailedWith: _errorCode
SQLDrivers: henv with: fDirection with: szDriverDesc with: cbDriverDescMax with: pcbDriverDesc with: szDriverAttributes with: cbDrvrAttrMax with: pcbDrvrAttr <C: SQLRETURN __stdcall SQLDrivers(SQLHENV henv, SQLUSMALLINT fDirection, SQLCHAR * szDriverDesc, SQLSMALLINT cbDriverDescMax, SQLSMALLINT * pcbDriverDesc, SQLCHAR * szDriverAttributes, SQLSMALLINT cbDrvrAttrMax, SQLSMALLINT * pcbDrvrAttr)> ^self externalAccessFailedWith: _errorCode
SQLEndTran: fHandleType with: hHandle with: fType <C: SQLRETURN __stdcall SQLEndTran(SQLSMALLINT fHandleType, SQLHANDLE hHandle, SQLSMALLINT fType)> ^self externalAccessFailedWith: _errorCode
SQLError: henv with: hdbc with: hstmt with: szSqlState with: pfNativeError with: szErrorMsg with: cbErrorMsgMax with: pcbErrorMsg <C: SQLRETURN __stdcall SQLError(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, SQLCHAR * szSqlState, SQLINTEGER * pfNativeError, SQLCHAR * szErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT * pcbErrorMsg)> ^self externalAccessFailedWith: _errorCode
SQLErrorW: henv with: hdbc with: hstmt with: szSqlState with: pfNativeError with: szErrorMsg with: cbErrorMsgMax with: pcbErrorMsg <C: SQLRETURN __stdcall SQLErrorW(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, SQLWCHAR * szSqlState, SQLINTEGER * pfNativeError, SQLWCHAR * szErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT * pcbErrorMsg)> ^self externalAccessFailedWith: _errorCode
SQLExecDirect: hstmt with: szSqlStr with: cbSqlStr <C: SQLRETURN __stdcall SQLExecDirect(SQLHSTMT hstmt, SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLExecDirectW: hstmt with: szSqlStr with: cbSqlStr <C: SQLRETURN __stdcall SQLExecDirectW(SQLHSTMT hstmt, SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLExecute: hstmt <C: SQLRETURN __stdcall SQLExecute(SQLHSTMT hstmt)> ^self externalAccessFailedWith: _errorCode
SQLExtendedBind: hstmt with: fBindCol with: cRecords with: pfCType with: rgbValue with: cbValueMax with: puiPrecisionCType with: psScaleCType with: pcbValue with: piIndicatorPtr with: pfParamType with: pfSQLType with: pcbColDef with: pibScale <C: SQLRETURN __stdcall SQLExtendedBind(SQLHSTMT hstmt, SQLSMALLINT fBindCol, SQLSMALLINT cRecords, SQLSMALLINT * pfCType, SQLPOINTER * rgbValue, SQLINTEGER * cbValueMax, SQLUINTEGER * puiPrecisionCType, SQLSMALLINT * psScaleCType, SQLINTEGER * * pcbValue, SQLINTEGER * * piIndicatorPtr, SQLSMALLINT * pfParamType, SQLSMALLINT * pfSQLType, SQLUINTEGER * pcbColDef, SQLSMALLINT * pibScale)> ^self externalAccessFailedWith: _errorCode
SQLExtendedFetch: hstmt with: fFetchType with: irow with: pcrow with: rgfRowStatus <C: SQLRETURN __stdcall SQLExtendedFetch(SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLINTEGER irow, SQLUINTEGER * pcrow, SQLUSMALLINT * rgfRowStatus)> ^self externalAccessFailedWith: _errorCode
SQLExtendedPrepare: hstmt with: pszSqlStmt with: cbSqlStmt with: cPars with: sStmtType with: cStmtAttrs with: piStmtAttr with: pvParams <C: SQLRETURN __stdcall SQLExtendedPrepare(SQLHSTMT hstmt, SQLCHAR * pszSqlStmt, SQLINTEGER cbSqlStmt, SQLINTEGER cPars, SQLSMALLINT sStmtType, SQLINTEGER cStmtAttrs, SQLINTEGER * piStmtAttr, SQLINTEGER * pvParams)> ^self externalAccessFailedWith: _errorCode
SQLFetch: hstmt <C: SQLRETURN __stdcall SQLFetch(SQLHSTMT hstmt)> ^self externalAccessFailedWith: _errorCode
SQLFetchScroll: StatementHandle with: FetchOrientation with: FetchOffset <C: SQLRETURN __stdcall SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)> ^self externalAccessFailedWith: _errorCode
SQLForeignKeys: hstmt with: szPkCatalogName with: cbPkCatalogName with: szPkSchemaName with: cbPkSchemaName with: szPkTableName with: cbPkTableName with: szFkCatalogName with: cbFkCatalogName with: szFkSchemaName with: cbFkSchemaName with: szFkTableName with: cbFkTableName <C: SQLRETURN __stdcall SQLForeignKeys(SQLHSTMT hstmt, SQLCHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName, SQLCHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName, SQLCHAR * szPkTableName, SQLSMALLINT cbPkTableName, SQLCHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName, SQLCHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName, SQLCHAR * szFkTableName, SQLSMALLINT cbFkTableName)> ^self externalAccessFailedWith: _errorCode
SQLForeignKeysW: hstmt with: szPkCatalogName with: cbPkCatalogName with: szPkSchemaName with: cbPkSchemaName with: szPkTableName with: cbPkTableName with: szFkCatalogName with: cbFkCatalogName with: szFkSchemaName with: cbFkSchemaName with: szFkTableName with: cbFkTableName <C: SQLRETURN __stdcall SQLForeignKeysW(SQLHSTMT hstmt, SQLWCHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName, SQLWCHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName, SQLWCHAR * szPkTableName, SQLSMALLINT cbPkTableName, SQLWCHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName, SQLWCHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName, SQLWCHAR * szFkTableName, SQLSMALLINT cbFkTableName)> ^self externalAccessFailedWith: _errorCode
SQLFreeConnect: hdbc <C: SQLRETURN __stdcall SQLFreeConnect(SQLHDBC hdbc)> ^self externalAccessFailedWith: _errorCode
SQLFreeEnv: henv <C: SQLRETURN __stdcall SQLFreeEnv(SQLHENV henv)> ^self externalAccessFailedWith: _errorCode
SQLFreeHandle: fHandleType with: hHandle <C: SQLRETURN __stdcall SQLFreeHandle(SQLSMALLINT fHandleType, SQLHANDLE hHandle)> ^self externalAccessFailedWith: _errorCode
SQLFreeStmt: hstmt with: fOption <C: SQLRETURN __stdcall SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption)> ^self externalAccessFailedWith: _errorCode
SQLGetConnectAttr: ConnectionHandle with: Attribute with: Value with: BufferLength with: StringLength <C: SQLRETURN __stdcall SQLGetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)> ^self externalAccessFailedWith: _errorCode
SQLGetConnectAttrW: hdbc with: fAttribute with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLGetConnectAttrW(SQLHDBC hdbc, SQLINTEGER fAttribute, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLGetConnectOption: hdbc with: fOption with: pvParam <C: SQLRETURN __stdcall SQLGetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam)> ^self externalAccessFailedWith: _errorCode
SQLGetCursorName: hstmt with: szCursor with: cbCursorMax with: pcbCursor <C: SQLRETURN __stdcall SQLGetCursorName(SQLHSTMT hstmt, SQLCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT * pcbCursor)> ^self externalAccessFailedWith: _errorCode
SQLGetCursorNameW: hstmt with: szCursor with: cbCursorMax with: pcbCursor <C: SQLRETURN __stdcall SQLGetCursorNameW(SQLHSTMT hstmt, SQLWCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT * pcbCursor)> ^self externalAccessFailedWith: _errorCode
SQLGetData: hstmt with: icol with: fCType with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLGetData(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLGetDataLinkAttr: hStmt with: fAttrType with: pDataLink with: cbDataLink with: pAttribute with: cbAttributeMax with: pcbAttribute <C: SQLRETURN __stdcall SQLGetDataLinkAttr(SQLHSTMT hStmt, SQLSMALLINT fAttrType, SQLCHAR * pDataLink, SQLINTEGER cbDataLink, SQLPOINTER pAttribute, SQLINTEGER cbAttributeMax, SQLINTEGER * pcbAttribute)> ^self externalAccessFailedWith: _errorCode
SQLGetDescField: DescriptorHandle with: RecNumber with: FieldIdentifier with: Value with: BufferLength with: StringLength <C: SQLRETURN __stdcall SQLGetDescField(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)> ^self externalAccessFailedWith: _errorCode
SQLGetDescFieldW: hdesc with: iRecord with: iField with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLGetDescFieldW(SQLHDESC hdesc, SQLSMALLINT iRecord, SQLSMALLINT iField, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLGetDescRec: DescriptorHandle with: RecNumber with: Name with: BufferLength with: StringLength with: Type with: SubType with: Length with: Precision with: Scale with: Nullable <C: SQLRETURN __stdcall SQLGetDescRec(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLCHAR * Name, SQLSMALLINT BufferLength, SQLSMALLINT * StringLength, SQLSMALLINT * Type, SQLSMALLINT * SubType, SQLINTEGER * Length, SQLSMALLINT * Precision, SQLSMALLINT * Scale, SQLSMALLINT * Nullable)> ^self externalAccessFailedWith: _errorCode
SQLGetDescRecW: hdesc with: iRecord with: szName with: cbNameMax with: pcbName with: pfType with: pfSubType with: pLength with: pPrecision with: pScale with: pNullable <C: SQLRETURN __stdcall SQLGetDescRecW(SQLHDESC hdesc, SQLSMALLINT iRecord, SQLWCHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT * pcbName, SQLSMALLINT * pfType, SQLSMALLINT * pfSubType, SQLINTEGER * pLength, SQLSMALLINT * pPrecision, SQLSMALLINT * pScale, SQLSMALLINT * pNullable)> ^self externalAccessFailedWith: _errorCode
SQLGetDiagField: fHandleType with: hHandle with: iRecNumber with: fDiagIdentifier with: pDiagInfo with: cbDiagInfoMax with: pcbDiagInfo <C: SQLRETURN __stdcall SQLGetDiagField(SQLSMALLINT fHandleType, SQLHANDLE hHandle, SQLSMALLINT iRecNumber, SQLSMALLINT fDiagIdentifier, SQLPOINTER pDiagInfo, SQLSMALLINT cbDiagInfoMax, SQLSMALLINT * pcbDiagInfo)> ^self externalAccessFailedWith: _errorCode
SQLGetDiagFieldW: fHandleType with: handle with: iRecord with: fDiagField with: rgbDiagInfo with: cbDiagInfoMax with: pcbDiagInfo <C: SQLRETURN __stdcall SQLGetDiagFieldW(SQLSMALLINT fHandleType, SQLHANDLE handle, SQLSMALLINT iRecord, SQLSMALLINT fDiagField, SQLPOINTER rgbDiagInfo, SQLSMALLINT cbDiagInfoMax, SQLSMALLINT * pcbDiagInfo)> ^self externalAccessFailedWith: _errorCode
SQLGetDiagRec: fHandleType with: hHandle with: iRecNumber with: pszSqlState with: pfNativeError with: pszErrorMsg with: cbErrorMsgMax with: pcbErrorMsg <C: SQLRETURN __stdcall SQLGetDiagRec(SQLSMALLINT fHandleType, SQLHANDLE hHandle, SQLSMALLINT iRecNumber, SQLCHAR * pszSqlState, SQLINTEGER * pfNativeError, SQLCHAR * pszErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT * pcbErrorMsg)> ^self externalAccessFailedWith: _errorCode
SQLGetDiagRecW: fHandleType with: handle with: iRecord with: szSqlState with: pfNativeError with: szErrorMsg with: cbErrorMsgMax with: pcbErrorMsg <C: SQLRETURN __stdcall SQLGetDiagRecW(SQLSMALLINT fHandleType, SQLHANDLE handle, SQLSMALLINT iRecord, SQLWCHAR * szSqlState, SQLINTEGER * pfNativeError, SQLWCHAR * szErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT * pcbErrorMsg)> ^self externalAccessFailedWith: _errorCode
SQLGetEnvAttr: henv with: Attribute with: Value with: BufferLength with: StringLength <C: SQLRETURN __stdcall SQLGetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)> ^self externalAccessFailedWith: _errorCode
SQLGetFunctions: hdbc with: fFunction with: pfExists <C: SQLRETURN __stdcall SQLGetFunctions(SQLHDBC hdbc, SQLUSMALLINT fFunction, SQLUSMALLINT * pfExists)> ^self externalAccessFailedWith: _errorCode
SQLGetInfo: hdbc with: fInfoType with: rgbInfoValue with: cbInfoValueMax with: pcbInfoValue <C: SQLRETURN __stdcall SQLGetInfo(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax, SQLSMALLINT * pcbInfoValue)> ^self externalAccessFailedWith: _errorCode
SQLGetInfoW: hdbc with: fInfoType with: rgbInfoValue with: cbInfoValueMax with: pcbInfoValue <C: SQLRETURN __stdcall SQLGetInfoW(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax, SQLSMALLINT * pcbInfoValue)> ^self externalAccessFailedWith: _errorCode
SQLGetLength: hstmt with: LocatorCType with: Locator with: StringLength with: IndicatorValue <C: SQLRETURN __stdcall SQLGetLength(SQLHSTMT hstmt, SQLSMALLINT LocatorCType, SQLINTEGER Locator, SQLINTEGER * StringLength, SQLINTEGER * IndicatorValue)> ^self externalAccessFailedWith: _errorCode
SQLGetPosition: hstmt with: LocatorCType with: SourceLocator with: SearchLocator with: SearchLiteral with: SearchLiteralLength with: FromPosition with: LocatedAt with: IndicatorValue <C: SQLRETURN __stdcall SQLGetPosition(SQLHSTMT hstmt, SQLSMALLINT LocatorCType, SQLINTEGER SourceLocator, SQLINTEGER SearchLocator, SQLCHAR * SearchLiteral, SQLINTEGER SearchLiteralLength, SQLUINTEGER FromPosition, SQLUINTEGER * LocatedAt, SQLINTEGER * IndicatorValue)> ^self externalAccessFailedWith: _errorCode
SQLGetSQLCA: henv with: hdbc with: hstmt with: pSqlca <C: SQLRETURN __stdcall SQLGetSQLCA(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, struct sqlca * pSqlca)> ^self externalAccessFailedWith: _errorCode
SQLGetStmtAttr: StatementHandle with: Attribute with: Value with: BufferLength with: StringLength <C: SQLRETURN __stdcall SQLGetStmtAttr(SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)> ^self externalAccessFailedWith: _errorCode
SQLGetStmtAttrW: hstmt with: fAttribute with: rgbValue with: cbValueMax with: pcbValue <C: SQLRETURN __stdcall SQLGetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER fAttribute, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLGetStmtOption: hstmt with: fOption with: pvParam <C: SQLRETURN __stdcall SQLGetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLPOINTER pvParam)> ^self externalAccessFailedWith: _errorCode
SQLGetSubString: hstmt with: LocatorCType with: SourceLocator with: FromPosition with: ForLength with: TargetCType with: rgbValue with: cbValueMax with: StringLength with: IndicatorValue <C: SQLRETURN __stdcall SQLGetSubString(SQLHSTMT hstmt, SQLSMALLINT LocatorCType, SQLINTEGER SourceLocator, SQLUINTEGER FromPosition, SQLUINTEGER ForLength, SQLSMALLINT TargetCType, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER * StringLength, SQLINTEGER * IndicatorValue)> ^self externalAccessFailedWith: _errorCode
SQLGetTypeInfo: hstmt with: fSqlType <C: SQLRETURN __stdcall SQLGetTypeInfo(SQLHSTMT hstmt, SQLSMALLINT fSqlType)> ^self externalAccessFailedWith: _errorCode
SQLMoreResults: hstmt <C: SQLRETURN __stdcall SQLMoreResults(SQLHSTMT hstmt)> ^self externalAccessFailedWith: _errorCode
SQLNativeSql: hdbc with: szSqlStrIn with: cbSqlStrIn with: szSqlStr with: cbSqlStrMax with: pcbSqlStr <C: SQLRETURN __stdcall SQLNativeSql(SQLHDBC hdbc, SQLCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER * pcbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLNativeSqlW: hdbc with: szSqlStrIn with: cbSqlStrIn with: szSqlStr with: cbSqlStrMax with: pcbSqlStr <C: SQLRETURN __stdcall SQLNativeSqlW(SQLHDBC hdbc, SQLWCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER * pcbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLNumParams: hstmt with: pcpar <C: SQLRETURN __stdcall SQLNumParams(SQLHSTMT hstmt, SQLSMALLINT * pcpar)> ^self externalAccessFailedWith: _errorCode
SQLNumResultCols: hstmt with: pccol <C: SQLRETURN __stdcall SQLNumResultCols(SQLHSTMT hstmt, SQLSMALLINT * pccol)> ^self externalAccessFailedWith: _errorCode
SQLParamData: hstmt with: prgbValue <C: SQLRETURN __stdcall SQLParamData(SQLHSTMT hstmt, SQLPOINTER * prgbValue)> ^self externalAccessFailedWith: _errorCode
SQLParamOptions: hstmt with: crow with: pirow <C: SQLRETURN __stdcall SQLParamOptions(SQLHSTMT hstmt, SQLUINTEGER crow, SQLUINTEGER * pirow)> ^self externalAccessFailedWith: _errorCode
SQLPrepare: hstmt with: szSqlStr with: cbSqlStr <C: SQLRETURN __stdcall SQLPrepare(SQLHSTMT hstmt, SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLPrepareW: hstmt with: szSqlStr with: cbSqlStr <C: SQLRETURN __stdcall SQLPrepareW(SQLHSTMT hstmt, SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)> ^self externalAccessFailedWith: _errorCode
SQLPrimaryKeys: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName <C: SQLRETURN __stdcall SQLPrimaryKeys(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName)> ^self externalAccessFailedWith: _errorCode
SQLPrimaryKeysW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName <C: SQLRETURN __stdcall SQLPrimaryKeysW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName)> ^self externalAccessFailedWith: _errorCode
SQLProcedureColumns: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szProcName with: cbProcName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLProcedureColumns(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szProcName, SQLSMALLINT cbProcName, SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLProcedureColumnsW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szProcName with: cbProcName with: szColumnName with: cbColumnName <C: SQLRETURN __stdcall SQLProcedureColumnsW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szProcName, SQLSMALLINT cbProcName, SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)> ^self externalAccessFailedWith: _errorCode
SQLProcedures: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szProcName with: cbProcName <C: SQLRETURN __stdcall SQLProcedures(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szProcName, SQLSMALLINT cbProcName)> ^self externalAccessFailedWith: _errorCode
SQLProceduresW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szProcName with: cbProcName <C: SQLRETURN __stdcall SQLProceduresW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szProcName, SQLSMALLINT cbProcName)> ^self externalAccessFailedWith: _errorCode
SQLPutData: hstmt with: rgbValue with: cbValue <C: SQLRETURN __stdcall SQLPutData(SQLHSTMT hstmt, SQLPOINTER rgbValue, SQLINTEGER cbValue)> ^self externalAccessFailedWith: _errorCode
SQLRowCount: hstmt with: pcrow <C: SQLRETURN __stdcall SQLRowCount(SQLHSTMT hstmt, SQLINTEGER * pcrow)> ^self externalAccessFailedWith: _errorCode
SQLSetColAttributes: hstmt with: icol with: pszColName with: cbColName with: fSQLType with: cbColDef with: ibScale with: fNullable <C: SQLRETURN __stdcall SQLSetColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLCHAR * pszColName, SQLSMALLINT cbColName, SQLSMALLINT fSQLType, SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLSMALLINT fNullable)> ^self externalAccessFailedWith: _errorCode
SQLSetConnectAttr: hdbc with: fOption with: pvParam with: fStrLen <C: SQLRETURN __stdcall SQLSetConnectAttr(SQLHDBC hdbc, SQLINTEGER fOption, SQLPOINTER pvParam, SQLINTEGER fStrLen)> ^self externalAccessFailedWith: _errorCode
SQLSetConnectAttrW: hdbc with: fAttribute with: rgbValue with: cbValue <C: SQLRETURN __stdcall SQLSetConnectAttrW(SQLHDBC hdbc, SQLINTEGER fAttribute, SQLPOINTER rgbValue, SQLINTEGER cbValue)> ^self externalAccessFailedWith: _errorCode
SQLSetConnection: hdbc <C: SQLRETURN __stdcall SQLSetConnection(SQLHDBC hdbc)> ^self externalAccessFailedWith: _errorCode
SQLSetConnectOption: hdbc with: fOption with: vParam <C: SQLRETURN __stdcall SQLSetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLUINTEGER vParam)> ^self externalAccessFailedWith: _errorCode
SQLSetCursorName: hstmt with: szCursor with: cbCursor <C: SQLRETURN __stdcall SQLSetCursorName(SQLHSTMT hstmt, SQLCHAR * szCursor, SQLSMALLINT cbCursor)> ^self externalAccessFailedWith: _errorCode
SQLSetCursorNameW: hstmt with: szCursor with: cbCursor <C: SQLRETURN __stdcall SQLSetCursorNameW(SQLHSTMT hstmt, SQLWCHAR * szCursor, SQLSMALLINT cbCursor)> ^self externalAccessFailedWith: _errorCode
SQLSetDescField: DescriptorHandle with: RecNumber with: FieldIdentifier with: Value with: BufferLength <C: SQLRETURN __stdcall SQLSetDescField(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, SQLPOINTER Value, SQLINTEGER BufferLength)> ^self externalAccessFailedWith: _errorCode
SQLSetDescFieldW: DescriptorHandle with: RecNumber with: FieldIdentifier with: Value with: BufferLength <C: SQLRETURN __stdcall SQLSetDescFieldW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, SQLPOINTER Value, SQLINTEGER BufferLength)> ^self externalAccessFailedWith: _errorCode
SQLSetDescRec: DescriptorHandle with: RecNumber with: Type with: SubType with: Length with: Precision with: Scale with: Data with: StringLength with: Indicator <C: SQLRETURN __stdcall SQLSetDescRec(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT Type, SQLSMALLINT SubType, SQLINTEGER Length, SQLSMALLINT Precision, SQLSMALLINT Scale, SQLPOINTER Data, SQLINTEGER * StringLength, SQLINTEGER * Indicator)> ^self externalAccessFailedWith: _errorCode
SQLSetEnvAttr: henv with: Attribute with: Value with: StringLength <C: SQLRETURN __stdcall SQLSetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER StringLength)> ^self externalAccessFailedWith: _errorCode
SQLSetParam: hstmt with: ipar with: fCType with: fSqlType with: cbParamDef with: ibScale with: rgbValue with: pcbValue <C: SQLRETURN __stdcall SQLSetParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLUINTEGER cbParamDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLINTEGER * pcbValue)> ^self externalAccessFailedWith: _errorCode
SQLSetPos: hstmt with: irow with: fOption with: fLock <C: SQLRETURN __stdcall SQLSetPos(SQLHSTMT hstmt, SQLUSMALLINT irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock)> ^self externalAccessFailedWith: _errorCode
SQLSetScrollOptions: hstmt with: fConcurrency with: crowKeyset with: crowRowset <C: SQLRETURN __stdcall SQLSetScrollOptions(SQLHSTMT hstmt, SQLUSMALLINT fConcurrency, SQLINTEGER crowKeyset, SQLUSMALLINT crowRowset)> ^self externalAccessFailedWith: _errorCode
SQLSetStmtAttr: hstmt with: fOption with: pvParam with: fStrLen <C: SQLRETURN __stdcall SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER fOption, SQLPOINTER pvParam, SQLINTEGER fStrLen)> ^self externalAccessFailedWith: _errorCode
SQLSetStmtAttrW: hstmt with: fAttribute with: rgbValue with: cbValueMax <C: SQLRETURN __stdcall SQLSetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER fAttribute, SQLPOINTER rgbValue, SQLINTEGER cbValueMax)> ^self externalAccessFailedWith: _errorCode
SQLSetStmtOption: hstmt with: fOption with: vParam <C: SQLRETURN __stdcall SQLSetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLUINTEGER vParam)> ^self externalAccessFailedWith: _errorCode
SQLSpecialColumns: hstmt with: fColType with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: fScope with: fNullable <C: SQLRETURN __stdcall SQLSpecialColumns(SQLHSTMT hstmt, SQLUSMALLINT fColType, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fScope, SQLUSMALLINT fNullable)> ^self externalAccessFailedWith: _errorCode
SQLSpecialColumnsW: hstmt with: fColType with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: fScope with: fNullable <C: SQLRETURN __stdcall SQLSpecialColumnsW(SQLHSTMT hstmt, SQLUSMALLINT fColType, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fScope, SQLUSMALLINT fNullable)> ^self externalAccessFailedWith: _errorCode
SQLStatistics: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: fUnique with: fAccuracy <C: SQLRETURN __stdcall SQLStatistics(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fUnique, SQLUSMALLINT fAccuracy)> ^self externalAccessFailedWith: _errorCode
SQLStatisticsW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: fUnique with: fAccuracy <C: SQLRETURN __stdcall SQLStatisticsW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fUnique, SQLUSMALLINT fAccuracy)> ^self externalAccessFailedWith: _errorCode
SQLTablePrivileges: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName <C: SQLRETURN __stdcall SQLTablePrivileges(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName)> ^self externalAccessFailedWith: _errorCode
SQLTablePrivilegesW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName <C: SQLRETURN __stdcall SQLTablePrivilegesW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName)> ^self externalAccessFailedWith: _errorCode
SQLTables: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szTableType with: cbTableType <C: SQLRETURN __stdcall SQLTables(SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLCHAR * szTableType, SQLSMALLINT cbTableType)> ^self externalAccessFailedWith: _errorCode
SQLTablesW: hstmt with: szCatalogName with: cbCatalogName with: szSchemaName with: cbSchemaName with: szTableName with: cbTableName with: szTableType with: cbTableType <C: SQLRETURN __stdcall SQLTablesW(SQLHSTMT hstmt, SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR * szTableName, SQLSMALLINT cbTableName, SQLWCHAR * szTableType, SQLSMALLINT cbTableType)> ^self externalAccessFailedWith: _errorCode
SQLTransact: henv with: hdbc with: fType <C: SQLRETURN __stdcall SQLTransact(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType)> ^self externalAccessFailedWith: _errorCode
</methods> <initialize> Database.DB2APIInterface </initialize> <initialize> Database.DB2Connection </initialize> <initialize> Database.DB2CLIInterface </initialize> <initialize> Database.DB2CLIWinInterface </initialize> <initialize> Database.DB2CLILinuxInterface </initialize> <initialize> Database.DB2Buffer </initialize> <initialize> Database.DB2Session </initialize> "Imported Classes:" self error: 'Attempting to file-in parcel imports. Choose terminate or close' <class> <name>Object</name> <environment>Core</environment> <super></super> <private>false</private> none <imports></imports> <category>Kernel-Objects</category> <attributes> <package>Kernel-Objects</package> </attributes> </class> <class> <name>ExternalDatabaseBuffer</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none databaseType encoding elementSize count bufferPointer <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>ExternalDatabaseException</name> <environment>Database</environment> <super>Core.Error</super> <private>false</private> none <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>Float</name> <environment>Core</environment> <super>Core.LimitedPrecisionReal</super> <private>false</private> bytes <imports></imports> <category>Magnitude-Numbers</category> <attributes> <package>Magnitude-Numbers</package> </attributes> </class> <class> <name>Timestamp</name> <environment>Core</environment> <super>Core.Magnitude</super> <private>false</private> none year month day hour minute second millisecond <imports></imports> <category>UIBasics-Support</category> <attributes> <package>UIBasics-Support</package> </attributes> </class> <class> <name>PositionableStream</name> <environment>Core</environment> <super>Core.PeekableStream</super> <private>false</private> none collection position readLimit writeLimit policy <imports></imports> <category>Collections-Streams</category> <attributes> <package>Collections-Streams</package> </attributes> </class> <class> <name>CharacterArray</name> <environment>Core</environment> <super>Core.ArrayedCollection</super> <private>false</private> none <imports></imports> <category>Collections-Text</category> <attributes> <package>Collections-Text</package> </attributes> </class> <class> <name>ExternalInterface</name> <environment>External</environment> <super>Core.Object</super> <private>false</private> none includeFiles includeDirectories libraryFiles libraryDirectories virtual optimizationLevel <imports> private Kernel.OpcodePool.* </imports> <category>External-Interface</category> <attributes> <package>External-Interface</package> </attributes> </class> <class> <name>Double</name> <environment>Core</environment> <super>Core.LimitedPrecisionReal</super> <private>false</private> bytes <imports></imports> <category>Magnitude-Numbers</category> <attributes> <package>Magnitude-Numbers</package> </attributes> </class> <class> <name>ExternalDatabaseTransaction</name> <environment>Database</environment> <super>Database.ExternalDatabaseFramework</super> <private>false</private> none memberCountHolder remainingCountHolder <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>ExternalDatabaseConnection</name> <environment>Database</environment> <super>Database.ExternalDatabaseFramework</super> <private>false</private> none transaction username password environment transactionCoordinator cachedSession isolationLevel environmentMap xif xifMap dependents <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>UndefinedObject</name> <environment>Core</environment> <super>Core.Object</super> <private>false</private> none <imports></imports> <category>Kernel-Objects</category> <attributes> <package>Kernel-Objects</package> </attributes> </class> <class> <name>ExternalDatabaseError</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none dbmsErrorCode dbmsErrorString osErrorCode osErrorString <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>ExternalDatabaseSession</name> <environment>Database</environment> <super>Database.ExternalDatabaseFramework</super> <private>false</private> none connection query queryFragments bindInput bindTemplate bindOutput useNamedOutputBinding bindValues resultTemplate allocateForEachRow blockFactor numColumns columnDescriptions rowAdaptors rowBuffersHolder bufferIndex answerStream currentRow scrollable <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>Time</name> <environment>Core</environment> <super>Core.Magnitude</super> <private>false</private> none hours minutes seconds <imports></imports> <category>Magnitude-General</category> <attributes> <package>Magnitude-General</package> </attributes> </class> <class> <name>Integer</name> <environment>Core</environment> <super>Core.Number</super> <private>false</private> none <imports></imports> <category>Magnitude-Numbers</category> <attributes> <package>Magnitude-Numbers</package> </attributes> </class> <class> <name>LargeInteger</name> <environment>Core</environment> <super>Core.Integer</super> <private>false</private> bytes <imports></imports> <category>Magnitude-Numbers</category> <attributes> <package>Magnitude-Numbers</package> </attributes> </class> <class> <name>String</name> <environment>Core</environment> <super>Core.CharacterArray</super> <private>false</private> none <imports></imports> <category>Collections-Text</category> <attributes> <package>Collections-Text</package> </attributes> </class> <class> <name>ByteArray</name> <environment>Core</environment> <super>Core.IntegerArray</super> <private>false</private> bytes <imports></imports> <category>Collections-Arrayed</category> <attributes> <package>Collections-Arrayed</package> </attributes> </class> <class> <name>Boolean</name> <environment>Core</environment> <super>Core.Object</super> <private>false</private> none <imports></imports> <category>Kernel-Objects</category> <attributes> <package>Kernel-Objects</package> </attributes> </class> <class> <name>FixedPoint</name> <environment>Core</environment> <super>Core.Number</super> <private>false</private> none numerator denominator scale <imports></imports> <category>Magnitude-Numbers</category> <attributes> <package>Magnitude-Numbers</package> </attributes> </class> <class> <name>ExternalDatabaseColumnDescription</name> <environment>Database</environment> <super>Core.Object</super> <private>false</private> none name index type length precision scale nullable <imports></imports> <category>Database-Interface</category> <attributes> <package>Database</package> </attributes> </class> <class> <name>BufferedExternalStream</name> <environment>OS</environment> <super>OS.ExternalStream</super> <private>false</private> none lineEndCharacter binary lineEndConvention bufferType ioBuffer ioConnection <imports> private OS.IOConstants.* </imports> <category>OS-Streaming</category> <attributes> <package>OS-Streaming</package> </attributes> </class> <class> <name>Date</name> <environment>Core</environment> <super>Core.Magnitude</super> <private>false</private> none day year <imports></imports> <category>Magnitude-General</category> <attributes> <package>Magnitude-General</package> </attributes> </class>