]>
Commit | Line | Data |
---|---|---|
7c673cae | 1 | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved. |
11fdf7f2 TL |
2 | // This source code is licensed under both the GPLv2 (found in the |
3 | // COPYING file in the root directory) and Apache 2.0 License | |
4 | // (found in the LICENSE.Apache file in the root directory). | |
7c673cae FG |
5 | |
6 | package org.rocksdb; | |
7 | ||
8 | import java.util.*; | |
9 | ||
494da23a TL |
10 | public class MutableColumnFamilyOptions |
11 | extends AbstractMutableOptions { | |
7c673cae | 12 | |
494da23a TL |
13 | /** |
14 | * User must use builder pattern, or parser. | |
15 | * | |
16 | * @param keys the keys | |
17 | * @param values the values | |
18 | * | |
19 | * See {@link #builder()} and {@link #parse(String)}. | |
20 | */ | |
21 | private MutableColumnFamilyOptions(final String[] keys, | |
22 | final String[] values) { | |
23 | super(keys, values); | |
7c673cae FG |
24 | } |
25 | ||
26 | /** | |
27 | * Creates a builder which allows you | |
28 | * to set MutableColumnFamilyOptions in a fluent | |
29 | * manner | |
30 | * | |
31 | * @return A builder for MutableColumnFamilyOptions | |
32 | */ | |
33 | public static MutableColumnFamilyOptionsBuilder builder() { | |
34 | return new MutableColumnFamilyOptionsBuilder(); | |
35 | } | |
36 | ||
37 | /** | |
38 | * Parses a String representation of MutableColumnFamilyOptions | |
39 | * | |
40 | * The format is: key1=value1;key2=value2;key3=value3 etc | |
41 | * | |
1e59de90 | 42 | * For int[] values, each int should be separated by a colon, e.g. |
7c673cae | 43 | * |
1e59de90 | 44 | * key1=value1;intArrayKey1=1:2:3 |
7c673cae FG |
45 | * |
46 | * @param str The string representation of the mutable column family options | |
1e59de90 | 47 | * @param ignoreUnknown what to do if the key is not one of the keys we expect |
7c673cae FG |
48 | * |
49 | * @return A builder for the mutable column family options | |
50 | */ | |
1e59de90 TL |
51 | public static MutableColumnFamilyOptionsBuilder parse( |
52 | final String str, final boolean ignoreUnknown) { | |
7c673cae FG |
53 | Objects.requireNonNull(str); |
54 | ||
1e59de90 TL |
55 | final List<OptionString.Entry> parsedOptions = OptionString.Parser.parse(str); |
56 | return new MutableColumnFamilyOptionsBuilder().fromParsed(parsedOptions, ignoreUnknown); | |
57 | } | |
7c673cae | 58 | |
1e59de90 TL |
59 | public static MutableColumnFamilyOptionsBuilder parse(final String str) { |
60 | return parse(str, false); | |
7c673cae FG |
61 | } |
62 | ||
494da23a | 63 | private interface MutableColumnFamilyOptionKey extends MutableOptionKey {} |
7c673cae FG |
64 | |
65 | public enum MemtableOption implements MutableColumnFamilyOptionKey { | |
66 | write_buffer_size(ValueType.LONG), | |
67 | arena_block_size(ValueType.LONG), | |
68 | memtable_prefix_bloom_size_ratio(ValueType.DOUBLE), | |
1e59de90 | 69 | memtable_whole_key_filtering(ValueType.BOOLEAN), |
7c673cae FG |
70 | @Deprecated memtable_prefix_bloom_bits(ValueType.INT), |
71 | @Deprecated memtable_prefix_bloom_probes(ValueType.INT), | |
72 | memtable_huge_page_size(ValueType.LONG), | |
73 | max_successive_merges(ValueType.LONG), | |
74 | @Deprecated filter_deletes(ValueType.BOOLEAN), | |
75 | max_write_buffer_number(ValueType.INT), | |
1e59de90 TL |
76 | inplace_update_num_locks(ValueType.LONG), |
77 | experimental_mempurge_threshold(ValueType.DOUBLE); | |
7c673cae FG |
78 | |
79 | private final ValueType valueType; | |
80 | MemtableOption(final ValueType valueType) { | |
81 | this.valueType = valueType; | |
82 | } | |
83 | ||
84 | @Override | |
85 | public ValueType getValueType() { | |
86 | return valueType; | |
87 | } | |
88 | } | |
89 | ||
90 | public enum CompactionOption implements MutableColumnFamilyOptionKey { | |
91 | disable_auto_compactions(ValueType.BOOLEAN), | |
7c673cae | 92 | soft_pending_compaction_bytes_limit(ValueType.LONG), |
7c673cae FG |
93 | hard_pending_compaction_bytes_limit(ValueType.LONG), |
94 | level0_file_num_compaction_trigger(ValueType.INT), | |
95 | level0_slowdown_writes_trigger(ValueType.INT), | |
96 | level0_stop_writes_trigger(ValueType.INT), | |
97 | max_compaction_bytes(ValueType.LONG), | |
98 | target_file_size_base(ValueType.LONG), | |
99 | target_file_size_multiplier(ValueType.INT), | |
100 | max_bytes_for_level_base(ValueType.LONG), | |
101 | max_bytes_for_level_multiplier(ValueType.INT), | |
494da23a | 102 | max_bytes_for_level_multiplier_additional(ValueType.INT_ARRAY), |
1e59de90 TL |
103 | ttl(ValueType.LONG), |
104 | periodic_compaction_seconds(ValueType.LONG); | |
7c673cae FG |
105 | |
106 | private final ValueType valueType; | |
107 | CompactionOption(final ValueType valueType) { | |
108 | this.valueType = valueType; | |
109 | } | |
110 | ||
111 | @Override | |
112 | public ValueType getValueType() { | |
113 | return valueType; | |
114 | } | |
115 | } | |
116 | ||
1e59de90 TL |
117 | public enum BlobOption implements MutableColumnFamilyOptionKey { |
118 | enable_blob_files(ValueType.BOOLEAN), | |
119 | min_blob_size(ValueType.LONG), | |
120 | blob_file_size(ValueType.LONG), | |
121 | blob_compression_type(ValueType.ENUM), | |
122 | enable_blob_garbage_collection(ValueType.BOOLEAN), | |
123 | blob_garbage_collection_age_cutoff(ValueType.DOUBLE), | |
124 | blob_garbage_collection_force_threshold(ValueType.DOUBLE), | |
125 | blob_compaction_readahead_size(ValueType.LONG), | |
126 | blob_file_starting_level(ValueType.INT), | |
127 | prepopulate_blob_cache(ValueType.ENUM); | |
128 | ||
129 | private final ValueType valueType; | |
130 | BlobOption(final ValueType valueType) { | |
131 | this.valueType = valueType; | |
132 | } | |
133 | ||
134 | @Override | |
135 | public ValueType getValueType() { | |
136 | return valueType; | |
137 | } | |
138 | } | |
139 | ||
7c673cae FG |
140 | public enum MiscOption implements MutableColumnFamilyOptionKey { |
141 | max_sequential_skip_in_iterations(ValueType.LONG), | |
142 | paranoid_file_checks(ValueType.BOOLEAN), | |
143 | report_bg_io_stats(ValueType.BOOLEAN), | |
1e59de90 | 144 | compression(ValueType.ENUM); |
7c673cae FG |
145 | |
146 | private final ValueType valueType; | |
147 | MiscOption(final ValueType valueType) { | |
148 | this.valueType = valueType; | |
149 | } | |
150 | ||
151 | @Override | |
152 | public ValueType getValueType() { | |
153 | return valueType; | |
154 | } | |
155 | } | |
156 | ||
7c673cae | 157 | public static class MutableColumnFamilyOptionsBuilder |
494da23a TL |
158 | extends AbstractMutableOptionsBuilder<MutableColumnFamilyOptions, MutableColumnFamilyOptionsBuilder, MutableColumnFamilyOptionKey> |
159 | implements MutableColumnFamilyOptionsInterface<MutableColumnFamilyOptionsBuilder> { | |
7c673cae FG |
160 | |
161 | private final static Map<String, MutableColumnFamilyOptionKey> ALL_KEYS_LOOKUP = new HashMap<>(); | |
162 | static { | |
163 | for(final MutableColumnFamilyOptionKey key : MemtableOption.values()) { | |
164 | ALL_KEYS_LOOKUP.put(key.name(), key); | |
165 | } | |
166 | ||
167 | for(final MutableColumnFamilyOptionKey key : CompactionOption.values()) { | |
168 | ALL_KEYS_LOOKUP.put(key.name(), key); | |
169 | } | |
170 | ||
171 | for(final MutableColumnFamilyOptionKey key : MiscOption.values()) { | |
172 | ALL_KEYS_LOOKUP.put(key.name(), key); | |
173 | } | |
1e59de90 TL |
174 | |
175 | for (final MutableColumnFamilyOptionKey key : BlobOption.values()) { | |
176 | ALL_KEYS_LOOKUP.put(key.name(), key); | |
177 | } | |
7c673cae FG |
178 | } |
179 | ||
494da23a TL |
180 | private MutableColumnFamilyOptionsBuilder() { |
181 | super(); | |
7c673cae FG |
182 | } |
183 | ||
494da23a TL |
184 | @Override |
185 | protected MutableColumnFamilyOptionsBuilder self() { | |
7c673cae | 186 | return this; |
7c673cae FG |
187 | } |
188 | ||
494da23a TL |
189 | @Override |
190 | protected Map<String, MutableColumnFamilyOptionKey> allKeys() { | |
191 | return ALL_KEYS_LOOKUP; | |
7c673cae FG |
192 | } |
193 | ||
494da23a TL |
194 | @Override |
195 | protected MutableColumnFamilyOptions build(final String[] keys, | |
196 | final String[] values) { | |
197 | return new MutableColumnFamilyOptions(keys, values); | |
7c673cae FG |
198 | } |
199 | ||
200 | @Override | |
201 | public MutableColumnFamilyOptionsBuilder setWriteBufferSize( | |
202 | final long writeBufferSize) { | |
203 | return setLong(MemtableOption.write_buffer_size, writeBufferSize); | |
204 | } | |
205 | ||
206 | @Override | |
207 | public long writeBufferSize() { | |
208 | return getLong(MemtableOption.write_buffer_size); | |
209 | } | |
210 | ||
211 | @Override | |
212 | public MutableColumnFamilyOptionsBuilder setArenaBlockSize( | |
213 | final long arenaBlockSize) { | |
214 | return setLong(MemtableOption.arena_block_size, arenaBlockSize); | |
215 | } | |
216 | ||
217 | @Override | |
218 | public long arenaBlockSize() { | |
219 | return getLong(MemtableOption.arena_block_size); | |
220 | } | |
221 | ||
222 | @Override | |
223 | public MutableColumnFamilyOptionsBuilder setMemtablePrefixBloomSizeRatio( | |
224 | final double memtablePrefixBloomSizeRatio) { | |
225 | return setDouble(MemtableOption.memtable_prefix_bloom_size_ratio, | |
226 | memtablePrefixBloomSizeRatio); | |
227 | } | |
228 | ||
229 | @Override | |
230 | public double memtablePrefixBloomSizeRatio() { | |
231 | return getDouble(MemtableOption.memtable_prefix_bloom_size_ratio); | |
232 | } | |
233 | ||
1e59de90 TL |
234 | @Override |
235 | public MutableColumnFamilyOptionsBuilder setMemtableWholeKeyFiltering( | |
236 | final boolean memtableWholeKeyFiltering) { | |
237 | return setBoolean(MemtableOption.memtable_whole_key_filtering, memtableWholeKeyFiltering); | |
238 | } | |
239 | ||
240 | @Override | |
241 | public boolean memtableWholeKeyFiltering() { | |
242 | return getBoolean(MemtableOption.memtable_whole_key_filtering); | |
243 | } | |
244 | ||
7c673cae FG |
245 | @Override |
246 | public MutableColumnFamilyOptionsBuilder setMemtableHugePageSize( | |
247 | final long memtableHugePageSize) { | |
248 | return setLong(MemtableOption.memtable_huge_page_size, | |
249 | memtableHugePageSize); | |
250 | } | |
251 | ||
252 | @Override | |
253 | public long memtableHugePageSize() { | |
254 | return getLong(MemtableOption.memtable_huge_page_size); | |
255 | } | |
256 | ||
257 | @Override | |
258 | public MutableColumnFamilyOptionsBuilder setMaxSuccessiveMerges( | |
259 | final long maxSuccessiveMerges) { | |
260 | return setLong(MemtableOption.max_successive_merges, maxSuccessiveMerges); | |
261 | } | |
262 | ||
263 | @Override | |
264 | public long maxSuccessiveMerges() { | |
265 | return getLong(MemtableOption.max_successive_merges); | |
266 | } | |
267 | ||
268 | @Override | |
269 | public MutableColumnFamilyOptionsBuilder setMaxWriteBufferNumber( | |
270 | final int maxWriteBufferNumber) { | |
271 | return setInt(MemtableOption.max_write_buffer_number, | |
272 | maxWriteBufferNumber); | |
273 | } | |
274 | ||
275 | @Override | |
276 | public int maxWriteBufferNumber() { | |
277 | return getInt(MemtableOption.max_write_buffer_number); | |
278 | } | |
279 | ||
280 | @Override | |
281 | public MutableColumnFamilyOptionsBuilder setInplaceUpdateNumLocks( | |
282 | final long inplaceUpdateNumLocks) { | |
283 | return setLong(MemtableOption.inplace_update_num_locks, | |
284 | inplaceUpdateNumLocks); | |
285 | } | |
286 | ||
287 | @Override | |
288 | public long inplaceUpdateNumLocks() { | |
289 | return getLong(MemtableOption.inplace_update_num_locks); | |
290 | } | |
291 | ||
1e59de90 TL |
292 | @Override |
293 | public MutableColumnFamilyOptionsBuilder setExperimentalMempurgeThreshold( | |
294 | final double experimentalMempurgeThreshold) { | |
295 | return setDouble( | |
296 | MemtableOption.experimental_mempurge_threshold, experimentalMempurgeThreshold); | |
297 | } | |
298 | ||
299 | @Override | |
300 | public double experimentalMempurgeThreshold() { | |
301 | return getDouble(MemtableOption.experimental_mempurge_threshold); | |
302 | } | |
303 | ||
7c673cae FG |
304 | @Override |
305 | public MutableColumnFamilyOptionsBuilder setDisableAutoCompactions( | |
306 | final boolean disableAutoCompactions) { | |
307 | return setBoolean(CompactionOption.disable_auto_compactions, | |
308 | disableAutoCompactions); | |
309 | } | |
310 | ||
311 | @Override | |
312 | public boolean disableAutoCompactions() { | |
313 | return getBoolean(CompactionOption.disable_auto_compactions); | |
314 | } | |
315 | ||
316 | @Override | |
317 | public MutableColumnFamilyOptionsBuilder setSoftPendingCompactionBytesLimit( | |
318 | final long softPendingCompactionBytesLimit) { | |
319 | return setLong(CompactionOption.soft_pending_compaction_bytes_limit, | |
320 | softPendingCompactionBytesLimit); | |
321 | } | |
322 | ||
323 | @Override | |
324 | public long softPendingCompactionBytesLimit() { | |
325 | return getLong(CompactionOption.soft_pending_compaction_bytes_limit); | |
326 | } | |
327 | ||
328 | @Override | |
329 | public MutableColumnFamilyOptionsBuilder setHardPendingCompactionBytesLimit( | |
330 | final long hardPendingCompactionBytesLimit) { | |
331 | return setLong(CompactionOption.hard_pending_compaction_bytes_limit, | |
332 | hardPendingCompactionBytesLimit); | |
333 | } | |
334 | ||
335 | @Override | |
336 | public long hardPendingCompactionBytesLimit() { | |
337 | return getLong(CompactionOption.hard_pending_compaction_bytes_limit); | |
338 | } | |
339 | ||
340 | @Override | |
341 | public MutableColumnFamilyOptionsBuilder setLevel0FileNumCompactionTrigger( | |
342 | final int level0FileNumCompactionTrigger) { | |
343 | return setInt(CompactionOption.level0_file_num_compaction_trigger, | |
344 | level0FileNumCompactionTrigger); | |
345 | } | |
346 | ||
347 | @Override | |
348 | public int level0FileNumCompactionTrigger() { | |
349 | return getInt(CompactionOption.level0_file_num_compaction_trigger); | |
350 | } | |
351 | ||
352 | @Override | |
353 | public MutableColumnFamilyOptionsBuilder setLevel0SlowdownWritesTrigger( | |
354 | final int level0SlowdownWritesTrigger) { | |
355 | return setInt(CompactionOption.level0_slowdown_writes_trigger, | |
356 | level0SlowdownWritesTrigger); | |
357 | } | |
358 | ||
359 | @Override | |
360 | public int level0SlowdownWritesTrigger() { | |
361 | return getInt(CompactionOption.level0_slowdown_writes_trigger); | |
362 | } | |
363 | ||
364 | @Override | |
365 | public MutableColumnFamilyOptionsBuilder setLevel0StopWritesTrigger( | |
366 | final int level0StopWritesTrigger) { | |
367 | return setInt(CompactionOption.level0_stop_writes_trigger, | |
368 | level0StopWritesTrigger); | |
369 | } | |
370 | ||
371 | @Override | |
372 | public int level0StopWritesTrigger() { | |
373 | return getInt(CompactionOption.level0_stop_writes_trigger); | |
374 | } | |
375 | ||
376 | @Override | |
377 | public MutableColumnFamilyOptionsBuilder setMaxCompactionBytes(final long maxCompactionBytes) { | |
378 | return setLong(CompactionOption.max_compaction_bytes, maxCompactionBytes); | |
379 | } | |
380 | ||
381 | @Override | |
382 | public long maxCompactionBytes() { | |
383 | return getLong(CompactionOption.max_compaction_bytes); | |
384 | } | |
385 | ||
386 | ||
387 | @Override | |
388 | public MutableColumnFamilyOptionsBuilder setTargetFileSizeBase( | |
389 | final long targetFileSizeBase) { | |
390 | return setLong(CompactionOption.target_file_size_base, | |
391 | targetFileSizeBase); | |
392 | } | |
393 | ||
394 | @Override | |
395 | public long targetFileSizeBase() { | |
396 | return getLong(CompactionOption.target_file_size_base); | |
397 | } | |
398 | ||
399 | @Override | |
400 | public MutableColumnFamilyOptionsBuilder setTargetFileSizeMultiplier( | |
401 | final int targetFileSizeMultiplier) { | |
402 | return setInt(CompactionOption.target_file_size_multiplier, | |
403 | targetFileSizeMultiplier); | |
404 | } | |
405 | ||
406 | @Override | |
407 | public int targetFileSizeMultiplier() { | |
408 | return getInt(CompactionOption.target_file_size_multiplier); | |
409 | } | |
410 | ||
411 | @Override | |
412 | public MutableColumnFamilyOptionsBuilder setMaxBytesForLevelBase( | |
413 | final long maxBytesForLevelBase) { | |
414 | return setLong(CompactionOption.max_bytes_for_level_base, | |
415 | maxBytesForLevelBase); | |
416 | } | |
417 | ||
418 | @Override | |
419 | public long maxBytesForLevelBase() { | |
420 | return getLong(CompactionOption.max_bytes_for_level_base); | |
421 | } | |
422 | ||
423 | @Override | |
424 | public MutableColumnFamilyOptionsBuilder setMaxBytesForLevelMultiplier( | |
425 | final double maxBytesForLevelMultiplier) { | |
426 | return setDouble(CompactionOption.max_bytes_for_level_multiplier, maxBytesForLevelMultiplier); | |
427 | } | |
428 | ||
429 | @Override | |
430 | public double maxBytesForLevelMultiplier() { | |
431 | return getDouble(CompactionOption.max_bytes_for_level_multiplier); | |
432 | } | |
433 | ||
434 | @Override | |
435 | public MutableColumnFamilyOptionsBuilder setMaxBytesForLevelMultiplierAdditional( | |
436 | final int[] maxBytesForLevelMultiplierAdditional) { | |
437 | return setIntArray( | |
438 | CompactionOption.max_bytes_for_level_multiplier_additional, | |
439 | maxBytesForLevelMultiplierAdditional); | |
440 | } | |
441 | ||
442 | @Override | |
443 | public int[] maxBytesForLevelMultiplierAdditional() { | |
444 | return getIntArray( | |
445 | CompactionOption.max_bytes_for_level_multiplier_additional); | |
446 | } | |
447 | ||
448 | @Override | |
449 | public MutableColumnFamilyOptionsBuilder setMaxSequentialSkipInIterations( | |
450 | final long maxSequentialSkipInIterations) { | |
451 | return setLong(MiscOption.max_sequential_skip_in_iterations, | |
452 | maxSequentialSkipInIterations); | |
453 | } | |
454 | ||
455 | @Override | |
456 | public long maxSequentialSkipInIterations() { | |
457 | return getLong(MiscOption.max_sequential_skip_in_iterations); | |
458 | } | |
459 | ||
460 | @Override | |
461 | public MutableColumnFamilyOptionsBuilder setParanoidFileChecks( | |
462 | final boolean paranoidFileChecks) { | |
463 | return setBoolean(MiscOption.paranoid_file_checks, paranoidFileChecks); | |
464 | } | |
465 | ||
466 | @Override | |
467 | public boolean paranoidFileChecks() { | |
468 | return getBoolean(MiscOption.paranoid_file_checks); | |
469 | } | |
470 | ||
471 | @Override | |
472 | public MutableColumnFamilyOptionsBuilder setCompressionType( | |
473 | final CompressionType compressionType) { | |
1e59de90 | 474 | return setEnum(MiscOption.compression, compressionType); |
7c673cae FG |
475 | } |
476 | ||
477 | @Override | |
478 | public CompressionType compressionType() { | |
1e59de90 | 479 | return (CompressionType) getEnum(MiscOption.compression); |
7c673cae FG |
480 | } |
481 | ||
482 | @Override | |
483 | public MutableColumnFamilyOptionsBuilder setReportBgIoStats( | |
484 | final boolean reportBgIoStats) { | |
485 | return setBoolean(MiscOption.report_bg_io_stats, reportBgIoStats); | |
486 | } | |
487 | ||
488 | @Override | |
489 | public boolean reportBgIoStats() { | |
490 | return getBoolean(MiscOption.report_bg_io_stats); | |
491 | } | |
494da23a TL |
492 | |
493 | @Override | |
494 | public MutableColumnFamilyOptionsBuilder setTtl(final long ttl) { | |
495 | return setLong(CompactionOption.ttl, ttl); | |
496 | } | |
497 | ||
498 | @Override | |
499 | public long ttl() { | |
500 | return getLong(CompactionOption.ttl); | |
501 | } | |
1e59de90 TL |
502 | |
503 | @Override | |
504 | public MutableColumnFamilyOptionsBuilder setPeriodicCompactionSeconds( | |
505 | final long periodicCompactionSeconds) { | |
506 | return setLong(CompactionOption.periodic_compaction_seconds, periodicCompactionSeconds); | |
507 | } | |
508 | ||
509 | @Override | |
510 | public long periodicCompactionSeconds() { | |
511 | return getLong(CompactionOption.periodic_compaction_seconds); | |
512 | } | |
513 | ||
514 | @Override | |
515 | public MutableColumnFamilyOptionsBuilder setEnableBlobFiles(final boolean enableBlobFiles) { | |
516 | return setBoolean(BlobOption.enable_blob_files, enableBlobFiles); | |
517 | } | |
518 | ||
519 | @Override | |
520 | public boolean enableBlobFiles() { | |
521 | return getBoolean(BlobOption.enable_blob_files); | |
522 | } | |
523 | ||
524 | @Override | |
525 | public MutableColumnFamilyOptionsBuilder setMinBlobSize(final long minBlobSize) { | |
526 | return setLong(BlobOption.min_blob_size, minBlobSize); | |
527 | } | |
528 | ||
529 | @Override | |
530 | public long minBlobSize() { | |
531 | return getLong(BlobOption.min_blob_size); | |
532 | } | |
533 | ||
534 | @Override | |
535 | public MutableColumnFamilyOptionsBuilder setBlobFileSize(final long blobFileSize) { | |
536 | return setLong(BlobOption.blob_file_size, blobFileSize); | |
537 | } | |
538 | ||
539 | @Override | |
540 | public long blobFileSize() { | |
541 | return getLong(BlobOption.blob_file_size); | |
542 | } | |
543 | ||
544 | @Override | |
545 | public MutableColumnFamilyOptionsBuilder setBlobCompressionType( | |
546 | final CompressionType compressionType) { | |
547 | return setEnum(BlobOption.blob_compression_type, compressionType); | |
548 | } | |
549 | ||
550 | @Override | |
551 | public CompressionType blobCompressionType() { | |
552 | return (CompressionType) getEnum(BlobOption.blob_compression_type); | |
553 | } | |
554 | ||
555 | @Override | |
556 | public MutableColumnFamilyOptionsBuilder setEnableBlobGarbageCollection( | |
557 | final boolean enableBlobGarbageCollection) { | |
558 | return setBoolean(BlobOption.enable_blob_garbage_collection, enableBlobGarbageCollection); | |
559 | } | |
560 | ||
561 | @Override | |
562 | public boolean enableBlobGarbageCollection() { | |
563 | return getBoolean(BlobOption.enable_blob_garbage_collection); | |
564 | } | |
565 | ||
566 | @Override | |
567 | public MutableColumnFamilyOptionsBuilder setBlobGarbageCollectionAgeCutoff( | |
568 | final double blobGarbageCollectionAgeCutoff) { | |
569 | return setDouble( | |
570 | BlobOption.blob_garbage_collection_age_cutoff, blobGarbageCollectionAgeCutoff); | |
571 | } | |
572 | ||
573 | @Override | |
574 | public double blobGarbageCollectionAgeCutoff() { | |
575 | return getDouble(BlobOption.blob_garbage_collection_age_cutoff); | |
576 | } | |
577 | ||
578 | @Override | |
579 | public MutableColumnFamilyOptionsBuilder setBlobGarbageCollectionForceThreshold( | |
580 | final double blobGarbageCollectionForceThreshold) { | |
581 | return setDouble( | |
582 | BlobOption.blob_garbage_collection_force_threshold, blobGarbageCollectionForceThreshold); | |
583 | } | |
584 | ||
585 | @Override | |
586 | public double blobGarbageCollectionForceThreshold() { | |
587 | return getDouble(BlobOption.blob_garbage_collection_force_threshold); | |
588 | } | |
589 | ||
590 | @Override | |
591 | public MutableColumnFamilyOptionsBuilder setBlobCompactionReadaheadSize( | |
592 | final long blobCompactionReadaheadSize) { | |
593 | return setLong(BlobOption.blob_compaction_readahead_size, blobCompactionReadaheadSize); | |
594 | } | |
595 | ||
596 | @Override | |
597 | public long blobCompactionReadaheadSize() { | |
598 | return getLong(BlobOption.blob_compaction_readahead_size); | |
599 | } | |
600 | ||
601 | @Override | |
602 | public MutableColumnFamilyOptionsBuilder setBlobFileStartingLevel( | |
603 | final int blobFileStartingLevel) { | |
604 | return setInt(BlobOption.blob_file_starting_level, blobFileStartingLevel); | |
605 | } | |
606 | ||
607 | @Override | |
608 | public int blobFileStartingLevel() { | |
609 | return getInt(BlobOption.blob_file_starting_level); | |
610 | } | |
611 | ||
612 | @Override | |
613 | public MutableColumnFamilyOptionsBuilder setPrepopulateBlobCache( | |
614 | final PrepopulateBlobCache prepopulateBlobCache) { | |
615 | return setEnum(BlobOption.prepopulate_blob_cache, prepopulateBlobCache); | |
616 | } | |
617 | ||
618 | @Override | |
619 | public PrepopulateBlobCache prepopulateBlobCache() { | |
620 | return (PrepopulateBlobCache) getEnum(BlobOption.prepopulate_blob_cache); | |
621 | } | |
7c673cae FG |
622 | } |
623 | } |