sdsyb.pas

SQLDirect Component Library is a light-weight Borland Database Engine replacement for Borland Delphi

{**********************************************************}
{							   }
{       Delphi SQLDirect Component Library		   }
{	Sybase Open Client/Server API(11.5,12.5) Interface Unit }
{       			                           }
{       Copyright (c) 1997,2005 by Yuri Sheino		   }
{                                                          }
{**********************************************************}
{$I SqlDir.inc}
unit SDSyb {$IFDEF SD_CLR} platform {$ENDIF};

interface

uses
  Windows, SysUtils, Classes, Db, SyncObjs,
{$IFDEF SD_CLR}
  System.Runtime.InteropServices,
{$ENDIF}
  SDConsts, SDCommon;


{*******************************************************************************
**	csconfig.h (Sybase Open Client/Server Library) from 21.07.1997
**
** This file will try to hide any interface differences found on various
** platform/compiler combinations. Any datatype or define that is
** dependant on a particular platform/compiler should have its definition here.
*******************************************************************************}

{
   Define the scoping rules that will be used in all libraries. These defines
   exist to support different compiler-specific keywords describing the
   calling convention of a C function.
   CS_PUBLIC		Interface define for functions which are called
			outside of a library or DLL.
   CS_INTERNAL		Interface define for functions which are only called
			within a library or DLL.
   CS_VARARGS		Interface define for functions with variable argument
			lists which are called outside of a library or DLL.
   CS_STATIC		Interface define for functions which are only called
			within a C module.


#define CS_PUBLIC	__stdcall
#define CS_INTERNAL     CS_PUBLIC
#define CS_VARARGS      __stdcall
#define CS_STATIC       static
}


{-------------------------------------------------------------------------------
			Datatype definitions.
-------------------------------------------------------------------------------}
//** Certain Sybase C datatypes must be defined as 4 bytes in size.
type
  TCS_INT	= LongInt;
  TCS_RETCODE	= LongInt;
  TCS_BOOL	= LongInt;
  TCS_UINT	= DWORD;	//typedef	unsigned long	CS_UINT;


type
  void 		= TSDPtr;
  TCS_VOID	= void;
  TCS_THRDRES	= void;
  TCS_FLOAT	= Double;	// 8 byte float type
{$IFDEF SD_CLR}
  PCS_VOID	= TCS_VOID;
  PCS_INT	= TCS_VOID;
  PCS_THRDRES	= TCS_VOID;
{$ELSE}
  PCS_VOID	= ^TCS_VOID;
  PCS_INT	= ^TCS_INT;
  PCS_THRDRES	= ^TCS_THRDRES;
{$ENDIF}

const
  CS_BITS_PER_BYTE	= 8;	// Define the number of bits that a CS_BYTE can hold.

{*******************************************************************************
**	cstypes.h (Sybase Open Client/Server Library)
**
** This file defines basic error codes and data types used in all Open
** Client/Server System 10 Products.
*******************************************************************************}

{-------------------------------------------------------------------------------
	Return code defines used in client/server applications.
-------------------------------------------------------------------------------}
const
//** Define the core return codes.
  CS_SUCCEED		= TCS_RETCODE( 1);
  CS_FAIL		= TCS_RETCODE( 0);
  CS_MEM_ERROR		= TCS_RETCODE(-1);
  CS_PENDING		= TCS_RETCODE(-2);
  CS_QUIET		= TCS_RETCODE(-3);
  CS_BUSY		= TCS_RETCODE(-4);
  CS_INTERRUPT		= TCS_RETCODE(-5);
  CS_BLK_HAS_TEXT	= TCS_RETCODE(-6);
  CS_CONTINUE		= TCS_RETCODE(-7);
  CS_FATAL		= TCS_RETCODE(-8);
  CS_RET_HAFAILOVER	= TCS_RETCODE(-9);

//** Define error offsets. All other CS_RETCODE error codes should be
//** based off of these values to avoid define conflicts.
  CS_CONV_ERR		= TCS_RETCODE(-100);
  CS_EXTERNAL_ERR      	= TCS_RETCODE(-200);
  CS_INTERNAL_ERR      	= TCS_RETCODE(-300);

