lidavidm commented on code in PR #13311: URL: https://github.com/apache/arrow/pull/13311#discussion_r916814844
########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_shared) + # We don't directly use symbols from the reflection library, so + # ensure the linker still links to it + set(GRPC_REFLECTION_LINK_LIBS -Wl,--no-as-needed gRPC::grpc++_reflection + -Wl,--as-needed) Review Comment: ```suggestion ``` ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_shared) + # We don't directly use symbols from the reflection library, so + # ensure the linker still links to it + set(GRPC_REFLECTION_LINK_LIBS -Wl,--no-as-needed gRPC::grpc++_reflection + -Wl,--as-needed) + else() + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_static) + if(APPLE) + set(GRPC_REFLECTION_LINK_LIBS -Wl,-force_load gRPC::grpc++_reflection) + else() + set(GRPC_REFLECTION_LINK_LIBS -Wl,--whole-archive gRPC::grpc++_reflection + -Wl,--no-whole-archive) + endif() Review Comment: ```suggestion ``` ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() Review Comment: Don't think we need this (as explained below) ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) Review Comment: Just `if(ARROW_FLIGHT)`? ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) Review Comment: Should be no need for us to link to gRPC ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_shared) + # We don't directly use symbols from the reflection library, so + # ensure the linker still links to it + set(GRPC_REFLECTION_LINK_LIBS -Wl,--no-as-needed gRPC::grpc++_reflection + -Wl,--as-needed) + else() + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_static) + if(APPLE) + set(GRPC_REFLECTION_LINK_LIBS -Wl,-force_load gRPC::grpc++_reflection) + else() + set(GRPC_REFLECTION_LINK_LIBS -Wl,--whole-archive gRPC::grpc++_reflection + -Wl,--no-whole-archive) + endif() + endif() + + set(FLIGHT_PROTO_PATH "${ARROW_SOURCE}/format") + set(FLIGHT_PROTO "${ARROW_SOURCE}/format/Flight.proto") + + set(FLIGHT_GENERATED_PROTO_FILES + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.pb.cc" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.pb.h" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.grpc.pb.cc" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.grpc.pb.h") + + set(PROTO_DEPENDS ${FLIGHT_PROTO} gRPC::grpc_cpp_plugin) + + add_custom_command(OUTPUT ${FLIGHT_GENERATED_PROTO_FILES} + COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}" + "--cpp_out=${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/" + "${FLIGHT_PROTO}" + DEPENDS ${PROTO_DEPENDS} ARGS + COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}" + "--grpc_out=${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/" + "--plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>" + "${FLIGHT_PROTO}") + + set_source_files_properties(${FLIGHT_GENERATED_PROTO_FILES} PROPERTIES GENERATED TRUE) + add_custom_target(flight_grpc_gen ALL DEPENDS ${FLIGHT_GENERATED_PROTO_FILES}) + + add_arrow_lib(arrow_python_flight + CMAKE_PACKAGE_NAME + ArrowPythonFlight + PKG_CONFIG_NAME + arrow-python-flight + SOURCES + flight.cc + OUTPUTS + ARROW_PYFLIGHT_LIBRARIES + DEPENDENCIES + flight_grpc_gen Review Comment: ```suggestion ``` ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_shared) Review Comment: this should probably be renamed something like `FLIGHT_LINK_LIBS` since this isn't an example ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) Review Comment: This should just be `if(ARROW_BUILD_SHARED)` I think ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt + + if(ARROW_GRPC_USE_SHARED) + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_shared) + # We don't directly use symbols from the reflection library, so + # ensure the linker still links to it + set(GRPC_REFLECTION_LINK_LIBS -Wl,--no-as-needed gRPC::grpc++_reflection + -Wl,--as-needed) + else() + set(FLIGHT_EXAMPLES_LINK_LIBS arrow_flight_static) + if(APPLE) + set(GRPC_REFLECTION_LINK_LIBS -Wl,-force_load gRPC::grpc++_reflection) + else() + set(GRPC_REFLECTION_LINK_LIBS -Wl,--whole-archive gRPC::grpc++_reflection + -Wl,--no-whole-archive) + endif() + endif() + + set(FLIGHT_PROTO_PATH "${ARROW_SOURCE}/format") + set(FLIGHT_PROTO "${ARROW_SOURCE}/format/Flight.proto") + + set(FLIGHT_GENERATED_PROTO_FILES + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.pb.cc" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.pb.h" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.grpc.pb.cc" + "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/Flight.grpc.pb.h") + + set(PROTO_DEPENDS ${FLIGHT_PROTO} gRPC::grpc_cpp_plugin) + + add_custom_command(OUTPUT ${FLIGHT_GENERATED_PROTO_FILES} + COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}" + "--cpp_out=${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/" + "${FLIGHT_PROTO}" + DEPENDS ${PROTO_DEPENDS} ARGS + COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}" + "--grpc_out=${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/src/arrow/flight/" + "--plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>" + "${FLIGHT_PROTO}") + + set_source_files_properties(${FLIGHT_GENERATED_PROTO_FILES} PROPERTIES GENERATED TRUE) + add_custom_target(flight_grpc_gen ALL DEPENDS ${FLIGHT_GENERATED_PROTO_FILES}) Review Comment: None of this should be needed - we don't need to regenerate the Protobuf sources here. ########## python/pyarrow/src_arrow/CMakeLists.txt: ########## @@ -0,0 +1,573 @@ +# 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. + +# +# arrow_python +# + +cmake_minimum_required(VERSION 3.5) + +# RPATH settings on macOS do not affect install_name. +# https://cmake.org/cmake/help/latest/policy/CMP0068.html +if(POLICY CMP0068) + cmake_policy(SET CMP0068 NEW) +endif() + +# +# Define +# ARROW_SOURCE_DIR: location of arrow/cpp +# CMAKE_MODULE_PATH: location of cmake_modules in python +# + +get_filename_component(PYARROW_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY) +get_filename_component(PYTHON_SOURCE_DIR ${PYARROW_SOURCE_DIR} DIRECTORY) +get_filename_component(ARROW_SOURCE ${PYTHON_SOURCE_DIR} DIRECTORY) +set(ARROW_CPP_SOURCE_DIR "${ARROW_SOURCE}/cpp") +set(ARROW_SOURCE_DIR "${ARROW_CPP_SOURCE_DIR}") + +# normalize ARROW_HOME path +file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME) +set(CMAKE_MODULE_PATH "${PYTHON_SOURCE_DIR}/cmake_modules" "${ARROW_HOME}/lib/cmake/arrow") + +# +# Arrow version +# + +set(ARROW_PYTHON_VERSION "9.0.0-SNAPSHOT") +string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_PYTHON_BASE_VERSION "${ARROW_PYTHON_VERSION}") +# Need to set to ARRROW_VERSION before finding Arrow package! +project(arrow_python VERSION "${ARROW_PYTHON_BASE_VERSION}") + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +# +# Arrow +# + +find_package(Arrow REQUIRED) +include(ArrowOptions) + +# +# Python +# +# Use the first Python installation on PATH, not the newest one +set(Python3_FIND_STRATEGY "LOCATION") +# On Windows, use registry last, not first +set(Python3_FIND_REGISTRY "LAST") +# On macOS, use framework last, not first +set(Python3_FIND_FRAMEWORK "LAST") + +find_package(Python3Alt 3.7 REQUIRED) +include_directories(SYSTEM ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} src) + +add_custom_target(arrow_python-all) +add_custom_target(arrow_python) +add_custom_target(arrow_python-tests) +add_dependencies(arrow_python-all arrow_python arrow_python-tests) + +set(ARROW_PYTHON_SRCS + arrow_to_pandas.cc + benchmark.cc + common.cc + datetime.cc + decimal.cc + deserialize.cc + extension_type.cc + gdb.cc + helpers.cc + inference.cc + init.cc + io.cc + ipc.cc + numpy_convert.cc + numpy_to_arrow.cc + python_to_arrow.cc + pyarrow.cc + serialize.cc + udf.cc) + +set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + +# +# Arrow vs C PyArrow options +# + +# Check all the options from Arrow and C PyArrow to be in line +if(PYARROW_WITH_DATASET) + find_package(ArrowDataset REQUIRED) +endif() + +if(PYARROW_WITH_PARQUET_ENCRYPTION) + if(PARQUET_REQUIRE_ENCRYPTION) + list(APPEND ARROW_PYTHON_SRCS parquet_encryption.cc) + find_package(Parquet REQUIRED) + else() + message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON") + endif() +endif() + +if(PYARROW_WITH_HDFS) + if(NOT ARROW_HDFS) + message(FATAL_ERROR "You must build Arrow C++ with ARROW_HDFS=ON") + endif() +endif() + +# Check for only Arrow C++ options +if(ARROW_CSV) + list(APPEND ARROW_PYTHON_SRCS csv.cc) +endif() + +if(ARROW_FILESYSTEM) + list(APPEND ARROW_PYTHON_SRCS filesystem.cc) +endif() + +# Link to arrow dependecies +if(ARROW_BUILD_SHARED) + set(ARROW_PYTHON_DEPENDENCIES arrow_shared) +else() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + set(ARROW_PYTHON_DEPENDENCIES arrow_static Threads::Threads) +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_property(SOURCE pyarrow.cc + APPEND_STRING + PROPERTY COMPILE_FLAGS " -Wno-cast-qual ") +endif() + +# +# Compiler stuff +# + +include(GNUInstallDirs) + +# This ensures that things like gnu++11 get passed correctly +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + +# We require a C++11 compliant compiler +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Needed gdb flags + +# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .') +if(ARROW_GGDB_DEBUG) + set(ARROW_DEBUG_SYMBOL_TYPE "gdb") + set(C_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(C_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") + set(CXX_FLAGS_DEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O0") + set(CXX_FLAGS_FASTDEBUG "-g${ARROW_DEBUG_SYMBOL_TYPE} -O1") +else() + set(C_FLAGS_DEBUG "-g -O0") + set(C_FLAGS_FASTDEBUG "-g -O1") + set(CXX_FLAGS_DEBUG "-g -O0") + set(CXX_FLAGS_FASTDEBUG "-g -O1") +endif() + +set(C_FLAGS_RELEASE "-O3 -DNDEBUG") +set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG") + +set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") +set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate") +set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use") + +string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) +# Set compile flags based on the build type. +message(STATUS "Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})" +) + +if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO") + +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}") +elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}") +else() + message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +endif() + +message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}") + +# +# Linker flags +# + +# Localize thirdparty symbols using a linker version script. This hides them +# from the client application. The OS X linker does not support the +# version-script option. +if(CMAKE_VERSION VERSION_LESS 3.18) + if(APPLE OR WIN32) + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT FALSE) + else() + set(CXX_LINKER_SUPPORTS_VERSION_SCRIPT TRUE) + endif() +else() + include(CheckLinkerFlag) + check_linker_flag(CXX + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map" + CXX_LINKER_SUPPORTS_VERSION_SCRIPT) +endif() + +# Need to set ARROW_VERSION_SCRIPT_FLAGS for add_arrow_lib +if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT) + set(ARROW_VERSION_SCRIPT_FLAGS + "-Wl,--version-script=${ARROW_CPP_SOURCE_DIR}/src/arrow/symbols.map") +endif() + +# +# shred/static link libs +# + +set(ARROW_PYTHON_SHARED_LINK_LIBS arrow_shared) +set(ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS) +set(ARROW_PYTHON_STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}) + +if(WIN32) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS ${PYTHON_LIBRARIES} ${PYTHON_OTHER_LIBS}) +endif() +if(PARQUET_REQUIRE_ENCRYPTION AND PYARROW_WITH_PARQUET_ENCRYPTION) + list(APPEND ARROW_PYTHON_SHARED_LINK_LIBS parquet_shared) +endif() + +if((NOT ARROW_SIMD_LEVEL STREQUAL "NONE") OR (NOT ARROW_RUNTIME_SIMD_LEVEL STREQUAL "NONE" + )) + set(ARROW_USE_XSIMD TRUE) +else() + set(ARROW_USE_XSIMD FALSE) +endif() + +if(ARROW_USE_XSIMD) + set(XSIMD_PREFIX "${ARROW_CPP_SOURCE_DIR}/${ARROW_BUILD_DIR}/xsimd_ep/src/xsimd_ep-install") + if(EXISTS ${XSIMD_PREFIX}/include) + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + else() + set(XSIMD_PREFIX "$ENV{CONDA_PREFIX}") + set(XSIMD_INCLUDE_DIR "${XSIMD_PREFIX}/include") + endif() + + add_library(xsimd INTERFACE IMPORTED) + if(CMAKE_VERSION VERSION_LESS 3.11) + set_target_properties(xsimd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${XSIMD_INCLUDE_DIR}") + else() + target_include_directories(xsimd INTERFACE "${XSIMD_INCLUDE_DIR}") + endif() + + list(APPEND ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS xsimd) + list(APPEND ARROW_PYTHON_STATIC_LINK_LIBS xsimd) +endif() + +set(ARROW_PYTHON_INCLUDES ${NUMPY_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS}) + +# Inlude macros needed to find and use add_arrow_lib function +include(BuildUtils) +include(CMakePackageConfigHelpers) + +# Set the output directory for cmake module +# (CMAKE_INSTALL_PREFIX = python/build/dist! should be set in setup.py!) +set(ARROW_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") + +add_arrow_lib(arrow_python + CMAKE_PACKAGE_NAME + ArrowPython + PKG_CONFIG_NAME + arrow-python + SOURCES + ${ARROW_PYTHON_SRCS} + PRECOMPILED_HEADERS + "$<$<COMPILE_LANGUAGE:CXX>:pch.h>" + OUTPUTS + ARROW_PYTHON_LIBRARIES + DEPENDENCIES + ${ARROW_PYTHON_DEPENDENCIES} + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} + SHARED_LINK_LIBS + ${ARROW_PYTHON_SHARED_LINK_LIBS} + SHARED_PRIVATE_LINK_LIBS + ${ARROW_PYTHON_SHARED_PRIVATE_LINK_LIBS} + STATIC_LINK_LIBS + ${ARROW_PYTHON_STATIC_LINK_LIBS} + EXTRA_INCLUDES + "${ARROW_PYTHON_INCLUDES}") + +add_dependencies(arrow_python ${ARROW_PYTHON_LIBRARIES}) + +foreach(LIB_TARGET ${ARROW_PYTHON_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_PYTHON_EXPORTING) +endforeach() + +if(ARROW_BUILD_STATIC AND MSVC) + target_compile_definitions(arrow_python_static PUBLIC ARROW_STATIC) +endif() + +if(ARROW_FLIGHT AND ARROW_BUILD_SHARED) + + # Static gRPC means we cannot link to shared Arrow, since then + # we'll violate ODR for gRPC symbols + if(NOT ARROW_GRPC_USE_SHARED AND NOT ARROW_BUILD_STATIC) + message(FATAL_ERROR "Statically built gRPC requires ARROW_BUILD_STATIC=ON") + endif() + + find_package(ArrowFlight REQUIRED) + find_package(gRPC CONFIG REQUIRED) + include_directories("${ARROW_CPP_SOURCE_DIR}/src" "${ARROW_CPP_SOURCE_DIR}/}/${ARROW_BUILD_DIR}/src") + + # Using example + # https://github.com/apache/arrow/blob/7a0f00c16e084d194ae53d209b33b809cfc8f2d5/cpp/examples/arrow/CMakeLists.txt Review Comment: The example is a little overcomplicated because it's trying to link in gRPC and Flight and you have to be careful there. But if you are just trying to link Flight then you don't need to do anything 'special' -- 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]
