src.com.ibm.as400.access.DBExtendedData Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk9 Show documentation
Show all versions of jt400-jdk9 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: DBExtendedData.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2001 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
/**
The DBExtendedData class is an implementation of DBData which
describes the data used in datastreams for V4R4 and later
systems.
**/
class DBExtendedData
implements DBData
{
private static final String copyright = "Copyright (C) 1997-2001 International Business Machines Corporation and others.";
// Private data.
private byte[] rawBytes_ = null;
private int offset_ = -1;
private int actualLength_ = -1; // @D0A
private boolean dataCompressed_ = false; // @D0A
private boolean vlfCompressed_ = false; // @K54
private int rowCount_ = -1;
private int columnCount_ = -1;
private int indicatorSize_ = -1;
private int rowSize_ = -1;
private int indicatorOffset_ = -1;
private int dataOffset_ = -1;
private int length_ = -1;
private int offsetToRowInformationHeader_ = -1;
private int offsetToRowInformationArray_ = -1;
private int aliasCount_ = 0;
/**
Constructs a DBExtendedData object. Use this when overlaying
on a reply datastream. The cached data will be set when overlay()
is called.
* @param actualLength
* @param dataCompressed
**/
public DBExtendedData (int actualLength, boolean dataCompressed) // @D0C
{
actualLength_ = actualLength; // @D0A
dataCompressed_ = dataCompressed; // @D0A
}
//@K54
/**
Constructs a DBExtendedData object. Use this when overlaying
on a reply datastream. The cached data will be set when overlay()
is called.
* @param actualLength
* @param dataCompressed
* @param vlfCompressed
**/
public DBExtendedData (int actualLength, boolean dataCompressed, boolean vlfCompressed)
{
actualLength_ = actualLength;
dataCompressed_ = dataCompressed;
vlfCompressed_ = vlfCompressed;
}
/**
Constructs a DBExtendedData object. Use this when overlaying
on a request datastream. This sets the cached data so that
the total length can be calculated before calling overlay().
* @param rowCount
* @param columnCount
* @param indicatorSize
* @param rowSize
* @throws DBDataStreamException If there is an error in the datastream.
**/
public DBExtendedData (int rowCount,
int columnCount,
int indicatorSize,
int rowSize)
throws DBDataStreamException
{
rowCount_ = rowCount;
columnCount_ = columnCount;
indicatorSize_ = indicatorSize;
rowSize_ = rowSize;
length_ = 20 + rowCount_ * (columnCount_ * indicatorSize_
+ rowSize_);
}
/**
Positions the overlay structure. This reads the cached data only
when it was not previously set by the constructor.
**/
public void overlay (byte[] rawBytes, int offset)
{
offset_ = offset;
if (rowCount_ == -1) {
rowCount_ = BinaryConverter.byteArrayToInt (rawBytes, offset_ + 4);
columnCount_ = BinaryConverter.byteArrayToShort (rawBytes, offset_ + 8);
indicatorSize_ = BinaryConverter.byteArrayToShort (rawBytes, offset_ + 10);
rowSize_ = BinaryConverter.byteArrayToInt (rawBytes, offset_ + 16);
length_ = 20 + rowCount_ * (columnCount_ * indicatorSize_ + rowSize_);
// If the data is compressed, then we need to uncompress it and store // @D0A
// it in a new byte array. Note that only the indicators and data are // @D0A
// compressed. // @D0A
if (dataCompressed_) { // @D0A
length_ = length_ + offset; //@E0A
byte[] decompressedBytes = new byte[length_]; // @D0A
System.arraycopy(rawBytes, 0, decompressedBytes, 0, offset_ + 20); // @D0A //@E0C
JDUtilities.decompress(rawBytes, offset_ + 20, actualLength_ - 26, // @D0A
decompressedBytes, offset_ + 20); // @D0A //@E0C
rawBytes_ = decompressedBytes; // @D0A
indicatorOffset_ = offset_ + 20; // @D0A //@E0C
} // @D0A
else { // @D0A
rawBytes_ = rawBytes;
indicatorOffset_ = offset_ + 20;
} // @D0A
//If the variable-length fields are compressed, then we need to know where each row starts //@K54
// Note: only the data is compressed //@K54
//Format is:
// Consistency Token 4 bytes (will match data format token for returned data, unused on parameter marker data)
// Row count 4 bytes (number of rows being sent. This must be 1 for the open function.)
// Column count 2 bytes (number of columns/parameter markers in 1 row)
// Indicator size 2 bytes (0 if no indicators, otherwise 2)
// Reserved 4 bytes
// Row size 4 bytes (size of 1 row in bytes)
// Indicators x bytes (x = column count * row count * Indicator size)
// *********** above remained unchanged *************
// Row Information Header:
// Row-Information-Array-Offset 4 bytes
// Number-of-rows-fetched 4 bytes
//
//
//
// Row Information Array:
// Offset-to-row-data(1) 4 bytes
// Offset-to-row-data(2) 4 bytes
// Offset-to-row-data(3) 4 bytes
if(vlfCompressed_){ //@K54
offsetToRowInformationHeader_ = indicatorOffset_ + (columnCount_ * rowCount_ * indicatorSize_);
//offset is calculated from the offset to Row Information header
offsetToRowInformationArray_ = offsetToRowInformationHeader_ + BinaryConverter.byteArrayToInt(rawBytes, offsetToRowInformationHeader_);
}
}
else {
rawBytes_ = rawBytes;
indicatorOffset_ = offset_ + 20;
setRowCount (rowCount_);
setColumnCount (columnCount_);
setIndicatorSize (indicatorSize_);
setRowSize (rowSize_);
initializeReserved(); /*@L3A*/
}
dataOffset_ = indicatorOffset_ + (rowCount_ * columnCount_ * indicatorSize_);
}
public int getLength ()
{
return length_;
}
public int getConsistencyToken ()
{
return BinaryConverter.byteArrayToInt (rawBytes_, offset_);
}
public int getRowCount ()
{
return rowCount_;
}
public int getColumnCount ()
{
return columnCount_;
}
public int getIndicatorSize ()
{
return indicatorSize_;
}
public int getRowSize ()
{
return rowSize_;
}
public int getIndicator (int rowIndex, int columnIndex)
{
if (indicatorSize_ == 0)
return 0;
else
return BinaryConverter.byteArrayToShort (rawBytes_,
indicatorOffset_ + indicatorSize_
* ((rowIndex + aliasCount_) * columnCount_ + columnIndex)); // If aliasCount_ > 0, then DatabaseMetaData.getTables(...) was called and our result data contains aliases. We want to skip the rows that are aliases.
}
/** the current offset_ value
* @return current offset value*/
//@K3A
public int getRawOffset() {
return offset_;
}
public int getRowDataOffset (int rowIndex)
{
//if variable-length fields are compressed return row offset
if(vlfCompressed_) //@K54
{
if((rowIndex >= rowCount_) || rowIndex < 0) //We do not have data for that row.
return -1;
else
return offsetToRowInformationHeader_ + BinaryConverter.byteArrayToInt(rawBytes_, offsetToRowInformationArray_ + (rowIndex*4));//return rowOffset_[rowIndex]; //@K54
}
else //@K54
{
return dataOffset_ + ((rowIndex + aliasCount_) * rowSize_); //If aliasCount_ > 0, then DatabaseMetaData.getTables(...) was called and our result data contains aliases. We want to skip the rows that are aliases.
}
}
public byte[] getRawBytes ()
{
return rawBytes_;
}
public void setConsistencyToken (int consistencyToken)
{
BinaryConverter.intToByteArray (consistencyToken, rawBytes_,
offset_);
}
/**
* Set the flag that variable length parameter marker input compression is used.
* @param b
*/
// @K3A
public void setParameterMarkerInputCompression(boolean b) {
if (b) {
rawBytes_[offset_ + 12] = -128; /* 0x80*/
} else {
rawBytes_[offset_ + 12] = -0;
}
}
/* @L3A*/
public void initializeReserved()
{
BinaryConverter.intToByteArray (0, rawBytes_,
offset_ + 12);
}
public void setRowCount (int rowCount)
{
BinaryConverter.intToByteArray (rowCount, rawBytes_,
offset_ + 4);
}
public void setColumnCount (int columnCount)
{
BinaryConverter.shortToByteArray ((short) columnCount, rawBytes_,
offset_ + 8);
}
public void setIndicatorSize (int indicatorSize)
{
BinaryConverter.shortToByteArray ((short) indicatorSize, rawBytes_,
offset_ + 10);
}
public void setRowSize (int rowSize)
{
BinaryConverter.intToByteArray (rowSize, rawBytes_,
offset_ + 16);
}
public void setIndicator (int rowIndex, int columnIndex, int indicator)
{
if (indicatorSize_ != 0)
BinaryConverter.shortToByteArray ((short) indicator,
rawBytes_,
indicatorOffset_ + indicatorSize_
* (rowIndex * columnCount_ + columnIndex));
}
//@K54
/*
Specifies if variable-length fields are compressed.
@return true if variable-length fields are compressed, false otherwise.
*/
public boolean isVariableFieldsCompressed()
{
return vlfCompressed_;
}
// Resets the number of rows to the total number of rows minus the number of rows that contain aliases.
// This method is called by AS400JDBCDatabaseMetaData.parseResultData().
public void resetRowCount(int rowCount){ //
rowCount_ = rowCount;
}
// Sets the number of aliases the result data contains.
// This method is called by AS400JDBCDatabaseMetaData.parseResultData().
public void setAliasCount(int aliases){ //
aliasCount_ = aliases;
}
//@array
//Returns indicator
public int getIndicator (int rowIndex, int columnIndex, int arrayIndex){
return -9999; //valid in DBVariableData
}
//@array
//returns size footprint of data in column
public int getDataTotalSize (int colIndex){
return -9999; //valid in DBVariableData
}
public void logInformation(String prefix) {
JDTrace.logInformation(this, prefix+"offset_="+offset_);
JDTrace.logInformation(this, prefix+"actualLength_="+actualLength_);
JDTrace.logInformation(this, prefix+"dataCompressed_="+dataCompressed_);
JDTrace.logInformation(this, prefix+"vlfCompressed_="+vlfCompressed_);
JDTrace.logInformation(this, prefix+"rowCount_="+rowCount_);
JDTrace.logInformation(this, prefix+"columnCount_="+columnCount_);
JDTrace.logInformation(this, prefix+"indicatorSize_="+indicatorSize_);
JDTrace.logInformation(this, prefix+"rowSize_="+rowSize_);
JDTrace.logInformation(this, prefix+"indicatorOffset_="+indicatorOffset_);
JDTrace.logInformation(this, prefix+"dataOffset_="+dataOffset_);
JDTrace.logInformation(this, prefix+"length_="+length_);
JDTrace.logInformation(this, prefix+"offsetToRowInformationHeader_="+offsetToRowInformationHeader_);
JDTrace.logInformation(this, prefix+"offsetToRowInformationArray_="+offsetToRowInformationArray_);
JDTrace.logInformation(this, prefix+"aliasCount_="+aliasCount_);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy