LBRYFoundation/lbry-database-java
1
0
Fork 0
mirror of https://github.com/LBRYFoundation/lbry-database-java.git synced 2025-08-23 09:27:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix database rows

Browse source
This commit is contained in:
Ben van Hartingsveldt 2024-09-21 00:03:04 +02:00
parent 26f7b360a2
commit 047df3a149
No known key found for this signature in database
GPG key ID: 261AA214130CE7AB
44 changed files with 675 additions and 497 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

340
src/main/java/com/lbry/database/BasePrefixDB.java Normal file
View file

@ -0,0 +1,340 @@
package com.lbry.database;
import com.lbry.database.keys.UndoKey;
import com.lbry.database.revert.RevertibleDelete;
import com.lbry.database.revert.RevertibleOperation;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.revert.RevertiblePut;
import org.rocksdb.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;
/**
* Base class for a revertible RocksDB database (a RocksDB database where each set of applied changes can be undone).
*/
public abstract class BasePrefixDB{
private final List<ColumnFamilyHandle> columnFamilyHandles;
protected final RocksDB database;
protected final RevertibleOperationStack operationStack;
private final int maxUndoDepth;
public BasePrefixDB(String path, int maxOpenFiles, String secondaryPath, int maxUndoDepth, Set<Byte> unsafePrefixes, boolean enforceIntegrity) throws RocksDBException{
List<ColumnFamilyDescriptor> columnFamilyDescriptors = new ArrayList<>();
columnFamilyDescriptors.add(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY));
for(Prefix prefix : Prefix.values()){
byte[] name = new byte[]{prefix.getValue()};
ColumnFamilyDescriptor descriptor = new ColumnFamilyDescriptor(name);
columnFamilyDescriptors.add(descriptor);
}
this.columnFamilyHandles = new ArrayList<>();
Options options = new Options()
.setCreateIfMissing(true)
.setUseFsync(false)
.setTargetFileSizeBase(33554432)
.setMaxOpenFiles(secondaryPath==null?maxOpenFiles:-1)
.setCreateMissingColumnFamilies(true);
this.database = RocksDB.open(new DBOptions(options),path,columnFamilyDescriptors,this.columnFamilyHandles);
this.operationStack = new RevertibleOperationStack((byte[] key) -> {
try{
return Optional.of(this.get(key));
}catch(RocksDBException e){}
return Optional.empty();
},(List<byte[]> keys) -> {
List<Optional<byte[]>> optionalKeys = new ArrayList<>();
for(byte[] key : keys){
optionalKeys.add(Optional.of(key));
}
return optionalKeys;
},unsafePrefixes,enforceIntegrity);
this.maxUndoDepth = maxUndoDepth;
}
/**
* Write staged changes to the database without keeping undo information. Changes written cannot be undone.
*/
public void unsafeCommit() throws RocksDBException {
this.applyStash();
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
if(this.operationStack.length()!=0){
return;
}
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
this.database.write(writeOptions,batch);
}
}finally{
writeOptions.close();
this.operationStack.clear();
}
}
public void commit(int height,byte[] blockHash) throws RocksDBException{
this.applyStash();
byte[] undoOperations = this.operationStack.getUndoOperations();
List<byte[]> deleteUndos = new ArrayList<>();
if(height>this.maxUndoDepth){
byte[] upperBound = ByteBuffer.allocate(1+8).order(ByteOrder.BIG_ENDIAN).put(Prefix.UNDO.getValue()).putLong(height-this.maxUndoDepth).array();
RocksIterator iterator = this.database.newIterator(new ReadOptions().setIterateUpperBound(new Slice(upperBound)));
iterator.seek(ByteBuffer.allocate(1+8).order(ByteOrder.BIG_ENDIAN).put(Prefix.UNDO.getValue()).array());
while(iterator.isValid()){
deleteUndos.add(iterator.key());
iterator.next();
}
}
try{
ColumnFamilyHandle undoColumnFamily = this.getColumnFamilyByPrefix(Prefix.UNDO);
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
}
for(byte[] undoToDelete : deleteUndos){
batch.delete(undoColumnFamily,undoToDelete);
}
UndoKey undoKey = new UndoKey();
undoKey.height = height;
undoKey.block_hash = blockHash;
byte[] undoKeyBytes = ((PrefixDB)this).undo.packKey(undoKey);
batch.put(undoColumnFamily,undoKeyBytes,undoOperations);
this.database.write(writeOptions,batch);
}finally{
writeOptions.close();
this.operationStack.clear();
}
}finally{
this.operationStack.clear();
}
}
public void rollback(int height,byte[] blockHash) throws RocksDBException{
UndoKey undoKey = new UndoKey();
undoKey.height = height;
undoKey.block_hash = blockHash;
byte[] undoKeyBytes = ((PrefixDB)this).undo.packKey(undoKey);
ColumnFamilyHandle undoColumnFamily = this.getColumnFamilyByPrefix(Prefix.UNDO);
byte[] undoInfo = this.database.get(undoColumnFamily,undoKeyBytes);
this.operationStack.applyPackedUndoOperations(undoInfo);
this.operationStack.validateAndApplyStashedOperations();
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
this.database.write(writeOptions,batch);
}
// batch.delete(undoKey)
}finally{
writeOptions.close();
this.operationStack.clear();
}
}
public void applyStash(){
this.operationStack.validateAndApplyStashedOperations();
}
/**
* Get value by prefixed key.
* @param key The prefixed key.
* @return The value or null.
* @throws RocksDBException The exception.
*/
public byte[] get(byte[] key) throws RocksDBException{
return this.get(key,true);
}
/**
* Get value by prefixed key.
* @param key The prefixed key.
* @param fillCache Fill cache option.
* @return The value or null.
* @throws RocksDBException The exception.
*/
public byte[] get(byte[] key,boolean fillCache) throws RocksDBException{
ColumnFamilyHandle columnFamily = null;
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(key.length>0 && Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamily = handle;
break;
}
}
ReadOptions options = new ReadOptions().setFillCache(fillCache);
byte[] value = this.database.get(columnFamily,options,key);
options.close();
return value;
}
/**
* Get multiple values by prefixed keys.
* @param keys The prefixed keys.
* @return The values.
* @throws RocksDBException The exception.
*/
public List<byte[]> multiGet(List<byte[]> keys) throws RocksDBException{
return this.multiGet(keys,true);
}
/**
* Get multiple values by prefixed keys.
* @param keys The prefixed keys.
* @param fillCache Fill cache option.
* @return The values.
* @throws RocksDBException The exception.
*/
public List<byte[]> multiGet(List<byte[]> keys,boolean fillCache) throws RocksDBException{
List<ColumnFamilyHandle> columnFamilies = new ArrayList<>();
for(byte[] key : keys){
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamilies.add(handle);
break;
}
}
}
ReadOptions options = new ReadOptions().setFillCache(fillCache);
List<byte[]> values = this.database.multiGetAsList(options,columnFamilies,keys);
options.close();
return values;
}
/**
* Stash multiple items for deletion.
* @param items The items.
*/
public void multiDelete(Map<byte[],byte[]> items){
this.operationStack.stashOperations(items.entrySet().stream().map((entry) -> new RevertibleDelete(entry.getKey(),entry.getValue())).toArray(RevertibleOperation[]::new));
}
/**
* Stash multiple items for putting.
* @param items The items.
*/
public void multiPut(Map<byte[],byte[]> items){
this.operationStack.stashOperations(items.entrySet().stream().map((entry) -> new RevertiblePut(entry.getKey(),entry.getValue())).toArray(RevertibleOperation[]::new));
}
public RocksIterator iterator(){
return this.iterator(null,null);
}
public RocksIterator iterator(ReadOptions readOptions){
return this.iterator(null,readOptions);
}
public RocksIterator iterator(ColumnFamilyHandle columnFamily){
return this.iterator(columnFamily,null);
}
public RocksIterator iterator(ColumnFamilyHandle columnFamily,ReadOptions readOptions){
if(columnFamily==null && readOptions==null){
return this.database.newIterator();
}
if(columnFamily==null){
return this.database.newIterator(readOptions);
}
if(readOptions==null){
return this.database.newIterator(columnFamily);
}
return this.database.newIterator(columnFamily,readOptions);
}
/**
* Close database.
*/
public void close(){
this.database.close();
}
public void tryCatchUpWithPrimary() throws RocksDBException{
this.database.tryCatchUpWithPrimary();
}
/**
* Stash item for deletion.
* @param key The item prefixed key.
* @param value The value.
*/
public void stashRawDelete(byte[] key,byte[] value){
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertibleDelete(key,value),
});
}
/**
* Stash item for putting.
* @param key The item prefixed key.
* @param value The value.
*/
public void stashRawPut(byte[] key,byte[] value){
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertiblePut(key,value),
});
}
public int estimateNumKeys() throws RocksDBException{
return this.estimateNumKeys(null);
}
public int estimateNumKeys(ColumnFamilyHandle columnFamily) throws RocksDBException{
return Integer.parseInt(this.database.getProperty(columnFamily,"rocksdb.estimate-num-keys"));
}
public boolean keyMayExist(byte[] key) throws RocksDBException{
ColumnFamilyHandle columnFamily = null;
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(key.length>0 && Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamily = handle;
break;
}
}
return this.database.keyMayExist(columnFamily,ByteBuffer.wrap(key));
}
public List<ColumnFamilyHandle> getColumnFamilyHandles(){
return new ArrayList<>(this.columnFamilyHandles);
}
public ColumnFamilyHandle getColumnFamilyByPrefix(Prefix prefix) throws RocksDBException{
if(prefix==null){
return this.database.getDefaultColumnFamily();
}
for(ColumnFamilyHandle columnFamily : this.columnFamilyHandles){
if(Arrays.equals(columnFamily.getName(),new byte[]{prefix.getValue()})){
return columnFamily;
}
}
return null;
}
}

