[ceph.git] / ceph / src / arrow / cpp / src / parquet / CMakeLists.txt

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

add_custom_target(parquet-all)
add_custom_target(parquet)
add_custom_target(parquet-benchmarks)
add_custom_target(parquet-tests)
add_dependencies(parquet-all parquet parquet-tests parquet-benchmarks)

function(ADD_PARQUET_TEST REL_TEST_NAME)
  set(one_value_args)
  set(multi_value_args EXTRA_DEPENDENCIES LABELS)
  cmake_parse_arguments(ARG
                        "${options}"
                        "${one_value_args}"
                        "${multi_value_args}"
                        ${ARGN})

  set(TEST_ARGUMENTS PREFIX "parquet" LABELS "parquet-tests")

  if(ARROW_TEST_LINKAGE STREQUAL "static")
    add_test_case(${REL_TEST_NAME}
                  STATIC_LINK_LIBS
                  ${PARQUET_STATIC_TEST_LINK_LIBS}
                  ${TEST_ARGUMENTS}
                  ${ARG_UNPARSED_ARGUMENTS})
  else()
    add_test_case(${REL_TEST_NAME}
                  STATIC_LINK_LIBS
                  ${PARQUET_SHARED_TEST_LINK_LIBS}
                  ${TEST_ARGUMENTS}
                  ${ARG_UNPARSED_ARGUMENTS})
  endif()
endfunction()

function(ADD_PARQUET_FUZZ_TARGET REL_FUZZING_NAME)
  set(options)
  set(one_value_args PREFIX)
  set(multi_value_args)
  cmake_parse_arguments(ARG
                        "${options}"
                        "${one_value_args}"
                        "${multi_value_args}"
                        ${ARGN})

  if(ARG_PREFIX)
    set(PREFIX ${ARG_PREFIX})
  else()
    set(PREFIX "parquet")
  endif()

  if(ARROW_BUILD_STATIC)
    set(LINK_LIBS parquet_static)
  else()
    set(LINK_LIBS parquet_shared)
  endif()
  add_fuzz_target(${REL_FUZZING_NAME}
                  PREFIX
                  ${PREFIX}
                  LINK_LIBS
                  ${LINK_LIBS}
                  ${ARG_UNPARSED_ARGUMENTS})
endfunction()

function(ADD_PARQUET_BENCHMARK REL_TEST_NAME)
  set(options)
  set(one_value_args PREFIX)
  set(multi_value_args)
  cmake_parse_arguments(ARG
                        "${options}"
                        "${one_value_args}"
                        "${multi_value_args}"
                        ${ARGN})
  if(ARG_PREFIX)
    set(PREFIX ${ARG_PREFIX})
  else()
    set(PREFIX "parquet")
  endif()
  add_benchmark(${REL_TEST_NAME}
                PREFIX
                ${PREFIX}
                LABELS
                "parquet-benchmarks"
                ${PARQUET_BENCHMARK_LINK_OPTION}
                ${ARG_UNPARSED_ARGUMENTS})
endfunction()

# ----------------------------------------------------------------------
# Link libraries setup

# TODO(wesm): Handling of ABI/SO version

if(ARROW_BUILD_STATIC)
  set(PARQUET_STATIC_LINK_LIBS arrow_static)
  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_static arrow_static)
else()
  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
endif()

set(PARQUET_MIN_TEST_LIBS GTest::gtest_main GTest::gtest)

if(APPLE)
  set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} ${CMAKE_DL_LIBS})
elseif(NOT MSVC)
  set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} pthread ${CMAKE_DL_LIBS})
endif()

set(PARQUET_SHARED_TEST_LINK_LIBS arrow_testing_shared ${PARQUET_MIN_TEST_LIBS}
                                  parquet_shared thrift::thrift)

set(PARQUET_STATIC_TEST_LINK_LIBS ${PARQUET_MIN_TEST_LIBS} parquet_static thrift::thrift
                                  ${ARROW_LIBRARIES_FOR_STATIC_TESTS})

