/* Copyright (c) 2001-2010, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hsqldb.persist;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import org.hsqldb.Database;
import org.hsqldb.DatabaseURL;
import org.hsqldb.HsqlException;
import org.hsqldb.HsqlNameManager.HsqlName;
import org.hsqldb.Session;
import org.hsqldb.Statement;
import org.hsqldb.Table;
import org.hsqldb.error.Error;
import org.hsqldb.error.ErrorCode;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.HashMappedList;
import org.hsqldb.lib.LineGroupReader;
import org.hsqldb.navigator.RowSetNavigator;
import org.hsqldb.result.Result;
import org.hsqldb.result.ResultLob;
import org.hsqldb.result.ResultMetaData;
import org.hsqldb.result.ResultProperties;
import org.hsqldb.store.ValuePool;
import org.hsqldb.types.BlobData;
import org.hsqldb.types.BlobDataID;
import org.hsqldb.types.ClobData;
import org.hsqldb.types.ClobDataID;
import org.hsqldb.types.Types;
/**
* @author Fred Toussi (fredt@users dot sourceforge.net)
* @version 1.9.0
* @since 1.9.0
*/
public class LobManager {
static final String resourceFileName =
"/org/hsqldb/resources/lob-schema.sql";
static final String[] starters = new String[]{ "/*" };
//
Database database;
LobStore lobStore;
Session sysLobSession;
//
//
int lobBlockSize;
int totalBlockLimitCount = Integer.MAX_VALUE;
//
int deletedLobCount;
//
Statement getLob;
Statement getLobPart;
Statement deleteLobCall;
Statement deleteLobPartCall;
Statement divideLobPartCall;
Statement createLob;
Statement createLobPartCall;
Statement updateLobLength;
Statement updateLobUsage;
Statement getNextLobId;
Statement deleteUnusedLobs;
Statement getLobCount;
// LOBS columns
private interface LOBS {
int BLOCK_ADDR = 0;
int BLOCK_COUNT = 1;
int BLOCK_OFFSET = 2;
int LOB_ID = 3;
}
private interface LOB_IDS {
int LOB_ID = 0;
int LOB_LENGTH = 1;
int LOB_USAGE_COUNT = 2;
int LOB_TYPE = 3;
}
private interface GET_LOB_PART {
int LOB_ID = 0;
int BLOCK_OFFSET = 1;
int BLOCK_LIMIT = 2;
}
private interface DIVIDE_BLOCK {
int BLOCK_OFFSET = 0;
int LOB_ID = 1;
}
private interface DELETE_BLOCKS {
int LOB_ID = 0;
int BLOCK_OFFSET = 1;
int BLOCK_LIMIT = 2;
int TX_ID = 3;
}
private interface ALLOC_BLOCKS {
int BLOCK_COUNT = 0;
int BLOCK_OFFSET = 1;
int LOB_ID = 2;
}
private interface UPDATE_USAGE {
int BLOCK_COUNT = 0;
int LOB_ID = 1;
}
private interface UPDATE_LENGTH {
int LOB_LENGTH = 0;
int LOB_ID = 1;
}
//BLOCK_ADDR INT, BLOCK_COUNT INT, TX_ID BIGINT
private static String initialiseBlocksSQL =
"INSERT INTO SYSTEM_LOBS.BLOCKS VALUES(?,?,?)";
private static String getLobSQL =
"SELECT * FROM SYSTEM_LOBS.LOB_IDS WHERE LOB_ID = ?";
private static String getLobPartSQL =
"SELECT * FROM SYSTEM_LOBS.LOBS WHERE LOB_ID = ? AND BLOCK_OFFSET + BLOCK_COUNT > ? AND BLOCK_OFFSET < ? ORDER BY BLOCK_OFFSET";
private static String deleteLobPartCallSQL =
"CALL SYSTEM_LOBS.DELETE_BLOCKS(?,?,?,?)";
private static String createLobSQL =
"INSERT INTO SYSTEM_LOBS.LOB_IDS VALUES(?, ?, ?, ?)";
private static String updateLobLengthSQL =
"UPDATE SYSTEM_LOBS.LOB_IDS SET LOB_LENGTH = ? WHERE LOB_ID = ?";
private static String createLobPartCallSQL =
"CALL SYSTEM_LOBS.ALLOC_BLOCKS(?, ?, ?)";
private static String divideLobPartCallSQL =
"CALL SYSTEM_LOBS.DIVIDE_BLOCK(?, ?)";
private static String getSpanningBlockSQL =
"SELECT * FROM SYSTEM_LOBS.LOBS WHERE LOB_ID = ? AND ? > BLOCK_OFFSET AND ? < BLOCK_OFFSET + BLOCK_COUNT";
private static String updateLobUsageSQL =
"UPDATE SYSTEM_LOBS.LOB_IDS SET LOB_USAGE_COUNT = ? WHERE LOB_ID = ?";
private static String getNextLobIdSQL =
"VALUES NEXT VALUE FOR SYSTEM_LOBS.LOB_ID";
private static String deleteLobCallSQL =
"CALL SYSTEM_LOBS.DELETE_LOB(?, ?)";
private static String deleteUnusedCallSQL =
"CALL SYSTEM_LOBS.DELETE_UNUSED()";
private static String getLobCountSQL =
"SELECT COUNT(*) FROM SYSTEM_LOBS.LOB_IDS";
public LobManager(Database database) {
this.database = database;
}
synchronized public void createSchema() {
sysLobSession = database.sessionManager.getSysLobSession();
InputStream fis = getClass().getResourceAsStream(resourceFileName);
InputStreamReader reader = null;
try {
reader = new InputStreamReader(fis, "ISO-8859-1");
} catch (Exception e) {}
LineNumberReader lineReader = new LineNumberReader(reader);
LineGroupReader lg = new LineGroupReader(lineReader, starters);
HashMappedList map = lg.getAsMap();
lg.close();
String sql = (String) map.get("/*lob_schema_definition*/");
Statement statement = sysLobSession.compileStatement(sql,
ResultProperties.defaultPropsValue);
Result result = statement.execute(sysLobSession);
if (result.isError()) {
throw result.getException();
}
HsqlName name =
database.schemaManager.getSchemaHsqlName("SYSTEM_LOBS");
Table table = database.schemaManager.getTable(sysLobSession, "BLOCKS",
"SYSTEM_LOBS");
getLob = sysLobSession.compileStatement(getLobSQL,
ResultProperties.defaultPropsValue);
getLobPart = sysLobSession.compileStatement(getLobPartSQL,
ResultProperties.defaultPropsValue);
createLob = sysLobSession.compileStatement(createLobSQL,
ResultProperties.defaultPropsValue);
createLobPartCall =
sysLobSession.compileStatement(createLobPartCallSQL,
ResultProperties.defaultPropsValue);
divideLobPartCall =
sysLobSession.compileStatement(divideLobPartCallSQL,
ResultProperties.defaultPropsValue);
deleteLobCall = sysLobSession.compileStatement(deleteLobCallSQL,
ResultProperties.defaultPropsValue);
deleteLobPartCall =
sysLobSession.compileStatement(deleteLobPartCallSQL,
ResultProperties.defaultPropsValue);
updateLobLength = sysLobSession.compileStatement(updateLobLengthSQL,
ResultProperties.defaultPropsValue);
updateLobUsage = sysLobSession.compileStatement(updateLobUsageSQL,
ResultProperties.defaultPropsValue);
getNextLobId = sysLobSession.compileStatement(getNextLobIdSQL,
ResultProperties.defaultPropsValue);
deleteUnusedLobs = sysLobSession.compileStatement(deleteUnusedCallSQL,
ResultProperties.defaultPropsValue);
getLobCount = sysLobSession.compileStatement(getLobCountSQL,
ResultProperties.defaultPropsValue);
}
synchronized public void initialiseLobSpace() {
Statement statement =
sysLobSession.compileStatement(initialiseBlocksSQL,
ResultProperties.defaultPropsValue);
Object[] params = new Object[3];
params[0] = ValuePool.INTEGER_0;
params[1] = ValuePool.getInt(totalBlockLimitCount);
params[2] = ValuePool.getLong(0);
sysLobSession.executeCompiledStatement(statement, params);
}
synchronized public void open() {
if (lobStore != null) {
return;
}
lobBlockSize = database.logger.getLobBlockSize();
if (database.getType() == DatabaseURL.S_RES) {
lobStore = new LobStoreInJar(database, lobBlockSize);
} else if (database.getType() == DatabaseURL.S_FILE) {
lobStore = new LobStoreRAFile(database, lobBlockSize);
} else {
lobStore = new LobStoreMem(lobBlockSize);
}
}
synchronized public void close() {
lobStore.close();
}
LobStore getLobStore() {
if (lobStore == null) {
open();
}
return lobStore;
}
//
private long getNewLobID() {
Result result = getNextLobId.execute(sysLobSession);
if (result.isError()) {
return 0;
}
RowSetNavigator navigator = result.getNavigator();
boolean next = navigator.next();
if (!next) {
navigator.close();
return 0;
}
Object[] data = navigator.getCurrent();
return ((Long) data[0]).longValue();
}
private Object[] getLobHeader(long lobID) {
ResultMetaData meta = getLob.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[0] = ValuePool.getLong(lobID);
sysLobSession.sessionContext.pushDynamicArguments(params);
Result result = getLob.execute(sysLobSession);
sysLobSession.sessionContext.pop();
if (result.isError()) {
return null;
}
RowSetNavigator navigator = result.getNavigator();
boolean next = navigator.next();
if (!next) {
navigator.close();
return null;
}
Object[] data = navigator.getCurrent();
return data;
}
synchronized public BlobData getBlob(long lobID) {
Object[] data = getLobHeader(lobID);
if (data == null) {
return null;
}
BlobData blob = new BlobDataID(lobID);
return blob;
}
synchronized public ClobData getClob(long lobID) {
Object[] data = getLobHeader(lobID);
if (data == null) {
return null;
}
ClobData clob = new ClobDataID(lobID);
return clob;
}
synchronized public long createBlob(long length) {
long lobID = getNewLobID();
ResultMetaData meta = createLob.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[LOB_IDS.LOB_ID] = ValuePool.getLong(lobID);
params[LOB_IDS.LOB_LENGTH] = ValuePool.getLong(length);
params[LOB_IDS.LOB_USAGE_COUNT] = ValuePool.INTEGER_0;
params[LOB_IDS.LOB_TYPE] = ValuePool.getInt(Types.SQL_BLOB);
Result result = sysLobSession.executeCompiledStatement(createLob,
params);
return lobID;
}
synchronized public long createClob(long length) {
long lobID = getNewLobID();
ResultMetaData meta = createLob.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[LOB_IDS.LOB_ID] = ValuePool.getLong(lobID);
params[LOB_IDS.LOB_LENGTH] = ValuePool.getLong(length);
params[LOB_IDS.LOB_USAGE_COUNT] = ValuePool.INTEGER_0;
params[LOB_IDS.LOB_TYPE] = ValuePool.getInt(Types.SQL_CLOB);
Result result = sysLobSession.executeCompiledStatement(createLob,
params);
return lobID;
}
synchronized public Result deleteLob(long lobID) {
ResultMetaData meta = deleteLobCall.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[0] = ValuePool.getLong(lobID);
params[1] = ValuePool.getLong(0);
Result result = sysLobSession.executeCompiledStatement(deleteLobCall,
params);
return result;
}
synchronized public Result deleteUnusedLobs() {
Result result =
sysLobSession.executeCompiledStatement(deleteUnusedLobs,
ValuePool.emptyObjectArray);
deletedLobCount = 0;
return result;
}
synchronized public Result getLength(long lobID) {
try {
Object[] data = getLobHeader(lobID);
if (data == null) {
throw Error.error(ErrorCode.X_0F502);
}
long length = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
int type = ((Integer) data[LOB_IDS.LOB_TYPE]).intValue();
return ResultLob.newLobSetResponse(lobID, length);
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
}
synchronized public int compare(BlobData a, byte[] b) {
Object[] data = getLobHeader(a.getId());
long aLength = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
int[][] aAddresses = getBlockAddresses(a.getId(), 0,
Integer.MAX_VALUE);
int aIndex = 0;
int bOffset = 0;
int aOffset = 0;
while (true) {
int aBlockOffset = aAddresses[aIndex][LOBS.BLOCK_ADDR] + aOffset;
byte[] aBytes = getLobStore().getBlockBytes(aBlockOffset, 1);
for (int i = 0; i < aBytes.length; i++) {
if (bOffset + i >= b.length) {
if (aLength == b.length) {
return 0;
}
return 1;
}
if (aBytes[i] == b[bOffset + i]) {
continue;
}
return (((int) aBytes[i]) & 0xff)
> (((int) b[bOffset + i]) & 0xff) ? 1
: -1;
}
aOffset++;
bOffset += lobBlockSize;
if (aOffset == aAddresses[aIndex][LOBS.BLOCK_COUNT]) {
aOffset = 0;
aIndex++;
}
if (aIndex == aAddresses.length) {
break;
}
}
return -1;
}
synchronized public int compare(BlobData a, BlobData b) {
if (a.getId() == b.getId()) {
return 0;
}
Object[] data = getLobHeader(a.getId());
// abnormal case
if (data == null) {
return 1;
}
long lengthA = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
data = getLobHeader(b.getId());
// abnormal case
if (data == null) {
return -1;
}
long lengthB = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
if (lengthA > lengthB) {
return 1;
}
if (lengthA < lengthB) {
return -1;
}
return compareBytes(a.getId(), b.getId());
}
// todo - implement as compareText()
synchronized public int compare(ClobData a, String b) {
Object[] data = getLobHeader(a.getId());
long aLength = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
int[][] aAddresses = getBlockAddresses(a.getId(), 0,
Integer.MAX_VALUE);
int aIndex = 0;
int bOffset = 0;
int aOffset = 0;
while (true) {
int aBlockOffset = aAddresses[aIndex][LOBS.BLOCK_ADDR] + aOffset;
byte[] aBytes = getLobStore().getBlockBytes(aBlockOffset, 1);
long aLimit = aLength
- (aAddresses[aIndex][LOBS.BLOCK_OFFSET] + aOffset)
* lobBlockSize / 2;
if (aLimit > lobBlockSize / 2) {
aLimit = lobBlockSize / 2;
}
String aString = new String(ArrayUtil.byteArrayToChars(aBytes), 0,
(int) aLimit);
int bLimit = b.length() - bOffset;
if (bLimit > lobBlockSize / 2) {
bLimit = lobBlockSize / 2;
}
String bString = b.substring(bOffset, bOffset + bLimit);
int diff = database.collation.compare(aString, bString);
if (diff != 0) {
return diff;
}
aOffset++;
bOffset += lobBlockSize / 2;
if (aOffset == aAddresses[aIndex][LOBS.BLOCK_COUNT]) {
aOffset = 0;
aIndex++;
}
if (aIndex == aAddresses.length) {
break;
}
}
return 0;
}
synchronized public int compare(ClobData a, ClobData b) {
if (a.getId() == b.getId()) {
return 0;
}
return compareText(a.getId(), b.getId());
}
synchronized int compareBytes(long aID, long bID) {
int[][] aAddresses = getBlockAddresses(aID, 0, Integer.MAX_VALUE);
int[][] bAddresses = getBlockAddresses(bID, 0, Integer.MAX_VALUE);
int aIndex = 0;
int bIndex = 0;
int aOffset = 0;
int bOffset = 0;
while (true) {
int aBlockOffset = aAddresses[aIndex][LOBS.BLOCK_ADDR] + aOffset;
int bBlockOffset = bAddresses[bIndex][LOBS.BLOCK_ADDR] + bOffset;
byte[] aBytes = getLobStore().getBlockBytes(aBlockOffset, 1);
byte[] bBytes = getLobStore().getBlockBytes(bBlockOffset, 1);
for (int i = 0; i < aBytes.length; i++) {
if (aBytes[i] == bBytes[i]) {
continue;
}
return (((int) aBytes[i]) & 0xff) > (((int) bBytes[i]) & 0xff)
? 1
: -1;
}
aOffset++;
bOffset++;
if (aOffset == aAddresses[aIndex][LOBS.BLOCK_COUNT]) {
aOffset = 0;
aIndex++;
}
if (bOffset == bAddresses[bIndex][LOBS.BLOCK_COUNT]) {
bOffset = 0;
bIndex++;
}
if (aIndex == aAddresses.length) {
break;
}
}
return 0;
}
/** @todo - word-separator and end block zero issues */
synchronized int compareText(long aID, long bID) {
Object[] data = getLobHeader(aID);
long aLength = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
data = getLobHeader(bID);
long bLength = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
int[][] aAddresses = getBlockAddresses(aID, 0, Integer.MAX_VALUE);
int[][] bAddresses = getBlockAddresses(bID, 0, Integer.MAX_VALUE);
int aIndex = 0;
int bIndex = 0;
int aOffset = 0;
int bOffset = 0;
while (true) {
int aBlockOffset = aAddresses[aIndex][LOBS.BLOCK_ADDR] + aOffset;
int bBlockOffset = bAddresses[bIndex][LOBS.BLOCK_ADDR] + bOffset;
byte[] aBytes = getLobStore().getBlockBytes(aBlockOffset, 1);
byte[] bBytes = getLobStore().getBlockBytes(bBlockOffset, 1);
long aLimit = aLength
- (aAddresses[aIndex][LOBS.BLOCK_OFFSET] + aOffset)
* lobBlockSize / 2;
if (aLimit > lobBlockSize / 2) {
aLimit = lobBlockSize / 2;
}
long bLimit = bLength
- (bAddresses[bIndex][LOBS.BLOCK_OFFSET] + bOffset)
* lobBlockSize / 2;
if (bLimit > lobBlockSize / 2) {
bLimit = lobBlockSize / 2;
}
String aString = new String(ArrayUtil.byteArrayToChars(aBytes), 0,
(int) aLimit);
String bString = new String(ArrayUtil.byteArrayToChars(bBytes), 0,
(int) bLimit);
int diff = database.collation.compare(aString, bString);
if (diff != 0) {
return diff;
}
aOffset++;
bOffset++;
if (aOffset == aAddresses[aIndex][LOBS.BLOCK_COUNT]) {
aOffset = 0;
aIndex++;
}
if (bOffset == bAddresses[bIndex][LOBS.BLOCK_COUNT]) {
bOffset = 0;
bIndex++;
}
if (aIndex == aAddresses.length) {
break;
}
}
return 0;
}
/**
* Used for SUBSTRING
*/
synchronized public Result getLob(long lobID, long offset, long length) {
throw Error.runtimeError(ErrorCode.U_S0500, "LobManager");
}
synchronized public Result createDuplicateLob(long lobID) {
Object[] data = getLobHeader(lobID);
if (data == null) {
return Result.newErrorResult(Error.error(ErrorCode.X_0F502));
}
long newLobID = getNewLobID();
Object params[] = new Object[data.length];
params[LOB_IDS.LOB_ID] = ValuePool.getLong(newLobID);
params[1] = data[1];
params[2] = data[2];
params[3] = data[3];
Result result = sysLobSession.executeCompiledStatement(createLob,
params);
if (result.isError()) {
return result;
}
long length = ((Long) data[1]).longValue();
long byteLength = length;
int lobType = ((Integer) data[1]).intValue();
if (lobType == Types.SQL_CLOB) {
byteLength *= 2;
}
int newBlockCount = (int) byteLength / lobBlockSize;
if (byteLength % lobBlockSize != 0) {
newBlockCount++;
}
createBlockAddresses(newLobID, 0, newBlockCount);
// copy the contents
int[][] sourceBlocks = getBlockAddresses(lobID, 0, Integer.MAX_VALUE);
int[][] targetBlocks = getBlockAddresses(newLobID, 0,
Integer.MAX_VALUE);
try {
copyBlockSet(sourceBlocks, targetBlocks);
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
return ResultLob.newLobSetResponse(newLobID, length);
}
private void copyBlockSet(int[][] source, int[][] target) {
int sourceIndex = 0;
int targetIndex = 0;
while (true) {
int sourceOffset = source[sourceIndex][LOBS.BLOCK_OFFSET]
+ sourceIndex;
int targetOffset = target[targetIndex][LOBS.BLOCK_OFFSET]
+ targetIndex;
byte[] bytes = getLobStore().getBlockBytes(sourceOffset, 1);
getLobStore().setBlockBytes(bytes, targetOffset, 1);
sourceOffset++;
targetOffset++;
if (sourceOffset == source[sourceIndex][LOBS.BLOCK_COUNT]) {
sourceOffset = 0;
sourceIndex++;
}
if (targetOffset == target[sourceIndex][LOBS.BLOCK_COUNT]) {
targetOffset = 0;
targetIndex++;
}
if (sourceIndex == source.length) {
break;
}
}
}
synchronized public Result getChars(long lobID, long offset, int length) {
Result result = getBytes(lobID, offset * 2, length * 2);
if (result.isError()) {
return result;
}
byte[] bytes = ((ResultLob) result).getByteArray();
char[] chars = ArrayUtil.byteArrayToChars(bytes);
/*
HsqlByteArrayInputStream be = new HsqlByteArrayInputStream(bytes);
char[] chars = new char[bytes.length / 2];
try {
for (int i = 0; i < chars.length; i++) {
chars[i] = be.readChar();
}
} catch (Exception e) {
return Result.newErrorResult(e);
}
*/
return ResultLob.newLobGetCharsResponse(lobID, offset, chars);
}
synchronized public Result getBytes(long lobID, long offset, int length) {
int blockOffset = (int) (offset / lobBlockSize);
int byteBlockOffset = (int) (offset % lobBlockSize);
int blockLimit = (int) ((offset + length) / lobBlockSize);
int byteLimitOffset = (int) ((offset + length) % lobBlockSize);
if (byteLimitOffset == 0) {
byteLimitOffset = lobBlockSize;
} else {
blockLimit++;
}
int dataBytesPosition = 0;
byte[] dataBytes = new byte[length];
int[][] blockAddresses = getBlockAddresses(lobID, blockOffset,
blockLimit);
if (blockAddresses.length == 0) {
return Result.newErrorResult(Error.error(ErrorCode.X_0F502));
}
//
int i = 0;
int blockCount = blockAddresses[i][LOBS.BLOCK_COUNT]
+ blockAddresses[i][LOBS.BLOCK_OFFSET] - blockOffset;
if (blockAddresses[i][LOBS.BLOCK_COUNT]
+ blockAddresses[i][LOBS.BLOCK_OFFSET] > blockLimit) {
blockCount -= (blockAddresses[i][LOBS.BLOCK_COUNT]
+ blockAddresses[i][LOBS.BLOCK_OFFSET]
- blockLimit);
}
byte[] bytes;
try {
bytes =
getLobStore().getBlockBytes(blockAddresses[i][LOBS.BLOCK_ADDR]
+ blockOffset, blockCount);
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
int subLength = lobBlockSize * blockCount - byteBlockOffset;
if (subLength > length) {
subLength = length;
}
System.arraycopy(bytes, byteBlockOffset, dataBytes, dataBytesPosition,
subLength);
dataBytesPosition += subLength;
i++;
for (; i < blockAddresses.length && dataBytesPosition < length; i++) {
blockCount = blockAddresses[i][LOBS.BLOCK_COUNT];
if (blockAddresses[i][LOBS.BLOCK_COUNT]
+ blockAddresses[i][LOBS.BLOCK_OFFSET] > blockLimit) {
blockCount -= (blockAddresses[i][LOBS.BLOCK_COUNT]
+ blockAddresses[i][LOBS.BLOCK_OFFSET]
- blockLimit);
}
try {
bytes = getLobStore().getBlockBytes(
blockAddresses[i][LOBS.BLOCK_ADDR], blockCount);
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
subLength = lobBlockSize * blockCount;
if (subLength > length - dataBytesPosition) {
subLength = length - dataBytesPosition;
}
System.arraycopy(bytes, 0, dataBytes, dataBytesPosition,
subLength);
dataBytesPosition += subLength;
}
return ResultLob.newLobGetBytesResponse(lobID, offset, dataBytes);
}
synchronized public Result setBytesBA(long lobID, byte[] dataBytes,
long offset, int length) {
int blockOffset = (int) (offset / lobBlockSize);
int byteBlockOffset = (int) (offset % lobBlockSize);
int blockLimit = (int) ((offset + length) / lobBlockSize);
int byteLimitOffset = (int) ((offset + length) % lobBlockSize);
if (byteLimitOffset == 0) {
byteLimitOffset = lobBlockSize;
} else {
blockLimit++;
}
int[][] blockAddresses = getBlockAddresses(lobID, blockOffset,
blockLimit);
byte[] newBytes = new byte[(blockLimit - blockOffset) * lobBlockSize];
if (blockAddresses.length > 0) {
int blockAddress = blockAddresses[0][LOBS.BLOCK_ADDR]
+ (blockOffset
- blockAddresses[0][LOBS.BLOCK_OFFSET]);
try {
byte[] block = getLobStore().getBlockBytes(blockAddress, 1);
System.arraycopy(block, 0, newBytes, 0, lobBlockSize);
if (blockAddresses.length > 1) {
blockAddress =
blockAddresses[blockAddresses.length - 1][LOBS.BLOCK_ADDR]
+ (blockLimit
- blockAddresses[blockAddresses.length - 1][LOBS.BLOCK_OFFSET]
- 1);
block = getLobStore().getBlockBytes(blockAddress, 1);
System.arraycopy(block, 0, newBytes,
blockLimit - blockOffset - 1,
lobBlockSize);
} else if (blockLimit - blockOffset > 1) {
blockAddress = blockAddresses[0][LOBS.BLOCK_ADDR]
+ (blockLimit
- blockAddresses[0][LOBS.BLOCK_OFFSET]
- 1);
block = getLobStore().getBlockBytes(blockAddress, 1);
System.arraycopy(block, 0, newBytes,
(blockLimit - blockOffset - 1)
* lobBlockSize, lobBlockSize);
}
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
// should turn into SP
divideBlockAddresses(lobID, blockOffset);
divideBlockAddresses(lobID, blockLimit);
deleteBlockAddresses(lobID, blockOffset, blockLimit);
}
createBlockAddresses(lobID, blockOffset, blockLimit - blockOffset);
System.arraycopy(dataBytes, 0, newBytes, byteBlockOffset, length);
blockAddresses = getBlockAddresses(lobID, blockOffset, blockLimit);
//
try {
for (int i = 0; i < blockAddresses.length; i++) {
getLobStore().setBlockBytes(newBytes, blockAddresses[i][0],
blockAddresses[i][1]);
}
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
return ResultLob.newLobSetResponse(lobID, 0);
}
private Result setBytesIS(long lobID, InputStream inputStream,
long length) {
int blockLimit = (int) (length / lobBlockSize);
int byteLimitOffset = (int) (length % lobBlockSize);
if (byteLimitOffset == 0) {
byteLimitOffset = lobBlockSize;
} else {
blockLimit++;
}
createBlockAddresses(lobID, 0, blockLimit);
int[][] blockAddresses = getBlockAddresses(lobID, 0, blockLimit);
byte[] dataBytes = new byte[lobBlockSize];
for (int i = 0; i < blockAddresses.length; i++) {
for (int j = 0; j < blockAddresses[i][LOBS.BLOCK_COUNT]; j++) {
int localLength = lobBlockSize;
if (i == blockAddresses.length - 1
&& j == blockAddresses[i][LOBS.BLOCK_COUNT] - 1) {
localLength = byteLimitOffset;
// todo -- use block op
for (int k = localLength; k < lobBlockSize; k++) {
dataBytes[k] = 0;
}
}
try {
int count = 0;
while (localLength > 0) {
int read = inputStream.read(dataBytes, count,
localLength);
if (read == -1) {
return Result.newErrorResult(new EOFException());
}
localLength -= read;
count += read;
}
// read more
} catch (IOException e) {
// deallocate
return Result.newErrorResult(e);
}
try {
getLobStore().setBlockBytes(
dataBytes, blockAddresses[i][LOBS.BLOCK_ADDR] + j, 1);
} catch (HsqlException e) {
return Result.newErrorResult(e);
}
}
}
return ResultLob.newLobSetResponse(lobID, 0);
}
synchronized public Result setBytes(long lobID, byte[] dataBytes,
long offset) {
if (dataBytes.length == 0) {
return ResultLob.newLobSetResponse(lobID, 0);
}
Object[] data = getLobHeader(lobID);
if (data == null) {
return Result.newErrorResult(Error.error(ErrorCode.X_0F502));
}
long length = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
Result result = setBytesBA(lobID, dataBytes, offset, dataBytes.length);
if (offset + dataBytes.length > length) {
setLength(lobID, offset + dataBytes.length);
}
return result;
}
synchronized public Result setBytesForNewBlob(long lobID,
InputStream inputStream, long length) {
if (length == 0) {
return ResultLob.newLobSetResponse(lobID, 0);
}
Result result = setBytesIS(lobID, inputStream, length);
return result;
}
synchronized public Result setChars(long lobID, long offset,
char[] chars) {
if (chars.length == 0) {
return ResultLob.newLobSetResponse(lobID, 0);
}
Object[] data = getLobHeader(lobID);
if (data == null) {
return Result.newErrorResult(Error.error(ErrorCode.X_0F502));
}
long length = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
byte[] bytes = ArrayUtil.charArrayToBytes(chars);
/*
HsqlByteArrayOutputStream os =
new HsqlByteArrayOutputStream(chars.length * 2);
os.write(chars, 0, chars.length);
byte[] bytes = os.getBuffer();
*/
Result result = setBytesBA(lobID, bytes, offset * 2, chars.length * 2);
if (result.isError()) {
return result;
}
if (offset + chars.length > length) {
result = setLength(lobID, offset + chars.length);
if (result.isError()) {
return result;
}
}
return ResultLob.newLobSetResponse(lobID, 0);
}
synchronized public Result setCharsForNewClob(long lobID,
InputStream inputStream, long length) {
if (length == 0) {
return ResultLob.newLobSetResponse(lobID, 0);
}
Result result = setBytesIS(lobID, inputStream, length * 2);
if (result.isError()) {
return result;
}
return ResultLob.newLobSetResponse(lobID, 0);
}
synchronized public Result truncate(long lobID, long offset) {
Object[] data = getLobHeader(lobID);
if (data == null) {
return Result.newErrorResult(Error.error(ErrorCode.X_0F502));
}
/** @todo 1.9.0 - double offset for clob */
long length = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
int blockOffset = (int) (offset / lobBlockSize);
ResultMetaData meta = deleteLobPartCall.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[DELETE_BLOCKS.LOB_ID] = ValuePool.getLong(lobID);
params[DELETE_BLOCKS.BLOCK_OFFSET] = new Integer(blockOffset);
params[DELETE_BLOCKS.BLOCK_LIMIT] = new Integer(Integer.MAX_VALUE);
params[DELETE_BLOCKS.TX_ID] =
ValuePool.getLong(sysLobSession.getTransactionTimestamp());
Result result =
sysLobSession.executeCompiledStatement(deleteLobPartCall, params);
setLength(lobID, offset);
return ResultLob.newLobTruncateResponse(lobID);
}
synchronized Result setLength(long lobID, long length) {
ResultMetaData meta = updateLobLength.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[UPDATE_LENGTH.LOB_LENGTH] = ValuePool.getLong(length);
params[UPDATE_LENGTH.LOB_ID] = ValuePool.getLong(lobID);
Result result = sysLobSession.executeCompiledStatement(updateLobLength,
params);
return result;
}
synchronized public Result adjustUsageCount(long lobID, int delta) {
Object[] data = getLobHeader(lobID);
int count = ((Number) data[LOB_IDS.LOB_USAGE_COUNT]).intValue();
if (count + delta == 0) {
deletedLobCount++;
}
ResultMetaData meta = updateLobUsage.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[UPDATE_USAGE.BLOCK_COUNT] = ValuePool.getInt(count + delta);
params[UPDATE_USAGE.LOB_ID] = ValuePool.getLong(lobID);
sysLobSession.sessionContext.pushDynamicArguments(params);
Result result = updateLobUsage.execute(sysLobSession);
sysLobSession.sessionContext.pop();
return result;
}
private int[][] getBlockAddresses(long lobID, int offset, int limit) {
ResultMetaData meta = getLobPart.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[GET_LOB_PART.LOB_ID] = ValuePool.getLong(lobID);
params[GET_LOB_PART.BLOCK_OFFSET] = ValuePool.getInt(offset);
params[GET_LOB_PART.BLOCK_LIMIT] = ValuePool.getInt(limit);
sysLobSession.sessionContext.pushDynamicArguments(params);
Result result = getLobPart.execute(sysLobSession);
sysLobSession.sessionContext.pop();
RowSetNavigator navigator = result.getNavigator();
int size = navigator.getSize();
int[][] blocks = new int[size][3];
for (int i = 0; i < size; i++) {
navigator.absolute(i);
Object[] data = navigator.getCurrent();
blocks[i][LOBS.BLOCK_ADDR] =
((Integer) data[LOBS.BLOCK_ADDR]).intValue();
blocks[i][LOBS.BLOCK_COUNT] =
((Integer) data[LOBS.BLOCK_COUNT]).intValue();
blocks[i][LOBS.BLOCK_OFFSET] =
((Integer) data[LOBS.BLOCK_OFFSET]).intValue();
}
navigator.close();
return blocks;
}
private void deleteBlockAddresses(long lobID, int offset, int limit) {
ResultMetaData meta = deleteLobPartCall.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[DELETE_BLOCKS.LOB_ID] = ValuePool.getLong(lobID);
params[DELETE_BLOCKS.BLOCK_OFFSET] = ValuePool.getInt(offset);
params[DELETE_BLOCKS.BLOCK_LIMIT] = ValuePool.getInt(limit);
params[DELETE_BLOCKS.TX_ID] =
ValuePool.getLong(sysLobSession.getTransactionTimestamp());
Result result =
sysLobSession.executeCompiledStatement(deleteLobPartCall, params);
}
private void divideBlockAddresses(long lobID, int offset) {
ResultMetaData meta = divideLobPartCall.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[DIVIDE_BLOCK.BLOCK_OFFSET] = ValuePool.getInt(offset);
params[DIVIDE_BLOCK.LOB_ID] = ValuePool.getLong(lobID);
Result result =
sysLobSession.executeCompiledStatement(divideLobPartCall, params);
}
private void createBlockAddresses(long lobID, int offset, int count) {
ResultMetaData meta = createLobPartCall.getParametersMetaData();
Object params[] = new Object[meta.getColumnCount()];
params[ALLOC_BLOCKS.BLOCK_COUNT] = ValuePool.getInt(count);
params[ALLOC_BLOCKS.BLOCK_OFFSET] = ValuePool.getInt(offset);
params[ALLOC_BLOCKS.LOB_ID] = ValuePool.getLong(lobID);
Result result =
sysLobSession.executeCompiledStatement(createLobPartCall, params);
}
synchronized public int getLobCount() {
sysLobSession.sessionContext.pushDynamicArguments(new Object[]{});
Result result = getLobCount.execute(sysLobSession);
sysLobSession.sessionContext.pop();
RowSetNavigator navigator = result.getNavigator();
boolean next = navigator.next();
if (!next) {
navigator.close();
return 0;
}
Object[] data = navigator.getCurrent();
return ((Number) data[0]).intValue();
}
}