/** @see Openable#openBuffer(IProgressMonitor, Object) */
protected IBuffer openBuffer(IProgressMonitor pm, Object info) throws JavaModelException {
// create buffer
IBuffer buffer = this.owner.createBuffer(this);
if (buffer == null) return null;
// set the buffer source
if (buffer.getCharacters() == null) {
IBuffer classFileBuffer = this.classFile.getBuffer();
if (classFileBuffer != null) {
buffer.setContents(classFileBuffer.getCharacters());
} else {
// Disassemble
IClassFileReader reader =
ToolFactory.createDefaultClassFileReader(this.classFile, IClassFileReader.ALL);
Disassembler disassembler = new Disassembler();
String contents =
disassembler.disassemble(
reader,
Util.getLineSeparator("", getJavaProject()),
ClassFileBytesDisassembler.WORKING_COPY); // $NON-NLS-1$
buffer.setContents(contents);
}
}
// add buffer to buffer cache
BufferManager bufManager = getBufferManager();
bufManager.addBuffer(buffer);
// listen to buffer changes
buffer.addBufferChangedListener(this);
return buffer;
}
/** Loads the buffer via SourceMapper, and maps it in SourceMapper */
private IBuffer mapSource(
SourceMapper mapper, ClassFileElementInfo info, IClassFile bufferOwner) {
char[] contents =
mapper.findSource(getPart(), info.getEglFileName(), info.getCaseSensitivePackageName());
// create buffer
BufferManager bufManager = getBufferManager();
IBuffer buffer = bufManager.createBuffer(bufferOwner);
if (buffer == null) return null;
bufManager.addBuffer(buffer);
if (contents != null) {
// set the buffer source
if (buffer.getCharacters() == null) {
buffer.setContents(contents);
}
} else {
if (buffer.getCharacters() == null) {
String result = EGLModelResources.eglarNoSourceAttachmentContent;
buffer.setContents(result.toCharArray());
}
}
buffer.addBufferChangedListener(this);
return buffer;
}
@Test
public void testInlining() throws Exception {
BufferManager buffMgr = BufferManagerFactory.getStandaloneBufferManager();
FileStore fs = buffMgr.createFileStore("temp");
ClobType clob =
new ClobType(
new ClobImpl(
new InputStreamFactory() {
@Override
public InputStream getInputStream() throws IOException {
return new ReaderInputStream(
new StringReader("small"), Charset.forName(Streamable.ENCODING));
}
},
5));
assertEquals(StorageMode.OTHER, InputStreamFactory.getStorageMode(clob));
LobManager lobManager = new LobManager(new int[] {0}, fs);
lobManager.updateReferences(Arrays.asList(clob), ReferenceMode.CREATE);
assertEquals(StorageMode.MEMORY, InputStreamFactory.getStorageMode(clob));
}
/** Write a document out */
public void writeDocument(DocumentImpl doc) throws ShutdownException {
int start = doc.getIndex();
int offset = BufferManager.getOffset(start);
Page page = BufferManager.getPage(start);
int size = page.documentSize(offset);
while (size > 0) {
// Fill our buffer with events
short nRead = (short) Math.min(size, MAX_EVENTS - current_offset);
page.copyEvents(offset, nRead, current_offset, types, strings);
size -= nRead;
offset += nRead;
int pageSize = BufferManager.getPageSize();
if (size > 0 && offset >= pageSize)
do {
offset -= pageSize;
page = page.getNext();
} while (offset >= pageSize);
current_offset += nRead;
assert current_offset == MAX_EVENTS || size == 0;
// Write out as many full pages as possible
writeOutPages(false);
}
}
public void insertRecord(String tableName, List<String> row)
throws TableNotFoundException, UniqueKeyException, Exception {
Table table = cm.getTable(tableName);
if (table == null) throw new TableNotFoundException(tableName);
byte[] bytesToInsert = getInsertBytes(table, row);
// check uniqueness
ArrayList<Index> allTableIndices = cm.getAllIndicesOfTable(tableName);
for (Index idx : allTableIndices) {
byte[] key = Arrays.copyOfRange(bytesToInsert, idx.pos, idx.pos + idx.columnLength);
if (im.searchEqual(idx, key) != null) throw new UniqueKeyException(idx.indexName);
}
// Use free list for insertion and deletion
int recordSize = table.totalLength + POINTER_SIZE;
while (true) {
// BufferNode bn = bm.getIfIsInBuffer(table.name + ".table", table.nextInsertBlock);
BufferNode bn = bm.getBufferNode(table.name + ".table", table.nextInsertBlock);
byte[] block = bn.data;
int insertIndex = getInsertIndex(block);
int pos = getPositionFromIndex(table, insertIndex);
// No free space, get a new block
if (pos + recordSize > BufferManager.BLOCK_SIZE) {
table.nextInsertBlock++;
if (table.nextInsertBlock >= table.blockNum) bm.addBlockInFile(table);
continue;
}
// Write to buffer
block[pos] = NOT_EMPTY;
System.arraycopy(bytesToInsert, 0, block, pos + 1, table.totalLength);
// Modify available insert index value and increase record number
int nextIndex = getNextInsertIndex(block, table, insertIndex);
setInsertIndex(block, nextIndex);
incRecordNum(block);
// Update index
for (Attribute attr : table.attributes) {
if (!attr.index.equals("")) { // has index
Index idx = cm.getIndex(attr.index);
byte[] key = Arrays.copyOfRange(bytesToInsert, idx.pos, idx.pos + idx.columnLength);
im.insertKey(idx, key, table.nextInsertBlock, pos);
}
}
bn.isWritten = true;
return;
}
}
public void selectRecord(String tableName, ArrayList<Condition> conditions)
throws TableNotFoundException {
Table table = cm.getTable(tableName);
if (table == null) throw new TableNotFoundException(tableName);
Data selectResult = new Data();
for (int blockOffset = 0; blockOffset < table.blockNum; blockOffset++) {
BufferNode bn = bm.getBufferNode(table.name + ".table", blockOffset);
byte[] block = bn.data;
int recordNum = getRecordNum(block);
int recordIndex = 0;
int accessedRecordNum = 0;
while (accessedRecordNum < recordNum) {
int pos = getPositionFromIndex(table, recordIndex);
if (block[pos] == EMPTY) { // record is empty, skip
recordIndex++;
continue;
}
byte[] recordBytes = bn.getBytes(pos + 1, table.totalLength);
if (matchAllCond(table, recordBytes, conditions)) {
byte[] bytes = bn.getBytes(pos + 1, table.totalLength);
selectResult.add(new Row(bytesToString(table, bytes)));
}
recordIndex++;
accessedRecordNum++;
}
}
displaySelectResult(table, selectResult);
}
public int deleteRecord(String tableName, List<Condition> conditions)
throws TableNotFoundException, Exception {
Table table = cm.getTable(tableName);
if (table == null) throw new TableNotFoundException(tableName);
int count = 0;
for (int blockOffset = 0; blockOffset < table.blockNum; blockOffset++) {
BufferNode bn = bm.getBufferNode(table.name + ".table", blockOffset);
byte[] block = bn.data;
int recordNum = getRecordNum(block);
int recordIndex = 0;
int accessedRecordNum = 0;
int nextDeleted = getInsertIndex(block);
int prevDeleted = -1;
ArrayList<Index> allTableIndices = cm.getAllIndicesOfTable(tableName);
while (accessedRecordNum < recordNum) {
int pos = getPositionFromIndex(table, recordIndex);
if (block[pos] == EMPTY) { // record is empty, skip
recordIndex++;
continue;
}
byte[] recordBytes = bn.getBytes(pos + 1, table.totalLength);
if (matchAllCond(table, recordBytes, conditions)) {
block[pos] = EMPTY;
if (recordIndex < nextDeleted) {
setNextInsertIndex(block, table, prevDeleted, recordIndex);
setNextInsertIndex(block, table, recordIndex, nextDeleted);
prevDeleted = recordIndex;
} else {
int nextOfNext = getNextInsertIndex(block, table, nextDeleted);
setNextInsertIndex(block, table, nextDeleted, recordIndex);
setNextInsertIndex(block, table, recordIndex, nextOfNext);
nextDeleted = nextOfNext;
prevDeleted = recordIndex;
}
decRecordNum(block);
// there remains some space for insertion
if (table.nextInsertBlock > blockOffset) table.nextInsertBlock = blockOffset;
// Delete in index
for (Index idx : allTableIndices) {
byte[] key = Arrays.copyOfRange(recordBytes, idx.pos, idx.pos + idx.columnLength);
im.deleteKey(idx, key);
}
bn.isWritten = true;
count++;
}
recordIndex++;
accessedRecordNum++;
}
}
return count;
}
/**
* {@inheritDoc}
*
* @see java.net.URLStreamHandler#openConnection(java.net.URL)
*/
@Override
protected URLConnection openConnection(URL u) throws IOException {
try {
return new MemoryURLConnection(u, BufferManager.getInstance().getMemBuffer(u));
} catch (Exception ex) {
throw new IOException("Unknown URL: " + u);
}
}
public void createTable(Table table) {
String filename = table.name + ".table";
try {
File f = new File(filename);
f.createNewFile();
bm.addBlockInFile(table);
} catch (Exception e) {
e.printStackTrace();
}
}
/** Loads the buffer via SourceMapper, and maps it in SourceMapper */
private IBuffer mapSource(SourceMapper mapper, IBinaryType info, IClassFile bufferOwner) {
char[] contents = mapper.findSource(getType(), info);
if (contents != null) {
// create buffer
IBuffer buffer = BufferManager.createBuffer(bufferOwner);
if (buffer == null) return null;
BufferManager bufManager = getBufferManager();
bufManager.addBuffer(buffer);
// set the buffer source
if (buffer.getCharacters() == null) {
buffer.setContents(contents);
}
// listen to buffer changes
buffer.addBufferChangedListener(this);
// do the source mapping
mapper.mapSource(getOuterMostEnclosingType(), contents, info);
return buffer;
} else {
// create buffer
IBuffer buffer = BufferManager.createNullBuffer(bufferOwner);
if (buffer == null) return null;
BufferManager bufManager = getBufferManager();
bufManager.addBuffer(buffer);
// listen to buffer changes
buffer.addBufferChangedListener(this);
return buffer;
}
}
/**
* {@inheritDoc}
*
* @see java.net.URLStreamHandler#setURL(java.net.URL, java.lang.String, java.lang.String, int,
* java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
*/
@Override
protected void setURL(
URL u,
String protocol,
String host,
int port,
String authority,
String userInfo,
String path,
String query,
String ref) {
if (path == null || path.trim().isEmpty()) {
path = "" + counter.incrementAndGet();
}
if (host == null || host.trim().isEmpty()) {
host = "localhost";
}
super.setURL(u, protocol, host, port, authority, userInfo, path, query, ref);
u.hashCode();
BufferManager.getInstance().registerMemBuffer(u);
}
@Test
public void testLobPeristence() throws Exception {
BufferManager buffMgr = BufferManagerFactory.getStandaloneBufferManager();
FileStore fs = buffMgr.createFileStore("temp");
ClobType clob =
new ClobType(
new ClobImpl(
new InputStreamFactory() {
@Override
public InputStream getInputStream() throws IOException {
return new ReaderInputStream(
new StringReader("Clob contents One"),
Charset.forName(Streamable.ENCODING));
}
},
-1));
BlobType blob =
new BlobType(
new BlobImpl(
new InputStreamFactory() {
@Override
public InputStream getInputStream() throws IOException {
return new ReaderInputStream(
new StringReader("Blob contents Two"),
Charset.forName(Streamable.ENCODING));
}
}));
BlobType blobEmpty =
new BlobType(
new BlobImpl(
new InputStreamFactory() {
@Override
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(new byte[0]);
}
}));
FileStore fs1 = buffMgr.createFileStore("blob");
FileStoreInputStreamFactory fsisf = new FileStoreInputStreamFactory(fs1, Streamable.ENCODING);
FileStoreOutputStream fsos = fsisf.getOuputStream();
byte[] b = new byte[DataTypeManager.MAX_LOB_MEMORY_BYTES + 1];
fsos.write(b);
fsos.close();
BlobType blob1 = new BlobType(new BlobImpl(fsisf));
assertNotNull(blob1.getReferenceStreamId());
LobManager lobManager = new LobManager(new int[] {0, 1, 2, 3}, fs);
lobManager.setMaxMemoryBytes(4);
List<?> tuple = Arrays.asList(clob, blob, blob1, blobEmpty);
lobManager.updateReferences(tuple, ReferenceMode.CREATE);
assertNotNull(blob1.getReferenceStreamId());
lobManager.persist();
Streamable<?> lob = lobManager.getLobReference(clob.getReferenceStreamId());
assertTrue(lob.getClass().isAssignableFrom(ClobType.class));
ClobType clobRead = (ClobType) lob;
assertEquals(ClobType.getString(clob), ClobType.getString(clobRead));
assertTrue(clobRead.length() != -1);
lob = lobManager.getLobReference(blob.getReferenceStreamId());
assertTrue(lob.getClass().isAssignableFrom(BlobType.class));
BlobType blobRead = (BlobType) lob;
assertTrue(
Arrays.equals(
ObjectConverterUtil.convertToByteArray(blob.getBinaryStream()),
ObjectConverterUtil.convertToByteArray(blobRead.getBinaryStream())));
lobManager.updateReferences(tuple, ReferenceMode.REMOVE);
assertEquals(0, lobManager.getLobCount());
}
@Override
public DrillBuf getManagedBuffer() {
return bufferManager.getManagedBuffer();
}