#
# Generated Thrift sources
set_source_files_properties(src/generated/parquet_types.cpp src/generated/parquet_types.h
                            src/generated/parquet_constants.cpp
                            src/generated/parquet_constants.h
                            PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                       SKIP_UNITY_BUILD_INCLUSION ON)

if(NOT MSVC)
  set_source_files_properties(src/parquet/parquet_types.cpp
                              PROPERTIES COMPILE_FLAGS -Wno-unused-variable)
endif()

#
# Library config

set(PARQUET_SRCS
    arrow/path_internal.cc
    arrow/reader.cc
    arrow/reader_internal.cc
    arrow/schema.cc
    arrow/schema_internal.cc
    arrow/writer.cc
    bloom_filter.cc
    column_reader.cc
    column_scanner.cc
    column_writer.cc
    encoding.cc
    encryption/encryption.cc
    encryption/internal_file_decryptor.cc
    encryption/internal_file_encryptor.cc
    exception.cc
    file_reader.cc
    file_writer.cc
    level_comparison.cc
    level_conversion.cc
    metadata.cc
    murmur3.cc
    "${ARROW_SOURCE_DIR}/src/generated/parquet_constants.cpp"
    "${ARROW_SOURCE_DIR}/src/generated/parquet_types.cpp"
    platform.cc
    printer.cc
    properties.cc
    schema.cc
    statistics.cc
    stream_reader.cc
    stream_writer.cc
    types.cc)

if(ARROW_HAVE_RUNTIME_AVX2)
  # AVX2 is used as a proxy for BMI2.
  list(APPEND PARQUET_SRCS level_comparison_avx2.cc level_conversion_bmi2.cc)
  set_source_files_properties(level_comparison_avx2.cc
                              PROPERTIES SKIP_PRECOMPILE_HEADERS ON COMPILE_FLAGS
                                                                    "${ARROW_AVX2_FLAG}")
  # WARNING: DO NOT BLINDLY COPY THIS CODE FOR OTHER BMI2 USE CASES.
  # This code is always guarded by runtime dispatch which verifies
  # BMI2 is present.  For a very small number of CPUs AVX2 does not
  # imply BMI2.
  set_source_files_properties(level_conversion_bmi2.cc
                              PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                         COMPILE_FLAGS
                                         "${ARROW_AVX2_FLAG} -DARROW_HAVE_BMI2 -mbmi2")
endif()

if(PARQUET_REQUIRE_ENCRYPTION)
  set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal.cc)
  # Encryption key management
  set(PARQUET_SRCS
      ${PARQUET_SRCS}
      encryption/crypto_factory.cc
      encryption/file_key_unwrapper.cc
      encryption/file_key_wrapper.cc
      encryption/kms_client.cc
      encryption/key_material.cc
      encryption/key_metadata.cc
      encryption/key_toolkit.cc
      encryption/key_toolkit_internal.cc
      encryption/local_wrap_kms_client.cc)
else()
  set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal_nossl.cc)
endif()

if(NOT PARQUET_MINIMAL_DEPENDENCY)
  set(PARQUET_SHARED_LINK_LIBS arrow_shared)

  # These are libraries that we will link privately with parquet_shared (as they
  # do not need to be linked transitively by other linkers)
  set(PARQUET_SHARED_PRIVATE_LINK_LIBS thrift::thrift)

  # Link publicly with parquet_static (because internal users need to
  # transitively link all dependencies)
  set(PARQUET_STATIC_LINK_LIBS ${PARQUET_STATIC_LINK_LIBS} thrift::thrift)

  # Although we don't link parquet_objlib against anything, we need it to depend
  # on these libs as we may generate their headers via ExternalProject_Add
  if(ARROW_BUILD_SHARED)
    set(PARQUET_DEPENDENCIES ${PARQUET_DEPENDENCIES} ${PARQUET_SHARED_LINK_LIBS}
                             ${PARQUET_SHARED_PRIVATE_LINK_LIBS})
  endif()

  if(ARROW_BUILD_STATIC)
    set(PARQUET_DEPENDENCIES ${PARQUET_DEPENDENCIES} ${PARQUET_STATIC_LINK_LIBS})
  endif()

