fix: build unit tests with shared library

CMakeLists.txt

@@ -46,6 +46,25 @@ option(ICEBERG_BUILD_REST_INTEGRATION_TESTS "Build rest catalog integration test
 option(ICEBERG_ENABLE_ASAN "Enable Address Sanitizer" OFF)
 option(ICEBERG_ENABLE_UBSAN "Enable Undefined Behavior Sanitizer" OFF)
 
+if(ICEBERG_BUILD_SHARED)
+  set(ICEBERG_TEST_LINKAGE_DEFAULT "shared")
+else()
+  set(ICEBERG_TEST_LINKAGE_DEFAULT "static")
+endif()
+set(ICEBERG_TEST_LINKAGE
+    ${ICEBERG_TEST_LINKAGE_DEFAULT}
+    CACHE STRING "Linkage of Iceberg libraries with unit tests executables")
+if(ICEBERG_BUILD_TESTS)
+  if(ICEBERG_TEST_LINKAGE STREQUAL "shared" AND NOT ICEBERG_BUILD_SHARED)
+    message(FATAL_ERROR "If using ICEBERG_TEST_LINKAGE=shared, must also pass ICEBERG_BUILD_SHARED=ON"
+    )
+  endif()
+  if(ICEBERG_TEST_LINKAGE STREQUAL "static" AND NOT ICEBERG_BUILD_STATIC)
+    message(FATAL_ERROR "If using ICEBERG_TEST_LINKAGE=static, must also pass ICEBERG_BUILD_STATIC=ON"
+    )
+  endif()
+endif()
+
 include(GNUInstallDirs)
 include(FetchContent)
 

cmake_modules/IcebergBuildUtils.cmake

@@ -152,10 +152,6 @@ function(add_iceberg_lib LIB_NAME)
 
     string(TOUPPER ${LIB_NAME} VISIBILITY_NAME)
     target_compile_definitions(${LIB_NAME}_shared PRIVATE ${VISIBILITY_NAME}_EXPORTING)
-    set_target_properties(${LIB_NAME}_shared
-                          PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET
-                                                                hidden
-                                     VISIBILITY_INLINES_HIDDEN 1)
 
     install(TARGETS ${LIB_NAME}_shared
             EXPORT iceberg_targets

cmake_modules/IcebergThirdpartyToolchain.cmake

@@ -83,8 +83,8 @@ endmacro()
 function(resolve_arrow_dependency)
   prepare_fetchcontent()
 
-  set(ARROW_BUILD_SHARED OFF)
-  set(ARROW_BUILD_STATIC ON)
+  set(ARROW_BUILD_SHARED ${ICEBERG_BUILD_SHARED})
+  set(ARROW_BUILD_STATIC ${ICEBERG_BUILD_STATIC})
   # Work around undefined symbol: arrow::ipc::ReadSchema(arrow::io::InputStream*, arrow::ipc::DictionaryMemo*)
   set(ARROW_IPC ON)
   set(ARROW_FILESYSTEM ON)
@@ -113,43 +113,74 @@ function(resolve_arrow_dependency)
   fetchcontent_makeavailable(VendoredArrow)
 
   if(vendoredarrow_SOURCE_DIR)
-    if(NOT TARGET Arrow::arrow_static)
-      add_library(Arrow::arrow_static INTERFACE IMPORTED)
-      target_link_libraries(Arrow::arrow_static INTERFACE arrow_static)
-      target_include_directories(Arrow::arrow_static
-                                 INTERFACE ${vendoredarrow_BINARY_DIR}/src
-                                           ${vendoredarrow_SOURCE_DIR}/cpp/src)
+    if(ARROW_BUILD_STATIC)
+      if(NOT TARGET Arrow::arrow_static)
+        add_library(Arrow::arrow_static INTERFACE IMPORTED)
+        target_link_libraries(Arrow::arrow_static INTERFACE arrow_static)
+        target_include_directories(Arrow::arrow_static
+                                   INTERFACE ${vendoredarrow_BINARY_DIR}/src
+                                             ${vendoredarrow_SOURCE_DIR}/cpp/src)
+      endif()
+
+      if(NOT TARGET Parquet::parquet_static)
+        add_library(Parquet::parquet_static INTERFACE IMPORTED)
+        target_link_libraries(Parquet::parquet_static INTERFACE parquet_static)
+        target_include_directories(Parquet::parquet_static
+                                   INTERFACE ${vendoredarrow_BINARY_DIR}/src
+                                             ${vendoredarrow_SOURCE_DIR}/cpp/src)
+      endif()
+
+      set_target_properties(arrow_static PROPERTIES OUTPUT_NAME
+                                                    "iceberg_vendored_arrow_static")
+      set_target_properties(parquet_static PROPERTIES OUTPUT_NAME
+                                                      "iceberg_vendored_parquet_static")
+      install(TARGETS arrow_static parquet_static
+              EXPORT iceberg_targets
+              RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
+              ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
+              LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
+
+      if(TARGET arrow_bundled_dependencies)
+        message(STATUS "arrow_bundled_dependencies found")
+        # arrow_bundled_dependencies is only INSTALL_INTERFACE and will not be built by default.
+        # We need to add it as a dependency to arrow_static so that it will be built.
+        add_dependencies(arrow_static arrow_bundled_dependencies)
+        # We cannot install an IMPORTED target, so we need to install the library manually.
+        get_target_property(arrow_bundled_dependencies_location
+                            arrow_bundled_dependencies IMPORTED_LOCATION)
+        install(FILES ${arrow_bundled_dependencies_location}
+                DESTINATION ${ICEBERG_INSTALL_LIBDIR})
+      endif()
     endif()
 
-    if(NOT TARGET Parquet::parquet_static)
-      add_library(Parquet::parquet_static INTERFACE IMPORTED)
-      target_link_libraries(Parquet::parquet_static INTERFACE parquet_static)
-      target_include_directories(Parquet::parquet_static
-                                 INTERFACE ${vendoredarrow_BINARY_DIR}/src
-                                           ${vendoredarrow_SOURCE_DIR}/cpp/src)
+    if(ARROW_BUILD_SHARED)
+      if(NOT TARGET Arrow::arrow_shared)
+        add_library(Arrow::arrow_shared INTERFACE IMPORTED)
+        target_link_libraries(Arrow::arrow_shared INTERFACE arrow_shared)
+        target_include_directories(Arrow::arrow_shared
+                                   INTERFACE ${vendoredarrow_BINARY_DIR}/src
+                                             ${vendoredarrow_SOURCE_DIR}/cpp/src)
+      endif()
+
+      if(NOT TARGET Parquet::parquet_shared)
+        add_library(Parquet::parquet_shared INTERFACE IMPORTED)
+        target_link_libraries(Parquet::parquet_shared INTERFACE parquet_shared)
+        target_include_directories(Parquet::parquet_shared
+                                   INTERFACE ${vendoredarrow_BINARY_DIR}/src
+                                             ${vendoredarrow_SOURCE_DIR}/cpp/src)
+      endif()
+
+      set_target_properties(arrow_shared PROPERTIES OUTPUT_NAME "iceberg_vendored_arrow")
+      set_target_properties(parquet_shared PROPERTIES OUTPUT_NAME
+                                                      "iceberg_vendored_parquet")
+      install(TARGETS arrow_shared parquet_shared
+              EXPORT iceberg_targets
+              RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
+              ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
+              LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
     endif()
 
     set(ARROW_VENDORED TRUE)
-    set_target_properties(arrow_static PROPERTIES OUTPUT_NAME "iceberg_vendored_arrow")
-    set_target_properties(parquet_static PROPERTIES OUTPUT_NAME
-                                                    "iceberg_vendored_parquet")
-    install(TARGETS arrow_static parquet_static
-            EXPORT iceberg_targets
-            RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
-            ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
-            LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
-
-    if(TARGET arrow_bundled_dependencies)
-      message(STATUS "arrow_bundled_dependencies found")
-      # arrow_bundled_dependencies is only INSTALL_INTERFACE and will not be built by default.
-      # We need to add it as a dependency to arrow_static so that it will be built.
-      add_dependencies(arrow_static arrow_bundled_dependencies)
-      # We cannot install an IMPORTED target, so we need to install the library manually.
-      get_target_property(arrow_bundled_dependencies_location arrow_bundled_dependencies
-                          IMPORTED_LOCATION)
-      install(FILES ${arrow_bundled_dependencies_location}
-              DESTINATION ${ICEBERG_INSTALL_LIBDIR})
-    endif()
   else()
     set(ARROW_VENDORED FALSE)
     list(APPEND ICEBERG_SYSTEM_DEPENDENCIES Arrow)
@@ -168,6 +199,8 @@ endfunction()
 
 function(resolve_avro_dependency)
   prepare_fetchcontent()
+  set(BUILD_SHARED_LIBS ${ICEBERG_BUILD_SHARED})
+  set(BUILD_STATIC_LIBS ${ICEBERG_BUILD_STATIC})
 
   set(AVRO_USE_BOOST
       OFF
@@ -221,28 +254,50 @@ function(resolve_avro_dependency)
   fetchcontent_makeavailable(avro-cpp)
 
   if(avro-cpp_SOURCE_DIR)
-    if(NOT TARGET avro-cpp::avrocpp_static)
-      add_library(avro-cpp::avrocpp_static INTERFACE IMPORTED)
-      target_link_libraries(avro-cpp::avrocpp_static INTERFACE avrocpp_s)
-      target_include_directories(avro-cpp::avrocpp_static
-                                 INTERFACE ${avro-cpp_BINARY_DIR}
-                                           ${avro-cpp_SOURCE_DIR}/lang/c++)
+    if(BUILD_STATIC_LIBS)
+      if(NOT TARGET avro-cpp::avrocpp_static)
+        add_library(avro-cpp::avrocpp_static INTERFACE IMPORTED)
+        target_link_libraries(avro-cpp::avrocpp_static INTERFACE avrocpp_s)
+        target_include_directories(avro-cpp::avrocpp_static
+                                   INTERFACE ${avro-cpp_BINARY_DIR}
+                                             ${avro-cpp_SOURCE_DIR}/lang/c++)
+      endif()
+
+      set_target_properties(avrocpp_s PROPERTIES OUTPUT_NAME
+                                                 "iceberg_vendored_avrocpp_static")
+      set_target_properties(avrocpp_s PROPERTIES POSITION_INDEPENDENT_CODE ON)
+      install(TARGETS avrocpp_s
+              EXPORT iceberg_targets
+              RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
+              ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
+              LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
+
+      # TODO: add vendored ZLIB and Snappy support
+      find_package(Snappy CONFIG)
+      if(Snappy_FOUND)
+        list(APPEND ICEBERG_SYSTEM_DEPENDENCIES Snappy)
+      endif()
     endif()
 
-    set(AVRO_VENDORED TRUE)
-    set_target_properties(avrocpp_s PROPERTIES OUTPUT_NAME "iceberg_vendored_avrocpp")
-    set_target_properties(avrocpp_s PROPERTIES POSITION_INDEPENDENT_CODE ON)
-    install(TARGETS avrocpp_s
-            EXPORT iceberg_targets
-            RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
-            ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
-            LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
-
-    # TODO: add vendored ZLIB and Snappy support
-    find_package(Snappy CONFIG)
-    if(Snappy_FOUND)
-      list(APPEND ICEBERG_SYSTEM_DEPENDENCIES Snappy)
+    if(BUILD_SHARED_LIBS)
+      if(NOT TARGET avro-cpp::avrocpp_shared)
+        add_library(avro-cpp::avrocpp_shared INTERFACE IMPORTED)
+        target_link_libraries(avro-cpp::avrocpp_shared INTERFACE avrocpp)
+        target_include_directories(avro-cpp::avrocpp_shared
+                                   INTERFACE ${avro-cpp_BINARY_DIR}
+                                             ${avro-cpp_SOURCE_DIR}/lang/c++)
+      endif()
+
+      set_target_properties(avrocpp PROPERTIES OUTPUT_NAME "iceberg_vendored_avrocpp")
+      set_target_properties(avrocpp PROPERTIES POSITION_INDEPENDENT_CODE ON)
+      install(TARGETS avrocpp
+              EXPORT iceberg_targets
+              RUNTIME DESTINATION "${ICEBERG_INSTALL_BINDIR}"
+              ARCHIVE DESTINATION "${ICEBERG_INSTALL_LIBDIR}"
+              LIBRARY DESTINATION "${ICEBERG_INSTALL_LIBDIR}")
     endif()
+
+    set(AVRO_VENDORED TRUE)
   else()
     set(AVRO_VENDORED FALSE)
     list(APPEND ICEBERG_SYSTEM_DEPENDENCIES Avro)

src/iceberg/CMakeLists.txt

@@ -91,35 +91,31 @@ set(ICEBERG_SOURCES
 
 set(ICEBERG_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_SHARED_BUILD_INTERFACE_LIBS)
+set(ICEBERG_SHARED_PRIVATE_BUILD_INTERFACE_LIBS)
 set(ICEBERG_STATIC_INSTALL_INTERFACE_LIBS)
 set(ICEBERG_SHARED_INSTALL_INTERFACE_LIBS)
 
 list(APPEND
      ICEBERG_STATIC_BUILD_INTERFACE_LIBS
-     nanoarrow::nanoarrow_static
+     nanoarrow::nanoarrow
      nlohmann_json::nlohmann_json
      roaring::roaring
      spdlog::spdlog
      ZLIB::ZLIB)
 list(APPEND
-     ICEBERG_SHARED_BUILD_INTERFACE_LIBS
-     nanoarrow::nanoarrow_shared
+     ICEBERG_SHARED_PRIVATE_BUILD_INTERFACE_LIBS
+     nanoarrow::nanoarrow
      nlohmann_json::nlohmann_json
      roaring::roaring
      spdlog::spdlog
      ZLIB::ZLIB)
 list(APPEND
      ICEBERG_STATIC_INSTALL_INTERFACE_LIBS
-     "$<IF:$<BOOL:${NANOARROW_VENDORED}>,iceberg::nanoarrow_static,$<IF:$<TARGET_EXISTS:nanoarrow::nanoarrow_static>,nanoarrow::nanoarrow_static,nanoarrow::nanoarrow_shared>>"
-     "$<IF:$<BOOL:${NLOHMANN_JSON_VENDORED}>,iceberg::nlohmann_json,$<IF:$<TARGET_EXISTS:nlohmann_json::nlohmann_json>,nlohmann_json::nlohmann_json,nlohmann_json::nlohmann_json>>"
+     "$<IF:$<BOOL:${NANOARROW_VENDORED}>,iceberg::nanoarrow_static,nanoarrow::nanoarrow>"
+     "$<IF:$<BOOL:${NLOHMANN_JSON_VENDORED}>,iceberg::nlohmann_json,nlohmann_json::nlohmann_json>"
      "$<IF:$<BOOL:${CROARING_VENDORED}>,iceberg::roaring,roaring::roaring>"
-     "$<IF:$<BOOL:${SPDLOG_VENDORED}>,iceberg::spdlog,spdlog::spdlog>")
-list(APPEND
-     ICEBERG_SHARED_INSTALL_INTERFACE_LIBS
-     "$<IF:$<BOOL:${NANOARROW_VENDORED}>,iceberg::nanoarrow_shared,$<IF:$<TARGET_EXISTS:nanoarrow::nanoarrow_shared>,nanoarrow::nanoarrow_shared,nanoarrow::nanoarrow_static>>"
-     "$<IF:$<BOOL:${NLOHMANN_JSON_VENDORED}>,iceberg::nlohmann_json,$<IF:$<TARGET_EXISTS:nlohmann_json::nlohmann_json>,nlohmann_json::nlohmann_json,nlohmann_json::nlohmann_json>>"
-     "$<IF:$<BOOL:${CROARING_VENDORED}>,iceberg::roaring,roaring::roaring>"
-     "$<IF:$<BOOL:${SPDLOG_VENDORED}>,iceberg::spdlog,spdlog::spdlog>")
+     "$<IF:$<BOOL:${SPDLOG_VENDORED}>,iceberg::spdlog,spdlog::spdlog>"
+     ZLIB::ZLIB)
 
 add_iceberg_lib(iceberg
                 SOURCES
@@ -128,6 +124,8 @@ add_iceberg_lib(iceberg
                 ${ICEBERG_INCLUDES}
                 SHARED_LINK_LIBS
                 ${ICEBERG_SHARED_BUILD_INTERFACE_LIBS}
+                SHARED_PRIVATE_LINK_LIBS
+                ${ICEBERG_SHARED_PRIVATE_BUILD_INTERFACE_LIBS}
                 STATIC_LINK_LIBS
                 ${ICEBERG_STATIC_BUILD_INTERFACE_LIBS}
                 STATIC_INSTALL_INTERFACE_LIBS
@@ -137,6 +135,13 @@ add_iceberg_lib(iceberg
                 OUTPUTS
                 ICEBERG_LIBRARIES)
 
+if(ICEBERG_BUILD_SHARED)
+  set_target_properties(iceberg_shared
+                        PROPERTIES C_VISIBILITY_PRESET hidden
+                                   CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN
+                                                                1)
+endif()
+
 iceberg_install_all_headers(iceberg)
 
 add_subdirectory(catalog)
@@ -165,44 +170,38 @@ if(ICEBERG_BUILD_BUNDLE)
   # Libraries to link with exported libiceberg_bundle.{so,a}.
   set(ICEBERG_BUNDLE_STATIC_BUILD_INTERFACE_LIBS)
   set(ICEBERG_BUNDLE_SHARED_BUILD_INTERFACE_LIBS)
+  set(ICEBERG_BUNDLE_SHARED_PRIVATE_BUILD_INTERFACE_LIBS)
   set(ICEBERG_BUNDLE_STATIC_INSTALL_INTERFACE_LIBS)
   set(ICEBERG_BUNDLE_SHARED_INSTALL_INTERFACE_LIBS)
 
   list(APPEND
        ICEBERG_BUNDLE_STATIC_BUILD_INTERFACE_LIBS
-       "$<IF:$<TARGET_EXISTS:iceberg_static>,iceberg_static,iceberg_shared>"
-       "$<IF:$<TARGET_EXISTS:Arrow::arrow_static>,Arrow::arrow_static,Arrow::arrow_shared>"
-       "$<IF:$<TARGET_EXISTS:Parquet::parquet_static>,Parquet::parquet_static,Parquet::parquet_shared>"
-       "$<IF:$<TARGET_EXISTS:avro-cpp::avrocpp_static>,avro-cpp::avrocpp_static,avro-cpp::avrocpp_shared>"
-  )
+       iceberg_static
+       Arrow::arrow_static
+       Parquet::parquet_static
+       avro-cpp::avrocpp_static)
   list(APPEND
        ICEBERG_BUNDLE_SHARED_BUILD_INTERFACE_LIBS
-       "$<IF:$<TARGET_EXISTS:iceberg_shared>,iceberg_shared,iceberg_static>"
-       "$<IF:$<TARGET_EXISTS:Arrow::arrow_shared>,Arrow::arrow_shared,Arrow::arrow_static>"
-       "$<IF:$<TARGET_EXISTS:Parquet::parquet_shared>,Parquet::parquet_shared,Parquet::parquet_static>"
-       "$<IF:$<TARGET_EXISTS:avro-cpp::avrocpp_shared>,avro-cpp::avrocpp_shared,avro-cpp::avrocpp_static>"
-  )
-
+       iceberg_shared
+       Arrow::arrow_shared
+       Parquet::parquet_shared
+       avro-cpp::avrocpp_shared)
+  list(APPEND ICEBERG_BUNDLE_SHARED_PRIVATE_BUILD_INTERFACE_LIBS nanoarrow::nanoarrow)
   list(APPEND
        ICEBERG_BUNDLE_STATIC_INSTALL_INTERFACE_LIBS
-       "$<IF:$<TARGET_EXISTS:iceberg::iceberg_static>,iceberg::iceberg_static,iceberg::iceberg_shared>"
-       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::arrow_static,$<IF:$<TARGET_EXISTS:Arrow::arrow_static>,Arrow::arrow_static,Arrow::arrow_shared>>"
-       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::parquet_static,$<IF:$<TARGET_EXISTS:Parquet::parquet_static>,Parquet::parquet_static,Parquet::parquet_shared>>"
-       "$<IF:$<BOOL:${AVRO_VENDORED}>,iceberg::avrocpp_s,$<IF:$<TARGET_EXISTS:avro-cpp::avrocpp_static>,avro-cpp::avrocpp_static,avro-cpp::avrocpp_shared>>"
-  )
-  list(APPEND
-       ICEBERG_BUNDLE_SHARED_INSTALL_INTERFACE_LIBS
-       "$<IF:$<TARGET_EXISTS:iceberg::iceberg_shared>,iceberg::iceberg_shared,iceberg::iceberg_static>"
-       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::arrow_static,$<IF:$<TARGET_EXISTS:Arrow::arrow_shared>,Arrow::arrow_shared,Arrow::arrow_static>>"
-       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::parquet_static,$<IF:$<TARGET_EXISTS:Parquet::parquet_shared>,Parquet::parquet_shared,Parquet::parquet_static>>"
-       "$<IF:$<BOOL:${AVRO_VENDORED}>,iceberg::avrocpp_s,$<IF:$<TARGET_EXISTS:avro-cpp::avrocpp_shared>,avro-cpp::avrocpp_shared,avro-cpp::avrocpp_static>>"
-  )
+       iceberg::iceberg_static
+       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::arrow_static,Arrow::arrow_static>"
+       "$<IF:$<BOOL:${ARROW_VENDORED}>,iceberg::parquet_static,Parquet::parquet_static>"
+       "$<IF:$<BOOL:${AVRO_VENDORED}>,iceberg::avrocpp_s,avro-cpp::avrocpp_static>")
+  list(APPEND ICEBERG_BUNDLE_SHARED_INSTALL_INTERFACE_LIBS iceberg::iceberg_shared)
 
   add_iceberg_lib(iceberg_bundle
                   SOURCES
                   ${ICEBERG_BUNDLE_SOURCES}
                   SHARED_LINK_LIBS
                   ${ICEBERG_BUNDLE_SHARED_BUILD_INTERFACE_LIBS}
+                  SHARED_PRIVATE_LINK_LIBS
+                  ${ICEBERG_BUNDLE_SHARED_PRIVATE_BUILD_INTERFACE_LIBS}
                   STATIC_LINK_LIBS
                   ${ICEBERG_BUNDLE_STATIC_BUILD_INTERFACE_LIBS}
                   STATIC_INSTALL_INTERFACE_LIBS

src/iceberg/arrow_c_data_guard_internal.cc

@@ -19,6 +19,8 @@
 
 #include "iceberg/arrow_c_data_guard_internal.h"
 
+#include <nanoarrow/nanoarrow.h>
+
 namespace iceberg::internal {
 
 ArrowArrayGuard::~ArrowArrayGuard() {