Skip to content

Commit 0b96f2e

Browse files
morningmanclaude
andcommitted
[perf](catalog) fe-connector-iceberg: memoize the file-format inference across queries (PERF-03)
Root cause: every SELECT/EXPLAIN of an iceberg table resolves the scan-level file_format_type through IcebergScanPlanProvider.getScanNodeProperties -> IcebergWriterHelper.getFileFormat. When the table carries neither the 'write-format' nickname nor 'write.format.default' (migrated tables, and any table whose writer never set the property -- parquet is an implicit default, not stored), resolution falls back to inferFileFormatFromDataFiles, an unfiltered table.newScan().planFiles() -- a whole-table manifest scan (remote FileIO; iceberg's ParallelIterable eagerly fans manifest readers) just to read the first data file's format. That apache#64134 fallback ran on every query with zero cross-query reuse: hundreds of ms to seconds of remote IO per query on large tables, multiplied by QPS. Fix (connector-side, no fe-core change): add IcebergFormatCache keyed by (TableIdentifier, currentSnapshotId), value = the inferred format-name string, owned by the long-lived IcebergConnector. A snapshot is immutable, so its first data file's format is a pure function of the key; the snapshot id is held stable across queries by IcebergLatestSnapshotCache. Only the inference fallback is cached -- the two cheap property probes stay uncached. No credential gate (like the PERF-02 partition cache): the value is bare metadata with no FileIO/token, so it is shared across users and built for every catalog (incl. session=user / REST vended). REFRESH TABLE/DB/CATALOG invalidate it. Route note: deriving the format from planScan's own file enumeration was rejected -- FileQueryScanNode.createScanRangeLocations computes file_format_type (getFileFormatType, line 325) BEFORE getSplits/planScan (line 422), and the inference is unfiltered while planScan is predicate-filtered, so a query that prunes all files would break the legacy "unfiltered fallback always finds a first file" parity. Memoization keeps strict parity. Parity: same currentSnapshot-derived inference as legacy IcebergUtils.getFileFormat (never the handle's time-travel pin); the orc/parquet mapping (and its throw on an unsupported format) stays OUTSIDE the cache, so an unsupported first file is inferred once yet re-throws every call as before. A failed inference is NOT cached (the loader propagates unchecked; the CloseableIterable.close IOException is wrapped UncheckedIOException), so a transient remote-IO failure retries on the next query. The scan-level value still only selects BE's V1/V2 scanner; per-file format still travels per range. Write-path getFileFormat callers are unchanged (left for PERF-07). Measurement gate: IcebergWriterHelperTest asserts the whole-table inference runs exactly once across repeated queries at one snapshot (loadCountForTest == 1) and matches a live resolution; property-path tables never populate the cache. IcebergFormatCacheTest covers TTL stability, the ttl<=0 disable, invalidation, and not-caching-on-failure. IcebergConnectorCacheTest asserts the no-gate build across plain/vended/session catalogs and REFRESH invalidation. Full iceberg module UT: 957 run / 0 fail / 0 error / 1 skip; checkstyle green. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]> Claude-Session: https://claude.ai/code/session_01SMtYwYyyubZZiC1odLZTG3
1 parent cab6e1e commit 0b96f2e

7 files changed

Lines changed: 573 additions & 8 deletions

File tree

‎fe/fe-connector/fe-connector-iceberg/src/main/java/org/apache/doris/connector/iceberg/IcebergConnector.java‎

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -168,6 +168,10 @@ public class IcebergConnector implements Connector {
168168
// Built unconditionally — the cached value is pure metadata with no FileIO/credential, so no credential gate
169169
// (unlike tableCache); only the TTL knob disables it.
170170
private final IcebergPartitionCache partitionCache;
171+
// PERF-03: cross-query inferred-file-format cache (the whole-table planFiles() fallback result, keyed by
172+
// (table, snapshotId)). Like partitionCache, the value is pure metadata (a format-name string) with no
173+
// FileIO/credential, so no gate; only the TTL knob disables it.
174+
private final IcebergFormatCache formatCache;
171175
private final IcebergManifestCache manifestCache = new IcebergManifestCache();
172176
// commit-bridge supply (S4 part 2): per-catalog stash carrying a row-level DML's non-equality delete supply
173177
// across the scan->write seam — the scan provider fills it (keyed by queryId), the write provider drains it
@@ -212,6 +216,9 @@ public IcebergConnector(Map<String, String> properties, ConnectorContext context
212216
// PERF-02: partition-view cache. Pure metadata (no credentials) -> no gate; same TTL/capacity as above.
213217
this.partitionCache = new IcebergPartitionCache(
214218
resolveTableCacheTtlSecond(this.properties), DEFAULT_TABLE_CACHE_CAPACITY);
219+
// PERF-03: inferred-file-format cache. Pure metadata (no credentials) -> no gate; same TTL/capacity.
220+
this.formatCache = new IcebergFormatCache(
221+
resolveTableCacheTtlSecond(this.properties), DEFAULT_TABLE_CACHE_CAPACITY);
215222
}
216223

217224
/**
@@ -551,6 +558,7 @@ public void invalidateTable(String dbName, String tableName) {
551558
tableCache.invalidate(TableIdentifier.of(dbName, tableName));
552559
}
553560
partitionCache.invalidate(TableIdentifier.of(dbName, tableName));
561+
formatCache.invalidate(TableIdentifier.of(dbName, tableName));
554562
}
555563

556564
/**
@@ -571,6 +579,7 @@ public void invalidateDb(String dbName) {
571579
tableCache.invalidateDb(dbName);
572580
}
573581
partitionCache.invalidateDb(dbName);
582+
formatCache.invalidateDb(dbName);
574583
}
575584

576585
/**
@@ -587,6 +596,7 @@ public void invalidateAll() {
587596
tableCache.invalidateAll();
588597
}
589598
partitionCache.invalidateAll();
599+
formatCache.invalidateAll();
590600
manifestCache.invalidateAll();
591601
}
592602

@@ -626,6 +636,11 @@ IcebergPartitionCache partitionCacheForTest() {
626636
return partitionCache;
627637
}
628638

639+
/** Test-only: the cross-query inferred-file-format cache (PERF-03; always built, no credential gate). */
640+
IcebergFormatCache formatCacheForTest() {
641+
return formatCache;
642+
}
643+
629644
@Override
630645
public ConnectorScanPlanProvider getScanPlanProvider() {
631646
// Mirrors PaimonConnector.getScanPlanProvider: build a fresh provider per call over the lazily-built
@@ -635,7 +650,7 @@ public ConnectorScanPlanProvider getScanPlanProvider() {
635650
// threaded for parity with the legacy single per-catalog IcebergMetadataOps.
636651
return new IcebergScanPlanProvider(properties,
637652
this::newCatalogBackedOps, context, manifestCache,
638-
rewritableDeleteStash, tableCache);
653+
rewritableDeleteStash, tableCache, formatCache);
639654
}
640655

641656
@Override
Lines changed: 145 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,145 @@
1+
// Licensed to the Apache Software Foundation (ASF) under one
2+
// or more contributor license agreements. See the NOTICE file
3+
// distributed with this work for additional information
4+
// regarding copyright ownership. The ASF licenses this file
5+
// to you under the Apache License, Version 2.0 (the
6+
// "License"); you may not use this file except in compliance
7+
// with the License. You may obtain a copy of the License at
8+
//
9+
// http://www.apache.org/licenses/LICENSE-2.0
10+
//
11+
// Unless required by applicable law or agreed to in writing,
12+
// software distributed under the License is distributed on an
13+
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14+
// KIND, either express or implied. See the License for the
15+
// specific language governing permissions and limitations
16+
// under the License.
17+
18+
package org.apache.doris.connector.iceberg;
19+
20+
import org.apache.doris.connector.cache.CacheSpec;
21+
import org.apache.doris.connector.cache.MetaCacheEntry;
22+
23+
import org.apache.iceberg.catalog.Namespace;
24+
import org.apache.iceberg.catalog.TableIdentifier;
25+
26+
import java.util.Objects;
27+
import java.util.concurrent.ForkJoinPool;
28+
import java.util.function.Supplier;
29+
30+
/**
31+
* Per-catalog cache of an iceberg table's inferred write file-format name (PERF-03), keyed by
32+
* {@code (TableIdentifier, snapshotId)}. Kills the per-query revival of the #64134 heavy fallback: when a table
33+
* carries neither the {@code write-format} nickname nor {@code write.format.default} (migrated tables, and any
34+
* table whose writer never set the property — parquet is an implicit default, not stored),
35+
* {@link IcebergScanPlanProvider#getScanNodeProperties} resolves the scan-level {@code file_format_type} through
36+
* {@link IcebergWriterHelper#getFileFormat}, which falls back to an unfiltered {@code table.newScan().planFiles()}
37+
* — a whole-table manifest scan (remote FileIO) — just to read the FIRST data file's format. That fallback was
38+
* re-run on every query/EXPLAIN with no cross-query reuse; this cache collapses it to one scan per
39+
* {@code (table, snapshot)}.
40+
*
41+
* <p><b>Snapshot-keyed, so always correct.</b> A snapshot is immutable, so its first data file's format is a
42+
* pure function of the key; a new commit yields a new snapshot id (a new key -&gt; a live scan). Within the TTL
43+
* the snapshot id itself is held stable by {@link IcebergLatestSnapshotCache}, which is what makes the key stable
44+
* across queries. The key snapshot is the table's {@code currentSnapshot().snapshotId()} — exactly what the
45+
* inference reads (it scans {@code table.newScan()}, never the handle's time-travel pin), matching legacy
46+
* {@code IcebergUtils.getFileFormat} and PERF-02's partition cache verbatim.
47+
*
48+
* <p><b>Only the inference fallback is cached.</b> The two cheap property probes ({@code write-format},
49+
* {@code write.format.default}) stay outside this cache — the caller consults it only when both miss.
50+
*
51+
* <p><b>No credential gate</b> (unlike {@link IcebergTableCache}, like {@link IcebergPartitionCache}): the cached
52+
* value is a bare format-name {@link String} with no {@code FileIO} / credential, so it is safe to share across
53+
* users and is built unconditionally (only the TTL knob disables it).
54+
*
55+
* <p>Backed identically to {@link IcebergPartitionCache}: a contextual, access-TTL {@link MetaCacheEntry} with
56+
* manual miss-load, so the inference runs OUTSIDE Caffeine's compute lock and a failed scan's exception
57+
* propagates verbatim and is NOT cached (the next query retries — legacy parity). TTL is
58+
* {@code meta.cache.iceberg.table.ttl-second}; {@code <= 0} disables (read live). Lives on the long-lived
59+
* per-catalog {@link IcebergConnector}; a REFRESH CATALOG rebuilds the connector and thus the cache.
60+
*/
61+
final class IcebergFormatCache {
62+
63+
/** Immutable composite key: a table's inferred format is distinct per pinned snapshot id. */
64+
static final class Key {
65+
final TableIdentifier id;
66+
final long snapshotId;
67+
68+
Key(TableIdentifier id, long snapshotId) {
69+
this.id = id;
70+
this.snapshotId = snapshotId;
71+
}
72+
73+
@Override
74+
public boolean equals(Object o) {
75+
if (this == o) {
76+
return true;
77+
}
78+
if (!(o instanceof Key)) {
79+
return false;
80+
}
81+
Key that = (Key) o;
82+
return snapshotId == that.snapshotId && Objects.equals(id, that.id);
83+
}
84+
85+
@Override
86+
public int hashCode() {
87+
return Objects.hash(id, snapshotId);
88+
}
89+
}
90+
91+
private final MetaCacheEntry<Key, String> entry;
92+
93+
IcebergFormatCache(long ttlSeconds, int maxSize) {
94+
// Mirror IcebergPartitionCache: translate the connector's "<= 0 disables" contract to CacheSpec's ttl == 0
95+
// (disabled) rather than passing a negative value through (which CacheSpec reads as "no expiration").
96+
CacheSpec spec = ttlSeconds > 0
97+
? CacheSpec.of(true, ttlSeconds, maxSize)
98+
: CacheSpec.of(true, CacheSpec.CACHE_TTL_DISABLE_CACHE, maxSize);
99+
this.entry = new MetaCacheEntry<>("iceberg-format", null, spec,
100+
ForkJoinPool.commonPool(), false, true, 0L, true);
101+
}
102+
103+
/** Caching is on only when the TTL is positive; ttl-second &lt;= 0 means "always infer live". */
104+
boolean isEnabled() {
105+
return entry.stats().isEffectiveEnabled();
106+
}
107+
108+
/**
109+
* Returns the cached format name for {@code key} if present and unexpired, else runs {@code loader} (the live
110+
* whole-table format inference), caches and returns it. Disabled cache -&gt; {@code loader} every call. The
111+
* loader runs OUTSIDE Caffeine's compute lock (single-flight per key) and its exception propagates unwrapped
112+
* and is NOT cached.
113+
*/
114+
String getOrLoad(Key key, Supplier<String> loader) {
115+
return entry.get(key, ignored -> loader.get());
116+
}
117+
118+
/** Drops every cached snapshot entry for one table so the next read infers live (REFRESH TABLE). */
119+
void invalidate(TableIdentifier id) {
120+
entry.invalidateIf(key -> key.id.equals(id));
121+
}
122+
123+
/** Drops every cached entry for one database (REFRESH DATABASE / DROP DATABASE); db match = namespace equality. */
124+
void invalidateDb(String dbName) {
125+
Namespace ns = Namespace.of(dbName);
126+
entry.invalidateIf(key -> key.id.namespace().equals(ns));
127+
}
128+
129+
/** Drops all cached entries (REFRESH CATALOG). */
130+
void invalidateAll() {
131+
entry.invalidateAll();
132+
}
133+
134+
/** Test-only: current number of cached entries (accurate map membership, not Caffeine's estimate). */
135+
int size() {
136+
int[] count = {0};
137+
entry.forEach((key, value) -> count[0]++);
138+
return count[0];
139+
}
140+
141+
/** Test-only: how many times the live loader (the whole-table format inference) actually ran — the metric gate. */
142+
long loadCountForTest() {
143+
return entry.stats().getLoadSuccessCount();
144+
}
145+
}

‎fe/fe-connector/fe-connector-iceberg/src/main/java/org/apache/doris/connector/iceberg/IcebergScanPlanProvider.java‎

Lines changed: 25 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -228,6 +228,10 @@ public class IcebergScanPlanProvider implements ConnectorScanPlanProvider {
228228
// when the connector's credential gate disables the cross-query layer; when null resolveTable still uses the
229229
// query-scoped fat handle and falls back to a direct remote load.
230230
private final IcebergTableCache tableCache;
231+
// PERF-03: cross-query inferred-file-format cache shared with the connector, owned by the long-lived
232+
// IcebergConnector and injected via getScanPlanProvider. Nullable — null via the offline-test ctors; when null
233+
// getScanNodeProperties resolves file_format_type live (matching pre-PERF-03 behaviour, node-memoized per query).
234+
private final IcebergFormatCache formatCache;
231235

232236
// FIX-SCAN-METRICS: per-query stash of the iceberg SDK scan diagnostics captured by the attached
233237
// IcebergScanProfileReporter during planScan, keyed by session queryId. fe-core drains it
@@ -280,12 +284,26 @@ public IcebergScanPlanProvider(Map<String, String> properties,
280284
Function<ConnectorSession, IcebergCatalogOps> catalogOpsResolver,
281285
ConnectorContext context, IcebergManifestCache manifestCache,
282286
IcebergRewritableDeleteStash rewritableDeleteStash, IcebergTableCache tableCache) {
287+
this(properties, catalogOpsResolver, context, manifestCache, rewritableDeleteStash, tableCache, null);
288+
}
289+
290+
/**
291+
* Full ctor used by {@link IcebergConnector#getScanPlanProvider()}, adding the PERF-03 cross-query
292+
* inferred-file-format cache ({@code formatCache}). The 6-arg ctor delegates here with a null format cache
293+
* (offline tests + pre-cache paths resolve {@code file_format_type} live).
294+
*/
295+
public IcebergScanPlanProvider(Map<String, String> properties,
296+
Function<ConnectorSession, IcebergCatalogOps> catalogOpsResolver,
297+
ConnectorContext context, IcebergManifestCache manifestCache,
298+
IcebergRewritableDeleteStash rewritableDeleteStash, IcebergTableCache tableCache,
299+
IcebergFormatCache formatCache) {
283300
this.properties = properties;
284301
this.catalogOpsResolver = catalogOpsResolver;
285302
this.context = context;
286303
this.manifestCache = manifestCache;
287304
this.rewritableDeleteStash = rewritableDeleteStash;
288305
this.tableCache = tableCache;
306+
this.formatCache = formatCache;
289307
}
290308

291309
/**
@@ -1326,8 +1344,14 @@ public Map<String, String> getScanNodeProperties(
13261344
// V1-only reader bug. Emit the table's real data format (legacy IcebergScanNode.getFileFormatType
13271345
// parity, same IcebergUtils.getFileFormat resolution, which throws on a non-parquet/orc table); the
13281346
// per-file format still travels per range, since one table may mix parquet and orc data files.
1347+
// PERF-03: the non-system format resolution falls back to an unfiltered whole-table planFiles() when the
1348+
// table sets neither write-format nor write.format.default; memoize that inference per (table, snapshot)
1349+
// across queries via formatCache (pure metadata, no credential gate). Null cache (offline) resolves live.
13291350
props.put("file_format_type",
1330-
systemTable ? "jni" : IcebergWriterHelper.getFileFormat(table).name().toLowerCase(Locale.ROOT));
1351+
systemTable ? "jni"
1352+
: IcebergWriterHelper.getFileFormat(table,
1353+
TableIdentifier.of(iceHandle.getDbName(), iceHandle.getTableName()), formatCache)
1354+
.name().toLowerCase(Locale.ROOT));
13311355
// [D-065] System (metadata) tables ($snapshots/$files/...) read via the JNI serialized-split path
13321356
// (planSystemTableScan): the metadata-table schema travels INSIDE the serialized FileScanTask, so BE
13331357
// needs neither the base-table path_partition_keys (a metadata table is not base-spec partitioned ->

‎fe/fe-connector/fe-connector-iceberg/src/main/java/org/apache/doris/connector/iceberg/IcebergWriterHelper.java‎

Lines changed: 73 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,11 @@
3434
import org.apache.iceberg.PartitionData;
3535
import org.apache.iceberg.PartitionSpec;
3636
import org.apache.iceberg.Schema;
37+
import org.apache.iceberg.Snapshot;
3738
import org.apache.iceberg.SortOrder;
3839
import org.apache.iceberg.Table;
3940
import org.apache.iceberg.TableProperties;
41+
import org.apache.iceberg.catalog.TableIdentifier;
4042
import org.apache.iceberg.io.CloseableIterable;
4143
import org.apache.iceberg.io.WriteResult;
4244
import org.apache.iceberg.types.Type;
@@ -45,6 +47,8 @@
4547
import org.apache.logging.log4j.LogManager;
4648
import org.apache.logging.log4j.Logger;
4749

50+
import java.io.IOException;
51+
import java.io.UncheckedIOException;
4852
import java.nio.ByteBuffer;
4953
import java.time.ZoneId;
5054
import java.util.ArrayList;
@@ -263,8 +267,21 @@ static List<DeleteFile> convertToDeleteFiles(FileFormat format, PartitionSpec sp
263267
* from the current snapshot's data files (defaulting to parquet). Throws on a non-orc/parquet format.
264268
*/
265269
static FileFormat getFileFormat(Table table) {
266-
Map<String, String> properties = table.properties();
267-
String fileFormatName = resolveFileFormatName(table, properties);
270+
return toFileFormat(resolveFileFormatName(table, table.properties()));
271+
}
272+
273+
/**
274+
* PERF-03 cache-aware overload used by the scan path ({@code IcebergScanPlanProvider.getScanNodeProperties}).
275+
* Identical resolution to {@link #getFileFormat(Table)}, except the whole-table {@code planFiles()} inference
276+
* fallback (fired only when the table sets neither {@code write-format} nor {@code write.format.default}) is
277+
* memoized per {@code (id, currentSnapshotId)} through {@code cache}. The two cheap property probes stay
278+
* uncached. A {@code null} cache/id (offline tests) or an empty table (no current snapshot) resolves live.
279+
*/
280+
static FileFormat getFileFormat(Table table, TableIdentifier id, IcebergFormatCache cache) {
281+
return toFileFormat(resolveFileFormatName(table, table.properties(), id, cache));
282+
}
283+
284+
private static FileFormat toFileFormat(String fileFormatName) {
268285
if (fileFormatName.toLowerCase().contains(ORC_NAME)) {
269286
return FileFormat.ORC;
270287
} else if (fileFormatName.toLowerCase().contains(PARQUET_NAME)) {
@@ -284,20 +301,70 @@ private static String resolveFileFormatName(Table table, Map<String, String> pro
284301
return inferFileFormatFromDataFiles(table);
285302
}
286303

304+
/**
305+
* PERF-03: like {@link #resolveFileFormatName(Table, Map)} but routes the inference fallback (the heavy
306+
* unfiltered {@code planFiles()}) through the cross-query {@code (id, snapshotId)} cache. Only the inference is
307+
* cached; the property probes are cheap. A failed inference (the loader throws) is NOT cached, so the next
308+
* query retries — for this query it degrades to the parquet default, mirroring the swallow of the live path.
309+
*/
310+
private static String resolveFileFormatName(Table table, Map<String, String> properties,
311+
TableIdentifier id, IcebergFormatCache cache) {
312+
if (properties.containsKey(WRITE_FORMAT)) {
313+
return properties.get(WRITE_FORMAT);
314+
}
315+
if (properties.containsKey(TableProperties.DEFAULT_FILE_FORMAT)) {
316+
return properties.get(TableProperties.DEFAULT_FILE_FORMAT);
317+
}
318+
Snapshot snapshot = table.currentSnapshot();
319+
if (cache == null || id == null || snapshot == null) {
320+
return inferFileFormatFromDataFiles(table);
321+
}
322+
try {
323+
return cache.getOrLoad(new IcebergFormatCache.Key(id, snapshot.snapshotId()),
324+
() -> inferFirstDataFileFormat(table));
325+
} catch (RuntimeException e) {
326+
LOG.warn("Failed to infer file format from data files for table {}, defaulting to {}",
327+
table.name(), PARQUET_NAME, e);
328+
return PARQUET_NAME;
329+
}
330+
}
331+
332+
/**
333+
* The whole-table format inference (the #64134 heavy op): reads the FIRST data file's format from the current
334+
* snapshot via an unfiltered {@code planFiles()}. The swallowing wrapper used by the write path and the direct
335+
* live path (a failure degrades to parquet). The cache loader instead calls {@link #inferFirstDataFileFormat}
336+
* so a transient failure is not memoized.
337+
*/
287338
private static String inferFileFormatFromDataFiles(Table table) {
288339
if (table.currentSnapshot() == null) {
289340
return PARQUET_NAME;
290341
}
342+
try {
343+
return inferFirstDataFileFormat(table);
344+
} catch (RuntimeException e) {
345+
LOG.warn("Failed to infer file format from data files for table {}, defaulting to {}",
346+
table.name(), PARQUET_NAME, e);
347+
return PARQUET_NAME;
348+
}
349+
}
350+
351+
/**
352+
* Raw first-data-file format inference that PROPAGATES failures (unchecked) so the cache loader does not
353+
* memoize a transient remote-IO error. The caller guarantees a non-null current snapshot; an empty snapshot
354+
* (no data files) yields the deterministic parquet default (cacheable). The try-with-resources
355+
* {@code CloseableIterable.close()} checked {@link IOException} is wrapped as {@link UncheckedIOException} so
356+
* the method stays unchecked (a {@code Supplier} loader cannot declare checked throws).
357+
*/
358+
private static String inferFirstDataFileFormat(Table table) {
291359
try (CloseableIterable<FileScanTask> files = table.newScan().planFiles()) {
292360
Iterator<FileScanTask> it = files.iterator();
293361
if (it.hasNext()) {
294362
return it.next().file().format().name().toLowerCase();
295363
}
296-
} catch (Exception e) {
297-
LOG.warn("Failed to infer file format from data files for table {}, defaulting to {}",
298-
table.name(), PARQUET_NAME, e);
364+
return PARQUET_NAME;
365+
} catch (IOException e) {
366+
throw new UncheckedIOException(e);
299367
}
300-
return PARQUET_NAME;
301368
}
302369

303370
/**

0 commit comments

Comments
 (0)