FEATURE EXISTS()


General Form:

Where:


The FEATURE EXISTS test is used to test whether a particular KCML feature exists in this version of KCML. It can be used by application code that needs to run on several versions of KCML to determine what features are available. The feature tested for can either be a part of the KCML syntax or a built in constant (normally a record). This provides a better check for functionality than a simple version check and allows for features in later KCML to be copied back to earlier versions.

The FEATURE EXIST syntax is intended to be used at resolve time, either as part of the constant expression in DIMming a constant or within the IF CONDITION statement. In the case of syntactic features, the #if variant can be used to enclose code that is only valid syntax if that feature is supported by KCML.

Special cases

The following table shows a number of features that can be checked for, such as specific forms of syntax that may not be available in all versions of KCML that the keyword is valid.
Component FEATURE EXISTS string Description
#WHERE :T #WHERE supports timestamp parameters with :T
32BIT system is running on a 32-bit KCML
64BIT system is running on a 64-bit KCML
AIX system is running on AIX
ALANG $PACK format ALANG supported. Alphanumeric multi-language format
ALPHA $PACK format ALPHA supported. Alphanumeric format
ASCIIINT $PACK format ASCIIINT supported. Legacy ASCII integer format
BASE64 $PACK format BASE64 supported. BASE64 encoding
BID $PACK format BID supported. KDB BLOB ID
BID6 $PACK format BID6 supported. KDB BLOB ID 6 byte version
BID8 $PACK format BID8 supported. KDB BLOB ID 8 byte version
BIG_ENDIAN system is running in big endian mode
BINARY $PACK format BINARY supported. Unsigned binary format
BITS $PACK format BITS supported. Count set bits in a string
BLOBSYM $PACK format BLOBSYM supported. The SYM of a bound database BLOB
BLOBSYM6 $PACK format BLOBSYM6 supported. The SYM of a bound database BLOB, 6 BYTE version
BLOBSYM8 $PACK format BLOBSYM8 supported. The SYM of a bound database BLOB, 8 BYTE version
BOOLEAN $PACK format BOOLEAN supported. Numeric boolean with "1" for TRUE and "0" for FALSE
BOOLEAN_FALSE $PACK format BOOLEAN_FALSE supported. Numeric boolean that is always FALSE. Othewise identical to BOOLEAN
BOOLEAN_SPACE $PACK format BOOLEAN_SPACE supported. As Boolean but a space is treated as FALSE rather than error
BR $PACK format BR supported. Byte swapped (little-endian) unsigned binary format
BRP $PACK format BRP supported. Byte swapped (little-endian) signed binary format
IP_TOS CALL IP_TOS Set IP header TOS field
CALL IP_TOS(oldvalue) IP_TOS parameter oldvalue$ is supported (old value of TOS field)
CALL IP_TOS(status) IP_TOS parameter status is supported (Return status)
CALL IP_TOS(value) IP_TOS parameter value$ is supported (Value to set TOS field to)
JSON_CLOSE CALL JSON_CLOSE Close a JSON handle
CALL JSON_CLOSE(handle) JSON_CLOSE parameter handle is supported (Handle to close)
CALL JSON_CLOSE(status) JSON_CLOSE parameter status is supported (Return status)
JSON_COUNT_CHILDREN CALL JSON_COUNT_CHILDREN Cound JSON node's children
CALL JSON_COUNT_CHILDREN(count) JSON_COUNT_CHILDREN parameter count is supported (Returned count)
CALL JSON_COUNT_CHILDREN(handle) JSON_COUNT_CHILDREN parameter handle is supported (Handle to count)
CALL JSON_COUNT_CHILDREN(status) JSON_COUNT_CHILDREN parameter status is supported (Return status)
JSON_FIND_PATH CALL JSON_FIND_PATH Find JSON item by path
CALL JSON_FIND_PATH(handle) JSON_FIND_PATH parameter handle is supported (JSON handle to search)
CALL JSON_FIND_PATH(path) JSON_FIND_PATH parameter path$ is supported (Path)
CALL JSON_FIND_PATH(rhandle) JSON_FIND_PATH parameter rhandle is supported (Returned JSON handle)
CALL JSON_FIND_PATH(status) JSON_FIND_PATH parameter status is supported (Return status)
JSON_PARSE_BUFFER CALL JSON_PARSE_BUFFER Parse a buffer containing JSON
CALL JSON_PARSE_BUFFER(buffer) JSON_PARSE_BUFFER parameter SYM(buffer$) is supported (Symbol of buffer)
CALL JSON_PARSE_BUFFER(handle) JSON_PARSE_BUFFER parameter handle is supported (Returned JSON handle)
CALL JSON_PARSE_BUFFER(status) JSON_PARSE_BUFFER parameter status is supported (Return status)
JSON_PARSE_FILE CALL JSON_PARSE_FILE Parse a file containing JSON
CALL JSON_PARSE_FILE(file) JSON_PARSE_FILE parameter file$ is supported (Name of JSON file to open)
CALL JSON_PARSE_FILE(handle) JSON_PARSE_FILE parameter handle is supported (Returned JSON handle)
CALL JSON_PARSE_FILE(status) JSON_PARSE_FILE parameter status is supported (Return status)
KI_ADD_TRACKED_LOCK CALL KI_ADD_TRACKED_LOCK Add a rowid to a handle's tracked locks
CALL KI_ADD_TRACKED_LOCK(handle) KI_ADD_TRACKED_LOCK parameter handle is supported (Handle)
CALL KI_ADD_TRACKED_LOCK(rowid) KI_ADD_TRACKED_LOCK parameter rowid$ is supported (Rowid to track)
CALL KI_ADD_TRACKED_LOCK(status) KI_ADD_TRACKED_LOCK parameter status is supported (Return status)
KI_AES_DECRYPT CALL KI_AES_DECRYPT AES decrypts cypher$ into plainText$ using a 256 bit key
CALL KI_AES_DECRYPT(cypher) KI_AES_DECRYPT parameter cypher$ is supported (Encrypted data)
CALL KI_AES_DECRYPT(key) KI_AES_DECRYPT parameter key$ is supported (Encryption key)
CALL KI_AES_DECRYPT(plainText) KI_AES_DECRYPT parameter SYM(plainText$) is supported (Decrypted string. This will be REDIMed to size of cypher$ rounded up to a multiple of 16 bytes)
CALL KI_AES_DECRYPT(status) KI_AES_DECRYPT parameter status is supported (Return status)
KI_AES_ENCRYPT CALL KI_AES_ENCRYPT AES encrypts plainText$ into cypher$ using a 256 bit key
CALL KI_AES_ENCRYPT(cypher) KI_AES_ENCRYPT parameter SYM(cypher$) is supported (Encrypted data. This will be REDIMed to size of plainText$ rounded up to a multiple of 16 bytes)
CALL KI_AES_ENCRYPT(key) KI_AES_ENCRYPT parameter key$ is supported (Encryption key)
CALL KI_AES_ENCRYPT(plainText) KI_AES_ENCRYPT parameter plainText$ is supported (String to encrypt)
CALL KI_AES_ENCRYPT(status) KI_AES_ENCRYPT parameter status is supported (Return status)
KI_ALLOC_CONNECT CALL KI_ALLOC_CONNECT Allocate a connection handle
CALL KI_ALLOC_CONNECT(bDefault) KI_ALLOC_CONNECT parameter bDefault is supported (Optional boolean flag TRUE if default connection)
CALL KI_ALLOC_CONNECT(connection) KI_ALLOC_CONNECT parameter connection is supported (Current database connection)
CALL KI_ALLOC_CONNECT(newConnection) KI_ALLOC_CONNECT parameter newConnection is supported (Connection to new database)
CALL KI_ALLOC_CONNECT(status) KI_ALLOC_CONNECT parameter status is supported (Return status)
KI_ALLOC_HANDLE CALL KI_ALLOC_HANDLE Allocate memory for a rowset handle
CALL KI_ALLOC_HANDLE(connection) KI_ALLOC_HANDLE parameter connection is supported (Current database connection)
CALL KI_ALLOC_HANDLE(handle) KI_ALLOC_HANDLE parameter handle is supported (Handle)
CALL KI_ALLOC_HANDLE(newhand) KI_ALLOC_HANDLE parameter newhand is supported (New handle)
CALL KI_ALLOC_HANDLE(status) KI_ALLOC_HANDLE parameter status is supported (Return status)
KI_BEGIN CALL KI_BEGIN Start a transaction on a database
CALL KI_BEGIN(connect) KI_BEGIN parameter connect is supported (Database connection)
CALL KI_BEGIN(status) KI_BEGIN parameter status is supported (Return status)
CALL KI_BEGIN(type) KI_BEGIN parameter type is supported (Optional extra flags)
KI_BIND_COL CALL KI_BIND_COL Bind a variable to a result set column
CALL KI_BIND_COL(bind) KI_BIND_COL parameter bind_sym is supported (SYM of the variable to be bound)
CALL KI_BIND_COL(col) KI_BIND_COL parameter col is supported (Column number or name)
CALL KI_BIND_COL(eBindType) KI_BIND_COL parameter eBindType is supported (Optional bind type)
CALL KI_BIND_COL(handle) KI_BIND_COL parameter handle is supported (Result set handle)
CALL KI_BIND_COL(status) KI_BIND_COL parameter status is supported (Return status)
KI_BIND_PARAM CALL KI_BIND_PARAM Bind a variable to a parameter in a query
CALL KI_BIND_PARAM(bind) KI_BIND_PARAM parameter bind_sym is supported (SYM of the variable to be bound)
CALL KI_BIND_PARAM(col) KI_BIND_PARAM parameter col is supported (Column number)
CALL KI_BIND_PARAM(eBindType) KI_BIND_PARAM parameter eBindType is supported (Optional bind type)
CALL KI_BIND_PARAM(handle) KI_BIND_PARAM parameter handle is supported (Prepared query handle)
CALL KI_BIND_PARAM(status) KI_BIND_PARAM parameter status is supported (Return status)
KI_BOUND_COL CALL KI_BOUND_COL Return sym of variable bound to a result set column
CALL KI_BOUND_COL(bound) KI_BOUND_COL parameter bound_var is supported (Variable that is bound)
CALL KI_BOUND_COL(col) KI_BOUND_COL parameter col is supported (Column number or name)
CALL KI_BOUND_COL(handle) KI_BOUND_COL parameter handle is supported (Result set handle)
CALL KI_BOUND_COL(status) KI_BOUND_COL parameter status is supported (Return status)
KI_BOUND_PARAM CALL KI_BOUND_PARAM Return sym of variable bound to a parameter in a query
CALL KI_BOUND_PARAM(bound) KI_BOUND_PARAM parameter bound_var is supported (Variable that is bound)
CALL KI_BOUND_PARAM(col) KI_BOUND_PARAM parameter col is supported (Column number)
CALL KI_BOUND_PARAM(handle) KI_BOUND_PARAM parameter handle is supported (Prepared query handle)
CALL KI_BOUND_PARAM(status) KI_BOUND_PARAM parameter status is supported (Return status)
KI_BUILD CALL KI_BUILD Build a key given a path and row
CALL KI_BUILD(buf) KI_BUILD parameter SYM(buf$) is supported (Symbol of data buffer)
CALL KI_BUILD(handle) KI_BUILD parameter handle is supported (Open handle)
CALL KI_BUILD(ki) KI_BUILD parameter ki_key$ is supported (New key)
CALL KI_BUILD(path) KI_BUILD parameter path is supported (Path number)
CALL KI_BUILD(status) KI_BUILD parameter status is supported (Return status)
KI_BU_CREATE CALL KI_BU_CREATE Create a flat file on a database handle
CALL KI_BU_CREATE(file) KI_BU_CREATE parameter file$ is supported (Filename)
CALL KI_BU_CREATE(handle) KI_BU_CREATE parameter handle is supported (Handle)
CALL KI_BU_CREATE(status) KI_BU_CREATE parameter status is supported (Return status)
KI_BU_OPEN CALL KI_BU_OPEN Open a flat file on a database handle
CALL KI_BU_OPEN(file) KI_BU_OPEN parameter file$ is supported (Filename)
CALL KI_BU_OPEN(handle) KI_BU_OPEN parameter handle is supported (Handle)
CALL KI_BU_OPEN(status) KI_BU_OPEN parameter status is supported (Return status)
KI_BU_READ CALL KI_BU_READ Read a flat file on a database handle
CALL KI_BU_READ(handle) KI_BU_READ parameter handle is supported (Handle)
CALL KI_BU_READ(len) KI_BU_READ parameter len is supported (Number of bytes to read)
CALL KI_BU_READ(offset) KI_BU_READ parameter offset is supported (Offset to start reading from)
CALL KI_BU_READ(rowbuf) KI_BU_READ parameter SYM(rowbuf$) is supported (Symbol of data buffer)
CALL KI_BU_READ(status) KI_BU_READ parameter status is supported (Return status)
KI_BU_WRITE CALL KI_BU_WRITE Write a flat file from a database handle
CALL KI_BU_WRITE(handle) KI_BU_WRITE parameter handle is supported (Handle)
CALL KI_BU_WRITE(len) KI_BU_WRITE parameter len is supported (Number of bytes to write)
CALL KI_BU_WRITE(offset) KI_BU_WRITE parameter offset is supported (Offset to start writing from)
CALL KI_BU_WRITE(rowbuf) KI_BU_WRITE parameter SYM(rowbuf$) is supported (Symbol of data buffer)
CALL KI_BU_WRITE(status) KI_BU_WRITE parameter status is supported (Return status)
KI_CLEAR CALL KI_CLEAR Close database handles and connections
CALL KI_CLEAR(status) KI_CLEAR parameter status is supported (Return status)
KI_CLEAR_HANDLES CALL KI_CLEAR_HANDLES Close non-permanent database handles
CALL KI_CLEAR_HANDLES(status) KI_CLEAR_HANDLES parameter status is supported (Return status)
KI_CLOSE CALL KI_CLOSE Close a handle
CALL KI_CLOSE(bClose) KI_CLOSE parameter bClose is supported (TRUE for forced close rather than decrement ref count)
CALL KI_CLOSE(handle) KI_CLOSE parameter handle is supported (Handle to close)
CALL KI_CLOSE(nRefCount) KI_CLOSE parameter nRefCount is supported (The new reference count after the close.)
CALL KI_CLOSE(status) KI_CLOSE parameter status is supported (Return status)
KI_CLOSE_TABLE CALL KI_CLOSE_TABLE Close all the zero ref count pooled handles for a table
CALL KI_CLOSE_TABLE(bClose) KI_CLOSE_TABLE parameter bClose is supported (TRUE for force close even if non-zero ref count)
CALL KI_CLOSE_TABLE(connection) KI_CLOSE_TABLE parameter connection is supported (Current database connection)
CALL KI_CLOSE_TABLE(handle) KI_CLOSE_TABLE parameter handle is supported (First non-zero ref count handle remaining)
CALL KI_CLOSE_TABLE(status) KI_CLOSE_TABLE parameter status is supported (Return status)
CALL KI_CLOSE_TABLE(table) KI_CLOSE_TABLE parameter table$ is supported (Table name)
KI_COLUMNS CALL KI_COLUMNS Create a pseudo table of columns for a given table
CALL KI_COLUMNS(hFetch) KI_COLUMNS parameter hFetch is supported (Handle)
CALL KI_COLUMNS(hTable) KI_COLUMNS parameter hTable is supported (Optional handle of open table (used if table name is blank))
CALL KI_COLUMNS(sTable) KI_COLUMNS parameter sTable$ is supported (Name of table to be described)
CALL KI_COLUMNS(status) KI_COLUMNS parameter status is supported (Return status)
KI_COMMIT CALL KI_COMMIT End a transaction on a database
CALL KI_COMMIT(connect) KI_COMMIT parameter connect is supported (Database connection)
CALL KI_COMMIT(status) KI_COMMIT parameter status is supported (Return status)
KI_COMP CALL KI_COMP Compress data
CALL KI_COMP(in) KI_COMP parameter SYM(in_buf$) is supported (Symbol of data to be compressed)
CALL KI_COMP(in) KI_COMP parameter in_size is supported (Size of source data)
CALL KI_COMP(out) KI_COMP parameter SYM(out_buf$) is supported (Symbol of output buffer)
CALL KI_COMP(out) KI_COMP parameter out_size is supported (Size of compressed data)
KI_COMPFILE CALL KI_COMPFILE Compress a file
CALL KI_COMPFILE(dstfile) KI_COMPFILE parameter dstfile$ is supported (Name of target file)
CALL KI_COMPFILE(size) KI_COMPFILE parameter size is supported (Size of the compressed file)
CALL KI_COMPFILE(srcfile) KI_COMPFILE parameter srcfile$ is supported (Name of source file to compress)
CALL KI_COMPFILE(status) KI_COMPFILE parameter status is supported (Return status)
KI_CONNECT CALL KI_CONNECT Connect to named database
CALL KI_CONNECT(connection) KI_CONNECT parameter connection is supported (Connection number)
CALL KI_CONNECT(dbase) KI_CONNECT parameter dbase$ is supported (Database type, KDB or ORACLE)
CALL KI_CONNECT(dsn) KI_CONNECT parameter dsn$ is supported (Database name)
CALL KI_CONNECT(pwd) KI_CONNECT parameter pwd$ is supported (Password for the above user)
CALL KI_CONNECT(status) KI_CONNECT parameter status is supported (Return status)
CALL KI_CONNECT(uid) KI_CONNECT parameter uid$ is supported (User ID)
KI_CONNECT_GET_ATTR CALL KI_CONNECT_GET_ATTR Get connection attribute
CALL KI_CONNECT_GET_ATTR(connection) KI_CONNECT_GET_ATTR parameter connection is supported (Connection handle)
CALL KI_CONNECT_GET_ATTR(eAttr) KI_CONNECT_GET_ATTR parameter eAttr is supported (attribute)
CALL KI_CONNECT_GET_ATTR(status) KI_CONNECT_GET_ATTR parameter status is supported (Return status)
CALL KI_CONNECT_GET_ATTR(value) KI_CONNECT_GET_ATTR parameter value is supported (Value)
KI_CONNECT_GET_ATTR_STR CALL KI_CONNECT_GET_ATTR_STR Get connection attribute strings
CALL KI_CONNECT_GET_ATTR_STR(connection) KI_CONNECT_GET_ATTR_STR parameter connection is supported (Connection handle)
CALL KI_CONNECT_GET_ATTR_STR(eAttr) KI_CONNECT_GET_ATTR_STR parameter eAttr is supported (attribute)
CALL KI_CONNECT_GET_ATTR_STR(nLen) KI_CONNECT_GET_ATTR_STR parameter nLen is supported (number of bytes in string)
CALL KI_CONNECT_GET_ATTR_STR(sValue) KI_CONNECT_GET_ATTR_STR parameter sValue$ is supported (Value)
CALL KI_CONNECT_GET_ATTR_STR(status) KI_CONNECT_GET_ATTR_STR parameter status is supported (Return status)
KI_CONNECT_SET_ATTR CALL KI_CONNECT_SET_ATTR Set connection attribute
CALL KI_CONNECT_SET_ATTR(connection) KI_CONNECT_SET_ATTR parameter connection is supported (Connection handle)
CALL KI_CONNECT_SET_ATTR(eAttr) KI_CONNECT_SET_ATTR parameter eAttr is supported (attribute)
CALL KI_CONNECT_SET_ATTR(previous) KI_CONNECT_SET_ATTR parameter previous is supported (Previous value)
CALL KI_CONNECT_SET_ATTR(status) KI_CONNECT_SET_ATTR parameter status is supported (Return status)
CALL KI_CONNECT_SET_ATTR(value) KI_CONNECT_SET_ATTR parameter value is supported (Value)
KI_CONNECT_SET_ATTR_STR CALL KI_CONNECT_SET_ATTR_STR Set connection attribute strings
CALL KI_CONNECT_SET_ATTR_STR(connection) KI_CONNECT_SET_ATTR_STR parameter connection is supported (Connection handle)
CALL KI_CONNECT_SET_ATTR_STR(eAttr) KI_CONNECT_SET_ATTR_STR parameter eAttr is supported (attribute)
CALL KI_CONNECT_SET_ATTR_STR(sPrevious) KI_CONNECT_SET_ATTR_STR parameter sPrevious$ is supported (Previous value)
CALL KI_CONNECT_SET_ATTR_STR(sValue) KI_CONNECT_SET_ATTR_STR parameter sValue$ is supported (Value)
CALL KI_CONNECT_SET_ATTR_STR(status) KI_CONNECT_SET_ATTR_STR parameter status is supported (Return status)
KI_COPY_TABLE CALL KI_COPY_TABLE Copy a table within a database
CALL KI_COPY_TABLE(connection) KI_COPY_TABLE parameter connection is supported (Current database connection)
CALL KI_COPY_TABLE(source) KI_COPY_TABLE parameter source$ is supported (Source table name)
CALL KI_COPY_TABLE(status) KI_COPY_TABLE parameter status is supported (Return status)
CALL KI_COPY_TABLE(target) KI_COPY_TABLE parameter target$ is supported (Destination table name)
KI_CREATE CALL KI_CREATE Create a table
CALL KI_CREATE(Type) KI_CREATE parameter Type is supported (Table type (4, 5 or 6))
CALL KI_CREATE(blocklen) KI_CREATE parameter blocklen is supported (Index block size)
CALL KI_CREATE(dictfile) KI_CREATE parameter dictfile$ is supported (Dictionary name (not used))
CALL KI_CREATE(handle) KI_CREATE parameter handle is supported (Handle)
CALL KI_CREATE(keyspec) KI_CREATE parameter SYM(keyspec$()) is supported (Symbol of key details)
CALL KI_CREATE(maxrows) KI_CREATE parameter maxrows is supported (Number of required rows)
CALL KI_CREATE(packing) KI_CREATE parameter packing is supported (Percentage packing factor)
CALL KI_CREATE(rowlen) KI_CREATE parameter rowlen is supported (Row length in bytes)
CALL KI_CREATE(status) KI_CREATE parameter status is supported (Return status)
CALL KI_CREATE(table) KI_CREATE parameter table$ is supported (Table name)
KI_CREATE_PRIMARY_KEY_CONSTRAINT CALL KI_CREATE_PRIMARY_KEY_CONSTRAINT Create a primary key on a table
CALL KI_CREATE_PRIMARY_KEY_CONSTRAINT(handle) KI_CREATE_PRIMARY_KEY_CONSTRAINT parameter handle is supported (Handle)
CALL KI_CREATE_PRIMARY_KEY_CONSTRAINT(status) KI_CREATE_PRIMARY_KEY_CONSTRAINT parameter status is supported (Return status)
KI_CREATE_TMP CALL KI_CREATE_TMP Create a table that will be temporary
CALL KI_CREATE_TMP(Type) KI_CREATE_TMP parameter Type is supported (Table type (4, 5 or 6))
CALL KI_CREATE_TMP(blocklen) KI_CREATE_TMP parameter blocklen is supported (Index block size)
CALL KI_CREATE_TMP(dictfile) KI_CREATE_TMP parameter dictfile$ is supported (Dictionary name (not used))
CALL KI_CREATE_TMP(handle) KI_CREATE_TMP parameter handle is supported (Handle)
CALL KI_CREATE_TMP(keyspec) KI_CREATE_TMP parameter SYM(keyspec$()) is supported (Symbol of key details)
CALL KI_CREATE_TMP(maxrows) KI_CREATE_TMP parameter maxrows is supported (Number of required rows)
CALL KI_CREATE_TMP(packing) KI_CREATE_TMP parameter packing is supported (Percentage packing factor)
CALL KI_CREATE_TMP(rowlen) KI_CREATE_TMP parameter rowlen is supported (Row length in bytes)
CALL KI_CREATE_TMP(status) KI_CREATE_TMP parameter status is supported (Return status)
CALL KI_CREATE_TMP(table) KI_CREATE_TMP parameter table$ is supported (Table name)
KI_CRYPT CALL KI_CRYPT Encrypt a password
CALL KI_CRYPT(key) KI_CRYPT parameter key$ is supported (Blank terminated password)
CALL KI_CRYPT(result) KI_CRYPT parameter result$ is supported (Encrypted password)
CALL KI_CRYPT(seed) KI_CRYPT parameter seed$ is supported (Encryption seed, at least 2 chars)
KI_DATABASES CALL KI_DATABASES Enumerate available databases
CALL KI_DATABASES(handle) KI_DATABASES parameter handle is supported (Handle to virtual result set)
CALL KI_DATABASES(status) KI_DATABASES parameter status is supported (Return status)
KI_DB_NAME CALL KI_DB_NAME Convert tablename to a database object name (or filename)
CALL KI_DB_NAME(Tablename) KI_DB_NAME parameter Tablename$ is supported (Table name)
CALL KI_DB_NAME(Tablespace) KI_DB_NAME parameter Tablespace$ is supported (Table space name)
CALL KI_DB_NAME(connection) KI_DB_NAME parameter connection is supported (Database connection number)
CALL KI_DB_NAME(out) KI_DB_NAME parameter SYM(out_name$) is supported (Symbol of output buffer)
CALL KI_DB_NAME(status) KI_DB_NAME parameter status is supported (Return status)
KI_DCOMP CALL KI_DCOMP Uncompress data
CALL KI_DCOMP(in) KI_DCOMP parameter SYM(in_buf$) is supported (Symbol of source data)
CALL KI_DCOMP(in) KI_DCOMP parameter in_size is supported (Size of source data)
CALL KI_DCOMP(out) KI_DCOMP parameter SYM(out_buf$) is supported (Symbol of output buffer)
CALL KI_DCOMP(out) KI_DCOMP parameter out_size is supported (Size of uncompressed data)
KI_DCOMPFILE CALL KI_DCOMPFILE Uncompress a file
CALL KI_DCOMPFILE(dstfile) KI_DCOMPFILE parameter dstfile$ is supported (Name of target file)
CALL KI_DCOMPFILE(size) KI_DCOMPFILE parameter size is supported (Size of the uncompressed file)
CALL KI_DCOMPFILE(srcfile) KI_DCOMPFILE parameter srcfile$ is supported (Name of source file to compress)
CALL KI_DCOMPFILE(status) KI_DCOMPFILE parameter status is supported (Return status)
KI_DEFAULT_ROW CALL KI_DEFAULT_ROW Get and set default row for a table
CALL KI_DEFAULT_ROW(handle) KI_DEFAULT_ROW parameter handle is supported (Open handle)
CALL KI_DEFAULT_ROW(newBuf) KI_DEFAULT_ROW parameter SYM(newBuf$) is supported (Symbol of new row buffer, or 0)
CALL KI_DEFAULT_ROW(oldBuf) KI_DEFAULT_ROW parameter SYM(oldBuf$) is supported (Symbol of old row buffer, or 0)
CALL KI_DEFAULT_ROW(status) KI_DEFAULT_ROW parameter status is supported (Return status)
KI_DELETE CALL KI_DELETE Remove a row
CALL KI_DELETE(handle) KI_DELETE parameter handle is supported (Handle)
CALL KI_DELETE(rowid) KI_DELETE parameter rowid$ is supported (Location of row)
CALL KI_DELETE(status) KI_DELETE parameter status is supported (Return status)
KI_DELETE_PRIMARY_KEY_CONSTRAINT CALL KI_DELETE_PRIMARY_KEY_CONSTRAINT Delete a primary key on a table
CALL KI_DELETE_PRIMARY_KEY_CONSTRAINT(handle) KI_DELETE_PRIMARY_KEY_CONSTRAINT parameter handle is supported (Handle)
CALL KI_DELETE_PRIMARY_KEY_CONSTRAINT(status) KI_DELETE_PRIMARY_KEY_CONSTRAINT parameter status is supported (Return status)
KI_DELETE_ROWS CALL KI_DELETE_ROWS Delete rows from a table
CALL KI_DELETE_ROWS(handle) KI_DELETE_ROWS parameter handle is supported (handle)
CALL KI_DELETE_ROWS(nRows) KI_DELETE_ROWS parameter nRows is supported (Optional, rows to delete, zero means use array size)
CALL KI_DELETE_ROWS(rowid) KI_DELETE_ROWS parameter SYM(rowid$()) is supported (Location of rows to be deleted)
CALL KI_DELETE_ROWS(status) KI_DELETE_ROWS parameter status is supported (Return status)
KI_DELETE_WHERE CALL KI_DELETE_WHERE Delete rows from a table
CALL KI_DELETE_WHERE(bPartialOK) KI_DELETE_WHERE parameter bPartialOK is supported (Optional, TRUE if partial deletion is OK, FALSE if every row in the result set must be deleted or none at all)
CALL KI_DELETE_WHERE(handle) KI_DELETE_WHERE parameter handle is supported (Handle)
CALL KI_DELETE_WHERE(sql) KI_DELETE_WHERE parameter sql is supported (SQL Where Handle)
CALL KI_DELETE_WHERE(status) KI_DELETE_WHERE parameter status is supported (Return status)
KI_DESCRIBE_COL CALL KI_DESCRIBE_COL Describe a column
CALL KI_DESCRIBE_COL(hTable) KI_DESCRIBE_COL parameter hTable is supported (Handle)
CALL KI_DESCRIBE_COL(nCol) KI_DESCRIBE_COL parameter nCol is supported (Column number (from 1))
CALL KI_DESCRIBE_COL(nOffset) KI_DESCRIBE_COL parameter nOffset is supported (Offset (from 1))
CALL KI_DESCRIBE_COL(r) KI_DESCRIBE_COL parameter SYM(r$) is supported (Symbol of KDB_COLUMN record)
CALL KI_DESCRIBE_COL(sDataType) KI_DESCRIBE_COL parameter sDataType$ is supported (SQL data type)
CALL KI_DESCRIBE_COL(sName) KI_DESCRIBE_COL parameter sName$ is supported (Name)
CALL KI_DESCRIBE_COL(sPack) KI_DESCRIBE_COL parameter sPack$ is supported (Packing as in $FORMAT)
CALL KI_DESCRIBE_COL(status) KI_DESCRIBE_COL parameter status is supported (Return status)
KI_DESCRIBE_KEY CALL KI_DESCRIBE_KEY Describe an index
CALL KI_DESCRIBE_KEY(buf) KI_DESCRIBE_KEY parameter SYM(buf$) is supported (Symbol of buffer)
CALL KI_DESCRIBE_KEY(handle) KI_DESCRIBE_KEY parameter handle is supported (Handle)
CALL KI_DESCRIBE_KEY(path) KI_DESCRIBE_KEY parameter path is supported (Path)
CALL KI_DESCRIBE_KEY(status) KI_DESCRIBE_KEY parameter status is supported (Return status)
CALL KI_DESCRIBE_KEY(type) KI_DESCRIBE_KEY parameter type$ is supported (Index type "A" or "W")
KI_DESCRIBE_SCHEMA CALL KI_DESCRIBE_SCHEMA Describe table schema
CALL KI_DESCRIBE_SCHEMA(buf) KI_DESCRIBE_SCHEMA parameter SYM(buf$) is supported (Symbol of buffer)
CALL KI_DESCRIBE_SCHEMA(handle) KI_DESCRIBE_SCHEMA parameter handle is supported (Handle)
CALL KI_DESCRIBE_SCHEMA(mode) KI_DESCRIBE_SCHEMA parameter mode is supported (Mode)
CALL KI_DESCRIBE_SCHEMA(status) KI_DESCRIBE_SCHEMA parameter status is supported (Return status)
KI_DES_DECRYPT CALL KI_DES_DECRYPT DES decrypts cypher$ into plainText$ using a 56 bit key
CALL KI_DES_DECRYPT(cypher) KI_DES_DECRYPT parameter cypher$ is supported (Encrypted data)
CALL KI_DES_DECRYPT(key) KI_DES_DECRYPT parameter key$ is supported (Encryption key)
CALL KI_DES_DECRYPT(plainText) KI_DES_DECRYPT parameter SYM(plainText$) is supported (Decrypted string. This will be REDIMed to size of cypher$ string.)
CALL KI_DES_DECRYPT(status) KI_DES_DECRYPT parameter status is supported (Return status)
KI_DES_ENCRYPT CALL KI_DES_ENCRYPT DES encrypts plainText$ into cypher$ using a 56 bit key
CALL KI_DES_ENCRYPT(cypher) KI_DES_ENCRYPT parameter SYM(cypher$) is supported (Encrypted data. This will be REDIMed to size of plainText$ string.)
CALL KI_DES_ENCRYPT(key) KI_DES_ENCRYPT parameter key$ is supported (Encryption key)
CALL KI_DES_ENCRYPT(plainText) KI_DES_ENCRYPT parameter plainText$ is supported (String to encrypt)
CALL KI_DES_ENCRYPT(status) KI_DES_ENCRYPT parameter status is supported (Return status)
KI_DF CALL KI_DF Find free space on filesystem in bytes
CALL KI_DF(bytes) KI_DF parameter bytes is supported (Amount of free space (bytes))
CALL KI_DF(file) KI_DF parameter file$ is supported (Pathname)
CALL KI_DF(inodes) KI_DF parameter inodes is supported (Number of spare inodes (-1 on Windows))
KI_DFK CALL KI_DFK Find free space on filesystem in kilobytes
CALL KI_DFK(file) KI_DFK parameter file$ is supported (Pathname)
CALL KI_DFK(inodes) KI_DFK parameter inodes is supported (Number of spare inodes (-1 on Windows))
CALL KI_DFK(kBytes) KI_DFK parameter kBytes is supported (Amount of free space (Kilo bytes))
KI_DIR CALL KI_DIR Search directory tree
CALL KI_DIR(buf) KI_DIR parameter SYM(buf$) is supported (Buffer to hold requested data)
CALL KI_DIR(count) KI_DIR parameter count is supported (Number of files found)
CALL KI_DIR(depth) KI_DIR parameter depth is supported (Number of subdirs to search)
CALL KI_DIR(field) KI_DIR parameter field$ is supported (Fields to retrieve)
CALL KI_DIR(filelen) KI_DIR parameter filelen is supported (Number of bytes of filename for 'N' field)
CALL KI_DIR(path) KI_DIR parameter path$ is supported (Pathname)
CALL KI_DIR(status) KI_DIR parameter status is supported (Optional return status)
KI_DIR_LIST CALL KI_DIR_LIST List directory tree
CALL KI_DIR_LIST(buf) KI_DIR_LIST parameter SYM(buf$) is supported (Buffer to hold requested data)
CALL KI_DIR_LIST(count) KI_DIR_LIST parameter count is supported (Number of files found)
CALL KI_DIR_LIST(path) KI_DIR_LIST parameter path$ is supported (Pathname)
CALL KI_DIR_LIST(status) KI_DIR_LIST parameter status is supported (Optional return status)
KI_DISCONNECT CALL KI_DISCONNECT Disconnect from external database
CALL KI_DISCONNECT(connection) KI_DISCONNECT parameter connection is supported (Connection number of external database)
CALL KI_DISCONNECT(status) KI_DISCONNECT parameter status is supported (Return status)
KI_DROP_TABLE CALL KI_DROP_TABLE Remove a table from a database
CALL KI_DROP_TABLE(connection) KI_DROP_TABLE parameter connection is supported (Database connection number)
CALL KI_DROP_TABLE(file) KI_DROP_TABLE parameter file$ is supported (Table to remove)
CALL KI_DROP_TABLE(status) KI_DROP_TABLE parameter status is supported (Return status)
KI_DROP_TRACKED_LOCK CALL KI_DROP_TRACKED_LOCK Drop a rowid from a handle's tracked locks
CALL KI_DROP_TRACKED_LOCK(handle) KI_DROP_TRACKED_LOCK parameter handle is supported (Handle)
CALL KI_DROP_TRACKED_LOCK(rowid) KI_DROP_TRACKED_LOCK parameter rowid$ is supported (Rowid to stop tracking)
CALL KI_DROP_TRACKED_LOCK(status) KI_DROP_TRACKED_LOCK parameter status is supported (Return status)
KI_DS CALL KI_DS Find the size of a filesystem
CALL KI_DS(diskSize) KI_DS parameter diskSize is supported (Size of file system (kBytes))
CALL KI_DS(file) KI_DS parameter file$ is supported (Pathname)
CALL KI_DS(inodes) KI_DS parameter inodes is supported (Total number of inodes (-1 on Windows))
KI_END CALL KI_END Close result set on a handle
CALL KI_END(eEnum) KI_END parameter eEnum is supported (KDB_END_ENUM to specify level of resource deallocation)
CALL KI_END(handle) KI_END parameter handle is supported (Handle)
CALL KI_END(status) KI_END parameter status is supported (Return status)
KI_ERROR CALL KI_ERROR Find error message from a database error code
CALL KI_ERROR(buf) KI_ERROR parameter SYM(buf$) is supported (Symbol of message buffer)
CALL KI_ERROR(major) KI_ERROR parameter major is supported (Major error code)
CALL KI_ERROR(minor) KI_ERROR parameter minor is supported (Minor error code)
KI_ERROR_TEXT CALL KI_ERROR_TEXT Return the description for last error
CALL KI_ERROR_TEXT(buf) KI_ERROR_TEXT parameter buf$ is supported (Buffer for error message)
CALL KI_ERROR_TEXT(handle) KI_ERROR_TEXT parameter handle is supported (Handle)
CALL KI_ERROR_TEXT(status) KI_ERROR_TEXT parameter status is supported (Return status)
KI_EXECUTE CALL KI_EXECUTE Execute an SQL statement
CALL KI_EXECUTE(bufsize) KI_EXECUTE parameter bufsize is supported (Size of the return buffer needed for a SELECT)
CALL KI_EXECUTE(count) KI_EXECUTE parameter count is supported (Row count)
CALL KI_EXECUTE(handle) KI_EXECUTE parameter handle is supported (Prepared handle)
CALL KI_EXECUTE(status) KI_EXECUTE parameter status is supported (Return status)
KI_EXTEND CALL KI_EXTEND Create a larger copy of a table
CALL KI_EXTEND(file) KI_EXTEND parameter file$ is supported (New file name)
CALL KI_EXTEND(handle) KI_EXTEND parameter handle is supported (Handle to source file)
CALL KI_EXTEND(new) KI_EXTEND parameter new_handle is supported (Handle of new file)
CALL KI_EXTEND(size) KI_EXTEND parameter size is supported (Number of rows in new file)
CALL KI_EXTEND(status) KI_EXTEND parameter status is supported (Return status)
KI_FETCH CALL KI_FETCH Fetch the next row in a result set
CALL KI_FETCH(handle) KI_FETCH parameter handle is supported (Handle)
CALL KI_FETCH(rowbuf) KI_FETCH parameter SYM(rowbuf$) is supported (Symbol of a buffer large enough to result)
CALL KI_FETCH(status) KI_FETCH parameter status is supported (Return status)
KI_FREE_CONNECT CALL KI_FREE_CONNECT Free up connection from a external database
CALL KI_FREE_CONNECT(connection) KI_FREE_CONNECT parameter connection is supported (Database connection number)
CALL KI_FREE_CONNECT(status) KI_FREE_CONNECT parameter status is supported (Return status)
KI_FREE_HANDLE CALL KI_FREE_HANDLE Free memory associated with a handle
CALL KI_FREE_HANDLE(handle) KI_FREE_HANDLE parameter handle is supported (Closed handle)
CALL KI_FREE_HANDLE(status) KI_FREE_HANDLE parameter status is supported (Return status)
KI_GET_COL_LIST CALL KI_GET_COL_LIST Get temporary column list
CALL KI_GET_COL_LIST(collist) KI_GET_COL_LIST parameter SYM(collist$) is supported (Buffer to hold the list)
CALL KI_GET_COL_LIST(handle) KI_GET_COL_LIST parameter handle is supported (Handle)
CALL KI_GET_COL_LIST(status) KI_GET_COL_LIST parameter status is supported (Return status)
KI_GET_ERROR_TEXT CALL KI_GET_ERROR_TEXT Return the description for last error resizing buf$
CALL KI_GET_ERROR_TEXT(buf) KI_GET_ERROR_TEXT parameter SYM(buf$) is supported (Buffer for error message)
CALL KI_GET_ERROR_TEXT(handle) KI_GET_ERROR_TEXT parameter handle is supported (Handle)
CALL KI_GET_ERROR_TEXT(status) KI_GET_ERROR_TEXT parameter status is supported (Return status)
KI_GET_HANDLE CALL KI_GET_HANDLE Allocate pooled handle on table, opening if necessary
CALL KI_GET_HANDLE(bPersist) KI_GET_HANDLE parameter bPersist is supported (TRUE for persistence across RUN)
CALL KI_GET_HANDLE(connection) KI_GET_HANDLE parameter connection is supported (Current database connection)
CALL KI_GET_HANDLE(eCacheOpts) KI_GET_HANDLE parameter eCacheOpts is supported (whether to cache read-only tables)
CALL KI_GET_HANDLE(mode) KI_GET_HANDLE parameter mode$ is supported (Access mode, "R", "W", "X" or "U")
CALL KI_GET_HANDLE(newhand) KI_GET_HANDLE parameter newhand is supported (New handle)
CALL KI_GET_HANDLE(status) KI_GET_HANDLE parameter status is supported (Return status)
CALL KI_GET_HANDLE(table) KI_GET_HANDLE parameter table$ is supported (Table name)
KI_GET_LANGUAGES CALL KI_GET_LANGUAGES Retrieve database languages
CALL KI_GET_LANGUAGES(connection) KI_GET_LANGUAGES parameter connection is supported (Current database connection)
CALL KI_GET_LANGUAGES(lang) KI_GET_LANGUAGES parameter SYM(lang()) is supported (Language array)
CALL KI_GET_LANGUAGES(status) KI_GET_LANGUAGES parameter status is supported (Return status)
KI_GET_SERIAL CALL KI_GET_SERIAL Return current unique serial number
CALL KI_GET_SERIAL(handle) KI_GET_SERIAL parameter handle is supported (Table handle)
CALL KI_GET_SERIAL(nCache) KI_GET_SERIAL parameter nCache is supported (Cache size)
CALL KI_GET_SERIAL(serial) KI_GET_SERIAL parameter serial is supported (Serial number)
CALL KI_GET_SERIAL(status) KI_GET_SERIAL parameter status is supported (Return status)
KI_GET_TRACKED_LOCKS CALL KI_GET_TRACKED_LOCKS Get tracked locks for a handle
CALL KI_GET_TRACKED_LOCKS(handle) KI_GET_TRACKED_LOCKS parameter handle is supported (Handle)
CALL KI_GET_TRACKED_LOCKS(rowids) KI_GET_TRACKED_LOCKS parameter SYM(rowids$()) is supported (Symbol of an array of _KDB_ROWIDs)
CALL KI_GET_TRACKED_LOCKS(status) KI_GET_TRACKED_LOCKS parameter status is supported (Return status)
KI_GROW CALL KI_GROW Increase table size
CALL KI_GROW(eMode) KI_GROW parameter eMode is supported (Mode of growth)
CALL KI_GROW(handle) KI_GROW parameter handle is supported (Handle of file)
CALL KI_GROW(nNewRows) KI_GROW parameter nNewRows is supported (Number of rows after the operation)
CALL KI_GROW(status) KI_GROW parameter status is supported (Return status)
KI_HANDLE_GET_ATTR CALL KI_HANDLE_GET_ATTR Get handle attribute
CALL KI_HANDLE_GET_ATTR(eAttr) KI_HANDLE_GET_ATTR parameter eAttr is supported (attribute)
CALL KI_HANDLE_GET_ATTR(handle) KI_HANDLE_GET_ATTR parameter handle is supported (Table handle)
CALL KI_HANDLE_GET_ATTR(status) KI_HANDLE_GET_ATTR parameter status is supported (Return status)
CALL KI_HANDLE_GET_ATTR(value) KI_HANDLE_GET_ATTR parameter value is supported (Value)
KI_HANDLE_GET_ATTR_POOL CALL KI_HANDLE_GET_ATTR_POOL Get handle attribute
CALL KI_HANDLE_GET_ATTR_POOL(HANDLE) KI_HANDLE_GET_ATTR_POOL parameter HANDLE is supported (Connection handle)
CALL KI_HANDLE_GET_ATTR_POOL(eAttr) KI_HANDLE_GET_ATTR_POOL parameter eAttr is supported (attribute)
CALL KI_HANDLE_GET_ATTR_POOL(status) KI_HANDLE_GET_ATTR_POOL parameter status is supported (Return status)
CALL KI_HANDLE_GET_ATTR_POOL(value) KI_HANDLE_GET_ATTR_POOL parameter value is supported (Value)
KI_HANDLE_GET_ATTR_STR CALL KI_HANDLE_GET_ATTR_STR Get handle attribute
CALL KI_HANDLE_GET_ATTR_STR(eAttr) KI_HANDLE_GET_ATTR_STR parameter eAttr is supported (attribute)
CALL KI_HANDLE_GET_ATTR_STR(handle) KI_HANDLE_GET_ATTR_STR parameter handle is supported (Table handle)
CALL KI_HANDLE_GET_ATTR_STR(nLen) KI_HANDLE_GET_ATTR_STR parameter nLen is supported (Length of string)
CALL KI_HANDLE_GET_ATTR_STR(sAttr) KI_HANDLE_GET_ATTR_STR parameter sAttr$ is supported (Buffer to receive attribute)
CALL KI_HANDLE_GET_ATTR_STR(status) KI_HANDLE_GET_ATTR_STR parameter status is supported (Return status)
KI_HANDLE_SET_ATTR CALL KI_HANDLE_SET_ATTR Set handle attribute
CALL KI_HANDLE_SET_ATTR(eAttr) KI_HANDLE_SET_ATTR parameter eAttr is supported (attribute)
CALL KI_HANDLE_SET_ATTR(handle) KI_HANDLE_SET_ATTR parameter handle is supported (Table handle)
CALL KI_HANDLE_SET_ATTR(previous) KI_HANDLE_SET_ATTR parameter previous is supported (Previous value)
CALL KI_HANDLE_SET_ATTR(status) KI_HANDLE_SET_ATTR parameter status is supported (Return status)
CALL KI_HANDLE_SET_ATTR(value) KI_HANDLE_SET_ATTR parameter value is supported (Value)
KI_HANDLE_SET_ATTR_POOL CALL KI_HANDLE_SET_ATTR_POOL Set handle attribute
CALL KI_HANDLE_SET_ATTR_POOL(eAttr) KI_HANDLE_SET_ATTR_POOL parameter eAttr is supported (attribute)
CALL KI_HANDLE_SET_ATTR_POOL(handle) KI_HANDLE_SET_ATTR_POOL parameter handle is supported (Table handle)
CALL KI_HANDLE_SET_ATTR_POOL(previous) KI_HANDLE_SET_ATTR_POOL parameter previous is supported (Previous value)
CALL KI_HANDLE_SET_ATTR_POOL(status) KI_HANDLE_SET_ATTR_POOL parameter status is supported (Return status)
CALL KI_HANDLE_SET_ATTR_POOL(value) KI_HANDLE_SET_ATTR_POOL parameter value is supported (Value)
KI_HANDLE_SET_ATTR_STR CALL KI_HANDLE_SET_ATTR_STR Get handle attribute
CALL KI_HANDLE_SET_ATTR_STR(eAttr) KI_HANDLE_SET_ATTR_STR parameter eAttr is supported (attribute)
CALL KI_HANDLE_SET_ATTR_STR(handle) KI_HANDLE_SET_ATTR_STR parameter handle is supported (Table handle)
CALL KI_HANDLE_SET_ATTR_STR(sAttr) KI_HANDLE_SET_ATTR_STR parameter sAttr$ is supported (Buffer containing attribute string)
CALL KI_HANDLE_SET_ATTR_STR(sPrevious) KI_HANDLE_SET_ATTR_STR parameter sPrevious$ is supported (Previous value)
CALL KI_HANDLE_SET_ATTR_STR(status) KI_HANDLE_SET_ATTR_STR parameter status is supported (Return status)
KI_INFO CALL KI_INFO Retrieve details of a table or connection
CALL KI_INFO(buf) KI_INFO parameter SYM(buf$) is supported (Symbol of a buffer to hold data)
CALL KI_INFO(eOpt) KI_INFO parameter eOpt is supported (Row count and serial number options)
CALL KI_INFO(handle) KI_INFO parameter handle is supported (Handle)
CALL KI_INFO(path) KI_INFO parameter path is supported (Path number)
CALL KI_INFO(status) KI_INFO parameter status is supported (Return status)
KI_INITIALISE CALL KI_INITIALISE Initialise a table
CALL KI_INITIALISE(eOpt) KI_INITIALISE parameter eOpt is supported (KDB_INITIALISE_ENUM)
CALL KI_INITIALISE(handle) KI_INITIALISE parameter handle is supported (Handle opened in "X" or "U" mode)
CALL KI_INITIALISE(status) KI_INITIALISE parameter status is supported (Return status)
KI_LOCK_ALL CALL KI_LOCK_ALL Lock/Unlock all the rows of a table
CALL KI_LOCK_ALL(bToggle) KI_LOCK_ALL parameter bToggle is supported (TRUE for lock, FALSE for unlock)
CALL KI_LOCK_ALL(handle) KI_LOCK_ALL parameter handle is supported (Handle)
CALL KI_LOCK_ALL(part) KI_LOCK_ALL parameter part_number is supported (Partition number that caused the function to fail)
KI_LOCK_OWNER CALL KI_LOCK_OWNER Find information about locking process
CALL KI_LOCK_OWNER(handle) KI_LOCK_OWNER parameter handle is supported (Handle of locked file)
CALL KI_LOCK_OWNER(info) KI_LOCK_OWNER parameter SYM(info$) is supported (Symbol of an info structure)
CALL KI_LOCK_OWNER(nId) KI_LOCK_OWNER parameter nId is supported (Identifier for the locking process)
CALL KI_LOCK_OWNER(status) KI_LOCK_OWNER parameter status is supported (Return status)
KI_LOG_SYNC CALL KI_LOG_SYNC Flush the recovery log
CALL KI_LOG_SYNC(connect) KI_LOG_SYNC parameter connect is supported (Database connection)
CALL KI_LOG_SYNC(status) KI_LOG_SYNC parameter status is supported (Return status)
KI_MD5 CALL KI_MD5 Computes a 128 bit MD5 hash from the given buffer
CALL KI_MD5(hash) KI_MD5 parameter SYM(hash$) is supported (MD5 Hash of source string)
CALL KI_MD5(status) KI_MD5 parameter status is supported (Return status)
CALL KI_MD5(text) KI_MD5 parameter text$ is supported (Source string)
KI_MOVE_ROWS CALL KI_MOVE_ROWS Archive rows from one table to another in a database
CALL KI_MOVE_ROWS(h1) KI_MOVE_ROWS parameter h1 is supported (Source handle)
CALL KI_MOVE_ROWS(h2) KI_MOVE_ROWS parameter h2 is supported (Destination handle)
CALL KI_MOVE_ROWS(nRows) KI_MOVE_ROWS parameter nRows is supported (Optional, rows to archive, zero means use array size)
CALL KI_MOVE_ROWS(rowid) KI_MOVE_ROWS parameter SYM(rowid$()) is supported (Location of rows in source table)
CALL KI_MOVE_ROWS(status) KI_MOVE_ROWS parameter status is supported (Return status)
KI_MOVE_TABLE CALL KI_MOVE_TABLE Rename a database table
CALL KI_MOVE_TABLE(connection) KI_MOVE_TABLE parameter connection is supported (Database connection)
CALL KI_MOVE_TABLE(source) KI_MOVE_TABLE parameter source$ is supported (Source table)
CALL KI_MOVE_TABLE(status) KI_MOVE_TABLE parameter status is supported (Return status)
CALL KI_MOVE_TABLE(target) KI_MOVE_TABLE parameter target$ is supported (Target table)
KI_OPEN CALL KI_OPEN Open a table
CALL KI_OPEN(eCacheOpts) KI_OPEN parameter eCacheOpts is supported (Whether to cache read-only tables)
CALL KI_OPEN(handle) KI_OPEN parameter handle is supported (Handle)
CALL KI_OPEN(mode) KI_OPEN parameter mode$ is supported (Access mode, "R", "W", "F", "X" or "U")
CALL KI_OPEN(status) KI_OPEN parameter status is supported (Return status)
CALL KI_OPEN(stream) KI_OPEN parameter stream is supported (Stream handle)
CALL KI_OPEN(table) KI_OPEN parameter table$ is supported (Table name)
KI_PARTITIONS CALL KI_PARTITIONS Create a pseudo table of partitions for a given base table
CALL KI_PARTITIONS(handle) KI_PARTITIONS parameter handle is supported (Handle)
CALL KI_PARTITIONS(status) KI_PARTITIONS parameter status is supported (Return status)
CALL KI_PARTITIONS(table) KI_PARTITIONS parameter table$ is supported (Base table name)
KI_PID CALL KI_PID Test if a process is running
CALL KI_PID(pid) KI_PID parameter pid is supported (Process ID)
CALL KI_PID(status) KI_PID parameter status is supported (Return status)
KI_PMATCH CALL KI_PMATCH Pattern match filenames
CALL KI_PMATCH(pattern) KI_PMATCH parameter pattern$ is supported (Pattern containing "?", "*" or "[]")
CALL KI_PMATCH(result) KI_PMATCH parameter result is supported (1 for a match, 0 for no match)
CALL KI_PMATCH(sample) KI_PMATCH parameter sample$ is supported (File name)
KI_PREFETCH_ROWS CALL KI_PREFETCH_ROWS Set number of rows to prefetch on sequential reads
CALL KI_PREFETCH_ROWS(handle) KI_PREFETCH_ROWS parameter handle is supported (Handle)
CALL KI_PREFETCH_ROWS(oldvalue) KI_PREFETCH_ROWS parameter oldvalue is supported (Previous value)
CALL KI_PREFETCH_ROWS(rows) KI_PREFETCH_ROWS parameter rows is supported (Number of rows to prefetch)
CALL KI_PREFETCH_ROWS(status) KI_PREFETCH_ROWS parameter status is supported (Return status)
KI_PREPARE CALL KI_PREPARE Generate a SQL execution plan
CALL KI_PREPARE(colcount) KI_PREPARE parameter colcount is supported (Number of columns in result set)
CALL KI_PREPARE(extratext) KI_PREPARE parameter extratext$ is supported (Extra SQL)
CALL KI_PREPARE(handle) KI_PREPARE parameter handle is supported (Handle)
CALL KI_PREPARE(sql) KI_PREPARE parameter sql$ is supported (SQL statement)
CALL KI_PREPARE(status) KI_PREPARE parameter status is supported (Return status)
KI_READ CALL KI_READ Indexed Read
CALL KI_READ(bQuery) KI_READ parameter bQuery is supported (Force use of DEFQUERY)
CALL KI_READ(eLockType) KI_READ parameter eLockType is supported (Optional lock type)
CALL KI_READ(handle) KI_READ parameter handle is supported (Handle)
CALL KI_READ(keys) KI_READ parameter keys$ is supported (Key)
CALL KI_READ(path) KI_READ parameter path is supported (Index path)
CALL KI_READ(rowbuf) KI_READ parameter SYM(rowbuf$) is supported (Symbol of a buffer)
CALL KI_READ(rowid) KI_READ parameter rowid$ is supported (Pointer to row)
CALL KI_READ(status) KI_READ parameter status is supported (Return code)
KI_READ_ARRAY CALL KI_READ_ARRAY Random read into an array
CALL KI_READ_ARRAY(handle) KI_READ_ARRAY parameter handle is supported (Handle)
CALL KI_READ_ARRAY(keys) KI_READ_ARRAY parameter SYM(keys$()) is supported (Key array)
CALL KI_READ_ARRAY(nRead) KI_READ_ARRAY parameter nRead is supported (Number of rows read)
CALL KI_READ_ARRAY(nReqRows) KI_READ_ARRAY parameter nReqRows is supported (Rows to request on server)
CALL KI_READ_ARRAY(nRows) KI_READ_ARRAY parameter nRows is supported (Rows to read)
CALL KI_READ_ARRAY(path) KI_READ_ARRAY parameter path is supported (Index path)
CALL KI_READ_ARRAY(rowbuf) KI_READ_ARRAY parameter SYM(rowbuf$()) is supported (Row array)
CALL KI_READ_ARRAY(rowid) KI_READ_ARRAY parameter SYM(rowid$()) is supported (Rowid array)
CALL KI_READ_ARRAY(status) KI_READ_ARRAY parameter status is supported (Return status)
KI_READ_HOLD CALL KI_READ_HOLD Read a random row and lock
CALL KI_READ_HOLD(bQuery) KI_READ_HOLD parameter bQuery is supported (Force use of DEFQUERY)
CALL KI_READ_HOLD(eLockType) KI_READ_HOLD parameter eLockType is supported (Optional lock type)
CALL KI_READ_HOLD(handle) KI_READ_HOLD parameter handle is supported (Handle)
CALL KI_READ_HOLD(key) KI_READ_HOLD parameter key$ is supported (Key index to row)
CALL KI_READ_HOLD(path) KI_READ_HOLD parameter path is supported (Index path)
CALL KI_READ_HOLD(rowbuf) KI_READ_HOLD parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_READ_HOLD(rowid) KI_READ_HOLD parameter rowid$ is supported (Row ID)
CALL KI_READ_HOLD(status) KI_READ_HOLD parameter status is supported (Return status)
KI_READ_HOLD_NEXT CALL KI_READ_HOLD_NEXT Read next row and lock
CALL KI_READ_HOLD_NEXT(bQuery) KI_READ_HOLD_NEXT parameter bQuery is supported (Force use of DEFQUERY)
CALL KI_READ_HOLD_NEXT(eLockType) KI_READ_HOLD_NEXT parameter eLockType is supported (Optional lock type)
CALL KI_READ_HOLD_NEXT(handle) KI_READ_HOLD_NEXT parameter handle is supported (Handle)
CALL KI_READ_HOLD_NEXT(key) KI_READ_HOLD_NEXT parameter key$ is supported (Key)
CALL KI_READ_HOLD_NEXT(path) KI_READ_HOLD_NEXT parameter path is supported (Path number, if <0 then read previous row)
CALL KI_READ_HOLD_NEXT(rowbuf) KI_READ_HOLD_NEXT parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_READ_HOLD_NEXT(rowid) KI_READ_HOLD_NEXT parameter rowid$ is supported (Row ID)
CALL KI_READ_HOLD_NEXT(status) KI_READ_HOLD_NEXT parameter status is supported (Return status)
KI_READ_HOLD_PTR CALL KI_READ_HOLD_PTR Read and lock using a row ID from a previous read
CALL KI_READ_HOLD_PTR(bRefresh) KI_READ_HOLD_PTR parameter bRefresh is supported (TRUE iff row was refreshed)
CALL KI_READ_HOLD_PTR(eLockType) KI_READ_HOLD_PTR parameter eLockType is supported (Optional lock type)
CALL KI_READ_HOLD_PTR(handle) KI_READ_HOLD_PTR parameter handle is supported (Handle)
CALL KI_READ_HOLD_PTR(rowbuf) KI_READ_HOLD_PTR parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_READ_HOLD_PTR(rowid) KI_READ_HOLD_PTR parameter rowid$ is supported (Row ID from a previous read)
CALL KI_READ_HOLD_PTR(status) KI_READ_HOLD_PTR parameter status is supported (Return status)
KI_READ_NEXT CALL KI_READ_NEXT Read next row
CALL KI_READ_NEXT(bQuery) KI_READ_NEXT parameter bQuery is supported (Force use of DEFQUERY)
CALL KI_READ_NEXT(eLockType) KI_READ_NEXT parameter eLockType is supported (Optional lock type)
CALL KI_READ_NEXT(handle) KI_READ_NEXT parameter handle is supported (Handle)
CALL KI_READ_NEXT(key) KI_READ_NEXT parameter key$ is supported (Key)
CALL KI_READ_NEXT(path) KI_READ_NEXT parameter path is supported (Path number, if <0 read previous row)
CALL KI_READ_NEXT(rowbuf) KI_READ_NEXT parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_READ_NEXT(rowid) KI_READ_NEXT parameter rowid$ is supported (Row ID)
CALL KI_READ_NEXT(status) KI_READ_NEXT parameter status is supported (Return status)
KI_READ_PTR CALL KI_READ_PTR Re-read a row using its row ID
CALL KI_READ_PTR(bRefresh) KI_READ_PTR parameter bRefresh is supported (TRUE iff row was refreshed)
CALL KI_READ_PTR(eLockType) KI_READ_PTR parameter eLockType is supported (Optional lock type)
CALL KI_READ_PTR(handle) KI_READ_PTR parameter handle is supported (Handle)
CALL KI_READ_PTR(rowbuf) KI_READ_PTR parameter SYM(rowbuf$) is supported (Symbol of data buffer)
CALL KI_READ_PTR(rowid) KI_READ_PTR parameter rowid$ is supported (Row ID from a previous read)
CALL KI_READ_PTR(status) KI_READ_PTR parameter status is supported (Return status)
KI_READ_RANDOM CALL KI_READ_RANDOM Random read, key taken from row
CALL KI_READ_RANDOM(bQuery) KI_READ_RANDOM parameter bQuery is supported (Force use of DEFQUERY)
CALL KI_READ_RANDOM(eLockType) KI_READ_RANDOM parameter eLockType is supported (Optional lock type)
CALL KI_READ_RANDOM(handle) KI_READ_RANDOM parameter handle is supported (Handle)
CALL KI_READ_RANDOM(path) KI_READ_RANDOM parameter path is supported (Index path)
CALL KI_READ_RANDOM(rowbuf) KI_READ_RANDOM parameter SYM(rowbuf$) is supported (Symbol of a row buffer)
CALL KI_READ_RANDOM(rowid) KI_READ_RANDOM parameter rowid$ is supported (Pointer to row)
CALL KI_READ_RANDOM(status) KI_READ_RANDOM parameter status is supported (Return code)
KI_READ_RAW CALL KI_READ_RAW Read successive rows, ignoring index
CALL KI_READ_RAW(handle) KI_READ_RAW parameter handle is supported (Handle)
CALL KI_READ_RAW(rowbuf) KI_READ_RAW parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_READ_RAW(rowid) KI_READ_RAW parameter rowid is supported (Initial row number)
CALL KI_READ_RAW(rowidbuf) KI_READ_RAW parameter SYM(rowidbuf$) is supported (Symbol of rowid buffer (Type 7 tables only))
CALL KI_READ_RAW(rowsin) KI_READ_RAW parameter rowsin is supported (Number of rows to read)
CALL KI_READ_RAW(rowsout) KI_READ_RAW parameter rowsout is supported (Number of rows actually read)
CALL KI_READ_RAW(status) KI_READ_RAW parameter status is supported (Return status)
KI_REBUILD CALL KI_REBUILD Rebuild a tables indexes from the data rows
CALL KI_REBUILD(handle) KI_REBUILD parameter handle is supported (Handle)
CALL KI_REBUILD(method) KI_REBUILD parameter method is supported (Method)
CALL KI_REBUILD(nIndex) KI_REBUILD parameter nIndex is supported (Index number)
CALL KI_REBUILD(status) KI_REBUILD parameter status is supported (Return status)
KI_REDIR_CONNECT CALL KI_REDIR_CONNECT Redirect a connection
CALL KI_REDIR_CONNECT(conn) KI_REDIR_CONNECT parameter conn is supported (Connect to be redirected)
CALL KI_REDIR_CONNECT(redirconn) KI_REDIR_CONNECT parameter redirconn is supported (Connect redirected to)
CALL KI_REDIR_CONNECT(status) KI_REDIR_CONNECT parameter status is supported (Return status)
CALL KI_REDIR_CONNECT(type) KI_REDIR_CONNECT parameter type is supported (Type of redirection)
KI_RESET_CACHEID CALL KI_RESET_CACHEID Reset a table's cache ID
CALL KI_RESET_CACHEID(handle) KI_RESET_CACHEID parameter handle is supported (Handle)
CALL KI_RESET_CACHEID(status) KI_RESET_CACHEID parameter status is supported (Return status)
KI_REWRITE CALL KI_REWRITE Overwrite an existing row
CALL KI_REWRITE(eLockType) KI_REWRITE parameter eLockType is supported (Optional lock type)
CALL KI_REWRITE(handle) KI_REWRITE parameter handle is supported (Handle)
CALL KI_REWRITE(rowbuf) KI_REWRITE parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_REWRITE(rowid) KI_REWRITE parameter rowid$ is supported (Row ID as returned from a previous operation)
CALL KI_REWRITE(status) KI_REWRITE parameter status is supported (Return status)
KI_ROLLBACK CALL KI_ROLLBACK Abandon a transaction on a database
CALL KI_ROLLBACK(connect) KI_ROLLBACK parameter connect is supported (Database connection)
CALL KI_ROLLBACK(status) KI_ROLLBACK parameter status is supported (Return status)
KI_SESSIONS CALL KI_SESSIONS Create a pseudo table of sessions in a database
CALL KI_SESSIONS(handle) KI_SESSIONS parameter handle is supported (Handle)
CALL KI_SESSIONS(nConnectId) KI_SESSIONS parameter nConnectId is supported (ConnectId of required session)
CALL KI_SESSIONS(status) KI_SESSIONS parameter status is supported (Return status)
KI_SET_COL_LIST CALL KI_SET_COL_LIST Specify temporary column list for next START
CALL KI_SET_COL_LIST(collist) KI_SET_COL_LIST parameter collist$ is supported (Comma separated list of columns)
CALL KI_SET_COL_LIST(handle) KI_SET_COL_LIST parameter handle is supported (Handle)
CALL KI_SET_COL_LIST(status) KI_SET_COL_LIST parameter status is supported (Return status)
KI_SET_DATESTAMP CALL KI_SET_DATESTAMP Turn datestamping on/off
CALL KI_SET_DATESTAMP(handle) KI_SET_DATESTAMP parameter handle is supported (Handle)
CALL KI_SET_DATESTAMP(mode) KI_SET_DATESTAMP parameter mode$ is supported ("S"et or "U"nset datestamping)
CALL KI_SET_DATESTAMP(status) KI_SET_DATESTAMP parameter status is supported (Return status)
KI_SET_EXTENT CALL KI_SET_EXTENT Defines how tables extents should be allocated
CALL KI_SET_EXTENT(handle) KI_SET_EXTENT parameter handle is supported (Handle)
CALL KI_SET_EXTENT(mode) KI_SET_EXTENT parameter mode is supported (Mode flags)
CALL KI_SET_EXTENT(percent) KI_SET_EXTENT parameter percent is supported (Percentage of original table size for the extent)
CALL KI_SET_EXTENT(status) KI_SET_EXTENT parameter status is supported (Return status)
KI_SET_LANGUAGE CALL KI_SET_LANGUAGE Set database languages
CALL KI_SET_LANGUAGE(connection) KI_SET_LANGUAGE parameter connection is supported (Current database connection)
CALL KI_SET_LANGUAGE(lang) KI_SET_LANGUAGE parameter lang is supported (Language)
CALL KI_SET_LANGUAGE(status) KI_SET_LANGUAGE parameter status is supported (Return status)
KI_SET_LANGUAGES CALL KI_SET_LANGUAGES Set database languages
CALL KI_SET_LANGUAGES(connection) KI_SET_LANGUAGES parameter connection is supported (Current database connection)
CALL KI_SET_LANGUAGES(lang) KI_SET_LANGUAGES parameter SYM(lang()) is supported (Language array)
CALL KI_SET_LANGUAGES(status) KI_SET_LANGUAGES parameter status is supported (Return status)
KI_SET_MODE CALL KI_SET_MODE Set recovery modes
CALL KI_SET_MODE(connect) KI_SET_MODE parameter connect is supported (Database connection)
CALL KI_SET_MODE(mode) KI_SET_MODE parameter mode is supported (New mode to be set)
CALL KI_SET_MODE(oldMode) KI_SET_MODE parameter oldMode is supported (Previous mode)
CALL KI_SET_MODE(status) KI_SET_MODE parameter status is supported (Return status)
KI_SET_ROWS CALL KI_SET_ROWS Set columns from the view in the rows for given rowids
CALL KI_SET_ROWS(h) KI_SET_ROWS parameter h is supported (Table handle)
CALL KI_SET_ROWS(nRows) KI_SET_ROWS parameter nRows is supported (Optional, rows to set, zero means use array size)
CALL KI_SET_ROWS(rowid) KI_SET_ROWS parameter SYM(rowid$()) is supported (Location of rows in table, zero for all of them)
CALL KI_SET_ROWS(status) KI_SET_ROWS parameter status is supported (Return status)
CALL KI_SET_ROWS(view) KI_SET_ROWS parameter SYM(view$) is supported (Symbol of row buffer for a view)
KI_SET_SERIAL CALL KI_SET_SERIAL Reset unique serial number of a handle
CALL KI_SET_SERIAL(handle) KI_SET_SERIAL parameter handle is supported (Handle)
CALL KI_SET_SERIAL(nCache) KI_SET_SERIAL parameter nCache is supported (Sequence cache size)
CALL KI_SET_SERIAL(offset) KI_SET_SERIAL parameter offset is supported (Offset of serial column)
CALL KI_SET_SERIAL(status) KI_SET_SERIAL parameter status is supported (Return status)
CALL KI_SET_SERIAL(value) KI_SET_SERIAL parameter value is supported (New serial number)
KI_SET_TIMESTAMP CALL KI_SET_TIMESTAMP Turn timestamping on/off
CALL KI_SET_TIMESTAMP(handle) KI_SET_TIMESTAMP parameter handle is supported (Handle)
CALL KI_SET_TIMESTAMP(mode) KI_SET_TIMESTAMP parameter mode$ is supported ("S"et or "U"nset timestamping)
CALL KI_SET_TIMESTAMP(status) KI_SET_TIMESTAMP parameter status is supported (Return status)
KI_SET_USERSTAMP CALL KI_SET_USERSTAMP Turn userstamping on/off
CALL KI_SET_USERSTAMP(handle) KI_SET_USERSTAMP parameter handle is supported (Handle)
CALL KI_SET_USERSTAMP(mode) KI_SET_USERSTAMP parameter mode$ is supported ("S"et or "U"nset userstamping)
CALL KI_SET_USERSTAMP(status) KI_SET_USERSTAMP parameter status is supported (Return status)
KI_SET_WLOCK_COUNT CALL KI_SET_WLOCK_COUNT Reset the table usage count
CALL KI_SET_WLOCK_COUNT(count) KI_SET_WLOCK_COUNT parameter count is supported (New value for count)
CALL KI_SET_WLOCK_COUNT(handle) KI_SET_WLOCK_COUNT parameter handle is supported (Handle)
CALL KI_SET_WLOCK_COUNT(oldCount) KI_SET_WLOCK_COUNT parameter oldCount is supported (Previous value)
CALL KI_SET_WLOCK_COUNT(status) KI_SET_WLOCK_COUNT parameter status is supported (Return status)
KI_SHA1 CALL KI_SHA1 Computes a 160 bit SHA-1 hash from the given buffer
CALL KI_SHA1(hash) KI_SHA1 parameter SYM(hash$) is supported (SHA-1 Hash of source string)
CALL KI_SHA1(status) KI_SHA1 parameter status is supported (Return status)
CALL KI_SHA1(text) KI_SHA1 parameter text$ is supported (Source string)
KI_SIZE CALL KI_SIZE Find the size of a file
CALL KI_SIZE(file) KI_SIZE parameter file$ is supported (File name)
CALL KI_SIZE(size) KI_SIZE parameter size is supported (Size in bytes)
KI_SIZE_FILE CALL KI_SIZE_FILE Find the expected size of a table
CALL KI_SIZE_FILE(blocklen) KI_SIZE_FILE parameter blocklen is supported (Index block size)
CALL KI_SIZE_FILE(dictfile) KI_SIZE_FILE parameter dictfile$ is supported (Dictionary name (not used))
CALL KI_SIZE_FILE(filetype) KI_SIZE_FILE parameter filetype is supported (1 for type 6 tables)
CALL KI_SIZE_FILE(handle) KI_SIZE_FILE parameter handle is supported (Handle)
CALL KI_SIZE_FILE(keyspec) KI_SIZE_FILE parameter SYM(keyspec$()) is supported (Symbol of key details)
CALL KI_SIZE_FILE(packing) KI_SIZE_FILE parameter packing is supported (Percentage packing factor)
CALL KI_SIZE_FILE(rowlen) KI_SIZE_FILE parameter rowlen is supported (Row length in bytes)
CALL KI_SIZE_FILE(rows) KI_SIZE_FILE parameter rows is supported (Number of required rows)
CALL KI_SIZE_FILE(size) KI_SIZE_FILE parameter size is supported (Size in 256 byte allocation units)
CALL KI_SIZE_FILE(status) KI_SIZE_FILE parameter status is supported (Return status)
KI_SNAPSHOT CALL KI_SNAPSHOT Snapshot a temporary KDB table
CALL KI_SNAPSHOT(eAttr) KI_SNAPSHOT parameter eAttr is supported (attribute)
CALL KI_SNAPSHOT(handle) KI_SNAPSHOT parameter handle is supported (Handle)
CALL KI_SNAPSHOT(status) KI_SNAPSHOT parameter status is supported (Return status)
KI_SQL CALL KI_SQL prepare and execute an SQL statement
CALL KI_SQL(colcount) KI_SQL parameter colcount is supported (Number of columns in result set)
CALL KI_SQL(extratext) KI_SQL parameter extratext$ is supported (Extra SQL)
CALL KI_SQL(handle) KI_SQL parameter handle is supported (Handle)
CALL KI_SQL(sql) KI_SQL parameter sql$ is supported (SQL statement)
CALL KI_SQL(status) KI_SQL parameter status is supported (Return status)
KI_SQL_XML CALL KI_SQL_XML Prepare, execute and fetch a SQL statement
CALL KI_SQL_XML(buf) KI_SQL_XML parameter SYM(buf$) is supported (Buffer to hold result)
CALL KI_SQL_XML(handle) KI_SQL_XML parameter handle is supported (Handle)
CALL KI_SQL_XML(len) KI_SQL_XML parameter len is supported (Length of result buffer)
CALL KI_SQL_XML(sql) KI_SQL_XML parameter sql$ is supported (SQL statement)
CALL KI_SQL_XML(status) KI_SQL_XML parameter status is supported (Return status)
CALL KI_SQL_XML(xsl) KI_SQL_XML parameter xsl$ is supported (Include xsl URL)
KI_START CALL KI_START Find the start of a row
CALL KI_START(bClosed) KI_START parameter bClosed is supported (Closed range flag)
CALL KI_START(bLock) KI_START parameter bLock is supported (Lock result set)
CALL KI_START(bSkipMatch) KI_START parameter bSkipMatch is supported (Skip matching row)
CALL KI_START(bUseAllCols) KI_START parameter bUseAllCols is supported (Use all columns of key when nCols is less)
CALL KI_START(handle) KI_START parameter handle is supported (Handle)
CALL KI_START(keys) KI_START parameter keys$ is supported (Row's key)
CALL KI_START(max) KI_START parameter max_rows is supported (Max rows to return)
CALL KI_START(nCols) KI_START parameter nCols is supported (Number of significant columns in a compound key)
CALL KI_START(path) KI_START parameter path is supported (Path number)
CALL KI_START(sql) KI_START parameter sql is supported (SQL Where Handle)
CALL KI_START(status) KI_START parameter status is supported (Return status)
KI_START_BEG CALL KI_START_BEG Find the first row
CALL KI_START_BEG(handle) KI_START_BEG parameter handle is supported (Handle)
CALL KI_START_BEG(maxrows) KI_START_BEG parameter maxrows is supported (Max number of rows required)
CALL KI_START_BEG(path) KI_START_BEG parameter path is supported (Path number)
CALL KI_START_BEG(row) KI_START_BEG parameter SYM(row$) is supported (Optional row buffer specifying the view)
CALL KI_START_BEG(sql) KI_START_BEG parameter sql is supported (SQL Where Handle)
CALL KI_START_BEG(status) KI_START_BEG parameter status is supported (Return status)
KI_START_BETWEEN CALL KI_START_BETWEEN Find rows between start and end keys limiting rows returned to max rows
CALL KI_START_BETWEEN(bLock) KI_START_BETWEEN parameter bLock is supported (Lock result set)
CALL KI_START_BETWEEN(bSkipMatch) KI_START_BETWEEN parameter bSkipMatch is supported (Skip matching row)
CALL KI_START_BETWEEN(cols1) KI_START_BETWEEN parameter cols1 is supported (Number of significant columns in the starting key)
CALL KI_START_BETWEEN(cols2) KI_START_BETWEEN parameter cols2 is supported (Number of significant columns in the end key)
CALL KI_START_BETWEEN(handle) KI_START_BETWEEN parameter handle is supported (Handle)
CALL KI_START_BETWEEN(key1) KI_START_BETWEEN parameter key1$ is supported (Starting key)
CALL KI_START_BETWEEN(key2) KI_START_BETWEEN parameter key2$ is supported (End key)
CALL KI_START_BETWEEN(max) KI_START_BETWEEN parameter max_rows is supported (Max rows to return)
CALL KI_START_BETWEEN(path) KI_START_BETWEEN parameter path is supported (Path number)
CALL KI_START_BETWEEN(sql) KI_START_BETWEEN parameter sql is supported (SQL Where Handle)
CALL KI_START_BETWEEN(status) KI_START_BETWEEN parameter status is supported (Return status)
KI_START_FIRST CALL KI_START_FIRST Find the start of a row limiting rows returned to max rows
CALL KI_START_FIRST(bSkipMatch) KI_START_FIRST parameter bSkipMatch is supported (Skip matching row)
CALL KI_START_FIRST(handle) KI_START_FIRST parameter handle is supported (Handle)
CALL KI_START_FIRST(keys) KI_START_FIRST parameter keys$ is supported (Row's key)
CALL KI_START_FIRST(max) KI_START_FIRST parameter max_rows is supported (Max rows to return)
CALL KI_START_FIRST(nCols) KI_START_FIRST parameter nCols is supported (Number of significant columns in a compound key)
CALL KI_START_FIRST(path) KI_START_FIRST parameter path is supported (Path number)
CALL KI_START_FIRST(sql) KI_START_FIRST parameter sql is supported (SQL Where Handle)
CALL KI_START_FIRST(status) KI_START_FIRST parameter status is supported (Return status)
KI_START_ON CALL KI_START_ON Start equals
CALL KI_START_ON(bSkipMatch) KI_START_ON parameter bSkipMatch is supported (Skip matching row)
CALL KI_START_ON(handle) KI_START_ON parameter handle is supported (Table handle)
CALL KI_START_ON(keys) KI_START_ON parameter keys$ is supported (Compound row key)
CALL KI_START_ON(max) KI_START_ON parameter max_rows is supported (Max rows to return)
CALL KI_START_ON(nCols) KI_START_ON parameter nCols is supported (Number of significant columns in a compound key)
CALL KI_START_ON(path) KI_START_ON parameter path is supported (Key path)
CALL KI_START_ON(sql) KI_START_ON parameter sql is supported (SQL Where Handle)
CALL KI_START_ON(status) KI_START_ON parameter status is supported (Return status)
KI_START_ROW CALL KI_START_ROW Start using row to specify key
CALL KI_START_ROW(bClosed) KI_START_ROW parameter bClosed is supported (Closed range flag)
CALL KI_START_ROW(bLock) KI_START_ROW parameter bLock is supported (Lock result set)
CALL KI_START_ROW(bSkipMatch) KI_START_ROW parameter bSkipMatch is supported (Skip matching row)
CALL KI_START_ROW(bUseAllCols) KI_START_ROW parameter bUseAllCols is supported (Use all columns of key even if nCols is non-zero)
CALL KI_START_ROW(handle) KI_START_ROW parameter handle is supported (Table handle)
CALL KI_START_ROW(max) KI_START_ROW parameter max_rows is supported (Max rows to return)
CALL KI_START_ROW(nCols) KI_START_ROW parameter nCols is supported (Number of significant columns in a compound key)
CALL KI_START_ROW(path) KI_START_ROW parameter path is supported (Key path)
CALL KI_START_ROW(row) KI_START_ROW parameter SYM(row$)> is supported (Row buffer)
CALL KI_START_ROW(sql) KI_START_ROW parameter sql is supported (SQL Where Handle)
CALL KI_START_ROW(status) KI_START_ROW parameter status is supported (Return status)
KI_START_ROW_BETWEEN CALL KI_START_ROW_BETWEEN Find rows between start and end keys limiting rows returned to max rows
CALL KI_START_ROW_BETWEEN(bLock) KI_START_ROW_BETWEEN parameter bLock is supported (Lock result set)
CALL KI_START_ROW_BETWEEN(bSkipMatch) KI_START_ROW_BETWEEN parameter bSkipMatch is supported (Skip matching row)
CALL KI_START_ROW_BETWEEN(handle) KI_START_ROW_BETWEEN parameter handle is supported (Handle)
CALL KI_START_ROW_BETWEEN(max) KI_START_ROW_BETWEEN parameter max_rows is supported (Max rows to return)
CALL KI_START_ROW_BETWEEN(nCols1) KI_START_ROW_BETWEEN parameter nCols1 is supported (Number of significant columns in a starting key)
CALL KI_START_ROW_BETWEEN(nCols2) KI_START_ROW_BETWEEN parameter nCols2 is supported (Number of significant columns in a ending key)
CALL KI_START_ROW_BETWEEN(path) KI_START_ROW_BETWEEN parameter path is supported (Path number)
CALL KI_START_ROW_BETWEEN(row1) KI_START_ROW_BETWEEN parameter SYM(row1$)> is supported (Row specifying starting key)
CALL KI_START_ROW_BETWEEN(row2) KI_START_ROW_BETWEEN parameter SYM(row2$)> is supported (Row specifying end key)
CALL KI_START_ROW_BETWEEN(sql) KI_START_ROW_BETWEEN parameter sql is supported (SQL Where Handle)
CALL KI_START_ROW_BETWEEN(status) KI_START_ROW_BETWEEN parameter status is supported (Return status)
KI_STAT CALL KI_STAT File information
CALL KI_STAT(path) KI_STAT parameter path$ is supported (Pathname)
CALL KI_STAT(rowbuf) KI_STAT parameter SYM(rowbuf$()) is supported (Row buffer or row buffer array)
CALL KI_STAT(status) KI_STAT parameter status is supported (Optional return status)
KI_STATFS CALL KI_STATFS Find filesystem statistics
CALL KI_STATFS(diskSize) KI_STATFS parameter diskSize is supported (Size of file system (kBytes))
CALL KI_STATFS(file) KI_STATFS parameter file$ is supported (Pathname)
CALL KI_STATFS(freeInodes) KI_STATFS parameter freeInodes is supported (Number of spare inodes (-1 on Windows))
CALL KI_STATFS(freeSpace) KI_STATFS parameter freeSpace is supported (Free space on file system (kBytes))
CALL KI_STATFS(maxInodes) KI_STATFS parameter maxInodes is supported (Total number of inodes (-1 on Windows))
CALL KI_STATFS(remote) KI_STATFS parameter remote is supported (True if a remote network drive)
KI_TABLES CALL KI_TABLES Create a pseudo table of tables in a database
CALL KI_TABLES(handle) KI_TABLES parameter handle is supported (Handle)
CALL KI_TABLES(status) KI_TABLES parameter status is supported (Return status)
KI_TABLESPACES CALL KI_TABLESPACES Create a pseudo table of tablespaces in a database
CALL KI_TABLESPACES(handle) KI_TABLESPACES parameter handle is supported (Handle)
CALL KI_TABLESPACES(status) KI_TABLESPACES parameter status is supported (Return status)
KI_TABLE_SYNC CALL KI_TABLE_SYNC Flush cached blocks to disk
CALL KI_TABLE_SYNC(handle) KI_TABLE_SYNC parameter handle is supported (Handle)
CALL KI_TABLE_SYNC(status) KI_TABLE_SYNC parameter status is supported (Return status)
KI_TOUCH CALL KI_TOUCH Create an empty file
CALL KI_TOUCH(file) KI_TOUCH parameter file$ is supported (File name)
CALL KI_TOUCH(status) KI_TOUCH parameter status is supported (Return status)
KI_UNIQ CALL KI_UNIQ Internal use
CALL KI_UNIQ(buf) KI_UNIQ parameter SYM(buf$) is supported ()
CALL KI_UNIQ(count) KI_UNIQ parameter count is supported ()
CALL KI_UNIQ(size) KI_UNIQ parameter size is supported ()
CALL KI_UNIQ(step) KI_UNIQ parameter step is supported ()
CALL KI_UNIQ(threshold) KI_UNIQ parameter threshold is supported ()
KI_UNLOCK CALL KI_UNLOCK Unlock a row
CALL KI_UNLOCK(handle) KI_UNLOCK parameter handle is supported (Handle)
CALL KI_UNLOCK(rowid) KI_UNLOCK parameter rowid$ is supported (Row ID to row)
CALL KI_UNLOCK(status) KI_UNLOCK parameter status is supported (Return status)
KI_UNLOCK_FILE CALL KI_UNLOCK_FILE Unlock all rows
CALL KI_UNLOCK_FILE(handle) KI_UNLOCK_FILE parameter handle is supported (Handle)
CALL KI_UNLOCK_FILE(mode) KI_UNLOCK_FILE parameter mode is supported (0 for fast, 1 for slow but sure)
CALL KI_UNLOCK_FILE(status) KI_UNLOCK_FILE parameter status is supported (Return status)
KI_VERIFY CALL KI_VERIFY Check integrity of a table
CALL KI_VERIFY(handle) KI_VERIFY parameter handle is supported (Handle)
CALL KI_VERIFY(level) KI_VERIFY parameter level is supported (Level of verification (1-5))
CALL KI_VERIFY(status) KI_VERIFY parameter status is supported (Return status)
KI_WMODE_BITMAP CALL KI_WMODE_BITMAP Get Write mode bitmap
CALL KI_WMODE_BITMAP(buf) KI_WMODE_BITMAP parameter SYM(buf$) is supported (Symbol of row buffer)
CALL KI_WMODE_BITMAP(handle) KI_WMODE_BITMAP parameter handle is supported (Handle)
CALL KI_WMODE_BITMAP(status) KI_WMODE_BITMAP parameter status is supported (Return status)
KI_WRITE CALL KI_WRITE Write a new row
CALL KI_WRITE(eLockType) KI_WRITE parameter eLockType is supported (Optional lock type)
CALL KI_WRITE(handle) KI_WRITE parameter handle is supported (Handle)
CALL KI_WRITE(rowbuf) KI_WRITE parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_WRITE(rowid) KI_WRITE parameter rowid$ is supported ()
CALL KI_WRITE(status) KI_WRITE parameter status is supported (Return status)
KI_WRITE_PTR CALL KI_WRITE_PTR Write a row using a row ID
CALL KI_WRITE_PTR(handle) KI_WRITE_PTR parameter handle is supported (Handle)
CALL KI_WRITE_PTR(rowbuf) KI_WRITE_PTR parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_WRITE_PTR(rowid) KI_WRITE_PTR parameter rowid$ is supported (Row ID from a previous read)
CALL KI_WRITE_PTR(status) KI_WRITE_PTR parameter status is supported (Return status)
KI_WRITE_RAW CALL KI_WRITE_RAW Write a row at a given row number
CALL KI_WRITE_RAW(handle) KI_WRITE_RAW parameter handle is supported (Handle)
CALL KI_WRITE_RAW(rowbuf) KI_WRITE_RAW parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL KI_WRITE_RAW(rowid) KI_WRITE_RAW parameter rowid is supported (Row to start writing at)
CALL KI_WRITE_RAW(rowsin) KI_WRITE_RAW parameter rowsin is supported (Number of rows to write)
CALL KI_WRITE_RAW(rowsout) KI_WRITE_RAW parameter rowsout is supported (Number of rows actually written)
CALL KI_WRITE_RAW(status) KI_WRITE_RAW parameter status is supported (Return status)
KI_WS_ADD_INDEX CALL KI_WS_ADD_INDEX Add a temporary word search index
CALL KI_WS_ADD_INDEX(handle) KI_WS_ADD_INDEX parameter handle is supported (Handle)
CALL KI_WS_ADD_INDEX(nPath) KI_WS_ADD_INDEX parameter nPath is supported (Word search path for index)
CALL KI_WS_ADD_INDEX(noisefile) KI_WS_ADD_INDEX parameter noisefile$ is supported (Optional noise filename)
CALL KI_WS_ADD_INDEX(sCols) KI_WS_ADD_INDEX parameter sCols$ is supported (Columns for the temporary index (comma separated))
CALL KI_WS_ADD_INDEX(sIdxInfo) KI_WS_ADD_INDEX parameter sIdxInfo$ is supported (Index descriptor of type KDB_INFO_WSX)
CALL KI_WS_ADD_INDEX(sOrderByCols) KI_WS_ADD_INDEX parameter sOrderByCols$ is supported (Any order by columns)
CALL KI_WS_ADD_INDEX(status) KI_WS_ADD_INDEX parameter status is supported (Return status)
KI_WS_CREATE CALL KI_WS_CREATE Create a word search index
CALL KI_WS_CREATE(block) KI_WS_CREATE parameter block_size is supported (Extract file block size)
CALL KI_WS_CREATE(data) KI_WS_CREATE parameter data_handle is supported (Handle of the data table)
CALL KI_WS_CREATE(data) KI_WS_CREATE parameter data_ptr_size is supported (Size of ROWID)
CALL KI_WS_CREATE(extract) KI_WS_CREATE parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_CREATE(index) KI_WS_CREATE parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_CREATE(key) KI_WS_CREATE parameter key_length is supported (Data table key length)
CALL KI_WS_CREATE(row) KI_WS_CREATE parameter row_length is supported (Data table row length)
CALL KI_WS_CREATE(status) KI_WS_CREATE parameter status is supported (Return status)
CALL KI_WS_CREATE(ws) KI_WS_CREATE parameter SYM(ws_spec$) is supported (Defines options for the WS index)
KI_WS_DELETE CALL KI_WS_DELETE Delete a entry from a word search index
CALL KI_WS_DELETE(extract) KI_WS_DELETE parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_DELETE(index) KI_WS_DELETE parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_DELETE(key) KI_WS_DELETE parameter SYM(key$) is supported ()
CALL KI_WS_DELETE(rowbuf) KI_WS_DELETE parameter SYM(rowbuf$) is supported ()
CALL KI_WS_DELETE(rowid) KI_WS_DELETE parameter rowid$ is supported ()
CALL KI_WS_DELETE(status) KI_WS_DELETE parameter status is supported (Return status)
KI_WS_END CALL KI_WS_END Drop word search rowset
CALL KI_WS_END(handle) KI_WS_END parameter handle is supported (Handle)
CALL KI_WS_END(status) KI_WS_END parameter status is supported (Return status)
KI_WS_NOISE_INFO CALL KI_WS_NOISE_INFO Get list of noise words
CALL KI_WS_NOISE_INFO(buf) KI_WS_NOISE_INFO parameter SYM(buf$) is supported (Output buffer)
CALL KI_WS_NOISE_INFO(handle) KI_WS_NOISE_INFO parameter handle is supported (Handle)
CALL KI_WS_NOISE_INFO(path) KI_WS_NOISE_INFO parameter path is supported (Word search path)
CALL KI_WS_NOISE_INFO(status) KI_WS_NOISE_INFO parameter status is supported (Return status)
KI_WS_OPEN CALL KI_WS_OPEN Open a word search index
CALL KI_WS_OPEN(data) KI_WS_OPEN parameter data_file$ is supported (Table name)
CALL KI_WS_OPEN(extract) KI_WS_OPEN parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_OPEN(index) KI_WS_OPEN parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_OPEN(mode) KI_WS_OPEN parameter mode$ is supported (Mode)
CALL KI_WS_OPEN(status) KI_WS_OPEN parameter status is supported (Return status)
KI_WS_READ CALL KI_WS_READ Look up a row via a word search index
CALL KI_WS_READ(extract) KI_WS_READ parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_READ(index) KI_WS_READ parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_READ(rowbuf) KI_WS_READ parameter SYM(rowbuf$) is supported ()
CALL KI_WS_READ(rowsout) KI_WS_READ parameter rowsout is supported (Rows read)
CALL KI_WS_READ(status) KI_WS_READ parameter status is supported (Return status)
CALL KI_WS_READ(words) KI_WS_READ parameter SYM(words$) is supported ()
KI_WS_READ_NEXT CALL KI_WS_READ_NEXT Read the next row in the word search rowset
CALL KI_WS_READ_NEXT(handle) KI_WS_READ_NEXT parameter handle is supported (Handle)
CALL KI_WS_READ_NEXT(nRows) KI_WS_READ_NEXT parameter nRows is supported (Rows to read)
CALL KI_WS_READ_NEXT(nRowsRead) KI_WS_READ_NEXT parameter nRowsRead is supported (Rows read)
CALL KI_WS_READ_NEXT(rowbuf) KI_WS_READ_NEXT parameter SYM(rowbuf$()) is supported (Row buffer or row buffer array)
CALL KI_WS_READ_NEXT(rowid) KI_WS_READ_NEXT parameter SYM(rowid$()) is supported (Row ID or rowid array)
CALL KI_WS_READ_NEXT(status) KI_WS_READ_NEXT parameter status is supported (Return status)
KI_WS_REWRITE CALL KI_WS_REWRITE Update an entry in a word search index
CALL KI_WS_REWRITE(extract) KI_WS_REWRITE parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_REWRITE(index) KI_WS_REWRITE parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_REWRITE(key) KI_WS_REWRITE parameter SYM(key$) is supported ()
CALL KI_WS_REWRITE(pre) KI_WS_REWRITE parameter SYM(pre_row$) is supported ()
CALL KI_WS_REWRITE(pre) KI_WS_REWRITE parameter SYM(pre_key$) is supported ()
CALL KI_WS_REWRITE(rowbuf) KI_WS_REWRITE parameter SYM(rowbuf$) is supported ()
CALL KI_WS_REWRITE(rowid) KI_WS_REWRITE parameter rowid$ is supported ()
CALL KI_WS_REWRITE(status) KI_WS_REWRITE parameter status is supported (Return status)
KI_WS_START CALL KI_WS_START Create a word search rowset based on words
CALL KI_WS_START(handle) KI_WS_START parameter handle is supported (Handle)
CALL KI_WS_START(path) KI_WS_START parameter path is supported (Word search path to search on)
CALL KI_WS_START(row) KI_WS_START parameter SYM(row$) is supported (Optional row buffer specifying the view)
CALL KI_WS_START(rows) KI_WS_START parameter rows is supported (Number of matching rows found)
CALL KI_WS_START(sql) KI_WS_START parameter sql is supported (SQL Where Handle)
CALL KI_WS_START(status) KI_WS_START parameter status is supported (Return status)
CALL KI_WS_START(word) KI_WS_START parameter word$ is supported (String of words to search for)
KI_WS_WRITE CALL KI_WS_WRITE Create an entry in a word search index
CALL KI_WS_WRITE(extract) KI_WS_WRITE parameter extract_handle is supported (Handle of the extract file)
CALL KI_WS_WRITE(index) KI_WS_WRITE parameter index_handle is supported (Handle of the WS index file)
CALL KI_WS_WRITE(key) KI_WS_WRITE parameter SYM(key$) is supported ()
CALL KI_WS_WRITE(rowbuf) KI_WS_WRITE parameter SYM(rowbuf$) is supported (The row bufer as written to the data table)
CALL KI_WS_WRITE(rowid) KI_WS_WRITE parameter rowid$ is supported (The ROWID for the row buffer)
CALL KI_WS_WRITE(status) KI_WS_WRITE parameter status is supported (Return status)
R7_DATE2J CALL R7_DATE2J Convert a date string into a Julian date
CALL R7_DATE2J(date) R7_DATE2J parameter date$ is supported (Date string dd/mm/yy or "TODAY")
CALL R7_DATE2J(julian) R7_DATE2J parameter julian_date is supported (Julian date)
R7_J2DATE CALL R7_J2DATE Convert Julian date to a string
CALL R7_J2DATE(date) R7_J2DATE parameter date$ is supported (Date buffer)
CALL R7_J2DATE(julian) R7_J2DATE parameter julian_date is supported (Julian date)
CALL R7_J2DATE(len) R7_J2DATE parameter len is supported (Length of date buffer either 8 or 10)
XML_CLOSE CALL XML_CLOSE Close an XML handle
CALL XML_CLOSE(handle) XML_CLOSE parameter handle is supported (Handle to close)
CALL XML_CLOSE(status) XML_CLOSE parameter status is supported (Return status)
XML_ERROR CALL XML_ERROR Return details of last error
CALL XML_ERROR(buf) XML_ERROR parameter buf$ is supported (Error text buffer)
CALL XML_ERROR(code) XML_ERROR parameter code is supported (Last error code)
CALL XML_ERROR(col) XML_ERROR parameter col is supported (Located at column)
CALL XML_ERROR(handle) XML_ERROR parameter handle is supported (Handle that encountered the error)
CALL XML_ERROR(line) XML_ERROR parameter line is supported (Located on line)
CALL XML_ERROR(offset) XML_ERROR parameter offset is supported (Located at byte offset)
CALL XML_ERROR(status) XML_ERROR parameter status is supported (Return status)
XML_NEXT CALL XML_NEXT Return next element in the XML file
CALL XML_NEXT(attr) XML_NEXT parameter SYM(attr$()) is supported (Symbol of elements array)
CALL XML_NEXT(handle) XML_NEXT parameter handle is supported (XML handle)
CALL XML_NEXT(level) XML_NEXT parameter level is supported (Returned indent level)
CALL XML_NEXT(name) XML_NEXT parameter SYM(name$) is supported (Symbol of element name)
CALL XML_NEXT(nodetype) XML_NEXT parameter nodetype is supported (Returned node type)
CALL XML_NEXT(status) XML_NEXT parameter status is supported (Return status)
CALL XML_NEXT(value) XML_NEXT parameter SYM(value$) is supported (Symbol of element value)
CALL XML_NEXT(values) XML_NEXT parameter SYM(values$()) is supported (Symbol of values array)
XML_OPEN CALL XML_OPEN Open an XML file
CALL XML_OPEN(file) XML_OPEN parameter file$ is supported (Name of XML file to open)
CALL XML_OPEN(handle) XML_OPEN parameter handle is supported (Returned XML Handle)
CALL XML_OPEN(status) XML_OPEN parameter status is supported (Return status)
XML_OPTIONS CALL XML_OPTIONS set options for XML parser
CALL XML_OPTIONS(handle) XML_OPTIONS parameter handle is supported (XML Handle)
CALL XML_OPTIONS(opt) XML_OPTIONS parameter opt$ is supported (Options array)
CALL XML_OPTIONS(status) XML_OPTIONS parameter status is supported (Return status)
XML_PARSE_BUFFER CALL XML_PARSE_BUFFER Parse a buffer containing XML
CALL XML_PARSE_BUFFER(buffer) XML_PARSE_BUFFER parameter SYM(buffer$) is supported (Symbol of buffer)
CALL XML_PARSE_BUFFER(handle) XML_PARSE_BUFFER parameter handle is supported (Returned XML handle)
CALL XML_PARSE_BUFFER(status) XML_PARSE_BUFFER parameter status is supported (Return status)
XML_TEXT CALL XML_TEXT Convert a rowbuf$ to XML text
CALL XML_TEXT(col) XML_TEXT parameter SYM(col()) is supported (Optional column array)
CALL XML_TEXT(handle) XML_TEXT parameter handle is supported (Handle)
CALL XML_TEXT(len) XML_TEXT parameter len is supported (Length of result buffer)
CALL XML_TEXT(mode) XML_TEXT parameter mode is supported (Mode: RAW, XMLData etc.)
CALL XML_TEXT(rowbuf) XML_TEXT parameter SYM(rowbuf$) is supported (Symbol of row buffer)
CALL XML_TEXT(status) XML_TEXT parameter status is supported (Return status)
CALL XML_TEXT(text) XML_TEXT parameter SYM(text$) is supported (Symbol of result text buffer)
CHAR $PACK format CHAR supported. Character field (presumed to be UTF-8 encoded)
COMP $PACK format COMP supported. Compressed alphanumeric format
COMPILED application is running in compiled mode
CURRENCY $PACK format CURRENCY supported. Currency. For now, identical to NUM.
CURRENCY_PACKFORMAT CURRENCY(p,s) pack format
DATE $PACK format DATE supported. Julian date
CREATE TABLE DB_LANGUAGE_INDEXES In CREATE TABLE you can mark columns as language columns
DISP $PACK format DISP supported. IBM display format
DOM_APPLYTRANSLATIONS If defined then the Xerces DOM method applyTranslations is defined.
EVENSIGN $PACK format EVENSIGN supported. Wang signed packed decimal format with even number of digits
CREATE POOL EXTENDED_CREATE_POOL If defined then CREATE POOL may take an optional name and/or a USING clause.
FP $PACK format FP supported. Internal representation of a KCML number. Use this for SYM values.
FREE $PACK format FREE supported. ASCII free format
HEX $PACK format HEX supported. Binary field
IBM8 $PACK format IBM8 supported. IBM USASCII-8 format
IEEE $PACK format IEEE supported. IEEE floating point L-H little-endian format
IEEE4 $PACK format IEEE4 supported. IEEE floating point L-H little-endian format
INFORMIX $PACK format INFORMIX supported. Informix money format
INIT_TYPED_PTR $PACK format INIT_TYPED_PTR supported. Record string represented as a pool handle allocated in initialisation
INT $PACK format INT supported. Integer (signed)
INTERNAL $PACK format INTERNAL supported. internal ptr
INTERPRETED application is running in interpreted mode
'KCML_decode KCML_decode(7) 7 argument form of 'KCML_decode
'KCML_encode KCML_encode(7) 7 argument form of 'KCML_encode
LANG $PACK format LANG supported. Multi-language string field
LANGCHECK $PACK format LANGCHECK supported. Locales available
LIBRARY true iff this code is being built into a library
LINUX system is running on LINUX
LITTLE_ENDIAN system is running in little endian mode
LOW_VAL_CURRENCY $PACK format LOW_VAL_CURRENCY supported. Packed decimal format with binary overflow supporting size > 6 bytes
LOW_VAL_UCURRENCY $PACK format LOW_VAL_UCURRENCY supported. Packed unsigned decimal format with binary overflow supporting size > 6 bytes
MB $PACK format MB supported. Legacy boolean with "Y" for TRUE and "N" for FALSE
MD3 $PACK format MD3 supported. Three byte packed date of the form YYMMDD
METAPHONE $PACK format METAPHONE supported. METAPHONE phoneme encoding
METHOD $PACK format METHOD supported. vtable entry
MJ $PACK format MJ supported. Julian date (replaced by DATE)
MOTOROLA $PACK format MOTOROLA supported. IEEE floating point H-L big-endian format
MOTOROLA4 $PACK format MOTOROLA4 supported. IEEE floating point H-L big-endian format
MOVE PTR MOVE PTR MOVE PTR ptr TO destination
MT $PACK format MT supported. Time in seconds since midnight (replaced by TIME)
NIAKWA $PACK format NIAKWA supported. BASIC-2C internal format
NUM $PACK format NUM supported. Numeric (signed)
OBJECT_PTR $PACK format OBJECT_PTR supported. OBJECT represented as a pool handle
OVERFLOW $PACK format OVERFLOW supported. Packed decimal format with binary overflow
PACK $PACK format PACK supported. IBM packed decimal format
PACKDATE $PACK format PACKDATE supported. Four byte packed date of the form CCYYMMDD
POOL $PACK format POOL supported. A pool allocating handle
NEW POOLS_ARE_TREES If defined, then pool allocations form a tree, such that NEW x USING y allocates x as a child of y and a later DELETE PTR y would automatically delete x. Otherwise, pools are flat and have no implicit ownership hierarchy.
NEW POOL_UNLIMITED If defined then the number of pool handles available per memory pool is limited only by memory. In KCML 7.03 this is not defined and the limit is 262, 144.
PTR $PACK format PTR supported. String represented as a pool handle
SBINARY $PACK format SBINARY supported. Signed binary format
SIGN $PACK format SIGN supported. Wang signed packed decimal format as in PACK
SKIP $PACK format SKIP supported. Skip field
SOUNDEX $PACK format SOUNDEX supported. SOUNDEX encoding
SQL(ABS) RW_ABS
SQL(ABSOLUTE) RW_ABSOLUTE
SQL(ACOS) RW_ACOS
SQL(ACTION) RW_ACTION
SQL(ADA) RW_ADA
SQL(ADC) RW_ADC
SQL(ADD) RW_ADD
SQL(ALIAS) RW_ALIAS
SQL(ALL) RW_ALL
SQL(ALLOCATE) RW_ALLOCATE
SQL(ALTER) RW_ALTER
SQL(AND) RW_AND
SQL(ANY) RW_ANY
SQL(ARE) RW_ARE
SQL(AS) RW_AS
SQL(ASC) RW_ASC
SQL(ASCII) RW_ASCII
SQL(ASIN) RW_ASIN
SQL(ASSERTION) RW_ASSERTION
SQL(AT) RW_AT
SQL(ATAN) RW_ATAN
SQL(ATAN2) RW_ATAN2
SQL(AUTHORIZATION) RW_AUTHORIZATION
SQL(AUTO) RW_AUTO
SQL(AUTOEXTEND) RW_AUTOEXTEND
SQL(AVG) RW_AVG
SQL(BCDDATE) RW_KSEDATE
SQL(BCDDATE3) RW_KSEDATE3
SQL(BEGIN) RW_BEGIN
SQL(BETWEEN) RW_BETWEEN
SQL(BIT) RW_BIT
SQL(BITMAP) RW_BITMAP
SQL(BIT_LENGTH) RW_BIT_LENGTH
SQL(BLOB) RW_BLOB
SQL(BLOBDATA) RW_BLOBDATA
SQL(BLOCKLEN) RW_BLOCKLEN
SQL(BOOL) RW_BOOL
SQL(BOTH) RW_BOTH
SQL(BREAK) RW_BREAK
SQL(BY) RW_BY
SQL(CASCADE) RW_CASCADE
SQL(CASCADED) RW_CASCADED
SQL(CASE) RW_CASE
SQL(CAST) RW_CAST
SQL(CATALOG) RW_CATALOG
SQL(CATALOGUE) RW_CATALOGUE
SQL(CBLOB) RW_CBLOB
SQL(CEILING) RW_CEILING
SQL(CHAR) RW_CHAR
SQL(CHARACTER) RW_CHARACTER
SQL(CHARACTER_LENGTH) RW_CHARACTER_LENGTH
SQL(CHAR_LENGTH) RW_CHAR_LENGTH
SQL(CHECK) RW_CHECK
SQL(CJKWIDTH) RW_CJKWIDTH
SQL(CLOB) RW_CLOB
SQL(CLOSE) RW_CLOSE
SQL(COALESCE) RW_COALESCE
SQL(COBOL) RW_COBOL
SQL(COLLATE) RW_COLLATE
SQL(COLLATION) RW_COLLATION
SQL(COLUMN) RW_COLUMN
SQL(COMMIT) RW_COMMIT
SQL(COMPRESS) RW_COMPRESS
SQL(CONCAT) RW_CONCAT
SQL(CONNECT) RW_CONNECT
SQL(CONNECTION) RW_CONNECTION
SQL(CONSTRAINT) RW_CONSTRAINT
SQL(CONSTRAINTS) RW_CONSTRAINTS
SQL(CONTINUE) RW_CONTINUE
SQL(CONVERT) RW_CONVERT
SQL(CORRESPONDING) RW_CORRESPONDING
SQL(COS) RW_COS
SQL(COT) RW_COT
SQL(COUNT) RW_COUNT
SQL(CREATE) RW_CREATE
SQL(CROSS) RW_CROSS
SQL(CURDATE) RW_CURDATE
SQL(CURRENT) RW_CURRENT
SQL(CURRENT_DATE) RW_CURRENT_DATE
SQL(CURRENT_TIME) RW_CURRENT_TIME
SQL(CURRENT_TIMESTAMP) RW_CURRENT_TIMESTAMP
SQL(CURRENT_USER) RW_CURRENT_USER
SQL(CURSOR) RW_CURSOR
SQL(CURTIME) RW_CURTIME
SQL(DATABASE) RW_DATABASE
SQL(DATE) RW_DATE
SQL(DATESTAMP) RW_DATESTAMP
SQL(DAY) RW_DAY
SQL(DAYNAME) RW_DAYNAME
SQL(DAYOFMONTH) RW_DAYOFMONTH
SQL(DAYOFWEEK) RW_DAYOFWEEK
SQL(DAYOFYEAR) RW_DAYOFYEAR
SQL(DBIDSTAMP) RW_DBIDSTAMP
SQL(DEALLOCATE) RW_DEALLOCATE
SQL(DEC) RW_DEC
SQL(DECIMAL) RW_DECIMAL
SQL(DECLARE) RW_DECLARE
SQL(DEFAULT) RW_SQLDEFAULT
SQL(DEFERRABLE) RW_DEFERRABLE
SQL(DEFERRED) RW_DEFERRED
SQL(DEGREES) RW_DEGREES
SQL(DELETE) RW_DELETE
SQL(DESC) RW_DESC
SQL(DESCRIBE) RW_DESCRIBE
SQL(DESCRIPTION) RW_DESCRIPTION
SQL(DESCRIPTOR) RW_DESCRIPTOR
SQL(DIAGNOSTICS) RW_DIAGNOSTICS
SQL(DIFFERENCE) RW_DIFFERENCE
SQL(DISABLE) RW_DISABLE
SQL(DISCONNECT) RW_DISCONNECT
SQL(DISPLAY) RW_DISPLAY
SQL(DISTINCT) RW_DISTINCT
SQL(DOMAIN) RW_DOMAIN
SQL(DOUBLE) RW_DOUBLE
SQL(DROP) RW_DROP
SQL(DTD) RW_DTD
SQL(ELSE) RW_ELSE
SQL(ENABLE) RW_ENABLE
SQL(END) RW_END
SQL(END-EXEC) RW_END_EXEC
SQL(ESCAPE) RW_ESCAPE
SQL(EVENTS) RW_EVENTS
SQL(EXCEPT) RW_EXCEPT
SQL(EXCEPTION) RW_EXCEPTION
SQL(EXCLUDE) RW_EXCLUDE
SQL(EXEC) RW_EXEC
SQL(EXECUTE) RW_EXECUTE
SQL(EXISTS) RW_EXISTS
SQL(EXP) RW_EXP
SQL(EXPLICIT) RW_EXPLICIT
SQL(EXTENT) RW_EXTENT
SQL(EXTERNAL) RW_EXTERNAL
SQL(EXTRACT) RW_EXTRACT
SQL(FALSE) RW_FALSE
SQL(FETCH) RW_FETCH
SQL(FIRST) RW_FIRST
SQL(FLAT) RW_FLAT
SQL(FLOAT) RW_FLOAT
SQL(FLOOR) RW_FLOOR
SQL(FOR) RW_FOR
SQL(FOREIGN) RW_FOREIGN
SQL(FORTRAN) RW_FORTRAN
SQL(FOUND) RW_FOUND
SQL(FROM) RW_FROM
SQL(FULL) RW_FULL
SQL(GET) RW_GET
SQL(GLOBAL) RW_GLOBAL
SQL(GO) RW_GO
SQL(GOTO) RW_GOTO
SQL(GRANT) RW_GRANT
SQL(GROUP) RW_GROUP
SQL(HAVING) RW_HAVING
SQL(HEX) RW_HEX
SQL(HOUR) RW_HOUR
SQL(IBMPACKED) RW_KSEPACKED
SQL(ICU) RW_ICU
SQL(IDENTIFIED) RW_IDENTIFIED
SQL(IDENTITY) RW_IDENTITY
SQL(IDEOGRAM) RW_IDEOGRAM
SQL(IF) RW_IF
SQL(IFNULL) RW_IFNULL
SQL(IMMEDIATE) RW_IMMEDIATE
SQL(IN) RW_IN
SQL(INCLUDE) RW_INCLUDE
SQL(INDEX) RW_INDEX
SQL(INDICATOR) RW_INDICATOR
SQL(INITIALLY) RW_INITIALLY
SQL(INNER) RW_INNER
SQL(INPUT) RW_INPUT
SQL(INSENSITIVE) RW_INSENSITIVE
SQL(INSERT) RW_INSERT
SQL(INTEGER) RW_INTEGER
SQL(INTERNAL_NUMBER) RW_INTERNAL_NUMBER
SQL(INTERSECT) RW_INTERSECT
SQL(INTERVAL) RW_INTERVAL
SQL(INTO) RW_INTO
SQL(IPREFIX) RW_IPREFIX
SQL(IS) RW_IS
SQL(ISOLATION) RW_ISOLATION
SQL(JOIN) RW_JOIN
SQL(KDB) RW_KDB
SQL(KEY) RW_KEY
SQL(LANGUAGE) RW_LANGUAGE
SQL(LAST) RW_LAST
SQL(LCASE) RW_LCASE
SQL(LEADING) RW_LEADING
SQL(LEFT) RW_LEFT
SQL(LENGTH) RW_LENGTH
SQL(LEVEL) RW_LEVEL
SQL(LIKE) RW_LIKE
SQL(LOCAL) RW_LOCAL
SQL(LOCATE) RW_LOCATE
SQL(LOG) RW_LOG
SQL(LOG10) RW_LOG10
SQL(LOGGING) RW_LOGGING
SQL(LOGOGRAM) RW_LOGOGRAM
SQL(LONGUSERNAMES) RW_LONGUSERNAME
SQL(LOWER) RW_LOWER
SQL(LTRIM) RW_LTRIM
SQL(MATCH) RW_MATCH
SQL(MAX) RW_MAX
SQL(MAX_DUMP_FILE_SIZE) RW_MAX_DUMP_FILE_SIZE
SQL(MIN) RW_MIN
SQL(MINUTE) RW_MINUTE
SQL(MOD) RW_MOD
SQL(MODIFY) RW_MODIFY
SQL(MODULE) RW_MODULE
SQL(MONTH) RW_MONTH
SQL(MONTHNAME) RW_MONTHNAME
SQL(MOVE) RW_MOVE
SQL(MUMPS) RW_MUMPS
SQL(NAME) RW_NAME
SQL(NAMES) RW_NAMES
SQL(NATIONAL) RW_NATIONAL
SQL(NATURAL) RW_NATURAL
SQL(NCHAR) RW_NCHAR
SQL(NEXT) RW_NEXT
SQL(NO) RW_NO
SQL(NOCOMPACT) RW_NOCOMPACT
SQL(NOEDIT) RW_NOEDIT
SQL(NOISE) RW_NOISE
SQL(NOLOGGING) RW_NOLOGGING
SQL(NONALPHA) RW_NONALPHA
SQL(NONE) RW_NONE
SQL(NORMALIZE) RW_NORMALIZE
SQL(NOROWDEPENDENCIES) RW_NOROWDEPENDENCIES
SQL(NOT) RW_NOT
SQL(NOW) RW_NOW
SQL(NULL) RW_NULL
SQL(NULLIF) RW_NULLIF
SQL(NUMERIC) RW_NUMERIC
SQL(OBJECT_IMAGE) RW_OBJECT_IMAGE
SQL(OCCURS) RW_OCCURS
SQL(OCTET_LENGTH) RW_OCTET_LENGTH
SQL(OF) RW_OF
SQL(OFFSET) RW_OFFSET
SQL(OLD_DATE) RW_OLD_DATE
SQL(ON) RW_ON
SQL(ONLY) RW_ONLY
SQL(OPEN) RW_OPEN
SQL(OPTION) RW_OPTION
SQL(OR) RW_OR
SQL(ORACLE) RW_ORACLE
SQL(ORDER) RW_ORDER
SQL(OUTER) RW_OUTER
SQL(OUTPUT) RW_OUTPUT
SQL(OVERLAPS) RW_OVERLAPS
SQL(PACKING) RW_PACKING
SQL(PAD) RW_PAD
SQL(PARTIAL) RW_PARTIAL
SQL(PARTITION) RW_PARTITION
SQL(PASCAL) RW_PASCAL
SQL(PATH) RW_PATH
SQL(PCTFREE) RW_PCTFREE
SQL(PERMISSIONS) RW_PERMISSIONS
SQL(PI) RW_PI
SQL(PLI) RW_PLI
SQL(POSITION) RW_POSITION
SQL(POSTVAL) RW_POSTVAL
SQL(POWER) RW_POWER
SQL(PRECISION) RW_PRECISION
SQL(PREPARE) RW_PREPARE
SQL(PRESERVE) RW_PRESERVE
SQL(PREVAL) RW_PREVAL
SQL(PRIMARY) RW_PRIMARY
SQL(PRIOR) RW_PRIOR
SQL(PRIORITY) RW_PRIORITY
SQL(PRIVILEGES) RW_PRIVILEGES
SQL(PROCEDURE) RW_PROCEDURE
SQL(PUBLIC) RW_PUBLIC
SQL(QUARTER) RW_QUARTER
SQL(RADIANS) RW_RADIANS
SQL(RAND) RW_RAND
SQL(RANGE) RW_RANGE
SQL(RAW) RW_RAW
SQL(READ) RW_READ
SQL(RECLEN) RW_RECLEN
SQL(REFERENCES) RW_REFERENCES
SQL(RELATIVE) RW_RELATIVE
SQL(RENAME) RW_RENAME
SQL(REPEAT) RW_REPEAT
SQL(REPLACE) RW_REPLACE
SQL(RESIZE) RW_RESIZE
SQL(RESTRICT) RW_RESTRICT
SQL(REVOKE) RW_REVOKE
SQL(RIGHT) RW_RIGHT
SQL(ROLLBACK) RW_ROLLBACK
SQL(ROUND) RW_ROUND
SQL(ROWDEPENDENCIES) RW_ROWDEPENDENCIES
SQL(ROWS) RW_ROWS
SQL(RTRIM) RW_RTRIM
SQL(SCHEMA) RW_SCHEMA
SQL(SCROLL) RW_SCROLL
SQL(SECOND) RW_SECOND
SQL(SECTION) RW_SECTION
SQL(SELECT) RW_SELECT
SQL(SEQUENCE) RW_SEQUENCE
SQL(SERIAL) RW_SERIAL
SQL(SESSION) RW_SESSION
SQL(SESSION_USER) RW_SESSION_USER
SQL(SET) RW_SET
SQL(SIGN) RW_SIGN
SQL(SIGNED) RW_SIGNED
SQL(SIN) RW_SIN
SQL(SIZE) RW_SIZE
SQL(SMALLINT) RW_SMALLINT
SQL(SOME) RW_SOME
SQL(SORTMERGE) RW_SORT_MERGE
SQL(SOUNDEX) RW_SOUNDEX
SQL(SOURCE_IMAGE) RW_SOURCE_IMAGE
SQL(SPACE) RW_SPACE
SQL(SPECIAL) RW_SPECIAL
SQL(SQL) RW_SQL
SQL(SQLCA) RW_SQLCA
SQL(SQLCODE) RW_SQLCODE
SQL(SQLERROR) RW_SQLERROR
SQL(SQLSTATE) RW_SQLSTATE
SQL(SQLWARNING) RW_SQLWARNING
SQL(SQL_TSI_DAY) RW_SQL_TSI_DAY
SQL(SQL_TSI_FRAC_SECOND) RW_SQL_TSI_FRAC_SECOND
SQL(SQL_TSI_HOUR) RW_SQL_TSI_HOUR
SQL(SQL_TSI_MINUTE) RW_SQL_TSI_MINUTE
SQL(SQL_TSI_MONTH) RW_SQL_TSI_MONTH
SQL(SQL_TSI_QUARTER) RW_SQL_TSI_QUARTER
SQL(SQL_TSI_SECOND) RW_SQL_TSI_SECOND
SQL(SQL_TSI_WEEK) RW_SQL_TSI_WEEK
SQL(SQL_TSI_YEAR) RW_SQL_TSI_YEAR
SQL(SQRT) RW_SQRT
SQL(STARTBYTE) RW_STARTBYTE
SQL(SUBSTR) RW_SUBSTR
SQL(SUBSTRING) RW_SUBSTRING
SQL(SUM) RW_SUM
SQL(SYSTEM_USER) RW_SYSTEM_USER
SQL(TABLE) RW_TABLE
SQL(TABLESPACE) RW_TABLESPACE
SQL(TAN) RW_TAN
SQL(TEMPORARY) RW_TEMPORARY
SQL(THEN) RW_THEN
SQL(TIME) RW_TIME
SQL(TIMESTAMP) RW_TIMESTAMP
SQL(TIMESTAMPADD) RW_TIMESTAMPADD
SQL(TIMESTAMPDIFF) RW_TIMESTAMPDIFF
SQL(TIMEZONE_HOUR) RW_TIMEZONE_HOUR
SQL(TIMEZONE_MINUTE) RW_TIMEZONE_MINUTE
SQL(TO) RW_TO
SQL(TOP) RW_TOP
SQL(TOTALLED) RW_TOTALLED
SQL(TRACEFILE_IDENTIFIER) RW_TRACEFILE_IDENTIFIER
SQL(TRAILING) RW_TRAILING
SQL(TRANSACTION) RW_TRANSACTION
SQL(TRANSLATE) RW_TRANSLATE
SQL(TRANSLATION) RW_TRANSLATION
SQL(TREE) RW_TREE
SQL(TRIM) RW_TRIM
SQL(TRUE) RW_TRUE
SQL(TRUNCATE) RW_TRUNCATE
SQL(TYPE) RW_TYPE
SQL(TYPESTAMP) RW_TYPESTAMP
SQL(UCASE) RW_UCASE
SQL(UNION) RW_UNION
SQL(UNIQUE) RW_UNIQUE
SQL(UNKNOWN) RW_UNKNOWN
SQL(UNLIMITED) RW_UNLIMITED
SQL(UNSIGNED) RW_UNSIGNED
SQL(UNUSED) RW_UNUSED
SQL(UPDATE) RW_UPDATE
SQL(UPPER) RW_UPPER
SQL(USAGE) RW_USAGE
SQL(USER) RW_USER
SQL(USERSTAMP) RW_USERSTAMP
SQL(USE_KRCN) RW_USE_KRCN
SQL(USING) RW_USING
SQL(UUIDSTAMP) RW_UUIDSTAMP
SQL(VALIDATE) RW_VALIDATE
SQL(VALUE) RW_VALUE
SQL(VALUES) RW_VALUES
SQL(VARCHAR) RW_VARCHAR
SQL(VARCHAR2) RW_VARCHAR2
SQL(VARYING) RW_VARYING
SQL(VIEW) RW_VIEW
SQL(VIRTUAL) RW_VIRTUAL
SQL(WEEK) RW_WEEK
SQL(WHEN) RW_WHEN
SQL(WHENEVER) RW_WHENEVER
SQL(WHERE) RW_WHERE
SQL(WITH) RW_WITH
SQL(WORD) RW_WORD
SQL(WORK) RW_WORK
SQL(WRITE) RW_WRITE
SQL(XML) RW_XML
SQL(XMLDATA) RW_XMLDATA
SQL(YEAR) RW_YEAR
SQL(YES) RW_YES
SYM $PACK format SYM supported. Internal representation of a KCML number (replaced by FP)
TEXT $PACK format TEXT supported. Multiline text field
TIME $PACK format TIME supported. Time in seconds since midnight
TIMESTAMP $PACK format TIMESTAMP supported. Time stamp in milliseconds since 0000-00-00T00:00:00.000Z held in 6 bytes. Replaces TS6.
TS4 $PACK format TS4 supported. Time stamp in seconds since 1970-01-01T0000Z held in 4 bytes
TS6 $PACK format TS6 supported. Time stamp in milliseconds since 0000-00-00T00:00:00.000Z held in 6 bytes. Replaced by TIMESTAMP.
TYPED_PTR $PACK format TYPED_PTR supported. Record string represented as a pool handle
UINT $PACK format UINT supported. Integer (unsigned)
UNDEFINED $PACK format UNDEFINED supported. Only here to own the UNDEFINED zero value
UNEXT8 UNEXT8(2) 2 argument form of UNEXT8(strexpr, numexpr)
UNEXT8 UNEXT8(3) 3 argument form of UNEXT8(strexpr, numexpr, numexpr)
UNUM $PACK format UNUM supported. Numeric (unsigned)
UPREV8 UPREV8(2) 2 argument form of UPREV8(strexpr, numexpr)
UPREV8 UPREV8(3) 3 argument form of UPREV8(strexpr, numexpr, numexpr)
URL $PACK format URL supported. URL encoding
USIGN $PACK format USIGN supported. Unsigned packed decimal format
USING_ATTRIBUTE_GROUP USING ATTRIBUTE _group_AC and use of group="AC" in library definitions in kmake are supported
UTF16 $PACK format UTF16 supported. UTF-16, UCS-2 or Unicode encoding
UTF16BE $PACK format UTF16BE supported. UTF-16, UCS-2 or Unicode encoding, big-endian
UTF16BEP $PACK format UTF16BEP supported. UTF-16, UCS-2 or Unicode encoding, big-endian, with XML encoding
UTF16LE $PACK format UTF16LE supported. UTF-16, UCS-2 or Unicode encoding, little-endian
UTF16LEP $PACK format UTF16LEP supported. UTF-16, UCS-2 or Unicode encoding, little-endian, with XML encoding
UTF16P $PACK format UTF16P supported. UTF-16, UCS-2 or Unicode encoding, with XML encoding
UTF32 $PACK format UTF32 supported. UTF-32 or UCS-4 encoding
UTF32BE $PACK format UTF32BE supported. UTF-32 or UCS-4 encoding, big-endian
UTF32BEP $PACK format UTF32BEP supported. UTF-32 or UCS-4 encoding, big-endian, with XML encoding
UTF32LE $PACK format UTF32LE supported. UTF-32 or UCS-4 encoding, little-endian
UTF32LEP $PACK format UTF32LEP supported. UTF-32 or UCS-4 encoding, little-endian, with XML encoding
UTF32P $PACK format UTF32P supported. UTF-32 or UCS-4 encoding with XML encoding
UTF8 $PACK format UTF8 supported. UTF-8 encoding
UTF8PLUS $PACK format UTF8PLUS supported. UTF-8 and XML encoding
VTABLE $PACK format VTABLE supported. vtable entry
WANG $PACK format WANG supported. BASIC-2 internal BCD format
WANG_A $PACK format WANG_A supported. BASIC-2 internal BCD format
WINDOWS system is running on WINDOWS
XML $PACK format XML supported. XML entity encoding format
int16_t $PACK format int16_t supported. signed short
int32_t $PACK format int32_t supported. int
int64_t $PACK format int64_t supported. int64
int8_t $PACK format int8_t supported. signed char
int_t $PACK format int_t supported. signed int
ptr_t $PACK format ptr_t supported. PTRWORD
uint16_t $PACK format uint16_t supported. unsigned short
uint32_t $PACK format uint32_t supported. unsigned
uint64_t $PACK format uint64_t supported. uint64
uint8_t $PACK format uint8_t supported. unsigned char
uint_t $PACK format uint_t supported. unsigned int

Compatibility

Introduced in KCML 7.00.

Syntax Examples

    : IF CONDITION (FEATURE EXISTS(_KCML_DEFRECORD_Entry))
    : IF CONDITION (FEATURE EXISTS(.DEFRECORD_Start))
    : IF CONDITION (FEATURE EXISTS(.DEFRECORD_Name$))
    : IF CONDITION (FEATURE EXISTS('KCML_Map_File))
    : IF CONDITION (FEATURE EXISTS(.numeric_fld))
    : IF CONDITION (FEATURE EXISTS(.string_fld$))
    :
    : DIM _UseMappedFiles = FEATURE EXISTS('KCML_Map_File)

See also:

IF CONDITION, #if