cadonna commented on a change in pull request #10568:
URL: https://github.com/apache/kafka/pull/10568#discussion_r626497390
##########
File path:
streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.java
##########
@@ -1381,6 +1364,313 @@ public WriteBufferManager writeBufferManager() {
return dbOptions.writeBufferManager();
}
+ @Override
+ public Options setMaxWriteBatchGroupSizeBytes(final long
maxWriteBatchGroupSizeBytes) {
+ dbOptions.setMaxWriteBatchGroupSizeBytes(maxWriteBatchGroupSizeBytes);
+ return this;
+ }
+
+ @Override
+ public long maxWriteBatchGroupSizeBytes() {
+ return dbOptions.maxWriteBatchGroupSizeBytes();
+ }
+
+ @Override
+ public Options oldDefaults(final int majorVersion, final int minorVersion)
{
+ columnFamilyOptions.oldDefaults(majorVersion, minorVersion);
+ return this;
+ }
+
+ @Override
+ public Options optimizeForSmallDb(final Cache cache) {
+ return super.optimizeForSmallDb(cache);
+ }
+
+ @Override
+ public AbstractCompactionFilter<? extends AbstractSlice<?>>
compactionFilter() {
+ return columnFamilyOptions.compactionFilter();
+ }
+
+ @Override
+ public AbstractCompactionFilterFactory<? extends
AbstractCompactionFilter<?>> compactionFilterFactory() {
+ return columnFamilyOptions.compactionFilterFactory();
+ }
+
+ @Override
+ public Options setStatsPersistPeriodSec(final int statsPersistPeriodSec) {
+ dbOptions.setStatsPersistPeriodSec(statsPersistPeriodSec);
+ return this;
+ }
+
+ @Override
+ public int statsPersistPeriodSec() {
+ return dbOptions.statsPersistPeriodSec();
+ }
+
+ @Override
+ public Options setStatsHistoryBufferSize(final long
statsHistoryBufferSize) {
+ dbOptions.setStatsHistoryBufferSize(statsHistoryBufferSize);
+ return this;
+ }
+
+ @Override
+ public long statsHistoryBufferSize() {
+ return dbOptions.statsHistoryBufferSize();
+ }
+
+ @Override
+ public Options setStrictBytesPerSync(final boolean strictBytesPerSync) {
+ dbOptions.setStrictBytesPerSync(strictBytesPerSync);
+ return this;
+ }
+
+ @Override
+ public boolean strictBytesPerSync() {
+ return dbOptions.strictBytesPerSync();
+ }
+
+ @Override
+ public Options setListeners(final List<AbstractEventListener> listeners) {
+ dbOptions.setListeners(listeners);
+ return this;
+ }
+
+ @Override
+ public List<AbstractEventListener> listeners() {
+ return dbOptions.listeners();
+ }
+
+ @Override
+ public Options setEnablePipelinedWrite(final boolean enablePipelinedWrite)
{
+ dbOptions.setEnablePipelinedWrite(enablePipelinedWrite);
+ return this;
+ }
+
+ @Override
+ public boolean enablePipelinedWrite() {
+ return dbOptions.enablePipelinedWrite();
+ }
+
+ @Override
+ public Options setUnorderedWrite(final boolean unorderedWrite) {
+ dbOptions.setUnorderedWrite(unorderedWrite);
+ return this;
+ }
+
+ @Override
+ public boolean unorderedWrite() {
+ return dbOptions.unorderedWrite();
+ }
+
+ @Override
+ public Options setSkipCheckingSstFileSizesOnDbOpen(final boolean
skipCheckingSstFileSizesOnDbOpen) {
+
dbOptions.setSkipCheckingSstFileSizesOnDbOpen(skipCheckingSstFileSizesOnDbOpen);
+ return this;
+ }
+
+ @Override
+ public boolean skipCheckingSstFileSizesOnDbOpen() {
+ return dbOptions.skipCheckingSstFileSizesOnDbOpen();
+ }
+
+ @Override
+ public Options setWalFilter(final AbstractWalFilter walFilter) {
+ dbOptions.setWalFilter(walFilter);
+ return this;
+ }
+
+ @Override
+ public WalFilter walFilter() {
+ return dbOptions.walFilter();
+ }
+
+ @Override
+ public Options setAllowIngestBehind(final boolean allowIngestBehind) {
+ dbOptions.setAllowIngestBehind(allowIngestBehind);
+ return this;
+ }
+
+ @Override
+ public boolean allowIngestBehind() {
+ return dbOptions.allowIngestBehind();
+ }
+
+ @Override
+ public Options setPreserveDeletes(final boolean preserveDeletes) {
+ dbOptions.setPreserveDeletes(preserveDeletes);
+ return this;
+ }
+
+ @Override
+ public boolean preserveDeletes() {
+ return dbOptions.preserveDeletes();
+ }
+
+ @Override
+ public Options setTwoWriteQueues(final boolean twoWriteQueues) {
+ dbOptions.setTwoWriteQueues(twoWriteQueues);
+ return this;
+ }
+
+ @Override
+ public boolean twoWriteQueues() {
+ return dbOptions.twoWriteQueues();
+ }
+
+ @Override
+ public Options setManualWalFlush(final boolean manualWalFlush) {
+ dbOptions.setManualWalFlush(manualWalFlush);
+ return this;
+ }
+
+ @Override
+ public boolean manualWalFlush() {
+ return dbOptions.manualWalFlush();
+ }
+
+ @Override
+ public Options setCfPaths(final Collection<DbPath> cfPaths) {
+ columnFamilyOptions.setCfPaths(cfPaths);
+ return this;
+ }
+
+ @Override
+ public List<DbPath> cfPaths() {
+ return columnFamilyOptions.cfPaths();
+ }
+
+ @Override
+ public Options setBottommostCompressionOptions(final CompressionOptions
bottommostCompressionOptions) {
+
columnFamilyOptions.setBottommostCompressionOptions(bottommostCompressionOptions);
+ return this;
+ }
+
+ @Override
+ public CompressionOptions bottommostCompressionOptions() {
+ return columnFamilyOptions.bottommostCompressionOptions();
+ }
+
+ @Override
+ public Options setTtl(final long ttl) {
+ columnFamilyOptions.setTtl(ttl);
+ return this;
+ }
+
+ @Override
+ public long ttl() {
+ return columnFamilyOptions.ttl();
+ }
+
+ @Override
+ public Options setAtomicFlush(final boolean atomicFlush) {
+ dbOptions.setAtomicFlush(atomicFlush);
+ return this;
+ }
+
+ @Override
+ public boolean atomicFlush() {
+ return dbOptions.atomicFlush();
+ }
+
+ @Override
+ public Options setAvoidUnnecessaryBlockingIO(final boolean
avoidUnnecessaryBlockingIO) {
+ dbOptions.setAvoidUnnecessaryBlockingIO(avoidUnnecessaryBlockingIO);
+ return this;
+ }
+
+ @Override
+ public boolean avoidUnnecessaryBlockingIO() {
+ return dbOptions.avoidUnnecessaryBlockingIO();
+ }
+
+ @Override
+ public Options setPersistStatsToDisk(final boolean persistStatsToDisk) {
+ dbOptions.setPersistStatsToDisk(persistStatsToDisk);
+ return this;
+ }
+
+ @Override
+ public boolean persistStatsToDisk() {
+ return dbOptions.persistStatsToDisk();
+ }
+
+ @Override
+ public Options setWriteDbidToManifest(final boolean writeDbidToManifest) {
+ dbOptions.setWriteDbidToManifest(writeDbidToManifest);
+ return this;
+ }
+
+ @Override
+ public boolean writeDbidToManifest() {
+ return dbOptions.writeDbidToManifest();
+ }
+
+ @Override
+ public Options setLogReadaheadSize(final long logReadaheadSize) {
+ dbOptions.setLogReadaheadSize(logReadaheadSize);
+ return this;
+ }
+
+ @Override
+ public long logReadaheadSize() {
+ return dbOptions.logReadaheadSize();
+ }
+
+ @Override
+ public Options setBestEffortsRecovery(final boolean bestEffortsRecovery) {
+ dbOptions.setBestEffortsRecovery(bestEffortsRecovery);
+ return this;
+ }
+
+ @Override
+ public boolean bestEffortsRecovery() {
+ return dbOptions.bestEffortsRecovery();
+ }
+
+ @Override
+ public Options setMaxBgErrorResumeCount(final int maxBgerrorResumeCount) {
+ dbOptions.setMaxBgErrorResumeCount(maxBgerrorResumeCount);
+ return this;
+ }
+
+ @Override
+ public int maxBgerrorResumeCount() {
+ return dbOptions.maxBgerrorResumeCount();
+ }
+
+ @Override
+ public Options setBgerrorResumeRetryInterval(final long
bgerrorResumeRetryInterval) {
+ dbOptions.setBgerrorResumeRetryInterval(bgerrorResumeRetryInterval);
+ return this;
+ }
+
+ @Override
+ public long bgerrorResumeRetryInterval() {
+ return dbOptions.bgerrorResumeRetryInterval();
+ }
+
+ @Override
+ public Options setSstPartitionerFactory(final SstPartitionerFactory
sstPartitionerFactory) {
+ columnFamilyOptions.setSstPartitionerFactory(sstPartitionerFactory);
+ return this;
+ }
+
+ @Override
+ public SstPartitionerFactory sstPartitionerFactory() {
+ return columnFamilyOptions.sstPartitionerFactory();
+ }
+
+ @Override
+ public Options setCompactionThreadLimiter(final ConcurrentTaskLimiter
compactionThreadLimiter) {
Review comment:
I am not sure either, but the following comment suggests that it limits
the number of outstanding compactions. So I guess it is about the queue of
compactions that are planned and not the number of compactions that are
currently performed. But I might be wrong. If I am correct, then the name is a
bit misleading.
```
// Compaction concurrent thread limiter for the column family.
// If non-nullptr, use given concurrent thread limiter to control
// the max outstanding compaction tasks. Limiter can be shared with
// multiple column families across db instances.
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