//* common library errors
  CS_COMN_ERR		= TCS_RETCODE(-400);

//** Return code for a routine which was cancelled via ct_cancel().
  CS_CANCELED		= TCS_RETCODE(CS_EXTERNAL_ERR - 2);

//** Special returns for ct_fetch().
  CS_ROW_FAIL		= TCS_RETCODE(CS_EXTERNAL_ERR - 3);
  CS_END_DATA		= TCS_RETCODE(CS_EXTERNAL_ERR - 4);

//** Special return for ct_results().
  CS_END_RESULTS	= TCS_RETCODE(CS_EXTERNAL_ERR - 5);

//** Special return for ct_get_data().
  CS_END_ITEM		= TCS_RETCODE(CS_EXTERNAL_ERR - 6);

//** Special return for ct_diag().
  CS_NOMSG		= TCS_RETCODE(CS_EXTERNAL_ERR - 7);

//** Special return for ct_poll().
  CS_TIMED_OUT		= TCS_RETCODE(CS_EXTERNAL_ERR - 8);

//** Special returns for passthru().
  CS_PASSTHRU_EOM      	= TCS_RETCODE(CS_EXTERNAL_ERR - 10);
  CS_PASSTHRU_MORE	= TCS_RETCODE(CS_EXTERNAL_ERR - 11);

//** Special return for ct_cancel().
  CS_TRYING		= TCS_RETCODE(CS_EXTERNAL_ERR - 13);

//** Errors caused by external events (i.e. bad params supplied by user).
  CS_EBADPARAM		= TCS_RETCODE(CS_EXTERNAL_ERR - 14);
  CS_EBADLEN		= TCS_RETCODE(CS_EXTERNAL_ERR - 15);
  CS_ENOCNVRT		= TCS_RETCODE(CS_EXTERNAL_ERR - 16);

//** Return codes for conversion errors. These should be used in any user-
//** defined conversion routines that are install via cs_set_convert().
  CS_EOVERFLOW		= TCS_RETCODE(CS_CONV_ERR - 1);
  CS_EUNDERFLOW		= TCS_RETCODE(CS_CONV_ERR - 2);
  CS_EPRECISION		= TCS_RETCODE(CS_CONV_ERR - 3);
  CS_ESCALE		= TCS_RETCODE(CS_CONV_ERR - 4);
  CS_ESYNTAX		= TCS_RETCODE(CS_CONV_ERR - 5);
  CS_EFORMAT		= TCS_RETCODE(CS_CONV_ERR - 6);
  CS_EDOMAIN		= TCS_RETCODE(CS_CONV_ERR - 7);
  CS_EDIVZERO		= TCS_RETCODE(CS_CONV_ERR - 8);
  CS_ERESOURCE		= TCS_RETCODE(CS_CONV_ERR - 9);
  CS_ENULLNOIND		= TCS_RETCODE(CS_CONV_ERR - 10);
  CS_ETRUNCNOIND	= TCS_RETCODE(CS_CONV_ERR - 11);
  CS_ENOBIND		= TCS_RETCODE(CS_CONV_ERR - 12);
  CS_TRUNCATED		= TCS_RETCODE(CS_CONV_ERR - 13);
  CS_ESTYLE		= TCS_RETCODE(CS_CONV_ERR - 14);
  CS_EBADXLT      	= TCS_RETCODE(CS_CONV_ERR - 15);
  CS_ENOXLT       	= TCS_RETCODE(CS_CONV_ERR - 16);
  CS_USEREP		= TCS_RETCODE(CS_CONV_ERR - 17);

//** Error Severities.
  CS_SV_INFORM		= TCS_INT(0);
  CS_SV_API_FAIL	= TCS_INT(1);
  CS_SV_RETRY_FAIL	= TCS_INT(2);
  CS_SV_RESOURCE_FAIL	= TCS_INT(3);
  CS_SV_CONFIG_FAIL	= TCS_INT(4);
  CS_SV_COMM_FAIL	= TCS_INT(5);
  CS_SV_INTERNAL_FAIL	= TCS_INT(6);
  CS_SV_FATAL		= TCS_INT(7);