404
src/main/java/com/lbry/database/PrefixDB.java
View file

@ -1,27 +1,15 @@
package com.lbry.database;
import com.lbry.database.keys.UndoKey;
import com.lbry.database.revert.RevertibleDelete;
import com.lbry.database.revert.RevertibleOperation;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.revert.RevertiblePut;
import com.lbry.database.rows.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;
import java.util.Set;
import org.rocksdb.*;
import org.rocksdb.RocksDBException;
/**
* Class for a revertible RocksDB database: A RocksDB database where each set of applied changes can be undone.
*/
public class PrefixDB{
private final List<ColumnFamilyHandle> columnFamilyHandles;
private final RocksDB database;
private final RevertibleOperationStack operationStack;
private final int maxUndoDepth;
public class PrefixDB extends BasePrefixDB{
public final ClaimToSupportPrefixRow claim_to_support;
public final SupportToClaimPrefixRow support_to_claim;
@ -79,356 +67,52 @@ public class PrefixDB{
this(path,maxOpenFiles,secondaryPath,maxUndoDepth,null);
}
public PrefixDB(String path,int maxOpenFiles,String secondaryPath,int maxUndoDepth,Set<Byte> unsafePrefixes) throws RocksDBException{
public PrefixDB(String path, int maxOpenFiles, String secondaryPath, int maxUndoDepth, Set<Byte> unsafePrefixes) throws RocksDBException{
this(path,maxOpenFiles,secondaryPath,maxUndoDepth,unsafePrefixes,true);
}
public PrefixDB(String path,int maxOpenFiles,String secondaryPath,int maxUndoDepth,Set<Byte> unsafePrefixes,boolean enforceIntegrity) throws RocksDBException{
List<ColumnFamilyDescriptor> columnFamilyDescriptors = new ArrayList<>();
columnFamilyDescriptors.add(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY));
for(Prefix prefix : Prefix.values()){
byte[] name = new byte[]{prefix.getValue()};
ColumnFamilyDescriptor descriptor = new ColumnFamilyDescriptor(name);
columnFamilyDescriptors.add(descriptor);
}
super(path,maxOpenFiles,secondaryPath,maxUndoDepth,unsafePrefixes,enforceIntegrity);
this.columnFamilyHandles = new ArrayList<>();
Options options = new Options()
.setCreateIfMissing(true)
.setUseFsync(false)
.setTargetFileSizeBase(33554432)
.setMaxOpenFiles(secondaryPath==null?maxOpenFiles:-1)
.setCreateMissingColumnFamilies(true);
this.database = RocksDB.open(new DBOptions(options),path,columnFamilyDescriptors,this.columnFamilyHandles);
this.operationStack = new RevertibleOperationStack((byte[] key) -> {
try{
return Optional.of(this.get(key));
}catch(RocksDBException e){}
return Optional.empty();
},(List<byte[]> keys) -> {
List<Optional<byte[]>> optionalKeys = new ArrayList<>();
for(byte[] key : keys){
optionalKeys.add(Optional.of(key));
}
return optionalKeys;
},unsafePrefixes,enforceIntegrity);
this.maxUndoDepth = maxUndoDepth;
this.claim_to_support = new ClaimToSupportPrefixRow(this,this.operationStack);
this.support_to_claim = new SupportToClaimPrefixRow(this,this.operationStack);
this.claim_to_txo = new ClaimToTXOPrefixRow(this,this.operationStack);
this.txo_to_claim = new TXOToClaimPrefixRow(this,this.operationStack);
this.claim_to_channel = new ClaimToChannelPrefixRow(this,this.operationStack);
this.channel_to_claim = new ChannelToClaimPrefixRow(this,this.operationStack);
this.claim_short_id = new ClaimShortIDPrefixRow(this,this.operationStack);
this.claim_expiration = new ClaimExpirationPrefixRow(this,this.operationStack);
this.claim_takeover = new ClaimTakeoverPrefixRow(this,this.operationStack);
this.pending_activation = new PendingActivationPrefixRow(this,this.operationStack);
this.activated = new ActivatedPrefixRow(this,this.operationStack);
this.active_amount = new ActiveAmountPrefixRow(this,this.operationStack);
this.bid_order = new BidOrderPrefixRow(this,this.operationStack);
this.repost = new RepostPrefixRow(this,this.operationStack);
this.reposted_claim = new RepostedPrefixRow(this,this.operationStack);
this.reposted_count = new RepostedCountPrefixRow(this,this.operationStack);
this.undo = new UndoPrefixRow(this,this.operationStack);
this.utxo = new UTXOPrefixRow(this,this.operationStack);
this.hashX_utxo = new HashXUTXOPrefixRow(this,this.operationStack);
this.hashX_history = new HashXHistoryPrefixRow(this,this.operationStack);
this.block_hash = new BlockHashPrefixRow(this,this.operationStack);
this.tx_count = new TxCountPrefixRow(this,this.operationStack);
this.tx_hash = new TXHashPrefixRow(this,this.operationStack);
this.tx_num = new TXNumPrefixRow(this,this.operationStack);
this.tx = new TXPrefixRow(this,this.operationStack);
this.header = new BlockHeaderPrefixRow(this,this.operationStack);
this.touched_or_deleted = new TouchedOrDeletedPrefixRow(this,this.operationStack);
this.channel_count = new ChannelCountPrefixRow(this,this.operationStack);
this.db_state = new DBStatePrefixRow(this,this.operationStack);
this.support_amount = new SupportAmountPrefixRow(this,this.operationStack);
this.block_txs = new BlockTxsPrefixRow(this,this.operationStack);
this.mempool_tx = new MempoolTXPrefixRow(this,this.operationStack);
this.trending_notification = new TrendingNotificationPrefixRow(this,this.operationStack);
this.touched_hashX = new TouchedHashXPrefixRow(this,this.operationStack);
this.hashX_status = new HashXStatusPrefixRow(this,this.operationStack);
this.hashX_mempool_status = new HashXMempoolStatusPrefixRow(this,this.operationStack);
this.effective_amount = new EffectiveAmountPrefixRow(this,this.operationStack);
this.future_effective_amount = new FutureEffectiveAmountPrefixRow(this,this.operationStack);
this.hashX_history_hasher = new HashXHistoryHasherPrefixRow(this,this.operationStack);
}
/**
* Write staged changes to the database without keeping undo information. Changes written cannot be undone.
*/
public void unsafeCommit() throws RocksDBException{
this.applyStash();
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
if(this.operationStack.length()!=0){
return;
}
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
this.database.write(writeOptions,batch);
}
}finally{
writeOptions.close();
this.operationStack.clear();
}
}
public void commit(int height,byte[] blockHash) throws RocksDBException{
this.applyStash();
byte[] undoOperations = this.operationStack.getUndoOperations();
List<byte[]> deleteUndos = new ArrayList<>();
if(height>this.maxUndoDepth){
byte[] upperBound = ByteBuffer.allocate(1+8).order(ByteOrder.BIG_ENDIAN).put(Prefix.UNDO.getValue()).putLong(height-this.maxUndoDepth).array();
RocksIterator iterator = this.database.newIterator(new ReadOptions().setIterateUpperBound(new Slice(upperBound)));
iterator.seek(ByteBuffer.allocate(1+8).order(ByteOrder.BIG_ENDIAN).put(Prefix.UNDO.getValue()).array());
while(iterator.isValid()){
deleteUndos.add(iterator.key());
iterator.next();
}
}
try{
ColumnFamilyHandle undoColumnFamily = this.getColumnFamilyByPrefix(Prefix.UNDO);
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
}
for(byte[] undoToDelete : deleteUndos){
batch.delete(undoColumnFamily,undoToDelete);
}
UndoKey undoKey = new UndoKey();
undoKey.height = height;
undoKey.block_hash = blockHash;
byte[] undoKeyBytes = this.undo.packKey(undoKey);
batch.put(undoColumnFamily,undoKeyBytes,undoOperations);
this.database.write(writeOptions,batch);
}finally{
writeOptions.close();
this.operationStack.clear();
}
}finally{
this.operationStack.clear();
}
}
public void rollback(int height,byte[] blockHash) throws RocksDBException{
UndoKey undoKey = new UndoKey();
undoKey.height = height;
undoKey.block_hash = blockHash;
byte[] undoKeyBytes = this.undo.packKey(undoKey);
ColumnFamilyHandle undoColumnFamily = this.getColumnFamilyByPrefix(Prefix.UNDO);
byte[] undoInfo = this.database.get(undoColumnFamily,undoKeyBytes);
this.operationStack.applyPackedUndoOperations(undoInfo);
this.operationStack.validateAndApplyStashedOperations();
WriteOptions writeOptions = new WriteOptions().setSync(true);
try{
WriteBatch batch = new WriteBatch();
for(RevertibleOperation stagedChange : this.operationStack.iterate()){
ColumnFamilyHandle columnFamily = this.getColumnFamilyByPrefix(Prefix.getByValue(stagedChange.getKey()[0]));
if(!stagedChange.isDelete()){
batch.put(columnFamily,stagedChange.getKey(),stagedChange.getValue());
}else{
batch.delete(columnFamily,stagedChange.getKey());
}
this.database.write(writeOptions,batch);
}
// batch.delete(undoKey)
}finally{
writeOptions.close();
this.operationStack.clear();
}
}
public void applyStash(){
this.operationStack.validateAndApplyStashedOperations();
}
/**
* Get value by prefixed key.
* @param key The prefixed key.
* @return The value or null.
* @throws RocksDBException The exception.
*/
public byte[] get(byte[] key) throws RocksDBException{
return this.get(key,true);
}
/**
* Get value by prefixed key.
* @param key The prefixed key.
* @param fillCache Fill cache option.
* @return The value or null.
* @throws RocksDBException The exception.
*/
public byte[] get(byte[] key,boolean fillCache) throws RocksDBException{
ColumnFamilyHandle columnFamily = null;
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(key.length>0 && Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamily = handle;
break;
}
}
ReadOptions options = new ReadOptions().setFillCache(fillCache);
byte[] value = this.database.get(columnFamily,options,key);
options.close();
return value;
}
/**
* Get multiple values by prefixed keys.
* @param keys The prefixed keys.
* @return The values.
* @throws RocksDBException The exception.
*/
public List<byte[]> multiGet(List<byte[]> keys) throws RocksDBException{
return this.multiGet(keys,true);
}
/**
* Get multiple values by prefixed keys.
* @param keys The prefixed keys.
* @param fillCache Fill cache option.
* @return The values.
* @throws RocksDBException The exception.
*/
public List<byte[]> multiGet(List<byte[]> keys,boolean fillCache) throws RocksDBException{
List<ColumnFamilyHandle> columnFamilies = new ArrayList<>();
for(byte[] key : keys){
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamilies.add(handle);
break;
}
}
}
ReadOptions options = new ReadOptions().setFillCache(fillCache);
List<byte[]> values = this.database.multiGetAsList(options,columnFamilies,keys);
options.close();
return values;
}
/**
* Stash multiple items for deletion.
* @param items The items.
*/
public void multiDelete(Map<byte[],byte[]> items){
this.operationStack.stashOperations(items.entrySet().stream().map((entry) -> new RevertibleDelete(entry.getKey(),entry.getValue())).toArray(RevertibleOperation[]::new));
}
/**
* Stash multiple items for putting.
* @param items The items.
*/
public void multiPut(Map<byte[],byte[]> items){
this.operationStack.stashOperations(items.entrySet().stream().map((entry) -> new RevertiblePut(entry.getKey(),entry.getValue())).toArray(RevertibleOperation[]::new));
}
public RocksIterator iterator(){
return this.iterator(null,null);
}
public RocksIterator iterator(ReadOptions readOptions){
return this.iterator(null,readOptions);
}
public RocksIterator iterator(ColumnFamilyHandle columnFamily){
return this.iterator(columnFamily,null);
}
public RocksIterator iterator(ColumnFamilyHandle columnFamily,ReadOptions readOptions){
if(columnFamily==null && readOptions==null){
return this.database.newIterator();
}
if(columnFamily==null){
return this.database.newIterator(readOptions);
}
if(readOptions==null){
return this.database.newIterator(columnFamily);
}
return this.database.newIterator(columnFamily,readOptions);
}
/**
* Close database.
*/
public void close(){
this.database.close();
}
public void tryCatchUpWithPrimary() throws RocksDBException{
this.database.tryCatchUpWithPrimary();
}
/**
* Stash item for deletion.
* @param key The item prefixed key.
* @param value The value.
*/
public void stashRawDelete(byte[] key,byte[] value){
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertibleDelete(key,value),
});
}
/**
* Stash item for putting.
* @param key The item prefixed key.
* @param value The value.
*/
public void stashRawPut(byte[] key,byte[] value){
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertiblePut(key,value),
});
}
public int estimateNumKeys() throws RocksDBException{
return this.estimateNumKeys(null);
}
public int estimateNumKeys(ColumnFamilyHandle columnFamily) throws RocksDBException{
return Integer.parseInt(this.database.getProperty(columnFamily,"rocksdb.estimate-num-keys"));
}
public boolean keyMayExist(byte[] key) throws RocksDBException{
ColumnFamilyHandle columnFamily = null;
for(ColumnFamilyHandle handle : this.columnFamilyHandles){
if(key.length>0 && Arrays.equals(handle.getName(),new byte[]{key[0]})){
columnFamily = handle;
break;
}
}
return this.database.keyMayExist(columnFamily,ByteBuffer.wrap(key));
}
public ColumnFamilyHandle getColumnFamilyByPrefix(Prefix prefix) throws RocksDBException{
if(prefix==null){
return this.database.getDefaultColumnFamily();
}
for(ColumnFamilyHandle columnFamily : this.columnFamilyHandles){
if(Arrays.equals(columnFamily.getName(),new byte[]{prefix.getValue()})){
return columnFamily;
}
}
return null;
this.claim_to_support = new ClaimToSupportPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.support_to_claim = new SupportToClaimPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.claim_to_txo = new ClaimToTXOPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.txo_to_claim = new TXOToClaimPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.claim_to_channel = new ClaimToChannelPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.channel_to_claim = new ChannelToClaimPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.claim_short_id = new ClaimShortIDPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.claim_expiration = new ClaimExpirationPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.claim_takeover = new ClaimTakeoverPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.pending_activation = new PendingActivationPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.activated = new ActivatedPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.active_amount = new ActiveAmountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.bid_order = new BidOrderPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.repost = new RepostPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.reposted_claim = new RepostedPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.reposted_count = new RepostedCountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.undo = new UndoPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.utxo = new UTXOPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.hashX_utxo = new HashXUTXOPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.hashX_history = new HashXHistoryPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.block_hash = new BlockHashPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.tx_count = new TxCountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.tx_hash = new TXHashPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.tx_num = new TXNumPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.tx = new TXPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.header = new BlockHeaderPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.touched_or_deleted = new TouchedOrDeletedPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.channel_count = new ChannelCountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.db_state = new DBStatePrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.support_amount = new SupportAmountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.block_txs = new BlockTxsPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.mempool_tx = new MempoolTXPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.trending_notification = new TrendingNotificationPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.touched_hashX = new TouchedHashXPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.hashX_status = new HashXStatusPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.hashX_mempool_status = new HashXMempoolStatusPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.effective_amount = new EffectiveAmountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.future_effective_amount = new FutureEffectiveAmountPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
this.hashX_history_hasher = new HashXHistoryHasherPrefixRow(this.database,this.operationStack,this.getColumnFamilyHandles());
}
}

