bump to 1.6.6

1 files changed, 745 insertions, 0 deletions

diff --git a/541.patch b/541.patch
new file mode 100644
index 000000000000..fc7327a2f887
--- /dev/null
+++ b/541.patch
@@ -0,0 +1,745 @@
+From 8c6406b01cf0c9e144466651c9fe7d833a2c5ca4 Mon Sep 17 00:00:00 2001
+From: Nehal J Wani <nehaljw.kkd1@gmail.com>
+Date: Sat, 29 Aug 2020 13:37:21 -0400
+Subject: [PATCH] Partially rework cmake modules to accommodate library types
+
+This patch allows selectively linking each third party library
+statically with a fallback to dynamic, if not available
+---
+ c++/src/CMakeLists.txt                  |  17 ++--
+ c++/test/CMakeLists.txt                 |  16 ++--
+ cmake_modules/FindGTest.cmake           |  37 ++++++--
+ cmake_modules/FindLZ4.cmake             |  21 +++--
+ cmake_modules/FindProtobuf.cmake        |  27 ++++--
+ cmake_modules/FindSnappy.cmake          |  21 +++--
+ cmake_modules/FindZLIB.cmake            |  20 ++--
+ cmake_modules/FindZSTD.cmake            |  24 ++---
+ cmake_modules/ThirdpartyToolchain.cmake | 118 +++++++++++++++++-------
+ tools/src/CMakeLists.txt                |   3 +-
+ tools/test/CMakeLists.txt               |  11 +--
+ 11 files changed, 200 insertions(+), 115 deletions(-)
+
+diff --git a/c++/src/CMakeLists.txt b/c++/src/CMakeLists.txt
+index 7ff543dd78..772f4c6671 100644
+--- a/c++/src/CMakeLists.txt
++++ b/c++/src/CMakeLists.txt
+@@ -155,7 +155,7 @@ CHECK_CXX_SOURCE_RUNS("
+ )
+ 
+ set(CMAKE_REQUIRED_INCLUDES ${ZLIB_INCLUDE_DIR})
+-set(CMAKE_REQUIRED_LIBRARIES zlib)
++set(CMAKE_REQUIRED_LIBRARIES orc_zlib)
+ CHECK_CXX_SOURCE_COMPILES("
+     #define Z_PREFIX
+     #include<zlib.h>
+@@ -174,12 +174,7 @@ configure_file (
+ include_directories (
+   ${CMAKE_CURRENT_SOURCE_DIR}
+   ${CMAKE_CURRENT_BINARY_DIR}
+-  ${PROTOBUF_INCLUDE_DIR}
+-  ${ZLIB_INCLUDE_DIR}
+-  ${SNAPPY_INCLUDE_DIR}
+-  ${LZ4_INCLUDE_DIR}
+   ${LIBHDFSPP_INCLUDE_DIR}
+-  ${ZSTD_INCLUDE_DIR}
+   )
+ 
+ add_custom_command(OUTPUT orc_proto.pb.h orc_proto.pb.cc
+@@ -236,11 +231,11 @@ endif(BUILD_LIBHDFSPP)
+ add_library (orc STATIC ${SOURCE_FILES})
+ 
+ target_link_libraries (orc
+-  protobuf
+-  zlib
+-  snappy
+-  lz4
+-  zstd
++  orc::protobuf
++  orc::zlib
++  orc::snappy
++  orc::lz4
++  orc::zstd
+   ${LIBHDFSPP_LIBRARIES}
+   )
+ 
+diff --git a/c++/test/CMakeLists.txt b/c++/test/CMakeLists.txt
+index ae4b807b16..da5ef577a6 100644
+--- a/c++/test/CMakeLists.txt
++++ b/c++/test/CMakeLists.txt
+@@ -14,10 +14,6 @@ include_directories(
+   ${PROJECT_SOURCE_DIR}/c++/src
+   ${PROJECT_BINARY_DIR}/c++/include
+   ${PROJECT_BINARY_DIR}/c++/src
+-  ${PROTOBUF_INCLUDE_DIR}
+-  ${ZLIB_INCLUDE_DIR}
+-  ${SNAPPY_INCLUDE_DIR}
+-  ${GTEST_INCLUDE_DIR}
+ )
+ 
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_FLAGS} ${WARN_FLAGS}")
+@@ -54,11 +50,11 @@ add_executable (orc-test
+ 
+ target_link_libraries (orc-test
+   orc
+-  lz4
+-  protobuf
+-  snappy
+-  zlib
+-  ${GTEST_LIBRARIES}
++  orc::lz4
++  orc::protobuf
++  orc::snappy
++  orc::zlib
++  orc::gmock
+ )
+ 
+ add_executable (create-test-files
+@@ -67,7 +63,7 @@ add_executable (create-test-files
+ 
+ target_link_libraries (create-test-files
+   orc
+-  protobuf
++  orc::protobuf
+ )
+ 
+ if (TEST_VALGRIND_MEMCHECK)
+diff --git a/cmake_modules/FindGTest.cmake b/cmake_modules/FindGTest.cmake
+index 3ae8954324..c1326ea5f0 100644
+--- a/cmake_modules/FindGTest.cmake
++++ b/cmake_modules/FindGTest.cmake
+@@ -13,8 +13,10 @@
+ # GTEST_HOME environmental variable is used to check for GTest headers and static library
+ 
+ # GTEST_INCLUDE_DIR: directory containing headers
+-# GTEST_LIBS: directory containing gtest libraries
++# GMOCK_LIBRARY: path to libgmock
++# GTEST_LIBRARY: path to libgtest
+ # GMOCK_STATIC_LIB: is set to gmock.a static library
++# GTEST_STATIC_LIB: is set to gtest.a static library
+ # GTEST_FOUND is set if GTEST is found
+ 
+ if (NOT "${GTEST_HOME}" STREQUAL "")
+@@ -28,24 +30,40 @@ find_path (GTEST_INCLUDE_DIR gmock/gmock.h HINTS
+   NO_DEFAULT_PATH
+   PATH_SUFFIXES "include")
+ 
+-find_library (GTEST_LIBRARIES NAMES gmock HINTS
++find_library (GMOCK_LIBRARY NAMES gmock HINTS
+   ${_gtest_path}
+   PATH_SUFFIXES "lib")
+ 
+-if (GTEST_INCLUDE_DIR AND GTEST_LIBRARIES)
++find_library (GTEST_LIBRARY NAMES gtest HINTS
++  ${_gtest_path}
++  PATH_SUFFIXES "lib")
++
++find_library (GMOCK_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}gmock${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_gtest_path}
++  PATH_SUFFIXES "lib")
++
++find_library (GTEST_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_gtest_path}
++  PATH_SUFFIXES "lib")
++
++if (GTEST_INCLUDE_DIR AND GMOCK_LIBRARY)
+   set (GTEST_FOUND TRUE)
+-  get_filename_component (GTEST_LIBS ${GTEST_LIBRARIES} PATH )
+   set (GTEST_HEADER_NAME gmock/gmock.h)
+   set (GTEST_HEADER ${GTEST_INCLUDE_DIR}/${GTEST_HEADER_NAME})
+-  set (GTEST_LIB_NAME gmock)
+-  set (GMOCK_STATIC_LIB ${GTEST_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${GTEST_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (GTEST_FOUND FALSE)
+ endif ()
+ 
+ if (GTEST_FOUND)
+   message (STATUS "Found the GTest header: ${GTEST_HEADER}")
+-  message (STATUS "Found the GTest library: ${GMOCK_STATIC_LIB}")
++  message (STATUS "Found the GTest library: ${GTEST_LIBRARY}")
++  message (STATUS "Found the GMock library: ${GMOCK_LIBRARY}")
++  if (GTEST_STATIC_LIB)
++    message (STATUS "Found the GTest static library: ${GTEST_STATIC_LIB}")
++  endif ()
++  if (GMOCK_STATIC_LIB)
++    message (STATUS "Found the GMock static library: ${GMOCK_STATIC_LIB}")
++  endif ()
+ else ()
+   if (_gtest_path)
+     set (GTEST_ERR_MSG "Could not find GTest. Looked in ${_gtest_path}.")
+@@ -63,6 +81,7 @@ endif ()
+ mark_as_advanced (
+   GTEST_INCLUDE_DIR
+   GMOCK_STATIC_LIB
+-  GTEST_LIBS
+-  GTEST_LIBRARIES
++  GTEST_STATIC_LIB
++  GMOCK_LIBRARY
++  GTEST_LIBRARY
+ )
+diff --git a/cmake_modules/FindLZ4.cmake b/cmake_modules/FindLZ4.cmake
+index e522a6f76a..f57984940a 100644
+--- a/cmake_modules/FindLZ4.cmake
++++ b/cmake_modules/FindLZ4.cmake
+@@ -13,7 +13,7 @@
+ # LZ4_HOME environment variable is used to check for LZ4 headers and static library
+ 
+ # LZ4_INCLUDE_DIR: directory containing headers
+-# LZ4_LIBS: directory containing LZ4 libraries
++# LZ4_LIBRARY: path to liblz4
+ # LZ4_STATIC_LIB: path to lz4.a
+ # LZ4_FOUND: whether LZ4 has been found
+ 
+@@ -28,24 +28,28 @@ find_path (LZ4_INCLUDE_DIR lz4.h HINTS
+   NO_DEFAULT_PATH
+   PATH_SUFFIXES "include")
+ 
+-find_library (LZ4_LIBRARIES NAMES lz4 HINTS
++find_library (LZ4_LIBRARY NAMES lz4 HINTS
+   ${_lz4_path}
+   PATH_SUFFIXES "lib" "lib64")
+ 
+-if (LZ4_INCLUDE_DIR AND LZ4_LIBRARIES)
++find_library (LZ4_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_lz4_path}
++  PATH_SUFFIXES "lib" "lib64")
++
++if (LZ4_INCLUDE_DIR AND LZ4_LIBRARY)
+   set (LZ4_FOUND TRUE)
+-  get_filename_component (LZ4_LIBS ${LZ4_LIBRARIES} PATH)
+   set (LZ4_HEADER_NAME lz4.h)
+   set (LZ4_HEADER ${LZ4_INCLUDE_DIR}/${LZ4_HEADER_NAME})
+-  set (LZ4_LIB_NAME lz4)
+-  set (LZ4_STATIC_LIB ${LZ4_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (LZ4_FOUND FALSE)
+ endif ()
+ 
+ if (LZ4_FOUND)
+   message (STATUS "Found the LZ4 header: ${LZ4_HEADER}")
+-  message (STATUS "Found the LZ4 library: ${LZ4_STATIC_LIB}")
++  message (STATUS "Found the LZ4 library: ${LZ4_LIBRARY}")
++  if (LZ4_STATIC_LIB)
++    message (STATUS "Found the LZ4 static library: ${LZ4_STATIC_LIB}")
++  endif ()
+ else()
+   if (_lz4_path)
+     set (LZ4_ERR_MSG "Could not find LZ4. Looked in ${_lz4_path}.")
+@@ -63,6 +67,5 @@ endif()
+ mark_as_advanced (
+   LZ4_INCLUDE_DIR
+   LZ4_STATIC_LIB
+-  LZ4_LIBS
+-  LZ4_LIBRARIES
++  LZ4_LIBRARY
+ )
+diff --git a/cmake_modules/FindProtobuf.cmake b/cmake_modules/FindProtobuf.cmake
+index d901c55a10..f2b6a7ca91 100644
+--- a/cmake_modules/FindProtobuf.cmake
++++ b/cmake_modules/FindProtobuf.cmake
+@@ -14,8 +14,9 @@
+ 
+ # PROTOBUF_FOUND is set if Protobuf is found
+ # PROTOBUF_INCLUDE_DIR: directory containing headers
+-# PROTOBUF_LIBS: directory containing Protobuf libraries
++# PROTOBUF_LIBRARY: location of libprotobuf
+ # PROTOBUF_STATIC_LIB: location of protobuf.a
++# PROTOC_LIBRARY: location of libprotoc
+ # PROTOC_STATIC_LIB: location of protoc.a
+ # PROTOBUF_EXECUTABLE: location of protoc
+ 
+@@ -40,10 +41,18 @@ find_library (PROTOBUF_LIBRARY NAMES protobuf HINTS
+   ${_protobuf_path}
+   PATH_SUFFIXES "lib")
+ 
++find_library (PROTOBUF_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}protobuf${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_protobuf_path}
++  PATH_SUFFIXES "lib")
++
+ find_library (PROTOC_LIBRARY NAMES protoc HINTS
+   ${_protobuf_path}
+   PATH_SUFFIXES "lib")
+ 
++find_library (PROTOC_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}protoc${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_protobuf_path}
++  PATH_SUFFIXES "lib")
++
+ find_program(PROTOBUF_EXECUTABLE protoc HINTS
+   ${_protobuf_path}
+   NO_DEFAULT_PATH
+@@ -51,20 +60,23 @@ find_program(PROTOBUF_EXECUTABLE protoc HINTS
+ 
+ if (PROTOBUF_INCLUDE_DIR AND PROTOBUF_LIBRARY AND PROTOC_LIBRARY AND PROTOBUF_EXECUTABLE)
+   set (PROTOBUF_FOUND TRUE)
+-  get_filename_component (PROTOBUF_LIBS ${PROTOBUF_LIBRARY} PATH)
+   set (PROTOBUF_LIB_NAME protobuf)
+   set (PROTOC_LIB_NAME protoc)
+-  set (PROTOBUF_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOBUF_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+-  set (PROTOC_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (PROTOBUF_FOUND FALSE)
+ endif ()
+ 
+ if (PROTOBUF_FOUND)
+   message (STATUS "Found the Protobuf headers: ${PROTOBUF_INCLUDE_DIR}")
+-  message (STATUS "Found the Protobuf library: ${PROTOBUF_STATIC_LIB}")
+-  message (STATUS "Found the Protoc library: ${PROTOC_STATIC_LIB}")
++  message (STATUS "Found the Protobuf library: ${PROTOBUF_LIBRARY}")
++  message (STATUS "Found the Protoc library: ${PROTOC_LIBRARY}")
+   message (STATUS "Found the Protoc executable: ${PROTOBUF_EXECUTABLE}")
++  if (PROTOBUF_STATIC_LIB)
++     message (STATUS "Found the Protobuf static library: ${PROTOBUF_STATIC_LIB}")
++  endif ()
++  if (PROTOC_STATIC_LIB)
++     message (STATUS "Found the Protoc static library: ${PROTOC_STATIC_LIB}")
++  endif ()
+ else()
+   if (_protobuf_path)
+     set (PROTOBUF_ERR_MSG "Could not find Protobuf. Looked in ${_protobuf_path}.")
+@@ -81,7 +93,8 @@ endif()
+ 
+ mark_as_advanced (
+   PROTOBUF_INCLUDE_DIR
+-  PROTOBUF_LIBS
++  PROTOBUF_LIBRARY
+   PROTOBUF_STATIC_LIB
+   PROTOC_STATIC_LIB
++  PROTOC_LIBRARY
+ )
+diff --git a/cmake_modules/FindSnappy.cmake b/cmake_modules/FindSnappy.cmake
+index 5aeb88e78c..a834dd0ddf 100644
+--- a/cmake_modules/FindSnappy.cmake
++++ b/cmake_modules/FindSnappy.cmake
+@@ -13,7 +13,7 @@
+ # SNAPPY_HOME environmental variable is used to check for Snappy headers and static library
+ 
+ # SNAPPY_INCLUDE_DIR: directory containing headers
+-# SNAPPY_LIBS: directory containing snappy libraries
++# SNAPPY_LIBRARY: path to libsnappy
+ # SNAPPY_STATIC_LIB: path to libsnappy.a
+ # SNAPPY_FOUND: whether snappy has been found
+ 
+@@ -28,24 +28,28 @@ find_path (SNAPPY_INCLUDE_DIR snappy.h HINTS
+   NO_DEFAULT_PATH
+   PATH_SUFFIXES "include")
+ 
+-find_library (SNAPPY_LIBRARIES NAMES snappy HINTS
++find_library (SNAPPY_LIBRARY NAMES snappy HINTS
+   ${_snappy_path}
+   PATH_SUFFIXES "lib" "lib64")
+ 
+-if (SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARIES)
++find_library (SNAPPY_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_snappy_path}
++  PATH_SUFFIXES "lib" "lib64")
++
++if (SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARY)
+   set (SNAPPY_FOUND TRUE)
+-  get_filename_component (SNAPPY_LIBS ${SNAPPY_LIBRARIES} PATH)
+   set (SNAPPY_HEADER_NAME snappy.h)
+   set (SNAPPY_HEADER ${SNAPPY_INCLUDE_DIR}/${SNAPPY_HEADER_NAME})
+-  set (SNAPPY_LIB_NAME snappy)
+-  set (SNAPPY_STATIC_LIB ${SNAPPY_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (SNAPPY_FOUND FALSE)
+ endif ()
+ 
+ if (SNAPPY_FOUND)
+   message (STATUS "Found the Snappy header: ${SNAPPY_HEADER}")
+-  message (STATUS "Found the Snappy library: ${SNAPPY_STATIC_LIB}")
++  message (STATUS "Found the Snappy library: ${SNAPPY_LIBRARY}")
++  if (SNAPPY_STATIC_LIB)
++      message (STATUS "Found the Snappy static library: ${SNAPPY_STATIC_LIB}")
++  endif()
+ else()
+   if (_snappy_path)
+     set (SNAPPY_ERR_MSG "Could not find Snappy. Looked in ${_snappy_path}.")
+@@ -63,6 +67,5 @@ endif()
+ mark_as_advanced (
+   SNAPPY_INCLUDE_DIR
+   SNAPPY_STATIC_LIB
+-  SNAPPY_LIBS
+-  SNAPPY_LIBRARIES
++  SNAPPY_LIBRARY
+ )
+diff --git a/cmake_modules/FindZLIB.cmake b/cmake_modules/FindZLIB.cmake
+index 6c09640e97..968d14821a 100644
+--- a/cmake_modules/FindZLIB.cmake
++++ b/cmake_modules/FindZLIB.cmake
+@@ -13,7 +13,7 @@
+ # ZLIB_HOME environmental variable is used to check for ZLIB headers and static library
+ 
+ # ZLIB_INCLUDE_DIR: directory containing headers
+-# ZLIB_LIBS: directory containing ZLIB libraries
++# ZLIB_LIBRARY: path to libz/libzlib
+ # ZLIB_STATIC_LIB: path to zlib.a
+ # ZLIB_FOUND: whether ZLIB has been found
+ 
+@@ -32,23 +32,28 @@ if (NOT ZLIB_STATIC_LIB_NAME)
+   set (ZLIB_STATIC_LIB_NAME z)
+ endif()
+ 
+-find_library (ZLIB_LIBRARIES NAMES ${ZLIB_STATIC_LIB_NAME} HINTS
++find_library (ZLIB_LIBRARY NAMES z zlib ${ZLIB_STATIC_LIB_NAME} HINTS
+   ${_zlib_path}
+   PATH_SUFFIXES "lib")
+ 
+-if (ZLIB_INCLUDE_DIR AND ZLIB_LIBRARIES)
++find_library (ZLIB_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}${ZLIB_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
++  ${_zlib_path}
++  PATH_SUFFIXES "lib")
++
++if (ZLIB_INCLUDE_DIR AND ZLIB_LIBRARY)
+   set (ZLIB_FOUND TRUE)
+-  get_filename_component (ZLIB_LIBS ${ZLIB_LIBRARIES} PATH )
+   set (ZLIB_HEADER_NAME zlib.h)
+   set (ZLIB_HEADER ${ZLIB_INCLUDE_DIR}/${ZLIB_HEADER_NAME})
+-  set (ZLIB_STATIC_LIB ${ZLIB_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${ZLIB_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (ZLIB_FOUND FALSE)
+ endif ()
+ 
+ if (ZLIB_FOUND)
+   message (STATUS "Found the ZLIB header: ${ZLIB_HEADER}")
+-  message (STATUS "Found the ZLIB library: ${ZLIB_STATIC_LIB}")
++  message (STATUS "Found the ZLIB library: ${ZLIB_LIBRARY}")
++  if (ZLIB_STATIC_LIB)
++    message (STATUS "Found the ZLIB static library: ${ZLIB_STATIC_LIB}")
++  endif ()
+ else()
+   if (_zlib_path)
+     set (ZLIB_ERR_MSG "Could not find ZLIB. Looked in ${_zlib_path}.")
+@@ -66,6 +71,5 @@ endif()
+ mark_as_advanced (
+   ZLIB_INCLUDE_DIR
+   ZLIB_STATIC_LIB
+-  ZLIB_LIBS
+-  ZLIB_LIBRARIES
++  ZLIB_LIBRARY
+ )
+diff --git a/cmake_modules/FindZSTD.cmake b/cmake_modules/FindZSTD.cmake
+index e0889769b8..02c5889a6c 100644
+--- a/cmake_modules/FindZSTD.cmake
++++ b/cmake_modules/FindZSTD.cmake
+@@ -13,7 +13,7 @@
+ # ZSTD_HOME environmental variable is used to check for Zstd headers and static library
+ 
+ # ZSTD_INCLUDE_DIR: directory containing headers
+-# ZSTD_LIBS: directory containing zstd libraries
++# ZSTD_LIBRARY: path to libzstd
+ # ZSTD_STATIC_LIB: path to libzstd.a
+ # ZSTD_FOUND: whether zstd has been found
+ 
+@@ -23,32 +23,33 @@ endif()
+ 
+ message (STATUS "ZSTD_HOME: ${ZSTD_HOME}")
+ 
+-if (NOT ZSTD_STATIC_LIB_NAME)
+-  set (ZSTD_STATIC_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}zstd)
+-endif()
+-
+ find_path (ZSTD_INCLUDE_DIR zstd.h HINTS
+         ${_zstd_path}
+         NO_DEFAULT_PATH
+         PATH_SUFFIXES "include")
+ 
+-find_library (ZSTD_LIBRARIES NAMES ${ZSTD_STATIC_LIB_NAME} HINTS
++find_library (ZSTD_LIBRARY NAMES zstd HINTS
++        ${_zstd_path}
++        PATH_SUFFIXES "lib")
++
++find_library (ZSTD_STATIC_LIB NAMES ${CMAKE_STATIC_LIBRARY_PREFIX}zstd${CMAKE_STATIC_LIBRARY_SUFFIX} HINTS
+         ${_zstd_path}
+         PATH_SUFFIXES "lib")
+ 
+-if (ZSTD_INCLUDE_DIR AND ZSTD_LIBRARIES)
++if (ZSTD_INCLUDE_DIR AND ZSTD_LIBRARY)
+   set (ZSTD_FOUND TRUE)
+-  get_filename_component (ZSTD_LIBS ${ZSTD_LIBRARIES} PATH)
+   set (ZSTD_HEADER_NAME zstd.h)
+   set (ZSTD_HEADER ${ZSTD_INCLUDE_DIR}/${ZSTD_HEADER_NAME})
+-  set (ZSTD_STATIC_LIB ${ZSTD_LIBS}/${ZSTD_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+ else ()
+   set (ZSTD_FOUND FALSE)
+ endif ()
+ 
+ if (ZSTD_FOUND)
+   message (STATUS "Found the zstd header: ${ZSTD_HEADER}")
+-  message (STATUS "Found the zstd library: ${ZSTD_STATIC_LIB}")
++  message (STATUS "Found the zstd library: ${ZSTD_LIBRARY}")
++  if (ZSTD_STATIC_LIB)
++    message (STATUS "Found the zstd static library: ${ZSTD_STATIC_LIB}")
++  endif ()
+ else()
+   if (_ZSTD_path)
+     set (ZSTD_ERR_MSG "Could not find zstd. Looked in ${_zstd_path}.")
+@@ -66,6 +67,5 @@ endif()
+ mark_as_advanced (
+         ZSTD_INCLUDE_DIR
+         ZSTD_STATIC_LIB
+-        ZSTD_LIBS
+-        ZSTD_LIBRARIES
++        ZSTD_LIBRARY
+ )
+diff --git a/cmake_modules/ThirdpartyToolchain.cmake b/cmake_modules/ThirdpartyToolchain.cmake
+index 3a35325796..f3e1089c5d 100644
+--- a/cmake_modules/ThirdpartyToolchain.cmake
++++ b/cmake_modules/ThirdpartyToolchain.cmake
+@@ -17,6 +17,13 @@ set(GTEST_VERSION "1.8.0")
+ set(PROTOBUF_VERSION "3.5.1")
+ set(ZSTD_VERSION "1.4.5")
+ 
++option(ORC_PREFER_STATIC_PROTOBUF "Prefer static protobuf library, if available" ON)
++option(ORC_PREFER_STATIC_SNAPPY   "Prefer static snappy library, if available"   ON)
++option(ORC_PREFER_STATIC_LZ4      "Prefer static lz4 library, if available"      ON)
++option(ORC_PREFER_STATIC_ZSTD     "Prefer static zstd library, if available"     ON)
++option(ORC_PREFER_STATIC_ZLIB     "Prefer static zlib library, if available"     ON)
++option(ORC_PREFER_STATIC_GMOCK    "Prefer static gmock library, if available"    ON)
++
+ # zstd requires us to add the threads
+ FIND_PACKAGE(Threads REQUIRED)
+ 
+@@ -75,15 +82,21 @@ else ()
+     ${THIRDPARTY_LOG_OPTIONS}
+     BUILD_BYPRODUCTS "${SNAPPY_STATIC_LIB}")
+ 
++  set(SNAPPY_LIBRARY ${SNAPPY_STATIC_LIB})
+   set(SNAPPY_VENDORED TRUE)
+ endif ()
+ 
+-include_directories (SYSTEM ${SNAPPY_INCLUDE_DIR})
+-add_library (snappy STATIC IMPORTED)
+-set_target_properties (snappy PROPERTIES IMPORTED_LOCATION ${SNAPPY_STATIC_LIB})
++add_library (orc_snappy INTERFACE)
++add_library (orc::snappy ALIAS orc_snappy)
++if (ORC_PREFER_STATIC_SNAPPY AND ${SNAPPY_STATIC_LIB})
++  target_link_libraries(orc_snappy INTERFACE ${SNAPPY_STATIC_LIB})
++else ()
++  target_link_libraries(orc_snappy INTERFACE ${SNAPPY_LIBRARY})
++endif ()
++target_include_directories (orc_snappy SYSTEM INTERFACE ${SNAPPY_INCLUDE_DIR})
+ 
+ if (SNAPPY_VENDORED)
+-  add_dependencies (snappy snappy_ep)
++  add_dependencies (orc_snappy snappy_ep)
+   if (INSTALL_VENDORED_LIBS)
+     install(FILES "${SNAPPY_STATIC_LIB}"
+             DESTINATION "lib")
+@@ -117,15 +130,21 @@ else ()
+     ${THIRDPARTY_LOG_OPTIONS}
+     BUILD_BYPRODUCTS "${ZLIB_STATIC_LIB}")
+ 
++  set(ZLIB_LIBRARY ${ZLIB_STATIC_LIB})
+   set(ZLIB_VENDORED TRUE)
+ endif ()
+ 
+-include_directories (SYSTEM ${ZLIB_INCLUDE_DIR})
+-add_library (zlib STATIC IMPORTED)
+-set_target_properties (zlib PROPERTIES IMPORTED_LOCATION ${ZLIB_STATIC_LIB})
++add_library (orc_zlib INTERFACE)
++add_library (orc::zlib ALIAS orc_zlib)
++if (ORC_PREFER_STATIC_ZLIB AND ${ZLIB_STATIC_LIB})
++  target_link_libraries (orc_zlib INTERFACE ${ZLIB_LIBRARY})
++else ()
++  target_link_libraries (orc_zlib INTERFACE ${ZLIB_STATIC_LIB})
++endif ()
++target_include_directories (orc_zlib SYSTEM INTERFACE ${ZLIB_INCLUDE_DIR})
+ 
+ if (ZLIB_VENDORED)
+-  add_dependencies (zlib zlib_ep)
++  add_dependencies (orc_zlib zlib_ep)
+   if (INSTALL_VENDORED_LIBS)
+     install(FILES "${ZLIB_STATIC_LIB}"
+             DESTINATION "lib")
+@@ -166,15 +185,21 @@ else ()
+           ${THIRDPARTY_LOG_OPTIONS}
+           BUILD_BYPRODUCTS ${ZSTD_STATIC_LIB})
+ 
++  set(ZSTD_LIBRARY ${ZSTD_STATIC_LIB})
+   set(ZSTD_VENDORED TRUE)
+ endif ()
+ 
+-include_directories (SYSTEM ${ZSTD_INCLUDE_DIR})
+-add_library (zstd STATIC IMPORTED)
+-set_target_properties (zstd PROPERTIES IMPORTED_LOCATION ${ZSTD_STATIC_LIB})
++add_library (orc_zstd INTERFACE)
++add_library (orc::zstd ALIAS orc_zstd)
++if (ORC_PREFER_STATIC_ZSTD AND ${ZSTD_STATIC_LIB})
++  target_link_libraries (orc_zstd INTERFACE ${ZSTD_STATIC_LIB})
++else ()
++  target_link_libraries (orc_zstd INTERFACE ${ZSTD_LIBRARY})
++endif ()
++target_include_directories (orc_zstd SYSTEM INTERFACE ${ZSTD_INCLUDE_DIR})
+ 
+ if (ZSTD_VENDORED)
+-  add_dependencies (zstd zstd_ep)
++  add_dependencies (orc_zstd zstd_ep)
+   if (INSTALL_VENDORED_LIBS)
+     install(FILES "${ZSTD_STATIC_LIB}"
+             DESTINATION "lib")
+@@ -208,15 +233,21 @@ else ()
+     ${THIRDPARTY_LOG_OPTIONS}
+     BUILD_BYPRODUCTS ${LZ4_STATIC_LIB})
+ 
++  set(LZ4_LIBRARY ${LZ4_STATIC_LIB})
+   set(LZ4_VENDORED TRUE)
+ endif ()
+ 
+-include_directories (SYSTEM ${LZ4_INCLUDE_DIR})
+-add_library (lz4 STATIC IMPORTED)
+-set_target_properties (lz4 PROPERTIES IMPORTED_LOCATION ${LZ4_STATIC_LIB})
++add_library (orc_lz4 INTERFACE)
++add_library (orc::lz4 ALIAS orc_lz4)
++if (ORC_PREFER_STATIC_LZ4 AND ${LZ4_STATIC_LIB})
++  target_link_libraries (orc_lz4 INTERFACE ${LZ4_STATIC_LIB})
++else ()
++  target_link_libraries (orc_lz4 INTERFACE ${LZ4_LIBRARY})
++endif ()
++target_include_directories (orc_lz4 SYSTEM INTERFACE ${LZ4_INCLUDE_DIR})
+ 
+ if (LZ4_VENDORED)
+-  add_dependencies (lz4 lz4_ep)
++  add_dependencies (orc_lz4 lz4_ep)
+   if (INSTALL_VENDORED_LIBS)
+     install(FILES "${LZ4_STATIC_LIB}"
+             DESTINATION "lib")
+@@ -267,21 +298,33 @@ if (BUILD_CPP_TESTS)
+       CMAKE_ARGS ${GTEST_CMAKE_ARGS}
+       BUILD_BYPRODUCTS "${GMOCK_STATIC_LIB}")
+ 
++    set(GMOCK_LIBRARY ${GMOCK_STATIC_LIB})
+     set(GTEST_VENDORED TRUE)
+   endif ()
+ 
+-  include_directories (SYSTEM ${GTEST_INCLUDE_DIR})
+-
+-  add_library (gmock STATIC IMPORTED)
+-  set_target_properties (gmock PROPERTIES IMPORTED_LOCATION ${GMOCK_STATIC_LIB})
++  # This is a bit special cased because gmock requires gtest and some
++  # distributions statically link gtest inside the gmock shared lib
++  add_library (orc_gmock INTERFACE)
++  add_library (orc::gmock ALIAS orc_gmock)
++  if (ORC_PREFER_STATIC_GMOCK AND ${GMOCK_STATIC_LIB})
++    target_link_libraries (orc_gmock INTERFACE ${GMOCK_STATIC_LIB})
++    if (NOT "${GTEST_STATIC_LIB}" STREQUAL "")
++      target_link_libraries (orc_gmock INTERFACE ${GTEST_STATIC_LIB})
++    endif ()
++  else ()
++    target_link_libraries (orc_gmock INTERFACE ${GMOCK_LIBRARY})
++    if (NOT "${GTEST_LIBRARY}" STREQUAL "")
++      target_link_libraries (orc_gmock INTERFACE ${GTEST_LIBRARY})
++    endif ()
++  endif ()
++  target_include_directories (orc_gmock SYSTEM INTERFACE ${GTEST_INCLUDE_DIR})
+ 
+   if (GTEST_VENDORED)
+-    add_dependencies (gmock googletest_ep)
++    add_dependencies (orc_gmock googletest_ep)
+   endif ()
+ 
+-  set(GTEST_LIBRARIES gmock)
+   if (NOT APPLE AND NOT MSVC)
+-    list (APPEND GTEST_LIBRARIES pthread)
++    target_link_libraries (orc_gmock INTERFACE Threads::Threads)
+   endif ()
+ endif ()
+ 
+@@ -322,20 +365,33 @@ else ()
+     ${THIRDPARTY_LOG_OPTIONS}
+     BUILD_BYPRODUCTS "${PROTOBUF_STATIC_LIB}" "${PROTOC_STATIC_LIB}")
+ 
++  set(PROTOBUF_LIBRARY ${PROTOBUF_STATIC_LIB})
++  set(PROTOC_LIBRARY ${PROTOC_STATIC_LIB})
+   set(PROTOBUF_VENDORED TRUE)
+ endif ()
+ 
+-include_directories (SYSTEM ${PROTOBUF_INCLUDE_DIR})
++add_library (orc_protobuf INTERFACE)
++add_library (orc::protobuf ALIAS orc_protobuf)
++add_library (orc_protoc INTERFACE)
++add_library (orc::protoc ALIAS orc_protoc)
+ 
+-add_library (protobuf STATIC IMPORTED)
+-set_target_properties (protobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_STATIC_LIB})
++if (ORC_PREFER_STATIC_PROTOBUF AND ${PROTOBUF_STATIC_LIB})
++  target_link_libraries (orc_protobuf INTERFACE ${PROTOBUF_STATIC_LIB})
++else ()
++  target_link_libraries (orc_protobuf INTERFACE ${PROTOBUF_LIBRARY})
++endif()
++target_include_directories (orc_protobuf SYSTEM INTERFACE ${PROTOBUF_INCLUDE_DIR})
+ 
+-add_library (protoc STATIC IMPORTED)
+-set_target_properties (protoc PROPERTIES IMPORTED_LOCATION ${PROTOC_STATIC_LIB})
++if (ORC_PREFER_STATIC_PROTOBUF AND ${PROTOC_STATIC_LIB})
++  target_link_libraries (orc_protoc INTERFACE ${PROTOC_STATIC_LIB})
++else ()
++  target_link_libraries (orc_protoc INTERFACE ${PROTOC_LIBRARY})
++endif()
++target_include_directories (orc_protoc SYSTEM INTERFACE ${PROTOBUF_INCLUDE_DIR})
+ 
+ if (PROTOBUF_VENDORED)
+-  add_dependencies (protoc protobuf_ep)
+-  add_dependencies (protobuf protobuf_ep)
++  add_dependencies (orc_protoc protobuf_ep)
++  add_dependencies (orc_protobuf protobuf_ep)
+   if (INSTALL_VENDORED_LIBS)
+     install(FILES "${PROTOBUF_STATIC_LIB}" "${PROTOC_STATIC_LIB}"
+             DESTINATION "lib")
+@@ -371,7 +427,7 @@ if(BUILD_LIBHDFSPP)
+                                 -DBUILD_SHARED_HDFSPP=FALSE)
+ 
+       ExternalProject_Add (libhdfspp_ep
+-        DEPENDS protobuf
++        DEPENDS orc::protobuf
+         URL ${LIBHDFSPP_SRC_URL}
+         LOG_DOWNLOAD 0
+         LOG_CONFIGURE 0
+diff --git a/tools/src/CMakeLists.txt b/tools/src/CMakeLists.txt
+index f5a53ca838..4b6768c5ec 100644
+--- a/tools/src/CMakeLists.txt
++++ b/tools/src/CMakeLists.txt
+@@ -22,7 +22,6 @@ include_directories (
+   ${PROJECT_BINARY_DIR}/c++/include
+   ${PROJECT_SOURCE_DIR}/c++/src
+   ${PROJECT_BINARY_DIR}/c++/src
+-  ${PROTOBUF_INCLUDE_DIR}
+   )
+ 
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g ${CXX11_FLAGS} ${WARN_FLAGS}")
+@@ -51,7 +50,7 @@ add_executable (orc-metadata
+ 
+ target_link_libraries (orc-metadata
+   orc
+-  protobuf
++  orc::protobuf
+   ${CMAKE_THREAD_LIBS_INIT}
+   )
+ 
+diff --git a/tools/test/CMakeLists.txt b/tools/test/CMakeLists.txt
+index 505fc8d289..29f54cb11a 100644
+--- a/tools/test/CMakeLists.txt
++++ b/tools/test/CMakeLists.txt
+@@ -16,9 +16,6 @@ include_directories(
+   ${PROJECT_SOURCE_DIR}/tools-c++/src
+   ${PROJECT_BINARY_DIR}/c++/include
+   ${PROJECT_BINARY_DIR}/c++/src
+-  ${PROTOBUF_INCLUDE_DIR}
+-  ${ZLIB_INCLUDE_DIR}
+-  ${GTEST_INCLUDE_DIR}
+ )
+ 
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_FLAGS} ${WARN_FLAGS}")
+@@ -36,10 +33,10 @@ add_executable (tool-test
+ 
+ target_link_libraries (tool-test
+   orc
+-  protobuf
+-  zlib
+-  snappy
+-  ${GTEST_LIBRARIES}
++  orc::protobuf
++  orc::zlib
++  orc::snappy
++  orc::gmock
+ )
+ 
+ if (TEST_VALGRIND_MEMCHECK)