{-------------------------------------------------------------------------------
   Error numbers, and macros for extracting information from a
   Client-Library error number.

   Error numbers are broken down into four components:
      	Layer		- Represents which layer is reporting the error.
        Origin		- Indicates where the error manifested itself.
        Severity	- How bad is the error?
        Number		- The actual layer specific error number being
               		  reported.
-------------------------------------------------------------------------------}

//** The error message number.
type
  TCS_MSGNUM	= LongInt;

{*
** The following macros are used to extract the components from a composite
** error number.
*
#define CS_LAYER(L)	(CS_MSGNUM) (((L) >> 24) & 0xff)
#define CS_ORIGIN(O)	(CS_MSGNUM) (((O) >> 16) & 0xff)
#define CS_SEVERITY(S)	(CS_MSGNUM) (((S) >> 8) & 0xff)
#define CS_NUMBER(N)	(CS_MSGNUM) ((N) & 0xff)
}

const

//** The following are the possible values for cs_status field of
//** CHAR_ATTRIB structure defined in intl_nls.h
  CS_STAT_DEFAULT	= $0000;
  CS_STAT_MULTIBYTE	= $0001;
  CS_STAT_SPACELAST	= $0002;
  CS_STAT_NONASCIISP	= $0004;

{-------------------------------------------------------------------------------
	Defines used in client/server applications.
-------------------------------------------------------------------------------}

//** The maximum localization name allowed. A four byte value is added (instead
//** of 1 byte) to provide space for null termination and remain on a modulo 4
//** byte boundary.
  CS_MAX_LOCALE		= TCS_INT(64 + 4);

//** The maximum column name allowed.
  CS_MAX_NAME		= TCS_INT(128 + 4);

//**
//** The maximum password length allowed.
//**
  CS_MAX_PASS		= TCS_INT(30);
//** The maximum number of characters in arrays. Please note that this define
//** does not correspond to any server definition of lengths (particularly
//** the length of the character data type, which is 255 bytes for the Sybase server).
  CS_MAX_CHAR		= TCS_INT(256);

//** Maximum string in Directory Services
  CS_MAX_DS_STRING	= TCS_INT(512);

//** Maximum data length of numeric/decimal datatypes.
  CS_MAX_NUMLEN		= TCS_INT(33);

//** To be true or not true.
  CS_TRUE		= TCS_BOOL(1);
  CS_FALSE		= TCS_BOOL(0);

//** Define basic default types.
  CS_NULLTERM		= TCS_INT(-9);
  CS_WILDCARD		= TCS_INT(-99);
  CS_NO_LIMIT		= TCS_INT(-9999);
  CS_UNUSED		= TCS_INT(-99999);


//** timeout values
//**	CS_NO_LIMIT		Resource will never expire.
//**	CS_UNEXPIRED		Resource did not expire.
  CS_UNEXPIRED		= TCS_INT(-999999);

//**
//** Enumerate part of usertypes dataserver support.
//**
  USER_UNICHAR_TYPE	= TCS_INT(34);
  USER_UNIVARCHAR_TYPE	= TCS_INT(35);

//** Enumerate what datatypes we support.
  CS_ILLEGAL_TYPE	= TCS_INT(-1);
  CS_CHAR_TYPE		= TCS_INT(0);
  CS_BINARY_TYPE	= TCS_INT(1);
  CS_LONGCHAR_TYPE	= TCS_INT(2);
  CS_LONGBINARY_TYPE	= TCS_INT(3);
  CS_TEXT_TYPE		= TCS_INT(4);
  CS_IMAGE_TYPE		= TCS_INT(5);
  CS_TINYINT_TYPE	= TCS_INT(6);
  CS_SMALLINT_TYPE	= TCS_INT(7);
  CS_INT_TYPE		= TCS_INT(8);
  CS_REAL_TYPE		= TCS_INT(9);
  CS_FLOAT_TYPE		= TCS_INT(10);
  CS_BIT_TYPE		= TCS_INT(11);
  CS_DATETIME_TYPE	= TCS_INT(12);
  CS_DATETIME4_TYPE	= TCS_INT(13);
  CS_MONEY_TYPE		= TCS_INT(14);
  CS_MONEY4_TYPE	= TCS_INT(15);
  CS_NUMERIC_TYPE	= TCS_INT(16);
  CS_DECIMAL_TYPE	= TCS_INT(17);
  CS_VARCHAR_TYPE	= TCS_INT(18);
  CS_VARBINARY_TYPE	= TCS_INT(19);
  CS_LONG_TYPE		= TCS_INT(20);
  CS_SENSITIVITY_TYPE	= TCS_INT(21);
  CS_BOUNDARY_TYPE	= TCS_INT(22);
  CS_VOID_TYPE		= TCS_INT(23);
  CS_USHORT_TYPE	= TCS_INT(24);
  CS_UNICHAR_TYPE	= TCS_INT(25);
  CS_BLOB_TYPE		= TCS_INT(26);

//** Define the minimum and maximum datatype values.
  CS_MIN_SYBTYPE 	= CS_CHAR_TYPE;
  CS_MAX_SYBTYPE 	= CS_UNICHAR_TYPE;

//** Define the number of datatypes that are supported by Sybase.
  CS_MAXSYB_TYPE	= CS_MAX_SYBTYPE + 1;

//** The minumum user-defined data type.
  CS_USER_TYPE		= TCS_INT(100);

//** Define the bit values used in the format element of the CS_DATAFMT
//** structure. The CS_FMT_JUSTIFY_RT flag exists for future use only.
  CS_FMT_UNUSED		= TCS_INT($00);
  CS_FMT_NULLTERM	= TCS_INT($01);
  CS_FMT_PADNULL	= TCS_INT($02);
  CS_FMT_PADBLANK	= TCS_INT($04);
  CS_FMT_JUSTIFY_RT	= TCS_INT($08);
  CS_FMT_STRIPBLANKS	= TCS_INT($10);
  CS_FMT_SAFESTR	= TCS_INT($20);

{*
** The following are bit values for the status field in the CS_DATAFMT
** structure.
**
** CS_HIDDEN		Set if this column would normally be hidden
**			from the user.
**
** CS_KEY		Set if the column is a key column.
**
** CS_VERSION_KEY	Set if the column is part of the version key for
**			the row.
**
** CS_NODATA		Not currently used in Open Client/Server.
**
** CS_UPDATABLE		Set if the column is an updatable cursor column.
**
** CS_CANBENULL		Set if the column can contain NULL values.
**
** CS_DESCIN
** CS_DESCOUT		Open Server-specific values for dynamic SQL.
**
** CS_INPUTVALUE	Set if the parameter is an input parameter value
**			for a Client-Library command.
**
** CS_UPDATECOL		Set if the parameter is the name of a column in
**			the update clause of a cursor declare command.
**
** CS_RETURN		Set if the parameter is a return parameter to
**			an RPC command.
**
** CS_TIMESTAMP		Set if the column is a timestamp column.
**
** CS_NODEFAULT		Open Server-specific status values for RPC parameters.
**
** CS_IDENTITY		Set if the column is an identity column.
**
*}
  CS_HIDDEN		= TCS_INT($0001);
  CS_KEY		= TCS_INT($0002);
  CS_VERSION_KEY	= TCS_INT($0004);
  CS_NODATA		= TCS_INT($0008);
  CS_UPDATABLE		= TCS_INT($0010);
  CS_CANBENULL		= TCS_INT($0020);
  CS_DESCIN		= TCS_INT($0040);
  CS_DESCOUT		= TCS_INT($0080);
  CS_INPUTVALUE		= TCS_INT($0100);
  CS_UPDATECOL		= TCS_INT($0200);
  CS_RETURN 		= TCS_INT($0400);
  CS_RETURN_CANBENULL	= TCS_INT($0420);  
  CS_TIMESTAMP		= TCS_INT($2000);
  CS_NODEFAULT		= TCS_INT($4000);
  CS_IDENTITY		= TCS_INT($8000);

