Class DRDAConnThread

java.lang.Object

java.lang.Thread

org.apache.derby.impl.drda.DRDAConnThread

All Implemented Interfaces:

Runnable

class DRDAConnThread
extends Thread

This class translates DRDA protocol from an application requester to JDBC for Derby and then translates the results from Derby to DRDA for return to the application requester.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	DRDAConnThread.PublicBufferOutputStream

Nested classes/interfaces inherited from class Thread

Thread.Builder, Thread.State, Thread.UncaughtExceptionHandler

Field Summary

Fields

Modifier and Type	Field	Description
private static int[]	ACCRDB_REQUIRED
private AppRequester	appRequester
private static final String	AUTHENTICATION_PROVIDER_BUILTIN_CLASS
private static final String	AUTHENTICATION_PROVIDER_NONE_CLASS
private boolean	close	End this thread.
private static final int	COMMIT
private int	correlationID
private int	currentRequiredLength
private Database	database
private SQLException	databaseAccessException
private static DecryptionManager	decryptionManager
private boolean	deferredReset	Tells if the reset / connect request is a deferred request.
private byte	diagnosticLevel
private static final DRDAProtocolExceptionInfo	dummy
private static final byte[]	eod00000
private static final byte[]	eod02000
private static final byte[]	errD5_D6
private Calendar	gmtCalendar	A cached Calendar instance using the GMT time zone.
private List<Integer>	knownManagers
private static final String	leftBrace
private boolean	logConnections	Whether or not to log connections.
private static HeaderPrintWriter	logStream
private static int	MAX_REQUIRED_LEN
private static final int	MGRLVL_3
private static final int	MGRLVL_4
private static final int	MGRLVL_5
private static final int	MGRLVL_6
private static final int	MGRLVL_7
private byte[]	myPublicKey
private byte[]	myTargetSeed
private static final byte	NULL_VALUE
private static final byte[]	nullSQLState
private int	pendingStatementTimeout
private DRDAString	pkgcnstkn	Current RDB Package Consistency Token.
private DRDAString	pkgid	Current RDB Package Identifier.
private int	pkgsn	Current RDB Package Section Number.
private static byte[]	prdIdBytes
private Pkgnamcsn	prevPkgnamcsn	The value returned by the previous call to parsePKGNAMCSN().
private DRDAString	rdbcolid	Current RDB Collection Identifier.
private DRDAString	rdbnam	Current RDB Package Name.
private DDMReader	reader
private int[]	required
private static final String	rightBrace
private static final int	ROLLBACK
private boolean	sendWarningsOnCNTQRY
private NetworkServerControlImpl	server
private Session	session
private InputStream	sockis
private OutputStream	sockos
private int	sqlamLevel
private static String	SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER	SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER, When full message text is sent for severe errors.
private static String	SQLERRMC_TOKEN_DELIMITER	SQLERRMC_TOKEN_DELIMITER separates message argument tokens
private static final String	SYNTAX_ERR
private static final String	TIMEOUT_STATEMENT
private long	timeSlice	Time slice for this thread.
private List<Integer>	unknownManagers
private static final byte[]	warn0_warnA
private DDMWriter	writer
private DRDAXAProtocol	xaProto

Fields inherited from class Thread

MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors

Constructor	Description
DRDAConnThread(Session session, NetworkServerControlImpl server, long timeSlice, boolean logConnections)	Create a new Thread for processing session requests

Method Summary

