grovedb-version 5.0.1

Versioning library for Platform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

use crate::version::grovedb_versions::GroveDBAggregateSumPathQueryMethodVersions;
use crate::version::{
    grovedb_versions::{
        GroveDBApplyBatchVersions, GroveDBElementMethodVersions,
        GroveDBOperationsAverageCaseVersions, GroveDBOperationsDeleteUpTreeVersions,
        GroveDBOperationsDeleteVersions, GroveDBOperationsGetVersions,
        GroveDBOperationsInsertVersions, GroveDBOperationsProofVersions,
        GroveDBOperationsQueryVersions, GroveDBOperationsVersions,
        GroveDBOperationsWorstCaseVersions, GroveDBPathQueryMethodVersions, GroveDBQueryLimits,
        GroveDBReplicationVersions, GroveDBVersions,
    },
    merk_versions::{
        MerkAverageCaseCostsVersions, MerkBatchVersions, MerkProofVersions, MerkVersions,
    },
    GroveVersion,
};

pub const GROVE_V1: GroveVersion = GroveVersion {
    protocol_version: 1,
    grovedb_versions: GroveDBVersions {
        apply_batch: GroveDBApplyBatchVersions {
            apply_batch_structure: 0,
            apply_body: 0,
            continue_partial_apply_body: 0,
            apply_operations_without_batching: 0,
            apply_batch: 0,
            apply_partial_batch: 0,
            open_batch_transactional_merk_at_path: 0,
            open_batch_merk_at_path: 0,
            apply_batch_with_element_flags_update: 0,
            apply_partial_batch_with_element_flags_update: 0,
            estimated_case_operations_for_batch: 0,
        },
        element: GroveDBElementMethodVersions {
            delete: 0,
            delete_with_sectioned_removal_bytes: 0,
            delete_into_batch_operations: 0,
            element_at_key_already_exists: 0,
            get: 0,
            get_optional: 0,
            get_from_storage: 0,
            get_optional_from_storage: 0,
            get_with_absolute_refs: 0,
            get_value_hash: 0,
            get_specialized_cost: 0,
            value_defined_cost: 0,
            value_defined_cost_for_serialized_value: 0,
            specialized_costs_for_key_value: 0,
            required_item_space: 0,
            required_item_with_sum_item_space: 0,
            required_reference_with_sum_item_space: 0,
            insert: 0,
            insert_into_batch_operations: 0,
            insert_if_not_exists: 0,
            insert_if_not_exists_into_batch_operations: 0,
            insert_if_changed_value: 0,
            insert_if_changed_value_into_batch_operations: 0,
            insert_reference: 0,
            insert_reference_into_batch_operations: 0,
            insert_subtree: 0,
            insert_subtree_into_batch_operations: 0,
            get_query: 0,
            get_aggregate_sum_query: 0,
            get_query_values: 0,
            get_query_apply_function: 0,
            get_path_query: 0,
            get_sized_query: 0,
            get_aggregate_sum_query_apply_function: 0,
            path_query_push: 0,
            aggregate_sum_path_query_push: 0,
            query_item: 0,
            basic_push: 0,
            basic_aggregate_sum_push: 0,
            serialize: 0,
            serialized_size: 0,
            deserialize: 0,
            get_with_value_hash: 0,
            insert_reference_if_changed_value: 0,
            aggregate_sum_query_item: 0,
        },
        operations: GroveDBOperationsVersions {
            get: GroveDBOperationsGetVersions {
                get: 0,
                get_caching_optional: 0,
                follow_reference: 0,
                get_raw: 0,
                get_raw_caching_optional: 0,
                get_raw_optional: 0,
                get_raw_optional_caching_optional: 0,
                has_raw: 0,
                check_subtree_exists_invalid_path: 0,
                average_case_for_has_raw: 0,
                average_case_for_has_raw_tree: 0,
                average_case_for_get_raw: 0,
                average_case_for_get: 0,
                average_case_for_get_tree: 0,
                worst_case_for_has_raw: 0,
                worst_case_for_get_raw: 0,
                worst_case_for_get: 0,
                is_empty_tree: 0,
                follow_reference_once: 0,
            },
            insert: GroveDBOperationsInsertVersions {
                insert: 0,
                insert_on_transaction: 0,
                insert_without_transaction: 0,
                add_element_on_transaction: 0,
                add_element_without_transaction: 0,
                insert_if_not_exists: 0,
                insert_if_not_exists_return_existing_element: 0,
                insert_if_changed_value: 0,
            },
            delete: GroveDBOperationsDeleteVersions {
                delete: 0,
                clear_subtree: 0,
                delete_with_sectional_storage_function: 0,
                delete_if_empty_tree: 0,
                delete_if_empty_tree_with_sectional_storage_function: 0,
                delete_operation_for_delete_internal: 0,
                delete_internal_on_transaction: 0,
                delete_internal_without_transaction: 0,
                average_case_delete_operation_for_delete: 0,
                worst_case_delete_operation_for_delete: 0,
            },
            delete_up_tree: GroveDBOperationsDeleteUpTreeVersions {
                delete_up_tree_while_empty: 0,
                delete_up_tree_while_empty_with_sectional_storage: 0,
                delete_operations_for_delete_up_tree_while_empty: 0,
                add_delete_operations_for_delete_up_tree_while_empty: 0,
                average_case_delete_operations_for_delete_up_tree_while_empty: 0,
                worst_case_delete_operations_for_delete_up_tree_while_empty: 0,
            },
            query: GroveDBOperationsQueryVersions {
                query_encoded_many: 0,
                query_many_raw: 0,
                get_proved_path_query: 0,
                query: 0,
                query_item_value: 0,
                query_item_value_or_sum: 0,
                query_aggregate_sums: 0,
                query_aggregate_count_on_range: 0,
                query_aggregate_sum_on_range: 0,
                query_aggregate_count_and_sum_on_range: 0,
                query_sums: 0,
                query_raw: 0,
                query_keys_optional: 0,
                query_raw_keys_optional: 0,
                follow_element: 0,
            },
            proof: GroveDBOperationsProofVersions {
                prove_query: 0,
                prove_query_many: 0,
                prove_query_non_serialized: 0,
                prove_trunk_chunk: 0,
                prove_trunk_chunk_non_serialized: 0,
                prove_branch_chunk: 0,
                prove_branch_chunk_non_serialized: 0,
                verify_query_with_options: 0,
                verify_query_raw: 0,
                verify_layer_proof: 0,
                verify_query: 0,
                verify_subset_query: 0,
                verify_query_with_absence_proof: 0,
                verify_subset_query_with_absence_proof: 0,
                verify_query_with_chained_path_queries: 0,
                verify_query_get_parent_tree_info_with_options: 0,
            },
            average_case: GroveDBOperationsAverageCaseVersions {
                add_average_case_get_merk_at_path: 0,
                average_case_merk_replace_tree: 0,
                average_case_merk_insert_tree: 0,
                average_case_merk_delete_tree: 0,
                average_case_merk_insert_element: 0,
                average_case_merk_replace_element: 0,
                average_case_merk_patch_element: 0,
                average_case_merk_delete_element: 0,
                add_average_case_has_raw_cost: 0,
                add_average_case_has_raw_tree_cost: 0,
                add_average_case_get_raw_cost: 0,
                add_average_case_get_raw_tree_cost: 0,
                add_average_case_get_cost: 0,
            },
            worst_case: GroveDBOperationsWorstCaseVersions {
                add_worst_case_get_merk_at_path: 0,
                worst_case_merk_replace_tree: 0,
                worst_case_merk_insert_tree: 0,
                worst_case_merk_delete_tree: 0,
                worst_case_merk_insert_element: 0,
                worst_case_merk_replace_element: 0,
                worst_case_merk_patch_element: 0,
                worst_case_merk_delete_element: 0,
                add_worst_case_has_raw_cost: 0,
                add_worst_case_get_raw_tree_cost: 0,
                add_worst_case_get_raw_cost: 0,
                add_worst_case_get_cost: 0,
            },
        },
        aggregate_sum_path_query_methods: GroveDBAggregateSumPathQueryMethodVersions { merge: 0 },
        path_query_methods: GroveDBPathQueryMethodVersions {
            terminal_keys: 0,
            merge: 0,
            query_items_at_path: 0,
            should_add_parent_tree_at_path: 0,
        },
        replication: GroveDBReplicationVersions {
            get_subtrees_metadata: 0,
            fetch_chunk: 0,
            start_snapshot_syncing: 0,
            apply_chunk: 0,
        },
        query_limits: GroveDBQueryLimits {
            max_aggregate_sum_query_elements_scanned: 1024,
        },
    },
    merk_versions: MerkVersions {
        batch: MerkBatchVersions { commit: 0 },
        average_case_costs: MerkAverageCaseCostsVersions {
            add_average_case_merk_propagate: 0,
            sum_tree_estimated_size: 0,
            value_with_feature_and_flags_size: 0,
        },
        // `prove_count_offset_on_range` is implementation-version 0
        // here too — but in grove v1 the V0 proof envelope rejects
        // offsets unconditionally at the grovedb layer, so this
        // method is never actually called from v1's prove path.
        // The field is kept consistent across grove versions so the
        // method's `check_merk_v0_with_cost!` gate doesn't accidentally
        // trip if someone calls it directly from a v1 context.
        proof: MerkProofVersions {
            prove_count_offset_on_range: 0,
        },
    },
};