{*
** The following are bit values for the status field in the CS_BROWSEDESC
** structure.
**
** CS_EXPRESSION	Set when the column is the result of an expression.
**
** CS_RENAMED		Set when that the column's heading is not the
**			original name of the column.
*}
  CS_EXPRESSION		= TCS_INT($0800);
  CS_RENAMED		= TCS_INT($1000);

{*
** Define special precision/scale value for using the precision/scale of the
** source element when doing a conversion from a numeric/decimal datatype to a
** numeric/decimal datatype.
*}
  CS_SRC_VALUE		= TCS_INT(-2562);

{*
** Minimum/maximum/default precision and scale values for numeric/decimal
** datatypes.
*}
  CS_MIN_PREC		= TCS_INT( 1);
  CS_MAX_PREC		= TCS_INT(77);
  CS_DEF_PREC		= TCS_INT(18);

  CS_MIN_SCALE		= TCS_INT( 0);
  CS_MAX_SCALE		= TCS_INT(77);
  CS_DEF_SCALE		= TCS_INT( 0);

{*
** The datetime format for converting datetime to char.
*}
  CS_DATES_SHORT	= TCS_INT(  0);	// default
  CS_DATES_MDY1		= TCS_INT(  1);	// mm/dd/yy
  CS_DATES_YMD1		= TCS_INT(  2);	// yy.mm.dd
  CS_DATES_DMY1		= TCS_INT(  3);	// dd/mm/yy
  CS_DATES_DMY2		= TCS_INT(  4);	// dd.mm.yy
  CS_DATES_DMY3		= TCS_INT(  5);	// dd-mm-yy
  CS_DATES_DMY4		= TCS_INT(  6);	// dd mon yy
  CS_DATES_MDY2		= TCS_INT(  7);	// mon dd, yy
  CS_DATES_HMS		= TCS_INT(  8);	// hh:mm:ss
  CS_DATES_LONG		= TCS_INT(  9);	// default with micro secs
  CS_DATES_MDY3		= TCS_INT( 10);	// mm-dd-yy
  CS_DATES_YMD2		= TCS_INT( 11);	// yy/mm/dd
  CS_DATES_YMD3		= TCS_INT( 12);	// yymmdd
  CS_DATES_YDM1		= TCS_INT( 13);	// yy/dd/mm
  CS_DATES_MYD1		= TCS_INT( 14);	// mm/yy/dd
  CS_DATES_DYM1		= TCS_INT( 15);	// dd/yy/mm
  CS_DATES_SHORT_ALT	= TCS_INT(100);	// default
  CS_DATES_MDY1_YYYY	= TCS_INT(101);	// mm/dd/yyyy
  CS_DATES_YMD1_YYYY	= TCS_INT(102);	// yyyy.mm.dd
  CS_DATES_DMY1_YYYY	= TCS_INT(103);	// dd/mm/yyyy
  CS_DATES_DMY2_YYYY	= TCS_INT(104);	// dd.mm.yyyy
  CS_DATES_DMY3_YYYY	= TCS_INT(105);	// dd-mm-yyyy
  CS_DATES_DMY4_YYYY	= TCS_INT(106);	// dd mon yyyy
  CS_DATES_MDY2_YYYY	= TCS_INT(107);	// mon dd, yyyy
  CS_DATES_HMS_ALT	= TCS_INT(108);	// hh:mm:ss
  CS_DATES_LONG_ALT	= TCS_INT(109);	// default with micro secs
  CS_DATES_MDY3_YYYY	= TCS_INT(110);	// mm-dd-yyyy
  CS_DATES_YMD2_YYYY	= TCS_INT(111);	// yyyy/mm/dd
  CS_DATES_YMD3_YYYY	= TCS_INT(112);	// yyyymmdd


{*
** sizeof macro which forces a CS_INT cast for portability.
*
  CS_SIZEOF		= (CS_INT)sizeof
}