#9867

Committed 18 Aug 2023 06:05AM UTC coverage: 48.003% (-0.08%) from 48.081%

Build # #9867

Build Type

push

travis_ci

Committed by

web-flow

Commit Message

[To rel/1.2] [IOTDB-6115] Fix Limit & Offset push down doesn't take effect while there exist null value

Run Details

103 of 103 new or added lines in 23 files covered. (100.0%)

79802 of 166243 relevant lines covered (48.0%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.22

/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/pipe/config/PipeConfig.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.iotdb.commons.pipe.config;

import org.apache.iotdb.commons.conf.CommonConfig;
import org.apache.iotdb.commons.conf.CommonDescriptor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PipeConfig {

  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();

  /////////////////////////////// File ///////////////////////////////

  public String getPipeHardlinkBaseDirName() {
    return COMMON_CONFIG.getPipeHardlinkBaseDirName();
  }

  public String getPipeHardlinkTsFileDirName() {
    return COMMON_CONFIG.getPipeHardlinkTsFileDirName();
  }

  public String getPipeHardlinkWALDirName() {
    return COMMON_CONFIG.getPipeHardlinkWALDirName();
  }

  public boolean getPipeHardLinkWALEnabled() {
    return COMMON_CONFIG.getPipeHardLinkWALEnabled();
  }

  /////////////////////////////// Tablet ///////////////////////////////

  public int getPipeDataStructureTabletRowSize() {
    return COMMON_CONFIG.getPipeDataStructureTabletRowSize();
  }

  /////////////////////////////// Subtask Executor ///////////////////////////////

  public int getPipeSubtaskExecutorMaxThreadNum() {
    return COMMON_CONFIG.getPipeSubtaskExecutorMaxThreadNum();
  }

  public int getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount() {
    return COMMON_CONFIG.getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount();
  }

  public long getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration() {
    return COMMON_CONFIG.getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration();
  }

  public long getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs() {
    return COMMON_CONFIG.getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs();
  }

  /////////////////////////////// Extractor ///////////////////////////////

  public int getPipeExtractorAssignerDisruptorRingBufferSize() {
    return COMMON_CONFIG.getPipeExtractorAssignerDisruptorRingBufferSize();
  }

  public int getPipeExtractorMatcherCacheSize() {
    return COMMON_CONFIG.getPipeExtractorMatcherCacheSize();
  }

  public int getPipeExtractorPendingQueueCapacity() {
    return COMMON_CONFIG.getPipeExtractorPendingQueueCapacity();
  }

  public int getPipeExtractorPendingQueueTabletLimit() {
    return COMMON_CONFIG.getPipeExtractorPendingQueueTabletLimit();
  }

  /////////////////////////////// Connector ///////////////////////////////

  public long getPipeConnectorTimeoutMs() {
    return COMMON_CONFIG.getPipeConnectorTimeoutMs();
  }

  public int getPipeConnectorReadFileBufferSize() {
    return COMMON_CONFIG.getPipeConnectorReadFileBufferSize();
  }

  public long getPipeConnectorRetryIntervalMs() {
    return COMMON_CONFIG.getPipeConnectorRetryIntervalMs();
  }

  public int getPipeConnectorPendingQueueSize() {
    return COMMON_CONFIG.getPipeConnectorPendingQueueSize();
  }

  public boolean isPipeConnectorRPCThriftCompressionEnabled() {
    return COMMON_CONFIG.isPipeConnectorRPCThriftCompressionEnabled();
  }

  public int getPipeAsyncConnectorSelectorNumber() {
    return COMMON_CONFIG.getPipeAsyncConnectorSelectorNumber();
  }

  public int getPipeAsyncConnectorCoreClientNumber() {
    return COMMON_CONFIG.getPipeAsyncConnectorCoreClientNumber();
  }

  public int getPipeAsyncConnectorMaxClientNumber() {
    return COMMON_CONFIG.getPipeAsyncConnectorMaxClientNumber();
  }

  /////////////////////////////// Meta Consistency ///////////////////////////////

  public boolean isSeperatedPipeHeartbeatEnabled() {
    return COMMON_CONFIG.isSeperatedPipeHeartbeatEnabled();
  }

  public int getPipeHeartbeatIntervalSecondsForCollectingPipeMeta() {
    return COMMON_CONFIG.getPipeHeartbeatIntervalSecondsForCollectingPipeMeta();
  }

  public long getPipeMetaSyncerInitialSyncDelayMinutes() {
    return COMMON_CONFIG.getPipeMetaSyncerInitialSyncDelayMinutes();
  }

  public long getPipeMetaSyncerSyncIntervalMinutes() {
    return COMMON_CONFIG.getPipeMetaSyncerSyncIntervalMinutes();
  }

  public long getPipeMetaSyncerAutoRestartPipeCheckIntervalRound() {
    return COMMON_CONFIG.getPipeMetaSyncerAutoRestartPipeCheckIntervalRound();
  }

  public boolean getPipeAutoRestartEnabled() {
    return COMMON_CONFIG.getPipeAutoRestartEnabled();
  }

  /////////////////////////////// Air Gap Receiver ///////////////////////////////

  public boolean getPipeAirGapReceiverEnabled() {
    return COMMON_CONFIG.getPipeAirGapReceiverEnabled();
  }

  public int getPipeAirGapReceiverPort() {
    return COMMON_CONFIG.getPipeAirGapReceiverPort();
  }

  /////////////////////////////// Utils ///////////////////////////////

  private static final Logger LOGGER = LoggerFactory.getLogger(PipeConfig.class);

  public void printAllConfigs() {
    LOGGER.info("PipeHardlinkBaseDirName: {}", getPipeHardlinkBaseDirName());
    LOGGER.info("PipeHardlinkTsFileDirName: {}", getPipeHardlinkTsFileDirName());
    LOGGER.info("PipeHardlinkWALDirName: {}", getPipeHardlinkWALDirName());
    LOGGER.info("PipeHardLinkWALEnabled: {}", getPipeHardLinkWALEnabled());

    LOGGER.info("PipeDataStructureTabletRowSize: {}", getPipeDataStructureTabletRowSize());

    LOGGER.info("PipeSubtaskExecutorMaxThreadNum: {}", getPipeSubtaskExecutorMaxThreadNum());
    LOGGER.info(
        "PipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount: {}",
        getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount());
    LOGGER.info(
        "PipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration: {}",
        getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration());
    LOGGER.info(
        "PipeSubtaskExecutorPendingQueueMaxBlockingTimeMs: {}",
        getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs());

    LOGGER.info(
        "PipeExtractorAssignerDisruptorRingBufferSize: {}",
        getPipeExtractorAssignerDisruptorRingBufferSize());
    LOGGER.info("PipeExtractorMatcherCacheSize: {}", getPipeExtractorMatcherCacheSize());
    LOGGER.info("PipeExtractorPendingQueueCapacity: {}", getPipeExtractorPendingQueueCapacity());
    LOGGER.info(
        "PipeExtractorPendingQueueTabletLimit: {}", getPipeExtractorPendingQueueTabletLimit());

    LOGGER.info("PipeConnectorTimeoutMs: {}", getPipeConnectorTimeoutMs());
    LOGGER.info("PipeConnectorReadFileBufferSize: {}", getPipeConnectorReadFileBufferSize());
    LOGGER.info("PipeConnectorRetryIntervalMs: {}", getPipeConnectorRetryIntervalMs());
    LOGGER.info("PipeConnectorPendingQueueSize: {}", getPipeConnectorPendingQueueSize());
    LOGGER.info(
        "PipeConnectorRPCThriftCompressionEnabled: {}",
        isPipeConnectorRPCThriftCompressionEnabled());

    LOGGER.info("PipeAsyncConnectorSelectorNumber: {}", getPipeAsyncConnectorSelectorNumber());
    LOGGER.info("PipeAsyncConnectorCoreClientNumber: {}", getPipeAsyncConnectorCoreClientNumber());
    LOGGER.info("PipeAsyncConnectorMaxClientNumber: {}", getPipeAsyncConnectorMaxClientNumber());

    LOGGER.info("SeperatedPipeHeartbeatEnabled: {}", isSeperatedPipeHeartbeatEnabled());
    LOGGER.info(
        "PipeHeartbeatIntervalSecondsForCollectingPipeMeta: {}",
        getPipeHeartbeatIntervalSecondsForCollectingPipeMeta());
    LOGGER.info(
        "PipeMetaSyncerInitialSyncDelayMinutes: {}", getPipeMetaSyncerInitialSyncDelayMinutes());
    LOGGER.info("PipeMetaSyncerSyncIntervalMinutes: {}", getPipeMetaSyncerSyncIntervalMinutes());
    LOGGER.info(
        "PipeMetaSyncerAutoRestartPipeCheckIntervalRound: {}",
        getPipeMetaSyncerAutoRestartPipeCheckIntervalRound());
    LOGGER.info("PipeAutoRestartEnabled: {}", getPipeAutoRestartEnabled());

    LOGGER.info("PipeAirGapReceiverEnabled: {}", getPipeAirGapReceiverEnabled());
    LOGGER.info("PipeAirGapReceiverPort: {}", getPipeAirGapReceiverPort());
  }

  /////////////////////////////// Singleton ///////////////////////////////

  private PipeConfig() {}

  public static PipeConfig getInstance() {
    return PipeConfigHolder.INSTANCE;
  }

  private static class PipeConfigHolder {
    private static final PipeConfig INSTANCE = new PipeConfig();
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19
20	package org.apache.iotdb.commons.pipe.config;
21
22	import org.apache.iotdb.commons.conf.CommonConfig;
23	import org.apache.iotdb.commons.conf.CommonDescriptor;
24
25	import org.slf4j.Logger;
26	import org.slf4j.LoggerFactory;
27
28	public class PipeConfig {
29
30	private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();	1✔
31
32	/////////////////////////////// File ///////////////////////////////
33
34	public String getPipeHardlinkBaseDirName() {
35	return COMMON_CONFIG.getPipeHardlinkBaseDirName();	1✔
36	}
37
38	public String getPipeHardlinkTsFileDirName() {
39	return COMMON_CONFIG.getPipeHardlinkTsFileDirName();	1✔
40	}
41
42	public String getPipeHardlinkWALDirName() {
43	return COMMON_CONFIG.getPipeHardlinkWALDirName();	1✔
44	}
45
46	public boolean getPipeHardLinkWALEnabled() {
47	return COMMON_CONFIG.getPipeHardLinkWALEnabled();	1✔
48	}
49
50	/////////////////////////////// Tablet ///////////////////////////////
51
52	public int getPipeDataStructureTabletRowSize() {
53	return COMMON_CONFIG.getPipeDataStructureTabletRowSize();	1✔
54	}
55
56	/////////////////////////////// Subtask Executor ///////////////////////////////
57
58	public int getPipeSubtaskExecutorMaxThreadNum() {
59	return COMMON_CONFIG.getPipeSubtaskExecutorMaxThreadNum();	1✔
60	}
61
62	public int getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount() {
63	return COMMON_CONFIG.getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount();	1✔
64	}
65
66	public long getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration() {
67	return COMMON_CONFIG.getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration();	1✔
68	}
69
70	public long getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs() {
71	return COMMON_CONFIG.getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs();	1✔
72	}
73
74	/////////////////////////////// Extractor ///////////////////////////////
75
76	public int getPipeExtractorAssignerDisruptorRingBufferSize() {
77	return COMMON_CONFIG.getPipeExtractorAssignerDisruptorRingBufferSize();	1✔
78	}
79
80	public int getPipeExtractorMatcherCacheSize() {
81	return COMMON_CONFIG.getPipeExtractorMatcherCacheSize();	1✔
82	}
83
84	public int getPipeExtractorPendingQueueCapacity() {
85	return COMMON_CONFIG.getPipeExtractorPendingQueueCapacity();	×
86	}
87
88	public int getPipeExtractorPendingQueueTabletLimit() {
89	return COMMON_CONFIG.getPipeExtractorPendingQueueTabletLimit();	1✔
90	}
91
92	/////////////////////////////// Connector ///////////////////////////////
93
94	public long getPipeConnectorTimeoutMs() {
95	return COMMON_CONFIG.getPipeConnectorTimeoutMs();	×
96	}
97
98	public int getPipeConnectorReadFileBufferSize() {
99	return COMMON_CONFIG.getPipeConnectorReadFileBufferSize();	×
100	}
101
102	public long getPipeConnectorRetryIntervalMs() {
103	return COMMON_CONFIG.getPipeConnectorRetryIntervalMs();	×
104	}
105
106	public int getPipeConnectorPendingQueueSize() {
107	return COMMON_CONFIG.getPipeConnectorPendingQueueSize();	×
108	}
109
110	public boolean isPipeConnectorRPCThriftCompressionEnabled() {
111	return COMMON_CONFIG.isPipeConnectorRPCThriftCompressionEnabled();	×
112	}
113
114	public int getPipeAsyncConnectorSelectorNumber() {
115	return COMMON_CONFIG.getPipeAsyncConnectorSelectorNumber();	×
116	}
117
118	public int getPipeAsyncConnectorCoreClientNumber() {
119	return COMMON_CONFIG.getPipeAsyncConnectorCoreClientNumber();	×
120	}
121
122	public int getPipeAsyncConnectorMaxClientNumber() {
123	return COMMON_CONFIG.getPipeAsyncConnectorMaxClientNumber();	×
124	}
125
126	/////////////////////////////// Meta Consistency ///////////////////////////////
127
128	public boolean isSeperatedPipeHeartbeatEnabled() {
129	return COMMON_CONFIG.isSeperatedPipeHeartbeatEnabled();	×
130	}
131
132	public int getPipeHeartbeatIntervalSecondsForCollectingPipeMeta() {
133	return COMMON_CONFIG.getPipeHeartbeatIntervalSecondsForCollectingPipeMeta();	×
134	}
135
136	public long getPipeMetaSyncerInitialSyncDelayMinutes() {
137	return COMMON_CONFIG.getPipeMetaSyncerInitialSyncDelayMinutes();	×
138	}
139
140	public long getPipeMetaSyncerSyncIntervalMinutes() {
141	return COMMON_CONFIG.getPipeMetaSyncerSyncIntervalMinutes();	×
142	}
143
144	public long getPipeMetaSyncerAutoRestartPipeCheckIntervalRound() {
145	return COMMON_CONFIG.getPipeMetaSyncerAutoRestartPipeCheckIntervalRound();	×
146	}
147
148	public boolean getPipeAutoRestartEnabled() {
149	return COMMON_CONFIG.getPipeAutoRestartEnabled();	×
150	}
151
152	/////////////////////////////// Air Gap Receiver ///////////////////////////////
153
154	public boolean getPipeAirGapReceiverEnabled() {
155	return COMMON_CONFIG.getPipeAirGapReceiverEnabled();	×
156	}
157
158	public int getPipeAirGapReceiverPort() {
159	return COMMON_CONFIG.getPipeAirGapReceiverPort();	×
160	}
161
162	/////////////////////////////// Utils ///////////////////////////////
163
164	private static final Logger LOGGER = LoggerFactory.getLogger(PipeConfig.class);	1✔
165
166	public void printAllConfigs() {
167	LOGGER.info("PipeHardlinkBaseDirName: {}", getPipeHardlinkBaseDirName());	×
168	LOGGER.info("PipeHardlinkTsFileDirName: {}", getPipeHardlinkTsFileDirName());	×
169	LOGGER.info("PipeHardlinkWALDirName: {}", getPipeHardlinkWALDirName());	×
170	LOGGER.info("PipeHardLinkWALEnabled: {}", getPipeHardLinkWALEnabled());	×
171
172	LOGGER.info("PipeDataStructureTabletRowSize: {}", getPipeDataStructureTabletRowSize());	×
173
174	LOGGER.info("PipeSubtaskExecutorMaxThreadNum: {}", getPipeSubtaskExecutorMaxThreadNum());	×
175	LOGGER.info(	×
176	"PipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount: {}",
177	getPipeSubtaskExecutorBasicCheckPointIntervalByConsumedEventCount());	×
178	LOGGER.info(	×
179	"PipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration: {}",
180	getPipeSubtaskExecutorBasicCheckPointIntervalByTimeDuration());	×
181	LOGGER.info(	×
182	"PipeSubtaskExecutorPendingQueueMaxBlockingTimeMs: {}",
183	getPipeSubtaskExecutorPendingQueueMaxBlockingTimeMs());	×
184
185	LOGGER.info(	×
186	"PipeExtractorAssignerDisruptorRingBufferSize: {}",
187	getPipeExtractorAssignerDisruptorRingBufferSize());	×
188	LOGGER.info("PipeExtractorMatcherCacheSize: {}", getPipeExtractorMatcherCacheSize());	×
189	LOGGER.info("PipeExtractorPendingQueueCapacity: {}", getPipeExtractorPendingQueueCapacity());	×
190	LOGGER.info(	×
191	"PipeExtractorPendingQueueTabletLimit: {}", getPipeExtractorPendingQueueTabletLimit());	×
192
193	LOGGER.info("PipeConnectorTimeoutMs: {}", getPipeConnectorTimeoutMs());	×
194	LOGGER.info("PipeConnectorReadFileBufferSize: {}", getPipeConnectorReadFileBufferSize());	×
195	LOGGER.info("PipeConnectorRetryIntervalMs: {}", getPipeConnectorRetryIntervalMs());	×
196	LOGGER.info("PipeConnectorPendingQueueSize: {}", getPipeConnectorPendingQueueSize());	×
197	LOGGER.info(	×
198	"PipeConnectorRPCThriftCompressionEnabled: {}",
199	isPipeConnectorRPCThriftCompressionEnabled());	×
200
201	LOGGER.info("PipeAsyncConnectorSelectorNumber: {}", getPipeAsyncConnectorSelectorNumber());	×
202	LOGGER.info("PipeAsyncConnectorCoreClientNumber: {}", getPipeAsyncConnectorCoreClientNumber());	×
203	LOGGER.info("PipeAsyncConnectorMaxClientNumber: {}", getPipeAsyncConnectorMaxClientNumber());	×
204
205	LOGGER.info("SeperatedPipeHeartbeatEnabled: {}", isSeperatedPipeHeartbeatEnabled());	×
206	LOGGER.info(	×
207	"PipeHeartbeatIntervalSecondsForCollectingPipeMeta: {}",
208	getPipeHeartbeatIntervalSecondsForCollectingPipeMeta());	×
209	LOGGER.info(	×
210	"PipeMetaSyncerInitialSyncDelayMinutes: {}", getPipeMetaSyncerInitialSyncDelayMinutes());	×
211	LOGGER.info("PipeMetaSyncerSyncIntervalMinutes: {}", getPipeMetaSyncerSyncIntervalMinutes());	×
212	LOGGER.info(	×
213	"PipeMetaSyncerAutoRestartPipeCheckIntervalRound: {}",
214	getPipeMetaSyncerAutoRestartPipeCheckIntervalRound());	×
215	LOGGER.info("PipeAutoRestartEnabled: {}", getPipeAutoRestartEnabled());	×
216
217	LOGGER.info("PipeAirGapReceiverEnabled: {}", getPipeAirGapReceiverEnabled());	×
218	LOGGER.info("PipeAirGapReceiverPort: {}", getPipeAirGapReceiverPort());	×
219	}	×
220
221	/////////////////////////////// Singleton ///////////////////////////////
222
223	private PipeConfig() {}
224
225	public static PipeConfig getInstance() {
226	return PipeConfigHolder.INSTANCE;	1✔
227	}
228
229	private static class PipeConfigHolder {
230	private static final PipeConfig INSTANCE = new PipeConfig();	1✔
231	}
232	}

apache / iotdb / #9867

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous