EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.client.net]

COVERAGE SUMMARY FOR SOURCE FILE [NetConnectionRequest.java]

nameclass, %method, %block, %line, %
NetConnectionRequest.java100% (1/1)56%  (29/52)73%  (375/513)74%  (123/167)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class NetConnectionRequest100% (1/1)56%  (29/52)73%  (375/513)74%  (123/167)
NetConnectionRequest (NetAgent, CcsidManager, int): void 100% (1/1)100% (6/6)100% (2/2)
buildACCRDB (String, boolean, byte [], byte [], Typdef): void 100% (1/1)100% (51/51)100% (14/14)
buildACCSEC (int, String, byte []): void 100% (1/1)84%  (16/19)88%  (7/8)
buildCRRTKN (byte []): void 100% (1/1)100% (5/5)100% (2/2)
buildDummyEXCSAT (): void 0%   (0/1)0%   (0/8)0%   (0/4)
buildEXCSAT (String, int, int, int, int, int, int, int, int, int): void 100% (1/1)100% (27/27)100% (9/9)
buildEXTNAM (String): void 100% (1/1)100% (13/13)100% (3/3)
buildMGRLVLLS (int, int, int, int, int, int, int): void 100% (1/1)82%  (37/45)86%  (12/14)
buildPASSWORD (String): void 100% (1/1)37%  (17/46)56%  (5/9)
buildPRDDTA (byte []): void 100% (1/1)100% (15/15)100% (3/3)
buildPRDID (): void 100% (1/1)100% (5/5)100% (2/2)
buildRDBACCCL (): void 100% (1/1)100% (5/5)100% (2/2)
buildRDBALWUPD (boolean): void 100% (1/1)43%  (3/7)67%  (2/3)
buildRDBCMM (): void 100% (1/1)100% (7/7)100% (3/3)
buildRDBNAM (String): void 100% (1/1)55%  (21/38)86%  (6/7)
buildRDBRLLBCK (): void 100% (1/1)100% (7/7)100% (3/3)
buildSECCHK (int, String, String, String, byte [], byte []): void 100% (1/1)82%  (28/34)86%  (12/14)
buildSECMEC (int): void 100% (1/1)100% (5/5)100% (2/2)
buildSECTKN (byte []): void 0%   (0/1)0%   (0/17)0%   (0/4)
buildSRVCLSNM (): void 100% (1/1)100% (5/5)100% (2/2)
buildSRVNAM (String): void 100% (1/1)100% (13/13)100% (3/3)
buildSRVRLSLV (): void 100% (1/1)100% (5/5)100% (2/2)
buildSYNCCTLCommit (int, Xid): void 0%   (0/1)0%   (0/1)0%   (0/1)
buildSYNCCTLMigrate (): void 0%   (0/1)0%   (0/1)0%   (0/1)
buildSYNCCTLRollback (int): void 0%   (0/1)0%   (0/1)0%   (0/1)
buildTYPDEFNAM (String): void 100% (1/1)100% (5/5)100% (2/2)
buildTYPDEFOVR (boolean, int, boolean, int, boolean, int): void 100% (1/1)100% (24/24)100% (9/9)
buildUSRID (String): void 100% (1/1)43%  (13/30)80%  (4/5)
writeAccessDatabase (String, boolean, byte [], byte [], Typdef): void 100% (1/1)100% (8/8)100% (2/2)
writeAccessSecurity (int, String, byte []): void 100% (1/1)100% (6/6)100% (2/2)
writeCommitSubstitute (NetConnection): void 0%   (0/1)0%   (0/3)0%   (0/2)
writeDummyExchangeServerAttributes (): void 0%   (0/1)0%   (0/3)0%   (0/2)
writeExchangeServerAttributes (String, int, int, int, int, int, int, int, int... 100% (1/1)100% (13/13)100% (2/2)
writeForget (int, int): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeLocalCommit (NetConnection): void 100% (1/1)100% (3/3)100% (2/2)
writeLocalRollback (NetConnection): void 100% (1/1)100% (3/3)100% (2/2)
writeLocalXACommit (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeLocalXARollback (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeLocalXAStart (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeNullXID (int): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeReleaseConversation (int, int): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeSYNCType (int, int): void 0%   (0/1)0%   (0/5)0%   (0/2)
writeSecurityCheck (int, String, String, String, byte [], byte []): void 100% (1/1)100% (9/9)100% (2/2)
writeXAFlags (int, int): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXID (int, Xid): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaCommit (NetConnection, Xid): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaEndUnitOfWork (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaForget (NetConnection, Xid): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaPrepare (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaRecover (NetConnection, int): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaRollback (NetConnection, Xid): void 0%   (0/1)0%   (0/1)0%   (0/1)
writeXaStartUnitOfWork (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)

1/*
2 
3   Derby - Class org.apache.derby.client.net.NetConnectionRequest
4 
5   Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors, where applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19*/
20 
21package org.apache.derby.client.net;
22 
23 
24import javax.transaction.xa.Xid;
25 
26import org.apache.derby.client.am.SqlException;
27import org.apache.derby.client.am.ClientMessageId;
28import org.apache.derby.client.am.Utils;
29import org.apache.derby.shared.common.reference.SQLState;
30 
31public class NetConnectionRequest extends Request implements ConnectionRequestInterface {
32    NetConnectionRequest(NetAgent netAgent, CcsidManager ccsidManager, int bufferSize) {
33        super(netAgent, ccsidManager, bufferSize);
34    }
35    //----------------------------- entry points ---------------------------------
36 
37    void writeExchangeServerAttributes(String externalName,
38                                       int targetAgent,
39                                       int targetSqlam,
40                                       int targetRdb,
41                                       int targetSecmgr,
42                                       int targetCmntcpip,
43                                       int targetCmnappc,
44                                       int targetXamgr,
45                                       int targetSyncptmgr,
46                                       int targetRsyncmgr) throws SqlException {
47        // send the exchange server attributes command to the server.
48        // no other commands will be chained to the excsat because
49        // the manager levels are needed before anything else is attempted.
50        buildEXCSAT(externalName,
51                targetAgent,
52                targetSqlam,
53                targetRdb,
54                targetSecmgr,
55                targetCmntcpip,
56                targetCmnappc,
57                targetXamgr,
58                targetSyncptmgr,
59                targetRsyncmgr);
60 
61    }
62 
63    void writeDummyExchangeServerAttributes() throws SqlException {
64        // send the exchange server attributes command to the server,
65        // without any parameters
66        buildDummyEXCSAT();
67    }
68 
69    void writeAccessSecurity(int securityMechanism,
70                             String databaseName,
71                             byte[] publicKey) throws SqlException {
72        buildACCSEC(securityMechanism, databaseName, publicKey);
73    }
74 
75    void writeSecurityCheck(int securityMechanism,
76                            String databaseName,
77                            String userid,
78                            String password,
79                            byte[] encryptedUserid,
80                            byte[] encryptedPassword) throws SqlException {
81        buildSECCHK(securityMechanism,
82                databaseName,
83                userid,
84                password,
85                encryptedUserid,
86                encryptedPassword);
87    }
88 
89    void writeAccessDatabase(String rdbnam,
90                             boolean readOnly,
91                             byte[] correlationToken,
92                             byte[] productData,
93                             Typdef typdef) throws SqlException {
94        buildACCRDB(rdbnam,
95                readOnly,
96                correlationToken,
97                productData,
98                typdef);
99    }
100 
101 
102    public void writeCommitSubstitute(NetConnection connection) throws SqlException {
103        buildDummyEXCSAT();
104    }
105 
106    public void writeLocalCommit(NetConnection connection) throws SqlException {
107        buildRDBCMM();
108    }
109 
110    public void writeLocalRollback(NetConnection connection) throws SqlException {
111        buildRDBRLLBCK();
112    }
113 
114    public void writeLocalXAStart(NetConnection connection) throws SqlException {
115    }
116 
117 
118    //Build the SYNNCTL commit command
119    public void writeLocalXACommit(NetConnection conn) throws SqlException {
120    }
121 
122    //Build the SYNNCTL rollback command
123    public void writeLocalXARollback(NetConnection conn) throws SqlException {
124    }
125 
126    public void writeXaStartUnitOfWork(NetConnection conn) throws SqlException {
127    }
128 
129    public void writeXaEndUnitOfWork(NetConnection conn) throws SqlException {
130    }
131 
132    protected void writeXaPrepare(NetConnection conn) throws SqlException {
133    }
134 
135    protected void writeXaCommit(NetConnection conn, Xid xid) throws SqlException {
136    }
137 
138    protected void writeXaRollback(NetConnection conn, Xid xid) throws SqlException {
139    }
140 
141    protected void writeXaRecover(NetConnection conn, int flag) throws SqlException {
142    }
143 
144    protected void writeXaForget(NetConnection conn, Xid xid) throws SqlException {
145    }
146 
147    public void writeSYNCType(int codepoint, int syncType) {
148        writeScalar1Byte(codepoint, syncType);
149    }
150 
151    public void writeForget(int codepoint, int value) {
152    }
153 
154    public void writeReleaseConversation(int codepoint, int value) {
155    }
156 
157    void writeNullXID(int codepoint) {
158    }
159 
160    void writeXID(int codepoint, Xid xid) throws SqlException {
161    }
162 
163 
164    void writeXAFlags(int codepoint, int xaFlags) {
165    }
166 
167 
168    //----------------------helper methods----------------------------------------
169    // These methods are "private protected", which is not a recognized java privilege,
170    // but means that these methods are private to this class and to subclasses,
171    // and should not be used as package-wide friendly methods.
172 
173    // RDB Commit Unit of Work (RDBCMM) Command commits all work performed
174    // for the current unit of work.
175    //
176    // The Relational Database Name (RDBNAM) is an optional parameter
177    // which will not be sent by this command to reduce size, building,
178    // and parsing.
179    void buildRDBCMM() throws SqlException {
180        createCommand();
181        writeLengthCodePoint(0x04, CodePoint.RDBCMM);
182    }
183 
184    // RDB Rollback Unit of Work(RDBRLLBCK) Command rolls back
185    // all work performed for the current unit of work.
186    //
187    // The Relational Database Name (RDBNAM) is an optional parameter
188    // which will not be sent by this command to reduce size, building,
189    // and parsing.
190    void buildRDBRLLBCK() throws SqlException {
191        createCommand();
192        writeLengthCodePoint(0x04, CodePoint.RDBRLLBCK);
193    }
194 
195    // build the Exchange Server Attributes Command.
196    // This command sends the following information to the server.
197    // - this driver's server class name
198    // - this driver's level of each of the manager's it supports
199    // - this driver's product release level
200    // - this driver's external name
201    // - this driver's server name
202    void buildEXCSAT(String externalName,
203                     int targetAgent,
204                     int targetSqlam,
205                     int targetRdb,
206                     int targetSecmgr,
207                     int targetCmntcpip,
208                     int targetCmnappc,
209                     int targetXamgr,
210                     int targetSyncptmgr,
211                     int targetRsyncmgr) throws SqlException {
212        createCommand();
213 
214        // begin excsat collection by placing the 4 byte llcp in the buffer.
215        // the length of this command will be computed later and "filled in"
216        // with the call to request.updateLengthBytes().
217        markLengthBytes(CodePoint.EXCSAT);
218 
219        // place the external name for the client into the buffer.
220        // the external name was previously calculated before the call to this method.
221        buildEXTNAM(externalName);
222 
223        // place the server name for the client into the buffer.
224        buildSRVNAM("Derby");
225 
226        // place the server release level for the client into the buffer.
227        // this is a hard coded value for the driver.
228        buildSRVRLSLV();
229 
230        // the managers supported by this driver and their levels will
231        // be sent to the server.  the variables which store these values
232        // were initialized during object constrcution to the highest values
233        // supported by the driver.
234 
235        // for the case of the manager levels object, there is no
236        // need to have the length of the ddm object dynamically calculated
237        // because this method knows exactly how many will be sent and can set
238        // this now.
239        // each manager level class and level are 4 bytes long and
240        // right now 5 are being sent for a total of 20 bytes or 0x14 bytes.
241        // writeScalarHeader will be called to insert the llcp.
242        buildMGRLVLLS(targetAgent,
243                targetSqlam,
244                targetRdb,
245                targetSecmgr,
246                targetXamgr,
247                targetSyncptmgr,
248                targetRsyncmgr);
249 
250 
251        // place the server class name into the buffer.
252        // this value is hard coded for the driver.
253        buildSRVCLSNM();
254 
255        // the excsat command is complete so the updateLengthBytes method
256        // is called to dynamically compute the length for this command and insert
257        // it into the buffer
258        updateLengthBytes();
259    }
260 
261    void buildDummyEXCSAT() throws SqlException {
262        createCommand();
263 
264        // begin excsat collection by placing the 4 byte llcp in the buffer.
265        // the length of this command will be computed later and "filled in"
266        // with the call to request.updateLengthBytes().
267        markLengthBytes(CodePoint.EXCSAT);
268 
269        // the excsat command is complete so the updateLengthBytes method
270        // is called to dynamically compute the length for this command and insert
271        // it into the buffer
272        updateLengthBytes();
273    }
274 
275    void buildACCSEC(int secmec,
276                     String rdbnam,
277                     byte[] sectkn) throws SqlException {
278        createCommand();
279 
280        // place the llcp for the ACCSEC in the buffer.  save the length bytes for
281        // later update
282        markLengthBytes(CodePoint.ACCSEC);
283 
284        // the security mechanism is a required instance variable.  it will
285        // always be sent.
286        buildSECMEC(secmec);
287 
288        // the rdbnam will be built and sent.  different sqlam levels support
289        // different lengths.  at this point the length has been checked against
290        // the maximum allowable length.  so write the bytes and padd up to the
291        // minimum length if needed.
292        buildRDBNAM(rdbnam);
293 
294        if (sectkn != null) {
295            buildSECTKN(sectkn);
296        }
297 
298        // the accsec command is complete so notify the the request object to
299        // update the ddm length and the dss header length.
300        updateLengthBytes();
301    }
302 
303    void buildSECCHK(int secmec,
304                     String rdbnam,
305                     String user,
306                     String password,
307                     byte[] sectkn,
308                     byte[] sectkn2) throws SqlException {
309        createCommand();
310        markLengthBytes(CodePoint.SECCHK);
311 
312        // always send the negotiated security mechanism for the connection.
313        buildSECMEC(secmec);
314 
315        // the rdbnam will be built and sent.  different sqlam levels support
316        // different lengths.  at this point the length has been checked against
317        // the maximum allowable length.  so write the bytes and padd up to the
318        // minimum length if needed.
319        buildRDBNAM(rdbnam);
320        if (user != null) {
321            buildUSRID(user);
322        }
323        if (password != null) {
324            buildPASSWORD(password);
325        }
326        if (sectkn != null) {
327            buildSECTKN(sectkn);
328        }
329        if (sectkn2 != null) {
330            buildSECTKN(sectkn2);
331        }
332        updateLengthBytes();
333 
334    }
335 
336    // The Access RDB (ACCRDB) command makes a named relational database (RDB)
337    // available to a requester by creating an instance of an SQL application
338    // manager.  The access RDB command then binds the created instance to the target
339    // agent and to the RDB. The RDB remains available (accessed) until
340    // the communications conversation is terminate.
341    void buildACCRDB(String rdbnam,
342                     boolean readOnly,
343                     byte[] crrtkn,
344                     byte[] prddta,
345                     Typdef typdef) throws SqlException {
346        createCommand();
347 
348        markLengthBytes(CodePoint.ACCRDB);
349 
350        // the relational database name specifies the name of the rdb to
351        // be accessed.  this can be different sizes depending on the level of
352        // support.  the size will have ben previously checked so at this point just
353        // write the data and pad with the correct number of bytes as needed.
354        // this instance variable is always required.
355        buildRDBNAM(rdbnam);
356 
357        // the rdb access manager class specifies an instance of the SQLAM
358        // that accesses the RDB.  the sqlam manager class codepoint
359        // is always used/required for this.  this instance variable
360        // is always required.
361        buildRDBACCCL();
362 
363        // product specific identifier specifies the product release level
364        // of this driver.  see the hard coded value in the NetConfiguration class.
365        // this instance variable is always required.
366        buildPRDID();
367 
368        // product specific data.  this is an optional parameter which carries
369        // product specific information.  although it is optional, it will be
370        // sent to the server.  use the first byte to determine the number
371        // of the prddta bytes to write to the buffer. note: this length
372        // doesn't include itself so increment by it by 1 to get the actual
373        // length of this data.
374        buildPRDDTA(prddta);
375 
376 
377        // the typdefnam parameter specifies the name of the data type to data representation
378        // mappings used when this driver sends command data objects.
379        buildTYPDEFNAM(typdef.getTypdefnam());
380 
381        if (crrtkn == null) {
382            netAgent_.netConnection_.constructCrrtkn();
383        }
384 
385        buildCRRTKN(netAgent_.netConnection_.crrtkn_);
386 
387        // This specifies the single-byte, double-byte
388        // and mixed-byte CCSIDs of the Scalar Data Arrays (SDAs) in the identified
389        // data type to the data representation mapping definitions.  This can
390        // contain 3 CCSIDs.  The driver will only send the ones which were set.
391        buildTYPDEFOVR(typdef.isCcsidSbcSet(),
392                typdef.getCcsidSbc(),
393                typdef.isCcsidDbcSet(),
394                typdef.getCcsidDbc(),
395                typdef.isCcsidMbcSet(),
396                typdef.getCcsidMbc());
397 
398        // RDB allow update is an optional parameter which indicates
399        // whether the RDB allows the requester to perform update operations
400        // in the RDB.  If update operations are not allowed, this connection
401        // is limited to read-only access of the RDB resources.
402        buildRDBALWUPD(readOnly);
403 
404 
405 
406        // the Statement Decimal Delimiter (STTDECDEL),
407        // Statement String Delimiter (STTSTRDEL),
408        // and Target Default Value Return (TRGDFTRT) are all optional
409        // instance variables which will not be sent to the server.
410 
411        // the command and the dss are complete so make the call to notify
412        // the request object.
413        updateLengthBytes();
414    }
415 
416 
417    void buildSYNCCTLMigrate() throws SqlException {
418    }
419 
420    void buildSYNCCTLCommit(int xaFlags, Xid xid) throws SqlException {
421    }
422 
423    void buildSYNCCTLRollback(int xaFlags) throws SqlException {
424    }
425 
426 
427    // The External Name is the name of the job, task, or process on a
428    // system for which a DDM server is active.
429    private void buildEXTNAM(String extnam) throws SqlException {
430        int extnamTruncateLength = Utils.min(extnam.length(),
431                NetConfiguration.EXTNAM_MAXSIZE);
432 
433        writeScalarString(CodePoint.EXTNAM,
434                extnam.substring(0, extnamTruncateLength));
435    }
436 
437    // Server Name is the name of the DDM server.
438    private void buildSRVNAM(String srvnam) throws SqlException {
439        int srvnamTruncateLength = Utils.min(srvnam.length(),
440                NetConfiguration.SRVNAM_MAXSIZE);
441        writeScalarString(CodePoint.SRVNAM,
442                srvnam.substring(0, srvnamTruncateLength));
443    }
444 
445    // Server Product Release Level String specifies the product
446    // release level of a DDM server.
447    private void buildSRVRLSLV() throws SqlException {
448        // Hard-coded to ClientDNC 1.0 for dnc 1.0.
449        writeScalarString(CodePoint.SRVRLSLV, NetConfiguration.SRVRLSLV);
450    }
451 
452    private void buildSRVCLSNM() throws SqlException {
453        // Server class name is hard-coded to QDERBY/JVM for dnc.
454        writeScalarString(CodePoint.SRVCLSNM, NetConfiguration.SRVCLSNM_JVM);
455    }
456 
457    // Precondition: valid secmec is assumed.
458    private void buildSECMEC(int secmec) throws SqlException {
459        writeScalar2Bytes(CodePoint.SECMEC, secmec);
460    }
461 
462    // Relational Database Name specifies the name of a relational database
463    // of the server.
464    // if length of RDB name <= 18 characters, there is not change to the format
465    // of the RDB name.  The length of the RDBNAM remains fixed at 18 which includes
466    // any right bland padding if necessary.
467    // if length of the RDB name is > 18 characters, the length of the RDB name is
468    // identical to the length of the RDB name.  No right blank padding is required.
469    private void buildRDBNAM(String rdbnam) throws SqlException {
470        // since this gets built more than once on the connect flow,
471        // see if we can optimize
472 
473        int rdbnamLength = rdbnam.length();
474        if (rdbnamLength <= NetConfiguration.PKG_IDENTIFIER_FIXED_LEN) {
475            writeScalarPaddedString(CodePoint.RDBNAM,
476                    rdbnam,
477                    NetConfiguration.PKG_IDENTIFIER_FIXED_LEN);  // minimum length of RDBNAM
478        } else {
479            if (rdbnamLength <= NetConfiguration.PKG_IDENTIFIER_MAX_LEN) {
480                writeScalarString(CodePoint.RDBNAM, rdbnam);
481            } else {
482                throw new SqlException(netAgent_.logWriter_, 
483                    new ClientMessageId(SQLState.NET_DBNAME_TOO_LONG), rdbnam);
484            }
485            //"at SQLAM level " + netAgent_.targetSqlam_);
486        }
487    }
488 
489    private void buildSECTKN(byte[] sectkn) throws SqlException {
490        if (sectkn.length > NetConfiguration.SECTKN_MAXSIZE) {
491            throw new SqlException(netAgent_.logWriter_, 
492                new ClientMessageId(SQLState.NET_SECTKN_TOO_LONG));
493        }
494        writeScalarBytes(CodePoint.SECTKN, sectkn);
495    }
496 
497    private void buildUSRID(String usrid) throws SqlException {
498        int usridLength = usrid.length();
499        if ((usridLength == 0) || (usridLength > NetConfiguration.USRID_MAXSIZE)) {
500            throw new SqlException(netAgent_.logWriter_, 
501                new ClientMessageId(SQLState.NET_USERID_TOO_LONG));
502        }
503 
504        writeScalarString(CodePoint.USRID, usrid);
505    }
506 
507    private void buildPASSWORD(String password) throws SqlException {
508        int passwordLength = password.length();
509        if ((passwordLength == 0) || (passwordLength > NetConfiguration.PASSWORD_MAXSIZE)) {
510            throw new SqlException(netAgent_.logWriter_, 
511                new ClientMessageId(SQLState.NET_PASSWORD_TOO_LONG));
512        }
513        if (netAgent_.logWriter_ != null) {
514            // remember the position of password in order to
515            // mask it out in trace (see Request.sendBytes()).
516            passwordIncluded_ = true;
517            passwordStart_ = offset_ + 4;
518            passwordLength_ = passwordLength;
519        }
520        writeScalarString(CodePoint.PASSWORD, password);
521    }
522 
523    private void buildRDBACCCL() throws SqlException {
524        writeScalar2Bytes(CodePoint.RDBACCCL, CodePoint.SQLAM);
525    }
526 
527 
528    private void buildPRDID() throws SqlException {
529        writeScalarString(CodePoint.PRDID, NetConfiguration.PRDID);  // product id is hard-coded to DNC01000 for dnc 1.0.
530    }
531 
532    private void buildPRDDTA(byte[] prddta) throws SqlException {
533        int prddtaLength = (prddta[NetConfiguration.PRDDTA_LEN_BYTE] & 0xff) + 1;
534        writeScalarBytes(CodePoint.PRDDTA, prddta, 0, prddtaLength);
535    }
536 
537    private void buildTYPDEFNAM(String typdefnam) throws SqlException {
538        writeScalarString(CodePoint.TYPDEFNAM, typdefnam);
539    }
540 
541    void buildTYPDEFOVR(boolean sendCcsidSbc,
542                        int ccsidSbc,
543                        boolean sendCcsidDbc,
544                        int ccsidDbc,
545                        boolean sendCcsidMbc,
546                        int ccsidMbc) throws SqlException {
547        markLengthBytes(CodePoint.TYPDEFOVR);
548        // write the single-byte ccsid used by this driver.
549        if (sendCcsidSbc) {
550            writeScalar2Bytes(CodePoint.CCSIDSBC, ccsidSbc);
551        }
552 
553        // write the double-byte ccsid used by this driver.
554        if (sendCcsidDbc) {
555            writeScalar2Bytes(CodePoint.CCSIDDBC, ccsidDbc);
556        }
557 
558        // write the mixed-byte ccsid used by this driver
559        if (sendCcsidMbc) {
560            writeScalar2Bytes(CodePoint.CCSIDMBC, ccsidMbc);
561        }
562 
563        updateLengthBytes();
564 
565    }
566 
567    private void buildMGRLVLLS(int agent,
568                               int sqlam,
569                               int rdb,
570                               int secmgr,
571                               int xamgr,
572                               int syncptmgr,
573                               int rsyncmgr) throws SqlException {
574        markLengthBytes(CodePoint.MGRLVLLS);
575 
576        // place the managers and their levels in the buffer
577        writeCodePoint4Bytes(CodePoint.AGENT, agent);
578        writeCodePoint4Bytes(CodePoint.SQLAM, sqlam);
579        writeCodePoint4Bytes(CodePoint.RDB, rdb);
580        writeCodePoint4Bytes(CodePoint.SECMGR, secmgr);
581 
582        if (netAgent_.netConnection_.isXAConnection()) {
583            if (xamgr != NetConfiguration.MGRLVL_NA) {
584                writeCodePoint4Bytes(CodePoint.XAMGR, xamgr);
585            }
586            if (syncptmgr != NetConfiguration.MGRLVL_NA) {
587                writeCodePoint4Bytes(CodePoint.SYNCPTMGR, syncptmgr);
588            }
589            if (rsyncmgr != NetConfiguration.MGRLVL_NA) {
590                writeCodePoint4Bytes(CodePoint.RSYNCMGR, rsyncmgr);
591            }
592        }
593        updateLengthBytes();
594    }
595 
596    private void buildCRRTKN(byte[] crrtkn) throws SqlException {
597        writeScalarBytes(CodePoint.CRRTKN, crrtkn);
598    }
599 
600    private void buildRDBALWUPD(boolean readOnly) throws SqlException {
601        if (readOnly) {
602            writeScalar1Byte(CodePoint.RDBALWUPD, CodePoint.FALSE);
603        }
604    }
605 
606}
607 
608 
609 

[all classes][org.apache.derby.client.net]
EMMA 2.0.5312 (C) Vladimir Roubtsov