1 // Copyright (c) 2011-present, Facebook, Inc. All rights reserved. 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). 5 6 package org.rocksdb; 7 8 import java.util.ArrayList; 9 import java.util.List; 10 import java.util.Properties; 11 12 /** 13 * ColumnFamilyOptions to control the behavior of a database. It will be used 14 * during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()). 15 * 16 * If {@link #dispose()} function is not called, then it will be GC'd 17 * automatically and native resources will be released as part of the process. 18 */ 19 public class ColumnFamilyOptions extends RocksObject 20 implements ColumnFamilyOptionsInterface<ColumnFamilyOptions>, 21 MutableColumnFamilyOptionsInterface<ColumnFamilyOptions> { 22 static { RocksDB.loadLibrary()23 RocksDB.loadLibrary(); 24 } 25 26 /** 27 * Construct ColumnFamilyOptions. 28 * 29 * This constructor will create (by allocating a block of memory) 30 * an {@code rocksdb::ColumnFamilyOptions} in the c++ side. 31 */ ColumnFamilyOptions()32 public ColumnFamilyOptions() { 33 super(newColumnFamilyOptions()); 34 } 35 36 /** 37 * Copy constructor for ColumnFamilyOptions. 38 * 39 * NOTE: This does a shallow copy, which means comparator, merge_operator, compaction_filter, 40 * compaction_filter_factory and other pointers will be cloned! 41 * 42 * @param other The ColumnFamilyOptions to copy. 43 */ ColumnFamilyOptions(ColumnFamilyOptions other)44 public ColumnFamilyOptions(ColumnFamilyOptions other) { 45 super(copyColumnFamilyOptions(other.nativeHandle_)); 46 this.memTableConfig_ = other.memTableConfig_; 47 this.tableFormatConfig_ = other.tableFormatConfig_; 48 this.comparator_ = other.comparator_; 49 this.compactionFilter_ = other.compactionFilter_; 50 this.compactionFilterFactory_ = other.compactionFilterFactory_; 51 this.compactionOptionsUniversal_ = other.compactionOptionsUniversal_; 52 this.compactionOptionsFIFO_ = other.compactionOptionsFIFO_; 53 this.bottommostCompressionOptions_ = other.bottommostCompressionOptions_; 54 this.compressionOptions_ = other.compressionOptions_; 55 } 56 57 /** 58 * Constructor from Options 59 * 60 * @param options The options. 61 */ ColumnFamilyOptions(final Options options)62 public ColumnFamilyOptions(final Options options) { 63 super(newColumnFamilyOptionsFromOptions(options.nativeHandle_)); 64 } 65 66 /** 67 * <p>Constructor to be used by 68 * {@link #getColumnFamilyOptionsFromProps(java.util.Properties)}, 69 * {@link ColumnFamilyDescriptor#getOptions()} 70 * and also called via JNI.</p> 71 * 72 * @param handle native handle to ColumnFamilyOptions instance. 73 */ ColumnFamilyOptions(final long handle)74 ColumnFamilyOptions(final long handle) { 75 super(handle); 76 } 77 78 /** 79 * <p>Method to get a options instance by using pre-configured 80 * property values. If one or many values are undefined in 81 * the context of RocksDB the method will return a null 82 * value.</p> 83 * 84 * <p><strong>Note</strong>: Property keys can be derived from 85 * getter methods within the options class. Example: the method 86 * {@code writeBufferSize()} has a property key: 87 * {@code write_buffer_size}.</p> 88 * 89 * @param properties {@link java.util.Properties} instance. 90 * 91 * @return {@link org.rocksdb.ColumnFamilyOptions instance} 92 * or null. 93 * 94 * @throws java.lang.IllegalArgumentException if null or empty 95 * {@link Properties} instance is passed to the method call. 96 */ getColumnFamilyOptionsFromProps( final Properties properties)97 public static ColumnFamilyOptions getColumnFamilyOptionsFromProps( 98 final Properties properties) { 99 if (properties == null || properties.size() == 0) { 100 throw new IllegalArgumentException( 101 "Properties value must contain at least one value."); 102 } 103 ColumnFamilyOptions columnFamilyOptions = null; 104 StringBuilder stringBuilder = new StringBuilder(); 105 for (final String name : properties.stringPropertyNames()){ 106 stringBuilder.append(name); 107 stringBuilder.append("="); 108 stringBuilder.append(properties.getProperty(name)); 109 stringBuilder.append(";"); 110 } 111 long handle = getColumnFamilyOptionsFromProps( 112 stringBuilder.toString()); 113 if (handle != 0){ 114 columnFamilyOptions = new ColumnFamilyOptions(handle); 115 } 116 return columnFamilyOptions; 117 } 118 119 @Override optimizeForSmallDb()120 public ColumnFamilyOptions optimizeForSmallDb() { 121 optimizeForSmallDb(nativeHandle_); 122 return this; 123 } 124 125 @Override optimizeForPointLookup( final long blockCacheSizeMb)126 public ColumnFamilyOptions optimizeForPointLookup( 127 final long blockCacheSizeMb) { 128 optimizeForPointLookup(nativeHandle_, 129 blockCacheSizeMb); 130 return this; 131 } 132 133 @Override optimizeLevelStyleCompaction()134 public ColumnFamilyOptions optimizeLevelStyleCompaction() { 135 optimizeLevelStyleCompaction(nativeHandle_, 136 DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); 137 return this; 138 } 139 140 @Override optimizeLevelStyleCompaction( final long memtableMemoryBudget)141 public ColumnFamilyOptions optimizeLevelStyleCompaction( 142 final long memtableMemoryBudget) { 143 optimizeLevelStyleCompaction(nativeHandle_, 144 memtableMemoryBudget); 145 return this; 146 } 147 148 @Override optimizeUniversalStyleCompaction()149 public ColumnFamilyOptions optimizeUniversalStyleCompaction() { 150 optimizeUniversalStyleCompaction(nativeHandle_, 151 DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); 152 return this; 153 } 154 155 @Override optimizeUniversalStyleCompaction( final long memtableMemoryBudget)156 public ColumnFamilyOptions optimizeUniversalStyleCompaction( 157 final long memtableMemoryBudget) { 158 optimizeUniversalStyleCompaction(nativeHandle_, 159 memtableMemoryBudget); 160 return this; 161 } 162 163 @Override setComparator( final BuiltinComparator builtinComparator)164 public ColumnFamilyOptions setComparator( 165 final BuiltinComparator builtinComparator) { 166 assert(isOwningHandle()); 167 setComparatorHandle(nativeHandle_, builtinComparator.ordinal()); 168 return this; 169 } 170 171 @Override setComparator( final AbstractComparator comparator)172 public ColumnFamilyOptions setComparator( 173 final AbstractComparator comparator) { 174 assert (isOwningHandle()); 175 setComparatorHandle(nativeHandle_, comparator.nativeHandle_, 176 comparator.getComparatorType().getValue()); 177 comparator_ = comparator; 178 return this; 179 } 180 181 @Override setMergeOperatorName(final String name)182 public ColumnFamilyOptions setMergeOperatorName(final String name) { 183 assert (isOwningHandle()); 184 if (name == null) { 185 throw new IllegalArgumentException( 186 "Merge operator name must not be null."); 187 } 188 setMergeOperatorName(nativeHandle_, name); 189 return this; 190 } 191 192 @Override setMergeOperator( final MergeOperator mergeOperator)193 public ColumnFamilyOptions setMergeOperator( 194 final MergeOperator mergeOperator) { 195 setMergeOperator(nativeHandle_, mergeOperator.nativeHandle_); 196 return this; 197 } 198 199 @Override setCompactionFilter( final AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter)200 public ColumnFamilyOptions setCompactionFilter( 201 final AbstractCompactionFilter<? extends AbstractSlice<?>> 202 compactionFilter) { 203 setCompactionFilterHandle(nativeHandle_, compactionFilter.nativeHandle_); 204 compactionFilter_ = compactionFilter; 205 return this; 206 } 207 208 @Override compactionFilter()209 public AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter() { 210 assert (isOwningHandle()); 211 return compactionFilter_; 212 } 213 214 @Override setCompactionFilterFactory(final AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory)215 public ColumnFamilyOptions setCompactionFilterFactory(final AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory) { 216 assert (isOwningHandle()); 217 setCompactionFilterFactoryHandle(nativeHandle_, compactionFilterFactory.nativeHandle_); 218 compactionFilterFactory_ = compactionFilterFactory; 219 return this; 220 } 221 222 @Override compactionFilterFactory()223 public AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory() { 224 assert (isOwningHandle()); 225 return compactionFilterFactory_; 226 } 227 228 @Override setWriteBufferSize(final long writeBufferSize)229 public ColumnFamilyOptions setWriteBufferSize(final long writeBufferSize) { 230 assert(isOwningHandle()); 231 setWriteBufferSize(nativeHandle_, writeBufferSize); 232 return this; 233 } 234 235 @Override writeBufferSize()236 public long writeBufferSize() { 237 assert(isOwningHandle()); 238 return writeBufferSize(nativeHandle_); 239 } 240 241 @Override setMaxWriteBufferNumber( final int maxWriteBufferNumber)242 public ColumnFamilyOptions setMaxWriteBufferNumber( 243 final int maxWriteBufferNumber) { 244 assert(isOwningHandle()); 245 setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); 246 return this; 247 } 248 249 @Override maxWriteBufferNumber()250 public int maxWriteBufferNumber() { 251 assert(isOwningHandle()); 252 return maxWriteBufferNumber(nativeHandle_); 253 } 254 255 @Override setMinWriteBufferNumberToMerge( final int minWriteBufferNumberToMerge)256 public ColumnFamilyOptions setMinWriteBufferNumberToMerge( 257 final int minWriteBufferNumberToMerge) { 258 setMinWriteBufferNumberToMerge(nativeHandle_, minWriteBufferNumberToMerge); 259 return this; 260 } 261 262 @Override minWriteBufferNumberToMerge()263 public int minWriteBufferNumberToMerge() { 264 return minWriteBufferNumberToMerge(nativeHandle_); 265 } 266 267 @Override useFixedLengthPrefixExtractor(final int n)268 public ColumnFamilyOptions useFixedLengthPrefixExtractor(final int n) { 269 assert(isOwningHandle()); 270 useFixedLengthPrefixExtractor(nativeHandle_, n); 271 return this; 272 } 273 274 @Override useCappedPrefixExtractor(final int n)275 public ColumnFamilyOptions useCappedPrefixExtractor(final int n) { 276 assert(isOwningHandle()); 277 useCappedPrefixExtractor(nativeHandle_, n); 278 return this; 279 } 280 281 @Override setCompressionType( final CompressionType compressionType)282 public ColumnFamilyOptions setCompressionType( 283 final CompressionType compressionType) { 284 setCompressionType(nativeHandle_, compressionType.getValue()); 285 return this; 286 } 287 288 @Override compressionType()289 public CompressionType compressionType() { 290 return CompressionType.getCompressionType(compressionType(nativeHandle_)); 291 } 292 293 @Override setCompressionPerLevel( final List<CompressionType> compressionLevels)294 public ColumnFamilyOptions setCompressionPerLevel( 295 final List<CompressionType> compressionLevels) { 296 final byte[] byteCompressionTypes = new byte[ 297 compressionLevels.size()]; 298 for (int i = 0; i < compressionLevels.size(); i++) { 299 byteCompressionTypes[i] = compressionLevels.get(i).getValue(); 300 } 301 setCompressionPerLevel(nativeHandle_, byteCompressionTypes); 302 return this; 303 } 304 305 @Override compressionPerLevel()306 public List<CompressionType> compressionPerLevel() { 307 final byte[] byteCompressionTypes = 308 compressionPerLevel(nativeHandle_); 309 final List<CompressionType> compressionLevels = new ArrayList<>(); 310 for (final Byte byteCompressionType : byteCompressionTypes) { 311 compressionLevels.add(CompressionType.getCompressionType( 312 byteCompressionType)); 313 } 314 return compressionLevels; 315 } 316 317 @Override setBottommostCompressionType( final CompressionType bottommostCompressionType)318 public ColumnFamilyOptions setBottommostCompressionType( 319 final CompressionType bottommostCompressionType) { 320 setBottommostCompressionType(nativeHandle_, 321 bottommostCompressionType.getValue()); 322 return this; 323 } 324 325 @Override bottommostCompressionType()326 public CompressionType bottommostCompressionType() { 327 return CompressionType.getCompressionType( 328 bottommostCompressionType(nativeHandle_)); 329 } 330 331 @Override setBottommostCompressionOptions( final CompressionOptions bottommostCompressionOptions)332 public ColumnFamilyOptions setBottommostCompressionOptions( 333 final CompressionOptions bottommostCompressionOptions) { 334 setBottommostCompressionOptions(nativeHandle_, 335 bottommostCompressionOptions.nativeHandle_); 336 this.bottommostCompressionOptions_ = bottommostCompressionOptions; 337 return this; 338 } 339 340 @Override bottommostCompressionOptions()341 public CompressionOptions bottommostCompressionOptions() { 342 return this.bottommostCompressionOptions_; 343 } 344 345 @Override setCompressionOptions( final CompressionOptions compressionOptions)346 public ColumnFamilyOptions setCompressionOptions( 347 final CompressionOptions compressionOptions) { 348 setCompressionOptions(nativeHandle_, compressionOptions.nativeHandle_); 349 this.compressionOptions_ = compressionOptions; 350 return this; 351 } 352 353 @Override compressionOptions()354 public CompressionOptions compressionOptions() { 355 return this.compressionOptions_; 356 } 357 358 @Override setNumLevels(final int numLevels)359 public ColumnFamilyOptions setNumLevels(final int numLevels) { 360 setNumLevels(nativeHandle_, numLevels); 361 return this; 362 } 363 364 @Override numLevels()365 public int numLevels() { 366 return numLevels(nativeHandle_); 367 } 368 369 @Override setLevelZeroFileNumCompactionTrigger( final int numFiles)370 public ColumnFamilyOptions setLevelZeroFileNumCompactionTrigger( 371 final int numFiles) { 372 setLevelZeroFileNumCompactionTrigger( 373 nativeHandle_, numFiles); 374 return this; 375 } 376 377 @Override levelZeroFileNumCompactionTrigger()378 public int levelZeroFileNumCompactionTrigger() { 379 return levelZeroFileNumCompactionTrigger(nativeHandle_); 380 } 381 382 @Override setLevelZeroSlowdownWritesTrigger( final int numFiles)383 public ColumnFamilyOptions setLevelZeroSlowdownWritesTrigger( 384 final int numFiles) { 385 setLevelZeroSlowdownWritesTrigger(nativeHandle_, numFiles); 386 return this; 387 } 388 389 @Override levelZeroSlowdownWritesTrigger()390 public int levelZeroSlowdownWritesTrigger() { 391 return levelZeroSlowdownWritesTrigger(nativeHandle_); 392 } 393 394 @Override setLevelZeroStopWritesTrigger(final int numFiles)395 public ColumnFamilyOptions setLevelZeroStopWritesTrigger(final int numFiles) { 396 setLevelZeroStopWritesTrigger(nativeHandle_, numFiles); 397 return this; 398 } 399 400 @Override levelZeroStopWritesTrigger()401 public int levelZeroStopWritesTrigger() { 402 return levelZeroStopWritesTrigger(nativeHandle_); 403 } 404 405 @Override setTargetFileSizeBase( final long targetFileSizeBase)406 public ColumnFamilyOptions setTargetFileSizeBase( 407 final long targetFileSizeBase) { 408 setTargetFileSizeBase(nativeHandle_, targetFileSizeBase); 409 return this; 410 } 411 412 @Override targetFileSizeBase()413 public long targetFileSizeBase() { 414 return targetFileSizeBase(nativeHandle_); 415 } 416 417 @Override setTargetFileSizeMultiplier( final int multiplier)418 public ColumnFamilyOptions setTargetFileSizeMultiplier( 419 final int multiplier) { 420 setTargetFileSizeMultiplier(nativeHandle_, multiplier); 421 return this; 422 } 423 424 @Override targetFileSizeMultiplier()425 public int targetFileSizeMultiplier() { 426 return targetFileSizeMultiplier(nativeHandle_); 427 } 428 429 @Override setMaxBytesForLevelBase( final long maxBytesForLevelBase)430 public ColumnFamilyOptions setMaxBytesForLevelBase( 431 final long maxBytesForLevelBase) { 432 setMaxBytesForLevelBase(nativeHandle_, maxBytesForLevelBase); 433 return this; 434 } 435 436 @Override maxBytesForLevelBase()437 public long maxBytesForLevelBase() { 438 return maxBytesForLevelBase(nativeHandle_); 439 } 440 441 @Override setLevelCompactionDynamicLevelBytes( final boolean enableLevelCompactionDynamicLevelBytes)442 public ColumnFamilyOptions setLevelCompactionDynamicLevelBytes( 443 final boolean enableLevelCompactionDynamicLevelBytes) { 444 setLevelCompactionDynamicLevelBytes(nativeHandle_, 445 enableLevelCompactionDynamicLevelBytes); 446 return this; 447 } 448 449 @Override levelCompactionDynamicLevelBytes()450 public boolean levelCompactionDynamicLevelBytes() { 451 return levelCompactionDynamicLevelBytes(nativeHandle_); 452 } 453 454 @Override setMaxBytesForLevelMultiplier(final double multiplier)455 public ColumnFamilyOptions setMaxBytesForLevelMultiplier(final double multiplier) { 456 setMaxBytesForLevelMultiplier(nativeHandle_, multiplier); 457 return this; 458 } 459 460 @Override maxBytesForLevelMultiplier()461 public double maxBytesForLevelMultiplier() { 462 return maxBytesForLevelMultiplier(nativeHandle_); 463 } 464 465 @Override setMaxCompactionBytes(final long maxCompactionBytes)466 public ColumnFamilyOptions setMaxCompactionBytes(final long maxCompactionBytes) { 467 setMaxCompactionBytes(nativeHandle_, maxCompactionBytes); 468 return this; 469 } 470 471 @Override maxCompactionBytes()472 public long maxCompactionBytes() { 473 return maxCompactionBytes(nativeHandle_); 474 } 475 476 @Override setArenaBlockSize( final long arenaBlockSize)477 public ColumnFamilyOptions setArenaBlockSize( 478 final long arenaBlockSize) { 479 setArenaBlockSize(nativeHandle_, arenaBlockSize); 480 return this; 481 } 482 483 @Override arenaBlockSize()484 public long arenaBlockSize() { 485 return arenaBlockSize(nativeHandle_); 486 } 487 488 @Override setDisableAutoCompactions( final boolean disableAutoCompactions)489 public ColumnFamilyOptions setDisableAutoCompactions( 490 final boolean disableAutoCompactions) { 491 setDisableAutoCompactions(nativeHandle_, disableAutoCompactions); 492 return this; 493 } 494 495 @Override disableAutoCompactions()496 public boolean disableAutoCompactions() { 497 return disableAutoCompactions(nativeHandle_); 498 } 499 500 @Override setCompactionStyle( final CompactionStyle compactionStyle)501 public ColumnFamilyOptions setCompactionStyle( 502 final CompactionStyle compactionStyle) { 503 setCompactionStyle(nativeHandle_, compactionStyle.getValue()); 504 return this; 505 } 506 507 @Override compactionStyle()508 public CompactionStyle compactionStyle() { 509 return CompactionStyle.fromValue(compactionStyle(nativeHandle_)); 510 } 511 512 @Override setMaxTableFilesSizeFIFO( final long maxTableFilesSize)513 public ColumnFamilyOptions setMaxTableFilesSizeFIFO( 514 final long maxTableFilesSize) { 515 assert(maxTableFilesSize > 0); // unsigned native type 516 assert(isOwningHandle()); 517 setMaxTableFilesSizeFIFO(nativeHandle_, maxTableFilesSize); 518 return this; 519 } 520 521 @Override maxTableFilesSizeFIFO()522 public long maxTableFilesSizeFIFO() { 523 return maxTableFilesSizeFIFO(nativeHandle_); 524 } 525 526 @Override setMaxSequentialSkipInIterations( final long maxSequentialSkipInIterations)527 public ColumnFamilyOptions setMaxSequentialSkipInIterations( 528 final long maxSequentialSkipInIterations) { 529 setMaxSequentialSkipInIterations(nativeHandle_, 530 maxSequentialSkipInIterations); 531 return this; 532 } 533 534 @Override maxSequentialSkipInIterations()535 public long maxSequentialSkipInIterations() { 536 return maxSequentialSkipInIterations(nativeHandle_); 537 } 538 539 @Override memTableConfig()540 public MemTableConfig memTableConfig() { 541 return this.memTableConfig_; 542 } 543 544 @Override setMemTableConfig( final MemTableConfig memTableConfig)545 public ColumnFamilyOptions setMemTableConfig( 546 final MemTableConfig memTableConfig) { 547 setMemTableFactory( 548 nativeHandle_, memTableConfig.newMemTableFactoryHandle()); 549 this.memTableConfig_ = memTableConfig; 550 return this; 551 } 552 553 @Override memTableFactoryName()554 public String memTableFactoryName() { 555 assert(isOwningHandle()); 556 return memTableFactoryName(nativeHandle_); 557 } 558 559 @Override tableFormatConfig()560 public TableFormatConfig tableFormatConfig() { 561 return this.tableFormatConfig_; 562 } 563 564 @Override setTableFormatConfig( final TableFormatConfig tableFormatConfig)565 public ColumnFamilyOptions setTableFormatConfig( 566 final TableFormatConfig tableFormatConfig) { 567 setTableFactory(nativeHandle_, tableFormatConfig.newTableFactoryHandle()); 568 this.tableFormatConfig_ = tableFormatConfig; 569 return this; 570 } 571 572 @Override tableFactoryName()573 public String tableFactoryName() { 574 assert(isOwningHandle()); 575 return tableFactoryName(nativeHandle_); 576 } 577 578 @Override setInplaceUpdateSupport( final boolean inplaceUpdateSupport)579 public ColumnFamilyOptions setInplaceUpdateSupport( 580 final boolean inplaceUpdateSupport) { 581 setInplaceUpdateSupport(nativeHandle_, inplaceUpdateSupport); 582 return this; 583 } 584 585 @Override inplaceUpdateSupport()586 public boolean inplaceUpdateSupport() { 587 return inplaceUpdateSupport(nativeHandle_); 588 } 589 590 @Override setInplaceUpdateNumLocks( final long inplaceUpdateNumLocks)591 public ColumnFamilyOptions setInplaceUpdateNumLocks( 592 final long inplaceUpdateNumLocks) { 593 setInplaceUpdateNumLocks(nativeHandle_, inplaceUpdateNumLocks); 594 return this; 595 } 596 597 @Override inplaceUpdateNumLocks()598 public long inplaceUpdateNumLocks() { 599 return inplaceUpdateNumLocks(nativeHandle_); 600 } 601 602 @Override setMemtablePrefixBloomSizeRatio( final double memtablePrefixBloomSizeRatio)603 public ColumnFamilyOptions setMemtablePrefixBloomSizeRatio( 604 final double memtablePrefixBloomSizeRatio) { 605 setMemtablePrefixBloomSizeRatio(nativeHandle_, memtablePrefixBloomSizeRatio); 606 return this; 607 } 608 609 @Override memtablePrefixBloomSizeRatio()610 public double memtablePrefixBloomSizeRatio() { 611 return memtablePrefixBloomSizeRatio(nativeHandle_); 612 } 613 614 @Override setBloomLocality(int bloomLocality)615 public ColumnFamilyOptions setBloomLocality(int bloomLocality) { 616 setBloomLocality(nativeHandle_, bloomLocality); 617 return this; 618 } 619 620 @Override bloomLocality()621 public int bloomLocality() { 622 return bloomLocality(nativeHandle_); 623 } 624 625 @Override setMaxSuccessiveMerges( final long maxSuccessiveMerges)626 public ColumnFamilyOptions setMaxSuccessiveMerges( 627 final long maxSuccessiveMerges) { 628 setMaxSuccessiveMerges(nativeHandle_, maxSuccessiveMerges); 629 return this; 630 } 631 632 @Override maxSuccessiveMerges()633 public long maxSuccessiveMerges() { 634 return maxSuccessiveMerges(nativeHandle_); 635 } 636 637 @Override setOptimizeFiltersForHits( final boolean optimizeFiltersForHits)638 public ColumnFamilyOptions setOptimizeFiltersForHits( 639 final boolean optimizeFiltersForHits) { 640 setOptimizeFiltersForHits(nativeHandle_, optimizeFiltersForHits); 641 return this; 642 } 643 644 @Override optimizeFiltersForHits()645 public boolean optimizeFiltersForHits() { 646 return optimizeFiltersForHits(nativeHandle_); 647 } 648 649 @Override 650 public ColumnFamilyOptions setMemtableHugePageSize( long memtableHugePageSize)651 setMemtableHugePageSize( 652 long memtableHugePageSize) { 653 setMemtableHugePageSize(nativeHandle_, 654 memtableHugePageSize); 655 return this; 656 } 657 658 @Override memtableHugePageSize()659 public long memtableHugePageSize() { 660 return memtableHugePageSize(nativeHandle_); 661 } 662 663 @Override setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit)664 public ColumnFamilyOptions setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit) { 665 setSoftPendingCompactionBytesLimit(nativeHandle_, 666 softPendingCompactionBytesLimit); 667 return this; 668 } 669 670 @Override softPendingCompactionBytesLimit()671 public long softPendingCompactionBytesLimit() { 672 return softPendingCompactionBytesLimit(nativeHandle_); 673 } 674 675 @Override setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit)676 public ColumnFamilyOptions setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit) { 677 setHardPendingCompactionBytesLimit(nativeHandle_, hardPendingCompactionBytesLimit); 678 return this; 679 } 680 681 @Override hardPendingCompactionBytesLimit()682 public long hardPendingCompactionBytesLimit() { 683 return hardPendingCompactionBytesLimit(nativeHandle_); 684 } 685 686 @Override setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger)687 public ColumnFamilyOptions setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger) { 688 setLevel0FileNumCompactionTrigger(nativeHandle_, level0FileNumCompactionTrigger); 689 return this; 690 } 691 692 @Override level0FileNumCompactionTrigger()693 public int level0FileNumCompactionTrigger() { 694 return level0FileNumCompactionTrigger(nativeHandle_); 695 } 696 697 @Override setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger)698 public ColumnFamilyOptions setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger) { 699 setLevel0SlowdownWritesTrigger(nativeHandle_, level0SlowdownWritesTrigger); 700 return this; 701 } 702 703 @Override level0SlowdownWritesTrigger()704 public int level0SlowdownWritesTrigger() { 705 return level0SlowdownWritesTrigger(nativeHandle_); 706 } 707 708 @Override setLevel0StopWritesTrigger(int level0StopWritesTrigger)709 public ColumnFamilyOptions setLevel0StopWritesTrigger(int level0StopWritesTrigger) { 710 setLevel0StopWritesTrigger(nativeHandle_, level0StopWritesTrigger); 711 return this; 712 } 713 714 @Override level0StopWritesTrigger()715 public int level0StopWritesTrigger() { 716 return level0StopWritesTrigger(nativeHandle_); 717 } 718 719 @Override setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional)720 public ColumnFamilyOptions setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional) { 721 setMaxBytesForLevelMultiplierAdditional(nativeHandle_, maxBytesForLevelMultiplierAdditional); 722 return this; 723 } 724 725 @Override maxBytesForLevelMultiplierAdditional()726 public int[] maxBytesForLevelMultiplierAdditional() { 727 return maxBytesForLevelMultiplierAdditional(nativeHandle_); 728 } 729 730 @Override setParanoidFileChecks(boolean paranoidFileChecks)731 public ColumnFamilyOptions setParanoidFileChecks(boolean paranoidFileChecks) { 732 setParanoidFileChecks(nativeHandle_, paranoidFileChecks); 733 return this; 734 } 735 736 @Override paranoidFileChecks()737 public boolean paranoidFileChecks() { 738 return paranoidFileChecks(nativeHandle_); 739 } 740 741 @Override setMaxWriteBufferNumberToMaintain( final int maxWriteBufferNumberToMaintain)742 public ColumnFamilyOptions setMaxWriteBufferNumberToMaintain( 743 final int maxWriteBufferNumberToMaintain) { 744 setMaxWriteBufferNumberToMaintain( 745 nativeHandle_, maxWriteBufferNumberToMaintain); 746 return this; 747 } 748 749 @Override maxWriteBufferNumberToMaintain()750 public int maxWriteBufferNumberToMaintain() { 751 return maxWriteBufferNumberToMaintain(nativeHandle_); 752 } 753 754 @Override setCompactionPriority( final CompactionPriority compactionPriority)755 public ColumnFamilyOptions setCompactionPriority( 756 final CompactionPriority compactionPriority) { 757 setCompactionPriority(nativeHandle_, compactionPriority.getValue()); 758 return this; 759 } 760 761 @Override compactionPriority()762 public CompactionPriority compactionPriority() { 763 return CompactionPriority.getCompactionPriority( 764 compactionPriority(nativeHandle_)); 765 } 766 767 @Override setReportBgIoStats(final boolean reportBgIoStats)768 public ColumnFamilyOptions setReportBgIoStats(final boolean reportBgIoStats) { 769 setReportBgIoStats(nativeHandle_, reportBgIoStats); 770 return this; 771 } 772 773 @Override reportBgIoStats()774 public boolean reportBgIoStats() { 775 return reportBgIoStats(nativeHandle_); 776 } 777 778 @Override setTtl(final long ttl)779 public ColumnFamilyOptions setTtl(final long ttl) { 780 setTtl(nativeHandle_, ttl); 781 return this; 782 } 783 784 @Override ttl()785 public long ttl() { 786 return ttl(nativeHandle_); 787 } 788 789 @Override setCompactionOptionsUniversal( final CompactionOptionsUniversal compactionOptionsUniversal)790 public ColumnFamilyOptions setCompactionOptionsUniversal( 791 final CompactionOptionsUniversal compactionOptionsUniversal) { 792 setCompactionOptionsUniversal(nativeHandle_, 793 compactionOptionsUniversal.nativeHandle_); 794 this.compactionOptionsUniversal_ = compactionOptionsUniversal; 795 return this; 796 } 797 798 @Override compactionOptionsUniversal()799 public CompactionOptionsUniversal compactionOptionsUniversal() { 800 return this.compactionOptionsUniversal_; 801 } 802 803 @Override setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO)804 public ColumnFamilyOptions setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO) { 805 setCompactionOptionsFIFO(nativeHandle_, 806 compactionOptionsFIFO.nativeHandle_); 807 this.compactionOptionsFIFO_ = compactionOptionsFIFO; 808 return this; 809 } 810 811 @Override compactionOptionsFIFO()812 public CompactionOptionsFIFO compactionOptionsFIFO() { 813 return this.compactionOptionsFIFO_; 814 } 815 816 @Override setForceConsistencyChecks(final boolean forceConsistencyChecks)817 public ColumnFamilyOptions setForceConsistencyChecks(final boolean forceConsistencyChecks) { 818 setForceConsistencyChecks(nativeHandle_, forceConsistencyChecks); 819 return this; 820 } 821 822 @Override forceConsistencyChecks()823 public boolean forceConsistencyChecks() { 824 return forceConsistencyChecks(nativeHandle_); 825 } 826 getColumnFamilyOptionsFromProps( String optString)827 private static native long getColumnFamilyOptionsFromProps( 828 String optString); 829 newColumnFamilyOptions()830 private static native long newColumnFamilyOptions(); copyColumnFamilyOptions(final long handle)831 private static native long copyColumnFamilyOptions(final long handle); newColumnFamilyOptionsFromOptions( final long optionsHandle)832 private static native long newColumnFamilyOptionsFromOptions( 833 final long optionsHandle); disposeInternal(final long handle)834 @Override protected final native void disposeInternal(final long handle); 835 optimizeForSmallDb(final long handle)836 private native void optimizeForSmallDb(final long handle); optimizeForPointLookup(long handle, long blockCacheSizeMb)837 private native void optimizeForPointLookup(long handle, 838 long blockCacheSizeMb); optimizeLevelStyleCompaction(long handle, long memtableMemoryBudget)839 private native void optimizeLevelStyleCompaction(long handle, 840 long memtableMemoryBudget); optimizeUniversalStyleCompaction(long handle, long memtableMemoryBudget)841 private native void optimizeUniversalStyleCompaction(long handle, 842 long memtableMemoryBudget); setComparatorHandle(long handle, int builtinComparator)843 private native void setComparatorHandle(long handle, int builtinComparator); setComparatorHandle(long optHandle, long comparatorHandle, byte comparatorType)844 private native void setComparatorHandle(long optHandle, 845 long comparatorHandle, byte comparatorType); setMergeOperatorName(long handle, String name)846 private native void setMergeOperatorName(long handle, String name); setMergeOperator(long handle, long mergeOperatorHandle)847 private native void setMergeOperator(long handle, long mergeOperatorHandle); setCompactionFilterHandle(long handle, long compactionFilterHandle)848 private native void setCompactionFilterHandle(long handle, 849 long compactionFilterHandle); setCompactionFilterFactoryHandle(long handle, long compactionFilterFactoryHandle)850 private native void setCompactionFilterFactoryHandle(long handle, 851 long compactionFilterFactoryHandle); setWriteBufferSize(long handle, long writeBufferSize)852 private native void setWriteBufferSize(long handle, long writeBufferSize) 853 throws IllegalArgumentException; writeBufferSize(long handle)854 private native long writeBufferSize(long handle); setMaxWriteBufferNumber( long handle, int maxWriteBufferNumber)855 private native void setMaxWriteBufferNumber( 856 long handle, int maxWriteBufferNumber); maxWriteBufferNumber(long handle)857 private native int maxWriteBufferNumber(long handle); setMinWriteBufferNumberToMerge( long handle, int minWriteBufferNumberToMerge)858 private native void setMinWriteBufferNumberToMerge( 859 long handle, int minWriteBufferNumberToMerge); minWriteBufferNumberToMerge(long handle)860 private native int minWriteBufferNumberToMerge(long handle); setCompressionType(long handle, byte compressionType)861 private native void setCompressionType(long handle, byte compressionType); compressionType(long handle)862 private native byte compressionType(long handle); setCompressionPerLevel(long handle, byte[] compressionLevels)863 private native void setCompressionPerLevel(long handle, 864 byte[] compressionLevels); compressionPerLevel(long handle)865 private native byte[] compressionPerLevel(long handle); setBottommostCompressionType(long handle, byte bottommostCompressionType)866 private native void setBottommostCompressionType(long handle, 867 byte bottommostCompressionType); bottommostCompressionType(long handle)868 private native byte bottommostCompressionType(long handle); setBottommostCompressionOptions(final long handle, final long bottommostCompressionOptionsHandle)869 private native void setBottommostCompressionOptions(final long handle, 870 final long bottommostCompressionOptionsHandle); setCompressionOptions(long handle, long compressionOptionsHandle)871 private native void setCompressionOptions(long handle, 872 long compressionOptionsHandle); useFixedLengthPrefixExtractor( long handle, int prefixLength)873 private native void useFixedLengthPrefixExtractor( 874 long handle, int prefixLength); useCappedPrefixExtractor( long handle, int prefixLength)875 private native void useCappedPrefixExtractor( 876 long handle, int prefixLength); setNumLevels( long handle, int numLevels)877 private native void setNumLevels( 878 long handle, int numLevels); numLevels(long handle)879 private native int numLevels(long handle); setLevelZeroFileNumCompactionTrigger( long handle, int numFiles)880 private native void setLevelZeroFileNumCompactionTrigger( 881 long handle, int numFiles); levelZeroFileNumCompactionTrigger(long handle)882 private native int levelZeroFileNumCompactionTrigger(long handle); setLevelZeroSlowdownWritesTrigger( long handle, int numFiles)883 private native void setLevelZeroSlowdownWritesTrigger( 884 long handle, int numFiles); levelZeroSlowdownWritesTrigger(long handle)885 private native int levelZeroSlowdownWritesTrigger(long handle); setLevelZeroStopWritesTrigger( long handle, int numFiles)886 private native void setLevelZeroStopWritesTrigger( 887 long handle, int numFiles); levelZeroStopWritesTrigger(long handle)888 private native int levelZeroStopWritesTrigger(long handle); setTargetFileSizeBase( long handle, long targetFileSizeBase)889 private native void setTargetFileSizeBase( 890 long handle, long targetFileSizeBase); targetFileSizeBase(long handle)891 private native long targetFileSizeBase(long handle); setTargetFileSizeMultiplier( long handle, int multiplier)892 private native void setTargetFileSizeMultiplier( 893 long handle, int multiplier); targetFileSizeMultiplier(long handle)894 private native int targetFileSizeMultiplier(long handle); setMaxBytesForLevelBase( long handle, long maxBytesForLevelBase)895 private native void setMaxBytesForLevelBase( 896 long handle, long maxBytesForLevelBase); maxBytesForLevelBase(long handle)897 private native long maxBytesForLevelBase(long handle); setLevelCompactionDynamicLevelBytes( long handle, boolean enableLevelCompactionDynamicLevelBytes)898 private native void setLevelCompactionDynamicLevelBytes( 899 long handle, boolean enableLevelCompactionDynamicLevelBytes); levelCompactionDynamicLevelBytes( long handle)900 private native boolean levelCompactionDynamicLevelBytes( 901 long handle); setMaxBytesForLevelMultiplier(long handle, double multiplier)902 private native void setMaxBytesForLevelMultiplier(long handle, double multiplier); maxBytesForLevelMultiplier(long handle)903 private native double maxBytesForLevelMultiplier(long handle); setMaxCompactionBytes(long handle, long maxCompactionBytes)904 private native void setMaxCompactionBytes(long handle, long maxCompactionBytes); maxCompactionBytes(long handle)905 private native long maxCompactionBytes(long handle); setArenaBlockSize( long handle, long arenaBlockSize)906 private native void setArenaBlockSize( 907 long handle, long arenaBlockSize) 908 throws IllegalArgumentException; arenaBlockSize(long handle)909 private native long arenaBlockSize(long handle); setDisableAutoCompactions( long handle, boolean disableAutoCompactions)910 private native void setDisableAutoCompactions( 911 long handle, boolean disableAutoCompactions); disableAutoCompactions(long handle)912 private native boolean disableAutoCompactions(long handle); setCompactionStyle(long handle, byte compactionStyle)913 private native void setCompactionStyle(long handle, byte compactionStyle); compactionStyle(long handle)914 private native byte compactionStyle(long handle); setMaxTableFilesSizeFIFO( long handle, long max_table_files_size)915 private native void setMaxTableFilesSizeFIFO( 916 long handle, long max_table_files_size); maxTableFilesSizeFIFO(long handle)917 private native long maxTableFilesSizeFIFO(long handle); setMaxSequentialSkipInIterations( long handle, long maxSequentialSkipInIterations)918 private native void setMaxSequentialSkipInIterations( 919 long handle, long maxSequentialSkipInIterations); maxSequentialSkipInIterations(long handle)920 private native long maxSequentialSkipInIterations(long handle); setMemTableFactory(long handle, long factoryHandle)921 private native void setMemTableFactory(long handle, long factoryHandle); memTableFactoryName(long handle)922 private native String memTableFactoryName(long handle); setTableFactory(long handle, long factoryHandle)923 private native void setTableFactory(long handle, long factoryHandle); tableFactoryName(long handle)924 private native String tableFactoryName(long handle); setInplaceUpdateSupport( long handle, boolean inplaceUpdateSupport)925 private native void setInplaceUpdateSupport( 926 long handle, boolean inplaceUpdateSupport); inplaceUpdateSupport(long handle)927 private native boolean inplaceUpdateSupport(long handle); setInplaceUpdateNumLocks( long handle, long inplaceUpdateNumLocks)928 private native void setInplaceUpdateNumLocks( 929 long handle, long inplaceUpdateNumLocks) 930 throws IllegalArgumentException; inplaceUpdateNumLocks(long handle)931 private native long inplaceUpdateNumLocks(long handle); setMemtablePrefixBloomSizeRatio( long handle, double memtablePrefixBloomSizeRatio)932 private native void setMemtablePrefixBloomSizeRatio( 933 long handle, double memtablePrefixBloomSizeRatio); memtablePrefixBloomSizeRatio(long handle)934 private native double memtablePrefixBloomSizeRatio(long handle); setBloomLocality( long handle, int bloomLocality)935 private native void setBloomLocality( 936 long handle, int bloomLocality); bloomLocality(long handle)937 private native int bloomLocality(long handle); setMaxSuccessiveMerges( long handle, long maxSuccessiveMerges)938 private native void setMaxSuccessiveMerges( 939 long handle, long maxSuccessiveMerges) 940 throws IllegalArgumentException; maxSuccessiveMerges(long handle)941 private native long maxSuccessiveMerges(long handle); setOptimizeFiltersForHits(long handle, boolean optimizeFiltersForHits)942 private native void setOptimizeFiltersForHits(long handle, 943 boolean optimizeFiltersForHits); optimizeFiltersForHits(long handle)944 private native boolean optimizeFiltersForHits(long handle); setMemtableHugePageSize(long handle, long memtableHugePageSize)945 private native void setMemtableHugePageSize(long handle, 946 long memtableHugePageSize); memtableHugePageSize(long handle)947 private native long memtableHugePageSize(long handle); setSoftPendingCompactionBytesLimit(long handle, long softPendingCompactionBytesLimit)948 private native void setSoftPendingCompactionBytesLimit(long handle, 949 long softPendingCompactionBytesLimit); softPendingCompactionBytesLimit(long handle)950 private native long softPendingCompactionBytesLimit(long handle); setHardPendingCompactionBytesLimit(long handle, long hardPendingCompactionBytesLimit)951 private native void setHardPendingCompactionBytesLimit(long handle, 952 long hardPendingCompactionBytesLimit); hardPendingCompactionBytesLimit(long handle)953 private native long hardPendingCompactionBytesLimit(long handle); setLevel0FileNumCompactionTrigger(long handle, int level0FileNumCompactionTrigger)954 private native void setLevel0FileNumCompactionTrigger(long handle, 955 int level0FileNumCompactionTrigger); level0FileNumCompactionTrigger(long handle)956 private native int level0FileNumCompactionTrigger(long handle); setLevel0SlowdownWritesTrigger(long handle, int level0SlowdownWritesTrigger)957 private native void setLevel0SlowdownWritesTrigger(long handle, 958 int level0SlowdownWritesTrigger); level0SlowdownWritesTrigger(long handle)959 private native int level0SlowdownWritesTrigger(long handle); setLevel0StopWritesTrigger(long handle, int level0StopWritesTrigger)960 private native void setLevel0StopWritesTrigger(long handle, 961 int level0StopWritesTrigger); level0StopWritesTrigger(long handle)962 private native int level0StopWritesTrigger(long handle); setMaxBytesForLevelMultiplierAdditional(long handle, int[] maxBytesForLevelMultiplierAdditional)963 private native void setMaxBytesForLevelMultiplierAdditional(long handle, 964 int[] maxBytesForLevelMultiplierAdditional); maxBytesForLevelMultiplierAdditional(long handle)965 private native int[] maxBytesForLevelMultiplierAdditional(long handle); setParanoidFileChecks(long handle, boolean paranoidFileChecks)966 private native void setParanoidFileChecks(long handle, 967 boolean paranoidFileChecks); paranoidFileChecks(long handle)968 private native boolean paranoidFileChecks(long handle); setMaxWriteBufferNumberToMaintain(final long handle, final int maxWriteBufferNumberToMaintain)969 private native void setMaxWriteBufferNumberToMaintain(final long handle, 970 final int maxWriteBufferNumberToMaintain); maxWriteBufferNumberToMaintain(final long handle)971 private native int maxWriteBufferNumberToMaintain(final long handle); setCompactionPriority(final long handle, final byte compactionPriority)972 private native void setCompactionPriority(final long handle, 973 final byte compactionPriority); compactionPriority(final long handle)974 private native byte compactionPriority(final long handle); setReportBgIoStats(final long handle, final boolean reportBgIoStats)975 private native void setReportBgIoStats(final long handle, 976 final boolean reportBgIoStats); reportBgIoStats(final long handle)977 private native boolean reportBgIoStats(final long handle); setTtl(final long handle, final long ttl)978 private native void setTtl(final long handle, final long ttl); ttl(final long handle)979 private native long ttl(final long handle); setCompactionOptionsUniversal(final long handle, final long compactionOptionsUniversalHandle)980 private native void setCompactionOptionsUniversal(final long handle, 981 final long compactionOptionsUniversalHandle); setCompactionOptionsFIFO(final long handle, final long compactionOptionsFIFOHandle)982 private native void setCompactionOptionsFIFO(final long handle, 983 final long compactionOptionsFIFOHandle); setForceConsistencyChecks(final long handle, final boolean forceConsistencyChecks)984 private native void setForceConsistencyChecks(final long handle, 985 final boolean forceConsistencyChecks); forceConsistencyChecks(final long handle)986 private native boolean forceConsistencyChecks(final long handle); 987 988 // instance variables 989 // NOTE: If you add new member variables, please update the copy constructor above! 990 private MemTableConfig memTableConfig_; 991 private TableFormatConfig tableFormatConfig_; 992 private AbstractComparator comparator_; 993 private AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter_; 994 private AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> 995 compactionFilterFactory_; 996 private CompactionOptionsUniversal compactionOptionsUniversal_; 997 private CompactionOptionsFIFO compactionOptionsFIFO_; 998 private CompressionOptions bottommostCompressionOptions_; 999 private CompressionOptions compressionOptions_; 1000 1001 } 1002