diff options
Diffstat (limited to 'src/main/java/com/healthmarketscience/jackcess')
14 files changed, 1033 insertions, 576 deletions
diff --git a/src/main/java/com/healthmarketscience/jackcess/Column.java b/src/main/java/com/healthmarketscience/jackcess/Column.java index 383f605..fc60f32 100644 --- a/src/main/java/com/healthmarketscience/jackcess/Column.java +++ b/src/main/java/com/healthmarketscience/jackcess/Column.java @@ -134,6 +134,14 @@ public interface Column public boolean isHyperlink(); /** + * Returns whether or not this is a calculated column. Note that jackess + * <b>won't interpret the calculation expression</b> (but the field can be + * written directly). + * @usage _general_method_ + */ + public boolean isCalculated(); + + /** * Returns extended functionality for "complex" columns. * @usage _general_method_ */ diff --git a/src/main/java/com/healthmarketscience/jackcess/PropertyMap.java b/src/main/java/com/healthmarketscience/jackcess/PropertyMap.java index a651811..779d92b 100644 --- a/src/main/java/com/healthmarketscience/jackcess/PropertyMap.java +++ b/src/main/java/com/healthmarketscience/jackcess/PropertyMap.java @@ -45,6 +45,8 @@ public interface PropertyMap extends Iterable<PropertyMap.Property> public static final String VALIDATION_TEXT_PROP = "ValidationText"; public static final String GUID_PROP = "GUID"; public static final String DESCRIPTION_PROP = "Description"; + public static final String RESULT_TYPE_PROP = "ResultType"; + public static final String EXPRESSION_PROP = "Expression"; public String getName(); diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/ByteUtil.java b/src/main/java/com/healthmarketscience/jackcess/impl/ByteUtil.java index 663ff95..67f0724 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/ByteUtil.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/ByteUtil.java @@ -512,7 +512,7 @@ public final class ByteUtil { } for(int i = 0; i < hexChars.length; i += 2) { String tmpStr = new String(hexChars, i, 2); - buffer.put((byte)Long.parseLong(tmpStr, 16)); + buffer.put((byte)Integer.parseInt(tmpStr, 16)); } } @@ -549,6 +549,20 @@ public final class ByteUtil { } /** + * Swaps the 8 bytes (changes endianness) of the bytes at the given offset. + * + * @param bytes buffer containing bytes to swap + * @param offset offset of the first byte of the bytes to swap + */ + public static void swap8Bytes(byte[] bytes, int offset) + { + swapBytesAt(bytes, offset + 0, offset + 7); + swapBytesAt(bytes, offset + 1, offset + 6); + swapBytesAt(bytes, offset + 2, offset + 5); + swapBytesAt(bytes, offset + 3, offset + 4); + } + + /** * Swaps the 4 bytes (changes endianness) of the bytes at the given offset. * * @param bytes buffer containing bytes to swap @@ -556,12 +570,8 @@ public final class ByteUtil { */ public static void swap4Bytes(byte[] bytes, int offset) { - byte b = bytes[offset + 0]; - bytes[offset + 0] = bytes[offset + 3]; - bytes[offset + 3] = b; - b = bytes[offset + 1]; - bytes[offset + 1] = bytes[offset + 2]; - bytes[offset + 2] = b; + swapBytesAt(bytes, offset + 0, offset + 3); + swapBytesAt(bytes, offset + 1, offset + 2); } /** @@ -572,9 +582,17 @@ public final class ByteUtil { */ public static void swap2Bytes(byte[] bytes, int offset) { - byte b = bytes[offset + 0]; - bytes[offset + 0] = bytes[offset + 1]; - bytes[offset + 1] = b; + swapBytesAt(bytes, offset + 0, offset + 1); + } + + /** + * Swaps the bytes at the given positions. + */ + private static void swapBytesAt(byte[] bytes, int p1, int p2) + { + byte b = bytes[p1]; + bytes[p1] = bytes[p2]; + bytes[p2] = b; } /** @@ -594,7 +612,7 @@ public final class ByteUtil { */ public static byte[] copyOf(byte[] arr, int newLength) { - return copyOf(arr, 0, newLength); + return copyOf(arr, 0, newLength, 0); } /** @@ -603,9 +621,20 @@ public final class ByteUtil { */ public static byte[] copyOf(byte[] arr, int offset, int newLength) { + return copyOf(arr, offset, newLength, 0); + } + + /** + * Returns a copy of the given array of the given length starting at the + * given position. + */ + public static byte[] copyOf(byte[] arr, int offset, int newLength, + int dstOffset) + { byte[] newArr = new byte[newLength]; int srcLen = arr.length - offset; - System.arraycopy(arr, offset, newArr, 0, Math.min(srcLen, newLength)); + int dstLen = newLength - dstOffset; + System.arraycopy(arr, offset, newArr, dstOffset, Math.min(srcLen, dstLen)); return newArr; } diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/CalculatedColumnUtil.java b/src/main/java/com/healthmarketscience/jackcess/impl/CalculatedColumnUtil.java new file mode 100644 index 0000000..930a0d7 --- /dev/null +++ b/src/main/java/com/healthmarketscience/jackcess/impl/CalculatedColumnUtil.java @@ -0,0 +1,327 @@ +/* +Copyright (c) 2014 James Ahlborn + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +USA +*/ + +package com.healthmarketscience.jackcess.impl; + +import java.io.IOException; +import java.math.BigDecimal; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + + +/** + * Utility code for dealing with calculated columns. + * <p/> + * These are the currently possible calculated types: FLOAT, DOUBLE, INT, + * LONG, GUID, SHORT_DATE_TIME, MONEY, BOOLEAN, NUMERIC, TEXT, MEMO. + * + * @author James Ahlborn + */ +class CalculatedColumnUtil +{ + private static final int CALC_DATA_LEN_OFFSET = 16; + private static final int CALC_DATA_OFFSET = CALC_DATA_LEN_OFFSET + 4; + private static final int CALC_EXTRA_DATA_LEN = 23; + + private static final byte[] CALC_BOOL_TRUE = wrapCalculatedValue( + new byte[]{(byte)0xFF}); + private static final byte[] CALC_BOOL_FALSE = wrapCalculatedValue( + new byte[]{0}); + + /** + * Creates the appropriate ColumnImpl class for a calculated column and + * reads a column definition in from a buffer + * + * @param table owning table + * @param buffer Buffer containing column definition + * @param offset Offset in the buffer at which the column definition starts + * @usage _advanced_method_ + */ + static ColumnImpl create(ColumnImpl.InitArgs args) throws IOException + { + switch(args.type) { + case BOOLEAN: + return new CalcBooleanColImpl(args); + case TEXT: + return new CalcTextColImpl(args); + case MEMO: + return new CalcMemoColImpl(args); + default: + // fall through + } + + if(args.type.getHasScalePrecision()) { + return new CalcNumericColImpl(args); + } + + return new CalcColImpl(args); + } + + private static byte[] unwrapCalculatedValue(byte[] data) { + if(data.length < CALC_DATA_OFFSET) { + return data; + } + + ByteBuffer buffer = PageChannel.wrap(data); + buffer.position(CALC_DATA_LEN_OFFSET); + int dataLen = buffer.getInt(); + byte[] newData = new byte[Math.min(buffer.remaining(), dataLen)]; + buffer.get(newData); + return newData; + } + + private static ByteBuffer wrapCalculatedValue(ByteBuffer buffer) { + int dataLen = buffer.remaining(); + byte[] data = new byte[dataLen + CALC_EXTRA_DATA_LEN]; + buffer.get(data, CALC_DATA_OFFSET, dataLen); + buffer = PageChannel.wrap(data); + buffer.putInt(CALC_DATA_LEN_OFFSET, dataLen); + return buffer; + } + + private static byte[] wrapCalculatedValue(byte[] data) { + int dataLen = data.length; + data = ByteUtil.copyOf(data, 0, dataLen + CALC_EXTRA_DATA_LEN, + CALC_DATA_OFFSET); + PageChannel.wrap(data).putInt(CALC_DATA_LEN_OFFSET, dataLen); + return data; + } + + private static ByteBuffer prepareWrappedCalcValue(int dataLen, ByteOrder order) + { + ByteBuffer buffer = ByteBuffer.allocate( + dataLen + CALC_EXTRA_DATA_LEN).order(order); + buffer.putInt(CALC_DATA_LEN_OFFSET, dataLen); + buffer.position(CALC_DATA_OFFSET); + return buffer; + } + + + private static class CalcColImpl extends ColumnImpl + { + CalcColImpl(InitArgs args) throws IOException { + super(args); + } + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + return super.read(unwrapCalculatedValue(data), order); + } + + @Override + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { + // we should only be working with fixed length types + return writeFixedLengthField( + obj, prepareWrappedCalcValue(getType().getFixedSize(), order)); + } + } + + private static class CalcBooleanColImpl extends ColumnImpl + { + CalcBooleanColImpl(InitArgs args) throws IOException { + super(args); + } + + @Override + public boolean storeInNullMask() { + // calculated booleans are _not_ stored in null mask + return false; + } + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + data = unwrapCalculatedValue(data); + return ((data[0] != 0) ? Boolean.TRUE : Boolean.FALSE); + } + + @Override + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { + return ByteBuffer.wrap( + toBooleanValue(obj) ? CALC_BOOL_TRUE : CALC_BOOL_FALSE).order(order); + } + } + + private static class CalcTextColImpl extends TextColumnImpl + { + CalcTextColImpl(InitArgs args) throws IOException { + super(args); + } + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + return decodeTextValue(unwrapCalculatedValue(data)); + } + + @Override + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { + int maxChars = getType().toUnitSize(getLength() - CALC_EXTRA_DATA_LEN); + return wrapCalculatedValue(encodeTextValue(obj, 0, maxChars, false)); + } + } + + private static class CalcMemoColImpl extends MemoColumnImpl + { + CalcMemoColImpl(InitArgs args) throws IOException { + super(args); + } + + @Override + protected byte[] readLongValue(byte[] lvalDefinition) + throws IOException + { + return unwrapCalculatedValue(super.readLongValue(lvalDefinition)); + } + + @Override + protected ByteBuffer writeLongValue(byte[] value, int remainingRowLength) + throws IOException + { + return super.writeLongValue(wrapCalculatedValue(value), remainingRowLength); + } + } + + private static class CalcNumericColImpl extends NumericColumnImpl + { + CalcNumericColImpl(InitArgs args) throws IOException { + super(args); + } + + @Override + public byte getPrecision() { + return (byte)getType().getMaxPrecision(); + } + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + data = unwrapCalculatedValue(data); + return readCalcNumericValue(ByteBuffer.wrap(data).order(order)); + } + + @Override + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { + int totalDataLen = Math.min(CALC_EXTRA_DATA_LEN + 16 + 4, getLength()); + int dataLen = totalDataLen - CALC_EXTRA_DATA_LEN; + ByteBuffer buffer = prepareWrappedCalcValue(dataLen, order); + + writeCalcNumericValue(buffer, obj, dataLen); + + buffer.flip(); + + return buffer; + } + + private static BigDecimal readCalcNumericValue(ByteBuffer buffer) + { + short totalLen = buffer.getShort(); + // numeric bytes need to be a multiple of 4 and we currently handle at + // most 16 bytes + int numByteLen = ((totalLen > 0) ? totalLen : buffer.remaining()) - 2; + numByteLen = Math.min((numByteLen / 4) * 4, 16); + byte scale = buffer.get(); + boolean negate = (buffer.get() != 0); + byte[] tmpArr = ByteUtil.getBytes(buffer, numByteLen); + + if(buffer.order() != ByteOrder.BIG_ENDIAN) { + fixNumericByteOrder(tmpArr); + } + + return toBigDecimal(tmpArr, negate, scale); + } + + private void writeCalcNumericValue(ByteBuffer buffer, Object value, + int dataLen) + throws IOException + { + Object inValue = value; + try { + BigDecimal decVal = toBigDecimal(value); + inValue = decVal; + + int signum = decVal.signum(); + if(signum < 0) { + decVal = decVal.negate(); + } + + int maxScale = getType().getMaxScale(); + if(decVal.scale() > maxScale) { + // adjust scale according to max (will cause the an + // ArithmeticException if number has too many decimal places) + decVal = decVal.setScale(maxScale); + } + int scale = decVal.scale(); + + // check precision + if(decVal.precision() > getType().getMaxPrecision()) { + throw new IOException( + "Numeric value is too big for specified precision " + + getType().getMaxPrecision() + ": " + decVal); + } + + // convert to unscaled BigInteger, big-endian bytes + byte[] intValBytes = toUnscaledByteArray(decVal, dataLen - 4); + + if(buffer.order() != ByteOrder.BIG_ENDIAN) { + fixNumericByteOrder(intValBytes); + } + + buffer.putShort((short)(dataLen - 2)); + buffer.put((byte)scale); + // write sign byte + buffer.put(signum < 0 ? (byte)0x80 : (byte)0); + buffer.put(intValBytes); + + } catch(ArithmeticException e) { + throw (IOException) + new IOException("Numeric value '" + inValue + "' out of range") + .initCause(e); + } + } + + private static void fixNumericByteOrder(byte[] bytes) { + + // this is a little weird. it looks like they decided to truncate + // leading 0 bytes and _then_ swapp endian, which ends up kind of odd. + int pos = 0; + if((bytes.length % 8) != 0) { + // leading 4 bytes are swapped + ByteUtil.swap4Bytes(bytes, 0); + pos += 4; + } + + // then fix endianness of each 8 byte segment + for(; pos < bytes.length; pos+=8) { + ByteUtil.swap8Bytes(bytes, pos); + } + } + + } + +} diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/ColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/ColumnImpl.java index ce8ff63..c9c67e7 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/ColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/ColumnImpl.java @@ -77,7 +77,7 @@ import org.apache.commons.logging.LogFactory; */ public class ColumnImpl implements Column, Comparable<ColumnImpl> { - private static final Log LOG = LogFactory.getLog(ColumnImpl.class); + protected static final Log LOG = LogFactory.getLog(ColumnImpl.class); /** * Placeholder object for adding rows which indicates that the caller wants @@ -102,27 +102,6 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { 25569L * (long)MILLISECONDS_PER_DAY; /** - * Long value (LVAL) type that indicates that the value is stored on the - * same page - */ - private static final byte LONG_VALUE_TYPE_THIS_PAGE = (byte) 0x80; - /** - * Long value (LVAL) type that indicates that the value is stored on another - * page - */ - private static final byte LONG_VALUE_TYPE_OTHER_PAGE = (byte) 0x40; - /** - * Long value (LVAL) type that indicates that the value is stored on - * multiple other pages - */ - private static final byte LONG_VALUE_TYPE_OTHER_PAGES = (byte) 0x00; - /** - * Mask to apply the long length in order to get the flag bits (only the - * first 2 bits are type flags). - */ - private static final int LONG_VALUE_TYPE_MASK = 0xC0000000; - - /** * mask for the fixed len bit * @usage _advanced_field_ */ @@ -154,7 +133,9 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { // some other flags? // 0x10: replication related field (or hidden?) - // 0x80: hyperlink (some memo based thing) + + protected static final byte COMPRESSED_UNICODE_EXT_FLAG_MASK = (byte)0x01; + private static final byte CALCULATED_EXT_FLAG_MASK = (byte)0xC0; /** the value for the "general" sort order */ private static final short GENERAL_SORT_ORDER_VALUE = 1033; @@ -188,6 +169,8 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { private final boolean _variableLength; /** Whether or not the column is an autonumber column */ private final boolean _autoNumber; + /** Whether or not the column is a calculated column */ + private final boolean _calculated; /** Data type */ private final DataType _type; /** Maximum column length */ @@ -199,7 +182,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { /** display index of the data for this column */ private final int _displayIndex; /** Column name */ - private String _name; + private final String _name; /** the offset of the fixed data in the row */ private final int _fixedDataOffset; /** the index of the variable length data in the var len offset table */ @@ -214,9 +197,10 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { /** * @usage _advanced_method_ */ - protected ColumnImpl(TableImpl table, DataType type, int colNumber, - int fixedOffset, int varLenIndex) { + protected ColumnImpl(TableImpl table, String name, DataType type, + int colNumber, int fixedOffset, int varLenIndex) { _table = table; + _name = name; _type = type; if(!_type.isVariableLength()) { @@ -226,6 +210,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { } _variableLength = type.isVariableLength(); _autoNumber = false; + _calculated = false; _autoNumberGenerator = null; _columnNumber = (short)colNumber; _columnIndex = colNumber; @@ -241,32 +226,37 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { * @param offset Offset in the buffer at which the column definition starts * @usage _advanced_method_ */ - ColumnImpl(TableImpl table, ByteBuffer buffer, int offset, int displayIndex, - DataType type, byte flags) + ColumnImpl(InitArgs args) throws IOException { - _table = table; - _displayIndex = displayIndex; - _type = type; + _table = args.table; + _name = args.name; + _displayIndex = args.displayIndex; + _type = args.type; - _columnNumber = buffer.getShort(offset + getFormat().OFFSET_COLUMN_NUMBER); - _columnLength = buffer.getShort(offset + getFormat().OFFSET_COLUMN_LENGTH); + _columnNumber = args.buffer.getShort( + args.offset + getFormat().OFFSET_COLUMN_NUMBER); + _columnLength = args.buffer.getShort( + args.offset + getFormat().OFFSET_COLUMN_LENGTH); - _variableLength = ((flags & FIXED_LEN_FLAG_MASK) == 0); - _autoNumber = ((flags & (AUTO_NUMBER_FLAG_MASK | AUTO_NUMBER_GUID_FLAG_MASK)) - != 0); + _variableLength = ((args.flags & FIXED_LEN_FLAG_MASK) == 0); + _autoNumber = ((args.flags & + (AUTO_NUMBER_FLAG_MASK | AUTO_NUMBER_GUID_FLAG_MASK)) != 0); + _calculated = ((args.extFlags & CALCULATED_EXT_FLAG_MASK) != 0); _autoNumberGenerator = createAutoNumberGenerator(); if(_variableLength) { - _varLenTableIndex = buffer.getShort(offset + getFormat().OFFSET_COLUMN_VARIABLE_TABLE_INDEX); + _varLenTableIndex = args.buffer.getShort( + args.offset + getFormat().OFFSET_COLUMN_VARIABLE_TABLE_INDEX); _fixedDataOffset = 0; } else { - _fixedDataOffset = buffer.getShort(offset + getFormat().OFFSET_COLUMN_FIXED_DATA_OFFSET); + _fixedDataOffset = args.buffer.getShort( + args.offset + getFormat().OFFSET_COLUMN_FIXED_DATA_OFFSET); _varLenTableIndex = 0; } } - + /** * Creates the appropriate ColumnImpl class and reads a column definition in * from a buffer @@ -275,49 +265,56 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { * @param offset Offset in the buffer at which the column definition starts * @usage _advanced_method_ */ - public static ColumnImpl create(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex) + public static ColumnImpl create(TableImpl table, ByteBuffer buffer, + int offset, String name, int displayIndex) throws IOException { - byte colType = buffer.get(offset + table.getFormat().OFFSET_COLUMN_TYPE); - byte flags = buffer.get(offset + table.getFormat().OFFSET_COLUMN_FLAGS); - - DataType type = null; + InitArgs args = new InitArgs(table, buffer, offset, name, displayIndex); + + boolean calculated = ((args.extFlags & CALCULATED_EXT_FLAG_MASK) != 0); + byte colType = args.colType; + if(calculated) { + // "real" data type is in the "result type" property + PropertyMap colProps = table.getPropertyMaps().get(name); + Byte resultType = (Byte)colProps.getValue(PropertyMap.RESULT_TYPE_PROP); + if(resultType != null) { + colType = resultType; + } + } + try { - type = DataType.fromByte(colType); + args.type = DataType.fromByte(colType); } catch(IOException e) { LOG.warn("Unsupported column type " + colType); - boolean variableLength = ((flags & FIXED_LEN_FLAG_MASK) == 0); - type = (variableLength ? DataType.UNSUPPORTED_VARLEN : - DataType.UNSUPPORTED_FIXEDLEN); - return new UnsupportedColumnImpl(table, buffer, offset, displayIndex, type, - flags, colType); + boolean variableLength = ((args.flags & FIXED_LEN_FLAG_MASK) == 0); + args.type = (variableLength ? DataType.UNSUPPORTED_VARLEN : + DataType.UNSUPPORTED_FIXEDLEN); + return new UnsupportedColumnImpl(args); } - switch(type) { + if(calculated) { + return CalculatedColumnUtil.create(args); + } + + switch(args.type) { case TEXT: - return new TextColumnImpl(table, buffer, offset, displayIndex, type, - flags); + return new TextColumnImpl(args); case MEMO: - return new MemoColumnImpl(table, buffer, offset, displayIndex, type, - flags); + return new MemoColumnImpl(args); case COMPLEX_TYPE: - return new ComplexColumnImpl(table, buffer, offset, displayIndex, type, - flags); + return new ComplexColumnImpl(args); default: // fall through } - if(type.getHasScalePrecision()) { - return new NumericColumnImpl(table, buffer, offset, displayIndex, type, - flags); + if(args.type.getHasScalePrecision()) { + return new NumericColumnImpl(args); } - if(type.isLongValue()) { - return new LongValueColumnImpl(table, buffer, offset, displayIndex, type, - flags); + if(args.type.isLongValue()) { + return new LongValueColumnImpl(args); } - return new ColumnImpl(table, buffer, offset, displayIndex, type, flags); + return new ColumnImpl(args); } /** @@ -359,13 +356,6 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { public String getName() { return _name; } - - /** - * @usage _advanced_method_ - */ - public void setName(String name) { - _name = name; - } public boolean isVariableLength() { return _variableLength; @@ -441,6 +431,10 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { public short getLengthInUnits() { return (short)getType().toUnitSize(getLength()); } + + public boolean isCalculated() { + return _calculated; + } /** * @usage _advanced_method_ @@ -525,10 +519,6 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { byte getOriginalDataType() { return _type.getValue(); } - - LongValueBufferHolder getLongValueBufferHolder() { - return null; - } private AutoNumberGenerator createAutoNumberGenerator() { if(!_autoNumber || (_type == null)) { @@ -581,7 +571,19 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { public Object getRowValue(Map<String,?> rowMap) { return rowMap.get(_name); } + + public boolean storeInNullMask() { + return (getType() == DataType.BOOLEAN); + } + public boolean writeToNullMask(Object value) { + return toBooleanValue(value); + } + + public Object readFromNullMask(boolean isNull) { + return Boolean.valueOf(!isNull); + } + /** * Deserialize a raw byte value for this column into an Object * @param data The raw byte value @@ -600,172 +602,45 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { * @usage _advanced_method_ */ public Object read(byte[] data, ByteOrder order) throws IOException { - ByteBuffer buffer = ByteBuffer.wrap(data); - buffer.order(order); - if (_type == DataType.BOOLEAN) { + ByteBuffer buffer = ByteBuffer.wrap(data).order(order); + + switch(getType()) { + case BOOLEAN: throw new IOException("Tried to read a boolean from data instead of null mask."); - } else if (_type == DataType.BYTE) { + case BYTE: return Byte.valueOf(buffer.get()); - } else if (_type == DataType.INT) { + case INT: return Short.valueOf(buffer.getShort()); - } else if (_type == DataType.LONG) { + case LONG: return Integer.valueOf(buffer.getInt()); - } else if (_type == DataType.DOUBLE) { + case DOUBLE: return Double.valueOf(buffer.getDouble()); - } else if (_type == DataType.FLOAT) { + case FLOAT: return Float.valueOf(buffer.getFloat()); - } else if (_type == DataType.SHORT_DATE_TIME) { + case SHORT_DATE_TIME: return readDateValue(buffer); - } else if (_type == DataType.BINARY) { + case BINARY: return data; - } else if (_type == DataType.TEXT) { + case TEXT: return decodeTextValue(data); - } else if (_type == DataType.MONEY) { + case MONEY: return readCurrencyValue(buffer); - } else if (_type == DataType.OLE) { - if (data.length > 0) { - return readLongValue(data); - } - return null; - } else if (_type == DataType.MEMO) { - if (data.length > 0) { - return readLongStringValue(data); - } - return null; - } else if (_type == DataType.NUMERIC) { + case NUMERIC: return readNumericValue(buffer); - } else if (_type == DataType.GUID) { + case GUID: return readGUIDValue(buffer, order); - } else if ((_type == DataType.UNKNOWN_0D) || - (_type == DataType.UNKNOWN_11)) { + case UNKNOWN_0D: + case UNKNOWN_11: // treat like "binary" data return data; - } else if (_type == DataType.COMPLEX_TYPE) { + case COMPLEX_TYPE: return new ComplexValueForeignKeyImpl(this, buffer.getInt()); - } else if(_type.isUnsupported()) { - return rawDataWrapper(data); - } else { + default: throw new IOException("Unrecognized data type: " + _type); } } /** - * @param lvalDefinition Column value that points to an LVAL record - * @return The LVAL data - */ - private byte[] readLongValue(byte[] lvalDefinition) - throws IOException - { - ByteBuffer def = PageChannel.wrap(lvalDefinition); - int lengthWithFlags = def.getInt(); - int length = lengthWithFlags & (~LONG_VALUE_TYPE_MASK); - - byte[] rtn = new byte[length]; - byte type = (byte)((lengthWithFlags & LONG_VALUE_TYPE_MASK) >>> 24); - - if(type == LONG_VALUE_TYPE_THIS_PAGE) { - - // inline long value - def.getInt(); //Skip over lval_dp - def.getInt(); //Skip over unknown - - int rowLen = def.remaining(); - if(rowLen < length) { - // warn the caller, but return whatever we can - LOG.warn(getName() + " value may be truncated: expected length " + - length + " found " + rowLen); - rtn = new byte[rowLen]; - } - - def.get(rtn); - - } else { - - // long value on other page(s) - if (lvalDefinition.length != getFormat().SIZE_LONG_VALUE_DEF) { - throw new IOException("Expected " + getFormat().SIZE_LONG_VALUE_DEF + - " bytes in long value definition, but found " + - lvalDefinition.length); - } - - int rowNum = ByteUtil.getUnsignedByte(def); - int pageNum = ByteUtil.get3ByteInt(def, def.position()); - ByteBuffer lvalPage = getPageChannel().createPageBuffer(); - - switch (type) { - case LONG_VALUE_TYPE_OTHER_PAGE: - { - getPageChannel().readPage(lvalPage, pageNum); - - short rowStart = TableImpl.findRowStart(lvalPage, rowNum, getFormat()); - short rowEnd = TableImpl.findRowEnd(lvalPage, rowNum, getFormat()); - - int rowLen = rowEnd - rowStart; - if(rowLen < length) { - // warn the caller, but return whatever we can - LOG.warn(getName() + " value may be truncated: expected length " + - length + " found " + rowLen); - rtn = new byte[rowLen]; - } - - lvalPage.position(rowStart); - lvalPage.get(rtn); - } - break; - - case LONG_VALUE_TYPE_OTHER_PAGES: - - ByteBuffer rtnBuf = ByteBuffer.wrap(rtn); - int remainingLen = length; - while(remainingLen > 0) { - lvalPage.clear(); - getPageChannel().readPage(lvalPage, pageNum); - - short rowStart = TableImpl.findRowStart(lvalPage, rowNum, getFormat()); - short rowEnd = TableImpl.findRowEnd(lvalPage, rowNum, getFormat()); - - // read next page information - lvalPage.position(rowStart); - rowNum = ByteUtil.getUnsignedByte(lvalPage); - pageNum = ByteUtil.get3ByteInt(lvalPage); - - // update rowEnd and remainingLen based on chunkLength - int chunkLength = (rowEnd - rowStart) - 4; - if(chunkLength > remainingLen) { - rowEnd = (short)(rowEnd - (chunkLength - remainingLen)); - chunkLength = remainingLen; - } - remainingLen -= chunkLength; - - lvalPage.limit(rowEnd); - rtnBuf.put(lvalPage); - } - - break; - - default: - throw new IOException("Unrecognized long value type: " + type); - } - } - - return rtn; - } - - /** - * @param lvalDefinition Column value that points to an LVAL record - * @return The LVAL data - */ - private String readLongStringValue(byte[] lvalDefinition) - throws IOException - { - byte[] binData = readLongValue(lvalDefinition); - if(binData == null) { - return null; - } - return decodeTextValue(binData); - } - - /** * Decodes "Currency" values. * * @param buffer Column value that points to currency data @@ -820,11 +695,22 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { fixNumericByteOrder(tmpArr); } - BigInteger intVal = new BigInteger(tmpArr); + return toBigDecimal(tmpArr, negate, getScale()); + } + + static BigDecimal toBigDecimal(byte[] bytes, boolean negate, int scale) + { + if((bytes[0] & 0x80) != 0) { + // the data is effectively unsigned, but the BigInteger handles it as + // signed twos complement. we need to add an extra byte to the input so + // that it will be treated as unsigned + bytes = ByteUtil.copyOf(bytes, 0, bytes.length + 1, 1); + } + BigInteger intVal = new BigInteger(bytes); if(negate) { intVal = intVal.negate(); } - return new BigDecimal(intVal, getScale()); + return new BigDecimal(intVal, scale); } /** @@ -838,13 +724,13 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { BigDecimal decVal = toBigDecimal(value); inValue = decVal; - boolean negative = (decVal.compareTo(BigDecimal.ZERO) < 0); - if(negative) { + int signum = decVal.signum(); + if(signum < 0) { decVal = decVal.negate(); } // write sign byte - buffer.put(negative ? (byte)0x80 : (byte)0); + buffer.put(signum < 0 ? (byte)0x80 : (byte)0); // adjust scale according to this column type (will cause the an // ArithmeticException if number has too many decimal places) @@ -858,18 +744,8 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { } // convert to unscaled BigInteger, big-endian bytes - byte[] intValBytes = decVal.unscaledValue().toByteArray(); - int maxByteLen = getType().getFixedSize() - 1; - if(intValBytes.length > maxByteLen) { - throw new IOException("Too many bytes for valid BigInteger?"); - } - if(intValBytes.length < maxByteLen) { - byte[] tmpBytes = new byte[maxByteLen]; - System.arraycopy(intValBytes, 0, tmpBytes, - (maxByteLen - intValBytes.length), - intValBytes.length); - intValBytes = tmpBytes; - } + byte[] intValBytes = toUnscaledByteArray( + decVal, getType().getFixedSize() - 1); if(buffer.order() != ByteOrder.BIG_ENDIAN) { fixNumericByteOrder(intValBytes); } @@ -881,6 +757,27 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { } } + static byte[] toUnscaledByteArray(BigDecimal decVal, int maxByteLen) + throws IOException + { + // convert to unscaled BigInteger, big-endian bytes + byte[] intValBytes = decVal.unscaledValue().toByteArray(); + if(intValBytes.length > maxByteLen) { + if((intValBytes[0] == 0) && ((intValBytes.length - 1) == maxByteLen)) { + // in order to not return a negative two's complement value, + // toByteArray() may return an extra leading 0 byte. we are working + // with unsigned values, so we can drop the extra leading 0 + intValBytes = ByteUtil.copyOf(intValBytes, 1, maxByteLen); + } else { + throw new IOException("Too many bytes for valid BigInteger?"); + } + } else if(intValBytes.length < maxByteLen) { + intValBytes = ByteUtil.copyOf(intValBytes, 0, maxByteLen, + (maxByteLen - intValBytes.length)); + } + return intValBytes; + } + /** * Decodes a date value. */ @@ -1008,8 +905,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { /** * Writes a GUID value. */ - private static void writeGUIDValue(ByteBuffer buffer, Object value, - ByteOrder order) + private static void writeGUIDValue(ByteBuffer buffer, Object value) throws IOException { Matcher m = GUID_PATTERN.matcher(toCharSequence(value)); @@ -1019,7 +915,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { ByteBuffer origBuffer = null; byte[] tmpBuf = null; - if(order != ByteOrder.BIG_ENDIAN) { + if(buffer.order() != ByteOrder.BIG_ENDIAN) { // write to a temp buf so we can do some swapping below origBuffer = buffer; tmpBuf = new byte[16]; @@ -1048,151 +944,6 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { static boolean isGUIDValue(Object value) throws IOException { return GUID_PATTERN.matcher(toCharSequence(value)).matches(); } - - /** - * Write an LVAL column into a ByteBuffer inline if it fits, otherwise in - * other data page(s). - * @param value Value of the LVAL column - * @return A buffer containing the LVAL definition and (possibly) the column - * value (unless written to other pages) - * @usage _advanced_method_ - */ - public ByteBuffer writeLongValue(byte[] value, - int remainingRowLength) throws IOException - { - if(value.length > getType().getMaxSize()) { - throw new IOException("value too big for column, max " + - getType().getMaxSize() + ", got " + - value.length); - } - - // determine which type to write - byte type = 0; - int lvalDefLen = getFormat().SIZE_LONG_VALUE_DEF; - if(((getFormat().SIZE_LONG_VALUE_DEF + value.length) <= remainingRowLength) - && (value.length <= getFormat().MAX_INLINE_LONG_VALUE_SIZE)) { - type = LONG_VALUE_TYPE_THIS_PAGE; - lvalDefLen += value.length; - } else if(value.length <= getFormat().MAX_LONG_VALUE_ROW_SIZE) { - type = LONG_VALUE_TYPE_OTHER_PAGE; - } else { - type = LONG_VALUE_TYPE_OTHER_PAGES; - } - - ByteBuffer def = getPageChannel().createBuffer(lvalDefLen); - // take length and apply type to first byte - int lengthWithFlags = value.length | (type << 24); - def.putInt(lengthWithFlags); - - if(type == LONG_VALUE_TYPE_THIS_PAGE) { - // write long value inline - def.putInt(0); - def.putInt(0); //Unknown - def.put(value); - } else { - - ByteBuffer lvalPage = null; - int firstLvalPageNum = PageChannel.INVALID_PAGE_NUMBER; - byte firstLvalRow = 0; - LongValueBufferHolder lvalBufferH = getLongValueBufferHolder(); - - // write other page(s) - switch(type) { - case LONG_VALUE_TYPE_OTHER_PAGE: - lvalPage = lvalBufferH.getLongValuePage(value.length); - firstLvalPageNum = lvalBufferH.getPageNumber(); - firstLvalRow = (byte)TableImpl.addDataPageRow(lvalPage, value.length, - getFormat(), 0); - lvalPage.put(value); - getPageChannel().writePage(lvalPage, firstLvalPageNum); - break; - - case LONG_VALUE_TYPE_OTHER_PAGES: - - ByteBuffer buffer = ByteBuffer.wrap(value); - int remainingLen = buffer.remaining(); - buffer.limit(0); - lvalPage = lvalBufferH.getLongValuePage(remainingLen); - firstLvalPageNum = lvalBufferH.getPageNumber(); - firstLvalRow = (byte)TableImpl.getRowsOnDataPage(lvalPage, getFormat()); - int lvalPageNum = firstLvalPageNum; - ByteBuffer nextLvalPage = null; - int nextLvalPageNum = 0; - int nextLvalRowNum = 0; - while(remainingLen > 0) { - lvalPage.clear(); - - // figure out how much we will put in this page (we need 4 bytes for - // the next page pointer) - int chunkLength = Math.min(getFormat().MAX_LONG_VALUE_ROW_SIZE - 4, - remainingLen); - - // figure out if we will need another page, and if so, allocate it - if(chunkLength < remainingLen) { - // force a new page to be allocated for the chunk after this - lvalBufferH.clear(); - nextLvalPage = lvalBufferH.getLongValuePage( - (remainingLen - chunkLength) + 4); - nextLvalPageNum = lvalBufferH.getPageNumber(); - nextLvalRowNum = TableImpl.getRowsOnDataPage(nextLvalPage, - getFormat()); - } else { - nextLvalPage = null; - nextLvalPageNum = 0; - nextLvalRowNum = 0; - } - - // add row to this page - TableImpl.addDataPageRow(lvalPage, chunkLength + 4, getFormat(), 0); - - // write next page info - lvalPage.put((byte)nextLvalRowNum); // row number - ByteUtil.put3ByteInt(lvalPage, nextLvalPageNum); // page number - - // write this page's chunk of data - buffer.limit(buffer.limit() + chunkLength); - lvalPage.put(buffer); - remainingLen -= chunkLength; - - // write new page to database - getPageChannel().writePage(lvalPage, lvalPageNum); - - // move to next page - lvalPage = nextLvalPage; - lvalPageNum = nextLvalPageNum; - } - break; - - default: - throw new IOException("Unrecognized long value type: " + type); - } - - // update def - def.put(firstLvalRow); - ByteUtil.put3ByteInt(def, firstLvalPageNum); - def.putInt(0); //Unknown - - } - - def.flip(); - return def; - } - - /** - * Writes the header info for a long value page. - */ - private void writeLongValueHeader(ByteBuffer lvalPage) - { - lvalPage.put(PageTypes.DATA); //Page type - lvalPage.put((byte) 1); //Unknown - lvalPage.putShort((short)getFormat().DATA_PAGE_INITIAL_FREE_SPACE); //Free space - lvalPage.put((byte) 'L'); - lvalPage.put((byte) 'V'); - lvalPage.put((byte) 'A'); - lvalPage.put((byte) 'L'); - lvalPage.putInt(0); //unknown - lvalPage.putShort((short)0); // num rows in page - } /** * Passes the given obj through the currently configured validator for this @@ -1230,60 +981,43 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { return ByteBuffer.wrap(((RawData)obj).getBytes()); } + return writeRealData(obj, remainingRowLength, order); + } + + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { if(!isVariableLength() || !getType().isVariableLength()) { return writeFixedLengthField(obj, order); } - // var length column - if(!getType().isLongValue()) { - - // this is an "inline" var length field - switch(getType()) { - case NUMERIC: - // don't ask me why numerics are "var length" columns... - ByteBuffer buffer = getPageChannel().createBuffer( - getType().getFixedSize(), order); - writeNumericValue(buffer, obj); - buffer.flip(); - return buffer; - - case TEXT: - byte[] encodedData = encodeTextValue( - obj, 0, getLengthInUnits(), false).array(); - obj = encodedData; - break; - - case BINARY: - case UNKNOWN_0D: - case UNSUPPORTED_VARLEN: - // should already be "encoded" - break; - default: - throw new RuntimeException("unexpected inline var length type: " + - getType()); - } - - ByteBuffer buffer = ByteBuffer.wrap(toByteArray(obj)); - buffer.order(order); + // this is an "inline" var length field + switch(getType()) { + case NUMERIC: + // don't ask me why numerics are "var length" columns... + ByteBuffer buffer = getPageChannel().createBuffer( + getType().getFixedSize(), order); + writeNumericValue(buffer, obj); + buffer.flip(); return buffer; - } - // var length, long value column - switch(getType()) { - case OLE: + case TEXT: + return encodeTextValue( + obj, 0, getLengthInUnits(), false).order(order); + + case BINARY: + case UNKNOWN_0D: + case UNSUPPORTED_VARLEN: // should already be "encoded" break; - case MEMO: - int maxMemoChars = DataType.MEMO.toUnitSize(DataType.MEMO.getMaxSize()); - obj = encodeTextValue(obj, 0, maxMemoChars, false).array(); - break; default: - throw new RuntimeException("unexpected var length, long value type: " + + throw new RuntimeException("unexpected inline var length type: " + getType()); - } + } - // create long value buffer - return writeLongValue(toByteArray(obj), remainingRowLength); + ByteBuffer buffer = ByteBuffer.wrap(toByteArray(obj)).order(order); + return buffer; } /** @@ -1293,14 +1027,18 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { * @return A buffer containing the bytes * @usage _advanced_method_ */ - public ByteBuffer writeFixedLengthField(Object obj, ByteOrder order) + protected ByteBuffer writeFixedLengthField(Object obj, ByteOrder order) throws IOException { int size = getType().getFixedSize(_columnLength); - // create buffer for data - ByteBuffer buffer = getPageChannel().createBuffer(size, order); + return writeFixedLengthField( + obj, getPageChannel().createBuffer(size, order)); + } + protected ByteBuffer writeFixedLengthField(Object obj, ByteBuffer buffer) + throws IOException + { // since booleans are not written by this method, it's safe to convert any // incoming boolean into an integer. obj = booleanToInteger(obj); @@ -1338,7 +1076,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { buffer.put(encodeTextValue(obj, numChars, numChars, true)); break; case GUID: - writeGUIDValue(buffer, obj, order); + writeGUIDValue(buffer, obj); break; case NUMERIC: // yes, that's right, occasionally numeric values are written as fixed @@ -1369,7 +1107,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { /** * Decodes a compressed or uncompressed text value. */ - private String decodeTextValue(byte[] data) + String decodeTextValue(byte[] data) throws IOException { try { @@ -1464,8 +1202,8 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { /** * Encodes a text value, possibly compressing. */ - private ByteBuffer encodeTextValue(Object obj, int minChars, int maxChars, - boolean forceUncompressed) + ByteBuffer encodeTextValue(Object obj, int minChars, int maxChars, + boolean forceUncompressed) throws IOException { CharSequence text = toCharSequence(obj); @@ -1556,7 +1294,10 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { " (" + _type + ")") .append("number", _columnNumber) .append("length", _columnLength) - .append("variableLength", _variableLength); + .append("variableLength", _variableLength); + if(_calculated) { + sb.append("calculated", _calculated); + } if(_type.isTextual()) { sb.append("compressedUnicode", isCompressedUnicode()) .append("textSortOrder", getTextSortOrder()); @@ -1569,7 +1310,11 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { if(isHyperlink()) { sb.append("hyperlink", isHyperlink()); } - } + } + if(_type.getHasScalePrecision()) { + sb.append("precision", getPrecision()) + .append("scale", getScale()); + } if(_autoNumber) { sb.append("lastAutoNumber", _autoNumberGenerator.getLast()); } @@ -1657,7 +1402,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { * <code>null</code> is returned as 0 and Numbers are converted * using their double representation. */ - private static BigDecimal toBigDecimal(Object value) + static BigDecimal toBigDecimal(Object value) { if(value == null) { return BigDecimal.ZERO; @@ -1770,8 +1515,8 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { private static void fixNumericByteOrder(byte[] bytes) { // fix endianness of each 4 byte segment - for(int i = 0; i < 4; ++i) { - ByteUtil.swap4Bytes(bytes, i * 4); + for(int i = 0; i < bytes.length; i+=4) { + ByteUtil.swap4Bytes(bytes, i); } } @@ -1909,6 +1654,15 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { int cpOffset = format.OFFSET_COLUMN_CODE_PAGE; return ((cpOffset >= 0) ? buffer.getShort(offset + cpOffset) : 0); } + + /** + * Read the extra flags field for a column definition. + */ + static byte readExtraFlags(ByteBuffer buffer, int offset, JetFormat format) + { + int extFlagsOffset = format.OFFSET_COLUMN_EXT_FLAGS; + return ((extFlagsOffset >= 0) ? buffer.get(offset + extFlagsOffset) : 0); + } /** * Writes the sort order info to the given buffer at the current position. @@ -1933,7 +1687,7 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { // for now, the only mutable value this class returns is byte[] return !(value instanceof byte[]); } - + /** * Date subclass which stashes the original date bits, in case we attempt to * re-write the value (will not lose precision). @@ -2192,55 +1946,31 @@ public class ColumnImpl implements Column, Comparable<ColumnImpl> { } /** - * Manages secondary page buffers for long value writing. + * Utility struct for passing params through ColumnImpl constructors. */ - abstract class LongValueBufferHolder + static final class InitArgs { - /** - * Returns a long value data page with space for data of the given length. - */ - public ByteBuffer getLongValuePage(int dataLength) throws IOException { - - TempPageHolder lvalBufferH = getBufferHolder(); - dataLength = Math.min(dataLength, getFormat().MAX_LONG_VALUE_ROW_SIZE); - - ByteBuffer lvalPage = null; - if(lvalBufferH.getPageNumber() != PageChannel.INVALID_PAGE_NUMBER) { - lvalPage = lvalBufferH.getPage(getPageChannel()); - if(TableImpl.rowFitsOnDataPage(dataLength, lvalPage, getFormat())) { - // the current page has space - return lvalPage; - } - } - - // need new page - return findNewPage(dataLength); - } - - protected ByteBuffer findNewPage(int dataLength) throws IOException { - ByteBuffer lvalPage = getBufferHolder().setNewPage(getPageChannel()); - writeLongValueHeader(lvalPage); - return lvalPage; - } - - public int getOwnedPageCount() { - return 0; - } - - /** - * Returns the page number of the current long value data page. - */ - public int getPageNumber() { - return getBufferHolder().getPageNumber(); - } - - /** - * Discards the current the current long value data page. - */ - public void clear() throws IOException { - getBufferHolder().clear(); + public final TableImpl table; + public final ByteBuffer buffer; + public final int offset; + public final String name; + public final int displayIndex; + public final byte colType; + public final byte flags; + public final byte extFlags; + public DataType type; + + InitArgs(TableImpl table, ByteBuffer buffer, int offset, String name, + int displayIndex) { + this.table = table; + this.buffer = buffer; + this.offset = offset; + this.name = name; + this.displayIndex = displayIndex; + + this.colType = buffer.get(offset + table.getFormat().OFFSET_COLUMN_TYPE); + this.flags = buffer.get(offset + table.getFormat().OFFSET_COLUMN_FLAGS); + this.extFlags = readExtraFlags(buffer, offset, table.getFormat()); } - - protected abstract TempPageHolder getBufferHolder(); } } diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/ComplexColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/ComplexColumnImpl.java index 85036a6..61edbaa 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/ComplexColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/ComplexColumnImpl.java @@ -20,9 +20,7 @@ USA package com.healthmarketscience.jackcess.impl; import java.io.IOException; -import java.nio.ByteBuffer; -import com.healthmarketscience.jackcess.DataType; import com.healthmarketscience.jackcess.complex.ComplexColumnInfo; import com.healthmarketscience.jackcess.complex.ComplexValue; import com.healthmarketscience.jackcess.impl.complex.ComplexColumnInfoImpl; @@ -38,12 +36,10 @@ class ComplexColumnImpl extends ColumnImpl /** additional information specific to complex columns */ private final ComplexColumnInfo<? extends ComplexValue> _complexInfo; - ComplexColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags) - throws IOException + ComplexColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); - _complexInfo = ComplexColumnSupport.create(this, buffer, offset); + super(args); + _complexInfo = ComplexColumnSupport.create(this, args.buffer, args.offset); } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/JetFormat.java b/src/main/java/com/healthmarketscience/jackcess/impl/JetFormat.java index ad5eb28..ebc9081 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/JetFormat.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/JetFormat.java @@ -207,7 +207,7 @@ public abstract class JetFormat { public final int OFFSET_COLUMN_CODE_PAGE; public final int OFFSET_COLUMN_COMPLEX_ID; public final int OFFSET_COLUMN_FLAGS; - public final int OFFSET_COLUMN_COMPRESSED_UNICODE; + public final int OFFSET_COLUMN_EXT_FLAGS; public final int OFFSET_COLUMN_LENGTH; public final int OFFSET_COLUMN_VARIABLE_TABLE_INDEX; public final int OFFSET_COLUMN_FIXED_DATA_OFFSET; @@ -342,7 +342,7 @@ public abstract class JetFormat { OFFSET_COLUMN_CODE_PAGE = defineOffsetColumnCodePage(); OFFSET_COLUMN_COMPLEX_ID = defineOffsetColumnComplexId(); OFFSET_COLUMN_FLAGS = defineOffsetColumnFlags(); - OFFSET_COLUMN_COMPRESSED_UNICODE = defineOffsetColumnCompressedUnicode(); + OFFSET_COLUMN_EXT_FLAGS = defineOffsetColumnExtFlags(); OFFSET_COLUMN_LENGTH = defineOffsetColumnLength(); OFFSET_COLUMN_VARIABLE_TABLE_INDEX = defineOffsetColumnVariableTableIndex(); OFFSET_COLUMN_FIXED_DATA_OFFSET = defineOffsetColumnFixedDataOffset(); @@ -445,7 +445,7 @@ public abstract class JetFormat { protected abstract int defineOffsetColumnCodePage(); protected abstract int defineOffsetColumnComplexId(); protected abstract int defineOffsetColumnFlags(); - protected abstract int defineOffsetColumnCompressedUnicode(); + protected abstract int defineOffsetColumnExtFlags(); protected abstract int defineOffsetColumnLength(); protected abstract int defineOffsetColumnVariableTableIndex(); protected abstract int defineOffsetColumnFixedDataOffset(); @@ -611,7 +611,7 @@ public abstract class JetFormat { @Override protected int defineOffsetColumnFlags() { return 13; } @Override - protected int defineOffsetColumnCompressedUnicode() { return 16; } + protected int defineOffsetColumnExtFlags() { return -1; } @Override protected int defineOffsetColumnLength() { return 16; } @Override @@ -836,7 +836,7 @@ public abstract class JetFormat { @Override protected int defineOffsetColumnFlags() { return 15; } @Override - protected int defineOffsetColumnCompressedUnicode() { return 16; } + protected int defineOffsetColumnExtFlags() { return 16; } @Override protected int defineOffsetColumnLength() { return 23; } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/LongValueColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/LongValueColumnImpl.java index 3ac1093..1f89b38 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/LongValueColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/LongValueColumnImpl.java @@ -21,6 +21,7 @@ package com.healthmarketscience.jackcess.impl; import java.io.IOException; import java.nio.ByteBuffer; +import java.nio.ByteOrder; import com.healthmarketscience.jackcess.DataType; @@ -32,19 +33,34 @@ import com.healthmarketscience.jackcess.DataType; */ class LongValueColumnImpl extends ColumnImpl { + /** + * Long value (LVAL) type that indicates that the value is stored on the + * same page + */ + private static final byte LONG_VALUE_TYPE_THIS_PAGE = (byte) 0x80; + /** + * Long value (LVAL) type that indicates that the value is stored on another + * page + */ + private static final byte LONG_VALUE_TYPE_OTHER_PAGE = (byte) 0x40; + /** + * Long value (LVAL) type that indicates that the value is stored on + * multiple other pages + */ + private static final byte LONG_VALUE_TYPE_OTHER_PAGES = (byte) 0x00; + /** + * Mask to apply the long length in order to get the flag bits (only the + * first 2 bits are type flags). + */ + private static final int LONG_VALUE_TYPE_MASK = 0xC0000000; + + /** Holds additional info for writing long values */ private LongValueBufferHolder _lvalBufferH; - LongValueColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags) - throws IOException + LongValueColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); - } - - @Override - LongValueBufferHolder getLongValueBufferHolder() { - return _lvalBufferH; + super(args); } @Override @@ -64,8 +80,363 @@ class LongValueColumnImpl extends ColumnImpl } super.postTableLoadInit(); } + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + switch(getType()) { + case OLE: + if (data.length > 0) { + return readLongValue(data); + } + return null; + case MEMO: + if (data.length > 0) { + return readLongStringValue(data); + } + return null; + default: + throw new RuntimeException("unexpected var length, long value type: " + + getType()); + } + } + + @Override + protected ByteBuffer writeRealData(Object obj, int remainingRowLength, + ByteOrder order) + throws IOException + { + switch(getType()) { + case OLE: + // should already be "encoded" + break; + case MEMO: + int maxMemoChars = DataType.MEMO.toUnitSize(DataType.MEMO.getMaxSize()); + obj = encodeTextValue(obj, 0, maxMemoChars, false).array(); + break; + default: + throw new RuntimeException("unexpected var length, long value type: " + + getType()); + } + + // create long value buffer + return writeLongValue(toByteArray(obj), remainingRowLength); + } + + /** + * @param lvalDefinition Column value that points to an LVAL record + * @return The LVAL data + */ + protected byte[] readLongValue(byte[] lvalDefinition) + throws IOException + { + ByteBuffer def = PageChannel.wrap(lvalDefinition); + int lengthWithFlags = def.getInt(); + int length = lengthWithFlags & (~LONG_VALUE_TYPE_MASK); + + byte[] rtn = new byte[length]; + byte type = (byte)((lengthWithFlags & LONG_VALUE_TYPE_MASK) >>> 24); + + if(type == LONG_VALUE_TYPE_THIS_PAGE) { + + // inline long value + def.getInt(); //Skip over lval_dp + def.getInt(); //Skip over unknown + + int rowLen = def.remaining(); + if(rowLen < length) { + // warn the caller, but return whatever we can + LOG.warn(getName() + " value may be truncated: expected length " + + length + " found " + rowLen); + rtn = new byte[rowLen]; + } + + def.get(rtn); + + } else { + + // long value on other page(s) + if (lvalDefinition.length != getFormat().SIZE_LONG_VALUE_DEF) { + throw new IOException("Expected " + getFormat().SIZE_LONG_VALUE_DEF + + " bytes in long value definition, but found " + + lvalDefinition.length); + } + + int rowNum = ByteUtil.getUnsignedByte(def); + int pageNum = ByteUtil.get3ByteInt(def, def.position()); + ByteBuffer lvalPage = getPageChannel().createPageBuffer(); + + switch (type) { + case LONG_VALUE_TYPE_OTHER_PAGE: + { + getPageChannel().readPage(lvalPage, pageNum); + + short rowStart = TableImpl.findRowStart(lvalPage, rowNum, getFormat()); + short rowEnd = TableImpl.findRowEnd(lvalPage, rowNum, getFormat()); + + int rowLen = rowEnd - rowStart; + if(rowLen < length) { + // warn the caller, but return whatever we can + LOG.warn(getName() + " value may be truncated: expected length " + + length + " found " + rowLen); + rtn = new byte[rowLen]; + } + + lvalPage.position(rowStart); + lvalPage.get(rtn); + } + break; + + case LONG_VALUE_TYPE_OTHER_PAGES: + + ByteBuffer rtnBuf = ByteBuffer.wrap(rtn); + int remainingLen = length; + while(remainingLen > 0) { + lvalPage.clear(); + getPageChannel().readPage(lvalPage, pageNum); + + short rowStart = TableImpl.findRowStart(lvalPage, rowNum, getFormat()); + short rowEnd = TableImpl.findRowEnd(lvalPage, rowNum, getFormat()); + + // read next page information + lvalPage.position(rowStart); + rowNum = ByteUtil.getUnsignedByte(lvalPage); + pageNum = ByteUtil.get3ByteInt(lvalPage); + + // update rowEnd and remainingLen based on chunkLength + int chunkLength = (rowEnd - rowStart) - 4; + if(chunkLength > remainingLen) { + rowEnd = (short)(rowEnd - (chunkLength - remainingLen)); + chunkLength = remainingLen; + } + remainingLen -= chunkLength; + + lvalPage.limit(rowEnd); + rtnBuf.put(lvalPage); + } + + break; + + default: + throw new IOException("Unrecognized long value type: " + type); + } + } + + return rtn; + } /** + * @param lvalDefinition Column value that points to an LVAL record + * @return The LVAL data + */ + private String readLongStringValue(byte[] lvalDefinition) + throws IOException + { + byte[] binData = readLongValue(lvalDefinition); + if((binData == null) || (binData.length == 0)) { + return null; + } + return decodeTextValue(binData); + } + + /** + * Write an LVAL column into a ByteBuffer inline if it fits, otherwise in + * other data page(s). + * @param value Value of the LVAL column + * @return A buffer containing the LVAL definition and (possibly) the column + * value (unless written to other pages) + * @usage _advanced_method_ + */ + protected ByteBuffer writeLongValue(byte[] value, int remainingRowLength) + throws IOException + { + if(value.length > getType().getMaxSize()) { + throw new IOException("value too big for column, max " + + getType().getMaxSize() + ", got " + + value.length); + } + + // determine which type to write + byte type = 0; + int lvalDefLen = getFormat().SIZE_LONG_VALUE_DEF; + if(((getFormat().SIZE_LONG_VALUE_DEF + value.length) <= remainingRowLength) + && (value.length <= getFormat().MAX_INLINE_LONG_VALUE_SIZE)) { + type = LONG_VALUE_TYPE_THIS_PAGE; + lvalDefLen += value.length; + } else if(value.length <= getFormat().MAX_LONG_VALUE_ROW_SIZE) { + type = LONG_VALUE_TYPE_OTHER_PAGE; + } else { + type = LONG_VALUE_TYPE_OTHER_PAGES; + } + + ByteBuffer def = getPageChannel().createBuffer(lvalDefLen); + // take length and apply type to first byte + int lengthWithFlags = value.length | (type << 24); + def.putInt(lengthWithFlags); + + if(type == LONG_VALUE_TYPE_THIS_PAGE) { + // write long value inline + def.putInt(0); + def.putInt(0); //Unknown + def.put(value); + } else { + + ByteBuffer lvalPage = null; + int firstLvalPageNum = PageChannel.INVALID_PAGE_NUMBER; + byte firstLvalRow = 0; + + // write other page(s) + switch(type) { + case LONG_VALUE_TYPE_OTHER_PAGE: + lvalPage = _lvalBufferH.getLongValuePage(value.length); + firstLvalPageNum = _lvalBufferH.getPageNumber(); + firstLvalRow = (byte)TableImpl.addDataPageRow(lvalPage, value.length, + getFormat(), 0); + lvalPage.put(value); + getPageChannel().writePage(lvalPage, firstLvalPageNum); + break; + + case LONG_VALUE_TYPE_OTHER_PAGES: + + ByteBuffer buffer = ByteBuffer.wrap(value); + int remainingLen = buffer.remaining(); + buffer.limit(0); + lvalPage = _lvalBufferH.getLongValuePage(remainingLen); + firstLvalPageNum = _lvalBufferH.getPageNumber(); + firstLvalRow = (byte)TableImpl.getRowsOnDataPage(lvalPage, getFormat()); + int lvalPageNum = firstLvalPageNum; + ByteBuffer nextLvalPage = null; + int nextLvalPageNum = 0; + int nextLvalRowNum = 0; + while(remainingLen > 0) { + lvalPage.clear(); + + // figure out how much we will put in this page (we need 4 bytes for + // the next page pointer) + int chunkLength = Math.min(getFormat().MAX_LONG_VALUE_ROW_SIZE - 4, + remainingLen); + + // figure out if we will need another page, and if so, allocate it + if(chunkLength < remainingLen) { + // force a new page to be allocated for the chunk after this + _lvalBufferH.clear(); + nextLvalPage = _lvalBufferH.getLongValuePage( + (remainingLen - chunkLength) + 4); + nextLvalPageNum = _lvalBufferH.getPageNumber(); + nextLvalRowNum = TableImpl.getRowsOnDataPage(nextLvalPage, + getFormat()); + } else { + nextLvalPage = null; + nextLvalPageNum = 0; + nextLvalRowNum = 0; + } + + // add row to this page + TableImpl.addDataPageRow(lvalPage, chunkLength + 4, getFormat(), 0); + + // write next page info + lvalPage.put((byte)nextLvalRowNum); // row number + ByteUtil.put3ByteInt(lvalPage, nextLvalPageNum); // page number + + // write this page's chunk of data + buffer.limit(buffer.limit() + chunkLength); + lvalPage.put(buffer); + remainingLen -= chunkLength; + + // write new page to database + getPageChannel().writePage(lvalPage, lvalPageNum); + + // move to next page + lvalPage = nextLvalPage; + lvalPageNum = nextLvalPageNum; + } + break; + + default: + throw new IOException("Unrecognized long value type: " + type); + } + + // update def + def.put(firstLvalRow); + ByteUtil.put3ByteInt(def, firstLvalPageNum); + def.putInt(0); //Unknown + + } + + def.flip(); + return def; + } + + /** + * Writes the header info for a long value page. + */ + private void writeLongValueHeader(ByteBuffer lvalPage) + { + lvalPage.put(PageTypes.DATA); //Page type + lvalPage.put((byte) 1); //Unknown + lvalPage.putShort((short)getFormat().DATA_PAGE_INITIAL_FREE_SPACE); //Free space + lvalPage.put((byte) 'L'); + lvalPage.put((byte) 'V'); + lvalPage.put((byte) 'A'); + lvalPage.put((byte) 'L'); + lvalPage.putInt(0); //unknown + lvalPage.putShort((short)0); // num rows in page + } + + + /** + * Manages secondary page buffers for long value writing. + */ + private abstract class LongValueBufferHolder + { + /** + * Returns a long value data page with space for data of the given length. + */ + public ByteBuffer getLongValuePage(int dataLength) throws IOException { + + TempPageHolder lvalBufferH = getBufferHolder(); + dataLength = Math.min(dataLength, getFormat().MAX_LONG_VALUE_ROW_SIZE); + + ByteBuffer lvalPage = null; + if(lvalBufferH.getPageNumber() != PageChannel.INVALID_PAGE_NUMBER) { + lvalPage = lvalBufferH.getPage(getPageChannel()); + if(TableImpl.rowFitsOnDataPage(dataLength, lvalPage, getFormat())) { + // the current page has space + return lvalPage; + } + } + + // need new page + return findNewPage(dataLength); + } + + protected ByteBuffer findNewPage(int dataLength) throws IOException { + ByteBuffer lvalPage = getBufferHolder().setNewPage(getPageChannel()); + writeLongValueHeader(lvalPage); + return lvalPage; + } + + public int getOwnedPageCount() { + return 0; + } + + /** + * Returns the page number of the current long value data page. + */ + public int getPageNumber() { + return getBufferHolder().getPageNumber(); + } + + /** + * Discards the current the current long value data page. + */ + public void clear() throws IOException { + getBufferHolder().clear(); + } + + protected abstract TempPageHolder getBufferHolder(); + } + + /** * Manages a common, shared extra page for long values. This is legacy * behavior from before it was understood that there were additional usage * maps for each columns. diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/MemoColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/MemoColumnImpl.java index 8a9c742..dbd4023 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/MemoColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/MemoColumnImpl.java @@ -20,8 +20,6 @@ USA package com.healthmarketscience.jackcess.impl; import java.io.IOException; -import com.healthmarketscience.jackcess.DataType; -import java.nio.ByteBuffer; /** * ColumnImpl subclass which is used for Memo data types. @@ -44,22 +42,21 @@ class MemoColumnImpl extends LongValueColumnImpl of type MEMO) */ private boolean _hyperlink; - MemoColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags) - throws IOException + MemoColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); + super(args); // co-located w/ precision/scale _sortOrder = readSortOrder( - buffer, offset + getFormat().OFFSET_COLUMN_SORT_ORDER, getFormat()); - _codePage = readCodePage(buffer, offset, getFormat()); + args.buffer, args.offset + getFormat().OFFSET_COLUMN_SORT_ORDER, + getFormat()); + _codePage = readCodePage(args.buffer, args.offset, getFormat()); - _compressedUnicode = ((buffer.get(offset + - getFormat().OFFSET_COLUMN_COMPRESSED_UNICODE) & 1) == 1); + _compressedUnicode = + ((args.extFlags & COMPRESSED_UNICODE_EXT_FLAG_MASK) != 0); // only memo fields can be hyperlinks - _hyperlink = ((flags & HYPERLINK_FLAG_MASK) != 0); + _hyperlink = ((args.flags & HYPERLINK_FLAG_MASK) != 0); } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/NumericColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/NumericColumnImpl.java index 667315a..cb19a42 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/NumericColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/NumericColumnImpl.java @@ -20,8 +20,6 @@ USA package com.healthmarketscience.jackcess.impl; import java.io.IOException; -import com.healthmarketscience.jackcess.DataType; -import java.nio.ByteBuffer; /** * ColumnImpl subclass which is used for numeric data types. @@ -36,14 +34,13 @@ class NumericColumnImpl extends ColumnImpl /** Numeric scale */ private final byte _scale; - NumericColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags) - throws IOException + NumericColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); + super(args); - _precision = buffer.get(offset + getFormat().OFFSET_COLUMN_PRECISION); - _scale = buffer.get(offset + getFormat().OFFSET_COLUMN_SCALE); + _precision = args.buffer.get( + args.offset + getFormat().OFFSET_COLUMN_PRECISION); + _scale = args.buffer.get(args.offset + getFormat().OFFSET_COLUMN_SCALE); } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/PropertyMaps.java b/src/main/java/com/healthmarketscience/jackcess/impl/PropertyMaps.java index 50712bc..bff4472 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/PropertyMaps.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/PropertyMaps.java @@ -448,7 +448,7 @@ public class PropertyMaps implements Iterable<PropertyMapImpl> private class PropColumn extends ColumnImpl { private PropColumn(DataType type) { - super(null, type, 0, 0, 0); + super(null, null, type, 0, 0, 0); } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/TableImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/TableImpl.java index 3f22847..3ab142c 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/TableImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/TableImpl.java @@ -692,11 +692,11 @@ public class TableImpl implements Table NullMask nullMask = rowState.getNullMask(rowBuffer); boolean isNull = nullMask.isNull(column); - if(column.getType() == DataType.BOOLEAN) { + if(column.storeInNullMask()) { // Boolean values are stored in the null mask. see note about // caching below return rowState.setRowCacheValue(column.getColumnIndex(), - Boolean.valueOf(!isNull)); + column.readFromNullMask(isNull)); } else if(isNull) { // well, that's easy! (no need to update cache w/ null) return null; @@ -995,8 +995,8 @@ public class TableImpl implements Table // now, create the table definition PageChannel pageChannel = creator.getPageChannel(); - ByteBuffer buffer = pageChannel .createBuffer(Math.max(totalTableDefSize, - format.PAGE_SIZE)); + ByteBuffer buffer = pageChannel.createBuffer(Math.max(totalTableDefSize, + format.PAGE_SIZE)); writeTableDefinitionHeader(creator, buffer, totalTableDefSize); if(creator.hasIndexes()) { @@ -1303,10 +1303,19 @@ public class TableImpl implements Table { int colOffset = getFormat().OFFSET_INDEX_DEF_BLOCK + _indexCount * getFormat().SIZE_INDEX_DEFINITION; + + tableBuffer.position(colOffset + + (columnCount * getFormat().SIZE_COLUMN_HEADER)); + List<String> colNames = new ArrayList<String>(columnCount); + for (int i = 0; i < columnCount; i++) { + colNames.add(readName(tableBuffer)); + } + int dispIndex = 0; for (int i = 0; i < columnCount; i++) { ColumnImpl column = ColumnImpl.create(this, tableBuffer, - colOffset + (i * getFormat().SIZE_COLUMN_HEADER), dispIndex++); + colOffset + (i * getFormat().SIZE_COLUMN_HEADER), colNames.get(i), + dispIndex++); _columns.add(column); if(column.isVariableLength()) { // also shove it in the variable columns list, which is ordered @@ -1314,12 +1323,7 @@ public class TableImpl implements Table _varColumns.add(column); } } - tableBuffer.position(colOffset + - (columnCount * getFormat().SIZE_COLUMN_HEADER)); - for (int i = 0; i < columnCount; i++) { - ColumnImpl column = _columns.get(i); - column.setName(readName(tableBuffer)); - } + Collections.sort(_columns); getAutoNumberColumns(); @@ -2056,10 +2060,9 @@ public class TableImpl implements Table Object rowValue = col.getRowValue(rowArray); - if (col.getType() == DataType.BOOLEAN) { + if (col.storeInNullMask()) { - if(ColumnImpl.toBooleanValue(rowValue)) { - //Booleans are stored in the null mask + if(col.writeToNullMask(rowValue)) { nullMask.markNotNull(col); } rowValue = null; diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/TextColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/TextColumnImpl.java index 0966d5b..d7d169f 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/TextColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/TextColumnImpl.java @@ -20,8 +20,6 @@ USA package com.healthmarketscience.jackcess.impl; import java.io.IOException; -import com.healthmarketscience.jackcess.DataType; -import java.nio.ByteBuffer; /** * ColumnImpl subclass which is used for Text data types. @@ -38,19 +36,18 @@ class TextColumnImpl extends ColumnImpl /** the code page for a text field (for certain db versions) */ private final short _codePage; - TextColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags) - throws IOException + TextColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); + super(args); // co-located w/ precision/scale _sortOrder = readSortOrder( - buffer, offset + getFormat().OFFSET_COLUMN_SORT_ORDER, getFormat()); - _codePage = readCodePage(buffer, offset, getFormat()); + args.buffer, args.offset + getFormat().OFFSET_COLUMN_SORT_ORDER, + getFormat()); + _codePage = readCodePage(args.buffer, args.offset, getFormat()); - _compressedUnicode = ((buffer.get(offset + - getFormat().OFFSET_COLUMN_COMPRESSED_UNICODE) & 1) == 1); + _compressedUnicode = + ((args.extFlags & COMPRESSED_UNICODE_EXT_FLAG_MASK) != 0); } @Override diff --git a/src/main/java/com/healthmarketscience/jackcess/impl/UnsupportedColumnImpl.java b/src/main/java/com/healthmarketscience/jackcess/impl/UnsupportedColumnImpl.java index 5165a53..6418ba9 100644 --- a/src/main/java/com/healthmarketscience/jackcess/impl/UnsupportedColumnImpl.java +++ b/src/main/java/com/healthmarketscience/jackcess/impl/UnsupportedColumnImpl.java @@ -20,9 +20,8 @@ USA package com.healthmarketscience.jackcess.impl; import java.io.IOException; -import java.nio.ByteBuffer; +import java.nio.ByteOrder; -import com.healthmarketscience.jackcess.DataType; /** * ColumnImpl subclass which is used for unknown/unsupported data types. @@ -34,18 +33,19 @@ class UnsupportedColumnImpl extends ColumnImpl { private final byte _originalType; - UnsupportedColumnImpl(TableImpl table, ByteBuffer buffer, int offset, - int displayIndex, DataType type, byte flags, - byte originalType) - throws IOException + UnsupportedColumnImpl(InitArgs args) throws IOException { - super(table, buffer, offset, displayIndex, type, flags); - _originalType = originalType; + super(args); + _originalType = args.colType; } @Override byte getOriginalDataType() { return _originalType; } - + + @Override + public Object read(byte[] data, ByteOrder order) throws IOException { + return rawDataWrapper(data); + } } |