7
src/main/java/com/lbry/database/rows/ActivatedPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ActivationKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ActivationValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ActivatedPrefixRow extends PrefixRow<ActivationKey,ActivationValue>{
public ActivatedPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ActivatedPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ActiveAmountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ActiveAmountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ActiveAmountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ActiveAmountPrefixRow extends PrefixRow<ActiveAmountKey,ActiveAmountValue>{
public ActiveAmountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ActiveAmountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/BidOrderPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.BidOrderKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.BidOrderValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class BidOrderPrefixRow extends PrefixRow<BidOrderKey,BidOrderValue>{
public BidOrderPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public BidOrderPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/BlockHashPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.BlockHashKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.BlockHashValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class BlockHashPrefixRow extends PrefixRow<BlockHashKey,BlockHashValue>{
public BlockHashPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public BlockHashPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/BlockHeaderPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.BlockHeaderKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.BlockHeaderValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class BlockHeaderPrefixRow extends PrefixRow<BlockHeaderKey,BlockHeaderValue>{
public BlockHeaderPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public BlockHeaderPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/BlockTxsPrefixRow.java
View file

@ -5,15 +5,18 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.BlockTxsKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.BlockTxsValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
public class BlockTxsPrefixRow extends PrefixRow<BlockTxsKey,BlockTxsValue>{
public BlockTxsPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public BlockTxsPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ChannelCountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ChannelCountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ChannelCountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ChannelCountPrefixRow extends PrefixRow<ChannelCountKey,ChannelCountValue>{
public ChannelCountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ChannelCountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ChannelToClaimPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ChannelToClaimKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ChannelToClaimValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ChannelToClaimPrefixRow extends PrefixRow<ChannelToClaimKey,ChannelToClaimValue>{
public ChannelToClaimPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ChannelToClaimPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimExpirationPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimExpirationKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimExpirationValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimExpirationPrefixRow extends PrefixRow<ClaimExpirationKey,ClaimExpirationValue>{
public ClaimExpirationPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimExpirationPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimShortIDPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimShortIDKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimShortIDValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimShortIDPrefixRow extends PrefixRow<ClaimShortIDKey,ClaimShortIDValue>{
public ClaimShortIDPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimShortIDPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimTakeoverPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimTakeoverKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimTakeoverValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimTakeoverPrefixRow extends PrefixRow<ClaimTakeoverKey,ClaimTakeoverValue>{
public ClaimTakeoverPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimTakeoverPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimToChannelPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimToChannelKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimToChannelValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimToChannelPrefixRow extends PrefixRow<ClaimToChannelKey,ClaimToChannelValue>{
public ClaimToChannelPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimToChannelPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimToSupportPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimToSupportKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimToSupportValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimToSupportPrefixRow extends PrefixRow<ClaimToSupportKey,ClaimToSupportValue>{
public ClaimToSupportPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimToSupportPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/ClaimToTXOPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.ClaimToTXOKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.ClaimToTXOValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class ClaimToTXOPrefixRow extends PrefixRow<ClaimToTXOKey,ClaimToTXOValue>{
public ClaimToTXOPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public ClaimToTXOPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/DBStatePrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.KeyInterface;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.DBState;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class DBStatePrefixRow extends PrefixRow<KeyInterface,DBState>{
public DBStatePrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public DBStatePrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/EffectiveAmountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.EffectiveAmountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.EffectiveAmountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class EffectiveAmountPrefixRow extends PrefixRow<EffectiveAmountKey,EffectiveAmountValue>{
public EffectiveAmountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public EffectiveAmountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/FutureEffectiveAmountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.FutureEffectiveAmountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.FutureEffectiveAmountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class FutureEffectiveAmountPrefixRow extends PrefixRow<FutureEffectiveAmountKey,FutureEffectiveAmountValue>{
public FutureEffectiveAmountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public FutureEffectiveAmountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/HashXHistoryHasherPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.HashXHistoryHasherKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.HashXHistoryHasherValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class HashXHistoryHasherPrefixRow extends PrefixRow<HashXHistoryHasherKey,HashXHistoryHasherValue>{
public HashXHistoryHasherPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public HashXHistoryHasherPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/HashXHistoryPrefixRow.java
View file

@ -5,15 +5,18 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.HashXHistoryKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.HashXHistoryValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
public class HashXHistoryPrefixRow extends PrefixRow<HashXHistoryKey,HashXHistoryValue>{
public HashXHistoryPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public HashXHistoryPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/HashXMempoolStatusPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.HashXStatusKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.HashXStatusValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class HashXMempoolStatusPrefixRow extends PrefixRow<HashXStatusKey,HashXStatusValue>{
public HashXMempoolStatusPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public HashXMempoolStatusPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/HashXStatusPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.HashXStatusKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.HashXStatusValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class HashXStatusPrefixRow extends PrefixRow<HashXStatusKey,HashXStatusValue>{
public HashXStatusPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public HashXStatusPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/HashXUTXOPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.HashXUTXOKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.HashXUTXOValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class HashXUTXOPrefixRow extends PrefixRow<HashXUTXOKey,HashXUTXOValue>{
public HashXUTXOPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public HashXUTXOPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/MempoolTXPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.MempoolTxKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.MempoolTxValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class MempoolTXPrefixRow extends PrefixRow<MempoolTxKey,MempoolTxValue>{
public MempoolTXPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public MempoolTXPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/PendingActivationPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.PendingActivationKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.PendingActivationValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class PendingActivationPrefixRow extends PrefixRow<PendingActivationKey,PendingActivationValue>{
public PendingActivationPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public PendingActivationPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

135
src/main/java/com/lbry/database/rows/PrefixRow.java
View file

@ -3,15 +3,20 @@ package com.lbry.database.rows;
import com.lbry.database.Prefix;
import com.lbry.database.PrefixDB;
import com.lbry.database.keys.KeyInterface;
import com.lbry.database.revert.RevertibleDelete;
import com.lbry.database.revert.RevertibleOperation;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.revert.RevertiblePut;
import com.lbry.database.util.Tuple2;
import com.lbry.database.values.ValueInterface;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.stream.Collectors;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.ReadOptions;
import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;
import org.rocksdb.RocksIterator;
@ -19,21 +24,34 @@ public abstract class PrefixRow<K extends KeyInterface,V extends ValueInterface>
public static final Map<Prefix,PrefixRow<?,?>> TYPES = new HashMap<>();
private final PrefixDB database;
private final RocksDB database;
private final RevertibleOperationStack operationStack;
private final ColumnFamilyHandle columnFamily;
public PrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
public PrefixRow(RocksDB database, RevertibleOperationStack operationStack,List<ColumnFamilyHandle> columnFamilyHandles){
this.database = database;
this.operationStack = operationStack;
this.columnFamily = columnFamilyHandles==null?null:columnFamilyHandles.stream().filter(x -> {
try {
return Arrays.equals(x.getName(),new byte[]{this.prefix().getValue()});
} catch (RocksDBException e) {
return false;
}
}).findFirst().orElse(null);
PrefixRow.TYPES.put(this.prefix(),this);
}
public abstract Prefix prefix();
public RocksIterator iterate() throws RocksDBException{
return this.iterate(null);
}
//TODO
public RocksIterator iterate(ReadOptions readOptions) throws RocksDBException{
return this.database.iterator(this.getColumnFamily(),readOptions);
return this.database.newIterator(this.columnFamily,readOptions);
}
public Object get(K key) throws RocksDBException{
@ -45,95 +63,106 @@ public abstract class PrefixRow<K extends KeyInterface,V extends ValueInterface>
}
public Object get(K key,boolean fillCache,boolean deserializeValue) throws RocksDBException {
byte[] v = this.database.get(this.packKey(key),fillCache);
ReadOptions readOptions = new ReadOptions().setFillCache(fillCache);
byte[] v = this.database.get(this.columnFamily,readOptions,this.packKey(key));
readOptions.close();
if(v!=null){
if(deserializeValue){
return this.unpackValue(v);
}
return v;
return !deserializeValue?v:this.unpackValue(v);
}
return null;
}
public boolean keyExists(K key) throws RocksDBException{
boolean keyMayExist = this.database.keyMayExist(this.packKey(key));
boolean keyMayExist = this.database.keyMayExist(this.columnFamily,this.packKey(key),null);
if(!keyMayExist){
return false;
}
return this.database.get(this.packKey(key),true)!=null;
ReadOptions readOptions = new ReadOptions().setFillCache(true);
boolean ret = this.database.get(readOptions,this.packKey(key))!=null;
readOptions.close();
return ret;
}
public List<Object> multiGet(List<K> keys,boolean fillCache,boolean deserializeValue) throws RocksDBException{
List<byte[]> result = this.database.multiGet(keys.stream().map(this::packKey).collect(Collectors.toList()),fillCache);
return result.stream().map(v -> {
if(v!=null){
if(deserializeValue){
return this.unpackValue(v);
public List<Object> multiGet(List<K> keys, boolean fillCache, boolean deserializeValue) throws RocksDBException{
List<byte[]> packedKeys = new ArrayList<>();
for(K key : keys){
packedKeys.add(this.packKey(key));
}
return v;
ReadOptions readOptions = new ReadOptions().setFillCache(fillCache);
List<byte[]> result = this.database.multiGetAsList(readOptions,Collections.singletonList(this.columnFamily),packedKeys);
readOptions.close();
List<Object> ret = new ArrayList<>();
for(int i=0;i<keys.size();i++){
byte[] v = result.get(i);//TODO Improve???
ret.add(v==null?null:(!deserializeValue?v:this.unpackValue(v)));
}
return null;
}).collect(Collectors.toList());
return ret;
}
//TODO multiGetAsyncGen
public void stashMultiPut(Map<K,V> items){
Map<byte[],byte[]> map = new LinkedHashMap<>();
RevertibleOperation[] revertibleOperationArray = new RevertibleOperation[items.size()];
int i = 0;
for(Map.Entry<K,V> entry : items.entrySet()){
map.put(this.packKey(entry.getKey()),this.packValue(entry.getValue()));
revertibleOperationArray[i] = new RevertiblePut(this.packKey(entry.getKey()),this.packValue(entry.getValue()));
i++;
}
this.database.multiPut(map);
this.operationStack.stashOperations(revertibleOperationArray);
}
public void stashMultiDelete(Map<K,V> items){
Map<byte[],byte[]> map = new LinkedHashMap<>();
RevertibleOperation[] revertibleOperationArray = new RevertibleOperation[items.size()];
int i = 0;
for(Map.Entry<K,V> entry : items.entrySet()){
map.put(this.packKey(entry.getKey()),this.packValue(entry.getValue()));
revertibleOperationArray[i] = new RevertibleDelete(this.packKey(entry.getKey()),this.packValue(entry.getValue()));
i++;
}
this.database.multiDelete(map);
this.operationStack.stashOperations(revertibleOperationArray);
}
public V getPending(K key){
public Object getPending(K key) throws RocksDBException {
return this.getPending(key,true);
}
public V getPending(K key,boolean fillCache){
return this.getPending(key,fillCache,true);
public Object getPending(K key,boolean fillCache) throws RocksDBException {
return this.getPending(key,true,true);
}
public V getPending(K key,boolean fillCache,boolean deserializeValue){
// byte[] packedKey = this.packKey(key);
// Optional<RevertibleOperation> pendingOperation = this.operationStack.getPendingOperation(packedKey);
// if(pendingOperation.isPresent() && pendingOperation.get().isDelete()){
// return null;
// }
// byte[] v;
// if(pendingOperation.isPresent()){
// v = pendingOperation.get().getValue();
// }else{
// v = this.database.get(this.getColumnFamily(),fillCache);
// }
public Object getPending(K key,boolean fillCache,boolean deserializeValue) throws RocksDBException{
byte[] packedKey = this.packKey(key);
Optional<RevertibleOperation> pendingOperation = this.operationStack.getPendingOperation(packedKey);
if(pendingOperation.isPresent() && pendingOperation.get().isDelete()){
return null;
}
//TODO getPending
byte[] v;
if(pendingOperation.isPresent()){
v = pendingOperation.get().getValue();
}else{
ReadOptions readOptions = new ReadOptions().setFillCache(fillCache);
v = this.database.get(this.columnFamily,readOptions,packedKey);
readOptions.close();
}
return v==null?null:(!deserializeValue?v:this.unpackValue(v));
}
public void stashPut(K key,V value){
this.database.stashRawPut(this.packKey(key),this.packValue(value));
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertiblePut(this.packKey(key),this.packValue(value)),
});
}
public void stashDelete(K key,V value){
this.database.stashRawDelete(this.packKey(key),this.packValue(value));
this.operationStack.stashOperations(new RevertibleOperation[]{
new RevertibleDelete(this.packKey(key),this.packValue(value)),
});
}
public ColumnFamilyHandle getColumnFamily() throws RocksDBException{
return this.database.getColumnFamilyByPrefix(this.prefix());
public byte[] packPartialKey(){
return ByteBuffer.allocate(1).put(this.prefix().getValue())/*TODO More key parts.*/.array();
}
public abstract Prefix prefix();
public abstract byte[] packKey(K key);
public abstract byte[] packValue(V value);
@ -142,4 +171,12 @@ public abstract class PrefixRow<K extends KeyInterface,V extends ValueInterface>
public abstract V unpackValue(byte[] value);
public Tuple2<K,V> unpackItem(byte[] key,byte[] value){
return new Tuple2<>(this.unpackKey(key),this.unpackValue(value));
}
public int estimateNumKeys() throws RocksDBException{
return Integer.parseInt(this.database.getProperty(this.columnFamily,"rocksdb.estimate-num-keys"));
}
}

7
src/main/java/com/lbry/database/rows/RepostPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.RepostKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.RepostValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class RepostPrefixRow extends PrefixRow<RepostKey,RepostValue>{
public RepostPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public RepostPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/RepostedCountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.RepostedCountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.RepostedCountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class RepostedCountPrefixRow extends PrefixRow<RepostedCountKey,RepostedCountValue>{
public RepostedCountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public RepostedCountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/RepostedPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.RepostedKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.RepostedValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class RepostedPrefixRow extends PrefixRow<RepostedKey,RepostedValue>{
public RepostedPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public RepostedPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/SupportAmountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.SupportAmountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.SupportAmountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class SupportAmountPrefixRow extends PrefixRow<SupportAmountKey,SupportAmountValue>{
public SupportAmountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public SupportAmountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/SupportToClaimPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.SupportToClaimKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.SupportToClaimValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class SupportToClaimPrefixRow extends PrefixRow<SupportToClaimKey,SupportToClaimValue>{
public SupportToClaimPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public SupportToClaimPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TXHashPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TxHashKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TxHashValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TXHashPrefixRow extends PrefixRow<TxHashKey, TxHashValue>{
public TXHashPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TXHashPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TXNumPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TxNumKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TxNumValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TXNumPrefixRow extends PrefixRow<TxNumKey,TxNumValue>{
public TXNumPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TXNumPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TXOToClaimPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TXOToClaimKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TXOToClaimValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TXOToClaimPrefixRow extends PrefixRow<TXOToClaimKey, TXOToClaimValue>{
public TXOToClaimPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TXOToClaimPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TXPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TxKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TxValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TXPrefixRow extends PrefixRow<TxKey,TxValue>{
public TXPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TXPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TouchedHashXPrefixRow.java
View file

@ -5,15 +5,18 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TouchedHashXKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TouchedHashXValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
public class TouchedHashXPrefixRow extends PrefixRow<TouchedHashXKey,TouchedHashXValue>{
public TouchedHashXPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TouchedHashXPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TouchedOrDeletedPrefixRow.java
View file

@ -5,15 +5,18 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TouchedOrDeletedClaimKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TouchedOrDeletedClaimValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.LinkedHashSet;
import java.util.List;
public class TouchedOrDeletedPrefixRow extends PrefixRow<TouchedOrDeletedClaimKey,TouchedOrDeletedClaimValue>{
public TouchedOrDeletedPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TouchedOrDeletedPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TrendingNotificationPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TrendingNotificationKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TrendingNotificationValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TrendingNotificationPrefixRow extends PrefixRow<TrendingNotificationKey,TrendingNotificationValue>{
public TrendingNotificationPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TrendingNotificationPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/TxCountPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.TxCountKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.TxCountValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class TxCountPrefixRow extends PrefixRow<TxCountKey, TxCountValue>{
public TxCountPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public TxCountPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/UTXOPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.UTXOKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.UTXOValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class UTXOPrefixRow extends PrefixRow<UTXOKey,UTXOValue>{
public UTXOPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public UTXOPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

7
src/main/java/com/lbry/database/rows/UndoPrefixRow.java
View file

@ -5,14 +5,17 @@ import com.lbry.database.PrefixDB;
import com.lbry.database.keys.UndoKey;
import com.lbry.database.revert.RevertibleOperationStack;
import com.lbry.database.values.UndoValue;
import org.rocksdb.ColumnFamilyHandle;
import org.rocksdb.RocksDB;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
public class UndoPrefixRow extends PrefixRow<UndoKey,UndoValue>{
public UndoPrefixRow(PrefixDB database,RevertibleOperationStack operationStack){
super(database,operationStack);
public UndoPrefixRow(RocksDB database, RevertibleOperationStack operationStack, List<ColumnFamilyHandle> columnFamilyHandleList){
super(database,operationStack,columnFamilyHandleList);
}
@Override

4
src/test/java/com/lbry/database/tests/RevertablePrefixDBTest.java
View file

@ -59,9 +59,9 @@ public class RevertablePrefixDBTest{
assertNull(this.database.claim_takeover.get(new ClaimTakeoverKey(){{
this.normalized_name = name;
}}));
assertEquals(10000000,this.database.claim_takeover.getPending(new ClaimTakeoverKey(){{
assertEquals(10000000,((ClaimTakeoverValue)this.database.claim_takeover.getPending(new ClaimTakeoverKey(){{
this.normalized_name = name;
}}).height);
}})).height);
/////////////////////

10
src/test/java/com/lbry/database/tests/RevertibleOperationStackTest.java
View file

@ -78,11 +78,11 @@ public class RevertibleOperationStackTest {
ClaimToTXOKey k1 = new ClaimToTXOKey();
k1.claim_hash = new byte[20];
Arrays.fill(k1.claim_hash,(byte) 0x01);
byte[] key1 = new ClaimToTXOPrefixRow(null,null).packKey(k1);
byte[] key1 = new ClaimToTXOPrefixRow(null,null,null).packKey(k1);
ClaimToTXOKey k2 = new ClaimToTXOKey();
k2.claim_hash = new byte[20];
Arrays.fill(k2.claim_hash,(byte) 0x02);
byte[] key2 = new ClaimToTXOPrefixRow(null,null).packKey(k2);
byte[] key2 = new ClaimToTXOPrefixRow(null,null,null).packKey(k2);
// ClaimToTXOKey k3 = new ClaimToTXOKey();
// k3.claim_hash = new byte[20];
// Arrays.fill(k3.claim_hash,(byte) 0x03);
@ -100,7 +100,7 @@ public class RevertibleOperationStackTest {
v1.amount = 1;
v1.channel_signature_is_valid = false;
v1.name = "derp";
byte[] val1 = new ClaimToTXOPrefixRow(null,null).packValue(v1);
byte[] val1 = new ClaimToTXOPrefixRow(null,null,null).packValue(v1);
ClaimToTXOValue v2 = new ClaimToTXOValue();
v2.tx_num = 1;
v2.position = 0;
@ -109,7 +109,7 @@ public class RevertibleOperationStackTest {
v2.amount = 1;
v2.channel_signature_is_valid = false;
v2.name = "oops";
byte[] val2 = new ClaimToTXOPrefixRow(null,null).packValue(v2);
byte[] val2 = new ClaimToTXOPrefixRow(null,null,null).packValue(v2);
ClaimToTXOValue v3 = new ClaimToTXOValue();
v3.tx_num = 1;
v3.position = 0;
@ -118,7 +118,7 @@ public class RevertibleOperationStackTest {
v3.amount = 1;
v3.channel_signature_is_valid = false;
v3.name = "other";
byte[] val3 = new ClaimToTXOPrefixRow(null,null).packValue(v3);
byte[] val3 = new ClaimToTXOPrefixRow(null,null,null).packValue(v3);
// Check that we can't delete a non-existent value.
assertThrows(OperationStackIntegrityException.class,() -> this.stack.appendOperation(new RevertibleDelete(key1,val1)));