github.com/EgonCoin/EgonChain@v1.10.16/ethdb/database.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Package ethdb defines the interfaces for an Ethereum data store. 18 package ethdb 19 20 import "io" 21 22 // KeyValueReader wraps the Has and Get method of a backing data store. 23 type KeyValueReader interface { 24 // Has retrieves if a key is present in the key-value data store. 25 Has(key []byte) (bool, error) 26 27 // Get retrieves the given key if it's present in the key-value data store. 28 Get(key []byte) ([]byte, error) 29 } 30 31 // KeyValueWriter wraps the Put method of a backing data store. 32 type KeyValueWriter interface { 33 // Put inserts the given value into the key-value data store. 34 Put(key []byte, value []byte) error 35 36 // Delete removes the key from the key-value data store. 37 Delete(key []byte) error 38 } 39 40 // Stater wraps the Stat method of a backing data store. 41 type Stater interface { 42 // Stat returns a particular internal stat of the database. 43 Stat(property string) (string, error) 44 } 45 46 // Compacter wraps the Compact method of a backing data store. 47 type Compacter interface { 48 // Compact flattens the underlying data store for the given key range. In essence, 49 // deleted and overwritten versions are discarded, and the data is rearranged to 50 // reduce the cost of operations needed to access them. 51 // 52 // A nil start is treated as a key before all keys in the data store; a nil limit 53 // is treated as a key after all keys in the data store. If both is nil then it 54 // will compact entire data store. 55 Compact(start []byte, limit []byte) error 56 } 57 58 // KeyValueStore contains all the methods required to allow handling different 59 // key-value data stores backing the high level database. 60 type KeyValueStore interface { 61 KeyValueReader 62 KeyValueWriter 63 Batcher 64 Iteratee 65 Stater 66 Compacter 67 io.Closer 68 } 69 70 // AncientReader contains the methods required to read from immutable ancient data. 71 type AncientReader interface { 72 // HasAncient returns an indicator whether the specified data exists in the 73 // ancient store. 74 HasAncient(kind string, number uint64) (bool, error) 75 76 // Ancient retrieves an ancient binary blob from the append-only immutable files. 77 Ancient(kind string, number uint64) ([]byte, error) 78 79 // AncientRange retrieves multiple items in sequence, starting from the index 'start'. 80 // It will return 81 // - at most 'count' items, 82 // - at least 1 item (even if exceeding the maxBytes), but will otherwise 83 // return as many items as fit into maxBytes. 84 AncientRange(kind string, start, count, maxBytes uint64) ([][]byte, error) 85 86 // Ancients returns the ancient item numbers in the ancient store. 87 Ancients() (uint64, error) 88 89 // AncientSize returns the ancient size of the specified category. 90 AncientSize(kind string) (uint64, error) 91 } 92 93 // AncientBatchReader is the interface for 'batched' or 'atomic' reading. 94 type AncientBatchReader interface { 95 AncientReader 96 97 // ReadAncients runs the given read operation while ensuring that no writes take place 98 // on the underlying freezer. 99 ReadAncients(fn func(AncientReader) error) (err error) 100 } 101 102 // AncientWriter contains the methods required to write to immutable ancient data. 103 type AncientWriter interface { 104 // ModifyAncients runs a write operation on the ancient store. 105 // If the function returns an error, any changes to the underlying store are reverted. 106 // The integer return value is the total size of the written data. 107 ModifyAncients(func(AncientWriteOp) error) (int64, error) 108 109 // TruncateAncients discards all but the first n ancient data from the ancient store. 110 TruncateAncients(n uint64) error 111 112 // Sync flushes all in-memory ancient store data to disk. 113 Sync() error 114 } 115 116 // AncientWriteOp is given to the function argument of ModifyAncients. 117 type AncientWriteOp interface { 118 // Append adds an RLP-encoded item. 119 Append(kind string, number uint64, item interface{}) error 120 121 // AppendRaw adds an item without RLP-encoding it. 122 AppendRaw(kind string, number uint64, item []byte) error 123 } 124 125 // Reader contains the methods required to read data from both key-value as well as 126 // immutable ancient data. 127 type Reader interface { 128 KeyValueReader 129 AncientBatchReader 130 } 131 132 // Writer contains the methods required to write data to both key-value as well as 133 // immutable ancient data. 134 type Writer interface { 135 KeyValueWriter 136 AncientWriter 137 } 138 139 // AncientStore contains all the methods required to allow handling different 140 // ancient data stores backing immutable chain data store. 141 type AncientStore interface { 142 AncientBatchReader 143 AncientWriter 144 io.Closer 145 } 146 147 // Database contains all the methods required by the high level database to not 148 // only access the key-value data store but also the chain freezer. 149 type Database interface { 150 Reader 151 Writer 152 Batcher 153 Iteratee 154 Stater 155 Compacter 156 io.Closer 157 }