Modifier and Type	Method	Description
protected void	agentError(String msg)	Agent error - something very bad happened
private void	badObjectLength(int codePoint)	Object length not allowed
private String	buildDataTruncationSqlerrmc(DataTruncation dt)	Build the SQLERRMC for a java.sql.DataTruncation warning.
private String	buildPreformattedSqlerrmc(SQLException se)	Build preformatted SQLException text for severe exceptions or SQLExceptions that are not Derby exceptions.
protected String	buildRuntimeInfo(String indent, LocalizedResource localLangUtil)
private String	buildSqlerrmc(SQLException se)	Create error message or message argements to return to client.
private String	buildTokenizedSqlerrmc(SQLException se)	Build Tokenized SQLERRMC to just send the tokenized arguments to the client. for a Derby SQLException or an SQLException thrown by user code.
private boolean	canIgnoreStmt(String stmt)
private void	checkLength(int codepoint, int reqlen)	Check that the length is equal to the required length for this codepoint
private void	checkRequired(int codePoint)	Check whether we have seen all the required code points
private void	checkValidTypDefNam(String typdefnam)	check that the given typdefnam is acceptable
private void	checkWarning(Connection conn, Statement stmt, ResultSet rs, long updateCount, boolean alwaysSend, boolean sendWarn)	Check SQLWarning and write SQLCARD as needed.
private void	cleanUpAndCloseResultSet(DRDAStatement stmt, SQLException sqle, int writerMark)	Cleans up and closes a result set if an exception is thrown when collecting QRYDTA in response to OPNQRY or CNTQRY.
protected void	close()	Close DRDA connection thread
private boolean	closed()	Test if DRDA connection thread is closed
private void	closeSession()	Close the current session
private static void	closeStream(InputStream stream)	Close a stream.
protected void	codePointNotSupported(int codePoint)	Don't support this code point
private static InputStream	convertAsByteArrayInputStream(EXTDTAReaderInputStream stream)
private String	convertToHexString(byte[] buf)	convert byte array to a Hex string
private void	copyToRequired(int[] req)	Copy a list of required code points to template for checking
private void	doneData(DRDAStatement stmt, ResultSet rs)	Done data Send SQLCARD for the end of the data
private void	errorInChain(SQLException e)	If there's a severe error in the DDM chain, and if the header indicates "terminate chain on error", we stop processing further commands in the chain nor do we send any reply for them.
private void	exchangeServerAttributes()	Exchange server attributes with application requester
private void	finalizeChain()	Finalize the current DSS chain and send it if needed.
private static Object	findService(String factoryInterface, String serviceName)	Privileged service lookup.
private String	formatDate(Date date)	Convert a java.sql.Date to a string with the format expected by the client.
private String	formatTime(Time time)	Convert a java.sql.Time to a string with the format expected by the client.
private String	formatTimestamp(Timestamp ts)	Convert a java.sql.Timestamp to a string with the format expected by the client.
private int	getByteOrder()
(package private) long	getBytesRead()
(package private) long	getBytesWritten()
private int	getConnFromDatabaseName()	Get connection from a database name Username and password is verified by making a connection to the database
protected int	getCorrelationID()	Get correlation id
protected byte[]	getCrrtkn()	Get correlation token
protected Database	getDatabase()	Get Database we are working on
protected String	getDbName()	Get database name
private int	getExceptionSeverity(SQLException e)	Translate from Derby exception severity to SVRCOD
private Calendar	getGMTCalendar()	Get a Calendar instance with time zone set to GMT.
protected InputStream	getInputStream()	Get input stream
private boolean	getLogConnections()	Get whether connections are logged
private static ModuleFactory	getMonitor()	Privileged Monitor lookup.
private Object	getObjectForWriteFdoca(CallableStatement cs, int index, int drdaType)	Get the value of an output parameter of the specified type from a CallableStatement, in a form suitable for being writted by writeFdocaVal(int, Object, int, int, int, boolean, DRDAStatement, boolean).
private Object	getObjectForWriteFdoca(ResultSet rs, int index, int drdaType)	Get a column value of the specified type from a ResultSet, in a form suitable for being writted by writeFdocaVal(int, Object, int, int, int, boolean, DRDAStatement, boolean).
protected OutputStream	getOutputStream()	Get output stream
private static byte[]	getProductIDBytes()	Get product id as bytes
private int	getRdbAccessErrorCodePoint()
protected DDMReader	getReader()	get DDMReader
protected NetworkServerControlImpl	getServer()	Get server
protected Session	getSession()	Get session we are working on
private int	getSqlCode(SQLException e)	Get the SQLCODE to send for an exception or a warning.
private long	getTimeSlice()	Get time slice value for length of time to work on a session
protected DDMWriter	getWriter()	get DDMWriter
private void	handleException(Exception e)	Handle Exceptions - write error protocol if appropriate and close session or thread as appropriate
(package private) boolean	hasSession()
private void	initialize()	Initialize class
private void	initializeDatabase(String dbname)	Create a new database and intialize the DRDAConnThread database.
private void	initializeForSession()	Initialize for a new session
private void	invalidClient(String prdid)	Invalid non-derby client tried to connect. thrown a required Value not found error and log a message to derby.log
protected void	invalidCodePoint(int codePoint)	Invalid codepoint for this command
private void	invalidValue(int codePoint)	Invalid value for this code point
private boolean	isAuthenticationException(SQLException sqlException)	There are multiple reasons for not getting a connection, and all these should throw SQLExceptions with SQL state 08004 according to the SQL standard.
protected void	markCommunicationsFailure(Exception e, String arg1, String arg2, String arg3, String arg4)	Indicate a communications failure.
protected void	markCommunicationsFailure(String arg1, String arg2, String arg3, String arg4)	Indicate a communications failure
protected void	missingCodePoint(int codePoint)	Missing code point
private void	padInt(char[] buf, int offset, int length, int value)	Insert an integer into a char array and pad it with leading zeros if its string representation is shorter than length characters.
private int	parseACCRDB()	Parse access RDB Instance variables RDBACCCL - RDB Access Manager Class - required must be SQLAM CRRTKN - Correlation Token - required RDBNAM - Relational database name -required PRDID - Product specific identifier - required TYPDEFNAM - Data Type Definition Name -required TYPDEFOVR - Type definition overrides -required RDBALWUPD - RDB Allow Updates optional PRDDTA - Product Specific Data - optional - ignorable STTDECDEL - Statement Decimal Delimiter - optional STTSTRDEL - Statement String Delimiter - optional TRGDFTRT - Target Default Value Return - optional
private int	parseACCSEC()	Parse Access Security If the target server supports the SECMEC requested by the application requester then a single value is returned and it is identical to the SECMEC value in the ACCSEC command.
private String	parseCcsidMBC(int length)	Parse mixed character string
private String	parseCcsidSBC(int length)	Parse single byte character string
private DRDAStatement	parseCLSQRY()	Parse CLSQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYINSID - Query Instance Identifier - required - level 7 MONITOR - Monitor events - optional.
private DRDAStatement	parseCNTQRY()	Parse CNTQRY - Continue Query Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required QRYBLKSZ - Query Block Size - required QRYRELSCR - Query Relative Scrolling Action - optional QRYSCRORN - Query Scroll Orientation - optional - level 7 QRYROWNBR - Query Row Number - optional QRYROWSNS - Query Row Sensitivity - optional - level 7 QRYBLKRST - Query Block Reset - optional - level 7 QRYRTNDTA - Query Returns Data - optional - level 7 QRYROWSET - Query Rowset Size - optional - level 7 QRYRFRTBL - Query Refresh Answer Set Table - optional NBRROW - Number of Fetch or Insert Rows - optional MAXBLKEXT - Maximum number of extra blocks - optional RTNEXTDTA - Return of EXTDTA Option - optional MONITOR - Monitor events - optional.
private void	parseCNTQRYobjects(DRDAStatement stmt)	Parse CNTQRY objects Instance Variables OUTOVR - Output Override Descriptor - optional
private Date	parseDate(String dateString, Calendar cal)	Parse a date string as it is received from the client.
private boolean	parseDRDAConnection()
private boolean	parseDSCSQLSTT()	Parse DSCSQLSTT - Describe SQL Statement previously prepared Instance Variables TYPSQLDA - sqlda type expected (output or input) RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required MONITOR - Monitor events - optional.
private String	parseEncodedString()	Parse an encoded data string from the Application Requester
private void	parseEXCSAT()	Parses EXCSAT (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
private void	parseEXCSAT2()	Parses EXCSAT2 (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
private long	parseEXCSQLIMM()	Parse EXCSQLIMM - Execute Immediate Statement Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required RDBCMTOK - RDB Commit Allowed - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLSTT - SQL Statement -required
private boolean	parseEXCSQLSET()	Parse EXCSQLSET - Execute Set SQL Environment Instance Variables RDBNAM - relational database name - optional PKGNAMCT - RDB Package Name, Consistency Token - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - required TYPDEFOVR - TYPDEF Overrides - required SQLSTT - SQL Statement - required (at least one; may be more)
private void	parseEXCSQLSETobjects()	Parse EXCSQLSET objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement - required (a list of at least one) Objects may follow in one DSS or in several DSS chained together.
private void	parseEXCSQLSTT()	Parse EXCSQLSTT - Execute non-cursor SQL Statement previously prepared Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required OUTEXP - Output expected NBRROW - Number of rows to be inserted if it's an insert PRCNAM - procedure name if specified by host variable, not needed for Derby QRYBLKSZ - query block size MAXRSLCNT - max resultset count MAXBLKEXT - Max number of extra blocks RSLSETFLG - resultset flag RDBCMTOK - RDB Commit Allowed - optional OUTOVROPT - output override option QRYROWSET - Query Rowset Size - Level 7 MONITOR - Monitor events - optional.
private boolean	parseEXCSQLSTTobjects(DRDAStatement stmt)	Parse EXCSQLSTT command objects Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLDTA - optional, variable data, specified if prpared statement has input parameters EXTDTA - optional, externalized FD:OCA data OUTOVR - output override descriptor, not allowed for stored procedure calls If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
private String	parseEXECSQLIMMobjects()	Parse EXCSQLIMM objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides SQLSTT - SQL Statement required If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
private void	parseMGRLVLLS(int time)	Parse manager levels Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager VALUE On the second appearance of this codepoint, it can only add managers
private void	parseMONITOR()	Parse MONITOR DRDA spec says this is optional.
private String	parseNOCMorNOCS()	Parse nullable character mixed byte or nullable character single byte Format 1 byte - null indicator I4 - mixed character length N bytes - mixed character string 1 byte - null indicator I4 - single character length N bytes - single character length string
private Pkgnamcsn	parseOPNQRY()	Parse OPNQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYBLKSZ - Query Block Size - required QRYBLKCTL - Query Block Protocol Control - optional MAXBLKEXT - Maximum Number of Extra Blocks - optional - default value 0 OUTOVROPT - Output Override Option QRYROWSET - Query Rowset Size - optional - level 7 MONITOR - Monitor events - optional.
private void	parseOPNQRYobjects(DRDAStatement stmt)	Parse OPNQRY objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLDTA- SQL Program Variable Data - optional If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
private void	parseOUTOVR(DRDAStatement stmt)	Parse OUTOVR - Output Override Descriptor This specifies the output format for data to be returned as output to a SQL statement or as output from a query.
private int	parseOUTOVROPT()	Parse OUTOVROPT - this indicates whether output description can be overridden on just the first CNTQRY or on any CNTQRY
private Pkgnamcsn	parsePKGNAMCSN()	Parse PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number
private String	parsePKGNAMCT()
private int	parsePRPSQLSTT()	Parse PRPSQLSTT - Prepare SQL Statement Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required RTNSQLDA - Return SQL Descriptor Area - optional MONITOR - Monitor events - optional.
private String	parsePRPSQLSTTobjects(DRDAStatement stmt)	Parse PRPSQLSTT objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement required SQLATTR - Cursor attributes on prepare - optional - level 7 If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
private int	parseQRYBLKSZ()	Parse QRYBLSZ - this gives the maximum size of the query blocks that can be returned to the requester
private int	parseQRYCLSIMP()	Parse a QRYCLSIMP - Implicitly close non-scrollable cursor after end of data.
private int	parseQRYCLSRLS()
private int	parseQRYROWSET(int minVal)	Parse QRYROWSET - this is the number of rows to return
private void	parseRDBCMTOK()	Parse RDBCMTOK - tells the database whether to allow commits or rollbacks to be executed as part of the command Since we don't have a SQL commit or rollback command, we will just ignore this for now
private String	parseRDBNAM()	Parse database name
private int	parseSECCHK()	Parse security check Instance Variables SECMGRNM - security manager name - optional, ignorable SECMEC - security mechanism - required SECTKN - security token - optional, (required if encryption used) PASSWORD - password - optional, (required if security mechanism uses it) NEWPASSWORD - new password - optional, (required if sec mech. uses it) USRID - user id - optional, (required if sec mec. uses it) RDBNAM - database name - optional (required if databases can have own sec.)
protected void	parseSQLATTR(DRDAStatement stmt)	Parse SQLATTR - Cursor attributes on prepare This is an encoded string.
private void	parseSQLDTA(DRDAStatement stmt)	Parse SQLDTA - SQL program variable data and handle exception.
private void	parseSQLDTA_work(DRDAStatement stmt)	Parse SQLDTA - SQL program variable data Instance Variables FDODSC - FD:OCA data descriptor - required FDODTA - FD:OCA data - optional
private String	parseSQLSTTDss()	Parse SQLSTT Dss
private Time	parseTime(String timeString, Calendar cal)	Parse a time string as it is received from the client.
private Timestamp	parseTimestamp(String timeString, Calendar cal)	Parse a timestamp string as it is received from the client.
private String	parseTYPDEFNAM()	Parse TYPDEFNAM
private void	parseTYPDEFOVR(DRDAStatement st)	Parse Type Defintion Overrides TYPDEF Overrides specifies the Coded Character SET Identifiers (CCSIDs) that are in a named TYPDEF.
private boolean	parseTYPSQLDA()	Parse TYPSQLDA - Type of the SQL Descriptor Area
private String	parseVCMorVCS()	Parse variable character mixed byte or variable character single byte Format I2 - VCM Length N bytes - VCM value I2 - VCS Length N bytes - VCS value Only 1 of VCM length or VCS length can be non-zero
private boolean	positionCursor(DRDAStatement stmt, ResultSet rs)	Position cursor for insensitive scrollable cursors
protected static void	println2Log(String dbname, String drdaID, String msg)	Print a line to the DB2j log
private void	processCommands()	Process DRDA commands we can receive once server attributes have been exchanged.
private boolean	processLeftoverQRYDTA(DRDAStatement stmt)	Process remainder data resulting from a split.
private void	rdbnamMismatch(int codePoint)	Database name given under code point doesn't match previous database names
private void	rdbNotFound(String rdbnam)	RDB not found
private void	readAndSetAllExtParams(DRDAStatement stmt, boolean streamLOB)
private void	readAndSetExtParam(int i, DRDAStatement stmt, int drdaType, int extLen, boolean streamLOB)	Read different types of input parameters and set them in PreparedStatement
private void	readAndSetParams(int i, DRDAStatement stmt, ParameterMetaData pmeta)	Read different types of input parameters and set them in PreparedStatement
private boolean	readBoolean(int codepoint)	Read and check a boolean value
private long	readLobLength(int extLenIndicator)
private Object	readUDT()	Read a UDT from the stream
private void	removeFromRequired(int codePoint)	Remove codepoint from required list
private void	requiredValueNotFound(int codePoint)	Required value not found.
void	run()	Main routine for thread, loops until the thread is closed Gets a session, does work for the session
private void	sendProtocolException(DRDAProtocolException de)	Notice the client about a protocol error.
private void	sendUnexpectedException(Exception e)	Send unpexpected error to the client
private void	sessionInitialState()	In initial state for a session, determine whether this is a command session or a DRDA protocol session.
private static void	setAsBinaryStream(DRDAStatement stmt, int index, EXTDTAReaderInputStream stream, boolean streamLOB)	Sets the specified binary EXTDTA parameter of the embedded statement.
private static void	setAsCharacterStream(DRDAStatement stmt, int i, EXTDTAReaderInputStream extdtaStream, boolean streamLOB, String encoding)	Sets the specified character EXTDTA parameter of the embedded statement.
private void	setDatabase(int codePoint)	Set the current database
protected void	setLogConnections(boolean value)	Set logging of connections
private void	setStmtOrDbByteOrder(boolean setDatabase, DRDAStatement stmt, String typDefNam)	Set a statement or the database' byte order, depending on the arguments
protected void	setTimeSlice(long value)	Set time slice value
static void	showmem()	Show runtime memory
private void	skipRemainder(boolean onlySkipSameIds)	Skip remainder of current DSS and all chained DSS'es
private void	splitQRYDTA(DRDAStatement stmt, int blksize)	Split QRYDTA into blksize chunks This routine is called if the QRYDTA data will not fit.
private int	svrcodFromSecchkcd(int securityCheckCode)	Calculate SVRCOD value from SECCHKCD
private void	switchToEbcdic()	Switch the DDMWriter and DDMReader to EBCDIC
private void	switchToUtf8()	Switch the DDMWriter and DDMReader to UTF8 IF supported
protected void	throwSyntaxrm(int errcd, int cpArg)	Syntax error
private void	tooBig(int codePoint)	Object too big
private void	tooMany(int codePoint)	Seen too many of this code point
protected void	trace(String value)	Send string to console
private void	traceEXTDTARead(int drdaType, int index, EXTDTAReaderInputStream stream, boolean streamLOB, String encoding)	Sends a trace string to the console when reading an EXTDTA value (if tracing is enabled).
private int	validateSecMecUSRSSBPWD()	Validate SECMEC_USRSSBPWD (Strong Password Substitute) can be used as DRDA security mechanism.
private void	valueNotSupported(int codePoint)	Don't support this value
private void	verifyInOrderACCSEC_SECCHK(int codePoint, int reqCodePoint)	Verify that the code point is in the right order
private void	verifyRequiredObject(int codePoint, int reqCodePoint)	Verify that the code point is the required code point
private int	verifyUserIdPassword()	Verify userId and password Username and password is verified by making a connection to the database
private void	writeABNUOWRM()	Write ABNUOWRM - query process has terminated in an error condition such as deadlock or lock timeout.
private void	writeACCRDBRM(int svrcod)	Write Access to RDB Completed Instance Variables SVRCOD - severity code - 0 info, 4 warning -required PRDID - product specific identifier -required TYPDEFNAM - type definition name -required TYPDEFOVR - type definition overrides - required RDBINTTKN - token which can be used to interrupt DDM commands - optional CRRTKN - correlation token - only returned if we didn't get one from requester SRVDGN - server diagnostic information - optional PKGDFTCST - package default character subtype - optional USRID - User ID at the target system - optional SRVLST - Server List
private void	writeACCSECRD(int securityCheckCode)	Write ACCSECRD If the security mechanism is known, we just send it back along with the security token if encryption is going to be used.
private void	writeCMDCHKRM(int severity)	Write CMDCHKRM Instance Variables SVRCOD - Severity Code - required
private void	writeENDQRYRM(int svrCod)	Write ENDQRYRM - query process has terminated in such a manner that the query or result set is now closed.
private void	writeENDUOWRM(int opType)	Write ENDUOWRM Instance Variables SVCOD - severity code - WARNING - required UOWDSP - Unit of Work Disposition - required RDBNAM - Relational Database name - optional SRVDGN - Server Diagnostics information - optional
private void	writeEXCSATRD()	Write reply to EXCSAT command Instance Variables EXTNAM - External Name (optional) MGRLVLLS - Manager Level List (optional) SRVCLSNM - Server Class Name (optional) - used by JCC SRVNAM - Server Name (optional) SRVRLSLV - Server Product Release Level (optional)
(package private) void	writeEXTDTA(DRDAStatement stmt)
protected void	writeFdocaVal(int index, Object val, int drdaType, int precision, int scale, boolean valNull, DRDAStatement stmt, boolean isParam)	Write Fdoca Value to client
private boolean	writeFDODTA(DRDAStatement stmt)	This routine places some data into the current QRYDTA block using FDODTA (Formatted Data Object DaTA rules).
private void	writeMGRLEVELS()	Write manager levels The target server must not provide information for any target managers unless the source explicitly requests it.
private void	writeNullability(int drdaType, boolean valNull)	write nullability if this is a nullable drdatype and FDOCA null value if appropriate
private void	writeNullSQLCARDobject()	Write a null SQLCARD as an object
private void	writeOPNQFLRM(SQLException e)	Write a OPNQFLRM - Open Query Failure Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required
private void	writeOPNQRYRM(boolean isDssObject, DRDAStatement stmt)	Write OPNQRYRM - Open Query Complete Instance Variables SVRCOD - Severity Code - required QRYPRCTYP - Query Protocol Type - required SQLCSRHLD - Hold Cursor Position - optional QRYATTSCR - Query Attribute for Scrollability - optional - level 7 QRYATTSNS - Query Attribute for Sensitivity - optional - level 7 QRYATTUPD - Query Attribute for Updatability -optional - level 7 QRYINSID - Query Instance Identifier - required - level 7 SRVDGN - Server Diagnostic Information - optional
private void	writePBSD()	Piggy-back any modified session attributes on the current message.
private void	writePKGNAMCSN()
private void	writePKGNAMCSN(byte[] pkgcnstkn)	Write PKGNAMCSN Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number There are two possible formats, fixed and extended which includes length information for the strings
private void	writeQRYDSC(DRDAStatement stmt, boolean FDODSConly)	Write QRYDSC - Query Answer Set Description
private void	writeQRYDTA(DRDAStatement stmt)	Write QRYDTA - Query Answer Set Data Contains some or all of the answer set data resulting from a query If the client is not using rowset processing, this routine attempts to pack as much data into the QRYDTA as it can.
private void	writeQRYNOPRM(int svrCod)	Write a QRYNOPRM - Query Not Opened Instance Variables SVRCOD - Severity Code - required - 4 Warning 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
private void	writeQRYPOPRM()	Write a QRYPOPRM - Query Previously opened Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
private void	writeRDBfailure(int codePoint)	Write RDB Failure Instance Variables SVRCOD - Severity Code - required RDBNAM - Relational Database name - required SRVDGN - Server Diagnostics - optional (not sent for now)
protected void	writeRDBNAM(String rdbnam)	Write RDBNAM
private void	writeRDBUPDRM()	Write RDBUPDRM Instance variables SVRCOD - Severity code - Information only - required RDBNAM - Relational database name -required SRVDGN - Server Diagnostic Information -optional
private void	writeRSLSETRM(DRDAStatement stmt)	Write RSLSETRM Instance variables SVRCOD - Severity code - Information only - required PKGSNLST - list of PKGNAMCSN -required SRVDGN - Server Diagnostic Information -optional
private void	writeSECCHKRM(int securityCheckCode)	Write security check reply Instance variables SVRCOD - serverity code - required SECCHKCD - security check code - required SECTKN - security token - optional, ignorable SVCERRNO - security service error number SRVDGN - Server Diagnostic Information
private void	writeSQLCAERRWARN(long updateCount, long rowCount)	Write the ERR and WARN part of the SQLCA
private void	writeSQLCAGRP(byte[] sqlState, int sqlcode, long updateCount, long rowCount)	Same as writeSQLCAGRP, but optimized for the case when there is no real exception, i.e. the exception is null, or "End of data" SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
private void	writeSQLCAGRP(SQLException e, long updateCount, long rowCount)	Write SQLCAGRP SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
private void	writeSQLCARD(SQLException e, long updateCount, long rowCount)
private void	writeSQLCARDs(SQLException e, long updateCount)
private void	writeSQLCARDs(SQLException e, long updateCount, boolean sendSQLERRRM)
private void	writeSQLCAXGRP(long updateCount, long rowCount, String sqlerrmc, SQLException nextException)	Write SQLCAXGRP SQLCAXGRP : EARLY FDOCA GROUP SQL Communications Area Exceptions Group Description FORMAT FOR SQLAM <= 6 SQLRDBNME; DRDA TYPE FCS; ENVLID 0x30; Length Override 18 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70 FORMAT FOR SQLAM >= 7 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLRDBNAME; DRDA TYPE VCS; ENVLID 0x32; Length Override 1024 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70
private void	writeSQLCINRD(DRDAStatement stmt)	Write SQLCINRD - result set column information
private void	writeSQLDAGRP(ResultSetMetaData rsmeta, ParameterMetaData pmeta, int elemNum, boolean rtnOutput)	Write SQLDAGRP SQLDAGRP : EARLY FDOCA GROUP SQL Data Area Group Description FORMAT FOR SQLAM <= 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 FORMAT FOR SQLAM == 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 SQLUDTGRP; DRDA TYPE N-GDA; ENVLID 0x51; Length Override 0 FORMAT FOR SQLAM >= 7 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLDOPTGRP; DRDA TYPE N-GDA; ENVLID 0xD2; Length Override 0
private void	writeSQLDARD(DRDAStatement stmt, boolean rtnOutput, SQLException e)	Write SQLDARD SQLDARD : FDOCA EARLY ARRAY SQL Descriptor Area Row Description with SQL Communications Area FORMAT FOR SQLAM <= 6 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDAROW; ROW LID 0x60; ELEMENT TAKEN 0(all); REP FACTOR 0(all) FORMAT FOR SQLAM >= 7 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDHROW; ROW LID 0xE0; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
private void	writeSQLDCGRP(long rowNum, int sqlCode, String sqlState, String dbname, String sqlerrmc)	writeSQLDCGRP: SQL Diagnostics Condition Group Description SQLDCCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCSTATE; DRDA TYPE FCS; ENVLID Ox30; Lengeh Override 5 SQLDCREASON; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCLINEN; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCROWN; DRDA TYPE FD; ENVLID 0x0E; Lengeh Override 31 SQLDCER01; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER02; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER03; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER04; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPART; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPPOP; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCMSGID; DRDA TYPE FCS; ENVLID 0x30; Length Override 10 SQLDCMDE; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLDCPMOD; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLDCRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 SQLDCTOKS; DRDA TYPE N-RLO; ENVLID 0xF7; Length Override 0 SQLDCMSG_m; DRDA TYPE NVMC; ENVLID 0x3F; Length Override 32672 SQLDCMSG_S; DRDA TYPE NVCS; ENVLID 0x33; Length Override 32672 SQLDCCOLN_m; DRDA TYPE NVCM ; ENVLID 0x3F; Length Override 255 SQLDCCOLN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCCURN_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCCURN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCPNAM_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCPNAM_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCXGRP; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 1
private void	writeSQLDCROW(long rowNum, int sqlCode, String sqlState, String dbname, String sqlerrmc)	writeSQLDCROW: SQL Diagnostics Condition Row - Identity 0xE5 SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1
private void	writeSQLDHROW(int holdability)	Holdability passed in as it can represent the holdability of the statement or a specific result set.
private void	writeSQLDIAGCI(SQLException nextException)	writeSQLDIAGCI: SQL Diagnostics Condition Information Array - Identity 0xF5 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
private void	writeSQLDIAGCN()
private void	writeSQLDIAGGRP(SQLException nextException)	Write SQLDIAGGRP: SQL Diagnostics Group Description - Identity 0xD1 Nullable Group SQLDIAGSTT; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 0 SQLDIAGCN; DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0 SQLDIAGCI; DRDA TYPE N-RLO; ENVLID 0xF5; Length Override 0
private void	writeSQLDIAGSTT()
private void	writeSQLDOPTGRP(ResultSetMetaData rsmeta, ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)
private void	writeSQLDTAGRP(DRDAStatement stmt, ResultSetMetaData rsmeta, ParameterMetaData pmeta, int colStart, int colEnd, boolean first)	Write SQLDTAGRP SQLDAGRP : Late FDOCA GROUP SQL Data Value Group Descriptor LENGTH - length of the SQLDTAGRP TRIPLET_TYPE - NGDA for first, CPT for following ID - SQLDTAGRP_LID for first, NULL_LID for following For each column DRDA TYPE LENGTH OVERRIDE For numeric/decimal types PRECISON SCALE otherwise LENGTH or DISPLAY_WIDTH
private void	writeSQLDXGRP(ResultSetMetaData rsmeta, ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)
private void	writeSQLERRRM(int severity)	Write SQLERRRM Instance Variables SVRCOD - Severity Code - required
private void	writeSQLNUMGRP(SQLException nextException)	writeSQLNUMGRP: Writes SQLNUMGRP : FDOCA EARLY GROUP SQL Number of Elements Group Description FORMAT FOR ALL SQLAM LEVELS SQLNUM; DRDA TYPE I2; ENVLID 0x04; Length Override 2
private void	writeSQLNUMROW(SQLException nextException)	writeSQLNUMROW: Writes SQLNUMROW : FDOCA EARLY ROW SQL Number of Elements Row Description FORMAT FOR SQLAM LEVELS SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1
private void	writeSQLRSLRD(DRDAStatement stmt)	Write SQLRSLRD - result set reply data
private void	writeSQLUDTGRP(ResultSetMetaData rsmeta, ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)	Write SQLUDTGRP (SQL Descriptor User-Defined Type Group Descriptor) This is the format from the DRDA spec, Volume 1, section 5.6.4.10.
private void	writeTYPDEFOVR()
private void	writeVCMorVCS(String s)	Write variable character mixed byte or single byte The preference is to write mixed byte if it is defined for the server, since that is our default and we don't allow it to be changed, we always write mixed byte.

Methods inherited from class Thread

activeCount, checkAccess, clone, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, isVirtual, join, join, join, join, ofPlatform, ofVirtual, onSpinWait, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, sleep, start, startVirtualThread, stop, threadId, toString, yield

Methods inherited from class Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

leftBrace

private static final String leftBrace

See Also:

• Constant Field Values

rightBrace

private static final String rightBrace

See Also:

• Constant Field Values

NULL_VALUE

private static final byte NULL_VALUE

See Also:

• Constant Field Values

SYNTAX_ERR

private static final String SYNTAX_ERR

See Also:

• Constant Field Values

MGRLVL_3

private static final int MGRLVL_3

See Also:

• Constant Field Values

MGRLVL_4

private static final int MGRLVL_4

See Also:

• Constant Field Values

MGRLVL_5

private static final int MGRLVL_5

See Also:

• Constant Field Values

MGRLVL_6

private static final int MGRLVL_6

See Also:

• Constant Field Values

MGRLVL_7

private static final int MGRLVL_7

See Also:

• Constant Field Values

COMMIT

private static final int COMMIT

See Also:

• Constant Field Values

ROLLBACK

private static final int ROLLBACK

See Also:

• Constant Field Values

correlationID

private int correlationID

sockis

private InputStream sockis

sockos

private OutputStream sockos

reader

private DDMReader reader

writer

private DDMWriter writer

xaProto

private DRDAXAProtocol xaProto

ACCRDB_REQUIRED

private static int[] ACCRDB_REQUIRED

MAX_REQUIRED_LEN

private static int MAX_REQUIRED_LEN

currentRequiredLength

private int currentRequiredLength

required

private int[] required

server

private NetworkServerControlImpl server

session

private Session session

timeSlice

private volatile long timeSlice

Time slice for this thread.

logConnections

private volatile boolean logConnections

Whether or not to log connections.

sendWarningsOnCNTQRY

private boolean sendWarningsOnCNTQRY

close

private volatile boolean close

End this thread.

logStream

private static HeaderPrintWriter logStream

appRequester

private AppRequester appRequester

database

private Database database

sqlamLevel

private int sqlamLevel

diagnosticLevel

private byte diagnosticLevel

unknownManagers

private List<Integer> unknownManagers

knownManagers

private List<Integer> knownManagers

databaseAccessException

private SQLException databaseAccessException

prevPkgnamcsn

private Pkgnamcsn prevPkgnamcsn

The value returned by the previous call to parsePKGNAMCSN().

rdbnam

private DRDAString rdbnam

Current RDB Package Name.

rdbcolid

private DRDAString rdbcolid

Current RDB Collection Identifier.

pkgid

private DRDAString pkgid

Current RDB Package Identifier.

pkgcnstkn

private DRDAString pkgcnstkn

Current RDB Package Consistency Token.

pkgsn

private int pkgsn

Current RDB Package Section Number.

TIMEOUT_STATEMENT

private static final String TIMEOUT_STATEMENT

See Also:

• Constant Field Values

pendingStatementTimeout

private int pendingStatementTimeout

decryptionManager

private static DecryptionManager decryptionManager

myPublicKey

private byte[] myPublicKey

myTargetSeed

private byte[] myTargetSeed

prdIdBytes

private static byte[] prdIdBytes

eod00000

private static final byte[] eod00000

eod02000

private static final byte[] eod02000

nullSQLState

private static final byte[] nullSQLState

errD5_D6

private static final byte[] errD5_D6

warn0_warnA

private static final byte[] warn0_warnA

AUTHENTICATION_PROVIDER_BUILTIN_CLASS

private static final String AUTHENTICATION_PROVIDER_BUILTIN_CLASS

See Also:

• Constant Field Values

AUTHENTICATION_PROVIDER_NONE_CLASS

private static final String AUTHENTICATION_PROVIDER_NONE_CLASS

See Also:

• Constant Field Values

dummy

private static final DRDAProtocolExceptionInfo dummy

deferredReset

private boolean deferredReset

Tells if the reset / connect request is a deferred request. This information is used to work around a bug (DERBY-3596) in a compatible manner, which also avoids any changes in the client driver.

The bug manifests itself when a connection pool data source is used and logical connections are obtained from the physical connection associated with the data source. Each new logical connection causes a new physical connection on the server, including a new transaction. These connections and transactions are not closed / cleaned up.

gmtCalendar

private Calendar gmtCalendar

A cached Calendar instance using the GMT time zone.

SQLERRMC_TOKEN_DELIMITER

private static String SQLERRMC_TOKEN_DELIMITER

SQLERRMC_TOKEN_DELIMITER separates message argument tokens

SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER

private static String SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER

SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER, When full message text is sent for severe errors. This value separates the messages.

Constructor Details

DRDAConnThread

DRDAConnThread(Session session,
 NetworkServerControlImpl server,
 long timeSlice,
 boolean logConnections)

Create a new Thread for processing session requests

Parameters:

session - Session requesting processing

server - Server starting thread

timeSlice - timeSlice for thread

logConnections -

Method Details

run

public void run()

Main routine for thread, loops until the thread is closed Gets a session, does work for the session

Specified by:

run in interface Runnable

Overrides:

run in class Thread

getInputStream

protected InputStream getInputStream()

Get input stream

Returns:

input stream

getOutputStream

protected OutputStream getOutputStream()

Get output stream

Returns:

output stream

getProductIDBytes

private static byte[] getProductIDBytes()

Get product id as bytes

getReader

protected DDMReader getReader()

get DDMReader

Returns:

DDMReader for this thread

getWriter

protected DDMWriter getWriter()

get DDMWriter

Returns:

DDMWriter for this thread

getCorrelationID

protected int getCorrelationID()

Get correlation id

Returns:

correlation id

getSession

protected Session getSession()

Get session we are working on

Returns:

session

getDatabase

protected Database getDatabase()

Get Database we are working on

Returns:

database

getServer

protected NetworkServerControlImpl getServer()

Get server

Returns:

server

getCrrtkn

protected byte[] getCrrtkn()

Get correlation token

Returns:

crrtkn

getDbName

protected String getDbName()

Get database name

Returns:

database name

close

protected void close()

Close DRDA connection thread

setLogConnections

protected void setLogConnections(boolean value)

Set logging of connections

Parameters:

value - value to set for logging connections

setTimeSlice

protected void setTimeSlice(long value)

Set time slice value

Parameters:

value - new value for time slice

markCommunicationsFailure

protected void markCommunicationsFailure(String arg1,
 String arg2,
 String arg3,
 String arg4)
                                  throws DRDAProtocolException

Indicate a communications failure

Parameters:

arg1 - - info about the communications failure

arg2 - - info about the communications failure

arg3 - - info about the communications failure

arg4 - - info about the communications failure

Throws:

DRDAProtocolException - disconnect exception always thrown

markCommunicationsFailure

protected void markCommunicationsFailure(Exception e,
 String arg1,
 String arg2,
 String arg3,
 String arg4)
                                  throws DRDAProtocolException

Indicate a communications failure. Log to derby.log

Parameters:

e - - Source exception that was thrown

arg1 - - info about the communications failure

arg2 - - info about the communications failure

arg3 - - info about the communications failure

arg4 - - info about the communications failure

Throws:

DRDAProtocolException - disconnect exception always thrown

throwSyntaxrm

protected void throwSyntaxrm(int errcd,
 int cpArg)
                      throws DRDAProtocolException

Syntax error

Parameters:

errcd - Error code

cpArg - code point value

Throws:

DRDAProtocolException

agentError

protected void agentError(String msg)
                   throws DRDAProtocolException

Agent error - something very bad happened

Parameters:

msg - Message describing error

Throws:

DRDAProtocolException - newAgentError always thrown

missingCodePoint

protected void missingCodePoint(int codePoint)
                         throws DRDAProtocolException

Missing code point

Parameters:

codePoint - code point value

Throws:

DRDAProtocolException

println2Log

protected static void println2Log(String dbname,
 String drdaID,
 String msg)

Print a line to the DB2j log

Parameters:

dbname - database name

drdaID - DRDA identifier

msg - message

writeRDBNAM

protected void writeRDBNAM(String rdbnam)
                    throws DRDAProtocolException

Write RDBNAM

Parameters:

rdbnam - database name

Throws:

DRDAProtocolException

initialize

private void initialize()

Initialize class

initializeForSession

private void initializeForSession()

Initialize for a new session

sessionInitialState

private void sessionInitialState()
                          throws Exception

In initial state for a session, determine whether this is a command session or a DRDA protocol session. A command session is for changing the configuration of the Net server, e.g., turning tracing on If it is a command session, process the command and close the session. If it is a DRDA session, exchange server attributes and change session state.

Throws:

Exception

cleanUpAndCloseResultSet

private void cleanUpAndCloseResultSet(DRDAStatement stmt,
 SQLException sqle,
 int writerMark)
                               throws DRDAProtocolException

Cleans up and closes a result set if an exception is thrown when collecting QRYDTA in response to OPNQRY or CNTQRY.

Parameters:

stmt - the DRDA statement to clean up

sqle - the exception that was thrown

writerMark - start index for the first DSS to clear from the output buffer

Throws:

DRDAProtocolException - if a DRDA protocol error is detected

processCommands

private void processCommands()
                      throws DRDAProtocolException

Process DRDA commands we can receive once server attributes have been exchanged.

Throws:

DRDAProtocolException

errorInChain

private void errorInChain(SQLException e)
                   throws DRDAProtocolException

If there's a severe error in the DDM chain, and if the header indicates "terminate chain on error", we stop processing further commands in the chain nor do we send any reply for them. In accordance to this, a SQLERRRM message indicating the severe error must have been sent! (otherwise application requestor, such as JCC, would not terminate the receiving of chain replies.) Each DRDA command is processed independently. DRDA defines no interdependencies across chained commands. A command is processed the same when received within a set of chained commands or received separately. The chaining was originally defined as a way to save network costs.

Parameters:

e - the SQLException raised

Throws:

DRDAProtocolException

exchangeServerAttributes

private void exchangeServerAttributes()
                               throws DRDAProtocolException

Exchange server attributes with application requester

Throws:

DRDAProtocolException

parseDRDAConnection

private boolean parseDRDAConnection()
                             throws DRDAProtocolException

Throws:

DRDAProtocolException

switchToUtf8

private void switchToUtf8()

Switch the DDMWriter and DDMReader to UTF8 IF supported

switchToEbcdic

private void switchToEbcdic()

Switch the DDMWriter and DDMReader to EBCDIC

writeRDBfailure

private void writeRDBfailure(int codePoint)
                      throws DRDAProtocolException

Write RDB Failure Instance Variables SVRCOD - Severity Code - required RDBNAM - Relational Database name - required SRVDGN - Server Diagnostics - optional (not sent for now)

Parameters:

codePoint - codepoint of failure

Throws:

DRDAProtocolException

getRdbAccessErrorCodePoint

private int getRdbAccessErrorCodePoint()

isAuthenticationException

private boolean isAuthenticationException(SQLException sqlException)

There are multiple reasons for not getting a connection, and all these should throw SQLExceptions with SQL state 08004 according to the SQL standard. Since only one of these SQL states indicate that an authentication error has occurred, it is not enough to check that the SQL state is 08004 and conclude that authentication caused the exception to be thrown. This method tries to get a StandardException from the SQLException and use getMessageId on that object to check for authentication error instead of the SQL state we get from SQLExceptions#getSQLState. getMessageId returns the entire id as defined in SQLState (e.g. 08004.C.1), while getSQLState only return the 5 first characters (i.e. 08004 instead of 08004.C.1) If the SQLException isn't linked to a StandardException, the assumption that SQL State 08004 is caused by an authentication failure is followed even though this is not correct. This was the pre DERBY-3060 way of solving the issue.

Parameters:

sqlException - The exception that is checked to see if this is really caused by an authentication failure

Returns:

true if sqlException is (or has to be assumed to be) caused by an authentication failure, false otherwise.

See Also:

• SQLState

verifyUserIdPassword

private int verifyUserIdPassword()
                          throws DRDAProtocolException

Verify userId and password Username and password is verified by making a connection to the database

Returns:

security check code, 0 is O.K.

Throws:

DRDAProtocolException

getConnFromDatabaseName

private int getConnFromDatabaseName()
                             throws DRDAProtocolException

Get connection from a database name Username and password is verified by making a connection to the database

Returns:

security check code, 0 is O.K.

Throws:

DRDAProtocolException

parseEXCSAT

private void parseEXCSAT()
                  throws DRDAProtocolException

Parses EXCSAT (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable

Throws:

DRDAProtocolException

parseEXCSAT2

private void parseEXCSAT2()
                   throws DRDAProtocolException

Parses EXCSAT2 (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable

Throws:

DRDAProtocolException - This parses a second occurrence of an EXCSAT command The target must ignore the values for extnam, srvclsnm, srvnam and srvrlslv. I am also going to ignore spvnam since it should be null anyway. Only new managers can be added.

parseMGRLVLLS

private void parseMGRLVLLS(int time)
                    throws DRDAProtocolException

Parse manager levels Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager VALUE On the second appearance of this codepoint, it can only add managers

Parameters:

time - 1 for first time this is seen, 2 for subsequent ones

Throws:

DRDAProtocolException

writeEXCSATRD

private void writeEXCSATRD()
                    throws DRDAProtocolException

Write reply to EXCSAT command Instance Variables EXTNAM - External Name (optional) MGRLVLLS - Manager Level List (optional) SRVCLSNM - Server Class Name (optional) - used by JCC SRVNAM - Server Name (optional) SRVRLSLV - Server Product Release Level (optional)

Throws:

DRDAProtocolException

writeMGRLEVELS

private void writeMGRLEVELS()
                     throws DRDAProtocolException

Write manager levels The target server must not provide information for any target managers unless the source explicitly requests it. For each manager class, if the target server's support level is greater than or equal to the source server's level, then the source server's level is returned for that class if the target server can operate at the source's level; otherwise a level 0 is returned. If the target server's support level is less than the source server's level, the target server's level is returned for that class. If the target server does not recognize the code point of a manager class or does not support that class, it returns a level of 0. The target server then waits for the next command or for the source server to terminate communications. When the source server receives EXCSATRD, it must compare each of the entries in the mgrlvlls parameter it received to the corresponding entries in the mgrlvlls parameter it sent. If any level mismatches, the source server must decide whether it can use or adjust to the lower level of target support for that manager class. There are no architectural criteria for making this decision. The source server can terminate communications or continue at the target servers level of support. It can also attempt to use whatever commands its user requests while receiving error reply messages for real functional mismatches. The manager levels the source server specifies or the target server returns must be compatible with the manager-level dependencies of the specified manangers. Incompatible manager levels cannot be specified. Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager XAMGR - XA manager VALUE

Throws:

DRDAProtocolException

parseACCSEC

private int parseACCSEC()
                 throws DRDAProtocolException

Parse Access Security If the target server supports the SECMEC requested by the application requester then a single value is returned and it is identical to the SECMEC value in the ACCSEC command. If the target server does not support the SECMEC requested, then one or more values are returned and the application requester must choose one of these values for the security mechanism. We currently support - user id and password (default for JCC) - encrypted user id and password - strong password substitute (USRSSBPWD w/ Derby network client only) Instance variables SECMGRNM - security manager name - optional SECMEC - security mechanism - required RDBNAM - relational database name - optional SECTKN - security token - optional, (required if sec mech. needs it)

Returns:

security check code - 0 if everything O.K.

Throws:

DRDAProtocolException

parseOPNQRY

private Pkgnamcsn parseOPNQRY()
                       throws DRDAProtocolException,
SQLException

Parse OPNQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYBLKSZ - Query Block Size - required QRYBLKCTL - Query Block Protocol Control - optional MAXBLKEXT - Maximum Number of Extra Blocks - optional - default value 0 OUTOVROPT - Output Override Option QRYROWSET - Query Rowset Size - optional - level 7 MONITOR - Monitor events - optional.

Returns:

RDB Package Name, Consistency Token, and Section Number

Throws:

DRDAProtocolException

SQLException

parseOPNQRYobjects

private void parseOPNQRYobjects(DRDAStatement stmt)
                         throws DRDAProtocolException,
SQLException

Parse OPNQRY objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLDTA- SQL Program Variable Data - optional If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.

Throws:

DRDAProtocolException

SQLException

parseOUTOVROPT

private int parseOUTOVROPT()
                    throws DRDAProtocolException

Parse OUTOVROPT - this indicates whether output description can be overridden on just the first CNTQRY or on any CNTQRY

Returns:

output override option

Throws:

DRDAProtocolException

parseQRYBLKSZ

private int parseQRYBLKSZ()
                   throws DRDAProtocolException

Parse QRYBLSZ - this gives the maximum size of the query blocks that can be returned to the requester

Returns:

query block size

Throws:

DRDAProtocolException

parseQRYROWSET

private int parseQRYROWSET(int minVal)
                    throws DRDAProtocolException

Parse QRYROWSET - this is the number of rows to return

Parameters:

minVal - - minimum value

Returns:

query row set size

Throws:

DRDAProtocolException

parseQRYCLSIMP

private int parseQRYCLSIMP()
                    throws DRDAProtocolException

Parse a QRYCLSIMP - Implicitly close non-scrollable cursor after end of data.

Returns:

true to close on end of data

Throws:

DRDAProtocolException

parseQRYCLSRLS

private int parseQRYCLSRLS()
                    throws DRDAProtocolException

Throws:

DRDAProtocolException

writeQRYPOPRM

private void writeQRYPOPRM()
                    throws DRDAProtocolException

Write a QRYPOPRM - Query Previously opened Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required

Throws:

DRDAProtocolException

writeQRYNOPRM

private void writeQRYNOPRM(int svrCod)
                    throws DRDAProtocolException

Write a QRYNOPRM - Query Not Opened Instance Variables SVRCOD - Severity Code - required - 4 Warning 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required

Parameters:

svrCod - Severity Code

Throws:

DRDAProtocolException

writeOPNQFLRM

private void writeOPNQFLRM(SQLException e)
                    throws DRDAProtocolException

Write a OPNQFLRM - Open Query Failure Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required

Parameters:

e - Exception describing failure

Throws:

DRDAProtocolException

writePKGNAMCSN

private void writePKGNAMCSN(byte[] pkgcnstkn)
                     throws DRDAProtocolException

Write PKGNAMCSN Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number There are two possible formats, fixed and extended which includes length information for the strings

Throws:

DRDAProtocolException

writePKGNAMCSN

private void writePKGNAMCSN()
                     throws DRDAProtocolException

Throws:

DRDAProtocolException

parseCNTQRY

private DRDAStatement parseCNTQRY()
                           throws DRDAProtocolException,
SQLException

Parse CNTQRY - Continue Query Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required QRYBLKSZ - Query Block Size - required QRYRELSCR - Query Relative Scrolling Action - optional QRYSCRORN - Query Scroll Orientation - optional - level 7 QRYROWNBR - Query Row Number - optional QRYROWSNS - Query Row Sensitivity - optional - level 7 QRYBLKRST - Query Block Reset - optional - level 7 QRYRTNDTA - Query Returns Data - optional - level 7 QRYROWSET - Query Rowset Size - optional - level 7 QRYRFRTBL - Query Refresh Answer Set Table - optional NBRROW - Number of Fetch or Insert Rows - optional MAXBLKEXT - Maximum number of extra blocks - optional RTNEXTDTA - Return of EXTDTA Option - optional MONITOR - Monitor events - optional.

Returns:

DRDAStatement we are continuing

Throws:

DRDAProtocolException

SQLException

skipRemainder

private void skipRemainder(boolean onlySkipSameIds)
                    throws DRDAProtocolException

Skip remainder of current DSS and all chained DSS'es

Parameters:

onlySkipSameIds - True if we _only_ want to skip DSS'es that are chained with the SAME id as the current DSS. False means skip ALL chained DSSes, whether they're chained with same or different ids.

Throws:

DRDAProtocolException

parseCNTQRYobjects

private void parseCNTQRYobjects(DRDAStatement stmt)
                         throws DRDAProtocolException,
SQLException

Parse CNTQRY objects Instance Variables OUTOVR - Output Override Descriptor - optional

Parameters:

stmt - DRDA statement we are working on

Throws:

DRDAProtocolException

SQLException

parseOUTOVR

private void parseOUTOVR(DRDAStatement stmt)
                  throws DRDAProtocolException,
SQLException

Parse OUTOVR - Output Override Descriptor This specifies the output format for data to be returned as output to a SQL statement or as output from a query.

Parameters:

stmt - DRDA statement this applies to

Throws:

DRDAProtocolException

SQLException

writePBSD

private void writePBSD()
                throws SQLException,
DRDAProtocolException

Piggy-back any modified session attributes on the current message. Writes a PBSD conataining one or both of PBSD_ISO and PBSD_SCHEMA. PBSD_ISO is followed by the jdbc isolation level as an unsigned byte. PBSD_SCHEMA is followed by the name of the current schema as an UTF-8 String.

Throws:

SQLException

DRDAProtocolException

writeOPNQRYRM

private void writeOPNQRYRM(boolean isDssObject,
 DRDAStatement stmt)
                    throws DRDAProtocolException,
SQLException

Write OPNQRYRM - Open Query Complete Instance Variables SVRCOD - Severity Code - required QRYPRCTYP - Query Protocol Type - required SQLCSRHLD - Hold Cursor Position - optional QRYATTSCR - Query Attribute for Scrollability - optional - level 7 QRYATTSNS - Query Attribute for Sensitivity - optional - level 7 QRYATTUPD - Query Attribute for Updatability -optional - level 7 QRYINSID - Query Instance Identifier - required - level 7 SRVDGN - Server Diagnostic Information - optional

Parameters:

isDssObject - - return as a DSS object (part of a reply)

stmt - - DRDA statement we are processing

Throws:

DRDAProtocolException

SQLException

writeENDQRYRM

private void writeENDQRYRM(int svrCod)
                    throws DRDAProtocolException

Write ENDQRYRM - query process has terminated in such a manner that the query or result set is now closed. It cannot be resumed with the CNTQRY command or closed with the CLSQRY command

Parameters:

svrCod - Severity code - WARNING or ERROR

Throws:

DRDAProtocolException

writeABNUOWRM

private void writeABNUOWRM()
                    throws DRDAProtocolException

Write ABNUOWRM - query process has terminated in an error condition such as deadlock or lock timeout. Severity code is always error * @exception DRDAProtocolException

Throws:

DRDAProtocolException

parseRDBNAM

private String parseRDBNAM()
                    throws DRDAProtocolException

Parse database name

Returns:

database name

Throws:

DRDAProtocolException

writeACCSECRD

private void writeACCSECRD(int securityCheckCode)
                    throws DRDAProtocolException

Write ACCSECRD If the security mechanism is known, we just send it back along with the security token if encryption is going to be used. If the security mechanism is not known, we send a list of the ones we know. Instance Variables SECMEC - security mechanism - required SECTKN - security token - optional (required if security mechanism uses encryption) SECCHKCD - security check code - error occurred in processing ACCSEC

Parameters:

securityCheckCode -

Throws:

DRDAProtocolException

parseSECCHK

private int parseSECCHK()
                 throws DRDAProtocolException

Parse security check Instance Variables SECMGRNM - security manager name - optional, ignorable SECMEC - security mechanism - required SECTKN - security token - optional, (required if encryption used) PASSWORD - password - optional, (required if security mechanism uses it) NEWPASSWORD - new password - optional, (required if sec mech. uses it) USRID - user id - optional, (required if sec mec. uses it) RDBNAM - database name - optional (required if databases can have own sec.)

Returns:

security check code

Throws:

DRDAProtocolException

writeSECCHKRM

private void writeSECCHKRM(int securityCheckCode)
                    throws DRDAProtocolException

Write security check reply Instance variables SVRCOD - serverity code - required SECCHKCD - security check code - required SECTKN - security token - optional, ignorable SVCERRNO - security service error number SRVDGN - Server Diagnostic Information

Throws:

DRDAProtocolException

svrcodFromSecchkcd

private int svrcodFromSecchkcd(int securityCheckCode)

Calculate SVRCOD value from SECCHKCD

Parameters:

securityCheckCode -

Returns:

SVRCOD value

parseACCRDB

private int parseACCRDB()
                 throws DRDAProtocolException

Parse access RDB Instance variables RDBACCCL - RDB Access Manager Class - required must be SQLAM CRRTKN - Correlation Token - required RDBNAM - Relational database name -required PRDID - Product specific identifier - required TYPDEFNAM - Data Type Definition Name -required TYPDEFOVR - Type definition overrides -required RDBALWUPD - RDB Allow Updates optional PRDDTA - Product Specific Data - optional - ignorable STTDECDEL - Statement Decimal Delimiter - optional STTSTRDEL - Statement String Delimiter - optional TRGDFTRT - Target Default Value Return - optional

Returns:

severity code

Throws:

DRDAProtocolException

parseTYPDEFNAM

private String parseTYPDEFNAM()
                       throws DRDAProtocolException

Parse TYPDEFNAM

Returns:

typdefnam

Throws:

DRDAProtocolException

setStmtOrDbByteOrder

private void setStmtOrDbByteOrder(boolean setDatabase,
 DRDAStatement stmt,
 String typDefNam)

Set a statement or the database' byte order, depending on the arguments

Parameters:

setDatabase - if true, set database' byte order, otherwise set statement's

stmt - DRDAStatement, used when setDatabase is false

typDefNam - TYPDEFNAM value

writeACCRDBRM

private void writeACCRDBRM(int svrcod)
                    throws DRDAProtocolException

Write Access to RDB Completed Instance Variables SVRCOD - severity code - 0 info, 4 warning -required PRDID - product specific identifier -required TYPDEFNAM - type definition name -required TYPDEFOVR - type definition overrides - required RDBINTTKN - token which can be used to interrupt DDM commands - optional CRRTKN - correlation token - only returned if we didn't get one from requester SRVDGN - server diagnostic information - optional PKGDFTCST - package default character subtype - optional USRID - User ID at the target system - optional SRVLST - Server List

Throws:

DRDAProtocolException

writeTYPDEFOVR

private void writeTYPDEFOVR()
                     throws DRDAProtocolException

Throws:

DRDAProtocolException

parseTYPDEFOVR

private void parseTYPDEFOVR(DRDAStatement st)
                     throws DRDAProtocolException

Parse Type Defintion Overrides TYPDEF Overrides specifies the Coded Character SET Identifiers (CCSIDs) that are in a named TYPDEF. Instance Variables CCSIDSBC - CCSID for Single-Byte - optional CCSIDDBC - CCSID for Double-Byte - optional CCSIDMBC - CCSID for Mixed-byte characters -optional

Parameters:

st - Statement this TYPDEFOVR applies to

Throws:

DRDAProtocolException

parsePRPSQLSTT

private int parsePRPSQLSTT()
                    throws DRDAProtocolException,
SQLException

Parse PRPSQLSTT - Prepare SQL Statement Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required RTNSQLDA - Return SQL Descriptor Area - optional MONITOR - Monitor events - optional.

Returns:

return 0 - don't return sqlda, 1 - return input sqlda, 2 - return output sqlda

Throws:

DRDAProtocolException

SQLException

parsePRPSQLSTTobjects

private String parsePRPSQLSTTobjects(DRDAStatement stmt)
                              throws DRDAProtocolException,
SQLException

Parse PRPSQLSTT objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement required SQLATTR - Cursor attributes on prepare - optional - level 7 If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.

Returns:

SQL statement

Throws:

DRDAProtocolException

SQLException

parseTYPSQLDA

private boolean parseTYPSQLDA()
                       throws DRDAProtocolException

Parse TYPSQLDA - Type of the SQL Descriptor Area

Returns:

true if for output; false otherwise

Throws:

DRDAProtocolException

parseSQLATTR

protected void parseSQLATTR(DRDAStatement stmt)
                     throws DRDAProtocolException

Parse SQLATTR - Cursor attributes on prepare This is an encoded string. Can have combination of following, eg INSENSITIVE SCROLL WITH HOLD Possible strings are SENSITIVE DYNAMIC SCROLL [FOR UPDATE] SENSITIVE STATIC SCROLL [FOR UPDATE] INSENSITIVE SCROLL FOR UPDATE WITH HOLD

Parameters:

stmt - DRDAStatement

Throws:

DRDAProtocolException

parseDSCSQLSTT

private boolean parseDSCSQLSTT()
                        throws DRDAProtocolException,
SQLException

Parse DSCSQLSTT - Describe SQL Statement previously prepared Instance Variables TYPSQLDA - sqlda type expected (output or input) RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required MONITOR - Monitor events - optional.

Returns:

expect "output sqlda" or not

Throws:

DRDAProtocolException

SQLException

parseEXCSQLSTT

private void parseEXCSQLSTT()
                     throws DRDAProtocolException,
SQLException

Parse EXCSQLSTT - Execute non-cursor SQL Statement previously prepared Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required OUTEXP - Output expected NBRROW - Number of rows to be inserted if it's an insert PRCNAM - procedure name if specified by host variable, not needed for Derby QRYBLKSZ - query block size MAXRSLCNT - max resultset count MAXBLKEXT - Max number of extra blocks RSLSETFLG - resultset flag RDBCMTOK - RDB Commit Allowed - optional OUTOVROPT - output override option QRYROWSET - Query Rowset Size - Level 7 MONITOR - Monitor events - optional.

Throws:

DRDAProtocolException

SQLException

parseRDBCMTOK

private void parseRDBCMTOK()
                    throws DRDAProtocolException

Parse RDBCMTOK - tells the database whether to allow commits or rollbacks to be executed as part of the command Since we don't have a SQL commit or rollback command, we will just ignore this for now

Throws:

DRDAProtocolException

parseEXCSQLSTTobjects

private boolean parseEXCSQLSTTobjects(DRDAStatement stmt)
                               throws DRDAProtocolException,
SQLException

Parse EXCSQLSTT command objects Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLDTA - optional, variable data, specified if prpared statement has input parameters EXTDTA - optional, externalized FD:OCA data OUTOVR - output override descriptor, not allowed for stored procedure calls If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.

Parameters:

stmt - the DRDAStatement to execute

Throws:

DRDAProtocolException

SQLException

writeSQLCINRD

private void writeSQLCINRD(DRDAStatement stmt)
                    throws DRDAProtocolException,
SQLException

Write SQLCINRD - result set column information

Throws:

DRDAProtocolException

SQLException

writeSQLRSLRD

private void writeSQLRSLRD(DRDAStatement stmt)
                    throws DRDAProtocolException,
SQLException

Write SQLRSLRD - result set reply data

Throws:

DRDAProtocolException

SQLException

writeRSLSETRM

private void writeRSLSETRM(DRDAStatement stmt)
                    throws DRDAProtocolException,
SQLException

Write RSLSETRM Instance variables SVRCOD - Severity code - Information only - required PKGSNLST - list of PKGNAMCSN -required SRVDGN - Server Diagnostic Information -optional

Throws:

DRDAProtocolException

SQLException

parseSQLDTA

private void parseSQLDTA(DRDAStatement stmt)
                  throws DRDAProtocolException,
SQLException

Parse SQLDTA - SQL program variable data and handle exception.

Throws:

DRDAProtocolException

SQLException

See Also:

• parseSQLDTA_work(DRDAStatement)

parseSQLDTA_work

private void parseSQLDTA_work(DRDAStatement stmt)
                       throws DRDAProtocolException,
SQLException

Parse SQLDTA - SQL program variable data Instance Variables FDODSC - FD:OCA data descriptor - required FDODTA - FD:OCA data - optional

Throws:

DRDAProtocolException

SQLException

getByteOrder

private int getByteOrder()

getGMTCalendar

private Calendar getGMTCalendar()

Get a Calendar instance with time zone set to GMT. The instance is cached for reuse by this thread. This calendar can be used to consistently read and write date and time values using the same calendar. Since the local default calendar may not be able to represent all times (for instance because the time would fall into a non-existing hour of the day when switching to daylight saving time, see DERBY-4582), we use the GMT time zone which doesn't observe daylight saving time.

Returns:

a calendar in the GMT time zone

readAndSetParams

private void readAndSetParams(int i,
 DRDAStatement stmt,
 ParameterMetaData pmeta)
                       throws DRDAProtocolException,
SQLException

Read different types of input parameters and set them in PreparedStatement

Parameters:

i - index of the parameter

stmt - drda statement

pmeta - parameter meta data

Throws:

DRDAProtocolException

SQLException

readUDT

private Object readUDT()
                throws DRDAProtocolException

Read a UDT from the stream

Throws:

DRDAProtocolException

readLobLength

private long readLobLength(int extLenIndicator)
                    throws DRDAProtocolException

Throws:

DRDAProtocolException

parseDate

private Date parseDate(String dateString,
 Calendar cal)

Parse a date string as it is received from the client.

Parameters:

dateString - the date string to parse

cal - the calendar in which the date is parsed

Returns:

a Date object representing the date in the specified calendar

Throws:

IllegalArgumentException - if the date is not correctly formatted

See Also:

• DateTime.dateToDateBytes(byte[], int, DateTimeValue)

parseTime

private Time parseTime(String timeString,
 Calendar cal)

Parse a time string as it is received from the client.

Parameters:

timeString - the time string to parse

cal - the calendar in which the time is parsed

Returns:

a Date object representing the time in the specified calendar

Throws:

IllegalArgumentException - if the time is not correctly formatted

See Also:

• DateTime.timeToTimeBytes(byte[], int, DateTimeValue)

parseTimestamp

private Timestamp parseTimestamp(String timeString,
 Calendar cal)

Parse a timestamp string as it is received from the client.

Parameters:

timeString - the time string to parse

cal - the calendar in which the timestamp is parsed

Returns:

a Date object representing the timestamp in the specified calendar

Throws:

IllegalArgumentException - if the timestamp is not correctly formatted

See Also:

• DateTime.timestampToTimestampBytes(byte[], int, DateTimeValue, boolean)

readAndSetAllExtParams

private void readAndSetAllExtParams(DRDAStatement stmt,
 boolean streamLOB)
                             throws SQLException,
DRDAProtocolException

Throws:

SQLException

DRDAProtocolException

readAndSetExtParam

private void readAndSetExtParam(int i,
 DRDAStatement stmt,
 int drdaType,
 int extLen,
 boolean streamLOB)
                         throws DRDAProtocolException,
SQLException

Read different types of input parameters and set them in PreparedStatement

Parameters:

i - zero-based index of the parameter

stmt - associated ps

drdaType - drda type of the parameter

Throws:

DRDAProtocolException

SQLException

parseEXCSQLIMM

private long parseEXCSQLIMM()
                     throws DRDAProtocolException,
SQLException

Parse EXCSQLIMM - Execute Immediate Statement Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required RDBCMTOK - RDB Commit Allowed - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLSTT - SQL Statement -required

Returns:

update count

Throws:

DRDAProtocolException

SQLException

parseEXCSQLSET

private boolean parseEXCSQLSET()
                        throws DRDAProtocolException,
SQLException

Parse EXCSQLSET - Execute Set SQL Environment Instance Variables RDBNAM - relational database name - optional PKGNAMCT - RDB Package Name, Consistency Token - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - required TYPDEFOVR - TYPDEF Overrides - required SQLSTT - SQL Statement - required (at least one; may be more)

Throws:

DRDAProtocolException

SQLException

parseEXECSQLIMMobjects

private String parseEXECSQLIMMobjects()
                               throws DRDAProtocolException,
SQLException

Parse EXCSQLIMM objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides SQLSTT - SQL Statement required If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.

Returns:

SQL Statement

Throws:

DRDAProtocolException

SQLException

parseEXCSQLSETobjects

private void parseEXCSQLSETobjects()
                            throws DRDAProtocolException,
SQLException

Parse EXCSQLSET objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement - required (a list of at least one) Objects may follow in one DSS or in several DSS chained together.

Throws:

DRDAProtocolException

SQLException

canIgnoreStmt

private boolean canIgnoreStmt(String stmt)

writeRDBUPDRM

private void writeRDBUPDRM()
                    throws DRDAProtocolException

Write RDBUPDRM Instance variables SVRCOD - Severity code - Information only - required RDBNAM - Relational database name -required SRVDGN - Server Diagnostic Information -optional

Throws:

DRDAProtocolException

parsePKGNAMCT

private String parsePKGNAMCT()
                      throws DRDAProtocolException

Throws:

DRDAProtocolException

parsePKGNAMCSN

private Pkgnamcsn parsePKGNAMCSN()
                          throws DRDAProtocolException

Parse PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number

Returns:

Pkgnamcsn value

Throws:

DRDAProtocolException

parseSQLSTTDss

private String parseSQLSTTDss()
                       throws DRDAProtocolException

Parse SQLSTT Dss

Throws:

DRDAProtocolException

parseEncodedString

private String parseEncodedString()
                           throws DRDAProtocolException

Parse an encoded data string from the Application Requester

Returns:

string value

Throws:

DRDAProtocolException

parseVCMorVCS

private String parseVCMorVCS()
                      throws DRDAProtocolException

Parse variable character mixed byte or variable character single byte Format I2 - VCM Length N bytes - VCM value I2 - VCS Length N bytes - VCS value Only 1 of VCM length or VCS length can be non-zero

Returns:

string value

Throws:

DRDAProtocolException

parseNOCMorNOCS

private String parseNOCMorNOCS()
                        throws DRDAProtocolException

Parse nullable character mixed byte or nullable character single byte Format 1 byte - null indicator I4 - mixed character length N bytes - mixed character string 1 byte - null indicator I4 - single character length N bytes - single character length string

Returns:

string value

Throws:

DRDAProtocolException

parseCcsidMBC

private String parseCcsidMBC(int length)
                      throws DRDAProtocolException

Parse mixed character string

Returns:

string value

Throws:

DRDAProtocolException

parseCcsidSBC

private String parseCcsidSBC(int length)
                      throws DRDAProtocolException

Parse single byte character string

Returns:

string value

Throws:

DRDAProtocolException

parseCLSQRY

private DRDAStatement parseCLSQRY()
                           throws DRDAProtocolException,
SQLException

Parse CLSQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYINSID - Query Instance Identifier - required - level 7 MONITOR - Monitor events - optional.

Returns:

DRDAstatement being closed

Throws:

DRDAProtocolException

SQLException

parseMONITOR

private void parseMONITOR()
                   throws DRDAProtocolException

Parse MONITOR DRDA spec says this is optional. Since we don't currently support it, we just ignore.

Throws:

DRDAProtocolException

writeSQLCARDs

private void writeSQLCARDs(SQLException e,
 long updateCount)
                    throws DRDAProtocolException

Throws:

DRDAProtocolException

writeSQLCARDs

private void writeSQLCARDs(SQLException e,
 long updateCount,
 boolean sendSQLERRRM)
                    throws DRDAProtocolException

Throws:

DRDAProtocolException

getSqlCode

private int getSqlCode(SQLException e)

Get the SQLCODE to send for an exception or a warning.

The client expects a negative SQLCODE for exceptions and a positive SQLCODE for warnings. SQLCODE 0 means there is no error or warning condition. SQLCODE is also used to encode the severity of the condition (as returned by SQLException.getErrorCode()).

For warnings, the SQLCODE is 10000, which is identical to ExceptionSeverity.WARNING_SEVERITY.

For exceptions, the SQLCODE is set to -severity-1, which allows all non-negative severity values to be encoded. (Derby only uses non-negative severity values in the first place.)

Parameters:

e - the exception or warning to get the SQLCODE for

Returns:

the value to send as SQLCODE

writeSQLCARD

private void writeSQLCARD(SQLException e,
 long updateCount,
 long rowCount)
                   throws DRDAProtocolException

Throws:

DRDAProtocolException

writeNullSQLCARDobject

private void writeNullSQLCARDobject()
                             throws DRDAProtocolException

Write a null SQLCARD as an object

Throws:

DRDAProtocolException

writeSQLERRRM

private void writeSQLERRRM(int severity)
                    throws DRDAProtocolException

Write SQLERRRM Instance Variables SVRCOD - Severity Code - required

Parameters:

severity - severity of error

Throws:

DRDAProtocolException

writeCMDCHKRM

private void writeCMDCHKRM(int severity)
                    throws DRDAProtocolException

Write CMDCHKRM Instance Variables SVRCOD - Severity Code - required

Parameters:

severity - severity of error

Throws:

DRDAProtocolException

getExceptionSeverity

private int getExceptionSeverity(SQLException e)

Translate from Derby exception severity to SVRCOD

Parameters:

e - SQLException

writeSQLCAGRP

private void writeSQLCAGRP(SQLException e,
 long updateCount,
 long rowCount)
                    throws DRDAProtocolException

Write SQLCAGRP SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0

Parameters:

e - SQLException encountered

Throws:

DRDAProtocolException

writeSQLCAGRP

private void writeSQLCAGRP(byte[] sqlState,
 int sqlcode,
 long updateCount,
 long rowCount)
                    throws DRDAProtocolException

Same as writeSQLCAGRP, but optimized for the case when there is no real exception, i.e. the exception is null, or "End of data" SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0

Parameters:

sqlState - SQLState (already converted to UTF8)

sqlcode - sqlcode

updateCount -

rowCount -

Throws:

DRDAProtocolException

buildSqlerrmc

private String buildSqlerrmc(SQLException se)

Create error message or message argements to return to client. The SQLERRMC will normally be passed back to the server in a call to the SYSIBM.SQLCAMESSAGE but for severe exceptions the stored procedure call cannot be made. So for Severe messages we will just send the message text. This method will also truncate the value according the client capacity. CCC can only handle 70 characters. Server sends the sqlerrmc using UTF8 encoding to the client. To get the message, client sends back information to the server calling SYSIBM.SQLCAMESSAGE (see Sqlca.getMessage). Several parameters are sent to this procedure including the locale, the sqlerrmc that the client received from the server. On server side, the procedure SQLCAMESSAGE in SystemProcedures then calls the MessageService.getLocalizedMessage to retrieve the localized error message. In MessageService.getLocalizedMessage the sqlerrmc that is passed in, is parsed to retrieve the message id. The value it uses to parse the MessageId is char value of 20, otherwise it uses the entire sqlerrmc as the message id. This messageId is then used to retrieve the localized message if present, to the client.

Parameters:

se - SQLException to build SQLERRMC

Returns:

String which is either the message arguments to be passed to SYSIBM.SQLCAMESSAGE or just message text for severe errors.

buildPreformattedSqlerrmc

private String buildPreformattedSqlerrmc(SQLException se)

Build preformatted SQLException text for severe exceptions or SQLExceptions that are not Derby exceptions. Just send the message text localized to the server locale.

Parameters:

se - SQLException for which to build SQLERRMC

Returns:

preformated message text with messages separted by SQLERRMC_PREFORMATED_MESSAGE_DELIMITER

buildTokenizedSqlerrmc

private String buildTokenizedSqlerrmc(SQLException se)

Build Tokenized SQLERRMC to just send the tokenized arguments to the client. for a Derby SQLException or an SQLException thrown by user code. Message argument tokens are separated by SQLERRMC_TOKEN_DELIMITER Multiple messages are separated by SystemProcedures.SQLERRMC_MESSAGE_DELIMITER ...

Parameters:

se - SQLException to print

buildDataTruncationSqlerrmc

private String buildDataTruncationSqlerrmc(DataTruncation dt)

Build the SQLERRMC for a java.sql.DataTruncation warning. Serialize all the fields of the DataTruncation instance in the order in which they appear in the parameter list of the constructor.

Parameters:

dt - the DataTruncation instance to serialize

Returns:

the SQLERRMC string with all fields of the warning

writeSQLCAXGRP

private void writeSQLCAXGRP(long updateCount,
 long rowCount,
 String sqlerrmc,
 SQLException nextException)
                     throws DRDAProtocolException

Write SQLCAXGRP SQLCAXGRP : EARLY FDOCA GROUP SQL Communications Area Exceptions Group Description FORMAT FOR SQLAM <= 6 SQLRDBNME; DRDA TYPE FCS; ENVLID 0x30; Length Override 18 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70 FORMAT FOR SQLAM >= 7 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLRDBNAME; DRDA TYPE VCS; ENVLID 0x32; Length Override 1024 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70

Parameters:

sqlerrmc - sqlcode

nextException - SQLException encountered

Throws:

DRDAProtocolException

writeSQLCAERRWARN

private void writeSQLCAERRWARN(long updateCount,
 long rowCount)

Write the ERR and WARN part of the SQLCA

Parameters:

updateCount -

rowCount -

writeSQLDIAGGRP

private void writeSQLDIAGGRP(SQLException nextException)
                      throws DRDAProtocolException

Write SQLDIAGGRP: SQL Diagnostics Group Description - Identity 0xD1 Nullable Group SQLDIAGSTT; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 0 SQLDIAGCN; DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0 SQLDIAGCI; DRDA TYPE N-RLO; ENVLID 0xF5; Length Override 0

Throws:

DRDAProtocolException

writeSQLDIAGSTT

private void writeSQLDIAGSTT()
                      throws DRDAProtocolException

Throws:

DRDAProtocolException

writeSQLDIAGCI

private void writeSQLDIAGCI(SQLException nextException)
                     throws DRDAProtocolException

writeSQLDIAGCI: SQL Diagnostics Condition Information Array - Identity 0xF5 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)

Throws:

DRDAProtocolException

writeSQLNUMROW

private void writeSQLNUMROW(SQLException nextException)
                     throws DRDAProtocolException

writeSQLNUMROW: Writes SQLNUMROW : FDOCA EARLY ROW SQL Number of Elements Row Description FORMAT FOR SQLAM LEVELS SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1

Throws:

DRDAProtocolException

writeSQLNUMGRP

private void writeSQLNUMGRP(SQLException nextException)
                     throws DRDAProtocolException

writeSQLNUMGRP: Writes SQLNUMGRP : FDOCA EARLY GROUP SQL Number of Elements Group Description FORMAT FOR ALL SQLAM LEVELS SQLNUM; DRDA TYPE I2; ENVLID 0x04; Length Override 2

Throws:

DRDAProtocolException

writeSQLDCROW

private void writeSQLDCROW(long rowNum,
 int sqlCode,
 String sqlState,
 String dbname,
 String sqlerrmc)
                    throws DRDAProtocolException

writeSQLDCROW: SQL Diagnostics Condition Row - Identity 0xE5 SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1

Throws:

DRDAProtocolException

writeSQLDCGRP

private void writeSQLDCGRP(long rowNum,
 int sqlCode,
 String sqlState,
 String dbname,
 String sqlerrmc)
                    throws DRDAProtocolException

writeSQLDCGRP: SQL Diagnostics Condition Group Description SQLDCCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCSTATE; DRDA TYPE FCS; ENVLID Ox30; Lengeh Override 5 SQLDCREASON; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCLINEN; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCROWN; DRDA TYPE FD; ENVLID 0x0E; Lengeh Override 31 SQLDCER01; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER02; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER03; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER04; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPART; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPPOP; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCMSGID; DRDA TYPE FCS; ENVLID 0x30; Length Override 10 SQLDCMDE; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLDCPMOD; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLDCRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 SQLDCTOKS; DRDA TYPE N-RLO; ENVLID 0xF7; Length Override 0 SQLDCMSG_m; DRDA TYPE NVMC; ENVLID 0x3F; Length Override 32672 SQLDCMSG_S; DRDA TYPE NVCS; ENVLID 0x33; Length Override 32672 SQLDCCOLN_m; DRDA TYPE NVCM ; ENVLID 0x3F; Length Override 255 SQLDCCOLN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCCURN_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCCURN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCPNAM_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCPNAM_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCXGRP; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 1

Throws:

DRDAProtocolException

writeSQLDIAGCN

private void writeSQLDIAGCN()
                     throws DRDAProtocolException

Throws:

DRDAProtocolException

writeSQLDARD

private void writeSQLDARD(DRDAStatement stmt,
 boolean rtnOutput,
 SQLException e)
                   throws DRDAProtocolException,
SQLException

Write SQLDARD SQLDARD : FDOCA EARLY ARRAY SQL Descriptor Area Row Description with SQL Communications Area FORMAT FOR SQLAM <= 6 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDAROW; ROW LID 0x60; ELEMENT TAKEN 0(all); REP FACTOR 0(all) FORMAT FOR SQLAM >= 7 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDHROW; ROW LID 0xE0; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1

Parameters:

stmt - prepared statement

Throws:

DRDAProtocolException

SQLException

writeQRYDSC

private void writeQRYDSC(DRDAStatement stmt,
 boolean FDODSConly)
                  throws DRDAProtocolException,
SQLException

Write QRYDSC - Query Answer Set Description

Parameters:

stmt - DRDAStatement we are working on

FDODSConly - simply the FDODSC, without the wrap Instance Variables SQLDTAGRP - required Only 84 columns can be sent in a single QRYDSC. If there are more columns they must be sent in subsequent QRYDSC. If the QRYDSC will not fit into the current block, as many columns as can fit are sent and then the remaining are sent in the following blocks.

Throws:

DRDAProtocolException

SQLException

writeSQLDTAGRP

private void writeSQLDTAGRP(DRDAStatement stmt,
 ResultSetMetaData rsmeta,
 ParameterMetaData pmeta,
 int colStart,
 int colEnd,
 boolean first)
                     throws DRDAProtocolException,
SQLException

Write SQLDTAGRP SQLDAGRP : Late FDOCA GROUP SQL Data Value Group Descriptor LENGTH - length of the SQLDTAGRP TRIPLET_TYPE - NGDA for first, CPT for following ID - SQLDTAGRP_LID for first, NULL_LID for following For each column DRDA TYPE LENGTH OVERRIDE For numeric/decimal types PRECISON SCALE otherwise LENGTH or DISPLAY_WIDTH

Parameters:

stmt - drda statement

rsmeta - resultset meta data

pmeta - parameter meta data for CallableStatement

colStart - starting column for group to send

colEnd - end column to send

first - is this the first group

Throws:

DRDAProtocolException

SQLException

writeSQLDHROW

private void writeSQLDHROW(int holdability)
                    throws DRDAProtocolException,
SQLException

Holdability passed in as it can represent the holdability of the statement or a specific result set.

Parameters:

holdability - HOLD_CURSORS_OVER_COMMIT or CLOSE_CURSORS_AT_COMMIT

Throws:

DRDAProtocolException

SQLException

writeQRYDTA

private void writeQRYDTA(DRDAStatement stmt)
                  throws DRDAProtocolException,
SQLException

Write QRYDTA - Query Answer Set Data Contains some or all of the answer set data resulting from a query If the client is not using rowset processing, this routine attempts to pack as much data into the QRYDTA as it can. This may result in splitting the last row across the block, in which case when the client calls CNTQRY we will return the remainder of the row. Splitting a QRYDTA block is expensive, for several reasons: - extra logic must be run, on both client and server side - more network round-trips are involved - the QRYDTA block which contains the continuation of the split row is generally wasteful, since it contains the remainder of the split row but no additional rows. Since splitting is expensive, the server makes some attempt to avoid it. Currently, the server's algorithm for this is to compute the length of the current row, and to stop trying to pack more rows into this buffer if another row of that length would not fit. However, since rows can vary substantially in length, this algorithm is often ineffective at preventing splits. For example, if a short row near the end of the buffer is then followed by a long row, that long row will be split. It is possible to improve this algorithm substantially: - instead of just using the length of the previous row as a guide for whether to attempt packing another row in, use some sort of overall average row size computed over multiple rows (e.g., all the rows we've placed into this QRYDTA block, or all the rows we've process for this result set) - when we discover that the next row will not fit, rather than splitting the row across QRYDTA blocks, if it is relatively small, we could just hold the entire row in a buffer to place it entirely into the next QRYDTA block, or reset the result set cursor back one row to "unread" this row. - when splitting a row across QRYDTA blocks, we tend to copy data around multiple times. Careful coding could remove some of these copies. However, it is important not to over-complicate this code: it is better to be correct than to be efficient, and there have been several bugs in the split logic already. Instance Variables Byte string

Parameters:

stmt - DRDA statement we are processing

Throws:

DRDAProtocolException

SQLException

writeFDODTA

private boolean writeFDODTA(DRDAStatement stmt)
                     throws DRDAProtocolException,
SQLException

This routine places some data into the current QRYDTA block using FDODTA (Formatted Data Object DaTA rules). There are 3 basic types of processing flow for this routine: - In normal non-rowset, non-scrollable cursor flow, this routine places a single row into the QRYDTA block and returns TRUE, indicating that the caller can call us back to place another row into the result set if he wishes. (The caller may need to send Externalized Data, which would be a reason for him NOT to place any more rows into the QRYDTA). - In ROWSET processing, this routine places an entire ROWSET of rows into the QRYDTA block and returns FALSE, indicating that the QRYDTA block is full and should now be sent. - In callable statement processing, this routine places the results from the output parameters of the called procedure into the QRYDTA block. This code path is really dramatically different from the other two paths and shares only a very small amount of common code in this routine. In all cases, it is possible that the data we wish to return may not fit into the QRYDTA block, in which case we call splitQRYDTA to split the data and remember the remainder data in the result set. Splitting the data is relatively rare in the normal cursor case, because our caller (writeQRYDTA) uses a coarse estimation technique to avoid calling us if he thinks a split is likely. The overall structure of this routine is implemented as two loops: - the outer "do ... while ... " loop processes a ROWSET, one row at a time. For non-ROWSET cursors, and for callable statements, this loop executes only once. - the inner "for ... i < numCols ..." loop processes each column in the current row, or each output parmeter in the procedure. Most column data is written directly inline in the QRYDTA block. Some data, however, is written as Externalized Data. This is commonly used for Large Objects. In that case, an Externalized Data Pointer is written into the QRYDTA block, and the actual data flows in separate EXTDTA blocks which are returned after this QRYDTA block.

Throws:

DRDAProtocolException

SQLException

getObjectForWriteFdoca

private Object getObjectForWriteFdoca(ResultSet rs,
 int index,
 int drdaType)
                               throws SQLException

Get a column value of the specified type from a ResultSet, in a form suitable for being writted by writeFdocaVal(int, Object, int, int, int, boolean, DRDAStatement, boolean). For most types, this means just calling ResultSet.getObject(int).

The only exception currently is the data types representing dates and times, as they need to be fetched using the same java.util.Calendar as writeFdocaVal(int, Object, int, int, int, boolean, DRDAStatement, boolean) uses when writing them (DERBY-4582).

Note: Changes made in this method should also be made in the corresponding method for CallableStatement: getObjectForWriteFdoca(java.sql.CallableStatement, int, int).

Parameters:

rs - the result set to fetch the object from

index - the column index

drdaType - the DRDA type of the object to fetch

Returns:

an object with the value of the column

Throws:

SQLException

See Also:

• getObjectForWriteFdoca(java.sql.CallableStatement, int, int)

getObjectForWriteFdoca

private Object getObjectForWriteFdoca(CallableStatement cs,
 int index,
 int drdaType)
                               throws SQLException

Get the value of an output parameter of the specified type from a CallableStatement, in a form suitable for being writted by writeFdocaVal(int, Object, int, int, int, boolean, DRDAStatement, boolean). For most types, this means just calling CallableStatement.getObject(int).

This method should behave like the corresponding method for ResultSet, and changes made to one of these methods, must be reflected in the other method. See getObjectForWriteFdoca(java.sql.ResultSet, int, int) for details.

Parameters:

cs - the callable statement to fetch the object from

index - the parameter index

drdaType - the DRDA type of the object to fetch

Returns:

an object with the value of the output parameter

Throws:

SQLException

See Also:

• getObjectForWriteFdoca(java.sql.ResultSet, int, int)

splitQRYDTA

private void splitQRYDTA(DRDAStatement stmt,
 int blksize)
                  throws SQLException,
DRDAProtocolException

Split QRYDTA into blksize chunks This routine is called if the QRYDTA data will not fit. It writes as much data as it can, then stores the remainder in the result set. At some later point, when the client returns with a CNTQRY, we will call processLeftoverQRYDTA to handle that data. The interaction between DRDAConnThread and DDMWriter is rather complicated here. This routine gets called because DRDAConnThread realizes that it has constructed a QRYDTA message which is too large. At that point, we need to reclaim the "extra" data and hold on to it. To aid us in that processing, DDMWriter provides the routines getDSSLength, copyDSSDataToEnd, and truncateDSS. For some additional detail on this complex sub-protocol, the interested reader should study bug DERBY-491 and 492 at: http://issues.apache.org/jira/browse/DERBY-491 and http://issues.apache.org/jira/browse/DERBY-492

Parameters:

stmt - DRDA statment

blksize - size of query block

Throws:

SQLException

DRDAProtocolException

processLeftoverQRYDTA

private boolean processLeftoverQRYDTA(DRDAStatement stmt)
                               throws SQLException,
DRDAProtocolException

Process remainder data resulting from a split. This routine is called at the start of building each QRYDTA block. Normally, it observes that there is no remainder data from the previous QRYDTA block, and returns FALSE, indicating that there was nothing to do. However, if it discovers that the previous QRYDTA block was split, then it retrieves the remainder data from the result set, writes as much of it as will fit into the QRYDTA block (hopefully all of it will fit, but the row may be very long), and returns TRUE, indicating that this QRYDTA block has been filled with remainder data and should now be sent immediately.

Throws:

SQLException

DRDAProtocolException

doneData

private void doneData(DRDAStatement stmt,
 ResultSet rs)
               throws DRDAProtocolException,
SQLException

Done data Send SQLCARD for the end of the data

Parameters:

stmt - DRDA statement

rs - Result set

Throws:

DRDAProtocolException

SQLException

positionCursor

private boolean positionCursor(DRDAStatement stmt,
 ResultSet rs)
                        throws SQLException,
DRDAProtocolException

Position cursor for insensitive scrollable cursors

Parameters:

stmt - DRDA statement

rs - Result set

Throws:

SQLException

DRDAProtocolException

writeSQLDAGRP

private void writeSQLDAGRP(ResultSetMetaData rsmeta,
 ParameterMetaData pmeta,
 int elemNum,
 boolean rtnOutput)
                    throws DRDAProtocolException,
SQLException

Write SQLDAGRP SQLDAGRP : EARLY FDOCA GROUP SQL Data Area Group Description FORMAT FOR SQLAM <= 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 FORMAT FOR SQLAM == 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 SQLUDTGRP; DRDA TYPE N-GDA; ENVLID 0x51; Length Override 0 FORMAT FOR SQLAM >= 7 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLDOPTGRP; DRDA TYPE N-GDA; ENVLID 0xD2; Length Override 0

Parameters:

rsmeta - resultset meta data

pmeta - parameter meta data

elemNum - column number we are returning (in case of result set), or, parameter number (in case of parameter)

rtnOutput - whether this is for a result set

Throws:

DRDAProtocolException

SQLException

writeVCMorVCS

private void writeVCMorVCS(String s)
                    throws DRDAProtocolException

Write variable character mixed byte or single byte The preference is to write mixed byte if it is defined for the server, since that is our default and we don't allow it to be changed, we always write mixed byte.

Parameters:

s - string to write

Throws:

DRDAProtocolException

writeSQLUDTGRP

private void writeSQLUDTGRP(ResultSetMetaData rsmeta,
 ParameterMetaData pmeta,
 int jdbcElemNum,
 boolean rtnOutput)
                     throws DRDAProtocolException,
SQLException

Write SQLUDTGRP (SQL Descriptor User-Defined Type Group Descriptor) This is the format from the DRDA spec, Volume 1, section 5.6.4.10. However, this format is not rich enough to carry the information needed by JDBC. This format does not have a subtype code for JAVA_OBJECT and this format does not convey the Java class name needed by ResultSetMetaData.getColumnClassName(). SQLUDXTYPE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 Constants which map to java.sql.Types constants DISTINCT, STRUCT, and REF. But DRDA does not define a constant which maps to java.sql.Types.JAVA_OBJECT. SQLUDTRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Database name. SQLUDTSCHEMA_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTSCHEMA_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Schema name. One of the above. SQLUDTNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Unqualified UDT name. One of the above. Instead, we use the following format and only for communication between Derby servers and Derby clients which are both at version 10.6 or higher. For all other client/server combinations, we send null. SQLUDTNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Fully qualified UDT name. One of the above. SQLUDTCLASSNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override FdocaConstants.LONGVARCHAR_MAX_LEN SQLUDTCLASSNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override FdocaConstants.LONGVARCHAR_MAX_LEN Name of the Java class bound to the UDT. One of the above.

Parameters:

rsmeta - resultset meta data

pmeta - parameter meta data

jdbcElemNum - column number we are returning (in case of result set), or, parameter number (in case of parameter)

rtnOutput - whether this is for a result set

Throws:

DRDAProtocolException

SQLException

writeSQLDOPTGRP

private void writeSQLDOPTGRP(ResultSetMetaData rsmeta,
 ParameterMetaData pmeta,
 int jdbcElemNum,
 boolean rtnOutput)
                      throws DRDAProtocolException,
SQLException

Throws:

DRDAProtocolException

SQLException

writeSQLDXGRP

private void writeSQLDXGRP(ResultSetMetaData rsmeta,
 ParameterMetaData pmeta,
 int jdbcElemNum,
 boolean rtnOutput)
                    throws DRDAProtocolException,
SQLException

Throws:

DRDAProtocolException

SQLException

writeFdocaVal

protected void writeFdocaVal(int index,
 Object val,
 int drdaType,
 int precision,
 int scale,
 boolean valNull,
 DRDAStatement stmt,
 boolean isParam)
                      throws DRDAProtocolException,
SQLException

Write Fdoca Value to client

Parameters:

index - Index of column being returned

val - Value to write to client

drdaType - FD:OCA DRDA Type from FdocaConstants

precision - Precision

stmt - Statement being processed

isParam - True when writing a value for a procedure parameter

Throws:

DRDAProtocolException

SQLException

See Also:

• FdocaConstants

writeNullability

private void writeNullability(int drdaType,
 boolean valNull)

write nullability if this is a nullable drdatype and FDOCA null value if appropriate

Parameters:

drdaType - FDOCA type

valNull - true if this is a null value. False otherwise

formatDate

private String formatDate(Date date)

Convert a java.sql.Date to a string with the format expected by the client.

Parameters:

date - the date to format

Returns:

a string on the format YYYY-MM-DD representing the date

See Also:

• DateTime.dateBytesToDate(byte[], int, Calendar, Charset)

formatTime

private String formatTime(Time time)

Convert a java.sql.Time to a string with the format expected by the client.

Parameters:

time - the time to format

Returns:

a string on the format HH:MM:SS representing the time

See Also:

• DateTime.timeBytesToTime(byte[], int, Calendar, Charset)

formatTimestamp

private String formatTimestamp(Timestamp ts)

Convert a java.sql.Timestamp to a string with the format expected by the client.

Parameters:

ts - the timestamp to format

Returns:

a string on the format YYYY-MM-DD-HH.MM.SS.ffffff[fff]

See Also:

• DateTime.timestampBytesToTimestamp(byte[], int, Calendar, Charset, boolean)

padInt

private void padInt(char[] buf,
 int offset,
 int length,
 int value)

Insert an integer into a char array and pad it with leading zeros if its string representation is shorter than length characters.

Parameters:

buf - the char array

offset - where in the array to start inserting the value

length - the desired length of the inserted string

value - the integer value to insert

copyToRequired

private void copyToRequired(int[] req)

Copy a list of required code points to template for checking

Parameters:

req - list of required codepoints

removeFromRequired

private void removeFromRequired(int codePoint)

Remove codepoint from required list

Parameters:

codePoint - - code point to be removed

checkRequired

private void checkRequired(int codePoint)
                    throws DRDAProtocolException

Check whether we have seen all the required code points

Parameters:

codePoint - code point for which list of code points is required

Throws:

DRDAProtocolException

tooMany

private void tooMany(int codePoint)
              throws DRDAProtocolException

Seen too many of this code point

Parameters:

codePoint - code point which has been duplicated

Throws:

DRDAProtocolException

tooBig

private void tooBig(int codePoint)
             throws DRDAProtocolException

Object too big

Parameters:

codePoint - code point with too big object

Throws:

DRDAProtocolException

invalidClient

private void invalidClient(String prdid)
                    throws DRDAProtocolException

Invalid non-derby client tried to connect. thrown a required Value not found error and log a message to derby.log

Parameters:

prdid - product id that does not match DNC

Throws:

DRDAProtocolException

requiredValueNotFound

private void requiredValueNotFound(int codePoint)
                            throws DRDAProtocolException

Required value not found.

Parameters:

codePoint - code point with invalid value

Throws:

DRDAProtocolException

badObjectLength

private void badObjectLength(int codePoint)
                      throws DRDAProtocolException

Object length not allowed

Parameters:

codePoint - code point with bad object length

Throws:

DRDAProtocolException

rdbNotFound

private void rdbNotFound(String rdbnam)
                  throws DRDAProtocolException

RDB not found

Parameters:

rdbnam - name of database

Throws:

DRDAProtocolException

invalidValue

private void invalidValue(int codePoint)
                   throws DRDAProtocolException

Invalid value for this code point

Parameters:

codePoint - code point value

Throws:

DRDAProtocolException

invalidCodePoint

protected void invalidCodePoint(int codePoint)
                         throws DRDAProtocolException

Invalid codepoint for this command

Parameters:

codePoint - code point value

Throws:

DRDAProtocolException

codePointNotSupported

protected void codePointNotSupported(int codePoint)
                              throws DRDAProtocolException

Don't support this code point

Parameters:

codePoint - code point value

Throws:

DRDAProtocolException

valueNotSupported

private void valueNotSupported(int codePoint)
                        throws DRDAProtocolException

Don't support this value

Parameters:

codePoint - code point value

Throws:

DRDAProtocolException

verifyRequiredObject

private void verifyRequiredObject(int codePoint,
 int reqCodePoint)
                           throws DRDAProtocolException

Verify that the code point is the required code point

Parameters:

codePoint - code point we have

reqCodePoint - code point required at this time

Throws:

DRDAProtocolException

verifyInOrderACCSEC_SECCHK

private void verifyInOrderACCSEC_SECCHK(int codePoint,
 int reqCodePoint)
                                 throws DRDAProtocolException

Verify that the code point is in the right order

Parameters:

codePoint - code point we have

reqCodePoint - code point required at this time

Throws:

DRDAProtocolException

rdbnamMismatch

private void rdbnamMismatch(int codePoint)
                     throws DRDAProtocolException

Database name given under code point doesn't match previous database names

Parameters:

codePoint - codepoint where the mismatch occurred

Throws:

DRDAProtocolException

closeSession

private void closeSession()

Close the current session

handleException

private void handleException(Exception e)

Handle Exceptions - write error protocol if appropriate and close session or thread as appropriate

sendProtocolException

private void sendProtocolException(DRDAProtocolException de)

Notice the client about a protocol error.

Parameters:

de - DRDAProtocolException to be sent

sendUnexpectedException

private void sendUnexpectedException(Exception e)

Send unpexpected error to the client

Parameters:

e - Exception to be sent

closed

private boolean closed()

Test if DRDA connection thread is closed

Returns:

true if close; false otherwise

getLogConnections

private boolean getLogConnections()

Get whether connections are logged

Returns:

true if connections are being logged; false otherwise

getTimeSlice

private long getTimeSlice()

Get time slice value for length of time to work on a session

Returns:

time slice

trace

protected void trace(String value)

Send string to console

Parameters:

value - - value to print on console

traceEXTDTARead

private void traceEXTDTARead(int drdaType,
 int index,
 EXTDTAReaderInputStream stream,
 boolean streamLOB,
 String encoding)

Sends a trace string to the console when reading an EXTDTA value (if tracing is enabled).

Parameters:

drdaType - the DRDA type of the EXTDTA value

index - the one-based parameter index

stream - the stream being read

streamLOB - whether or not the value is being streamed as the last parameter value in the DRDA protocol flow

encoding - the encoding of the data, if any

showmem

public static void showmem()

Show runtime memory

convertToHexString

private String convertToHexString(byte[] buf)

convert byte array to a Hex string

Parameters:

buf - buffer to convert

Returns:

hex string representation of byte array

checkValidTypDefNam

private void checkValidTypDefNam(String typdefnam)
                          throws DRDAProtocolException

check that the given typdefnam is acceptable

Parameters:

typdefnam -

Throws:

DRDAProtocolException

checkLength

private void checkLength(int codepoint,
 int reqlen)
                  throws DRDAProtocolException

Check that the length is equal to the required length for this codepoint

Parameters:

codepoint - codepoint we are checking

reqlen - required length

Throws:

DRDAProtocolException

readBoolean

private boolean readBoolean(int codepoint)
                     throws DRDAProtocolException

Read and check a boolean value

Parameters:

codepoint - codePoint to be used in error reporting

Returns:

true or false depending on boolean value read

Throws:

DRDAProtocolException

initializeDatabase

private void initializeDatabase(String dbname)

Create a new database and intialize the DRDAConnThread database.

Parameters:

dbname - database name to initialize. If dbnam is non null, add database to the current session

setDatabase

private void setDatabase(int codePoint)
                  throws DRDAProtocolException

Set the current database

Parameters:

codePoint - codepoint we are processing

Throws:

DRDAProtocolException

writeENDUOWRM

private void writeENDUOWRM(int opType)

Write ENDUOWRM Instance Variables SVCOD - severity code - WARNING - required UOWDSP - Unit of Work Disposition - required RDBNAM - Relational Database name - optional SRVDGN - Server Diagnostics information - optional

Parameters:

opType - - operation type 1 - commit, 2 -rollback

writeEXTDTA

void writeEXTDTA(DRDAStatement stmt)
          throws SQLException,
DRDAProtocolException

Throws:

SQLException

DRDAProtocolException

checkWarning

private void checkWarning(Connection conn,
 Statement stmt,
 ResultSet rs,
 long updateCount,
 boolean alwaysSend,
 boolean sendWarn)
                   throws DRDAProtocolException,
SQLException

Check SQLWarning and write SQLCARD as needed.

Parameters:

conn - connection to check

stmt - statement to check

rs - result set to check

updateCount - update count to include in SQLCARD

alwaysSend - whether always send SQLCARD regardless of the existance of warnings

sendWarn - whether to send any warnings or not.

Throws:

DRDAProtocolException

SQLException

hasSession

boolean hasSession()

getBytesRead

long getBytesRead()

getBytesWritten

long getBytesWritten()

buildRuntimeInfo

protected String buildRuntimeInfo(String indent,
 LocalizedResource localLangUtil)

finalizeChain

private void finalizeChain()
                    throws DRDAProtocolException

Finalize the current DSS chain and send it if needed.

Throws:

DRDAProtocolException

validateSecMecUSRSSBPWD

private int validateSecMecUSRSSBPWD()
                             throws DRDAProtocolException

Validate SECMEC_USRSSBPWD (Strong Password Substitute) can be used as DRDA security mechanism. Here we check that the target server can support SECMEC_USRSSBPWD security mechanism based on the environment, application requester's identity (PRDID) and connection URL. IMPORTANT NOTE: -------------- SECMEC_USRSSBPWD is ONLY supported by the target server if: - current authentication provider is Derby BUILTIN or NONE. (database / system level) (Phase I) - database-level password must have been encrypted with the SHA-1 based authentication scheme - Application requester is 'DNC' (Derby Network Client) (Phase I)

Returns:

security check code - 0 if everything O.K.

Throws:

DRDAProtocolException

closeStream

private static void closeStream(InputStream stream)
                         throws SQLException

Close a stream.

Parameters:

stream - the stream to close (possibly null)

Throws:

SQLException - wrapped around an IOException if closing the stream failed

convertAsByteArrayInputStream

private static InputStream convertAsByteArrayInputStream(EXTDTAReaderInputStream stream)
                                                  throws IOException

Throws:

IOException

setAsCharacterStream

private static void setAsCharacterStream(DRDAStatement stmt,
 int i,
 EXTDTAReaderInputStream extdtaStream,
 boolean streamLOB,
 String encoding)
                                  throws IOException,
SQLException

Sets the specified character EXTDTA parameter of the embedded statement.

Parameters:

stmt - the DRDA statement to use

i - the one-based index of the parameter

extdtaStream - the EXTDTA stream to read data from

streamLOB - whether or not the stream content is streamed as the last value in the DRDA protocol flow

encoding - the encoding of the EXTDTA stream

Throws:

IOException - if reading from the stream fails

SQLException - if setting the stream fails

setAsBinaryStream

private static void setAsBinaryStream(DRDAStatement stmt,
 int index,
 EXTDTAReaderInputStream stream,
 boolean streamLOB)
                               throws IOException,
SQLException

Sets the specified binary EXTDTA parameter of the embedded statement.

Parameters:

stmt - the DRDA statement to use

index - the one-based index of the parameter

stream - the EXTDTA stream to read data from

streamLOB - whether or not the stream content is streamed as the last value in the DRDA protocol flow

Throws:

IOException - if reading from the stream fails

SQLException - if setting the stream fails

getMonitor

private static ModuleFactory getMonitor()

Privileged Monitor lookup. Must be private so that user code can't call this entry point.

findService

private static Object findService(String factoryInterface,
 String serviceName)

Privileged service lookup. Must be private so that user code can't call this entry point.