a-agmon opened a new issue, #7841:
URL: https://github.com/apache/iceberg/issues/7841

   ### Apache Iceberg version
   
   1.2.1 (latest release)
   
   ### Query engine
   
   Spark
   
   ### Please describe the bug 🐞
   
   I use GlueCatalog and S3FileIO
   
   A call to this function (in order to check if it exists) raises 
   `[Finalizer] WARN org.apache.iceberg.aws.s3.S3FileIO - Unclosed S3FileIO 
instance`
   
   This is the function
   ```scala
     def isTableExist(fullTableName: String) (implicit spark: SparkSession): 
Boolean = {
       Try(spark.table(fullTableName)) match {
         case Success(df) => true
         case Failure(exception) =>
           logger.info(s"Exception occurred when getting table $fullTableName: 
$exception")
           false
       }
     }
   ```
   
   and this is full stack trace 
   ```
   [Finalizer] WARN org.apache.iceberg.aws.s3.S3FileIO - Unclosed S3FileIO 
instance created by:
        org.apache.iceberg.aws.s3.S3FileIO.initialize(S3FileIO.java:362)
        org.apache.iceberg.CatalogUtil.loadFileIO(CatalogUtil.java:325)
        
org.apache.iceberg.aws.glue.GlueTableOperations.initializeFileIO(GlueTableOperations.java:223)
        
org.apache.iceberg.aws.glue.GlueTableOperations.io(GlueTableOperations.java:115)
        
org.apache.iceberg.BaseMetastoreTableOperations.lambda$refreshFromMetadataLocation$0(BaseMetastoreTableOperations.java:189)
        
org.apache.iceberg.BaseMetastoreTableOperations.lambda$refreshFromMetadataLocation$1(BaseMetastoreTableOperations.java:208)
        org.apache.iceberg.util.Tasks$Builder.runTaskWithRetry(Tasks.java:413)
        org.apache.iceberg.util.Tasks$Builder.runSingleThreaded(Tasks.java:219)
        org.apache.iceberg.util.Tasks$Builder.run(Tasks.java:203)
        org.apache.iceberg.util.Tasks$Builder.run(Tasks.java:196)
        
org.apache.iceberg.BaseMetastoreTableOperations.refreshFromMetadataLocation(BaseMetastoreTableOperations.java:208)
        
org.apache.iceberg.BaseMetastoreTableOperations.refreshFromMetadataLocation(BaseMetastoreTableOperations.java:185)
        
org.apache.iceberg.BaseMetastoreTableOperations.refreshFromMetadataLocation(BaseMetastoreTableOperations.java:176)
        
org.apache.iceberg.aws.glue.GlueTableOperations.doRefresh(GlueTableOperations.java:141)
        
org.apache.iceberg.BaseMetastoreTableOperations.refresh(BaseMetastoreTableOperations.java:97)
        
org.apache.iceberg.BaseMetastoreTableOperations.current(BaseMetastoreTableOperations.java:80)
        
org.apache.iceberg.BaseMetastoreCatalog.loadTable(BaseMetastoreCatalog.java:47)
        
org.apache.iceberg.shaded.com.github.benmanes.caffeine.cache.BoundedLocalCache.lambda$doComputeIfAbsent$14(BoundedLocalCache.java:2406)
        
java.base/java.util.concurrent.ConcurrentHashMap.compute(ConcurrentHashMap.java:1908)
        
org.apache.iceberg.shaded.com.github.benmanes.caffeine.cache.BoundedLocalCache.doComputeIfAbsent(BoundedLocalCache.java:2404)
        
org.apache.iceberg.shaded.com.github.benmanes.caffeine.cache.BoundedLocalCache.computeIfAbsent(BoundedLocalCache.java:2387)
        
org.apache.iceberg.shaded.com.github.benmanes.caffeine.cache.LocalCache.computeIfAbsent(LocalCache.java:108)
        
org.apache.iceberg.shaded.com.github.benmanes.caffeine.cache.LocalManualCache.get(LocalManualCache.java:62)
        org.apache.iceberg.CachingCatalog.loadTable(CachingCatalog.java:166)
        org.apache.iceberg.spark.SparkCatalog.load(SparkCatalog.java:642)
        org.apache.iceberg.spark.SparkCatalog.loadTable(SparkCatalog.java:160)
        
org.apache.spark.sql.connector.catalog.CatalogV2Util$.loadTable(CatalogV2Util.scala:311)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$.$anonfun$lookupRelation$3(Analyzer.scala:1202)
        scala.Option.orElse(Option.scala:447)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$.$anonfun$lookupRelation$1(Analyzer.scala:1201)
        scala.Option.orElse(Option.scala:447)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$.org$apache$spark$sql$catalyst$analysis$Analyzer$ResolveRelations$$lookupRelation(Analyzer.scala:1193)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$$anonfun$apply$13.applyOrElse(Analyzer.scala:1064)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$$anonfun$apply$13.applyOrElse(Analyzer.scala:1028)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUpWithPruning$3(AnalysisHelper.scala:138)
        
org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:176)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUpWithPruning$1(AnalysisHelper.scala:138)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.allowInvokingTransformsInAnalyzer(AnalysisHelper.scala:323)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUpWithPruning(AnalysisHelper.scala:134)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUpWithPruning$(AnalysisHelper.scala:130)
        
org.apache.spark.sql.catalyst.plans.logical.LogicalPlan.resolveOperatorsUpWithPruning(LogicalPlan.scala:30)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$.apply(Analyzer.scala:1028)
        
org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveRelations$.apply(Analyzer.scala:987)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$2(RuleExecutor.scala:211)
        
scala.collection.LinearSeqOptimized.foldLeft(LinearSeqOptimized.scala:126)
        
scala.collection.LinearSeqOptimized.foldLeft$(LinearSeqOptimized.scala:122)
        scala.collection.immutable.List.foldLeft(List.scala:91)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1(RuleExecutor.scala:208)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1$adapted(RuleExecutor.scala:200)
        scala.collection.immutable.List.foreach(List.scala:431)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.execute(RuleExecutor.scala:200)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.org$apache$spark$sql$catalyst$analysis$Analyzer$$executeSameContext(Analyzer.scala:231)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$execute$1(Analyzer.scala:227)
        
org.apache.spark.sql.catalyst.analysis.AnalysisContext$.withNewAnalysisContext(Analyzer.scala:173)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:227)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:188)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$executeAndTrack$1(RuleExecutor.scala:179)
        
org.apache.spark.sql.catalyst.QueryPlanningTracker$.withTracker(QueryPlanningTracker.scala:88)
        
org.apache.spark.sql.catalyst.rules.RuleExecutor.executeAndTrack(RuleExecutor.scala:179)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:212)
        
org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330)
        
org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:211)
        
org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:76)
        
org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
        
org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$2(QueryExecution.scala:185)
        
org.apache.spark.sql.execution.QueryExecution$.withInternalError(QueryExecution.scala:510)
        
org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:185)
        org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:779)
        
org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:184)
        
org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:76)
        
org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:74)
        
org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:66)
        org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:91)
        org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:779)
        org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:89)
        org.apache.spark.sql.DataFrameReader.table(DataFrameReader.scala:607)
        org.apache.spark.sql.SparkSession.table(SparkSession.scala:600)
        
com.appsflyer.bde.TableChangeCapture$.$anonfun$isTableExist$1(TableChangeCapture.scala:86)
        scala.util.Try$.apply(Try.scala:213)
        
com.appsflyer.bde.TableChangeCapture$.isTableExist(TableChangeCapture.scala:86)
        
com.appsflyer.bde.TableChangeCapture$.updateCurrentUsersTable(TableChangeCapture.scala:204)
        
com.appsflyer.bde.TableChangeCapture$.runMergeJob(TableChangeCapture.scala:167)
        com.appsflyer.bde.IcebergRunner$.main(IcebergRunner.scala:70)
        com.appsflyer.bde.IcebergRunner.main(IcebergRunner.scala)
   ```


-- 
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.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to