endif(NOT PARQUET_MINIMAL_DEPENDENCY)

if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT)
  set(PARQUET_SHARED_LINK_FLAGS
      "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/symbols.map")
endif()

add_arrow_lib(parquet
              CMAKE_PACKAGE_NAME
              Parquet
              PKG_CONFIG_NAME
              parquet
              SOURCES
              ${PARQUET_SRCS}
              PRECOMPILED_HEADERS
              "$<$<COMPILE_LANGUAGE:CXX>:parquet/pch.h>"
              OUTPUTS
              PARQUET_LIBRARIES
              DEPENDENCIES
              ${PARQUET_DEPENDENCIES}
              SHARED_LINK_FLAGS
              ${PARQUET_SHARED_LINK_FLAGS}
              SHARED_LINK_LIBS
              ${PARQUET_SHARED_LINK_LIBS}
              SHARED_PRIVATE_LINK_LIBS
              ${PARQUET_SHARED_PRIVATE_LINK_LIBS}
              STATIC_LINK_LIBS
              ${PARQUET_STATIC_LINK_LIBS})

if(WIN32 AND NOT (ARROW_TEST_LINKAGE STREQUAL "static"))
  add_library(parquet_test_support STATIC
              "${ARROW_SOURCE_DIR}/src/generated/parquet_constants.cpp"
              "${ARROW_SOURCE_DIR}/src/generated/parquet_types.cpp")
  add_dependencies(parquet_test_support thrift::thrift)
  set(PARQUET_SHARED_TEST_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS} parquet_test_support)
  set(PARQUET_LIBRARIES ${PARQUET_LIBRARIES} parquet_test_support)
endif()

if(NOT ARROW_BUILD_SHARED)
  set(PARQUET_BENCHMARK_LINK_OPTION STATIC_LINK_LIBS benchmark::benchmark_main
                                    ${PARQUET_STATIC_TEST_LINK_LIBS})
else()
  set(PARQUET_BENCHMARK_LINK_OPTION EXTRA_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS})
endif()

if(ARROW_BUILD_STATIC AND WIN32)
  # ARROW-4848: Static Parquet lib needs to import static symbols on Windows
  target_compile_definitions(parquet_static PUBLIC ARROW_STATIC)
endif()

add_dependencies(parquet ${PARQUET_LIBRARIES} thrift::thrift)

add_definitions(-DPARQUET_THRIFT_VERSION_MAJOR=${THRIFT_VERSION_MAJOR})
add_definitions(-DPARQUET_THRIFT_VERSION_MINOR=${THRIFT_VERSION_MINOR})

# Thrift requires these definitions for some types that we use
foreach(LIB_TARGET ${PARQUET_LIBRARIES})
  target_compile_definitions(${LIB_TARGET}
                             PRIVATE PARQUET_EXPORTING
                             PRIVATE HAVE_INTTYPES_H
                             PRIVATE HAVE_NETDB_H)
  if(WIN32)
    target_compile_definitions(${LIB_TARGET} PRIVATE NOMINMAX)
  else()
    target_compile_definitions(${LIB_TARGET} PRIVATE HAVE_NETINET_IN_H)
  endif()
endforeach()

if(WIN32 AND ARROW_BUILD_STATIC)
  target_compile_definitions(parquet_static PUBLIC PARQUET_STATIC)
endif()

add_subdirectory(api)
add_subdirectory(arrow)
add_subdirectory(encryption)

arrow_install_all_headers("parquet")

configure_file(parquet_version.h.in "${CMAKE_CURRENT_BINARY_DIR}/parquet_version.h" @ONLY)

install(FILES "${CMAKE_CURRENT_BINARY_DIR}/parquet_version.h"
        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/parquet")

add_parquet_test(internals-test
                 SOURCES
                 bloom_filter_test.cc
                 properties_test.cc
                 statistics_test.cc
                 encoding_test.cc
                 metadata_test.cc
                 public_api_test.cc
                 types_test.cc
                 test_util.cc)

set_source_files_properties(public_api_test.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                                          SKIP_UNITY_BUILD_INCLUSION ON)

add_parquet_test(reader-test
                 SOURCES
                 column_reader_test.cc
                 level_conversion_test.cc
                 column_scanner_test.cc
                 reader_test.cc
                 stream_reader_test.cc
                 test_util.cc)

add_parquet_test(writer-test
                 SOURCES
                 column_writer_test.cc
                 file_serialize_test.cc
                 stream_writer_test.cc
                 test_util.cc)

add_parquet_test(arrow-test
                 SOURCES
                 arrow/arrow_reader_writer_test.cc
                 arrow/arrow_schema_test.cc
                 arrow/arrow_statistics_test.cc
                 test_util.cc)

add_parquet_test(arrow-internals-test
                 SOURCES
                 arrow/path_internal_test.cc
                 arrow/reconstruct_internal_test.cc
                 test_util.cc)

if(PARQUET_REQUIRE_ENCRYPTION)
  add_parquet_test(encryption-test
                   SOURCES
                   encryption/write_configurations_test.cc
                   encryption/read_configurations_test.cc
                   encryption/properties_test.cc
                   encryption/test_encryption_util.cc
                   test_util.cc)
  add_parquet_test(encryption-key-management-test
                   SOURCES
                   encryption/key_management_test.cc
                   encryption/key_metadata_test.cc
                   encryption/key_wrapping_test.cc
                   encryption/test_encryption_util.cc
                   encryption/test_in_memory_kms.cc
                   encryption/two_level_cache_with_expiration_test.cc
                   test_util.cc)
endif()

# Those tests need to use static linking as they access thrift-generated
# symbols which are not exported by parquet.dll on Windows (PARQUET-1420).
add_parquet_test(file_deserialize_test SOURCES file_deserialize_test.cc test_util.cc)
add_parquet_test(schema_test)

add_parquet_benchmark(column_io_benchmark)
add_parquet_benchmark(encoding_benchmark)
add_parquet_benchmark(level_conversion_benchmark)
add_parquet_benchmark(arrow/reader_writer_benchmark PREFIX "parquet-arrow")

if(ARROW_WITH_BROTLI)
  add_definitions(-DARROW_WITH_BROTLI)
endif()

if(ARROW_WITH_BZ2)
  add_definitions(-DARROW_WITH_BZ2)
endif()

if(ARROW_WITH_LZ4)
  add_definitions(-DARROW_WITH_LZ4)
endif()

if(ARROW_WITH_SNAPPY)
  add_definitions(-DARROW_WITH_SNAPPY)
endif()

if(ARROW_WITH_ZLIB)
  add_definitions(-DARROW_WITH_ZLIB)
endif()

if(ARROW_WITH_ZSTD)
  add_definitions(-DARROW_WITH_ZSTD)
endif()

if(ARROW_CSV)
  add_definitions(-DARROW_CSV)
endif()
Commit	Line	Data
1d09f67e TL	1	# Licensed to the Apache Software Foundation (ASF) under one
	2	# or more contributor license agreements. See the NOTICE file
	3	# distributed with this work for additional information
	4	# regarding copyright ownership. The ASF licenses this file
	5	# to you under the Apache License, Version 2.0 (the
	6	# "License"); you may not use this file except in compliance
	7	# with the License. You may obtain a copy of the License at
	8	#
	9	# http://www.apache.org/licenses/LICENSE-2.0
	10	#
	11	# Unless required by applicable law or agreed to in writing,
	12	# software distributed under the License is distributed on an
	13	# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	14	# KIND, either express or implied. See the License for the
	15	# specific language governing permissions and limitations
	16	# under the License.
	17
	18	add_custom_target(parquet-all)
	19	add_custom_target(parquet)
	20	add_custom_target(parquet-benchmarks)
	21	add_custom_target(parquet-tests)
	22	add_dependencies(parquet-all parquet parquet-tests parquet-benchmarks)
	23
	24	function(ADD_PARQUET_TEST REL_TEST_NAME)
	25	set(one_value_args)
	26	set(multi_value_args EXTRA_DEPENDENCIES LABELS)
	27	cmake_parse_arguments(ARG
	28	"${options}"
	29	"${one_value_args}"
	30	"${multi_value_args}"
	31	${ARGN})
	32
	33	set(TEST_ARGUMENTS PREFIX "parquet" LABELS "parquet-tests")
	34
	35	if(ARROW_TEST_LINKAGE STREQUAL "static")
	36	add_test_case(${REL_TEST_NAME}
	37	STATIC_LINK_LIBS
	38	${PARQUET_STATIC_TEST_LINK_LIBS}
	39	${TEST_ARGUMENTS}
	40	${ARG_UNPARSED_ARGUMENTS})
	41	else()
	42	add_test_case(${REL_TEST_NAME}
	43	STATIC_LINK_LIBS
	44	${PARQUET_SHARED_TEST_LINK_LIBS}
	45	${TEST_ARGUMENTS}
	46	${ARG_UNPARSED_ARGUMENTS})
	47	endif()
	48	endfunction()
	49
	50	function(ADD_PARQUET_FUZZ_TARGET REL_FUZZING_NAME)
	51	set(options)
	52	set(one_value_args PREFIX)
	53	set(multi_value_args)
	54	cmake_parse_arguments(ARG
	55	"${options}"
	56	"${one_value_args}"
	57	"${multi_value_args}"
	58	${ARGN})
	59
	60	if(ARG_PREFIX)
	61	set(PREFIX ${ARG_PREFIX})
	62	else()
	63	set(PREFIX "parquet")
	64	endif()
65
66	if(ARROW_BUILD_STATIC)
67	set(LINK_LIBS parquet_static)
68	else()
69	set(LINK_LIBS parquet_shared)
70	endif()
71	add_fuzz_target(${REL_FUZZING_NAME}
72	PREFIX
73	${PREFIX}
74	LINK_LIBS
75	${LINK_LIBS}
76	${ARG_UNPARSED_ARGUMENTS})
77	endfunction()
78
79	function(ADD_PARQUET_BENCHMARK REL_TEST_NAME)
80	set(options)
81	set(one_value_args PREFIX)
82	set(multi_value_args)
83	cmake_parse_arguments(ARG
84	"${options}"
85	"${one_value_args}"
86	"${multi_value_args}"
87	${ARGN})
88	if(ARG_PREFIX)
89	set(PREFIX ${ARG_PREFIX})
90	else()
91	set(PREFIX "parquet")
92	endif()
93	add_benchmark(${REL_TEST_NAME}
94	PREFIX
95	${PREFIX}
96	LABELS
97	"parquet-benchmarks"
98	${PARQUET_BENCHMARK_LINK_OPTION}
99	${ARG_UNPARSED_ARGUMENTS})
100	endfunction()
101
102	# ----------------------------------------------------------------------
103	# Link libraries setup
104
105	# TODO(wesm): Handling of ABI/SO version
106
107	if(ARROW_BUILD_STATIC)
108	set(PARQUET_STATIC_LINK_LIBS arrow_static)
109	set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_static arrow_static)
110	else()
111	set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
112	endif()
113
114	set(PARQUET_MIN_TEST_LIBS GTest::gtest_main GTest::gtest)
115
116	if(APPLE)
117	set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} ${CMAKE_DL_LIBS})
118	elseif(NOT MSVC)
119	set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} pthread ${CMAKE_DL_LIBS})
120	endif()
121
122	set(PARQUET_SHARED_TEST_LINK_LIBS arrow_testing_shared ${PARQUET_MIN_TEST_LIBS}
123	parquet_shared thrift::thrift)
124
125	set(PARQUET_STATIC_TEST_LINK_LIBS ${PARQUET_MIN_TEST_LIBS} parquet_static thrift::thrift
126	${ARROW_LIBRARIES_FOR_STATIC_TESTS})
127
128	#
129	# Generated Thrift sources
130	set_source_files_properties(src/generated/parquet_types.cpp src/generated/parquet_types.h
131	src/generated/parquet_constants.cpp
132	src/generated/parquet_constants.h
133	PROPERTIES SKIP_PRECOMPILE_HEADERS ON
134	SKIP_UNITY_BUILD_INCLUSION ON)
135
136	if(NOT MSVC)
137	set_source_files_properties(src/parquet/parquet_types.cpp
138	PROPERTIES COMPILE_FLAGS -Wno-unused-variable)
139	endif()
140
141	#
142	# Library config
143
144	set(PARQUET_SRCS
145	arrow/path_internal.cc
146	arrow/reader.cc
147	arrow/reader_internal.cc
148	arrow/schema.cc
149	arrow/schema_internal.cc
150	arrow/writer.cc
151	bloom_filter.cc
152	column_reader.cc
153	column_scanner.cc
154	column_writer.cc
155	encoding.cc
156	encryption/encryption.cc
157	encryption/internal_file_decryptor.cc
158	encryption/internal_file_encryptor.cc
159	exception.cc
160	file_reader.cc
161	file_writer.cc
162	level_comparison.cc
163	level_conversion.cc
164	metadata.cc
165	murmur3.cc
166	"${ARROW_SOURCE_DIR}/src/generated/parquet_constants.cpp"
167	"${ARROW_SOURCE_DIR}/src/generated/parquet_types.cpp"
168	platform.cc
169	printer.cc
170	properties.cc
171	schema.cc
172	statistics.cc
173	stream_reader.cc
174	stream_writer.cc
175	types.cc)
176
177	if(ARROW_HAVE_RUNTIME_AVX2)
178	# AVX2 is used as a proxy for BMI2.
179	list(APPEND PARQUET_SRCS level_comparison_avx2.cc level_conversion_bmi2.cc)
180	set_source_files_properties(level_comparison_avx2.cc
181	PROPERTIES SKIP_PRECOMPILE_HEADERS ON COMPILE_FLAGS
182	"${ARROW_AVX2_FLAG}")
183	# WARNING: DO NOT BLINDLY COPY THIS CODE FOR OTHER BMI2 USE CASES.
184	# This code is always guarded by runtime dispatch which verifies
185	# BMI2 is present. For a very small number of CPUs AVX2 does not
186	# imply BMI2.
187	set_source_files_properties(level_conversion_bmi2.cc
188	PROPERTIES SKIP_PRECOMPILE_HEADERS ON
189	COMPILE_FLAGS
190	"${ARROW_AVX2_FLAG} -DARROW_HAVE_BMI2 -mbmi2")
191	endif()
192
193	if(PARQUET_REQUIRE_ENCRYPTION)
194	set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal.cc)
195	# Encryption key management
196	set(PARQUET_SRCS
197	${PARQUET_SRCS}
198	encryption/crypto_factory.cc
199	encryption/file_key_unwrapper.cc
200	encryption/file_key_wrapper.cc
201	encryption/kms_client.cc
202	encryption/key_material.cc
203	encryption/key_metadata.cc
204	encryption/key_toolkit.cc
205	encryption/key_toolkit_internal.cc
206	encryption/local_wrap_kms_client.cc)
207	else()
208	set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal_nossl.cc)
209	endif()
210
211	if(NOT PARQUET_MINIMAL_DEPENDENCY)
212	set(PARQUET_SHARED_LINK_LIBS arrow_shared)
213
214	# These are libraries that we will link privately with parquet_shared (as they
215	# do not need to be linked transitively by other linkers)
216	set(PARQUET_SHARED_PRIVATE_LINK_LIBS thrift::thrift)
217
218	# Link publicly with parquet_static (because internal users need to
219	# transitively link all dependencies)
220	set(PARQUET_STATIC_LINK_LIBS ${PARQUET_STATIC_LINK_LIBS} thrift::thrift)
221
222	# Although we don't link parquet_objlib against anything, we need it to depend
223	# on these libs as we may generate their headers via ExternalProject_Add
224	if(ARROW_BUILD_SHARED)
225	set(PARQUET_DEPENDENCIES ${PARQUET_DEPENDENCIES} ${PARQUET_SHARED_LINK_LIBS}
226	${PARQUET_SHARED_PRIVATE_LINK_LIBS})
227	endif()
228
229	if(ARROW_BUILD_STATIC)
230	set(PARQUET_DEPENDENCIES ${PARQUET_DEPENDENCIES} ${PARQUET_STATIC_LINK_LIBS})
231	endif()
232
233	endif(NOT PARQUET_MINIMAL_DEPENDENCY)
234
235	if(CXX_LINKER_SUPPORTS_VERSION_SCRIPT)
236	set(PARQUET_SHARED_LINK_FLAGS
237	"-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/symbols.map")
238	endif()
239
240	add_arrow_lib(parquet
241	CMAKE_PACKAGE_NAME
242	Parquet
243	PKG_CONFIG_NAME
244	parquet
245	SOURCES
246	${PARQUET_SRCS}
247	PRECOMPILED_HEADERS
248	"$<$<COMPILE_LANGUAGE:CXX>:parquet/pch.h>"
249	OUTPUTS
250	PARQUET_LIBRARIES
251	DEPENDENCIES
252	${PARQUET_DEPENDENCIES}
253	SHARED_LINK_FLAGS
254	${PARQUET_SHARED_LINK_FLAGS}
255	SHARED_LINK_LIBS
256	${PARQUET_SHARED_LINK_LIBS}
257	SHARED_PRIVATE_LINK_LIBS
258	${PARQUET_SHARED_PRIVATE_LINK_LIBS}
259	STATIC_LINK_LIBS
260	${PARQUET_STATIC_LINK_LIBS})
261
262	if(WIN32 AND NOT (ARROW_TEST_LINKAGE STREQUAL "static"))
263	add_library(parquet_test_support STATIC
264	"${ARROW_SOURCE_DIR}/src/generated/parquet_constants.cpp"
265	"${ARROW_SOURCE_DIR}/src/generated/parquet_types.cpp")
266	add_dependencies(parquet_test_support thrift::thrift)
267	set(PARQUET_SHARED_TEST_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS} parquet_test_support)
268	set(PARQUET_LIBRARIES ${PARQUET_LIBRARIES} parquet_test_support)
269	endif()
270
271	if(NOT ARROW_BUILD_SHARED)
272	set(PARQUET_BENCHMARK_LINK_OPTION STATIC_LINK_LIBS benchmark::benchmark_main
273	${PARQUET_STATIC_TEST_LINK_LIBS})
274	else()
275	set(PARQUET_BENCHMARK_LINK_OPTION EXTRA_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS})
276	endif()
277
278	if(ARROW_BUILD_STATIC AND WIN32)
279	# ARROW-4848: Static Parquet lib needs to import static symbols on Windows
280	target_compile_definitions(parquet_static PUBLIC ARROW_STATIC)
281	endif()
282
283	add_dependencies(parquet ${PARQUET_LIBRARIES} thrift::thrift)
284
285	add_definitions(-DPARQUET_THRIFT_VERSION_MAJOR=${THRIFT_VERSION_MAJOR})
286	add_definitions(-DPARQUET_THRIFT_VERSION_MINOR=${THRIFT_VERSION_MINOR})
287
288	# Thrift requires these definitions for some types that we use
289	foreach(LIB_TARGET ${PARQUET_LIBRARIES})
290	target_compile_definitions(${LIB_TARGET}
291	PRIVATE PARQUET_EXPORTING
292	PRIVATE HAVE_INTTYPES_H
293	PRIVATE HAVE_NETDB_H)
294	if(WIN32)
295	target_compile_definitions(${LIB_TARGET} PRIVATE NOMINMAX)
296	else()
297	target_compile_definitions(${LIB_TARGET} PRIVATE HAVE_NETINET_IN_H)
298	endif()
299	endforeach()
300
301	if(WIN32 AND ARROW_BUILD_STATIC)
302	target_compile_definitions(parquet_static PUBLIC PARQUET_STATIC)
303	endif()
304
305	add_subdirectory(api)
306	add_subdirectory(arrow)
307	add_subdirectory(encryption)
308
309	arrow_install_all_headers("parquet")
310
311	configure_file(parquet_version.h.in "${CMAKE_CURRENT_BINARY_DIR}/parquet_version.h" @ONLY)
312
313	install(FILES "${CMAKE_CURRENT_BINARY_DIR}/parquet_version.h"
314	DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/parquet")
315
316	add_parquet_test(internals-test
317	SOURCES
318	bloom_filter_test.cc
319	properties_test.cc
320	statistics_test.cc
321	encoding_test.cc
322	metadata_test.cc
323	public_api_test.cc
324	types_test.cc
325	test_util.cc)
326
327	set_source_files_properties(public_api_test.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON
328	SKIP_UNITY_BUILD_INCLUSION ON)
329
330	add_parquet_test(reader-test
331	SOURCES
332	column_reader_test.cc
333	level_conversion_test.cc
334	column_scanner_test.cc
335	reader_test.cc
336	stream_reader_test.cc
337	test_util.cc)
338
339	add_parquet_test(writer-test
340	SOURCES
341	column_writer_test.cc
342	file_serialize_test.cc
343	stream_writer_test.cc
344	test_util.cc)
345
346	add_parquet_test(arrow-test
347	SOURCES
348	arrow/arrow_reader_writer_test.cc
349	arrow/arrow_schema_test.cc
350	arrow/arrow_statistics_test.cc
351	test_util.cc)
352
353	add_parquet_test(arrow-internals-test
354	SOURCES
355	arrow/path_internal_test.cc
356	arrow/reconstruct_internal_test.cc
357	test_util.cc)
358
359	if(PARQUET_REQUIRE_ENCRYPTION)
360	add_parquet_test(encryption-test
361	SOURCES
362	encryption/write_configurations_test.cc
363	encryption/read_configurations_test.cc
364	encryption/properties_test.cc
365	encryption/test_encryption_util.cc
366	test_util.cc)
367	add_parquet_test(encryption-key-management-test
368	SOURCES
369	encryption/key_management_test.cc
370	encryption/key_metadata_test.cc
371	encryption/key_wrapping_test.cc
372	encryption/test_encryption_util.cc
373	encryption/test_in_memory_kms.cc
374	encryption/two_level_cache_with_expiration_test.cc
375	test_util.cc)
376	endif()
377
378	# Those tests need to use static linking as they access thrift-generated
379	# symbols which are not exported by parquet.dll on Windows (PARQUET-1420).
380	add_parquet_test(file_deserialize_test SOURCES file_deserialize_test.cc test_util.cc)
381	add_parquet_test(schema_test)
382
383	add_parquet_benchmark(column_io_benchmark)
384	add_parquet_benchmark(encoding_benchmark)
385	add_parquet_benchmark(level_conversion_benchmark)
386	add_parquet_benchmark(arrow/reader_writer_benchmark PREFIX "parquet-arrow")
387
388	if(ARROW_WITH_BROTLI)
389	add_definitions(-DARROW_WITH_BROTLI)
390	endif()
391
392	if(ARROW_WITH_BZ2)
393	add_definitions(-DARROW_WITH_BZ2)
394	endif()
395
396	if(ARROW_WITH_LZ4)
397	add_definitions(-DARROW_WITH_LZ4)
398	endif()
399
400	if(ARROW_WITH_SNAPPY)
401	add_definitions(-DARROW_WITH_SNAPPY)
402	endif()
403
404	if(ARROW_WITH_ZLIB)
405	add_definitions(-DARROW_WITH_ZLIB)
406	endif()
407
408	if(ARROW_WITH_ZSTD)
409	add_definitions(-DARROW_WITH_ZSTD)
410	endif()
411
412	if(ARROW_CSV)
413	add_definitions(-DARROW_CSV)
414	endif()